DigitalData.UserManager/DigitalData.UserManager.Application/Services/GroupOfUserService.cs

using AutoMapper;
using DigitalData.Core.Application;
using DigitalData.Core.Contracts.Application;
using DigitalData.Core.Contracts.CultureServices;
using DigitalData.UserManager.Application.Contracts;
using DigitalData.UserManager.Application.DTOs.GroupOfUser;
using DigitalData.UserManager.Domain.Entities;
using DigitalData.UserManager.Infrastructure.Contracts;

namespace DigitalData.UserManager.Application.Services
{
    public class GroupOfUserService : CRUDService<IGroupOfUserRepository, GroupOfUserCreateDto, GroupOfUserReadDto, GroupOfUserUpdateDto, GroupOfUser, int>, IGroupOfUserService
    {
        public GroupOfUserService(IGroupOfUserRepository repository, IKeyTranslationService translationService, IMapper mapper) : base(repository, translationService, mapper)
        {
        }

        public async Task<IServiceMessage> DeleteAsyncByGroupUserId(int groupId, int userId)
        {
            var mous = await _repository.ReadByGroupUserIdAsync(groupId, userId);

            foreach (var mou in mous)
            {
                await _repository.DeleteAsync(mou);
            }

            return Successful();
        }

        public async Task<IServiceResult<IEnumerable<GroupOfUserReadDto>>> ReadAllAsyncWith(bool user, bool group)
        {
            IEnumerable<GroupOfUser> entities;

            if(user && group)
            {
                entities = await _repository.ReadAllAsyncWithGroupAndUser();
            }
            else if (user)
            {
                entities = await _repository.ReadAllAsyncWithUser();
            }
            else if (group)
            {
                entities = await _repository.ReadAllAsyncWithGroup();
            }
            else
            {
                entities = await _repository.ReadAllAsync();
            }

            var gouReadDtos = _mapper.MapOrThrow<IEnumerable<GroupOfUserReadDto>>(entities);
            return Successful(gouReadDtos);
        }
        
        public async Task<IServiceMessage> HasGroup(string username, string groupname, bool caseSensitive = true)
        {
            var gous = await _repository.ReadAllAsyncWithGroupAndUser();

            if(caseSensitive)
                gous = gous.Where(gous => gous.User?.Username == username && gous.Group?.Name == groupname);
            else
                gous = gous.Where(gous => gous.User?.Username.ToLower() == username.ToLower() && gous.Group?.Name?.ToLower() == groupname.ToLower());

            return CreateMessage(gous.Any());
        }
    }
}