monorepo/LCU.API.Internal.ArchiverApi/LCU.Api.Internal.ArchiverApi/Services/ApplicationMappingService.cs

using System;
using System.Collections.Generic;
using System.Data.SqlClient;
using System.Threading.Tasks;
using Serilog;
using LCU.Library.Internal.ArchiverApiLib.Repositories;
using LCU.Library.Internal.ArchiverApiModel.Entities;
using LCU.Library.Internal.Exceptions;
namespace LCU.Api.Internal.ArchiverApi.Services;

public class ApplicationMappingService : IApplicationMappingService
{
    private readonly IApplicationMappingRepository _applicationMappingRepository;
    private readonly IUnitOfWork _unitOfWork;

    public ApplicationMappingService(IUnitOfWork unitOfWork,
                                     IApplicationMappingRepository applicationMappingRepository)
    {
        _unitOfWork = unitOfWork;
        _applicationMappingRepository = applicationMappingRepository;
    }

    public async Task<IEnumerable<ApplicationMapping>> GetAsync()
    {
        try
        {
            return await _applicationMappingRepository.ListAsync();
        }
        catch (Exception exception)
        {
            Log.Error(exception, "Failure retrieving application mappings.");
            throw new ServiceException("Failure retrieving application mappings.");
        }
    }

    public async Task<ApplicationMapping> GetByIdAsync(int id)
    {
        try
        {
            var applicationMapping = await _applicationMappingRepository.FindByIdAsync(id);
            ArgumentNullException.ThrowIfNull(applicationMapping);
            return applicationMapping;
        }
        catch (Exception exception)
        {
            Log.Error(exception, $"Failure retrieving application mapping with id {id}.");
            throw new ServiceException($"Failure retrieving application mapping with id {id}.");
        }
    }

    public async Task<IEnumerable<ApplicationMapping>> GetByIdentifierAsync(string identifier)
    {
        try
        {
            var applicationMapping = await _applicationMappingRepository.FindByIdentifierAsync(identifier);
            ArgumentNullException.ThrowIfNull(applicationMapping);
            return applicationMapping;
        }
        catch (Exception exception)
        {
            Log.Error(exception, $"Failure retrieving application mapping with id {identifier}.");
            throw new ServiceException($"Failure retrieving application mapping with id {identifier}.");
        }
    }

    public async Task<ApplicationMapping> SaveAsync(ApplicationMapping applicationMapping)
    {
        try
        {
            var result = await _applicationMappingRepository.AddAsync(applicationMapping);
            await _unitOfWork.CompleteAsync();

            return result;
        }
        catch (Exception exception)
        {
            Log.Error(exception, "Failure saving application mapping");
            throw new ServiceException("Failure saving application mapping");
        }
    }

    public ApplicationMapping Update(ApplicationMapping applicationMapping)
    {
        try
        {
            var existing = GetByIdAsync(applicationMapping.ApplicationMappingId).Result;
            ArgumentNullException.ThrowIfNull(existing);

            existing.Identifier = applicationMapping.Identifier;
            existing.DesignatedName = applicationMapping.DesignatedName;
            existing.ApplicationOverrideName = applicationMapping.ApplicationOverrideName;
            existing.ParameterMappings = applicationMapping.ParameterMappings;

            _applicationMappingRepository.Update(existing);
            _unitOfWork.Complete();

            return existing;
        }
        catch (SqlException sqlException)
        {
            Log.Error(sqlException, "SQL Failure updating application mapping");
            throw new ServiceException("SQL Failure updating application mapping");
        }
        catch (Exception exception)
        {
            Log.Error(exception, "Failure updating application mapping");
            throw new ServiceException("Failure updating application mapping");
        }
    }

    public void DeleteAsync(int applicationMappingId)
    {
        try
        {
            var applicationMapping = _applicationMappingRepository.FindByIdAsync(applicationMappingId).Result;
            ArgumentNullException.ThrowIfNull(applicationMapping);
            _applicationMappingRepository.Remove(applicationMapping);
            _unitOfWork.Complete();
        }
        catch (SqlException sqlException)
        {
            Log.Error(sqlException, $"SQL failure removing application mapping. ApplicationMappingId: {applicationMappingId}");
            throw new ServiceException($"SQL failure removing application mapping. ApplicationMappingId: {applicationMappingId}");
        }
        catch (Exception exception)
        {
            Log.Error(exception, $"Failure removing application mapping. ApplicationMappingId: {applicationMappingId}");
            throw new ServiceException($"Failure removing application mapping. ApplicationMappingId: {applicationMappingId}");
        }
    }
}