//Đ
// For Customer to create request
public async Task <int> CreateCustomerRequest(CustomerRequestModel model, long userId)
{
var entity = this._mapper.Map <Request>(model);
// TODO: strings should be managed in constant class or enum
// Create RequestStatus constant class
// Then use
// entity.Status = RequestStatus.InActive;
// DONE
entity.Status = RequestStatus.INACTIVE;
entity.CreatedDate = DateTime.Now;
entity.Code = Helper.GenerateCode(DateTime.Now, 1);
entity.IssuerId = userId;
entity.CustomerId = userId;
entity.WareHouse = null;
// Step 2: Add request details
// Save to FeatureOfVehicle
//var featureEnity = new VehicleFeatureRequest()
//{
// RequestId = entity.Id,
// VehicleFeatureId = model.VehicleFeature.Value
//};
//_vehicleFeatureRequestRepository.Create(featureEnity);
//await _uow.SaveChangesAsync();
_repository.Create(entity);
await _uow.SaveChangesAsync();
return(entity.Id);
}
public async Task <IActionResult> GetCustomer(CustomerRequestModel request)
{
var validationMessage = CustomerControllerValidator.ValidateGetCustomerRequest(request);
if (validationMessage != null)
{
return(BadRequest(validationMessage));
}
if (request.CustomerId > 0)
{
var serviceResult = await _customerService.GetCustomerInfoAsync(request.CustomerId, TAKE_TRANSACTIONS_COUNT);
if (serviceResult.Status == ServiceResultStatus.NotFound)
{
serviceResult = await _customerService.GetCustomerInfoAsync(request.Email, TAKE_TRANSACTIONS_COUNT);
}
return(ReturnResult(serviceResult));
}
else
{
var serviceResult = await _customerService.GetCustomerInfoAsync(request.Email, TAKE_TRANSACTIONS_COUNT);
return(ReturnResult(serviceResult));
}
}
public Response <CustomerModel> UpdateCustomerStatus(CustomerRequestModel model)
{
string ReturnLink = string.Empty;
Response <CustomerModel> returnModel = new Response <CustomerModel>();
try
{
using (SqlConnection DB = new SqlConnection(SiteKey.ConnectionString))
{
DB.ExecuteSql(@"update customer set status = @status where id = @id ", new { id = model.id, status = model.status });
}
returnModel.status = (int)EnumClass.ResponseState.Success;
returnModel.msg = Resource_Kharban.UpdateSuccessfully;
returnModel.success = true;
}
catch (Exception ex)
{
returnModel.msg = ex.Message;
returnModel.status = (int)EnumClass.ResponseState.ResposityError;
returnModel.success = false;
LoggingRepository.SaveException(ex);
}
return(returnModel);
}
public async Task <CustomerResponseModel> CreateCustomer(CustomerRequestModel customerRequestModel)
{
var customer = _mapper.Map <Customer>(customerRequestModel);
var createdCustomer = await _customerRepository.AddAsync(customer);
return(_mapper.Map <CustomerResponseModel>(createdCustomer));
}
public async Task <ActionResult> UpdateCustomerAsync(CustomerRequestModel customerRequestModel)
{
int id = customerRequestModel.Id;
var customer = await _customerService.UpdateCustomerDetailsAsync(customerRequestModel);
return(Ok(customer));
}
public async Task <CustomerResponse> UpdateCustomer(Customer customer)
{
if (customer == null)
{
throw new ArgumentNullException(nameof(customer));
}
var url = new Uri(this.baseUrl, customer.Id);
try
{
var customerRequestModel = new CustomerRequestModel(customer);
var json = customerRequestModel.ToString();
var content = new StringContent(json);
content.Headers.ContentType = new MediaTypeHeaderValue("application/json");
using (var response = await this.httpClient.PutAsync(url, content))
{
response.EnsureSuccessStatusCode();
string responseBody = await response.Content.ReadAsStringAsync();
return(MapCustomerResponse(responseBody));
}
}
catch (Exception exception)
{
throw new CustomerException(url, exception);
}
}
public async Task <CustomerResponseModel> UpdateCustomerDetailsAsync(CustomerRequestModel customerRequestModel)
{
var customer = _mapper.Map <Customer>(customerRequestModel);
var updatedCustomer = await _customerRepository.UpdateCustomerAsync(customer);
return(_mapper.Map <CustomerResponseModel>(updatedCustomer));
}
public async Task <ActionResult <ServiceResult> > UpdateAsync(CustomerRequestModel requestModel)
{
#region Input Validation
CustomerModel customer = (await _customerService.GetAsync(c => c.Id == requestModel.Id)).FirstOrDefault();
if (customer is null)
{
return(new ServiceResult
{
StatusCode = HttpStatusCode.BadRequest,
Message = $"Customer not found"
});
}
bool customerWithEmailExists = await _customerService.AnyAsync(c => c.Id != requestModel.Id && c.Email == requestModel.Email);
if (customerWithEmailExists)
{
return(new ServiceResult
{
StatusCode = HttpStatusCode.BadRequest,
Message = $"Customer with email {requestModel.Email} already exists"
});
}
#endregion
customer = _mapper.Map <CustomerModel>(requestModel);
_customerService.Update(customer);
await _customerService.SaveChangesAsync();
return(new ServiceResult
{
StatusCode = HttpStatusCode.OK,
Message = "Success",
Data = customer
});
}
public ICollection <Customer> GetByRequest(CustomerRequestModel customer)
{
var result = db.Customers.AsQueryable();
if (customer == null)
{
return(result.ToList());
}
if (customer.Id > 0)
{
result = result.Where(c => c.Id == customer.Id);
}
if (!string.IsNullOrEmpty(customer.Name))
{
result = result.Where(c => c.Name.ToLower().Contains(customer.Name.ToLower()));
}
if (!string.IsNullOrEmpty(customer.Address))
{
result = result.Where(c => c.Address.ToLower().Contains(customer.Address.ToLower()));
}
if (!string.IsNullOrEmpty(customer.PhoneNo))
{
result = result.Where(c => c.PhoneNo.ToLower().Equals(customer.PhoneNo.ToLower()));
}
if (customer.IsDeleted != null)
{
result = result.Where(c => c.IsDeleted == customer.IsDeleted);
}
return(result.ToList());
}
public static CustomerDbModel ToDbModel(CustomerRequestModel model)
=> new CustomerDbModel
{
FirstName = model.FirstName,
LastName = model.LastName,
Email = model.Email,
Age = model.Age
};
public void TestGetCustomerNotFound()
{
CustomerRequestModel request = new CustomerRequestModel();
request.CustomerID = "1234568";
Assert.ThrowsException <NullReferenceException>(() => customerService.GetCustomer(request));
}
public void TestInvalidCustomerID()
{
CustomerRequestModel request = new CustomerRequestModel();
request.CustomerID = "1234567890123";
Assert.ThrowsException <FormatException>(() => customerService.GetCustomer(request));
}
public void TestInvalidEmail()
{
CustomerRequestModel request = new CustomerRequestModel();
request.Email = "[email protected]@[email protected]@domain.com";
Assert.ThrowsException <FormatException>(() => customerService.GetCustomer(request));
}
public ActionResult Create()
{
CustomerRequestModel payment = new CustomerRequestModel()
{
Locale = "nl_NL"
};
return(this.View(payment));
}
public CustomerViewModel CreateCustomers(CustomerRequestModel customer)
{
var customerDbModel = ConvertRequestModel.ToDbModel(customer);
customerGenericRepository.Add(customerDbModel);
unitOfWork.SaveChanges();
return(ConvertDbModel.ToViewModel(customerDbModel));
}
public async Task RunTests(int testId, CustomerRequestModel customer, bool expectedValid, List <string> errorListExpected)
{
var sut = new CustomerValidator();
var result = await sut.ValidateAsync(customer);
Assert.That(result.IsValid, Is.EqualTo(expectedValid));
Assert.That(result.Errors.Count, Is.EqualTo(errorListExpected.Count));
Assert.That(errorListExpected.All(x => result.Errors.Any(e => e.ErrorCode == x)), Is.True);
}
public IActionResult GetCustomers([FromQuery]CustomerRequestModel customer)
{
var result = _customerManager.GetByRequest(customer);
if(result == null)
{
return NotFound();
}
return Ok(result);
}
//Customer/List/[Filturing]
public IActionResult GetbyRequest([FromQuery] CustomerRequestModel customer)
{
var customerEntity = _customerManager.GetbyRequest(customer);
if (customerEntity == null)
{
return(View("Customer Not Found"));
}
return(View(customerEntity));
}
public IActionResult UpdateStatusCustomer([FromBody] CustomerRequestModel model)
{
if (model == null)
{
model = new CustomerRequestModel();
}
Response <CustomerModel> returnModel = new CustomerRepository().UpdateCustomerStatus(model);
return(Ok(returnModel));
}
public void TestGetCustomerByIDAndEmail()
{
CustomerRequestModel request = new CustomerRequestModel();
request.CustomerID = "123456";
request.Email = "*****@*****.**";
CustomerModel result = customerService.GetCustomer(request);
Assert.AreNotEqual(null, result);
}
public IActionResult GetCustomers([FromQuery] CustomerRequestModel customer)
{
var result = _customerManager.GetbyRequest(customer);
if (result == null)
{
return(BadRequest("Customer Not Found"));
}
return(Ok(result));
}
public async Task Create(CustomerRequestModel requestModel)
{
Customer customer = MapCustomerFromRequestModel(requestModel);
if (!_notificationService.IsEntityValid(customer))
{
return;
}
await _customerRepository.Create(customer);
}
// For Customer to update request
public async Task <int> UpdateCustomerRequest(CustomerRequestModel model, long userId)
{
var entity = _repository.GetEntityById(model.Id);
_mapper.Map(model, entity);
entity.WareHouse = null;
_repository.Update(entity);
await _uow.SaveChangesAsync();
return(model.Id);
}
public Response <CustomerModel> GetCustomerInfo(CustomerRequestModel request)
{
try
{
return(Response(customerService.GetCustomer(request)).Success());
}
catch (Exception ex)
{
return(Response(new CustomerModel()).Failed(ex.Message));
}
}
public async Task UpdateCustomer(int id, CustomerRequestModel customer)
{
var existingCustomer = await FindCustomer(id);
if (existingCustomer == null)
{
throw new KeyNotFoundException("No record Exists to update");
}
var mappedCustomer = _mapper.Map <CustomerRequestModel, Customer>(customer, existingCustomer);
_customerContext.Customers.Update(mappedCustomer);
_customerContext.SaveChanges();
}
public async Task <IActionResult> Post([FromBody] CustomerRequestModel value)
{
if (ModelState.IsValid)
{
await _databaseContext.Customers.AddAsync(_mapper.Map <CustomerRequestModel, Customer>(value));
await _databaseContext.SaveChangesAsync();
return(Ok());
}
return(BadRequest()); //TODO Specify errors
}
public async Task <ActionResult> UpdateCustomer(int id, CustomerRequestModel customer)
{
try
{
await _customerRepository.UpdateCustomer(id, customer);
return(Ok());
}
catch (KeyNotFoundException)
{
return(NotFound());
}
}
public async Task AddCustomer(CustomerRequestModel customer)
{
if (customer == null)
{
throw new ArgumentNullException(nameof(CustomerRequestModel));
}
var mappedCustomer = _mapper.Map <CustomerRequestModel, Customer>(customer);
await _customerContext.Customers.AddAsync(mappedCustomer);
_customerContext.SaveChanges();
}
public async Task <IActionResult> Put(Guid id, [FromBody] CustomerRequestModel value)
{
if (ModelState.IsValid)
{
value.Id = id;
var entry = _mapper.Map <CustomerRequestModel, Customer>(value);
_databaseContext.Entry(entry).State = EntityState.Modified;
await _databaseContext.SaveChangesAsync();
return(Ok());
}
return(BadRequest()); //TODO Specify errors
}
public async Task <IActionResult> CreateRequest([FromBody] CustomerRequestModel model)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
var userId = GetCurrentUserId <long>();
var requestResult = await this._requestService.CreateCustomerRequest(model, userId);
var saveToFeature = await this._vehicleFeatureRequestService.CreateVehicleFeatureRequest(requestResult, model.VehicleFeature.Value);
return(OkValueObject(requestResult));
}