2023_05_12/Air_mis (1)/Sellers/views.py

import json

from django.core.serializers import serialize
from django.db.models import Count, Sum
from django.http import JsonResponse
from django.shortcuts import render, redirect
from django.views.decorators.http import require_http_methods

from .models import Tickets, Flight, Order, Message
from index.models import UserInfo
from alipay import AliPay
import datetime
from decimal import Decimal
from datetime import datetime
from django.utils import timezone
from dateutil.parser import parse
from dateutil import parser


def hello(request):
    return render(request, 'sell-hello.html')

def report(request):
    return render(request, 'sell-report.html')

def show_tickets(request):
    tickets = Tickets.objects.all()
    now = str(datetime.datetime.now())
    # str类型
    eff_tickets = []
    non_eff_tickets = []
    for ticket in tickets:
        if now < str(ticket.starting_time):
            eff_tickets.append(ticket)
        else:
            non_eff_tickets.append(ticket)
    context = {
        'on_tickets': eff_tickets,
        'off_tickets': non_eff_tickets,
    }
    return render(request, 'show_tickets.html', context)


def choose_flight(request):
    flights = Flight.objects.all()
    context = {'flights': flights}
    return render(request, 'choose_flight.html', context)


def add_ticket(request, flight_id):
    if request.method != 'POST':
        flight = Flight.objects.filter(id=flight_id).first()
        num = flight.number
        sta = flight.sta_point
        fin = flight.fin_point
        Typ = flight.Type
        f_id = flight.id
        typ = flight.tye
        stop = flight.stopover_point
        hour = flight.stopover_hour
        minute = flight.stopover_minute
        f_seat = flight.F_seat_num
        c_seat = flight.C_seat_num
        y_seat = flight.Y_seat_num
        context = {
            'flight': num,
            'start': sta,
            'final': fin,
            'Type': Typ,
            'flight_id': f_id,
            'type': typ,
            'stop': stop,
            'stop_hour': hour,
            'stop_min': minute,
            'f_seat': f_seat,
            'c_seat': c_seat,
            'y_seat': y_seat,
        }
        return render(request, 'add_ticket.html', context)
    else:
        flight = Flight.objects.filter(id=flight_id).first()
        tickets = Tickets.objects.filter(flight_id=flight_id)
        fli = flight.number
        f_seat = flight.F_seat_num
        c_seat = flight.C_seat_num
        y_seat = flight.Y_seat_num
        sta = flight.sta_point
        fin = flight.fin_point
        Typ = flight.Type
        f_id = flight.id
        typ = flight.tye
        stop = flight.stopover_point
        hour = flight.stopover_hour
        min = flight.stopover_minute
        sta_tim = request.POST.get('sta_tim')
        fin_tim = request.POST.get('fin_tim')
        f_pri = float(request.POST.get('F_pri'))
        f_quan = request.POST.get('F_qua')
        f_dis = float(request.POST.get('F_dis'))
        f_real = f_pri * f_dis / 10
        c_pri = float(request.POST.get('C_pri'))
        c_quan = request.POST.get('C_qua')
        c_dis = float(request.POST.get('C_dis'))
        c_real = c_pri * c_dis / 10
        y_pri = float(request.POST.get('Y_pri'))
        y_quan = request.POST.get('Y_qua')
        y_dis = float(request.POST.get('Y_dis'))
        y_real = y_dis * y_pri / 10
        now = str(datetime.datetime.now())
        not_bet = True
        if sta_tim != '' and fin_tim != '' and now < sta_tim < fin_tim:
            for ticket in tickets:
                if datetime.datetime.strptime(sta_tim, "%Y-%m-%dT%H:%M") < ticket.starting_time:
                    if datetime.datetime.strptime(fin_tim, "%Y-%m-%dT%H:%M") < ticket.starting_time:
                        continue
                    else:
                        not_bet = False
                        break
                elif datetime.datetime.strptime(sta_tim, "%Y-%m-%dT%H:%M") == ticket.starting_time or \
                        ticket.final_time > datetime.datetime.strptime(sta_tim, "%Y-%m-%dT%H:%M") > ticket.starting_time \
                        or datetime.datetime.strptime(sta_tim, "%Y-%m-%dT%H:%M") == ticket.final_time:
                    not_bet = False
                    break
                else:
                    continue
        if sta_tim == '':
            return redirect('Sellers:non_sta_tim', f_id)
        elif fin_tim == '':
            return redirect('Sellers:non_fin_tim', f_id)
        elif fin_tim < sta_tim or fin_tim == sta_tim or sta_tim < now or sta_tim == now:
            return redirect('Sellers:wro_tim', f_id)
        elif not_bet == False:
            return redirect('Sellers:tim_con', f_id)
        elif f_pri == '' or c_pri == '' or y_pri == '':
            return redirect('Sellers:non_pri', f_id)
        elif float(f_pri) < 0 or float(f_pri) == 0 or float(c_pri) < 0 or float(c_pri) == 0 or float(
                y_pri) < 0 or float(y_pri) == 0:
            return redirect('Sellers:wro_pri', f_id)
        elif f_quan == '' or c_quan == '' or y_quan == '':
            return redirect('Sellers:non_qua', f_id)
        elif int(f_quan) < 0 or int(f_quan) == 0 or int(f_quan) > f_seat or int(c_quan) < 0 or int(c_quan) == 0 or int(
                c_quan) > c_seat or int(y_quan) < 0 or int(y_quan) == 0 or int(y_quan) > y_seat:
            return redirect('Sellers:wro_qua', f_id)
        elif f_dis < 0 or c_dis < 0 or y_dis < 0:
            return redirect('Sellers:non_dis', f_id)
        else:
            f_pric = float(f_pri)
            c_pric = float(c_pri)
            y_pric = float(y_pri)
            f_qua = int(f_quan)
            c_qua = int(c_quan)
            y_qua = int(y_quan)
            Tickets.objects.create(flight=fli, start_point=sta, final_point=fin, starting_time=sta_tim,
                                   final_time=fin_tim,
                                   F_price=f_pric, F_quantity=f_qua, F_discount=f_dis, C_price=c_pric, C_quantity=c_qua,
                                   C_discount=c_dis, Y_price=y_pric, Y_quantity=y_qua, Y_discount=y_dis, Type=Typ,
                                   flight_id=f_id, stopover_hour=hour, stopover_minute=min, stopover_point=stop,
                                   tye=typ,
                                   F_real_price=f_real, C_real_price=c_real, Y_real_price=y_real)
            return redirect('Sellers:show_tickets')


