GroupController.cs

using AutoMapper;
using Microsoft.AspNetCore.Authorization;
using Microsoft.AspNetCore.Identity;
using Microsoft.AspNetCore.Mvc;
using Microsoft.EntityFrameworkCore;
using SplitzBackend.Models;
using SplitzBackend.Services;

namespace SplitzBackend.Controllers;

[Authorize]
[ApiController]
[Route("[controller]")]
public class GroupController(
    SplitzDbContext db,
    UserManager<SplitzUser> userManager,
    IMapper mapper,
    IImageStorageService imageStorage)
    : ControllerBase
{
    /// <summary>
    ///     Get the current user's groups
    /// </summary>
    /// <returns></returns>
    [HttpGet(Name = "GetGroups")]
    [Produces("application/json")]
    [ProducesResponseType(401)]
    [ProducesResponseType(200)]
    public async Task<ActionResult<List<GroupDto>>> GetGroups()
    {
        var user = await userManager.GetUserAsync(User);
        if (user is null)
            return Unauthorized();
        var groups = await db.Groups
            .Where(g => g.Members.Contains(user))
            .Include(g => g.Members)
            .Include(g => g.Balances)
            .OrderByDescending(g => g.LastActivityTime)
            .ToListAsync();
        return mapper.Map<List<GroupDto>>(groups);
    }

    /// <summary>
    ///     Get the group info
    /// </summary>
    /// <returns></returns>
    [HttpGet("{groupId}", Name = "GetGroup")]
    [Produces("application/json")]
    [ProducesResponseType(401)]
    [ProducesResponseType(404)]
    [ProducesResponseType(200)]
    public async Task<ActionResult<GroupDto>> GetGroup(Guid groupId)
    {
        var user = await userManager.GetUserAsync(User);
        if (user is null)
            return Unauthorized();
        var group = await db.Groups
            .Where(g => g.Members.Contains(user) && g.GroupId == groupId)
            .Include(g => g.Members)
            .Include(g => g.Balances)
            .FirstOrDefaultAsync();
        if (group is null)
            return NotFound();
        return mapper.Map<GroupDto>(group);
    }

    /// <summary>
    ///     Get the group transactions
    /// </summary>
    /// <param name="groupId"></param>
    /// <returns></returns>
    [HttpGet("{groupId}/transactions", Name = "GetGroupTransactions")]
    [Produces("application/json")]
    [ProducesResponseType(401)]
    [ProducesResponseType(404)]
    [ProducesResponseType(200)]
    public async Task<ActionResult<List<TransactionDto>>> GetGroupTransactions(Guid groupId)
    {
        var user = await userManager.GetUserAsync(User);
        if (user is null)
            return Unauthorized();
        var group = await db.Groups
            .Where(g => g.Members.Contains(user) && g.GroupId == groupId)
            .FirstOrDefaultAsync();
        if (group is null)
            return NotFound();
        var transactions = await db.Transactions
            .Where(t => t.GroupId == groupId)
            .Include(t => t.Balances).ThenInclude(b => b.User)
            .ToListAsync();
        return mapper.Map<List<TransactionDto>>(transactions);
    }

    /// <summary>
    ///     Get the group invoices
    /// </summary>
    /// <param name="groupId"></param>
    /// <returns></returns>
    [HttpGet("{groupId}/invoices", Name = "GetGroupInvoices")]
    [Produces("application/json")]
    [ProducesResponseType(401)]
    [ProducesResponseType(404)]
    [ProducesResponseType(200)]
    public async Task<ActionResult<List<InvoiceReducedDto>>> GetGroupInvoices(Guid groupId)
    {
        var user = await userManager.GetUserAsync(User);
        if (user is null)
            return Unauthorized();
        var group = await db.Groups
            .Where(g => g.Members.Contains(user) && g.GroupId == groupId)
            .FirstOrDefaultAsync();
        if (group is null)
            return NotFound();
        var invoices = await db.Invoices
            .Where(i => i.GroupId == groupId)
            .OrderByDescending(i => i.CreateTime)
            .Include(i => i.CreatedBy)
            .ToListAsync();
        return mapper.Map<List<InvoiceReducedDto>>(invoices);
    }

    /// <summary>
    ///     Create a new group
    /// </summary>
    /// <param name="groupInputDto">group info</param>
    /// <returns></returns>
    [HttpPost(Name = "CreateGroup")]
    [Produces("application/json")]
    [ProducesResponseType(401)]
    [ProducesResponseType(201)]
    [ProducesResponseType(409)]
    public async Task<ActionResult<GroupDto>> Create(GroupInputDto groupInputDto)
    {
        var user = await userManager.GetUserAsync(User);
        if (user is null)
            return Unauthorized();

        var group = mapper.Map<Group>(groupInputDto);

        // check if members are user's friends
        var members = await db.Users.Include(splitzUser => splitzUser.Friends)
            .Where(splitzUser =>
                groupInputDto.MembersId.Contains(splitzUser.Id) &&
                splitzUser.Friends.Select(friend => friend.FriendUserId).Contains(user.Id))
            .ToListAsync();
        members = members.Concat([user]).Distinct().ToList();
        group.Members = members;
        group.UpdateMembersIdHash();

        group.Transactions = [];
        group.Balances = [];
        group.LastActivityTime = DateTime.UtcNow;
        db.Groups.Add(group);
        await db.SaveChangesAsync();
        return CreatedAtAction(nameof(GetGroup), new { groupId = group.GroupId }, mapper.Map<GroupDto>(group));
    }

    /// <summary>
    ///     Update group info
    /// </summary>
    /// <param name="groupId">Group Id</param>
    /// <param name="groupInputDto">group info</param>
    [HttpPut("{groupId}", Name = "UpdateGroup")]
    [Produces("application/json")]
    [ProducesResponseType(401)]
    [ProducesResponseType(404)]
    [ProducesResponseType(201)]
    public async Task<ActionResult<GroupDto>> UpdateGroup(Guid groupId, GroupInputDto groupInputDto)
    {
        var user = await userManager.GetUserAsync(User);
        if (user is null)
            return Unauthorized();
        var group = await db.Groups.Include(g => g.Members).FirstOrDefaultAsync(g => g.GroupId == groupId);
        if (group is null)
            return NotFound();
        if (!group.Members.Contains(user))
            return Unauthorized();
        mapper.Map(groupInputDto, group);
        await db.SaveChangesAsync();
        return CreatedAtAction(nameof(GetGroup), new { groupId = group.GroupId }, mapper.Map<GroupDto>(group));
    }

    /// <summary>
    ///     Upload a group avatar image.
    /// </summary>
    [HttpPost("{groupId}/avatar", Name = "UploadGroupAvatar")]
    [Consumes("multipart/form-data")]
    [Produces("application/json")]
    [ProducesResponseType(401)]
    [ProducesResponseType(404)]
    [ProducesResponseType(400)]
    [ProducesResponseType(200)]
    [RequestSizeLimit(10 * 1024 * 1024)]
    public async Task<ActionResult<UploadImageResult>> UploadGroupAvatar(
        Guid groupId,
        IFormFile file,
        CancellationToken cancellationToken = default)
    {
        var user = await userManager.GetUserAsync(User);
        if (user is null)
            return Unauthorized();
        if (file.Length <= 0)
            return BadRequest("Empty file");

        var group = await db.Groups.Include(g => g.Members)
            .FirstOrDefaultAsync(g => g.GroupId == groupId, cancellationToken);
        if (group is null)
            return NotFound();
        if (!group.Members.Contains(user))
            return Unauthorized();

        var existingPhoto = group.Photo;

        await using var input = file.OpenReadStream();
        var result = await imageStorage.UploadProcessedImageAsync(
            input,
            file.ContentType,
            $"groups/{groupId}/avatar",
            new ImageResizeRequest(512, false),
            cancellationToken);

        group.Photo = result.ObjectKey;
        group.LastActivityTime = DateTime.UtcNow;
        await db.SaveChangesAsync(cancellationToken);
        await imageStorage.DeleteIfOwnedAsync(existingPhoto, cancellationToken);
        return Ok(result);
    }

    /// <summary>
    ///     Delete a group.
    /// </summary>
    [HttpDelete("{groupId}", Name = "DeleteGroup")]
    [ProducesResponseType(401)]
    [ProducesResponseType(404)]
    [ProducesResponseType(204)]
    public async Task<IActionResult> DeleteGroup(Guid groupId, CancellationToken cancellationToken = default)
    {
        var user = await userManager.GetUserAsync(User);
        if (user is null)
            return Unauthorized();

        var group = await db.Groups.Include(g => g.Members)
            .FirstOrDefaultAsync(g => g.GroupId == groupId, cancellationToken);
        if (group is null)
            return NotFound();
        if (!group.Members.Contains(user))
            return Unauthorized();

        var groupPhoto = group.Photo;
        db.Groups.Remove(group);
        await db.SaveChangesAsync(cancellationToken);

        await imageStorage.DeleteIfOwnedAsync(groupPhoto, cancellationToken);

        return NoContent();
    }


    /// <summary>
    ///     Add members to a group
    /// </summary>
    /// <param name="groupId">group id</param>
    /// <param name="userIds">list of user ids</param>
    /// <returns></returns>
    [HttpPost("{groupId}/members", Name = "AddGroupMember")]
    [Produces("application/json")]
    [ProducesResponseType(401)]
    [ProducesResponseType(404)]
    [ProducesResponseType(201)]
    public async Task<ActionResult<GroupDto>> AddGroupMember(Guid groupId, List<string> userIds)
    {
        var user = await userManager.GetUserAsync(User);
        if (user is null)
            return Unauthorized();
        var group = await db.Groups.Include(g => g.Members).FirstOrDefaultAsync(g => g.GroupId == groupId);
        if (group is null)
            return NotFound();

        // check if members are user's friends
        var members = await db.Users.Include(splitzUser => splitzUser.Friends)
            .Where(splitzUser =>
                userIds.Contains(splitzUser.Id) &&
                splitzUser.Friends.Select(friend => friend.FriendUserId).Contains(user.Id))
            .ToListAsync();
        group.Members = [.. group.Members, .. members];
        group.Members = group.Members.Distinct().ToList();
        group.UpdateMembersIdHash();
        group.LastActivityTime = DateTime.UtcNow;
        await db.SaveChangesAsync();
        return CreatedAtAction(nameof(GetGroup), new { groupId = group.GroupId }, mapper.Map<GroupDto>(group));
    }

    /// <summary>
    ///     create a join link for a group
    /// </summary>
    /// <param name="groupId">group id</param>
    /// <returns></returns>
    [HttpPost("{groupId}/join-link", Name = "CreateGroupJoinLink")]
    [Produces("application/json")]
    [ProducesResponseType(200)]
    [ProducesResponseType(401)]
    [ProducesResponseType(404)]
    public async Task<ActionResult<GroupJoinLinkDto>> CreateGroupJoinLink(Guid groupId)
    {
        var user = await userManager.GetUserAsync(User);
        if (user is null)
            return Unauthorized();
        var group = await db.Groups.Where(g => g.GroupId == groupId && g.Members.Contains(user)).FirstOrDefaultAsync();
        if (group is null)
            return NotFound();
        var link = new GroupJoinLink { GroupId = groupId, GroupJoinLinkId = Guid.NewGuid() };
        db.GroupJoinLinks.Add(link);
        await db.SaveChangesAsync();
        return Ok(mapper.Map<GroupJoinLinkDto>(link));
    }

    /// <summary>
    ///     get group info from join link
    /// </summary>
    /// <param name="joinLinkId">join link id</param>
    /// <returns></returns>
    [HttpGet("join/{joinLinkId}", Name = "GetGroupInfoByLink")]
    [Produces("application/json")]
    [ProducesResponseType(200)]
    [ProducesResponseType(401)]
    [ProducesResponseType(404)]
    public async Task<ActionResult<GroupReducedDto>> GetGroupInfoByLink(Guid joinLinkId)
    {
        var user = await userManager.GetUserAsync(User);
        if (user is null)
            return Unauthorized();
        var groupJoinLink = await db.GroupJoinLinks.Include(e => e.Group)
            .FirstOrDefaultAsync(e => e.GroupJoinLinkId == joinLinkId);
        if (groupJoinLink is null)
            return NotFound();
        return mapper.Map<GroupReducedDto>(groupJoinLink.Group);
    }

    /// <summary>
    ///     join a group by a join link
    /// </summary>
    /// <param name="joinLinkId">join link id</param>
    /// <returns></returns>
    [HttpPost("join/{joinLinkId}", Name = "JoinGroupByLink")]
    [Produces("application/json")]
    [ProducesResponseType(200)]
    [ProducesResponseType(401)]
    [ProducesResponseType(404)]
    public async Task<ActionResult<GroupDto>> JoinGroupByLink(Guid joinLinkId)
    {
        var user = await userManager.GetUserAsync(User);
        if (user is null)
            return Unauthorized();
        var groupJoinLink = await db.GroupJoinLinks.Include(e => e.Group)
            .FirstOrDefaultAsync(e => e.GroupJoinLinkId == joinLinkId);
        if (groupJoinLink is null)
            return NotFound();
        groupJoinLink.Group.Members.Add(user);
        groupJoinLink.Group.UpdateMembersIdHash();
        groupJoinLink.Group.LastActivityTime = DateTime.UtcNow;
        await db.SaveChangesAsync();
        return mapper.Map<GroupDto>(groupJoinLink.Group);
    }
}