public AccountDTO FindByPhoneNumber(string phoneNumber) { var account = _context.Accounts.FirstOrDefault(x => x.PhoneNum == phoneNumber); var accountDTO = AccountMapper.toDTO(account); return(accountDTO); }
/// <summary> /// Method creates new account with given parameters and saves data to storage. /// </summary> /// <param name="accountOwner"> /// Account owner - required data to create account. /// </param> /// <param name="type"> /// Account type - required data to create account. /// </param> /// <param name="creator"> /// Account number generation strategy injected as method argument. /// </param> public void OpenAccount(string accountOwner, AccountType type, IAccountNumberCreateService creator) { Account newAccount = AccountMapper.CreateAccount(type, creator.GenerateAccountNumber(AccountDTO.id), accountOwner, 0, 0); AccountDTO.id++; this.repository.Create(newAccount.ToAccountDTO()); }
/// <summary> /// 帐号业务 /// </summary> public AccountBLL() { //RegistType(); _userDAL = new AccountDataBridge(); Mapper = AccountMapper.InitAllMapper(); }
public long?Save(AccountDto account) { if (account != null) { using (var context = new CashFlowContext()) { if (account.Id.HasValue) { context.Account.Update(AccountMapper.Map(account)); } else { Account accountMapped = AccountMapper.Map(account); context.Account.Add(accountMapped); account.Id = accountMapped.Id; AccountBalance accountBalance = new AccountBalance(); accountBalance.AccountId = account.Id.Value; accountBalance.Balance = 0; accountBalance.StartDate = DateTime.Now; context.AccountBalance.Add(accountBalance); } context.SaveChanges(); } return(account.Id); } else { return(null); } }
public void DepositAccount(BankAccount account, decimal deposit) { account.Deposit(deposit); BankAccountDTO accToUpdate = AccountMapper.AccountToDTO(account); _repository.UpdateAccount(accToUpdate); }
public void WithdrawAccount(BankAccount account, decimal withdraw) { account.Withdraw(withdraw); BankAccountDTO accToUpdate = AccountMapper.AccountToDTO(account); _repository.UpdateAccount(accToUpdate); }
/// <summary> /// Author: Suman Basyal /// </summary> /// <param name="login"></param> /// <returns></returns> public bool SaveUserDetails(Login login) { var entityUser = AccountMapper.ConvertToEntity(login); bool result = _accountService.SaveUserDetails(entityUser); return(result); }
public IEnumerable <Login> GetAllUser() { var list = _accountService.GetAllUser().ToList(); var convertedList = AccountMapper.ConvertToModel(list); return(convertedList); }
public IEnumerable <Account> GetAllAccounts() { foreach (AccountDTO account in _repository.GetAllAccounts()) { yield return(AccountMapper.MapAccountFromDTO(account)); } }
public void Deposit(int accountID, decimal amount) { foreach (AccountDTO accountDTO in _repository.GetAllAccounts()) { Account account = AccountMapper.MapAccountFromDTO(accountDTO); if (account.AccountID == accountID) { switch (account.Type) { case AccountType.BASE: amount *= 1.05M; break; case AccountType.GOLD: amount *= 1.10M; break; case AccountType.PLATINUM: amount *= 1.25M; break; } break; } } _repository.Deposit(accountID, amount); }
public ActionResult _Edit(AccountEditViewModel model) { if (!ModelState.IsValid) { return(PartialView(model)); } var account = AccountBL.Get(model.ID, base._DB); if (account.Password != model.ExPassword) { throw new BusinessException("Eski şifrenizi kontrol ederek tekrar deneyiniz."); } var mapper = new AccountMapper(); var accountDTO = mapper.MapToDTO(model); AccountBL.Update(accountDTO.ID, accountDTO, base._DB); return(new ContentResult() { Content = "OK" }); }
public ActionResult <List <Account> > Get() { var accounts = _accountService.Get(); var accountsMapped = AccountMapper.DomainToSDK(accounts); return(accountsMapped); }
public static void Main(string[] args) { IAccountService service = Resolver.Get <IAccountService>(); IAccountNumberCreateService creator = Resolver.Get <IAccountNumberCreateService>(); service.OpenAccount("Base acc owner 1", AccountType.Base, creator); service.OpenAccount("Silver acc owner 2", AccountType.Silver, creator); service.OpenAccount("Gold acc owner 3", AccountType.Gold, creator); service.OpenAccount("Platinum acc owner 4", AccountType.Platinum, creator); var creditNumbers = service.GetAllAccounts().Select(acc => acc.AccountNumber).ToArray(); foreach (var t in creditNumbers) { service.DepositAccount(t, 100); } foreach (var item in service.GetAllAccounts()) { Console.WriteLine(item); Console.WriteLine(); } foreach (var t in creditNumbers) { service.WithdrawAccount(t, 10); } foreach (var item in service.GetAllAccounts()) { Console.WriteLine(item); Console.WriteLine(); var qwe = AccountMapper.ConvertToDTO(item); } }
private DbAccount ToDbAccount(DTOAccount item) { var account = _bankContext.Accounts.Find(item.Id) ?? throw new InvalidOperationException("Account not found, incorrect id!"); var holder = _bankContext.Holders.Find(item.Holder.Id) ?? throw new InvalidOperationException("Holder not found, incorrect id!"); return(AccountMapper.UpdateDbAccount(item, account, holder)); }
public static AccountDTO Get(int id, MataDBEntities db) { var account = db.Account.Single(q => q.ID == id); var mapper = new AccountMapper(); return(mapper.MapToDTO(account)); }
public static AccountDTO Get(string email, string password, MataDBEntities db) { var account = db.Account.Single(q => q.Email == email && q.Password == password); var mapper = new AccountMapper(); return(mapper.MapToDTO(account)); }
/// <summary> /// Opens new account with given information /// </summary> /// <param name="accountOwner">The owner of the account</param> /// <param name="accountType">The account type</param> /// <param name="numberCreateService">Service for creating unique account number</param> public void OpenAccount(string accountOwner, Interface.Entities.AccountType accountType, IAccountNumberCreateService numberCreateService) { string accountNumber = numberCreateService.GetNumber(); Interface.Entities.Account account = new Interface.Entities.Account(accountNumber, accountOwner, accountType); _repository.OpenAccount(AccountMapper.MapToData(account)); }
public static int Create(AccountDTO account, JewelleryDBEntities db) { var newAccount = AccountMapper.MapToEntity(account); db.Account.Add(newAccount); db.SaveChanges(); return(newAccount.Id); }
public IEnumerable <BankAccount> GetAllAccounts() { var accounts = _repository.GetAll(); foreach (var acc in accounts) { yield return(AccountMapper.DTOToAccount(acc)); } }
public bool CreateUserAndAccount(RegisterModel model, out string result) { result = Messanger.Get(EMessages.CannotCreateUser); var account = new Account(); var accountMapper = new AccountMapper(); accountMapper.Map(model, account); return(_accountFacade.SaveOrUpdate(account)); }
public AccountHandler(IAccountRepository accountRepository, IUserRepository userRepository) { _accountRepository = accountRepository; _userRepository = userRepository; _mapper = new AccountMapper(); _createAccountCommandValidator = new CreateAccountCommandValidator(); _addUserToAccountCommandValidator = new AddUserToAccountCommandValidator(); _removeUserFromAccountCommandValidator = new RemoveUserFromAccountCommandValidator(); }
static void Main(string[] args) { Employee emp = new EmployeeMapper().Get("1037"); AccountMapper am = new AccountMapper(); Account account = new Account(emp, am.GetAccounts()); am.Insert(account); Console.ReadLine(); }
public IActionResult Delete( [FromHeader(Name = AuthProperties.HEADER_AUTH_ID)] string userId, [FromHeader(Name = AuthProperties.HEADER_AUTH_PASSOWRD)] string userPassword) { var serviceResult = _deleteAccountUseCase.Execute(userId, userPassword); var response = AccountMapper.Map(serviceResult); return(new JsonResult(response)); }
public IActionResult SignIn( string email, string password) { var serviceResult = _signInUseCase.Execute(email, password); var response = AccountMapper.Map(serviceResult); return(new JsonResult(response)); }
public static bool UpdatePWD(string username, string password) { AccountMapper account = new AccountMapper(); account.Username = username; account.Password = password; Global.db.Updateable(account).UpdateColumns(x => new { x.Password, x.Username }).WhereColumns(x => new { x.Username }).ExecuteCommand(); return(true); }
public ActionResult _Edit(int id) { var accountDTO = AccountBL.Get(id, base._DB); var mapper = new AccountMapper(); var model = mapper.MapToViewModel(accountDTO); return(PartialView(model)); }
public void Save() { List <Account> resList = new List <Account>(_accounts.Count); foreach (var account in _accounts) { resList.Add(AccountMapper.FromBllModel(account)); } _storage.Load(resList); }
public void Load() { var accounts = _storage.Read(); _accounts.Clear(); foreach (var account in accounts) { _accounts.Add(AccountMapper.ToBllModel(account)); } }
// private readonly TransactionMapper _transactionMapper; public MyDataQueriesRepository(IHolefeederContext context, AccountMapper accountMapper // CategoryMapper categoryMapper, CashflowMapper cashflowMapper, TransactionMapper transactionMapper ) { _context = context; _accountMapper = accountMapper; // _categoryMapper = categoryMapper; // _cashflowMapper = cashflowMapper; // _transactionMapper = transactionMapper; }
public IActionResult SignUp( string email, string password, [FromQuery(Name = "name")] string name) { var serviceResult = _signUpUseCase.Execute(email, password, name); var response = AccountMapper.Map(serviceResult); return(new JsonResult(response)); }