protected internal override void Execute <TOwner>(TriggerContext <TOwner> context)
{
if (!string.IsNullOrEmpty(Keys))
{
context.Driver.Perform(x => x.SendKeys(Keys));
}
}
public Task InvokeAsync(OnJoinTriggerInfo triggerInfo, TriggerContext context, CancellationToken cancellationToken)
{
_context = context;
_clientEvents.ClientConnected += OnClientConnected;
return(Task.Delay(TimeSpan.MaxValue, cancellationToken));
}
protected internal override void Process(ref TriggerContext triggerContext)
{
if (!_shouldTriggerPredicate(ref triggerContext))
{
triggerContext.Canceled = true;
}
}
public async Task InvokeAsync(ScheduledTriggerInfo triggerInfo, TriggerContext context, CancellationToken cancellationToken)
{
while (true)
{
var synchronizedTime = GetNextTriggerTime(triggerInfo, DateTimeOffset.UtcNow);
if (synchronizedTime == null)
{
return;
}
var nextTriggerTime = synchronizedTime.Value;
if (!triggerInfo.SynchronizeTimeZone)
{
//ignore offset
nextTriggerTime = new DateTimeOffset(nextTriggerTime.DateTime, DateTimeOffset.UtcNow.Offset);
}
context.ReportNextTrigger(nextTriggerTime);
await Task.Delay(nextTriggerTime - DateTimeOffset.UtcNow, cancellationToken);
//important: use synchronized time
var session = await context.CreateSession(SessionKey.Create("ScheduledTrigger", synchronizedTime.Value));
await session.Invoke();
}
}
/// <summary>
/// Called when [put].
/// </summary>
/// <param name="key">The key.</param>
/// <param name="document">The document.</param>
/// <param name="metadata">The metadata.</param>
/// <param name="transactionInformation">The transaction information.</param>
public override void OnPut(string key, RavenJObject document, RavenJObject metadata, TransactionInformation transactionInformation)
{
if (key.StartsWith("Raven/", true, CultureInfo.InvariantCulture)) // we don't deal with system documents
{
return;
}
if (TriggerContext.IsInTriggerContext)
{
return;
}
using (TriggerContext.Enter()) {
var meta = document["MetaData"] as RavenJObject;
if (meta != null)
{
var slug = meta.Value <string>("Slug");
RavenJToken parent;
if (document.TryGetValue("Parent", out parent) && parent.Type != JTokenType.Null)
{
var parentId = parent.Value <string>("Id");
var parentDocument = Database.Get(parentId, transactionInformation);
var parentUrl = parentDocument.DataAsJson.Value <JObject>("Metadata").Value <string>("Url");
if (parentUrl != null)
{
meta["Url"] = string.Format("{0}/{1}", parentUrl, slug);
base.OnPut(key, document, metadata, transactionInformation);
return;
}
}
meta["Url"] = slug;
}
}
base.OnPut(key, document, metadata, transactionInformation);
}
public override Task ExecuteAsync(TriggerContext context)
{
this.LastContext = context;
this.HitCount++;
return(Task.CompletedTask);
}
/// <summary>
/// The method to be called prior to the operation performed
/// </summary>
/// <param name="context">Contains the information about the operation performed and the document it is to be performed on</param>
public bool PreTrigger(TriggerContext context)
{
// The context contains the type of operation to be performed in the
// TriggerAction property i.e. if a document is being inserted, updated or deleted.
// A switch statement can be applied to perform a specific action on each of
// the operation type. The context also contains the document upon which the
// operation is going to be performed, hence providing the opportunity to perform an
// automated modification on the document beforehand.
switch (context.TriggerAction)
{
// This case is executed before inserting a new document
case TriggerAction.PreInsert:
return(IsValidUnitPrice(context.EventDocument));
// This case is executed before updating an existing document
case TriggerAction.PreUpdate:
return(IsValidUnitPrice(context.EventDocument));
// This case is executed before deleting an existing document
case TriggerAction.PreDelete:
break;
}
// The return statement controls the behavior of operation.
// A return false will cause the operation to fail.
return(true);
}
public CorrectAnswer(
TriggerContext triggerContext,
Specification <AnswerViewModel> meaningOfLifeSpecification)
{
_triggerContext = triggerContext;
_meaningOfLifeSpecification = meaningOfLifeSpecification;
}
public void Type_IsNotEmpty()
{
using var dbContext = new TestDbContext();
var sample1 = new TestModel();
var subject = new TriggerContext <object>(dbContext.Entry(sample1).Entity, dbContext.Entry(sample1).OriginalValues, ChangeType.Modified);
Assert.Equal(ChangeType.Modified, subject.ChangeType);
}
public async Task InvokeAsync(OnAppStartupTriggerInfo triggerInfo, TriggerContext context, CancellationToken cancellationToken)
{
var session = await context.CreateSession(SessionKey.Create("OnAppStartup", DateTimeOffset.UtcNow));
await session.Invoke();
await Task.Delay(int.MaxValue, cancellationToken);
}
public void UnmodifiedEntity_WhenTypeModified_IsNotEmpty()
{
using var dbContext = new TestDbContext();
var sample1 = new TestModel();
var subject = new TriggerContext <object>(dbContext.Entry(sample1).Entity, dbContext.Entry(sample1).OriginalValues, ChangeType.Modified);
Assert.NotNull(subject.UnmodifiedEntity);
}
protected AbstractStateMachine(
TriggerContext triggerContext,
StateContext stateContext)
{
TriggerContext = triggerContext;
StateContext = stateContext;
_triggersWithParameters = new List <StateMachine <TState, TTrigger> .TriggerWithParameters>();
}
public DeepThoughtController(
StateContext stateContext,
TriggerContext triggerContext,
IEnumerable <State> states,
IEnumerable <Trigger> triggers,
AbstractStateMachine <DeepThoughtStates.State, DeepThoughtTriggers.Trigger> stateMachine
) : base(stateContext, triggerContext, states, triggers, stateMachine)
{
}
/// <summary>
/// 觸發一個 DOM 事件
/// </summary>
/// <param name="selector"></param>
/// <param name="eventName"></param>
/// <param name="data"></param>
/// <returns></returns>
public static TriggerContext RaiseEvent(this TriggerContext trigger, string selector, string eventName, object data)
{
trigger.Add("event", new FireEventPack
{
selector = selector,
eventName = eventName,
data = data
});
return(trigger);
}
protected internal override void Execute <TOwner>(TriggerContext <TOwner> context)
{
if (context.Component is IClearable clearableComponent)
{
clearableComponent.Clear();
}
else
{
context.Component.Scope.ClearWithLogging();
}
}
protected internal override void Execute <TOwner>(TriggerContext <TOwner> context)
{
if (!string.IsNullOrEmpty(Keys))
{
context.Log.Start(new PressKeysLogSection((UIComponent)context.Component, Keys));
context.Driver.Perform(x => x.SendKeys(Keys));
context.Log.EndSection();
}
}
/// <summary>
/// 顯示訊息視窗
/// </summary>
/// <param name="message"></param>
/// <param name="title"></param>
/// <param name="type"></param>
/// <param name="timeout"></param>
/// <returns></returns>
public static TriggerContext Message(this TriggerContext trigger, object message, string title = null, MessageType type = MessageType.Info, int timeout = 2000)
{
trigger.Add("message", new MessagePack
{
title = title,
message = message.ToString(),
type = type,
timeout = timeout
});
return(trigger);
}
protected internal override void Execute <TOwner>(TriggerContext <TOwner> context)
{
var targetComponent = GetTargetComponent(context.Component, Of);
if (OnlyDescendants)
{
targetComponent.ClearCacheOfDescendants();
}
else
{
targetComponent.ClearCache();
}
}
protected StateMachineController(
StateContext stateContext,
TriggerContext triggerContext,
IEnumerable <State> states,
IEnumerable <Trigger> triggers,
AbstractStateMachine <TState, TTrigger> stateMachine)
{
_stateContext = stateContext;
_triggerContext = triggerContext;
_states = states;
_triggers = triggers;
StateMachine = stateMachine;
}
public async Task InvokeAsync(SystemRestartTriggerInfo triggerInfo, TriggerContext context, CancellationToken cancellationToken)
{
var now = DateTime.UtcNow;
var uptime = TimeSpan.FromMilliseconds(GetTickCount64());
var startupTime = now.Add(-uptime);
var session = await context.CreateSession(SessionKey.Create("SystemRestart"));
if (!session.Info.Executions.Any(x => x.CreatedOn > startupTime))
{
await session.Invoke();
}
await Task.Delay(TimeSpan.MaxValue, cancellationToken);
}
public async Task InvokeAsync(OnAppStartupTriggerInfo triggerInfo, TriggerContext context, CancellationToken cancellationToken)
{
var session = await context.CreateSession(SessionKey.Create("OnAppStart", DateTime.Now.Date));
if (triggerInfo.OncePerDay)
{
if (session.Info.Executions.Any())
{
await Task.Delay(int.MaxValue, cancellationToken);
}
}
await session.Invoke();
await Task.Delay(int.MaxValue, cancellationToken);
}
public void UnmodifiedEntity_WhenTypeModified_HoldsUnmodifiedStateAfterSaveChanges()
{
using var dbContext = new TestDbContext();
var sample1 = new TestModel {
Name = "test1"
};
dbContext.Add(sample1);
dbContext.SaveChanges();
var subject = new TriggerContext <TestModel>(dbContext.Entry(sample1).Entity, dbContext.Entry(sample1).OriginalValues.Clone(), ChangeType.Modified);
sample1.Name = "test2";
dbContext.SaveChanges();
Assert.NotNull(subject.UnmodifiedEntity);
Assert.Equal("test1", subject.UnmodifiedEntity.Name);
}
/// <summary>
/// The method to be called after to the operation performed
/// </summary>
/// <param name="context">Contains the information about the operation performed and the document it is performed on</param>
public void PostTrigger(TriggerContext context)
{
switch (context.TriggerAction)
{
// This case is executed after inserting a new document
case TriggerAction.PostInsert:
break;
// This case is executed after updating an existing document
case TriggerAction.PostUpdate:
break;
// This case is executed after deleting an existing document
case TriggerAction.PostDelete:
break;
}
}
public IDisposable Start([NotNull] IEnumerable <IJob> jobs)
{
var contexts = new List <TriggerContext>();
foreach (var job in jobs)
{
foreach (var trigger in job.Triggers)
{
var context = new TriggerContext(this, job, trigger);
this.triggerContexts.Add(context);
contexts.Add(context);
trigger.Enable(context);
}
}
return(new ActionOnDispose(() => this.Stop(contexts)));
}
public override void Trigger <T>(TriggerContext <T> triggerContext)
{
ProducerBlock <T> producer = null;
if (triggerContext.Id != null)
{
Guid value = triggerContext.Id.Value;
if (!_blockContainer.TryGetProducer(value, out producer))
{
throw new Exception($"Cannot find producer with id {value}. Unable to trigger flow plan.");
}
}
else
{
producer = (ProducerBlock <T>)_blockContainer.Entrypoints.First();
}
producer.Trigger(triggerContext.Item);
}
protected internal abstract void Process(ref TriggerContext triggerContext);
public TriggerContext trigger() {
TriggerContext _localctx = new TriggerContext(Context, State);
EnterRule(_localctx, 194, RULE_trigger);
int _la;
try {
State = 1954;
switch ( Interpreter.AdaptivePredict(TokenStream,108,Context) ) {
case 1:
EnterOuterAlt(_localctx, 1);
{
State = 1932; k_trigger();
State = 1936;
ErrorHandler.Sync(this);
_la = TokenStream.La(1);
while (_la==SCOL) {
{
{
State = 1933; trigrel();
}
}
State = 1938;
ErrorHandler.Sync(this);
_la = TokenStream.La(1);
}
State = 1939; Match(COL);
State = 1940; dur_value();
State = 1941; Match(CRLF);
}
break;
case 2:
EnterOuterAlt(_localctx, 2);
{
State = 1943; k_trigger();
State = 1947;
ErrorHandler.Sync(this);
_la = TokenStream.La(1);
while (_la==SCOL) {
{
{
State = 1944; trigabs();
}
}
State = 1949;
ErrorHandler.Sync(this);
_la = TokenStream.La(1);
}
State = 1950; Match(COL);
State = 1951; date_time();
State = 1952; Match(CRLF);
}
break;
}
}
catch (RecognitionException re) {
_localctx.exception = re;
ErrorHandler.ReportError(this, re);
ErrorHandler.Recover(this, re);
}
finally {
ExitRule();
}
return _localctx;
}
