public async Task <IActionResult> CreateContract(int?id, [Bind("IdContract,IdSponsor,IdEvent,ContractValidUntil,ContractBalance")] ContractEvent contract)
{
if (id == null && id != contract.IdEvent)
{
return(NotFound());
}
var event_data = await _context.Event.FindAsync(id);
if (event_data == null)
{
return(NotFound());
}
ViewBag.eventName = event_data.EventName;
if (contract.ContractBalance < 0)
{
ModelState.AddModelError("ContractBalance", "Can't be negative balance");
}
if (contract.ContractValidUntil < DateTime.Today)
{
ModelState.AddModelError("ContractValidUntil", "Invalid date");
}
if (ModelState.IsValid)
{
contract.IdEvent = id.GetValueOrDefault();
_context.Add(contract);
await _context.SaveChangesAsync();
return(RedirectToAction("Sponsorship", "Events", new { id }));
}
ViewBag.eventId = contract.IdEvent;
ViewData["Sponsors"] = new SelectList(_context.Sponsor, "IdSponsor", "SponsorName", contract.IdSponsor);
return(View());
}
private ContractEvent DeserializeContractEvent(XmlElement contractElement, XmlNamespaceManager ns)
{
var evt = new ContractEvent();
evt.UKPRN = contractElement.GetValue <int>("c:contractor/c:ukprn", ns);
evt.ContractNumber = contractElement.GetValue <string>("c:contractNumber", ns);
evt.ContractVersion = contractElement.GetValue <int>("c:contractVersionNumber", ns);
evt.ParentContractNumber = contractElement.GetValue <string>("c:parentContractNumber", ns);
evt.Status = ParseContractStatus(contractElement.GetValue <string>("c:contractStatus/c:status", ns));
evt.ParentStatus = Enum.Parse <ContractParentStatus>(contractElement.GetValue <string>("c:contractStatus/c:parentStatus", ns));
evt.ContractPeriodValue = contractElement.GetValue <string>("c:period/c:period", ns);
evt.Value = contractElement.GetValue <decimal>("c:contractValue", ns, true);
evt.AmendmentType = Enum.Parse <ContractAmendmentType>(contractElement.GetValue <string>("c:amendmentType", ns, true, "None"));
evt.Type = contractElement.GetValue <string>("c:contractType", ns, true);
var fundingType = contractElement.GetValue <string>("c:fundingType/c:fundingTypeCode", ns);
evt.FundingType = ParseContractFundingType(fundingType);
// Start date can be null
evt.StartDate = contractElement.GetValue <DateTime?>("c:startDate", ns, true);
// End date can be null
evt.EndDate = contractElement.GetValue <DateTime?>("c:endDate", ns, true);
evt.SignedOn = contractElement.GetValue <DateTime?>("c:ContractApprovalDate", ns, true);
evt.ContractAllocations = ExtractAllocations(contractElement, ns);
return(evt);
}
private string GetFilename(FeedEntry feedEntry, ContractEvent item)
{
// Filename format : [Entry.Updated]_[ContractNumber]_v[ContractVersion]_[Entry.BookmarkId].xml
string filename = $"{feedEntry.Updated:yyyyMMddHHmmss}_{item.ContractNumber}_v{item.ContractVersion}_{item.BookmarkId}.xml";
return(filename);
}
public void ProcessSessionMessageAsync_DoesNotSetSessionStateAndThrowsException()
{
// Arrange
var expectedBodyMessage = new ContractEvent();
var dummyMessage = GetDummyMessage(expectedBodyMessage);
var initialState = new SessionWorkflowState();
var mockSession = Mock.Of <IMessageSession>(MockBehavior.Strict);
var mockLogger = Mock.Of <IContractEventProcessorLogger <IContractEventSessionManager> >(MockBehavior.Strict);
var mockProcessLog = Mock.Of <IContractEventProcessLog>(MockBehavior.Strict);
Mock.Get(mockProcessLog)
.Setup(c => c.Initialise(It.IsAny <Message>(), It.IsAny <ContractEvent>()));
var mockContractService = Mock.Of <IContractService>(MockBehavior.Strict);
Mock.Get(mockContractService)
.Setup(c => c.ProcessMessage(expectedBodyMessage))
.Throws <Exception>();
var mockStateManager = Mock.Of <IWorkflowStateManager>(MockBehavior.Strict);
Mock.Get(mockStateManager)
.Setup(s => s.GetWorkflowStateAsync(mockSession))
.ReturnsAsync(initialState)
.Verifiable();
// Act
var sessionManager = new ContractEventSessionManager(mockStateManager, mockContractService, mockLogger, GetConfiguration(), mockProcessLog);
Func <Task <SessionWorkflowState> > act = async() => await sessionManager.ProcessSessionMessageAsync(mockSession, dummyMessage);
// Assert
act.Should().Throw <Exception>();
Mock.Get(mockSession).VerifyNoOtherCalls();
Mock.Get(mockStateManager).Verify();
Mock.Get(mockContractService).Verify();
}
/// <inheritdoc/>
public string FormatPeriod(ContractEvent contractEvent)
{
string periodValue = contractEvent.ContractPeriodValue;
DateTime?startDate = contractEvent.StartDate;
DateTime?endDate = contractEvent.EndDate;
if (periodValue.Length != 4)
{
throw new ContractEventExpectationFailedException(contractEvent.BookmarkId, contractEvent.ContractNumber, contractEvent.ContractVersion, $"{nameof(contractEvent.ContractPeriodValue)} has invalid value [{contractEvent.ContractPeriodValue}]");
}
var startsWith20 = periodValue.Substring(0, 2) == "20";
if (startsWith20)
{
var startYear = startDate.HasValue ? startDate.Value.Year : (int?)null;
var endYear = endDate.HasValue ? endDate.Value.Year : (int?)null;
if (startYear == endYear)
{
return(periodValue);
}
}
return("20" + periodValue.Substring(0, 2) + " to 20" + periodValue.Substring(2, 2));
}
public void Death()
{
if (ContainsEventType(EventType.GameObjectDeath))
{
ContractEvent contractEvent = new ContractEvent(contractId, EventType.GameObjectDeath, nebulaObject);
nebulaObject.mmoWorld().OnEvent(contractEvent);
}
}
private static Data.Api.Client.Enumerations.ContractType GetContractType(ContractEvent contractEvent)
{
var contractTypes = Enum.GetValues(typeof(Enums.ContractType)).Cast <Enums.ContractType>();
//SigleOrDefault is a workaround for known issue with ContractType enumeration used by MyESF and is added here for backward compatibility only, many feed types are not supported.
//This field is not used in MyESF and should be considered for decommissioning in the future contracts database design.
return((Data.Api.Client.Enumerations.ContractType)contractTypes.SingleOrDefault(e => e.GetEnumDisplayName().Equals(contractEvent.Type, StringComparison.OrdinalIgnoreCase)));
}
public ContractFunction(string name, string nameHex, string displayName, bool isStatic, IEnumerable <ContractFunctionArg> args = null, ContractEvent contractEvent = null)
{
Name = name;
NameHex = nameHex;
DisplayName = displayName;
IsStatic = isStatic;
Args = args ?? new List <ContractFunctionArg>();
Event = contractEvent;
}
private bool EventValidType(BaseEvent evt)
{
ContractEvent contractEvent = evt as ContractEvent;
return((evt.eventType == EventType.GameObjectDeath) &&
(contractEvent != null) &&
(evt.source != null) &&
(contractEvent.contractId == id));
}
public void ProcessSessionMessageAsync_SetsSessionStateAndThrowsException()
{
// Arrange
var expectedBodyMessage = new ContractEvent();
var dummyMessage = GetDummyMessage(expectedBodyMessage, 10);
var initialState = new SessionWorkflowState();
var mockSession = Mock.Of <IMessageSession>(MockBehavior.Strict);
Mock.Get(mockSession)
.SetupGet(s => s.SessionId)
.Returns("session-id")
.Verifiable();
var mockLogger = Mock.Of <IContractEventProcessorLogger <IContractEventSessionManager> >(MockBehavior.Strict);
Mock.Get(mockLogger)
.Setup(l => l.LogWarning(It.IsAny <string>()))
.Verifiable();
var mockProcessLog = Mock.Of <IContractEventProcessLog>(MockBehavior.Strict);
Mock.Get(mockProcessLog)
.Setup(c => c.Initialise(It.IsAny <Message>(), It.IsAny <ContractEvent>()));
var mockContractService = Mock.Of <IContractService>(MockBehavior.Strict);
Mock.Get(mockContractService)
.Setup(c => c.ProcessMessage(expectedBodyMessage))
.Throws <Exception>();
var mockStateManager = Mock.Of <IWorkflowStateManager>(MockBehavior.Strict);
Mock.Get(mockStateManager)
.Setup(s => s.GetWorkflowStateAsync(mockSession))
.ReturnsAsync(initialState)
.Verifiable();
Mock.Get(mockStateManager)
.Setup(s => s.SetWorkflowStateAsync(mockSession, It.Is <SessionWorkflowState>(s => s.IsFaulted && s.FailedMessageId == dummyMessage.MessageId)))
.Returns(Task.CompletedTask)
.Verifiable();
// Act
var sessionManager = new ContractEventSessionManager(mockStateManager, mockContractService, mockLogger, GetConfiguration(), mockProcessLog);
Func <Task <SessionWorkflowState> > act = async() => await sessionManager.ProcessSessionMessageAsync(mockSession, dummyMessage);
// Assert
act.Should().Throw <Exception>();
Mock.Get(mockSession).Verify();
Mock.Get(mockStateManager).Verify();
Mock.Get(mockContractService).Verify();
Mock.Get(mockLogger).Verify();
}
static object[] GenerateRow(string parametersListCode, string name, string expected)
{
var parametersListMock = parametersListCode != null?mockHelper.PrepareMock(parametersListCode, true, false) : null;
var e = new ContractEvent()
{
Name = name,
Parameters = parametersListMock
};
return(new object[] { e, expected });
}
/// <inheritdoc/>
public async Task <bool> WithdrawAsync(ContractEvent contractEvent)
{
var withdrawRequest = new WithdrawalRequest()
{
ContractNumber = contractEvent.ContractNumber,
ContractVersion = contractEvent.ContractVersion,
FileName = contractEvent.ContractEventXml,
WithdrawalType = (ClientEnums.ContractStatus)contractEvent.Status
};
await _contractsDataService.WithdrawAsync(withdrawRequest);
return(true);
}
/// <summary>
/// It will create a new contract.
/// </summary>
/// <param name="contractEvent">New contract Data.</param>
/// <returns>Returns true when a new contract created else false.</returns>
public async Task <bool> CreateAsync(ContractEvent contractEvent)
{
_logger.LogInformation($"[{nameof(CreateAsync)}] - Processing message for contract creation. ContractNumber: {contractEvent.ContractNumber}, ContractVersion: {contractEvent.ContractVersion}");
var createRequest = _contractEventMapper.GetCreateRequest(contractEvent);
var fileName = _contractEventMapper.GetFileNameForContractDocument(contractEvent.UKPRN, contractEvent.ContractNumber, contractEvent.ContractVersion);
var folderName = _contractEventMapper.GetFolderNameForContractDocument(contractEvent.FundingType.GetEnumShortName(), contractEvent.ContractPeriodValue, _spConfig.PublicationFolderSuffix);
var urlSafeFolderName = _contractEventMapper.GetUrlSafeFolderNameForContractDocument(folderName);
var pdfDoc = await _sharePointClientService.GetDocument(fileName, urlSafeFolderName);
var pdfADoc = _documentManagementService.ConvertToPdfA(pdfDoc);
createRequest.ContractContent = _contractEventMapper.GetContractContent(pdfADoc, fileName);
await _contractsDataService.CreateContractAsync(createRequest);
return(true);
}
/// <inheritdoc/>
public async Task ProcessMessage(ContractEvent contractEvent)
{
_logger.LogInformation($"[{nameof(ProcessMessage)}] Processing message for contract event : {contractEvent.BookmarkId}");
var eventType = contractEvent.GetContractEventType();
switch (eventType)
{
case ContractEventType.Create:
var existingContract = await _contractsDataService.TryGetContractAsync(contractEvent.ContractNumber, contractEvent.ContractVersion);
if (existingContract is null)
{
await _contractCreationService.CreateAsync(contractEvent);
}
else
{
_logger.LogWarning($"[{nameof(ContractEventProcessor)}] - Ignoring contract event with id [{contractEvent.BookmarkId}] because a contract with contract number [{contractEvent.ContractNumber}], version [{contractEvent.ContractVersion}] and Id [{existingContract.Id}] already exists.");
}
break;
case ContractEventType.Approve:
var approveContract = await _contractsDataService.TryGetContractAsync(contractEvent.ContractNumber, contractEvent.ContractVersion);
if (approveContract is null)
{
_logger.LogWarning($"[{nameof(ContractEventProcessor)}] - Ignoring contract event with id [{contractEvent.BookmarkId}] because unable to find a contract with contract number [{contractEvent.ContractNumber}], version [{contractEvent.ContractVersion}].");
}
else
{
await _contractApprovalService.ApproveAsync(contractEvent, approveContract);
}
break;
case ContractEventType.Withdraw:
await _contractWithdrawService.WithdrawAsync(contractEvent);
break;
default:
throw new NotImplementedException($"[{nameof(ContractService)}] - [{nameof(ProcessMessage)}] does not have an implementation for event type [{eventType}].");
}
}
private static Message GetDummyMessage(ContractEvent expectedBodyMessage = null, int deliveryCount = 1)
{
Message dummyMessage = new Message
{
MessageId = "1",
Body = Encoding.UTF8.GetBytes(JsonConvert.SerializeObject(expectedBodyMessage ?? new ContractEvent()))
};
//Workaround to set internal get properties
var systemProperties = new Message.SystemPropertiesCollection();
typeof(Message.SystemPropertiesCollection).GetProperty(nameof(systemProperties.SequenceNumber)).SetValue(systemProperties, 1);
typeof(Message.SystemPropertiesCollection).GetProperty(nameof(systemProperties.DeliveryCount)).SetValue(systemProperties, deliveryCount);
typeof(Message.SystemPropertiesCollection).GetProperty(nameof(systemProperties.EnqueuedTimeUtc)).SetValue(systemProperties, DateTime.Now);
typeof(Message.SystemPropertiesCollection).GetProperty(nameof(systemProperties.LockedUntilUtc)).SetValue(systemProperties, DateTime.Now);
typeof(Message).GetProperty(nameof(dummyMessage.SystemProperties)).SetValue(dummyMessage, systemProperties);
return(dummyMessage);
}
/// <summary>
/// Gets the type of the contract event.
/// </summary>
/// <param name="contractEvent">The contract event.</param>
/// <returns><see cref="ContractEventType"/> value based on parent status, status and ammendment type.</returns>
public static ContractEventType GetContractEventType(this ContractEvent contractEvent)
{
var eventType = (contractEvent.ParentStatus, contractEvent.Status, contractEvent.AmendmentType) switch
{
(ContractParentStatus.Draft, ContractStatus.PublishedToProvider, ContractAmendmentType.None) => ContractEventType.Create,
(ContractParentStatus.Draft, ContractStatus.PublishedToProvider, ContractAmendmentType.Variation) => ContractEventType.Create,
(ContractParentStatus.Approved, ContractStatus.Approved, ContractAmendmentType.Notification) => ContractEventType.Create,
(ContractParentStatus.Approved, ContractStatus.Modified, ContractAmendmentType.Notification) => ContractEventType.Create,
(ContractParentStatus.Approved, ContractStatus.UnderTermination, ContractAmendmentType.Notification) => ContractEventType.Create,
(ContractParentStatus.Approved, ContractStatus.Approved, ContractAmendmentType.None) => ContractEventType.Approve,
(ContractParentStatus.Approved, ContractStatus.Approved, ContractAmendmentType.Variation) => ContractEventType.Approve,
(ContractParentStatus.Approved, ContractStatus.Modified, ContractAmendmentType.None) => ContractEventType.Approve,
(ContractParentStatus.Approved, ContractStatus.Modified, ContractAmendmentType.Variation) => ContractEventType.Approve,
(ContractParentStatus.Approved, ContractStatus.UnderTermination, ContractAmendmentType.None) => ContractEventType.Approve,
(ContractParentStatus.Approved, ContractStatus.UnderTermination, ContractAmendmentType.Variation) => ContractEventType.Approve,
(ContractParentStatus.Withdrawn, ContractStatus.WithdrawnByAgency, ContractAmendmentType.None) => ContractEventType.Withdraw,
(ContractParentStatus.Withdrawn, ContractStatus.WithdrawnByAgency, ContractAmendmentType.Variation) => ContractEventType.Withdraw,
(ContractParentStatus.Withdrawn, ContractStatus.WithdrawnByProvider, ContractAmendmentType.None) => ContractEventType.Withdraw,
(ContractParentStatus.Withdrawn, ContractStatus.WithdrawnByProvider, ContractAmendmentType.Variation) => ContractEventType.Withdraw,
_ => throw new NotImplementedException($"BookmarkId: [{contractEvent.BookmarkId}] with contract number {contractEvent.ContractNumber} and version [{contractEvent.ContractVersion}] contains unexpected combination of ParentStatus: {contractEvent.ParentStatus}, Status: {contractEvent.Status} and AmendmentType: {contractEvent.AmendmentType}. This combination does not have a corresponding imeplementation defiend."),
};
/// <inheritdoc/>
public async Task <bool> ApproveAsync(ContractEvent contractEvent, Contract existingContract)
{
var approvalRequest = new ApprovalRequest()
{
ContractNumber = existingContract.ContractNumber,
ContractVersion = existingContract.ContractVersion,
Id = existingContract.Id,
FileName = contractEvent.ContractEventXml
};
var eventType = contractEvent.GetContractEventType();
if (eventType != Enums.ContractEventType.Approve)
{
throw new InvalidOperationException($"[{nameof(ContractApprovalService)}] - [{nameof(ApproveAsync)}] called for event type [{eventType}].");
}
switch (existingContract.Status)
{
case Data.Api.Client.Enumerations.ContractStatus.PublishedToProvider:
await _contractsDataService.ManualApproveAsync(approvalRequest);
break;
case Data.Api.Client.Enumerations.ContractStatus.ApprovedWaitingConfirmation:
await _contractsDataService.ConfirmApprovalAsync(approvalRequest);
break;
default:
_logger.LogInformation($"[{nameof(ContractApprovalService)}] - [{nameof(ApproveAsync)}] - No further action taken on [{existingContract.ContractNumber}], version [{existingContract.ContractVersion}], Id [{existingContract.Id}], event parent status [{contractEvent.ParentStatus}], event status [{contractEvent.Status}], event amendment type [{contractEvent.AmendmentType}] and contract status [{existingContract.Status}].");
break;
}
return(true);
}
/// <inheritdoc/>
public CreateRequest GetCreateRequest(ContractEvent contractEvent)
{
try
{
string contractTitle = CreateContractTitle(contractEvent);
var createRequest = new CreateRequest();
createRequest.AmendmentType = (Data.Api.Client.Enumerations.ContractAmendmentType)contractEvent.AmendmentType;
createRequest.ContractFundingStreamPeriodCodes = GetContractFundingStreamPeriodCodes(contractEvent.ContractAllocations);
createRequest.ContractNumber = contractEvent.ContractNumber;
createRequest.Year = FormatPeriod(contractEvent);
createRequest.Type = GetContractType(contractEvent);
createRequest.ContractVersion = contractEvent.ContractVersion;
createRequest.EndDate = contractEvent.EndDate;
createRequest.FundingType = (Data.Api.Client.Enumerations.ContractFundingType)contractEvent.FundingType;
createRequest.ParentContractNumber = contractEvent.ParentContractNumber;
createRequest.StartDate = contractEvent.StartDate;
createRequest.UKPRN = contractEvent.UKPRN;
createRequest.Value = contractEvent.Value;
createRequest.ContractData = contractEvent.ContractEventXml;
createRequest.Title = contractTitle;
createRequest.ContractAllocationNumber = contractEvent.ContractAllocations?.FirstOrDefault()?.ContractAllocationNumber;
createRequest.CreatedBy = CreatedBy;
createRequest.PageCount = 0;
createRequest.SignedOn = contractEvent.SignedOn;
return(createRequest);
}
catch (ContractEventExpectationFailedException)
{
throw;
}
catch (Exception ex)
{
throw new ContractEventExpectationFailedException(contractEvent.BookmarkId, contractEvent.ContractNumber, contractEvent.ContractVersion, $"Unhandled exception trying to parse contract event message, see inner exception for details.", ex);
}
}
private async Task <ContractProcessResultType> GetProcessedResultType(XmlElement feedItem, XmlNamespaceManager ns, ContractEvent evt)
{
var contractStatus = feedItem.GetValue <string>("c:contractStatus/c:status", ns);
var parentStatus = feedItem.GetValue <string>("c:contractStatus/c:parentStatus", ns);
var amendmentType = feedItem.GetValue("c:amendmentType", ns, true, "None");
var fundingType = feedItem.GetValue <string>("c:fundingType/c:fundingTypeCode", ns);
var resultCode = !await _validationService.ValidateContractStatusAsync(parentStatus, contractStatus, amendmentType)
? ContractProcessResultType.StatusValidationFailed
: !await _validationService.ValidateFundingTypeAsync(fundingType)
? ContractProcessResultType.FundingTypeValidationFailed
: ContractProcessResultType.Successful;
if (resultCode != ContractProcessResultType.Successful)
{
string msg = $"Contract event for Contract [{evt.ContractNumber}] Version [{evt.ContractVersion}]";
msg += resultCode switch
{
ContractProcessResultType.StatusValidationFailed => $" with parent status [{parentStatus}], status [{contractStatus}], and amendment type [{amendmentType}] has been ignored.",
ContractProcessResultType.FundingTypeValidationFailed => $" with funding type [{fundingType}] has been ignored.",
_ => throw new NotImplementedException(),
};
_loggerAdapter.LogWarning(msg);
await _auditService.TrySendAuditAsync(new Audit.Api.Client.Models.Audit()
{
Action = Audit.Api.Client.Enumerations.ActionType.ContractFeedEventFilteredOut,
Message = msg,
Severity = Audit.Api.Client.Enumerations.SeverityLevel.Information,
Ukprn = evt.UKPRN,
User = _auditApiUser
});
}
return(resultCode);
}
static void Main(string[] args)
{
var boolType = SolidityType.Bool;
var intType = SolidityType.Int;
var propertyName = "PropertyName1";
var propertyName2 = "PropertyName2";
var propertyName3 = "PropertyName3";
var pr1 = new ContractProperty()
{
Variable = PrepareVariable(propertyName, boolType),
Visibility = Visibility.Public
};
var pr2 = new ContractProperty()
{
Variable = PrepareVariable(propertyName2, intType),
Visibility = Visibility.Private
};
var pr3 = new ContractProperty()
{
Variable = PrepareVariable(propertyName3, boolType),
Visibility = Visibility.Public
};
var properties = new List <ContractProperty>()
{
pr1, pr2, pr3
};
var eventName = "EventName1";
var eventName2 = "EventName2";
var eventName3 = "EventName3";
var epl = new ParametersList()
{
Parameters = new List <Variable>()
{
PrepareVariable("ep1", boolType), PrepareVariable("ep2", intType)
}
};
var epl2 = new ParametersList()
{
Parameters = new List <Variable>()
{
PrepareVariable("ep1", boolType)
}
};
var epl3 = new ParametersList()
{
Parameters = new List <Variable>()
{
PrepareVariable("ep1", intType)
}
};
var e1 = new ContractEvent()
{
Name = eventName,
Parameters = epl
};
var e2 = new ContractEvent()
{
Name = eventName2,
Parameters = epl2
};
var e3 = new ContractEvent()
{
Name = eventName3,
Parameters = epl3
};
var events = new List <ContractEvent>()
{
e1, e2, e3
};
var name1 = "_p";
var name2 = "_q";
var name3 = "_r";
var name4 = "v";
var p1 = PrepareVariable(name1, boolType);
var p2 = PrepareVariable(name2, boolType);
var p3 = PrepareVariable(name3, boolType);
var v = PrepareVariable(name4, boolType);
var pl = new ParametersList()
{
Parameters = new List <Variable>()
{
p1, p2
}
};
var pl2 = new ParametersList()
{
Parameters = new List <Variable>()
{
p1, p2, p3
}
};
var cpl = new CallingParametersList()
{
Parameters = new List <IAssignable>()
{
p1, p2
}
};
var cpl2 = new CallingParametersList()
{
Parameters = new List <IAssignable>()
{
p1, p2, p3
}
};
var d = new Declaration()
{
Variable = v
};
var op = new Operation()
{
LeftSide = p1,
Operator = OperationOperator.OR,
RightSide = p2
};
var instruction = new Assignment()
{
Destination = d,
Source = op
};
var ao = new Operation()
{
LeftSide = v,
Operator = OperationOperator.Negation
};
var instruction2 = new Assignment()
{
Destination = v,
Source = ao
};
var instructions = new InstructionsList();
instructions.AppendInstruction(instruction);
instructions.AppendInstruction(instruction2);
var c = new Constructor()
{
Visibility = Visibility.Public,
Parameters = pl,
Instructions = instructions
};
var functionInstructions = new InstructionsList();
functionInstructions.AppendInstruction(instruction);
var aof = new Operation()
{
LeftSide = v,
Operator = OperationOperator.AND,
RightSide = p3
};
var instruction3 = new Assignment()
{
Destination = v,
Source = aof
};
functionInstructions.AppendInstruction(instruction3);
var function = new ContractFunction()
{
Name = "TestFunction",
Visibility = Visibility.Public,
Parameters = pl2,
Instructions = functionInstructions
};
var fp1 = PrepareVariable(name1, intType);
var fp2 = PrepareVariable(name2, intType);
var fp3 = PrepareVariable(name3, intType);
var fv = PrepareVariable(name4, intType);
var fpl = new ParametersList()
{
Parameters = new List <Variable>()
{
fp1, fp2, fp3
}
};
var fd = new Declaration()
{
Variable = fv
};
var fop = new Operation()
{
LeftSide = p1,
Operator = OperationOperator.Plus,
RightSide = p2
};
var finstruction = new Assignment()
{
Destination = fd,
Source = fop
};
var fao = new Operation()
{
LeftSide = v,
Operator = OperationOperator.Multiply,
RightSide = fp3
};
var finstruction2 = new Assignment()
{
Destination = pr2,
Source = fao
};
var finstructions = new InstructionsList();
finstructions.AppendInstruction(finstruction);
finstructions.AppendInstruction(finstruction2);
var function2 = new ContractFunction()
{
Name = "TestFunction2",
Visibility = Visibility.External,
Parameters = fpl,
Instructions = finstructions
};
var trueInstructions = new InstructionsList();
var falseInstructions = new InstructionsList();
trueInstructions.AppendInstruction(
new FunctionCall()
{
FunctionToCall = function, Parameters = cpl2
}
);
var ecpl = new CallingParametersList()
{
Parameters = new List <IAssignable>()
{
p1
}
};
falseInstructions.AppendInstruction(
new EventCall()
{
EventToCall = e2, Parameters = ecpl
}
);
var newFInstructions = new InstructionsList();
var condOp = new Operation()
{
LeftSide = p1,
Operator = OperationOperator.Negation
};
var cond = new Condition()
{
ConditionOperation = condOp
};
var ifStatement = new IfStatement()
{
Condition = cond,
TrueInstructions = trueInstructions,
FalseInstructions = falseInstructions
};
newFInstructions.AppendInstruction(ifStatement);
var loopVariable = PrepareVariable("loopVariable", intType);
var declaration = new Declaration()
{
Variable = loopVariable
};
var assignment = new Assignment()
{
Destination = declaration,
Source = new ConstantValue()
{
Value = "0"
}
};
var condOperation = new Operation()
{
LeftSide = loopVariable,
Operator = OperationOperator.NotEquals,
RightSide = new ConstantValue()
{
Value = "1"
}
};
var breakCondition = new Condition()
{
ConditionOperation = condOperation
};
var stepOp = new Operation()
{
LeftSide = loopVariable,
Operator = OperationOperator.Plus,
RightSide = new ConstantValue()
{
Value = "1"
}
};
var stepInstruction = new Assignment()
{
Destination = loopVariable,
Source = stepOp
};
var loopInstructions = new InstructionsList();
var cple = new CallingParametersList()
{
Parameters = new List <IAssignable>()
{
loopVariable
}
};
loopInstructions.AppendInstruction(
new EventCall()
{
EventToCall = e3,
Parameters = cple
}
);
var loop = new ContractLoop()
{
InitialAssignment = assignment,
BreakCondition = breakCondition,
StepInstruction = stepInstruction,
Instructions = loopInstructions
};
newFInstructions.AppendInstruction(loop);
var function3 = new ContractFunction()
{
Name = "NewFunction",
Visibility = Visibility.Public,
Parameters = pl2,
Instructions = newFInstructions
};
var functions = new List <ContractFunction>()
{
function, function2, function3
};
string contractName = "TestContract";
Contract contract = new Contract()
{
Name = contractName,
Constructor = c,
Functions = functions,
Events = events,
Properties = properties
};
Console.WriteLine(contract.GenerateCode(new Indentation()));
}
static IEnumerable <object[]> GetDataForGenerateCodeTest()
{
string funcName = "functionName";
var function = new ContractFunction()
{
Name = funcName
};
var functionCall = new FunctionCall()
{
FunctionToCall = function
};
yield return(new object[] { functionCall, $"{funcName}()" });
string eventName = "eventName";
var contractEvent = new ContractEvent()
{
Name = eventName
};
var eventCall = new EventCall()
{
EventToCall = contractEvent
};
yield return(new object[] { eventCall, $"emit {eventName}()" });
string modifierName = "modifierName";
var modifier = new Modifier()
{
Name = modifierName
};
var modifierAppliance = new ModifierAppliance()
{
ModifierToApply = modifier
};
yield return(new object[] { modifierAppliance, $"{modifierName}()" });
var variables = new List <IAssignable>();
var parameters = new CallingParametersList()
{
Parameters = variables
};
functionCall.Parameters = parameters;
yield return(new object[] { functionCall, $"{funcName}()" });
eventCall.Parameters = parameters;
yield return(new object[] { eventCall, $"emit {eventName}()" });
modifierAppliance.Parameters = parameters;
yield return(new object[] { modifierAppliance, $"{modifierName}()" });
var vName1 = "vName";
var v1 = new Variable()
{
Name = vName1,
Type = SolidityType.Bool
};
parameters.Parameters.Add(v1);
yield return(new object[] { eventCall, $"emit {eventName}({vName1})" });
yield return(new object[] { functionCall, $"{funcName}({vName1})" });
yield return(new object[] { modifierAppliance, $"{modifierName}({vName1})" });
var vName2 = "vName2";
var v2 = new Variable()
{
Name = vName2,
Type = SolidityType.Bool
};
parameters.Parameters.Add(v2);
yield return(new object[] { eventCall, $"emit {eventName}({vName1}, {vName2})" });
yield return(new object[] { functionCall, $"{funcName}({vName1}, {vName2})" });
yield return(new object[] { modifierAppliance, $"{modifierName}({vName1}, {vName2})" });
}
/// <inheritdoc/>
public string CreateContractTitle(ContractEvent contractEvent)
{
var fundingType = contractEvent.FundingType;
var fundingTypeName = fundingType.GetEnumDisplayName();
var lepArea = string.Empty;
var specification = string.Empty;
var contractAllocation = contractEvent.ContractAllocations?.FirstOrDefault();
if (fundingType == ContractFundingType.Esf && contractAllocation != null)
{
lepArea = contractAllocation.LEPArea;
specification = contractAllocation.TenderSpecTitle;
}
var variation = string.Empty;
if (contractEvent.ContractVersion > 1)
{
variation = "variation ";
}
var contractPeriod = FormatPeriod(contractEvent);
switch (fundingType)
{
case ContractFundingType.Mainstream:
if (GetStartingYear(contractEvent.ContractPeriodValue) >= 17)
{
return
($"Skills and adult education contract {variation}for {contractPeriod} version {contractEvent.ContractVersion}");
}
// All mainstream contracts are effectively variations so they always display variation in the friendly name.
return($"{fundingTypeName} contract {variation}for {contractPeriod} version {contractEvent.ContractVersion}");
case ContractFundingType.Age:
return($"{fundingTypeName} Grant contract {variation}for {contractPeriod} version {contractEvent.ContractVersion}");
case ContractFundingType.TwentyFourPlusLoan:
return($"Advanced Learner Loans contract {variation}for {contractPeriod} version {contractEvent.ContractVersion}");
case ContractFundingType.Eop:
case ContractFundingType.Eof:
return($"{GetFriendlyYear(contractEvent.ContractPeriodValue)} {fundingTypeName} contract variation version {contractEvent.ContractVersion}");
case ContractFundingType.Esf:
return($"{fundingTypeName} {specification} contract {variation}for {lepArea} version {contractEvent.ContractVersion}");
case ContractFundingType.Levy:
return($"{OrganizationNameAbbreviated} {fundingTypeName} {DateTime.Now.ToFullMonthAndFullYearDisplay()} version {contractEvent.ContractVersion}");
case ContractFundingType.Ncs:
return($"{fundingTypeName} contract {variation}for {contractPeriod} version {contractEvent.ContractVersion}");
case ContractFundingType.NonLevy:
return($"{OrganizationNameAbbreviated} apprenticeship contract for {contractPeriod} version {contractEvent.ContractVersion}");
case ContractFundingType.SixteenNineteenFunding:
return($"{fundingTypeName} contract for {contractPeriod} version {contractEvent.ContractVersion}");
case ContractFundingType.Aebp:
return($"{fundingTypeName} contract for {contractPeriod} version {contractEvent.ContractVersion}");
case ContractFundingType.Nla:
return($"{fundingTypeName} version {contractEvent.ContractVersion}");
case ContractFundingType.AdvancedLearnerLoans:
return($"Advanced Learner Loans contract {variation}for {contractPeriod} version {contractEvent.ContractVersion}");
case ContractFundingType.ProcuredNineteenToTwentyFourTraineeship:
return($"{fundingTypeName} contract for {contractPeriod} version {contractEvent.ContractVersion}");
case ContractFundingType.EducationAndSkillsFunding:
case ContractFundingType.NonLearningGrant:
case ContractFundingType.SixteenEighteenForensicUnit:
case ContractFundingType.DanceAndDramaAwards:
case ContractFundingType.CollegeCollaborationFund:
case ContractFundingType.FurtherEducationConditionAllocation:
return($"{fundingTypeName} {variation}for {contractPeriod} version {contractEvent.ContractVersion}");
default:
throw new NotImplementedException($"Title for {nameof(fundingType)} with value {fundingType} is not implemented.");
}
}
/// <inheritdoc/>
public void Initialise(Message message, ContractEvent contractEvent)
{
_message = message;
_contractEvent = contractEvent;
_hasInitialised = true;
}
public void GenerateCallCodeTest(ContractEvent e, string expected)
{
System.Diagnostics.Contracts.Contract.Requires(e != null);
Assert.AreEqual(expected, e.GenerateCallCode());
}
