public async Task <ZqSignResponseBase> CreateContractAsync(CreateContractRequest request)
{
const string path = "pdfTemplate";
var response = await GetResponseAsync <ZqSignResponseBase, CreateContractRequest>(path, request);
return(response);
}
public async Task GivenICreateAContractWithTheFollowingValues(Table table)
{
foreach (TableRow tableRow in table.Rows)
{
EstateDetails estateDetails = this.TestingContext.GetEstateDetails(tableRow);
String token = this.TestingContext.AccessToken;
if (String.IsNullOrEmpty(estateDetails.AccessToken) == false)
{
token = estateDetails.AccessToken;
}
String operatorName = SpecflowTableHelper.GetStringRowValue(tableRow, "OperatorName");
Guid operatorId = estateDetails.GetOperatorId(operatorName);
CreateContractRequest createContractRequest = new CreateContractRequest
{
OperatorId = operatorId,
Description = SpecflowTableHelper.GetStringRowValue(tableRow, "ContractDescription")
};
CreateContractResponse contractResponse =
await this.TestingContext.DockerHelper.EstateClient.CreateContract(token, estateDetails.EstateId, createContractRequest, CancellationToken.None);
estateDetails.AddContract(contractResponse.ContractId, createContractRequest.Description, operatorId);
}
}
public void CreateContractRequest_CanBeCreated_IsCreated()
{
CreateContractRequest createContractRequest = CreateContractRequest.Create(TestData.ContractId, TestData.EstateId, TestData.OperatorId, TestData.ContractDescription);
createContractRequest.ShouldNotBeNull();
createContractRequest.ContractId.ShouldBe(TestData.ContractId);
createContractRequest.EstateId.ShouldBe(TestData.EstateId);
createContractRequest.OperatorId.ShouldBe(TestData.OperatorId);
createContractRequest.Description.ShouldBe(TestData.ContractDescription);
}
public async Task Create_WithTestContract_CreatesContractInSystemTest()
{
// Arrange
CreateContractRequest request = Generate_CreateContractRequest();
// Act
var response = await _testClient.PostAsync("/api/contract", GetStringContent(request));
// Assert
response.StatusCode.Should().Be(HttpStatusCode.Created);
}
public void ContractRequestHandler_CreateContractRequest_IsHandled()
{
Mock <IContractDomainService> contractDomainService = new Mock <IContractDomainService>();
ContractRequestHandler handler = new ContractRequestHandler(contractDomainService.Object);
CreateContractRequest request = TestData.CreateContractRequest;
Should.NotThrow(async() =>
{
await handler.Handle(request, CancellationToken.None);
});
}
public async Task Create_InvalidContractVersion_ReturnsBadResponseTest()
{
// Arrange
CreateContractRequest request = Generate_CreateContractRequest();
request.ContractVersion = -1;
// Act
var response = await _testClient.PostAsync("/api/contract", GetStringContent(request));
// Assert
response.StatusCode.Should().Be(HttpStatusCode.BadRequest);
}
public async Task Create_ContractCreateRequest_WhenContractWithHigherVersionExists_ReturnsPreconditionFailedResponseTest()
{
// Arrange
CreateContractRequest request = Generate_CreateContractRequest();
request.ContractNumber = "Test-Contract-High";
request.ContractVersion = 2;
// Act
var response = await _testClient.PostAsync("/api/contract", GetStringContent(request));
// Assert
response.StatusCode.Should().Be(HttpStatusCode.PreconditionFailed);
}
public async Task Create_DuplicateContractCreateRequest_ReturnsConflictResponseTest()
{
// Arrange
CreateContractRequest request = Generate_CreateContractRequest();
request.ContractNumber = "Contract-Number";
request.ContractVersion = 2;
// Act
var response = await _testClient.PostAsync("/api/contract", GetStringContent(request));
// Assert
response.StatusCode.Should().Be(HttpStatusCode.Conflict);
}
public async Task CreateContractWithExistedContractIdTest()
{
var request = new CreateContractRequest
{
TemplateId = "bf4a24f22da44afaba254918febd7ce9",
ContractId = "201809131827",
ContractVal = "{'jsonVal':[{'测试':'','2':'','3':'','4':'','5':'','6':'','7':'','8':'','9':'','10':'','Signer1':'2018091316200001','Signer2':'2018091316200002','承租方':'张三','12':'','13':'','14':'','15':'','16':'','17':'','出租方':'李四','18':'','19':'','20':''}]}",
Name = "合同"
};
var response = await Service.CreateContractAsync(request);
Assert.NotNull(response);
Assert.Equal(ErrorCode.ContractIdExisted, response.Code);
}
private CreateContractRequest Generate_CreateContractRequest()
{
DateTime startDate = new DateTime(2021, 4, 1);
startDate = DateTime.SpecifyKind(startDate, DateTimeKind.Utc);
DateTime endDate = new DateTime(2022, 3, 31);
endDate = DateTime.SpecifyKind(endDate, DateTimeKind.Utc);
var request = new CreateContractRequest()
{
UKPRN = 12345678,
Title = "Test contract title",
ContractNumber = "Test123",
ContractVersion = 1,
Value = 1000m,
FundingType = ContractFundingType.Unknown,
Year = "2021 to 2030",
Type = ContractType.ConditionsOfFundingGrant,
ParentContractNumber = null,
StartDate = startDate,
EndDate = endDate,
AmendmentType = ContractAmendmentType.None,
ContractAllocationNumber = null,
FirstCensusDateId = null,
SecondCensusDateId = null,
CreatedBy = "Feed",
ContractContent = new CreateContractRequestDocument()
{
Content = new byte[20],
Size = 20,
FileName = "Test file"
},
PageCount = 0,
ContractData = BlobHelper.BlobName,
ContractFundingStreamPeriodCodes = new CreateContractCode[] { new CreateContractCode()
{
Code = "Test"
} }
};
return(request);
}
public bool Add(Contract el)
{
IRequest request = new CreateContractRequest(el);
try
{
using (var connection = new SqlConnection(connectionString))
{
connection.Open();
using (var transaction = connection.BeginTransaction())
{
connection.Execute(request.Sql, transaction: transaction);
transaction.Commit();
}
}
}
catch (Exception e)
{
return(false);
}
return(true);
}
/// <summary>
/// Creates the contract.
/// </summary>
/// <param name="accessToken">The access token.</param>
/// <param name="estateId">The estate identifier.</param>
/// <param name="createContractRequest">The create contract request.</param>
/// <param name="cancellationToken">The cancellation token.</param>
/// <returns></returns>
public async Task <CreateContractResponse> CreateContract(String accessToken,
Guid estateId,
CreateContractRequest createContractRequest,
CancellationToken cancellationToken)
{
CreateContractResponse response = null;
String requestUri = this.BuildRequestUrl($"/api/estates/{estateId}/contracts/");
try
{
String requestSerialised = JsonConvert.SerializeObject(createContractRequest);
StringContent httpContent = new StringContent(requestSerialised, Encoding.UTF8, "application/json");
// Add the access token to the client headers
this.HttpClient.DefaultRequestHeaders.Authorization = new AuthenticationHeaderValue("Bearer", accessToken);
// Make the Http Call here
HttpResponseMessage httpResponse = await this.HttpClient.PostAsync(requestUri, httpContent, cancellationToken);
// Process the response
String content = await this.HandleResponse(httpResponse, cancellationToken);
// call was successful so now deserialise the body to the response object
response = JsonConvert.DeserializeObject <CreateContractResponse>(content);
}
catch (Exception ex)
{
// An exception has occurred, add some additional information to the message
Exception exception = new Exception($"Error creating contract [{createContractRequest.Description}] for estate {estateId}.", ex);
throw exception;
}
return(response);
}
/// <inheritdoc/>
public async Task CreateAsync(CreateContractRequest request)
{
await _semaphoreOnEntity.WaitAsync(request.ContractNumber).ConfigureAwait(false);
try
{
_logger.LogInformation($"[{nameof(CreateAsync)}] Creating new contract [{request.ContractNumber}] version [{request.ContractVersion}] for [{request.UKPRN}].");
var existing = await _repository.GetByContractNumberAsync(request.ContractNumber);
_contractValidator.ValidateForNewContract(request, existing);
var newContract = _mapper.Map <Repository.DataModels.Contract>(request);
newContract.LastUpdatedAt = newContract.CreatedAt = DateTime.UtcNow;
// For amendment type notification the default status has to be approved
// For None and Variation, it should be published to provider
if (request.AmendmentType == ContractAmendmentType.Notfication)
{
newContract.Status = (int)ContractStatus.Approved;
newContract.SignedOn = request.SignedOn.Value.Date;
newContract.SignedBy = "Feed";
newContract.SignedByDisplayName = "Feed";
}
else if (request.AmendmentType == ContractAmendmentType.None || request.AmendmentType == ContractAmendmentType.Variation)
{
newContract.Status = (int)ContractStatus.PublishedToProvider;
}
await _contractDocumentService.UpsertOriginalContractXmlAsync(newContract, new ContractRequest()
{
FileName = request.ContractData, ContractNumber = request.ContractNumber, ContractVersion = request.ContractVersion
});
await _repository.CreateAsync(newContract);
var updatedContractStatusResponse = new UpdatedContractStatusResponse
{
Id = newContract.Id,
ContractNumber = newContract.ContractNumber,
ContractVersion = newContract.ContractVersion,
Ukprn = newContract.Ukprn,
NewStatus = (ContractStatus)newContract.Status,
Action = ActionType.ContractCreated,
AmendmentType = request.AmendmentType
};
_logger.LogInformation($"[{nameof(CreateAsync)}] Contract [{newContract.ContractNumber}] version [{newContract.ContractVersion}] has been created for [{newContract.Ukprn}].");
// Update operations to existing records can be done outside the semaphore
if (request.AmendmentType == ContractAmendmentType.Variation || request.AmendmentType == ContractAmendmentType.None)
{
var statuses = new int[]
{
(int)ContractStatus.PublishedToProvider
};
await ReplaceContractsWithGivenStatuses(existing, statuses);
}
else if (request.AmendmentType == ContractAmendmentType.Notfication)
{
var statuses = new int[]
{
(int)ContractStatus.Approved,
(int)ContractStatus.ApprovedWaitingConfirmation,
(int)ContractStatus.PublishedToProvider
};
await ReplaceContractsWithGivenStatuses(existing, statuses);
}
await _mediator.Publish(updatedContractStatusResponse);
}
finally
{
_semaphoreOnEntity.Release(request.ContractNumber);
}
}
