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()
        {
            using (var scope = this.applicationServices.CreateScope())
            {
                var nodeRepo = scope.ServiceProvider.GetService<IRepository<Node>>();
                var nodeDto = nodeRepo.ReadOnlyTable().FirstOrDefault().To<NodeDto>();
                this.SendNode(nodeDto);

                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<ProductDto>();
                    productDto.CategoryNumber = product.Category.Number;
                    this.SendProduct(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();
                foreach (var device in devices)
                {
                    var deviceDto = device.To<DeviceDto>();
                    deviceDto.ProductNumber = device.Product.Number;
                    deviceDto.NodeNumber = device.Node.Number;
                    this.SendDevice(deviceDto);
                    var dataDtoList = new List<DataDto>();
                    foreach (var deviceData in device.Data.Where(o => !o.Hidden))
                    {
                        var dataDto = deviceData.To<DataDto>();
                        dataDto.DeviceNumber = device.Number;
                        dataDtoList.Add(dataDto);
                    }
                    this.SendData(dataDtoList);
                }
            }
        }

        public override void OnServerToClient(string method, string message, string fromConnectionId)
        {
            if (method == Methods.HealthCheckRequest)
            {
                this.ClientToServer(Methods.HealthCheckResponse, this._cfg["node.number"]);
            }
            else if (method == Methods.ProductRequest)
            {
                var infoNumber = message;
                using (var scope = this.applicationServices.CreateScope())
                {
                    var productRepo = scope.ServiceProvider.GetService<IRepository<Product>>();
                    var product = productRepo.ReadOnlyTable().Include(o => o.Category).FirstOrDefault(o => o.Number == infoNumber);
                    if (product == null)
                    {
                        throw new Exception($"not has infoNumber:{infoNumber}");
                    }
                    var productDto = product.To<ProductDto>();
                    productDto.CategoryNumber = product.Category.Number;
                    this.SendProduct(productDto);
                }
            }
            else if (method == Methods.CallApi)
            {
                using (var scope = this.applicationServices.CreateScope())
                {
                    var serviceProvider = scope.ServiceProvider;
                    var cfg = serviceProvider.GetService<IConfiguration>();
                    var port = cfg["server.urls"].Split(':')[2];
                    var url = $"http://localhost:{port}{message}";
                    var httpClient = serviceProvider.GetService<IHttpClientFactory>().CreateClient();
                    var result = httpClient.GetStringAsync(url).Result;
                    this.Connection.SendAsync(Methods.ClientToServer, Methods.ApiCallback, result, cfg["connectId"]);
                }
            }
            else if (method == Methods.EditNodeRequest)
            {
                var model = message.FromJson<NodeDto>();
                using (var scope = this.applicationServices.CreateScope())
                {
                    var nodeRepo = scope.ServiceProvider.GetService<IRepository<Node>>();
                    var node = nodeRepo.Table().FirstOrDefault(o => o.Number == model.Number);
                    if (node != null)
                    {
                        node.From(model);
                        nodeRepo.SaveChanges();
                        var nodeDto = node.To<NodeDto>();
                        this.ClientToServer(Methods.EditNodeResponse, nodeDto.ToJson());
                    }
                }
            }
            else if (method == Methods.EditDeviceRequest)
            {
                var model = message.FromJson<DeviceDto>();
                using (var scope = this.applicationServices.CreateScope())
                {
                    var deviceRepo = scope.ServiceProvider.GetService<IRepository<Device>>();
                    var device = deviceRepo.Table().FirstOrDefault(o => o.Number == model.Number);
                    if (device != null)
                    {
                        device.From(model);
                        deviceRepo.SaveChanges();
                        var deviceDto = device.To<DeviceDto>();
                        deviceDto.NodeNumber = model.NodeNumber;
                        deviceDto.ProductNumber = model.ProductNumber;
                        this.ClientToServer(Methods.EditDeviceResponse, deviceDto.ToJson());
                    }
                }
            }
            else if (method == Methods.DeleteDeviceRequest)
            {
                using (var scope = this.applicationServices.CreateScope())
                {
                    var deviceRepo = scope.ServiceProvider.GetService<IRepository<Device>>();
                    var device = deviceRepo.Table().FirstOrDefault(o => o.Number == message);
                    if (device != null)
                    {
                        deviceRepo.Delete(device);
                        deviceRepo.SaveChanges();
                        this.ClientToServer(Methods.DeleteDeviceResponse, message);
                    }
                }
            }
            else if (method == Methods.EditDataRequest)
            {
                var model = message.FromJson<DataDto>();
                using (var scope = this.applicationServices.CreateScope())
                {
                    var dataRepo = scope.ServiceProvider.GetService<IRepository<Data>>();
                    var data = dataRepo.Table().FirstOrDefault(o => o.Key == model.Key);
                    if (data != null)
                    {
                        data.From(model);
                        dataRepo.SaveChanges();
                        var dataDto = data.To<DataDto>();
                        dataDto.DeviceNumber = model.DeviceNumber;
                        this.ClientToServer(Methods.EditDataResponse, dataDto.ToJson());
                    }
                }
            }
            else if (method == Methods.DeleteDataRequest)
            {
                using (var scope = this.applicationServices.CreateScope())
                {
                    var dataRepo = scope.ServiceProvider.GetService<IRepository<Data>>();
                    var data = dataRepo.Table().FirstOrDefault(o => o.Key == message);
                    if (data != null)
                    {
                        dataRepo.Delete(data);
                        dataRepo.SaveChanges();
                        this.ClientToServer(Methods.DeleteDataResponse, message);
                    }
                }
            }
        }

        public void SendNode(NodeDto node)
        {
            Task.Run(() =>
            {
                try
                {
                    Console.WriteLine("send node to server");
                    this.ClientToServer(Methods.NodeResponse, node.ToJson());
                }
                catch (Exception ex)
                {
                    ex.PrintStack();
                }
            });
        }

        public void SendProduct(ProductDto product)
        {
            Task.Run(() =>
            {
                try
                {
                    Console.WriteLine("send product to server");
                    this.ClientToServer(Methods.ProductResponse, product.ToJson());
                }
                catch (Exception ex)
                {
                    ex.PrintStack();
                }
            });
        }

        public void SendDevice(DeviceDto device)
        {
            Task.Run(() =>
            {
                try
                {
                    Console.WriteLine("send device to server");
                    this.ClientToServer(Methods.DeviceResponse, device.ToJson());
                }
                catch (Exception ex)
                {
                    ex.PrintStack();
                }
            });
        }

        public void SendData(List<DataDto> dataList)
        {
            Task.Run(() =>
            {
                try
                {
                    Console.WriteLine("send data to server");
                    this.ClientToServer(Methods.DataResponse, dataList.ToJson());
                }
                catch (Exception ex)
                {
                    ex.PrintStack();
                }
            });
        }
    }
}