def non_qua(request, flight_id):
    flight = Flight.objects.filter(id=flight_id).first()
    fli = flight.number
    seat = flight.seat_num
    sta = flight.sta_point
    fin = flight.fin_point
    typ = flight.Type
    context = {
        'flight': fli,
        'start': sta,
        'final': fin,
        'Type': typ,
        'max_seat': seat,
        'flight_id': flight_id
    }
    return render(request, 'non_qua.html', context)


def non_pri(request, flight_id):
    flight = Flight.objects.filter(id=flight_id).first()
    fli = flight.number
    seat = flight.seat_num
    sta = flight.sta_point
    fin = flight.fin_point
    typ = flight.Type
    context = {
        'flight': fli,
        'start': sta,
        'final': fin,
        'Type': typ,
        'max_seat': seat,
        'flight_id': flight_id
    }
    return render(request, 'non_pri.html', context)


def tim_con(request, flight_id):
    flight = Flight.objects.filter(id=flight_id).first()
    fli = flight.number
    seat = flight.seat_num
    sta = flight.sta_point
    fin = flight.fin_point
    typ = flight.Type
    context = {
        'flight': fli,
        'start': sta,
        'final': fin,
        'Type': typ,
        'max_seat': seat,
        'flight_id': flight_id
    }
    return render(request, 'tim_con.html', context)


def wro_tim(request, flight_id):
    flight = Flight.objects.filter(id=flight_id).first()
    fli = flight.number
    seat = flight.seat_num
    sta = flight.sta_point
    fin = flight.fin_point
    typ = flight.Type
    context = {
        'flight': fli,
        'start': sta,
        'final': fin,
        'Type': typ,
        'max_seat': seat,
        'flight_id': flight_id
    }
    return render(request, 'wro_tim.html', context)


def non_sta_tim(request, flight_id):
    flight = Flight.objects.filter(id=flight_id).first()
    fli = flight.number
    seat = flight.seat_num
    sta = flight.sta_point
    fin = flight.fin_point
    typ = flight.Type
    context = {
        'flight': fli,
        'start': sta,
        'final': fin,
        'Type': typ,
        'max_seat': seat,
        'flight_id': flight_id
    }
    return render(request, 'non_sta_tim.html', context)


