import concurrent.futures
import datetime
import os
import random
import time
import traceback
import requests
import socket
from flask import Flask, render_template, request, redirect, url_for, jsonify
from Functions import utils, DataComputer as DataComputer, ipcall,  flaskDBUtils4PG as flaskDBUtils
import json
from unitls.settings import DBServer, flightDB4, DataTransferMode,Server_Class,Main_Sever
from unitls.LogerinTxt import app_logger
from unitls.StaticDataclass import initialize_file,write_status_to_file
from waitress import serve
from Functions.DButilsFunction import flightDB, judge_bc as Judge_bc, initFlightDatabase as InitFlightDatabase,\
    insertTaskDataToTable, sortFlighttime, sortFlighttime2, checkTFUairplane, createWorkloadtablesFromPg as CreateWorkloadtablesFromPg,\
    checkFlightAlert,dingdingDelete_flight,dingdingFlightsts,dingdinginfoget,calledChecked as CalledChecked,\
    infoConfirm as InfoConfirm, infoConfirm3 as InfoConfirm3, infoConfirm2 as InfoConfirm2, maintainAuthCheck as  MaintainAuthCheck,\
    checkLoadSingal as CheckLoadSingal, changepassword as Changepassword, postgresql_local, mapDispaly as MapDispaly,\
    checkPglist as CheckPglist, updateEidteItem as UpdateEidteItem, updateDragDropItem as UpdateDragDropItem,\
    qtPeopleLoad as QtPeopleLoad,tableWidgetDispaly as TableWidgetDispaly, tableWidgetDispaly2 as TableWidgetDispaly2,\
    tableWidgetDispalyRead2 as TableWidgetDispalyRead2, tableWidgetDispalyRead as TableWidgetDispalyRead,\
    bakupdata as Bakupdata,  getphonelist as Getphonelist, MM_GJJH_LIST as mM_GJJH_LIST,checkCalllist as CheckCalllist,\
    tableWidgetLOGDispaly as TableWidgetLOGDispaly, tableWidgetDisplayChange as TableWidgetDisplayChange,\
    manAddFlight as ManAddFlight, get_dic as Get_dic,manChangests as ManChangests,insertLogs as InsertLogs, insertLogs2 as InsertLogs2,\
    selftaxiLogs as SelftaxiLogs,taskAtuoCheck as TaskAtuoCheck,deleteFlight as DeleteFlight,\
    get_empNos as Get_empNos,updateTaskAuto as UpdateTaskAuto,insertCalllist as InsertCalllist,insertWorkjob as InsertWorkjob,\
    getRiskData as GetRiskData,saveRisktable as SaveRisktable,updateRiskdb as UpdateRiskdb,updateStopFlight as UpdateStopFlight,\
    dealLogs as DealLogs,update_Pglist as Update_Pglist,getWorkjobInfo as GetWorkjobInfo,mandealAllLogs as MandealAllLogs,\
    calltry as Calltry, callon as Callon,get_empNos_phoone as Get_empNos_phoone,FlightSearchInsert,TaskListInsert,checkWorkerlaod_new,\
    GetPglistInDatabase,Getworkload ,HandoverStsChange,ManCahangeWorkload,UpdateNoteItem,postgresql_bakup

from urllib3.exceptions import InsecureRequestWarning
requests.packages.urllib3.disable_warnings(InsecureRequestWarning)

app = Flask(__name__)
dir = os.getcwd()
app.config["SECRET_KEY"] = "Can't not guess it ."

dbhost, dbport, dbuser, dbpassword,online_host, online_port, online_user, online_password = DBServer()
mainseverip, maindatabase=Main_Sever()
backupactive = False #备用服务器激活标注
database="flaskDatabase"
databaseDB4 = flightDB4()
databaseWorkLoad = 'workLoad'
databaseLoginDB = 'loginDB'
flightDataTransfer,displayDataTransfer=DataTransferMode()
ServerClas = Server_Class()
severVersion = "17.0.1"
displayVersion = "17.0.0"
print(f"当前客户端版本：{severVersion}/白板版本：{displayVersion}")
print(f"当前服务器为:【{ServerClas}】")
print(f"当前服务器航班数据传输模式为:【{flightDataTransfer}】")
print(f"当前服务器显示计算请求模式为:【{displayDataTransfer}】")

# 获取本地IP地址
def get_local_ip():
    try:
        s = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)
        s.connect(("8.8.8.8", 80))  # 连接到Google DNS服务器
        ip = s.getsockname()[0]
        s.close()
        return ip
    except:
        return socket.gethostbyname(socket.gethostname())

def check_a_availability():
    """检查A服务器的可用性"""
    try:
        ip = "http://" + mainseverip + ":7162/static/health"
        #ip = "http://" + "192.168.2.65" + ":7162/static/health"
        response = requests.get(ip, timeout=5)
        return response.status_code != 200  #看是否连接成功
    except Exception as e:
        return True  #出问题了
# 健康检查接口
@app.route('/static/health')
def health_check():
    try:
        # 检查数据库连接
        db = flaskDBUtils.flaskDB(host=dbhost,port=dbport,user=dbuser,password=dbpassword,database=database)
        db.close()
        return jsonify({"status": "ok", "timestamp": datetime.datetime.now().isoformat()}), 200
    except Exception as e:
        return jsonify({"status": "error", "message": str(e)}), 500
@app.route('/')
def root():
    return render_template('index.html')
@app.route('/changeSinglepoepleNotice/<boolsts>')
def changeSinglepoepleNotice(boolsts):
    global singlePeopleNotice
    singlePeopleNotice = str(boolsts) == "1"
    write_status_to_file(singlePeopleNotice,'D:\\flightinfo\\DATABASE\\singlepoeple_notice.txt')
    return jsonify({"status": "success", "new_value": singlePeopleNotice})
@app.route('/getSinglepoepleNotice')
def getSinglepoepleNotice():
    global singlePeopleNotice
    return jsonify({"singlepoepleNotice": singlePeopleNotice})

@app.route('/findserver')
def findserver():
    return ServerClas

@app.route('/home/<name>')
def home(name):
    return render_template('index.html', name=name)

@app.route('/checkLogin')
def checkLogin():
    db = flaskDBUtils.flaskDB(host=dbhost,port=dbport,user=dbuser,password=dbpassword,database=database)
    cookie = flaskDBUtils.getToken(db)
    if str(flaskDBUtils.checkLogin(db)) == '1':
        logincode = fl.checkCookieSts(cookie)
        if logincode and logincode != 200:
            flaskDBUtils.logout(db)
            time.sleep(0.1)
    #db.close()
    return str(flaskDBUtils.checkLogin(db))

@app.route('/login',methods=["GET","POST"])
def login():
    remote_addr = request.remote_addr
    if request.method == "GET":
        return render_template('login.html')
    else:
        db = flaskDBUtils.flaskDB(host=dbhost, port=dbport, user=dbuser, password=dbpassword, database=database)
        if 'cookie' in request.form.keys():
            user = request.form.get('user')
            token = "_amro_sk="+request.form.get("cookie")
            flaskDBUtils.login(db, user, token)
        else:
            user = request.form.get('user')
            pwd = request.form.get('pwd')
            #print(user, pwd)
            token = fl.start(user, pwd)
            flaskDBUtils.login(db, user, token)
        if token == None:
            return redirect(url_for('login'))
        else:
            print(datetime.datetime.now(),"[%s]已获取Token"%remote_addr)
        db.close()
        return redirect(url_for('home', name=user))

@app.route('/static/remoteCookielogin/<username>/<cookie>',methods=["GET","POST"])
def remoteCookielogin(username,cookie):
    remote_addr = request.remote_addr
    db = flaskDBUtils.flaskDB(host=dbhost,port=dbport,user=dbuser,password=dbpassword,database=database)
    user = username
    token = "_amro_sk=" + cookie
    flaskDBUtils.login(db, user, token)
    db.close()
    if token != None:
        print(datetime.datetime.now(),"[%s]远程登录已获取Token"%remote_addr)
        return "ok"
    else:
        return "fail"

@app.route('/static/remotelogin/<username>/<password>',methods=["GET","POST"])
def remotelogin(username,password):
    remote_addr = request.remote_addr
    db = flaskDBUtils.flaskDB(host=dbhost,port=dbport,user=dbuser,password=dbpassword,database=database)
    user = username
    pwd =password
    #print(user, pwd)
    token = fl.start(user, pwd)
    flaskDBUtils.login(db, user, token)
    if token != None:
        print(datetime.datetime.now(),"[%s]远程登录已获取Token"%remote_addr)
        return "ok"
    else:
        return "fail"

