慕课DJANGO配置

在项目settings.py中添加配置

MEDIA_URL='/media/'
MEDIA_ROOT=os.path.join(BASE_DIR,'medias')
在项目urls中添加配置

from django.views.static import serve
from django.conf import settings

urlpatterns += [
    url(r'^medias/(?P<path>.*)$',serve,{
        'document_root':settings.MEDIA_ROOT,
    }),
]

请求头信息META
REMOTE_ADDR------请求的IP地址
HTTP_USER_AGENT-----用户请求终端信息

text/html——超文本标记语言文本(HTML)
text/plain——普通文本  text/xml——XML文档
image/png、image/jpeg、image/gif——图片或图形
application/json ——json数据类型

HttpResponse
HttpResponseRedirect
JsonResponse——响应json
FileResponse——响应文件

status查看HTTP响应状态码
status_code查看HTTP响应状态码
content_type设置响应的类型
write()写入响应内容

def content(request):
    dic = {
        'username':'jamie',
    }
    # return HttpResponse('ok',content_type='text/plain')
    import json
    ret = json.dumps(dic)
    # return HttpResponse(ret,content_type='application/json')
    return JsonResponse(dic)

def status(request):
    # 改变响应状态码
    ret = HttpResponse('status_code', status=404)
    # 重新设置HTTP的状态码
    ret.status_code = 200
    # 打印HTTPS状态码
    print(ret.status_code)
    # 写入响应内容
    ret.write('多写入响应内容')
    return ret

def image(request):
    # pring image
    import os
    from django.conf import settings
    try:
        file_name = os.path.join(settings.BASE_DIR,'medias/images/1111.png')
        f = open(file_name, 'rb')
    except Exception as e:
        print(e)
    return FileResponse(f,content_type='image/png')
    # application/vnd.ms-excel 这样可以导出EXCEL

url(r'^class/',views.classview.as_view(), name='class'),

from django.views.generic import TemplateView

class classview(TemplateView):
    '''class'''
    template_name = 'class.html'

# !/usr/bin/env python
# _*_ coding:utf-8 _*_
# Author: Jamie


import re
from django import forms
from weibo import models
class UserLoginForm(forms.Form):
    username = forms.CharField(label='用户名',max_length=64)
    password = forms.CharField(label='密码',max_length=64,widget=forms.PasswordInput)
    verify_code = forms.CharField(label='验证码',max_length=64)

    def clean_username(self):
        username = self.cleaned_data['username']
        pattern = r'^0{0,1}1[0-9]{10}$'
        if not re.search(pattern,username):
            raise forms.ValidationError('请输入正确的手机号码')
        return username

    def clean(self):
        cleand_data = super().clean()
        username = cleand_data.get('username',None)
        password = cleand_data.get('password',None)
        if username and password:
            user_list = models.WeiboUser.users.filter(username=username)
            if user_list.count() == 0:
                raise forms.ValidationError('用户名不存在')
            if not user_list.filter(password=password).exists*():
                raise forms.ValidationError('密码错误')
        return cleand_data


class UserForm(forms.ModelForm):
    class Meta:
        model = models.WeiboUser
        fields = ['username','password']
        widgets = {
            'password':forms.PasswordInput(attrs={
                'class':'text-error',
            })
        }
        labels = {
            'username':'手机号码',
        }
        error_messages = {
            'username':{
                'required':'请输入手机号码',
                'max_length':'最长不超过32',
            }
        }

class AvatarUploadForm(forms.Form):
    remark = forms.CharField(label='备注',max_length=32)
    touxiang = forms.FileField(label='头像')

class WeiboImageForm(forms.ModelForm):
    content = forms.CharField(label='微博内容',max_length=256,widget=forms.Textarea(attrs={'placeholder':'请输入微博内容'}))
    class Meta:
        model = models.WeiboImage
        fields = ['image']

    def save(self,user,commit=False):
        obj = super().save(commit)
        data = self.cleaned_data
        content = self.cleaned_data['content']
        #1 创建微博记录
        weibo = models.Weibo.objects.create(user=user,content=content)
        #2 修改微博关联关系
        obj.weibo = weibo
        obj.save()
        return obj

