prs/PRS.Avalonia/PRS.Avalonia/ViewModelBase.cs

using System;
using System.Collections.Generic;
using System.Collections.ObjectModel;
using System.Linq;
using System.Threading;
using System.Threading.Tasks;
using Comal.Classes;
using CommunityToolkit.Mvvm.ComponentModel;
using CommunityToolkit.Mvvm.Input;
using DialogHostAvalonia;
using InABox.Configuration;
using InABox.Rpc;
using PRS.Avalonia.Components;
using PRS.Avalonia;

namespace PRS.Avalonia;

public abstract partial class ViewModelBase : ObservableObject
{

    public ViewModelBase()
    {
    }
    
    private static DataAccessLayer? _dataAccessLayer;
    public DataAccessLayer DataAccess
    {
        get
        {
            if (_dataAccessLayer == null)
            {
                _dataAccessLayer = new DataAccessLayer();
                _dataAccessLayer.Connected += (s, e) => Connected();
                _dataAccessLayer.Disconnected += (s, e) => Disconnected();
            }
            _dataAccessLayer ??= new DataAccessLayer();
            return _dataAccessLayer;
        }
    }

    private static RepositoryLayer? _repositories;
    public RepositoryLayer Repositories
    {
        get
        {
            _repositories ??= new RepositoryLayer(DataAccess);
            return _repositories;
        }
    }    

    
    private void Connected()
    {
    }

    private void Validated()
    {
        Repositories.Me.Refresh(true);
    }

    private void Disconnected()
    {
        
    }


    [RelayCommand]
    private void BackButtonPressed()
    {
        if (OnBackButtonPressed())
            Navigation.Back();
    }

    protected virtual bool OnBackButtonPressed()
    {
        return true;
    }

    private CancellationTokenSource _cts =
        new CancellationTokenSource( );

    public void Activate()
    {
        OnActivated();
        var token = _cts.Token;
        Task refreshtask = Task.Run(
            async () =>
            {
                var result = await Refresh();
                while (result != TimeSpan.Zero)
                {
                    if ( token.IsCancellationRequested )
                        break;
                    
                    await Task.Delay(result);
                    
                    if (!token.IsCancellationRequested )
                        result = await Refresh();
                }
            },
            token
        );
    }
    
    protected virtual void OnActivated()
    {
        
    }

    protected async Task<TimeSpan> Refresh()
    {
        return await OnRefresh();
    }

    protected virtual async Task<TimeSpan> OnRefresh()
    {
        return TimeSpan.FromSeconds(30);
    }

    public void Deactivate()
    {
        _cts.Cancel( );
        _cts.Dispose( );
        _cts = new CancellationTokenSource( );
        
        OnDeactivated();
    }
    
    protected virtual void OnDeactivated()
    {
        
    }
    
    [ObservableProperty]
    private ObservableCollection<PRSAvaloniaMenuItem> _primaryMenu = new();
    
    [ObservableProperty]
    private ObservableCollection<PRSAvaloniaMenuItem> _secondaryMenu = new();
    
    [ObservableProperty] 
    private bool _backButtonVisible = true;
    
    [ObservableProperty] 
    private bool _reverseTransition;

    private static Dictionary<String, MobileDatabaseSettings>? _databaseSettings;
    public static Dictionary<String, MobileDatabaseSettings> DatabaseSettings
    {
        get
        {
            if (_databaseSettings == null)
                LoadDatabaseSettings();
            return _databaseSettings;
        }
    }
    
    private static MobileDatabaseSettings? _currentDatabase;
    public static MobileDatabaseSettings CurrentDatabase
    {
        get
        {
            if (_currentDatabase == null)
                LoadDatabaseSettings();
            return DatabaseSettings.Any(x => x.Value.IsDefault)
                ? DatabaseSettings.FirstOrDefault(x => x.Value.IsDefault).Value
                : DatabaseSettings.First().Value;
        }
    }

    public static string CurrentDatabaseName => DatabaseSettings.Any(x => x.Value.IsDefault)
        ? DatabaseSettings.FirstOrDefault(x => x.Value.IsDefault).Key
        : DatabaseSettings.First().Key;
    
    public static bool IsSharedDevice => 
        string.IsNullOrWhiteSpace(CurrentDatabase.UserID) 
        || string.IsNullOrWhiteSpace(CurrentDatabase.Password);

    public static void SaveDatabaseSettings()
    {
        var config = new LocalConfiguration<MobileDatabaseSettings>();
        var old = config.LoadAll();
        foreach(var key in old.Keys)
        {
            if (!DatabaseSettings.ContainsKey(key))
            {
                new LocalConfiguration<MobileDatabaseSettings>(key).Delete();
            }
        }
        config.SaveAll(DatabaseSettings);
    }
    
    public static void LoadDatabaseSettings()
    {
        _databaseSettings = new LocalConfiguration<MobileDatabaseSettings>().LoadAll();
        
        // Migrate from Old Database Settings (if present)
        if (!_databaseSettings.Any())
        {
            var oldsettings = new LocalConfiguration<DatabaseSettings>().LoadAll();
            foreach (var key in oldsettings.Keys)
            {
                if (oldsettings[key].URLs?.Any() == true)
                {
                    var newsetting = new MobileDatabaseSettings()
                    {
                        URLs = oldsettings[key].URLs,
                        UserID = oldsettings[key].UserID,
                        Password = oldsettings[key].Password,
                        IsDefault = String.IsNullOrWhiteSpace(key),
                        CacheID = Guid.NewGuid()
                    };
                    _databaseSettings[String.IsNullOrWhiteSpace(key) ? "Default Profile" : key] = newsetting;
                }

                new LocalConfiguration<MobileDatabaseSettings>().SaveAll(_databaseSettings);
                new LocalConfiguration<DatabaseSettings>().Delete();
            }
        }
        
        // Contruct Defaults if required
        if (!_databaseSettings.Any())
        {
            _currentDatabase = new MobileDatabaseSettings();
            _currentDatabase.URLs = new String[]
            {
                "demo.prsdigital.com.au:8033",
                "demo2.prsdigital.com.au:8033",
            };
            _currentDatabase.UserID = "GUEST";
            _currentDatabase.Password = "guest";
            _currentDatabase.IsDefault = true;
            _currentDatabase.CacheID = Guid.NewGuid();
            _databaseSettings["Demo Database"] = _currentDatabase;
            new LocalConfiguration<MobileDatabaseSettings>().SaveAll(_databaseSettings);
        }

        // Retrieve the Default (or the first, if there is no default)
        _currentDatabase = _databaseSettings.Any(x => x.Value.IsDefault)
            ? _databaseSettings.FirstOrDefault(x => x.Value.IsDefault).Value
            : _databaseSettings.First().Value;
        if (_currentDatabase.CacheID == Guid.Empty)
        {
            _currentDatabase.CacheID = Guid.NewGuid();
            new LocalConfiguration<MobileDatabaseSettings>().SaveAll(_databaseSettings);
        }
    }
    

}