@app.route('/static/remotelogout')
def remotelogout():
    remote_addr = request.remote_addr
    db = flaskDBUtils.flaskDB(host=dbhost,port=dbport,user=dbuser,password=dbpassword,database=database)
    flaskDBUtils.logout(db)
    db.close()
    print(datetime.datetime.now(), "[%s]远程注销服务器AMRO账号"%remote_addr)
    return "ok"

@app.route('/static/checkjobcard', methods=['GET', 'POST'])
def checkjobcard():
    remote_addr = request.remote_addr
    if request.method == 'GET':
        file_path = request.args.get('path')
    else:
        file_path = request.form.get('path')
    try:
        res= fl.request_jobcard("_udid=80c6089a041646db9c1d9f1a2bc1381a", file_path)
        print(datetime.datetime.now(), "[%s]调取电签工卡查询" % remote_addr)
    except Exception as e:
        app_logger.log_error(e)
        res = ""
    return res

@app.route('/static/VinCheck/<vinLcoal>/<mode>/<num>')
def VinCheck(vinLcoal,mode,num):
    if int(num) !=4:
        db = flaskDBUtils.flaskDB(host=dbhost,port=dbport,user=dbuser,password=dbpassword,database=database)
        vinOnline = flaskDBUtils.getVin(db,mode,int(num))
        db.close()
        if vinLcoal == vinOnline:
            a = "检验一致"
            res = {"返回值":"ok"}
        else:
            a = "服务器有更新"
            res = {"返回值": "update"}
    else:
        a = "非昨天、今天、明天无需获取"
        res = {"返回值": "ok"}
    remote_addr = request.remote_addr
    print(datetime.datetime.now(), "[%s]刷新识别码监测:%s" % (remote_addr,a))
    return res

@app.route('/static/remoteCheck/<checknumber>') #操作系统版本验证
def remoteCheck(checknumber):
    if checknumber ==severVersion:
        res={"返回值":"ok"}
    else:
        res={"返回值":severVersion}
    return res

@app.route('/static/remoteCheck2/<checknumber>') #电子白板系统版本验证
def remoteCheck2(checknumber):
    if checknumber ==displayVersion:
        res={"返回值": "ok"}
    else:
        res={"返回值": displayVersion}
    return res

@app.route('/logout')
def logout():
    db = flaskDBUtils.flaskDB(host=dbhost,port=dbport,user=dbuser,password=dbpassword,database=database)
    flaskDBUtils.logout(db)
    db.close()
    return redirect(url_for('root'))

@app.route('/static/setIpPhone/<ip>')
def setIpPhone(ip):
    remote_addr = request.remote_addr
    db = flaskDBUtils.flaskDB(host=dbhost,port=dbport,user=dbuser,password=dbpassword,database=database)
    token=si.start(ip)
    if token != "fail":
        res={"返回值":"ok"}
        flaskDBUtils.setIpPhone(db, ip, token)
        print(datetime.datetime.now(), "[%s]自动网页电话登录成功[%s,%s]" % (remote_addr,ip, token))
    else:
        res={"返回值":"fail"}
        flaskDBUtils.setIpPhone(db, ip, None)
        print(datetime.datetime.now(), "[%s]自动网页电话登录失败[%s]" % (remote_addr,ip))
    db.close()
    return res

@app.route('/bakupdata')
def bakupdata():
    remote_addr = request.remote_addr
    fdb = flightDB(host=dbhost,port=dbport,user=dbuser,password=dbpassword,database=databaseDB4)
    Bakupdata(fdb)
    fdb.close()
    print(datetime.datetime.now(), "[%s]5分钟间隔自动备份"%remote_addr)
    return "ok"
@app.route('/postgresql')
def postgresql():
    try:
        if flightDataTransfer == 1:
            local = flightDB(host=dbhost,port=dbport,user=dbuser,password=dbpassword,database=databaseDB4)
            try:
                postgresql_local(local,online_host,online_port,online_user,online_password,databaseDB4)
            except:
                local.close()
                print(datetime.datetime.now(), "[远端链接失败]云端数据库服务器")
                return "fail"
            local.close()
        if displayDataTransfer == 1:
            res= DataComputer.mytask()
            if res == "ok":
                url = "https://"+online_host+":7162/computerDispalydata"
                #url = "https://192.168.2.87:5070/computerDispalydata"
                try:
                    ress=requests.get(url, verify=False)
                    ress.raise_for_status()  # 检查HTTP状态码是否为成功
                    data = ress.json()
                    #ress=requests.post(url, cert=('D:\\flightinfo\\DATABASE\\sichuanair.com.pem','D:\\flightinfo\\DATABASE\\sichuanair.com.key')).json()
                    if data == "ok":
                    #if data.get("result") == "ok":
                        print(datetime.datetime.now(), "远端显示中心计算请求成功")
                    else:
                        print(datetime.datetime.now(), "[返回为fail]远端显示中心计算请求失败")
                except Exception as e:
                    print(e)
                    print(datetime.datetime.now(), "[请求被拒绝]远端显示中心计算请求失败")
        return "ok"
    except:
        print(traceback.format_exc())
        return "fail"

@app.route('/static/maintainAuthCheck/<name>/<flighttype>')
def maintainAuthCheck(name,flighttype):
    remote_addr = request.remote_addr
    fdb = flightDB(host=dbhost,port=dbport,user=dbuser,password=dbpassword,database=databaseDB4)
    res=MaintainAuthCheck(fdb,name,flighttype)
    fdb.close()
    print(datetime.datetime.now(), "[%s]维修权限验证"%remote_addr)
    return res

def task_function(taskname, paramaDict):
    #ts = time.time()
    #print('开始请求：{}'.format(taskname))
    time.sleep(random.randint(10,100)/100)
    if taskname == "taskflightdata":
        result = fl.request_task_filght_list(paramaDict['nowDayStr'], paramaDict['token'])
    elif taskname == "Thirdtaskflightdata":
        result = fl.request_task_filght_third_list(paramaDict['nowDayStr'], paramaDict['token'])
    elif taskname == "flightsearch":
        result = fl.request_LM_FLIGHT_SEARCH_LIST(paramaDict['nowDayStr'], paramaDict['token'])
    elif taskname == "flightsearch_1":
        result = fl.request_LM_FLIGHT_SEARCH_LIST(paramaDict['nowDay_1'], paramaDict['token'])
    elif taskname == "TaskList":
        result = fl.request_LM_TASK_ARCHIVE_LIST(paramaDict['nowDayStr'], paramaDict['token'])
    elif taskname == "TaskList_1":
        result = fl.request_LM_TASK_ARCHIVE_LIST(paramaDict['nowDay_1'], paramaDict['token'])
    else:
        result = {'code': 404}
    #print("{} 请求耗时：{}".format(taskname, time.time()-ts))
    return result

