WingDeviceService/Service/DeviceService.cs

using System;
using System.Collections.Generic;
using System.Linq;
using WingInterfaceLibrary.Enum;
using System.Threading.Tasks;
using JsonRpcLite.Services;
using WingInterfaceLibrary.DTO.Device;
using WingInterfaceLibrary.Interface;
using WingInterfaceLibrary.Request.Device;
using WingInterfaceLibrary.DTO.Dictionary;
using WingServerCommon.Log;
using WingServerCommon.Service;
using WingInterfaceLibrary.Interface.DBInterface;
using WingInterfaceLibrary.DB.Request;
using WingServerCommon.Mapper;
using WingInterfaceLibrary.Request;
using WingInterfaceLibrary.DTO.User;
using System.IO;
using WingInterfaceLibrary.DTO.Management;
using WingServerCommon.Config;
using WingDeviceService.Common;

namespace WingDeviceService.Service
{
    /// <summary>
    /// 设备管理服务
    /// </summary>
    public partial class DeviceService : JsonRpcService, IDeviceService
    {

        private IUserDBService _userServiceProxy;

        private IDeviceInfoDBService _deviceInfoDBServiceProxy;

        private IAuthenticationService _authenticationServiceProxy;

        private IOrganizationDBService _organizationDBService;

        private INotificationService _notificationService;

        private CacheManager<CacheDeviceDTO> _cacheDeviceManager
        {
            get
            {
                return CacheManagerSingle<CacheDeviceDTO>.Instance;
            }
        }

        /// <summary>
        /// Init service
        /// </summary>
        public override void Load(JsonRpcClientPool jsonRpcClientPool)
        {
            base.Load(jsonRpcClientPool);
            _userServiceProxy = GetProxy<IUserDBService>();
            _authenticationServiceProxy = GetProxy<IAuthenticationService>();
            _deviceInfoDBServiceProxy = GetProxy<IDeviceInfoDBService>();
            _organizationDBService = GetProxy<IOrganizationDBService>();
            _notificationService = GetProxy<INotificationService>();
        }


