public ContractResponse ContractApplicationSend(ContractRequest request)
{
var result = new ContractResponse();
var query = new ContractApplicationSend.Query {
Request = request, Responce = result
};
_mediator.Send(query).Wait();
return(result);
}
public async Task <JsonResult> Put(int id, [FromBody] ContractRequest <AddUpdateProductRequest> request)
{
var response = await Task.Run(() =>
{
var productsResponse = _productService.UpdateProduct(request);
return(Json(productsResponse));
});
return(response);
}
public async Task InsertContract()
{
var bankAccount = new BankAccount
{
Branch = "1144",
Account = "13341",
AccountDigit = "X5",
AccountType = BankAccountType.CC,
Ispb = "12345678",
DocumentType = DocumentType.CNPJ,
DocumentNumber = "39624514000153"
};
var ctEspecification = new ContractSpecification
{
ExpectedSettlementDate = DateTime.Parse("2021-01-01T05:00:00Z"),
OriginalAssetHolderDocumentType = DocumentType.CNPJ,
OriginalAssetHolder = "39624514000153",
ReceivableDebtor = "74190072000185",
PaymentScheme = "VCC",
EffectValue = 100L
};
var ctEspecifications = new List <ContractSpecification>
{
ctEspecification
};
var ctItem = new Contract
{
Reference = "CT_01",
ContractDueDate = DateTime.Parse("2021-01-01T05:00:00Z"),
AssetHolderDocumentType = DocumentType.CNPJ,
AssetHolder = "39624514000153",
ContractUniqueIdentifier = "CT_01",
SignatureDate = DateTime.Parse("2021-01-01T05:00:00Z"),
EffectType = EffectType.WARRANTY,
WarrantyType = WarrantyType.FIDUCIARY,
WarrantyAmount = 100L,
BalanceDue = 100L,
DivisionMethod = DivisionMethodType.FIXEDAMOUNT,
EffectStrategy = EffectStrategy.SPECIFIC,
PercentageValue = 10,
BankAccount = bankAccount,
ContractSpecifications = ctEspecifications
};
var ctItems = new List <Contract>
{
ctItem
};
var contractInput = new ContractRequest
{
Contracts = ctItems
};
var result = await _contractService.InsertContract(contractInput);
Print(result);
}
public ActionResult Put(int id, [FromBody] ContractRequest <AddUpdatePatientRequest> request)
{
if (id != request.Data.Patient.Id)
{
return(BadRequest());
}
var patientsResponse = _patientService.Add(request);
return(Json(patientsResponse));
}
public async Task <ActionResult> Post([FromBody] ContractRequest request)
{
if (request == null)
{
BadRequest();
}
await _contractRepository.CreateContract(request);
return(Created("api/Contracts", null));
}
private RestRequest CreateRequest <T>(ContractRequest <T> request, string url, RestSharp.Method method)
where T : class
{
var json = Newtonsoft.Json.JsonConvert.SerializeObject(request);
var requestService = new RestRequest(url, method);
requestService.AddHeader("Cache-Control", "no-cache");
requestService.AddHeader("Content-Type", "application/json; charset-utf-8");
requestService.AddParameter("application/json", json, ParameterType.RequestBody);
return(requestService);
}
public IActionResult submitcontractobject([FromBody] ContractRequest request)
{
var metric = Metrics.CreateCounter("contract_api",
"Data about Contract API Data", new CounterConfiguration
{
LabelNames = new[] { "method", "data" }
});
metric.WithLabels(HttpContext.Request.Method, JsonConvert.SerializeObject(request));
return(Ok());
}
public async Task ApproveManuallyAsync_ReturnsExpectedResult_DocumentTest()
{
//Arrange
SetAsposeLicense();
var signer = $"hand and approved by ESFA";
string baseUrl = $"https://localhost:5001";
SetMapperHelper();
var contracts = GetDataModel_ForManualApprove();
var request = new ContractRequest()
{
ContractNumber = "main-0001", ContractVersion = 1, FileName = BlobHelper.BlobName
};
ILoggerAdapter <ContractService> logger = new LoggerAdapter <ContractService>(new Logger <ContractService>(new LoggerFactory()));
MockAuditService();
var contractRepo = await GetContractRepository(contracts);
var uriService = new UriService(baseUrl);
var asposeDocumentManagementContractService = GetDocumentService();
var contractValidationService = GetContractValidationService();
var mediator = BuildMediator();
var contractDocumentService = BuildContractDocumentService();
var service = new ContractService(contractRepo, _mapper, uriService, logger, _mockAuditService.Object, _semaphoreOnEntity, asposeDocumentManagementContractService, contractValidationService, mediator, contractDocumentService);
//Act
var beforeUpdate = await contractRepo.GetByContractNumberAndVersionWithIncludesAsync(request.ContractNumber, request.ContractVersion, ContractDataEntityInclude.Datas | ContractDataEntityInclude.Content);
// assigning to a new variable before update because this is an in memory db the
// update will update the object.
var actualBeforeUpdate = GetClonedContract(beforeUpdate);
var contract = await service.ApproveManuallyAsync(request);
var afterUpdate = await contractRepo.GetByContractNumberAndVersionWithIncludesAsync(request.ContractNumber, request.ContractVersion, ContractDataEntityInclude.Datas);
//Assert
contract.Should().NotBeNull();
actualBeforeUpdate.Status.Should().Be((int)ContractStatus.PublishedToProvider);
afterUpdate.Status.Should().Be((int)ContractStatus.Approved);
afterUpdate.ContractContent.Content.ShouldHaveSignedPage("testDoc", signer, afterUpdate.SignedOn.Value, true, afterUpdate.ContractContent.FileName, ContractFundingType.CityDeals, null);
afterUpdate.ContractData.OriginalContractXml.Should().Be(BlobHelper.BlobSampleContent);
}
public async Task <ContractResponse> InsertContract(ContractRequest contract)
{
var request = new RestRequest($"{Options.BaseUrl}/{_pathBase}", DataFormat.Json)
{
Method = Method.POST
};
request.AddJsonBody(contract);
return(await GetPipeline <ContractResponse>().Execute(new Commands.RequestCommand <ContractResponse>()
{
Model = contract,
RestRequest = request,
Profile = _baseProfile
}).MapResponse());
}
public IActionResult submitcontract([FromBody] ContractRequest request)
{
var response = contractApplication.GenerateRandomResponse(request);
valueHistogram.Observe((double)response.contractValue);
// summaryMetric.Observe((double)response.contractValue);
// gaugeMetric.WithLabels(response.contractValue.ToString());
// valueCounter.WithLabels(response.contractValue.ToString());
contractsCounter.WithLabels(response.contractId.ToString()).Inc();
return(Ok());
}
public ContractResponse <GetProductResponse> UpdateProduct(ContractRequest <AddUpdateProductRequest> request)
{
ContractResponse <GetProductResponse> response;
try
{
var model = request.Data.Product.ToProduct();
var brokenRules = model.GetBrokenRules().ToList();
if (brokenRules.Any())
{
var message = new GetProductResponse
{
Product = request.Data.Product,
};
response = ContractUtil.CreateInvalidResponse <GetProductResponse>(brokenRules, message);
}
else
{
var oldProduct = _productRepository.FindById(request.Data.Product.Id);
if (string.IsNullOrEmpty(request?.Data?.Product?.Image))
{
model.Image = oldProduct.Image;
}
_productRepository.Update(model);
var product = model.ToProductView();
var message = new GetProductResponse
{
Product = product
};
response = ContractUtil.CreateResponse <GetProductResponse, AddUpdateProductRequest>(request, message);
}
}
catch (Exception ex)
{
_logger.LogError(20, ex, ex.Message);
return(ContractUtil.CreateInvalidResponse <GetProductResponse>(ex));
}
return(response);
}
/// <inheritdoc/>
public async Task <UpdatedContractStatusResponse> ApproveManuallyAsync(ContractRequest request)
{
_logger.LogInformation($"[{nameof(ApproveManuallyAsync)}] called with contract number: {request.ContractNumber} and contract version {request.ContractVersion}.");
UpdatedContractStatusResponse updatedContractStatusResponse = null;
var manuallyApproved = true;
var newContractStatus = ContractStatus.Approved;
var contract = await _repository.GetByContractNumberAndVersionWithIncludesAsync(request.ContractNumber, request.ContractVersion, ContractDataEntityInclude.Datas | ContractDataEntityInclude.Content);
_contractValidator.Validate(contract, request, c => c.ContractContent != null);
_contractValidator.ValidateStatusChange(contract, newContractStatus, manuallyApproved);
updatedContractStatusResponse = new UpdatedContractStatusResponse
{
Id = contract.Id,
ContractNumber = contract.ContractNumber,
ContractVersion = contract.ContractVersion,
Ukprn = contract.Ukprn,
Status = (ContractStatus)contract.Status,
Action = ActionType.ContractManualApproval
};
var contractRefernce = contract.ContractContent.FileName.Replace(".pdf", string.Empty);
var signer = $"hand and approved by ESFA";
var updatedDate = DateTime.UtcNow;
var signedContractDocument = _documentService.AddSignedDocumentPage(contract.ContractContent.Content, contractRefernce, signer, updatedDate, manuallyApproved, (ContractFundingType)contract.FundingType);
contract.ContractContent.Content = signedContractDocument;
contract.ContractContent.Size = signedContractDocument.Length;
contract.Status = (int)newContractStatus;
contract.SignedOn = updatedDate;
contract.SignedBy = signer;
contract.SignedByDisplayName = signer;
contract.WasManuallyApproved = manuallyApproved;
await _contractDocumentService.UpsertOriginalContractXmlAsync(contract, request);
await _repository.UpdateContractAsync(contract);
updatedContractStatusResponse.NewStatus = (ContractStatus)contract.Status;
await _mediator.Publish(updatedContractStatusResponse);
return(updatedContractStatusResponse);
}
public ContractResponse <UserGetResponse> GetUser(ContractRequest <UserGetRequest> request)
{
User user;
if (string.IsNullOrEmpty(request.Data.UserName))
{
user = _userRepository.First(u => u.Id == request.Data.Id);
}
else
{
user = _userRepository.First(u => u.UserName.Equals(request.Data.UserName, StringComparison.InvariantCultureIgnoreCase));
}
return(ContractUtil.CreateResponse(request, new UserGetResponse
{
User = user?.ToUserView()
}));
}
public ContractResponse <GetProductResponse> UpdateProduct(ContractRequest <AddUpdateProductRequest> request)
{
ContractResponse <GetProductResponse> response;
try
{
var requestService = CreateRequest(request, $"products/{request.Data.Product.Id}", Method.PUT);
var responseService = _client.Execute <ContractResponse <GetProductResponse> >(requestService);
response = responseService.Data;
}
catch (Exception ex)
{
_logger.LogError(20, ex, ex.Message);
response = ContractUtil.CreateInvalidResponse <GetProductResponse>(ex);
}
return(response);
}
public ContractResponse <GetProductResponse> AddProduct(ContractRequest <AddUpdateProductRequest> request)
{
ContractResponse <GetProductResponse> response;
try
{
var model = request.Data.Product.ToProduct();
var brokenRules = model.GetBrokenRules().ToList();
if (brokenRules.Any())
{
var message = new GetProductResponse
{
Product = request.Data.Product,
};
response = ContractUtil.CreateInvalidResponse <GetProductResponse>(brokenRules, message);
}
else
{
_productRepository.Add(model);
var product = model.ToProductView();
var message = new GetProductResponse
{
Product = product
};
response = ContractUtil.CreateResponse <GetProductResponse, AddUpdateProductRequest>(request, message);
}
}
catch (Exception ex)
{
_logger.LogError(20, ex, ex.Message);
return(ContractUtil.CreateInvalidResponse <GetProductResponse>(ex));
}
return(response);
}
public ContractResponse <PatientListGetResponse> Get(ContractRequest <PatientGetRequest> request)
{
ContractResponse <PatientListGetResponse> response;
try
{
var model = _patientRepository.FindBy(e => e.Id == request.Data.Id);
var modelListResponse = model.ToPatientViewList();
response = ContractUtil.CreateResponse(request, new PatientListGetResponse {
Patients = modelListResponse.ToList()
});
}
catch (Exception ex)
{
_logger.LogError(20, ex, ex.Message);
response = ContractUtil.CreateInvalidResponse <PatientListGetResponse>(ex);
}
return(response);
}
public ContractResponse <GetAllProductsResponse> GetAllProducts(ContractRequest <BaseRequest> request)
{
ContractResponse <GetAllProductsResponse> response;
try
{
var userList = _productRepository.FindAll();
var modelResponse = userList.ToProductViewList();
response = ContractUtil.CreateResponse(request, new GetAllProductsResponse {
Products = modelResponse
});
}
catch (Exception ex)
{
_logger.LogError(20, ex, ex.Message);
response = ContractUtil.CreateInvalidResponse <GetAllProductsResponse>(ex);
}
return(response);
}
public ContractResponse <GetProductResponse> GetProduct(ContractRequest <GetProductRequest> request)
{
ContractResponse <GetProductResponse> response;
try
{
var model = _productRepository.FindById(request.Data.Id);
var modelResponse = model?.ToProductView();
response = ContractUtil.CreateResponse(request, new GetProductResponse {
Product = modelResponse
});
}
catch (Exception ex)
{
_logger.LogError(20, ex, ex.Message);
response = ContractUtil.CreateInvalidResponse <GetProductResponse>(ex);
}
return(response);
}
public ContractResponse <AppointmentListGetResponse> GetAll(ContractRequest <BaseRequest> request)
{
ContractResponse <AppointmentListGetResponse> response;
try
{
var modelList = _appointmentRepository.GetAll();
var modelListResponse = modelList.ToAppointmentViewList();
response = ContractUtil.CreateResponse(request, new AppointmentListGetResponse {
Appointments = modelListResponse.ToList()
});
}
catch (Exception ex)
{
_logger.LogError(20, ex, ex.Message);
response = ContractUtil.CreateInvalidResponse <AppointmentListGetResponse>(ex);
}
return(response);
}
public ContractResponse <BaseResponse> RemoveProduct(ContractRequest <GetProductRequest> request)
{
ContractResponse <BaseResponse> response;
try
{
var model = new Product {
Id = request.Data.Id
};
_productRepository.Remove(model);
response = ContractUtil.CreateResponse(request, new BaseResponse());
}
catch (Exception ex)
{
_logger.LogError(20, ex, ex.Message);
response = ContractUtil.CreateInvalidResponse <BaseResponse>(ex);
}
return(response);
}
private async Task <string> GetDocumentContentAsync(ContractRequest request)
{
_logger.LogInformation($"[{nameof(GetDocumentContentAsync)}] called with contract number: {request.ContractNumber} and contract version: {request.ContractVersion} and file name: {request.FileName} ");
string documentContent = null;
try
{
BlobClient blob = _blobContainerClient.GetBlobClient(request.FileName);
if (!blob.Exists())
{
throw new BlobException("Blob name does not exist.");
}
var response = await blob.DownloadAsync();
using var reader = new StreamReader(response.Value.Content);
documentContent = reader.ReadToEnd();
}
catch (BlobException ex)
{
_logger.LogError($"[{nameof(GetDocumentContentAsync)}] called with contract number: {request.ContractNumber}, contract version: {request.ContractVersion} and file name: {request.FileName}. Failed with {ex.Message}.");
throw new BlobException(request.ContractNumber, request.ContractVersion, request.FileName, ex);
}
catch (Exception ex)
{
_logger.LogError($"[{nameof(GetDocumentContentAsync)}] called with contract number: {request.ContractNumber}, contract version: {request.ContractVersion} and file name: {request.FileName}. Failed with {ex.Message}.");
throw new BlobException(request.ContractNumber, request.ContractVersion, request.FileName, ex);
}
if (string.IsNullOrWhiteSpace(documentContent))
{
_logger.LogError($"[{nameof(GetDocumentContentAsync)}] called with contract number: {request.ContractNumber}, contract version: {request.ContractVersion} and file name: {request.FileName}. Failed because blob filename has no content.");
throw new BlobNoContentException(request.ContractNumber, request.ContractVersion, request.FileName);
}
return(documentContent);
}
/// <summary> /// Approve a contract as middleman. /// Requires <see cref="APIPermission.CONTRACTS" /> /// <summary> /// <param name="contractId">The id of the contract.</param> public ContractResult ContractMiddlemanApprove(int contractId) => ContractRequest.MiddlemanApprove(Client, contractId);
/// <summary> /// Cancel as contract (spawned from contract template) as Vendor. /// Requires <see cref="APIPermission.CONTRACTS" /> /// <summary> /// <param name="contractId">The id of the contract.</param> public ContractResult ContractVendorCancel(int contractId) => ContractRequest.VendorCancel(Client, contractId);
public ContractUpdateResponse Put(ContractRequest _request)
{
RestAPITools apiTools = new RestAPITools();
return(apiTools.updateContract(_request));
}
public JsonResult Post([FromBody] ContractRequest <AddUpdatePatientRequest> request)
{
var patientsResponse = _patientService.Add(request);
return(Json(patientsResponse));
}
public ContractInsertResponse Post(ContractRequest _request)
{
RestAPITools apiTools = new RestAPITools();
return(apiTools.createContract(_request));
}
/// <summary> /// Request cancel (requires both parties to cancel). /// Requires <see cref="APIPermission.CONTRACTS" /> /// <summary> /// <param name="contractId">The id of the contract.</param> public ContractResult ContractCancel(int contractId) => ContractRequest.Cancel(Client, contractId);
/// <summary> /// Mark a contract as complete. /// Requires <see cref="APIPermission.CONTRACTS" /> /// <summary> /// <param name="contractId">The id of the contract.</param> /// <param name="txn">The transaction.</param> public ContractResult ContractComplete(int contractId, string txn = null) => ContractRequest.Complete(Client, contractId, txn);
private bool ContractMatches(ContractRequest contract, HttpRequest request)
{
return(contract.Method == request.Method && contract.Url == request.Path);
}
public async Task <ContractResponse <GetAllProductsResponse> > GetAllProducts(ContractRequest <BaseRequest> request)
{
ContractResponse <GetAllProductsResponse> response;
try
{
var requestService = CreateRequest(request, "products", Method.GET);
var responseService = await _client.ExecuteGetTaskAsync <ContractResponse <GetAllProductsResponse> >(requestService);
response = responseService.Data;
}
catch (Exception ex)
{
_logger.LogError(20, ex, ex.Message);
response = ContractUtil.CreateInvalidResponse <GetAllProductsResponse>(ex);
}
return(response);
}
