public async Task <ActionResult> CreateCustomerAsync(CustomerCreateDTO customerDto)
{
var newCustomer = _mapper.Map <Customer>(customerDto);
var createdCustomer = await _customerService.AddCustomerAsync(newCustomer);
return(Ok(createdCustomer));
}
public async Task <ActionResult> Create(CustomerCreateViewModel model)
{
try
{
var CustomerDto = new CustomerCreateDTO
{
PhoneNumber = model.PhoneNumber,
FullName = model.FullName,
Email = model.Email,
Gender = model.Gender,
Address = model.Address
};
await _customerService.Create(CustomerDto).ConfigureAwait(true);
var Customer = await _customerRepo.GetByNumber(CustomerDto.PhoneNumber) ?? throw new CustomerNotFoundException();
return(Ok(CreateReponseDto(Customer)));
}
catch (Exception ex)
{
return(BadRequest(ex.Message));
}
}
public CustomerServiceTest()
{
_customerService = new CustomerService(_customerRepo.Object, _context.Object);
_createDto = new CustomerCreateDTO();
_updateDto = new CustomerUpdateDTO();
_customer = new Customer(full_name);
}
public async Task <IActionResult> Create(CustomerCreateViewModel model)
{
try
{
if (ModelState.IsValid)
{
var customer = new CustomerCreateDTO
{
PhoneNumber = model.PhoneNumber,
FullName = model.FullName,
Email = model.Email,
Gender = model.Gender,
Address = model.Address
};
await _customerService.Create(customer).ConfigureAwait(true);
_toastNotification.AddSuccessToastMessage("Created:- " + customer.FullName);
return(RedirectToAction("Index"));
}
}
catch (Exception ex)
{
_toastNotification.AddErrorToastMessage(ex.Message);
}
return(View(model));
}
public int Create(CustomerCreateDTO entityToCreate)
{
try
{
string query = @"
INSERT INTO Customers(CustomerCode, CustomerContactNumber, CustomerEmailAddress, CustomerName, CustomerTypeID, DefaultAddressID)
VALUES (@CustomerCode, @CustomerContactNumber, @CustomerEmailAddress,@CustomerName,@CustomerTypeID,@DefaultAddressID)
SELECT SCOPE_IDENTITY()";
var queryParameters = new DynamicParameters();
queryParameters.Add("@CustomerCode", entityToCreate.CustomerCode);
queryParameters.Add("@CustomerContactNumber", entityToCreate.CustomerContactNumber);
queryParameters.Add("@CustomerEmailAddress", entityToCreate.CustomerEmailAddress);
queryParameters.Add("@CustomerName", entityToCreate.CustomerName);
queryParameters.Add("@CustomerTypeID", entityToCreate.CustomerTypeID);
queryParameters.Add("@DefaultAddressID", entityToCreate.DefaultAddressID);
return(Connection.QueryFirst <int>(query, queryParameters, CurrentTrans));
}
catch (Exception ex)
{
throw SqlExceptionHandler.HandleSqlException(ex) ?? ex;
}
}
public async Task <IActionResult> Create([FromBody] CustomerCreateDTO CustomerDTO)
{
var location = GetControllerActionNames();
try
{
_logger.LogInfo($"{location}: Create Attempted");
if (CustomerDTO == null)
{
_logger.LogWarn($"{location}: Empty Request was submitted");
return(BadRequest(ModelState));
}
if (!ModelState.IsValid)
{
_logger.LogWarn($"{location}: Data was Incomplete");
return(BadRequest(ModelState));
}
var customer = _mapper.Map <Customer>(CustomerDTO);
var result = await _businessLogic.Add(customer);
if (result.IsFailed)
{
return(InternalError($"{location}: Creation failed"));
}
_logger.LogInfo($"{location}: Creation was successful");
return(Created("Create", new { customer }));
}
catch (Exception e)
{
return(InternalError($"{location}: {e.Message} - {e.InnerException}"));
}
}
public async Task <ActionResult> Create(CustomerCreateDTO Customer)
{
var result = await _CustomerService.Create(Customer);
return(CreatedAtAction(
"GetById",
new { id = result.CustomerId },
result));
}
public async Task <bool> CreateCustomer(CustomerCreateDTO dto)
{
var rao = _mapper.Map <CustomerCreateRAO>(dto);
if (await _repository.CreateCustomer(rao))
{
return(true);
}
throw new NotImplementedException();
}
public async Task <IActionResult> Create(CustomerCreateDTO customerCreate)
{
try
{
var customer =
Mapper.Map <CustomerDTO>(
await CustomerCreateService.CreateAsync(Mapper.Map <CustomerUpdateModel>(customerCreate)));
return(Redirect($"/customers/{customer.Id}"));
}
catch
{
return(View());
}
}
public async Task <CustomerDTO> Create(CustomerCreateDTO model)
{
var entry = new Customer
{
CustomerId = model.CustomerId,
UserId = model.UserId
};
await _context.AddAsync(entry);
await _context.SaveChangesAsync();
return(_mapper.Map <CustomerDTO>(entry));
}
public CustomerDTO Create(CustomerCreateDTO modelToCreate)
{
try
{
int newID = UOW.CustomerRepo.Create(modelToCreate);
var createResult = UOW.CustomerRepo.GetByID(newID);
UOW.SaveChanges();
return(createResult);
}
catch (Exception ex)
{
UOW.RollbackChanges();
throw ex;
}
}
public IActionResult AddCustomer([FromBody] CustomerCreateDTO customerCreateDto)
{
Customer toAdd = Mapper.Map <Customer>(customerCreateDto);
_customerRepository.Add(toAdd);
bool result = _customerRepository.Save();
if (!result)
{
return(new StatusCodeResult(500));
}
return(CreatedAtRoute("GetSingleCustomer", new { id = toAdd.Id }, Mapper.Map <CustomerDTO>(toAdd)));
}
private void Button_Click(object sender, RoutedEventArgs e)
{
CustomerCreateDTO customerDTO = new CustomerCreateDTO();
customerDTO.FirstName = ImeKorisnika.Text;
customerDTO.LastName = PrezimeKorisnika.Text;
customerDTO.Email = Email.Text;
customerDTO.CustomerRoles.Add(3);
var convertedModel = JsonConvert.SerializeObject(customerDTO);
//CreateProductAsync(userAccessModel);
new HttpClient().PostAsync("http://localhost:9388/addcustomer", new StringContent(convertedModel, Encoding.UTF8, "application/json"));
}
public async Task Create(CustomerCreateDTO dto)
{
using var tx = TransactionScopeHelper.GetInstance();
await ValidateCustomerNumber(dto.PhoneNumber);
var customer = new Customer(dto.FullName);
customer.Email = dto.Email;
customer.Address = dto.Address;
customer.PhoneNumber = dto.PhoneNumber;
customer.Gender = dto.Gender;
await _customerRepo.InsertAsync(customer);
tx.Complete();
}
public async Task <IHttpActionResult> PostCustomer(CustomerCreateDTO customerData)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
Customer customer = new Customer
{
tradingName = customerData.tradingName,
registrationDate = DateTime.Now,
//reference = customerData.reference
};
db.Customers.Add(customer);
await db.SaveChangesAsync();
return(CreatedAtRoute("DefaultApi", new { id = customer.id }, customer));
}
public ActionResult AddCustomer([FromBody] CustomerCreateDTO customer)
{
string[] lines = System.IO.File.ReadAllLines(@"auth.txt");
var accessToken = lines[0]; //Settings.Default["accessToken"].ToString();//HttpContext.Session.GetString("accessToken");
var serverUrl = lines[1];
CustomerSendDTO customerSendDTO = new CustomerSendDTO();
customerSendDTO.customer = customer;
var nopApiClient = new ApiClient(accessToken, serverUrl);
var convertedModel = JsonConvert.SerializeObject(customerSendDTO,
Formatting.None,
new JsonSerializerSettings {
NullValueHandling = NullValueHandling.Ignore
});
string jsonUrl = $"/api/customers";
object productsData = nopApiClient.Post(jsonUrl, convertedModel);
return(Ok());
}
public IActionResult CustomerCreate([FromBody] CustomerCreateDTO customerDTO)
{
if (ModelState.IsValid)
{
var customerIntity = _mapper.Map<Customer>(customerDTO);
bool isSaved = _customerManager.Add(customerIntity);
if (isSaved)
{
customerDTO.Id = customerIntity.Id;
return CreatedAtRoute("GetById", new {id=customerDTO.Id }, customerDTO);
}
else
{
return BadRequest("Customer Could Not Be Saved");
}
}
else
{
return BadRequest(ModelState);
}
}
public IActionResult PostCustomer([FromBody] CustomerCreateDTO customerDto)
{
if (ModelState.IsValid)
{
var customerEntity = _mapper.Map <Customer>(customerDto);
bool isSaved = _customerManager.Add(customerEntity);
if (isSaved)
{
customerDto.Id = customerEntity.Id;
//return Ok(customerDto);
return(CreatedAtRoute("GetById", new { id = customerDto.Id }, customerDto));
}
else
{
return(BadRequest("Customer could not be saved!"));
}
}
else
{
return(BadRequest(ModelState));
}
}
public IActionResult AddCustomer([FromBody] CustomerCreateDTO customer)
{
if (ModelState.IsValid)
{
var customerEntity = _mapper.Map <Customer>(customer);
bool isSaved = _customerManager.Add(customerEntity);
if (isSaved)
{
customer.Id = customerEntity.Id;
return(CreatedAtRoute("GetbyId", new { id = customer.Id }, customer));
}
else
{
return(BadRequest("Customer is Invalid"));
}
}
else
{
return(BadRequest(ModelState));
}
}
public async Task <CustomerDTO> Create(CustomerCreateDTO customerCreate)
{
return(Mapper.Map <CustomerDTO>(
await CustomerCreateService.CreateAsync(Mapper.Map <CustomerUpdateModel>(customerCreate))));
}
public ActionResult <CustomerDTO> Create([FromBody] CustomerCreateDTO userInput)
{
try { return(_customerManager.Create(userInput)); }
catch (BaseCustomException ex) { return(BadRequest(ex.Message)); }
}
public CustomerDTO Create(CustomerCreateDTO createModel)
{
return(_customerService.Create(createModel));
}
