Dotnet-WebAPI/DbServices/DbTeamService.cs

using AppContext.Entities;
using Converters;
using Microsoft.EntityFrameworkCore;
using Model;
using Services;

namespace DbServices;

public class DbTeamService(AppContext.AppContext context) : ITeamService
{
    public Task<IEnumerable<Team>> ListTeamsOf(int userId)
    {
        return Task.FromResult(
            context.Teams
                .Include(t => t.Members)
                .Where(t => t.Members.Any(m => m.UserId == userId))
                .AsEnumerable()
                .Select(t => t.ToModel())
        );
    }

    public Task<IEnumerable<Team>> ListTeams(string nameNeedle)
    {
        return Task.FromResult(
            context.Teams.Where(t => t.Name.ToLower().Contains(nameNeedle.ToLower()))
                .AsEnumerable()
                .Select(e => e.ToModel())
        );
    }

    public Task<IEnumerable<Team>> ListTeams()
    {
        return Task.FromResult(
            context.Teams
                .AsEnumerable()
                .Select(e => e.ToModel())
        );
    }

    public async Task<int> CountTeams(string nameNeedle)
    {
        return await context.Teams.CountAsync(t => t.Name.ToLower().Contains(nameNeedle.ToLower()));
    }

    public async Task<int> CountTotalTeams()
    {
        return await context.Teams.CountAsync();
    }

    public async Task<Team> AddTeam(string name, string picture, string firstColor, string secondColor)
    {
        var entity = new TeamEntity
        {
            Name = name,
            Picture = picture,
            MainColor = firstColor,
            SecondColor = secondColor
        };

        await context.Teams.AddAsync(entity);
        await context.SaveChangesAsync();
        return entity.ToModel();
    }

    public async Task RemoveTeams(params int[] teams)
    {
        await context.Teams
            .Where(t => teams.Contains(t.Id))
            .ExecuteDeleteAsync();
    }

    public async Task<bool> UpdateTeam(Team team)
    {
        var entity = await context.Teams.FirstOrDefaultAsync(t => t.Id == team.Id);
        if (entity == null)
            return false;

        entity.Name = team.Name;
        entity.MainColor = team.MainColor;
        entity.SecondColor = team.SecondColor;
        entity.Picture = team.Picture;

        return await context.SaveChangesAsync() > 0;
    }

    public async Task<IEnumerable<Tactic>> GetSharedTacticsToTeam(int teamId)
    {
        var sharedTactics = await context.SharedTactics
            .Where(st => st.SharedWithTeamId == teamId)
            .ToListAsync();

        var tactics = new List<Tactic>();
        foreach (var sharedTactic in sharedTactics)
        {
            var tactic = await context.Tactics
                .Where(t => t.Id == sharedTactic.TacticId)
                .Select(t => t.ToModel())
                .FirstOrDefaultAsync();

            if (tactic != null)
            {
                tactics.Add(tactic);
            }
        }

        return tactics;
    }


    public IEnumerable<Member> GetMembersOf(int teamId)
    {
        return context.Members.Where(m => m.TeamId == teamId)
            .AsEnumerable()
            .Select(e => e.ToModel());
    }

    public async Task<Member> AddMember(int teamId, int userId, MemberRole role)
    {
        await context.Members.AddAsync(new MemberEntity
        {
            TeamId = teamId,
            UserId = userId,
            Role = role
        });
        await context.SaveChangesAsync();
        return new Member(teamId, userId, role);
    }

    public async Task<bool> UpdateMember(Member member)
    {
        var entity =
            await context.Members.FirstOrDefaultAsync(e => e.TeamId == member.TeamId && e.UserId == member.UserId);
        if (entity == null)
            return false;
        entity.Role = member.Role;

        return await context.SaveChangesAsync() > 0;
    }

    public async Task<bool> RemoveMember(int teamId, int userId)
    {
        await context.Members
            .Where(e => e.TeamId == teamId && e.UserId == userId)
            .ExecuteDeleteAsync();
        return await context.SaveChangesAsync() > 0;
    }
    
    public async Task<bool> IsUserInTeam(int userId, int teamId)
    {
        return await context.Members
            .AnyAsync(m => m.TeamId == teamId && m.UserId == userId);
    }
}