def non_fin_tim(request, flight_id):
    flight = Flight.objects.filter(id=flight_id).first()
    fli = flight.number
    seat = flight.seat_num
    sta = flight.sta_point
    fin = flight.fin_point
    typ = flight.Type
    context = {
        'flight': fli,
        'start': sta,
        'final': fin,
        'Type': typ,
        'max_seat': seat,
        'flight_id': flight_id
    }
    return render(request, 'non_fin_tim.html', context)


def wro_pri(request, flight_id):
    flight = Flight.objects.filter(id=flight_id).first()
    fli = flight.number
    seat = flight.seat_num
    sta = flight.sta_point
    fin = flight.fin_point
    typ = flight.Type
    context = {
        'flight': fli,
        'start': sta,
        'final': fin,
        'Type': typ,
        'max_seat': seat,
        'flight_id': flight_id
    }
    return render(request, 'wro_pri.html', context)


def wro_qua(request, flight_id):
    print(260, flight_id)
    flight = Flight.objects.filter(id=flight_id).first()
    fli = flight.number
    seat = flight.F_seat_num + flight.C_seat_num + flight.Y_seat_num
    sta = flight.sta_point
    fin = flight.fin_point
    typ = flight.Type
    context = {
        'flight': fli,
        'start': sta,
        'final': fin,
        'Type': typ,
        'max_seat': seat,
        'flight_id': flight_id
    }
    return render(request, 'wro_qua.html', context)


def non_stop(request, flight_id):
    flight = Flight.objects.filter(id=flight_id).first()
    fli = flight.number
    seat = flight.seat_num
    sta = flight.sta_point
    fin = flight.fin_point
    typ = flight.Type
    context = {
        'flight': fli,
        'start': sta,
        'final': fin,
        'Type': typ,
        'max_seat': seat,
        'flight_id': flight_id
    }
    return render(request, 'non_stop.html', context)


def show_flights(request):
    flights = Flight.objects.all()
    for flight in flights:
        flag = 0
        now = str(datetime.datetime.now())
        tickets = Tickets.objects.filter(flight_id=flight.id)
        for ticket in tickets:
            if now > str(ticket.starting_time) and now < str(ticket.final_time):
                Flight.objects.filter(id=flight.id).update(status='飞行中')
                flag = 1
                break
        if flag == 0:
            Flight.objects.filter(id=flight.id).update(status='未起飞')
    flights = Flight.objects.all()
    context = {'flights': flights}
    return render(request, 'show_flights.html', context)


def add_flight(request):
    if request.method != 'POST':
        return render(request, 'add_flight.html')
    else:
        fli_num = request.POST.get('fli_num')
        F_seat_num = int(request.POST.get('F_seat_num'))
        C_seat_num = int(request.POST.get('C_seat_num'))
        Y_seat_num = int(request.POST.get('Y_seat_num'))
        sta_point = request.POST.get('sta_point')
        stop_point = request.POST.get('stop_point')
        stop_hour = int(request.POST.get('stop_hour'))
        stop_minute = int(request.POST.get('stop_min'))
        fin_point = request.POST.get('fin_point')
        Type = int(request.POST.get('Type'))
        tye = request.POST.get('typ')
        income = 0
        status = '未起飞'
        if fli_num == '':
            return redirect('Sellers:non_flinum')
        elif F_seat_num < 0 or F_seat_num == 0:
            return redirect('Sellers:wro_seat_num')
        elif sta_point == '':
            return redirect('Sellers:non_sta')
        elif fin_point == '':
            return redirect('Sellers:non_fin')
        elif Type == 0:
            return redirect('Sellers:non_Typ')
        else:
            Flight.objects.create(number=fli_num, F_seat_num=F_seat_num, C_seat_num=C_seat_num, Y_seat_num=Y_seat_num,
                                  sta_point=sta_point, fin_point=fin_point, stopover_point=stop_point,
                                  stopover_hour=stop_hour, stopover_minute=stop_minute, Type=Type, tye=tye,
                                  income=income, status=status)
            return redirect('Sellers:show_flights')


def non_flinum(request):
    return render(request, 'non_flight.html')


def wro_seat_num(request):
    return render(request, 'wro_seat_num.html')


