IotCloudPlatform/IoTIntegrationPlatform/IoTIntegrationPlatform.Services/DeviceService.cs

using IoTIntegrationPlatform.Common;
using IoTIntegrationPlatform.Interface;
using IoTIntegrationPlatform.Model.common;
using IoTIntegrationPlatform.Model.Dto;
using IoTIntegrationPlatform.Model.Enum;
using IoTIntegrationPlatform.Model.Model;
using MySqlX.XDevAPI.Relational;
using SqlSugar;
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using static IoTIntegrationPlatform.Model.Enum.EnumDevice;

namespace IoTIntegrationPlatform.Services
{
    /// <summary>
    /// 设备服务
    /// </summary>
    public class DeviceService : IDeviceService
    {
        private ISqlSugarClient db { get; }
        public DeviceService(ISqlSugarClient _db)
        {
            db = _db;
        }

        #region 类句柄操作
        private IntPtr handle;
        private bool disposed = false;
        //关闭句柄
        [System.Diagnostics.CodeAnalysis.SuppressMessage("Microsoft.Design", "CA1060:MovePInvokesToNativeMethodsClass"), System.Diagnostics.CodeAnalysis.SuppressMessage("Microsoft.Interoperability", "CA1401:PInvokesShouldNotBeVisible"), System.Runtime.InteropServices.DllImport("Kernel32")]
        public extern static Boolean CloseHandle(IntPtr handle);


        /// <summary>
        /// 释放对象资源
        /// </summary>
        public void Dispose()
        {
            Dispose(true);
            GC.SuppressFinalize(this);
        }

        /// <summary>
        /// 释放对象资源
        /// </summary>
        /// <param name="disposing"></param>
        protected virtual void Dispose(bool disposing)
        {
            if (!this.disposed)
            {
                if (handle != IntPtr.Zero)
                {
                    CloseHandle(handle);
                    handle = IntPtr.Zero;
                }
            }
            disposed = true;
        }
        ~DeviceService()
        {
            Dispose(false);
        }
        #endregion

        #region 平台型号

        /// <summary>
        /// 获取平台型号
        /// </summary>
        /// <param name="platformModelId"></param>
        /// <param name="code"></param>
        /// <returns></returns>
        public PlatformModel GetPlatformModelInfo(int platformModelId, string code)
        {
            PlatformModel model = new PlatformModel();
            try
            {
                model = db.Queryable<PlatformModel>()
                    .Where(it => it.IsValid == true)
                    .WhereIF(platformModelId > 0, it => it.PlatformModelId == platformModelId)
                    .WhereIF(!string.IsNullOrEmpty(code), it => it.PlatformModelCode.Equals(code))
                    .First();
            }
            catch (Exception ex)
            {
                Logging.Error(ex, ex.Message);
            }
            return model;
        }

        /// <summary>
        /// 获取平台型号列表
        /// </summary>
        /// <param name="parm"></param>
        /// <param name="page"></param>
        /// <returns></returns>
        public List<PlatformModel> GetPlatformModelList(BaseParm parm, ref int page)
        {
            List<PlatformModel> list = new List<PlatformModel>();
            try
            {
                list = db.Queryable<PlatformModel>()
                    .Where(it => it.IsValid == true)
                    .WhereIF(!string.IsNullOrEmpty(parm.Code), it => it.PlatformModelCode.Equals(parm.Code))
                    .ToPageList(parm.PageIndex, parm.PageSize, ref page);
            }
            catch (Exception ex)
            {
                Logging.Error(ex, ex.Message);
            }
            return list;
        }

        /// <summary>
        /// 添加平台型号
        /// </summary>
        /// <param name="model"></param>
        /// <returns></returns>
        public bool AddPlatformModel(PlatformModel model)
        {
            bool result = false;
            try
            {
                model.CreateTime = DateTime.Now;
                model.UpdateTime = DateTime.Now;
                model.IsValid = true;

                int row = db.Insertable(model).ExecuteCommand();

                if (row > 0)
                {
                    result = true;
                }
            }
            catch (Exception ex)
            {
                Logging.Error(ex, "添加平台设备型号");
            }
            return result;
        }

