public LedgerAutoMapperConfiguration(
[NotNull] ILedgerTransactionFactory ledgerTransactionFactory,
[NotNull] IAccountTypeRepository accountTypeRepo,
[NotNull] IBudgetBucketRepository bucketRepo,
[NotNull] ILogger logger)
{
if (ledgerTransactionFactory == null)
{
throw new ArgumentNullException("ledgerTransactionFactory");
}
if (accountTypeRepo == null)
{
throw new ArgumentNullException("accountTypeRepo");
}
if (bucketRepo == null)
{
throw new ArgumentNullException("bucketRepo");
}
if (logger == null)
{
throw new ArgumentNullException("logger");
}
this.ledgerTransactionFactory = ledgerTransactionFactory;
this.accountTypeRepo = accountTypeRepo;
this.bucketRepo = bucketRepo;
this.logger = logger;
}
private DBContext()
{
_accounts = new AccountRepository();
_accountTypes = new AccountTypeRepository();
_audits = new AuditRepository();
_categories = new CategoryRepository();
_containers = new ContainerRepository();
_dimensions = new DimensionRepository();
_facilities = new FacilityRepository();
_facilityTypes = new FacilityTypeRepository();
_priorities = new PriorityRepository();
_users = new UserRepository();
_packagingLevels = new PackagingLevelRepository();
_pictures = new PictureRepository();
_projects = new ProjectRepository();
_ratings = new RatingRepository();
_requests = new RequestRepository();
_requestItems = new RequestItemRepository();
_requestItemTypes = new RequestItemTypeRepository();
_roles = new RoleRepository();
_sources = new SourceRepository();
_status = new StatusRepository();
_status = new StatusRepository();
_tasks = new TaskRespository();
_dcIssueItems = new DCIssueItemRepository();
_dcIssues = new DCIssueRepository();
_dcIssuesFacilities = new DCIssueFacilityRepository();
_failedSamples = new FailedSampleRepository();
_requestCategories = new RequestCategoryRepository();
}
public LedgerService(
[NotNull] ILedgerBookRepository ledgerRepository,
[NotNull] IAccountTypeRepository accountTypeRepository,
[NotNull] ILedgerBucketFactory ledgerBucketFactory,
[NotNull] MonitorableDependencies monitorableDependencies)
{
if (ledgerRepository == null)
{
throw new ArgumentNullException(nameof(ledgerRepository));
}
if (accountTypeRepository == null)
{
throw new ArgumentNullException(nameof(accountTypeRepository));
}
if (ledgerBucketFactory == null)
{
throw new ArgumentNullException(nameof(ledgerBucketFactory));
}
if (monitorableDependencies == null)
{
throw new ArgumentNullException(nameof(monitorableDependencies));
}
this.ledgerRepository = ledgerRepository;
this.accountTypeRepository = accountTypeRepository;
this.ledgerBucketFactory = ledgerBucketFactory;
this.monitorableDependencies = monitorableDependencies;
}
public LoadFileController(
[NotNull] UiContext uiContext,
[NotNull] IAccountTypeRepository accountTypeRepository,
[NotNull] IVersionedStatementModelRepository statementModelRepository)
{
if (uiContext == null)
{
throw new ArgumentNullException("uiContext");
}
if (accountTypeRepository == null)
{
throw new ArgumentNullException("accountTypeRepository");
}
if (statementModelRepository == null)
{
throw new ArgumentNullException("statementModelRepository");
}
this.messageBox = uiContext.UserPrompts.MessageBox;
this.statementModelRepository = statementModelRepository;
this.userPromptOpenFileFactory = uiContext.UserPrompts.OpenFileFactory;
this.accountTypeRepository = accountTypeRepository;
UseExistingAccountName = true;
MessengerInstance = uiContext.Messenger;
MessengerInstance.Register<ShellDialogResponseMessage>(this, OnShellDialogResponseReceived);
}
public AccountsController(
IMaskIds maskIds,
//IRepository<Account> accountRepository,
IAccountRepository accountRepository,
IAppUserRepository appUserRepository,
IDropDownListRepository <Country> countryRepository,
IDropDownListRepository <Gender> genderRepository,
IDropDownListRepository <Currency> currencyRepository,
IAccountTypeRepository accountTypeRepository,
ITransactionType transactionTypeRepository,
IOrderByTypeRepository orderByTypeRepository,
ISetAccountRate satAccountRate,
UserManager <AppUser> userManager,
IUnitOfWorkB <Account> unitOfWorkAccount,
IMapper mapper)
{
_maskIds = maskIds;
_accountRepository = accountRepository;
_appUserRepository = appUserRepository;
_countryRepository = countryRepository;
_genderRepository = genderRepository;
_currencyRepository = currencyRepository;
_accountTypeRepository = accountTypeRepository;
_transactionTypeRepository = transactionTypeRepository;
_orderByTypeRepository = orderByTypeRepository;
_userManager = userManager;
_unitOfWorkAccount = unitOfWorkAccount;
_cancellationToken = new CancellationToken();
_setAccounRate = satAccountRate;
_mapper = mapper;
}
public GetCustomersSettingsQueryHandler(
ICustomerRepository customerRepository,
IAccountTypeRepository accountTypeRepository)
{
_customerRepository = customerRepository;
_accountTypeRepository = accountTypeRepository;
}
public GlobalFilterController(
[NotNull] UiContext uiContext,
[NotNull] IAccountTypeRepository accountTypeRepository)
{
if (uiContext == null)
{
throw new ArgumentNullException("uiContext");
}
if (accountTypeRepository == null)
{
throw new ArgumentNullException("accountTypeRepository");
}
this.accountTypeRepository = accountTypeRepository;
this.userMessageBox = uiContext.UserPrompts.MessageBox;
this.doNotUseCriteria = new GlobalFilterCriteria();
MessengerInstance = uiContext.Messenger;
MessengerInstance.Register<ApplicationStateLoadedMessage>(this, OnApplicationStateLoaded);
MessengerInstance.Register<ApplicationStateLoadFinishedMessage>(this, OnApplicationStateLoadFinished);
MessengerInstance.Register<ApplicationStateRequestedMessage>(this, OnApplicationStateRequested);
MessengerInstance.Register<RequestFilterMessage>(this, OnGlobalFilterRequested);
MessengerInstance.Register<WidgetActivatedMessage>(this, OnWidgetActivatedMessageReceived);
MessengerInstance.Register<ShellDialogResponseMessage>(this, OnShellDialogResponseReceived);
MessengerInstance.Register<RequestFilterChangeMessage>(this, OnGlobalFilterChangeRequested);
}
public Mapper_LedgerBookDto_LedgerBook(
[NotNull] IBudgetBucketRepository bucketRepo,
[NotNull] IAccountTypeRepository accountTypeRepo,
[NotNull] ILedgerBucketFactory bucketFactory,
[NotNull] ILedgerTransactionFactory transactionFactory,
[NotNull] IReconciliationBuilder reconciliationBuilder)
{
if (bucketRepo == null)
{
throw new ArgumentNullException(nameof(bucketRepo));
}
if (accountTypeRepo == null)
{
throw new ArgumentNullException(nameof(accountTypeRepo));
}
if (bucketFactory == null)
{
throw new ArgumentNullException(nameof(bucketFactory));
}
if (transactionFactory == null)
{
throw new ArgumentNullException(nameof(transactionFactory));
}
if (reconciliationBuilder == null)
{
throw new ArgumentNullException(nameof(reconciliationBuilder));
}
this.bucketRepo = bucketRepo;
this.accountTypeRepo = accountTypeRepo;
this.bucketFactory = bucketFactory;
this.transactionFactory = transactionFactory;
this.reconciliationBuilder = reconciliationBuilder;
}
public AccountService(IAccountRepository accountRepository, IAccountTypeRepository accountTypeRepository, ICustomerRepository customerRepository, IUnitOfWork uow)
{
this.accountRepository = accountRepository;
this.accountTypeRepository = accountTypeRepository;
this.customerRepository = customerRepository;
this.uow = uow;
}
public SetAccountRate(IAccountTypeRepository accountTypeRepository, IMapper mapper)
{
_accountTypeRepository = accountTypeRepository;
_mapper = mapper;
_savingAccount = new SavingAccount();
_currentAccount = new CurrentAccount();
}
public StatementAutoMapperConfiguration(
[NotNull] ITransactionTypeRepository transactionTypeRepo,
[NotNull] IAccountTypeRepository accountTypeRepo,
[NotNull] IBudgetBucketRepository bucketRepo,
[NotNull] ILogger logger)
{
if (transactionTypeRepo == null)
{
throw new ArgumentNullException("transactionTypeRepo");
}
if (accountTypeRepo == null)
{
throw new ArgumentNullException("accountTypeRepo");
}
if (bucketRepo == null)
{
throw new ArgumentNullException("bucketRepo");
}
if (logger == null)
{
throw new ArgumentNullException("logger");
}
this.transactionTypeRepo = transactionTypeRepo;
this.accountTypeRepo = accountTypeRepo;
this.bucketRepo = bucketRepo;
this.logger = logger;
}
public GetAccountTypesListQueryHandler(
IAccountTypeRepository repository,
IMapper mapper)
{
_repository = repository;
_mapper = mapper;
}
public SignUpController(IAccountTypeRepository accountTypeRepository,
IUserRepository userRepository, IStudentRepository studentRepository)
{
this.accountTypeRepository = accountTypeRepository;
this.userRepository = userRepository;
this.studentRepository = studentRepository;
}
public OrganizationController
(
IAccountTypeRepository accountTypeRepository,
IUserRepository userRepository,
IEventRepository eventRepository,
IEventCategoryRepository eventCategoryRepository,
IStudentRepository studentRepository,
IJudgeRepository judgeRepository,
IOrganizationRepository organizationRepository,
IJobPostRepository jobPostRepository,
IJobCategoryRepository JobCategoryRepository,
IJobApplyActivityRepository jobApplyActivityRepository
)
{
this.accountTypeRepository = accountTypeRepository;
this.userRepository = userRepository;
this.eventRepository = eventRepository;
this.eventCategoryRepository = eventCategoryRepository;
this.studentRepository = studentRepository;
this.judgeRepository = judgeRepository;
this.organizationRepository = organizationRepository;
this.jobPostRepository = jobPostRepository;
this.JobCategoryRepository = JobCategoryRepository;
this.jobApplyActivityRepository = jobApplyActivityRepository;
}
public CustomeRepositoryTest(DatabaseFixture fixture, ITestOutputHelper output)
{
_output = output;
_context = fixture.Context;
_customerRepository = new CustomerRepository(fixture.Context);
_accountTypeRepository = new AccountTypeRepository(fixture.Context);
}
public AccountTypeBusinessEngine(IDataRepositoryFactory data_repo_fact, ICache cache, IEntityServiceFactory ent_serv_fact)
: base(data_repo_fact, null, ent_serv_fact)
{
_cache = cache;
_repo_acct_type = _data_repository_factory.GetDataRepository <IAccountTypeRepository>();
_acct_es = _entity_service_factory.GetEntityService <IAccountTypeEntityService>();
GetTypes();
}
public CsvOnDiskStatementModelRepositoryV1TestHarness(IAccountTypeRepository accountTypeRepo, IUserMessageBox userMessageBox, IBudgetBucketRepository bucketRepo, BankImportUtilities importUtilities, ILogger logger)
: base(userMessageBox,
importUtilities,
logger,
new TransactionSetDtoToStatementModelMapper(),
new StatementModelToTransactionSetDtoMapper())
{
}
public CreditController(IAccountTypeRepository saveTypeRepo, IAccountRepository saveRepo, IPaymentMethodRepository payRepo,
ICreditBalanceRepository creditRepo)
{
_saveTypeRepo = saveTypeRepo;
_saveRepo = saveRepo;
_payRepo = payRepo;
_creditRepo = creditRepo;
}
public AccountTypeController(IImsQueries queries, IAccountTypeRepository repository, IMapper mapper,
IIdentityService identityService)
{
_queries = queries;
_repository = repository;
_mapper = mapper;
_identityService = identityService;
}
/// <summary>
/// Standard constructor.
/// </summary>
/// <param name="accountRepository">Repo to use for account information.</param>
/// <param name="accountBalanceRepository">Repo for account balance information.</param>
/// <param name="accountTemplateRepository">Repo fro account template information.</param>
/// <param name="accountTypeRepository">Repo for account type information.</param>
/// <param name="requestLogger">Logger used to log information about request.</param>
public AccountService(IAccountRepository accountRepository, IAccountBalanceRepository accountBalanceRepository, IAccountTemplateRepository accountTemplateRepository, IAccountTypeRepository accountTypeRepository, IApiRequestLogger requestLogger)
{
RequestLogger = requestLogger;
AccountRepo = accountRepository;
AccountBalanceRepo = accountBalanceRepository;
AccountTemplateRepo = accountTemplateRepository;
AccountTypeRepository = accountTypeRepository;
}
public Mapper_LedgerTransactionDto_BankBalanceAdjustmentTransaction([NotNull] IAccountTypeRepository accountTypeRepo)
{
if (accountTypeRepo == null)
{
throw new ArgumentNullException(nameof(accountTypeRepo));
}
this.accountTypeRepo = accountTypeRepo;
}
public Mapper_BankBalanceDto_BankBalance([NotNull] IAccountTypeRepository accountTypeRepo)
{
if (accountTypeRepo == null)
{
throw new ArgumentNullException(nameof(accountTypeRepo));
}
this.accountTypeRepo = accountTypeRepo;
}
public AccountController(IAccountRepository accountRepo, IAccountTypeRepository accountTypeRepo,
ITransactionTypeRepository transactionTypeRepo, ICurrentUser currentUser)
{
_accountRepository = accountRepo;
_accountTypeRepository = accountTypeRepo;
_transactionTypeRepository = transactionTypeRepo;
_user = currentUser;
}
public IncomeController(IIncomeEntryRespository repo, IIncomeCategoryRepository catRepo, IAccountTypeRepository accountTypeRepo,
IAccountRepository accountRepo)
{
_repo = repo;
_catRepo = catRepo;
_accountTypeRepo = accountTypeRepo;
_accountRepo = accountRepo;
}
public Mapper_TransactionDto_Transaction([NotNull] IAccountTypeRepository accountRepo, [NotNull] IBudgetBucketRepository bucketRepo, [NotNull] ITransactionTypeRepository transactionTypeRepo)
{
if (accountRepo == null) throw new ArgumentNullException(nameof(accountRepo));
if (bucketRepo == null) throw new ArgumentNullException(nameof(bucketRepo));
if (transactionTypeRepo == null) throw new ArgumentNullException(nameof(transactionTypeRepo));
this.accountRepo = accountRepo;
this.bucketRepo = bucketRepo;
this.transactionTypeRepo = transactionTypeRepo;
}
public AccountsController(IAccountRepository accountRepository, ICustomerRepository customerRepository,
ISequenceRepository sequenceRepository, IAccountTypeRepository accounttypeRepository, ILocationRepository locationRepository)
{
_accountRepository = accountRepository;
_customerRepository = customerRepository;
_sequenceRepository = sequenceRepository;
_locationRepository = locationRepository;
_accounttypeRepository = accounttypeRepository;
}
public CreateAccountQueryHandler(
IAccountTypeRepository accountTypeRepository,
ICustomerRepository customerRepository,
IUserRepository userRepository)
{
_accountTypeRepository = accountTypeRepository;
_customerRepository = customerRepository;
_userRepository = userRepository;
}
public AccountNumberGenerator(
IAccountOwnerService accountOwnerService,
IAccountRepository accountRepository,
IAccountTypeRepository accountTypeRepository
)
{
this.accountOwnerService = accountOwnerService;
this.accountRepository = accountRepository;
this.accountTypeRepository = accountTypeRepository;
}
public AccountTypeService(
IAccountTypeRepository accountTypeRepository,
IMapper mapper,
ISelectService selectService
)
{
_accountTypeRepository = accountTypeRepository;
_mapper = mapper;
_selectService = selectService;
}
public CryptoController(ICoinRepository repo, ICryptoCurrencyRepository stockRepo,
ITargetAmountRepository goalRepo, ITargetTypeRepository goalTypeRepo,
IAccountRepository saveRepo, IAccountTypeRepository saveTypeRepo, IIncomeEntryRespository incomeRepo)
{
_repo = repo;
_stockRepo = stockRepo;
_goalRepo = goalRepo;
_goalTypeRepo = goalTypeRepo;
_saveRepo = saveRepo;
_saveTypeRepo = saveTypeRepo;
_incomeRepo = incomeRepo;
}
public Mapper_LedgerTransactionDto_LedgerTransaction([NotNull] ILedgerTransactionFactory transactionFactory, [NotNull] IAccountTypeRepository accountTypeRepo)
{
if (transactionFactory == null)
{
throw new ArgumentNullException(nameof(transactionFactory));
}
if (accountTypeRepo == null)
{
throw new ArgumentNullException(nameof(accountTypeRepo));
}
this.transactionFactory = transactionFactory;
this.accountTypeRepo = accountTypeRepo;
}
public UsersController(IAccountTypeRepository accountTypeRepository,
IUserRepository userRepository, IEventRepository eventRepository,
IEventCategoryRepository eventCategoryRepository, IStudentRepository studentRepository,
IJudgeRepository judgeRepository, IOrganizationRepository organizationRepository)
{
this.accountTypeRepository = accountTypeRepository;
this.userRepository = userRepository;
this.eventRepository = eventRepository;
this.eventCategoryRepository = eventCategoryRepository;
this.studentRepository = studentRepository;
this.judgeRepository = judgeRepository;
this.organizationRepository = organizationRepository;
}
public AccountCommandHandler(
IAccountRepository accountRepository,
IAccountTypeRepository accountTypeRepository,
IUserRepository userRepository,
IAccountAdminRepository accountAdminRepository,
IAccountUserRepository accountUserRepository)
{
_accountRepository = accountRepository;
_accountTypeRepository = accountTypeRepository;
_userRepository = userRepository;
_accountAdminRepository = accountAdminRepository;
_accountUserRepository = accountUserRepository;
}
public ExpenseController(IExpenseRepository repo, IExpenseCategoryRepository catRepo,
ITargetAmountRepository goalRepo, ITargetTypeRepository goalTypeRepo, IAccountTypeRepository saveTypeRepo,
IAccountRepository saveRepo, IPaymentMethodRepository payRepo, ICreditBalanceRepository creditRepo)
{
_repo = repo;
_catRepo = catRepo;
_goalRepo = goalRepo;
_goalTypeRepo = goalTypeRepo;
_saveTypeRepo = saveTypeRepo;
_saveRepo = saveRepo;
_payRepo = payRepo;
_creditRepo = creditRepo;
}
public StockController(IShareRepository repo, IStockRepository stockRepo,
ITargetAmountRepository goalRepo, ITargetTypeRepository goalTypeRepo, ISectorRepository sectorRepo,
IAccountRepository saveRepo, IAccountTypeRepository saveTypeRepo, IIncomeEntryRespository incomeRepo)
{
_repo = repo;
_stockRepo = stockRepo;
_goalRepo = goalRepo;
_goalTypeRepo = goalTypeRepo;
_sectorRepo = sectorRepo;
_saveRepo = saveRepo;
_saveTypeRepo = saveTypeRepo;
_incomeRepo = incomeRepo;
}
public IsCanAddProductTest(DatabaseFixture fixture, ITestOutputHelper output)
{
_output = output;
_context = fixture.Context;
_customerRepository = new CustomerRepository(fixture.Context);
_accountTypeRepository = new AccountTypeRepository(fixture.Context);
_surveyRepository = new SurveyRepository(fixture.Context);
_productRepository = new ProductRepository(fixture.Context);
_bundleRepository = new BundleRepository(fixture.Context);
_questionRepository = new QuestionRepository(fixture.Context);
_customerSurveyRepository = new CustomerSurveyRepository(fixture.Context);
_answerRepository = new AnswerRepository(fixture.Context);
_possibleAnswersRepository = new PossibleAnswersRepository(fixture.Context);
}
public RecomendedBundleTest(DatabaseFixture fixture, ITestOutputHelper output)
{
_output = output;
_output.WriteLine("Start RecomendedBundle Tests");
_context = fixture.Context;
_customerRepository = new CustomerRepository(fixture.Context);
_accountTypeRepository = new AccountTypeRepository(fixture.Context);
_surveyRepository = new SurveyRepository(fixture.Context);
//_productRepository = new ProductRepository(fixture.Context);
//_bundleRepository = new BundleRepository(fixture.Context);
_questionRepository = new QuestionRepository(fixture.Context);
_customerSurveyRepository = new CustomerSurveyRepository(fixture.Context);
_answerRepository = new AnswerRepository(fixture.Context);
_possibleAnswersRepository = new PossibleAnswersRepository(fixture.Context);
}
public LedgerBucketFactory([NotNull] IBudgetBucketRepository bucketRepo,
[NotNull] IAccountTypeRepository accountRepo)
{
if (bucketRepo == null)
{
throw new ArgumentNullException(nameof(bucketRepo));
}
if (accountRepo == null)
{
throw new ArgumentNullException(nameof(accountRepo));
}
this.bucketRepo = bucketRepo;
this.accountRepo = accountRepo;
}
public LedgerTransactionsController([NotNull] UiContext uiContext, [NotNull] IAccountTypeRepository accountTypeRepository)
{
this.accountTypeRepository = accountTypeRepository;
if (uiContext == null)
{
throw new ArgumentNullException("uiContext");
}
if (accountTypeRepository == null)
{
throw new ArgumentNullException("accountTypeRepository");
}
MessengerInstance = uiContext.Messenger;
MessengerInstance.Register<ShellDialogResponseMessage>(this, OnShellDialogResponseReceived);
Reset();
}
public Mapper_LedgerBookDto_LedgerBook(
[NotNull] IBudgetBucketRepository bucketRepo,
[NotNull] IAccountTypeRepository accountTypeRepo,
[NotNull] ILedgerBucketFactory bucketFactory,
[NotNull] ILedgerTransactionFactory transactionFactory,
[NotNull] IReconciliationBuilder reconciliationBuilder)
{
if (bucketRepo == null) throw new ArgumentNullException(nameof(bucketRepo));
if (accountTypeRepo == null) throw new ArgumentNullException(nameof(accountTypeRepo));
if (bucketFactory == null) throw new ArgumentNullException(nameof(bucketFactory));
if (transactionFactory == null) throw new ArgumentNullException(nameof(transactionFactory));
if (reconciliationBuilder == null) throw new ArgumentNullException(nameof(reconciliationBuilder));
this.bucketRepo = bucketRepo;
this.accountTypeRepo = accountTypeRepo;
this.bucketFactory = bucketFactory;
this.transactionFactory = transactionFactory;
this.reconciliationBuilder = reconciliationBuilder;
}
public AddLedgerReconciliationController(
[NotNull] UiContext uiContext,
[NotNull] IAccountTypeRepository accountTypeRepository)
{
this.accountTypeRepository = accountTypeRepository;
if (uiContext == null)
{
throw new ArgumentNullException(nameof(uiContext));
}
if (accountTypeRepository == null)
{
throw new ArgumentNullException(nameof(accountTypeRepository));
}
MessengerInstance = uiContext.Messenger;
MessengerInstance.Register<ShellDialogResponseMessage>(this, OnShellDialogResponseReceived);
this.messageBox = uiContext.UserPrompts.MessageBox;
}
public LoadFileController(
[NotNull] IUiContext uiContext,
[NotNull] IAccountTypeRepository accountTypeRepository)
{
if (uiContext == null)
{
throw new ArgumentNullException(nameof(uiContext));
}
if (accountTypeRepository == null)
{
throw new ArgumentNullException(nameof(accountTypeRepository));
}
this.messageBox = uiContext.UserPrompts.MessageBox;
this.userPromptOpenFileFactory = uiContext.UserPrompts.OpenFileFactory;
this.accountTypeRepository = accountTypeRepository;
MessengerInstance = uiContext.Messenger;
MessengerInstance.Register<ShellDialogResponseMessage>(this, OnShellDialogResponseReceived);
}
public LedgerBucketViewController([NotNull] IAccountTypeRepository accountRepo, [NotNull] IUiContext context, [NotNull] ILedgerService ledgerService)
{
if (accountRepo == null)
{
throw new ArgumentNullException(nameof(accountRepo));
}
if (context == null)
{
throw new ArgumentNullException(nameof(context));
}
if (ledgerService == null)
{
throw new ArgumentNullException(nameof(ledgerService));
}
MessengerInstance = context.Messenger;
MessengerInstance.Register<ShellDialogResponseMessage>(this, OnShellDialogResponseReceived);
this.accountRepo = accountRepo;
this.ledgerService = ledgerService;
this.messageBox = context.UserPrompts.MessageBox;
}
public ChooseBudgetBucketController([NotNull] IUiContext uiContext, [NotNull] IBudgetBucketRepository bucketRepository, [NotNull] IAccountTypeRepository accountRepo)
{
if (uiContext == null)
{
throw new ArgumentNullException(nameof(uiContext));
}
if (bucketRepository == null)
{
throw new ArgumentNullException(nameof(bucketRepository));
}
if (accountRepo == null)
{
throw new ArgumentNullException(nameof(accountRepo));
}
this.bucketRepository = bucketRepository;
this.accountRepo = accountRepo;
BudgetBuckets = bucketRepository.Buckets.ToList();
MessengerInstance = uiContext.Messenger;
MessengerInstance.Register<ShellDialogResponseMessage>(this, OnShellDialogResponseReceived);
}
public Mapper_LedgerTransactionDto_LedgerTransaction([NotNull] ILedgerTransactionFactory transactionFactory, [NotNull] IAccountTypeRepository accountTypeRepo)
{
if (transactionFactory == null) throw new ArgumentNullException(nameof(transactionFactory));
if (accountTypeRepo == null) throw new ArgumentNullException(nameof(accountTypeRepo));
this.transactionFactory = transactionFactory;
this.accountTypeRepo = accountTypeRepo;
}
public Mapper_LedgerTransactionDto_BankBalanceAdjustmentTransaction([NotNull] IAccountTypeRepository accountTypeRepo)
{
if (accountTypeRepo == null) throw new ArgumentNullException(nameof(accountTypeRepo));
this.accountTypeRepo = accountTypeRepo;
}
public Mapper_LedgerEntryLineDto_LedgerEntryLine(
[NotNull] IAccountTypeRepository accountTypeRepo,
[NotNull] ILedgerBucketFactory bucketFactory,
[NotNull] ILedgerTransactionFactory transactionFactory)
{
if (accountTypeRepo == null) throw new ArgumentNullException(nameof(accountTypeRepo));
if (bucketFactory == null) throw new ArgumentNullException(nameof(bucketFactory));
if (transactionFactory == null) throw new ArgumentNullException(nameof(transactionFactory));
this.accountTypeRepo = accountTypeRepo;
this.bucketFactory = bucketFactory;
this.transactionFactory = transactionFactory;
}
public Mapper_LedgerBucketDto_LedgerBucket([NotNull] IBudgetBucketRepository bucketRepo, [NotNull] IAccountTypeRepository accountTypeRepo, [NotNull] ILedgerBucketFactory bucketFactory)
{
if (bucketRepo == null) throw new ArgumentNullException(nameof(bucketRepo));
if (accountTypeRepo == null) throw new ArgumentNullException(nameof(accountTypeRepo));
if (bucketFactory == null) throw new ArgumentNullException(nameof(bucketFactory));
this.bucketRepo = bucketRepo;
this.accountTypeRepo = accountTypeRepo;
this.bucketFactory = bucketFactory;
}
public Mapper_BankBalanceDto_BankBalance([NotNull] IAccountTypeRepository accountTypeRepo)
{
if (accountTypeRepo == null) throw new ArgumentNullException(nameof(accountTypeRepo));
this.accountTypeRepo = accountTypeRepo;
}
