$ curl https://downloads.drone.io/cli/latest/drone_linux_amd64.tar.gz \ | tar zx $ sudo install -t /usr/local/bin drone

$ drone exec

public class UnitOfWork : IUnitOfWork
{
    private IDbContext _dbContext;

    public UnitOfWork(IDbContext dbContext)
    {
        _dbContext = dbContext;
    }

    public void RegisterNew<TEntity>(TEntity entity)
        where TEntity : class
    {
        _dbContext.Set<TEntity>().Add(entity);
    }

    public void RegisterDirty<TEntity>(TEntity entity)
        where TEntity : class
    {
        _dbContext.Entry<TEntity>(entity).State = EntityState.Modified;
    }

    public void RegisterClean<TEntity>(TEntity entity)
        where TEntity : class
    {
        _dbContext.Entry<TEntity>(entity).State = EntityState.Unchanged;
    }

    public void RegisterDeleted<TEntity>(TEntity entity)
        where TEntity : class
    {
        _dbContext.Set<TEntity>().Remove(entity);
    }

    public async Task<bool> CommitAsync()
    {
        return await _dbContext.SaveChangesAsync() > 0;
    }

    public void Rollback()
    {
        throw new NotImplementedException();
    }
}

public async Task<bool> Add(string name)
{
    var teacher = new Teacher { Name = "teacher one" };
    _unitOfWork.RegisterNew(teacher);
    await _unitOfWork.CommitAsync();

    

    var student = new Student { Name = name, TeacherId = teacher.Id };
    _unitOfWork.RegisterNew(student);
await _unitOfWork.CommitAsync();

    return true;
}

public interface IDbContext
{
    Database Database { get; } 

    DbSet<TEntity> Set<TEntity>()
        where TEntity : class;

    DbEntityEntry<TEntity> Entry<TEntity>(TEntity entity)
        where TEntity : class;

    Task<int> SaveChangesAsync();
}

public class UnitOfWork : IUnitOfWork
{
    private IDbContext _dbContext;
    private DbContextTransaction _dbTransaction;

    public UnitOfWork(IDbContext dbContext)
    {
        _dbContext = dbContext;
        _dbTransaction = _dbContext.Database.BeginTransaction();
    }

    public async Task<bool> RegisterNew<TEntity>(TEntity entity)
        where TEntity : class
    {
        _dbContext.Set<TEntity>().Add(entity);
        return await _dbContext.SaveChangesAsync() > 0;
    }

    public async Task<bool> RegisterDirty<TEntity>(TEntity entity)
        where TEntity : class
    {
        _dbContext.Entry<TEntity>(entity).State = EntityState.Modified;
        return await _dbContext.SaveChangesAsync() > 0;
    }

    public async Task<bool> RegisterClean<TEntity>(TEntity entity)
        where TEntity : class
    {
        _dbContext.Entry<TEntity>(entity).State = EntityState.Unchanged;
        return await _dbContext.SaveChangesAsync() > 0;
    }

    public async Task<bool> RegisterDeleted<TEntity>(TEntity entity)
        where TEntity : class
    {
        _dbContext.Set<TEntity>().Remove(entity);
        return await _dbContext.SaveChangesAsync() > 0;
    }

    public void Commit()
    {
        _dbTransaction.Commit();
    }

    public void Rollback()
    {
        _dbTransaction.Rollback();
    }
}

public async Task<bool> AddWithTransaction(string name)
{
    var teacher = new Teacher { Name = "teacher one" };
    await _unitOfWork.RegisterNew(teacher);

    

var student = new Student { Name = name, TeacherId = teacher.Id };
    await _unitOfWork.RegisterNew(student);

    _unitOfWork.Commit();
    return true;
}

public class UnitOfWork : IUnitOfWork
{
    private IDbContext _dbContext;
    private DbContextTransaction _dbTransaction;

    public UnitOfWork(IDbContext dbContext)
    {
        _dbContext = dbContext;
    }

    
    public void BeginTransaction()
    {
        _dbTransaction = _dbContext.Database.BeginTransaction();
    }

    public async Task<bool> RegisterNew<TEntity>(TEntity entity)
        where TEntity : class
    {
        _dbContext.Set<TEntity>().Add(entity);
        if (_dbTransaction != null)
            return await _dbContext.SaveChangesAsync() > 0;
        return true;
    }

