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;
}
