public CustomerBO Create(CustomerBO cust)
{
using (var uow = facade.UnitOfWork)
{
newCustomer = uow.CustomerRepository.Create(custConv.Convert(cust));
uow.Complete();
return(custConv.Convert(newCustomer));
}
}
public CustomerBO Create(CustomerBO cust)
{
using (var uow = this.facade.UnitOfWork)
{
var newCust = uow.CustomerRepository.Create(converter.Convert(cust));
uow.complete();
return(converter.Convert(newCust));
}
}
public CustomerBO Create(CustomerBO c)
{
using (var uov = facade.UnitOfWork)
{
var newCust = uov.CustomerRepository.Create(conv.Convert(c));
uov.Complete();
return(conv.Convert(newCust)); //converting the customer that we created in repository to a´customerBO
}
}
public CustomerDTO Execute(CreateCustomerRequest request)
{
CustomerId id = new CustomerId(request.Id);
CustomerName name = new CustomerName(request.Name);
Customer customer = Customer.SignUp(id, name);
_customerRepository.Save(customer);
return(_customerConverter.Convert(customer));
}
public bool Execute(CreateCustomerRequest request)
{
CustomerId customerId = new CustomerId(request.id);
CustomerName customerName = new CustomerName(request.name);
Customer customer = Customer.SignUp(customerId, customerName);
var dto = converter.Convert(customer);
return(customerRepository.Save(customer));
}
public void ItShouldReturnDTOFromCustomer()
{
CustomerId id = new CustomerId("1111");
CustomerName name = new CustomerName("customer");
Customer customer = Customer.SignUp(id, name);
CustomerConverter converter = new CustomerConverter();
var actual = converter.Convert(customer);
Assert.AreEqual("1111", actual.Id);
Assert.AreEqual("customer", actual.Name);
}
public void Execute(object parameter)
{
var mainViewModel = (MainViewModel)Application.Current.Properties["mainViewModel"];
var customerConverter = new CustomerConverter(mainViewModel.SelectedItemRow);
var customer = customerConverter.Convert();
CustomerDetailVm viewModel = new CustomerDetailVm(customer);
CustomerDetail customerDetail = new CustomerDetail(viewModel);
customerDetail.Show();
}
public async Task <CustomerViewModel> GetCustomerByIdAsync(int id,
CancellationToken ct = default(CancellationToken))
{
var customerViewModel = CustomerConverter.Convert(await _customerRepository.GetByIdAsync(id, ct));
customerViewModel.Invoices = await GetInvoiceByCustomerIdAsync(customerViewModel.CustomerId, ct);
customerViewModel.SupportRep =
await GetEmployeeByIdAsync(customerViewModel.SupportRepId.GetValueOrDefault(), ct);
customerViewModel.SupportRepName =
$"{customerViewModel.SupportRep.LastName}, {customerViewModel.SupportRep.FirstName}";
return(customerViewModel);
}
public BOVideo Create(BOVideo vid)
{
using (var uow = facade.UnitOfWork) // using keyword is calling the disposable. Once it exited the curly braces then it will aut. dispose.
{
var Video = uow.VideoRepository.Create(con.Convert(vid));
uow.Complete();
return(con.Convert(Video));
}
}
public CustomerBussinesObject Create(CustomerBussinesObject _customerBussines)
{
using (IUnitOfWork _unitOfWork = _dataAccess.UnitOfWork)
{
Customer _newCustomer = _unitOfWork.CustomerRepository.Create(_converter.Convert(_customerBussines));
_unitOfWork.Complete();
return(_converter.Convert(_newCustomer));
}
}
public void ItShoulReturnSameDTOWhenIsTryingToConvert()
{
//Arrange
CustomerId customerId = new CustomerId(1234);
CustomerName customerName = new CustomerName("customer");
Customer customer = Customer.Create(customerId, customerName);
CustomerConverter converter = new CustomerConverter();
//Act
var result = converter.Convert(customer);
//Assert
Assert.AreEqual(result.Id, customer.Id().CustomerID);
Assert.AreEqual(result.Name, customer.Name().CustomerNAME);
}
/// <summary>
/// Executes the operations associated with the cmdlet.
/// </summary>
public override void ExecuteCmdlet()
{
CustomerConverter converter;
Customer customer;
IValidator <Address> validator;
string customerId;
try
{
customerId = (InputObject == null) ? CustomerId : InputObject.CustomerId;
if (ShouldProcess(string.Format(CultureInfo.CurrentCulture, Resources.SetPartnerCustomerWhatIf, customerId)))
{
if (InputObject == null && string.IsNullOrEmpty(CustomerId))
{
throw new PSInvalidOperationException(Resources.InvalidSetCustomerIdentifierException);
}
customer = Partner.Customers[customerId].Get();
converter = new CustomerConverter(this, customer);
converter.Convert();
validator = new AddressValidator(Partner);
if (validator.IsValid(customer.BillingProfile.DefaultAddress))
{
Partner.Customers[customerId].Profiles.Billing.Update(customer.BillingProfile);
WriteObject(new PSCustomer(customer));
}
else
{
throw new PSInvalidOperationException("The address specified was invalid. Please check the values and try again.");
}
}
}
catch (PartnerException ex)
{
throw new PSPartnerException("An error was encountered when communicating with Partner Center.", ex);
}
finally
{
converter = null;
customer = null;
}
}
public async Task <IActionResult> Get(int id)
{
try
{
var customer = await _context.Customer
.Where(c => c.CustomerId == id)
.FirstOrDefaultAsync();
if (customer == null)
{
return(NotFound());
}
return(Ok(CustomerConverter.Convert(customer)));
}
catch (Exception ex)
{
_logger.LogError(ex, ex.Message);
return(StatusCode(500, ex));
}
}
public async Task <CustomerDto> CreateAsync(CustomerDto item)
{
try
{
int count = _context.Customers.Count();
item.Code = $"{count.ToString("0000")}-{DateTime.Now.Year}";
while ((await _context.Customers.AsNoTracking().FirstOrDefaultAsync(x => x.Code == item.Code)) != null)
{
++count;
item.Code = $"{count.ToString("0000")}-{DateTime.Now.Year}";
}
var result = await _context.Customers.AddAsync(CustomerConverter.Convert(item));
await _context.SaveChangesAsync();
return(CustomerConverter.Convert(result.Entity));
}
catch (Exception)
{
return(null);
}
}
public async Task <object> Register(CustomerDto item)
{
int count = _context.Customers.Count();
item.Code = $"{count.ToString("0000")}-{DateTime.Now.Year}";
while ((await _context.Customers.AsNoTracking().FirstOrDefaultAsync(x => x.Code == item.Code)) != null)
{
++count;
item.Code = $"{count.ToString("0000")}-{DateTime.Now.Year}";
}
var user = CustomerConverter.Convert(item);
var result = await _userManager.CreateAsync(user, item.Password);
if (result.Succeeded)
{
await _signInManager.SignInAsync(user, false);
await _userManager.AddToRoleAsync(user, "customer");
return(await _jwt.GenerateJwt(user));
}
return(null);
}
public CustomerBO Create(CustomerBO cust)
{
string firstName = cust.Firstname;
firstName = System.Threading.Thread.CurrentThread.CurrentCulture.TextInfo.ToTitleCase(firstName.ToLower());
cust.Firstname = firstName;
string lastName = cust.Lastname;
lastName = System.Threading.Thread.CurrentThread.CurrentCulture.TextInfo.ToTitleCase(lastName.ToLower());
cust.Lastname = lastName;
using (var uow = _facade.UnitOfWork)
{
_newCustomer = uow.CustomerRepository.Create(_custConv.Convert(cust));
uow.Complete();
return(_custConv.Convert(_newCustomer));
}
}
public IEnumerable <CustomerDto> GetCustomers()
{
var customer = dalFacade._customersRepository.GetAll();
return(customerConverter.Convert(customer));
}