    public async Task<bool> RegisterDirty<TEntity>(TEntity entity)
        where TEntity : class
    {
        _dbContext.Entry<TEntity>(entity).State = EntityState.Modified;
        if (_dbTransaction != null)
            return await _dbContext.SaveChangesAsync() > 0;
        return true;
    }

    public async Task<bool> RegisterClean<TEntity>(TEntity entity)
        where TEntity : class
    {
        _dbContext.Entry<TEntity>(entity).State = EntityState.Unchanged;
        if (_dbTransaction != null)
            return await _dbContext.SaveChangesAsync() > 0;
        return true;
    }

    public async Task<bool> RegisterDeleted<TEntity>(TEntity entity)
        where TEntity : class
    {
        _dbContext.Set<TEntity>().Remove(entity);
        if (_dbTransaction != null)
            return await _dbContext.SaveChangesAsync() > 0;
        return true;
    }

    public async Task<bool> Commit()
    {
        if (_dbTransaction == null)
            return await _dbContext.SaveChangesAsync() > 0;
        else
            _dbTransaction.Commit();
        return true;
    }

    public void Rollback()
    {
        if (_dbTransaction != null)
            _dbTransaction.Rollback();
    }
}

public int UserId { get; set; }

public string UserLoginName { get; set; }

public string UserDisplayName { get; set; }

public string UserEmail { get; set; }

public string UserAlias { get; set; }

namespace CNBlogs.Apply.Domain.ValueObjects
{
    public class User
    {
        public string LoginName { get; set; }

        public string DisplayName { get; set; }

        public string Email { get; set; }

        public string Alias { get; set; }

        [JsonProperty("SpaceUserID")]
        public int Id { get; set; }
    }
}

namespace CNBlogs.Apply.ServiceAgent
{
    public class UserService
    {
        private static string userHost = "";

        public static async Task<User> GetUserByLoginName(string loginName)
        {
            using (var httpCilent = new HttpClient())
            {
                httpCilent.BaseAddress = new System.Uri(userHost);
                var response = await httpCilent.GetAsync($"/users?loginName={Uri.EscapeDataString(loginName)}");
                if (response.StatusCode == HttpStatusCode.OK)
                {
                    return await response.Content.ReadAsAsync<CNBlogs.Apply.Domain.ValueObjects.User>();
                }
                return null;
            }
        }
    }
}

namespace CNBlogs.Apply.Domain
{
    public class JsPermissionApply : IAggregateRoot
    {
        private IEventBus eventBus;

        public JsPermissionApply()
        { }

        public JsPermissionApply(string reason, User user, string ip)
        {
            if (string.IsNullOrEmpty(reason))
            {
                throw new ArgumentException("申请内容不能为空");
            }
            if (reason.Length > 3000)
            {
                throw new ArgumentException("申请内容超出最大长度");
            }
            if (user == null)
            {
                throw new ArgumentException("用户为null");
            }
            if (user.Id == 0)
            {
                throw new ArgumentException("用户Id为0");
            }
            this.Reason = HttpUtility.HtmlEncode(reason);
            this.User = user;
            this.Ip = ip;
            this.Status = Status.Wait;
        }

        public int Id { get; private set; }

        public string Reason { get; private set; }

        public virtual User User { get; private set; }

        public Status Status { get; private set; } = Status.Wait;

        public string Ip { get; private set; }

        public DateTime ApplyTime { get; private set; } = DateTime.Now;

        public string ReplyContent { get; private set; }

        public DateTime? ApprovedTime { get; private set; }

        public bool IsActive { get; private set; } = true;

        public async Task<bool> Pass()
        {
            if (this.Status != Status.Wait)
            {
                return false;
            }
            this.Status = Status.Pass;
            this.ApprovedTime = DateTime.Now;
            this.ReplyContent = "恭喜您！您的JS权限申请已通过审批。";
            eventBus = IocContainer.Default.Resolve<IEventBus>();
            await eventBus.Publish(new JsPermissionOpenedEvent() { UserId = this.User.Id });
            return true;
        }

        public bool Deny(string replyContent)
        {
            if (this.Status != Status.Wait)
            {
                return false;
            }
            this.Status = Status.Deny;
            this.ApprovedTime = DateTime.Now;
            this.ReplyContent = replyContent;
            return true;
        }

