DeviceCenter/model/AcsDevice.cs

using DeviceCenter.utils;
using log4net;
using System;
using System.Collections.Generic;
using System.Diagnostics;
using System.IO;
using System.Runtime.InteropServices;
using System.Threading;
using System.Threading.Tasks;
using System.Windows;
using System.Windows.Interop;

namespace DeviceCenter
{
    public class AcsDevice : Device
    {
        public static readonly ILog log = LogManager.GetLogger("DeviceCenter");

        public int _userId { get; set; }
        public AcsDevice()
        {
            _userId = -1;
            type = DeviceType.ACS;
        }

        public int userId
        {
            get
            {
                return _userId;
            }
        }

        //public override void Init()
        //{
        //    CHCNetSDK.NET_DVR_USER_LOGIN_INFO struLoginInfo = new CHCNetSDK.NET_DVR_USER_LOGIN_INFO();
        //    CHCNetSDK.NET_DVR_DEVICEINFO_V40 struDeviceInfoV40 = new CHCNetSDK.NET_DVR_DEVICEINFO_V40();

        //    struLoginInfo.bUseAsynLogin = false;
        //    struLoginInfo.sDeviceAddress = ip;
        //    struLoginInfo.sUserName = username;
        //    struLoginInfo.sPassword = password;
        //    struLoginInfo.wPort = (ushort)port;

        //    struDeviceInfoV40.struDeviceV30.sSerialNumber = new byte[CHCNetSDK.SERIALNO_LEN];

        //    int m_userId = CHCNetSDK.NET_DVR_Login_V40(ref struLoginInfo, ref struDeviceInfoV40);
        //    if (m_userId < 0)
        //    {
        //        status = DeviceStatus.FAIL;
        //        uint nErr = CHCNetSDK.NET_DVR_GetLastError();
        //        if (nErr == CHCNetSDK.NET_DVR_PASSWORD_ERROR)
        //        {
        //            message = "user name or password error!";
        //            if (1 == struDeviceInfoV40.bySupportLock)
        //            {
        //                string strTemp1 = string.Format(" Left {0} try opportunity", struDeviceInfoV40.byRetryLoginTime);
        //                message += strTemp1;
        //            }
        //        }
        //        else if (nErr == CHCNetSDK.NET_DVR_USER_LOCKED)
        //        {
        //            if (1 == struDeviceInfoV40.bySupportLock)
        //            {
        //                string strTemp1 = string.Format("user is locked, the remaining lock time is {0}", struDeviceInfoV40.dwSurplusLockTime);
        //                message = strTemp1;
        //            }
        //        }
        //        else
        //        {
        //            message = "net error or dvr is busy!";
        //        }
        //        return;
        //    }
        //    _userId = m_userId;

        //    CHCNetSDK.NET_DVR_SETUPALARM_PARAM struSetupAlarmParam = new CHCNetSDK.NET_DVR_SETUPALARM_PARAM();
        //    struSetupAlarmParam.dwSize = (uint)Marshal.SizeOf(struSetupAlarmParam);
        //    struSetupAlarmParam.byLevel = 1;
        //    struSetupAlarmParam.byAlarmInfoType = 1;
        //    struSetupAlarmParam.byDeployType = 1;
        //    int handle = CHCNetSDK.NET_DVR_SetupAlarmChan_V41(m_userId, ref struSetupAlarmParam);
        //    if (-1 == handle)
        //    {
        //        message = "Setup alarm chan failed";
        //        status = DeviceStatus.FAIL;
        //    }
        //    else
        //    {
        //        message = "";
        //        status = DeviceStatus.CONNECTED;
        //    }
        //}

