parkMonitor_V2.0/PLCLinker/centralController/Terminal/Terminal.cs

using Terminal;
using db;
using System.Collections.Generic;
using System.Threading.Tasks;
using PLCS7;
using System;
using System.Text;
using MySql.Data.MySqlClient;
using System.Threading;
using BroadcastModule;
using parkMonitor.LOG;

namespace Terminal
{
    public class Terminal
    {
        public static List<TerminalStru> terminalInfo = new List<PLCS7.TerminalStru>();
        public static Dictionary<int, string> idLicMap = new Dictionary<int, string>();
        public static Dictionary<int, bool> termUsedMap = new Dictionary<int, bool>();
        public static bool isClosing = false;

        public void FeeCal()
        {

        }

        public void GetTerminalState()
        {

        }

        private object SearchPaymentScheme()
        {
            return null;
        }

        private void UpdateParkingRecords(int Object)
        {

        }

        /// <summary>
        /// 从终端结构体中获得车牌号
        /// </summary>
        /// <param name="ts"></param>
        /// <returns></returns>
        private static string GetLicenseFromTerm(TerminalStru ts)
        {
            string header = Encoding.ASCII.GetString(BitConverter.GetBytes(ts.licenseCodeB));
            string identityA = Encoding.ASCII.GetString(BitConverter.GetBytes(ts.licenseCodeC));
            byte[] bytes = BitConverter.GetBytes(ts.licenseCodeD);
            List<byte> newBytes = new List<byte>();
            for (int i = 0; i < bytes.Length; i++)
            {
                if (bytes[i] != 0x00) { newBytes.Add(bytes[i]); }
            }
            string identityB = Encoding.ASCII.GetString(newBytes.ToArray());
            Log.WriteLog(LogType.process, LogFile.INFO, "已从终端" + ts.terminalID + "获得号牌：" + header + identityA + identityB);
            //根据省份对应的两位数字查找汉字
            string province = header.Substring(0, 2);
            string provinceIndex = header.Substring(2);
            string provinceQuerySql = "select NumberPlateHeader from numberplatemapping where mappedString = " + province + ";";
            MySqlDataReader reader = Monitor.Monitor.localDBOper.Query(provinceQuerySql);
            try
            {
                if (reader != null && reader.Read() && reader.HasRows)
                {
                    province = reader.GetString("NumberPlateHeader");
                    //Console.WriteLine(province);
                }
            }
            catch { }
            if (reader != null)
            {
                reader.Close();
                reader.Dispose();
            }
            return province + provinceIndex + identityA + identityB;
        }
        /// <summary>
        /// 更新所有车位信息
        /// </summary>
        private static void UpdateAllParkingSpace()
        {
            string findParkingSpace = "select parkingSpaceID from parkingspace;";
            MySqlDataReader reader = Monitor.Monitor.localDBOper.Query(findParkingSpace);
            HashSet<int> recordsIDSet = new HashSet<int>();
            if (reader != null)
            {
                while (reader.Read())
                {
                    if (reader.HasRows)
                    {
                        recordsIDSet.Add(reader.GetInt32("parkingSpaceID"));
                    }
                }
            }
            try
            {
                if (reader != null)
                {
                    reader.Close();
                    reader.Dispose();
                }
            }
            catch { }
            List<string> updateSpaceList = new List<string>();
            List<string> insertSpaceList = new List<string>();
            string updateParkingSpace = "";
            string insertParkingSpace = "";
            for (int i = 0; i < Monitor.Monitor.parkingSpaceInfo.Count; i++)
            {
                if (recordsIDSet.Contains(Monitor.Monitor.parkingSpaceInfo[i].parkingSpace))
                {
                    updateParkingSpace = "update parkingspace set parkingSpaceX = " + Monitor.Monitor.parkingSpaceInfo[i].coordX +
                        ",parkingSpaceY = " + Monitor.Monitor.parkingSpaceInfo[i].coordY + ",parkingSpaceZ = " + Monitor.Monitor.parkingSpaceInfo[i].floorNo + ",parkingSpaceState = " + Monitor.Monitor.parkingSpaceInfo[i].spaceStatus + " where (parkingSpaceID = " + Monitor.Monitor.parkingSpaceInfo[i].parkingSpace + ");";
                    updateSpaceList.Add(updateParkingSpace);
                }
                else
                {
                    insertParkingSpace = "insert into parkingspace (parkingSpaceID,parkingSpaceX,parkingSpaceY,parkingSpaceZ,parkingSpaceState) values (" + Monitor.Monitor.parkingSpaceInfo[i].parkingSpace + "," + Monitor.Monitor.parkingSpaceInfo[i].coordX +
                        "," + Monitor.Monitor.parkingSpaceInfo[i].coordY + "," + Monitor.Monitor.parkingSpaceInfo[i].floorNo + "," + Monitor.Monitor.parkingSpaceInfo[i].spaceStatus + ");";
                    insertSpaceList.Add(insertParkingSpace);
                }
            }
            try
            {
                Monitor.Monitor.localDBOper.UpdateTransaction(updateSpaceList);
                Monitor.Monitor.localDBOper.Insert(insertSpaceList);
            }
            catch (Exception e) { Log.WriteLog(LogType.process, LogFile.ERROR, "更新本地所有车位异常"); Console.WriteLine("更新本地所有车位异常" + e.Message); }
        }
        /// <summary>
        /// 更新车辆状态
        /// </summary>
        /// <param name="lic"></param>
        /// <param name="state"></param>
        private static void UpdateVehicle(string lic, int state, int parkingRecordsID, bool park, bool remote)
        {
            if (lic != "")
            {
                MySqlDataReader reader;
                //查询车辆是否在车辆表中
                string checkVehicleState = "select * from vehicle where numberPlate = '" + lic + "';";
                if (!remote)
                {
                    reader = Monitor.Monitor.localDBOper.Query(checkVehicleState);
                }
                else
                {
                    reader = Monitor.Monitor.remoteDBOper.Query(checkVehicleState);
                }
                if (reader != null && reader.Read() && reader.HasRows)
                {
                    //更新车辆状态
                    string updateVehicleState = "";
                    if (park)
                    {
                        if (parkingRecordsID > 0)
                            updateVehicleState = "update vehicle set vehiclepParkState = " + state + " ,parkingRecordsID = " + parkingRecordsID + " where numberPlate = '" + lic + "';";
                        else
                            updateVehicleState = "update vehicle set vehiclepParkState = " + state + " where numberPlate = '" + lic + "';";
                    }
                    else
                    {
                        updateVehicleState = "update vehicle set vehiclepParkState = " + state + " where numberPlate = '" + lic + "';";
                    }
                    List<string> list = new List<string>();
                    list.Add(updateVehicleState);
                    if (!remote)
                    {
                        Monitor.Monitor.localDBOper.UpdateTransaction(list);
                    }
                    else
                    {
                        Monitor.Monitor.remoteDBOper.UpdateTransaction(list);
                    }
                }
                else
                {
                    //插入车辆
                    string insertVehicleWithState = "";
                    if (park)
                    {
                        if (parkingRecordsID > 0)
                            insertVehicleWithState = "insert into vehicle (numberPlate,vehicleTypeID,vehiclepParkState,parkingRecordsID) values " +
                        "('" + lic + "',NULL,'" + state + "'," + parkingRecordsID + ");";
                        else
                            insertVehicleWithState = "insert into vehicle (numberPlate,vehicleTypeID,vehiclepParkState) values " +
                        "('" + lic + "',NULL,'" + state + "');";
                    }
                    else
                    {
                        Log.WriteLog(LogType.process, LogFile.ERROR, "取车无法获得车辆信息");
                        Console.WriteLine("明显异常，取车发现无车辆");
                        return;
                    }

                    List<string> list = new List<string>();
                    list.Add(insertVehicleWithState);
                    if (!remote)
                    {
                        Monitor.Monitor.localDBOper.Insert(list);
                    }
                    else
                    {
                        Monitor.Monitor.remoteDBOper.Insert(list);
                    }
                }
                try
                {
                    reader.Close();
                    reader.Dispose();
                }
                catch { }
            }
        }
        /// <summary>
        /// 流程结束清除终端相关信息
        /// </summary>
        /// <param name="id"></param>
        private static void ClearTerminal(int id)
        {
            TerminalStru tsFromCentral = new TerminalStru
            {
                terminalID = (short)id,
                parkingFee = (short)32767,
            };
            TerminalStru tsFromTerminal = new TerminalStru
            {
                terminalID = (short)id,
                btnStatus = -1,
            };
            Monitor.Monitor.PLC.WriteToPLC(tsFromCentral, PLCDataType.central);
            Monitor.Monitor.PLC.WriteToPLC(tsFromTerminal, PLCDataType.terminal);
        }

