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

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

using AutoMapper;
using MVCTemplate.Business.Dtos;
using MVCTemplate.Business.Interfaces;
using MVCTemplate.Data.Data;
using MVCTemplate.Data.DbContexts;
using Microsoft.EntityFrameworkCore;
using MVCTemplate.Business.Infrastructure;

namespace MVCTemplate.Business.Services
{
    public 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)
        {
            Message 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)
        {
            MessageDto messageDto = await GetById(messageId);
            if (messageDto == null) return false;
            _dbContext.Set<Message>().Remove(_mapper.Map<Message>(messageDto));
            try
            {
                await _dbContext.SaveChangesAsync();

            }
            catch (Microsoft.EntityFrameworkCore.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();
        }
    }
}