python_93040206/admin_site/order/views.py

from django.core.files.storage import default_storage
from django.shortcuts import get_object_or_404
import json
# Create your views here.
from django.http import HttpResponse, JsonResponse, Http404
from django.views.decorators.http import require_http_methods
from django.views.decorators.csrf import csrf_exempt
from order.models import Order as Order_models
from order.tasks import get_AUC
from user.models import User as User_models
from django.utils import timezone
from django.db.models import Q
from django.core.paginator import Paginator, EmptyPage
from files.tasks import del_one_file
from files.models import Files as Files_models
import re
from json.decoder import JSONDecodeError
from admin_site.utils import setError, setSuccess, char_2_datetime
import os


# 获取订单详情
@csrf_exempt
@require_http_methods(["POST", "GET"])
def info(request):
    body = json.loads(request.body)
    print(32, body)
    if body.get('id') == None:
        return HttpResponse(setError("改订单不存在！"))
    try:
        order = Order_models.objects.get(id=body['id'])
    except Order_models.DoesNotExist:
        return JsonResponse(setError("Order not found"))
    def get_txt_data(name):
        base_path = 'Rdata/' + str(order.id) + '/'
        txt_data = []
        # 从文本文件中读取列表
        with open(f'{base_path}{name}.txt', 'r') as f:
            txt_data = [int(line.strip()) for line in f]
            # print(txt_data)  # 输出 [1, 2, 3, 4]
        return txt_data

        # 将订单信息转换为字典形式
    order_dict = {
        "id": order.id,
        "user_id": order.user_id,
        "name": order.name,
        "desc": order.desc,
        "source": order.source,
        "start_time": order.start_time,
        "end_time": order.end_time,
        "run_time": order.run_time,
        "status": order.status,
        "create_time": order.create_time,
        "update_time": order.update_time,
        "DL_GRS": "http://localhost:8000/order/img/"+ str(order.id) +"/DL_GRS.png",
        "DL_GRS_list": get_txt_data('DL_GRS'),
        "DL_GRS_prob_pre": "http://localhost:8000/order/img/"+ str(order.id) +"/DL_GRS_prob_pre.png",
        "OR_GRS": "http://localhost:8000/order/img/"+ str(order.id) +"/OR_GRS.png",
        "OR_GRS_list": get_txt_data('OR_GRS'),
        "OR_GRS_prob_pre": "http://localhost:8000/order/img/"+ str(order.id) +"/OR_GRS_prob_pre.png",
        "SC_GRS": "http://localhost:8000/order/img/"+ str(order.id) +"/SC_GRS.png",
        "SC_GRS_list": get_txt_data('SC_GRS'),
        "SC_GRS_prob_pre": "http://localhost:8000/order/img/"+ str(order.id) +"/SC_GRS_prob_pre.png",
        "t_alt_count": "http://localhost:8000/order/img/"+ str(order.id) +"/t_alt_count.png",
        "t_depth": "http://localhost:8000/order/img/"+ str(order.id) +"/t_depth.png",
        "t_ref_count": "http://localhost:8000/order/img/"+ str(order.id) +"/t_ref_count.png",
        "Variant_Type": "http://localhost:8000/order/img/"+ str(order.id) +"/Variant_Type.png",
    }

    # 返回 JSON 格式的响应
    return JsonResponse(setSuccess(msg='成功', data=order_dict))


@csrf_exempt
@require_http_methods(["POST", "GET"])
def img(request):
    pattern = r'/order/img/(\d+)/(\w+\.\w+)'
    match = re.search(pattern, request.path)
    order_id = ''
    img_filename = ''
    if match:
        order_id = match.group(1)
        img_filename = match.group(2)
    else:
        print("No match found.")
    file_path = 'Rdata/' + order_id + '/' + img_filename
    print('file_path', file_path)
    try:
        with default_storage.open(file_path, 'rb') as f:
            response = HttpResponse(f.read(), content_type='image/png')
            response['Content-Disposition'] = 'inline; filename=' + os.path.basename(file_path)
            return response
    except:
        raise Http404