        /// <summary>
        /// 停车流程，收到号牌机启动后操作过程
        /// </summary>
        private static void ParkNumSubProcess()
        {
            int numMachineLaunch = Monitor.Monitor.mainBlockInfo.numMachineLaunch;
            if (numMachineLaunch != 0)
            {
                for (int i = 0; i < terminalInfo.Count; i++)
                {
                    //启动指令与终端id匹配
                    if (numMachineLaunch == terminalInfo[i].terminalID)
                    {
                        int numReceivedStatus = 0;//1获得，2终止
                        TerminalStru term = terminalInfo[i];
                        if (term.terminalStatus == (short)1)
                        {
                            string license = Monitor.Monitor.numMachineLinker.GetLicensePlate(numMachineLaunch);
                            //未获得号牌，告知PLC终止，告诉终端提示用户重新操作
                            if (license == "")
                            {
                                MainBlockStru mb = new MainBlockStru
                                {
                                    licenseReceived = (short)2
                                };
                                Monitor.Monitor.PLC.WriteToPLC(mb, PLCDataType.central);
                                TerminalStru ts = new TerminalStru
                                {
                                    terminalID = (short)numMachineLaunch,
                                    paymentStatus = -1,
                                    parkingFee = -1,
                                    userType = -1,
                                    licVerification = (short)2
                                };
                                Monitor.Monitor.PLC.WriteToPLC(ts, PLCDataType.central);
                                Log.WriteLog(LogType.process, LogFile.ERROR, "未获得号牌");
                            }
                            else
                            {
                                //记录或更新当前号牌
                                lock (idLicMap)
                                {
                                    if (idLicMap.ContainsKey(numMachineLaunch))
                                    {
                                        idLicMap[numMachineLaunch] = license;
                                    }
                                    else
                                    {
                                        idLicMap.Add(numMachineLaunch, license);
                                    }
                                }
                                Log.WriteLog(LogType.process, LogFile.ERROR, "号牌" + license + "已记录");

                                TerminalStru ts = new TerminalStru
                                {
                                    terminalID = (short)numMachineLaunch,
                                    paymentStatus = -1,
                                    parkingFee = -1,
                                    userType = -1
                                };
                                //注册用户
                                if (term.btnStatus == (short)2)
                                {
                                    int userID = term.licenseCodeA;
                                    string userLicense = GetLicenseFromTerm(term);
                                    //与云端数据比对
                                    string checkNetSql = "select * from user where userID = 1;";
                                    if (Monitor.Monitor.remoteDBOper.Query(checkNetSql) != null)
                                    {
                                        string userInfoCheckSql = "select * from usercarrelation where userID = '" + userID + "'and numberPlate = '" + userLicense + "';";
                                        MySqlDataReader reader = Monitor.Monitor.remoteDBOper.Query(userInfoCheckSql);
                                        if (reader != null && reader.Read() && reader.HasRows && userID != 0 && userLicense != "")
                                        {
                                            ts.licVerification = 1;//验证成功
                                            Monitor.Monitor.PLC.WriteToPLC(ts, PLCDataType.central);
                                            numReceivedStatus = 1;
                                            Log.WriteLog(LogType.process, LogFile.INFO, "号牌验证成功");
                                            try
                                            {
                                                reader.Close();
                                                reader.Dispose();
                                            }
                                            catch { }
                                        }
                                        else
                                        {
                                            ts.licVerification = 2;//验证失败
                                            Monitor.Monitor.PLC.WriteToPLC(ts, PLCDataType.central);
                                            numReceivedStatus = 2;
                                            Log.WriteLog(LogType.process, LogFile.WARNING, "号牌验证失败");
                                        }
                                    }
                                    else
                                    {
                                        ts.licVerification = 1;//网络异常，跳过验证
                                        Monitor.Monitor.PLC.WriteToPLC(ts, PLCDataType.central);
                                        numReceivedStatus = 1;
                                        Log.WriteLog(LogType.process, LogFile.ERROR, "网络异常，无法验证号牌");
                                    }
                                }
                                //非注册用户
                                else if (term.btnStatus == (short)1)
                                {
                                    numReceivedStatus = 1;
                                    ts.licVerification = 1;
                                    Monitor.Monitor.PLC.WriteToPLC(ts, PLCDataType.central);
                                }
                                //无论是否注册，皆告知PLC，已获取号牌或比对异常、终止流程
                                MainBlockStru mb = new MainBlockStru
                                {
                                    licenseReceived = (short)numReceivedStatus
                                };
                                Monitor.Monitor.PLC.WriteToPLC(mb, PLCDataType.central);
                                //号牌获取结果被清零才跳出
                                while (Monitor.Monitor.mainBlockInfo.numMachineLaunch != 0)
                                {
                                    Thread.Sleep(2000);
                                }
                            }
                        }
                    }
                }
            }
        }
        /// <summary>
        /// 停车流程，收到PLC停车完成信号后操作过程
        /// </summary>
        private static void ParkCompleteSubProcess()
        {
            int processAttrib = Monitor.Monitor.mainBlockInfo.parkingRunning;
            int processCompleted = Monitor.Monitor.mainBlockInfo.processCompleted;
            int currentTerm = Monitor.Monitor.mainBlockInfo.terminalID;
            int parkingSpaceID = 0;
            if (processAttrib == 1 && processCompleted == 1)
            {
                TerminalStru term;
                string license;
                //找到终端号，判断是否注册用户
                for (int i = 0; i < terminalInfo.Count; i++)
                {
                    //拿到号牌
                    if (terminalInfo[i].terminalID == currentTerm && idLicMap.TryGetValue(currentTerm, out license) && license != "")
                    {
                        term = terminalInfo[i];
                        //找到停车位置
                        for (int s = 0; s < Monitor.Monitor.parkingSpaceInfo.Count; s++)
                        {
                            if (Monitor.Monitor.parkingSpaceInfo[i].receiptNum == term.receiptNum)
                            {
                                parkingSpaceID = Monitor.Monitor.parkingSpaceInfo[i].parkingSpace;
                                break;
                            }
                        }
                        //无车位信息则跳出当前循环
                        if (parkingSpaceID == 0) break;
                        UpdateVehicle(license, 0, 0, true, false);
                        UpdateVehicle(license, 0, 0, true, true);
                        //插入停车记录
                        string parkingRecordsSql = "";
                        if (term.licenseCodeA != 0)
                        {
                            parkingRecordsSql = "INSERT INTO parkingrecords (userID, numberPlate,parkingSpaceID,garageID,parkingRecordsState,realParkTime,receiptNum,parkingPrice)" +
                                "values ('" + term.licenseCodeA + "','" + license + "','" + parkingSpaceID + "','" + Monitor.Monitor.garageID + "',3,'" + DateTime.Now.ToLocalTime().ToString("yyyy-MM-dd HH:mm:ss") + "','" + term.receiptNum + "',NULL);";
                        }
                        else
                        {
                            parkingRecordsSql = "INSERT INTO parkingrecords (userID, numberPlate,parkingSpaceID,garageID,parkingRecordsState,realParkTime,receiptNum,parkingPrice)" +
                                "values ('" + 1 + "','" + license + "','" + parkingSpaceID + "','" + Monitor.Monitor.garageID + "',3,'" + DateTime.Now.ToLocalTime().ToString("yyyy-MM-dd HH:mm:ss") + "','" + term.receiptNum + "',NULL);";
                        }
                        List<string> list = new List<string>();
                        list.Add(parkingRecordsSql);
                        Monitor.Monitor.localDBOper.Insert(list);
                        Monitor.Monitor.remoteDBOper.Insert(list);
                        Log.WriteLog(LogType.process, LogFile.INFO, "停车记录已插入");
                        ////注册用户记录插入云端
                        //if (term.btnStatus == 0)
                        //{
                        //Monitor.Monitor.remoteDBOper.Insert(list);
                        //}
                        //查询记录ID号
                        string findRecordSql = "select parkingRecordsID from parkingrecords where receiptNum = " + term.receiptNum + ";";
                        MySqlDataReader reader = Monitor.Monitor.localDBOper.Query(findRecordSql);
                        MySqlDataReader remoteReader = Monitor.Monitor.remoteDBOper.Query(findRecordSql);
                        int parkingRecordsID = 0;
                        int remoteParkingRecordsID = 0;
                        try
                        {
                            if (reader != null && reader.Read())
                            {
                                parkingRecordsID = reader.GetInt32("parkingRecordsID");
                                try
                                {
                                    if (reader != null)
                                    {
                                        reader.Close();
                                        reader.Dispose();
                                    }
                                }
                                catch { }
                            }
                            if (remoteReader != null && remoteReader.Read())
                            {
                                remoteParkingRecordsID = remoteReader.GetInt32("parkingRecordsID");
                                try
                                {
                                    if (remoteReader != null)
                                    {
                                        remoteReader.Close();
                                        remoteReader.Dispose();
                                    }
                                }
                                catch { }
                            }
                        }
                        catch (Exception e) { Log.WriteLog(LogType.process, LogFile.ERROR, "查询停车记录id失败"); ; Console.WriteLine(e.Message); };
                        //更新本地车辆表
                        if (parkingRecordsID != 0)
                        {
                            UpdateVehicle(license, 1, parkingRecordsID, true, false);
                        }
                        if (remoteParkingRecordsID != 0)
                        {
                            UpdateVehicle(license, 1, remoteParkingRecordsID, true, true);
                        }
                        Log.WriteLog(LogType.process, LogFile.INFO, "停车记录表已更新");
                        //更新本地车位
                        UpdateAllParkingSpace();
                        while (Monitor.Monitor.mainBlockInfo.processCompleted != 0)
                        {
                            Thread.Sleep(1000);
                        }
                        //中控清除车牌、凭证号、号牌验证等信息
                        ClearTerminal(term.terminalID);
                    }
                }
            }
        }

