def list(request):
    u_dict = {}
    try:
        u_dict = all_data(Blog)
        # 嵌套一层
        u_dict = success_response(u_dict)
    except:
        u_dict = error_response(u_dict, "服务器错误,查询异常!")
    return JsonResponse(u_dict)

def all_data(a_model_class, order="id"):
    # 先定义一个字典类型的返回内容
    u_list = {}
    # 要加的key
    i = 0
    # 查询模型
    objs = a_model_class.objects.order_by(order)
    # 遍历模型
    for obj in objs:
        # 转换成当前的查询集字典
        curr_data = model_to_dict(obj)
        # 判断有没有key是img的
        if "img" in curr_data.keys():
            # 要是有就拼settings里面的静态文件路径
            curr_data["img"] = settings.BASE_URL + curr_data["img"]
            # 头像图片
        if "avator_img" in curr_data.keys():
            curr_data["avator_img"] = settings.BASE_URL + curr_data["avator_img"]
        if "src" in curr_data.keys():
            curr_data["src"] = settings.BASE_URL + curr_data["src"]
        # 将处理后的当前数据赋值给字典
        u_list[i] = curr_data
        # 更新key的值
        i += 1
    # 返回数据
    return u_list

def add(request):
    # 定义返回数据
    u_dict = {

    }
    # 判断请求方式
    if (request.method == 'POST'):
        try:
            # 开始处理图片
            # 1.获取表单内容
            data = request.POST.dict()
            print(data)
            # 2. 获取表单中的文件
            file = request.FILES.get('file', None)
            print("file",file)
            # 3. 执行保存文件,并返回文件路径
            # save_file ---> 自定义函数
            path = save_file(file)
            print("path:",path)
            # 构建img字段数据
            data["img"] = path
            # data.pop("file")
            # 保存数据
            Blog(**data).save()
            # 返回数据内容
            u_dict = {
                "msg": "ok",
                "code": "200"
            }
        except:
            u_dict = {
                "msg": "error",
                "code": "500"
            }
    if (request.method == 'GET'):
        u_dict = {
            "msg": "no",
            "code": "666"
        }
    return JsonResponse(u_dict)
	
def save_file(file):
    if file:
        # 上传了头像
        import hashlib
        # 待加密信息(随机数)
        ran_str = str(random.randint(0, 9999999))
        # 创建md5对象
        hl = hashlib.md5()
        to_md5_str = str(time.time())+ran_str
        # Tips
        # 此处必须声明encode
        # 若写法为hl.update(str)  报错为： Unicode-objects must be encoded before hashing
        hl.update(to_md5_str.encode(encoding='utf-8'))
        # 加密完的md5字符串
        md5_str = hl.hexdigest()
        # 文件扩展名
        file_extend_name = file.name.split('.').pop()
        # 拼接文件名
        filename = md5_str + '.' + file_extend_name

        with open(f'./static/uploads/' + filename, 'wb+') as f:
            f.write(file.read())
        # with open(f'./media/uploads/' + filename, 'wb+') as fp:
        #     fp.write(file.read())
        return filename
    else:
        return ""

def delete(request):
    try:
        # 尝试删除
        id = request.GET.get("id")
        obj = Blog.objects.get(id=id)
        obj.delete()
        u_dict = {
            "msg": "ok",
            "code": "200"
        }
    except:
        u_dict = {
            "msg": "error",
            "code": "500"
        }
    return JsonResponse(u_dict)

def edit(request):
    '''
    编辑视图函数
    :param request:
    :return:
    '''

    u_dict = {
    }
    if (request.method == 'POST'):

        # 获取修改的id
        data = request.POST.dict()
        id = data["id"]

        # 2. 获取表单中的文件
        src = request.FILES.get('src', None)
        img = request.FILES.get('img', None)
        path1 = save_file(src)
        path2 = save_file(img)

        print("path1:", path1)
        print("path2:", path2)

        obj = AssessVideo.objects.get(id=id)
        # 删除源文件
        # 获取文件路径
        dict = model_to_dict(obj)
        old_path1 = dict['src']
        old_path2 = dict['img']

        # 如果没有上传文件
        if path1:
            # 执行删除
            del_file(old_path1)
        else:
            path1 = old_path1

        if path2:
            del_file(old_path2)
        else:
            path2 = old_path2

        # 构建img字段数据
        data["src"] = path1
        data["img"] = path2

        # try:
        # 执行更新
        obj = AssessVideo.objects.filter(id=id)
        obj.update(**data)
        # 成功状态码
        u_dict = {
            "info": "ok",
            "status": "200"
        }
        # except:
        #     # 失败状态码
        #     u_dict = {
        #         "info": "error",
        #         "status": "500"
        #     }
    if (request.method == 'GET'):
        # 请求方式不对状态码
        u_dict = {
            "info": "no",
            "status": "666"
        }
    return JsonResponse(u_dict)

def blog(request):
	1. filter从数据库中查数据  
    objs = Blog.objects.filter()
    u_list = {}
    i = 0
	2. 然后遍历，目的是变成单条数据，能转化成字典(键是字段，值是数据) 
    for obj in objs:
        curr_data = model_to_dict(obj)
        curr_data.pop("id")
        curr_data.pop("is_del")
        curr_data["img"] = settings.BASE_URL + curr_data["img"]
		3. 然后再循环给每个字典加上键(键是0123，值是字典)，形成双层字典  
        u_list[i] = curr_data
        i += 1
	4. 然后把字典转化成json返回  
    return JsonResponse(u_list)

def success_response(u_dict):
    '''
    正确返回数据 过滤器
    :param u_dict: 返回的数据主体内容
    :return: 嵌套后的数据
    '''
    u_dict = {
        "status": "200",
        "info": "返回信息成功!",
        "data": u_dict
    }
    return u_dict

def error_response(u_dict, err_info):
    '''
    返回错误json
    :param u_dict: json返回的主要内容
    :param err_info: 错误提示信息
    :return:
    '''
    u_dict = {
        "status": "500",
        "info": err_info,
        "data": u_dict
    }
    return u_dict