using System;
using System.Collections.Generic;
using Newtonsoft.Json.Linq;
using Shared;
using Shared.Phone.UserCenter;

namespace ZigBee.Device
{
    public class DoorLock : CommonDevice
    {
        public DoorLock()
        {
            this.Type = DeviceType.DoorLock;
        }

        #region 与云端通讯接口
        /// <summary>
        ///  添加门锁
        /// </summary>
        public class AddDoorLockData
        {
            /// <summary>
            /// RequestVersion
            /// </summary>
            public string RequestVersion = Shared.Common.CommonPage.RequestVersion;
            /// <summary>
            /// LoginAccessToken
            /// </summary>
            public string LoginAccessToken = Shared.Common.Config.Instance.Token;
            /// <summary>
            /// 住宅Id -->键名 : HomeId
            /// </summary>
            public string HomeId = "";
            /// <summary>
            /// 云端帐号Id -->键名 : CloudAccountId
            /// </summary>
            public string CloudAccountId = "";
            /// <summary>
            /// 门锁Id -->键名 : DoorLockId
            /// </summary>
            public string DoorLockId = "";
            /// <summary>
            /// OpenLockMode 开锁方式(密码、指纹、IC卡) -->键名 : OpenLockMode (可选)
            /// </summary>
            public int OpenLockMode = 0;
            /// <summary>
            /// 门锁本地用户Id -->键名 : DoorLockLocalUserId
            /// </summary>
            public string DoorLockLocalUserId = "";
            /// <summary>
            /// Data 相关内容(如:密码、指纹、IC卡 的二进制) -->键名 : Data (可选)
            public byte[] Data = null;
            /// <summary>
            /// 用户Id备注 -->键名 : UserIdRemarks
            /// </summary>
            public string UserIdRemarks = "";
            /// <summary>
            /// IsFreezeUser 是否冻结用户 -->键名 : IsFreezeUser (可选)
            /// </summary>
            public bool IsFreezeUser = false;
            /// <summary>
            /// IsTempUnlockAuthority 是否临时开锁权限 -->键名 : IsTempUnlockAuthority(可选)
            /// </summary>
            public bool IsTempUnlockAuthority = false;
            /// <summary>
            /// EntryTime 录入时间 -->键名 : EntryTime(可选)
            /// </summary>
            public DateTime EntryTime;
        }

        /// <summary>
        /// 获取子账户信息
        /// </summary> 
        static List<Shared.Phone.UserCenter.MemberInfoRes> DoorLockAccountList = new List<Shared.Phone.UserCenter.MemberInfoRes> { };
        public static async System.Threading.Tasks.Task<List<Shared.Phone.UserCenter.MemberInfoRes>> GetSubAccountByDistributedMark()
        {
            DoorLockAccountList.Clear();
            return await System.Threading.Tasks.Task.Run((Func<System.Threading.Tasks.Task<List<Shared.Phone.UserCenter.MemberInfoRes>>>)(async () =>
           {
               var pra = new Shared.Phone.UserCenter.MemberListInfoPra();
               string result = await UserCenterLogic.GetResponseDataByRequestHttps("ZigbeeUsers/GetSubAccountByDistributedMark", true, pra);
               var listInfo = Newtonsoft.Json.JsonConvert.DeserializeObject<List<Shared.Phone.UserCenter.MemberInfoRes>>(result);
               return listInfo;
           }));
        }

        /// <summary>
        /// 服务器获取数据失败提示
        /// </summary>
        public void FailureToServer()
        {
            Application.RunOnMainThread(() =>
            {
                var alert = new Alert(Language.StringByID(Shared.R.MyInternationalizationString.TIP), Language.StringByID(Shared.R.MyInternationalizationString.RequestServerFailed), Language.StringByID(Shared.R.MyInternationalizationString.Confrim));
                alert.Show();
            });
        }
        #endregion

        #region 门锁本地变量
        /// <summary>
        /// 门锁本地用户列表
        /// </summary>
        /// <returns></returns>
        public Dictionary<int, DoorLockProgrammingEventNotificationCommand> localDoorLockUserList = new Dictionary<int, DoorLockProgrammingEventNotificationCommand>();
        public string currentUserDisplayMethod = string.Empty;

        #endregion

        public async System.Threading.Tasks.Task GetDoorLockAllInfo()
        {
            FingerprintInfo fingerprint = await GetFingerprintAsync();
            var password = GetPasswordAsync();
            var proximity = GetProximityAsync();
        }

        #region 门锁操作事件通知
        /// <summary>
        /// 门锁操作事件通知
        /// </summary>
        public DoorLockOperatingEventNotificationCommand doorLockOperatingEventNotificationCommand;
        /// <summary>
        /// 门锁操作事件通知
        /// </summary>
        [System.Serializable]
        public class DoorLockOperatingEventNotificationCommand
        {
            /// <summary>
            /// 用户id
            ///门锁本地录入的密码、指纹、感应卡都有唯一对应的用户Id
            /// </summary>
            public int UserID;
            /// <summary>
            /// 事件触发源
            /// 常用：
            /// 0:Keypad(键盘/密码)；3:RFID(射频卡)；15:指纹
            ///不常用：
            /// 1:RF(Zigbee无线)；2:Manual(手动)；255:Indeterminate(不确定)
            /// </summary>
            public int OperationEventSource;
            /// <summary>
            /// 事件码
            /// 常用：
            /// 键盘/密码，指纹、感应卡：1:Lock命令成功事件；2:Unlock命令成功事件
            ///不常用：
            /// 请查看枚举
            /// </summary>
            public int OperationEventCode;
            /// <summary>
            /// 保留，默认0
            /// </summary>
            public int PIN;
            /// <summary>
            /// 门锁本地当前时间的时间戳
            /// </summary>
            public int ZigbeeLocalTime;
        }

        public class AccountsObj
        {
            /// <summary>
            /// 关联app账号
            /// </summary>
            public string Account;
            /// <summary>
            /// 保留
            /// </summary>
            public int Type;
            /// <summary>
            ///  保留
            /// </summary>
            public int Status;
        }

        /// <summary>
        /// “OperationEventSoure”列表
        /// </summary>
        public enum OperationEventSoure
        {
            /// <summary>
            /// 键盘/密码
            /// </summary>
            Keypad = 0,
            /// <summary>
            /// Zigbee无线
            /// </summary>
            RF = 1,
            /// <summary>
            /// 手动
            /// </summary>
            Manual = 2,
            /// <summary>
            /// 射频卡
            /// </summary>
            RFID = 3,
            /// <summary>
            /// 指纹
            /// </summary>
            Fingerprint = 15,
            /// <summary>
            /// Indeterminate(不确定)
            /// </summary>
            Indeterminate = 255,
        }