@app.route('/getFlightData2/<type>')
async def getFlightData2(type):
    global singlePeopleNotice,loaclseverip
    db = flaskDBUtils.flaskDB(host=dbhost, port=dbport, user=dbuser, password=dbpassword, database=database)
    fdb = flightDB(host=dbhost, port=dbport, user=dbuser, password=dbpassword, database=databaseDB4)
    workLoad = flightDB(host=dbhost, port=dbport, user=dbuser, password=dbpassword, database=databaseWorkLoad)
    if (mainseverip and mainseverip == loaclseverip) or mainseverip == "" or (mainseverip and mainseverip != loaclseverip and check_a_availability()):
        try:
            #print(type)
            ts = time.time()
            taskname_queue = ["taskflightdata","Thirdtaskflightdata","flightsearch","TaskList","flightsearch_1","TaskList_1"]
            taskparama_queue = []
            date_time = Judge_bc()["date"]
            nowDay = datetime.datetime.now()
            nowDayStr = nowDay.strftime("%Y%m%d")
            now_130 = (datetime.datetime.now() + datetime.timedelta(minutes=210)).strftime("%Y%m%d")
            nowStr = nowDay.strftime("%Y%m%d %H:%M:%S")
            print(datetime.datetime.now(), "[判断：%s,当前：%s,+130：%s]" % (date_time, nowDayStr, now_130))
            if date_time == nowDayStr and now_130 == nowDayStr:  # 当班次判断为09：00-20:30时，只查当日   20：30取决于210min不取决于班次判断
                nowDay_1 =nowDayStr
                nowday_11=nowDayStr
                searchDay=f"{nowDayStr[:4]}-{nowDayStr[4:6]}-{nowDayStr[6:]}"
            elif date_time == nowDayStr and now_130 != nowDayStr:  # 当班次判断为20：30-2400时，今日和明日
                nowDay_1 = (datetime.date.today() + datetime.timedelta(days=1)).strftime("%Y%m%d")
                nowday_11=nowDayStr
                searchDay=f"{nowDayStr[:4]}-{nowDayStr[4:6]}-{nowDayStr[6:]}"
            else:                                             #当班次判断为000-0900时，查昨日和今日
                nowDay_1 = date_time
                nowday_11= nowDayStr
                searchDay=f"{date_time[:4]}-{date_time[4:6]}-{date_time[6:]}"
            print('nowDay_1:{},nowday_11:{},searchDay:{}'.format(nowDay_1,nowday_11,searchDay))
            if type == "A":
                if str(flaskDBUtils.checkLogin(db)) == '1':
                    token = flaskDBUtils.getToken(db)
                    #print('db-token:{}'.format(token))
                    print(datetime.datetime.now(), "A动态获取获取[%s/%s]" % (nowDayStr, nowDay_1))
                    taskparama_queue.append({'nowDayStr':searchDay, 'token': token})
                    taskparama_queue.append({'nowDayStr':searchDay, 'token': token})
                    taskparama_queue.append({'nowDayStr':nowday_11, 'token': token})
                    taskparama_queue.append({'nowDayStr':nowday_11, 'token': token})
                    taskparama_queue.append({'nowDay_1': nowDay_1, 'token': token})
                    taskparama_queue.append({'nowDay_1': nowDay_1, 'token': token})
                    flaskDBUtils.clearinfolog(db)
                    with concurrent.futures.ThreadPoolExecutor() as executor:
                        if nowday_11 == nowDay_1: #如果两个日期相同，只查一次避免相同
                            results = executor.map(task_function, taskname_queue[:4], taskparama_queue[:4])
                        else:
                            results = executor.map(task_function, taskname_queue, taskparama_queue)
                    resultsList = []
                    for result in results:
                        resultsList.append(result)
                    taskflightdata= resultsList[0]
                    Thirdtaskflightdata= resultsList[1]
                    flightsearchdata= resultsList[2]
                    tasklistdata= resultsList[3]
                    if nowday_11 != nowDay_1:  ##如果两个日期相同，就没有另外一天的数据
                        flightsearchdata_1= resultsList[4]
                        tasklistdata_1= resultsList[5]

                    if taskflightdata['code'] and taskflightdata['code'] != 200:
                        flaskDBUtils.logout(db)
                        flaskDBUtils.insertinfolog(db, nowStr, str(taskflightdata['code']))
                        InitFlightDatabase(fdb,workLoad, nowDayStr)
                        InitFlightDatabase(fdb,workLoad, nowDay_1)
                        sortFlighttime(fdb,workLoad)
                        sortFlighttime2(fdb,workLoad)
                        checkTFUairplane(fdb)
                        checkWorkerlaod_new(fdb,workLoad,nowDayStr,nowDay_1)
                        checkFlightAlert(fdb, singlePeopleNotice)
                        dingdingDelete_flight(fdb)
                        dingdingFlightsts(fdb)
                        dingdinginfoget(fdb)
                        CalledChecked(fdb)
                        print(datetime.datetime.now(), "A静态刷新")
                        code=str(taskflightdata['code'])
                    else:
                        #ts2 = time.time()
                        InitFlightDatabase(fdb,workLoad, nowDayStr)
                        InitFlightDatabase(fdb,workLoad, nowDay_1)
                        insertTaskDataToTable(fdb, nowDayStr, taskflightdata['data'], Thirdtaskflightdata['data'])
                        FlightSearchInsert(fdb, nowDayStr, flightsearchdata['data'])
                        TaskListInsert(fdb, nowDayStr, tasklistdata['data'])
                        if nowday_11 != nowDay_1:  ##如果两个日期相同，就没有另外一天的数据，无需写入
                            insertTaskDataToTable(fdb, nowDay_1, taskflightdata['data'], Thirdtaskflightdata['data'])
                            FlightSearchInsert(fdb, nowDay_1, flightsearchdata_1['data'])
                            TaskListInsert(fdb, nowDay_1, tasklistdata_1['data'])
                        sortFlighttime(fdb,workLoad)
                        sortFlighttime2(fdb,workLoad)
                        checkTFUairplane(fdb)
                        checkWorkerlaod_new(fdb,workLoad,nowDayStr,nowDay_1)
                        checkFlightAlert(fdb, singlePeopleNotice)
                        dingdingDelete_flight(fdb)
                        dingdingFlightsts(fdb)
                        dingdinginfoget(fdb)
                        CalledChecked(fdb)
                        flaskDBUtils.insertinfolog(db,nowStr,str(taskflightdata['code']))
                        print(datetime.datetime.now(), "A动态刷新")
                        #print('数据库耗时：{}'.format(time.time()-ts2))
                        code = str(taskflightdata['code'])+str(time.time()-ts)
                else:
                    code = '未登录'
            else: #type==B
                InitFlightDatabase(fdb,workLoad, nowDayStr)
                InitFlightDatabase(fdb,workLoad, nowDay_1)
                sortFlighttime(fdb,workLoad)
                sortFlighttime2(fdb,workLoad)
                checkTFUairplane(fdb)
                checkWorkerlaod_new(fdb,workLoad,nowDayStr,nowDay_1)
                checkFlightAlert(fdb, singlePeopleNotice)
                dingdingDelete_flight(fdb)
                dingdingFlightsts(fdb)
                dingdinginfoget(fdb)
                CalledChecked(fdb)
                print(datetime.datetime.now(),"B静态刷新")
                code = "200"
            if mainseverip and mainseverip != loaclseverip and type == "B":
                print(datetime.datetime.now(), '[系统警告]主服务器通讯失败，备份服务器工作中')
                main_fdb=flightDB(host=maindatabase, port=dbport, user=dbuser, password=dbpassword, database=databaseDB4)
                main_db = flaskDBUtils.flaskDB(host=maindatabase, port=dbport, user=dbuser, password=dbpassword, database=database)
                main_loginTabledb = flightDB(host=maindatabase, port=dbport, user=dbuser, password=dbpassword, database=databaseLoginDB)
                loginTabledb = flightDB(host=dbhost, port=dbport, user=dbuser, password=dbpassword, database=databaseLoginDB)
                try:
                    postgresql_bakup(fdb, main_fdb,1)
                    postgresql_bakup(db, main_db,3)
                    postgresql_bakup(loginTabledb, main_loginTabledb,2)
                    main_fdb.close()
                    main_db.close()
                    main_loginTabledb.close()
                except Exception as e:
                    main_fdb.close()
                    main_db.close()
                    main_loginTabledb.close()
                    print(datetime.datetime.now(), '[系统警告]向主数据传输失败')
            fdb.close()
            workLoad.close()
            db.close()
            return code
        except Exception as e:
            fdb.close()
            workLoad.close()
            db.close()
            app_logger.log_error(e)
            return '未登录'

    else:
        #需要加入数据库同步
        if type == "B":
            print(datetime.datetime.now(), '[主从备份]非主服务器,该服务器仅同步')
            main_fdb=flightDB(host=maindatabase, port=dbport, user=dbuser, password=dbpassword, database=databaseDB4)
            main_db = flaskDBUtils.flaskDB(host=maindatabase, port=dbport, user=dbuser, password=dbpassword, database=database)
            main_loginTabledb = flightDB(host=maindatabase, port=dbport, user=dbuser, password=dbpassword, database=databaseLoginDB)
            loginTabledb = flightDB(host=dbhost, port=dbport, user=dbuser, password=dbpassword, database=databaseLoginDB)
            try:
                postgresql_bakup(main_fdb,fdb,1)
                postgresql_bakup(main_db, db, 3)
                postgresql_bakup(main_loginTabledb, loginTabledb, 2)
                db.close()
                fdb.close()
                workLoad.close()
                main_fdb.close()
                main_db.close()
                main_loginTabledb.close()
                return '200'
            except Exception as e:
                print(e)
                db.close()
                fdb.close()
                workLoad.close()
                main_fdb.close()
                main_db.close()
                main_loginTabledb.close()
                print(datetime.datetime.now(), '[系统警告]从主数据备份失败')
                return '未登录'
        else:
            return "200"