def non_sta(request):
    return render(request, 'non_sta.html')


def non_fin(request):
    return render(request, 'non_fin.html')


def non_Typ(request):
    return render(request, 'non_Typ.html')


def del_flight_ask(request, flight_id):
    flights = Flight.objects.all()
    flight = Flight.objects.filter(id=flight_id).first()
    context = {
        'flights': flights,
        'flight': flight,
    }
    return render(request, 'del_flight_ask.html', context)


def del_flight(request, flight_id):
    tickets = Tickets.objects.all()
    for ticket in tickets:
        if ticket.flight_id == flight_id:
            return redirect('Sellers:have_ticket')
    Flight.objects.filter(id=flight_id).delete()
    return redirect('Sellers:show_flights')


def have_ticket(request):
    flights = Flight.objects.all()
    context = {'flights': flights}
    return render(request, 'have_ticket.html', context)


def user_man(request):
    users = UserInfo.objects.all()
    context = {
        'users': users,
    }
    return render(request, 'user_man.html', context)


def turn_down(request, user_id):
    UserInfo.objects.filter(id=user_id).update(Type=2)
    return redirect('Sellers:user_man')


def back_to_use(request, user_id):
    UserInfo.objects.filter(id=user_id).update(Type=0)
    return redirect('Sellers:user_man')


def refund_manage(request):
    orders = Order.objects.all()
    eff_orders = []
    now = str(datetime.datetime.now())
    for order in orders:
        if order.status == '退款审核中':
            eff_orders.append(order)
    for order in eff_orders:
        if now > str(order.starting_time) or now == str(order.starting_time):
            print(438, order.id)
            # turn_down_refund_fn(order.id)
            # return redirect('Sellers:turn_down_refund', order.id)
    context = {'orders': eff_orders}
    return render(request, 'refund_manage.html', context)


def ask_turn_down_refund(request, order_id):
    orders = Order.objects.all()
    eff_orders = []
    for order in orders:
        if order.status == '退款审核中':
            eff_orders.append(order)
    context = {
        'orders': eff_orders,
        'order_id': order_id
    }
    return render(request, 'ask_turn_down_refund.html', context)

def turn_down_refund_fn(order_id):
    order = Order.objects.filter(id=order_id).first()
    Order.objects.filter(id=order_id).update(status='已支付')
    # 原订单返回已支付状态
    Order.objects.create(flight=order.flight, start_point=order.start_point, final_point=order.final_point,
                         stopover_point=order.stopover_point, starting_time=order.starting_time,
                         final_time=order.final_time, true_price=order.true_price, berth=order.berth,
                         add_time=order.add_time,
                         be_price=order.be_price, discount=order.discount, Type=order.Type,
                         ticket_id=order.ticket_id, user_id=order.user_id, status='退款驳回',
                         stopover_hour=order.stopover_hour,
                         stopover_minute=order.stopover_minute, tye=order.tye)

def turn_down_refund(request, order_id):
    turn_down_refund_fn(order_id)
    # 新建订单保存退款驳回记录
    # return JsonResponse({"msg": '更新成功', "data": True})
    return redirect('Sellers:refund_manage')


def ask_pass_refund(request, order_id):
    orders = Order.objects.all()
    eff_orders = []
    for order in orders:
        if order.status == '退款审核中':
            eff_orders.append(order)
    context = {
        'orders': eff_orders,
        'order_id': order_id,
    }
    return render(request, 'ask_pass_refund.html', context)