        /// <summary>
        /// 停车相关操作
        /// 1.读取到号牌机启动指令，启动号牌机并根据是否注册用户进行操作
        ///     非注册拿到号牌后记录并告知plc
        ///     注册用户，核对号牌与用户关联信息
        /// 2.停车流程结束,写数据库
        /// </summary>
        /// 
        private static void ParkProcess()
        {
            Task.Factory.StartNew(() =>
            {
                while (!isClosing)
                {
                    ParkNumSubProcess();
                    Thread.Sleep(Monitor.Monitor.plcRefreshInterval);
                }
            });

            Task.Factory.StartNew(() =>
            {
                while (!isClosing)
                {
                    ParkCompleteSubProcess();
                    Thread.Sleep(Monitor.Monitor.plcRefreshInterval);
                }
            });
        }

        /// <summary>
        /// 根据凭证号查询停车记录
        /// </summary>
        /// <param name="receipt"></param>
        /// <param name="recordID"></param>
        /// <param name="userID"></param>
        /// <param name="numberPlate"></param>
        /// <param name="realParkTime"></param>
        private static bool FindLocalParkingRecord(int receipt, out int recordID, out int userID, out string numberPlate, out string realParkTime)
        {
            recordID = 0;
            userID = 0;
            numberPlate = "";
            realParkTime = "";
            string parkRecordsSql = "select parkingRecordsID,userID,numberPlate,realParkTime from parkingrecords where receiptNum = " + receipt + ";";
            try
            {
                MySqlDataReader reader = Monitor.Monitor.localDBOper.Query(parkRecordsSql);
                if (reader != null && reader.Read())
                {
                    object[] receiver = new object[4];
                    reader.GetValues(receiver);
                    recordID = (int)receiver[0];
                    userID = (int)receiver[1];
                    numberPlate = (string)receiver[2];
                    realParkTime = (string)receiver[3];
                }
                if (reader != null)
                {
                    reader.Close();
                    reader.Dispose();
                }

            }
            catch (Exception e) { Log.WriteLog(LogType.process, LogFile.ERROR, "根据凭证号查询停车记录失败"); Console.WriteLine(e.Message); return false; }
            Log.WriteLog(LogType.process, LogFile.INFO, "根据凭证号查询停车记录成功");
            return true;
        }