        /// <summary>
        /// “OperationEventSoure”类型为“Keypad”即密码 的“OperationEventCode”事件
        /// </summary>
        public enum KeypadEventDescription
        {
            /// <summary>
            /// 未知事件
            /// </summary>
            UnknownEvent = 0,
            /// <summary>
            /// Lock命令成功事件
            /// </summary>
            LockSuccessEvent = 1,
            /// <summary>
            /// Unlock命令成功事件
            /// </summary>
            UnlockSuccessEvent = 2,
            /// <summary>
            /// Lock命令：error,invalid PIN事件
            /// </summary>
            LockInvalidPinEvent = 3,
            /// <summary>
            /// Lock命令：error,invalid schedule事件
            /// </summary>
            LockInvalidScheduleEvent = 4,
            /// <summary>
            /// Unlock命令：error,invalid PIN事件
            /// </summary>
            UnlockInvalidPinEvent = 5,
            /// <summary>
            /// Unlock命令：error,invalid schedule事件Unlock命令：error,invalid schedule事件
            /// </summary>
            UnlockInvalidScheduleEvent = 6,
            /// <summary>
            /// 非访问用户操作事件
            /// </summary>
            NonAccess = 15,
        }

        /// <summary>
        /// “OperationEventSoure”类型为“RF” 的“OperationEventCode”事件
        /// </summary>
        public enum RfEventDescription
        {
            /// <summary>
            /// 未知事件
            /// </summary>
            UnknownEvent = 0,
            /// <summary>
            /// Lock命令成功事件
            /// </summary>
            LockSuccessEvent = 1,
            /// <summary>
            /// Unlock命令成功事件
            /// </summary>
            UnlockSuccessEvent = 2,
            /// <summary>
            /// Lock命令：error,invalid code事件
            /// </summary>
            LockInvalidPinEvent = 3,
            /// <summary>
            /// Lock命令：error,invalid schedule事件
            /// </summary>
            LockInvalidScheduleEvent = 4,
            /// <summary>
            /// Unlock命令：error,invalid code事件
            /// </summary>
            UnlockInvalidPinEvent = 5,
            /// <summary>
            /// Unlock命令：error,invalid schedule事件
            /// </summary>
            UnlockInvalidScheduleEvent = 6,
        }

        /// <summary>
        /// “OperationEventSoure”类型为“Manual” 的“OperationEventCode”事件
        /// </summary>
        public enum ManualEventDescription
        {
            /// <summary>
            /// 未知事件
            /// </summary>
            UnknownEvent = 0,
            /// <summary>
            /// Thumbturn Lock；手动转动上锁
            /// </summary>
            ThumbturnLockEvent = 1,
            /// <summary>
            /// Thumbturn Unlock；手动转动解锁
            /// </summary>
            UnlockSuccessEvent = 2,
            /// <summary>
            /// One touch Lock；一键上锁
            /// </summary>
            LockInvalidPinEvent = 7,
            /// <summary>
            ///Key Lock；按键上锁
            /// </summary>
            LockInvalidScheduleEvent = 8,
            /// <summary>
            /// Key Unlock；按键解锁
            /// </summary>
            UnlockInvalidPinEvent = 9,
            /// <summary>
            /// Auto lock；自动上锁
            /// </summary>
            UnlockInvalidScheduleEvent = 10,
            /// <summary>
            /// Schedule Lock；时间表上锁
            /// </summary>
            ScheduleLockEvent = 11,
            /// <summary>
            /// Schedule Unlock；时间表解锁
            /// </summary>
            ScheduleUnlockEvent = 12,
            /// <summary>
            /// Manual Lock(Key or Thumbturn)；手动上锁
            /// </summary>
            ManualLockEvent = 13,
            /// <summary>
            ///anual Unlock(Key or Thumbturn)；手动解锁
            /// </summary>
            ManualUnlockEvent = 14,
        }

        /// <summary>
        /// “OperationEventSoure”类型为“RFID” 的“OperationEventCode”事件
        /// </summary>
        public enum RfidEventDescription
        {
            /// <summary>
            /// 未知事件
            /// </summary>
            UnknownEvent = 0,
            /// <summary>
            /// Lock命令成功事件
            /// </summary>
            LockSuccessEvent = 1,
            /// <summary>
            /// Unlock命令成功事件
            /// </summary>
            UnlockSuccessEvent = 2,
            /// <summary>
            /// Lock命令：error,invalid RFID ID事件
            /// </summary>
            LockInvalidRfidIdEvent = 3,
            /// <summary>
            /// Lock命令：error,invalid schedule事件
            /// </summary>
            LockInvalidScheduleEvent = 4,
            /// <summary>
            /// Unlock命令：error,invalid RFID ID事件
            /// </summary>
            UnlockInvalidRfidIdEvent = 5,
            /// <summary>
            /// Unlock命令：error,invalid schedule事件
            /// </summary>
            UnlockInvalidScheduleEvent = 6,
        }
        #endregion

        #region 门锁编程事件通知
        /// <summary>
        /// 门锁编程事件通知
        /// </summary>
        public DoorLockProgrammingEventNotificationCommand doorLockProgrammingEventNotificationCommand;
        /// <summary>
        /// 门锁编程事件通知
        /// </summary>
        [System.Serializable]
        public class DoorLockProgrammingEventNotificationCommand
        {
            /// <summary>
            /// 用户id
            ///门锁本地录入的密码、指纹、感应卡都有唯一对应的用户Id
            /// </summary>
            public int UserID;
            /// <summary>
            /// 保留
            /// </summary>
            public int UserType;
            /// <summary>
            ///  保留
            /// </summary>
            public int UserStatus;
            /// <summary> 
            /// 编程事件触发源
            /// 常用：
            /// 0:Keypad(键盘/密码)；3:RFID(射频卡)；15:指纹
            ///不常用：
            /// 1:RF(Zigbee无线)；2:Manual(手动)；255:Indeterminate(不确定)
            /// </summary>
            public int ProgramEventSoure;
            /// <summary>
            /// 编程事件码
            /// 常用：
            /// 键盘/密码，指纹、感应卡：1:Lock命令成功事件；2:Unlock命令成功事件
            ///不常用：
            /// 请查看枚举 
            /// </summary>
            public int ProgramEventCode;
            /// <summary>
            /// 保留，默认0
            /// </summary>
            public int PIN;
            /// <summary>
            /// 门锁本地当前时间的时间戳
            /// </summary>
            public int ZigbeeLocalTime;
        }
        #endregion

