Flawless-Version-Control/Flawless.Client/Service/RepositoryService.cs

using System;
using System.Collections.Generic;
using System.Collections.ObjectModel;
using System.IO;
using System.Linq;
using System.Threading.Tasks;
using Flawless.Client.Models;
using Flawless.Client.Remote;

namespace Flawless.Client.Service;

public class RepositoryService : BaseService<RepositoryService>
{
    public ObservableCollection<RepositoryModel> Repositories => _repositories;


    private readonly ObservableCollection<RepositoryModel> _repositories = new();

    public async ValueTask<bool> CreateRepositoryOnServerAsync(string repositoryName)
    {
        
        var api = Api.C;
        try
        {
            if (api.RequireRefreshToken() && !(await api.TryRefreshTokenAsync()))
            {
                api.ClearGateway();
                return false;
            }

            var r = await api.Gateway.RepoCreate(repositoryName);
            
            var repo = new RepositoryModel();
            repo.Name = r.RepositoryName;
            repo.OwnerName = r.OwnerUsername;
            repo.StandaloneName = RepositoryModel.GetStandaloneName(r.RepositoryName, r.OwnerUsername);
            repo.Description = r.Description;
            repo.Archived = r.IsArchived;
            repo.OwnByCurrentUser = (int) r.Role == (int) RepositoryModel.RepositoryRole.Owner;
                
            Repositories.Insert(0, repo);
        }
        catch (Exception e)
        {
            Console.WriteLine(e);
            return false;
        }
        
        return true;
    }

    public async ValueTask<bool> UpdateRepositoriesFromServerAsync()
    {
        var api = Api.C;
        try
        {
            if (api.RequireRefreshToken() && !(await api.TryRefreshTokenAsync()))
            {
                api.ClearGateway();
                return false;
            }

            var result = (await api.Gateway.RepoList()).Result;
            var dict = result.ToDictionary(rp => RepositoryModel.GetStandaloneName(rp.RepositoryName, rp.OwnerUsername));
            for (var i = 0; i < Repositories.Count; i++)
            {
                var ele = Repositories[i];
                if (!dict.Remove(ele.StandaloneName, out var role))
                {
                    Repositories.RemoveAt(i);
                    i -= 1;
                    continue;
                }

                ele.Archived = ele.Archived;
                ele.Description = ele.Description;
            }
            
            foreach (var (repoStandaloneName, rsp) in dict)
            {
                var repo = new RepositoryModel();
                repo.Name = rsp.RepositoryName;
                repo.OwnerName = rsp.OwnerUsername;
                repo.StandaloneName = repoStandaloneName;
                repo.Description = rsp.Description;
                repo.Archived = rsp.IsArchived;
                repo.OwnByCurrentUser = (int) rsp.Role == (int) RepositoryModel.RepositoryRole.Owner;
                
                Repositories.Add(repo);
            }
        }
        catch (Exception e)
        {
            Console.WriteLine(e);
            return false;
        }
        
        return true;
    }

    public async ValueTask<bool> UpdateRepositoriesDownloadedFromDiskAsync()
    {
        foreach (var repo in _repositories)
        {
            var fsPath = Path.Combine(SettingService.C.AppSetting.RepositoryPath, repo.OwnerName, repo.Name);
            repo.IsDownloaded = Directory.Exists(fsPath);
        }
        
        return true;
    }

    public async ValueTask<bool> UpdateRepositoryMembersFromServerAsync(RepositoryModel repo)
    {
        var api = Api.C;
        try
        {
            if (api.RequireRefreshToken() && !(await api.TryRefreshTokenAsync()))
            {
                api.ClearGateway();
                return false;
            }
            
            var members = await api.Gateway.GetUsers(repo.Name, repo.OwnerName);
            
            // Update existed
            var dict = members.Result.ToDictionary(m => m.Username);
            for (var i = 0; i < repo.Members.Count; i++)
            {
                var ele = repo.Members[i];
                if (!dict.Remove(ele.Username, out var role))
                {
                    repo.Members.RemoveAt(i);
                    i -= 1;
                    continue;
                }

                ele.Username = role.Username;
                ele.Role = (RepositoryModel.RepositoryRole) role.Role;
            }
            
            // Add missing
            foreach (var role in dict.Values)
            {
                var r = new RepositoryModel.Member
                {
                    Username = role.Username,
                    Role = (RepositoryModel.RepositoryRole) role.Role
                };
                
                repo.Members.Add(r);
            }
        }
        catch (Exception e)
        {
            Console.WriteLine(e);
            return false;
        }
        
        return true;
    }
}