public void Complete(ISchedulerContext context, bool wasCancelled)
{
if (context.Guild == null)
{
return;
}
var data = TitanLordTimerData.FromJson(context.Record.Data);
var settings = context.GuildSettings.Get <TitanLordSettings>(data.GroupId);
var messageChannel = context.Client.GetChannel(data.MessageChannelId) as IMessageChannel;
if (messageChannel == null || context.Author == null)
{
return;
}
if (data.MessageId != 0)
{
var message = messageChannel?.GetMessageAsync(data.MessageId)?.Result as IUserMessage;
message?.DeleteAsync().Wait();
}
if (!wasCancelled)
{
context.Replier.Reply(messageChannel, context.Author).WithMessage((RawString)settings.NowText.Contextualise(settings.CQ,
context.Record,
context.Record.EndTime,
context.GeneralGuildSetting.DateTimeFormat)).Send();
var history = Database?.AddOrGet(context.Guild.Id, () => new TitanLordHistory()).Result;
history?.SpawnTimes.Add(context.CycleTime);
Database?.Upsert(history);
}
}
public void Complete(ISchedulerContext context, bool wasCancelled)
{
if (!wasCancelled)
{
Handle(context);
}
}
public void Handle(ISchedulerContext context)
{
var endAt = DateTime.Now.AddMilliseconds(200);
while (DateTime.Now < endAt)
{
}
}
public static JobItem Create(ISchedulerContext ctx)
{
var definition = JobFactory.Interval("Foo1", () =>
{
return(Task.Factory.StartNew(() => Console.WriteLine("Foo1")));
}, TimeSpan.FromMinutes(10), "Some");
return(new InlineScheduler.Advanced.JobItemFactory(ctx).Create(definition));
}
public DateTime? NextExecution(IJobState state, ISchedulerContext context)
{
if (state.Status != JobStatus.Pending)
{
return null; // Have no clue
}
return context.GetCurrentTime().Date.Add(_dayTime);
}
public Scheduler(ISchedulerContext context = null)
{
context = context ?? new DefaultSchedulerContext();
_work = new JobManager(context);
_stopped = true;
_sartTime = DateTime.Now;
// Start timer
_timer = new Timer(OnTimerElapsed);
_timer.Change(TimeSpan.Zero, TimeSpan.FromMilliseconds(1000));
}
public Scheduler(ISchedulerContext context = null)
{
context = context ?? new DefaultSchedulerContext();
_work = new JobManager(context);
_stopped = true;
_sartTime = DateTime.Now;
// Start timer
_timer = new Timer(OnTimerElapsed);
_timer.Change(TimeSpan.Zero, TimeSpan.FromMilliseconds(1000));
}
public DiscoverCoreAssembliesBehavior(ExportExampleViewModel target, ISchedulerContext schedulerContext)
: base(target)
{
Target.LibrariesPath = ExportExampleHelper.TryAutomaticallyFindAssemblies();
Target.WhenPropertyChanged(x => x.LibrariesPath)
.Where(x => !string.IsNullOrEmpty(x))
.Select(ExportExampleHelper.SearchForCoreAssemblies)
.ObserveOn(schedulerContext.Dispatcher)
.Subscribe(b => Target.IsAssemblyOk = b)
.DisposeWith(this);
}
public Task <SimpleWorkflowResult> Start(ISchedulerContext schedulerContext, object input)
{
var s = schedulerContext.Default;
var task = Task.Factory.StartNew(() => TaskBody(input), s);
if (_subsequentStep != null)
{
task.Then(r => _subsequentStep.Start(schedulerContext, r.Result), s);
}
return(task);
}
/// <summary>
/// Asynchronously executes the action using <see cref="RpcClient"/>.
/// </summary>
/// <param name="serviceProvider">Dependency injection container for resolving services.</param>
/// <param name="context">Scheduler context for executing actions.</param>
/// <returns><c>Task</c> object executing the action.</returns>
/// <exception cref="InvalidOperationException"><see cref="RpcClient"/> object is not configured.</exception>
public async Task Execute(IServiceProvider serviceProvider, ISchedulerContext context)
{
var client = serviceProvider.GetService(typeof(RpcClient)) as RpcClient;
if (client == null)
{
throw new InvalidOperationException("RpcClient service not configured");
}
_parameters = _parameterResolver(context);
ActionStartTS = DateTime.Now;
ActionSkip = _canSkipPredicate(context);
ActionProcessed = false;
ActionError = false;
if (!ActionSkip)
{
try
{
XElement requestData = _messageDataResolver(context);
List <MessageParameter> requestParameters = new List <MessageParameter>();
foreach (var paramKey in _parameters.Keys)
{
requestParameters.Add(new MessageParameter(paramKey, _parameters[paramKey]));
}
RequestMessage request = new RequestMessage(ActionCode, requestData, requestParameters);
ResponseMessage response = await client.Execute(request, SecondsTimeout);
context.AppendContextData(this, response.Data);
ActionProcessed = true;
}
catch (Exception ex)
{
ErrorMessage = ex.Message;
ActionError = true;
}
}
else
{
ActionProcessed = true;
}
ActionEndTS = DateTime.Now;
if (ActionProcessed)
{
_postProcessing(context);
}
}
public JobItem(ISchedulerContext context, JobDefinition definition, WorkState presavedState = null)
{
_context = context;
_definition = definition;
_created = _context.GetCurrentTime();
if (presavedState != null)
{
_lastCompleteTime = presavedState.LastCompleteTime;
}
UpdateState();
}
public JobItem(ISchedulerContext context, JobDefinition definition, WorkState presavedState = null)
{
_context = context;
_definition = definition;
_created = _context.GetCurrentTime();
if (presavedState != null)
{
_lastCompleteTime = presavedState.LastCompleteTime;
}
UpdateState();
}
public bool Handle(ISchedulerContext context)
{
if (_lastCall.TryGetValue(context.Record.Id, out var lastTime) && lastTime > DateTime.Now.AddSeconds(-5))
{
return(true);
}
_lastCall.AddOrUpdate(context.Record.Id, DateTime.Now, (u, d) => DateTime.Now > d ? DateTime.Now : d);
if (context.Guild == null)
{
return(false);
}
var data = TitanLordTimerData.FromJson(context.Record.Data);
var settings = context.GuildSettings.Get <TitanLordSettings>(data.GroupId);
var actualTime = context.Record.EndTime.AddTicks(-((context.Record.EndTime - context.CycleTime + context.Delay).Ticks / context.Record.Interval.Ticks) * context.Record.Interval.Ticks);
var messageChannel = context.Client.GetChannel(data.MessageChannelId) as IMessageChannel;
if (messageChannel == null || context.Author == null)
{
return(false);
}
if (data.MessageId != 0)
{
if (messageChannel?.GetMessageAsync(data.MessageId)?.Result is IUserMessage message)
{
context.Replier.Modify(message, context.Author).ChangeMessage((RawString)settings.TimerText.Contextualise(settings.CQ,
context.Record,
actualTime,
context.GeneralGuildSetting.DateTimeFormat)).Modify();
}
}
foreach (var ping in settings.PrePings)
{
var pingTime = context.Record.EndTime.AddTicks(-ping * TimeSpan.TicksPerSecond);
if (pingTime.Between(context.CycleTime, context.CycleTime + context.Delay + context.Record.Interval))
{
context.Replier.Reply(messageChannel, context.Author).WithMessage((RawString)settings.InXText.Contextualise(settings.CQ,
context.Record,
pingTime,
context.GeneralGuildSetting.DateTimeFormat)).Send();
}
}
return(true);
}
public DateTime?NextExecution(IJobState state, ISchedulerContext context)
{
if (state.Status != JobStatus.Pending)
{
return(null); // Have no clue
}
if (state.LastComplete != null)
{
return(state.LastComplete.Value.Date.AddDays(1).Add(_dayTime));
}
return(context.GetCurrentTime().Date.Add(_dayTime));
}
public DateTime? NextExecution(IJobState state, ISchedulerContext context)
{
if (state.Status != JobStatus.Pending)
{
return null; // Have no clue
}
if (state.LastComplete != null)
{
return state.LastComplete.Value.Date.AddDays(1).Add(_dayTime);
}
return context.GetCurrentTime().Date.Add(_dayTime);
}
public AutoCompleteSearchBehaviour(MainWindowViewModel target, ISchedulerContext schedulerContext, IExampleSearchProvider searchProvider, IModule module)
: base(target)
{
_searchProvider = searchProvider;
_module = module;
var searchTextObs = Target.WhenPropertyChanged(x => x.SearchText);
searchTextObs.Skip(1).Subscribe(UpdateBlurEffect).DisposeWith(this);
searchTextObs.Where(x => !String.IsNullOrEmpty(x))
.Throttle(TimeSpan.FromMilliseconds(200), schedulerContext.Default)
.Select(SearchExamples)
.ObserveOn(schedulerContext.Dispatcher)
.Subscribe(UpdateSearchResults)
.DisposeWith(this);
}
public DateTime?NextExecution(IJobState state, ISchedulerContext context)
{
if (state.Status != JobStatus.Pending)
{
return(null); // Have no clue
}
if (state.LastComplete != null)
{
return(state.LastComplete + _interval);
}
else
{
var shift = context.GetNextRandom(200, (int)_interval.TotalMilliseconds / 3);
return(state.Created.AddMilliseconds(shift));
}
}
public async void Complete(ISchedulerContext context, bool wasCancelled)
{
var message = context.Record.Data;
if (string.IsNullOrWhiteSpace(message))
{
return;
}
var channel = await context.Author?.GetOrCreateDMChannelAsync();
if (channel == null)
{
return;
}
var timespan = DateTime.Now - context.Record.StartTime;
await context.Replier.Reply(channel, context.Author).WithMessage(new RawString("{0} ago you asked me to remind you this:\n{1}", timespan, message)).SendAsync();
}
public override void OnMapRequest(PLAggregatorDecisionRequest request, ISchedulerContext context)
{
policyCheckerAction = (new PolicyCheckerAction())
.WithParameters((schedulerContext) =>
{
var parameters = new Dictionary <string, object>();
parameters.Add("FIRST_NAME", request.FirstName);
parameters.Add("LAST_NAME", request.LastName);
parameters.Add("DOB", request.DOB.Date);
parameters.Add("POSTCODE", request.Postcode);
return(parameters);
});
getSoftQuoteAction = (new GetSoftQuoteAction())
.WithMessageData((schedulerContext) =>
{
XElement data = new XElement("ApplicantData");
data.Add(new XElement("FIRST_NAME", request.FirstName));
data.Add(new XElement("LAST_NAME", request.LastName));
data.Add(new XElement("DOB", request.DOB.ToString("dd/MM/yyyy", CultureInfo.InvariantCulture)));
data.Add(new XElement("POSTCODE", request.Postcode));
return(data);
})
.WithSkipCondition((schedulerContext) =>
{
var policyCheckerResult = schedulerContext.GetActionDataById(policyCheckerAction.Id);
var policyRules = policyCheckerResult.Descendants("PolicyRules").FirstOrDefault();
if (policyRules != null && policyRules.Attribute("Status").Value == "PASSED")
{
return(false);
}
else
{
return(true);
}
});
context.AppendAction(policyCheckerAction);
context.AppendAction(getSoftQuoteAction);
}
/// <summary>
/// Executes the actions configured in the scheduler context.
/// </summary>
/// <param name="request">Instance of the request object.</param>
/// <param name="context">Scheduler execution context.</param>
/// <returns><c>Task</c> object that completes when all the actions in the scheduler context finishes.</returns>
public async Task <RESPONSE> Execute(REQUEST request, ISchedulerContext context)
{
context.LogStartTime();
OnMapRequest(request, context);
await context.ExecuteActions();
context.LogEndTime();
if (context.Status == "ERROR")
{
throw new Exception(context.ErrorMessage);
}
else
{
RESPONSE response = OnMapResponse(context);
return(response);
}
}
public InitializationBehaviour(MainWindowViewModel target, IModule module, ISchedulerContext schedulerContext)
: base(target)
{
_module = module;
Task.Factory.StartNew(() =>
{
CreateInvertedIndex.CreateIndex(_module.Examples);
CreateInvertedIndex.CreateIndexForCode(_module.Examples);
})
.Then(() => Target.SearchBoxEnabled = true)
.Catch(ex => target.Exception = new ExceptionViewModel("Initialization Error", ex.Flatten()));
var groupsByCategory = _module.GroupsByCategory;
Target.Categories = groupsByCategory.Select(y => new ExampleCategoryViewModel()
{
Category = y.Key, Groups = y.Value
}).ToList();
int midCount = (Target.Categories.Count() - 1) / 2;
if (midCount >= 0 && midCount < Target.Categories.Count())
{
Target.SelectedCategory = Target.Categories.ElementAt(midCount);
}
Target.EverythingViewModel = new EverythingViewModel();
Target.WhenPropertyChanged(x => x.SelectedCategory)
.Do(_ => Target.IsBusy = true)
.Throttle(TimeSpan.FromMilliseconds(500))
.Do(c => Target.EverythingViewModel.SelectedCategory = c != null ? c.Category : null)
.Delay(TimeSpan.FromMilliseconds(200), schedulerContext.Default)
.ObserveOn(schedulerContext.Dispatcher)
.Subscribe(_ => Target.IsBusy = false)
.DisposeWith(this);
Target.WhenPropertyChanged(x => x.IsBusy)
.Skip(1)
.Subscribe(b => Target.BlurBackgroundParams = b ? _blurredParams : _defaultParams)
.DisposeWith(this);
}
public SearchExamplesBehaviour(MainViewModel target, ISchedulerContext schedulerContext) : base(target)
{
var assembly = typeof(MainWindow).Assembly;
_exampleTypes = assembly.GetTypes()
.Select(type => new ExampleCache {
Type = type, Attribute = (TestCaseAttribute)type.GetCustomAttributes(typeof(TestCaseAttribute), false).FirstOrDefault()
})
.Where(tuple => tuple.Attribute != null)
.ToList();
Target.RunExampleCommand = new ActionCommand(OnRunExample, () => Target.SelectedExample != null);
Target.WhenPropertyChanged(x => x.FilterText)
.Throttle(TimeSpan.FromMilliseconds(250), schedulerContext.Default)
.Select(DiscoverExamples)
.ObserveOn(schedulerContext.Dispatcher)
.Subscribe(UpdateExamples)
.DisposeWith(this);
}
public bool Handle(ISchedulerContext context)
{
if (context.Guild == null)
{
return(false);
}
var data = TitanLordTimerData.FromJson(context.Record.Data);
var settings = context.GuildSettings.Get <TitanLordSettings>(data.GroupId);
var messageChannel = context.Client.GetChannel(data.MessageChannelId) as IMessageChannel;
if (settings.RoundPings && messageChannel != null && context.Author != null)
{
context.Replier.Reply(messageChannel, context.Author).WithMessage((RawString)settings.RoundText.Contextualise(settings.CQ,
context.Record,
context.CycleTime,
context.GeneralGuildSetting.DateTimeFormat)).Send();
}
return(true);
}
public override PLAggregatorDecisionResponse OnMapResponse(ISchedulerContext context)
{
var result = new PLAggregatorDecisionResponse();
if (!getSoftQuoteAction.ActionError && !getSoftQuoteAction.ActionSkip)
{
var actionData = context.GetActionDataById(getSoftQuoteAction.Id);
result.Decision = actionData.Descendants("Decision").First().Value;
if (result.Decision != "DECLINE")
{
result.DecisionId = actionData.Descendants("DecisionId").First().Value;
result.Score = int.Parse(actionData.Descendants("Score").First().Value);
}
}
else
{
result.Decision = "DECLINE";
result.DecisionId = "";
result.Score = 0;
}
return(result);
}
public PopulateExamplesBehaviour(EverythingViewModel target, IModule module, ISchedulerContext schedulerContext) : base(target)
{
var categoryObs = Target.WhenPropertyChanged(x => x.SelectedCategory)
.Do(c =>
{
var allExamples = module.Examples;
var newDict = new Dictionary <Guid, Example>();
foreach (var example in allExamples)
{
if (c == null || example.Value.TopLevelCategory == c)
{
newDict.Add(example.Key, example.Value);
}
}
Target.Examples = newDict;
});
Observable.CombineLatest(Target.WhenPropertyChanged(x => x.SelectedGroupingMode), categoryObs, Tuple.Create)
.Where(tpl => tpl.Item1 != null && tpl.Item2 != null)
.ObserveOn(schedulerContext.Dispatcher)
.Subscribe(tpl => Target.UpdateEverythingSource(tpl.Item1.GroupingPredicate))
.DisposeWith(this);
}
/// <summary>
/// Executes the actions in parallel.
/// </summary>
/// <param name="serviceProvider">Dependency injection container for resolving services.</param>
/// <param name="context">Scheduler context for executing actions.</param>
/// <returns>A single <c>Task</c> object that completes when all the action finish execution.</returns>
public async Task Execute(IServiceProvider serviceProvider, ISchedulerContext context)
{
List <Task> actionTasks = new List <Task>();
foreach (var action in _actions)
{
actionTasks.Add(action.Execute(serviceProvider, context));
}
await Task.WhenAll(actionTasks);
if (_actions.Any(a => a.ActionError))
{
ActionError = true;
StringBuilder sb = new StringBuilder();
foreach (var errorMessage in _actions.Where(a => a.ActionError).Select(a => a.ErrorMessage))
{
sb.AppendLine(errorMessage);
}
ErrorMessage = sb.ToString();
}
}
public static JobItem Create(ISchedulerContext ctx)
{
var definition = JobFactory.Interval("Foo1", () =>
{
return Task.Factory.StartNew(() => Console.WriteLine("Foo1"));
}, TimeSpan.FromMinutes(10), "Some");
return new InlineScheduler.Advanced.JobItemFactory(ctx).Create(definition);
}
public SimpleWorkflow(ISchedulerContext schedulerContext)
{
_schedulerContext = schedulerContext;
}
public JobManager(ISchedulerContext context)
{
_context = context;
}
public void Handle(ISchedulerContext context)
{
Console.WriteLine("Tick " + context.Record.Id);
}
void IScheduler.Schedule(ISchedulerContext context, TaskInfo task)
{
Schedule((TSchedulerContext)context, (TTaskInfo)task);
}
Task IScheduler.Next(ISchedulerContext context)
{
return(Next((TSchedulerContext)context));
}
public JobItemFactory(ISchedulerContext context)
{
_context = context;
}
public JobItemFactory(ISchedulerContext context)
{
_context = context;
}
public JobManager(ISchedulerContext context)
{
_context = context;
}
/// <summary> /// Called before the <see cref="Execute(REQUEST, ISchedulerContext)"/> method. Use this method to setup the scheduler context. /// </summary> /// <param name="request">Instance of the request object.</param> /// <param name="context">Scheduler execution context.</param> public abstract void OnMapRequest(REQUEST request, ISchedulerContext context);
/// <summary> /// Called after the <see cref="Execute(REQUEST, ISchedulerContext)"/> method. Use this method to generate the response object. /// </summary> /// <param name="context">Scheduler execution context.</param> /// <returns>Generated response object.</returns> public abstract RESPONSE OnMapResponse(ISchedulerContext context);