        public bool Lock()
        {
            if (this.Status != Status.Wait)
            {
                return false;
            }
            this.Status = Status.Lock;
            this.ApprovedTime = DateTime.Now;
            this.ReplyContent = "抱歉！您的JS权限申请没有被批准，并且申请已被锁定，具体请联系contact@cnblogs.com。";
            return true;
        }

        public async Task Passed()
        {
            if (this.Status != Status.Pass)
            {
                return;
            }
            eventBus = IocContainer.Default.Resolve<IEventBus>();
            await eventBus.Publish(new MessageSentEvent() { Title = "您的JS权限申请已批准", Content = this.ReplyContent, RecipientId = this.User.Id });
        }

        public async Task Denied()
        {
            if (this.Status != Status.Deny)
            {
                return;
            }
            eventBus = IocContainer.Default.Resolve<IEventBus>();
            await eventBus.Publish(new MessageSentEvent() { Title = "您的JS权限申请未通过审批", Content = this.ReplyContent, RecipientId = this.User.Id });
        }

        public async Task Locked()
        {
            if (this.Status != Status.Lock)
            {
                return;
            }
            eventBus = IocContainer.Default.Resolve<IEventBus>();
            await eventBus.Publish(new MessageSentEvent() { Title = "您的JS权限申请未通过审批", Content = this.ReplyContent, RecipientId = this.User.Id });
        }
    }
}

SELECT TOP 1000 [Id]
      ,[Reason]
      ,[Status]
      ,[Ip]
      ,[ApplyTime]
      ,[ReplyContent]
      ,[ApprovedTime]
      ,[IsActive]
      ,[User_LoginName]
      ,[User_DisplayName]
      ,[User_Email]
      ,[User_Alias]
      ,[User_Id]
  FROM [cnblogs_apply].[dbo].[JsPermissionApplys]

namespace CNBlogs.Apply.Application.DTOs
{
    public class JsPermissionApplyDTO
    {
        public int Id { get; set; }

        public string Reason { get; set; }

        public string Ip { get; set; }

        public DateTime ApplyTime { get; set; }

        public int UserId { get; set; }

        public string UserLoginName { get; set; }

        public string UserDisplayName { get; set; }

        public string UserEmail { get; set; }

        public string UserAlias { get; set; }
    }
}

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中打开

os.environ.setdefault("DJANGO_SETTINGS_MODULE", "shop.settings") 
os.environ.setdefault("DJANGO_SETTINGS_MODULE", "shop.settings.dev") 

TEMPLATES = [
    {
        'BACKEND': 'django.template.backends.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',
            ],
            
            'environment': 'meiduo_mall.utils.jinja2_env.jinja2_environment', 
        },
    },
]

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 -uroot -p111

create database shop charset=utf8; 
create user shoproot identified by '111'; 
grant all on shop.* to 'shop'@'%'; 
flush privileges; 

DATABASES = {
    'default': {
        'ENGINE': 'django.db.backends.mysql', 
        'HOST': '127.0.0.1', 
        'PORT': 3306, 
        'USER': 'shoproot', 
        'PASSWORD': '111', 
        'NAME': 'shop' 
    },
}

from pymysql import install_as_MySQLdb
install_as_MySQLdb()

CACHES = {
    "default": { 
        "BACKEND": "django_redis.cache.RedisCache",
        "LOCATION": "redis://127.0.0.1:6379/0",
        "OPTIONS": {
            "CLIENT_CLASS": "django_redis.client.DefaultClient",
        }
    },
    "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"

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.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': {  
            'handlers': ['console', 'file'],  
            'propagate': True,  
            'level': 'INFO',  
        },
    }
}

STATIC_URL = '/static/'


STATICFILES_DIRS = [os.path.join(BASE_DIR, 'static')]

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

‘shop.apps.users.apps.UsersConfig’，

import sys
sys.path.insert(0, os.path.join(BASE_DIR, 'apps'))

‘users.apps.UsersConfig’，

from django.conf.urls import url
from . import views

urlpatterns = [
    url(r'^register/$', views.RegisterView.as_view()),  
]

from django.conf.urls import url, include
from django.contrib import admin

urlpatterns = [
    url(r'^admin/', admin.site.urls),  
    url(r'^', include('users.urls')),  
]