def pass_refund(request, order_id):
    order = Order.objects.filter(id=order_id).first()
    Order.objects.filter(id=order_id).update(status='退款成功')
    ticket = Tickets.objects.filter(id=order.ticket_id).first()
    flight = Flight.objects.filter(id=ticket.flight_id).first()
    new_flight_income = flight.income - order.true_price  # 对订单对应的航班收入进行修改
    Flight.objects.filter(id=ticket.flight_id).update(income=new_flight_income)
    order = Order.objects.filter(id=order_id).first()
    if order.berth == '头等舱':
        new_ticket_quan = ticket.F_quantity + 1
        Tickets.objects.filter(id=order.ticket_id).update(F_quantity=new_ticket_quan)
    elif order.berth == '商务舱':
        new_ticket_quan = ticket.C_quantity + 1
        Tickets.objects.filter(id=order.ticket_id).update(C_quantity=new_ticket_quan)
    elif order.berth == '经济舱':
        new_ticket_quan = ticket.Y_quantity + 1
        Tickets.objects.filter(id=order.ticket_id).update(Y_quantity=new_ticket_quan)

    refund_num = order.true_price * (1 - order.refund_precent * Decimal(str(0.01)))
    app_private_key_string = open(r"Users/rsakey/private2048.txt").read()
    alipay_public_key_string = open(r"Users/rsakey/paypublic.txt").read()
    alipay = AliPay(
        appid="2021000122675132",
        app_notify_url=None,  # 支付宝会向这个地址发送post请求
        app_private_key_string=app_private_key_string,  # 应用私钥
        alipay_public_key_string=alipay_public_key_string,  # 支付宝公钥
        sign_type="RSA2",  # 加密方式
        debug=True,  # 默认是False
    )
    result = alipay.api_alipay_fund_trans_toaccount_transfer(
        out_biz_no=str(order.id),
        payee_type="ALIPAY_LOGONID",
        payee_account="efaqng2626@sandbox.com",
        amount=str(refund_num)
    )
    print(result)
    return redirect("Sellers:refund_manage")


def change_manage(request):
    orders = Order.objects.all()
    eff_orders = []
    eff_tickets = []
    new_orders = []
    now = str(datetime.datetime.now())
    for order in orders:
        if order.status == '改签审核中':
            eff_orders.append(order)
            ticket_id = order.new_ticket_id
            ticket = Tickets.objects.filter(id=ticket_id).first()
            eff_tickets.append(ticket)
            new_orders.append({
                "order": order,
                "ticket": ticket
            })
    # for order in eff_orders:
    #     new_ticket = Tickets.objects.filter(id=order.new_ticket_id).first()
    #     if now > str(order.starting_time) or now == (order.starting_time) or now > str(new_ticket.starting_time) or \
    #             now == str(new_ticket.starting_time):
    #         return redirect(requmy_ordersest, 'Sellers:turn_down_change', order.id)
    context = {
        # 'orders': eff_orders,
        # 'tickets': eff_tickets,
        'neworders': new_orders,
    }
    return render(request, 'change_manage.html', context)


def ask_turn_down_change(request, order_id):
    orders = Order.objects.all()
    eff_orders = []
    eff_tickets = []
    for order in orders:
        if order.status == '改签审核中':
            eff_orders.append(order)
            ticket_id = order.new_ticket_id
            ticket = Tickets.objects.filter(id=ticket_id).first()
            eff_tickets.append(ticket)
    context = {
        'orders': eff_orders,
        'tickets': eff_tickets,
        'order_id': order_id,
    }
    return render(request, 'ask_turn_down_change.html', context)


def turn_down_change(request, order_id):
    order = Order.objects.filter(id=order_id).first()
    new_ticket = Tickets.objects.filter(id=order.new_ticket_id).first()
    Order.objects.filter(id=order_id).update(status='改签驳回')
    # 原订单保存驳回记录（含有new_ticket_id）
    Order.objects.create(flight=order.flight, start_point=order.start_point, final_point=order.final_point,
                         stopover_point=order.stopover_point, starting_time=order.starting_time,
                         be_price=order.be_price,
                         discount=order.discount, true_price=order.true_price, berth=order.berth,
                         final_time=order.final_time,
                         Type=order.Type, add_time=order.add_time, stopover_hour=order.stopover_hour,
                         stopover_minute=order.stopover_minute, tye=order.tye, ticket_id=order.ticket_id,
                         user_id=order.user_id, status='已支付')
    # 新建订单保存改签后信息

    value = order.true_price * (1 - order.change_percent * 0.01)
    if order.new_berth == '头等舱':
        nee_val = new_ticket.F_price
    elif order.new_berth == '商务舱':
        nee_val = new_ticket.C_price
    elif order.new_berth == '经济舱':
        nee_val = new_ticket.Y_price
    if value < nee_val:
        refund_num = nee_val - value

        app_private_key_string = open(r"C:\Users\Mr.Z\Desktop\毕业设计\Air_mis\Users\rsakey\private2048.txt").read()
        alipay_public_key_string = open(r"C:\Users\Mr.Z\Desktop\毕业设计\Air_mis\Users\rsakey\paypublic.txt").read()
        alipay = AliPay(
            appid="2021000122675132",
            app_notify_url=None,  # 支付宝会向这个地址发送post请求
            app_private_key_string=app_private_key_string,  # 应用私钥
            alipay_public_key_string=alipay_public_key_string,  # 支付宝公钥
            sign_type="RSA2",  # 加密方式
            debug=True,  # 默认是False
        )
        result = alipay.api_alipay_fund_trans_toaccount_transfer(
            out_biz_no=str(order.id),
            payee_type="ALIPAY_LOGONID",
            payee_account="efaqng2626@sandbox.com",
            amount=str(refund_num)
        )
        print(result)
    return redirect('Sellers:change_manage')