        /// <summary>
        /// 编辑平台设备型号
        /// </summary>
        /// <param name="model"></param>
        /// <returns></returns>
        public bool UpdatedPlatformModel(PlatformModel model)
        {

            bool result = false;
            try
            {
                var row = db.Updateable(model).IgnoreColumns(it => new { it.PlatformModelId, it.CreateTime, it.IsValid })
                    .Where(it => it.PlatformModelId == model.PlatformModelId)
                    .ExecuteCommand();

                if (row > 0)
                {
                    result = true;
                }

            }
            catch (Exception ex)
            {
                Logging.Error(ex, ex.Message);
            }
            return result;
        }

        /// <summary>
        /// 删除平台设备型号
        /// </summary>
        /// <param name="id"></param>
        /// <returns></returns>
        public bool DeletePlatformModel(int id)
        {
            bool result = false;
            try
            {
                int row = db.Updateable<PlatformModel>()
                    .SetColumns(it => new PlatformModel { UpdateTime = DateTime.Now, IsValid = false })
                    .Where(it => it.PlatformModelId == id)
                    .ExecuteCommand();

                if (row > 0)
                {
                    result = true;
                }

            }
            catch (Exception ex)
            {
                Logging.Error(ex, ex.Message);
            }
            return result;
        }


        #endregion

        #region 平台型号明细

        /// <summary>
        /// 获取设备明细信息
        /// </summary>
        /// <param name="detailId"></param>
        /// <param name="deviceName"></param>
        /// <param name="platformModelId"></param>
        /// <param name="deviceType"></param>
        /// <param name="deviceCommunicationType"></param>
        /// <returns></returns>
        public PlatformModelDetail GetPlatformModelDetailInfo(int detailId, string deviceName, int platformModelId, int deviceType, int deviceCommunicationType)
        {
            PlatformModelDetail model = new PlatformModelDetail();
            try
            {
                model = db.Queryable<PlatformModelDetail>()
                    .Where(it => it.IsValid == true)
                    .WhereIF(detailId > 0, it => it.PlatformModelDetailId == detailId)
                    .WhereIF(!string.IsNullOrEmpty(deviceName), it => it.DeviceName.Contains(deviceName))
                    .WhereIF(platformModelId > 0, it => it.PlatformModelId == platformModelId)
                    .WhereIF(deviceType > 0, it => it.DeviceType == (EnumDeviceType)deviceType)
                     .WhereIF(deviceType > 0, it => it.DeviceCommunicationType == (EnumDeviceCommunicationType)deviceCommunicationType)
                    .First();
            }
            catch (Exception ex)
            {
                Logging.Error(ex, ex.Message);
            }
            return model;
        }

        /// <summary>
        /// 获取平台型号明细列表
        /// </summary>
        /// <param name="parm"></param>
        /// <param name="page"></param>
        /// <returns></returns>
        public List<PlatformModelDetail> GetPlatformModelDetailList(BaseParm parm, ref int page)
        {
            List<PlatformModelDetail> list = new List<PlatformModelDetail>();
            try
            {
                list = db.Queryable<PlatformModelDetail>()
                    .Where(it => it.IsValid == true)
                    .WhereIF(!string.IsNullOrEmpty(parm.Name), it => it.DeviceName.Contains(parm.Name))
                    .WhereIF(parm.Int1 > 0, it => it.DeviceType == (EnumDeviceType)parm.Int1)
                    .WhereIF(parm.Int2 > 0, it => it.DeviceCommunicationType == (EnumDeviceCommunicationType)parm.Int2)
                    .WhereIF(parm.Type > 0, it => it.ModbusRegisterType == (EnumModbusRegisterType)parm.Type)
                    .OrderBy(it => it.CreateTime)
                    .ToPageList(parm.PageIndex, parm.PageSize, ref page);
            }
            catch (Exception ex)
            {
                Logging.Error(ex, ex.Message);
            }
            return list;
        }

