商城项目---day05---用户中心页面的实现

我就是我 2022-12-04 08:59 107阅读 0赞

一：修改密码：  
1：user.views:  
思路：先提取新旧密码—>校验密码是否正确—>设置新的密码—>推出状态保持–>干掉前端的cookie。  
首先：修改密码肯定是在登录状态修改，所以要继承LoginRequiredJSONMixin。  
知识点1：request.body是个二进制数据，所以需要转码成字符串（json）类型。  
知识点2：json.loads()： 将json格式转换成字典类型。  
知识点3：request.user.check\_password(old\_password)查看输入的密码和数据库的是否一致。  
知识点4：调用当前用户对象的setpassword就可以设置密码了。request.user.set\_password(),然后保持request.user.save()。  
知识点5：退出登录： logout(request)  
知识点6：清除cookie: response.delete\_cookie(“username”)

class ChangePasswordView(LoginRequiredJSONMixin, View):
    
        def put(self, request):
            # 1:提取参数:request.body是个二进制数据，所以需要转码成字符串类型(json)
            request_json = request.body.decode()
            # 将json格式转换成字典类型
            request_dict = json.loads(request_json)
    
            old_password = request_dict.get("old_password")
            new_password = request_dict.get("new_password")
            new_password2 = request_dict.get("new_password2")
            # 2:校验参数
    
            # 校验参数
            if not all([old_password, new_password, new_password2]):
                return JsonResponse({
        'code': 400,
                                          'errmsg': '缺少必传参数'})
    
            result = request.user.check_password(old_password)
            if not result:
                return JsonResponse({
        'code': 400,
                                          'errmsg': '原始密码不正确'})
    
            if not re.match(r'^[0-9A-Za-z]{8,20}$', new_password):
                return JsonResponse({
        'code': 400,
                                          'errmsg': '密码最少8位,最长20位'})
    
            if new_password != new_password2:
                return JsonResponse({
        'code': 400,
                                          'errmsg': '两次输入密码不一致'})
    
            # 3：数据处理---设置新密码---退出状态保持---干掉前端cookie
            try:
                request.user.set_password(new_password)
                request.user.save()
            except Exception as e:
                JsonResponse({
        
                    "code": 400,
                    "errmsg": "新密码设置失败"
                })
    
            logout(request)
    
            response = JsonResponse({
        
                "code": 0,
                "errmsg": "ok"
            })
    
            response.delete_cookie("username")
            
            return response

2：users.urls

path('password/', views.ChangePasswordView.as_view()),

二：省市区三级联动：  
1:准备工作：  
1.1:新建子应用：

cd apps/
     python ../manage.py startapp areas

1.2：注册子应用：dev.py

INSTALLED_APPS = [
              ...
         'apps.areas',
     ]

1.3:设置总路由：meiduo\_mall.urls.py

path('', include('apps.areas.urls')),

1.4:构建地区模型类areas.models.py

class Area(models.Model):
        """
        行政区划
        """
        # 创建 name 字段, 用户保存名称
        name = models.CharField(max_length=20, verbose_name='名称')
        # 自关联字段 parent
        parent = models.ForeignKey('self', on_delete=models.SET_NULL, related_name='subs', null=True, blank=True, verbose_name='上级行政区划')
    
        class Meta:
            db_table = 'tb_areas'
    
        def __str__(self):
            return self.name

1.5：数据迁移建表：

python manage.py makemigrations
    python manage.py migrate

1.6：数据导入数据库：

# 1.cd 到放置 areas.sql文件的录
       # 2.执行导入指令
       mysql -uroot -pmysql meiduo_mall < areas.sql 2>/dev/null

2:功能的实现  
2.1：获取省份数据的视图：areas.views.py:  
思路：根据parent\_\_isnull过滤出省份信息。  
知识点1：filter得到的结果是个查询集对象，查询集对象里面是我们自定义模型类对象。  
知识点2：列表推导式的使用。

class ProvinceAreasView(View):
        """省级地区"""
    
        def get(self, request):
            """提供省级地区数据
            1.查询省级数据
            2.序列化省级数据
            3.响应省级数据
            """
            try:
                # 1.查询省级数据对象
                provinces = Area.objects.filter(parent=None)
                print(type(provinces))
                # 2:遍历省级数据queryset对象<class 'django.db.models.query.QuerySet'>，得到<class 'apps.areas.models.Area'>
                province_list = [{
        'id': p.id, 'name': p.name} for p in provinces]
    
            except Exception as e:
                  # 如果报错, 则返回错误原因:
                return JsonResponse({
        'code': 400,  'errmsg': '省份数据错误'})
    
            # 3.返回整理好的省级数据
            return JsonResponse({
        'code': 0, 'errmsg': 'OK', 'province_list': province_list})

path('areas/', views.ProvinceAreasView.as_view()),

2.2 ： 获取市区数据的视图实现：  
思路：前端传入父级主键pk , 根据pk可以查询出父级对象，和子集的查询结果集。然后构建前端需要的格式返回。

