iot/projects/IoT/IoT.Shared/Infrastructure/ClientService.cs

using Application.Domain.Entities;
using Application.Models;
using Infrastructure.Data;
using Infrastructure.Extensions;
using Microsoft.AspNetCore.SignalR.Client;
using Microsoft.EntityFrameworkCore;
using Microsoft.Extensions.Configuration;
using Microsoft.Extensions.DependencyInjection;
using System;
using System.Collections.Generic;
using System.Linq;
using System.Net.Http;
using System.Threading.Tasks;

namespace IoT.Shared.Infrastructure
{
    public class ClientService : BaseClientService
    {
        public ClientService(IServiceProvider applicationServices, IConfiguration configuration) : base(applicationServices, configuration)
        {
        }

        public override void OnConnected()
        {
            Console.WriteLine($"{_notifyHost} OnConnected");
            this.UpdateServer();
        }

        [System.Diagnostics.CodeAnalysis.SuppressMessage("Design", "CA1031:不捕获常规异常类型", Justification = "<挂起>")]
        public override void OnServerToClient(string method, string message, string fromConnectionId)
        {
            using var scope = this.applicationServices.CreateScope();
            if (method == Methods.HealthCheckRequest)
            {
                this.ClientToServer(Methods.HealthCheckResponse, this._cfg["sn"]);
            }
            else if (method == Methods.GetProductRequest)
            {
                var productNumber = message;
                var productRepo = scope.ServiceProvider.GetService<IRepository<Product>>();
                var product = productRepo.ReadOnlyTable().Include(o => o.Category).FirstOrDefault(o => o.Number == productNumber);
                if (product == null)
                {
                    throw new Exception($"not has infoNumber:{productNumber}");
                }
                var model = product.To<EditProductModel>();
                model.CategoryNumber = product.Category.Number;
                this.SendToServer(Methods.GetProductResponse, model);
            }
            else if (method == Methods.CallApi)
            {
                var cfg = scope.ServiceProvider.GetService<IConfiguration>();
                var port = cfg["server.urls"].Split(':')[2];
                var url = $"http://localhost:{port}{message}";
                var httpClient = scope.ServiceProvider.GetService<IHttpClientFactory>().CreateClient();
                var result = httpClient.GetStringAsync(url).Result;
                this.Connection.SendAsync(Methods.ClientToServer, Methods.ApiCallback, result, cfg["sn"]);
            }
            else if (method == Methods.CallScene)
            {
                var commandRepo = scope.ServiceProvider.GetService<IRepository<Command>>();
                var commands = commandRepo.ReadOnlyTable()
                    .Include(o => o.Api)
                    .Include(o => o.Device)
                    //.Where(o => o.Scene.Name == message)
                    .ToList();
                foreach (var command in commands)
                {
                    try
                    {
                        var cfg = scope.ServiceProvider.GetService<IConfiguration>();
                        var port = cfg["server.urls"].Split(':')[2];
                        var url = $"http://localhost:{port}{command.Api.Path}{command.Api.Command}?number={command.Device.Number}{(string.IsNullOrEmpty(command.QueryString) ? "" : "&")}{command.QueryString}";
                        var httpClient = scope.ServiceProvider.GetService<IHttpClientFactory>().CreateClient();
                        var result = httpClient.GetStringAsync(url).Result;
                    }
                    catch (Exception ex)
                    {
                        ex.PrintStack();
                    }
                }
            }
            else if (method == Methods.RefreshNodeRequest)
            {
                this.UpdateServer();
            }
            else if (method == Methods.EditNodeRequest)
            {
                var model = message.FromJson<EditNodeModel>();
                var nodeRepo = scope.ServiceProvider.GetService<IRepository<Node>>();
                var node = nodeRepo.Table().FirstOrDefault(o => o.Number == model.Number);
                if (node != null)
                {
                    node.FromDto(model);
                    nodeRepo.SaveChanges();
                    this.ClientToServer(Methods.EditNodeResponse, message);
                }
            }
            else if (method == Methods.EditDeviceRequest)
            {
                var model = message.FromJson<EditDeviceModel>();
                var deviceRepo = scope.ServiceProvider.GetService<IRepository<Device>>();
                var device = deviceRepo.Table().FirstOrDefault(o => o.Number == model.Number);
                if (device != null)
                {
                    device.FromDto(model);
                    deviceRepo.SaveChanges();
                    this.ClientToServer(Methods.EditDeviceResponse, message);
                }
            }
            else if (method == Methods.DeleteDeviceRequest)
            {
                var deviceRepo = scope.ServiceProvider.GetService<IRepository<Device>>();
                var model = message.FromJson<EditDeviceModel>();
                var device = deviceRepo.Table().FirstOrDefault(o => o.Number == model.Number);
                if (device != null)
                {
                    deviceRepo.Delete(device);
                    deviceRepo.SaveChanges();
                    this.ClientToServer(Methods.DeleteDeviceResponse, message);
                }
            }
            else if (method == Methods.EditDataRequest)
            {
                var model = message.FromJson<EditDataModel>();
                var dataRepo = scope.ServiceProvider.GetService<IRepository<Data>>();
                var data = dataRepo.Table().FirstOrDefault(o => o.Device.Number == model.DeviceNumber && o.Key == model.Key);
                if (data != null)
                {
                    data.FromDto(model);
                    dataRepo.SaveChanges();
                    this.ClientToServer(Methods.EditDataResponse, new List<EditDataModel>() { model }.ToJson());
                }
            }
            else if (method == Methods.DeleteDataRequest)
            {
                var model = message.FromJson<EditDataModel>();
                var dataRepo = scope.ServiceProvider.GetService<IRepository<Data>>();
                var data = dataRepo.Table().FirstOrDefault(o => o.Device.Number == model.DeviceNumber && o.Key == model.Key);
                if (data != null)
                {
                    dataRepo.Delete(data);
                    dataRepo.SaveChanges();
                    this.ClientToServer(Methods.DeleteDataResponse, message);
                }
            }
            else if (method == Methods.EditSceneRequest)
            {
                var model = message.FromJson<EditSceneModel>();
                var nodeRepo = scope.ServiceProvider.GetService<IRepository<Node>>();
                var sceneRepo = scope.ServiceProvider.GetService<IRepository<Scene>>();
                var scene = sceneRepo.Table().FirstOrDefault(o => o.Id == model.Id);
                if (scene == null)
                {
                    scene = new Scene
                    {
                        Id = model.Id
                    };
                    sceneRepo.Add(scene);
                }
                scene.FromDto(model);
                scene.NodeId = nodeRepo.ReadOnlyTable().FirstOrDefault(o => o.Number == model.NodeNumber).Id;
                sceneRepo.SaveChanges();
                this.ClientToServer(Methods.EditSceneResponse, message);
            }
            else if (method == Methods.DeleteSceneRequest)
            {
                var model = message.FromJson<EditSceneModel>();
                var sceneRepo = scope.ServiceProvider.GetService<IRepository<Scene>>();
                var scene = sceneRepo.Table().FirstOrDefault(o => o.Id == model.Id);
                if (scene != null)
                {
                    sceneRepo.Delete(scene);
                    sceneRepo.SaveChanges();
                }
                this.ClientToServer(Methods.DeleteSceneResponse, message);
            }
            else if (method == Methods.EditCommandRequest)
            {
                var model = message.FromJson<EditCommandModel>();
                var commandRepo = scope.ServiceProvider.GetService<IRepository<Command>>();
                var apiRepo = scope.ServiceProvider.GetService<IRepository<Api>>();
                var deviceRepo = scope.ServiceProvider.GetService<IRepository<Device>>();
                var device = deviceRepo.ReadOnlyTable().FirstOrDefault(o => o.Number == model.DeviceNumber);

                var command = commandRepo.Table().FirstOrDefault(o => o.Id == model.Id);
                if (command == null)
                {
                    command = new Command
                    {
                        Id = model.Id
                    };
                    commandRepo.Add(command);
                }
                command.FromDto(model);
                command.DeviceId = device.Id;
                command.ApiId = apiRepo.ReadOnlyTable().Where(o => o.ProductId == device.ProductId && o.Name == model.ApiName).FirstOrDefault().Id;
                commandRepo.SaveChanges();
                this.ClientToServer(Methods.EditCommandResponse, message);
            }
            else if (method == Methods.DeleteCommandRequest)
            {
                var model = message.FromJson<EditCommandModel>();
                var commandRepo = scope.ServiceProvider.GetService<IRepository<Command>>();
                var command = commandRepo.Table().FirstOrDefault(o => o.Id == model.Id);
                if (command != null)
                {
                    commandRepo.Delete(command);
                    commandRepo.SaveChanges();
                }
                this.ClientToServer(Methods.DeleteCommandResponse, message);
            }
            else if (method == Methods.EditSceneCommandRequest)
            {
                var model = message.FromJson<EditSceneCommandModel>();
                var sceneRepo = scope.ServiceProvider.GetService<IRepository<Scene>>();
                var commandRepo = scope.ServiceProvider.GetService<IRepository<Command>>();
                var scene = sceneRepo.Table().FirstOrDefault(o => o.Id == model.Id);
                var command = commandRepo.Table().FirstOrDefault(o => o.Id == model.Id);
                var sceneCommandRepo = scope.ServiceProvider.GetService<IRepository<SceneCommand>>();
                var sceneCommand = sceneCommandRepo.Table().FirstOrDefault(o => o.Id == model.Id);
                if (sceneCommand == null)
                {
                    sceneCommand = new SceneCommand
                    {
                        Id = model.Id
                    };
                    sceneCommandRepo.Add(sceneCommand);
                }
                sceneCommand.SceneId = model.SceneId.Value;
                sceneCommand.CommandId = model.CommandId.Value;
                sceneCommandRepo.SaveChanges();
                this.ClientToServer(Methods.EditSceneCommandResponse, message);
            }
            else if (method == Methods.DeleteSceneCommandRequest)
            {
                var model = message.FromJson<EditCommandModel>();
                var sceneCommandRepo = scope.ServiceProvider.GetService<IRepository<SceneCommand>>();
                var sceneCommand = sceneCommandRepo.Table().FirstOrDefault(o => o.Id == model.Id);
                if (sceneCommand != null)
                {
                    sceneCommandRepo.Delete(sceneCommand);
                    sceneCommandRepo.SaveChanges();
                }
                this.ClientToServer(Methods.DeleteSceneCommandResponse, message);
            }
        }

