public async Task <SaveCustomerResponse> UpdateAsync(long id, SaveCustomerRequest request)
{
var existing = await repository.GetAsync(id);
if (existing == null)
{
throw new NotFoundException();
}
if (existing.IsDeleted)
{
throw new GoneException();
}
Entities.Customer customer = new Entities.Customer
{
Id = id,
Name = request.Name,
SourceId = request.SourceId,
IndustryCodes = request.IndustryCodes,
UpdatedBy = await identityResolver.GetUserNameAsync(),
Updated = DateTime.UtcNow,
Created = existing.Created,
CreatedBy = existing.CreatedBy
};
var resultId = await repository.UpdateAsync(customer);
return(new SaveCustomerResponse
{
Id = resultId
});
}
public async Task UpdateAsync_Sets_Updated_Audit_Columns()
{
// arrange
var scope = new DefaultScope();
const long expectedId = 12L;
SaveCustomerRequest request = new SaveCustomerRequest
{
IndustryCodes = new List <string> {
"234"
},
Name = "notacustomer",
SourceId = 3
};
scope.CustomerRepositoryMock.Setup(x => x.GetAsync(expectedId)).ReturnsAsync(new Customer {
Id = expectedId, Updated = DateTimeOffset.MinValue, UpdatedBy = "franklin"
});
scope.CustomerRepositoryMock.Setup(x => x.UpdateAsync(It.Is <Customer>(
c => c.Updated > DateTimeOffset.MinValue &&
c.UpdatedBy == DefaultScope.UserName
))).ReturnsAsync(expectedId);
// act
var result = await scope.InstanceUnderTest.UpdateAsync(expectedId, request);
// assert
Assert.AreEqual(expectedId, result.Id);
}
public async Task UpdateAsync_Delegates_To_Repository()
{
// arrange
var scope = new DefaultScope();
const long expectedId = 12L;
SaveCustomerRequest request = new SaveCustomerRequest
{
IndustryCodes = new List <string> {
"234"
},
Name = "notacustomer",
SourceId = 3
};
scope.CustomerRepositoryMock.Setup(x => x.GetAsync(expectedId)).ReturnsAsync(new Customer {
Id = expectedId
});
scope.CustomerRepositoryMock.Setup(x => x.UpdateAsync(It.Is <Customer>(
c => c.Id == expectedId &&
c.IndustryCodes.First() == request.IndustryCodes.First() &&
c.Name == request.Name &&
c.SourceId == request.SourceId
))).ReturnsAsync(expectedId);
// act
var result = await scope.InstanceUnderTest.UpdateAsync(expectedId, request);
// assert
Assert.AreEqual(expectedId, result.Id);
}
public async Task UpdateCustomer_Returns_Location_If_Successful()
{
// arrange
var scope = new DefaultScope();
var expectedId = 12L;
var saveCustomerRequest = new SaveCustomerRequest()
{
Name = "good enough"
};
var saveCustomerResponse = new SaveCustomerResponse
{
Id = expectedId
};
scope.UpdateCustomerMock.Setup(x => x.UpdateAsync(expectedId, saveCustomerRequest)).ReturnsAsync(saveCustomerResponse);
scope.SetupUrlHelper(expectedId);
// act
var result = await scope.InstanceUnderTest.PutAsync(expectedId, saveCustomerRequest);
// assert
Assert.IsTrue(result.Value.Links.First().Href.EndsWith(expectedId.ToString()));
Assert.AreEqual("self", result.Value.Links.First().Rel);
Assert.AreEqual("GET", result.Value.Links.First().Method);
}
public async Task <ActionResult> Update(long id, [FromBody] SaveCustomerRequest entity)
{
try
{
var customer = await context.Customers
.AsNoTracking()
.SingleOrDefaultAsync(a => a.Id == id);
if (customer == null)
{
return(NotFound(id));
}
customer = mapper.Map <Customer>(entity);
context.Update(customer);
await context.SaveChangesAsync();
return(StatusCode(StatusCodes.Status204NoContent));
}
catch (DbUpdateConcurrencyException concurrencyEx)
{
logger.LogError(concurrencyEx.Message);
return(StatusCode(StatusCodes.Status409Conflict, Constants.ErrorMessages.ConcurrencyErrorMessage));
}
catch (Exception ex)
{
logger.LogError(ex.Message);
return(StatusCode(StatusCodes.Status500InternalServerError));
}
}
public async Task <ActionResult <SaveCustomerLinkedResponse> > PostAsync([FromBody] SaveCustomerRequest value)
{
var response = await addCustomer.AddAsync(value);
var result = CreateSaveCustomerLinkedResponse(response);
return(result);
}
public override async Task <SaveCustomerResponse> SaveCustomer(SaveCustomerRequest request, ServerCallContext context)
{
await Task.Delay(1000);
return(new SaveCustomerResponse
{
Message = $"{request.Name} {request.Surname} - {request.Mail}"
});
}
public SaveCustomerResponse SaveCustomer(SaveCustomerRequest saveCustomerRequestModel)
{
SaveCustomerResponse saveCustomerResponseModel = new SaveCustomerResponse();
Customer customer = new Customer();
customer.Added_By = saveCustomerRequestModel.Added_By;
customer.Address_Line_2 = saveCustomerRequestModel.Address_Line_2;
customer.Address_Line_3 = saveCustomerRequestModel.Address_Line_3;
customer.Address_Line_4 = saveCustomerRequestModel.Address_Line_4;
customer.Address_Type = saveCustomerRequestModel.Address_Type;
customer.anniversary_date = saveCustomerRequestModel.anniversary_date;
customer.Company_Name = saveCustomerRequestModel.Company_Name;
//customer. = saveCustomerRequestModel.Cross_Street_Code;
customer.date_of_birth = saveCustomerRequestModel.date_of_birth;
//customer. = saveCustomerRequestModel.Finance_Charge_Rate;
customer.First_Order_Date = saveCustomerRequestModel.First_Order_Date;
customer.Last_Order_Date = saveCustomerRequestModel.Last_Order_Date;
customer.Location_Code = saveCustomerRequestModel.Location_Code;
customer.Name = saveCustomerRequestModel.Name;
customer.Phone_Ext = saveCustomerRequestModel.Phone_Ext;
customer.Phone_Number = saveCustomerRequestModel.Phone_Number;
customer.Postal_Code = saveCustomerRequestModel.Postal_Code;
//customer.stre = saveCustomerRequestModel.Street_Code;
customer.Street_Number = saveCustomerRequestModel.Street_Number;
customer.Suite = saveCustomerRequestModel.Suite;
customer.Tax_Exempt1 = saveCustomerRequestModel.Tax_Exempt1;
customer.Tax_Exempt2 = saveCustomerRequestModel.Tax_Exempt2;
customer.Tax_Exempt3 = saveCustomerRequestModel.Tax_Exempt3;
customer.Tax_Exempt4 = saveCustomerRequestModel.Tax_Exempt4;
customer.Tax_ID1 = saveCustomerRequestModel.Tax_ID1;
customer.Tax_ID2 = saveCustomerRequestModel.Tax_ID2;
customer.Tax_ID3 = saveCustomerRequestModel.Tax_ID3;
customer.Tax_ID4 = saveCustomerRequestModel.Tax_ID4;
customer.Customer_Code = saveCustomerRequestModel.Customer_Code;
int returnId = _customerRepo.SaveCustomer(customer);
if (returnId > 0)
{
saveCustomerResponseModel.Result = new SaveCustomerResult();
saveCustomerResponseModel.Result.ResponseStatus = CustomMessage.SuccessMessage;
saveCustomerResponseModel.Result.ResponseStatusCode = CustomMessage.SuccessCode;
}
else
{
saveCustomerResponseModel.Result = new SaveCustomerResult();
saveCustomerResponseModel.Result.ResponseStatus = CustomMessage.FailureMessage;
saveCustomerResponseModel.Result.ResponseStatusCode = CustomMessage.FailureMessage;
}
return(saveCustomerResponseModel);
}
public async Task <ActionResult <Guid> > Save([FromBody] SaveCustomerRequest request)
{
var validator = new SaveCustomerValidator();
var validationResult = await validator.ValidateAsync(request);
if (!validationResult.IsValid)
{
return(BadRequest(validationResult.Errors));
}
return(Created("", await _customerService.Add(request)));
}
/// <summary>
/// Add.
/// </summary>
/// <param name="request"></param>
/// <returns></returns>
public async Task <Guid> Add(SaveCustomerRequest request)
{
Customer customer = MapperConfiguration.Mapper.Map <Customer>(request);
customer.CreatedBy = Guid.NewGuid();
customer.CreatedDate = DateTime.UtcNow;
await _unitOfWork.Customers.AddAsync(customer);
await _unitOfWork.SaveChangesAsync();
return(customer.Id);
}
public async Task <CustomerDTO> SaveCustomer(PurchaseModel model, SiteUser user)
{
var request = new SaveCustomerRequest();
var existingCustomerDTO = await GetCustomer(user.CustomerId);
existingCustomerDTO = mapper.Map <SiteUser, CustomerDTO>(user, existingCustomerDTO);
existingCustomerDTO = mapper.Map(model.Billing, existingCustomerDTO);
request.Customer = existingCustomerDTO;
var response = await client.Put <SaveCustomerRequest, SaveCustomerResponse>(routingConfig.CustomerService.URL,
routingConfig.CustomerService.Update, request, HeaderAccept.Json);
return(response.Customer);
}
public async Task <string> SaveCustomerAsync(Customer customer)
{
SaveCustomerRequest request = new SaveCustomerRequest
{
Name = customer.Name,
Surname = customer.Surname,
Mail = customer.Mail
};
var channel = GrpcChannel.ForAddress("https://localhost:5001");
var client = new CustomersEndpoint.CustomersEndpointClient(channel);
var response = await client.SaveCustomerAsync(request);
return(response.Message);
}
public async Task <ActionResult <SaveCustomerRequest> > Create([FromBody] SaveCustomerRequest entity)
{
try
{
var customer = mapper.Map <Customer>(entity);
await context.Customers.AddAsync(customer);
await context.SaveChangesAsync();
return(CreatedAtRoute(nameof(GetCustomerById), new { id = customer.Id }, entity));
}
catch (Exception e)
{
logger.LogError(e.Message);
return(StatusCode(StatusCodes.Status500InternalServerError));
}
}
public async Task <SaveCustomerResponse> Update(SaveCustomerRequest request)
{
var customer = builder.Build(request.Customer);
customer.UpdateAddress(request.Customer.Address1, request.Customer.Address2, request.Customer.ZipCode,
request.Customer.Country, request.Customer.StateAbbreviation);
customer = await this.repo.SaveAsync(customer);
var dto = mapper.Map <CustomerDTO>(customer);
var response = mapper.Map <SaveCustomerResponse>(dto);
response.ResponseAction = ResponseAction.Updated;
return(response);
}
public async Task UpdateCustomer_Returns_409_If_Deleted()
{
// arrange
var scope = new DefaultScope();
var expectedId = 12L;
var saveCustomerRequest = new SaveCustomerRequest()
{
Name = "good enough"
};
scope.UpdateCustomerMock.Setup(x => x.UpdateAsync(expectedId, saveCustomerRequest)).ThrowsAsync(new GoneException());
// actd
var result = await scope.InstanceUnderTest.PutAsync(expectedId, saveCustomerRequest);
// assert
Assert.AreEqual(StatusCodes.Status410Gone, ((StatusCodeResult)result.Result).StatusCode);
}
public async Task UpdateCustomer_Returns_404_If_NotFound()
{
// arrange
var scope = new DefaultScope();
var expectedId = 12L;
var saveCustomerRequest = new SaveCustomerRequest()
{
Name = "good enough"
};
scope.UpdateCustomerMock.Setup(x => x.UpdateAsync(expectedId, saveCustomerRequest)).ThrowsAsync(new NotFoundException());
// act
var result = await scope.InstanceUnderTest.PutAsync(expectedId, saveCustomerRequest);
// assert
Assert.IsInstanceOfType(result.Result, typeof(NotFoundResult));
}
public async Task UpdateAsync_Throws_NotFound_If_Doesnt_Exist()
{
// arrange
var scope = new DefaultScope();
const long expectedId = 12L;
SaveCustomerRequest request = new SaveCustomerRequest
{
IndustryCodes = new List <string> {
"234"
},
Name = "notacustomer",
SourceId = 3
};
scope.CustomerRepositoryMock.Setup(x => x.GetAsync(expectedId)).ReturnsAsync(null as Customer);
// act and assert
await Assert.ThrowsExceptionAsync <NotFoundException>(() => scope.InstanceUnderTest.UpdateAsync(expectedId, request));
}
public async Task <SaveCustomerResponse> AddAsync(SaveCustomerRequest request)
{
Entities.Customer customer = new Entities.Customer
{
Name = request.Name,
SourceId = request.SourceId,
IndustryCodes = request.IndustryCodes,
CreatedBy = await identityResolver.GetUserNameAsync(),
Created = DateTime.UtcNow
};
customer.Updated = customer.Created;
customer.UpdatedBy = customer.CreatedBy;
var id = await repository.AddAsync(customer);
return(new SaveCustomerResponse
{
Id = id
});
}
public async Task <IActionResult> Update([FromBody] SaveCustomerRequest request)
{
var client = getClientFactory.Create <ISaveCustomerRequest, SaveCustomerResponse>();
return(await HandleAsync(async() => await client.Request(request, CancellationToken.None)));
}
public async Task <ActionResult <SaveCustomerLinkedResponse> > PutAsync(long id, [FromBody] SaveCustomerRequest value)
{
try
{
var response = await updateCustomer.UpdateAsync(id, value); var result = CreateSaveCustomerLinkedResponse(response);
return(result);
}
catch (GoneException)
{
return(StatusCode(StatusCodes.Status410Gone));
}
catch (NotFoundException)
{
return(NotFound());
}
}
public async Task <IActionResult> Update([FromBody] SaveCustomerRequest request)
{
return(await HandleAsync(async() => await this.workflow.Update(request)));
}
public SaveCustomerResponse SaveCustomer(SaveCustomerRequest saveCustomerRequestModel)
{
return(_customerService.SaveCustomer(saveCustomerRequestModel));
}
