iot/projects/IoTNode/DeviceServices/BaseDeviceService.cs

using Application.Domain.Entities;
using Application.Models;
using Infrastructure.Data;
using Infrastructure.Events;
using Infrastructure.Extensions;
using IoT.Shared.Services;
using Microsoft.Extensions.Configuration;
using Microsoft.Extensions.DependencyInjection;
using Microsoft.Extensions.Hosting;
using System;
using System.Linq;
using System.Threading;
using System.Threading.Tasks;

namespace IoTNode.DeviceServices
{
    public abstract class BaseDeviceService : IHostedService
    {
        internal readonly IServiceProvider _applicationServices;
        internal readonly IConfiguration _configuration;

        public BaseDeviceService(IServiceProvider applicationServices, IConfiguration configuration)
        {
            this._applicationServices = applicationServices;
            this._configuration = configuration;
        }

        public virtual Task StartAsync(CancellationToken cancellationToken)
        {
            Task.Run(async () =>
            {
                while (!cancellationToken.IsCancellationRequested)
                {
                    try
                    {
                        Execute();
                    }
                    catch (Exception ex)
                    {
                        ex.PrintStack();
                    }
                    await Task.Delay(_configuration.GetValue("timer.seconds", 60) * 1000).ConfigureAwait(true);
                }
            });
            return Task.CompletedTask;
        }

        public abstract void Execute();

        public virtual Task StopAsync(CancellationToken cancellationToken)
        {
            return Task.CompletedTask;
        }

        public void SendToServer(string method, object data)
        {
            Console.WriteLine("send device to server");
            using var scope = _applicationServices.CreateScope();
            var iotNodeClient = scope.ServiceProvider.GetService<IoTNodeClient>();
            iotNodeClient.ClientToServer(method, data);
        }

        public void SendDataToServer(Data data)
        {
            using var scope = _applicationServices.CreateScope();
            var iotNodeClient = scope.ServiceProvider.GetService<IoTNodeClient>();
            iotNodeClient.ClientToServer($"Edit{typeof(Data).Name}", data.To<EditDataModel>());
            var eventPubliser = scope.ServiceProvider.GetService<IEventPublisher>();
            eventPubliser.Publish(new EntityUpdatedEvent<Data>(data));
        }

        public Product UpdateProduct(string productName, string productNumber, string path, string categoryNumber, string productIcon)
        {
            var scope = _applicationServices.CreateScope();

            var categoryRepo = scope.ServiceProvider.GetService<IRepository<Category>>();
            var productRepo = scope.ServiceProvider.GetService<IRepository<Product>>();
            var product = productRepo.ReadOnlyTable().FirstOrDefault(o => o.Number == productNumber);
            if (product == null)
            {
                product = new Product
                {
                    Number = productNumber,
                    Name = productName,
                    Icon = productIcon,
                    CategoryId = categoryRepo.ReadOnlyTable().FirstOrDefault(o => o.Number == categoryNumber).Id
                };
                if (!string.IsNullOrEmpty(path))
                {
                    var iotNodeClient = scope.ServiceProvider.GetService<IoTNodeClient>();
                    product.ApiJson = iotNodeClient.GetApiJson(path);
                }
                OpenApiService.UpdateApi(product);
                productRepo.Add(product);
                productRepo.SaveChanges();
                this.SendToServer(Methods.UpdateProductResponse, product);
            }
            return product;
        }
    }
}