public override string Execute(EventEntry evtlog) { if (ranges == null) { return goto_failure; } bool contain = false; foreach (KeyValuePair<IPAddress, int> range in ranges) { IPAddress network = Utils.GetNetwork(evtlog.Address, range.Value); Log.Info("RangeFile::Execute: " + evtlog.Address + "/" + range.Value + " -> " + network + (range.Key.Equals(network) ? "" : " not") + " in " + range.Key + "/" + range.Value); if (range.Key.Equals(network)) { contain = true; break; } } if (!contain) { return goto_failure; } if (evtlog.HasProcData("RangeFile.All")) { string all = evtlog.GetProcData<string>("RangeFile.All"); evtlog.SetProcData("RangeFile.All", all + "," + Name); } else { evtlog.SetProcData("RangeFile.All", Name); } evtlog.SetProcData("RangeFile.Last", Name); // try to find email address for minimum IP range foreach (int prefix in prefixes.Reverse()) { string mail; IPAddress network = Utils.GetNetwork(evtlog.Address, prefix); if (rangesEmail.TryGetValue(network + "/" + prefix, out mail)) { evtlog.SetProcData(Name + ".Range", network + "/" + prefix); if (!string.IsNullOrEmpty(mail)) { evtlog.SetProcData(Name + ".Mail", mail); } break; } } return goto_success; }
public override string Execute(EventEntry evtlog) { if (itype != null) { Log.Error("regex: " + itype.ToString() + ", data: " + evtlog.Input.InputType); if (!itype.IsMatch(evtlog.Input.InputType)) { return goto_failure; } } if (input != null) { Log.Error("regex: " + input.ToString() + ", data: " + evtlog.Input.InputName); if (!input.IsMatch(evtlog.Input.InputName)) { return goto_failure; } } if (selector != null) { Log.Error("regex: " + selector.ToString() + ", data: " + evtlog.Input.SelectorName); if (!selector.IsMatch(evtlog.Input.SelectorName)) { return goto_failure; } } return goto_success; }
internal static string JsonSerializePayload(EventEntry entry) { try { using (var writer = new StringWriter(CultureInfo.InvariantCulture)) using (var jsonWriter = new JsonTextWriter(writer) { Formatting = Newtonsoft.Json.Formatting.Indented, CloseOutput = false }) { EventEntryUtil.JsonWritePayload(jsonWriter, entry); jsonWriter.Flush(); return writer.ToString(); } } catch (JsonWriterException jwe) { SemanticLoggingEventSource.Log.EventEntrySerializePayloadFailed(jwe.ToString()); var errorDictionary = new Dictionary<string, object> { { "Error", string.Format(CultureInfo.CurrentCulture, Properties.Resources.JsonSerializationError, jwe.Message) } }; return JsonConvert.SerializeObject(errorDictionary, Newtonsoft.Json.Formatting.Indented); } }
public static void Raise(string eventName, IGameObject sender, EventArgs args) { var key = new EventEntry(sender, eventName); if(!Entries.ContainsKey(key)) { Log.Warning("A handler for the event '{0}' was not found while attempting to raise the event.", eventName); return; } var list = Entries[key]; var removes = new List<WeakReference>(); foreach (var weakRef in list) { if (!weakRef.IsAlive || weakRef.Target != null) { removes.Add(weakRef); continue; } var action = (Action<IGameObject, EventArgs>) weakRef.Target; if (action == null) continue; action(sender, args); } foreach (var weakReference in removes) { Entries[key].Remove(weakReference); } }
public override string Execute(EventEntry evtlog) { if (string.IsNullOrEmpty(this.interval)) return goto_next; ProcessorEventStringTemplate tpl = new ProcessorEventStringTemplate(evtlog); string value = tpl.Apply(this.interval); int intvl; if (!int.TryParse(value, out intvl)) { Log.Info("unable to parse \"" + value + "\" as integer"); return goto_next; } switch (mode) { case SleepMode.Normal: Thread.Sleep(1000 * intvl); break; case SleepMode.Random: Thread.Sleep(rnd.Next(1000 * intvl)); break; default: Log.Warn("unsupported sleep mode " + mode); break; } return goto_next; }
public override string Execute(EventEntry evtlog) { if (!evtlog.HasProcData("Fail2ban.Last")) { throw new ArgumentException("Missing Fail2ban.Last, no Fail2ban processor reached fail treshold"); } string fail2banName = evtlog.GetProcData<string>("Fail2ban.Last"); if (!evtlog.HasProcData(fail2banName + ".Address")) { throw new ArgumentException("Missing " + fail2banName + ".Address!?"); } if (!evtlog.HasProcData(fail2banName + ".Prefix")) { throw new ArgumentException("Missing " + fail2banName + ".Prefix!?"); } IPAddress addr = evtlog.GetProcData<IPAddress>(fail2banName + ".Address"); int prefix = evtlog.GetProcData<int>(fail2banName + ".Prefix"); int btime = evtlog.GetProcData(fail2banName + ".Bantime", bantime); // check in memory cache with recently send F2B messages string recentKey = null; long now = DateTimeOffset.Now.Ticks; if (max_ignore > 0) { recentKey = Name + "[" + addr + "/" + prefix + "]"; object cacheEntry = recent[recentKey]; if (cacheEntry != null) { Tuple<long, int> item = (Tuple<long, int>)cacheEntry; long ticksDiff = Math.Abs(item.Item1 - now); if (ticksDiff < TimeSpan.FromSeconds(btime).Ticks / 100) { Log.Info("Skipping F2B firewall for recent address (" + TimeSpan.FromTicks(ticksDiff).TotalSeconds + "s ago)"); return goto_next; } } } long expiration = DateTime.UtcNow.Ticks + btime * TimeSpan.TicksPerSecond; ExecuteFail2banAction(evtlog, addr, prefix, expiration); // add this message to in memory cache of recently send F2B messages if (max_ignore > 0) { long bantimeTicks = TimeSpan.FromSeconds(btime).Ticks / 100; long expirationTicks = Math.Min(bantimeTicks, TimeSpan.FromSeconds(max_ignore).Ticks); TimeSpan expirationOffset = TimeSpan.FromTicks(expirationTicks); DateTimeOffset absoluteExpiration = DateTimeOffset.Now + expirationOffset; recent.Add(recentKey, new Tuple<long, int>(now, btime), absoluteExpiration); } return goto_next; }
public void TestAddEventWithTwoArguments() { var entry = new EventEntry() { Title = "C# exam", Date = new DateTime(2012, 03, 26, 9, 00, 00) }; manager.AddEvent(entry); var actual = manager.ListEvents(new DateTime(2012, 03, 26, 9, 00, 00), 1).ToArray()[0].ToString(); var expected = "2012-03-26T09:00:00 | C# exam"; Assert.AreEqual(expected, actual); }
public static void Register(string eventName, IGameObject owner, Action<IGameObject, EventArgs> handler) { var key = new EventEntry(owner, eventName); if (!Entries.ContainsKey(key)) Entries[key] = new List<WeakReference>(); Entries[key].Add(new WeakReference(handler)); }
public override string Execute(EventEntry evtlog) { foreach (string processor in processors) { Produce(new EventEntry(evtlog), processor, EventQueue.Priority.Medium); } return goto_next; }
public void ShouldPreserveRemainingTimeWhenResetting() { var eventFrequency = TimeSpan.FromSeconds(1); var excessTime = TimeSpan.FromMilliseconds(250); var entry = new EventEntry((r, d) => null, eventFrequency); entry.UpdateElapsedTime(eventFrequency.Add(excessTime)); entry.ResetElapsedTime(); Assert.Equal(excessTime, entry.ElapsedTime); }
/// <summary> /// Formats the event as a string. /// </summary> /// <param name="entry">The entry to format.</param> /// <param name="formatter">The formatter to use.</param> /// <returns>A formatted entry.</returns> public static string WriteEvent(this IEventTextFormatter formatter, EventEntry entry) { Guard.ArgumentNotNull(formatter, "formatter"); using (var writer = new StringWriter(CultureInfo.CurrentCulture)) { formatter.WriteEvent(entry, writer); return writer.ToString(); } }
public void ShouldExpectToSendAfterElapsedTimePasses() { var frequency = TimeSpan.FromSeconds(1); var actualElapsed = TimeSpan.FromSeconds(2); var entry = new EventEntry((r, d) => null, frequency); entry.UpdateElapsedTime(actualElapsed); Assert.True(entry.ShouldSendEvent()); }
public static void Unregister(string eventName, IGameObject owner, Action<IGameObject, EventArgs> handler) { var key = new EventEntry(owner, eventName); if (!Entries.ContainsKey(key)) { Log.Warning("A handler for the event '{0}' was not found while attempting to unregister.", eventName); return; } var item = Entries[key].FirstOrDefault(wr => wr.IsAlive && wr.Target != null && (Action<IGameObject, EventArgs>)wr.Target == handler); Entries[key].Remove(item); }
public void TestDeleteNonExistingEvent() { var entry = new EventEntry() { Title = "C# exam", Date = new DateTime(2012, 03, 26, 9, 00, 00), Location = "Telerik" }; var actual = manager.DeleteEventsByTitle(entry.Title); var expected = 0; Assert.AreEqual(expected, actual); }
public void ShouldNotExpectToSendIfElapsedTimeHasNotPassed() { var frequency = TimeSpan.FromSeconds(2); var elapsed = TimeSpan.FromSeconds(1); var entry = new EventEntry((r, d) => null, frequency); entry.UpdateElapsedTime(elapsed); Assert.False(entry.ShouldSendEvent()); }
public void ShouldNotExpectToSendAfterReset() { var frequency = TimeSpan.FromSeconds(1); var elapsed = frequency.Add(TimeSpan.FromMilliseconds(100)); var entry = new EventEntry((r, d) => null, frequency); entry.UpdateElapsedTime(elapsed); Assert.True(entry.ShouldSendEvent()); entry.ResetElapsedTime(); Assert.False(entry.ShouldSendEvent()); }
private void ToggleFavoriteStatus(EventEntry entity) { entity.AttributesProxy.Extension.IsFavorite = !entity.AttributesProxy.Extension.IsFavorite; if (entity.AttributesProxy.Extension.IsFavorite) { _toastNotificationService.QueueEventNotifications(entity); } else { _toastNotificationService.DequeueEventNotifications(entity); } }
public void DequeueEventNotifications(EventEntry entity) { var parts = SplitGuid(entity.Id); var toasts = _toastNotificationManager .GetScheduledToastNotifications() .Where(a => a.Group.StartsWith("e:") && a.Id == parts.Item1 && a.Tag == parts.Item2); foreach (var toast in toasts) { _toastNotificationManager.RemoveFromSchedule(toast); } }
public void WriteEvent(EventEntry eventEntry, TextWriter writer) { if (throwOnWrite) { SemanticLoggingEventSource.Log.CustomFormatterUnhandledFault("unhandled exception from formatter"); } this.WriteEventCalls.Add(Tuple.Create(eventEntry, writer)); if (eventEntry.Payload.Count > 0) { writer.Write(eventEntry.Payload[0]); } }
internal static void JsonWritePayload(JsonWriter writer, EventEntry entry) { writer.WriteStartObject(); var eventSchema = entry.Schema; for (int i = 0; i < entry.Payload.Count; i++) { JsonWriteProperty(writer, eventSchema.Payload[i], entry.Payload[i]); } writer.WriteEndObject(); }
public void WriteEvent(EventEntry eventEntry, TextWriter writer) { if (throwOnWrite) { throw new InvalidOperationException(); } this.WriteEventCalls.Add(Tuple.Create(eventEntry, writer)); if (eventEntry.Payload.Count > 0) { writer.Write(eventEntry.Payload[0]); } }
public void WriteEvent(EventEntry eventData, TextWriter writer) { this.WriteEventCalls.Add(eventData); if (BeforeWriteEventAction != null) BeforeWriteEventAction(this); if (!string.IsNullOrWhiteSpace(eventData.FormattedMessage)) writer.Write(eventData.FormattedMessage); writer.Write(string.Join(",", eventData.Payload)); if (AfterWriteEventAction != null) AfterWriteEventAction(this); }
public override string Execute(EventEntry evtlog) { if (!(evtlog.LogData.GetType() == typeof(EventRecordWrittenEventArgs) || evtlog.LogData.GetType().IsSubclassOf(typeof(EventRecordWrittenEventArgs)))) { return goto_next; } EventRecordWrittenEventArgs evtarg = evtlog.LogData as EventRecordWrittenEventArgs; EventRecord evtrec = evtarg.EventRecord; string xmlString = evtrec.ToXml(); evtlog.SetProcData("EventData.XML", xmlString); evtlog.SetProcData("EventData.Description", evtrec.FormatDescription()); // process event XML data var doc = XDocument.Parse(xmlString); var namespaces = new XmlNamespaceManager(new NameTable()); var ns = doc.Root.GetDefaultNamespace(); namespaces.AddNamespace("ns", ns.NamespaceName); //foreach (var element in doc.XPathSelectElements("/ns:Event/ns:System/*", namespaces)) //{ // evtlog.SetProcData("Event.System." + element.Name.LocalName, element.Value); //} int dataCnt = 0; foreach (var element in doc.XPathSelectElements("/ns:Event/ns:EventData/ns:Data", namespaces)) { var path = element.AncestorsAndSelf().Select(e => e.Name.LocalName).Reverse(); var xPath = string.Join("/", path); var name = element.Attribute("Name"); if (name != null) { evtlog.SetProcData("EventData." + name.Value, element.Value); } else { evtlog.SetProcData("EventData[" + dataCnt + "]", element.Value); dataCnt++; } } if (dataCnt > 0) { evtlog.SetProcData("EventData", dataCnt); } return goto_next; }
public void ShouldTrackElapsedTimeAcrossMultipleUpdates() { const int FrequencyInSeconds = 2; var frequency = TimeSpan.FromSeconds(FrequencyInSeconds); var elapsed = TimeSpan.FromSeconds(FrequencyInSeconds / 2); var entry = new EventEntry((r, d) => null, frequency); // update 3 times, since 2 should not be enough to trigger entry.UpdateElapsedTime(elapsed); entry.UpdateElapsedTime(elapsed); entry.UpdateElapsedTime(elapsed); Assert.True(entry.ShouldSendEvent()); }
public static string RolesCount(this EventEntry model, Status?status = null) { var statuses = model.Signups .Where(s => status != null ? s.Status == status : s.Status != Status.RejectedOrNotPayed && s.Status != Status.Denied) .ToReadOnlyCollection(); if (model.RoleSignup) { var leads = statuses.Count(s => s.Role == DanceRole.Lead); var follows = statuses.Count(s => s.Role == DanceRole.Follow); return($"{leads}+{follows}"); } return(statuses.Count(s => s.Role == DanceRole.None).ToString()); }
public void testSaveUnisens() { eventEntry = unisens.createEventEntry("test.bin", sampleRate); eventEntry.setTypeLength(2); eventEntry.setCommentLength(11); eventEntry.setFileFormat(new BinFileFormatImpl()); eventEntry.append(events); unisens.closeAll(); unisens.save(); unisens = factory.createUnisens(EXAMPLE_TEMP_EVENT_ENTRY); Assert.AreEqual(timestampStart.ToString(), unisens.getTimestampStart().ToString()); eventEntry = (EventEntry)unisens.getEntry("test.bin"); Assert.AreEqual("BIN", eventEntry.getFileFormat().getFileFormatName()); Assert.AreEqual(sampleRate, eventEntry.getSampleRate(), 0); Assert.IsTrue(eventEntry.getFileFormat() is BinFileFormat); Assert.AreEqual(Endianess.LITTLE, ((BinFileFormat)eventEntry.getFileFormat()).getEndianess()); }
/// <summary> /// Writes the event. /// </summary> /// <param name="eventData">The <see cref="EventWrittenEventArgs" /> instance containing the event data.</param> /// <param name="writer">The writer.</param> public void WriteEvent(EventEntry eventEntry, TextWriter writer) { // Write header if (!string.IsNullOrWhiteSpace(this.Header)) { writer.WriteLine(this.Header); } if (eventEntry.Payload.First().ToString() == "error") { writer.WriteLine("This is an entry containing and error and should not be logged"); throw new InvalidOperationException("error"); } if (eventEntry.Schema.Level >= this.Detailed) { // Write properties writer.WriteLine("SourceId : {0}", eventEntry.ProviderId); writer.WriteLine("EventId : {0}", eventEntry.EventId); writer.WriteLine("Keywords : {0}", eventEntry.Schema.Keywords); writer.WriteLine("Level : {0}", eventEntry.Schema.Level); writer.WriteLine("Message : {0}", eventEntry.FormattedMessage); writer.WriteLine("Opcode : {0}", eventEntry.Schema.Opcode); writer.WriteLine("Task : {0} {1}", eventEntry.Schema.Task, eventEntry.Schema.EventName); writer.WriteLine("Version : {0}", eventEntry.Schema.Version); writer.WriteLine("Payload :{0}", FormatPayload(eventEntry)); writer.WriteLine("Timestamp : {0}", eventEntry.GetFormattedTimestamp(this.DateTimeFormat)); } else { writer.WriteLine("EventId : {0}, Level : {1}, Message : {2}, Payload :{3}, Timestamp : {4}", eventEntry.EventId, eventEntry.Schema.Level, eventEntry.FormattedMessage, FormatPayload(eventEntry), eventEntry.GetFormattedTimestamp(this.DateTimeFormat)); } // Write footer if (!string.IsNullOrWhiteSpace(this.Footer)) { writer.WriteLine(this.Footer); } writer.WriteLine(); }
private object CreateAuditEntityFromType(Type definingType, Type auditType, EventEntry entry) { var entity = entry.Entry.Entity; var auditEntity = Activator.CreateInstance(auditType); if (_ignoreMatchedPropertiesFunc == null || !_ignoreMatchedPropertiesFunc(auditType)) { var auditFields = GetPropertiesToSet(auditType); var entityFields = GetPropertiesToGet(definingType); foreach (var field in entityFields.Where(af => auditFields.ContainsKey(af.Key))) { var value = field.Value.GetValue(entity); auditFields[field.Key].SetValue(auditEntity, value); } } return(auditEntity); }
protected override void ExecuteFail2banAction(EventEntry evtlog, IPAddress addr, int prefix, long expiration) { ProcessorEventStringTemplate tpl = new ProcessorEventStringTemplate(evtlog); // run process without creating window System.Diagnostics.Process process = new System.Diagnostics.Process(); System.Diagnostics.ProcessStartInfo startInfo = new System.Diagnostics.ProcessStartInfo(); startInfo.WindowStyle = System.Diagnostics.ProcessWindowStyle.Hidden; startInfo.FileName = path; startInfo.Arguments = tpl.Apply(args); startInfo.UseShellExecute = false; //startInfo.EnvironmentVariables.Add("F2B_ADDRESS", address); //startInfo.EnvironmentVariables.Add("F2B_EXPIRATION", expiration.ToString()); process.StartInfo = startInfo; Log.Info("Fail2banCmdProcessor: executing command: " + startInfo.FileName + " " + startInfo.Arguments); process.Start(); }
internal static SqlDataRecord ToSqlDataRecord(this EventEntry record, string instanceName) { var sqlDataRecord = new SqlDataRecord(SqlMetaData); sqlDataRecord.SetValue(0, instanceName ?? string.Empty); sqlDataRecord.SetValue(1, record.ProviderId); sqlDataRecord.SetValue(2, record.Schema.ProviderName ?? string.Empty); sqlDataRecord.SetValue(3, record.EventId); sqlDataRecord.SetValue(4, (long)record.Schema.Keywords); sqlDataRecord.SetValue(5, (int)record.Schema.Level); sqlDataRecord.SetValue(6, (int)record.Schema.Opcode); sqlDataRecord.SetValue(7, (int)record.Schema.Task); sqlDataRecord.SetValue(8, record.Timestamp); sqlDataRecord.SetValue(9, record.Schema.Version); sqlDataRecord.SetValue(10, (object)record.FormattedMessage ?? DBNull.Value); sqlDataRecord.SetValue(11, (object)EventEntryUtil.XmlSerializePayload(record) ?? DBNull.Value); // sqlDataRecord.SetValue(12, record.ActivityId); // sqlDataRecord.SetValue(13, record.RelatedActivityId); // sqlDataRecord.SetValue(14, record.ProcessId); // sqlDataRecord.SetValue(15, record.ThreadId); sqlDataRecord.SetValue(12, EventEntryUtil.GetPayloadValue(record, "IpAddress")); sqlDataRecord.SetValue(13, EventEntryUtil.GetPayloadValue(record, "Source")); sqlDataRecord.SetValue(14, EventEntryUtil.GetPayloadValue(record, "UserName")); sqlDataRecord.SetValue(15, EventEntryUtil.GetPayloadValue(record, "SessionId")); sqlDataRecord.SetValue(16, I18NHelper.DateTimeOffsetParseInvariant(EventEntryUtil.GetPayloadValue(record, "OccurredAt"))); var actionName = EventEntryUtil.GetPayloadValue(record, "ActionName"); sqlDataRecord.SetValue(17, actionName); // if (!string.IsNullOrWhiteSpace(actionName)) // { Guid correlationId; if (Guid.TryParse(EventEntryUtil.GetPayloadValue(record, "CorrelationId"), out correlationId)) { sqlDataRecord.SetValue(18, correlationId); } double duration = 0; if (double.TryParse(EventEntryUtil.GetPayloadValue(record, "Duration"), out duration)) { sqlDataRecord.SetValue(19, duration); } // } return(sqlDataRecord); }
private object CreateAuditEntity(Type definingType, Type auditType, EventEntry entry) { var entity = entry.Entry.Entity; var auditEntity = Activator.CreateInstance(auditType); if (!_ignoreMatchedProperties) { var auditFields = auditType.GetProperties(BindingFlags.Public | BindingFlags.Instance).ToDictionary(k => k.Name); var entityFields = definingType.GetProperties(BindingFlags.Public | BindingFlags.Instance); foreach (var field in entityFields.Where(af => auditFields.ContainsKey(af.Name))) { var value = field.GetValue(entity); auditFields[field.Name].SetValue(auditEntity, value); } } return(auditEntity); }
private void ReadObjects() { var version = ReadInt(); var count = ReadInt(); for (var i = 0; i < count; i++) { Project.Objects.NextIndex = i; if (ReadInt() != 0) { var obj = Project.Objects.Create(); obj.Name = ReadString(); version = ReadInt(); obj.SpriteIndex = ReadInt(); obj.Solid = ReadBool(); obj.Visible = ReadBool(); obj.Depth = ReadInt(); obj.Persistent = ReadBool(); obj.Parent = ReadInt(); obj.MaskSpriteIndex = ReadInt(); var eventType = (EventType)ReadInt(); // Event type count minus 1 obj.Events = new Dictionary <EventType, List <EventEntry> >(); while (eventType >= 0) { obj.Events.Add(eventType, new List <EventEntry>()); int numb; while ((numb = ReadInt()) != -1) // Once we get to -1, we can decrement eventType. { var evt = new EventEntry(eventType, numb, GetActions()); obj.Events[eventType].Add(evt); } eventType -= 1; } } } }
private void WriteJsonEntry(EventEntry entry) { this.writer.WriteStartObject(); WriteValue("EventId", entry.EventId); WriteValue("EventName", entry.Schema.EventName); WriteValue("Timestamp", ToJsonIso8601(entry.Timestamp.UtcDateTime)); WriteValue("Keywords", (long)entry.Schema.Keywords); WriteValue("ProviderId", entry.Schema.ProviderId); WriteValue("ProviderName", entry.Schema.ProviderName); WriteValue("InstanceName", this.instanceName); WriteValue("Level", (int)entry.Schema.Level); WriteValue("Message", entry.FormattedMessage); WriteValue("Opcode", (int)entry.Schema.Opcode); WriteValue("Task", (int)entry.Schema.Task); WriteValue("Version", entry.Schema.Version); WriteValue("ProcessId", entry.ProcessId); WriteValue("ThreadId", entry.ThreadId); WriteValue("ActivityId", entry.ActivityId); WriteValue("RelatedActivityId", entry.RelatedActivityId); //If we are not going to flatten the payload then write opening if (!flattenPayload) { writer.WritePropertyName("Payload"); writer.WriteStartObject(); } foreach (var payload in entry.Schema.Payload.Zip(entry.Payload, Tuple.Create)) { this.WriteValue( this.flattenPayload ? string.Format(CultureInfo.InvariantCulture, PayloadFlattenFormatString, payload.Item1) : payload.Item1, payload.Item2); } //If we are not going to flatten the payload then write closing if (!flattenPayload) { writer.WriteEndObject(); } this.writer.WriteEndObject(); this.writer.WriteWhitespace("\n"); }
public EntryInfoPanel(EventEntry e, TimeSpan span) { tagBorder.Padding = new Thickness(6, 3, 6, 3); tagBorder.Margin = new Thickness(18, 3, 6, 3); tbkTimeOffset.Margin = new Thickness(12, 6, 0, 6); tbkDescription.Margin = new Thickness(18, 6, 0, 6); switch (e.GetTag()) { case "Deadline": tagBorder.Background = new SolidColorBrush(Colors.OrangeRed); if (span.Days < 4) { tagBorder.Background = new SolidColorBrush(Colors.Red); } break; case "Exam/Test": tagBorder.Background = new SolidColorBrush(Color.FromArgb(255, 255, 201, 14)); break; default: tagBorder.Background = new SolidColorBrush(Color.FromArgb(255, 200, 200, 200)); break; } tagText.Foreground = new SolidColorBrush(Colors.White); tagText.Text = e.GetTag(); DateTime date = e.GetDateTime(); if (span.Days == 0) { tbkTimeOffset.Text = (span.Hours != 0 ? (span.Hours + " hours ") : "") + span.Minutes + " minutes left"; } else { tbkTimeOffset.Text = span.Days + " days " + (span.Hours != 0 ? (span.Hours + " hours ") : "") + "left"; } tbkDescription.Text = "[ " + e.GetDescription() + " ]"; tagBorder.Child = tagText; Orientation = Orientation.Horizontal; // Children.Add(tagBorder); Children.Add(tbkTimeOffset); Children.Add(tbkDescription); }
/// <summary> /// Syncs the outlook calendar item. /// </summary> /// <param name="outlookCalendarItem">The outlook calendar item.</param> /// <param name="googleCalendarItems">The google calendar items.</param> private void SyncOutlookCalendarItem(AppointmentItem outlookCalendarItem, IEnumerable <EventEntry> googleCalendarItems) { var mergeables = googleCalendarItems.Mergeable(outlookCalendarItem).ToList(); EventEntry googleCalendarItem; if (mergeables.Any()) { googleCalendarItem = mergeables.First(); var changed = googleCalendarItem.MergeWith(outlookCalendarItem); try { if (changed) { googleCalendarItem = this.Repository.GoogleData.CalendarService.Update(googleCalendarItem); } } catch (GDataRequestException ex) { var response = ex.Response as HttpWebResponse; if (response != null && response.StatusCode != HttpStatusCode.Conflict) { // TODO: Add functionality to resolve update conflict. throw; } } } else { googleCalendarItem = new EventEntry(); var changed = googleCalendarItem.MergeWith(outlookCalendarItem); if (changed) { googleCalendarItem = this.Repository.GoogleData.CalendarService.Insert(ApplicationData.GoogleCalendarUri, googleCalendarItem); } } var outlookChanged = outlookCalendarItem.UserProperties.SetProperty("GoogleId", googleCalendarItem.EventId); if (outlookChanged) { outlookCalendarItem.Save(); } }
public void FilledEventEntryReturnsExpectedJaevnerEntry() { var entry = new JaevnerEntry(); entry.Title = "Title"; entry.Description = "Description"; entry.Location = "Location"; entry.StartDateTime = DateTime.Now; entry.EndDateTime = DateTime.Now.AddHours(1); EventEntry eventEntry = EntryConverter.GetEventEntry(entry); eventEntry.Title.Text.Should().Be("Title"); eventEntry.Content.Content.Should().Be("Description"); eventEntry.Locations[0].ValueString.Should().Be("Location"); eventEntry.Times[0].StartTime.Should().BeCloseTo(DateTime.Now, 5000); eventEntry.Times[0].EndTime.Should().BeCloseTo(DateTime.Now.AddHours(1), 5000); }
public void Produce(EventEntry item, string processor, EventQueue.Priority priority = EventQueue.Priority.Low) { if (equeue == null) { Log.Error("Unable to produce events before queue initialization!?!?"); return; } if (string.IsNullOrEmpty(processor)) { Log.Error("Unable to queue events with empty processor name"); return; } Log.Info("Service[" + item.Id + "@" + item.Input.Name + "] (re)queued message" + " with first processor name " + processor); equeue.Produce(item, processor, priority); }
public DbEventEntry(EventEntry entry, string payload) { ActivityId = entry.ActivityId; EventId = entry.EventId; FormattedMessage = entry.FormattedMessage; Keywords = (long)entry.Schema.Keywords; Level = (int)entry.Schema.Level; Opcode = (int)entry.Schema.Opcode; Payload = payload; ProcessId = entry.ProcessId; ProviderId = entry.ProviderId; ProviderName = entry.Schema.ProviderName; RelatedActivityId = entry.RelatedActivityId; Task = (int)entry.Schema.Task; ThreadId = entry.ThreadId; Timestamp = entry.Timestamp; Version = entry.Schema.Version; }
// =------------------------------------------------------------------ // = Methods // =------------------------------------------------------------------ protected virtual void AddEventHandler(object key, Delegate handler) { lock (this) { if (handler == null) { return; } for (EventEntry e = eventList; e != null; e = e.next) { if (e.key == key) { e.handler = Delegate.Combine(e.handler, handler); return; } } eventList = new EventEntry(eventList, key, handler); } }
public override string Execute(EventEntry evtlog) { if (value == null) { return(goto_next); } ProcessorEventStringTemplate tpl = new ProcessorEventStringTemplate(evtlog); string data = tpl.Apply(value); if (!regex.IsMatch(data)) { return(goto_failure); } return(goto_success); }
public override string Execute(EventEntry evtlog) { string user = evtlog.GetProcData <string>(username); if (string.IsNullOrEmpty(user)) { return(goto_error); } if (account.Exists(user, status)) { return(goto_success); } else { return(goto_failure); } }
private Guid GetExtentedPropertyValue(EventEntry entry) { var result = new Guid(); foreach (var extension in entry.ExtensionElements) { if (extension is ExtendedProperty) { var property = extension as ExtendedProperty; if (property.Name == SynchronisationProperty) { result = new Guid(property.Value); } break; } } return(result); }
public void StartingApplicationTest() { EventEntry _lastEvent = null; int _calls = 0; ObservableEventListener _listener = new ObservableEventListener(); IDisposable subscription = _listener.Subscribe(x => { _calls++; _lastEvent = x; }); using (SinkSubscription <ObservableEventListener> _sinkSubscription = new SinkSubscription <ObservableEventListener>(subscription, _listener)) { Assert.IsNotNull(_sinkSubscription.Sink); ReferenceApplicationEventSource _log = ReferenceApplicationEventSource.Log; _sinkSubscription.Sink.EnableEvents(_log, EventLevel.LogAlways, EventKeywords.All); Assert.IsNull(_lastEvent); _log.StartingApplication("Message handler name"); Assert.IsNotNull(_lastEvent); Assert.AreEqual <int>(1, _calls); //_lastEvent content Assert.AreEqual <int>(2, _lastEvent.EventId); Assert.AreEqual <Guid>(Guid.Empty, _lastEvent.ActivityId); string _message = "The application has been started using the message handling provider Message handler name."; Assert.AreEqual <string>(_message, _lastEvent.FormattedMessage, _lastEvent.FormattedMessage); //schema EventSchema _Schema = _lastEvent.Schema; Assert.AreEqual <string>("InfrastructureStart", _Schema.EventName); Assert.AreEqual <int>(2, _Schema.Id); //Assert.IsTrue((_Schema.Keywords & SemanticEventSource.Keywords.Diagnostic2) > 0); //Assert.AreEqual<string>("PackageContent", _Schema.KeywordsDescription); Assert.AreEqual <EventLevel>(EventLevel.Informational, _Schema.Level); Assert.AreEqual <string>("Start", _Schema.OpcodeName); Assert.AreEqual <EventOpcode>(EventOpcode.Start, _Schema.Opcode); Assert.AreEqual <Guid>(new Guid("D8637D00-5EAD-4538-9286-8C6DE346D8C8"), _Schema.ProviderId); Assert.AreEqual <string>("UAOOI-Networking-ReferenceApplication-Diagnostic", _Schema.ProviderName); Assert.AreEqual <string>("Infrastructure", _Schema.TaskName); Assert.AreEqual <EventTask>(Tasks.Infrastructure, _Schema.Task); Assert.AreEqual <int>(0, _Schema.Version); //Payload Assert.AreEqual <string>("System.Collections.ObjectModel.ReadOnlyCollection`1[System.Object]", _lastEvent.Payload.ToString(), _lastEvent.Payload.ToString()); Assert.AreEqual <int>(1, _lastEvent.Payload.Count); } }
private static string FormatPayload(EventEntry entry) { string strContext = null; string strCode = null; string strMessage = null; string strDetail = null; var eventSchema = entry.Schema; var sb = new StringBuilder(); for (int i = 0; i < entry.Payload.Count; i++) { switch ((string)eventSchema.Payload[i]) { case "strContext": strContext = (string)entry.Payload[i]; break; case "strCode": strCode = (string)entry.Payload[i]; break; case "strMessage": strMessage = (string)entry.Payload[i]; break; case "strDetail": strDetail = (string)entry.Payload[i]; break; } } switch (entry.EventId) { case 1: // auth failure sb.AppendFormat("{0}: {1}\r\n", strMessage, strDetail); break; case 2: // web failure sb.AppendFormat("{0}: {1}\r\n{2}\r\n", strCode, strDetail, strContext); break; } return(sb.ToString()); }
public async Task <string> Insert(Guid userId, string title, string content, DateTime start, DateTime end) { try { //同步到Google日历 var item = _iSysUserService.GetById(userId); if (string.IsNullOrEmpty(item.GoogleUserName) || string.IsNullOrEmpty(item.GooglePassword)) { return(""); } var myService = new CalendarService(item.GoogleUserName); myService.setUserCredentials(item.GoogleUserName, item.GooglePassword); // Set the title and content of the entry. var entry = new EventEntry { Title = { Text = "云集 " + title }, Content = { Content = content } }; //计划时间 var eventTime = new When(start, end); //判断是否为全天计划 if (start.Date != end.Date) { eventTime.AllDay = true; } entry.Times.Add(eventTime); var postUri = new Uri("https://www.google.com/calendar/feeds/default/private/full"); // Send the request and receive the response: var eventEntry = myService.Insert(postUri, entry); return(eventEntry.EventId); } catch { return(""); } }
private EventFeed createEventFeedFromEvents(List <DateTimeRange> events) { Uri uri = new Uri("http://localhost"); EventFeed result = new EventFeed(uri, null); result.TimeZone = new Google.GData.Calendar.TimeZone("EST"); foreach (DateTimeRange r in events) { EventEntry e = result.CreateFeedEntry() as EventEntry; DateTime start = DateTime.SpecifyKind(r.Start, DateTimeKind.Utc).ToLocalTime(); DateTime end = DateTime.SpecifyKind(r.End, DateTimeKind.Utc).ToLocalTime(); e.Times.Add(new When(start, end)); result.Entries.Add(e); } return(result); }
/// <summary> /// Write the formatted event output. /// </summary> /// <param name="eventEntry">The event data to be formatted.</param> /// <param name="writer">The writer to receive the formatted output.</param> public void WriteEvent(EventEntry eventEntry, TextWriter writer) { Guard.ArgumentNotNull(eventEntry, "eventEntry"); using (var jsonWriter = new JsonTextWriter(writer) { CloseOutput = false, Formatting = this.formatting }) { jsonWriter.WriteStartObject(); jsonWriter.WritePropertyName(PropertyNames.ProviderId); jsonWriter.WriteValue(eventEntry.ProviderId); jsonWriter.WritePropertyName(PropertyNames.EventId); jsonWriter.WriteValue(eventEntry.EventId); jsonWriter.WritePropertyName(PropertyNames.Keywords); jsonWriter.WriteValue((long)eventEntry.Schema.Keywords); jsonWriter.WritePropertyName(PropertyNames.Level); jsonWriter.WriteValue((int)eventEntry.Schema.Level); jsonWriter.WritePropertyName(PropertyNames.Message); jsonWriter.WriteValue(eventEntry.FormattedMessage); jsonWriter.WritePropertyName(PropertyNames.Opcode); jsonWriter.WriteValue((int)eventEntry.Schema.Opcode); jsonWriter.WritePropertyName(PropertyNames.Task); jsonWriter.WriteValue((int)eventEntry.Schema.Task); jsonWriter.WritePropertyName(PropertyNames.Version); jsonWriter.WriteValue(eventEntry.Schema.Version); jsonWriter.WritePropertyName(PropertyNames.Payload); EventEntryUtil.JsonWritePayload(jsonWriter, eventEntry); jsonWriter.WritePropertyName(PropertyNames.EventName); jsonWriter.WriteValue(eventEntry.Schema.EventName); jsonWriter.WritePropertyName(PropertyNames.Timestamp); jsonWriter.WriteValue(eventEntry.GetFormattedTimestamp(this.DateTimeFormat)); jsonWriter.WriteEndObject(); // Write an entry separator so all the logs can be read as an array, // adding the [] chars to the raw written data ( i.e: "[" + raw + "]" ) // where raw = {log1},{log2}, ... {logN}, jsonWriter.WriteRaw(EntrySeparator); // Writes new line when indented if (jsonWriter.Formatting == Newtonsoft.Json.Formatting.Indented) { jsonWriter.WriteRaw("\r\n"); } } }
private static string FormatPayload(EventEntry entry) { var eventSchema = entry.Schema; var sb = new StringBuilder(); for (int i = 0; i < entry.Payload.Count; i++) { try { sb.AppendFormat(" [{0} : {1}]", eventSchema.Payload[i], entry.Payload[i]); } catch (Exception e) { SemanticLoggingEventSource.Log.EventEntryTextWriterFailed(e.ToString()); sb.AppendFormat(" [{0} : {1}]", "Exception", string.Format(CultureInfo.CurrentCulture, TextSerializationError, e.Message)); } } return(sb.ToString()); }
public static string ToJson(this EventEntry eventEntry) { JObject jo = new JObject(); jo["EventId"] = eventEntry.EventId; jo["EventName"] = eventEntry.Schema.EventName; jo["ProviderId"] = eventEntry.ProviderId; jo["ProviderName"] = eventEntry.Schema.ProviderName; jo["TaskName"] = eventEntry.Schema.TaskName; jo["OpCodeName"] = eventEntry.Schema.OpcodeName; jo["Level"] = eventEntry.Schema.Level.ToString(); jo["KeywordsDescription"] = eventEntry.Schema.KeywordsDescription; jo["FormattedMessage"] = eventEntry.FormattedMessage; jo["Payload"] = eventEntry.Payload(); jo["Timestamp"] = eventEntry.Timestamp; jo["@timestamp"] = DateTimeOffset.UtcNow; return(jo.ToString()); }
/// <summary> /// Converts an <see cref="EventEntry"/> to a <see cref="EventRecord"/>. /// </summary> /// <param name="entry">The entry to convert.</param> /// <returns>A converted entry, or <see langword="null"/> if the payload is invalid.</returns> public static EventRecord TryConvertToEventRecord(this EventEntry entry) { var entity = new EventRecord() { ProviderId = entry.ProviderId, ProviderName = entry.Schema.ProviderName, EventId = entry.EventId, EventKeywords = (long)entry.Schema.Keywords, Level = (int)entry.Schema.Level, Opcode = (int)entry.Schema.Opcode, Task = (int)entry.Schema.Task, Timestamp = entry.Timestamp, Version = entry.Schema.Version, FormattedMessage = entry.FormattedMessage, Payload = EventEntryUtil.JsonSerializePayload(entry) }; return(entity); }
private static EventEntry AddChange(Change change) { var name = change.name; var startTime = change.DateParsed; var endTime = change.DateParsed.Date.Add(TimeSpan.Parse(change.endtime)); var eventEntry = new EventEntry(name, startTime, endTime); eventEntry.Description += "Diese Veranstaltung wurde nachträglich von dir hinzugefügt. Nutze 'Veranstaltungsänderungen' im Bot um dies anzupassen.\nhttps://t.me/HAWHHCalendarBot"; eventEntry.Location = change.room ?? string.Empty; eventEntry.PrettyName = "➕ " + name; if (!string.IsNullOrWhiteSpace(change.namesuffix)) { eventEntry.PrettyName += " " + change.namesuffix; } return(eventEntry); }
//public event OnCommitHandler OnCommit = null; /// <summary> /// Pushes the log entry to all registered <see cref="BaseLogDestination"/>s, in addition to calling notifying all NotifyEvent consumers. /// </summary> /// <param name="EventEntry">The log entry.</param> public override void NotifyGeneric(EventEntry EventEntry) { if (Categories != null && Categories.Count > 0) { EventEntry.Categories.AddRange(Categories); EventEntry.Categories = EventEntry.Categories.Distinct().ToList(); } base.NotifyGeneric(EventEntry); foreach (BaseLogDestination destination in Destinations) { if (destination.ShouldLog(EventEntry)) { destination.Log(EventEntry); } } }
// =------------------------------------------------------------------ // = Methods // =------------------------------------------------------------------ protected virtual void AddEventHandler(object key, Delegate handler) { // Locking 'this' here is ok since this is an internal class. See VSW#464499. lock (this) { if (handler == null) { return; } for (EventEntry e = eventList; e != null; e = e.next) { if (e.key == key) { e.handler = Delegate.Combine(e.handler, handler); return; } } eventList = new EventEntry(eventList, key, handler); } }
public static void AuditAction(AuditEvent ev, EventEntry entry, AuditLog audit) { audit.OriginalId = entry.PrimaryKey.First().Value.ToString(); audit.EntityType = entry.EntityType.Name; audit.EventType = entry.Action; audit.AuditDetails = GetCustomKey(ev, CustomFields.AuditDetails); audit.AuditDateTime = DateTime.Now; audit.AuditUser = GetCustomKey(ev, CustomFields.OverrideUser) ?? GetCustomKey(ev, CustomFields.AppUser) ?? ev.Environment.UserName; switch (audit.EventType) { case "Insert": audit.AuditData = JsonSerializer.Serialize(entry.ColumnValues, Audit.Core.Configuration.JsonSettings); break; case "Update": if (Boolean.Parse(GetCustomKey(ev, CustomFields.IncludeTypeInUpdate) ?? "false") && entry.ColumnValues.ContainsKey("Type")) { entry.Changes.Insert(0, new EventEntryChange { ColumnName = "Type", OriginalValue = entry.ColumnValues["Type"] }); } audit.AuditData = JsonSerializer.Serialize(entry.Changes, Audit.Core.Configuration.JsonSettings); break; } switch (entry.Entity) { case IHasRootEntityForAuditing entityWithParent: audit.RootEntity = entityWithParent.RootEntityType; audit.RootId = entityWithParent.RootId; break; case IOwnedEntityForAuditing ownedEntity: audit.RootEntity = ownedEntity.RootEntityType; audit.RootId = audit.OriginalId; break; } }
protected virtual void AddEventHandler(object key, Delegate handler) { lock (this) { if (handler != null) { for (EventEntry entry = this.eventList; entry != null; entry = entry.next) { if (entry.key == key) { entry.handler = Delegate.Combine(entry.handler, handler); goto Label_0060; } } this.eventList = new EventEntry(this.eventList, key, handler); } Label_0060 :; } }
public ActionResult Edit(int id, EventEntry collection) { try { var data = context.EventEntries.Single(x => x.Id == id); data.Name = collection.Name; data.Description = collection.Description; data.DateCreate = collection.DateCreate; data.DateUpdated = collection.DateUpdated; context.SubmitChanges(); // TODO: Add update logic here return(RedirectToAction("Index")); } catch { return(View()); } }
/// <summary> /// Runs the methods above to demonstrate usage of the .NET /// client library. The methods that add, update, or remove /// users on access control lists will not run by default. /// </summary> static void RunSample() { CalendarService service = new CalendarService("exampleCo-exampleApp-1"); service.setUserCredentials(userName, userPassword); // Demonstrate retrieving a list of the user's calendars. PrintUserCalendars(service); // Demonstrate various feed queries. PrintAllEvents(service); FullTextQuery(service, "Tennis"); DateRangeQuery(service, new DateTime(2007, 1, 5), new DateTime(2007, 1, 7)); // Demonstrate creating a single-occurrence event. EventEntry singleEvent = CreateSingleEvent(service, "Tennis with Mike"); Console.WriteLine("Successfully created event {0}", singleEvent.Title.Text); // Demonstrate creating a recurring event. AtomEntry recurringEvent = CreateRecurringEvent(service, "Tennis with Dan"); Console.WriteLine("Successfully created recurring event {0}", recurringEvent.Title.Text); // Demonstrate updating the event's text. singleEvent = UpdateTitle(singleEvent, "Important meeting"); Console.WriteLine("Event's new title is {0}", singleEvent.Title.Text); // Demonstrate adding a reminder. Note that this will only work on a primary // calendar. singleEvent = AddReminder(singleEvent, 15); Console.WriteLine("Set a {0}-minute reminder for the event.", singleEvent.Reminder.Minutes); // Demonstrate adding an extended property. AddExtendedProperty(singleEvent); // Demonstrate deleting the item. singleEvent.Delete(); // Demonstrate retrieving access control lists for all calendars. RetrieveAcls(service); }
public override string Execute(EventEntry evtlog) { if (template == null) { return goto_next; } ProcessorEventStringTemplate tpl = new ProcessorEventStringTemplate(evtlog); string label = tpl.Apply(template); if (service.HasProcessor(label)) { return label; } else { Log.Info("processor " + label + " not defined, using goto error"); return goto_error; } }
public void WriteEvent(EventEntry eventEntry, System.IO.TextWriter writer) { writer.Write("EventId=" + eventEntry.EventId + " "); writer.Write("EventName=" + eventEntry.Schema.EventName + " "); writer.Write("Level=" + eventEntry.Schema.Level + " "); writer.Write("\"FormattedMessage=" + eventEntry.FormattedMessage + "\" "); for (int i = 0; i < eventEntry.Payload.Count; i++) { try { if (i != 0) { writer.Write(" "); } writer.Write("\"{0}={1}\"", eventEntry.Schema.Payload[i], eventEntry.Payload[i]); } catch (Exception) { } } writer.WriteLine(); }
public override string Execute(EventEntry evtlog) { string firstRange = null; foreach (KeyValuePair<IPAddress, int> range in ranges) { IPAddress network = Utils.GetNetwork(evtlog.Address, range.Value); Log.Info("Range::Execute: " + evtlog.Address + "/" + range.Value + " -> " + network + (range.Key.Equals(network) ? "" : " not") + " in " + range.Key + "/" + range.Value); if (range.Key.Equals(network)) { firstRange = range.Key + "/" + range.Value; break; } } if (firstRange == null) { return goto_failure; } if (evtlog.HasProcData("Range.All")) { string all = evtlog.GetProcData<string>("Range.All"); evtlog.SetProcData("Range.All", all + "," + Name); } else { evtlog.SetProcData("Range.All", Name); } evtlog.SetProcData("Range.Last", Name); evtlog.SetProcData(Name + ".Range", firstRange); evtlog.SetProcData(Name + ".Mail", mail); return goto_success; }