private async Task RecordPeriodEndJob(PeriodEndTaskType taskType, PeriodEndEvent periodEndEvent)
{
logger.LogDebug($"Recording period end job. Type: {taskType:G}");
var generatedMessage = new GeneratedMessage
{
MessageId = periodEndEvent.EventId,
MessageName = periodEndEvent.GetType().FullName,
StartTime = periodEndEvent.EventTime
};
if (taskType == PeriodEndTaskType.PeriodEndStart ||
taskType == PeriodEndTaskType.PeriodEndRun ||
taskType == PeriodEndTaskType.PeriodEndStop ||
taskType == PeriodEndTaskType.PeriodEndSubmissionWindowValidation ||
taskType == PeriodEndTaskType.PeriodEndReports)
{
var job = CreatePeriodEndJob(taskType);
job.JobId = periodEndEvent.JobId;
job.CollectionYear = periodEndEvent.CollectionPeriod.AcademicYear;
job.CollectionPeriod = periodEndEvent.CollectionPeriod.Period;
job.GeneratedMessages = new List <GeneratedMessage> {
generatedMessage
};
await jobClient.StartPeriodEndJob(job).ConfigureAwait(false);
}
else
{
throw new InvalidOperationException($"Unhandled period end task type: {taskType:G}");
}
}
public async Task Stores_In_Progress_Messages()
{
var generatedMessageA = new GeneratedMessage
{
StartTime = DateTimeOffset.UtcNow,
MessageId = Guid.NewGuid(),
MessageName = "MessageA",
};
var generatedMessageB = new GeneratedMessage
{
StartTime = DateTimeOffset.UtcNow,
MessageId = Guid.NewGuid(),
MessageName = "MessageB",
};
var jobStatusMessage = new RecordJobMessageProcessingStatus
{
Id = Guid.NewGuid(),
JobId = 1,
GeneratedMessages = new List <GeneratedMessage> {
generatedMessageA, generatedMessageB
},
EndTime = DateTime.UtcNow,
Succeeded = true
};
var service = mocker.Create <JobMessageService>();
await service.RecordCompletedJobMessageStatus(jobStatusMessage, CancellationToken.None);
mocker.Mock <IJobStorageService>()
.Verify(x => x.StoreInProgressMessages(It.Is <long>(jobId => jobId == jobStatusMessage.JobId), It.Is <List <InProgressMessage> >(identifiers =>
identifiers.Count == 2 &&
identifiers.Exists(inProgress => inProgress.MessageId == generatedMessageA.MessageId) &&
identifiers.Exists(inProgress => inProgress.MessageId == generatedMessageB.MessageId)), It.IsAny <CancellationToken>()), Times.Once);
}
public async Task Stores_Earning_Job_Inprogress_Messages()
{
var generatedMessageA = new GeneratedMessage
{
StartTime = DateTimeOffset.UtcNow,
MessageId = Guid.NewGuid(),
MessageName = "MessageA",
};
var generatedMessageB = new GeneratedMessage
{
StartTime = DateTimeOffset.UtcNow,
MessageId = Guid.NewGuid(),
MessageName = "MessageB",
};
var jobStarted = new RecordJobAdditionalMessages
{
GeneratedMessages = new List <GeneratedMessage> {
generatedMessageA, generatedMessageB
},
JobId = 1,
};
var service = mocker.Create <EarningsJobService>();
await service.RecordNewJobAdditionalMessages(jobStarted, CancellationToken.None);
mocker.Mock <IJobStorageService>()
.Verify(x => x.StoreInProgressMessages(It.Is <long>(jobId => jobId == jobStarted.JobId), It.Is <List <InProgressMessage> >(identifiers =>
identifiers.Count == 2 &&
identifiers.Exists(inProgress => inProgress.MessageId == generatedMessageA.MessageId) &&
identifiers.Exists(inProgress => inProgress.MessageId == generatedMessageB.MessageId)), It.IsAny <CancellationToken>()), Times.Once);
}
public static SEMessage Create(Guid eventID, GeneratedMessage message, StringDictionary stringDictionary, string body)
{
var mail = new SEMessage();
mail.HtmlBody = body;
mail.EventID = eventID;
foreach (string key in stringDictionary.Keys)
{
mail[key] = stringDictionary[key];
}
if (message.Subject != null)
{
mail[SEMessage.SUBJECT] = message.Subject;
}
if (message.Body != null)
{
mail.HtmlBody = message.Body;
}
if (message.Replay != null)
{
mail[REPLYTO] = message.Replay;
}
if (message.From != null)
{
mail[FROM] = message.From;
}
return(mail);
}
protected uint SendProto <TMessage, TBuilder>(uint protoID, GeneratedMessage <TMessage, TBuilder> req)
where TMessage : Google.ProtocolBuffers.GeneratedMessage <TMessage, TBuilder>
where TBuilder : Google.ProtocolBuffers.GeneratedBuilder <TMessage, TBuilder>, new()
{
if (this.channel != null)
{
byte[] data = req.ToByteArray();
IntPtr dataPtr = Marshal.AllocHGlobal(data.Length);
Marshal.Copy(data, 0, dataPtr, data.Length);
uint serialNo = FTCAPI.FTAPIChannel_SendProto(this.channel, protoID, (byte)0, dataPtr, data.Length);
Marshal.FreeHGlobal(dataPtr);
return(serialNo);
}
return(0);
}
private async Task RecordPeriodEndJob(PeriodEndTaskType taskType, PeriodEndEvent periodEndEvent)
{
logger.LogDebug($"Recording period end job. Type: {taskType:G}");
var generatedMessage = new GeneratedMessage
{
MessageId = periodEndEvent.EventId,
MessageName = periodEndEvent.GetType().FullName,
StartTime = periodEndEvent.EventTime
};
switch (taskType)
{
case PeriodEndTaskType.PeriodEndStart:
await jobClient.RecordPeriodEndStart(periodEndEvent.JobId, periodEndEvent.CollectionPeriod.AcademicYear,
periodEndEvent.CollectionPeriod.Period, new List <GeneratedMessage> {
generatedMessage
}).ConfigureAwait(false);
break;
case PeriodEndTaskType.PeriodEndRun:
await jobClient.RecordPeriodEndRun(periodEndEvent.JobId, periodEndEvent.CollectionPeriod.AcademicYear,
periodEndEvent.CollectionPeriod.Period, new List <GeneratedMessage> {
generatedMessage
}).ConfigureAwait(false);
break;
case PeriodEndTaskType.PeriodEndStop:
await jobClient.RecordPeriodEndStop(periodEndEvent.JobId, periodEndEvent.CollectionPeriod.AcademicYear,
periodEndEvent.CollectionPeriod.Period, new List <GeneratedMessage> {
generatedMessage
}).ConfigureAwait(false);
break;
case PeriodEndTaskType.PeriodEndSubmissionWindowValidation:
await jobClient.RecordPeriodEndSubmissionWindowValidation(periodEndEvent.JobId, periodEndEvent.CollectionPeriod.AcademicYear,
periodEndEvent.CollectionPeriod.Period, new List <GeneratedMessage> {
generatedMessage
}).ConfigureAwait(false);
break;
default:
throw new InvalidOperationException($"Unhandled period end task type: {taskType:G}");
}
}
public async Task Stores_In_Progress_Messages()
{
var generatedMessageA = new GeneratedMessage
{
StartTime = DateTimeOffset.UtcNow,
MessageId = Guid.NewGuid(),
MessageName = "MessageA",
};
var generatedMessageB = new GeneratedMessage
{
StartTime = DateTimeOffset.UtcNow,
MessageId = Guid.NewGuid(),
MessageName = "MessageB",
};
var jobStarted = new RecordEarningsJob
{
CollectionPeriod = 1,
CollectionYear = 1819,
JobId = 1,
Ukprn = 9999,
IlrSubmissionTime = DateTime.UtcNow.AddMinutes(-20),
StartTime = DateTimeOffset.UtcNow,
GeneratedMessages = new List <GeneratedMessage> {
generatedMessageA, generatedMessageB
}
};
var service = mocker.Create <EarningsJobService>();
await service.RecordNewJob(jobStarted, default(CancellationToken));
mocker.Mock <IJobStorageService>()
.Verify(x => x.StoreInProgressMessages(It.Is <long>(jobId => jobId == jobStarted.JobId), It.Is <List <InProgressMessage> >(identifiers =>
identifiers.Count == 2 &&
identifiers.Exists(inProgress => inProgress.MessageId == generatedMessageA.MessageId) &&
identifiers.Exists(inProgress => inProgress.MessageId == generatedMessageB.MessageId)), It.IsAny <CancellationToken>()), Times.Once);
}
private static int GetOndiskTrunkSize(GeneratedMessage s)
{
return(CodedOutputStream.ComputeRawVarint32Size(s.GetSerializedSize()) + s.GetSerializedSize
());
}