class SubAreasView(View):
    
        def get(self, request, pk):
    
            try:
                # 1: 根据传入的pk值，查询子集
                son_list = Area.objects.filter(parent=pk)
    
                # 2：将查询结果集变成列表套字典格式
                sub_list = [{
        "id":p.id,"name":p.name} for p in son_list ]
    
                # 3:得到父级对象
                parent_model = Area.objects.get(id=pk)
            except Exception as e:
                return JsonResponse({
        
                    "code": 400,
                    "errmsg": "查询数据库错误"
                })
    
            sub_data = {
        
                "id": parent_model.id,
                "name": parent_model.name,
                "subs": sub_list,
            }
    
            return JsonResponse({
        
                "code": 0,
                "errmsg": "ok",
                "sub_data": sub_data,
            }, status=200)

re_path(r'^areas/(?P<pk>\d+)/$', views.SubAreaView.as_view()),

三：新增收货地址：  
1：准备工作  
1.1：准备收货地址模型类：  
users.models.py

class Address(BaseModel):
        """
        用户地址
        """
        user = models.ForeignKey('users.User', on_delete=models.CASCADE, related_name='addresses', verbose_name='用户')
        province = models.ForeignKey('areas.Area', on_delete=models.PROTECT, related_name='province_addresses', verbose_name='省')
        city = models.ForeignKey('areas.Area', on_delete=models.PROTECT, related_name='city_addresses', verbose_name='市')
        district = models.ForeignKey('areas.Area', on_delete=models.PROTECT, related_name='district_addresses', verbose_name='区')
        title = models.CharField(max_length=20, verbose_name='地址名称')
        receiver = models.CharField(max_length=20, verbose_name='收货人')
        place = models.CharField(max_length=50, verbose_name='地址')
        mobile = models.CharField(max_length=11, verbose_name='手机')
        tel = models.CharField(max_length=20, null=True, blank=True, default='', verbose_name='固定电话')
        email = models.CharField(max_length=30, null=True, blank=True, default='', verbose_name='电子邮箱')
        is_deleted = models.BooleanField(default=False, verbose_name='逻辑删除')
    
        class Meta:
            db_table = 'tb_address'
            # 设置默认 已更新时间降序
            ordering = ['-update_time']

1.2：给user模型类增加默认地址属性：  
users.models.py

default_address = models.ForeignKey('Address', related_name='users', null=True, blank=True, on_delete=models.SET_NULL, verbose_name='默认地址')

1.3：数据迁移建表：

python manage.py makemigrations
    python manage.py migrate

2：功能实现：  
知识点1：使用Address.objects.create() 新增地址。

# 思路：将前端传来的数据保存在数据库再返回给前段，实现局部刷新。
    class  CreateAddressView(View):
    
        def post(self, request):
    
            # 1:接受参数
            json_dict = json.loads(request.body.decode())
            receiver = json_dict.get('receiver')
            province_id = json_dict.get('province_id')
            city_id = json_dict.get('city_id')
            district_id = json_dict.get('district_id')
            place = json_dict.get('place')
            mobile = json_dict.get('mobile')
            tel = json_dict.get('tel')
            email = json_dict.get('email')
    
            # 2：校验参数
            if not all([receiver, province_id, city_id, district_id, place, mobile]):
                return JsonResponse({
        'code': 400,
                                          'errmsg': '缺少必传参数'})
    
            if not re.match(r'^1[3-9]\d{9}$', mobile):
                return JsonResponse({
        'code': 400, 'errmsg': '参数mobile有误'})
    
            if tel:
                if not re.match(r'^(0[0-9]{2,3}-)?([2-9][0-9]{6,7})+(-[0-9]{1,4})?$', tel):
                    return JsonResponse({
        'code': 400, 'errmsg': '参数tel有误'})
            if email:
                if not re.match(r'^[a-z0-9][\w\.\-]*@[a-z0-9\-]+(\.[a-z]{2,5}){1,2}$', email):
                    return JsonResponse({
        'code': 400, 'errmsg': '参数email有误'})
    
    
            #3： 数据处理：将接受到的参数保存到数据库
            try:
                # address = Address.objects.create(**json_dict)
    
                address = Address.objects.create(
                    user=request.user,
                    title=receiver,
                    receiver=receiver,
                    province_id=province_id,
                    city_id=city_id,
                    district_id=district_id,
                    place=place,
                    mobile=mobile,
                    tel=tel,
                    email=email
                )
                # 检测有没有默认地址，如果没有默认地址，将这个设值成默认地址
                if not request.user.default_address:
                    request.user.default_address = address
                    request.user.save()
    
            except Exception as e:
                JsonResponse({
        
                    "code": 400,
                    "errmsg": "收货地址信息保存到数据库失败"
                })
    
            # 新增地址成功，现在将新增的地址进行刷新，还给前端显示。
            address_dict = dict(**json_dict)
    
            return JsonResponse({
        
                "code": 0,
                "errmsg": "ok",
                "address": address_dict
            })

# 新增收货地址
        re_path('addresses/create/', views.CreateAddressView.as_view()),

四：展示地址：