        /*
        #region 获取门锁本地log记录
        ///<summary >
        ///获取门锁本地log记录
        ///<para>若命令中的PIN/RFID Code与门锁中的PIN/RFID Code相匹配，则将门锁上锁</para>
        ///<para>command :门锁设备记录的索引号；取值范围：</para>
        ///<para>1~“Number of Log Records Supported attribute”；</para>
        ///<para>值为0表示获取设备最近的记录数据。</para>
        ///</summary>
        public async System.Threading.Tasks.Task<LogRecordResponAllData> LogRecordAsync(int logIndex)
        {
            if (Gateway == null)
            {
                return null;
            }
            return await System.Threading.Tasks.Task.Run(async () =>
            {
                LogRecordResponAllData dataRes = null;
                Action<string, string> action = (topic, message) =>
                {
                    var gatewayID = topic.Split('/')[0];
                    var jobject = Newtonsoft.Json.Linq.JObject.Parse(message);

                    if (topic == gatewayID + "/" + "Error_Respon")
                    {
                        var gatewayTemp = new ZbGateway() { Time = jobject.Value<int>("Time"), DataID = jobject.Value<int>("Data_ID"), CurrentGateWayId = Gateway.getGatewayBaseInfo.gwID };
                        var temp = Newtonsoft.Json.JsonConvert.DeserializeObject<ZbGateway.ErrorResponData>(jobject["Data"].ToString());

                        if (temp == null)
                        {
                            dataRes = new LogRecordResponAllData { errorMessageBase = "网关错误回复，且数据是空" };
                        }
                        else
                        {
                            dataRes = new LogRecordResponAllData { errorResponData = temp, errorMessageBase = ErrorMess(temp.Error) };
                        }
                    }

                    if (topic == gatewayID + "/" + "DoorLock/DoorLockGetLogRecordResponseCommand")
                    {
                        var gatewayTemp = new ZbGateway() { DeviceID = jobject.Value<int>("Device_ID"), DeviceAddr = jobject.Value<string>("DeviceAddr"), DeviceEpoint = jobject.Value<int>("Epoint"), CurrentGateWayId = Gateway.getGatewayBaseInfo.gwID };
                        var tempData = Newtonsoft.Json.JsonConvert.DeserializeObject<LogRecordResData>(jobject["Data"].ToString());

                        if (tempData == null)
                        {
                            dataRes = new LogRecordResponAllData { errorMessageBase = "网关返回的数据为空" };
                        }
                        else
                        {
                            dataRes = new LogRecordResponAllData { logRecordResData = tempData };
                            DebugPrintLog($"UI收到通知后的主题_{ topic}");
                        }
                    }
                };
                Gateway.Actions += action;
                DebugPrintLog("DoorLock/DoorLockGetLogRecordResponseCommand_Actions 启动" + System.DateTime.Now.ToString());

                try
                {
                    var jObject = new JObject { { "DeviceAddr", DeviceAddr }, { "Epoint", DeviceEpoint }, { "Cluster_ID", 257 }, { "Command", 4 }, { "SendMode", 2 } };
                    var data = new JObject { { "LogIndex", logIndex } };
                    jObject.Add("Data", data);
                    Gateway.Send("DoorLock/test", jObject.ToString());
                }
                catch { }
                var dateTime = DateTime.Now;
                while ((DateTime.Now - dateTime).TotalMilliseconds < WaitReceiveDataTime)
                {
                    await System.Threading.Tasks.Task.Delay(10);
                    if (dataRes != null)
                    {
                        break;
                    }
                }
                if ((DateTime.Now - dateTime).TotalMilliseconds > WaitReceiveDataTime)
                {
                    dataRes = new LogRecordResponAllData { errorMessageBase = " 回复超时，请重新操作" };
                }
                Gateway.Actions -= action;
                DebugPrintLog("DoorLock/DoorLockGetLogRecordResponseCommand_Actions 退出" + System.DateTime.Now.ToString());

                return dataRes;
            });
        }

        ///<summary >
        ///获取门锁本地log记录
        /// </summary>
        public class LogRecordResponAllData
        {
            /// <summary>
            /// 错误信息
            /// </summary>
            public string errorMessageBase;
            /// <summary>
            /// 网关信息错误反馈
            /// <para>当网关接收到客户端信息后，出现以下异常情况将反馈错误。</para>
            /// </summary>
            public ErrorResponData errorResponData;
            /// <summary>
            /// 获取门锁本地log记录
            /// </summary>
            public LogRecordResData logRecordResData;
        }

        ///<summary >
        ///获取门锁本地log记录
        /// </summary>
        public class LogRecordResData
        {
            /// <summary>
            /// 事件触发
            /// </summary>
            public int OperationEventSoure;
            /// <summary>
            /// 事件
            /// </summary>
            public int OperationEventCode;
            /// <summary>
            /// 设备当前时间的时间戳
            /// </summary>
            public int ZigbeeLocalTime;
        }
        #endregion
        */

