public async Task <IActionResult> GetCustomer(Guid customerId) { CustomerOutput output = await _getCustomerDetailsUseCase.Execute(customerId); _presenter.Populate(output); return(_presenter.ViewModel); }
public async Task Process(GetCustomerDetailsInput input) { Customer customer = await customerReadOnlyRepository.Get(input.CustomerId); if (customer == null) { throw new CustomerNotFoundException($"The customer {input.CustomerId} does not exist or it was not processed yet."); } List <Order> orders = await orderReadOnlyRepository.GetByCustomer(input.CustomerId); List <OrderOutput> orderOutputs = new List <OrderOutput>(); if (orders.Count == 0) { throw new CustomerNotFoundException($"No order found for customer {input.CustomerId}."); } else { foreach (var item in orders) { OrderOutput orderOutput = outputConverter.Map <OrderOutput>(item); orderOutputs.Add(orderOutput); } } CustomerOutput output = outputConverter.Map <CustomerOutput>(customer); output = new CustomerOutput(customer.Id, customer.PIN.Text, customer.Name.Text, orderOutputs); outputBoundary.Populate(output); }
public CheckoutOutput(CustomerOutput customer, BasketOutput basket, DateTime orderDate, double totalPrice) { Customer = customer; Basket = basket; OrderDate = orderDate; TotalPrice = totalPrice; }
public async Task <CustomerOutput> Execute(Guid customerId) { Customer customer = await _customerReadOnlyRepository.Get(customerId); if (customer == null) { throw new CustomerNotFoundException($"The customer {customerId} does not exists or is not processed yet."); } List <AccountOutput> accounts = new List <AccountOutput> (); foreach (Guid accountId in customer.Accounts.ToReadOnlyCollection()) { Account account = await _accountReadOnlyRepository.Get(accountId); if (account != null) { AccountOutput accountOutput = new AccountOutput(account); accounts.Add(accountOutput); } } CustomerOutput output = new CustomerOutput(customer, accounts); return(output); }
/// <summary> /// Метод получает одно задание заказчика. /// </summary> /// <param name="userName">Логин юзера.</param> /// <param name="taskId">Id задачи. Может быть null.</param> /// <returns>Коллекцию заданий.</returns> async Task <IList> GetSingleTask(string userName, long?taskId) { // Выбирает объект задачи, который нужно редактировать. TaskEntity oEditTask = await _postgre.Tasks.Where(t => t.TaskId == taskId).FirstOrDefaultAsync(); // Выбирает список специализаций конкретной категории по коду категории. IList aTaskSpecializations = await _postgre.TaskCategories .Where(c => c.CategoryCode.Equals(oEditTask.CategoryCode)) .Select(s => s.Specializations) .FirstOrDefaultAsync(); string specName = string.Empty; // Выбирает название специализации. foreach (Specialization spec in aTaskSpecializations) { if (spec.SpecCode.Equals(oEditTask.SpecCode)) { specName = spec.SpecName; } } // Получит логин и иконку профиля заказчика задания. CustomerOutput customer = await _userService.GetCustomerLoginByTaskId(taskId); // TODO: отрефачить этот метод, чтоб не обращаться два раза к БД за получением задания. var oTask = await(from tasks in _postgre.Tasks join categories in _postgre.TaskCategories on tasks.CategoryCode equals categories.CategoryCode join statuses in _postgre.TaskStatuses on tasks.StatusCode equals statuses.StatusCode where tasks.TaskId == taskId select new { tasks.CategoryCode, tasks.CountOffers, tasks.CountViews, tasks.OwnerId, tasks.SpecCode, categories.CategoryName, specName, tasks.StatusCode, statuses.StatusName, taskBegda = string.Format("{0:f}", tasks.TaskBegda), //taskEndda = string.Format("{0:f}", tasks.TaskEndda), tasks.TaskEndda, tasks.TaskTitle, tasks.TaskDetail, tasks.TaskId, taskPrice = string.Format("{0:0,0}", tasks.TaskPrice), tasks.TypeCode, userName, customerLogin = customer.UserName, customerProfileIcon = customer.UserIcon }) .ToListAsync(); return(oTask); }
public RentOutput(Rent rent) { Id = rent.Id; RentDate = rent.RentDate; rentExpirationDate = rent.rentExpirationDate; Status = rent.Status; FullPrice = rent.FullPrice; CustomerId = rent.CustomerId; Customer = new CustomerOutput(rent.Customer); Items = new List <RentItemOutput>(rent.Items.Select(item => new RentItemOutput(item))); }
public async Task Process(RegisterInput input) { Customer customer = new Customer(input.PIN, input.Name); await customerWriteOnlyRepository.Add(customer); CustomerOutput customerOutput = outputConverter.Map <CustomerOutput>(customer); RegisterOutput output = new RegisterOutput(customerOutput); outputBoundary.Populate(output); }
/// <summary> /// Метод получит логин и иконку профиля заказчика по Id его задания. /// </summary> /// <param name="taskId">Id задания.</param> /// <returns>Данные заказчика.</returns> public async Task <CustomerOutput> GetCustomerLoginByTaskId(long?taskId) { try { if (taskId <= 0) { throw new NotFoundTaskIdException(taskId); } // Получит Id заказчика, который создал задание. string customerId = await _postgre.Tasks .Where(t => t.TaskId == taskId) .Select(t => t.OwnerId) .FirstOrDefaultAsync(); // Если заказчика задания с таким OwnerId не найдено. if (string.IsNullOrEmpty(customerId)) { throw new NotFoundTaskCustomerIdException(customerId); } // Найдет логин и иконку профиля заказчика задания и мапит к типу CustomerOutput. MapperConfiguration config = new MapperConfiguration(cfg => cfg.CreateMap <UserEntity, CustomerOutput>()); Mapper mapper = new Mapper(config); CustomerOutput customer = mapper.Map <CustomerOutput>(await _postgre.Users .Where(u => u.Id .Equals(customerId)) .FirstOrDefaultAsync()); // Если логина заказчика задания не найдено. if (!string.IsNullOrEmpty(customer.UserName)) { // Если у заказчика не установлена иконка профиля, то запишет ее по дефолту. if (string.IsNullOrEmpty(customer.UserIcon)) { customer.UserIcon = NoPhotoUrl.NO_PHOTO; } return(customer); } throw new NotFoundCustomerLoginException(); } catch (Exception ex) { Logger _logger = new Logger(_db, ex.GetType().FullName, ex.Message.ToString(), ex.StackTrace); _ = _logger.LogCritical(); throw new Exception(ex.Message.ToString()); } }
public void Populate(CustomerOutput output, Controller controller) { List <AccountDetailsModel> accounts = new List <AccountDetailsModel>(); foreach (var account in output.Accounts) { accounts.Add(new AccountDetailsModel( account.AccountId, account.CurrentBalance)); } CustomerDetailsModel model = new CustomerDetailsModel( output.CustomerId, output.Personnummer, output.Name, accounts ); ViewModel = controller.View(model); }
public async Task Process(AddBasketInput input) { Customer customer = await customerReadOnlyRepository.Get(input.CustomerId); if (customer == null) { throw new CustomerNotFoundException($"The customer {input.CustomerId} does not exist or it was not processed yet."); } Basket basket = new Basket(customer.Id); await basketWriteOnlyRepository.Add(basket); CustomerOutput customerOutput = outputConverter.Map <CustomerOutput>(customer); BasketOutput basketOutput = outputConverter.Map <BasketOutput>(basket); AddBasketOutput output = new AddBasketOutput(customerOutput, basketOutput); outputBoundary.Populate(output); }
public async Task Process(RegisterInput message) { Customer customer = new Customer(message.PIN, message.Name); Account account = new Account(); account.Open(customer.Id, new Credit(account.Id, message.InitialAmount)); customer.Register(account.Id); var customerEvents = customer.GetEvents(); var accountEvents = account.GetEvents(); await bus.Publish(customerEvents); await bus.Publish(accountEvents); // // To ensure the Customer and Account are created in the database // we wait for the records be available in the following queries // with retry // bool consumerReady = await RetryGet(async() => await customerReadOnlyRepository.Get(customer.Id)) && await RetryGet(async() => await accountReadOnlyRepository.Get(account.Id)); if (!consumerReady) { customer = null; account = null; // // TODO: Throw exception, monitor the inconsistencies and fail fast. // } CustomerOutput customerOutput = responseConverter.Map <CustomerOutput>(customer); AccountOutput accountOutput = responseConverter.Map <AccountOutput>(account); RegisterOutput output = new RegisterOutput(customerOutput, accountOutput); outputBoundary.Populate(output); }
public async Task Process(RegisterInput input) { Customer customer = new Customer(input.PIN, input.Name); Account account = new Account(customer.Id); Credit credit = new Credit(account.Id, input.InitialAmount); account.Deposit(credit); customer.Register(account.Id); await customerWriteOnlyRepository.Add(customer); await accountWriteOnlyRepository.Add(account, credit); CustomerOutput customerOutput = outputConverter.Map <CustomerOutput>(customer); AccountOutput accountOutput = outputConverter.Map <AccountOutput>(account); RegisterOutput output = new RegisterOutput(customerOutput, accountOutput); outputBoundary.Populate(output); }
public RegisterOutput(Customer customer, Account account) { List <TransactionOutput> transactionOutputs = new List <TransactionOutput> (); foreach (ITransaction transaction in account.Transactions.ToReadOnlyCollection()) { transactionOutputs.Add( new TransactionOutput( transaction.Description, transaction.Amount, transaction.TransactionDate)); } Account = new AccountOutput(account.Id, account.GetCurrentBalance(), transactionOutputs); List <AccountOutput> accountOutputs = new List <AccountOutput> (); accountOutputs.Add(Account); Customer = new CustomerOutput(customer, accountOutputs); }
public async Task Process(GetCustomerDetailsInput input) { // // TODO: The following queries could be simplified // Customer customer = await customerReadOnlyRepository.Get(input.CustomerId); if (customer == null) { throw new CustomerNotFoundException($"The customer {input.CustomerId} does not exists or is not processed yet."); } List <AccountOutput> accounts = new List <AccountOutput>(); foreach (var accountId in customer.Accounts) { Account account = await accountReadOnlyRepository.Get(accountId); // // TODO: The "Accout closed state" is not propagating to the Customer Aggregate // if (account != null) { AccountOutput accountOutput = outputConverter.Map <AccountOutput>(account); accounts.Add(accountOutput); } } CustomerOutput output = outputConverter.Map <CustomerOutput>(customer); output = new CustomerOutput( customer.Id, customer.PIN.Text, customer.Name.Text, accounts); outputBoundary.Populate(output); }
public void Populate(CustomerOutput output) { if (output == null) { ViewModel = new NoContentResult(); return; } List <AccountDetailsModel> accounts = new List <AccountDetailsModel> (); foreach (var account in output.Accounts) { List <TransactionModel> transactions = new List <TransactionModel> (); foreach (var item in account.Transactions) { var transaction = new TransactionModel( item.Amount, item.Description, item.TransactionDate); transactions.Add(transaction); } accounts.Add(new AccountDetailsModel( account.AccountId, account.CurrentBalance, transactions)); } CustomerDetailsModel model = new CustomerDetailsModel( output.CustomerId, output.Personnummer, output.Name, accounts ); ViewModel = new ObjectResult(model); }
public async Task Process(CheckoutInput input) { Customer customer = await customerReadOnlyRepository.Get(input.CustomerId); if (customer == null) { throw new CustomerNotFoundException($"The customer {input.CustomerId} does not exist or it was not processed yet."); } Basket basket = await basketReadOnlyRepository.Get(input.BasketId); if (basket == null) { throw new BasketNotFoundException($"The basket {input.BasketId} does not exist or it was already deleted."); } CustomerOutput customerOutput = outputConverter.Map <CustomerOutput>(customer); BasketOutput basketOutput = outputConverter.Map <BasketOutput>(basket); CheckoutOutput output = new CheckoutOutput(customerOutput, basketOutput, input.OrderDate, basket.GetTotalPrice().Value); outputBoundary.Populate(output); }
public async Task GetCustomerDetails_ValidId_ShouldReturnAnCustomer() { //ARRANGE var customerId = Guid.NewGuid(); var ssn = new SSN("0101010000"); var name = new Name("Test_Customer"); var accountList = new AccountCollection(); var account = new Account(customerId); accountList.Add(account.Id); var customer = Customer.Load(customerId, name, ssn, accountList); _accountReadOnlyRepository.Setup(m => m.Get(account.Id)).Returns(Task.FromResult(account)); _customerReadOnlyRepository.Setup(m => m.Get(customerId)).Returns(Task.FromResult(customer)); //ACT CustomerOutput customerOutPut = await getCustomerDetailsUseCase.Execute(customerId); //ASSERT _accountReadOnlyRepository.Verify(v => v.Get(account.Id), Times.Once()); Assert.Equal(customerOutPut.CustomerId, customerId); }
public AddBasketOutput(CustomerOutput customer, BasketOutput basket) { Customer = customer; Basket = basket; }
public RegisterOutput(CustomerOutput customer, AccountOutput account) { Customer = customer; Account = account; }
public RegisterOutput(CustomerOutput customer) { Customer = customer; }