@app.route('/static/getPglist/<bcstr>')
def getPglist(bcstr):
    try:
        remote_addr = request.remote_addr
        #print('获取派工数据')
        bc=bcstr
        #bc = "B"  #需要获取
        db = flaskDBUtils.flaskDB(host=dbhost,port=dbport,user=dbuser,password=dbpassword,database=database)
        token = flaskDBUtils.getToken(db)
        db.close()
        #token = utils.flight_list.get_cookie()
        nowDay = datetime.datetime.now()
        nowDayStr = nowDay.strftime("%Y%m%d")
        nowDayStr2 = nowDay.strftime("%Y-%m-%d")
        # (self, taskid:str, shiftDate:str, shift:str, cookie):
        fdb = flightDB(host=dbhost,port=dbport,user=dbuser,password=dbpassword,database=databaseDB4)
        taskids=fdb.queryTabel("TaskFlightinfo{}".format(nowDayStr),"航班编号","进出港航班号 like '%3U%'")
        if taskids[0][0] != "":
            Pglistdata=fl.request_LM_TSK_EMP_PGLIST(taskids[0][0],nowDayStr2,bc,token)
            Update_Pglist(fdb,nowDayStr,bc,Pglistdata['data'])
            fdb.close()
            print(datetime.datetime.now(),"[%s]获取派工人员清单请求"%remote_addr)
            return str(Pglistdata['code'])
        else:
            return '404'
    except Exception as e:
        app_logger.log_error("获取派工失败")
        app_logger.log_error(e)
        return '404'

@app.route('/static/getPglistInDatabase')
def getPglistInDatabase():
    fdb = flightDB(host=dbhost,port=dbport,user=dbuser,password=dbpassword,database=databaseDB4)
    try:
        res = Judge_bc()
        ress = GetPglistInDatabase(fdb,res)
        fdb.close()
        return {"返回值":ress}
    except Exception as e:
        fdb.close()
        app_logger.log_error(e)
        return {"返回值":[]}

@app.route('/static/getworkload',methods=["GET","POST"])
def getworkload():
    names = json.loads(request.get_data())
    fdb = flightDB(host=dbhost,port=dbport,user=dbuser,password=dbpassword,database=databaseDB4)
    workLoad = flightDB(host=dbhost, port=dbport, user=dbuser, password=dbpassword, database=databaseWorkLoad)
    try:
        res=Getworkload(fdb,workLoad,names)
        return res
    except Exception as e:
        fdb.close()
        workLoad.close()
        app_logger.log_error(e)
        return {}

@app.route('/static/manchangecosttime',methods=["GET","POST"])
def manchangecosttime():
    remote_addr = request.remote_addr
    data = json.loads(request.get_data())
    workLoad = flightDB(host=dbhost, port=dbport, user=dbuser, password=dbpassword, database=databaseWorkLoad)
    res=ManCahangeWorkload(workLoad,data)
    workLoad.close()
    return {"返回值":res}

@app.route('/static/handoverflight',methods=["GET","POST"])
def handoverflight():
    remote_addr = request.remote_addr
    data = json.loads(request.get_data())
    workLoad = flightDB(host=dbhost, port=dbport, user=dbuser, password=dbpassword, database=databaseWorkLoad)
    res=HandoverStsChange(workLoad,data)
    workLoad.close()
    return {"返回值":res}


@app.route('/static/handoverflightAMRO',methods=["GET","POST"])
def handoverflightAMRO():
    remote_addr = request.remote_addr
    data = json.loads(request.get_data())
    db = flaskDBUtils.flaskDB(host=dbhost,port=dbport,user=dbuser,password=dbpassword,database=database)
    token = flaskDBUtils.getToken(db)
    #token = utils.flight_list.get_cookie()

    Pglistdata=fl.request_LM_TSK_HANDOVER(data,token)
    if Pglistdata['code'] == 200:
        res = {"返回值": "ok"}
    else:
        res = {"返回值": "fail"}
    print(datetime.datetime.now(),"[%s]使用AMRO工作交接功能"%remote_addr)
    return res

@app.route('/static/MM_GJJH_LIST/<team>')
def MM_GJJH_LIST(team):
    remote_addr = request.remote_addr
    db = flaskDBUtils.flaskDB(host=dbhost,port=dbport,user=dbuser,password=dbpassword,database=database)
    token = flaskDBUtils.getToken(db)
    db.close()
    Pglistdata=fl.request_MM_GJJH_LIST(token)
    fdb = flightDB(host=dbhost,port=dbport,user=dbuser,password=dbpassword,database=databaseDB4)
    mM_GJJH_LIST(fdb,team,Pglistdata['data'])
    fdb.close()
    print(datetime.datetime.now(),"[%s]%s工具接还查询"%(remote_addr,team))
    return str(Pglistdata['code'])

@app.route('/static/checkWorkjob/<taskid>')
def checkWorkjob(taskid):
    remote_addr = request.remote_addr
    res = {"返回值": "fail"}
    db = flaskDBUtils.flaskDB(host=dbhost,port=dbport,user=dbuser,password=dbpassword,database=database)
    token = flaskDBUtils.getToken(db)
    db.close()
    fdb = flightDB(host=dbhost,port=dbport,user=dbuser,password=dbpassword,database=databaseDB4)
    getinfos=GetWorkjobInfo(fdb,taskid)
    if getinfos !={}:
        getworkjob = fl.checkWorkjob(getinfos["taskids"], getinfos["acno"], getinfos["taskType"], getinfos["actype"], getinfos["startDate"], getinfos["endDate"], token)
        res=InsertWorkjob(fdb,getworkjob["data"],taskid)
        print(datetime.datetime.now(), "[%s]获取%s工作包请求"%(remote_addr,getinfos["acno"]))
    fdb.close()
    return res

@app.route('/static/mandealAllLogs/<mode>/<user>')
def mandealAllLogs(mode,user):
    remote_addr = request.remote_addr
    fdb = flightDB(host=dbhost,port=dbport,user=dbuser,password=dbpassword,database=databaseDB4)
    MandealAllLogs(fdb, user,mode)
    fdb.close()
    print(datetime.datetime.now(),"[%s]%s人工处理所有待办"%(remote_addr,user))
    return "ok"

@app.route('/static/calltry')
def calltry():
    remote_addr = request.remote_addr
    db = flaskDBUtils.flaskDB(host=dbhost,port=dbport,user=dbuser,password=dbpassword,database=database)
    phoneip=flaskDBUtils.getIpPhoneip(db)
    db.close()
    ip=phoneip["ip"]
    token = phoneip["token"]
    db.close()
    #print("客户端点击尝试拨打请求获取的IP：%s"%phoneip)
    if ip !="" and token!="":
        fdb = flightDB(host=dbhost,port=dbport,user=dbuser,password=dbpassword,database=databaseDB4)
        A=Calltry(fdb, ip,token)
        fdb.close()
        res = {"返回值": "ok"}
        print(datetime.datetime.now(),"[%s]尝试自动拨打请求"%remote_addr)
    else:
        res = {"返回值": "fail"}
    return res

@app.route('/static/manAddFlight/<flighttype>/<acno>/<eng>/<actype>/<flightno>/<flightdate>/<bay>/<eta>/<etd>/<user>')
def manAddFlight(flighttype,acno,eng,actype,flightno,flightdate,bay,eta,etd,user):
    fdb = flightDB(host=dbhost,port=dbport,user=dbuser,password=dbpassword,database=databaseDB4)
    res=ManAddFlight(fdb,flighttype,acno,eng,actype,flightno,flightdate,bay,eta,etd,user)
    print(datetime.datetime.now(),"%s人工添加航班%s"%(user,flightno))
    fdb.close()
    return res

@app.route('/static/getphonelist')
def getphonelist():
    fdb = flightDB(host=dbhost,port=dbport,user=dbuser,password=dbpassword,database=databaseDB4)
    res=Getphonelist(fdb)
    remote_addr = request.remote_addr
    fdb.close()
    print(datetime.datetime.now(),"[%s]客户端获取通讯录名单"%remote_addr)
    return res

