public async Task <CustomerEntity> Create(CreateCustomerModel model)
{
if (GetQuery().Any(u => u.Email == model.Email.Trim()))
{
throw new BadRequestException("Customer with this email address exists.");
}
var customer = new CustomerEntity
{
Id = Guid.NewGuid(),
FirstName = model.FirstName,
Surname = model.Surname,
Email = model.Email,
PhoneNumber = model.PhoneNumber,
Address = model.Address,
City = model.City,
AnnualIncome = model.AnnualIncome,
CreateUserId = model.CreateUserId,
CreateDate = DateTime.UtcNow.ToLocalTime(),
ModifyUserId = model.ModifyUserId,
ModifyDate = DateTime.UtcNow.ToLocalTime(),
StatusId = 1
};
_unitOfWork.Add(customer);
await _unitOfWork.CommitAsync();
return(customer);
}
public MappingProfileTests()
{
var mockMapper = new MapperConfiguration(cfg =>
{
cfg.AddProfile(new MappingProfile());
});
_mapper = mockMapper.CreateMapper();
_createCustomerModel = new CreateCustomerModel
{
FirstName = "FirstName",
LastName = "LastName",
Birthday = new DateTime(1989, 11, 23),
Age = 30
};
_updateCustomerModel = new UpdateCustomerModel
{
Id = Guid.Parse("9f35b48d-cb87-4783-bfdb-21e36012930a"),
FirstName = "FirstName",
LastName = "LastName",
Birthday = new DateTime(1989, 11, 23),
Age = 30
};
}
public ActionResult EditCustomer(int customerId)
{
CustomerManagement customerMgr = new CustomerManagement(User.Identity.GetUserId <int>());
List <BCustomer> customers = customerMgr.FindCustomers(User.Identity.GetUserId <int>(), customerId, out total);
if (customers == null || customers.Count <= 0)
{
ViewBag.Message = string.Format("编号为{0}的客户不存在", customerId);
return(View("Error"));
}
BCustomer customer = customers[0];
CreateCustomerModel model = new CreateCustomerModel()
{
Amount = customer.RemainingAmount,
ContactAddress = customer.ContactAddress,
ContactEmail = customer.ContactEmail,
ContactPeople = customer.ContactPeople,
ContactPhone = customer.ContactPhone,
CreditAmount = customer.CreditAmount,
Description = customer.Description,
Id = customer.Id,
Name = customer.Name,
OpenAccount = customer.OpenId,
OpenType = customer.OpenType
};
List <DictionaryTemplate> types = StaticDictionary.GetOpenTypeList();
ViewBag.OpenTypes = new SelectList(types, "Id", "Value");
return(View("CreateCustomer", model));
}
public HttpResponseMessage Create(CreateCustomerModel model)
{
try
{
ValidateName(model.Name);
ValidateEmail(model.PrimaryEmail, "Primary email");
if (model.SecondaryEmail != null)
{
ValidateEmail(model.SecondaryEmail, "Secondary email");
}
Industry industry = _industryRepository.GetByName(model.Industry);
if (industry == null)
{
throw new BusinessException("Industry name is invalid: " + model.Industry);
}
var customer = new Customer(model.Name, model.PrimaryEmail, model.SecondaryEmail, industry);
_customerRepository.Save(customer);
_unitOfWork.Commit();
return(Request.CreateResponse(HttpStatusCode.OK, Envelope.Ok()));
}
catch (BusinessException ex)
{
return(Request.CreateResponse(HttpStatusCode.BadRequest, Envelope.Error(ex.Message)));
}
catch (Exception ex)
{
return(Request.CreateResponse(HttpStatusCode.InternalServerError, Envelope.Error(ex.Message)));
}
}
public CustomerControllerTests()
{
var mapper = A.Fake <IMapper>();
_mediator = A.Fake <IMediator>();
_testee = new CustomerController(mapper, _mediator);
_createCustomerModel = new CreateCustomerModel
{
FirstName = "FirstName",
LastName = "LastName",
Birthday = new DateTime(1989, 11, 23),
Age = 30
};
_updateCustomerModel = new UpdateCustomerModel
{
Id = _id,
FirstName = "FirstName",
LastName = "LastName",
Birthday = new DateTime(1989, 11, 23),
Age = 30
};
var customer = new Customer
{
Id = _id,
FirstName = "FirstName",
LastName = "LastName",
Birthday = new DateTime(1989, 11, 23),
Age = 30
};
A.CallTo(() => mapper.Map <Customer>(A <Customer> ._)).Returns(customer);
A.CallTo(() => _mediator.Send(A <CreateCustomerCommand> ._, default)).Returns(customer);
A.CallTo(() => _mediator.Send(A <UpdateCustomerCommand> ._, default)).Returns(customer);
}
public async Task <IActionResult> Post([FromBody] CreateCustomerModel customer)
{
var request = new CreateCustomerRequest(customer);
var result = await _mediator.Send(request);
return(Ok(result));
}
public CustomerModel Create(CreateCustomerModel model)
{
try
{
if (model.Invalid)
{
return(default);
public int CreateCustomer(CreateCustomerModel input, [Service] ICustomerService service) =>
service.Create(new CustomerModel
{
Location = input.Location,
Name = input.Name,
EmployeesIds = input.EmployeesIds
});
public ActionResult CreateCustomer(CreateCustomerModel model)
{
var createCustomerRequest = new CreateCustomerRequestDto
{
FirstName = model.FirstName,
LastName = model.LastName,
SocialSecurityNumber = model.SocialSecurityNumber,
YearlySalary = model.YearlySalary
};
try
{
string jsonCreateCustomer = JsonConvert.SerializeObject(createCustomerRequest);
var httpContent = new StringContent(jsonCreateCustomer, Encoding.UTF8, "application/json");
using (HttpClient client = new HttpClient())
{
var response = client.PostAsync(new Uri(_endpoints.CreateCustomer), httpContent).Result;
if (response.StatusCode != System.Net.HttpStatusCode.OK)
{
return(View("Error"));
}
}
}
catch (Exception ex)
{
_logger.LogCriticalError("Could not create new Customer for UserInterface", ex.ToString());
}
_logger.LogInfo("Customer was created sucessfully");
return(View("~/Views/Customer/CustomerCreated.cshtml"));
}
public CustomerModel CreateCustomer(CreateCustomerModel createCustomerModel)
{
Customer customer = new Customer(createCustomerModel.FirstName, createCustomerModel.LastName, createCustomerModel.Birthday);
_customerRepository.Save(customer);
return customer.ConvertToCustomer();
}
public async Task <IActionResult> CreateCustomerAsync([FromBody] CreateCustomerModel customerModel)
{
if (await _identity.CreateCustomerAsync(customerModel))
{
return(new OkResult());
}
return(new BadRequestResult());
}
public Customer Execute(CreateCustomerModel model)
{
var customer = _factory.Create(model.FirstName, model.LastName);
_database.Customers.Add(customer);
_database.Save();
return customer;
}
public async Task ItShouldReturnOk()
{
var data = new CreateCustomerModel {
Name = "Sample Customer"
};
var response = await _fixture.Post("api/customers", data);
Assert.Equal(HttpStatusCode.OK, response.StatusCode);
}
public ActionResult CreateCustomer()
{
CreateCustomerModel model = new CreateCustomerModel();
model.Id = 0;
List <DictionaryTemplate> types = StaticDictionary.GetOpenTypeList();
ViewBag.OpenTypes = new SelectList(types, "Id", "Value");
model.OpenType = 1;
return(View(model));
}
public async Task CanCreateCustomer()
{
var createCustomerModel = new CreateCustomerModel
{
Name = "CreateTestCustomer"
};
var response = await Client.Value.CreateCustomer(createCustomerModel);
await Client.Value.DeleteCustomer(response.CustomerNumber);
}
public IActionResult Create(CreateCustomerModel model)
{
if (!ModelState.IsValid)
{
return(View(model));
}
this.customers.Create(model.Name, model.Birthday, model.IsYoungDriver);
return(this.RedirectToAction(nameof(All), new { order = OrderingType.Ascending }));
}
public IActionResult Create(CreateCustomerModel customer)
{
if (!this.ModelState.IsValid)
{
return(this.View(customer));
}
this.customerService.Create(customer);
return(RedirectToAction("Index", "Customer"));
}
public async Task <IActionResult> Create(CreateCustomerModel model)
{
if (!ModelState.IsValid)
{
return(View());
}
await _customerStorageClient.Create(model);
return(RedirectToAction(nameof(this.Index)));
}
public async Task <IActionResult> PostCustomer([FromBody] CreateCustomerModel customer)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
await _createCustomerCommand.Execute(customer);
return(CreatedAtAction("GetCustomer", new { id = customer.CustomerId }, customer));
}
public void EditCustomer(CreateCustomerModel input)
{
var customer = this.GetSingleCustomer(input.Id);
customer.FirstName = input.FirstName;
customer.LastName = input.LastName;
customer.Gender = input.Gender;
customer.Telephone = input.Telephone;
this.customerRepository.SaveChanges();
}
public static Customer MapToCustomerModel(this CreateCustomerModel model) => new Customer
{
Firstname = model.FirstName,
Insertion = model.Insertion,
LastName = model.LastName,
UserName = model.Email,
Email = model.Email,
PostalCode = model.PostalCode,
HouseNumber = model.HouseNumber,
Address = model.Address,
City = model.City
};
public void ShouldReturnSuccessWhenCreateCustomer()
{
// Arrange
var customerInputModel = new CreateCustomerModel("Daniel", "Negrisoli Batista", new DateTime(1980, 1, 1));
var customerService = new CustomerService(this.CustomerRepositoryMock);
// Act
var customer = customerService.CreateCustomer(customerInputModel);
// Assert
Assert.Equal(customerInputModel.FirstName, customer.FirstName);
}
public IActionResult Create(CreateCustomerModel model)
{
if (!ModelState.IsValid)
{
return(this.View(model));
}
this.customerService.Create(model.Name, model.BirthDate);
this.logService.Create(User.Identity.Name, "Create", "Customer");
return(RedirectToAction(nameof(All), new { order = "assending" }));
}
public async Task <IActionResult> Execute(CreateCustomerModel data)
{
var customer = new Customer(data.Name);
await _db.AddAsync(customer);
await _db.SaveChangesAsync();
var result = new CreateCustomerResult {
Id = customer.Id, Name = customer.Name
};
return(Ok(result));
}
private Customer GetOrCreateCustomer()
{
var customer = _database.Customers.Where(c => c.FirstName == _model.CustomerFirstName && c.LastName == _model.CustomerLastName).FirstOrDefault();
if (customer == null)
{
var createCustomerModel = new CreateCustomerModel();
createCustomerModel.FirstName = _model.CustomerFirstName;
createCustomerModel.LastName = _model.CustomerLastName;
customer = _customerCommand.Execute(createCustomerModel);
}
return(customer);
}
public async Task <ActionResult <Customer> > Customer(CreateCustomerModel createCustomerModel)
{
try
{
return(await _mediator.Send(new CreateCustomerCommand
{
Customer = _mapper.Map <Customer>(createCustomerModel)
}));
}
catch (Exception ex)
{
return(BadRequest(ex.Message));
}
}
public async Task RunAsync([ServiceBusTrigger("testthomasuser", "UserSubscriber", Connection = "ServiceBusConnection")]
UserDTO dto, string label, ILogger log)
{
log.LogInformation($"ServiceBus topic trigger function processed user with username: {dto.Username}");
if (label == "INSERT")
{
var customer = new CreateCustomerModel();
customer.Name = $"{dto.Firstname} {dto.Lastname}";
customer.Email = dto.Username;
var request = new CreateCustomerRequest(customer);
var result = await _mediator.Send(request);
}
}
public async Task <IActionResult> Create([FromBody] CreateCustomerModel customer)
{
if (customer == null)
{
return(BadRequest());
}
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
await _createCustomerCommand.Execute(customer);
return(CreatedAtRoute("Create", new { customer.Id }, customer));
}
public async Task CanFilterCustomers()
{
var customer1 = new CreateCustomerModel
{
Name = "FilterTestCustomer 1"
};
var customer2 = new CreateCustomerModel
{
Name = "FilterTestCustomer 2"
};
var customer3 = new CreateCustomerModel
{
Name = "Peter"
};
var createdCustomer1 = await Client.Value.CreateCustomer(customer1);
var createdCustomer2 = await Client.Value.CreateCustomer(customer2);
var createdCustomer3 = await Client.Value.CreateCustomer(customer3);
// Get By Eq Name
var peterFilter = new QueryFilter <CustomerReadModel>();
peterFilter.Where(x => x.Name, QueryOperator.Eq, "Peter");
var filteredEquals = await Client.Value.ListCustomers(peterFilter);
var filteredEqualsCount = filteredEquals.Collection.Count;
// Get By Like Name
var testFilter = new QueryFilter <CustomerReadModel>();
testFilter.Where(x => x.Name, QueryOperator.Like, "FilterTestCustomer");
filteredEquals = await Client.Value.ListCustomers(testFilter);
var filteredEqualsCount2 = filteredEquals.Collection.Count;
await Client.Value.DeleteCustomer(createdCustomer1.CustomerNumber);
await Client.Value.DeleteCustomer(createdCustomer2.CustomerNumber);
await Client.Value.DeleteCustomer(createdCustomer3.CustomerNumber);
filteredEqualsCount.Should().Be(1);
filteredEqualsCount2.Should().Be(2);
}
public ActionResult <ApiResponse <CustomerModel> > CreateCustomer([FromBody] CreateCustomerModel model)
{
try
{
var onlineUser = this._userService.GetOnlineUser(this.HttpContext);
if (onlineUser == null)
{
return(Json(ApiResponse.WithError("Not Authority")));
}
if (onlineUser.Type == UserType.Admin)
{
if (onlineUser.Type != UserType.Admin)
{
return(Json(ApiResponse.WithError("Not Authority")));
}
}
if (onlineUser.Type == UserType.Manager)
{
if (onlineUser.Type != UserType.Admin)
{
return(Json(ApiResponse.WithError("Not Authority")));
}
}
CustomerModel result = null;
var newCustomer = new Customer();
newCustomer.Fullname = model.Fullname;
newCustomer.Phone = model.Phone;
var phoneContains = this._customerService.PhoneCounter(model.Phone.ToString());
if (phoneContains >= 1)
{
return(Json(ApiResponse.WithError("This Phone Exists")));
}
this._customerService.AddNewCustomer(newCustomer);
result = this._customerService.GetById(newCustomer.Id);
return(Json(ApiResponse <CustomerModel> .WithSuccess(result)));
}
catch (Exception exp)
{
return(Json(ApiResponse <CustomerModel> .WithError(exp.ToString())));
}
}