def upload_one(request):
    if request.method == 'POST':
        file = request.FILES.get('touxiang',None)
        import os
        from dalaohu import settings
        filename = os.path.join(settings.MEDIA_ROOT,'touxiang')
        with open(filename,'wb+') as f:
            for i in file.chunks():
                f.write(i)
            print('上传陈功了')
    return render(request,'upload_one.html')

def upload_two(request):
    if request.method == 'POST':
        form = forms.AvatarUploadForm(request.POST,request.FILES)
        if form.is_valid():
            file = request.FILES.get('touxiang', None)
            import os
            from dalaohu import settings
            filename = os.path.join(settings.MEDIA_ROOT, 'touxiang1')
            with open(filename, 'wb+') as f:
                for i in file.chunks():
                    f.write(i)
                print('上传陈功了')
    else:
        form = forms.AvatarUploadForm()
    return render(request,'upload_two.html',{'form':form})

def upload_three(request):
    if request.method == 'POST':
        user = WeiboUser.users.get(pk=1)
        form = forms.WeiboImageForm(request.POST,request.FILES)
        if form.is_valid():
            obj = form.save(user,False)
            print('保存陈功了',obj.pk)
    else:
        form = forms.WeiboImageForm()
    return render(request,'upload_three.html',{
        'form':form
    })

import re

from django import forms
from django.forms import widgets
from django.forms import fields
from django.contrib.auth import authenticate, login
from django.contrib.auth.models import User

from utils.verify import VerifyCode

class UserLoginForm(forms.Form):
    """ 用户登录表单 """
    username = forms.CharField(label='用户名', max_length=64,widget=widgets.TextInput(attrs={'class':'form-control','placeholder':'请输入用户名'}),
                               error_messages={
                                   'required': '请输入用户名',
                               }
                               )
    password = forms.CharField(label='密码', max_length=64,widget=widgets.PasswordInput(attrs={'class':'form-control','placeholder':'请输入密码'}),
                               error_messages={
                                   'required': '请输入密码',
                               })
    verify_code = forms.CharField(label='验证码', max_length=4,widget=widgets.TextInput(attrs={'class':'form-control','placeholder':'验证码'}),
                               error_messages={
                                   'required': '请输入验证码',
                               })

    def __init__(self, request, *args, **kwargs):
        super().__init__(*args, **kwargs)
        self.request = request

    # def clean_username(self):
    #     """ 验证用户名 hook 钩子函数"""
    #     username = self.cleaned_data['username']
    #     print(username)
    #     # 判断用户名是否为手机号码
    #     pattern = r'^0{0,1}1[0-9]{10}$'
    #     if not re.search(pattern, username):
    #         raise forms.ValidationError('请输入正确的手机号码')
    #     return username

    def clean_verify_code(self):
        """ 验证用户输入的验证码是否正确 """
        verify_code = self.cleaned_data['verify_code']
        if not verify_code:
            raise forms.ValidationError('请输入验证码')
        client = VerifyCode(self.request)
        if not client.validate_code(verify_code):
            raise forms.ValidationError('验证码不正确')
        return verify_code

    def clean(self):
        cleaned_data = super().clean()
        print(cleaned_data)
        # 获取用户名和密码 ，不建议使用[]的方式
        # username = cleaned_data['username']

        username = cleaned_data.get('username', None)
        password = cleaned_data.get('password', None)
        if username and password:
            # 查询用户名和密码匹配的用户
            user_list = User.objects.filter(username=username)
            if user_list.count() == 0:
                raise forms.ValidationError('用户名不存在')
            # # 验证密码是否正确
            # if not user_list.filter(password=password).exists():
            #     raise forms.ValidationError('密码错误')
            if not authenticate(username=username, password=password):
                raise forms.ValidationError('密码错误')
        return cleaned_data