        /* 获取网关门锁信息，暂不支持
        #region 获取所有门锁所有用户信息
        ///<summary >
        ///获取所有门锁所有用户信息
        ///</summary>
        public async System.Threading.Tasks.Task<AlldoorlockUserInfoResponAllData> GetAlldoorlockUserInfoRspAsync()
        {
            if (Gateway == null)
            {
                return null;
            }
            return await System.Threading.Tasks.Task.Run(async () =>
            {
                AlldoorlockUserInfoResponAllData dataRes = null;
                Action<string, string> action = (topic, message) =>
                {
                    var gatewayID = topic.Split('/')[0];
                    var jobject = Newtonsoft.Json.Linq.JObject.Parse(message);

                    if (topic == gatewayID + "/" + "Error_Respon")
                    {
                        var gatewayTemp = new ZbGateway() { Time = jobject.Value<int>("Time"), DataID = jobject.Value<int>("Data_ID"), CurrentGateWayId = Gateway.getGatewayBaseInfo.gwID };
                        var temp = Newtonsoft.Json.JsonConvert.DeserializeObject<ZbGateway.ErrorResponData>(jobject["Data"].ToString());

                        if (temp == null)
                        {
                            dataRes = new AlldoorlockUserInfoResponAllData { errorMessageBase = "网关错误回复，且数据是空" };
                        }
                        else
                        {
                            dataRes = new AlldoorlockUserInfoResponAllData { errorResponData = temp, errorMessageBase = ErrorMess(temp.Error) };
                        }
                    }

                    if (topic == gatewayID + "/" + "Doorlock/GetAlldoorlockUserInfoRsp")
                    {
                        var gatewayTemp = new ZbGateway() { DeviceID = jobject.Value<int>("Device_ID"), DeviceAddr = jobject.Value<string>("DeviceAddr"), DeviceEpoint = jobject.Value<int>("Epoint"), CurrentGateWayId = Gateway.getGatewayBaseInfo.gwID };
                        var tempData = Newtonsoft.Json.JsonConvert.DeserializeObject<AlldoorlockUserInfoResData>(jobject["Data"].ToString());

                        if (tempData == null)
                        {
                            dataRes = new AlldoorlockUserInfoResponAllData { errorMessageBase = "网关返回的数据为空" };
                        }
                        else
                        {
                            dataRes = new AlldoorlockUserInfoResponAllData { alldoorlockUserInfoResData = tempData };
                            DebugPrintLog($"UI收到通知后的主题_{ topic}");
                        }
                    }
                };
                Gateway.Actions += action;
                DebugPrintLog("门锁Doorlock/GetAlldoorlockUserInfoRsp_Actions 启动" + System.DateTime.Now.ToString());

                try
                {
                    var jObject = new JObject { { "Cluster_ID", 0 }, { "Command", 6100 } };
                    Gateway.Send("DoorLock/test", jObject.ToString());
                }
                catch { }
                var dateTime = DateTime.Now;
                while ((DateTime.Now - dateTime).TotalMilliseconds < WaitReceiveDataTime)
                {
                    await System.Threading.Tasks.Task.Delay(10);
                    if (dataRes != null)
                    {
                        break;
                    }
                }
                if ((DateTime.Now - dateTime).TotalMilliseconds > WaitReceiveDataTime)
                {
                    dataRes = new AlldoorlockUserInfoResponAllData { errorMessageBase = " 回复超时，请重新操作" };
                }
                Gateway.Actions -= action;
                DebugPrintLog("门锁Doorlock/GetAlldoorlockUserInfoRsp_Actions 退出" + System.DateTime.Now.ToString());

                return dataRes;
            });
        }

        ///<summary >
        ///获取所有门锁所有用户信息
        /// </summary>
        public class AlldoorlockUserInfoResponAllData
        {
            /// <summary>
            /// 错误信息
            /// </summary>
            public string errorMessageBase;
            /// <summary>
            /// 网关信息错误反馈
            /// <para>当网关接收到客户端信息后，出现以下异常情况将反馈错误。</para>
            /// </summary>
            public ErrorResponData errorResponData;
            /// <summary>
            /// 获取所有门锁所有用户信息
            /// </summary>
            public AlldoorlockUserInfoResData alldoorlockUserInfoResData;
        }

        ///<summary >
        ///获取所有门锁所有用户信息
        /// </summary>
        public class AlldoorlockUserInfoResData
        {
            /// <summary>
            /// 事件触发
            /// </summary>
            public int doorlockUserInfoRecordSum;
            /// <summary>
            /// 事件
            /// </summary>
            public int OperationEventCode;
            /// <summary>
            /// 设备当前时间的时间戳
            /// </summary>
            public int ZigbeeLocalTime;
        }
        #endregion

        #region 获取单个门锁单个用户信息
        ///<summary >
        ///获取单个门锁单个用户信息
        ///<para>userId:门锁本地用户Id</para>
        ///</summary>
        public async System.Threading.Tasks.Task<UserInfoByMACEPUserIdResponAllData> GetdoorlockUserInfoByMACEPUserIdAsync(int userId)
        {
            if (Gateway == null)
            {
                return null;
            }
            return await System.Threading.Tasks.Task.Run(async () =>
            {
                UserInfoByMACEPUserIdResponAllData dataRes = null;
                Action<string, string> action = (topic, message) =>
                {
                    var gatewayID = topic.Split('/')[0];
                    var jobject = Newtonsoft.Json.Linq.JObject.Parse(message);

                    if (topic == gatewayID + "/" + "Error_Respon")
                    {
                        var gatewayTemp = new ZbGateway() { Time = jobject.Value<int>("Time"), DataID = jobject.Value<int>("Data_ID"), CurrentGateWayId = Gateway.getGatewayBaseInfo.gwID };
                        var temp = Newtonsoft.Json.JsonConvert.DeserializeObject<ZbGateway.ErrorResponData>(jobject["Data"].ToString());

                        if (temp == null)
                        {
                            dataRes = new UserInfoByMACEPUserIdResponAllData { errorMessageBase = "网关错误回复，且数据是空" };
                        }
                        else
                        {
                            dataRes = new UserInfoByMACEPUserIdResponAllData { errorResponData = temp, errorMessageBase = ErrorMess(temp.Error) };
                        }
                    }

                    if (topic == gatewayID + "/" + "Doorlock/GetdoorlockUserInfoByMACEPUserIdRsp")
                    {
                        var gatewayTemp = new ZbGateway() { DeviceID = jobject.Value<int>("Device_ID"), DeviceAddr = jobject.Value<string>("DeviceAddr"), DeviceEpoint = jobject.Value<int>("Epoint"), CurrentGateWayId = Gateway.getGatewayBaseInfo.gwID };
                        var tempData = Newtonsoft.Json.JsonConvert.DeserializeObject<UserInfoByMACEPUserIdRspResData>(jobject["Data"].ToString());

                        if (tempData == null)
                        {
                            dataRes = new UserInfoByMACEPUserIdResponAllData { errorMessageBase = "网关返回的数据为空" };
                        }
                        else
                        {
                            dataRes = new UserInfoByMACEPUserIdResponAllData { userInfoByMACEPUserIdRspResData = tempData };
                            DebugPrintLog($"UI收到通知后的主题_{ topic}");
                        }
                    }
                };
                Gateway.Actions += action;
                DebugPrintLog("门锁Doorlock/GetdoorlockUserInfoByMACEPUserIdRsp 启动" + System.DateTime.Now.ToString());

                try
                {
                    var jObject = new JObject { { "DeviceAddr", DeviceAddr }, { "Epoint", DeviceEpoint }, { "Cluster_ID", 0 }, { "Command", 6102 } };
                    var data = new JObject { { "UserId", userId } };
                    jObject.Add("Data", data);
                    Gateway.Send("DoorLock/test", jObject.ToString());
                }
                catch { }
                var dateTime = DateTime.Now;
                while ((DateTime.Now - dateTime).TotalMilliseconds < WaitReceiveDataTime)
                {
                    await System.Threading.Tasks.Task.Delay(10);
                    if (dataRes != null)
                    {
                        break;
                    }
                }
                if ((DateTime.Now - dateTime).TotalMilliseconds > WaitReceiveDataTime)
                {
                    dataRes = new UserInfoByMACEPUserIdResponAllData { errorMessageBase = " 回复超时，请重新操作" };
                }
                Gateway.Actions -= action;
                DebugPrintLog("门锁Doorlock/GetdoorlockUserInfoByMACEPUserIdRsp 退出" + System.DateTime.Now.ToString());

                return dataRes;
            });
        }

        ///<summary >
        ///获取单个门锁单个用户信息
        /// </summary>
        public class UserInfoByMACEPUserIdResponAllData
        {
            /// <summary>
            /// 错误信息
            /// </summary>
            public string errorMessageBase;
            /// <summary>
            /// 网关信息错误反馈
            /// <para>当网关接收到客户端信息后，出现以下异常情况将反馈错误。</para>
            /// </summary>
            public ErrorResponData errorResponData;
            /// <summary>
            /// 获取单个门锁单个用户信息
            /// </summary>
            public UserInfoByMACEPUserIdRspResData userInfoByMACEPUserIdRspResData;
        }

        ///<summary >
        ///获取所有门锁所有用户信息
        /// </summary>
        public class UserInfoByMACEPUserIdRspResData
        {
            /// <summary>
            /// 事件触发
            /// </summary>
            public int OperationEventSoure;
            /// <summary>
            /// 事件
            /// </summary>
            public int OperationEventCode;
            /// <summary>
            /// 设备当前时间的时间戳
            /// </summary>
            public int ZigbeeLocalTime;
        }
        #endregion 
       */