@csrf_exempt
@require_http_methods(["POST"])
def add(request):
    # get_AUC(94)
    # return JsonResponse(setSuccess(msg='更新成功', data=True))
    body = json.loads(request.body)
    params = {
        'name': body.get('name', None),
        'source': body.get('source', None),
        'desc': body.get('desc', None),
        'user_id': body.get('user_id', None),
    }
    fileListID = body.get('fileListID', [])
    fileListID2 = body.get('fileListID2', [])
    if body.get('isRunNow', 'false') == 'false':
        params.setdefault('run_time', char_2_datetime(body['runTime']))
    else:
        params.setdefault('run_time', timezone.now())
    # 创建订单
    order_add = Order_models(**params)
    order_add.save()
    # 定义文件删除程序
    del_file_time = body.get('delTime', None)
    print(del_file_time)
    if len(fileListID) > 0:
        files_id = fileListID[0]
        file_params = {
            'user_id': body.get('user_id', None),
            'order_id': order_add.id,
        }
        if del_file_time != None and del_file_time != '':
            file_params.setdefault('delete_time', del_file_time)
            print(file_params)
        Files_models.objects.filter(id=files_id).update(**file_params)
        if del_file_time != None and del_file_time != '':
            # 定义定时删除任务
            del_one_file.apply_async(args=[files_id], eta=char_2_datetime(del_file_time))
    if len(fileListID2) > 0:
        files_id = fileListID2[0]
        file_params = {
            'user_id': body.get('user_id', None),
            'order_id': order_add.id,
        }
        if del_file_time != None and del_file_time != '':
            file_params.setdefault('delete_time', del_file_time)
        Files_models.objects.filter(id=files_id).update(**file_params)
        if del_file_time != None and del_file_time != '':
            # 定义定时删除任务
            del_one_file.apply_async(args=[files_id], eta=char_2_datetime(del_file_time))
    # 如果不是立即执行订单，就设置指定的执行时间
    if body.get('isRunNow', 'false') == 'false':
        # 运行定时任务
        get_AUC.apply_async(args=[order_add.id], eta=char_2_datetime(body['runTime']))
    else:
        # 如果是立即执行订单，就执行异步任务
        get_AUC.delay(order_id=order_add.id)
    return JsonResponse(setSuccess(msg='更新成功', data=True))


@csrf_exempt
@require_http_methods(["POST"])
def update(request):
    return JsonResponse(setSuccess(msg='更新成功', data=True))

@csrf_exempt
@require_http_methods(["POST"])
def list(request):
    try:
        body = json.loads(request.body)
        token = body.get('token')
        page = body.get('page', 1)
        page_size = body.get('pageSize', 10)
        keyword = body.get('keyword', '')
    except (JSONDecodeError, KeyError) as e:
        return JsonResponse(setError(str(e)))

    data_list = Order_models.objects.filter(is_delete=0)
    if keyword:
        query = Q(name__icontains=keyword)
        data_list = data_list.filter(query)

    try:
        user_info = User_models.objects.get(token=token)
        is_root = user_info.type == 'root'
        if not is_root:
            data_list = data_list.filter(user_id=user_info.id)
    except User_models.DoesNotExist:
        return JsonResponse(setError('User not found'))

    data_list = data_list.order_by('-create_time')
    paginator = Paginator(data_list, page_size)
    try:
        data = paginator.page(page)
    except EmptyPage:
        return JsonResponse(setError('Page out of range'))
    total_count = paginator.count  # 获取数据总数
    data_json = {
        'has_previous': data.has_previous(),
        'has_next': data.has_next(),
        'number': data.number,
        'total_count': total_count,
        'num_pages': paginator.num_pages,
        'list': [{'id': item.id, 'create_time': item.create_time, 'update_time': item.update_time,
                  'start_time': item.start_time, 'desc': item.desc, 'name': item.name, 'source': item.source,
                  'run_time': item.run_time, 'status': item.status, } for item in data]
    }
    return JsonResponse(setSuccess(msg='更新成功', data=data_json))


# 创建订单
@csrf_exempt
@require_http_methods(["POST"])
def create_order(request):
    body = request.POST.dict()
    if body['id'] == None or body['id'] == '':
        return JsonResponse(setError("用户不存在"))
    body.setdefault('is_sick', body['isSick'])
    return JsonResponse(setSuccess(msg='更新成功', data=True))

@csrf_exempt
@require_http_methods(["POST"])
def delete(request):
    body = json.loads(request.body)
    if body['id'] == None or body['id'] == '':
        return JsonResponse(setError("订单不存在"))
    order = get_object_or_404(Order_models, id=body['id'])
    print(order)
    params = {
        "is_delete": 1
    }
    files = Files_models.objects.filter(order_id=order.id)
    for item in files:
        os.remove(str(item.file_path))
    Files_models.objects.filter(order_id=order.id).update(**params)
    Order_models.objects.filter(id=order.id).update(**params)
    # order.delete()
    return JsonResponse(setSuccess(msg='更新成功', data=True))