# 展示地址
    # 思路：获取所有的列表，然后遍历列表，对列表进行拆包，最后返回列表和默认地址id
    class AddressView(View):
    
        def get(self, request):
            # 必须逻辑删除的地址为False
            # addresses是个查询集对象<QuerySet [<Addresses: Addresses object (1)>]>
    
            # 方案一：
            # addresses = Address.objects.filter(user=request.user, is_deleted=False)
            # # 使用model_to_dict直接将查询集对象转化成字典格式
            # # 使用列表推导式构造列表
            # address_dict_list = [model_to_dict(address) for address in addresses ]
    
            # 方案二：
            addresses = Address.objects.filter(user=request.user, is_deleted=False).values()
            # <QuerySet [{'district_id': 110101, 'province_id': 110000, 'title': '任善文', 'tel': ''>
            address_dict_list = list(addresses)
            print(address_dict_list)
            default_id = request.user.default_address_id
    
            return JsonResponse({
        
                "code": 0,
                "errmsg": "ok",
                "addresses":address_dict_list,
                "default_address_id" : default_id,
            })

# 展示收货地址
        re_path(r'^addresses/$', views.AddressView.as_view()),

五：修改地址：

class UpdateDestroyAddressView(View):
        """修改和删除地址"""
    
        def put(self, request, address_id):
            """修改地址"""
            # 接收参数
            address_id = int(address_id)
            json_dict = json.loads(request.body.decode())
    
            receiver = json_dict.get('receiver')
            province_id = json_dict.get('province_id')
            city_id = json_dict.get('city_id')
            district_id = json_dict.get('district_id')
            place = json_dict.get('place')
            mobile = json_dict.get('mobile')
            tel = json_dict.get('tel')
            email = json_dict.get('email')
    
            # 校验参数
            if not all([receiver, province_id, city_id, district_id, place, mobile]):
                return JsonResponse({
        'code': 400,
                                          'errmsg': '缺少必传参数'})
    
    
            if not re.match(r'^1[3-9]\d{9}$', mobile):
                return JsonResponse({
        'code': 400,
                                          'errmsg': '参数mobile有误'})
    
            if tel:
                if not re.match(r'^(0[0-9]{2,3}-)?([2-9][0-9]{6,7})+(-[0-9]{1,4})?$', tel):
                    return JsonResponse({
        'code': 400,
                                              'errmsg': '参数tel有误'})
            if email:
                if not re.match(r'^[a-z0-9][\w\.\-]*@[a-z0-9\-]+(\.[a-z]{2,5}){1,2}$', email):
                    return JsonResponse({
        'code': 400,
                                              'errmsg': '参数email有误'})
    
            # 判断地址是否存在,并更新地址信息
            try:
                Address.objects.filter(id=address_id).update(
                    user = request.user,
                    title = receiver,
                    receiver = receiver,
                    province_id = province_id,
                    city_id = city_id,
                    district_id = district_id,
                    place = place,
                    mobile = mobile,
                    tel = tel,
                    email = email
                )
            except Exception as e:
                return JsonResponse({
        'code': 400,
                                          'errmsg': '更新地址失败'})
    
            # 响应更新地址结果
            return JsonResponse({
        'code': 0,
                                      'errmsg': '更新地址成功',
                                      'address': json_dict})

# 修改和删除收货地址
        re_path(r"^addresses/(?P<address_id>\d+)/$", views.UpdateDestroyAddressView.as_view())

六：删除地址：

def delete(self, request, address_id):
    
            try:
                address = Address.objects.get(id = address_id)
    
                address.is_deleted = True
                address.save()
    
            except Exception as e:
                JsonResponse({
        
                    "code": 400,
                    "errmsg": "删除地址失败"
                })
    
            return JsonResponse({
        
                "code": 0,
                "errmsg": "ok"
            })

# 修改和删除收货地址
        re_path(r"^addresses/(?P<address_id>\d+)/$", views.UpdateDestroyAddressView.as_view())

七：设置默认地址：

class DefaultAddressView(View):
    
        def put(self, request, address_id):
    
            try:
                address = Address.objects.get(id=address_id)
                request.user.default_address = address
                request.user.save()
    
            except Exception as e:
                JsonResponse({
        
                    "code": 400,
                    "errmsg": "设置默认地址失败"
                })
    
            return JsonResponse({
        
                "code": 0,
                "errmsg": "ok"
            })

path('addresses/(?P<address_id>\d+)/default/', views.DefaultAddressView.as_view()),

八：修改地址标题：

class  UpdateTitleAddressView(View):
    
        def put(self, request, address_id):
            # 1:获取新默认标题
            request_data = request.body.decode()
            data_dict = json.loads(request_data)
            title = data_dict.get("title")
            try:
                address = Address.objects.get(id= address_id)
    
                address.title = title
                address.save()
    
            except Exception as e:
                JsonResponse({
        
                    "code": 400,
                    "errmsg": "设置默认标题失败"
                })
    
            return JsonResponse({
        
                "code": 0,
                "errmsg": "ok"
            })

path('addresses/(?P<address_id>\d+)/title/', views.UpdateTitleAddressView.as_view()),