def ask_pass_change(request, order_id):
    orders = Order.objects.all()
    eff_orders = []
    eff_tickets = []
    for order in orders:
        if order.status == '改签审核中':
            eff_orders.append(order)
            ticket_id = order.new_ticket_id
            ticket = Tickets.objects.filter(id=ticket_id).first()
            eff_tickets.append(ticket)
    context = {
        'orders': eff_orders,
        'tickets': eff_tickets,
        'order_id': order_id,
    }
    return render(request, 'ask_pass_change.html', context)


def pass_change(request, order_id):
    order = Order.objects.filter(id=order_id).first()
    ticket = Tickets.objects.filter(id=order.ticket_id).first()
    new_ticket = Tickets.objects.filter(id=order.new_ticket_id).first()
    flight = Flight.objects.filter(id=ticket.flight_id).first()
    new_flight = Flight.objects.filter(id=new_ticket.flight_id).first()
    if order.berth == '头等舱':
        ticket_quan = ticket.F_quantity + 1
        Tickets.objects.filter(id=order.ticket_id).update(F_quantity=ticket_quan)
    elif order.berth == '商务舱':
        ticket_quan = ticket.C_quantity + 1
        Tickets.objects.filter(id=order.ticket_id).update(C_quantity=ticket_quan)
    elif order.berth == '经济舱':
        ticket_quan = ticket.Y_quantity + 1
        Tickets.objects.filter(id=order.ticket_id).update(Y_quantity=ticket_quan)
    flight_inc = flight.income - order.true_price
    ticket = Tickets.objects.filter(id=order.ticket_id).first()
    Flight.objects.filter(id=ticket.flight_id).update(income=flight_inc)

    if order.new_berth == '头等舱':
        new_ticket_quan = new_ticket.F_quantity - 1
        Tickets.objects.filter(id=order.new_ticket_id).update(F_quantity=new_ticket_quan)
        new_flight_inc = new_flight.income + new_ticket.F_real_price
        Flight.objects.filter(id=new_ticket.flight_id).update(income=new_flight_inc)
    elif order.new_berth == '商务舱':
        new_ticket_quan = new_ticket.C_quantity - 1
        Tickets.objects.filter(id=order.new_ticket_id).update(C_quantity=new_ticket_quan)
        new_flight_inc = new_flight.income + new_ticket.C_real_price
        Flight.objects.filter(id=new_ticket.flight_id).update(income=new_flight_inc)
    elif order.new_berth == '经济舱':
        new_ticket_quan = new_ticket.Y_quantity - 1
        Tickets.objects.filter(id=order.new_ticket_id).update(Y_quantity=new_ticket_quan)
        new_flight_inc = new_flight.income + new_ticket.Y_real_price
        Flight.objects.filter(id=new_ticket.flight_id).update(income=new_flight_inc)

    Order.objects.filter(id=order_id).update(status='改签成功')

    order = Order.objects.filter(id=order_id).first()
    ticket = Tickets.objects.filter(id=order.ticket_id).first()
    new_ticket = Tickets.objects.filter(id=order.new_ticket_id).first()
    flight = Flight.objects.filter(id=ticket.flight_id).first()

    if order.new_berth == '头等舱':
        be_price = new_ticket.F_price
        discount = new_ticket.F_discount
        true_price = new_ticket.F_real_price
    elif order.new_berth == '商务舱':
        be_price = new_ticket.C_price
        discount = new_ticket.C_discount
        true_price = new_ticket.C_real_price
    elif order.new_berth == '经济舱':
        be_price = new_ticket.Y_price
        discount = new_ticket.Y_discount
        true_price = new_ticket.Y_real_price
    print(638, be_price)
    Order.objects.create(flight=new_ticket.flight, start_point=new_ticket.start_point,
                         final_point=new_ticket.final_point, stopover_point=new_ticket.stopover_point,
                         starting_time=new_ticket.starting_time, final_time=new_ticket.final_time,
                         be_price=be_price, discount=discount, true_price=true_price, berth=order.new_berth,
                         Type=new_ticket.Type, status='已支付', ticket_id=new_ticket.id,
                         stopover_hour=new_ticket.stopover_hour,
                         stopover_minute=new_ticket.stopover_minute, tye=new_ticket.tye, user_id=order.user_id)

    value = order.true_price * (1 - order.change_percent * 0.01)
    nee_val = true_price

    if value < nee_val or value == nee_val:
        return redirect("Sellers:change_manage")

    else:
        refund_num = value - nee_val

        app_private_key_string = open(r"C:\Users\Mr.Z\Desktop\毕业设计\Air_mis\Users\rsakey\private2048.txt").read()
        alipay_public_key_string = open(r"C:\Users\Mr.Z\Desktop\毕业设计\Air_mis\Users\rsakey\paypublic.txt").read()
        alipay = AliPay(
            appid="2021000122675132",
            app_notify_url=None,  # 支付宝会向这个地址发送post请求
            app_private_key_string=app_private_key_string,  # 应用私钥
            alipay_public_key_string=alipay_public_key_string,  # 支付宝公钥
            sign_type="RSA2",  # 加密方式
            debug=True,  # 默认是False
        )
        result = alipay.api_alipay_fund_trans_toaccount_transfer(
            out_biz_no=str(order.id),
            payee_type="ALIPAY_LOGONID",
            payee_account="efaqng2626@sandbox.com",
            amount=str(refund_num)
        )
        print(result)
        return redirect("Sellers:change_manage")