from django.shortcuts import render
from django.views import View


class RegisterView(View):
    def get(self, request):
        return render(request, 'register.html')

from django.db import models
from django.contrib.auth.models import AbstractUser




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

AUTH_USER_MODEL = 'users.User' 

python manage.py makemigrations

python manage.py migrate

def post(self, request):
    
    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')
    
    
    if not all([user_name, pwd, cpwd, phone, allow, sms_code_request]):
        return http.HttpResponseBadRequest('参数不完整') 
    
    if not re.match(r'^[a-zA-Z0-9_-]{5,20}$', user_name):
        return http.HttpResponseBadRequest('请输入5-20个字符') 
    if User.object.filter(username=user_name).count() > 0: 
        return http.HttpResponseBadRequest('用户名已存在')
    
    if not re.match(r'[0-9A-Za-z]{8,20}$', pwd):
        return http.HttpResponseBadRequest('请输入8-20的密码')
    if pwd != cpwd:
        return http.HttpResponseBadRequest('两次密码输入不一致')
    
    if not re.match(r'^1[345789]\d{9}', phone):
        return http.HttpResponseBadRequest('手机号格式不正确')
    if User.objects.filter(mobile=phone).count() > 0:
        return http.HttpResponseBadRequest('手机号已存在')
    
    user = User.objects.create_user(username=user_name, password=pwd, mobile=phone)
    
    login(request, user) 
    
    return redirect('/') 

url(r'^usernames/(?P<username>[a-zA-Z0-9_-]{5,20})/count/$', views.UsernameCountView.as_view()),

class UsernameCountView(View):
    def get(self, request, username):
        
        
        
        count = User.objects.filter(username=username).count()
        
        return http.JsonResponse({
            'code':RETCODE.OK, 
            'errmsg':'OK',
            'count':count
        })

url('^mobiles/(?P<mobile>1[3-9]\d{9})/count/$', views.MobileCountView.as_view()),

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
        })

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"

pip install Pillow

python ../../manage.py startapp verifications

'verifications.apps.VerificationsConfig',

urlpatterns = [
    url(r'^image_codes/(?P<uuid>[\w-]+)/$', views.ImagecodeView.as_view()), 
] 

urlpatterns = [
    url(r'^', include('verifications.urls')),
]

class ImagecodeView(View):
    def get(self, request, uuid):
        
        
        
        
        text, code, image = captcha.generate_captcha()
        
        
        
        redis_cli = get_redis_connection('verify_code') 
        
        redis_cli.setex(uuid, constants.IMAGE_CODE_EXPIRES, code)
        
        
        return http.HttpResponse(image, content_type='image/png')

IMAGE_CODE_EXPIRES = 60 * 5 

SMS_CODE_EXPIRES = 60 * 5

SMS_CODE_FLAG_EXPIRES = 60

"verify_code":{
    "BACKEND":"django_redis.cache.RedisCache",
    "LOCATION":"redis://127.0.0.1:6379/2", 
    "OPTIONS":{
        "CLIENT_CLASS":"django_redis.client.DefaultClient",
    }
},

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()),
]

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)
        
        
        if image_code_redis.decode() != image_code_request.upper():
            return http.JsonResponse({
                'code':RETCODE.PARAMERR,
                'errmsg':'图形验证码错误'
            })
        
        
        sms_code = '%6d' % random.randint(0, 999999)
        
        redis_cli.setex('sms_'+mobile, 300, sms_code)
        
        
        
        print(sms_code)
        
        return http.JsonResponse({
            'code':RETCODE.OK,
            'errmsg':'OK'
        })

def post(self, request):
    
    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') 
    
    
    if not all([user_name, pwd, cpwd, phone, allow, sms_code_request]):
        return http.HttpResponseBadRequest('参数不完整') 
    
    if not re.match(r'^[a-zA-Z0-9_-]{5,20}$', user_name):
        return http.HttpResponseBadRequest('请输入5-20个字符') 
    if User.objects.filter(username=user_name).count() > 0: 
        return http.HttpResponseBadRequest('用户名已存在')
    
    if not re.match(r'[0-9A-Za-z]{8,20}$', pwd):
        return http.HttpResponseBadRequest('请输入8-20的密码')
    if pwd != cpwd:
        return http.HttpResponseBadRequest('两次密码输入不一致')
    
    if not re.match(r'^1[345789]\d{9}', phone):
        return http.HttpResponseBadRequest('手机号格式不正确')
    if User.objects.filter(mobile=phone).count() > 0:
        return http.HttpResponseBadRequest('手机号已存在')
    
    
    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('短信验证码错误')
    
    
    user = User.objects.create_user(username=user_name, password=pwd, mobile=phone)
    
    login(request, user) 
    
    return redirect('/') 

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':'已经向次手机号发过短信，请查看手机'
    })