        private void UpdateServer()
        {
            using var scope = this.applicationServices.CreateScope();
            //同步Node
            var nodeRepo = scope.ServiceProvider.GetService<IRepository<Node>>();
            var nodeDto = nodeRepo.ReadOnlyTable().FirstOrDefault().To<EditNodeModel>();
            this.SendToServer(Methods.EditNodeResponse, nodeDto);

            //同步Product
            var productRepo = scope.ServiceProvider.GetService<IRepository<Product>>();
            var products = productRepo.ReadOnlyTable()
                .Include(o => o.Category)
                .ToList();
            foreach (var product in products)
            {
                var productDto = product.To<EditProductModel>();
                productDto.CategoryNumber = product.Category.Number;
                this.SendToServer(Methods.GetProductResponse, productDto);
            }

            var deviceRepo = scope.ServiceProvider.GetService<IRepository<Device>>();
            var devices = deviceRepo.ReadOnlyTable()
                .Include(o => o.Product)
                .Include(o => o.Node)
                .Include(o => o.Data).ToList();

            //从服务器删除节点已经删除的设备
            this.SendToServer(Methods.RefreshDeviceListResponse, devices.Select(o => o.Number).ToList());

            //同步设备及其数据
            foreach (var device in devices)
            {
                var deviceDto = device.To<EditDeviceModel>();
                deviceDto.ProductNumber = device.Product.Number;
                deviceDto.NodeNumber = device.Node.Number;
                this.SendToServer(Methods.EditDeviceResponse, deviceDto);
                var dataDtoList = new List<EditDataModel>();
                foreach (var deviceData in device.Data.Where(o => !o.Hidden))
                {
                    var dataDto = deviceData.To<EditDataModel>();
                    dataDto.DeviceNumber = device.Number;
                    dataDtoList.Add(dataDto);
                }
                this.SendToServer(Methods.EditDataResponse, dataDtoList);
            }

            var sceneRepo = scope.ServiceProvider.GetService<IRepository<Scene>>();
            var scenes = sceneRepo.ReadOnlyTable().Include(o => o.Node).ToList();
            //从服务器删除节点已经删除的场景
            this.SendToServer(Methods.RefreshSceneListResponse, scenes.Select(o => o.Id).ToList());
            //同步场景
            foreach (var scene in scenes)
            {
                var sceneDto = scene.To<EditSceneModel>();
                sceneDto.NodeNumber = scene.Node.Number;
                this.SendToServer(Methods.EditSceneResponse, sceneDto);
            }

            var commandRepo = scope.ServiceProvider.GetService<IRepository<Command>>();
            var commands = commandRepo.ReadOnlyTable().Include(o => o.Api).Include(o => o.Device).ThenInclude(o => o.Node).ToList();
            //从服务器删除节点已经删除的命令
            this.SendToServer(Methods.RefreshCommandListResponse, commands.Select(o => o.Id).ToList());
            //同步命令
            foreach (var command in commands)
            {
                var commandDto = command.To<EditCommandModel>();
                commandDto.NodeNumber = command.Device.Node.Number;
                commandDto.DeviceNumber = command.Device.Number;
                commandDto.ApiName = command.Api.Name;
                this.SendToServer(Methods.EditCommandResponse, commandDto);
            }
        }

        [System.Diagnostics.CodeAnalysis.SuppressMessage("Design", "CA1031:不捕获常规异常类型", Justification = "<挂起>")]
        public void SendToServer(string method, object data)
        {
            Task.Run(() =>
            {
                try
                {
                    Console.WriteLine($"send node to server {_notifyHost}");
                    this.ClientToServer(method, data.ToJson());
                }
                catch (Exception ex)
                {
                    ex.PrintStack();
                }
            });
        }
    }
}