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 ThenTheCreateEventCommandShouldBeSent()
{
//Arrange
var periodEndEvent = new PeriodEndEvent <Payment> {
PeriodEnd = new PeriodEnd {
Id = "ABC123"
}
};
//Act
await _handler.Handle(periodEndEvent);
//Assert
_mediator.Verify(x => x.PublishAsync(It.Is <CreatePaymentsForPeriodEndCommand>(c => c.PeriodEndId == periodEndEvent.PeriodEnd.Id)), Times.Once);
}
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 override async Task Handle(PeriodEndEvent <T> @event)
{
await Handle(@event, EventTypeName, @event.PeriodEnd.Id);
}
/// <summary>
/// Handles the click of the Period Start/End button
/// </summary>
/// <param name="sender">Should just be the periodStartButton</param>
/// <param name="e">Some arguments that we may or may not user</param>
private void periodChange_Click(object sender, EventArgs e)
{
// create a generic event. We may have either a period start or period end event
Button button = (Button)sender;
// Check if its a period or an overtime
string perOrOver = pac.Period > 2 ? "Overtime" : "Period";
Event ev = null;
// if the button had "Start" in it
if (button.Text.Contains("Start"))
{
ev = new PeriodStartEvent(pac);
pac.post(ev);
perOrOver += " End";
return;
}// end if
//PERIOD END
else
{
ev = new PeriodEndEvent(pac);
bool sameScore = confirmScore(false);
if (pac.Period >= 2)
{
// going into overtime
if (sameScore)
{
pac.post(ev);
perOrOver = "Overtime";
}
//we are trying to end the game
else
{
pac.post(ev);
//the score is different, we are ending NOW
if (!confirmScore(true))
{
ev = new GameEndEvent(pac);
pac.post(ev);
}
// the user changed the score so we are going into another overtime
else
{
perOrOver = "Overtime";
}
}
}
else
{
pac.post(ev);
}
perOrOver += " Start";
}// end else
button.Text = perOrOver;
}
protected override async Task ProcessEvent(PeriodEndEvent <Payment> @event)
{
await Mediator.PublishAsync(new CreatePaymentsForPeriodEndCommand { PeriodEndId = @event.PeriodEnd.Id });
}
protected override async Task ProcessEvent(PeriodEndEvent <AccountTransfer> @event)
{
await Mediator.PublishAsync(new CreateTransfersForPeriodEndCommand { PeriodEndId = @event.PeriodEnd.Id });
}
public List<Event> getEvents(Alpaca pac)
{
List<Event> events = new List<Event>();
if (gameEvents == null)
return events;
foreach(Dictionary<string, object> dict in gameEvents)
{
Event e = null;
string eventType = dict["eventType"].ToString().Split(new char[] { '/' })[1];
Console.WriteLine("Found eventType: " + eventType);
Context context = JsonConvert.DeserializeObject<Context>(dict["context"].ToString());
if (eventType.Equals("gameEnd"))
{
e = new GameEndEvent(pac);
}
else if (eventType.Equals("periodStart"))
{
Console.WriteLine("Found a periodStart event");
e = new PeriodStartEvent(pac);
}
else if (eventType.Equals("periodEnd"))
{
e = new PeriodEndEvent(pac);
}
else if (eventType.Equals("madeShot"))
{
string shooter = dict["shooter"].ToString();
object assisted;
dict.TryGetValue("assistedBy", out assisted);
string assistedBy = null;
if (assisted != null)
assistedBy = assisted.ToString();
string shotType = dict["shotType"].ToString();
int pointsScored = int.Parse(dict["pointsScored"].ToString());
bool fastBreak = bool.Parse(dict["fastBreakOpportunity"].ToString());
bool goaltending = bool.Parse(dict["goaltending"].ToString());
int[] location = JsonConvert.DeserializeObject<int[]>(dict["location"].ToString());
Point locPt = new Point(location[0], location[1]);
Console.WriteLine("made shot");
Console.WriteLine(shooter);
Console.WriteLine(location[0] + " " + location[1]);
e = new MadeShotEvent(pac, shooter, pac.getPlayer(shooter).TeamId, assistedBy, shotType, pointsScored, fastBreak,
goaltending, locPt);
}
else if (eventType.Equals("missedShot"))
{
string shooter = dict["shooter"].ToString();
object blocked;
dict.TryGetValue("blockedBy", out blocked);
string blockedBy = null;
if (blocked != null)
blockedBy = blocked.ToString();
string shotType = dict["shotType"].ToString();
int pointsAttempted = int.Parse(dict["pointsAttempted"].ToString());
bool fastBreak = bool.Parse(dict["fastBreakOpportunity"].ToString());
int[] location = JsonConvert.DeserializeObject<int[]>(dict["location"].ToString());
Point locPt = new Point(location[0], location[1]);
e = new MissedShotEvent(pac, shooter, pac.getPlayer(shooter).TeamId, blockedBy, shotType, pointsAttempted, fastBreak, locPt);
}
else if (eventType.Equals("jumpBall"))
{
string homePlayer = dict["homePlayer"].ToString();
string awayPlayer = dict["awayPlayer"].ToString();
string winner = dict["winner"].ToString();
int[] location = JsonConvert.DeserializeObject<int[]>(dict["location"].ToString());
Point locPt = new Point(location[0], location[1]);
e = new JumpballEvent(pac, homePlayer, awayPlayer, winner, locPt);
}
else if (eventType.Equals("rebound"))
{
object rebound;
dict.TryGetValue("rebounder", out rebound);
string rebounder = null;
if (rebound != null)
{
rebounder = rebound.ToString();
}
string reboundType = dict["reboundType"].ToString();
int[] location = JsonConvert.DeserializeObject<int[]>(dict["location"].ToString());
Point locPt = new Point(location[0], location[1]);
e = new ReboundEvent(pac, rebounder, reboundType, locPt);
}
else if (eventType.Equals("substitution"))
{
string exitingPlayer = dict["exitingPlayer"].ToString();
string enteringPlayer = dict["enteringPlayer"].ToString();
e = new SubstitutionEvent(pac, enteringPlayer, exitingPlayer, pac.getPlayer(enteringPlayer).TeamId);
}
else if (eventType.Equals("turnover"))
{
string committedBy = dict["committedBy"].ToString();
object forced;
dict.TryGetValue("forcedBy", out forced);
string forcedBy = null;
if (forced != null)
{
forcedBy = forced.ToString();
}
string turnoverType = dict["turnoverType"].ToString();
int[] location = JsonConvert.DeserializeObject<int[]>(dict["location"].ToString());
Point locPt = new Point(location[0], location[1]);
e = new TurnoverEvent(pac, committedBy, forcedBy, turnoverType, locPt);
}
else if (eventType.Equals("timeout"))
{
object team;
dict.TryGetValue("timeoutTeam", out team);
string timeoutTeam = null;
if (team != null)
{
timeoutTeam = team.ToString();
}
string timeoutType = dict["timeoutType"].ToString();
e = new TimeoutEvent(pac, timeoutTeam, timeoutType);
}
else if (eventType.Equals("foul"))
{
string committedBy = dict["committedBy"].ToString();
object drew;
dict.TryGetValue("drewBy", out drew);
string drewBy = null;
if (drew != null)
{
drewBy = drew.ToString();
}
string foulType = dict["foulType"].ToString();
bool ejected = bool.Parse(dict["ejected"].ToString());
int[] location = JsonConvert.DeserializeObject<int[]>(dict["location"].ToString());
Point locPt = new Point(location[0], location[1]);
e = new FoulEvent(pac, pac.getPlayer(committedBy).TeamId, committedBy, drewBy, foulType, ejected, locPt);
}
if (e != null)
{
e.EventId = dict["eventId"].ToString();
e.setContext(context);
e.resolve();
events.Add(e);
}
}
return events;
}