@app.route('/static/deleteFlight/<flightid>/<user>/<time>')
def deleteFlight(flightid,user,time):
    remote_addr = request.remote_addr
    fdb = flightDB(host=dbhost,port=dbport,user=dbuser,password=dbpassword,database=databaseDB4)
    res=DeleteFlight(fdb,flightid,time)
    fdb.close()
    print(datetime.datetime.now(),"[%s]%s删除航班操作(%s)"%(remote_addr,user,flightid))
    return res

'''
@app.route('/static/called/<phonenum>')
def called(phonenum):
    remote_addr = request.remote_addr
    fdb = flightDB(host=dbhost,port=dbport,user=dbuser,password=dbpassword,database=databaseDB4)
    Called(fdb,phonenum)
    fdb.close()
    res = {"返回值": "ok"}
    print(datetime.datetime.now(),"[%s]%s通话建立请求"%(remote_addr,phonenum))
    return res
'''
@app.route('/static/called/')
def calledChecked():
    remote_addr = request.remote_addr
    fdb = flightDB(host=dbhost,port=dbport,user=dbuser,password=dbpassword,database=databaseDB4)
    CalledChecked(fdb)
    fdb.close()
    res = {"返回值": "ok"}
    print(datetime.datetime.now(),"[%s]通话建立情况检查请求"%remote_addr)
    return res

@app.route('/static/dingdong',methods=["GET","POST"])
def dingdong():
    remote_addr = request.remote_addr
    data = json.loads(request.get_data())
    db = flaskDBUtils.flaskDB(host=dbhost,port=dbport,user=dbuser,password=dbpassword,database=database)
    token=flaskDBUtils.getToken(db)
    db.close()
    LM_TSK_DINGDONG=fl.request_LM_TSK_DINGDONG(data,token)
    #print(data)
    if LM_TSK_DINGDONG['code'] and LM_TSK_DINGDONG['code'] == 200:
        res = {"返回值": "ok"}
    else:
        res = {"返回值": "fail"}
    print(datetime.datetime.now(),"[%s]使用叮咚消息"%remote_addr)
    return res

@app.route('/static/LM_TSK_SURE_PG',methods=["GET","POST"])
def LM_TSK_SURE_PG():
    remote_addr = request.remote_addr
    data = json.loads(request.get_data())
    db = flaskDBUtils.flaskDB(host=dbhost,port=dbport,user=dbuser,password=dbpassword,database=database)
    token = flaskDBUtils.getToken(db)
    db.close()
    LM_TSK_SURE_PG=fl.request_LM_TSK_SURE_PG(data,token)
    #print(data)
    if LM_TSK_SURE_PG['code'] and LM_TSK_SURE_PG['code'] == 200:
        res = {"返回值": "ok"}
    else:
        res = {"返回值": "fail"}
    print(datetime.datetime.now(),"[%s]使用派工"%remote_addr)
    return res

@app.route('/static/insertCalllist',methods=["GET","POST"])
def insertCalllist():
    remote_addr = request.remote_addr
    data = json.loads(request.get_data())
    fdb = flightDB(host=dbhost,port=dbport,user=dbuser,password=dbpassword,database=databaseDB4)
    res=InsertCalllist(fdb, data)
    fdb.close()
    print(datetime.datetime.now(),"[%s]录入拨号数据库"%remote_addr)
    #print(datetime.datetime.now(),data)
    return res
@app.route('/static/get_empNos_phoone/<name>')
def get_empNos_phoone(name):
    remote_addr = request.remote_addr
    fdb = flightDB(host=dbhost,port=dbport,user=dbuser,password=dbpassword,database=databaseDB4)
    res=Get_empNos_phoone(fdb, name)
    fdb.close()
    print(datetime.datetime.now(),"[%s]获取员工号和电话号码"%remote_addr)
    #print(datetime.datetime.now(),data)
    return res

@app.route('/static/get_empNos',methods=["GET","POST"])
def get_empNos():
    remote_addr = request.remote_addr
    data = json.loads(request.get_data())
    fdb = flightDB(host=dbhost,port=dbport,user=dbuser,password=dbpassword,database=databaseDB4)
    res=Get_empNos(fdb, data)
    fdb.close()
    print(datetime.datetime.now(),"[%s]获取员工号"%remote_addr)
    #print(datetime.datetime.now(),data)
    return res


@app.route('/static/linktest')
def linktest():

   return "ok"

@app.route('/static/updatecheck')
def updatecheck():
    try:
        remote_addr = request.remote_addr
        flaskDB =flaskDBUtils.flaskDB(host=dbhost,port=dbport,user=dbuser,password=dbpassword,database=database)
        updatests=flaskDBUtils.updatecheck(flaskDB)
        res = {"返回值":updatests}
        flaskDB.close()
        #print(res)
        print(datetime.datetime.now(),"[%s]客户端自动检查更新请求"%remote_addr)
        return res
    except:
        return {"返回值": "0"}


@app.route('/static/calling/<phonenum0>')  #呼出通话建立
def calling(phonenum0):
    remote_addr = request.remote_addr
    #print(phonenum0)
    flaskDB = flaskDBUtils.flaskDB(host=dbhost,port=dbport,user=dbuser,password=dbpassword,database=database)
    now=datetime.datetime.now()
    a=flaskDBUtils.callingphoneUpdate(flaskDB,phonenum0,now)
    res = {"返回值":"ok"}
    flaskDB.close()
    #print(res)
    print(datetime.datetime.now(),"[%s]%s自动电话通话正在呼出"%(remote_addr,phonenum0))
    return res

@app.route('/static/calldown')  #通话结束
def calldown():
    remote_addr = request.remote_addr
    flaskDB = flaskDBUtils.flaskDB(host=dbhost,port=dbport,user=dbuser,password=dbpassword,database=database)
    now=datetime.datetime.now()
    a=flaskDBUtils.callingphoneUpdate(flaskDB,None,now)
    res = {"返回值":"ok"}
    flaskDB.close()
    #print(res)
    print(datetime.datetime.now(),"[%s]自动电话缓存恢复初始值"%remote_addr)
    return res

@app.route('/static/callon')  #呼出通话建立
def callon():
    remote_addr = request.remote_addr
    flaskDB = flaskDBUtils.flaskDB(host=dbhost,port=dbport,user=dbuser,password=dbpassword,database=database)
    phonenum=flaskDBUtils.getPhoneNum(flaskDB)
    flaskDB.close()
    if phonenum != None:
        fdb = flightDB(host=dbhost,port=dbport,user=dbuser,password=dbpassword,database=databaseDB4)
        Callon(fdb,phonenum)
        fdb.close()
        #print(res)
        print(datetime.datetime.now(),"[%s]%s自动电话通话建立写入"%(remote_addr,phonenum))
    res = {"返回值": "ok"}
    return res

@app.route('/static/initFlightDatabase/<selectedtime>')
def initFlightDatabase(selectedtime):
    remote_addr = request.remote_addr
    fdb = flightDB(host=dbhost,port=dbport,user=dbuser,password=dbpassword,database=databaseDB4)
    workLoad = flightDB(host=dbhost, port=dbport, user=dbuser, password=dbpassword, database=databaseWorkLoad)
    InitFlightDatabase(fdb,workLoad,selectedtime)
    fdb.close()
    workLoad.close()
    res = {"返回值": "ok"}
    print(datetime.datetime.now(),"[%s]初始化航班信息数据库"%remote_addr)
    return res

@app.route('/static/selftaxiLogs/<text>/<flightid>')
def selftaxiLogs(text,flightid):
    fdb = flightDB(host=dbhost,port=dbport,user=dbuser,password=dbpassword,database=databaseDB4)
    SelftaxiLogs(fdb,text,flightid)
    fdb.close()
    res = {"返回值": "ok"}
    return res

@app.route('/static/checkCalllist/<time>')
def checkCalllist(time):
    fdb = flightDB(host=dbhost,port=dbport,user=dbuser,password=dbpassword,database=databaseDB4)
    res=CheckCalllist(fdb,time)
    fdb.close()
    return res

@app.route('/static/insertLogs/<text>/<name>/<time>')
def insertLogs(text,name,time):
    remote_addr = request.remote_addr
    fdb = flightDB(host=dbhost,port=dbport,user=dbuser,password=dbpassword,database=databaseDB4)
    InsertLogs(fdb,text,name,time)
    fdb.close()
    res = {"返回值": "ok"}
    print(datetime.datetime.now(),"[%s]%s插入日志信息"%(remote_addr,name))
    return res