        #region 临时密码信息
        /// <summary>
        /// 临时密码本地存储对象
        /// </summary>
        public TempPasswordObj tempPasswordObj = new TempPasswordObj();
        /// <summary>
        /// 临时密码本地对象
        /// </summary>
        [System.Serializable]
        public class TempPasswordObj
        {
            /// <summary>
            /// 门锁有效时间
            /// </summary>
            public int validTime;
            /// <summary>
            /// 门锁时间
            /// </summary>
            public int times;
        }
        #endregion

        #region 指纹信息
        public async System.Threading.Tasks.Task<FingerprintInfo> GetFingerprintAsync()
        {
            FingerprintInfo result = null;
            return result;
        }

        /// <summary>
        /// 用户指纹列表  
        /// </summary>
        public List<FingerprintInfo> fingerprintList = new List<FingerprintInfo>();

        /// <summary>
        /// 用户指纹列表信息
        /// </summary>
        [System.Serializable]
        public class FingerprintInfo
        {
            /// <summary>
            /// 指纹备注
            /// </summary>
            public string fingerprintRemark = string.Empty;
            /// <summary>
            /// 指纹图片
            /// </summary>
            public string fingerprintImage = string.Empty;
            /// <summary>
            /// 指纹ID
            /// </summary>
            public int userFingerprintID;
            /// <summary>
            /// 指纹目标列表
            /// </summary>
            public readonly List<string> sceneFingerprintTargetList = new List<string>();
        }
        #endregion

        #region 密码信息
        public PasswordInfo GetPasswordAsync()
        {
            return null;
        }
        /// <summary>
        /// 用户密码列表  
        /// </summary>
        public List<PasswordInfo> passwordList = new List<PasswordInfo>();

        /// <summary>
        /// 用户密码列表信息
        /// </summary>
        [System.Serializable]
        public class PasswordInfo
        {
            /// <summary>
            /// 密码备注
            /// </summary>
            public string passwordRemark = string.Empty;
            /// <summary>
            /// 密码图片
            /// </summary>
            public string passwordImage = string.Empty;
            /// <summary>
            /// 密码ID
            /// </summary>
            public int userPasswordID;
            /// <summary>
            /// 密码目标列表
            /// </summary>
            public readonly List<string> scenePasswordTargetList = new List<string>();
        }
        #endregion

        #region 感应卡信息
        public ProximityInfo GetProximityAsync()
        {
            return null;
        }
        /// <summary>
        /// 用户感应卡列表  
        /// </summary>
        public List<ProximityInfo> proximityList = new List<ProximityInfo>();

        /// <summary>
        /// 用户感应卡列表信息
        /// </summary>
        [System.Serializable]
        public class ProximityInfo
        {
            /// <summary>
            /// 感应卡备注
            /// </summary>
            public string proximityRemark = string.Empty;
            /// <summary>
            /// 感应卡图片
            /// </summary>
            public string proximityImage = string.Empty;
            /// <summary>
            /// 感应卡ID
            /// </summary>
            public int userProximityID;
            /// <summary>
            /// 感应卡目标列表
            /// </summary>
            public readonly List<string> sceneProximityTargetList = new List<string>();
        }
        #endregion

        #region 历史记录
        /// <summary>
        /// 历史记录列表  
        /// </summary>
        public List<HistoryRecord> historyRecordList = new List<HistoryRecord> { };
        /// <summary>
        /// 门锁状态和报警信息
        /// </summary>
        [System.Serializable]
        public class HistoryRecord
        {
            /// <summary>
            /// 门锁开锁类型对应1 2 3 6
            /// </summary>
            public byte type;

            /// <summary>
            /// 门锁开锁用户ID
            /// </summary>
            public int userID;

            /// <summary>
            /// 年
            /// </summary>
            public string year;

            /// <summary>
            ///  月
            /// </summary>
            public string month;

            /// <summary>
            /// 日
            /// </summary>
            public string day;

            /// <summary>
            /// 时
            /// </summary>
            public string hour;

            /// <summary>
            /// 分
            /// </summary>
            public string minute;

            /// <summary>
            /// 秒
            /// </summary>
            public string second;
        }
        #endregion

        #region 私有命令
        #region 回复默认响应的控制
        ///<summary >
        ///默认响应控制
        /// <para>passData:透传数据</para>
        /// </summary>
        public async System.Threading.Tasks.Task<ResponseAllData> DefaultControlAsync(string passData)
        {
            ResponseAllData result = null;
            if (Gateway == null)
            {
                result = new ResponseAllData { errorMessageBase = "当前没有网关" };
                return result;
            }
            return await System.Threading.Tasks.Task.Run(async () =>
            {
                Action<string, string> action = (topic, message) =>
                {
                    var gatewayID = topic.Split('/')[0];
                    var jobject = Newtonsoft.Json.Linq.JObject.Parse(message);

                    if (topic == gatewayID + "/" + "Error_Respon")
                    {
                        var gatewayTemp = new ZbGateway() { Time = jobject.Value<int>("Time"), DataID = jobject.Value<int>("Data_ID"), CurrentGateWayId = Gateway.getGatewayBaseInfo.gwID };
                        var temp = Newtonsoft.Json.JsonConvert.DeserializeObject<ZbGateway.ErrorResponData>(jobject["Data"].ToString());

                        if (temp == null)
                        {
                            result = new ResponseAllData { errorMessageBase = "网关错误回复，且数据是空" };
                        }

                        else
                        {
                            result = new ResponseAllData { errorResponData = temp, errorMessageBase = ErrorMess(temp.Error) };
                        }
                    }
                    if (topic == gatewayID + "/" + "ZbDataPassthrough")
                    {
                        var gatewayTemp = new ZbGateway() { DataID = jobject.Value<int>("Data_ID") };
                        gatewayTemp.clientDataPassthroughResponseData = Newtonsoft.Json.JsonConvert.DeserializeObject<ClientDataPassthroughResponseData>(jobject["Data"].ToString());

                        if (gatewayTemp.clientDataPassthroughResponseData == null)
                        {
                            result = new ResponseAllData { errorMessageBase = "网关返回的数据为空" };
                        }
                        else
                        {
                            if (gatewayTemp.clientDataPassthroughResponseData?.PassData != null)
                            {
                                var data = gatewayTemp.clientDataPassthroughResponseData.PassData;
                                if (data.Length == 16)
                                {
                                    var command = data[4].ToString() + data[5].ToString() + data[2].ToString() + data[3].ToString();
                                    if (command == "0002")
                                    {
                                        var tempD = new ResponseData();
                                        tempD.command = Convert.ToInt32(data[10].ToString() + data[11].ToString() + data[12].ToString() + data[13].ToString(), 16);
                                        tempD.status = Convert.ToInt32(data[14].ToString() + data[15].ToString(), 16);
                                        result = new ResponseAllData { responseData = tempD };
                                        DebugPrintLog($"UI收到通知后的主题_command:0402_{ topic}");
                                    }
                                }
                            }
                        }
                    }
                };

                Gateway.Actions += action;
                DebugPrintLog("ClientDataPassthrough_Actions 启动" + System.DateTime.Now.ToString());

                try
                {
                    var jObject = new JObject { { "DeviceAddr", DeviceAddr }, { "Epoint", 200 }, { "Cluster_ID", 64513 }, { "Command", 0 } };
                    var data = new JObject { { "PassData", passData } };
                    jObject.Add("Data", data);
                    Gateway.Send(("ClientDataPassthrough"), jObject.ToString());
                }
                catch { }

                var dateTime = DateTime.Now;
                while ((DateTime.Now - dateTime).TotalMilliseconds < 9000)// WaitReceiveDataTime)
                {
                    await System.Threading.Tasks.Task.Delay(10);
                    if (result != null)
                    {
                        break;
                    }
                }
                if ((DateTime.Now - dateTime).TotalMilliseconds > WaitReceiveDataTime)
                {
                    result = new ResponseAllData { errorMessageBase = " 回复超时，请重新操作" };
                }
                Gateway.Actions -= action;
                DebugPrintLog("ClientDataPassthrough_Actions 退出" + System.DateTime.Now.ToString());

                return result;
            });
        }
        #endregion

