Flawless-Version-Control/Flawless.Server/Controllers/RepositoryOutieController.cs

using Flawless.Communication.Request;
using Flawless.Communication.Response;
using Flawless.Communication.Shared;
using Flawless.Server.Models;
using Flawless.Server.Services;
using Microsoft.AspNetCore.Authorization;
using Microsoft.AspNetCore.Identity;
using Microsoft.AspNetCore.Mvc;
using Microsoft.EntityFrameworkCore;

namespace Flawless.Server.Controllers;

//todo Merging RepositoryManageController and RepositoryController
[ApiController, Authorize, Route("api")]
public class RepositoryOutieController(AppDbContext dbContext, UserManager<AppUser> userManager) : ControllerBase
{
    
    [HttpGet("repo_list")]
    public async Task<ActionResult<ListingResponse<RepositoryInfoResponse>>> ListAllAvailableRepositoriesAsync()
    {
        var u = (await userManager.GetUserAsync(HttpContext.User))!;
        var query = dbContext.Repositories
            .Include(repository => repository.Owner)
            .Include(repository => repository.Commits)
            .Include(repository => repository.Members)
            .ThenInclude(repositoryMember => repositoryMember.User)
            .Where(rp => rp.Members.Any(m => m.User == u) || rp.Owner == u)
            .Select(rp => new RepositoryInfoResponse
                {
                    RepositoryName = rp.Name,
                    OwnerUsername = rp.Owner.UserName!,
                    Description = rp.Description,
                    IsArchived = rp.IsArchived,
                    Role = rp.Owner == u ? RepositoryRole.Owner : rp.Members.First(m => m.User == u).Role
                })
            .ToArray();

        return Ok(new ListingResponse<RepositoryInfoResponse>(query));
    }

    [HttpPost("repo_create")]
    public async Task<ActionResult<RepositoryInfoResponse>> CreateRepositoryAsync([FromQuery] string repositoryName, [FromQuery] string? description)
    {
        repositoryName = repositoryName.Trim().Replace(' ', '_');
        if (repositoryName.Length <= 3)
            return BadRequest(new FailedResponse("Repository name is empty or too short!"));

        var u = (await userManager.GetUserAsync(HttpContext.User))!;
        if (await dbContext.Repositories.AnyAsync(rp => rp.Name == repositoryName && u == rp.Owner))
            return BadRequest(new FailedResponse("Repository name has already created!"));

        var repo = new Repository()
        {
            Name = repositoryName,
            Description = description,
            Owner = u,
        };
        
        await dbContext.Repositories.AddAsync(repo);
        await dbContext.SaveChangesAsync();
        return Ok(new RepositoryInfoResponse()
        {
            RepositoryName = repositoryName,
            OwnerUsername = u.UserName!,
            Description = description,
            IsArchived = false,
            Role = RepositoryRole.Owner
        });
    }
    
    [HttpPost("update_user")]
    public async Task<IActionResult> UpdateUserAsync(string repositoryName, string modUser, RepositoryRole role)
    {
        if (string.IsNullOrWhiteSpace(repositoryName) || repositoryName.Length <= 3)
            return BadRequest(new FailedResponse("Repository name is empty or too short!"));
        
        var u = (await userManager.GetUserAsync(HttpContext.User))!;
        var tu = await userManager.FindByNameAsync(modUser);
        if (tu == null) return BadRequest(new FailedResponse("User not found!"));
        if (u == tu) return BadRequest(new FailedResponse("Not able to update the role on self-own repository!"));
        
        var rp = await dbContext.Repositories
            .Include(repository => repository.Members)
            .ThenInclude(repositoryMember => repositoryMember.User)
            .FirstOrDefaultAsync(rp => rp.Name == repositoryName && u == rp.Owner);
        
        if (rp == null) return BadRequest(new FailedResponse("Repository not found!"));

        var m = rp.Members.FirstOrDefault(m => m.User == tu);
        if (m == null)
        {
            m = new RepositoryMember
            {
                User = tu,
                Role = role
            };
            
            rp.Members.Add(m);
        }
        else
        {
            m.Role = role;
        }
        
        await dbContext.SaveChangesAsync();
        return Ok();
    }

    [HttpPost("delete_user")]
    public async Task<IActionResult> DeleteUserAsync(string repositoryName, string delUser)
    {
        if (string.IsNullOrWhiteSpace(repositoryName) || repositoryName.Length <= 3)
            return BadRequest(new FailedResponse("Repository name is empty or too short!"));
        
        var u = (await userManager.GetUserAsync(HttpContext.User))!;
        var tu = await userManager.FindByNameAsync(delUser);
        if (tu == null) return BadRequest(new FailedResponse("User not found!"));
        if (u == tu) return BadRequest(new FailedResponse("Not able to update the role on self-own repository!"));
        
        var rp = await dbContext.Repositories
            .Include(repository => repository.Members)
            .ThenInclude(repositoryMember => repositoryMember.User)
            .FirstOrDefaultAsync(rp => rp.Name == repositoryName && u == rp.Owner);
        
        if (rp == null) return BadRequest(new FailedResponse("Repository not found!"));

        var m = rp.Members.FirstOrDefault(m => m.User == tu);
        if (m == null) return BadRequest(new FailedResponse("User is not being granted to this repository!"));
        
        rp.Members.Remove(m);
        await dbContext.SaveChangesAsync();
        return Ok();
    }
}