@app.route('/static/insertLogs2/<text>/<name>/<time>')
def insertLogs2(text,name,time):
    remote_addr = request.remote_addr
    fdb = flightDB(host=dbhost,port=dbport,user=dbuser,password=dbpassword,database=databaseDB4)
    InsertLogs2(fdb,text,name,time)
    fdb.close()
    res = {"返回值": "ok"}
    print(datetime.datetime.now(),"[%s]%s插入日志信息"%(remote_addr,name))
    return res

@app.route('/static/checkLoadSingal/<worknum>/<time1>/<time2>')
def checkLoadSingal(worknum,time1,time2):
    remote_addr = request.remote_addr
    wdb = flightDB(host=dbhost,port=dbport,user=dbuser,password=dbpassword,database=databaseWorkLoad)
    res=CheckLoadSingal(wdb,worknum,time1,time2)
    wdb.close()
    print(datetime.datetime.now(),"[%s]查询个人工作量请求"%remote_addr)
    return res

@app.route('/static/loginTable/<username>/<password>')
def loginTable(username,password):
    remote_addr = request.remote_addr
    res1={"返回值":""}
    #t1 = datetime.datetime.now()
    loginTabledb = flightDB(host=dbhost,port=dbport,user=dbuser,password=dbpassword,database=databaseLoginDB)
    #t2 = datetime.datetime.now()
    #print(f'登录时间:{t2 - t1}')
    res=loginTabledb.queryTabel('loginTable', '*', "登录名='{}' and 密码='{}'".format(username,password))
    loginTabledb.close()
    if res !=[]:
        res1["返回值"]=res[0]
    print(datetime.datetime.now(),"[%s]%s尝试登录" %(remote_addr,username))
    #t3 = datetime.datetime.now()
    #print(f'处理时间:{t3-t2}')
    return res1

@app.route('/static/authorityCheck/<username>')
def authorityCheck(username):
    remote_addr = request.remote_addr
    res1={"返回值":""}
    loginTabledb = flightDB(host=dbhost,port=dbport,user=dbuser,password=dbpassword,database=databaseLoginDB)
    res=loginTabledb.queryTabel('loginTable', '*', "登录名='{}'".format(username))
    loginTabledb.close()
    if res !=[]:
        res1["返回值"]=res[0]
    print(datetime.datetime.now(),"[%s]%s验证权限请求" %(remote_addr,username))
    return res1

@app.route('/static/loginDbget/<username>')
def loginDbget(username):
    remote_addr = request.remote_addr
    res1= {}
    loginTabledb = flightDB(host=dbhost,port=dbport,user=dbuser,password=dbpassword,database=databaseLoginDB)
    res=loginTabledb.getAlldata('loginTable')
    loginTabledb.close()
    if res !=[] and username in str(res):
        for i in res:
            res2={}
            res2["登录名"] = i[1]
            res2["权限"] = i[3]
            res2["使用人"] = i[4]
            res1[i[1]] = res2
    print(datetime.datetime.now(),"[%s]%s权限修改信息获取" % (remote_addr,username))
    return res1

@app.route('/static/changePassword',methods=["GET","POST"])
def changePassword():
    remote_addr = request.remote_addr
    data = json.loads(request.get_data())
    loginTabledb = flightDB(host=dbhost,port=dbport,user=dbuser,password=dbpassword,database=databaseLoginDB)
    Changepassword(loginTabledb,data["登录名"], data["旧密码"], data["新密码"])
    loginTabledb.close()
    res1 = {"返回值": "ok"}
    print(datetime.datetime.now(),"[%s]%s更改密码请求" % (remote_addr,data["登录名"]))
    return res1

@app.route('/static/addUserWidget',methods=["GET","POST"])
def addUserWidget():
    remote_addr = request.remote_addr
    res1={"返回值":""}
    data = json.loads(request.get_data())
    loginTabledb = flightDB(host=dbhost,port=dbport,user=dbuser,password=dbpassword,database=databaseLoginDB)
    res=loginTabledb.queryTabel('loginTable', '*', "登录名='%s'"%data["登录名"])
    if res == []:
        loginTabledb.insertData('loginTable', data)
        res1["返回值"]="1"
    else:
        res1["返回值"] = "2"
    loginTabledb.close()
    print(datetime.datetime.now(),"[%s]创建新用户：%s请求" % (remote_addr,data["登录名"]))
    return res1

@app.route('/static/changeAuth',methods=["GET","POST"])
def changeAuth():
    remote_addr = request.remote_addr
    res1={"返回值":""}
    data = json.loads(request.get_data())
    loginTabledb = flightDB(host=dbhost,port=dbport,user=dbuser,password=dbpassword,database=databaseLoginDB)
    res=loginTabledb.queryTabel('loginTable', '*', "登录名='%s'"%str(data["登录名"]).replace("'",""))
    if res != []:
        loginTabledb.upDateItem('loginTable',data,"登录名='%s'"%str(data["登录名"]).replace("'",""))
        res1["返回值"]="1"
    else:
        res1["返回值"] = "2"
    loginTabledb.close()
    print(datetime.datetime.now(),"[%s]权限变更写入：%s请求" % (remote_addr,data["登录名"]))
    return res1

@app.route('/static/infoConfirm/<type>/<flightid>/<displaymode>/<selectedtime>')
def infoConfirm(type,flightid,displaymode,selectedtime):
    remote_addr = request.remote_addr
    fdb = flightDB(host=dbhost,port=dbport,user=dbuser,password=dbpassword,database=databaseDB4)
    InfoConfirm(fdb,type,flightid,displaymode,selectedtime)
    fdb.close()
    res = {"返回值": "ok"}
    print(datetime.datetime.now(), "[%s]确认通知操作"%remote_addr)
    return res

@app.route('/static/infoConfirm3/<type>/<flightid>/<displaymode>/<selectedtime>')
def infoConfirm3(type,flightid,displaymode,selectedtime):
    remote_addr = request.remote_addr
    fdb = flightDB(host=dbhost,port=dbport,user=dbuser,password=dbpassword,database=databaseDB4)
    InfoConfirm3(fdb,type,flightid,displaymode,selectedtime)
    fdb.close()
    res = {"返回值": "ok"}
    print(datetime.datetime.now(),"[%s]确认自滑推送操作"%remote_addr)
    return res

@app.route('/static/infoConfirm2/<type>/<flightid>/<displaymode>/<selectedtime>')
def infoConfirm2(type,flightid,displaymode,selectedtime):
    remote_addr = request.remote_addr
    fdb = flightDB(host=dbhost,port=dbport,user=dbuser,password=dbpassword,database=databaseDB4)
    InfoConfirm2(fdb,type,flightid,displaymode,selectedtime)
    fdb.close()
    res = {"返回值": "ok"}
    print(datetime.datetime.now(),"[%s]确认推送操作"%remote_addr)
    return res

@app.route('/static/manChangests/<text>/<type>/<selectedtime>/<username>')
def manChangests(text,type,selectedtime,username):
    remote_addr = request.remote_addr
    fdb = flightDB(host=dbhost,port=dbport,user=dbuser,password=dbpassword,database=databaseDB4)
    ManChangests(fdb,text,type,selectedtime,username)
    fdb.close()
    res = {"返回值": "ok"}
    print(datetime.datetime.now(),"[%s][%s]%s人工改变航班状态"%(remote_addr,username,text))
    return res

@app.route('/static/updateDragDropItem/<column>/<text>/<flightid>/<displayMode>/<flighttype>/<selectedtime>')
def updateDragDropItem(column,text,flightid,displayMode,flighttype,selectedtime):
    #t1 = datetime.datetime.now()
    remote_addr = request.remote_addr
    fdb = flightDB(host=dbhost,port=dbport,user=dbuser,password=dbpassword,database=databaseDB4)
    #print(fdb,column,text,flightid,displayMode,flighttype,selectedtime)
    #t2 = datetime.datetime.now()
    #print(f'编辑登录时间:{t2 - t1}')
    res = UpdateDragDropItem(fdb,column,text,flightid,displayMode,flighttype,selectedtime)
    fdb.close()
    res1={"返回值":"OK"}
    print(datetime.datetime.now(),"[%s]拖拽更新请求"%remote_addr)
    #t3 = datetime.datetime.now()
    #print(f'编辑处理时间:{t3 - t2}')
    return res1