def consult_manage(request):
    messages = Message.objects.all()
    read_messages = []
    # 装有所有的未读且发往管理员的消息数据行
    users_nums = []
    user_nums = []
    # 装有去重过的具有未读消息的用户id
    users = []
    # 装有去重过的具有未读消息的用户名
    for message in messages:
        if message.status == 0 and message.to_id == 1:
            read_messages.append(message)
    for message in read_messages:
        users_nums.append(message.from_id)
    for num in set(users_nums):
        user_nums.append(num)
    for user_num in user_nums:
        user = UserInfo.objects.filter(id=user_num).first()
        users.append(user)
    context = {
        'users': users,
    }
    return render(request, 'consults.html', context)


def ans_con(request, user_id):
    if request.method != 'POST':
        user = UserInfo.objects.filter(id=user_id).first()
        messages = Message.objects.all()
        user_messages = []
        for message in messages:
            if message.from_id == user_id and message.to_id == 1:
                Message.objects.filter(id=message.id).update(status=1)
                user_messages.append(message)
            if message.from_id == 1 and message.to_id == user_id:
                user_messages.append(message)
        context = {
            'user': user,
            'messages': user_messages,
        }
        return render(request, 'ans_con.html', context)
    else:
        mess = request.POST.get('new_mess')
        Message.objects.create(content=mess, from_id=1, to_id=user_id, status=1)
        return redirect('Sellers:ans_con', user_id)

