Moonlight/Moonlight/Shared/Components/ServerControl/ServerBackups.razor

@using Moonlight.App.Services
@using Moonlight.App.Helpers
@using Logging.Net
@using BlazorContextMenu
@using Moonlight.App.Database.Entities
@using Moonlight.App.Events
@using Moonlight.App.Services.Interop

@inject ServerService ServerService
@inject NavigationManager NavigationManager
@inject AlertService AlertService
@inject ToastService ToastService
@inject ClipboardService ClipboardService
@inject EventSystem Event
@inject SmartTranslateService SmartTranslateService

@implements IDisposable

<LazyLoader @ref="LazyLoader" Load="Refresh">
    @if (3 > AllBackups.Length)
    {
        <WButton 
            Text="@(SmartTranslateService.Translate("Create"))" 
            WorkingText="@(SmartTranslateService.Translate("Creating"))" 
            CssClasses="btn-primary mb-2" 
            OnClick="Create"></WButton>
    }
    else
    {
        <button class="btn btn-primary disabled mb-2" disabled=""><TL>Delete</TL></button>
    }
    <div class="table-responsive">
        <table class="table align-middle table-row-dashed fs-6 gy-5 dataTable no-footer">
            <thead>
            </thead>
            <tbody class="fw-semibold text-gray-600">
            @foreach (var backup in AllBackups)
            {
                <tr class="odd">
                    <td>
                        <div class="d-flex align-items-center">
                            <div class="ms-5">
                                <a class="text-gray-800 text-hover-primary fs-5 fw-bold">@(backup.Name)</a>
                            </div>
                        </div>
                    </td>
                    <td class="text-end pe-0">
                        <span class="fw-bold">@(backup.Uuid)</span>
                    </td>
                    <td class="text-end pe-0">
                        <span class="fw-bold">@(Formatter.FormatSize(backup.Bytes))</span>
                    </td>
                    <td class="text-end pe-0">
                        <span class="fw-bold ms-3">@backup.CreatedAt.Date.ToLongDateString(), @backup.CreatedAt.Date.ToLongTimeString()</span>
                    </td>
                    <td class="text-end">
                        @if (backup.Created)
                        {
                            <ContextMenuTrigger MenuId="triggerMenu" MouseButtonTrigger="MouseButtonTrigger.Both" Data="backup">
                                <button class="btn btn-sm btn-icon btn-light btn-active-light-primary me-2">
                                    <span class="svg-icon svg-icon-5 m-0">
                                        <svg width="24" height="24" viewBox="0 0 24 24" fill="none" xmlns="http://www.w3.org/2000/svg">
                                            <rect x="10" y="10" width="4" height="4" rx="2" fill="currentColor"></rect>
                                            <rect x="17" y="10" width="4" height="4" rx="2" fill="currentColor"></rect>
                                            <rect x="3" y="10" width="4" height="4" rx="2" fill="currentColor"></rect>
                                        </svg>
                                    </span>
                                </button>
                            </ContextMenuTrigger>
                        }
                        else
                        {
                            <span class="fw-bold">
                                <TL>Backup is going to be created</TL>
                            </span>
                        }
                    </td>
                </tr>
            }
            </tbody>
        </table>
    </div>

    <ContextMenu Id="triggerMenu" CssClass="bg-secondary z-10">
        <Item Id="restore" OnClick="OnContextMenuClick">
            <TL>Restore</TL>
        </Item>
        <Item Id="copyurl" OnClick="OnContextMenuClick">
            <TL>Copy url</TL>
        </Item>
        <Item Id="download" OnClick="OnContextMenuClick">
            <TL>Download</TL>
        </Item>
        <Item Id="delete" OnClick="OnContextMenuClick">
            <TL>Delete</TL>
        </Item>
    </ContextMenu>
</LazyLoader>