@app.route('/static/updateEidteItem/<text>/<flightid>/<displayMode>/<flighttype>/<selectedtime>')
def updateEidteItem(text,flightid,displayMode,flighttype,selectedtime):
    remote_addr = request.remote_addr
    fdb = flightDB(host=dbhost,port=dbport,user=dbuser,password=dbpassword,database=databaseDB4)
    #print(fdb,column,text,flightid,displayMode,flighttype,selectedtime)
    UpdateEidteItem(fdb,text,flightid,displayMode,flighttype,selectedtime)
    fdb.close()
    res1={"返回值":"OK"}
    print(datetime.datetime.now(),"[%s]附加消息请求"%remote_addr)
    return res1
@app.route('/static/updateNoteItem/<text>/<name>')
def updateNoteItem(text,name):
    try:
        remote_addr = request.remote_addr
        fdb = flightDB(host=dbhost,port=dbport,user=dbuser,password=dbpassword,database=databaseDB4)
        UpdateNoteItem(fdb,text,name)
        fdb.close()
        res1={"返回值":"OK"}
        print(datetime.datetime.now(),"[%s]排班辅助备注修改"%remote_addr)
        return res1
    except Exception as e:
        res1={"返回值":"fail"}
        print("有bug,请联系管理员")
        app_logger.log_error(e)
        return res1

@app.route('/static/checkPglist/<name>/<selectedtime>/<bc>')
def checkPglist(name,selectedtime,bc):
    remote_addr = request.remote_addr
    fdb = flightDB(host=dbhost,port=dbport,user=dbuser,password=dbpassword,database=databaseDB4)
    #print(fdb,column,text,flightid,displayMode,flighttype,selectedtime)
    res = CheckPglist(fdb,name,selectedtime,bc)
    fdb.close()
    #print(res)
    if res == "YES":
        res1 = {"返回值": "OK"}
        print(datetime.datetime.now(), "[%s]人工录入派工核查成功"%remote_addr)
    else:
        res1 = {"返回值": "fail"}
        print(datetime.datetime.now(), "[%s]人工录入派工核查失败"%remote_addr)
    return res1

@app.route('/static/tableWidgetLOGDispaly/<selectedtime>')
def tableWidgetLOGDispaly(selectedtime):
    fdb = flightDB(host=dbhost,port=dbport,user=dbuser,password=dbpassword,database=databaseDB4)
    res=TableWidgetLOGDispaly(fdb,selectedtime)
    fdb.close()
    remote_addr = request.remote_addr
    print(datetime.datetime.now(),"[%s]日志刷新请求"%remote_addr)
    return res

@app.route('/static/qtPeopleLoad/<selectedtime>/<bc>')
def qtPeopleLoad(selectedtime,bc):
    fdb = flightDB(host=dbhost,port=dbport,user=dbuser,password=dbpassword,database=databaseDB4)
    workLoad = flightDB(host=dbhost,port=dbport,user=dbuser,password=dbpassword,database=databaseWorkLoad)
    res=QtPeopleLoad(fdb,workLoad,bc,selectedtime)
    workLoad.close()
    fdb.close()
    remote_addr = request.remote_addr
    print(datetime.datetime.now(),"[%s]人员工作状态刷新请求"%remote_addr)
    return res

@app.route('/static/getVin/<mode>/<num>')
def getVin(mode,num):
    db = flaskDBUtils.flaskDB(host=dbhost,port=dbport,user=dbuser,password=dbpassword,database=database)
    vin=flaskDBUtils.getVin(db,mode,int(num)) # 刷新航班
    db.close()
    res = {"返回值": "%s"%vin}
    remote_addr = request.remote_addr
    print(datetime.datetime.now(), "[%s]获取在线Vin码"%remote_addr)
    return res

@app.route('/static/updateVin/<mode>/<num>')
def updateVin(mode,num):
    db = flaskDBUtils.flaskDB(host=dbhost,port=dbport,user=dbuser,password=dbpassword,database=database)
    vin=flaskDBUtils.updateVin(db,mode,int(num))  # 刷新航班
    db.close()
    res = {"返回值": "%s"%vin}
    remote_addr = request.remote_addr
    print(datetime.datetime.now(), "[%s]更新在线Vin码"%remote_addr)
    return res

@app.route('/static/tableWidgetDispalyRead/<date>')
def tableWidgetDispalyRead(date):
    fdb = flightDB(host=dbhost,port=dbport,user=dbuser,password=dbpassword,database=databaseDB4)
    res=TableWidgetDispalyRead(fdb,date)
    fdb.close()
    #print(datetime.datetime.now(),res)
    remote_addr = request.remote_addr
    print(datetime.datetime.now(),"[%s]A模式航班信息刷新请求"%remote_addr)
    return res

@app.route('/static/tableWidgetDispalyRead2/<date>')
def tableWidgetDispalyRead2(date):
    fdb = flightDB(host=dbhost,port=dbport,user=dbuser,password=dbpassword,database=databaseDB4)
    res=TableWidgetDispalyRead2(fdb,date)
    fdb.close()
    #print(datetime.datetime.now(),res)
    remote_addr = request.remote_addr
    print(datetime.datetime.now(),"[%s]B模式航班信息刷新请求"%remote_addr)
    return res

@app.route('/static/tableWidgetDispaly/<selectedtime>/<date>')
def tableWidgetDispaly(selectedtime,date):
    #t1 = datetime.datetime.now()
    fdb = flightDB(host=dbhost,port=dbport,user=dbuser,password=dbpassword,database=databaseDB4)
    #t2 = datetime.datetime.now()
    #print(f'航班刷新登录时间:{t2 - t1}')
    res=TableWidgetDispaly(fdb,selectedtime,date)
    fdb.close()
    #print(datetime.datetime.now(),res)
    remote_addr = request.remote_addr
    print(datetime.datetime.now(),"[%s]A模式航班信息刷新请求[%s]"%(remote_addr,date))
    #t3 = datetime.datetime.now()
    #print(f'航班刷新处理时间:{t3 - t2}')
    return res

@app.route('/static/tableWidgetDispaly11/<selectedtime>')
def tableWidgetDispaly11(selectedtime):
    remote_addr = request.remote_addr
    fdb = flightDB(host=dbhost,port=dbport,user=dbuser,password=dbpassword,database=databaseDB4)
    res=TableWidgetDispaly(fdb,selectedtime,"4")
    fdb.close()
    #print(datetime.datetime.now(),res)
    print(datetime.datetime.now(),"[%s]文件存储1航班信息刷新请求"%remote_addr)
    return res

@app.route('/static/tableWidgetDispaly22/<selectedtime>')
def tableWidgetDispaly22(selectedtime):
    remote_addr = request.remote_addr
    fdb = flightDB(host=dbhost,port=dbport,user=dbuser,password=dbpassword,database=databaseDB4)
    res=TableWidgetDispaly2(fdb,selectedtime,"4")
    fdb.close()
    print(datetime.datetime.now(),"[%s]文件存储2航班信息刷新请求"%remote_addr)
    return res

@app.route('/static/tableWidgetDispaly2/<selectedtime>/<date>')
def tableWidgetDispaly2(selectedtime,date):
    fdb = flightDB(host=dbhost,port=dbport,user=dbuser,password=dbpassword,database=databaseDB4)
    res=TableWidgetDispaly2(fdb,selectedtime,date)
    fdb.close()
    remote_addr = request.remote_addr
    print(datetime.datetime.now(),"[%s]B模式航班信息刷新请求[%s]"%(remote_addr,date))
    return res

@app.route('/static/mapDispaly/<selectedtime>')
def mapDispaly(selectedtime):
    fdb = flightDB(host=dbhost,port=dbport,user=dbuser,password=dbpassword,database=databaseDB4)
    res = MapDispaly(fdb, selectedtime)
    fdb.close()
    #print(datetime.datetime.now(),'获取的机位数据：{}'.format(res))
    remote_addr = request.remote_addr
    print(datetime.datetime.now(),"[%s]地图显示刷新请求"%remote_addr)
    return res

@app.route('/static/judge_bc')
def judge_bc():
    remote_addr = request.remote_addr
    fdb = flightDB(host=dbhost,port=dbport,user=dbuser,password=dbpassword,database=databaseDB4)
    aa=Judge_bc()
    fdb.close()
    print(datetime.datetime.now(),"[%s]判断班次请求"%remote_addr)
    return aa

