public async Task <CustomerResponseDto> AddCustomerAsync(CustomerRequestDto customerDto) { var customer = _mapper.Map <CustomerRequestDto, Customer>(customerDto); var result = await _customerRepository.AddCustomerAsync(customer); return(_mapper.Map <CustomerResponseDto>(result)); }
private static async Task <StringContent> CreateStringContent(CustomerRequestDto dto) { var content = new StringContent(await Task.Factory.StartNew(() => JsonConvert.SerializeObject(dto))); content.Headers.ContentType = new MediaTypeHeaderValue("application/json"); return(content); }
public bool RegisterCustomer(CustomerRequestDto customerRequestDto) { if (UserExists(customerRequestDto.userRequestDto.Username)) { return(false); } byte[] passwordHash, passwordSalt; CreatePasswordHash(customerRequestDto.userRequestDto.Password, out passwordHash, out passwordSalt); var user = new User { UserId = Guid.NewGuid(), Username = customerRequestDto.userRequestDto.Username, PasswordHash = passwordHash, PasswordSalt = passwordSalt }; _ecommerceContext.Add(user); if (_ecommerceContext.SaveChanges() == 1) { if (_customerServiceManager.AddCustomer(user.UserId, customerRequestDto)) { if (_cartServiceManager.CreateCart(user.UserId)) { return(true); } } } return(false); }
public async Task CreateCustomerExistingEmailTest() { var email = CreateValidEmail(); var dto = new CustomerRequestDto { FirstName = "Test Name", Surname = "Test Surname", Email = email, Password = "******", ConfirmPassword = "******" }; var content = await CreateStringContent(dto); var client = _factory.CreateClient(); var response = await client.PostAsync(CustomerUrl, content); Assert.True(response.StatusCode == HttpStatusCode.Created); var clientNotOk = _factory.CreateClient(); var responseNotOk = await clientNotOk.PostAsync(CustomerUrl, content); Assert.True(responseNotOk.StatusCode == HttpStatusCode.BadRequest); }
public async Task CreateTest() { //Arrange var customer = new CustomerMngt.Domain.Entities.Customer { Id = 1, Password = "******", Email = "*****@*****.**", Surname = "Surname", FirstName = "First Name" }; var customerRequestDto = new CustomerRequestDto { Email = "*****@*****.**", Surname = "Surname", FirstName = "First Name", Password = "******", ConfirmPassword = "******", }; //Act const long id = 1; var mockService = new Mock <ICustomerService>(); var mockMapper = new Mock <IMapper>(); mockMapper.Setup(x => x.Map <CustomerMngt.Domain.Entities.Customer>(customerRequestDto)).Returns(customer); mockService.Setup(x => x.CreateAsync(customer)).ReturnsAsync(id); //Assert var mockFacade = new CustomerFacade(mockService.Object, mockMapper.Object); var result = await mockFacade.CreateAsync(customerRequestDto); Assert.Equal(id, result); }
public async Task GetCustomerTest() { var customerOneEmail = CreateValidEmail(); var dto = new CustomerRequestDto { FirstName = "Test Name", Surname = "Test Surname", Email = customerOneEmail, Password = "******", ConfirmPassword = "******" }; var content = await CreateStringContent(dto); var client = _factory.CreateClient(); var response = await client.PostAsync(CustomerUrl, content); Assert.True(response.StatusCode == HttpStatusCode.Created); client = _factory.CreateClient(); var getResponse = await client.GetAsync(response.Headers.Location.ToString()); Assert.True(getResponse.StatusCode == HttpStatusCode.OK); }
public async Task <IActionResult> UpdateCustomer(CustomerRequestDto customerRequestDto) { return(Ok(await _mediator.Send(new UpdateCustomerCommand { CustomerRequestDto = customerRequestDto }))); }
public async Task DeleteCustomerOkTest() { var email = CreateValidEmail(); var dto = new CustomerRequestDto { FirstName = "Test Name", Surname = "Test Surname", Email = email, Password = "******", ConfirmPassword = "******" }; var content = await CreateStringContent(dto); var client = _factory.CreateClient(); var response = await client.PostAsync(CustomerUrl, content); Assert.True(response.StatusCode == HttpStatusCode.Created); client = _factory.CreateClient(); var getResponse = await client.GetAsync(response.Headers.Location.ToString()); Assert.True(getResponse.StatusCode == HttpStatusCode.OK); var customer = JsonConvert.DeserializeObject <CustomerResponseDto>(await getResponse.Content.ReadAsStringAsync()); client = _factory.CreateClient(); var deleteResponse = await client.DeleteAsync($"{CustomerUrl}/{customer.Id}"); Assert.True(deleteResponse.StatusCode == HttpStatusCode.NoContent); }
public async Task <ResponseMessageDto> DeleteCustomer(CustomerRequestDto dto) { try { await _asyncRepository.DeleteAsync(_mapper.Map <Customer>(dto)); return(new ResponseMessageDto() { Id = dto.Id, SuccessMessage = ResponseMessages.DeleteSuccessMessage, Success = true, Error = false }); } catch (Exception e) { Console.WriteLine(e); return(new ResponseMessageDto() { Id = Convert.ToInt16(Enums.FailureId), FailureMessage = ResponseMessages.DeleteFailureMessage, Success = false, Error = true, ExceptionMessage = e.InnerException != null ? e.InnerException.Message : e.Message }); } }
public async Task <long> CreateAsync(CustomerRequestDto customerRequestDto) { var customer = _mapper.Map <Customer>(customerRequestDto); var id = await _customerService.CreateAsync(customer); return(id); }
public IActionResult RegisterCustomer([FromBody] CustomerRequestDto customerRequestDto) { var userRegistered = _authServiceManager.RegisterCustomer(customerRequestDto); if (!userRegistered) { return(UnprocessableEntity()); } return(Ok()); }
public async Task <IActionResult> Delete([FromBody] CustomerRequestDto dto) { try { return(Ok(await _customerService.DeleteCustomer(dto))); } catch (Exception e) { Console.WriteLine(e); throw; } }
public async Task UpdateCustomerExistingEmailTest() { var customerOneEmail = CreateValidEmail(); var dto = new CustomerRequestDto { FirstName = "Test Name", Surname = "Test Surname", Email = customerOneEmail, Password = "******", ConfirmPassword = "******" }; var contentCustomerOne = await CreateStringContent(dto); var client = _factory.CreateClient(); var createCustomerOneResponse = await client.PostAsync(CustomerUrl, contentCustomerOne); Assert.True(createCustomerOneResponse.StatusCode == HttpStatusCode.Created); dto.Email = CreateValidEmail(); var contentCustomerTwo = await CreateStringContent(dto); client = _factory.CreateClient(); var createCustomerTwoResponse = await client.PostAsync(CustomerUrl, contentCustomerTwo); Assert.True(createCustomerTwoResponse.StatusCode == HttpStatusCode.Created); var parameters = new Dictionary <string, string> { { "email", dto.Email } }; var requestUri = QueryHelpers.AddQueryString(CustomerUrl, parameters); client = _factory.CreateClient(); var getResponse = await client.GetAsync(requestUri); Assert.True(getResponse.StatusCode == HttpStatusCode.OK); var customer = JsonConvert.DeserializeObject <CustomerResponseDto>(await getResponse.Content.ReadAsStringAsync()); dto.Email = customerOneEmail; var content = await CreateStringContent(dto); client = _factory.CreateClient(); var response = await client.PutAsync($"{CustomerUrl}/{customer.Id}", content); Assert.True(response.StatusCode == HttpStatusCode.BadRequest); }
public async Task <IActionResult> Post([FromBody] CustomerRequestDto dto) { try { if (!ModelState.IsValid) { return(BadRequest(ModelState)); } return(Ok(await _customerService.AddCustomer(dto))); } catch (Exception e) { Console.WriteLine(e); throw; } }
public async Task GetCustomerListTest() { var dto = new CustomerRequestDto { FirstName = "Test Name Get", Surname = "Test Surname", Email = CreateValidEmail(), Password = "******", ConfirmPassword = "******" }; var content = await CreateStringContent(dto); var client = _factory.CreateClient(); var response = await client.PostAsync(CustomerUrl, content); Assert.True(response.StatusCode == HttpStatusCode.Created); dto.Email = CreateValidEmail(); var contentTwo = await CreateStringContent(dto); client = _factory.CreateClient(); var responseTwo = await client.PostAsync(CustomerUrl, contentTwo); Assert.True(responseTwo.StatusCode == HttpStatusCode.Created); var parameters = new Dictionary <string, string> { { "currentPage", "1" }, { "pageSize", "1" }, { "orderBy", dto.FirstName }, { "sortBy", "asc" } }; var requestUri = QueryHelpers.AddQueryString(CustomerUrl, parameters); client = _factory.CreateClient(); var getResponse = await client.GetAsync(requestUri); Assert.True(getResponse.StatusCode == HttpStatusCode.OK); var customers = JsonConvert.DeserializeObject <PaginationDto <CustomerResponseDto> >( await getResponse.Content.ReadAsStringAsync()); Assert.True(customers.Count > 1); }
public async Task CreateRequiredPasswordTest() { var dto = new CustomerRequestDto { FirstName = "Test First", Surname = "Test Surname", Email = CreateValidEmail(), Password = "" }; var content = await CreateStringContent(dto); var client = _factory.CreateClient(); var response = await client.PostAsync(CustomerUrl, content); Assert.True(response.StatusCode == HttpStatusCode.BadRequest); }
public async Task <ResponseMessageDto> UpdateCustomer(CustomerRequestDto dto) { try { if (_customerRepository.IsCustomerNameAvailable(dto.Id, dto.Name)) { return new ResponseMessageDto() { SuccessMessage = ResponseMessages.CustomerNameNotAvailable, Success = true, Error = false } } ; await _asyncRepository.PartialUpdate(dto, m => ///yahan woh values aengi jo ke update karni hongi { m.CustomerTypeId = dto.CustomerTypeId; m.Name = dto.Name; m.Address = dto.Address; m.Contact = dto.Contact; }); return(new ResponseMessageDto() { Id = dto.Id, SuccessMessage = ResponseMessages.UpdateSuccessMessage, Success = true, Error = false }); } catch (Exception e) { Console.WriteLine(e); return(new ResponseMessageDto() { Id = Convert.ToInt16(Enums.FailureId), FailureMessage = ResponseMessages.UpdateFailureMessage, Success = false, Error = true, ExceptionMessage = e.InnerException != null ? e.InnerException.Message : e.Message }); } }
public async Task CreateCustomerOkTest() { var dto = new CustomerRequestDto { FirstName = "Test Name", Surname = "Test Surname", Email = CreateValidEmail(), Password = "******", ConfirmPassword = "******" }; var content = await CreateStringContent(dto); var client = _factory.CreateClient(); var response = await client.PostAsync(CustomerUrl, content); response.EnsureSuccessStatusCode(); Assert.True(response.StatusCode == HttpStatusCode.Created); }
public async Task UpdateTest() { //Arrange var customerRequestDto = new CustomerRequestDto { Password = "******", ConfirmPassword = "******", Email = "*****@*****.**", Surname = "Surname", FirstName = "First Name" }; var customer = new CustomerMngt.Domain.Entities.Customer { Password = "******", Email = "*****@*****.**", Surname = "Surname", FirstName = "First Name" }; const long id = 1; //Act var mockService = new Mock <ICustomerService>(); var mockMapper = new Mock <IMapper>(); //Assert mockMapper.Setup(x => x.Map <CustomerMngt.Domain.Entities.Customer>(customerRequestDto)).Returns(customer); var mockFacade = new CustomerFacade(mockService.Object, mockMapper.Object); try { await Assert.ThrowsAsync <Exception>(() => mockFacade.UpdateAsync(id, customerRequestDto)); } catch (AssertActualExpectedException exception) { Assert.Equal("(No exception was thrown)", exception.Actual); } }
public async Task <ResponseMessageDto> AddCustomer(CustomerRequestDto dto) { try { if (_customerRepository.IsCustomerNameAvailable(dto.Name)) { return new ResponseMessageDto() { FailureMessage = ResponseMessages.CustomerNameNotAvailable, Success = false, Error = true } } ; dto.CreatedOn = DateTime.Now.Date; var customer = await _asyncRepository.AddAsync(_mapper.Map <Customer>(dto)); return(new ResponseMessageDto() { Id = customer.Id, SuccessMessage = ResponseMessages.InsertionSuccessMessage, Success = true, Error = false }); } catch (Exception e) { Console.WriteLine(e); return(new ResponseMessageDto() { Id = Convert.ToInt16(Enums.FailureId), FailureMessage = ResponseMessages.InsertionFailureMessage, Success = false, Error = true, ExceptionMessage = e.InnerException != null ? e.InnerException.Message : e.Message }); } }
public async Task <IActionResult> Post([FromBody] CustomerRequestDto customerRequestDto) { try { if (!ModelState.IsValid) { return(BadRequest(ModelState)); } var id = await _customerFacade.CreateAsync(customerRequestDto); return(CreatedAtAction(nameof(Get), new { id }, new { id })); } catch (ValidationException e) { _logger.LogError( "Exception Details: {message}, {innerException}, {stackTrace}. CorrelationId: {correlationId}", e.Message, e.InnerException?.Message, e.StackTrace, _correlationContext.CorrelationContext.CorrelationId); return(BadRequest(e.Message)); } }
public async Task <IActionResult> Put(long id, [FromBody] CustomerRequestDto customerRequestDto) { try { if (!ModelState.IsValid) { return(BadRequest(ModelState)); } if (id <= 0) { return(BadRequest("Invalid id.")); } await _customerFacade.UpdateAsync(id, customerRequestDto); return(NoContent()); } catch (EntityNotFoundException e) { _logger.LogError( "Exception Details: {message}, {innerException}, {stackTrace}. CorrelationId: {correlationId}", e.Message, e.InnerException?.Message, e.StackTrace, _correlationContext.CorrelationContext.CorrelationId); return(NotFound()); } catch (ValidationException e) { _logger.LogError( "Exception Details: {message}, {innerException}, {stackTrace}. CorrelationId: {correlationId}", e.Message, e.InnerException?.Message, e.StackTrace, _correlationContext.CorrelationContext.CorrelationId); return(BadRequest(e.Message)); } }
public async Task UpdateAsync(long id, CustomerRequestDto customerRequestDto) { var customer = _mapper.Map <Customer>(customerRequestDto); await _customerService.UpdateAsync(id, customer); }
public async Task <ActionResult <CustomerResponseDto> > Post(CustomerRequestDto request) { var response = await _customerService.AddCustomerAsync(request); return(Ok(response)); }