register and models

requirements.txt

@@ -1,2 +1,4 @@
 django
 requests
+django-crispy-forms
+crispy-bootstrap5

src/main/main/settings.py

@@ -37,7 +37,8 @@ INSTALLED_APPS = [
     'django.contrib.sessions',
     'django.contrib.messages',
     'django.contrib.staticfiles',
-
+    "crispy_forms",
+    "crispy_bootstrap5",
     'helloworld',
     'user',
 ]
@@ -134,3 +135,7 @@ STATICFILES_DIRS = [
 # https://docs.djangoproject.com/en/5.0/ref/settings/#default-auto-field
 
 DEFAULT_AUTO_FIELD = 'django.db.models.BigAutoField'
+
+CRISPY_TEMPLATE_PACK = 'bootstrap5'
+
+AUTH_USER_MODEL = 'user.CustomUser'

src/main/templates/register.html

@@ -0,0 +1,8 @@
+{% block title %} Create an Account {% endblock %}
+{% block content %}
+<form method="post" class="form-group">
+    {% csrf_token %}
+    {{ form }}
+    <button type="submit" class="btn btn-success">Register</button>
+</form>
+{% endblock %}

src/main/user/admin.py

@@ -1,3 +1,11 @@
+from user.models import CustomUser
+from django.contrib.auth.models import Group
 from django.contrib import admin
 
 # Register your models here.
+
+
+
+
+admin.site.register(CustomUser)
+admin.site.unregister(Group)

src/main/user/forms.py

@@ -0,0 +1,212 @@
+from django import forms
+from django.contrib.auth import authenticate, password_validation
+from django.contrib.auth.forms import UsernameField, ReadOnlyPasswordHashField, UserModel
+from django.core.exceptions import ValidationError
+from django.utils.text import capfirst
+from django.utils.translation import gettext_lazy as _
+from .models import CustomUser
+
+
+class BaseCustomUserCreationForm(forms.ModelForm):
+    """
+    A form that creates a user, with no privileges, from the given username and
+    password.
+    """
+
+    error_messages = {
+        "password_mismatch": _("The two password fields didn’t match."),
+    }
+    password1 = forms.CharField(
+        label=_("Password"),
+        strip=False,
+        widget=forms.PasswordInput(attrs={"autocomplete": "new-password"}),
+        help_text=password_validation.password_validators_help_text_html(),
+    )
+    password2 = forms.CharField(
+        label=_("Password confirmation"),
+        widget=forms.PasswordInput(attrs={"autocomplete": "new-password"}),
+        strip=False,
+        help_text=_("Enter the same password as before, for verification."),
+    )
+
+    class Meta:
+        model = CustomUser
+        fields = ("email", "username")
+        field_classes = {"email": forms.EmailField}
+
+    def __init__(self, *args, **kwargs):
+        super().__init__(*args, **kwargs)
+        if self._meta.model.EMAIL_FIELD in self.fields:
+            self.fields[self._meta.model.EMAIL_FIELD].widget.attrs[
+                "autofocus"
+            ] = True
+
+    def clean_password2(self):
+        password1 = self.cleaned_data.get("password1")
+        password2 = self.cleaned_data.get("password2")
+        if password1 and password2 and password1 != password2:
+            raise ValidationError(
+                self.error_messages["password_mismatch"],
+                code="password_mismatch",
+            )
+        return password2
+
+    def _post_clean(self):
+        super()._post_clean()
+        # Validate the password after self.instance is updated with form data
+        # by super().
+        password = self.cleaned_data.get("password2")
+        if password:
+            try:
+                password_validation.validate_password(password, self.instance)
+            except ValidationError as error:
+                self.add_error("password2", error)
+
+    def save(self, commit=True):
+        user = super().save(commit=False)
+        user.set_password(self.cleaned_data["password1"])
+        if commit:
+            user.save()
+            if hasattr(self, "save_m2m"):
+                self.save_m2m()
+        return user
+
+
+class CustomUserCreationForm(BaseCustomUserCreationForm):
+    def clean_username(self):
+        """Reject emails that differ only in case."""
+        email = self.cleaned_data.get("email")
+        if (
+            email
+            and self._meta.model.objects.filter(username__iexact=email).exists()
+        ):
+            self._update_errors(
+                ValidationError(
+                    {
+                        "email": self.instance.unique_error_message(
+                            self._meta.model, ["email"]
+                        )
+                    }
+                )
+            )
+        else:
+            return email
+
+
+class CustomUserChangeForm(forms.ModelForm):
+    password = ReadOnlyPasswordHashField(
+        label=_("Password"),
+        help_text=_(
+            "Raw passwords are not stored, so there is no way to see this "
+            "user’s password, but you can change the password using "
+            '<a href="{}">this form</a>.'
+        ),
+    )
+
+    class Meta:
+        model = CustomUser
+        fields = "__all__"
+        field_classes = {"email": UsernameField}
+
+    def __init__(self, *args, **kwargs):
+        super().__init__(*args, **kwargs)
+        password = self.fields.get("password")
+        if password:
+            password.help_text = password.help_text.format(
+                f"../../{self.instance.pk}/password/"
+            )
+        user_permissions = self.fields.get("user_permissions")
+        if user_permissions:
+            user_permissions.queryset = user_permissions.queryset.select_related(
+                "content_type"
+            )
+
+
+class CustomAuthenticationForm(forms.Form):
+    """
+    Base class for authenticating users. Extend this to get a form that accepts
+    username/password logins.
+    """
+
+    username = UsernameField(widget=forms.TextInput(attrs={"autofocus": True}))
+    password = forms.CharField(
+        label=_("Password"),
+        strip=False,
+        widget=forms.PasswordInput(attrs={"autocomplete": "current-password"}),
+    )
+
+    error_messages = {
+        "invalid_login": _(
+            "Please enter a correct %(username)s and password. Note that both "
+            "fields may be case-sensitive."
+        ),
+        "inactive": _("This account is inactive."),
+    }
+
+    def __init__(self, request=None, *args, **kwargs):
+        """
+        The 'request' parameter is set for custom auth use by subclasses.
+        The form data comes in via the standard 'data' kwarg.
+        """
+        self.request = request
+        self.user_cache = None
+        super().__init__(*args, **kwargs)
+
+        # Set the max length and label for the "username" field.
+        self.email_field = UserModel._meta.get_field(UserModel.EMAIL_FIELD)
+        email_max_length = self.email_field.max_length or 254
+        self.fields["email"].max_length = email_max_length
+        self.fields["email"].widget.attrs["maxlength"] = email_max_length
+        if self.fields["email"].label is None:
+            self.fields["email"].label = capfirst(
+                self.email_field.verbose_name)
+
+    def clean(self):
+        email = self.cleaned_data.get("username")
+        password = self.cleaned_data.get("password")
+
+        if email is not None and password:
+            self.user_cache = authenticate(
+                self.request, email=email, password=password
+            )
+            if self.user_cache is None:
+                raise self.get_invalid_login_error()
+            else:
+                self.confirm_login_allowed(self.user_cache)
+
+        return self.cleaned_data
+
+    def confirm_login_allowed(self, user):
+        """
+        Controls whether the given User may log in. This is a policy setting,
+        independent of end-user authentication. This default behavior is to
+        allow login by active users, and reject login by inactive users.
+
+        If the given user cannot log in, this method should raise a
+        ``ValidationError``.
+
+        If the given user may log in, this method should return None.
+        """
+        if not user.is_active:
+            raise ValidationError(
+                self.error_messages["inactive"],
+                code="inactive",
+            )
+
+    def get_user(self):
+        return self.user_cache
+
+    def get_invalid_login_error(self):
+        return ValidationError(
+            self.error_messages["invalid_login"],
+            code="invalid_login",
+            params={"email": self.email_field.verbose_name},
+        )
+
+
+class RegisterForm(CustomUserCreationForm):
+    email = forms.EmailField()
+
+    class Meta:
+        model = CustomUser
+        fields = ['email', 'username', 'password1', 'password2']

src/main/user/migrations/0001_initial.py

@@ -0,0 +1,45 @@
+# Generated by Django 5.0.3 on 2024-03-25 13:35
+
+import django.core.validators
+import django.utils.timezone
+import user.models
+from django.db import migrations, models
+
+
+class Migration(migrations.Migration):
+
+    initial = True
+
+    dependencies = [
+        ('auth', '0012_alter_user_first_name_max_length'),
+    ]
+
+    operations = [
+        migrations.CreateModel(
+            name='CustomUser',
+            fields=[
+                ('id', models.BigAutoField(auto_created=True, primary_key=True, serialize=False, verbose_name='ID')),
+                ('password', models.CharField(max_length=128, verbose_name='password')),
+                ('last_login', models.DateTimeField(blank=True, null=True, verbose_name='last login')),
+                ('is_superuser', models.BooleanField(default=False, help_text='Designates that this user has all permissions without explicitly assigning them.', verbose_name='superuser status')),
+                ('email', models.EmailField(error_messages={'unique': 'A user with that email already exists.'}, help_text='Required. 150 characters or fewer. Letters, digits and @/./+/-/_ only.', max_length=150, unique=True, validators=[django.core.validators.EmailValidator()], verbose_name='email')),
+                ('first_name', models.CharField(blank=True, max_length=150, verbose_name='first name')),
+                ('last_name', models.CharField(blank=True, max_length=150, verbose_name='last name')),
+                ('username', models.CharField(blank=True, max_length=150, verbose_name='username')),
+                ('is_staff', models.BooleanField(default=False, help_text='Designates whether the user can log into this admin site.', verbose_name='staff status')),
+                ('is_active', models.BooleanField(default=True, help_text='Designates whether this user should be treated as active. Unselect this instead of deleting accounts.', verbose_name='active')),
+                ('date_joined', models.DateTimeField(default=django.utils.timezone.now, verbose_name='date joined')),
+                ('groups', models.ManyToManyField(blank=True, help_text='The groups this user belongs to. A user will get all permissions granted to each of their groups.', related_name='user_set', related_query_name='user', to='auth.group', verbose_name='groups')),
+                ('user_permissions', models.ManyToManyField(blank=True, help_text='Specific permissions for this user.', related_name='user_set', related_query_name='user', to='auth.permission', verbose_name='user permissions')),
+            ],
+            options={
+                'verbose_name': 'user',
+                'verbose_name_plural': 'users',
+                'abstract': False,
+                'swappable': 'AUTH_USER_MODEL',
+            },
+            managers=[
+                ('objects', user.models.CustomUserManager()),
+            ],
+        ),
+    ]

src/main/user/models.py

@@ -1,3 +1,162 @@
 from django.db import models
+from django.contrib.auth.models import (
+    AbstractBaseUser, PermissionsMixin, BaseUserManager)
+from django.core.validators import EmailValidator
+from django.core.mail import send_mail
+from django.utils import timezone
+from django.utils.translation import gettext_lazy as _
+from django.apps import apps
+from django.contrib.auth.hashers import make_password
+from django.contrib import auth
+
+
+class CustomUserManager(BaseUserManager):
+    use_in_migrations = True
+
+    def _create_user(self, username, email, password, **extra_fields):
+        """
+        Create and save a user with the given username, email, and password.
+        """
+        if not email:
+            raise ValueError("The given email must be set")
+        email = self.normalize_email(email)
+        # Lookup the real model class from the global app registry so this
+        # manager method can be used in migrations. This is fine because
+        # managers are by definition working on the real model.
+        GlobalUserModel = apps.get_model(
+            self.model._meta.app_label, self.model._meta.object_name
+        )
+        username = GlobalUserModel.normalize_username(username)
+        user = self.model(username=username, email=email, **extra_fields)
+        user.password = make_password(password)
+        user.save(using=self._db)
+        return user
+
+    def create_user(self, email, username=None, password=None, **extra_fields):
+        extra_fields.setdefault("is_staff", False)
+        extra_fields.setdefault("is_superuser", False)
+        return self._create_user(username, email, password, **extra_fields)
+
+    def create_superuser(self, username, email=None, password=None, **extra_fields):
+        extra_fields.setdefault("is_staff", True)
+        extra_fields.setdefault("is_superuser", True)
+
+        if extra_fields.get("is_staff") is not True:
+            raise ValueError("Superuser must have is_staff=True.")
+        if extra_fields.get("is_superuser") is not True:
+            raise ValueError("Superuser must have is_superuser=True.")
+
+        return self._create_user(username, email, password, **extra_fields)
+
+    def with_perm(
+        self, perm, is_active=True, include_superusers=True, backend=None, obj=None
+    ):
+        if backend is None:
+            backends = auth._get_backends(return_tuples=True)
+            if len(backends) == 1:
+                backend, _ = backends[0]
+            else:
+                raise ValueError(
+                    "You have multiple authentication backends configured and "
+                    "therefore must provide the `backend` argument."
+                )
+        elif not isinstance(backend, str):
+            raise TypeError(
+                "backend must be a dotted import path string (got %r)." % backend
+            )
+        else:
+            backend = auth.load_backend(backend)
+        if hasattr(backend, "with_perm"):
+            return backend.with_perm(
+                perm,
+                is_active=is_active,
+                include_superusers=include_superusers,
+                obj=obj,
+            )
+        return self.none()
 
 # Create your models here.
+
+
+class AbstractCustomUser(AbstractBaseUser, PermissionsMixin):
+    """
+    An abstract base class implementing a fully featured User model with
+    admin-compliant permissions.
+
+    Email and password are required. Other fields are optional.
+    """
+
+    email_validator = EmailValidator()
+
+    email = models.EmailField(
+        _("email"),
+        max_length=150,
+        unique=True,
+        help_text=_(
+            "Required. 150 characters or fewer. Letters, digits and @/./+/-/_ only."
+        ),
+        validators=[email_validator],
+        error_messages={
+            "unique": _("A user with that email already exists."),
+        },
+    )
+    first_name = models.CharField(_("first name"), max_length=150, blank=True)
+    last_name = models.CharField(_("last name"), max_length=150, blank=True)
+    username = models.CharField(_("username"), max_length=150, blank=True)
+    is_staff = models.BooleanField(
+        _("staff status"),
+        default=False,
+        help_text=_(
+            "Designates whether the user can log into this admin site."),
+    )
+    is_active = models.BooleanField(
+        _("active"),
+        default=True,
+        help_text=_(
+            "Designates whether this user should be treated as active. "
+            "Unselect this instead of deleting accounts."
+        ),
+    )
+    date_joined = models.DateTimeField(_("date joined"), default=timezone.now)
+
+    objects = CustomUserManager()
+
+    EMAIL_FIELD = "username"
+    USERNAME_FIELD = "email"
+    REQUIRED_FIELDS = ["username"]
+
+    class Meta:
+        verbose_name = _("user")
+        verbose_name_plural = _("users")
+        abstract = True
+
+    def clean(self):
+        super().clean()
+        self.email = self.__class__.objects.normalize_email(self.email)
+
+    def get_full_name(self):
+        """
+        Return the first_name plus the last_name, with a space in between.
+        """
+        full_name = "%s %s" % (self.first_name, self.last_name)
+        return full_name.strip()
+
+    def get_short_name(self):
+        """Return the short name for the user."""
+        return self.first_name
+
+    def email_user(self, subject, message, from_email=None, **kwargs):
+        """Send an email to this user."""
+        send_mail(subject, message, from_email, [self.email], **kwargs)
+
+
+class CustomUser(AbstractCustomUser):
+    """
+    Users within the Django authentication system are represented by this
+    model.
+
+    Email and password are required. Other fields are optional.
+    """
+
+    class Meta(AbstractCustomUser.Meta):
+        swappable = "AUTH_USER_MODEL"

src/main/user/urls.py

@@ -21,4 +21,5 @@ app_name = 'user'
 urlpatterns = [
     path('login/', views.login, name="login"),
     path('verify_password/', views.verify_password),
+    path('register/', views.register, name="register"),
 ]

src/main/user/utils.py

@@ -0,0 +1,11 @@
+from .models import CustomUser
+
+
+def export_user_to_json():
+    # q=CustomUser.objects.create(key="value") # 插入数据
+    q = list(q)
+    for i in q:
+        print(i.email)
+        print(i.password)
+        print(i.username)
+        # todo: 写入json文件

src/main/user/views.py

@@ -1,9 +1,9 @@
 import os
 from django.http import HttpResponse, HttpResponseRedirect
 from django.shortcuts import render, redirect
+from .forms import RegisterForm
 import requests
 from . import status
-
 # Create your views here.
 
 base_url = "https://pgsoft-pguser.hf.space"
@@ -68,3 +68,16 @@ def verify_password(request) -> HttpResponse | HttpResponseRedirect:
         "email": email,
     }
     return render(request, "loggedin.html", context)
+
+
+def register(request):
+    if request.method == "POST":
+        print("posting")
+        form = RegisterForm(request.POST)
+        if form.is_valid():
+            form.save()
+            # upload to dataset
+            return redirect("/")
+    else:
+        form = RegisterForm()
+    return render(request, "register.html", {"form": form})