Django项目搭建
本项目是一个典型的电商项目，采用
Python语言编写，Django框架搭建。
在github中创建远程仓库
在github上创建仓库meiduo，填写描述，选择.gitignore文件的语言为python，软件许可协议为MIT。
修改.gitignore的内容为：.idea/，*.pyc，*.log。
新建分支dev。
在本地克隆项目
git clone https://github.com/junsircoding/meiduo.git # 克隆项目
cd meiduo # 进入项目目录
git branch # 查看当前分支
git branch dev origin/dev # 克隆远程仓库中的dev分支
git checkout dev # 切换到dev分支
在虚拟环境中创建项目
workon django_py3_1.11 # 进入虚拟环境
django-admin startproject shop # 创建项目，项目名称为shop
cd shop # 进入项目目录
pwd # 查看当前地址并拷贝，在pycharm中打开
在Pycharm中搭建项目
重设settings文件路径
开发环境和上线环境用不同的配置文件比较容易部署和维护，故而最好重新设置
settings的路径。在
django自动创建的项目中，根目录下有一个同名目录，在此做一个约定：根目录的shop为一级shop，根目录下的同名目录为二级shop。
新建名为settings的python package于二级shop中，将原二级shop中的settings.py更名为dev.py，并将其移动到新建的settings目录中。
修改一级shop下的manage.py中的环境变量：
os.environ.setdefault("DJANGO_SETTINGS_MODULE", "shop.settings") # 原
os.environ.setdefault("DJANGO_SETTINGS_MODULE", "shop.settings.dev") # 现
配置jinja2模板
在dev.py（位于二级shop）中配置jinja2的模板：
TEMPLATES = [
{
'BACKEND': 'django.template.backends.jinja2.Jinja2', # jinja2模板引擎
'DIRS': [os.path.join(BASE_DIR, 'templates')],
'APP_DIRS': True,
'OPTIONS': {
'context_processors': [
'django.template.context_processors.debug',
'django.template.context_processors.request',
'django.contrib.auth.context_processors.auth',
'django.contrib.messages.context_processors.messages',
],
# 补充Jinja2模板引擎环境
'environment': 'meiduo_mall.utils.jinja2_env.jinja2_environment',
},
},
]
新建名为utils的python package于二级shop中。
新建名为jinja2_env.py的python file于utils目录中，并在其中写如下代码：
from django.contrib.staticfiles.storage import staticfiles_storage
from django.urls import reverse
from jinja2 import Environment
def jinja2_environment(**options):
env = Environment(**options)
env.globals.update({
'static': staticfiles_storage.url,
'url': reverse,
})
return env
"""
确保可以使用Django模板引擎中的{% url('') %} {% static('') %}这类的语句
"""
配置mysql数据库
新建mysql数据库
mysql -uroot -p111
create database shop charset=utf8; # 创建名为shop的数据库，指定字符编码为utf8
create user shoproot identified by '111'; # 创建名为shoproot的mysql新用户，授权其访问shop数据库
grant all on shop.* to 'shop'@'%'; # %表示匹配用户名为junsir的所有ip地址
flush privileges; # 刷新刚才所做的设置
配置mysql数据库于dev.py中
DATABASES = {
'default': {
'ENGINE': 'django.db.backends.mysql', # 数据库引擎
'HOST': '127.0.0.1', # 数据库主机
'PORT': 3306, # 数据库端口
'USER': 'shoproot', # 数据库用户名
'PASSWORD': '111', # 数据库用户密码
'NAME': 'shop' # 数据库名字
},
}
修改__init__.py（二级shop目录），配置pymysql连接
from pymysql import install_as_MySQLdb
install_as_MySQLdb()
配置Redis中的缓存及Session
在dev.py（二级shop/settings）中添加如下内容：
CACHES = {
"default": { # 默认
"BACKEND": "django_redis.cache.RedisCache",
"LOCATION": "redis://127.0.0.1:6379/0",
"OPTIONS": {
"CLIENT_CLASS": "django_redis.client.DefaultClient",
}
},
"session": { # session
"BACKEND": "django_redis.cache.RedisCache",
"LOCATION": "redis://127.0.0.1:6379/1",
"OPTIONS": {
"CLIENT_CLASS": "django_redis.client.DefaultClient",
}
},
}
SESSION_ENGINE = "django.contrib.sessions.backends.cache"
SESSION_CACHE_ALIAS = "session"
配置工程日志
新建名为logs的python package于一级shop中
新建名为shop.log的file于目录logs中
在dev.py（二级shop/settings）中添加日志的配置信息：
LOGGING = {
'version': 1,
'disable_existing_loggers': False, # 是否禁用已经存在的日志器
'formatters': { # 日志信息显示的格式
'verbose': {
'format': '%(levelname)s %(asctime)s %(module)s %(lineno)d %(message)s'
},
'simple': {
'format': '%(levelname)s %(module)s %(lineno)d %(message)s'
},
},
'filters': { # 对日志进行过滤
'require_debug_true': { # django在debug模式下才输出日志
'()': 'django.utils.log.RequireDebugTrue',
},
},
'handlers': { # 日志处理方法
'console': { # 向终端中输出日志
'level': 'INFO',
'filters': ['require_debug_true'],
'class': 'logging.StreamHandler',
'formatter': 'simple'
},
'file': { # 向文件中输出日志
'level': 'INFO',
'class': 'logging.handlers.RotatingFileHandler',
'filename': os.path.join(os.path.dirname(BASE_DIR), 'logs/shop.log'), # 日志文件的位置
'maxBytes': 300 * 1024 * 1024,
'backupCount': 10,
'formatter': 'verbose'
},
},
'loggers': { # 日志器
'django': { # 定义了一个名为django的日志器
'handlers': ['console', 'file'], # 可以同时向终端与文件中输出日志
'propagate': True, # 是否继续传递日志信息
'level': 'INFO', # 日志器接收的最低日志级别
},
}
}
配置静态页面
将静态页面文件拷贝到二级shop目录下
在dev.py中配置静态文件路径
STATIC_URL = '/static/'
# 配置静态文件加载路径
STATICFILES_DIRS = [os.path.join(BASE_DIR, 'static')]
配置模板文件
新建名为templates的python package于二级shop中，将其标记为Template Folder
项目环境搭建完毕，开启服务器，在浏览器中查看效果
在浏览器中输入地址：127.0.0.1:8000/static/index.html
编写用户模块代码
新建名为apps的python package于二级shop中
进入apps目录，用Django命令创建子应用：
cd apps
python ../../manage.py startapp users
在dev.py中注册app，在二级shop/apps/users/apps.py中，右击app名称sConfig，选择Copy Reference，拷贝引用，在dev.py中粘贴
‘shop.apps.users.apps.UsersConfig’，
在dev.py中追加导包路径
import sys
sys.path.insert(0, os.path.join(BASE_DIR, 'apps'))
改写注册内容：
‘users.apps.UsersConfig’，
新建名为urls.py的python file于二级shop/apps/users中，在其中填写如下内容：
from django.conf.urls import url
from . import views
urlpatterns = [
url(r'^register/$', views.RegisterView.as_view()), # 匹配注册功能的路由
]
将此子路由添加至总路由（二级shop/urls.py）:
from django.conf.urls import url, include
from django.contrib import admin
urlpatterns = [
url(r'^admin/', admin.site.urls), # 匹配admin站点的路由
url(r'^', include('users.urls')), # 匹配用户模块的路由
]
编写视图函数RegisterView在二级shop/apps/users/views.py中：
from django.shortcuts import render
from django.views import View
class RegisterView(View):
def get(self, request):
return render(request, 'register.html')
编写用户模型类
Django自带了用户模型类，如要添加别的字段，只需继承Django自带的模型类，再添加自己的特有字段即可
在二级shop/apps/users/models.py中添加如下内容：
from django.db import models
from django.contrib.auth.models import AbstractUser
# Create your models here.
class User(AbstractUser):
"""自定义用户模型类"""
mobile = models.CharField(max_length=11, unique=True, verbose_name='手机号')
class Meta:
db_table = 'tb_users'
verbose_name = '用户'
verbose_name_plural = verbose_name
def __str__(self):
return self.username
在dev.py中指定用户模型类：
AUTH_USER_MODEL = 'users.User' # 应用名.模型类名
迁移用户模型类
创建迁移文件
python manage.py makemigrations
执行迁移文件
python manage.py migrate
编码
注册功能
填写完注册页面表单后，后台要处理
POST请求
在二级shop/apps/users/views.py/RegisterView中添加如下代码：
def post(self, request):
# 1.接收
user_name = request.POST.get('user_name')
pwd = request.POST.get('pwd')
cpwd = request.POST.get('cpwd')
phone = request.POST.get('phone')
allow = request.POST.get('allow')
# 2.验证
# 2.1验证非空
if not all([user_name, pwd, cpwd, phone, allow, sms_code_request]):
return http.HttpResponseBadRequest('参数不完整') # from django import http
# 2.2用户名拼写是否符合规范，是否已存在该用户名
if not re.match(r'^[a-zA-Z0-9_-]{5,20}$', user_name):
return http.HttpResponseBadRequest('请输入5-20个字符') # import re
if User.object.filter(username=user_name).count() > 0: # from .models import User
return http.HttpResponseBadRequest('用户名已存在')
# 2.3密码拼写是否符合规范，两次密码输入是否一致
if not re.match(r'[0-9A-Za-z]{8,20}$', pwd):
return http.HttpResponseBadRequest('请输入8-20的密码')
if pwd != cpwd:
return http.HttpResponseBadRequest('两次密码输入不一致')
# 2.4手机号拼写是否符合规范，手机号是否已经被使用
if not re.match(r'^1[345789]\d{9}', phone):
return http.HttpResponseBadRequest('手机号格式不正确')
if User.objects.filter(mobile=phone).count() > 0:
return http.HttpResponseBadRequest('手机号已存在')
# 3.创建用户对象并保存在列表中
user = User.objects.create_user(username=user_name, password=pwd, mobile=phone)
# 4.状态保持
login(request, user) # from django.contrib.auth import login
# 5.响应，返回首页
return redirect('/') # from django.shortcuts import redirect
用Ajax异步校验的方式验证用户名是否存在
在子路由中添加ajax的路由：
url(r'^usernames/(?P<username>[a-zA-Z0-9_-]{5,20})/count/$', views.UsernameCountView.as_view()),
在二级shop/apps/users/views.py中添加视图类：
class UsernameCountView(View):
def get(self, request, username):
# 接收
# 验证
# 处理
count = User.objects.filter(username=username).count()
# 响应
return http.JsonResponse({
'code':RETCODE.OK, # from shop.utils.response_code import RETCODE
'errmsg':'OK',
'count':count
})
用Ajax异步校验的方式验证手机号是否存在
在子路由中添加ajax的路由：
url('^mobiles/(?P<mobile>1[3-9]\d{9})/count/$', views.MobileCountView.as_view()),
在二级shop/apps/users/views.py中添加视图类：
class MobileCountView(View):
def get(self, request, mobile):
# 接收
# 验证
# 处理，查询统计
count = User.objects.filter(mobile=mobile).count()
# 响应
return http.JsonResponse({
'code':RETCODE.OK,
'errmsg':'OK',
'count':count
})
新建名为response_code的python file于utils目录中，内容如下：
class RETCODE:
OK = "0"
IMAGECODEERR = "4001"
THROTTLINGERR = "4002"
NECESSARYPARAMERR = "4003"
USERERR = "4004"
PWDERR = "4005"
CPWDERR = "4006"
MOBILEERR = "4007"
SMSCODERR = "4008"
ALLOWERR = "4009"
SESSIONERR = "4101"
DBERR = "5000"
EMAILERR = "5001"
TELERR = "5002"
NODATAERR = "5003"
NEWPWDERR = "5004"
OPENIDERR = "5005"
PARAMERR = "5006"
STOCKERR = "5007"
图片验证码
安装pillow
pip install Pillow
新建名为libs的python package目录于二级shop中，将第三方图片验证码工具captcha拷贝至这里。
新建名为verifications的app于apps中：
python ../../manage.py startapp verifications
注册app于dev.py中：
'verifications.apps.VerificationsConfig',
新建路由表urls，在子路由中添加路由：
urlpatterns = [
url(r'^image_codes/(?P<uuid>[\w-]+)/$', views.ImagecodeView.as_view()), # from . import views
] # from django.conf.urls import url
在总路由中包含子路由：
urlpatterns = [
url(r'^', include('verifications.urls')),
]
编写视图函数：
class ImagecodeView(View):
def get(self, request, uuid):
# 接收
# 验证
# 处理
# 1.生成图形验证码数据：字符code、图片image
text, code, image = captcha.generate_captcha()
# from shop.libs.captcha.captcha import captcha
# 2.保存字符，用于后续验证
# 2.1连接redis，参数为caches中的键
redis_cli = get_redis_connection('verify_code') # from django_redis import get_redis_connection
# 2.2向redis中写数据
redis_cli.setex(uuid, constants.IMAGE_CODE_EXPIRES, code)
# from . import constants
# 响应，输出图片数据
return http.HttpResponse(image, content_type='image/png')
新建名为constants的py文件于verifications目录下，编写其内容如下：
# 验证码过期时间，当前为5分钟
IMAGE_CODE_EXPIRES = 60 * 5 # 设置过期时间
# 短信验证码过期时间，当前为5分钟
SMS_CODE_EXPIRES = 60 * 5
# 过期时间of短信是否重复发送的标记，当前为60s
SMS_CODE_FLAG_EXPIRES = 60
验证码字符在redis缓存中存储，在dev.py中新建缓存字段verify_code：
"verify_code":{
"BACKEND":"django_redis.cache.RedisCache",
"LOCATION":"redis://127.0.0.1:6379/2", # 用第二个数据库
"OPTIONS":{
"CLIENT_CLASS":"django_redis.client.DefaultClient",
}
},
注意：chrome有个大坑，它会缓存之前请求过的地址。验证码的请求地址是和host.js关联的。当更改了host.js时，重新访问发现地址并没有更改，这是chrome缓存的缘故，记得定期清理缓存。
短信验证码
拷贝工具代码yuntongxun(短信)至子shop/libs目录中
在verifications/url中添加路由：
from django.conf.urls import url
from . import views
urlpatterns = [
url(r'^image_codes/(?P<uuid>[\w-]+)/$', views.ImagecodeViews.as_view()),
url('^sms_codes/(?P<mobile>1[3-9]\d{9})/$', views.SmscodeView.as_view()),
]
在verifications/views.py中添加名为SmscodeView的视图函数：
class SmscodeView(View):
def get(self, request):
# 接收
image_code_request = request.GET.get('image_code') # 用户填写的图形验证码文本
uuid = request.GET.get('image_code_id') # 图形验证码的唯一编号
# 验证，图形验证码是否正确
redis_cli = get_redis_connection('verify_code')
image_code_redis = redis_cli.get(uuid)
if not image_code_redis:
return http.JsonResponse({
'code':RETCODE.PARAMERR,
'errmsg':'图形验证码已过期'
})
# 强制验证码只能使用一次
redis_cli.delete(uuid)
# 判断用户输入的值是否正确
# 注意：所有从redis总读取的数据都是bytes，需要转码
if image_code_redis.decode() != image_code_request.upper():
return http.JsonResponse({
'code':RETCODE.PARAMERR,
'errmsg':'图形验证码错误'
})
# 处理
# 1.生成六位随机数
sms_code = '%6d' % random.randint(0, 999999)
# 2.保存到redis
redis_cli.setex('sms_'+mobile, 300, sms_code)
# 发短信，from shop.lib.yuntongxun.sms import CCP
# ccp = CCP()
# ret = ccp.send_template_sms(mobile, [sms_code, contansts.SMS_CODE_EXPIRES / 60], 1)
print(sms_code)
# 响应
return http.JsonResponse({
'code':RETCODE.OK,
'errmsg':'OK'
})
在注册视图中验证短信验证码，改写二级shop/apps/users/views.py：
def post(self, request):
# 1.接收
user_name = request.POST.get('user_name')
pwd = request.POST.get('pwd')
cpwd = request.POST.get('cpwd')
phone = request.POST.get('phone')
allow = request.POST.get('allow')
sms_code_request = request.POST.get('msg_code') # 新添加
# 2.验证
# 2.1验证非空
if not all([user_name, pwd, cpwd, phone, allow, sms_code_request]):
return http.HttpResponseBadRequest('参数不完整') # from django import http
# 2.2用户名拼写是否符合规范，是否已存在该用户名
if not re.match(r'^[a-zA-Z0-9_-]{5,20}$', user_name):
return http.HttpResponseBadRequest('请输入5-20个字符') # import re
if User.objects.filter(username=user_name).count() > 0: # from .models import User
return http.HttpResponseBadRequest('用户名已存在')
# 2.3密码拼写是否符合规范，两次密码输入是否一致
if not re.match(r'[0-9A-Za-z]{8,20}$', pwd):
return http.HttpResponseBadRequest('请输入8-20的密码')
if pwd != cpwd:
return http.HttpResponseBadRequest('两次密码输入不一致')
# 2.4手机号拼写是否符合规范，手机号是否已经被使用
if not re.match(r'^1[345789]\d{9}', phone):
return http.HttpResponseBadRequest('手机号格式不正确')
if User.objects.filter(mobile=phone).count() > 0:
return http.HttpResponseBadRequest('手机号已存在')
# 2.5短信验证码，from django_redis import get_redis_connection
# 连接redis
redis_cli = get_redis_connection('verify_code')
# 读取短信验证码
sms_code_redis = redis_cli.get('sms_' + phone)
# 判断是否过期
if not sms_code_redis:
return http.HttpResponseBadRequest('短信验证已过期')
# 强制立即过期
redis_cli.delete('sms_' + phone)
# 判断短信验证码是否正确
if sms_code_redis != sms_code_request:
return http.HttpResponseBadRequest('短信验证码错误')
# 3.创建用户对象并保存在列表中
user = User.objects.create_user(username=user_name, password=pwd, mobile=phone)
# 4.状态保持
login(request, user) # from django.contrib.auth import login
# 5.响应，返回首页
return redirect('/') # from django.shortcuts import redirect
避免频繁发送短信，添加如下代码于verificatons/views.py中：
# 判断用户输入的值是否正确
# 注意：所有从redis总读取的数据都是bytes，需要转码
if image_code_redis.decode() != image_code_request.upper():
return http.JsonRequest({
'code':RETCODE.PARAMERR,
'errmsg':'图形验证码错误'
})
# 是否已经向此手机号发送过短信，新加代码
if redis_cli.get('sms_flag_' + mobile):
return http.JsonResponse({
'code':RETCODE.PARAMERR,
'errmsg':'已经向次手机号发过短信，请查看手机'
})
# 处理
# 1.生成六位随机数
sms_code = '%6d' % random.randint(0, 999999)
# 2.保存到redis
redis_cli.setex('sms_'+mobile, constants.SMS_CODE_EXPIRES, sms_code)
# 存储60s发送的标记,新加代码
redis_cli.setex('sms_flag_' + mobile, constants.SMS_CODE_FLAG_EXPIRES, 1)
# 发短信，from shop.lib.yuntongxun.sms import CCP
# ccp = CCP()
# ret = ccp.send_template_sms(mobile, [sms_code, contansts.SMS_CODE_EXPIRES / 60], 1)
print(sms_code)
使用pipeline优化与redis交互，只与redis服务器交互一次，执行多条命令
# 1.生成六位随机数
# sms_code = '%6d' % random.randint(0, 999999)
# 2.保存到redis
# redis_cli.setex('sms_'+mobile, constants.SMS_CODE_EXPIRES, sms_code)
# 存储60s发送的标记,新加代码
# redis_cli.setex('sms_flag_' + mobile, constants.SMS_CODE_FLAG_EXPIRES, 1)
# 改写成下面这样
redis_pl = redis_cli.pipeline()
redis_pl.setex('sms_'+mobile, constants.SMS_CODE_EXPIRES, sms_code)
redis_pl.setex('sms_flag_' + mobile, constants.SMS_CODE_FLAG_EXPIRES, 1)
redis_pl.execute()
使用celery框架实现异步
新建名为celery_tasks的python package于一级shop中
新建名为main的python file于celery_tasks中，内容如下：
from celery import Celery
import os
os.environ["DJANGO_SETTINGS_MODULE"] = "shop.settings.dev"
# 创建主对象
app = Celery('shop')
# 读取配置：指定消息队列，当前使用redis
app.config_from_object('celery_tasks.config')
# 自动识别
app.autodiscover_tasks([
'celery_tasks.sms',
])
新建名为config的python file于celery_tasks中，内容如下：
broker_url = 'redis://127.0.0.1:6379/15'
新建名为sms的python package于celery_tasks中
新建名为tasks的python file于sms中，内容如下：
from shop.libs.yuntongxun.sms import CCP
from celery_tasks.main import app
@app.task(bind=True, name='send_sms', retry_backoff = 3)
def send_sms(self, to, datas, tempid):
try:
#ccp = CCP()
#ret = ccp.send_template_sms(to, datas, 1)
print(datas[0])
except Exception as e:
self.retry(exc = e, max_retries = 3)
在shell中运行如下命令，开启celery服务：
celery -A celery_tasks.main worker -l info
调用任务，于二级shop/apps/users/views.py中：
from celery_tasks.sms.tasks import send_sms
# 发短信，from shop.lib.yuntongxun.sms import CCP
# ccp = CCP()
# ret = ccp.send_template_sms(mobile, [sms_code, contansts.SMS_CODE_EXPIRES / 60], 1)
# print(sms_code)
send_sms.delay(mobile, [sms_code, contansts.SMS_CODE_EXPIRES / 60], 1)
登录功能
在二级shop/apps/users/urls.py中添加登录的路由：
url('^login/$', views.LoginView.as_view()),
在二级shop/apps/users/views.py中添加视图类：
class LoginView(View):
def get(self, request):
return render(request, 'login.html') # 之后拷贝模板
def post(self, request):
# 接收
username = request.POST.get('username')
pwd = request.POST.get('pwd')
# 验证
if not all([user_name, pwd]):
return http.HttpResponseBadRequest('参数不完整') # from django import http
# 2.2用户名拼写是否符合规范，是否已存在该用户名
if not re.match(r'^[a-zA-Z0-9_-]{5,20}$', user_name):
return http.HttpResponseBadRequest('请输入5-20个字符') # import re
if not re.match(r'[0-9A-Za-z]{8,20}$', pwd):
return http.HttpResponseBadRequest('请输入8-20的密码')
# 处理
user = authenticate(username = username, pwd = pwd) # from django.contrib.auth import authenticate
if user is None:
# 用户名或密码错误
return render(request, 'login.html', {
'loginerror':'用户名或密码错误'
})
else:
# 登录成功，状态保持
login(request, user)
return redirect('/')
# 响应
多账号登录
新建名为shop_backends的python file于utils中，内容如下：
from django.contrib.auth.backends import ModelBackend
class ShopModelBackend(ModelBackend):
def authenticate(self, request, username=None, password=None, **kwargs):
# username接收的数据，可能是手机号，也可能是用户名
try:
if re.match('^1[3-9]\d{9}$', username):
# 手机号
user = User.objects.get(mobile=username)
else:
# 用户名
user = User.objects.get(username=username)
except:
return None
else:
# 验证密码
if user.check_password(password):
return user
else:
return None
在dev.py中添加自定义认证类型：
AUTHENTICATION_BACKENDS = ['shop.utils.auth_backends.ShopModelBackend']
首页用户名显示
新建应用，cd shop/shop/apps，python ../../manage.py startapp contents
注册应用，新建urls.py：
from django.conf.urls import url
from . import views
urlpatterns = [
url('^$', views.IndexView.as_view()),
]
在dev.py中注册应用：
'contents.apps.ContentsConfig',
在总路由中添加子路由：
url('^', include('content.urls')),
添加视图类：
from django.shortcuts import render
from django.views import View
class IndexView(View):
def get(self, request):
return render(request, 'index.html')
更改users/views.py.LoginView ：
else:
# 登录成功，状态保持
login(request, user)
# 向cookie中输出用户名，用于在前端提示登录状态
response = redirect('/')
response.set_cookie('username', user.username, max_age=60*60*24*14)
return response
更改users/views.py.RegisterView：
# 响应
response = redirect('/')
response.set_cookie('username', user.username, max_age=60*60*24*14)
return response
退出
在users/views.py中添加新的视图类：
class LogoutView(View):
def get(self, request):
# 删除session
logout(request)
# 删除cookie
response = redirect('/')
response.delete_cookie('usename')
return response
在users.urls.py中添加路由：
url('^logout/$', views.LogoutView.as_view()),
用户个人信息
添加路由在users/urls.py中：
url('^info/$', views.InfoView.as_view()),
添加视图类在users/views.py中：
class InfoView(View):
def get(self, request):
# 判断是否登录
if request.user.is_authenticated:
# 已登录
return render(request, 'user_center_info.html')
else:
# 未登录
return redirect('/login/')
拷贝页面至templates中。
判断是否登录
在dev.py中指定登录页视图：
LOGIN_URL = '/login/'
改写views.py中的代码：
from django.contrib.auth.mixins import LoginRequiredMixin
class InfoView(LoginRequiredMixin, View):
def get(self, request):
# 判断是否登录
# if request.user.is_authenticated:
# 已登录
# return render(request, 'user_center_info.html')
# else:
# 未登录
# return redirect('/login/')
return render(request, 'user_center_info.html')
完善登录视图代码：
class LoginView(View):
def get(self, request):
return render(request, 'login.html') # 之后拷贝模板
def post(self, request):
# 接收
username = request.POST.get('username')
pwd = request.POST.get('pwd')
# 接收重定向参数，新加代码
next_url = request.GET.get('next', '/')
# 验证
if not all([user_name, pwd]):
return http.HttpResponseBadRequest('参数不完整') # from django import http
# 2.2用户名拼写是否符合规范，是否已存在该用户名
if not re.match(r'^[a-zA-Z0-9_-]{5,20}$', user_name):
return http.HttpResponseBadRequest('请输入5-20个字符') # import re
if not re.match(r'[0-9A-Za-z]{8,20}$', pwd):
return http.HttpResponseBadRequest('请输入8-20的密码')
# 处理
user = authenticate(username = username, pwd = pwd) # from django.contrib.auth import authenticate
if user is None:
# 用户名或密码错误
return render(request, 'login.html', {
'loginerror':'用户名或密码错误'
})
else:
# 登录成功，状态保持
login(request, user)
# 向cookie中输出用户名，用于在前端提示登录状态
response = redirect(next_url)
response.set_cookie('username', user.username, max_age=60*60*24*14)
return response
QQ授权登录
在虚拟环境中安装QQLoginTool
pip install QQLoginTool
新建名为oauth的应用，python ../../manage.py startapp oauth
新建urls.py，内容如下：
from django.conf.urls import url
from . import views
urlpatterns = [
url('^qq/login/$', views.QQurlView.as_view()),
url('^oauth_callback$', views.QQopenidView.as_view()),
]
在总路由中添加子路由：
url('^', include('oauth.urls')),
在dev.py中注册app
'oauth.apps.OauthConfig',
在views.py中创建类视图：
from django.shortcuts import render
from django.views import View
from django import http
from QQLoginTool.QQtool import OAuthQQ
from django.conf import settings
class QQurlView(View):
def get(self, request):
# 生成QQ授权地址url
next_url = request.GET.get('next', '/')
# 创建工具对象，提供appid、appkey、回调地址
oauthqq_tool = OAuthQQ(
settings.QQ_CLIENT_ID,
settings.QQ_CLIENT_SECRET,
settings.QQ_CLIENT_URI,
next_url
)
login_url = oauthqq_tool.get_qq_url()
return http.JsonResponse({
'code':RETCODE.OK,
'errmsg':'OK',
'login_url':login_url
})
class QQopenidView(View):
def get(self, request):
# 获取授权用户的唯一标识openid
# 接收code
code = request.GET.get('code')
next_url = request.GET.get('state', '/')
# 创建工具对象，提供appid、appkey、回调地址
oauthqq_tool = OAuthQQ(
settings.QQ_CLIENT_ID,
settings.QQ_CLIENT_SECRET,
settings.QQ_CLIENT_URI,
next_url
)
try:
# 根据code获取token
token = oauthqq_tool.get_access_token(code)
# 根据token获取openid
openid = oauthqq_tool.get_openid(token)
except:
openid = '0'
return http.HttpResponse(openid)
在dev.py中添加QQ授权信息：
QQ_CLIENT_ID = '101518219'
QQ_CLIENT_SECRET = '418d84ebdc7241efb79536886ae95224'
QQ_REDIRECT_URI = 'http://www.meiduo.site:8000/oauth_callback'
在/etc/hosts中添加127.0.0.1 www.meiduo.site
在dev.py中添加：ALLOWED_HOSTS = ['www.meiduo.site',]
将host.js中的var host = 'http://www.meiduo.site:8000'的注释打开，其余均注释
QQ账号信息与本网站绑定
新建视图类于oauth/model.py中：
from users.models import User
from shop.utils.models import BaseModel
class OAuthQQUser(models.Model):
user = models.ForeignKey(User)
openid = models.CharField(max_length = 50)
class Meta:
db_table = 'tb_oauth_qq'
新建名为models.py的python file文件于utils目录中，内容为：
from django.db import models
class BaseModel(models.Model):
create_time = models.DateField(auto_now_add = True)
update_time = models.DateField(auto_now = True)
class Meta:
# 当前模型类为抽象类，用于继承，不需要创建表
abstract = True
执行迁移：
python manage.py makemigrations
python manage.py migrate
改写oauth/views.py文件：
from django.shortcuts import render
from django.views import View
from django import http
from QQLoginTool.QQtool import OAuthQQ
from django.conf import settings
from .models import OAuthQQUser
class QQurlView(View):
def get(self, request):
# 生成QQ授权地址url
next_url = request.GET.get('next', '/')
# 创建工具对象，提供appid、appkey、回调地址
oauthqq_tool = OAuthQQ(
settings.QQ_CLIENT_ID,
settings.QQ_CLIENT_SECRET,
settings.QQ_CLIENT_URI,
next_url
)
login_url = oauthqq_tool.get_qq_url()
return http.JsonResponse({
'code':RETCODE.OK,
'errmsg':'OK',
'login_url':login_url
})
class QQopenidView(View):
def get(self, request):
# 获取授权用户的唯一标识openid
# 接收code
code = request.GET.get('code')
next_url = request.GET.get('state', '/')
# 创建工具对象，提供appid、appkey、回调地址
oauthqq_tool = OAuthQQ(
settings.QQ_CLIENT_ID,
settings.QQ_CLIENT_SECRET,
settings.QQ_CLIENT_URI,
next_url
)
try:
# 根据code获取token
token = oauthqq_tool.get_access_token(code)
# 根据token获取openid
openid = oauthqq_tool.get_openid(token)
# 绑定
try:
# 1.查询是否已经绑定过
qquser = OAuthQQUser.objects.get(openid=openid)
except:
# 2.如果未绑定过，则提示绑定页面
return render(request, 'oauth_callback.html') # 将oauth_callback.html放到templates目录中
# 3.如果已绑定过，则状态保持
except:
openid = '0'
return http.HttpResponse(openid)
在views.py中添加post方法：
class QQopenidView(View):
def get(self, request):
# 获取授权用户的唯一标识openid
# 接收code
code = request.GET.get('code')
next_url = request.GET.get('state', '/')
# 创建工具对象，提供appid、appkey、回调地址
oauthqq_tool = OAuthQQ(
settings.QQ_CLIENT_ID,
settings.QQ_CLIENT_SECRET,
settings.QQ_CLIENT_URI,
next_url
)
try:
# 根据code获取token
token = oauthqq_tool.get_access_token(code)
# 根据token获取openid
openid = oauthqq_tool.get_openid(token)
# 绑定
try:
# 1.查询是否已经绑定过
qquser = OAuthQQUser.objects.get(openid=openid)
except:
# 2.如果未绑定过，则提示绑定页面
context = {'token':openid}
return render(request, 'oauth_callback.html'， context) # 将oauth_callback.html放到templates目录中
# 3.如果已绑定过，则状态保持
except:
openid = '0'
return http.HttpResponse(openid)
def post(self, request):
# openid与账号绑定
安装加密的包：itsdangerous
pip install itsdangerous
新建名为shop_signature.py的python file文件于utils.py中，内容如下：
from itsdangerous import TimedJSONWebSignatureSerializer as Serializer
from django.conf import settings
def dumps(json, expires):
'''
:param json:字典
:param expires:加密数据的过期时间
:return:字符串
'''
# 将字典加密，返回字符串
# 1.创建工具对象
serializer = Serializer(settings.SECRET_KEY, expires)
# 2.加密
serializer.dumps(json)
# 3.转字符串，返回
return s1.decode()
def loadds(s1， expires):
'''
:param s1:字符串
:param expires:加密数据的过期时间
:return:字典
'''
# 将字符串解密，返回字典
# 1.创建工具对象
serializer = Serializer(settings.SECRET_KEY, expires)
# 2.解密
try:
json = serializer.loads(s1)
except:
return None
# 3.返回字典
return json
更改views.py：
class QQopenidView(View):
def get(self, request):
# 获取授权用户的唯一标识openid
# 接收code
code = request.GET.get('code')
next_url = request.GET.get('state', '/')
# 创建工具对象，提供appid、appkey、回调地址
oauthqq_tool = OAuthQQ(
settings.QQ_CLIENT_ID,
settings.QQ_CLIENT_SECRET,
settings.QQ_CLIENT_URI,
next_url
)
try:
# 根据code获取token
token = oauthqq_tool.get_access_token(code)
# 根据token获取openid
openid = oauthqq_tool.get_openid(token)
# 绑定
try:
# 1.查询是否已经绑定过
qquser = OAuthQQUser.objects.get(openid=openid)
except:
# 2.如果未绑定过，则提示绑定页面
token = shop_signature.dumps({'openid':openid}, contants.OPENID_EXPIRES) # from shop.utils import shop_signature, from . import contants
context = {'token':openid}
return render(request, 'oauth_callback.html'， context) # 将oauth_callback.html放到templates目录中
# 3.如果已绑定过，则状态保持
except:
openid = '0'
return http.HttpResponse(openid)
def post(self, request):
# openid与账号绑定
新建名为contants的python file文件于oauth目录中，内容如下：
# openid的过期时间
OPENID_EXPIRES = 60 * 10
写post方法：
def post(self, request):
# openid与账号绑定
# 接收
mobile = request.POST.get('mobile')
pwd = request.POST.get('pwd')
sms_code_request = request.POST.get('sms_code')
access_token = request.POST.get('access_token')
next_url = request.GET.get('state')
# 验证:与注册逻辑相同，参考注册代码
json = shop_signature.loadds(access_token, contants.OPENID_EXPIRES)
if json is None:
return http.HttpResponseBadRequest('授权信息无效，请重新授权')
openid = json.get('openid')
# 处理
# 根据手机号查询注册对象
try:
user = User.objects.get(mobile = mobile)
except:
# 手机号不存在，则注册新用户
user = User.objects.create_user(username=mobile, password=pwd, mobile=mobile)
else:
# 手机号存在，则验证密码
if not user.check_password(pwd):
return http.HttpResponseBadRequest('密码错误')
# 绑定
OAuthQQUSer.objects.create(user=user, openid=openid) # from .models import OAuthQQUser
# 状态保持
login(request, user) # from django.contrib.auth import login
# 响应
response = redirect(next_url) # from django.shortcuts import redirect
response.set_cookie('username', user.username, max_age = 60 * 60 * 24 * 14)
return response
非初次授权的情况。补充get方法：
# 3.如果已绑定过，则状态保持
login(request, qquser.user)
response = redirect(next_url)
response.set_cookie('username', qquser.user.username, max_age = 60 * 60 * 24 * 14)
return response
显示用户的个人信息
改写users/views.py/InfoView：
def InfoView(LoginRequiredMixin, View):
def get(self, request):
# 获取当前登录的用户
user = request.user
context = {
'username':user.username,
'mobile':user.mobile,
'email':user.email,
'email_active':user.email_active
}
在models.py/User中添加邮箱激活属性：
class User(AbstractUser):
mobile = model.CharField(max_length=11)
# 邮箱是否被激活
email_active = models.BooleanField(default=False)
迁移：
python manage.py makemigratons
python manage.py migrate
邮箱
在users/urls.py中添加路由：
url('^emails$', views.EmailView.as_view()),
在users.views.py中添加视类图：
class EmailView(LoginRequiredMixin, View):
def put(self, request):
# 接收，以put方式发送的请求
dict1 = json.loads(request.body.decode()) # import json
email = dict1.get('email')
# 验证
if not all([email]):
return http.JsonResponse({
'code':RETCODE.PARAMERR,
'errmsg':'没有邮箱参数'
})
if not re.match('^[a-z0-9][\w\.\-]*@[a-z0-9\-]+(\.[a-z]{2,5}){1,2}$', email):
return http.JsonResponse({
'code':RETCODE.PARAMERR,
'errmsg':'邮箱格式错误'
})
# 处理
# 修改属性
user = request.user
user.email = email
user.save()
# 发邮件
# 响应
return http.JsonResponse({
'code':RETCODE.OK,
'errmsg':'OK'
})
发邮件
在dev.py中添加邮件服务器配置：
EMAIL_BACKEND = 'django.core.mail.backends.smtp.EmailBackend'
EMAIL_HOST = 'smtp.163.com'
EMAIL_PORT = 25
EMAIL_HOST_USER = 'hmmeiduo@163.com'
EMAIL_HOST_PASSWORD = 'hmmeiduo123'
EMAIL_FROM = '美多商城<hmmeiduo@163.com>'
EMAIL_VERIFY_URL = 'http://www.meiduo.site:8000/emails/verification/'
新建名为mail的python package于celery_tasks目录中，在其中新加文件tasks.py
在其中定义方法：
from django.core.mail import send_mail
from django.conf import settings
from celery_tasks.main import app
@app.task(name='send_user_email', bind=True)
def send_user_email(to_mail, verify_url):
html_message = '您的邮箱为：%s，激活链接为%s' % (to_mail, verify_url)
try:
send_mail('美多商城-邮箱激活','', settings.EMAIL_FROM, [to_mail], html_message=html_message)
except Exception as e:
self.retry(exc=e, max_retries=2)
在celery_tasks/sms/main.py中添加任务：
app.autodiscover_tasks([
'celery_tasks.sms',
'celery_tasks.mail',
])
启动celery：celery -A celery tasks.main worker -l info
在views.py中调用任务
from celery_tasks.mail.tasks import send_user_email
...
# 发邮件,from django.conf import settings, from shop.utils import shop_signature,from . import contants
token = shop_signature.dumps({'user_id':user_id}, contants.EMAIL_EXPIRES)
verify_url = settings.EMAIL_VERIFY_URL + '?token=%s' % token
send_user_email.delay(email, verify_url)
在users，目录总新建contants.py，内容为：
# 邮箱激活的有效时间
EMAIL_EXPIRES = 60 * 60 * 2
激活邮箱
新建视图类：
class EmailVerifyView(View):
def get(self, request):
# 接收
token = request.GET.get('token')
# 验证
dict1 = meiduo_signature.loadds(token, contants.EMAIL_EXPIRES)
if dict1 is None:
return http.HttpResponseBadRequest('激活信息无效，请重新发邮件')
user_id = dict1.get('user_id')
# 处理
try:
user = User.objects.get(pk=user_id)
except:
return http.HttpResponseBadRequest('激活信息无效')
else:
user.email_active = True
user.save()
# 响应
return redirect('/info/')
添加路由：
url('^emails/verifyication$', views.EmailVerifyView.as_view()),
收货地址
在users/urls.py中添加路由：
url('^addresses$', views.AddressesView.as_view()),
在users/views.py中定义视图类：
class AddressesView(LoginRequiredMixin, View):
def get(self, request):
return render(request, 'user_center_site.html')
新建应用
cd shop/shop/apps/
python ../../manage.py startapp areas
新建路由urls.py
from django.conf.urls import url
from . import views
urlpatterns = [
]
在总路由中添加子路由
url('^', include('areas.urls')),
注册app
'areas.apps.AreasConfig',