        /// <summary>
        /// 添加平台型号明细
        /// </summary>
        /// <param name="model"></param>
        /// <returns></returns>
        public bool AddPlatformModelDetail(PlatformModelDetail model)
        {
            bool result = false;
            try
            {
                model.CreateTime = DateTime.Now;
                model.UpdateTime = DateTime.Now;
                model.IsValid = true;

                int row = db.Insertable(model).ExecuteCommand();

                if (row > 0)
                {
                    result = true;
                }
            }
            catch (Exception ex)
            {
                Logging.Error(ex, "添加平台设备型号");
            }
            return result;
        }

        /// <summary>
        /// 编辑平台设备型号
        /// </summary>
        /// <param name="model"></param>
        /// <returns></returns>
        public bool UpdatedPlatformModelDetail(PlatformModelDetail model)
        {

            bool result = false;
            try
            {
                var row = db.Updateable(model).IgnoreColumns(it => new { it.PlatformModelDetailId, it.CreateTime, it.IsValid })
                    .Where(it => it.PlatformModelDetailId == model.PlatformModelDetailId)
                    .ExecuteCommand();

                if (row > 0)
                {
                    result = true;
                }

            }
            catch (Exception ex)
            {
                Logging.Error(ex, ex.Message);
            }
            return result;
        }

        /// <summary>
        /// 删除平台设备型号
        /// </summary>
        /// <param name="id"></param>
        /// <returns></returns>
        public bool DeletePlatformModelDetail(int id)
        {
            bool result = false;
            try
            {
                int row = db.Updateable<PlatformModelDetail>()
                    .SetColumns(it => new PlatformModelDetail { UpdateTime = DateTime.Now, IsValid = false })
                    .Where(it => it.PlatformModelDetailId == id)
                    .ExecuteCommand();

                if (row > 0)
                {
                    result = true;
                }

            }
            catch (Exception ex)
            {
                Logging.Error(ex, ex.Message);
            }
            return result;
        }
        #endregion

        #region 平台设备

        /// <summary>
        /// 获取平台设备信息
        /// </summary>
        /// <param name="platformId"></param>
        /// <param name="code"></param>
        /// <param name="customerId"></param>
        /// <returns></returns>
        public PlatformDeviceInfo GetPlatformDeviceInfoInfo(int platformId, string code, int customerId)
        {
            PlatformDeviceInfo model = new PlatformDeviceInfo();
            try
            {
                model = db.Queryable<PlatformDeviceInfo>()
                    .Where(it => it.IsValid == true)
                    .WhereIF(platformId > 0, it => it.PlatformId == platformId)
                    .WhereIF(!string.IsNullOrEmpty(code), it => it.PlatformCode.Equals(code))
                    .WhereIF(customerId > 0, it => it.CustomerId == customerId)
                    .First();
            }
            catch (Exception ex)
            {
                Logging.Error(ex, ex.Message);
            }
            return model;
        }