        /// <summary>
        /// 预约与停车费用计算
        /// </summary>
        /// <param name="scheme"></param>
        /// <param name="parkTime"></param>
        /// <param name="orderTimeLength"></param>
        /// <returns></returns>
        private static int FeeCalc(PaymentScheme scheme, DateTime parkTime, TimeSpan orderTimeLength)
        {
            try
            {
                int orderFee = scheme.bookCharge * (int)orderTimeLength.TotalHours;
                int parkFee = 0;
                int hours = (int)(DateTime.Now - parkTime).TotalHours;
                switch (scheme.schemeType)
                {
                    //按时计费
                    case 1:
                        if (hours > scheme.firstChargeTime)
                        {
                            parkFee = Math.Min(scheme.firstCharge + scheme.intervalCharge * hours / scheme.chargeInterval, scheme.upperBound);
                        }
                        else
                        {
                            parkFee = scheme.firstCharge;
                        }
                        break;
                    //按次计费
                    case 2:
                        int overnightCount = hours / 24;
                        parkFee = scheme.eachCharge + overnightCount * scheme.overnightCharge;
                        break;
                    //按时间段计费
                    case 3:
                        TimeSpan currentTimeOfDay = DateTime.Now.TimeOfDay;
                        TimeSpan parkTimeOfDay = parkTime.TimeOfDay;
                        TimeSpan startTimeOfDay = DateTime.Parse(scheme.startChargeTime).TimeOfDay;
                        TimeSpan endTimeOfDay = DateTime.Parse(scheme.endChargeTime).TimeOfDay;
                        double countingHoursOfDay = endTimeOfDay.TotalHours - startTimeOfDay.TotalHours;
                        int days = (int)((DateTime.Now - parkTime).TotalHours - currentTimeOfDay.TotalHours + parkTimeOfDay.TotalHours);
                        int previousOffset = (int)(-(Math.Max(0, parkTimeOfDay.TotalHours - startTimeOfDay.TotalHours)));
                        int currentOffset = (int)Math.Min((currentTimeOfDay.TotalHours - startTimeOfDay.TotalHours), countingHoursOfDay);
                        parkFee = (days * (int)countingHoursOfDay + previousOffset + currentOffset) * scheme.chargeStandard;
                        break;
                }
                Log.WriteLog(LogType.process, LogFile.INFO, "停车费用" + parkFee);
                return parkFee;
            }
            catch (Exception e) { Console.WriteLine("费用计算异常"); return -1; }
        }

