public EventActivitySet(bool startsProcess, EventPredicate <TEvent, TData> starterPredicate = null)
{
StartsProcess = startsProcess;
_starterPredicate = starterPredicate;
EffectFunc = NoEffectFunc;
SetStateFunc = NoSetStateFunc;
}
public EventActivitySetBuilder <TEvent, TData> When <TEvent>(EventPredicate <TEvent, TData> predicate = null)
{
var ea = new EventActivitySet <TEvent, TData>(false, predicate);
_eventActivities.Add(ea);
return(new EventActivitySetBuilder <TEvent, TData>(ea));
}
public PlayerCheckin(CheckinLister lister, Message checkinEvent,
Predicate allCheckedInPredicate = null,
EventPredicate checkinPredicate = null,
Callback onCheckin = null,
Callback onReset = null,
Message?checkoutEvent = null)
{
this.lister = lister;
if (allCheckedInPredicate != null)
{
this.allCheckedInPredicate = allCheckedInPredicate;
}
if (checkinPredicate != null)
{
this.checkinPredicate = checkinPredicate;
}
if (onCheckin != null)
{
this.onCheckin = onCheckin;
}
if (onReset != null)
{
this.onReset = onReset;
}
GameManager.instance.notificationManager.CallOnMessageWithSender(checkinEvent, Checkin);
if (checkoutEvent.HasValue)
{
GameManager.instance.notificationManager.CallOnMessageWithSender(checkoutEvent.Value, Checkout);
}
}
/// <summary>
/// Register a job for a calendar event as specified by the <paramref name="predicate"/>
/// </summary>
/// <typeparam name="T"></typeparam>
/// <param name="predicate">Predicate filter calendar events.</param>
/// <param name="factory">Factory for creating job after a match has been found.</param>
/// <param name="job">Job method that will be ran when event starts.</param>
public Task RegisterEvent <T>(EventPredicate predicate, JobFactory factory, Job <T> job) where T : IJob
{
jobPredicates.Add(predicate);
jobFactories.Add(factory);
return(JobModule.RegisterJobAsync(job));
}
public static PlayerCheckin TextCountCheckin(
CheckinLister lister, Message checkinEvent,
Text textBox, Predicate allCheckedInPredicate = null,
EventPredicate checkinPredicate = null,
Callback onCheckin = null,
Callback onReset = null,
Message?checkoutEvent = null)
{
PlayerCheckin result = new PlayerCheckin(
lister, checkinEvent, allCheckedInPredicate,
checkinPredicate, checkoutEvent: checkoutEvent);
Callback modifyText = () =>
{
textBox.text = string.Format("{0}/{1}", result.NumberCheckedIn(), lister().Count);
};
onCheckin = onCheckin ?? delegate { };
onCheckin += modifyText;
onReset = onReset ?? delegate { };
onReset += modifyText;
result.onCheckin = onCheckin;
result.onReset = onReset;
return(result);
}
public EventActivitySetBuilder <TEvent, TData> RequestTimeout <T>(TimeSpan timeSpan, Func <TEvent, InstanceData <TData>, T> messageFactory,
EventPredicate <TEvent, TData> predicate = null)
where T : IEvent
{
Then((whenEvent, state) => Timeout.Request(state.InstanceId.ToString(), timeSpan, messageFactory(whenEvent, state)), predicate);
return(this);
}
public EventActivitySetBuilder <TEvent, TData> StartWith <TEvent>(EventPredicate <TEvent, TData> predicate = null)
{
var ea = new EventActivitySet <TEvent, TData>(true, predicate);
_eventActivities.Add(ea);
return(new EventActivitySetBuilder <TEvent, TData>(ea));
}
public GenericOutput <Event> EventSelect(EventPredicate eventPredicate)
{
if (eventPredicate != null)
{
eventPredicate.PersonPredicate = PersonPredicate(eventPredicate.PersonPredicate);
}
return(ModelData.Instance.EventSelect(eventPredicate));
}
public GenericOutput <Event> EventSelect(EventPredicate eventPredicate)
{
return(Action("[Feed].[Event.Action]", new GenericInput <Event, EventPredicate>
{
ActionType = ActionType.EventSelect,
Predicate = eventPredicate
}));
}
public Event GetEventFromSupplyToBuy(GameState gameState, EventPredicate acceptableEvent)
{
var saved = gameState.self;
gameState.self = this.self;
var result = this.playerAction.GetEventFromSupplyToBuy(gameState, acceptableEvent);
gameState.self = saved;
return(result);
}
public void CallOnMessageIf(Message event_type, EventCallback callback,
EventPredicate predicate)
{
onMessage[event_type] += (object o) =>
{
if (predicate(o))
{
callback(o);
}
};
}
public void CallOnMessageIf(Message event_type, EventCallback callback,
EventPredicate predicate, bool early = false)
{
if (early)
{
onMessage_early[event_type] += (object o) =>
{
if (predicate(o))
{
callback(o);
}
};
}
else
{
onMessage[event_type] += (object o) =>
{
if (predicate(o))
{
callback(o);
}
};
}
}
private async Task QueryAsync(Func <StoredEvent, Task> callback, StreamPosition lastPosition, EventFilter filterDefinition, EventPredicate filterExpression, CancellationToken ct = default)
{
using (Profiler.TraceMethod <MongoEventStore>())
{
await Collection.Find(filterDefinition, options : Batching.Options).Sort(Sort.Ascending(TimestampField)).ForEachPipelineAsync(async commit =>
{
var eventStreamOffset = (int)commit.EventStreamOffset;
var commitTimestamp = commit.Timestamp;
var commitOffset = 0;
foreach (var @event in commit.Events)
{
eventStreamOffset++;
if (commitOffset > lastPosition.CommitOffset || commitTimestamp > lastPosition.Timestamp)
{
var eventData = @event.ToEventData();
if (filterExpression(eventData))
{
var eventToken = new StreamPosition(commitTimestamp, commitOffset, commit.Events.Length);
await callback(new StoredEvent(commit.EventStream, eventToken, eventStreamOffset, eventData));
}
}
commitOffset++;
}
}, ct);
}
}
public GenericOutput <Event> EventSelect(EventPredicate eventPredicate)
{
return(ModelLogic.Instance.EventSelect(eventPredicate));
}
public EventActivitySetBuilder <TEvent, TData> Then(EffectFunc <TEvent, TData> func, EventPredicate <TEvent, TData> predicate = null)
{
_eventActivitySet.AddEffectHandler((whenEvent, data) =>
{
if (predicate != null && !predicate(whenEvent, data))
{
return(Effect.Pure());
}
return(func(whenEvent, data));
});
return(this);
}
public EventActivitySetBuilder <TEvent, TData> SetState(SetStateFunc <TEvent, TData> func, EventPredicate <TEvent, TData> predicate = null)
{
_eventActivitySet.AddSetStateHandler((whenEvent, data) =>
{
if (predicate != null && !predicate(whenEvent, data))
{
return(data.Data);
}
return(func(whenEvent, data));
});
return(this);
}
public void UseForCompletion(EventPredicate <TEvent, TData> predicate = null)
{
_completionPredicate = predicate;
CompletesProcess = true;
}
virtual public Event GetEventFromSupplyToBuy(GameState gameState, EventPredicate eventPredicate)
{
return(NoEvent());
}
public EventActivitySetBuilder <TEvent, TData> SendCommand <T>(Func <TEvent, InstanceData <TData>, T> handler, EventPredicate <TEvent, TData> predicate = null)
where T : ICommand
{
Then((whenEvent, state) =>
{
var command = handler(whenEvent, state);
return(MessageBus.Publish(command));
}, predicate);
return(this);
}
public virtual Event GetEventFromSupplyToBuy(GameState gameState, EventPredicate acceptableCard)
{
return(this.playerAction.GetEventFromSupplyToBuy(gameState, acceptableCard));
}
private async Task QueryAsync(Func <StoredEvent, Task> callback, StreamPosition lastPosition, SqlQuerySpec query, EventPredicate filterExpression, CancellationToken ct = default)
{
using (Profiler.TraceMethod <CosmosDbEventStore>())
{
await documentClient.QueryAsync(collectionUri, query, async commit =>
{
var eventStreamOffset = (int)commit.EventStreamOffset;
var commitTimestamp = commit.Timestamp;
var commitOffset = 0;
foreach (var @event in commit.Events)
{
eventStreamOffset++;
if (commitOffset > lastPosition.CommitOffset || commitTimestamp > lastPosition.Timestamp)
{
var eventData = @event.ToEventData();
if (filterExpression(eventData))
{
var eventToken = new StreamPosition(commitTimestamp, commitOffset, commit.Events.Length);
await callback(new StoredEvent(commit.EventStream, eventToken, eventStreamOffset, eventData));
}
}
commitOffset++;
}
}, ct);
}
}
public void Complete(EventPredicate <TEvent, TData> predicate = null)
{
_eventActivitySet.UseForCompletion(predicate);
Then((whenEvent, state) => Timeout.Cancel(state.InstanceId.ToString()), predicate);
}
public EventActivitySetBuilder <TEvent, TData> PublishEvent <T>(Func <TEvent, InstanceData <TData>, T> handler, EventPredicate <TEvent, TData> predicate = null)
where T : IEvent
{
Then((whenEvent, state) =>
{
var @event = handler(whenEvent, state);
return(MessageBus.Publish(@event));
}, predicate);
return(this);
}