@app.route('/static/dealLogs/<user>/<id>')
def dealLogs(user,id):
    remote_addr = request.remote_addr
    fdb = flightDB(host=dbhost,port=dbport,user=dbuser,password=dbpassword,database=databaseDB4)
    DealLogs(fdb,user,id)
    fdb.close()
    res = {"返回值": "ok"}
    print(datetime.datetime.now(),"[%s]%s处理待办信息" % (remote_addr,user))
    return res

@app.route('/static/checkLogs/<start>/<end>')
def checkLogs(start,end):
    try:
        remote_addr = request.remote_addr
        res={}
        fdb = flightDB(host=dbhost,port=dbport,user=dbuser,password=dbpassword,database=databaseDB4)
        res=fdb.sort_queryTable("*",'logs',"产生时间<'%s' and 产生时间>'%s'"%(end,start),"产生时间","desc")
        fdb.close()
        print(datetime.datetime.now(),"[%s]查询全部日志请求"%remote_addr)
        return jsonify(res)
    except:
        return jsonify({})

@app.route('/static/tableWidgetDisplayChange/<selectedtime>')
def tableWidgetDisplayChange(selectedtime):
    fdb = flightDB(host=dbhost,port=dbport,user=dbuser,password=dbpassword,database=databaseDB4)
    res=TableWidgetDisplayChange(fdb,selectedtime)
    fdb.close()
    remote_addr = request.remote_addr
    print(datetime.datetime.now(),"[%s]待办信息刷新请求"%remote_addr)
    return res

@app.route('/static/get_dic',methods=["GET","POST"])
def get_dic():
    remote_addr = request.remote_addr
    data = json.loads(request.get_data())
    fdb = flightDB(host=dbhost,port=dbport,user=dbuser,password=dbpassword,database=databaseDB4)
    ress=Get_dic(fdb,data["fileName"])
    fdb.close()
    res = {"返回值": ress}
    print(datetime.datetime.now(),"[%s]获取人员信息EXCEL表格"%remote_addr)
    return res
@app.route('/static/handovechange',methods=["GET","POST"])
def handovechange():
    remote_addr = request.remote_addr
    data = json.loads(request.get_data())
    fdb = flightDB(host=dbhost,port=dbport,user=dbuser,password=dbpassword,database=databaseDB4)
    Get_dic(fdb,data["fileName"])
    fdb.close()
    res = {"返回值": "ok"}
    print(datetime.datetime.now(),"[%s]获取人员信息EXCEL表格"%remote_addr)
    return res

@app.route('/static/updateStopFlight',methods=["GET","POST"])
def updateStopFlight():
    try:
        remote_addr = request.remote_addr
        data = json.loads(request.get_data())
        fdb = flightDB(host=dbhost,port=dbport,user=dbuser,password=dbpassword,database=databaseDB4)
        workLoad = flightDB(host=dbhost, port=dbport, user=dbuser, password=dbpassword, database=databaseWorkLoad)
        res=UpdateStopFlight(fdb,workLoad,data["fileName"])
        fdb.close()
        workLoad.close()
        print(datetime.datetime.now(),"[%s]上传停场航班EXCEL数据"%remote_addr)
        return res
    except:
        fdb.close()
        workLoad.close()
        print(datetime.datetime.now(), "[%s]上传停场航班EXCEL数据失败" % remote_addr)
        return {"返回值": "fail"}



@app.route('/static/updateTaskAuto',methods=["GET","POST"])
def updateTaskAuto():
    try:
        remote_addr = request.remote_addr
        data = json.loads(request.get_data())
        fdb = flightDB(host=dbhost,port=dbport,user=dbuser,password=dbpassword,database=databaseDB4)
        UpdateTaskAuto(fdb,data["fileName"])
        fdb.close()
        res = {"返回值": "ok"}
        print(datetime.datetime.now(),"[%s]获取准备组任务EXCEL表格"%remote_addr)
        return res
    except:
        print(datetime.datetime.now(), "[%s]获取准备组任务EXCEL表格失败" % remote_addr)
        return {"返回值":"fail"}
#新增内容
@app.route('/static/saveRisktable')
def saveRisktable():
    remote_addr = request.remote_addr
    fdb = flightDB(host=dbhost,port=dbport,user=dbuser,password=dbpassword,database=databaseDB4)
    res=SaveRisktable(fdb)
    fdb.close()
    print(datetime.datetime.now(),"[%s]导出风险数据库"%remote_addr)
    return {"返回值":res}

@app.route('/static/getRiskData/<bay>/<time>/<acno>')
def getRiskData(bay,time,acno):
    remote_addr = request.remote_addr
    fdb = flightDB(host=dbhost,port=dbport,user=dbuser,password=dbpassword,database=databaseDB4)
    res=GetRiskData(fdb,bay,time,acno)
    fdb.close()
    print(datetime.datetime.now(),"[%s]导出风险数据库"%remote_addr)
    return {"返回值":res}

@app.route('/static/updateRiskdb',methods=["GET","POST"])
def updateRiskdb():
    remote_addr = request.remote_addr
    data = json.loads(request.get_data())
    fdb = flightDB(host=dbhost,port=dbport,user=dbuser,password=dbpassword,database=databaseDB4)
    UpdateRiskdb(fdb,data["fileName"])
    fdb.close()
    res = {"返回值": "ok"}
    print(datetime.datetime.now(),"[%s]获取风险数据库EXCEL表格"%remote_addr)
    return res

@app.route('/static/taskAtuoCheck/<time>')
def taskAtuoCheck(time):
    remote_addr = request.remote_addr
    fdb = flightDB(host=dbhost,port=dbport,user=dbuser,password=dbpassword,database=databaseDB4)
    TaskAtuoCheck(fdb,time)
    fdb.close()
    res = {"返回值": "ok"}
    print(datetime.datetime.now(),"[%s]确认准备组任务待办信息情况"%remote_addr)
    return res

@app.route('/static/createWorkloadtablesFromPg/<selectedtime>')
def createWorkloadtablesFromPg(selectedtime):
    remote_addr = request.remote_addr
    fdb = flightDB(host=dbhost,port=dbport,user=dbuser,password=dbpassword,database=databaseDB4)
    workLoad = flightDB(host=dbhost,port=dbport,user=dbuser,password=dbpassword,database=databaseWorkLoad)
    CreateWorkloadtablesFromPg(fdb,workLoad,selectedtime)
    fdb.close()
    workLoad.close()
    res={"返回值":"ok"}
    print(datetime.datetime.now(),"[%s]通过派工信息创建人员工作统计表"%remote_addr)
    return res


@app.route('/table')
def table():
    flaskDB = flaskDBUtils.flaskDB(host=dbhost,port=dbport,user=dbuser,password=dbpassword,database=database)
    result = flaskDBUtils.getinfolog(flaskDB)
    flaskDB.close()
    dl = []
    if result !=None:
        for i in result:
            dl.append([i[0], i[1], i[2]])
        data = {
            "data":dl
        }
        #print(data)
        #print('get table data')
        return data

@app.route("/map/<selectedtime>")
def index(selectedtime):
    return render_template("map.html", selectedtime=selectedtime)

@app.route("/map/getSelectInf/<selectedtime>", methods=['POST','GET'])
def getSelectInf(selectedtime):
    if request.method == 'POST':
        result = request.form
        fdb = flightDB(host=dbhost,port=dbport,user=dbuser,password=dbpassword,database=databaseDB4)
        res = MapDispaly(fdb, selectedtime)
        data = res[result['bay']]
        fdb.close()
        return render_template('table.html', data=data)
    return 'err'

#'''
@app.before_first_request
def init():
    print('####  Flask Start... ####')
    global fl,si,singlePeopleNotice,loaclseverip
    fl = utils.flight_list()
    si = ipcall.searchinfo()
    loaclseverip = get_local_ip()
    print(f"当前服务器IP:{loaclseverip}")
    singlePeopleNotice = initialize_file('D:\\flightinfo\\DATABASE\\singlepoeple_notice.txt',False)
if __name__ == '__main__':
    serve(app, host='0.0.0.0',port=7162, threads=20)
'''
if __name__ == '__main__':
    if os.environ.get('WERKZEUG_RUN_MAIN') == 'true':
        fl = utils.flight_list()
        si = ipcall.searchinfo()
        loaclseverip=get_local_ip()
        singlePeopleNotice = initialize_file('D:\\flightinfo\\DATABASE\\singlepoeple_notice.txt', False)
    app.run(host='0.0.0.0', port=7162, debug=True)
#'''