public void RegisterEvent(Func <IEnumerator> Event, string name, float minDiff, float weight, float cooldown)
{
EventSettings settings = GetEventSettings(name);
if (settings.Enabled)
{
Events.Add(new PacingEvent(Event, name, minDiff, weight, cooldown, settings));
}
}
public void DebounceStored()
{
var x = new EventSettings
{
DebounceInterval = 5
};
Assert.Equal(5, x.DebounceInterval);
}
//methods
public override List <SignalDispatch <TKey> > Build(EventSettings <TKey> settings, SignalEvent <TKey> signalEvent,
List <Subscriber <TKey> > subscribers, List <TemplateData> languageTemplateData)
{
List <string> bodies = FillTemplateProperty(ContentProvider, ContentTransformer, subscribers, languageTemplateData);
return(subscribers
.Select((subscriber, i) => AssembleHttpRequest(settings, signalEvent, subscriber, bodies[i]))
.Cast <SignalDispatch <TKey> >()
.ToList());
}
//methods
public override List <SignalDispatch <TKey> > Build(EventSettings <TKey> settings, SignalEvent <TKey> signalEvent,
List <Subscriber <TKey> > subscribers, List <TemplateData> languageTemplateData)
{
List <string> texts = FillTemplateProperty(TextProvider, TextTransformer, subscribers, languageTemplateData);
return(subscribers
.Select((subscriber, i) => AssembleSlackMessage(settings, signalEvent, subscriber, texts[i]))
.Cast <SignalDispatch <TKey> >()
.ToList());
}
public virtual async Task <EventSettings <TKey> > Select(TKey eventSettingsId)
{
TotalResult <List <EventSettings <TKey> > > allItems = await GetFromCacheOrFetch()
.ConfigureAwait(false);
EventSettings <TKey> item = allItems.Data.FirstOrDefault(
x => EqualityComparer <TKey> .Default.Equals(x.EventSettingsId, eventSettingsId));
return(item);
}
public void Initialize()
{
this.store.TransactionManager.DoWithinTransaction(() =>
{
var patternModel = this.store.ElementFactory.CreateElement <PatternModelSchema>();
var pattern = patternModel.Create <PatternSchema>();
var automationSettings = pattern.Create <AutomationSettingsSchema>();
this.settings = automationSettings.AddExtension <EventSettings>();
});
}
//methods
public virtual bool Execute(SignalWrapper <SignalDispatch <TKey> > item)
{
if (item.Signal.EventSettingsId == null)
{
//SignalDispatch can be provided by ISignalProver without EventSettingsId
return(true);
}
EventSettings <TKey> eventSettings = _eventSettingsQueries.Select(item.Signal.EventSettingsId.Value).Result;
if (eventSettings == null)
{
_logger.LogError(SenderInternalMessages.Common_NoServiceWithKeyFound,
typeof(EventSettings <TKey>), nameof(EventSettings <TKey> .EventSettingsId), item.Signal.EventSettingsId.Value);
_dispatchQueue.ApplyResult(item, ProcessingResult.NoHandlerFound);
return(false);
}
bool shouldConsolidate = ValidateRequiredProperties(item.Signal, eventSettings);
if (!shouldConsolidate)
{
//Continue processing dispatch without consolidation
return(true);
}
ITemplateDataConsolidator consolidator = MatchConsolidator(item.Signal, eventSettings.ConsolidatorId.Value);
if (consolidator == null)
{
_dispatchQueue.ApplyResult(item, ProcessingResult.NoHandlerFound);
return(false);
}
DispatchTemplate <TKey> dispatchTemplate = eventSettings.Templates == null
? null
: eventSettings.Templates.FirstOrDefault(x => EqualityComparer <TKey> .Default.Equals(x.DispatchTemplateId, item.Signal.DispatchTemplateId.Value));
if (dispatchTemplate == null)
{
_logger.LogError(SenderInternalMessages.Common_NoServiceWithKeyFound,
typeof(DispatchTemplate <TKey>), nameof(DispatchTemplate <TKey> .DispatchTemplateId), item.Signal.DispatchTemplateId.Value);
_dispatchQueue.ApplyResult(item, ProcessingResult.NoHandlerFound);
return(false);
}
IEnumerable <TemplateData[]> batches = GetTemplateDataBatches(item, consolidator.BatchSize);
TemplateData consolidatedData = consolidator.Consolidate(batches);
dispatchTemplate.Update(item.Signal, consolidatedData);
item.IsUpdated = true;
item.IsConsolidationCompleted = true;
return(true);
}
//methods
public override List <SignalDispatch <TKey> > Build(EventSettings <TKey> settings, SignalEvent <TKey> signalEvent
, List <Subscriber <TKey> > subscribers, List <TemplateData> languageTemplateData)
{
List <string> subjects = FillTemplateProperty(SubjectProvider, SubjectTransformer, subscribers, languageTemplateData);
List <string> bodies = FillTemplateProperty(BodyProvider, BodyTransformer, subscribers, languageTemplateData);
return(subscribers
.Select((subscriber, i) => AssembleEmail(settings, signalEvent, subscriber, subjects[i], bodies[i]))
.Cast <SignalDispatch <TKey> >()
.ToList());
}
public EventsViewModel()
{
_es = _sm.GetSettings(SettingType.Event) as EventSettings;
_bs = _sm.GetSettings(SettingType.Baisc) as BasicSettings;
WatchedEvents = new ObservableCollection <string>();
if (_es != null && _es.WatchedEvents != null)
{
_es.WatchedEvents.Values.ToList().ForEach(x => WatchedEvents.Add(x));
}
LoadAsync();
}
public override bool TryGiveQuestTo(Pawn questPawn, QuestDef questDef)
{
if (questPawn == null)
{
return(false);
}
EventSettings settings = Settings.EventsSettings["Quest_KillOrder"];
if (!settings.Active)
{
return(false);
}
if (!TryResolveTwoFaction(out Faction faction1, out Faction faction2))
{
return(false);
}
if (!TileFinder.TryFindPassableTileWithTraversalDistance(Find.AnyPlayerHomeMap.Tile, 8, 24, out int result))
{
return(false);
}
Pawn pawn = PawnGenerator.GeneratePawn(PawnKindDefOf.AncientSoldier, faction2);
Find.WorldPawns.PassToWorld(pawn);
if (pawn == null)
{
return(false);
}
TargetPawn = pawn;
Faction = faction1;
TicksToPass = Rand.Range(6, 12) * 60000;
id = QuestsManager.Communications.UniqueIdManager.GetNextQuestID();
GenerateRewards();
ShowInConsole = false;
QuestsManager.Communications.AddQuestPawn(questPawn, this);
QuestsManager.Communications.AddQuest(this);
if (TargetPawn == null)
{
return(false);
}
return(true);
}
public void SubscribeDocumentEventEnqueues()
{
var doc = new Document(new MyPage(), 100);
var settings = new EventSettings();
Assert.True(doc.CanDiscard);
SubscribeDelta.Enqueue(doc, settings);
Assert.False(doc.CanDiscard);
var q = doc.GetQueue();
Assert.NotEmpty(q);
}
public virtual async Task <EventSettings <ObjectId> > Select(ObjectId eventSettingsId)
{
var filter = Builders <EventSettings <ObjectId> > .Filter.Where(
p => p.EventSettingsId == eventSettingsId);
EventSettings <ObjectId> item = await _collectionFactory
.GetCollection <EventSettings <ObjectId> >()
.Find(filter)
.FirstOrDefaultAsync()
.ConfigureAwait(false);
return(item);
}
protected virtual ProcessingResult UpdateSubscribers(
EventSettings <TKey> settings, SignalEvent <TKey> signalEvent
, List <Subscriber <TKey> > subscribers, List <SignalDispatch <TKey> > dispatches)
{
if (settings.Updates == null ||
signalEvent.AddresseeType == AddresseeType.DirectAddresses)
{
return(ProcessingResult.Success);
}
_subscriberQueries.Update(settings.Updates, dispatches);
return(ProcessingResult.Success);
}
protected virtual SlackDispatch <TKey> AssembleSlackMessage(EventSettings <TKey> settings
, SignalEvent <TKey> signalEvent, Subscriber <TKey> subscriber, string content)
{
var dispatch = new SlackDispatch <TKey>()
{
Text = content,
Channel = Channel,
Username = Username
};
SetBaseProperties(dispatch, settings, signalEvent, subscriber);
return(dispatch);
}
protected override void Load()
{
EventSettings section = (EventSettings)ConfigurationManager.GetSection("Saga.Factory.Events");
if (section != null)
{
foreach (FactoryFileElement element in section.FolderItems)
{
WriteLine("Event Manager", "Loading event information from: {0} using format {1}", element.Path, element.Reader);
LoadParameterizedStreamContent(Saga.Structures.Server.SecurePath(element.Path), element.Reader);
}
}
}
private void DisplayEventSettings(EventSettings settings)
{
if (settings == null)
{
return;
}
cboSeries.SelectedValue = settings.seriesId;
cboActivities.SelectedValue = settings.activityId;
cboSession.SelectedValue = settings.sessionId;
txtSeason.Text = settings.season.ToString();
txtEventId.Text = settings.eventId.ToString();
}
private void UpdateEventSettings()
{
if (EventSettings == null)
{
EventSettings = new EventSettings();
}
EventSettings.seriesId = (int)cboSeries.SelectedValue;
EventSettings.activityId = (int)cboActivities.SelectedValue;
EventSettings.sessionId = (int)cboSession.SelectedValue;
EventSettings.season = Int32.Parse(txtSeason.Text);
EventSettings.eventId = Int32.Parse(txtEventId.Text);
}
EventSettings GetEventSettings(string name)
{
if (Settings.EventSettings.ContainsKey(name))
{
return(Settings.EventSettings[name]);
}
else
{
EventSettings NewSettings = new EventSettings();
Settings.EventSettings.Add(name, NewSettings);
return(NewSettings);
}
}
protected virtual HttpDispatch <TKey> AssembleHttpRequest(EventSettings <TKey> settings
, SignalEvent <TKey> signalEvent, Subscriber <TKey> subscriber, string content)
{
var dispatch = new HttpDispatch <TKey>()
{
Url = Url,
HttpMethod = HttpMethod,
Headers = Headers,
Content = content
};
SetBaseProperties(dispatch, settings, signalEvent, subscriber);
return(dispatch);
}
/// <summary>
/// Default constructor
/// </summary>
/// <param name="eventData">The event's details/data</param>
/// <param name="userSettings">Event tracker user settings</param>
/// <param name="displayedNotificationsCollection">Collection of displayed event notifications</param>
public EventViewModel(WorldEvent eventData, EventSettings userSettings, ICollection <EventViewModel> displayedNotificationsCollection)
{
this.EventModel = eventData;
this.userSettings = userSettings;
this.displayedNotifications = displayedNotificationsCollection;
this.IsVisible = true;
this.IsNotificationShown = false;
this.IsRemovingNotification = false;
this.State = EventState.Unknown;
this.TimerValue = TimeSpan.Zero;
this.userSettings.PropertyChanged += (o, e) => this.RefreshVisibility();
this.userSettings.HiddenEvents.CollectionChanged += (o, e) => this.RefreshVisibility();
}
/// <summary>
/// Initializes a new instance of the <see cref="Settings"/> class.
/// </summary>
public InstanceSettings(GlobalSettings globalSettings)
{
Global = globalSettings;
Away = new AwaySettings();
BadNickname = new BadNicknameSettings();
Control = new ControlSettings();
Event = new EventSettings();
Idle = new IdleSettings();
Message = new MessageSettings();
Record = new RecordSettings();
Sticky = new StickySettings();
TeamSpeak = new TeamSpeakServerSettings();
Vote = new VoteSettings();
}
/// <summary>
/// Initializes a new instance of the <see cref="Settings"/> class.
/// </summary>
public InstanceSettings(GlobalSettings globalSettings)
{
Global = globalSettings;
Away = new AwaySettings();
BadNickname = new BadNicknameSettings();
Control = new ControlSettings();
Event = new EventSettings();
Idle = new IdleSettings();
Message = new MessageSettings();
Record = new RecordSettings();
Sticky = new StickySettings();
TeamSpeak = new TeamSpeakServerSettings();
Vote = new VoteSettings();
}
private void ShowEventSettingInfo(Appointment e, bool newEvent)
{
MainWindowViewModel o1 = this.vm1;
EventSettings wnd = new EventSettings();
EventSettingsWindowViewModel s = wnd.vm1;
if (newEvent)
{
s.LoadNewEventInfo(e, o1.CalendarModel);
}
else
{
s.LoadEventInfo(e, o1.CalendarModel);
}
bool?res = wnd.ShowDialog();
}
public void InitializeContext()
{
this.store.TransactionManager.DoWithinTransaction(() =>
{
var patternModel = this.store.ElementFactory.CreateElement <PatternModelSchema>();
var pattern = patternModel.Create <PatternSchema>();
var automationSettings = pattern.Create <AutomationSettingsSchema>();
this.settings = automationSettings.AddExtension <EventSettings>();
});
this.validator = new EventSettingsValidations(Mock.Of <INuPatternCompositionService>())
{
ProjectTypeProvider = Mock.Of <INuPatternProjectTypeProvider>(),
};
validationContext = new ValidationContext(ValidationCategories.Save, this.settings);
}
public void PlugOptionsBlocking()
{
var settings = new EventSettings
{
BlockOptions = new BlockOptions
{
BlockedElementId = "a",
ShowElementId = "b",
ShowHtmlMessage = "c"
}
};
var x = new PlugOptions(settings);
Assert.Equal("a", x.BlockElementId);
Assert.Equal("b", x.BlockShownId);
Assert.Equal("c", x.BlockHTML);
}
protected virtual EmailDispatch <TKey> AssembleEmail(EventSettings <TKey> settings,
SignalEvent <TKey> signalEvent, Subscriber <TKey> subscriber, string subject, string body)
{
var dispatch = new EmailDispatch <TKey>()
{
ReceiverDisplayName = subscriber.Address,
MessageSubject = subject,
MessageBody = body,
IsBodyHtml = IsBodyHtml,
CCAddresses = CCAddresses,
BCCAddresses = BCCAddresses,
ReplyToAddresses = ReplyToAddresses
};
SetBaseProperties(dispatch, settings, signalEvent, subscriber);
return(dispatch);
}
public void EmailDispatchTemplate_BuildTest(string language, string expectedText)
{
//arrange
var emailTemplate = new EmailDispatchTemplate <long>()
{
BodyProvider = new ResourceTemplate(typeof(ContentRes), "ContentKey"),
BodyTransformer = new ReplaceTransformer()
};
var settings = new EventSettings <long>()
{
Subscription = new DAL.Parameters.SubscriptionParameters
{
CategoryId = 1
}
};
var signalEvent = new SignalEvent <long>();
var subscriberList = new List <Subscriber <long> >()
{
new Subscriber <long>()
{
SubscriberId = 2,
Language = language
}
};
var templateData = new List <TemplateData>()
{
new TemplateData(
keyValueModel: new Dictionary <string, string>()
{
{ "key", "value" }
},
objectModel: null,
language: language
)
};
//act
List <SignalDispatch <long> > actual = emailTemplate.Build(settings, signalEvent, subscriberList, templateData);
//assert
EmailDispatch <long> item = (EmailDispatch <long>)actual.First();
Assert.AreEqual(expectedText, item.MessageBody);
}
//methods
public virtual ProcessingResult SetSendingTime(EventSettings <TKey> settings, SignalEvent <TKey> signalEvent
, List <Subscriber <TKey> > subscribers, List <SignalDispatch <TKey> > dispatches)
{
if (signalEvent.AddresseeType == AddresseeType.DirectAddresses)
{
return(ProcessingResult.Success);
}
List <SubscriberScheduleSettings <TKey> > receivePeriods = SelectReceivePeriods(settings, subscribers);
Dictionary <TKey, Subscriber <TKey>[]> subscribersBySubscriberId = subscribers
.GroupBy(x => x.SubscriberId)
.ToDictionary(x => x.Key, x => x.ToArray());
Dictionary <TKey, SubscriberScheduleSettings <TKey>[]> receivePeriodsBySubscriberId = receivePeriods
.GroupBy(x => x.SubscriberId)
.ToDictionary(x => x.Key, x => x.ToArray());
foreach (SignalDispatch <TKey> dispatch in dispatches)
{
if (dispatch.ReceiverSubscriberId == null ||
dispatch.ScheduleSet == null ||
!subscribersBySubscriberId.ContainsKey(dispatch.ReceiverSubscriberId.Value) ||
!receivePeriodsBySubscriberId.ContainsKey(dispatch.ReceiverSubscriberId.Value))
{
continue;
}
Subscriber <TKey> subscriber = subscribersBySubscriberId[dispatch.ReceiverSubscriberId.Value]
.FirstOrDefault(x => x.DeliveryType == dispatch.DeliveryType);
if (subscriber == null)
{
continue;
}
List <SubscriberScheduleSettings <TKey> > dispatchReceivePeriods = receivePeriodsBySubscriberId[dispatch.ReceiverSubscriberId.Value]
.Where(x => x.Set == dispatch.ScheduleSet.Value)
.ToList();
bool isScheduled;
dispatch.SendDateUtc = GetSendTimeUtc(subscriber.TimeZoneId, dispatchReceivePeriods, out isScheduled);
dispatch.IsScheduled = isScheduled;
}
return(ProcessingResult.Success);
}
//methods
public virtual bool Execute(SignalWrapper <SignalDispatch <TKey> > item)
{
EventSettings <TKey> eventSettings = item.Signal.EventSettingsId == null
? null
: _eventSettingsQueries.Select(item.Signal.EventSettingsId.Value).Result;
if (eventSettings == null)
{
return(true);
}
if (eventSettings.StoreInHistory)
{
_flushQueues[FlushAction.Insert].Queue.Add(item.Signal);
}
return(true);
}
public async Task <EventSettings> GetLiveEventSettingsAsync()
{
EventSettings liveEvent = new EventSettings();
var feed = await GetLiveFeedAsync();
if (feed != null)
{
liveEvent.eventId = feed.race_id;
liveEvent.seriesId = feed.series_id;
liveEvent.activityId = feed.run_type;
liveEvent.sessionId = feed.run_id;
liveEvent.trackId = feed.track_id;
liveEvent.trackLength = feed.track_length;
}
return(liveEvent);
}
protected virtual EventHandleResult <Subscriber <TKey> > QuerySubscribers(
EventSettings <TKey> eventSettings, SignalEvent <TKey> signalEvent, SubscribersRangeParameters <TKey> rangeParameters)
{
if (eventSettings.Subscription == null)
{
_logger.LogError(SenderInternalMessages.Common_ParameterMissing, nameof(eventSettings.Subscription));
return(EventHandleResult <Subscriber <TKey> > .FromResult(ProcessingResult.Fail));
}
//use TopicId from SignalEvent over default one in EventSettings
//if both are null will not query for topic
rangeParameters.TopicId = signalEvent.TopicId ?? eventSettings.Subscription.TopicId;
//overwrite Subscription filters data with SignalEvent filters data
rangeParameters.SubscriberFilters = new Dictionary <string, string>();
rangeParameters.SubscriberFilters.Merge(eventSettings.Subscription.SubscriberFiltersData);
rangeParameters.SubscriberFilters.Merge(signalEvent.SubscriberFiltersData);
bool categoryParameterChecked = eventSettings.Subscription.CheckCategoryLastSendDate ||
eventSettings.Subscription.CheckCategoryEnabled ||
eventSettings.Subscription.CheckCategorySendCountNotGreater != null;
rangeParameters.SelectFromCategories = eventSettings.Subscription.CategoryId != null &&
categoryParameterChecked;
bool topicParameterChecked = eventSettings.Subscription.CheckTopicLastSendDate ||
eventSettings.Subscription.CheckTopicEnabled ||
eventSettings.Subscription.CheckTopicSendCountNotGreater != null;
//if delivery type is not specified, will look for topic settings for all delivery types
rangeParameters.SelectFromTopics = eventSettings.Subscription.CategoryId != null &&
rangeParameters.TopicId != null &&
topicParameterChecked;
List <Subscriber <TKey> > subscribers = _subscriberQueries
.Select(eventSettings.Subscription, rangeParameters).Result;
return(new EventHandleResult <Subscriber <TKey> >()
{
Items = subscribers,
IsFinished = subscribers.Count < rangeParameters.Limit,
Result = ProcessingResult.Success
});
}
