public IncomeService(IIncomeRepository incomeRepository, IBankAccountRepository bankAccountRepository,
                      IHistoricMovementRepository historicMovementRepository)
 {
     this._incomeRepository           = incomeRepository;
     this._bankAccountRepository      = bankAccountRepository;
     this._historicMovementRepository = historicMovementRepository;
 }
Esempio n. 2
0
        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));
        }
Esempio n. 4
0
        /// <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;
        }
Esempio n. 5
0
 public SystemController(IBankAccountRepository accountRepository, IProviderRepository providerRepository,
                         IInstitutionRepository institutionRepository)
 {
     _accountRepository     = accountRepository;
     _providerRepository    = providerRepository;
     _institutionRepository = institutionRepository;
 }
Esempio n. 6
0
        //
        // 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;
                    }
                }
            }
        }
Esempio n. 7
0
 public DataService(IProviderRepository providerRepository, IBankAccountRepository accountRepository, IConfiguration configuration)
 {
     _configuration      = configuration;
     _providerRepository = providerRepository;
     _accountRepository  = accountRepository;
     _client             = new HttpClient();
 }
Esempio n. 8
0
 public LoanController(IRepository repo, IMapper map, UserManager <User> custom, IBankAccountRepository bank)
 {
     _repo            = repo;
     _mapper          = map;
     _customerManager = custom;
     _bankRepo        = bank;
 }
Esempio n. 9
0
 public BankAccountController(IBankAccountRepository accountRepository, IDataService dataService,
                              IValidationHelper validationHelper)
 {
     _accountRepository = accountRepository;
     _dataService       = dataService;
     _validationHelper  = validationHelper;
 }
Esempio n. 10
0
        //
        // 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;
                    }
                }
            }
        }
Esempio n. 11
0
 public OverviewController(IBankAccountRepository bankAccountRepository, ICreditCardRepository creditAccountRepository,
                           IValidationHelper validationHelper)
 {
     _bankAccountRepository   = bankAccountRepository;
     _creditAccountRepository = creditAccountRepository;
     _validationHelper        = validationHelper;
 }
Esempio n. 12
0
 public ApplicationBankAccountService(
     BankAccountService bankAccountService,
     IBankAccountRepository bankRepository)
 {
     _bankAccountService = bankAccountService;
     _bankRepository     = bankRepository;
 }
 public CustomerService(ICustomerRepository customerRepository, IBankAccountRepository bankAccountRepository,
                        ITransactionRepository transactionRepository)
 {
     _customerRepository    = customerRepository;
     _bankAccountRepository = bankAccountRepository;
     _transactionRepository = transactionRepository;
 }
Esempio n. 14
0
 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;
 }
Esempio n. 20
0
 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();
        }
Esempio n. 22
0
        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));
            }
                );
        }
Esempio n. 23
0
 public SalesTaxManager(IHttpContextAccessor contextAccessor, ISalesTaxRepository repository, IBankAccountRepository bankAccountRepository, IUnitOfWork unitOfWork)
 {
     _userId                = contextAccessor.HttpContext.User.GetUserId();
     _repository            = repository;
     _bankAccountRepository = bankAccountRepository;
     _unitOfWork            = unitOfWork;
 }
Esempio n. 24
0
 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;
 }
Esempio n. 26
0
 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();
        }
Esempio n. 28
0
        /// <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();
        }
Esempio n. 29
0
 public PaymentService(IPaymentTypeRepository paymentTypeRepository, IPaymentCategoryRepository paymentCategoryRepository, IPaymentRepository paymentRepository, IBankAccountRepository bankAccountRepository)
 {
     this.paymentTypeRepository     = paymentTypeRepository;
     this.paymentCategoryRepository = paymentCategoryRepository;
     this.paymentRepository         = paymentRepository;
     this.bankAccountRepository     = bankAccountRepository;
 }
Esempio n. 30
0
        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;
 }
Esempio n. 32
0
 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;
 }
Esempio n. 36
0
        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;
 }
Esempio n. 38
0
 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
                        }
                    }
                }
            };
        }
Esempio n. 41
0
        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));
        }
Esempio n. 43
0
 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);
        }
Esempio n. 45
0
        /// <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;
 }
Esempio n. 49
0
 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 = "" };
        }
Esempio n. 54
0
        public BankAccountService(IBankAccountRepository repository)
        {
            Assert.NotNull(repository);

            _repository = repository;
        }