基于Django+MySQL+HTML的用户注册

from django.utils.deprecation import MiddlewareMixin
from django.shortcuts import redirect


class AuthMiddleware(MiddlewareMixin):
    def process_request(self, request):
        # 排除那些不需要登录就能访问的页面
        if request.path_info in ["/login/","image/code/"]:
            return
        # 读取当前访问session信息
        info_dict = request.session.get("info")
        if info_dict:
            return

        # 若没有登录
        return redirect('/login/')

中间件

class BootStrap:
    bootstrap_exclude_fields = []

    def __init__(self, *args, **kwargs):
        super().__init__(*args, **kwargs)
        #             重新定义init方法写上super就是执行父类的方法
        for name, field in self.fields.items():
            if name in self.bootstrap_exclude_fields:
                continue
            if field.widget.attrs:
                field.widget.attrs['class'] = 'form-control'
                field.widget.attrs['placeholder'] = field.label
            else:
                field.widget.attrs = {"class": "form-control", "placeholder": field.label}


class BootStrapForm(BootStrap, forms.ModelForm):
    pass


class BootStrapFormForm(BootStrap, forms.Form):
    pass

Class BootStrapForm是modelForm模板

Class BootStrapFormForm是Form模板

def md5(data_string):
    # salt = "xxxxxxxx"
    # obj = hashlib.md5(salt.encode('utf-8'))
    obj = hashlib.md5(settings.SECRET_KEY.encode('utf8'))
    obj.update(data_string.encode('utf-8'))
    return obj.hexdigest()

对输入的字符串进行MD5哈希加密

from new_freshman import models
from django import forms
from django.core.validators import RegexValidator
from django.core.validators import ValidationError
from new_freshman.utils.bootstrap import BootStrapForm



class UserModelForm(BootStrapForm):
    name = forms.CharField(min_length=2, label='用户名',widget=forms.TextInput(attrs={'class':'form-control'}))
    password = forms.CharField(min_length=6, label='密码')

    class Meta:
        model = models.Employee
        fields = ["name", "age", "password", "gender", "time", "depart"]
        # widgets = {
        #     "name": forms.TextInput(attrs={'class': 'form-control'}),
        #     "age": forms.TextInput(attrs={'class': 'form-control'}),
        #     "password": forms.TextInput(attrs={'class': 'form-control'}),
        # }


class PrettyForm(BootStrapForm):
    mobile = forms.CharField(
        label='手机号',
        validators=[RegexValidator(r'^1[3,9]\d{9}$', '手机号格式错误')],
    )

    # 验证方式一（正则）
    # r'^1[3,9]\d{9}$'表示第一个数为1第二个数为3-9,后面9位随意
    # validators = [RegexValidator(r'^159[0-9]+$','数字必须以159开头')]

    class Meta:
        model = models.PrettyNum
        fields = ["mobile", "price", "level", "status"]
        # fields = "__all__"  所有数据
        # exclude = ['level']  除了level外的所有数据
        # widgets = {
        #     "name": forms.TextInput(attrs={'class': 'form-control'}),
        #     "age": forms.TextInput(attrs={'class': 'form-control'}),
        #     "password": forms.TextInput(attrs={'class': 'form-control'}),
        # }
    # 验证方式二（钩子方法）

    def clean_mobile(self):
        txt_mobile = self.cleaned_data['mobile']

        exists = models.PrettyNum.objects.filter(mobile=txt_mobile).exists()
        if exists:
            raise ValidationError("手机号已经存在")
        #         若不通过,就会返还错误信息
        return txt_mobile



class PrettyEditForm(BootStrapForm):
        # mobile = forms.CharField(disabled=True,label='手机号')

        class Meta:
            model = models.PrettyNum
            fields = ["mobile", "price", "level", "status"]

        def clean_mobile(self):
            txt_mobile = self.cleaned_data.get('mobile')

            exists = models.PrettyNum.objects.exclude(id=self.instance.pk).filter(mobile=txt_mobile).exists()
            if exists:
                raise ValidationError("手机号已经存在")
                #         若不通过,就会返还错误信息
            return txt_mobile

继承上面Bootstrap样式

from django.utils.safestring import mark_safe
import copy