        public override async void Init()
        {
            await Task.Run(() =>
            {
                status = DeviceStatus.CONNECTING;
                CHCNetSDK.NET_DVR_USER_LOGIN_INFO struLoginInfo = new CHCNetSDK.NET_DVR_USER_LOGIN_INFO();
                CHCNetSDK.NET_DVR_DEVICEINFO_V40 struDeviceInfoV40 = new CHCNetSDK.NET_DVR_DEVICEINFO_V40();

                struLoginInfo.bUseAsynLogin = false;
                struLoginInfo.sDeviceAddress = ip;
                struLoginInfo.sUserName = username;
                struLoginInfo.sPassword = password;
                struLoginInfo.wPort = (ushort)port;

                struDeviceInfoV40.struDeviceV30.sSerialNumber = new byte[CHCNetSDK.SERIALNO_LEN];

                int m_userId = CHCNetSDK.NET_DVR_Login_V40(ref struLoginInfo, ref struDeviceInfoV40);
                if (m_userId < 0)
                {
                    status = DeviceStatus.FAIL;
                    uint nErr = CHCNetSDK.NET_DVR_GetLastError();
                    if (nErr == CHCNetSDK.NET_DVR_PASSWORD_ERROR)
                    {
                        message = "user name or password error!";
                        if (1 == struDeviceInfoV40.bySupportLock)
                        {
                            string strTemp1 = string.Format(" Left {0} try opportunity", struDeviceInfoV40.byRetryLoginTime);
                            message += strTemp1;
                        }
                    }
                    else if (nErr == CHCNetSDK.NET_DVR_USER_LOCKED)
                    {
                        if (1 == struDeviceInfoV40.bySupportLock)
                        {
                            string strTemp1 = string.Format("user is locked, the remaining lock time is {0}", struDeviceInfoV40.dwSurplusLockTime);
                            message = strTemp1;
                        }
                    }
                    else
                    {
                        message = "net error or dvr is busy!";
                    }
                    return;
                }
                _userId = m_userId;

                CHCNetSDK.NET_DVR_SETUPALARM_PARAM struSetupAlarmParam = new CHCNetSDK.NET_DVR_SETUPALARM_PARAM();
                struSetupAlarmParam.dwSize = (uint)Marshal.SizeOf(struSetupAlarmParam);
                struSetupAlarmParam.byLevel = 1;
                struSetupAlarmParam.byAlarmInfoType = 1;
                struSetupAlarmParam.byDeployType = 1;
                int handle = CHCNetSDK.NET_DVR_SetupAlarmChan_V41(m_userId, ref struSetupAlarmParam);
                if (-1 == handle)
                {
                    message = "Setup alarm chan failed";
                    status = DeviceStatus.FAIL;
                }
                else
                {
                    message = "";
                    status = DeviceStatus.CONNECTED;
                    log.Info("asc device " + ip + " connected, userid: " + userId);
                }
            });
        }

        public override void dispose()
        {
            status = DeviceStatus.IDLE;
        }

