public async Task Lesson_Start_Test()
{
A.CallTo(() => _repository.GetActiveLessonAsync(A <Guid> .Ignored, A <int> .Ignored))
.Returns(Task.FromResult(Array.Empty <Lesson>()));
#region #L1(^A)
var message = new LessonMessage(
loginSessionId: LOGIN_SESSION_ID,
userId: 1,
lessonId: 10,
lessonSessionId: 101,
stepId: 20,
tabId: "A",
clientStamp: _baseTime,
serviceStamp: _baseTime.AddSeconds(1),
operationKind: OperationKind.Start);
#endregion // #L1(^A)
await _processor.ProcessAsync(message);
A.CallTo(() => _repository.UpsertLessonAsync(
A <ChangeSet> .That.Matches(
c => c.Added.StartReason == ActionReason.Client &&
c.Added.StartServiceStamp == message.ServiceStamp &&
c.Added.StartClientStamp == message.ClientStamp &&
c.Added.TabId == message.TabId &&
c.Added.LessonSessionId == message.LessonSessionId &&
c.Added.UserId == message.UserId &&
c.Modified.Length == 0)))
.MustHaveHappenedOnceExactly();
}
public async Task <ChangeSet> HandleEndAsync(
LessonMessage data,
Lesson[] openedLessens)
{
Lesson[] sameLessons = openedLessens
.Where(l => l.LessonSessionId == data.LessonSessionId &&
l.TabId == data.TabId)
.ToArray();
foreach (var lesson in sameLessons)
{
if (lesson.EndReason == ActionReason.Undefined)
{
lesson.EndReason = ActionReason.Client;
lesson.EndServiceStamp = data.ServiceStamp;
}
if (!lesson.FinalEndClientStamp.HasValue)
{
lesson.FinalEndClientStamp = data.ClientStamp;
}
if (!lesson.FinalEndServiceStamp.HasValue)
{
lesson.FinalEndServiceStamp = data.ServiceStamp;
}
}
Lesson[] otherLessons = openedLessens
.Where(l => (l.LessonSessionId != data.LessonSessionId ||
l.TabId != data.TabId) &&
l.EndReason == ActionReason.Undefined)
.ToArray();
foreach (var lesson in otherLessons)
{
lesson.EndReason = ActionReason.Deactivate;
lesson.EndServiceStamp = data.ServiceStamp;
}
Lesson reopen = openedLessens
.OrderByDescending(l => l.StartServiceStamp)
.FirstOrDefault(l =>
l.LessonSessionId != data.LessonSessionId);
Lesson added = null;
if (reopen != null)
{
added = new Lesson
{
TabId = reopen.TabId,
UserId = reopen.UserId,
LoginSessionId = reopen.LoginSessionId,
LessonId = reopen.LessonId,
LessonSessionId = reopen.LessonSessionId,
StepId = reopen.StepId,
StartClientStamp = data.ClientStamp,
StartServiceStamp = data.ServiceStamp,
StartReason = ActionReason.Deactivate,
};
}
Lesson[] changes = sameLessons.Concat(otherLessons).ToArray();
return(new ChangeSet(added, changes));
}
public LessonQueueMessage(
object token,
int retryCount,
LessonMessage data)
{
Token = token;
RetryCount = retryCount;
Data = data;
}
public async Task <ActionResult <Product> > PostMessage(LessonMsgPost msgModel)
{
//Result<List<Product>> result = new Result<List<Product>>();
var result = new Result <object>();
var lessonMessage = new LessonMessage();
//role 1:teacher 3:Receptionist,manager,principal 4:learner
if (msgModel.role == 1)
{
lessonMessage.TeacherId = (short)msgModel.Id;
}
else if (msgModel.role == 4)
{
lessonMessage.LearnerId = (short)msgModel.Id;
}
else
{
lessonMessage.StaffId = (short)msgModel.Id;
}
var lesson = await _ablemusicContext.Lesson.
FirstOrDefaultAsync(l => l.LessonId == msgModel.LessonId);
var learner = await _ablemusicContext.Learner.
FirstOrDefaultAsync(l => l.LearnerId == lesson.LearnerId);
var teacher = await _ablemusicContext.Teacher.
FirstOrDefaultAsync(l => l.TeacherId == lesson.TeacherId);
lessonMessage.Message = msgModel.MessageContent;
lessonMessage.LessonId = msgModel.LessonId;
lessonMessage.LearnerEmail = learner.Email;
lessonMessage.TeacherEmail = teacher.Email;
lessonMessage.CreatedAt = DateTime.UtcNow.ToNZTimezone();
try
{
await _ablemusicContext.LessonMessage.AddAsync(lessonMessage);
if (PackageEmailContent(msgModel.role, msgModel.MessageContent, lesson, learner.Email, teacher.Email) == false)
{
throw new Exception("Email Send Error!");
}
await _ablemusicContext.SaveChangesAsync();
}
catch (Exception e)
{
result.ErrorMessage = e.Message;
result.IsSuccess = false;
return(BadRequest(result));
}
return(Ok(result));
}
public async Task ProcessAsync(LessonMessage data)
{
Lesson[] openedLessens =
await _repository.GetActiveLessonAsync(
data.LoginSessionId,
data.UserId);
ChangeSet changeSet = null;
if (data.OperationKind == OperationKind.Start)
{
changeSet = await HandleStartAsync(data, openedLessens);
}
else
{
changeSet = await HandleEndAsync(data, openedLessens);
}
await _repository.UpsertLessonAsync(changeSet);
}
public async Task <ChangeSet> HandleStartAsync(
LessonMessage data,
Lesson[] openedLessens)
{
Lesson added = null;
Lesson duplicateStat = openedLessens.FirstOrDefault(l => // avoid duplicate processing
l.LessonSessionId == data.LessonSessionId &&
l.TabId == data.TabId &&
l.EndReason == ActionReason.Undefined);
if (duplicateStat == null)
{
added = new Lesson
{
TabId = data.TabId,
UserId = data.UserId,
LoginSessionId = data.LoginSessionId,
LessonId = data.LessonId,
LessonSessionId = data.LessonSessionId,
StepId = data.StepId,
StartClientStamp = data.ClientStamp,
StartServiceStamp = data.ServiceStamp,
StartReason = ActionReason.Client,
};
}
else
{
Trace.WriteLine($"Duplicate processing of start [{duplicateStat.StartServiceStamp}] and [{data.ServiceStamp}]");
}
Lesson[] changes = openedLessens
.Where(l => l.EndReason == ActionReason.Undefined)
.ToArray();
foreach (var lesson in changes)
{
lesson.EndReason = ActionReason.Deactivate;
lesson.EndServiceStamp = data.ServiceStamp;
}
return(new ChangeSet(added, changes));
}
// #L1(^A)-|
private static async Task SimulateStartStopAsync(CloudQueue queue)
{
#region #L1(^A)
var message = new LessonMessage(
loginSessionId: LOGIN_SESSION_ID,
userId: 1,
lessonId: 10,
lessonSessionId: 101,
stepId: 20,
tabId: "A",
clientStamp: DateTimeOffset.UtcNow,
serviceStamp: DateTimeOffset.UtcNow,
operationKind: OperationKind.Start);
var json = JsonConvert.SerializeObject(message);
var cloudMessage = new CloudQueueMessage(json);
await queue.AddMessageAsync(cloudMessage);
#endregion // #L1(^A)
await Task.Delay(DELAY);
#region L1(^A)-|
message = new LessonMessage(
loginSessionId: LOGIN_SESSION_ID,
userId: 1,
lessonId: 10,
lessonSessionId: 101,
stepId: 20,
tabId: "A",
clientStamp: DateTimeOffset.UtcNow,
serviceStamp: DateTimeOffset.UtcNow,
operationKind: OperationKind.Stop);
json = JsonConvert.SerializeObject(message);
cloudMessage = new CloudQueueMessage(json);
await queue.AddMessageAsync(cloudMessage);
#endregion // L1(^A)-|
}
