public IncomeService(IIncomeRepository incomeRepository, IBankAccountRepository bankAccountRepository,
IHistoricMovementRepository historicMovementRepository)
{
this._incomeRepository = incomeRepository;
this._bankAccountRepository = bankAccountRepository;
this._historicMovementRepository = historicMovementRepository;
}
public TransferEditorViewModel(
ITransferRepository transferRepository,
IBankAccountRepository bankAccountRepository,
IBankAccountAgent bankAccountAgent,
IEnumerable <IScheduleFrequency> frequencyCalculators,
Transfer entity
)
{
this.transferRepository = transferRepository;
this.bankAccountRepository = bankAccountRepository;
this.bankAccountAgent = bankAccountAgent;
this.frequencyCalculators = frequencyCalculators;
this.entity = entity;
this.Amount.PropertyChanged += (s, e) =>
{
base.Validate();
};
base.ValidationHelper.AddInstance(this.Amount);
this.FrequencyEvery.PropertyChanged += (s, e) =>
{
base.Validate();
NotifyPropertyChanged(() => this.FrequencyEveryLabel);
};
base.ValidationHelper.AddInstance(this.FrequencyEvery);
NewFromBankAccountCommand = base.AddNewCommand(new ActionCommand(this.NewFromBankAccount));
NewToBankAccountCommand = base.AddNewCommand(new ActionCommand(this.NewToBankAccount));
}
public TransferEditorViewModel(
ITransferRepository transferRepository,
IBankAccountRepository bankAccountRepository,
IBankAccountAgent bankAccountAgent,
IEnumerable<IScheduleFrequency> frequencyCalculators,
Transfer entity
)
{
this.transferRepository = transferRepository;
this.bankAccountRepository = bankAccountRepository;
this.bankAccountAgent = bankAccountAgent;
this.frequencyCalculators = frequencyCalculators;
this.entity = entity;
this.Amount.PropertyChanged += (s,e) =>
{
base.Validate();
};
base.ValidationHelper.AddInstance(this.Amount);
this.FrequencyEvery.PropertyChanged += (s, e) =>
{
base.Validate();
NotifyPropertyChanged(() => this.FrequencyEveryLabel);
};
base.ValidationHelper.AddInstance(this.FrequencyEvery);
NewFromBankAccountCommand = base.AddNewCommand(new ActionCommand(this.NewFromBankAccount));
NewToBankAccountCommand = base.AddNewCommand(new ActionCommand(this.NewToBankAccount));
}
/// <summary>
/// Create a new instance
/// </summary>
public BankAppService(
IBankAccountRepository bankAccountRepository,
// the bank account repository dependency
ICustomerRepository customerRepository,
// the customer repository dependency
IBankTransferService transferService)
{
//check preconditions
if (bankAccountRepository == null)
{
throw new ArgumentNullException("bankAccountRepository");
}
if (customerRepository == null)
{
throw new ArgumentNullException("customerRepository");
}
if (transferService == null)
{
throw new ArgumentNullException("trasferService");
}
_bankAccountRepository = bankAccountRepository;
_customerRepository = customerRepository;
_transferService = transferService;
}
public SystemController(IBankAccountRepository accountRepository, IProviderRepository providerRepository,
IInstitutionRepository institutionRepository)
{
_accountRepository = accountRepository;
_providerRepository = providerRepository;
_institutionRepository = institutionRepository;
}
//
// GET: /Member/
public BankBalanceController(IBankAccountRepository BankaccountParam, IConstantRepository ConstantParam, IBankBalanceRepository BankBalanceParam,
IIncomeRepository IncomeParam, IExpenseRepository ExpenseParam)
{
BankAccountRepository = BankaccountParam;
ConstantRepository = ConstantParam;
BankBalanceRepository = BankBalanceParam;
IncomeRepository = IncomeParam;
ExpenseRepository = ExpenseParam;
ViewBag.Supervisor = false;
int memberID = Convert.ToInt16(System.Web.HttpContext.Current.Session["personID"]);
if (memberID > 0)
{
if (MembershipRepositroy.IsUser(memberID))
{
user user = MembershipRepositroy.GetUserByID(memberID);
if ((user.role.Name == "WebMaster") || (user.role.Name == "Pastor") || (user.role.Name == "Admin") || (user.role.Name == "FinanceLead")) //creator access
{
ViewBag.Supervisor = true;
}
if (user.role.Name == "WebMaster") //creator access
{
ViewBag.WebMaster = true;
}
if (user.role.Name == "FinanceStaff") //creator access
{
ViewBag.Supervisor2 = true;
}
}
}
}
public DataService(IProviderRepository providerRepository, IBankAccountRepository accountRepository, IConfiguration configuration)
{
_configuration = configuration;
_providerRepository = providerRepository;
_accountRepository = accountRepository;
_client = new HttpClient();
}
public LoanController(IRepository repo, IMapper map, UserManager <User> custom, IBankAccountRepository bank)
{
_repo = repo;
_mapper = map;
_customerManager = custom;
_bankRepo = bank;
}
public BankAccountController(IBankAccountRepository accountRepository, IDataService dataService,
IValidationHelper validationHelper)
{
_accountRepository = accountRepository;
_dataService = dataService;
_validationHelper = validationHelper;
}
//
// GET: /Payee/
public PayeeController(IConstantRepository constantParam, IPayeeCategoryRepository PayeeCategoryParam, IPayeeRepository payeeParam, IBankAccountRepository BankAccountParam,
ISubCategoryRepository SubCategoryParam, ISubCategoryItemRepository SubCategoryItemParam)
{
ConstantRepository = constantParam;
PayeeCategoryRepository = PayeeCategoryParam;
PayeeRepository = payeeParam;
BankAccountRepository = BankAccountParam;
SubCategoryRepository = SubCategoryParam;
SubCategoryItemRepository = SubCategoryItemParam;
ViewBag.Supervisor = false;
int memberID = Convert.ToInt16(System.Web.HttpContext.Current.Session["personID"]);
if (memberID > 0)
{
if (MembershipRepositroy.IsUser(memberID))
{
user user = MembershipRepositroy.GetUserByID(memberID);
if ((user.role.Name == "WebMaster") || (user.role.Name == "Pastor") || (user.role.Name == "Admin") || (user.role.Name == "FinanceLead")) //creator access
{
ViewBag.Supervisor = true;
}
if (user.role.Name == "WebMaster") //creator access
{
ViewBag.WebMaster = true;
}
if (user.role.Name == "FinanceStaff") //creator access
{
ViewBag.Supervisor2 = true;
}
}
}
}
public OverviewController(IBankAccountRepository bankAccountRepository, ICreditCardRepository creditAccountRepository,
IValidationHelper validationHelper)
{
_bankAccountRepository = bankAccountRepository;
_creditAccountRepository = creditAccountRepository;
_validationHelper = validationHelper;
}
public ApplicationBankAccountService(
BankAccountService bankAccountService,
IBankAccountRepository bankRepository)
{
_bankAccountService = bankAccountService;
_bankRepository = bankRepository;
}
public CustomerService(ICustomerRepository customerRepository, IBankAccountRepository bankAccountRepository,
ITransactionRepository transactionRepository)
{
_customerRepository = customerRepository;
_bankAccountRepository = bankAccountRepository;
_transactionRepository = transactionRepository;
}
public GetSharedAccountsQueryHandler(
IMapper mapper,
IBankAccountRepository bankAccountRepository)
{
this.mapper = mapper ?? throw new ArgumentNullException(nameof(mapper));
this.bankAccountRepository = bankAccountRepository;
}
public static MovementStrategy GetMovementStrategy(Movement movement, IBankAccountRepository bankAccountRepository, IHistoricMovementRepository historicMovementRepository, IIncomeRepository incomeRepository, IAtmWithdrawRepository atmWithdrawRepository)
{
MovementStrategy strategy = null;
switch (movement.PaymentMethod)
{
case PaymentMethod.Cash:
strategy = new CashMovementStrategy(movement, bankAccountRepository, historicMovementRepository, incomeRepository, atmWithdrawRepository);
break;
case PaymentMethod.InternalTransfer:
strategy = new InternalTransferMovementStrategy(movement, bankAccountRepository, historicMovementRepository, incomeRepository, atmWithdrawRepository);
break;
case PaymentMethod.CB:
case PaymentMethod.DirectDebit:
case PaymentMethod.Transfer:
strategy = new CommonMovementStrategy(movement, bankAccountRepository, historicMovementRepository, incomeRepository, atmWithdrawRepository);
break;
default:
throw new ArgumentException("Unknown PaymentMethod");
}
return(strategy);
}
public BankAccountService(IMapper mapper, IBankAccountRepository bankAccountRepository, TransactionObservable transactionObservable)
: base(bankAccountRepository)
{
_mapper = mapper;
_bankAccountRepository = bankAccountRepository;
_transactionObservable = transactionObservable;
}
public void Initialize()
{
//string connectionString = "data source=MIKE_LAPTOP;initial catalog=FinanceINT;integrated security=True;App=MSTest;";
//var mcfactory = new ModelContextFactory(connectionString);
//IScheduleFactory scheduleFactory = new Fakes.FakeScheduleFactory();
//transferFactory = new Fakes.FakeTransferFactory(scheduleFactory);
//new Finances.Persistence.EF.MappingCreator(transferFactory).CreateMappings();
//repository = new BankAccountRepository(mcfactory,Mapper.Engine);
repository = container.Resolve<IBankAccountRepository>();
testEntity = new Core.Entities.BankAccount()
{
Bank = new Core.Entities.Bank() { BankId = 1 },
AccountNumber = "1234",
AccountOwner = "me",
Name = "Test-" + Guid.NewGuid().ToString(),
LoginID = "login",
LoginURL = "abc",
PasswordHint = "hint",
OpenedDate = DateTime.Now.Date,
ClosedDate = DateTime.Now.Date.AddDays(1),
SortCode = "000010",
InitialRate = 1.1M,
PaysTaxableInterest = true,
MilestoneDate = DateTime.Now.Date.AddDays(2),
MilestoneNotes = "msnotes",
Notes = "test notes"
};
}
public GetBankAccountByIdQueryHandler(
IBankAccountRepository bankAccountRepository,
IMapper mapper)
{
this.bankAccountRepository = bankAccountRepository ?? throw new ArgumentNullException(nameof(bankAccountRepository));
this.mapper = mapper ?? throw new ArgumentNullException(nameof(mapper));
}
public ApplyDepositHandler(IDepositRepository depositRepository, ILogger <ApplyDepositHandler> logger, IMediator mediator, IBankAccountRepository bankAccountRepository)
{
_depositRepository = depositRepository;
_logger = logger;
_mediator = mediator;
_bankAccountRepository = bankAccountRepository;
}
public ApplicationBankAccountService(
IBankAccountRepository bankRepository,
BankAccountService bankAccountService)
{
_bankRepository = bankRepository;
_bankAccountService = bankAccountService;
}
public void Initialize()
{
fakeBankAccountRepository = new FakeBankAccountRepository();
mockTransferFrequencyDateCalculatorFactory = new Mock <IScheduleFrequencyFactory>();
mockTransferDirectionGenerator = new Mock <ITransferDirectionGenerator>();
mockTransferFrequencyDateCalculatorMonthly = new Mock <IScheduleFrequency>();
mockTransferFrequencyDateCalculatorMonthly.Setup(s => s.CalculateNextDate(It.IsAny <Schedule>(), It.IsAny <DateTime>()))
.Returns((Transfer t, DateTime d) => d.AddMonths(1));
allAccounts = new List <CashflowBankAccount>();
sut = new CashflowProjectionTransferGenerator(
fakeBankAccountRepository,
//mockTransferFrequencyDateCalculatorFactory.Object,
mockTransferDirectionGenerator.Object
);
scheduleFrequencyCalculators = new IScheduleFrequency[] {
new ScheduleFrequencyMonthly(),
new ScheduleFrequencyWeekly()
};
scheduleFactory = new Fakes.FakeScheduleFactory();
}
public GrapQlQuery(IBankAccountRepository bankAccountRepository, IBankRepository bankRepository)
{
Field <ListGraphType <BankAccountType> >(
"bankAccounts",
resolve: context => bankAccountRepository.Get()
);
Field <ListGraphType <BankType> >(
"banks",
resolve: context => bankRepository.Get()
);
Field <BankAccountType>(
name: "bankAccountGetById",
arguments: new QueryArguments(new
QueryArgument <StringGraphType>
{
Name = "id"
}),
resolve: context =>
{
Guid id = context.GetArgument <Guid>("id");
return(bankAccountRepository.GetById(id));
}
);
}
public SalesTaxManager(IHttpContextAccessor contextAccessor, ISalesTaxRepository repository, IBankAccountRepository bankAccountRepository, IUnitOfWork unitOfWork)
{
_userId = contextAccessor.HttpContext.User.GetUserId();
_repository = repository;
_bankAccountRepository = bankAccountRepository;
_unitOfWork = unitOfWork;
}
public CreditController(IAsyncRepository <Credit> creditRepository, IBankAccountRepository bankAccountRepository,
IMediator mediator)
{
_creditRepository = creditRepository;
_mediator = mediator;
_bankAccountRepository = bankAccountRepository;
}
public BankAccountsWithoutActiveDepositHandle(
IDepositRepository depositRepository,
IBankAccountRepository bankAccountRepository)
{
_accountRepository = bankAccountRepository;
_depositRepository = depositRepository;
}
public AccountService(IBankAccountRepository bankAccountRepository, ICreditCardAccountRepository creditCardAccountRepository, IPortfolioRepository portfolioRepository, IMapper mapper)
{
BankAccountRepository = bankAccountRepository;
CreditCardAccountRepository = creditCardAccountRepository;
PortfolioRepository = portfolioRepository;
Mapper = mapper;
}
public void Initialize()
{
fakeBankAccountRepository = new FakeBankAccountRepository();
mockTransferFrequencyDateCalculatorFactory = new Mock<IScheduleFrequencyFactory>();
mockTransferDirectionGenerator = new Mock<ITransferDirectionGenerator>();
mockTransferFrequencyDateCalculatorMonthly = new Mock<IScheduleFrequency>();
mockTransferFrequencyDateCalculatorMonthly.Setup(s => s.CalculateNextDate(It.IsAny<Schedule>(), It.IsAny<DateTime>()))
.Returns((Transfer t, DateTime d) => d.AddMonths(1));
allAccounts = new List<CashflowBankAccount>();
sut = new CashflowProjectionTransferGenerator(
fakeBankAccountRepository,
//mockTransferFrequencyDateCalculatorFactory.Object,
mockTransferDirectionGenerator.Object
);
scheduleFrequencyCalculators = new IScheduleFrequency[] {
new ScheduleFrequencyMonthly(),
new ScheduleFrequencyWeekly() };
scheduleFactory = new Fakes.FakeScheduleFactory();
}
/// <summary>
/// Create a new instance
/// </summary>
public BankAppService(IBankAccountRepository bankAccountRepository, // the bank account repository dependency
ICustomerRepository customerRepository, // the customer repository dependency
IBankTransferService transferService,
ILogger <BankAppService> logger)
{
//check preconditions
if (bankAccountRepository == null)
{
throw new ArgumentNullException("bankAccountRepository");
}
if (customerRepository == null)
{
throw new ArgumentNullException("customerRepository");
}
if (transferService == null)
{
throw new ArgumentNullException("trasferService");
}
_bankAccountRepository = bankAccountRepository;
_customerRepository = customerRepository;
_transferService = transferService;
_logger = logger;
_resources = LocalizationFactory.CreateLocalResources();
}
public PaymentService(IPaymentTypeRepository paymentTypeRepository, IPaymentCategoryRepository paymentCategoryRepository, IPaymentRepository paymentRepository, IBankAccountRepository bankAccountRepository)
{
this.paymentTypeRepository = paymentTypeRepository;
this.paymentCategoryRepository = paymentCategoryRepository;
this.paymentRepository = paymentRepository;
this.bankAccountRepository = bankAccountRepository;
}
public void SetUp()
{
_session = new Mock<IDocumentSession>();
// System Under Test
_sut = new BankAccountRepository(_session.Object);
}
public BankAccountService(IBankAccountRepository bankAccountRepository, IUserRepository userRepository, ITransactionService transactionService, IMapper mapper)
{
_bankAccountRepository = bankAccountRepository;
_userRepository = userRepository;
_transactionService = transactionService;
_mapper = mapper;
}
public BankAccountController(
IBankAccountRepository bankAccountRepository,
IBankAccountFactory factory
)
{
_bankAccountRepository = bankAccountRepository;
_factory = factory;
}
public CashflowProjectionTransferGenerator(
IBankAccountRepository bankAccountRepository,
ITransferDirectionGenerator transferDirectionGenerator
)
{
this.bankAccountRepository = bankAccountRepository;
this.transferDirectionGenerator = transferDirectionGenerator;
}
public AccountController(IBankAccountRepository bankAccountRepository, UserManager <IdentityUser> userMgr,
SignInManager <IdentityUser> signInMgr, ILogger <AccountController> logger)
{
_bankAccountRepository = bankAccountRepository;
_signInManager = signInMgr;
_userManager = userMgr;
_logger = logger;
}
public BankAccountController(IBankAccountRepository repository, IMapper mapper, LinkGenerator linkGenerator,
ILogger <BankAccountController> logger)
{
_repository = repository;
_mapper = mapper;
_linkGenerator = linkGenerator;
_logger = logger;
}
public BankAccountController(IBankAccountRepository repository, string catalog, LoginView view)
{
this._LoginId = view.LoginId.ToLong();
this._UserId = view.UserId.ToInt();
this._OfficeId = view.OfficeId.ToInt();
this._Catalog = catalog;
this.BankAccountRepository = repository;
}
public BalanceDateEditorViewModel(
IBankAccountRepository bankAccountRepository,
IBalanceDateRepository balanceDateRepository,
BalanceDate entity
)
{
this.bankAccountRepository = bankAccountRepository;
this.balanceDateRepository = balanceDateRepository;
this.entity = entity;
}
public BankAccountAgent(
IBankAccountRepository bankAccountRepository,
IDialogService dialogService,
IBankAccountEditorViewModelFactory bankEditorViewModelFactory
)
{
this.bankAccountRepository = bankAccountRepository;
this.dialogService = dialogService;
this.bankAccountEditorViewModelFactory = bankEditorViewModelFactory;
}
/// <summary>
/// Default constructor for this service
/// </summary>
///<param name="bankTransferDomainService">Bank transfer domain service dependency</param>
/// <param name="bankAccountRepository">Bank account repository dependency</param>
public BankingManagementService(IBankTransferDomainService bankTransferDomainService, IBankAccountRepository bankAccountRepository)
{
if (bankTransferDomainService == (IBankTransferDomainService)null)
throw new ArgumentNullException("bankTransferDomainService", Resources.Messages.exception_DependenciesAreNotInitialized);
if (bankAccountRepository == (IBankAccountRepository)null)
throw new ArgumentNullException("bankAccountRepository", Resources.Messages.exception_DependenciesAreNotInitialized);
_bankTransferDomainService = bankTransferDomainService;
_bankAccountRepository = bankAccountRepository;
}
public void Initialize()
{
/*
* Cashflow(IProjectionTransferGenerator)
*
* ProjectionTransferGenerator(IBankAccountRepository,ITransferDirectionGenerator) : IProjectionTransferGenerator
*
* TransferDirectionGenerator(ITransferRepository) : ITransferDirectionGenerator
*
*/
transfers = new List<Transfer>()
{
new Transfer(new FakeScheduleFactory())
{
TransferId=1,
FromBankAccount = new BankAccount() { BankAccountId=1 },
ToBankAccount = new BankAccount() { BankAccountId=2 },
Amount = transferAmount,
Category = new TransferCategory() { Code="NONE" },
IsEnabled = true,
Schedule = new Schedule(scheduleFrequencyCalculators)
{
StartDate = cashflowStartDate,
EndDate = new DateTime(2016,08,01),
Frequency = "Monthly",
FrequencyEvery = 1
}
}
};
mockTransferRepository
.Setup(s => s.ReadList())
.Returns(transfers);
fakeBankAccountRepository = new FakeBankAccountRepository();
sut = new Cashflow(new CashflowProjection(new CashflowProjectionTransferGenerator(fakeBankAccountRepository,
new TransferDirectionGenerator(mockTransferRepository.Object)),null))
{
OpeningBalance = cashflowOperningBalance,
StartDate = cashflowStartDate,
CashflowBankAccounts = new List<CashflowBankAccount>()
{
new CashflowBankAccount()
{
BankAccount = new BankAccount()
{
BankAccountId=1
}
}
}
};
}
public BankAccountController()
{
this._LoginId = AppUsers.GetCurrent().View.LoginId.ToLong();
this._UserId = AppUsers.GetCurrent().View.UserId.ToInt();
this._OfficeId = AppUsers.GetCurrent().View.OfficeId.ToInt();
this._Catalog = AppUsers.GetCurrentUserDB();
this.BankAccountRepository = new MixERP.Net.Schemas.Core.Data.BankAccount
{
_Catalog = this._Catalog,
_LoginId = this._LoginId,
_UserId = this._UserId
};
}
public BankAccountEditorViewModel(
IBankAccountRepository bankAccountRepository,
IBankRepository bankRepository,
IBankAgent bankAgent,
BankAccount entity
)
{
this.bankRepository = bankRepository;
this.bankAccountRepository = bankAccountRepository;
this.bankAgent = bankAgent;
this.entity = entity;
NewBankCommand = base.AddNewCommand(new ActionCommand(this.NewBank));
}
public SupplierAppService(ISupplierQuery supplierQuery, ISupplierRepository supplierRepository,
ISupplierRoleRepository supplierRoleRepository,
ISupplierCompanyRepository supplierCompanyRepository, ILinkmanRepository linkmanRepository,
IBankAccountRepository bankAccountRepository,
ISupplierCompanyMaterialRepository supplierCompanyMaterialRepository)
{
_supplierQuery = supplierQuery;
_supplierRepository = supplierRepository;
_supplierRoleRepository = supplierRoleRepository;
_supplierCompanyRepository = supplierCompanyRepository;
_linkmanRepository = linkmanRepository;
_bankAccountRepository = bankAccountRepository;
_supplierCompanyMaterialRepository = supplierCompanyMaterialRepository;
}
public CashflowEditorViewModel(
ICashflowRepository cashflowRepository,
IBankAccountRepository bankAccountRepository,
Cashflow entity
)
{
this.cashflowRepository = cashflowRepository;
this.bankAccountRepository = bankAccountRepository;
this.entity = entity;
this.OpeningBalance.PropertyChanged += (s,e) =>
{
base.Validate();
};
base.ValidationHelper.AddInstance(this.OpeningBalance);
}
/// <summary>
/// Create a new instance
/// </summary>
public BankAppService(IBankAccountRepository bankAccountRepository, // the bank account repository dependency
ICustomerRepository customerRepository, // the customer repository dependency
IBankTransferService transferService)
{
//check preconditions
if (bankAccountRepository == null)
throw new ArgumentNullException("bankAccountRepository");
if (customerRepository == null)
throw new ArgumentNullException("customerRepository");
if (transferService == null)
throw new ArgumentNullException("trasferService");
_bankAccountRepository = bankAccountRepository;
_customerRepository = customerRepository;
_transferService = transferService;
}
public ApplicationDetailsService(IApplicationRepository applicationRepository, IBankAgencyRepository bankAgencyRepository, IApplicantRepository applicantRepository,
IEmploymentRepository employmentRepository, IAddressRepository addressRepository, IContactRepository contactRepository,
IBankAccountRepository bankAccountRepository, IBankCardRepository bankCardRepository, INoteRepository noteRepository, IDocumentRepository documentRepository,
IReasonRepository reasonRepository, IActionLogRepository actionLogRepository)
{
_applicationRepository = applicationRepository;
_bankAgencyRepository = bankAgencyRepository;
_applicantRepository = applicantRepository;
_employmentRepository = employmentRepository;
_addressRepository = addressRepository;
_contactRepository = contactRepository;
_bankAccountRepository = bankAccountRepository;
_bankCardRepository = bankCardRepository;
_noteRepository = noteRepository;
_documentRepository = documentRepository;
_reasonRepository = reasonRepository;
_actionLogRepository = actionLogRepository;
}
// the entities - dto adapters
/// <summary>
/// Create a new instance
/// </summary>
public BankAppService(IBankAccountRepository bankAccountRepository, // the bank account repository dependency
ICustomerRepository customerRepository, // the customer repository dependency
IBankTransferService transferService, // bank transfer domain services
ITypeAdapter adapter)
{
//check preconditions
if (bankAccountRepository == null)
throw new ArgumentNullException("bankAccountRepository");
if (customerRepository == null)
throw new ArgumentNullException("customerRepository");
if (adapter == null)
throw new ArgumentNullException("adapter");
if (transferService == null)
throw new ArgumentNullException("trasferService");
_bankAccountRepository = bankAccountRepository;
_customerRepository = customerRepository;
_adapter = adapter;
_transferService = transferService;
}
public BankAccountHandler(IBankAccountRepository repository)
{
_repository = repository;
}
public BankAccountService(IBankAccountRepository bankAccountRepository)
{
_bankAccountRepository = bankAccountRepository;
}
public BankAccountService(IBankAccountRepository repo)
{
this.repository = repo;
}
public ApplicationBankAccountService(BankAccountService bankAccountService, IBankAccountRepository bankRepository)
{
_bankAccountService = bankAccountService;
_bankRepository = bankRepository;
}
public ApplicationBankAccountService(IBankAccountRepository bankRepository, BankAccountService bankAccountService)
{
_bankRepository = bankRepository;
_bankAccountService = bankAccountService;
}
public void Setup()
{
_sut = IoC.Resolve<IBankAccountRepository>();
_account = new BankAccount(3500) { Name = "" };
}
public BankAccountService(IBankAccountRepository repository)
{
Assert.NotNull(repository);
_repository = repository;
}