iot/projects/IoT.Shared/Services/DataService.cs

using Application.Domain.Entities;
using Infrastructure.Application;
using Infrastructure.Data;
using Infrastructure.Domain;
using Infrastructure.Events;
using Infrastructure.Extensions;
using Microsoft.EntityFrameworkCore;
using Microsoft.Extensions.DependencyInjection;
using System;
using System.Collections.Generic;
using System.Linq;
using System.Linq.Expressions;

namespace IoT.Shared.Services
{
    public class DataService
    {
        private readonly IServiceProvider _services;

        public DataService(IServiceProvider services)
        {
            this._services = services;
        }

        public void UpdateList<T>(string message, Expression<Func<T, bool>> predicate) where T : BaseEntity
        {
            using var scope = this._services.CreateScope();
            var repo = scope.ServiceProvider.GetService<IRepository<T>>();
            var list = message.FromJson<List<Guid>>();
            var entities = repo.Table().Where(predicate).Where(o => !list.Contains(o.Id)).ToList();
            foreach (var entity in entities)
            {
                repo.Delete(entity);
                if (repo.SaveChanges() > 0)
                {
                    var eventPublisher = scope.ServiceProvider.GetService<IEventPublisher>();
                    eventPublisher.Publish(new EntityDeletedEvent<T>(entity));
                }
            }
        }

        #region private

        public void Update<T>(string message) where T : BaseEntity
        {
            using var scope = this._services.CreateScope();
            var repo = scope.ServiceProvider.GetService<IRepository<T>>();
            var model = message.FromJson<T>();
            var entity = repo.Table().FirstOrDefault(o => o.Id == model.Id);
            var isNew = false;
            if (entity == null)
            {
                entity = Activator.CreateInstance<T>();
                repo.Add(entity);
                isNew = true;
            }
            entity.From(model);
            if (repo.SaveChanges() > 0)
            {
                var eventPublisher = scope.ServiceProvider.GetService<IEventPublisher>();
                if (isNew)
                {
                    eventPublisher.Publish(new EntityInsertedEvent<T>(entity));
                }
                else
                {
                    eventPublisher.Publish(new EntityUpdatedEvent<T>(entity));
                }
            }
        }

        public T Edit<T, TEditModel>(TEditModel model)
            where T : BaseEntity
            where TEditModel : EditModel
        {
            using var scope = this._services.CreateScope();
            var repo = scope.ServiceProvider.GetService<IRepository<T>>();
            var entity = repo.Table().FirstOrDefault(o => o.Id == model.Id);
            var isNew = false;
            if (entity == null)
            {
                entity = Activator.CreateInstance<T>();
                repo.Add(entity);
                isNew = true;
            }
            entity.From(model);
            if (repo.SaveChanges() > 0)
            {
                if (entity is Data)
                {
                    var data = entity as Data;
                    data.Device = scope.ServiceProvider.GetService<IRepository<Device>>().ReadOnlyTable().Include(o => o.Node)
                        .Where(o => o.Id == data.DeviceId)
                        .Select(o => new Device { DisplayName = o.DisplayName, Node = new Node { Name = o.Node.Name } }).FirstOrDefault();
                }
                var eventPublisher = scope.ServiceProvider.GetService<IEventPublisher>();
                if (isNew)
                {
                    eventPublisher.Publish(new EntityInsertedEvent<T>(entity));
                }
                else
                {
                    eventPublisher.Publish(new EntityUpdatedEvent<T>(entity));
                }
            }
            return entity;
        }

        public void Delete<T, TEditModel>(TEditModel model)
            where T : BaseEntity
            where TEditModel : EditModel
        {
            try
            {
                using var scope = this._services.CreateScope();
                var repo = scope.ServiceProvider.GetService<IRepository<T>>();
                var entity = repo.Table().FirstOrDefault(o => o.Id == model.Id);
                if (entity != null)
                {
                    repo.Delete(entity);
                    if (repo.SaveChanges() > 0)
                    {
                        var eventPublisher = scope.ServiceProvider.GetService<IEventPublisher>();
                        eventPublisher.Publish(new EntityDeletedEvent<T>(entity));
                    }
                }
            }
            catch (Exception ex)
            {
                ex.PrintStack();
            }
        }

        #endregion private
    }
}