        #region 用户管理发送数据
        /// <summary>
        /// 用户管理发送数据
        /// </summary>
        public string SetUserAccessData(int userId, AccessType accessType)
        {
            string data = "";
            string dataLength = "07";
            string dataComand1 = "50";
            string dataComand2 = "04";
            string dataSerialNum = "01";
            string addDataLength = "03";
            string delUserTypeStr = "";
            string userIdStr = "";
            try
            {
                switch ((int)accessType)
                {
                    case 0:
                        delUserTypeStr = "00";
                        break;
                    case 1:
                        delUserTypeStr = "01";
                        break;
                    case 2:
                        delUserTypeStr = "20";
                        break;
                    case 3:
                        delUserTypeStr = "21";
                        break;
                }
                var sbString = new System.Text.StringBuilder();
                string temp = Convert.ToString(userId, 16);

                switch (temp.Length)
                {
                    case 1:
                        userIdStr = "0" + temp + "00";
                        break;
                    case 2:
                        userIdStr = temp + "00";
                        break;
                    case 3:
                        var thirdBit = temp.Substring(temp.Length - 2, 1);
                        userIdStr = temp + "0" + thirdBit;
                        break;
                    case 4:
                        userIdStr = temp;
                        break;
                }
                sbString.Append(userIdStr.ToString().ToUpper());
                data = dataLength + dataComand1 + dataComand2 + dataSerialNum + addDataLength +
                   delUserTypeStr + sbString;
            }
            catch { };

            return data;
        }
        #endregion

        #region 远程发送数据
        /// <summary>
        /// 远程发送数据
        /// </summary>
        public string RemoteData(string keyPassword, string password, string fixedPassword = "190605")
        {
            string data = "";
            string dataLength = "09";
            string dataComand1 = "62";
            string dataComand2 = "04";
            string dataSerialNum = "01";
            string addDataLength = "04";
            string passwordStr = "";
            try
            {
                int keyPasswordInt = System.Convert.ToInt32(keyPassword, 16);
                int passwordInt = System.Convert.ToInt32(password, 16);
                var fixedPasswordInt = System.Convert.ToInt32(fixedPassword, 16);
                var pawStr = System.Convert.ToString((keyPasswordInt ^ passwordInt) + fixedPasswordInt, 16);
                pawStr = pawStr.PadLeft(8, '0');
                for (int i = 6; i >= 0; i = i - 2)
                {
                    passwordStr += passwordStr.Substring(i, 2);
                }
                data = dataLength + dataComand1 + dataComand2 + dataSerialNum + addDataLength +
                 passwordStr;
            }
            catch { };

            return data;
        }
        #endregion

        #region 临时密码发送数据
        /// <summary>
        /// 临时密码发送数据
        /// </summary>
        public string TempPasswordData(string keyPassword, string password, System.DateTime startTime, System.DateTime endTime, string fixedPassword = "190605")
        {
            string data = "";
            string dataLength = "14";//十进制是19
            string dataComand1 = "63";
            string dataComand2 = "04";
            string dataSerialNum = "01";
            string addDataLength = "0c";
            string passwordStr = "";
            string vaildTimeStr = "";
            string invalidTimeStr = "";
            try
            {
                int keyPasswordInt = System.Convert.ToInt32(keyPassword, 16);
                int passwordInt = System.Convert.ToInt32(password, 16);
                var fixedPasswordInt = System.Convert.ToInt32(fixedPassword, 16);
                var pawStr = System.Convert.ToString((keyPasswordInt ^ passwordInt) + fixedPasswordInt, 16);
                pawStr = pawStr.PadLeft(8, '0');
                for (int i = 6; i >= 0; i = i - 2)
                {
                    passwordStr += passwordStr.Substring(i, 2);
                }
                var startTimeStr = System.Convert.ToString(GetUnixTimeStamp(startTime, false), 16);
                var endTimeStr = System.Convert.ToString(GetUnixTimeStamp(endTime, false), 16);
                for (int i = 6; i >= 0; i = i - 2)
                {
                    vaildTimeStr += startTimeStr.Substring(i, 2);
                    invalidTimeStr += endTimeStr.Substring(i, 2);
                }
                data = dataLength + dataComand1 + dataComand2 + dataSerialNum + addDataLength +
                   passwordStr + vaildTimeStr + vaildTimeStr;
            }
            catch { };

            return data;
        }
        #endregion

        #region 获取门锁密钥
        /// <summary>
        /// 门锁随机密码
        /// <para>获取加密的随机密钥，返回的密钥经过一个简单的加法加密加上0x190605，因此获取的密钥需要减上0x190605</para>
        /// </summary>
        /// <returns></returns>
        async System.Threading.Tasks.Task<string> GetkeyPassword()
        {
            var result = await GetKeyPassworAsync();
            if (result == null || result.keyPassword == null)
            {
                return "";
            }
            return result.keyPassword;
        }