        /// <summary>
        /// 添加分享设备关联用户请求
        /// </summary>
        /// <param name="request"></param>
        /// <returns></returns>
        public async Task<bool> CreateShareDeviceToUserAsync(CreateShareDeviceToUserRequest request)
        {
            var userCodes = request.UserCodes;
            var deviceCode = request.DeviceCode;
            if (!await _authenticationServiceProxy.CheckTokenAsync(new WingInterfaceLibrary.Request.TokenRequest() { Token = request.Token }))
            {
                throw new RpcException(1002, "Permission validation error", "Permission validation error");
            }
            //检查设备编码不为空
            if (string.IsNullOrWhiteSpace(request.DeviceCode))
            {
                throw new RpcException(1004, "Required parameter:DeviceCode cannot be empty", "Required parameter:DeviceCode cannot be empty");
            }
            if (userCodes == null || userCodes.Count <= 0)
            {
                throw new RpcException(1004, "Required parameter:UserCodes cannot be empty", "Required parameter:UserCodes cannot be empty");
            }
            //查询设备对象
            var deviceDb = await _deviceInfoDBServiceProxy.FindDeviceInfoByCodeAsync(deviceCode);
            if (deviceDb == null)
            {
                throw new RpcException(1007, "Device not exist.", "Device not exist.");
            }
            foreach (var userCode in userCodes)
            {
                var existUser = await _userServiceProxy.FindUserByCodeAsync(userCode);
                if (existUser == null)
                {
                    throw new RpcException(1007, " Users not exist.", " Users not exist.");
                }
            }

            await _userServiceProxy.BingDevicesToUsersAsync(new BingDevicesToUsersRequest
            {
                DeviceCodes = new List<string> { deviceCode },
                UserCodes = userCodes.ToList()
            });
            return true;
        }
        /// <summary>
        /// 根据设备code获取设备信息
        /// </summary>
        /// <param name="request">设备code请求实体</param>
        /// <returns>返回查询到的设备对象信息</returns>
        public async Task<DeviceExtendInfoDTO> GetDeviceInfoAsync(GetDeviceRequest request)
        {
            //验证
            if (!await _authenticationServiceProxy.CheckTokenAsync(new WingInterfaceLibrary.Request.TokenRequest() { Token = request.Token }))
            {
                throw new RpcException(1002, "Permission validation error", "Permission validation error");
            }
            if (string.IsNullOrWhiteSpace(request.DeviceCode))
            {
                throw new RpcException(1001, "DeviceCode empty error", "DeviceCode empty error");
            }
            var deviceDb = await _deviceInfoDBServiceProxy.FindDeviceInfoByCodeAsync(request.DeviceCode);
            if (deviceDb == null || deviceDb.DeviceCode != request.DeviceCode)
            {
                throw new RpcException(1001, "DeviceInfo not exist error", "DeviceInfo not exist error");
            }
            //根据机构编号查询机构名称
            var organizationName = "";
            if (!string.IsNullOrEmpty(deviceDb.OrganizationCode))
            {
                var organization = await _organizationDBService.GetOrganizationDetailAsync(new GetOrganizationDBRequest { OrganizationCode = deviceDb.OrganizationCode });
                organizationName = organization?.OrganizationName ?? string.Empty;
            }
            //根据机构编号查询科室名称
            var departmentName = "";
            if (!string.IsNullOrEmpty(deviceDb.DepartmentCode))
            {
                var department = await _organizationDBService.GetOrganizationDetailAsync(new GetOrganizationDBRequest { OrganizationCode = deviceDb.DepartmentCode });
                departmentName = department?.OrganizationName ?? string.Empty;
            }
            //是否在线 todo
            var result = new DeviceExtendInfoDTO()
            {
                DepartmentName = departmentName,
                OrganizationName = organizationName,
                IsOnline = (deviceDb.Name == null ? false : ((deviceDb.Name.ToString().Length % 2 == 0) ? true : false)),
                DeviceCode = deviceDb.DeviceCode,
                SerialNumber = deviceDb.SerialNumber,
                Name = deviceDb.Name,
                Description = deviceDb.Description,
                DeviceModel = deviceDb.DeviceModel,
                DeviceType = deviceDb.DeviceType,
                HeadPicUrl = deviceDb.HeadPicUrl,
                DeviceSoftwareVersion = deviceDb.DeviceSoftwareVersion,
                SDKSoftwareVersion = deviceDb.SDKSoftwareVersion,
                OrganizationCode = deviceDb.OrganizationCode,
                DepartmentCode = deviceDb.DepartmentCode,
                ShortCode = deviceDb.ShortCode
            };
            return result;
        }

        public async Task<PageCollection<DeviceInfoDTO>> GetDeviceInfoPageAsync(PageFilterRequest request)
        {
            throw new System.NotImplementedException();
        }

        public async Task<bool> DeleteShareDeviceToUserAsync(DeleteShareDeviceToUserRequest request)
        {
            var userCodes = request.UserCodes;
            var deviceCode = request.DeviceCode;
            if (!await _authenticationServiceProxy.CheckTokenAsync(new WingInterfaceLibrary.Request.TokenRequest() { Token = request.Token }))
            {
                throw new RpcException(1002, "Permission validation error", "Permission validation error");
            }
            //检查设备编码不为空
            if (string.IsNullOrWhiteSpace(request.DeviceCode))
            {
                throw new RpcException(1004, "Required parameter:DeviceCode cannot be empty", "Required parameter:DeviceCode cannot be empty");
            }
            //用户编码集合检查
            if (userCodes == null || userCodes.Count <= 0)
            {
                throw new RpcException(1004, "Required parameter:UserCodes cannot be empty", "Required parameter:UserCodes cannot be empty");
            }
            //查询设备对象
            var deviceDb = await _deviceInfoDBServiceProxy.FindDeviceInfoByCodeAsync(deviceCode);
            if (deviceDb == null)
            {
                throw new RpcException(1007, "Device not exist.", "Device not exist.");
            }
            var updateUsers = new List<TableDataItem<UserPasswordDTO>>();
            foreach (var userCode in userCodes)
            {
                var user = await _userServiceProxy.FindUserByCodeAsync(userCode);
                if (user != null)
                {
                    if (user.BindDevices.Contains(deviceCode))
                    {
                        user.BindDevices.Remove(deviceCode);
                        updateUsers.Add(new TableDataItem<UserPasswordDTO>()
                        {
                            Data = user.MappingTo<UserPasswordDTO>(),
                        });
                    }
                }
            }
            if (updateUsers.Count > 0)
            {
                var updateUsersDBRequest = new UpdateUsersDBRequest() { Users = updateUsers };
                await _userServiceProxy.UpdateUsersAsync(updateUsersDBRequest);
            }
            return true;
        }