sms_code = '%6d' % random.randint(0, 999999)

redis_cli.setex('sms_'+mobile, constants.SMS_CODE_EXPIRES, sms_code)

redis_cli.setex('sms_flag_' + mobile, constants.SMS_CODE_FLAG_EXPIRES, 1)



print(sms_code)

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()

from celery import Celery
import os

os.environ["DJANGO_SETTINGS_MODULE"] = "shop.settings.dev"

app = Celery('shop')

app.config_from_object('celery_tasks.config')

app.autodiscover_tasks([
    'celery_tasks.sms',
])

broker_url = 'redis://127.0.0.1:6379/15'

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:
        
        
        print(datas[0])
    except Exception as e:
        self.retry(exc = e, max_retries = 3)

celery -A celery_tasks.main worker -l info

from celery_tasks.sms.tasks import send_sms




send_sms.delay(mobile, [sms_code, contansts.SMS_CODE_EXPIRES / 60], 1)

url('^login/$', views.LoginView.as_view()),

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('参数不完整') 
        
        if not re.match(r'^[a-zA-Z0-9_-]{5,20}$', user_name):
            return http.HttpResponseBadRequest('请输入5-20个字符') 
        if not re.match(r'[0-9A-Za-z]{8,20}$', pwd):
            return http.HttpResponseBadRequest('请输入8-20的密码')
        
        user = authenticate(username = username, pwd = pwd) 
        if user is None:
            
            return render(request, 'login.html', {
                'loginerror':'用户名或密码错误'
            })
        else:
            
            login(request, user)
            return redirect('/')
        

from django.contrib.auth.backends import ModelBackend
class ShopModelBackend(ModelBackend):
    def authenticate(self, request, username=None, password=None, **kwargs):
    
        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

AUTHENTICATION_BACKENDS = ['shop.utils.auth_backends.ShopModelBackend']

from django.conf.urls import url
from . import views

urlpatterns = [
    url('^$', views.IndexView.as_view()),
]

'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')

else:
    
    login(request, user)
    
    response = redirect('/')
    response.set_cookie('username', user.username, max_age=60*60*24*14)
    return response

response = redirect('/')
    response.set_cookie('username', user.username, max_age=60*60*24*14)
    return response

class LogoutView(View):
    def get(self, request):
        
        logout(request)
        
        response = redirect('/')
        response.delete_cookie('usename')
        return response

url('^logout/$', views.LogoutView.as_view()),

url('^info/$', views.InfoView.as_view()),

class InfoView(View):
    def get(self, request):
        
        if request.user.is_authenticated:
            
            return render(request, 'user_center_info.html')
        else:
            
            return redirect('/login/')

LOGIN_URL = '/login/'

from django.contrib.auth.mixins import LoginRequiredMixin
class InfoView(LoginRequiredMixin, View):
    def get(self, request):
        
        
            
            
        
            
            
        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('参数不完整') 
        
        if not re.match(r'^[a-zA-Z0-9_-]{5,20}$', user_name):
            return http.HttpResponseBadRequest('请输入5-20个字符') 
        if not re.match(r'[0-9A-Za-z]{8,20}$', pwd):
            return http.HttpResponseBadRequest('请输入8-20的密码')
        
        user = authenticate(username = username, pwd = pwd) 
        if user is None:
            
            return render(request, 'login.html', {
                'loginerror':'用户名或密码错误'
            })
        else:
        
        login(request, user)
        
        response = redirect(next_url)
        response.set_cookie('username', user.username, max_age=60*60*24*14)
        return response

pip install QQLoginTool

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')),

