AccountingNext/Schaad.Accounting.Db/Repositories/AccountRepository.cs

using System;
using System.Collections.Generic;
using System.IO;
using System.Linq;
using System.Threading.Tasks;
using Microsoft.Extensions.Logging;
using Schaad.Accounting.Interfaces;
using Schaad.Accounting.Models;

namespace Schaad.Accounting.Repositories
{
    public class AccountRepository : BaseRepository, IAccountRepository
    {
        private readonly string ACCOUNTS = "Accounts.xml";

        public AccountRepository(ISettingsService settingsService, RepositoryCache cache, ILogger<AccountRepository> logger)
            : base(settingsService, cache, logger)
        {
            EnsureAccountsFile();
        }

        public Task<List<Account>> GetAccountListAsync() => LoadListAsync<Account>(ACCOUNTS);

        public async Task SaveAccountAsync(Account account)
        {
            if (string.IsNullOrEmpty(account.Currency))
            {
                account.Currency = "CHF";
            }

            var accounts = await GetAccountListAsync();
            var idx = accounts.FindIndex(a => a.Id == account.Id);
            if (idx >= 0)
            {
                accounts[idx] = account;
            }
            else
            {
                account.Id = Guid.NewGuid().ToString();
                accounts.Add(account);
            }
            await SaveAsync(accounts, ACCOUNTS);
        }

        public async Task<Account> GetAccountAsync(string id)
        {
            var accounts = await GetAccountListAsync();
            return accounts.FirstOrDefault(t => t.Id == id);
        }

        public async Task DeleteAccountAsync(string id)
        {
            var accounts = await GetAccountListAsync();
            accounts.RemoveAll(t => t.Id == id);
            await SaveAsync(accounts, ACCOUNTS);
        }

        public async Task<Account> GetAccountForBankAccountNumberAsync(string bankAccountNumber)
        {
            var accounts = await GetAccountListAsync();
            return accounts.SingleOrDefault(t => t.BankAccountNumber == bankAccountNumber);
        }

        public async Task SaveBankAccountBalanceAsync(string bankAccountNumber, decimal accountBalance)
        {
            var account = await GetAccountForBankAccountNumberAsync(bankAccountNumber);
            account.LastBankBalance = accountBalance;
            await SaveAccountAsync(account);
        }

        private void EnsureAccountsFile()
        {
            string filePath = Path.Combine(settingsService.GetDbPath(), ACCOUNTS);
            if (File.Exists(filePath))
            {
                return;
            }

            var lastYearFile = Path.Combine(settingsService.GetLastYearDbPath(), ACCOUNTS);
            if (File.Exists(lastYearFile))
            {
                File.Copy(lastYearFile, filePath);
            }

            // Year rollover: seed start balances from the previous year's closing values.
            // Bank accounts start at the last known bank balance; cash accounts start at zero.
            // Uses the sync GetAwaiter().GetResult() bridge because this runs from the
            // constructor; the file was just copied so the underlying I/O is local.
            var accounts = GetAccountListAsync().GetAwaiter().GetResult();
            var modified = false;
            foreach (var account in accounts.Where(a => a.Class == ClassIds.Activa))
            {
                if (account.LastBankBalance > 0)
                {
                    account.StartBalance = account.LastBankBalance;
                    modified = true;
                }
                else if (account.Number < 1010)
                {
                    account.StartBalance = 0;
                    modified = true;
                }
            }
            if (modified)
            {
                SaveAsync(accounts, ACCOUNTS).GetAwaiter().GetResult();
            }
        }
    }
}