        /// <summary>

        /// 机构设备移除-根据机构code和设备code解除其绑定关系

        /// </summary>

        /// <param name="request">移除设备请求实体</param>

        /// <returns>移除是否成功：true-成功；false-失败</returns>

        public async Task<bool> RemoveDeviceRelevancyAsync(RemoveDeviceRelevancyRequest request)
        {
            //验证
            if (!await _authenticationServiceProxy.CheckTokenAsync(new WingInterfaceLibrary.Request.TokenRequest() { Token = request.Token }))
            {
                throw new RpcException(1002, "Permission validation error", "Permission validation error");
            }
            if (string.IsNullOrWhiteSpace(request.DeviceCode) || string.IsNullOrWhiteSpace(request.OrganizationCode))
            {
                throw new RpcException(1001, "DeviceCode Or OrganizationCode empty error", "DeviceCode Or OrganizationCode empty error");
            }
            var deviceDb = await _deviceInfoDBServiceProxy.FindDeviceInfoByCodeAsync(request.DeviceCode);
            if (deviceDb == null || deviceDb.OrganizationCode != request.OrganizationCode || deviceDb.DepartmentCode != request.DepartmentCode)
            {
                throw new RpcException(1001, "DeviceInfo not exist error", "DeviceInfo not exist error");
            }
            // //根据机构code和设备code去用户表查询关联数据，如果有则返回异常，否则就解除绑定关系；
            // var isExistUserRelevancy = false;
            // //todo 到时候调用mike的关联用户接口
            // if (isExistUserRelevancy)
            // {
            //     throw new RpcException(1001, "This Device Exist Share User error", "This Device Exist Share User error");
            // }
            //根据设备code和机构code查询相关数据，查到则删除关联
            if (!string.IsNullOrEmpty(deviceDb.DepartmentCode))
            {
                deviceDb.DepartmentCode = "";
                deviceDb.OrganizationCode = "";
            }
            else
            {
                deviceDb.OrganizationCode = "";
            }
            bool removeDeviceResult = await _deviceInfoDBServiceProxy.UpdateDeviceInfoByCodeAsync(deviceDb.DeviceCode, deviceDb, string.Empty, true);
            return removeDeviceResult;
        }