        /// <summary>
        /// 获取平台设备列表
        /// </summary>
        /// <param name="parm"></param>
        /// <param name="page"></param>
        /// <returns></returns>
        public List<PlatformDeviceInfoDto> GetPlatformDeviceList(BaseParm parm, ref int page)
        {
            List<PlatformDeviceInfoDto> list = new List<PlatformDeviceInfoDto>();
            try
            {
                list = db.Queryable<PlatformDeviceInfo>()
                    .Where(it => it.IsValid == true)
                    .WhereIF(!string.IsNullOrEmpty(parm.Param), it => it.PlatformCode.Contains(parm.Param))
                    .WhereIF(!string.IsNullOrEmpty(parm.Code), it => it.PlatformCode.Equals(parm.Code))//平台编号
                    .WhereIF(parm.Int1 > 0, it => it.PlatformModelId == parm.Int1)//平台型号id
                    .WhereIF(parm.CustomerId > 0, it => it.CustomerId == parm.CustomerId)//客户id
                    .WhereIF(parm.Status > 0, it => it.PlatformStatus == (EnumPlatformStatus)parm.Status)//平台状态
                      .Select(it => new PlatformDeviceInfoDto()
                      {
                          PlatformId = it.PlatformId,
                          PlatformCode = it.PlatformCode,
                          PlatformModelId = it.PlatformModelId,
                          CustomerId = it.CustomerId,
                          EffectiveTime = it.EffectiveTime,
                          ExpireTime = it.ExpireTime,
                          DeviceMac = it.DeviceMac,
                          HeartbeatTime = it.HeartbeatTime,
                          DeviceState = it.DeviceState,
                          PlatformStatus = it.PlatformStatus,
                          Remark = it.Remark,
                          UpdateTime = it.UpdateTime,
                          OperationId = it.OperationId,
                          OperationName = it.OperationName,
                          CustomerCode = SqlFunc.Subqueryable<CustomerInfo>().Where(t => t.IsValid && t.CustomerId == it.CustomerId).Select(t => t.CustomerCode),
                          CustomerName = SqlFunc.Subqueryable<CustomerInfo>().Where(t => t.IsValid && t.CustomerId == it.CustomerId).Select(t => t.CustomerName),
                          PlatformModelCode = SqlFunc.Subqueryable<PlatformModel>().Where(t => t.IsValid && t.PlatformModelId == it.PlatformModelId).Select(t => t.PlatformModelCode),
                          PlatformModelName = SqlFunc.Subqueryable<PlatformModel>().Where(t => t.IsValid && t.PlatformModelId == it.PlatformModelId).Select(t => t.PlatformModelName)
                      })
                    .ToPageList(parm.PageIndex, parm.PageSize, ref page);
            }
            catch (Exception ex)
            {
                Logging.Error(ex, ex.Message);
            }
            return list;
        }

        /// <summary>
        /// 添加平台设备
        /// </summary>
        /// <param name="model"></param>
        /// <returns></returns>
        public bool AddPlatformDeviceInfo(PlatformDeviceInfo model)
        {
            bool result = false;
            db.Ado.BeginTran();
            try
            {
                //序列号
                string serialNumber = RandomHelper.GenerateRandomStr(16);

                model.CreateTime = DateTime.Now;
                model.UpdateTime = DateTime.Now;
                model.DeviceMac = DeviceHelper.GenerateDeviceMacAddress(serialNumber);
                model.HeartbeatTime = DateTime.Now;
                model.DeviceState = EnumDeviceStatus.Close;
                model.IsValid = true;
                model.PlatformStatus = EnumPlatformStatus.NotActivated;
                model.PlatformId = db.Insertable(model).ExecuteReturnIdentity();

                //根据物联网平台型号id获取平台型号明细设备
                //物联网平台型号id
                int platformModelId = model.PlatformModelId;
                //获取当前平台型号下的明细设备
                List<PlatformModelDetail> platformModelDeviceList = db.Queryable<PlatformModelDetail>().Where(it => it.IsValid && it.PlatformModelId == platformModelId).OrderBy(it => it.PlatformModelDetailId).ToList();

                //平台子设备
                List<PlatformDeviceDetail> subDevicelist = new List<PlatformDeviceDetail>();
                foreach (var item in platformModelDeviceList)
                {
                    PlatformDeviceDetail subDevicdModel = new PlatformDeviceDetail();
                    subDevicdModel = Mapping.EntityMapping<PlatformDeviceDetail, PlatformModelDetail>(item);
                    subDevicdModel.DeviceId = Guid.NewGuid().ToString();
                    subDevicdModel.PlatformId = model.PlatformId;
                    subDevicdModel.DeviceName = item.DeviceName;
                    subDevicdModel.DeviceType = item.DeviceType;
                    subDevicdModel.DeviceTypeName = EnumExtension.GetDescription(subDevicdModel.DeviceType);
                    subDevicdModel.DeviceState = EnumDeviceStatus.Close;
                    subDevicdModel.DeviceValue = item.DeviceValue;
                    subDevicdModel.CreateTime = DateTime.Now;
                    subDevicdModel.UpdateTime = DateTime.Now;
                    subDevicdModel.IsValid = true;
                    subDevicelist.Add(subDevicdModel);
                }
                int row = db.Insertable(subDevicelist).ExecuteCommand();
                if (row > 0)
                {
                    db.Ado.CommitTran();
                    result = true;
                }
            }
            catch (Exception ex)
            {
                Logging.Error(ex, ex.Message);
                db.Ado.RollbackTran();
            }
            return result;
        }