        ///<summary >
        ///获取门锁密钥
        /// </summary>
        public async System.Threading.Tasks.Task<KeyPasswordInfo> GetKeyPassworAsync(int keyType = 0)
        {
            KeyPasswordInfo result = null;
            if (Gateway == null)
            {
                result = new KeyPasswordInfo { errorMessageBase = "当前没有网关" };
                return result;
            }
            return await System.Threading.Tasks.Task.Run(async () =>
            {
                Action<string, string> action = (topic, message) =>
                {
                    var gatewayID = topic.Split('/')[0];
                    var jobject = Newtonsoft.Json.Linq.JObject.Parse(message);

                    if (topic == gatewayID + "/" + "Error_Respon")
                    {
                        var gatewayTemp = new ZbGateway() { Time = jobject.Value<int>("Time"), DataID = jobject.Value<int>("Data_ID"), CurrentGateWayId = Gateway.getGatewayBaseInfo.gwID };
                        var temp = Newtonsoft.Json.JsonConvert.DeserializeObject<ZbGateway.ErrorResponData>(jobject["Data"].ToString());

                        if (temp == null)
                        {
                            result = new KeyPasswordInfo { errorMessageBase = "网关错误回复，且数据是空" };
                        }

                        else
                        {
                            result = new KeyPasswordInfo { errorResponData = temp, errorMessageBase = ErrorMess(temp.Error) };
                        }
                    }

                    if (topic == gatewayID + "/" + "ZbDataPassthrough")
                    {
                        var gatewayTemp = new ZbGateway() { DataID = jobject.Value<int>("Data_ID") };
                        gatewayTemp.clientDataPassthroughResponseData = Newtonsoft.Json.JsonConvert.DeserializeObject<ClientDataPassthroughResponseData>(jobject["Data"].ToString());

                        if (gatewayTemp.clientDataPassthroughResponseData == null)
                        {
                            result = new KeyPasswordInfo { errorMessageBase = "网关返回的数据为空" };
                        }
                        else
                        {
                            if (gatewayTemp.clientDataPassthroughResponseData?.PassData != null)
                            {
                                var data = gatewayTemp.clientDataPassthroughResponseData.PassData;
                                if (data.Length == 14)
                                {
                                    var command = data[4].ToString() + data[5].ToString() + data[2].ToString() + data[3].ToString();

                                    if (command == "0461")
                                    {
                                        var kType = Convert.ToInt32(data[10].ToString() + data[11].ToString(), 16);
                                        var keyPassword = data[12].ToString() + data[13].ToString() + data[14].ToString() + data[15].ToString() + data[16].ToString() + data[17].ToString() + data[18].ToString() + data[19].ToString();
                                        result = new KeyPasswordInfo { keyType = kType, keyPassword = keyPassword };
                                        System.Console.WriteLine($"UI收到通知后的主题_command:0406_{ topic}");
                                    }
                                }
                            }
                        }
                    }
                };

                Gateway.Actions += action;
                System.Console.WriteLine("ClientDataPassthrough_Actions 启动" + System.DateTime.Now.ToString());

                try
                {
                    var passData = KeyPasswordData(keyType);
                    var jObject = new JObject { { "DeviceAddr", DeviceAddr }, { "Epoint", 200 }, { "Cluster_ID", 64513 }, { "Command", 0 } };
                    var data = new JObject { { "PassData", passData } };
                    jObject.Add("Data", data);
                    Gateway.Send(("ClientDataPassthrough"), jObject.ToString());
                }
                catch { }

                var dateTime = DateTime.Now;
                while ((DateTime.Now - dateTime).TotalMilliseconds < 9000)//WaitReceiveDataTime)
                {
                    await System.Threading.Tasks.Task.Delay(10);
                    if (result != null)
                    {
                        break;
                    }
                }
                if ((DateTime.Now - dateTime).TotalMilliseconds > WaitReceiveDataTime)
                {
                    result = new KeyPasswordInfo { errorMessageBase = " 回复超时，请重新操作" };
                }
                Gateway.Actions -= action;
                System.Console.WriteLine("ClientDataPassthrough_Actions 退出" + System.DateTime.Now.ToString());

                return result;
            });
        }

        /// <summary>
        /// 获取门锁密钥
        /// </summary>
        string KeyPasswordData(int keyType)
        {
            string data = "";
            string dataLength = "05";
            string dataComand1 = "60";
            string dataComand2 = "04";
            string dataSerialNum = "01";
            string addDataLength = "01";
            string keyTypeData = "";

            try
            {
                var tempTypeString = new System.Text.StringBuilder();
                var temp = Convert.ToString(keyType, 16);
                switch (temp.Length)
                {
                    case 1:
                        keyTypeData = "0" + temp;
                        break;
                    case 2:
                        keyTypeData = temp;
                        break;
                }
                tempTypeString.Append(keyTypeData.ToString().ToUpper());
                data = dataLength + dataComand1 + dataComand2 + dataSerialNum + addDataLength +
            tempTypeString;
            }
            catch { };

            return data;
        }

        /// <summary>
        /// 获取门锁密钥回复
        /// </summary>
        [System.Serializable]
        public class KeyPasswordInfo
        {
            /// <summary>
            /// 错误信息
            /// </summary>
            public string errorMessageBase;
            /// <summary>
            /// 网关信息错误反馈
            /// <para>当网关接收到客户端信息后，出现以下异常情况将反馈错误。</para>
            /// </summary>
            public ErrorResponData errorResponData;
            /// <summary>
            ///密钥类型
            ///<apra></apra>
            /// </summary>
            public int keyType = -1;

            /// <summary>
            /// 密钥
            /// </summary>
            public string keyPassword;
        }
        #endregion

