WingDeviceService/Service/ConnectService.cs

using System;
using System.Collections.Generic;
using System.Linq;
using System.Threading.Tasks;
using JsonRpcLite.Services;
using WingInterfaceLibrary.DB.Request;
using WingInterfaceLibrary.DTO.Device;
using WingInterfaceLibrary.DTO.Organization;
using WingInterfaceLibrary.Enum;
using WingInterfaceLibrary.Interface;
using WingInterfaceLibrary.Request;
using WingInterfaceLibrary.Request.Authentication;
using WingInterfaceLibrary.Request.Device;
using WingInterfaceLibrary.Result.Device;
using WingServerCommon.Log;
using WingServerCommon.Mapper;
using WingServerCommon.Service;

namespace WingDeviceService.Service
{
    /// <summary>
    /// 鉴权服务
    /// </summary>
    public partial class DeviceService : JsonRpcService, IConnectService
    {
        private readonly string _sourceUrl = "cloud.xinglinghui.com";
        private readonly object _createShortCodeLocker = new object();

        /// <summary>设备连接云服务</summary>
        /// <param name="request">请求对象</param>
        /// <returns>授权响应</returns>
        /// <remarks>POST</remarks>        
        public async Task<ConnectResult> ConnectAsync(ConnectRequest request)
        {
            try
            {
                #region Params Check

                if (string.IsNullOrWhiteSpace(request.DeviceUniqueCode))
                {
                    throw new RpcException(1001, "DeviceUniqueCode empty error", "DeviceUniqueCode empty error");
                }
                if (string.IsNullOrWhiteSpace(request.DeviceModel))
                {
                    throw new RpcException(1001, "DeviceModel empty error", "DeviceModel empty error");
                }
                if (string.IsNullOrWhiteSpace(request.DeviceType))
                {
                    throw new RpcException(1001, "DeviceType empty error", "DeviceType empty error");
                }
                if (string.IsNullOrWhiteSpace(request.SoftwareVersion))
                {
                    throw new RpcException(1001, "SoftwareVersion empty error", "SoftwareVersion empty error");
                }
                if (string.IsNullOrWhiteSpace(request.SystemVersion))
                {
                    throw new RpcException(1001, "SystemVersion empty error", "SystemVersion empty error");
                }
                if (string.IsNullOrWhiteSpace(request.CPUModel))
                {
                    throw new RpcException(1001, "CPUModel empty error", "CPUModel empty error");
                }
                if (string.IsNullOrWhiteSpace(request.SystemLanguage))
                {
                    throw new RpcException(1001, "SystemLanguage empty error", "SystemLanguage empty error");
                }

                #endregion

                var deviceDto = await _deviceInfoDBServiceProxy.FindDeviceInfoBySerialNumberAsync(request.DeviceUniqueCode);
                var shortCode = deviceDto?.ShortCode;
                var deviceCode = deviceDto?.DeviceCode;
                var deviceName = deviceDto?.Name;
                if (string.IsNullOrWhiteSpace(shortCode))
                {
                    shortCode = GenerateShortCode();
                }
                if (string.IsNullOrWhiteSpace(deviceName))
                {
                    if (deviceDto == null && !string.IsNullOrWhiteSpace(request.Name))
                    {
                        deviceName = request.Name;
                    }
                    else
                    {
                        deviceName = shortCode;
                    }
                }
                if (deviceDto == null)
                {
                    var deviceInfoDB = new DeviceInfoDTO()
                    {
                        SerialNumber = request.DeviceUniqueCode,
                        Name = request.Name,
                        Description = request.Description,
                        OrganizationCode = request.OrganizationCode,
                        DeviceModel = request.DeviceModel,
                        DeviceType = request.DeviceType,
                        DeviceSoftwareVersion = request.SoftwareVersion,
                        ShortCode = shortCode,
                        SystemVersion = request.SystemVersion,
                        CPUModel = request.CPUModel,
                        SystemLanguage = request.SystemLanguage
                    };
                    deviceCode = await _deviceInfoDBServiceProxy.InsertDeviceInfoAsync(new WingInterfaceLibrary.DB.Request.CreateDeviceInfoDBRequest
                    {
                        Data = deviceInfoDB
                    });
                    //创建虚拟机构
                    var inventedOrgCode = "invented_" + shortCode;
                    var orgData = new TableDataItem<OrganizationDTO>
                    {
                        Data = new OrganizationDTO
                        {
                            OrganizationCode = inventedOrgCode,
                            RootCode = inventedOrgCode,
                            OrganizationName = shortCode,
                            OrganizationType = OrganizationTypeEnum.Corporation,
                            State = OrganizationStateEnum.Audited,
                            RegionCode = "1000000",
                            Isinvented = true
                        },
                        PlatformDatas = new Dictionary<string, string>(),
                        ExtensionData = string.Empty,
                    };
                    await _organizationDBService.CreateOrganizationsAsync(new CreateOrganizationsDBRequest { Infos = new List<TableDataItem<OrganizationDTO>> { orgData } });
                }
                var applyRequest = new ApplyTokenRequest(AccountType.US, deviceName, request.Platform, request.LoginSource, deviceCode, _sourceUrl, 0);
                var tokenInfo = await _authenticationService.ApplyTokenAsync(applyRequest);
                if (!string.IsNullOrWhiteSpace(tokenInfo.Code))
                {
                    _deviceHeartRateManager.AddOrUpdate(tokenInfo.Code);
                }
                return new ConnectResult
                {
                    Token = tokenInfo.Code,
                    UniqueCode = shortCode
                };
            }
            catch (RpcException)
            {
                throw;
            }
            catch (Exception ex)
            {
                throw new RpcException(1001, ex.Message, ex.InnerException?.Message);
            }
        }