class Pagination(object):
    def __init__(self, request, queryset, page_size=10, page_param="page", plus=5):

        query_dict = copy.deepcopy(request.GET)
        query_dict._mutable = True
        self.query_dict = query_dict
        query_dict.setlist('xx', [11])
        self.page_param = page_param
        page = request.GET.get(page_param, "1")
        if page.isdecimal():
            page = int(page)
        else:
            page = 1
            # 若输入中文则拿到第一页

        self.page = page
        self.page_size = page_size
        self.start = (page - 1) * page_size
        self.end = page * page_size

        self.page_queryset = queryset[self.start:self.end]

        total = queryset.count()
        # 数据总条数
        # 按等级降序排
        # 数据库desc
        total_page_count, div = divmod(total, page_size)
        if div:
            total_page_count += 1
        # 相除得总页数
        self.total_page_count = total_page_count
        self.plus = plus

    def html(self):

        if self.total_page_count <= 2 * self.plus + 1:
            start_page = 1
            end_page = self.total_page_count
        #     # 数据比较少,少于11页
        else:
            if self.page <= self.plus:
                start_page = 1
                end_page = 2 * self.plus + 1
            #     当前页小于5时
            else:

                if (self.page + self.plus) > self.total_page_count:
                    start_page = self.total_page_count - 2 * self.plus
                    end_page = self.total_page_count
                    #     当前页大于五
                else:
                    start_page = self.page - self.plus
                    end_page = self.page + self.plus

            # 显示前后五页
            # 数据库数据多,大于11页

        page_circle = []
        self.query_dict.setlist(self.page_param,[1])

        page_circle.append('<li><a href="?{}">首页</a></li>'.format(self.query_dict.urlencode()))

        if self.page > 1:
            self.query_dict.setlist(self.page_param, [self.page-1])
            prev = '<li><a href="?{}">上一页</a></li>'.format(self.query_dict.urlencode())
        else:
            self.query_dict.setlist(self.page_param, [1])
            prev = '<li><a href="?{}">上一页</a></li>'.format(self.query_dict.urlencode())
        page_circle.append(prev)

        for i in range(start_page, end_page + 1):
            self.query_dict.setlist(self.page_param, [i])
            # for i in range(1, total_page_count+1):
            if i == self.page:
                ele = '<li class = "active"><a href="?={}">{}</a></li>'.format(self.query_dict.urlencode(), i)
            else:
                ele = '<li><a href="?={}">{}</a></li>'.format(self.query_dict.urlencode(), i)
            page_circle.append(ele)

        if self.page < self.total_page_count:
            self.query_dict.setlist(self.page_param, [self.page + 1])
            self.query_dict.urlencode()
            prev = '<li><a href="?{}">下一页</a></li>'.format(self.query_dict.urlencode())
        else:
            self.query_dict.setlist(self.page_param, [self.total_page_count])
            prev = '<li><a href="?{}">下一页</a></li>'.format(self.query_dict.urlencode())
        page_circle.append(prev)

        self.query_dict.setlist(self.page_param, [self.total_page_count])
        page_circle.append('<li><a href="?{}">尾页</a></li>'.format(self.query_dict.urlencode()))

        search_string = """
                       <li>
                            <form style="float: left; margin-left: -1px" method="get">
                                <input name="page"
                                        style="position: relative;float: left;display: inline-block;width: 80px; border-radius: 0"
                                        type="text" class="form-control" placeholder="页码">
                                <button style="border-radius: 0" class="btn btn-default" type="submit">跳转</button>
                            </form>
                        </li>
                        """
        page_circle.append(search_string)
        page_string = mark_safe(''.join(page_circle))
        # ''.join(page_circle)是一个字符串,需要导入from django.utils.safestring import mark_safe
        # mark_safe()将字符串在前端转换成分页形式
        return page_string

分页模板

from django.shortcuts import render, redirect
from new_freshman import models
from django import forms
from new_freshman.utils.bootstrap import BootStrapFormForm
from django.core.exceptions import ValidationError
from new_freshman.utils.encrypt import md5
from new_freshman.utils.code import check_code
from io import BytesIO


class LoginForm(BootStrapFormForm):
    username = forms.CharField(label="用户名", widget=forms.TextInput, required=True)
    password = forms.CharField(label="密码", widget=forms.PasswordInput(render_value=True), required=True)

    def clean_password(self):
        password = self.cleaned_data.get('password')
        return md5(password)


def login(request):
    if request.method == 'GET':
        form = LoginForm()
        return render(request, "login.html", {'form': form})

    form = LoginForm(request.POST)
    if form.is_valid():

        admin_object = models.Admin.objects.filter(**form.cleaned_data).first()
        if not admin_object:
            form.add_error("password", "用户名或密码错误")
            return render(request, "login.html", {'form': form})

        # 网站随机生成字符串;写到用户浏览器的cookie中;在写入到session中;
        request.session["info"] = {"id": admin_object.id, "name": admin_object.username}

        return redirect("/admin_list/")

    return render(request, "login.html", {'form': form})