        /// <summary>
        /// 取车计费子操作
        /// </summary>
        private static void FetchFeeCalcSubProcess()
        {
            int fetchState = Monitor.Monitor.mainBlockInfo.fetchingRunning;
            int receiptNum = 0;
            int termIndex = -1;
            TerminalStru ts = new TerminalStru();
            for (int i = 0; i < terminalInfo.Count; i++)
            {
                if (terminalInfo[i].terminalID == Monitor.Monitor.mainBlockInfo.terminalID)
                {
                    ts = terminalInfo[i];
                    termIndex = ts.terminalID;
                    receiptNum = ts.receiptNum;
                    break;
                }
            }
            //取车状态、凭证号不为空，查询数据库计费
            if (termIndex != -1 && termUsedMap.Count >= termIndex && termUsedMap.TryGetValue(termIndex, out bool value) && !value && fetchState == 1 && receiptNum != 0)
            {
                termUsedMap[termIndex] = true;
                Console.WriteLine("终端编号" + termIndex);
                Task.Factory.StartNew(() =>
                {
                    int parkingRecordsID = 0;
                    int remoteParkingRecordsID = 0;
                    int userID = 0;
                    string numberPlate = "";
                    string realParkTime = "";
                    //1.根据凭证号查询停车记录
                    if (!FindLocalParkingRecord(receiptNum, out parkingRecordsID, out userID, out numberPlate, out realParkTime))
                    {
                        return;
                    }
                    string remoteParkRecordsSql = "select parkingRecordsID from parkingrecords where receiptNum = " + receiptNum + ";";
                    try
                    {
                        MySqlDataReader reader = Monitor.Monitor.remoteDBOper.Query(remoteParkRecordsSql);
                        if (reader != null && reader.Read())
                        {
                            object[] receiver = new object[1];
                            reader.GetValues(receiver);
                            remoteParkingRecordsID = (int)receiver[0];
                        }
                        if (reader != null)
                        {
                            reader.Close();
                            reader.Dispose();
                        }
                    }
                    catch (Exception e) { Console.WriteLine(e.Message); }
                    //本地存在号牌，后续操作
                    if (numberPlate != "")
                    {
                        //2.根据号牌查询车辆月卡信息与预约记录
                        int orderRecordsID = 0;
                        int monthCardType = -1;
                        string monthCardTime = "";
                        TimeSpan monthCardTimeLength = new TimeSpan(0);
                        TimeSpan orderTimeLength = new TimeSpan(0);
                        //本地VIP信息
                        string vipInfoSql = "select orderRecordsID,monthCardType,monthCardTime from vehicle where numberPlate = '" + numberPlate + "';";
                        try
                        {
                            MySqlDataReader reader = Monitor.Monitor.localDBOper.Query(vipInfoSql);
                            if (reader != null && reader.Read())
                            {
                                object[] receiver = new object[3];
                                reader.GetValues(receiver);
                                Console.WriteLine(receiver[2].GetType());
                                if (!receiver[0].GetType().Equals(typeof(DBNull)))
                                {
                                    orderRecordsID = (int)receiver[0];
                                }
                                if (!receiver[1].GetType().Equals(typeof(DBNull)))
                                {
                                    monthCardType = (int)(UInt32)receiver[1];
                                }
                                if (!receiver[2].GetType().Equals(typeof(DBNull)))
                                {
                                    monthCardTime = (string)receiver[2];
                                }
                                //orderRecordsID = (Int32)receiver[0];
                                //monthCardType = (Int32)receiver[1];
                                //monthCardTime = (string)receiver[2];
                                monthCardTimeLength = DateTime.Parse(monthCardTime) - DateTime.Now;
                                if (monthCardTimeLength.TotalHours <= 0)
                                {
                                    monthCardType = 0;
                                }
                                Log.WriteLog(LogType.process, LogFile.INFO, "已获取本地预约与月卡信息");
                            }
                            if (reader != null)
                            {
                                reader.Close();
                                reader.Dispose();
                            }
                        }
                        catch (Exception e) { Console.WriteLine(e.Message); }
                        //云端VIP信息
                        try
                        {
                            MySqlDataReader reader = Monitor.Monitor.remoteDBOper.Query(vipInfoSql);
                            if (reader != null && reader.Read())
                            {
                                object[] receiver = new object[3];
                                reader.GetValues(receiver);
                                int cardType = (int)(UInt32)receiver[1];
                                string CardTime = (string)receiver[2];
                                TimeSpan t = DateTime.Parse(CardTime) - DateTime.Now;
                                //云端
                                if (t.TotalHours > 0 && cardType > monthCardType)
                                {
                                    monthCardType = cardType;
                                    monthCardTimeLength = t;
                                }
                                Log.WriteLog(LogType.process, LogFile.INFO, "已获取云端预约与月卡信息");
                            }
                            if (reader != null)
                            {
                                reader.Close();
                                reader.Dispose();
                            }
                        }
                        catch (Exception e) { Console.WriteLine(e.Message); }

                        //有预约记录，判断记录有效性，有效则获取预约时长
                        if (orderRecordsID != 0)
                        {
                            //修改orderTimeLength
                        }

                        //3.获取停车时刻，根据用户类型计费发送给PLC，暂认为无预约
                        DateTime parkTime = DateTime.Parse(realParkTime);
                        DateTime currentTime = DateTime.Now;
                        int fee = 32767;
                        if (PaymentScheme.ins != null && monthCardType != -1)
                        {
                            if (monthCardTimeLength.TotalHours > 0)
                            {
                                fee = 0;
                            }
                            else
                            {
                                fee = FeeCalc(PaymentScheme.ins, parkTime, orderTimeLength);
                            }

                            if (Monitor.Monitor.PLC != null)
                            {
                                TerminalStru FeeMsg = new TerminalStru
                                {
                                    terminalID = (short)termIndex,
                                    paymentStatus = (short)-1,
                                    licVerification = (short)-1,
                                    parkingFee = (short)fee,
                                    userType = (short)(monthCardType + 1)
                                };
                                Console.WriteLine(FeeMsg);
                                Monitor.Monitor.PLC.WriteToPLC(FeeMsg, PLCDataType.central);
                                Log.WriteLog(LogType.process, LogFile.INFO, "停车费用已发送至PLC");
                            }
                        }
                        //4.等待终端获得收费完成信号且将凭证号清除后，清除收费完成信号并将信息写入数据库
                        while (!isClosing && termIndex != -1)
                        {
                            if (terminalInfo[termIndex-1].receiptNum == 0)
                            {
                                Log.WriteLog(LogType.process, LogFile.INFO, "检测到凭证号已被清除");
                                TerminalStru fetchReset = new TerminalStru
                                {
                                    terminalID = (short)termIndex,
                                    paymentStatus = (short)0,
                                    licVerification = (short)0,
                                    parkingFee = (short)32767,
                                    userType = (short)0
                                };
                                Monitor.Monitor.PLC.WriteToPLC(fetchReset, PLCDataType.central);
                                //更新停车记录
                                string updateParkingRecordsSql = "update parkingrecords set parkingRecordsState = 6,realGetTime = '"
                        + currentTime.ToString("yyyy-MM-dd HH:mm:ss") + "',parkingPrice = " + fee + " where receiptNum = '" + receiptNum + "';";
                                List<string> list = new List<string>();
                                list.Add(updateParkingRecordsSql);
                                Monitor.Monitor.localDBOper.UpdateTransaction(list);
                                Monitor.Monitor.remoteDBOper.UpdateTransaction(list);
                                //更新车辆状态
                                UpdateVehicle(numberPlate, 0, parkingRecordsID, false, false);
                                UpdateVehicle(numberPlate, 0, remoteParkingRecordsID, false, true);
                                break;
                            }
                            Thread.Sleep(1000);
                        }
                    }
                    termUsedMap[termIndex] = false;
                });
            }
        }

