src/AppRemoteConfig/Services/ApplicationService.cs - trunk - qwiklly/arc-server

src/AppRemoteConfig/Services/ApplicationService.cs
293 строки11 KB
CLTanuki
chore: modules exploded
24 янв 2024, 18:53
24 янв 2024, 18:536b5ba70
namespace AppRemoteConfig.Services
{
    using System.Security.Claims;
    using AppRemoteConfig.Models;
    using AppRemoteConfig.Models.Database;
    using AppRemoteConfig.Models.Dto;
    using AppRemoteConfig.Services.Interfaces;
    using Microsoft.AspNetCore.Components.Authorization;
    using Microsoft.EntityFrameworkCore;
    using Microsoft.Extensions.Logging;

    public class ApplicationService : IApplicationService
    {
        private readonly ILogger<ApplicationService> _logger;
        private readonly ApplicationContext _dbContext;
        private readonly AuthenticationStateProvider _authenticationStateProvider;
        

        public ApplicationService(
            ILogger<ApplicationService> logger,
            ApplicationContext dbContext,
            AuthenticationStateProvider authenticationStateProvider)
        {
            
            this._logger = logger;
            this._dbContext = dbContext;
            this._authenticationStateProvider = authenticationStateProvider;
        }

        public async Task<IEnumerable<ApplicationEntityDto>> ListApplications(bool includeArchived=false)
        {
            var apps = await this.GetAvailableApps();
            if (!includeArchived)
            {
                apps = apps.Where(app => app.IsArchive == false);
            }

            var appsList = await apps.ToListAsync(); 
            return appsList.ConvertAll(Converters.AppEntityToDto);
        }

        public async Task<ApplicationEntityDto?> GetApplication(Guid appId)
        {
            var app = await this._dbContext.Applications.FindAsync(appId);

            return app == null ? null : (ApplicationEntityDto) app;
        }

        public async Task<ApplicationEntityDto?> CreateApplication(ApplicationEntityDto application)
        {
            var organization = await this._dbContext.Organizations.FindAsync(application.OrganizationId);
            if (organization == null)
            {
                return null;
            }

            var newApp = new Application()
            {
                Title = application.Title,
                Description = application.Description,
                Organization = organization
            };
            var savedApp = await this._dbContext.Applications.AddAsync(newApp);
            await this._dbContext.SaveChangesAsync();
        
            return Converters.AppEntityToDto(savedApp.Entity);
        }

        public async Task<ApplicationEntityDto?> PutApplication(ApplicationEntityDto application)
        {
            if (application.Id.HasValue && !ApplicationExists(application.Id.Value))
            {
                return null;
            }

            this._dbContext.Update(Converters.AppDtoToEntity(application));
            await this._dbContext.SaveChangesAsync();

            return application;
        }

        private bool ApplicationExists(Guid id)
        {
            return this._dbContext.Applications.Any(e => e.Id == id);
        }

        public async Task<bool> DeleteApplication(Guid id)
        {
            var application = await this._dbContext.Applications.FindAsync(id);
            if (application == null)
            {
                this._logger.LogError("App with the ID provided was not found");
                return false;
            }

            this._dbContext.Applications.Remove(application);
            await this._dbContext.SaveChangesAsync();

            return true;
        }

        public async Task<AppVersionEntityDto?> GetApplicationVersion(Guid versionId)
        {
            var appVersion = await this._dbContext.Versions.FindAsync(versionId);

            return appVersion == null ? null : Converters.AppVersionEntityToDto(appVersion);
        }

        public async Task<AppVersionEntityDto[]> ListApplicationVersions()
        {
            var apps = await this.GetAvailableApps();
            var appVersions = await apps.SelectMany(app => app.Versions).ToListAsync();

            return appVersions.ConvertAll(Converters.AppVersionEntityToDto).ToArray();
        }

        public async Task<AppVersionEntityDto[]> ListApplicationVersions(Guid appId)
        {
            var app = await this._dbContext.Applications.Include(application => application.Versions).FirstOrDefaultAsync(app => app.Id == appId);
            if (app == null)
            {
                return Array.Empty<AppVersionEntityDto>();
            }

            var versions = app.Versions.ConvertAll(Converters.AppVersionEntityToDto);
            return versions.ToArray();
        }

        public async Task<AppVersionEntityDto?> CreateApplicationVersion(AppVersionEntityDto applicationVersion)
        {
            var app = await this._dbContext.Applications.FindAsync(applicationVersion.ApplicationId);
            if (app == null)
            {
                return null;
            }

            var newVersion = new AppVersion()
            {
                Description = applicationVersion.Description,
                Major = applicationVersion.Major,
                Minor = applicationVersion.Minor,
                Patch = applicationVersion.Patch,
                Application = app
            };
            var savedVersion = this._dbContext.Versions.Add(newVersion);
            await this._dbContext.SaveChangesAsync();
        
            return Converters.AppVersionEntityToDto(savedVersion.Entity);
        }