        /// <summary>
        /// 编辑平台设备
        /// </summary>
        /// <param name="model"></param>
        /// <returns></returns>
        public bool UpdatedPlatformDeviceInfo(PlatformDeviceInfo model)
        {

            bool result = false;
            try
            {
                model.UpdateTime = DateTime.Now;
                var row = db.Updateable(model).IgnoreColumns(it => new { it.PlatformId, it.PlatformCode, it.UpdateTime, it.IsValid })
                    .Where(it => it.PlatformId == model.PlatformId)
                    .ExecuteCommand();

                if (row > 0)
                {
                    result = true;
                }

            }
            catch (Exception ex)
            {
                Logging.Error(ex, ex.Message);
            }
            return result;
        }

        /// <summary>
        /// 批量编辑平台设备状态
        /// </summary>
        /// <param name="dataList"></param>
        /// <returns></returns>
        public bool BatchUpdatePlatformDeviceStatus(List<PlatformDeviceInfoDto> dataList)
        {
            bool result = false;
            db.Ado.BeginTran();
            try
            {
                foreach (var item in dataList)
                {
                    db.Updateable<PlatformDeviceInfo>()
                      .SetColumns(it => new PlatformDeviceInfo() { UpdateTime = DateTime.Now, DeviceState = item.DeviceState })
                     .Where(it => it.IsValid && it.PlatformId == item.PlatformId)
                     .ExecuteCommand();
                }
                db.Ado.CommitTran();
            }
            catch (Exception ex)
            {
                db.Ado.RollbackTran();
                Logging.Error(ex, "BatchUpdateDeviceStatus");
            }
            return result;
        }


        /// <summary>
        /// 编辑平台状态
        /// </summary>
        /// <param name="model"></param>
        /// <returns></returns>
        public bool UpdatedPlatformState(PlatformDeviceInfo model)
        {
            bool result = false;
            try
            {
                model.UpdateTime = DateTime.Now;

                var row = 0;
                if (model.PlatformStatus == EnumPlatformStatus.NotActivated)
                {
                    model.ExpireTime = DateTime.Now;
                    row = db.Updateable(model).UpdateColumns(it => new { it.PlatformStatus, it.UpdateTime }).Where(it => it.PlatformId == model.PlatformId).ExecuteCommand();
                }
                else if (model.PlatformStatus == EnumPlatformStatus.Normal)
                {
                    model.EffectiveTime = DateTime.Now;
                    row = db.Updateable(model).UpdateColumns(it => new { it.PlatformStatus, it.UpdateTime, it.EffectiveTime, it.ExpireTime }).Where(it => it.PlatformId == model.PlatformId).ExecuteCommand();
                }
                else if (model.PlatformStatus == EnumPlatformStatus.HaveExpired)
                {
                    model.ExpireTime = DateTime.Now;
                    row = db.Updateable(model).UpdateColumns(it => new { it.PlatformStatus, it.UpdateTime, it.ExpireTime }).Where(it => it.PlatformId == model.PlatformId).ExecuteCommand();
                }
                if (row > 0)
                {
                    result = true;
                }

            }
            catch (Exception ex)
            {
                Logging.Error(ex, ex.Message);
            }
            return result;
        }