        #region 读取锁上信息
        ///<summary >
        ///读取锁上信息
        /// </summary>
        public async System.Threading.Tasks.Task<DoorlockUserInfo> GetDoorlockUserInfoAsync(int keyType = 0)
        {
            DoorlockUserInfo result = null;
            if (Gateway == null)
            {
                result = new DoorlockUserInfo { errorMessageBase = "当前没有网关" };
                return result;
            }
            return await System.Threading.Tasks.Task.Run(async () =>
            {
                Action<string, string> action = (topic, message) =>
                {
                    var gatewayID = topic.Split('/')[0];
                    var jobject = Newtonsoft.Json.Linq.JObject.Parse(message);

                    if (topic == gatewayID + "/" + "Error_Respon")
                    {
                        var gatewayTemp = new ZbGateway() { Time = jobject.Value<int>("Time"), DataID = jobject.Value<int>("Data_ID"), CurrentGateWayId = Gateway.getGatewayBaseInfo.gwID };
                        var temp = Newtonsoft.Json.JsonConvert.DeserializeObject<ZbGateway.ErrorResponData>(jobject["Data"].ToString());

                        if (temp == null)
                        {
                            result = new DoorlockUserInfo { errorMessageBase = "网关错误回复，且数据是空" };
                        }

                        else
                        {
                            result = new DoorlockUserInfo { errorResponData = temp, errorMessageBase = ErrorMess(temp.Error) };
                        }
                    }

                    if (topic == gatewayID + "/" + "ZbDataPassthrough")
                    {
                        var gatewayTemp = new ZbGateway() { DataID = jobject.Value<int>("Data_ID") };
                        gatewayTemp.clientDataPassthroughResponseData = Newtonsoft.Json.JsonConvert.DeserializeObject<ClientDataPassthroughResponseData>(jobject["Data"].ToString());

                        if (gatewayTemp.clientDataPassthroughResponseData == null)
                        {
                            result = new DoorlockUserInfo { errorMessageBase = "网关返回的数据为空" };
                        }
                        else
                        {
                            if (gatewayTemp.clientDataPassthroughResponseData?.PassData != null)
                            {
                                var data = gatewayTemp.clientDataPassthroughResponseData.PassData;
                                if (data.Length == 14)
                                {
                                    var command = data[4].ToString() + data[5].ToString() + data[2].ToString() + data[3].ToString();

                                    if (command == "0452")
                                    {
                                        //var kType = Convert.ToInt32(data[10].ToString() + data[11].ToString(), 16);
                                        //var keyPassword = data[12].ToString() + data[13].ToString() + data[14].ToString() + data[15].ToString() + data[16].ToString() + data[17].ToString() + data[18].ToString() + data[19].ToString();
                                        //result = new DoorlockUserInfo { keyType = kType, keyPassword = keyPassword };
                                        System.Console.WriteLine($"UI收到通知后的主题_command:0451_{ topic}");
                                    }
                                }
                            }
                        }
                    }
                };

                Gateway.Actions += action;
                System.Console.WriteLine("ClientDataPassthrough_Actions 启动" + System.DateTime.Now.ToString());

                try
                {
                    var passData = KeyPasswordData(keyType);
                    var jObject = new JObject { { "DeviceAddr", DeviceAddr }, { "Epoint", 200 }, { "Cluster_ID", 64513 }, { "Command", 0 } };
                    var data = new JObject { { "PassData", passData } };
                    jObject.Add("Data", data);
                    Gateway.Send(("ClientDataPassthrough"), jObject.ToString());
                }
                catch { }

                var dateTime = DateTime.Now;
                while ((DateTime.Now - dateTime).TotalMilliseconds < 9000)//WaitReceiveDataTime)
                {
                    await System.Threading.Tasks.Task.Delay(10);
                    if (result != null)
                    {
                        break;
                    }
                }
                if ((DateTime.Now - dateTime).TotalMilliseconds > WaitReceiveDataTime)
                {
                    result = new DoorlockUserInfo { errorMessageBase = " 回复超时，请重新操作" };
                }
                Gateway.Actions -= action;
                System.Console.WriteLine("ClientDataPassthrough_Actions 退出" + System.DateTime.Now.ToString());

                return result;
            });
        }

        /// <summary>
        /// 读取锁上信息
        /// </summary>
        string DoorlockUserData(int userType)
        {
            string data = "";
            string dataLength = "05";
            string dataComand1 = "51";
            string dataComand2 = "04";
            string dataSerialNum = "01";
            string addDataLength = "01";
            string keyTypeData = "";

            try
            {
                var tempTypeString = new System.Text.StringBuilder();
                var temp = Convert.ToString(userType, 16);
                switch (temp.Length)
                {
                    case 1:
                        keyTypeData = "0" + temp;
                        break;
                    case 2:
                        keyTypeData = temp;
                        break;
                }
                tempTypeString.Append(keyTypeData.ToString().ToUpper());
                data = dataLength + dataComand1 + dataComand2 + dataSerialNum + addDataLength +
            tempTypeString;
            }
            catch { };

            return data;
        }

        /// <summary>
        /// 读取锁上信息回复
        /// </summary>
        [System.Serializable]
        public class DoorlockUserInfo
        {
            /// <summary>
            /// 错误信息
            /// </summary>
            public string errorMessageBase;
            /// <summary>
            /// 网关信息错误反馈
            /// <para>当网关接收到客户端信息后，出现以下异常情况将反馈错误。</para>
            /// </summary>
            public ErrorResponData errorResponData;
        }

        public class DoorLockUserDetailData
        {
            /// <summary>
            /// 类型
            /// </summary>
            public int userType;
            /// <summary>
            /// 数据包总数
            /// </summary>
            public int totalNum;
            /// <summary>
            /// 数据包序号
            /// </summary>
            public int currentNum;
            /// <summary>
            /// 用户数据
            /// </summary>
            public byte userData;
        }
        #endregion

        public enum AccessType
        {
            /// <summary>
            /// 0x00 删除全部单次用户
            /// </summary>
            DelAllUsers = 0,
            /// <summary>
            /// 0x01 删除指定用户(按编号)
            /// </summary>
            DelCurrentUser = 1,
            /// <summary>
            /// 0x20 冻结指定用户
            /// </summary>
            DisEnable = 2,
            /// <summary>
            /// 0x21 解冻指定用户
            /// </summary>
            Enable = 3,
        }

        /// <summary>
        /// 获取从格林威治时间到当前某一时刻的总毫秒数
        /// </summary>
        /// <param name="dateTime">北京时间</param>
        /// <param name="accurateToMilliseconds">精确到毫秒，否到秒</param>
        /// <returns>返回一个长整数时间戳</returns>
        public static long GetUnixTimeStamp(DateTime dateTime, bool accurateToMilliseconds)
        {
            DateTime startTime = TimeZoneInfo.ConvertTimeToUtc(new DateTime(1970, 1, 1, 8, 0, 0));//北京所在东八区
            DateTime endTime = TimeZoneInfo.ConvertTimeToUtc(dateTime);
            return (long)(accurateToMilliseconds ? (endTime - startTime).TotalMilliseconds : (endTime - startTime).TotalSeconds);
        }

        /// <summary>
        /// 将UNIX时间戳转为北京时间        
        /// </summary>
        /// <param name="unixTimeStamp">时间戳</param>
        /// <param name="accurateToMilliseconds">精确到毫秒,佛为秒</param>
        /// <returns></returns>
        public static DateTime GetLocalTime(long unixTimeStamp, bool accurateToMilliseconds)
        {
            DateTime startTime = TimeZoneInfo.ConvertTimeToUtc(new DateTime(1970, 1, 1, 8, 0, 0));//北京所在东八区
            return (accurateToMilliseconds ? startTime.AddMilliseconds(unixTimeStamp) : startTime.AddSeconds(unixTimeStamp)).ToLocalTime();
        }
        #endregion
    }
}