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)); }