def logout(request):
    request.session.clear()
    return redirect("/login")

# def image_code(request):
#
#     img, code_string = check_code()
#     print(code_string)
#
#     stream = BytesIO()
#     img.save(stream,'png')
#     return HttpResponse(stream.getvalue())

管理员登录界面

from django.shortcuts import render, redirect
from new_freshman import models
from new_freshman.utils.pagination import Pagination
from django import forms
from new_freshman.utils.bootstrap import BootStrapForm
from django.core.exceptions import ValidationError
from new_freshman.utils.encrypt import md5


def admin_list(request):
    # 检查用户是否登录
    # 用户发请求,获取cookie字符串,与session中的字符串对比是否有登陆过
    # info = request.session.get("info")
    # if not info:
    #     return redirect("/login")
    info_dict = request.session.get('info', None)

    data_dict = {}
    search = request.GET.get('q', "")
    if search:
        data_dict["username__contains"] = search

    queryset = models.Admin.objects.filter(**data_dict)

    page_object = Pagination(request, queryset)
    context = {'queryset': page_object.page_queryset, "page_string": page_object.html(), "search": search}

    return render(request, "admin_list.html", context)


class AdminModelForm(BootStrapForm):
    confirm_password = forms.CharField(label="确认密码", widget=forms.PasswordInput(render_value=True))

    # render_value=True密码输入错误后不会消失

    class Meta:
        model = models.Admin
        fields = ["username", "password", "confirm_password"]
        widgets = {
            "password": forms.PasswordInput(render_value=True)
        }

    def clean_password(self):
        password = self.cleaned_data.get("password")
        return md5(password)

    def clean_confirm_password(self):
        password = self.cleaned_data.get('password')
        confirm = md5(self.cleaned_data.get("confirm_password"))
        if confirm != password:
            raise ValidationError("密码不一致")
        return confirm


class AdminEditModelForm(BootStrapForm):
    class Meta:
        model = models.Admin
        fields = ["username"]


class AdminResetModelForm(BootStrapForm):
    confirm_password = forms.CharField(label="确认密码", widget=forms.PasswordInput(render_value=True))

    class Meta:
        model = models.Admin
        fields = ["password"]
        widgets = {
            "password": forms.PasswordInput(render_value=True)
        }

    def clean_password(self):
        password = self.cleaned_data.get("password")
        md5_pwd = md5(password)
        exists = models.Admin.objects.filter(id=self.instance.pk, password=md5_pwd).exists()
        if exists:
            raise ValidationError("不能与以前的密码一致")
        return md5_pwd

    def clean_confirm_password(self):
        password = self.cleaned_data.get('password')
        confirm = md5(self.cleaned_data.get("confirm_password"))
        if confirm != password:
            raise ValidationError("密码不一致")
        return confirm


def admin_add(request):
    title = "新建管理员"

    if request.method == "GET":
        form = AdminModelForm()
        return render(request, "change.html", {'form': form, "title": title})

    form = AdminModelForm(data=request.POST)
    if form.is_valid():
        form.save()
        return redirect('/admin_list/')

    return render(request, "change.html", {'form': form, "title": title})


def admin_edit(request, nid):
    row_object = models.Admin.objects.filter(id=nid).first()
    if not row_object:
        return render(request, "error.html", {"msg": "数据不存在"})
    title = "编辑管理员"
    if request.method == "GET":
        form = AdminEditModelForm(instance=row_object)
        return render(request, "change.html", {"form": form, "title": title})

    form = AdminEditModelForm(data=request.POST, instance=row_object)
    if form.is_valid():
        form.save()
        return redirect('/admin_list/')

    return render(request, "change.html", {'form': form, "title": title})


def admin_delete(request, nid):
    models.Admin.objects.filter(id=nid).delete()

    return redirect("/admin_list/")


def admin_reset(request, nid):
    row_object = models.Admin.objects.filter(id=nid).first()
    if not row_object:
        return render(request, "error.html", {"msg": "数据不存在"})

    title = "重置密码 - {}".format(row_object.username)
    if request.method == "GET":
        form = AdminResetModelForm()
        return render(request, "change.html", {"form": form, "title": title})

    form = AdminResetModelForm(data=request.POST, instance=row_object)
    if form.is_valid():
        form.save()
        return redirect('/admin_list/')
    return render(request, "change.html", {"form": form, "title": title})

部门管理

完整功能展示

用户注册