        public void onAlarm(ref CHCNetSDK.NET_DVR_ALARMER pAlarmer, IntPtr pAlarmInfo, uint dwBufLen, IntPtr pUser)
        {
            CHCNetSDK.NET_DVR_ACS_ALARM_INFO struAcsAlarmInfo = new CHCNetSDK.NET_DVR_ACS_ALARM_INFO();
            struAcsAlarmInfo = (CHCNetSDK.NET_DVR_ACS_ALARM_INFO)Marshal.PtrToStructure(pAlarmInfo, typeof(CHCNetSDK.NET_DVR_ACS_ALARM_INFO));
            CHCNetSDK.NET_DVR_LOG_V30 struFileInfo = new CHCNetSDK.NET_DVR_LOG_V30();
            struFileInfo.dwMajorType = struAcsAlarmInfo.dwMajor;
            struFileInfo.dwMinorType = struAcsAlarmInfo.dwMinor;
            char[] csTmp = new char[256];

            if (CHCNetSDK.MAJOR_ALARM == struFileInfo.dwMajorType)
            {
                TypeMap.AlarmMinorTypeMap(struFileInfo, csTmp);
            }
            else if (CHCNetSDK.MAJOR_OPERATION == struFileInfo.dwMajorType)
            {
                TypeMap.OperationMinorTypeMap(struFileInfo, csTmp);
            }
            else if (CHCNetSDK.MAJOR_EXCEPTION == struFileInfo.dwMajorType)
            {
                TypeMap.ExceptionMinorTypeMap(struFileInfo, csTmp);
            }
            else if (CHCNetSDK.MAJOR_EVENT == struFileInfo.dwMajorType)
            {
                TypeMap.EventMinorTypeMap(struFileInfo, csTmp);
            }
            string eventType = new String(csTmp).TrimEnd('\0');
            string time = $"{struAcsAlarmInfo.struTime.dwYear:D4}-{struAcsAlarmInfo.struTime.dwMonth:D2}-{struAcsAlarmInfo.struTime.dwDay:D2} {struAcsAlarmInfo.struTime.dwHour:D2}:{struAcsAlarmInfo.struTime.dwMinute:D2}:{struAcsAlarmInfo.struTime.dwSecond:D2}";
            string cardNo = null;
            string employNo = null;
            string doorNo = null;
            string cardType = null;
            string readerNo = null;
            string accessChannel = null;
            string path = null;
            if (struAcsAlarmInfo.struAcsEventInfo.byCardNo[0] != 0)
            {
                cardNo = System.Text.Encoding.UTF8.GetString(struAcsAlarmInfo.struAcsEventInfo.byCardNo).TrimEnd('\0');
            }
            if (struAcsAlarmInfo.struAcsEventInfo.dwCaseSensorNo != 0)
            {
                employNo = struAcsAlarmInfo.struAcsEventInfo.dwEmployeeNo.ToString();
            }
            if (struAcsAlarmInfo.struAcsEventInfo.dwDoorNo != 0)
            {
                doorNo = struAcsAlarmInfo.struAcsEventInfo.dwDoorNo.ToString();
            }
            String[] szCardType = { "normal card", "disabled card", "blacklist card", "night watch card", "stress card", "super card", "guest card" };
            byte byCardType = struAcsAlarmInfo.struAcsEventInfo.byCardType;
            if (byCardType != 0 && byCardType <= szCardType.Length)
            {
                cardType = szCardType[byCardType - 1];
            }
            if (struAcsAlarmInfo.struAcsEventInfo.dwCardReaderNo != 0)
            {
                readerNo = struAcsAlarmInfo.struAcsEventInfo.dwCardReaderNo.ToString();
            }
            if (struAcsAlarmInfo.struAcsEventInfo.wAccessChannel >= 0)
            {
                accessChannel = struAcsAlarmInfo.struAcsEventInfo.wAccessChannel.ToString();
            }
            //其它消息先不罗列了......
            if (struAcsAlarmInfo.dwPicDataLen > 0)
            {
                Random rand = new Random(unchecked((int)DateTime.Now.Ticks));
                path = string.Format(@"{0}Picture/acs_{1}_{2}.bmp", AppDomain.CurrentDomain.BaseDirectory, DateTime.Now.ToString("yyyy-MM-dd_HH-mm-ss"), rand.Next());
                using (FileStream fs = new FileStream(path, FileMode.Create))
                {
                    int iLen = (int)struAcsAlarmInfo.dwPicDataLen;
                    byte[] by = new byte[iLen];
                    Marshal.Copy(struAcsAlarmInfo.pPicData, by, 0, iLen);
                    fs.Write(by, 0, iLen);
                    fs.Close();
                }
            }
            log.Info($"{ip}[{userId}] {eventType}  {time}  doorNo:{doorNo}  channel:{accessChannel}  readerNo:{readerNo}  cardNo:{cardNo}  cardType:{cardType}  employNo:{employNo}  path:{path}");

            try
            {
                if ("MINOR_FACE_VERIFY_PASS".Equals(eventType) || "MINOR_FACE_VERIFY_FAIL".Equals(eventType))
                {
                    Dictionary<string, string> data = new Dictionary<string, string>();
                    if (!string.IsNullOrEmpty(cardNo))
                    {
                        try
                        {
                            employNo = getEmployNo(cardNo);
                        }
                        catch (Exception ex)
                        {
                            log.Error("get employNo error", ex);
                        }

                    }
                    data.Add("pass", "MINOR_FACE_VERIFY_PASS".Equals(eventType).ToString());
                    data.Add("cardNo", cardNo);
                    data.Add("employNo", employNo);
                    data.Add("doorNo", doorNo);
                    data.Add("readerNo", readerNo);
                    data.Add("channel", accessChannel);
                    data.Add("ip", ip);
                    data.Add("direction", direction.ToString());
                    data.Add("time", time);
                    if (path != null)
                    {
                        data.Add("pic", Convert.ToBase64String(file_get_byte_contents(path)));
                    }
                    http.post<string>("staffAccess/access", data);

                }
            }
            catch (Exception e)
            {
                log.Error("上传门禁事件出错", e);
            }
        }