class UserRegistForm(forms.Form):
    """ 用户注册表单 """
    username = forms.CharField(label='用户名', max_length=64)
    nickname = forms.CharField(label='昵称', max_length=64)
    password = forms.CharField(label='密码', max_length=64, widget=forms.PasswordInput)
    password_repeat = forms.CharField(label='重复密码', max_length=64, widget=forms.PasswordInput)
    verify_code = forms.CharField(label='验证码', max_length=4)

    def __init__(self, request, *args, **kwargs):
        super().__init__(*args, **kwargs)
        self.request = request

    def clean_username(self):
        """ 验证用户名是否已经被注册 """
        data = self.cleaned_data['username']
        if User.objects.filter(username=data).exists():
            raise forms.ValidationError('用户名已存在')
        return data

    def clean_verify_code(self):
        """ 验证用户输入的验证码是否正确 """
        verify_code = self.cleaned_data['verify_code']
        if not verify_code:
            raise forms.ValidationError('请输入验证码')
        client = VerifyCode(self.request)
        if not client.validate_code(verify_code):
            raise forms.ValidationError('您输入的验证码不正确')
        return verify_code

    def clean(self):
        cleaned_data = super().clean()
        password = cleaned_data.get('password', None)
        password_repeat = cleaned_data.get('password_repeat', None)
        if password and password_repeat:
            if password != password_repeat:
                raise forms.ValidationError('两次密码输入不一致')
        return cleaned_data

    def register(self):
        """ 注册方法 """
        data = self.cleaned_data
        # 1. 创建用户
        User.objects.create_user(username=data['username'],
                                 password=data['password'],
                                 level=0,
                                 nickname='昵称')
        # 2. 自动登录
        user = authenticate(username=data['username'],
                     password=data['password'])
        login(self.request, user)
        return user

from django.contrib.auth import authenticate, login, logout
from utils.verify import VerifyCode
from weibo.forms import UserLoginForm,UserRegistForm
from django.contrib.auth.models import User
def user_add(request):
    '''创建用户'''
    user = User.objects.create_user('liqianlong','lal@126.com',123456)
    return HttpResponse('创建账号成功')

def user_login1(request):
    """ 用户登录 """
    # 如果登录是从其他页面跳转过来的，会带next参数，如果有next参数，登录完成后，需要调转到
    # next所对应的地址，否则，跳转到首页上去
    next_url = request.GET.get('next', 'weibo:index')

    if request.method == 'POST':
        form = UserLoginForm(request=request, data=request.POST)
        # print(request.POST)
        # client = VerifyCode(request)
        # code = request.POST.get('verify_code', None)
        # rest = client.validate_code(code)
        # print('验证结果：', rest)
        # 表单是否通过了验证
        if form.is_valid():
            # 执行登录
            data = form.cleaned_data

            # ## 使用自定义的方式实现登录
            # # 查询用户信息 [MD5]加密算法，不可逆的加密算法 1243 -> sdfadfad
            # user = User.objects.get(username=data['username'], password=data['password'])
            # # 设置用户ID到session
            # request.session[constants.LOGIN_SESSION_ID] = user.id
            # # 登录后的跳转
            # return redirect('index')

            ### 使用django-auth来实现登录
            user = authenticate(request, username=data['username'], password=data['password'])
            print('view:%s' %user.id)
            if user is not None:
                ### 为了测试自定义中间件加的session
                request.session['user_id'] = user.id
                login(request, user)
                # 登录后的跳转
                return redirect(next_url)
        else:
            print(form.errors)
    else:
        form = UserLoginForm(request)
    return render(request, 'login.html', {'form': form,'next_url':next_url})


def user_logout(request):
    """ 用户退出登录 """
    logout(request)
    return redirect('weibo:user_login1')


import logging
logger = logging.getLogger('index')
logger.debug('调试信息')
logger.info('普通信息')
logger.error("异常")

@login_required
def index(request):
    # 记录调试信息
    print('登录成功，打开首页',request.my_user)
    return render(request,'wbindex.html')

def user_register(request):
    """  用户注册 """
    if request.method == 'POST':
        form = UserRegistForm(request=request, data=request.POST)
        if form.is_valid():
            # 调用注册方法
            form.register()
            return redirect('index')
        else:
            print(form.errors)
    else:
        form = UserRegistForm(request=request)
    return render(request, 'register.html', {
        'form': form
    })