        /// <summary>
        /// 查询个人名下所有设备列表接口
        /// </summary>
        /// <param name="request">签名令牌请求信息</param>
        /// <returns>返回设备信息列表</returns>
        public async Task<List<DeviceExtendInfoDTO>> GetPersonDeviceListAsync(WingInterfaceLibrary.Request.TokenRequest request)
        {
            //验证
            var tokenInfo = await _authenticationServiceProxy.GetTokenInfoAsync(new WingInterfaceLibrary.Request.TokenRequest() { Token = request.Token });
            if (tokenInfo == null)
            {
                throw new RpcException(1002, "Permission validation error", "Permission validation error");
            }
            //查询用户是否存在
            var userInfoDO = await _userServiceProxy.FindUserByCodeAsync(tokenInfo.UserCode);
            if (userInfoDO == null)
            {
                throw new RpcException(1007, "User not exist.", "User not exist.");
            }
            var result = new List<DeviceExtendInfoDTO>();
            //查询用户的医院是否存在
            if (string.IsNullOrEmpty(userInfoDO.OrganizationCode))
            {
                throw new RpcException(1007, "User's organization not exist.", "User's organization not exist.");
            }
            //查询用户绑定的设备
            if (userInfoDO.BindDevices == null || userInfoDO.BindDevices.Count <= 0)
            {
                return result;
            }
            //根据用户名下的设备id查询所有的设备信息
            var deviceInfoDOList = await _deviceInfoDBServiceProxy.FindDeviceInfoListByCodeListAsync(userInfoDO.BindDevices);
            if (deviceInfoDOList?.Count > 0)
            {
                //根据机构编号查询机构名称
                var organizationCode = deviceInfoDOList.FindAll(c => !string.IsNullOrEmpty(c.OrganizationCode)).Select(c => c.OrganizationCode).FirstOrDefault() ?? string.Empty;
                var organization = await _organizationDBService.GetOrganizationDetailAsync(new GetOrganizationDBRequest { OrganizationCode = organizationCode });
                var organizationName = organization?.OrganizationName ?? string.Empty;
                //根据机构编号查询科室名称
                var department = await _organizationDBService.GetOrganizationDetailAsync(new GetOrganizationDBRequest { OrganizationCode = userInfoDO.OrganizationCode });
                var departmentName = department?.OrganizationName ?? string.Empty;
                //是否在线 todo
                result = deviceInfoDOList.Select(c => new DeviceExtendInfoDTO()
                {
                    DepartmentName = departmentName,
                    OrganizationName = organizationName,
                    IsOnline = (c.Name == null ? false : ((c.Name.ToString().Length % 2 == 0) ? true : false)),
                    DeviceCode = c.DeviceCode,
                    SerialNumber = c.SerialNumber,
                    Name = c.Name,
                    Description = c.Description,
                    DeviceModel = c.DeviceModel,
                    DeviceType = c.DeviceType,
                    HeadPicUrl = c.HeadPicUrl,
                    DeviceSoftwareVersion = c.DeviceSoftwareVersion,
                    SDKSoftwareVersion = c.SDKSoftwareVersion,
                    OrganizationCode = c.OrganizationCode,
                    DepartmentCode = c.DepartmentCode,
                    ShortCode = c.ShortCode
                }).ToList();
            }
            return result;
        }

        /// <summary>
        /// 绑定设备
        /// </summary>
        /// <param name="request"></param>
        /// <returns></returns>
        public async Task<bool> BindDeviceAsync(BindDeviceRequest request)
        {
            if (!await _authenticationServiceProxy.CheckTokenAsync(new WingInterfaceLibrary.Request.TokenRequest() { Token = request.Token }))
            {
                throw new RpcException(1002, "Permission validation error", "Permission validation error");
            }
            var deviceDb = await _deviceInfoDBServiceProxy.FindDeviceInfoByShortCodeAsync(request.ShortCode);
            if (deviceDb == null)
            {
                throw new RpcException(1001, "Not find device", "Not find device");
            }
            try
            {
                deviceDb.Name = request.Name;
                deviceDb.SerialNumber = request.SerialNumber;
                deviceDb.Description = request.Description;
                if (!string.IsNullOrEmpty(request.HeadPicUrl))
                {
                    // var fileName = Path.GetFileName(request.HeadPicUrl);
                    // var fileExtension = Path.GetExtension(request.HeadPicUrl);
                    // if (fileName.Contains("_"))
                    // {
                    //     deviceDb.HeadPicUrl = fileName.Replace(fileExtension, "");
                    // }
                    // else
                    // {
                    //     Enum.TryParse<UploadFileTypeEnum>(fileExtension.Replace(".", ""), out var type);
                    //     deviceDb.HeadPicUrl = fileName.Replace(fileExtension, "") + "_" + type.GetHashCode() + "_0";
                    // }
                    deviceDb.HeadPicUrl = request.HeadPicUrl.ToUrlToken();
                }
                deviceDb.OrganizationCode = request.OrganizationCode;
                deviceDb.DepartmentCode = request.DepartmentCode;
                deviceDb.IsAutoShared = request.IsAutoShared;
                if (deviceDb.IsAutoShared)
                {
                    if (await _deviceInfoDBServiceProxy.UpdateDeviceInfoByCodeAsync(deviceDb.DeviceCode, deviceDb, string.Empty))
                    {
                        var users = new List<UserDTO>();
                        if (!string.IsNullOrEmpty(deviceDb.DepartmentCode))
                        {
                            users = await _userServiceProxy.FindUserListByOrganizationCodesAsync(new List<string> { deviceDb.DepartmentCode });
                        }
                        else
                        {
                            users = await _userServiceProxy.FindUserListByOrganizationCodesAsync(new List<string> { deviceDb.OrganizationCode });
                        }
                        var userCodes = users.Select(f => f.UserCode).ToList();
                        await _userServiceProxy.BingDevicesToUsersAsync(new BingDevicesToUsersRequest
                        {
                            DeviceCodes = new List<string> { deviceDb.DeviceCode.ToString() },
                            UserCodes = userCodes.Select(f => f.ToString()).ToList()
                        });
                    }
                }
                return true;
            }
            catch (Exception ex)
            {
                Logger.WriteLineError($"BindDeviceAsync error {ex}");
            }
            return false;
        }