        static byte[] file_get_byte_contents(string fileName)
        {
            byte[] sContents;
            if (fileName.ToLower().IndexOf("http:") > -1)
            {
                // URL 
                System.Net.WebClient wc = new System.Net.WebClient();
                sContents = wc.DownloadData(fileName);
            }
            else
            {
                // Get file size
                FileInfo fi = new FileInfo(fileName);

                // Disk
                FileStream fs = new FileStream(fileName, FileMode.Open, FileAccess.Read);
                BinaryReader br = new BinaryReader(fs);
                sContents = br.ReadBytes((int)fi.Length);
                br.Close();
                fs.Close();
            }

            return sContents;
        }

        public void getEvent(DateTime start, DateTime end)
        {
            CHCNetSDK.NET_DVR_ACS_EVENT_COND struCond = new CHCNetSDK.NET_DVR_ACS_EVENT_COND();
            struCond.Init();
            struCond.dwSize = (uint)Marshal.SizeOf(struCond);

            struCond.dwMajor = CHCNetSDK.MAJOR_EVENT;

            struCond.dwMinor = CHCNetSDK.MINOR_FACE_VERIFY_PASS;

            DateTime date = DateTime.Now.AddDays(-1);
            struCond.struStartTime.dwYear = start.Year;
            struCond.struStartTime.dwMonth = start.Month;
            struCond.struStartTime.dwDay = start.Day;
            struCond.struStartTime.dwHour = start.Hour;
            struCond.struStartTime.dwMinute = start.Minute;
            struCond.struStartTime.dwSecond = start.Second;

            struCond.struEndTime.dwYear = end.Year;
            struCond.struEndTime.dwMonth = end.Month;
            struCond.struEndTime.dwDay = end.Day;
            struCond.struEndTime.dwHour = end.Hour;
            struCond.struEndTime.dwMinute = end.Minute;
            struCond.struEndTime.dwSecond = end.Second;

            struCond.byPicEnable = 0;
            struCond.szMonitorID = "";
            struCond.wInductiveEventType = 65535;

            //if (!StrToByteArray(ref struCond.byCardNo, textBoxCardNo.Text))
            //{
            //    return;
            //}

            //if (!StrToByteArray(ref struCond.byName, textBoxName.Text))
            //{
            //    return;
            //}
            //struCond.dwBeginSerialNo = 0;
            //struCond.dwEndSerialNo = 0;

            uint dwSize = struCond.dwSize;
            IntPtr ptrCond = Marshal.AllocHGlobal((int)dwSize);
            Marshal.StructureToPtr(struCond, ptrCond, false);
            int m_lGetAcsEventHandle = CHCNetSDK.NET_DVR_StartRemoteConfig(userId, CHCNetSDK.NET_DVR_GET_ACS_EVENT, ptrCond, (int)dwSize, null, IntPtr.Zero);
            if (-1 == m_lGetAcsEventHandle)
            {
                Marshal.FreeHGlobal(ptrCond);
                log.Error($"NET_DVR_StartRemoteConfig FAIL, ERROR CODE {CHCNetSDK.NET_DVR_GetLastError()}");
                return;
            }

            Thread m_pDisplayListThread = new Thread(() =>
            {
                List<AcsEvent> events = ProcessEvent(m_lGetAcsEventHandle);
                EventUploadReq req = new EventUploadReq(ip, start.ToString("yyyy-MM-dd HH:mm:ss"), end.ToString("yyyy-MM-dd HH:mm:ss"), events);
                http.postJson<string>("staffAccess/uploadEvent", req);
            });
            m_pDisplayListThread.Start();
            Marshal.FreeHGlobal(ptrCond);
        }