        /// <summary>查询当前设备信息</summary>
        /// <param name="request">请求对象</param>
        /// <returns>设备信息</returns>
        /// <remarks>POST</remarks>
        public async Task<CacheDeviceDTO> GetDeviceByTokenAsync(TokenRequest request)
        {
            var deviceCode = await ValidateTokenAsync(request.Token);
            var deviceDTO = await _deviceInfoDBServiceProxy.FindDeviceInfoByCodeAsync(deviceCode);

            var cacheDeviceInfo = deviceDTO.MappingTo<CacheDeviceDTO>();
            cacheDeviceInfo.IsOnline = await GetDeviceOnlineState(deviceCode);
            return cacheDeviceInfo;
        }

        /// <summary>设备与云服务断开连接</summary>
        /// <param name="request">请求对象</param>
        /// <returns>是否成功</returns>
        /// <value>true</value>
        public async Task<bool> DisConnectAsync(TokenRequest request)
        {
            try
            {
                await ValidateTokenAsync(request.Token);
                await _authenticationService.LogOffAsync(request);
                return true;
            }
            catch (RpcException)
            {
                throw;
            }
            catch (Exception ex)
            {
                throw new RpcException(1001, ex.Message, ex.InnerException?.Message);
            }
        }

        /// <summary>获取设备在线状态</summary>
        /// <param name="deviceCode"></param>
        /// <returns></returns>
        private async Task<bool> GetDeviceOnlineState(string deviceCode)
        {
            var tokenList = await _authenticationService.GetTokensWithClientIdAsync(new GetTokensWithClientIdRequest { ClientId = deviceCode });
            return tokenList.FirstOrDefault()?.IsOnline ?? false;
        }

        /// <summary>生成唯一 shortCode</summary>
        /// <returns></returns>
        private string GenerateShortCode()
        {
            try
            {
                lock (_createShortCodeLocker)
                {
                    var uniqueId = new byte[6];
                    var rand = new Random((int)(DateTime.Now.Ticks % 1000000));
                    for (int i = 0; i < 6; i++)
                    {
                        int randCode;
                        do
                        {
                            randCode = rand.Next(50, 90);
                            uniqueId[i] = Convert.ToByte(randCode);
                        } while (randCode >= 58 && randCode <= 64 || randCode == 79 || randCode == 73);
                    }

                    return System.Text.Encoding.ASCII.GetString(uniqueId);
                }
            }
            catch (Exception ex)
            {
                Logger.WriteLineError($"GenerateShortCode error {ex}");
            }
            return string.Empty;
        }

    }
}