        /// <summary>
        /// 删除平台设备
        /// </summary>
        /// <param name="platformId"></param>
        /// <returns></returns>
        public bool DeletePlatformDeviceInfo(int platformId)
        {
            bool result = false;
            try
            {
                int row = db.Updateable<PlatformDeviceInfo>()
                    .SetColumns(it => new PlatformDeviceInfo { UpdateTime = DateTime.Now, IsValid = false })
                    .Where(it => it.PlatformId == platformId)
                    .ExecuteCommand();

                if (row > 0)
                {
                    result = true;
                }

            }
            catch (Exception ex)
            {
                Logging.Error(ex, ex.Message);
            }
            return result;
        }

        /// <summary>
        /// 根据mac地址修改平台设备心跳时间
        /// </summary>
        /// <param name="deviceMac"></param>
        /// <returns></returns>
        public bool UpdateGatewayDeviceHeartTime(string deviceMac)
        {
            bool result = false;
            try
            {
                int row = db.Updateable<PlatformDeviceInfo>()
                    .SetColumns(it => new PlatformDeviceInfo { UpdateTime = DateTime.Now, HeartbeatTime = DateTime.Now, DeviceState = EnumDeviceStatus.Open })
                    .Where(it => it.IsValid && it.DeviceMac == deviceMac)
                    .ExecuteCommand();
                if (row > 0)
                {
                    result = true;
                }
            }
            catch (Exception ex)
            {
                Logging.Error(ex, ex.Message);
            }
            return result;
        }

        #endregion

        #region 平台设备明细


        /// <summary>
        /// 获取平台设备明细列表
        /// </summary>
        /// <param name="parm"></param>
        /// <param name="page"></param>
        /// <returns></returns>
        public List<PlatformDeviceDetailDto> GetPlatformDeviceDetailList(BaseParm parm, ref int page)
        {
            List<PlatformDeviceDetailDto> list = new List<PlatformDeviceDetailDto>();
            try
            {
                list = db.Queryable<PlatformDeviceDetail>()
                    .Where(it => it.IsValid)
                    .WhereIF(parm.Id > 0, it => it.PlatformId == parm.Id)//平台id
                    .WhereIF(!string.IsNullOrEmpty(parm.Name), it => it.DeviceName.Contains(parm.Name))//设备名称
                    .WhereIF(parm.Int1 > 0, it => it.DeviceType == (EnumDeviceType)parm.Int1)//设备类型
                    .WhereIF(parm.Int2 > 0, it => it.DeviceCommunicationType == (EnumDeviceCommunicationType)parm.Int2)//设备通讯方式
                    .OrderBy(it => it.PlatformModelDetailId)
                    .Select(it => new PlatformDeviceDetailDto()
                    {
                        DeviceCommunicationTypeName = "Rs485",
                        ModbusRegisterTypeName = "保持寄存器"
                    },
                    true)//开启自动映射
                    .ToPageList(parm.PageIndex, parm.PageSize, ref page);
            }
            catch (Exception ex)
            {
                Logging.Error(ex, ex.Message);
            }
            return list;
        }

        /// <summary>
        /// 编辑平台设备
        /// </summary>
        /// <param name="model"></param>
        /// <returns></returns>
        public bool UpdatedPlatformSubDeviceInfo(PlatformDeviceDetail model)
        {

            bool result = false;
            try
            {
                var row = db.Updateable(model).IgnoreColumns(it => new { it.DeviceId, it.PlatformId, it.CreateTime, it.IsValid })
                    .Where(it => it.DeviceId == model.DeviceId)
                    .ExecuteCommand();

                if (row > 0)
                {
                    result = true;
                }

            }
            catch (Exception ex)
            {
                Logging.Error(ex, ex.Message);
            }
            return result;
        }