        public List<AcsEvent> ProcessEvent(int m_lGetAcsEventHandle)
        {
            int dwStatus = 0;
            Boolean Flag = true;
            CHCNetSDK.NET_DVR_ACS_EVENT_CFG struCFG = new CHCNetSDK.NET_DVR_ACS_EVENT_CFG();
            struCFG.dwSize = (uint)Marshal.SizeOf(struCFG);
            int dwOutBuffSize = (int)struCFG.dwSize;
            struCFG.init();
            List<AcsEvent> eventList = new List<AcsEvent>();
            while (Flag)
            {
                dwStatus = CHCNetSDK.NET_DVR_GetNextRemoteConfig(m_lGetAcsEventHandle, ref struCFG, dwOutBuffSize);
                switch (dwStatus)
                {
                    case CHCNetSDK.NET_SDK_GET_NEXT_STATUS_SUCCESS://成功读取到数据，处理完本次数据后需调用next
                        int employNo = (int)struCFG.struAcsEventInfo.dwEmployeeNo;
                        string cardNo = System.Text.Encoding.UTF8.GetString(struCFG.struAcsEventInfo.byCardNo).TrimEnd('\0');
                        string time = $"{struCFG.struTime.dwYear:D4}-{struCFG.struTime.dwMonth:D2}-{struCFG.struTime.dwDay:D2} {struCFG.struTime.dwHour:D2}:{struCFG.struTime.dwMinute:D2}:{struCFG.struTime.dwSecond:D2}";
                        log.Info($"receive acs event employNo:{employNo} cardNo:{cardNo} time:{time}");
                        eventList.Add(new AcsEvent(ip, direction.ToString(), employNo.ToString(), cardNo, time));
                        break;
                    case CHCNetSDK.NET_SDK_GET_NEXT_STATUS_NEED_WAIT:
                        Thread.Sleep(200);
                        break;
                    case CHCNetSDK.NET_SDK_GET_NEXT_STATUS_FAILED:
                        CHCNetSDK.NET_DVR_StopRemoteConfig(m_lGetAcsEventHandle);
                        log.Error($"NET_SDK_GET_NEXT_STATUS_FAILED {CHCNetSDK.NET_DVR_GetLastError()}");
                        Flag = false;
                        break;
                    case CHCNetSDK.NET_SDK_GET_NEXT_STATUS_FINISH:
                        CHCNetSDK.NET_DVR_StopRemoteConfig(m_lGetAcsEventHandle);
                        Flag = false;
                        break;
                    default:
                        log.Info($"NET_SDK_GET_NEXT_STATUS_UNKOWN {CHCNetSDK.NET_DVR_GetLastError()}");
                        Flag = false;
                        CHCNetSDK.NET_DVR_StopRemoteConfig(m_lGetAcsEventHandle);
                        break;
                }
            }

            return eventList;
        }