def code(request):
    client = VerifyCode(request)
    return client.gen_code()

    # 用户登录
    url(r'^user/user_add/$', views.user_add, name='user_add'),
    url(r'^user/login/$', views.user_login1, name='user_login1'),
    # 用户退出
    url(r'^user/logout/$', views.user_logout, name='user_logout'),
    # 用户注册
    url(r'^user/register/$', views.user_register, name='user_register'),
    # 验证码
    url(r'^user/code/$', views.code, name='verify_code'),
    # index
    url(r'^user/index/$', views.index, name='index'),

"""
生成验证码：
1. 准备素材
字体（ttf），文字内容，颜色，干扰线
2. 画验证码
pip install Pillow   、random
创建图片
记录文字内容，django session【服务器，python代码】
abcdefg  cookie 【浏览器】

(1) 第一次请求，cookie + session 对应关系生成
(2) 第二次请求，携带了cookie，找到对应的session【提交表单】
    请求带上验证码参数 与 session中的验证码进行比较
3. io文件流
BytesIO
"""
import random

import os

from PIL import Image, ImageDraw, ImageFont
from django.conf import settings
from io import BytesIO

from django.http import HttpResponse


class VerifyCode(object):
    """ 验证码类 """

    def __init__(self, dj_request):
        self.dj_request = dj_request
        # 验证码长度
        self.code_len = 4
        # 验证码图片尺寸
        self.img_width = 100
        self.img_height = 30

        # django中session的名称
        self.session_key = 'verify_code'

    def gen_code(self):
        """ 生成验证码 """
        # 1. 使用随机数生成验证码字符串
        code = self._get_vcode()
        # 2. 把验证码存在的session
        self.dj_request.session[self.session_key] = code
        # 3. 准备随机元素（背景颜色、验证码文字的颜色、干扰线、）
        font_color = ['black', 'darkblue', 'darkred', 'brown', 'green', 'darkmagenta', 'cyan', 'darkcyan']
        # RGB随机背景色
        bg_color = (random.randrange(230, 255), random.randrange(230, 255), random.randrange(230, 255))
        # 字体路径
        font_path = os.path.join(settings.BASE_DIR, 'medias', 'fonts', 'timesbi.ttf')

        # 创建图片
        im = Image.new('RGB', (self.img_width, self.img_height), bg_color)
        draw = ImageDraw.Draw(im)

        # 画干扰线
        # 随机条数，到底画几条
        for i in range(random.randrange(1, int(self.code_len / 2) + 1)):
            # 线条的颜色
            line_color = random.choice(font_color)
            # 线条的位置
            point = (
                random.randrange(0, self.img_width * 0.2),
                random.randrange(0, self.img_height),
                random.randrange(self.img_width - self.img_width * 0.2, self.img_width),
                random.randrange(0, self.img_height))
            # 线条的宽度
            width = random.randrange(1, 4)
            draw.line(point, fill=line_color, width=width)

        # 画验证码
        for index, char in enumerate(code):
            code_color = random.choice(font_color)
            # 指定字体
            font_size = random.randrange(15, 25)
            font = ImageFont.truetype(font_path, font_size)
            point = (index * self.img_width / self.code_len,
                     random.randrange(0, self.img_height / 3))
            draw.text(point, char, font=font, fill=code_color)

        buf = BytesIO()
        im.save(buf, 'gif')
        return HttpResponse(buf.getvalue(), 'image/gif')

    def _get_vcode(self):
        random_str = 'ABCDEFGHIGKLMNPQRSTUVWXYZabcdefghijkmnpqrstuvwxyz23456789'
        code_list = random.sample(list(random_str), self.code_len)
        code = ''.join(code_list)
        return code

    def validate_code(self, code):
        """ 验证验证码是否正确 """
        # 1. 转变大小写
        code = str(code).lower()
        vcode = self.dj_request.session.get(self.session_key, '')
        # if vcode.lower() == code:
        #     return True
        # return False
        return vcode.lower() == code

# if __name__ == '__main__':
#     client = VerifyCode(None)
#     client.gen_code()

# orm时间查询时候要是false
USE_TZ = False

# 使用自定义模型的时候，当没有经过验证就会走这里
LOGIN_URL = '/weibo/user/login/'