@code
{
    [CascadingParameter]
    public Server CurrentServer { get; set; }

    private ServerBackup[]? AllBackups;

    private LazyLoader LazyLoader;

    protected override void OnInitialized()
    {
        Event.On<ServerBackup>("wings.backups.create", this, async (backup) =>
        {
            if (AllBackups == null)
                return;

            if (AllBackups.Any(x => x.Id == backup.Id))
            {
                await Task.Delay(TimeSpan.FromSeconds(1));
                await ToastService.Success(SmartTranslateService.Translate("Backup successfully created"));
                await LazyLoader.Reload();
            }
        });

        Event.On<ServerBackup>("wings.backups.createFailed", this, async (backup) =>
        {
            if (AllBackups == null)
                return;

            if (AllBackups.Any(x => x.Id == backup.Id))
            {
                await ToastService.Error(SmartTranslateService.Translate("Backup creation failed"));
                await LazyLoader.Reload();
            }
        });

        Event.On<ServerBackup>("wings.backups.delete", this, async (backup) =>
        {
            if (AllBackups == null)
                return;

            if (AllBackups.Any(x => x.Id == backup.Id))
            {
                await ToastService.Success(SmartTranslateService.Translate("Backup successfully deleted"));
                await LazyLoader.Reload();
            }
        });

        Event.On<ServerBackup>("wings.backups.restore", this, async (backup) =>
        {
            if (AllBackups == null)
                return;

            if (AllBackups.Any(x => x.Id == backup.Id))
            {
                await ToastService.Success(SmartTranslateService.Translate("Backup successfully restored"));
            }
        });
    }

    private async Task Refresh(LazyLoader lazyLoader)
    {
        await InvokeAsync(StateHasChanged);

        await lazyLoader.SetText(SmartTranslateService.Translate("Loading backups"));
        AllBackups = await ServerService.GetBackups(CurrentServer, true);

        await InvokeAsync(StateHasChanged);
    }

    private async Task Download(ServerBackup serverBackup)
    {
        var url = await ServerService.DownloadBackup(CurrentServer, serverBackup);

        NavigationManager.NavigateTo(url);
        await ToastService.Success(SmartTranslateService.Translate("Backup download successfully started"));
        
        /*
        try
        {
            
        }
        catch (Exception e)
        {
            Logger.Warn("Error starting backup download");
            Logger.Warn(e);
            await ToastService.Error(SmartTranslateService.Translate("Backup download failed"));
        }*/
    }

    private async Task CopyUrl(ServerBackup serverBackup)
    {
        var url = await ServerService.DownloadBackup(CurrentServer, serverBackup);

        await ClipboardService.Copy(url);
        await AlertService.Success(
            SmartTranslateService.Translate("Success"), 
            SmartTranslateService.Translate("Backup URL successfully copied to your clipboard"));
        
        /*
        try
        {
            
        }
        catch (Exception e)
        {
            Logger.Warn("Error copying backup url");
            Logger.Warn(e);
            await ToastService.Error(SmartTranslateService.Translate("An unknown error occured while generating backup url"));
        }*/
    }

    private async Task Delete(ServerBackup serverBackup)
    {
        await ToastService.Info(SmartTranslateService.Translate("Backup deletion started"));
        await ServerService.DeleteBackup(CurrentServer, serverBackup);
        
        /*
        try
        {
            
        }
        catch (Exception e)
        {
            Logger.Warn("Error deleting backup");
            Logger.Warn(e);
            await ToastService.Error(SmartTranslateService.Translate("An unknown error occured while starting backup deletion"));
        }*/
    }

    private async Task Restore(ServerBackup serverBackup)
    {
        await ServerService.RestoreBackup(CurrentServer, serverBackup);
        await ToastService.Info(SmartTranslateService.Translate("Backup restore started"));
        
        /*
        try
        {
            
        }
        catch (Exception e)
        {
            Logger.Warn("Error restoring backup");
            Logger.Warn(e);
            await ToastService.Error(SmartTranslateService.Translate("An unknown error occured while restoring a backup"));
        }*/
    }

    private async Task Create()
    {
        await ToastService.Info(SmartTranslateService.Translate("Started backup creation"));
        await ServerService.CreateBackup(CurrentServer);
        await LazyLoader.Reload();
        
        /*
        try
        {
            // Modify the backup list so no reload needed. Also the create event will work
            //var list = AllBackups!.ToList();
            //list.Add(backup);
            //AllBackups = list.ToArray();
        }
        catch (Exception e)
        {
            Logger.Warn("Error creating backup");
            Logger.Warn(e);
            await ToastService.Error(SmartTranslateService.Translate("An unknown error has occured while creating a backup"));
        }*/
    }

    private async Task OnContextMenuClick(ItemClickEventArgs args)
    {
        var backup = (ServerBackup)args.Data;

        switch (args.MenuItem.Id)
        {
            case "delete":
                await Delete(backup);
                break;
            case "copyurl":
                await CopyUrl(backup);
                break;
            case "restore":
                await Restore(backup);
                break;
            case "download":
                await Download(backup);
                break;
        }

        await Refresh(LazyLoader);
    }

    public async void Dispose()
    {
        await Event.Off("wings.backups.create", this);
        await Event.Off("wings.backups.createFailed", this);
        await Event.Off("wings.backups.restore", this);
        await Event.Off("wings.backups.delete", this);
    }
}