        /// <summary>
        /// 修改设备
        /// </summary>
        /// <param name="request"></param>
        /// <returns></returns>
        public async Task<bool> AlterDeviceAsync(AlterDeviceRequest request)
        {
            if (!await _authenticationServiceProxy.CheckTokenAsync(new WingInterfaceLibrary.Request.TokenRequest() { Token = request.Token }))
            {
                throw new RpcException(1002, "Permission validation error", "Permission validation error");
            }
            var deviceDb = await _deviceInfoDBServiceProxy.FindDeviceInfoByCodeAsync(request.DeviceCode);
            if (deviceDb == null)
            {
                throw new RpcException(1001, "Not find device", "Not find device");
            }
            deviceDb.Name = request.Name;
            deviceDb.SerialNumber = request.SerialNumber;
            deviceDb.Description = request.Description;
            deviceDb.HeadPicUrl = request.HeadPicUrl.ToUrlToken();
            deviceDb.OrganizationCode = request.OrganizationCode;
            return await _deviceInfoDBServiceProxy.UpdateDeviceInfoByCodeAsync(deviceDb.DeviceCode, deviceDb, string.Empty);
        }

        /// <summary>
        /// 创建字典
        /// </summary>
        /// <param name="request"></param>
        /// <returns></returns>
        public async Task<string> CreateDictionaryItemAsync(CreateDictionaryItemRequest request)
        {
            if (!await _authenticationServiceProxy.CheckTokenAsync(new WingInterfaceLibrary.Request.TokenRequest() { Token = request.Token }))
            {
                throw new RpcException(1002, "Permission validation error", "Permission validation error");
            }
            var tokenInfo = await _authenticationServiceProxy.GetTokenInfoAsync(new WingInterfaceLibrary.Request.TokenRequest() { Token = request.Token });
            return await _deviceInfoDBServiceProxy.CreateDictionaryItemAsync(new CreateDictionaryItemDBRequest
            {
                Data = new DictionaryDTO { DictionaryType = request.DictionaryType, Value = request.DictionaryItemValue, ParentCode = request.ParentCode },
                PlatformDatas = tokenInfo.HeaderMap,
                ExtensionData = string.Empty
            });
        }

        /// <summary>
        /// 查找设备型号所有字典项
        /// </summary>
        /// <param name="request"></param>
        /// <returns></returns>
        public async Task<List<DictionaryDTO>> FindDeviceModelItemsAsync(FindDeviceModelItemsRequest request)
        {
            if (!await _authenticationServiceProxy.CheckTokenAsync(new WingInterfaceLibrary.Request.TokenRequest() { Token = request.Token }))
            {
                throw new RpcException(1002, "Permission validation error", "Permission validation error");
            }
            var dictionaryDOList = await _deviceInfoDBServiceProxy.FindDictionaryItemsAsync(new FindDictionaryItemsDBRequest
            {
                DictionaryType = (int)request.DictionaryType,
                ParentCode = request.DeviceTypeCode
            });
            return dictionaryDOList;
        }

