secure-sharing/SecureSharing.Business/Services/MessageService.cs

using System;
using System.Collections.Generic;
using System.Linq;
using System.Threading.Tasks;
using AutoMapper;
using Microsoft.EntityFrameworkCore;
using SecureSharing.Business.Dtos;
using SecureSharing.Business.Infrastructure;
using SecureSharing.Business.Interfaces;
using SecureSharing.Data.Data;
using SecureSharing.Data.DbContexts;

namespace SecureSharing.Business.Services;

public sealed class MessageService : IMessageService
{
    private readonly AppDbContext _dbContext;
    private readonly IMapper _mapper;

    public MessageService(AppDbContext dbContext, IMapper mapper)
    {
        _dbContext = dbContext;
        _mapper = mapper;
    }

    public async Task<int> Create(MessageDto messageDto, PeriodOfValidity chosenPeriod)
    {
        var message = _mapper.Map<Message>(messageDto);
        switch (chosenPeriod)
        {
            case PeriodOfValidity.ONE_TIME:
                message.ExpiryDate = null;
                break;
            case PeriodOfValidity.ONE_DAY:
                message.ExpiryDate = DateTime.UtcNow.AddMinutes(1);
                break;
            case PeriodOfValidity.ONE_HOUR:
                message.ExpiryDate = DateTime.UtcNow.AddHours(1);
                break;
            case PeriodOfValidity.ONE_WEEK:
                message.ExpiryDate = DateTime.UtcNow.AddDays(7);
                break;
            default:
                message.ExpiryDate = null;
                break;
        }

        await _dbContext.Messages.AddAsync(message);
        await _dbContext.SaveChangesAsync();
        return message.Id;
    }

    public async Task DeleteExpiredMessages()
    {
        var result = await _dbContext.Messages
            .Where(m => (m.ExpiryDate != null && m.ExpiryDate <= DateTime.UtcNow) || !m.IsValid).ToListAsync();
        _dbContext.RemoveRange(result);
        await _dbContext.SaveChangesAsync();
    }

    public async Task InvalidateMessage(int id)
    {
        var message = await _dbContext.Messages.Where(m => m.Id == id).FirstOrDefaultAsync();
        message.IsValid = false;
        await _dbContext.SaveChangesAsync();
    }


    public async Task<bool> Delete(int messageId)
    {
        var messageDto = await GetById(messageId);
        if (messageDto == null) return false;
        _dbContext.Set<Message>().Remove(_mapper.Map<Message>(messageDto));
        try
        {
            await _dbContext.SaveChangesAsync();
        }
        catch (DbUpdateException)
        {
            return false;
        }

        return true;
    }

    public async Task<IEnumerable<MessageDto>> GetAll()
    {
        var result = await _dbContext.Messages.AsNoTracking().ToListAsync();
        var mappedResult = _mapper.Map<IEnumerable<MessageDto>>(result);
        return mappedResult;
    }


    public async Task<MessageDto> GetById(int messageId)
    {
        var result = await _dbContext.Messages.AsNoTracking().FirstOrDefaultAsync(x => x.Id == messageId);
        var mappedResult = _mapper.Map<MessageDto>(result);
        return mappedResult;
    }

    public async Task Update(MessageDto messageDto)
    {
        var a = _dbContext.Messages.Update(_mapper.Map<Message>(messageDto));
        await _dbContext.SaveChangesAsync();
    }
}