        private string getEmployNo(string cardNo)
        {
            CHCNetSDK.NET_DVR_CARD_COND struCond = new CHCNetSDK.NET_DVR_CARD_COND();
            struCond.Init();
            struCond.dwSize = (uint)Marshal.SizeOf(struCond);
            struCond.dwCardNum = 1;
            IntPtr ptrStruCond = Marshal.AllocHGlobal((int)struCond.dwSize);
            Marshal.StructureToPtr(struCond, ptrStruCond, false);

            CHCNetSDK.NET_DVR_CARD_RECORD struData = new CHCNetSDK.NET_DVR_CARD_RECORD();
            struData.Init();
            struData.dwSize = (uint)Marshal.SizeOf(struData);
            byte[] byTempCardNo = new byte[CHCNetSDK.ACS_CARD_NO_LEN];
            byTempCardNo = System.Text.Encoding.UTF8.GetBytes(cardNo);
            for (int i = 0; i < byTempCardNo.Length; i++)
            {
                struData.byCardNo[i] = byTempCardNo[i];
            }
            IntPtr ptrStruData = Marshal.AllocHGlobal((int)struData.dwSize);
            Marshal.StructureToPtr(struData, ptrStruData, false);

            CHCNetSDK.NET_DVR_CARD_SEND_DATA struSendData = new CHCNetSDK.NET_DVR_CARD_SEND_DATA();
            struSendData.Init();
            struSendData.dwSize = (uint)Marshal.SizeOf(struSendData);
            for (int i = 0; i < byTempCardNo.Length; i++)
            {
                struSendData.byCardNo[i] = byTempCardNo[i];
            }
            IntPtr ptrStruSendData = Marshal.AllocHGlobal((int)struSendData.dwSize);
            Marshal.StructureToPtr(struSendData, ptrStruSendData, false);
            int m_lGetCardCfgHandle = CHCNetSDK.NET_DVR_StartRemoteConfig(userId, CHCNetSDK.NET_DVR_GET_CARD, ptrStruCond, (int)struCond.dwSize, null, Process.GetCurrentProcess().MainWindowHandle);
            if (m_lGetCardCfgHandle < 0)
            {
                log.Error("NET_DVR_GET_CARD error: " + CHCNetSDK.NET_DVR_GetLastError());
                Marshal.FreeHGlobal(ptrStruCond);
                return null;
            }
            else
            {
                int dwState = (int)CHCNetSDK.NET_SDK_SENDWITHRECV_STATUS.NET_SDK_CONFIG_STATUS_SUCCESS;
                uint dwReturned = 0;
                while (true)
                {
                    dwState = CHCNetSDK.NET_DVR_SendWithRecvRemoteConfig(m_lGetCardCfgHandle, ptrStruSendData, struSendData.dwSize, ptrStruData, struData.dwSize, ref dwReturned);
                    struData = (CHCNetSDK.NET_DVR_CARD_RECORD)Marshal.PtrToStructure(ptrStruData, typeof(CHCNetSDK.NET_DVR_CARD_RECORD));
                    if (dwState == (int)CHCNetSDK.NET_SDK_SENDWITHRECV_STATUS.NET_SDK_CONFIG_STATUS_NEEDWAIT)
                    {
                        Thread.Sleep(10);
                        continue;
                    }
                    else if (dwState == (int)CHCNetSDK.NET_SDK_SENDWITHRECV_STATUS.NET_SDK_CONFIG_STATUS_FAILED)
                    {
                        MessageBox.Show("NET_DVR_GET_CARD fail error: " + CHCNetSDK.NET_DVR_GetLastError());
                    }
                    else if (dwState == (int)CHCNetSDK.NET_SDK_SENDWITHRECV_STATUS.NET_SDK_CONFIG_STATUS_SUCCESS)
                    {
                        string cardRightPlan = struData.wCardRightPlan[0].ToString();
                        string employNo = struData.dwEmployeeNo.ToString();
                        string name = System.Text.Encoding.UTF8.GetString(struData.byName);
                        log.Info($"NET_DVR_GET_CARD success:: employNo:{employNo} name:{name}");
                        return employNo;
                    }
                    else if (dwState == (int)CHCNetSDK.NET_SDK_SENDWITHRECV_STATUS.NET_SDK_CONFIG_STATUS_FINISH)
                    {
                        log.Info("NET_DVR_GET_CARD finish");
                        break;
                    }
                    else if (dwState == (int)CHCNetSDK.NET_SDK_SENDWITHRECV_STATUS.NET_SDK_CONFIG_STATUS_EXCEPTION)
                    {
                        log.Error("NET_DVR_GET_CARD exception error: " + CHCNetSDK.NET_DVR_GetLastError());
                        break;
                    }
                    else
                    {
                        log.Error("unknown status error: " + CHCNetSDK.NET_DVR_GetLastError());
                        break;
                    }
                }
            }
            CHCNetSDK.NET_DVR_StopRemoteConfig(m_lGetCardCfgHandle);
            m_lGetCardCfgHandle = -1;
            Marshal.FreeHGlobal(ptrStruSendData);
            Marshal.FreeHGlobal(ptrStruData);
            return null;
        }
    }
}