        /// <summary>
        /// 编辑平台明细设备值
        /// </summary>
        /// <param name="model"></param>
        /// <returns></returns>
        public bool UpdatedPlatformSubDeviceValue(PlatformDeviceDetail model)
        {

            bool result = false;
            try
            {
                model.UpdateTime = DateTime.Now;
                var row = db.Updateable(model).UpdateColumns(it => new { it.DeviceValue, it.UpdateTime }).Where(it => it.DeviceId == model.DeviceId).ExecuteCommand();

                if (row > 0)
                {
                    result = true;
                }

            }
            catch (Exception ex)
            {
                Logging.Error(ex, ex.Message);
            }
            return result;
        }

        /// <summary>
        /// 删除平台子设备
        /// </summary>
        /// <param name="deviceId"></param>
        /// <returns></returns>
        public bool DeletePlatformSubDeviceInfo(string deviceId)
        {
            bool result = false;
            try
            {
                int row = db.Updateable<PlatformDeviceDetail>()
                    .SetColumns(it => new PlatformDeviceDetail { UpdateTime = DateTime.Now, IsValid = false })
                    .Where(it => it.DeviceId == deviceId)
                    .ExecuteCommand();

                if (row > 0)
                {
                    result = true;
                }
            }
            catch (Exception ex)
            {
                Logging.Error(ex, ex.Message);
            }
            return result;
        }


        /// <summary>
        /// 编辑设备状态或值(根据设备ID)
        /// </summary>
        /// <param name="deviceId"></param>
        /// <param name="deviceStatus"></param>
        /// <param name="deviceValue"></param>
        /// <returns></returns>
        public bool UpdateDeviceStateOrValue(string deviceId, EnumDeviceStatus deviceStatus, string deviceValue)
        {
            bool result = false;
            try
            {


                //int row = db.Updateable<PlatformDeviceDetail>()
                //    .SetColumns(it => new PlatformDeviceDetail { UpdateTime = DateTime.Now, DeviceState = deviceStatus, DeviceValue = deviceValue })
                //    .Where(it => it.DeviceId == deviceId)
                //    .ExecuteCommand();
                if (1 > 0)
                {
                    result = true;
                }
            }
            catch (Exception ex)
            {
                Logging.Error(ex, ex.Message);
            }
            return result;
        }

        /// <summary>
        /// 获取设备信息
        /// </summary>
        /// <param name="device_id"></param>
        /// <param name="deviceMac"></param>
        /// <param name="type"></param>
        /// <returns></returns>
        public PlatformDeviceDetail GetDevideInfo(string device_id)
        {
            PlatformDeviceDetail model = new PlatformDeviceDetail();
            try
            {
                model = db.Queryable<PlatformDeviceDetail>()
                    .Where(it => it.IsValid)
                    .WhereIF(!string.IsNullOrEmpty(device_id), it => it.DeviceId.Equals(device_id))
                    .First();
            }
            catch (Exception ex)
            {
                Logging.Error(ex, ex.Message);
            }
            return model;
        }


        /// <summary>
        /// 编辑设备读取数据状态
        /// </summary>
        /// <param name="model"></param>
        /// <returns></returns>
        public bool UpdateDeviceReadState(PlatformDeviceDetail model)
        {
            bool result = false;
            try
            {
                model.UpdateTime = DateTime.Now;

                var row = db.Updateable(model).UpdateColumns(it => new { it.UpdateTime, it.IsRead }).Where(it => it.DeviceId == model.DeviceId).ExecuteCommand();
                if (row > 0)
                {
                    result = true;
                }

            }
            catch (Exception ex)
            {
                Logging.Error(ex, ex.Message);
            }
            return result;
        }


        #endregion



    }
}