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