Backend-Api/CompanyManagment.EFCore/Repository/ContractingPartyBankAccountsRepository.cs

using System.Collections.Generic;
using System.Linq;
using System.Threading.Tasks;
using _0_Framework.Application;
using _0_Framework.InfraStructure;
using Company.Domain.ContractingPartyBankAccountsAgg;
using CompanyManagment.App.Contracts.ContractingPartyBankAccounts;
using Microsoft.AspNetCore.Mvc.Formatters;
using Microsoft.EntityFrameworkCore;

namespace CompanyManagment.EFCore.Repository;

public class ContractingPartyBankAccountsRepository : RepositoryBase<long, ContractingPartyBankAccount>,
    IContractingPartyBankAccountsRepository
{
    private readonly CompanyContext _context;

    public ContractingPartyBankAccountsRepository(CompanyContext context) : base(context)
    {
        _context = context;
    }

    public async Task<GetContractingPartyBankAccountViewModel> GetList(
        ContractingPartyBankAccountSearchModel searchModel)
    {
        var query = _context.ContractingPartyBankAccounts.AsQueryable();
        if (!string.IsNullOrEmpty(searchModel.CardNumber))
            query = query.Where(x => x.CardNumber.Contains(searchModel.CardNumber));

        if (!string.IsNullOrEmpty(searchModel.AccountNumber))
            query = query.Where(x => x.AccountNumber.Contains(searchModel.AccountNumber));

        if (!string.IsNullOrWhiteSpace(searchModel.IBan))
            query = query.Where(x => x.IBan.Contains(searchModel.IBan));

        if (!string.IsNullOrWhiteSpace(searchModel.ContractingPartyOrAccountHolderName))
            query = query.Where(x => x.AccountHolderName
                                         .Contains(searchModel.ContractingPartyOrAccountHolderName) ||
                                     (x.ContractingParty.FName + " " + x.ContractingParty.LName).Contains(searchModel
                                         .ContractingPartyOrAccountHolderName));
        var count = await query.CountAsync();

        var result = new GetContractingPartyBankAccountViewModel()
        {
            Count = count,
            List = await query
                .GroupBy(x => new { x.ContractingPartyId, x.ContractingParty.FName, x.ContractingParty.LName })
                .Select(g => new ContractingPartyBankAccountsGroupedViewModel()
                {
                    ContractingPartyId = g.Key.ContractingPartyId,
                    ContractingPartyName = g.Key.FName + " " + g.Key.LName,
                    BankAccountsItems = g.Select(x => new ContractingPartyBankAccountsItemViewModel
                    {
                        AccountHolderName = x.AccountHolderName,
                        AccountNumber = x.AccountNumber,
                        CardNumber = x.CardNumber,
                        IBan = x.IBan,
                    }).ToList()
                }).Skip(searchModel.PageIndex)
                .Take(30).ToListAsync()
        };
        
        return result;
    }

    public async Task<OperationResult<List<string>>> ContractingPartyOrAccountHolderNameSelectList(string search,
        string selected)
    {
        var accountHolderQuery = _context.ContractingPartyBankAccounts.Select(x => x.AccountHolderName);
        var contractingPartyNameQuery =
            _context.ContractingPartyBankAccounts.Select(x =>
                x.ContractingParty.FName + " " + x.ContractingParty.LName);
        if (!string.IsNullOrWhiteSpace(search))
        {
            accountHolderQuery = accountHolderQuery.Where(x => x.Contains(search));
            contractingPartyNameQuery = contractingPartyNameQuery.Where(x => x.Contains(search));
        }

        var result = await accountHolderQuery.Union(contractingPartyNameQuery).Take(50).ToListAsync();

        if (!string.IsNullOrWhiteSpace(selected))
        {
            result.Add(selected);
        }

        return new OperationResult<List<string>>().Succcedded(result.Distinct().ToList());
    }

    public async Task<OperationResult<List<string>>> IBanSelectList(string search, string selected)
    {
        var iBanQuery = _context.ContractingPartyBankAccounts.Select(x => x.IBan);
        if (!string.IsNullOrWhiteSpace(search))
        {
            iBanQuery = iBanQuery.Where(x => x.Contains(search));
        }

        var result = await iBanQuery.Take(50).ToListAsync();

        if (!string.IsNullOrWhiteSpace(selected))
        {
            result.Add(selected);
        }

        return new OperationResult<List<string>>().Succcedded(result.Distinct().ToList());
    }

    public async Task<OperationResult<List<string>>> CardNumberSelectList(string search, string selected)
    {
        var cardNumberQuery = _context.ContractingPartyBankAccounts.Select(x => x.CardNumber);
        if (!string.IsNullOrWhiteSpace(search))
        {
            cardNumberQuery = cardNumberQuery.Where(x => x.Contains(search));
        }

        var result = await cardNumberQuery.Take(50).ToListAsync();

        if (!string.IsNullOrWhiteSpace(selected))
        {
            result.Add(selected);
        }

        return new OperationResult<List<string>>().Succcedded(result.Distinct().ToList());
    }

    public async Task<OperationResult<List<string>>> AccountNumberSelectList(string search, string selected)
    {
        var accountNumberQuery = _context.ContractingPartyBankAccounts.Select(x => x.IBan);
        if (!string.IsNullOrWhiteSpace(search))
        {
            accountNumberQuery = accountNumberQuery.Where(x => x.Contains(search));
        }

        var result = await accountNumberQuery.Take(50).ToListAsync();

        if (!string.IsNullOrWhiteSpace(selected))
        {
            result.Add(selected);
        }

        return new OperationResult<List<string>>().Succcedded(result.Distinct().ToList());
    }
}