'oauth.apps.OauthConfig',

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):
        
        next_url = request.GET.get('next', '/')
        
        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):
        
        
        code = request.GET.get('code')
        next_url = request.GET.get('state', '/')
        
        oauthqq_tool = OAuthQQ(
            settings.QQ_CLIENT_ID,
            settings.QQ_CLIENT_SECRET,
            settings.QQ_CLIENT_URI,
            next_url
        )
        try:
            
            token = oauthqq_tool.get_access_token(code)
            
            openid = oauthqq_tool.get_openid(token)
        except:
            openid = '0'
        return http.HttpResponse(openid)

QQ_CLIENT_ID = '101518219'
QQ_CLIENT_SECRET = '418d84ebdc7241efb79536886ae95224'
QQ_REDIRECT_URI = 'http://www.meiduo.site:8000/oauth_callback'

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'

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

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):
        
        next_url = request.GET.get('next', '/')
        
        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):
        
        
        code = request.GET.get('code')
        next_url = request.GET.get('state', '/')
        
        oauthqq_tool = OAuthQQ(
            settings.QQ_CLIENT_ID,
            settings.QQ_CLIENT_SECRET,
            settings.QQ_CLIENT_URI,
            next_url
        )
        try:
            
            token = oauthqq_tool.get_access_token(code)
            
            openid = oauthqq_tool.get_openid(token)
            
            try:
                
                qquser = OAuthQQUser.objects.get(openid=openid)
            except:
                
                return render(request, 'oauth_callback.html') 
                
        except:
            openid = '0'
        return http.HttpResponse(openid)

class QQopenidView(View):
    def get(self, request):
        
        
        code = request.GET.get('code')
        next_url = request.GET.get('state', '/')
        
        oauthqq_tool = OAuthQQ(
            settings.QQ_CLIENT_ID,
            settings.QQ_CLIENT_SECRET,
            settings.QQ_CLIENT_URI,
            next_url
        )
        try:
            
            token = oauthqq_tool.get_access_token(code)
            
            openid = oauthqq_tool.get_openid(token)
            
            try:
                
                qquser = OAuthQQUser.objects.get(openid=openid)
            except:
                
                context = {'token':openid}
                return render(request, 'oauth_callback.html'， context) 
                
        except:
            openid = '0'
        return http.HttpResponse(openid)
    def post(self, request):
        

pip install itsdangerous

from itsdangerous import TimedJSONWebSignatureSerializer as Serializer
from django.conf import settings

def dumps(json, expires):
    '''
    :param json:字典
    :param expires:加密数据的过期时间
    :return:字符串
    '''
    
    
serializer = Serializer(settings.SECRET_KEY, expires)
    
    serializer.dumps(json)
    
    return s1.decode()

def loadds(s1， expires):
    '''
    :param s1:字符串
    :param expires:加密数据的过期时间
    :return:字典
    '''
    
    
serializer = Serializer(settings.SECRET_KEY, expires)
    
    try:
        json = serializer.loads(s1)
    except:
        return None
    
    return json
    

class QQopenidView(View):
    def get(self, request):
        
        
        code = request.GET.get('code')
        next_url = request.GET.get('state', '/')
        
        oauthqq_tool = OAuthQQ(
            settings.QQ_CLIENT_ID,
            settings.QQ_CLIENT_SECRET,
            settings.QQ_CLIENT_URI,
            next_url
        )
        try:
            
            token = oauthqq_tool.get_access_token(code)
            
            openid = oauthqq_tool.get_openid(token)
            
            try:
                
                qquser = OAuthQQUser.objects.get(openid=openid)
            except:
                
                token = shop_signature.dumps({'openid':openid}, contants.OPENID_EXPIRES) 
                context = {'token':openid}
                return render(request, 'oauth_callback.html'， context) 
                
        except:
            openid = '0'
        return http.HttpResponse(openid)
    def post(self, request):
        

OPENID_EXPIRES = 60 * 10

def post(self, request):
    
    
    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) 
    
    login(request, user) 
    
    response = redirect(next_url) 
    response.set_cookie('username', user.username, max_age = 60 * 60 * 24 * 14)
    return response

login(request, qquser.user)
response = redirect(next_url)
response.set_cookie('username', qquser.user.username, max_age = 60 * 60 * 24 * 14)
return response

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
        }
        

class User(AbstractUser):
    mobile = model.CharField(max_length=11)
    
    email_active = models.BooleanField(default=False)

python manage.py makemigratons
python manage.py migrate

url('^emails$', views.EmailView.as_view()),