        /// <summary>
        /// 查找设备类型所有字典项
        /// </summary>
        /// <param name="request"></param>
        /// <returns></returns>
        public async Task<List<DictionaryDTO>> FindDeviceTypeItemsAsync(FindDeviceTypeItemsRequest request)
        {
            if (!await _authenticationServiceProxy.CheckTokenAsync(new WingInterfaceLibrary.Request.TokenRequest() { Token = request.Token }))
            {
                throw new RpcException(1002, "Permission validation error", "Permission validation error");
            }
            var dictionaryDOList = await _deviceInfoDBServiceProxy.FindDictionaryItemsAsync(new FindDictionaryItemsDBRequest
            {
                DictionaryType = (int)request.DictionaryType
            });
            return dictionaryDOList;
        }

        /// <summary>
        /// 根据组织编码查询所属全部设备信息
        /// </summary>
        /// <param name="request"></param>
        /// <returns></returns>
        public async Task<List<DeviceInfoDTO>> FindDevicesByOrganizationCodeAsync(FindDevicesByOrganizationCodeRequest request)
        {

            if (!await _authenticationServiceProxy.CheckTokenAsync(new WingInterfaceLibrary.Request.TokenRequest() { Token = request.Token }))
            {

                throw new RpcException(1002, "Permission validation error", "Permission validation error");
            }
            var deviceInfosDO = await _deviceInfoDBServiceProxy.FindDeviceInfoListByOrganizationCodeAsync(request.OrganizationCode);
            return deviceInfosDO;
        }

        public Task<DeviceInfoDTO> CreateDeviceInfoAsync(CreateDeviceRequest request)
        {
            throw new NotImplementedException();
        }

        public async Task<List<SelectItemDTO>> GetPersonDeviceDropdownListAsync(TokenRequest request)
        {
            //验证
            var tokenInfo = await _authenticationServiceProxy.GetTokenInfoAsync(request);
            if (tokenInfo == null)
            {
                throw new RpcException(1002, "Permission validation error", "Permission validation error");
            }
            //查询用户是否存在
            var userInfoDO = await _userServiceProxy.FindUserByCodeAsync(tokenInfo.UserCode);
            if (userInfoDO == null)
            {
                throw new RpcException(1007, "User not exist.", "User not exist.");
            }
            var result = new List<SelectItemDTO>();
            //查询用户的医院是否存在
            if (string.IsNullOrEmpty(userInfoDO.OrganizationCode))
            {
                throw new RpcException(1007, "User's organization not exist.", "User's organization not exist.");
            }
            //查询用户绑定的设备
            if (userInfoDO.BindDevices == null || userInfoDO.BindDevices.Count <= 0)
            {
                return result;
            }
            //根据用户名下的设备id查询所有的设备信息
            var deviceInfoDOList = await _deviceInfoDBServiceProxy.FindDeviceInfoListByCodeListAsync(userInfoDO.BindDevices);
            if (deviceInfoDOList?.Count > 0)
            {
                result = deviceInfoDOList.Select(c => new SelectItemDTO()
                {
                    Key = c.DeviceCode,
                    Value = c.Name
                }).ToList();
            }
            return result;
        }
        /// <summary>
        /// 设备端调用，查询获取服务器配置信息接口
        /// </summary>
        /// <param name="request">Token验证</param>
        /// <returns>服务器配置信息结果:key:字段，value:数据值，复杂类型可为json</returns>
        public async Task<Dictionary<string, string>> QueryServerConfig(TokenRequest request)
        {
            var cacheDeviceDTO = await GetDeviceByToken(request);            
            //设备Code编码
            var code = cacheDeviceDTO.DeviceCode;
            var dictionary = new Dictionary<string, string>();
            //定义配置字段 并扩充字段，返回数据可持续更新接口文档,如果数据是复杂类型可以转成json
            //TODO 配置信息: 直播配置、存储配置、
            //存储上传图像或者视频是 是否本地上传缩略图
            var isUploadThumbnail = ConfigurationManager.RemedicalSettings.IsUploadThumbnail;
            dictionary.Add("IsUploadThumbnail", isUploadThumbnail.ToString());
            return dictionary;
        }
    }

}