        /// <summary>
        /// 取车相关操作
        /// 
        /// </summary>
        private static void FetchProcess()
        {
            Task.Factory.StartNew(() =>
            {
                while (!isClosing)
                {
                    FetchFeeCalcSubProcess();
                    Thread.Sleep(Monitor.Monitor.plcRefreshInterval);
                }
            });

        }

        public static void Start()
        {
            ParkProcess();
            FetchProcess();
        }

        public static void Stop()
        {
            isClosing = true;
        }
    }
    public class PaymentScheme
    {
        public static PaymentScheme ins;
        public int paymentSchemeID;
        /// <summary>
        /// 策略类型。1按时，2按次，3按时间段
        /// </summary>
        public int schemeType;
        /// <summary>
        /// 免费时间
        /// </summary>
        public int freeTime;
        //******************** 按时收费 *******************
        /// <summary>
        /// 首段收费时间
        /// </summary>
        public int firstChargeTime;
        /// <summary>
        /// 首段费用
        /// </summary>
        public int firstCharge;
        /// <summary>
        /// 间隔收费时间
        /// </summary>
        public int chargeInterval;
        /// <summary>
        /// 间隔收费单价
        /// </summary>
        public int intervalCharge;
        /// <summary>
        /// 每日停车收费上限
        /// </summary>
        public int upperBound;
        //******************** 按次收费 *******************
        /// <summary>
        /// 按次收费，每次费用
        /// </summary>
        public int eachCharge;
        /// <summary>
        /// 按次收费，加收过夜费
        /// </summary>
        public int overnightCharge;
        //******************** 按时间段收费 *******************
        /// <summary>
        /// 按时间段收费，起始时间
        /// </summary>
        public string startChargeTime;
        /// <summary>
        /// 按时间段收费，终止时间
        /// </summary>
        public string endChargeTime;
        /// <summary>
        /// 按时间段收费，每小时费用
        /// </summary>
        public int chargeStandard;
        //******************** VIP卡 *******************
        /// <summary>
        /// 月卡办理价格
        /// </summary>
        public int monthCardCharge;
        /// <summary>
        /// 季卡办理价格
        /// </summary>
        public int seasonCardCharge;
        /// <summary>
        /// 半年卡办理价格
        /// </summary>
        public int halfYearCardCharge;
        /// <summary>
        /// 年卡办理价格
        /// </summary>
        public int yearCardCharge;
        /// <summary>
        /// 预约小时费用
        /// </summary>
        public int bookCharge;