# CSRF 跨站请求伪造的另一个种解决方法，这样相当于植入到COOKIE中，模板通过jquery.cookie可以获取到
CSRF_USE_SESSIONS=False

import os
import os.path


class FileBackup(object):
    """
    文本文件备份
    """

    def __init__(self, src, dist):
        """
        构造方法
        :param src: 目录 需要备份的文件目录
        :param dist: 目录 备份后的目录
        """
        self.src = src
        self.dist = dist

    def read_files(self):
        """
        读取src目录下的所有文件
        """
        ls = os.listdir(self.src)
        print(ls)
        for l in ls:
            # 循环处理每一个文件/文件夹
            # self.backup_file(l)
            self.backup_file2(l)

    def backup_file(self, file_name):
        """
        处理备份
        :param file_name: 文件/文件夹的名称
        """
        # 1. 判断dist是否存在，如果不存在，要创建这个目录
        if not os.path.exists(self.dist):
            os.makedirs(self.dist)
            print('指定的目录不存在，创建完成')

        # 2. 判断文件是否为我们要备份的文件

        # 拼接文件的完整路径
        full_src_path = os.path.join(self.src, file_name)
        full_dist_path = os.path.join(self.dist, file_name)

        # 首先要判断是否为文件夹，然后借助于文件的后缀名进行判断
        if os.path.isfile(full_src_path) and os.path.splitext(full_src_path)[-1].lower() == '.txt':
            print(full_src_path)
            # 3. 读取文件内容
            with open(full_dist_path, 'w', encoding='utf-8') as f_dist:
                print('>> 开始备份【{0}】'.format(file_name))
                with open(full_src_path, 'r', encoding='utf-8') as f_src:
                    while True:
                        rest = f_src.read(100)
                        if not rest:
                            break
                        # 4. 把读取到的内容写入到新的文件中
                        f_dist.write(rest)
                    f_dist.flush()
                print('>>> 【{0}】备份完成'.format(file_name))
        else:
            print('文件类型不符合备份要求，跳过>>')

    def backup_file2(self, file_name):
        """
        处理备份-优化版本
        :param file_name: 文件/文件夹的名称
        """
        # 1. 判断dist是否存在，如果不存在，要创建这个目录
        if not os.path.exists(self.dist):
            os.makedirs(self.dist)
            print('指定的目录不存在，创建完成')

        # 2. 判断文件是否为我们要备份的文件

        # 拼接文件的完整路径
        full_src_path = os.path.join(self.src, file_name)
        full_dist_path = os.path.join(self.dist, file_name)

        # 首先要判断是否为文件夹，然后借助于文件的后缀名进行判断
        if os.path.isfile(full_src_path) and os.path.splitext(full_src_path)[-1].lower() == '.txt':
            # 3. 读取文件内容
            with open(full_dist_path, 'w', encoding='utf-8') as f_dist, \
                open(full_src_path, 'r', encoding='utf-8') as f_src:
                print('>> 开始备份【{0}】'.format(file_name))
                while True:
                    rest = f_src.read(100)
                    if not rest:
                        break
                    # 4. 把读取到的内容写入到新的文件中
                    f_dist.write(rest)
                f_dist.flush()
                print('>>> 【{0}】备份完成'.format(file_name))
        else:
            print('文件类型不符合备份要求，跳过>>')


if __name__ == '__main__':
    # # 要备份的文件目录地址
    # src_path = 'C:\\Users\\yima1\\Desktop\\py_learn\\chapter04\\src'
    # # 备份后的目录地址
    # dist_path = 'C:\\Users\\yima1\\Desktop\\py_learn\\chapter04\\dist'

    # 当前代码的目录名称
    # C:\Users\yima1\Desktop\py_learn\chapter04\   test_backup.py
    base_path = os.path.dirname(os.path.abspath(__file__))
    # 要备份的文件目录地址
    src_path = os.path.join(base_path, 'src')
    print(src_path)
    # 备份后的目录地址
    dist_path = os.path.join(base_path, 'dist')
    print(dist_path)
    bak = FileBackup(src_path, dist_path)
    bak.read_files()

BACKUPFILE