# Create your views here.
@require_http_methods(["POST","GET"])
def get_report(request):
    print('user_id', request.POST)

    def get_time(time_str):
        try:
            new_time_str = '+'.join(time_str.split('+')[1:4])
            new_time_str += '+' + time_str.split('+')[4].split()[0]
            print('new_time_str', new_time_str)
            return datetime.strptime(new_time_str, '%b+%d+%Y+%H:%M:%S')
        except ValueError:
            print('时间字符串格式不正确')


    # start_time = get_time(request.POST['start_time'])
    # end_time = get_time(request.POST['end_time'])

    start_time = datetime.strptime(request.POST['start_time'], '%Y-%m-%d+%H:%M:%S')
    end_time = datetime.strptime(request.POST['end_time'], '%Y-%m-%d+%H:%M:%S')

    print('start_time', start_time)
    print('end_time', end_time)
    # print('end_time', datetime.strptime(end_time, '%Y+%d+%b+%H:%M:%S'))
    # add_time # 添加时间
    # status # 已支付
    # 查询符合条件的订单
    orders = Order.objects.filter(add_time__range=(start_time, end_time), status='已支付').order_by('add_time')
    print(817, orders)





    # # 统计历史订单中最多记录的机票信息,以终点为目标进行统计
    # duplicate_orders = Order.objects.values('final_point').annotate(count=Count('final_point')).filter(count__gt=1, user_id=user_id).order_by('-count')[:3]
    # final_point_list = []
    # for order in duplicate_orders:
    #     final_point_list.append(order['final_point'])
    #     # print(order['final_point'], order['count'])
    # # 查询航班信息
    # final_list=Flight.objects.filter(fin_point__in=final_point_list,status = '未起飞')
    # final_list_data = []
    # for item in json.loads(serialize('json', final_list)):
    #     params = {**item['fields']}
    #     params.setdefault('id', item['pk'])
    #     final_list_data.append(params)
    order_list = []

    for item in json.loads(serialize('json', orders)):
        params = {**item['fields']}
        params.setdefault('id', item['pk'])
        params.setdefault('id', item['pk'])

        order_list.append(params)
    # 总票数，营业额， 折线图，饼图
    '''
    1、从日期纬度整理经营纬度
    2、营业额，票数，总金额，目的地, 座舱分类和数量
    '''
    # 按照日期进行分组，统计每日的价格总和和订单数量
    daily_stats = orders.values('add_time__date').annotate(total_price=Sum('true_price'), order_count=Count('id'))
    plt_order_list = []
    all_total_price=0
    all_order_count=0
    # 遍历每日统计结果（日期维度）
    for stats in daily_stats:
        date = stats['add_time__date']
        total_price = stats['total_price']
        order_count = stats['order_count']
        is_push=True
        item_index=0
        all_total_price = all_total_price + total_price
        all_order_count = all_order_count + order_count
        for index,item in enumerate(plt_order_list):
            if item['date'] == date:
                is_push=False
                item_index=index
                break
        if is_push:
            plt_order_list.append({
                "date": date,
                "total_price":total_price,
                "order_count": order_count
            })
        else:
            plt_order_list[item_index]['total_price'] = plt_order_list[item_index]['total_price'] + total_price
            plt_order_list[item_index]['order_count'] = plt_order_list[item_index]['order_count'] + order_count

    # 座舱维度统计
    berth_list = orders.values('berth').annotate(total_price=Sum('true_price'),order_count=Count('id'))
    plt_berth_list=[]
    for index, item in enumerate(berth_list):
        is_push = True
        item_index = 0
        total_price = item['total_price']
        order_count = item['order_count']
        for index, elm in enumerate(plt_berth_list):
            if elm['berth'] == item['berth']:
                is_push = False
                item_index = index
                break
        if is_push:
            plt_berth_list.append({
                "berth": item['berth'],
                "order_count": order_count,
                "total_price": total_price
            })
        else:
            plt_berth_list[item_index]['total_price'] = plt_berth_list[item_index]['total_price'] + total_price
            plt_berth_list[item_index]['order_count'] = plt_berth_list[item_index]['order_count'] + order_count

        # print("日期:", date)
        # print("价格总和:", total_price)
        # print("订单数量:", order_count)
        # print("--------------")
    # 航班维度统计
    final_point_list = orders.values('final_point').annotate(total_price=Sum('true_price'), order_count=Count('id'))
    plt_final_point_list = []
    for index, item in enumerate(final_point_list):
        is_push = True
        item_index = 0
        total_price = item['total_price']
        order_count = item['order_count']
        for index, elm in enumerate(plt_final_point_list):
            if elm['final_point'] == item['final_point']:
                is_push = False
                item_index = index
                break
        if is_push:
            plt_final_point_list.append({
                "final_point": item['final_point'],
                "order_count": order_count,
                "total_price": total_price
            })
        else:
            plt_final_point_list[item_index]['total_price'] = plt_final_point_list[item_index]['total_price'] + total_price
            plt_final_point_list[item_index]['order_count'] = plt_final_point_list[item_index]['order_count'] + order_count

    return JsonResponse({
        # 'data': order_list,
        'plt_order_list': plt_order_list, # 日期维度
        'plt_berth_list': plt_berth_list, # 座舱维度
        'plt_final_point_list': plt_final_point_list, # 航班维度
        "all_total_price": all_total_price, # 营业额
        'all_order_count': all_order_count # 订单总数
    })