        public PaymentScheme()
        {
            this.paymentSchemeID = 0;
            this.schemeType = 0;
            this.freeTime = 0;
            this.firstChargeTime = 0;
            this.firstCharge = 0;
            this.chargeInterval = 0;
            this.upperBound = 0;
            this.eachCharge = 0;
            this.overnightCharge = 0;
            this.startChargeTime = "";
            this.endChargeTime = "";
            this.chargeStandard = 0;
            this.monthCardCharge = 0;
            this.seasonCardCharge = 0;
            this.halfYearCardCharge = 0;
            this.yearCardCharge = 0;
            this.bookCharge = 0;
        }
        public PaymentScheme(int pID, int type, int freeTime, int firstChargeTime, int firstCharge, int chargeInterval, int intervalCharge,
            int upperBound, int eachCharge, int overnightCharge, string startChargeTime, string endChargeTime, int chargeStandard,
            int monthCardCharge, int seasonCardCharge, int halfYearCardCharge, int yearCardCharge, int bookCharge)
        {
            ins = new PaymentScheme();
            ins.paymentSchemeID = pID;
            ins.schemeType = type;
            ins.freeTime = freeTime;
            ins.firstChargeTime = firstChargeTime;
            ins.firstCharge = firstCharge;
            ins.chargeInterval = chargeInterval;
            ins.intervalCharge = intervalCharge;
            ins.upperBound = upperBound;
            ins.eachCharge = eachCharge;
            ins.overnightCharge = overnightCharge;
            ins.startChargeTime = startChargeTime;
            ins.endChargeTime = endChargeTime;
            ins.chargeStandard = chargeStandard;
            ins.monthCardCharge = monthCardCharge;
            ins.seasonCardCharge = seasonCardCharge;
            ins.halfYearCardCharge = halfYearCardCharge;
            ins.yearCardCharge = yearCardCharge;
            ins.bookCharge = bookCharge;
        }
        public static PaymentScheme GetCurrentPaymentScheme(int index)
        {
            string currentPaymentSchemeQuerySql = "select * from paymentScheme where paymentSchemeID = " + index + ";";
            object[] paramArray = null;
            PaymentScheme scheme = null;
            try
            {
                MySqlDataReader reader = Monitor.Monitor.localDBOper.Query(currentPaymentSchemeQuerySql);
                if (reader != null && reader.Read())
                {
                    scheme = new PaymentScheme();
                    paramArray = new object[reader.FieldCount];
                    reader.GetValues(paramArray);
                    scheme.paymentSchemeID = index;
                    scheme.schemeType = (int)((UInt32)paramArray[1]);
                    scheme.freeTime = (int)paramArray[2];
                    scheme.firstChargeTime = (int)paramArray[3];
                    scheme.firstCharge = (int)paramArray[4];
                    scheme.chargeInterval = (int)paramArray[5];
                    scheme.intervalCharge = (int)paramArray[6];
                    scheme.upperBound = (int)paramArray[7];
                    scheme.eachCharge = (int)paramArray[8];
                    scheme.overnightCharge = (int)paramArray[9];
                    scheme.startChargeTime = (string)paramArray[10];
                    scheme.endChargeTime = (string)paramArray[11];
                    scheme.chargeStandard = (int)paramArray[12];
                    scheme.monthCardCharge = (int)paramArray[13];
                    scheme.seasonCardCharge = (int)paramArray[14];
                    scheme.halfYearCardCharge = (int)paramArray[15];
                    scheme.yearCardCharge = (int)paramArray[16];
                    scheme.bookCharge = (int)paramArray[17];
                }
                if (reader != null)
                {
                    reader.Close();
                    reader.Dispose();
                }
            }
            catch (Exception e) { Console.WriteLine("读取本地计费策略，" + e.Message); }
            return scheme;
        }
    }
}