        public async Task<AppVersionEntityDto?> PutApplicationVersion(AppVersionEntityDto applicationVersion)
        {
            if (applicationVersion.Id.HasValue && !ApplicationVersionExists(applicationVersion.Id.Value))
            {
                return null;
            }

            this._dbContext.SetModified(Converters.AppVersionDtoToEntity(applicationVersion));
            await this._dbContext.SaveChangesAsync();

            return applicationVersion;
        }

        private bool ApplicationVersionExists(Guid id)
        {
            return this._dbContext.Versions.Any(e => e.Id == id);
        }
    
        public async Task<bool> DeleteApplicationVersion(Guid id)
        {
            var version = await this._dbContext.Versions.FindAsync(id);
            if (version == null)
            {
                this._logger.LogError("App version with the ID provided was not found");
                return false;
            }

            this._dbContext.Versions.Remove(version);
            await this._dbContext.SaveChangesAsync();

            return true;
        }
        public async Task<ValueFlagEntityDto?> GetValueFlag(Guid flagId)
        {
            var valueFlag = await _dbContext.ValueFlags
                .Include(flag => flag.Application)
                .Include(flag => flag.ApplicableVersions)
                .FirstOrDefaultAsync(flag => flag.Id == flagId);

            var response = valueFlag == null ? null : Converters.ValueFlagEntityToDto(valueFlag);
            return response;
        }

        public async Task<ValueFlagEntityDto[]?> ListValueFlags()
        {
            var apps = await this.GetAvailableApps();
            var valueFlagsQueryable = apps.SelectMany(app => app.ValueFlags);
            var valueFlags = await valueFlagsQueryable.Include(flag => flag.Application).Include(flag => flag.ApplicableVersions).ToListAsync();

            return valueFlags.ConvertAll(Converters.ValueFlagEntityToDto).ToArray();
        }

        public async Task<ValueFlagEntityDto[]?> ListApplicationValueFlags(Guid id)
        {
            var valueFlags = await _dbContext.ValueFlags.Where(flag => flag.Application.Id == id).ToListAsync();

            return valueFlags.ConvertAll(Converters.ValueFlagEntityToDto).ToArray();
        }

        public async Task<ValueFlagEntityDto?> CreateValueFlag(ValueFlagEntityDto valueFlag)
        {
            var app = await this._dbContext.Applications.FindAsync(valueFlag.ApplicationId);
            if (app == null)
            {
                return null;
            }

            var newFlag = Converters.ValueFlagCreateRequestToEntity(valueFlag);
            newFlag.Application = app;
            foreach (var versionId in valueFlag.ApplicableVersionIds)
            {
                var version = await this._dbContext.Versions.FindAsync(versionId);
                if (version == null)
                {
                    return null;
                }
            
                newFlag.ApplicableVersions.Add(version);
            }
            var savedFlag = this._dbContext.ValueFlags.Add(newFlag);
        
            await this._dbContext.SaveChangesAsync();
            var resultingFlag = await this._dbContext.ValueFlags.FindAsync(savedFlag.Entity.Id);
        
            return Converters.ValueFlagEntityToDto(resultingFlag!);
        }

        public async Task<ValueFlagEntityDto?> PutValueFlag(ValueFlagEntityDto valueFlagDto)
        {
            if (valueFlagDto.Id.HasValue && !ValueFlagExists(valueFlagDto.Id.Value))
            {
                return null;
            }

            var entity = await this._dbContext.ValueFlags.FindAsync(valueFlagDto.Id);
            if (entity == null)
            {
                return null;
            }

            entity.UpdateFromDto(valueFlagDto);
            entity.ApplicableVersions = entity.ApplicableVersions.Select(version => _dbContext.Versions.First(vers => vers.Id == version.Id)).ToList();
            this._dbContext.SetModified(entity);

            // delete unused versions
            await _dbContext.Versions.Include(version => version.Parameters).ForEachAsync(version => version.Parameters.RemoveAll(param =>
                param.Id == valueFlagDto.Id && !valueFlagDto.ApplicableVersionIds.Contains(version.Id)));
        
            await this._dbContext.SaveChangesAsync();

            return valueFlagDto;
        }

        private bool ValueFlagExists(Guid id)
        {
            return this._dbContext.ValueFlags.Any(e => e.Id == id);
        }

        public async Task<bool> DeleteValueFlag(Guid id)
        {
            var valueFlag = await this._dbContext.ValueFlags.FindAsync(id);
            if (valueFlag == null)
            {
                this._logger.LogError("Value flag with the ID provided was not found");
                return false;
            }

            this._dbContext.ValueFlags.Remove(valueFlag);
            await this._dbContext.SaveChangesAsync();

            return true;
        }

        private async Task<IQueryable<Application>> GetAvailableApps()
        {
            var authState = await this._authenticationStateProvider.GetAuthenticationStateAsync();
            var userIdClaim = authState.User.FindFirst(ClaimTypes.NameIdentifier).Value;
            Guid.TryParse(userIdClaim, out var uuid);
            var apps = this._dbContext.Organizations.Include(org => org.Applications).Where(o => o.OrganizationAccesses.Any(a => a.AppUserId == uuid)).SelectMany(o => o.Applications);
            return apps;
        }
    }
}