public void Send(SessionState sessionState, ISendProtocol sendProtocol, EventTypes eventType, Int32 refNum)
{
if (sendProtocol != null)
{
var header = new Header
{
eventType = eventType.ToString(),
refNum = refNum,
};
var data = new byte[0];
try
{
data = sendProtocol.Serialize(new Message
{
sessionState = sessionState,
header = header,
});
}
catch (Exception ex)
{
ex.Log();
}
header.length = (UInt32)(data == null ? 0 : data.Length);
switch (eventType)
{
case EventTypes.MSG_LISTOFALLROOMS:
header.refNum = (Int32)((MSG_LISTOFALLROOMS)sendProtocol).nbrRooms;
break;
case EventTypes.MSG_LISTOFALLUSERS:
header.refNum = (Int32)((MSG_LISTOFALLUSERS)sendProtocol).nbrUsers;
break;
}
PalaceAsyncSocket.Send(sessionState, header.Serialize(data));
}
else
{
var header = new Header
{
eventType = eventType.ToString(),
length = (UInt32)0,
refNum = refNum,
};
PalaceAsyncSocket.Send(sessionState, header.Serialize());
}
}
internal AutomationsCollection SetAutomation <TAutomation>(EventTypes eventType) where TAutomation : IAutomation
{
if (_automations.TryGetValue(eventType.ToString(), out var types))
{
types.Add(typeof(TAutomation));
}
else
{
_automations[eventType.ToString()] = new List <Type> {
typeof(TAutomation)
}
};
return(this);
}
public EventHandlerProperty(EventTypes eventType)
: base()
{
EventType = eventType;
TargetValueType = mdr.ValueTypes.Function;
//We should static or constants in the following methods to avoid expensive delegates!
OnGetDValue = (mdr.DObject This, ref mdr.DValue v) =>
{
var eventListeners = GetEventListeners(This, eventType);
var idlListener = eventListeners.IdlListener;
if (idlListener != null)
{
v.Set(idlListener);
}
else
{
v.Set(mdr.Runtime.Instance.DefaultDNull);
}
};
OnSetDValue = (mdr.DObject This, ref mdr.DValue v) =>
{
var eventListeners = GetEventListeners(This, eventType);
Debug.WriteLine("Setting the IDL listener for event type " + eventType.ToString() + " : type " + v.ValueType.ToString());
var idlListener = (v.ValueType == mdr.ValueTypes.Function) ? v.AsDFunction() : null;
eventListeners.IdlListener = idlListener;
};
}
public void Send(SessionState sessionState, ISendProtocol sendProtocol, EventTypes eventType, Int32 refNum)
{
var header = new Header
{
eventType = eventType.ToString(),
refNum = refNum,
};
try
{
header.message = sendProtocol?.SerializeJSON(new Message
{
sessionState = sessionState,
header = header,
});
}
catch (Exception ex)
{
ex.Log();
}
var json = JsonConvert.SerializeObject(new object[] {
header.eventType.ToString(),
header.refNum,
header.message,
});
WebAsyncSocket.Send(sessionState, connectionState, json);
}
public Task HandleEventAsync <T>(EventTypes eventType, T message)
{
return(Task.Run(() =>
Policy
.Handle <Exception>()
.WaitAndRetry(9, r => TimeSpan.FromSeconds(5), (ex, ts) => { Console.WriteLine("Error connecting to RabbitMQ. Retrying in 5 sec."); })
.Execute(() =>
{
var factory = new ConnectionFactory()
{
Uri = _uri
};
using (var connection = factory.CreateConnection())
{
using (var model = connection.CreateModel())
{
model.ExchangeDeclare(_exchange, "fanout", durable: true, autoDelete: false);
var data = JsonSerializer.Serialize(message);
IBasicProperties properties = model.CreateBasicProperties();
properties.Type = eventType.ToString();
model.BasicPublish(_exchange, "", properties, data);
}
}
})));
}
public void Send(string sender, EventTypes eventType, params object[] parameter)
{
lock (publisherSocket)
{
publisherSocket.SendMoreFrame(eventType.ToString()).SendFrame(EventMessage.Create(sender, parameter).GetBytes());
Debug.Log("Event send for " + eventType.ToString());
}
//Thread asyncSendingThread = new Thread(() =>
//{
// lock (localInstance.publisherSocket)
// {
// localInstance.publisherSocket.SendMoreFrame(eventType.ToString()).SendFrame(EventMessage.Create(sender, parameter).GetBytes());
// Debug.Log("Event send for " + eventType.ToString());
// }
//});
//asyncSendingThread.Start();
}
public UniEvent(EventTypes type)
{
Type = type;
Actions = new List<UniAction>();
Options = new JSONObject();
Options.AddField("type", Type.ToString());
}
public void SubscribeToEvent(EventTypes eventType, Action <string, object[]> delegateMethod)
{
var filter = eventType.ToString();
if (!subscriberDelegates.Keys.Contains(eventType.ToString()))
{
lock (subscriberDelegates)
{
subscriberDelegates.Add(filter, new HashSet <Action <string, object[]> >());
BackgroundWorker worker = new BackgroundWorker();
worker.WorkerSupportsCancellation = true;
worker.DoWork += FilteredBackgroundWorker;
worker.RunWorkerAsync(filter);
Debug.Log("Worker created for " + filter);
}
}
Debug.Log("Subscribed for " + filter);
subscriberDelegates[filter].Add(delegateMethod);
}
protected override bool OnCheck()
{
bool eventCheck = false;
if (toggleState)
{
if (savedEvent == eventType.ToString())
{
toggleValue = !toggleValue;
eventCheck = toggleValue;
}
}
else
{
if (savedEvent == eventType.ToString())
{
eventCheck = true;
}
}
// so we only process incoming event once
savedEvent = "";
return(eventCheck);
}
public EventHistoryData(string action, string aggregate, EventDetails details, string when, string who,
string category, string ip, EventTypes eventType)
{
Action = action;
When = when;
Who = who;
Aggregate = aggregate;
Category = category;
Ip = ip;
if ((int)eventType > 0)
{
EventType = eventType.ToString().AddSpacesToSentence();
}
Details = details?.Metadata;
}
/// <summary>
/// 触发事件
/// </summary>
/// <typeparam name="T1">参数类型1</typeparam>
/// <typeparam name="T2">参数类型2</typeparam>
/// <param name="eventType">事件类型</param>
/// <param name="arg1">参数1</param>
/// <param name="arg2">参数2</param>
public void TriggerEvent <T1, T2>(EventTypes eventType, T1 arg1, T2 arg2)
{
eventCollection.TryGetValue(eventType, out Delegate eventValue);
if (eventValue != null)
{
if (eventValue is Action <T1, T2> action)
{
action(arg1, arg2);
}
else
{
Console.WriteLine($"The right type of {eventType.ToString()} is {eventValue.GetType().FullName}");
}
}
}
private void PerformEventLookup(string query)
{
StoreIncident result = DefDatabase <StoreIncident> .AllDefs.FirstOrDefault(
i => i.cost > 0 && (i.abbreviation.ToToolkit().EqualsIgnoreCase(query.ToToolkit()) || i.defName.ToToolkit().EqualsIgnoreCase(query.ToToolkit()))
);
if (result == null)
{
return;
}
EventTypes eventType = result.GetModExtension <EventExtension>()?.EventType ?? EventTypes.Default;
switch (eventType)
{
case EventTypes.Default:
NotifyLookupComplete("TKUtils.Price.Limited".LocalizeKeyed(result.abbreviation.CapitalizeFirst(), result.cost.ToString("N0")));
return;
case EventTypes.Item:
case EventTypes.PawnKind:
case EventTypes.Trait:
NotifyLookupComplete("TKUtils.Price.Overridden".LocalizeKeyed(eventType.ToString()));
return;
case EventTypes.Misc:
NotifyLookupComplete("TKUtils.Price.External".Localize());
return;
case EventTypes.Variable:
NotifyLookupComplete(
new[]
{
"TKUtils.Price.Variables".LocalizeKeyed(result.abbreviation.CapitalizeFirst(), result.cost.ToString("N0")),
"TKUtils.Price.External".Localize()
}.GroupedJoin()
);
return;
}
}
public async System.Threading.Tasks.Task GenerateEventsAsync()
{
eventListItem.Clear();
calendarEvents = await apiClient.GetTodaysCalendarEvents("5c9cc5e521b8387d32991a5c");
foreach (var calenderEvent in calendarEvents)
{
EventTypes type = (EventTypes)Enum.Parse(typeof(EventTypes), calenderEvent.Type.ToString());
string json = JsonConvert.SerializeObject(calenderEvent.Data);
object data = calenderEvent.Data;
JObject d = JObject.FromObject(data);
eventListItem.Add(new CalendarModel()
{
EventType = type.ToString(),
EventDesc = d.GetValue("name").ToString()
});
}
}
public void ActionHandler(string actionString)
{
string actionType = PrismStringSplitter(actionString, 0);
switch (actionType)
{
case ("Keyboard"):
//einstellung in keymanager nachsehen
//enstprechende action aufrufen!
//Keyhandler
/// <param name="eventType"></param>
/// <param name="mouseKeyEventType"></param>
/// <param name="mouseKeyEventValue"></param>
/// <param name="HWNDString"></param>
/// <param name="dateTimeNow"></param>
///
EventTypes t = EventTypes.Keyboard;
Debug.WriteLine("Keyhandler" + t.ToString("G") + " " + Enum.GetName(typeof(EventTypes), EventTypes.Maus));
KeyHandler(actionString);
//hwnd id bei eventvalueparsing methode
//String foundId = treeOperations.searchNodes.getIdFilteredNodeByHwnd(test);
break;
case ("UIA"):
Debug.WriteLine("UIA Handler");
break;
default:
Debug.WriteLine("No Handler");
break;
}
}
//Aufschlüsselung der Informationen aus dem Event-String in ein OSMEvent-Format für die weitere Verarbeitung
//liefert den string, die eventid
public void EventValueParsing(string osm)
{
Debug.WriteLine("winevent verarbeitet in eventprocessor" + osm);
//osm = "werhers";
//Aufruf eienr Methode aus EventAction über startegymanager
//strategyManager.getSpecifiedEventAction().filterOSM();
//strategyManager.getSpecifiedEventManager().deliverActionListForEvent();
//strategyManager.getSpecifiedEventManager()
//id des events ermittelt
Debug.WriteLine("winevent verarbeitet in mainwindowxaml_" + osm);
string pattern = "_";
string[] substrings = System.Text.RegularExpressions.Regex.Split(osm, pattern);
//NodeBox.Text = ("osm" + osm + " " + substrings[0]);
IntPtr test;
test = (IntPtr)Convert.ToInt32(substrings[3]);
//string applicationName = strategyMgr.getSpecifiedOperationSystem().getProcessNameOfApplication((int)test);
Debug.WriteLine("osmpat" + test.ToString());
//id nur aus bereits gefiltertem osm-baum erhaltbar mit der methode getidfilterednodebyhwnd
//dazu muss hier auch der baum hier in treeoperation abfragbar sein, siehe InitializeFilterComponent in mainwindowxamls.cs von grantexample
//String foundId = treeOperation.searchNodes.getIdFilteredNodeByHwnd(osmData.properties.hWndFiltered);
String foundId = treeOperations.searchNodes.getIdFilteredNodeByHwnd(test);
Debug.WriteLine("osmpat2" + test.ToString() + " " + foundId);
EventTypes t = EventTypes.Keyboard;
Debug.WriteLine("Keyhandler" + t.ToString("G") + " " + Enum.GetName(typeof(EventTypes), EventTypes.Maus));
}
public EventHandlerProperty(EventTypes eventType)
: base()
{
EventType = eventType;
TargetValueType = mdr.ValueTypes.Function;
//We should static or constants in the following methods to avoid expensive delegates!
OnGetDValue = (mdr.DObject This, ref mdr.DValue v) =>
{
var eventListeners = GetEventListeners(This, eventType);
var idlListener = eventListeners.IdlListener;
if (idlListener != null)
v.Set(idlListener);
else
v.Set(mdr.Runtime.Instance.DefaultDNull);
};
OnSetDValue = (mdr.DObject This, ref mdr.DValue v) =>
{
var eventListeners = GetEventListeners(This, eventType);
Debug.WriteLine("Setting the IDL listener for event type " + eventType.ToString() + " : type " + v.ValueType.ToString());
var idlListener = (v.ValueType == mdr.ValueTypes.Function) ? v.AsDFunction() : null;
eventListeners.IdlListener = idlListener;
};
}
public static void AddTaskLog(this Events events, int taskId, EventTypes type, string description)
{
events.Event.AddEventRow(taskId, (int)type, description ?? type.ToString(), DateTime.Now);
}
XComment CreateEventComment( EventTypes aType, int aParameter )
{
string parameter = null;
Dictionary<int, string> parameterNames;
if ( aType == EventTypes.Create || aType == EventTypes.Destroy || aType == EventTypes.Draw )
return new XComment( "Node below refers to an event of type " + aType.ToString() );
else if ( aType == EventTypes.Alarm )
parameter = aParameter.ToString();
else if ( aType == EventTypes.Collision )
parameter = FindResourceName( m_gmk.Objects, aParameter );
else if ( aType == EventTypes.Keyboard || aType == EventTypes.KeyPress || aType == EventTypes.KeyRelease )
parameter = GetKeyName( aParameter );
else if ( aType == EventTypes.Trigger )
parameter = FindResourceName( m_gmk.Triggers, aParameter );
else if ( EventTable.TryGetValue( aType, out parameterNames ) )
parameter = parameterNames[aParameter];
else if ( aType == EventTypes.Other ) {
if ( aParameter >= 40 && aParameter <= 47 )
parameter = "Outside view " + (aParameter - 40);
else if ( aParameter >= 50 && aParameter <= 57 )
parameter = "Boundary view " + (aParameter - 50);
} else
return null;
return new XComment( "Node below refers to an event of type \"" + aType.ToString() +
"\" with parameter \"" + parameter + '"' );
}
public static UniEvent GetEventInstanceByType(EventTypes type)
{
return (UniEvent)Activator.CreateInstance("Assembly-CSharp", "UniMaker.Events.Event" + type.ToString()).Unwrap();
}
public override string ToSmallString()
{
return(type.ToString() + "|" + Common.ArrayToString(data));
}
internal IEnumerable <Type> Get(EventTypes eventType) => Get(eventType.ToString());
public Event(string eventName, int eventUserId, EventTypes eventType, string companyDescription)
{
if (string.IsNullOrEmpty(eventName) || string.IsNullOrEmpty(eventUserId.ToString()) || string.IsNullOrEmpty(eventType.ToString()) || string.IsNullOrEmpty(companyDescription))
{
throw new ArgumentNullException("Fill all required fields");
}
Name = eventName;
UserId = eventUserId;
CreateDate = DateTime.UtcNow.Date;
Type = eventType;
Description = companyDescription;
Del = (int)ObjectDel.Active;
}
public string OnEvent(string verify, string version, string eventType, string eventData)
{
// Trace
string s = string.Format("eventType:{0},eventData:{1}", eventType, eventData);
System.Diagnostics.Trace.WriteLine(s);
InfoPlusResponse r = new InfoPlusResponse();
try
{
// 1.Data type conversion.
EventTypes eTypes = (EventTypes)Enum.Parse(typeof(EventTypes), eventType);
// just return the default response when ECHO
if (eTypes == EventTypes.ECHO)
{
return(JsonConvert.ExportToString(r));
}
InfoPlusEvent e = JsonConvert.Import <InfoPlusEvent>(eventData);
if (null == e)
{
return(JsonConvert.ExportToString(new InfoPlusResponse(true, true, "InfoPlusEvent malformed")));
}
// 2.Retrieve messengers
IList <AbstractMessenger> messengers = this.settings.Messengers;
var targets = from m in messengers where m.Match(e) select m;
// 3.Dispatch messages.
// Devoted to Charles Petzold, the first Win32 program, Orz by marstone, 2011/06/29
// Changed switch(eventType) to Reflection. Devoted to Brian Cantwell Smith, 2011/07
bool verified = !targets.Any();
string detail = null;
foreach (AbstractMessenger messenger in targets)
{
// 4.Check verify.
verified = true;
if (messenger.RequireVerification && ServiceType.Insecure != ApplicationSettings.ServiceType)
{
ResponseEntity re = this.CheckParameters(messenger, verify, version, version, eventType, eventData);
if (false == re.Successful)
{
verified = false;
detail = re.error;
break;
}
}
// Notice: the CurrentEvent is thread safe. by marstone, 2011/10/18
messenger.CurrentEvent = e;
InfoPlusResponse response = null;
try
{
var words = (from t in eTypes.ToString().Split(new char[] { '_' })
select t[0] + t.Substring(1).ToLower());
string method = "On" + string.Join("", words.ToArray());
string log = string.Format("Dispatching {0} to {1}->{2}", eTypes, messenger.GetType().Name, method);
System.Diagnostics.Trace.WriteLine(log);
response = (InfoPlusResponse)messenger.GetType().InvokeMember(
method,
BindingFlags.InvokeMethod | BindingFlags.Public | BindingFlags.Instance,
null,
messenger,
new object[] { e }
);
}
catch (Exception mex)
{
System.Diagnostics.Trace.WriteLine(mex);
String message = mex.Message + "\n" + mex.StackTrace;
while (true)
{
if (mex.InnerException == null || mex.InnerException == mex)
{
break;
}
mex = mex.InnerException;
message += "\n" + mex.Message + "\n" + mex.StackTrace;
}
response = new InfoPlusResponse(true, true, "发生未知的错误", message);
}
if (null != response)
{
r += response;
// skip next messenger if said Break.
if (response.Break)
{
break;
}
}
}
if (false == verified)
{
r = new InfoPlusResponse(true, true, "Verification Failed.", detail);
}
return(JsonConvert.ExportToString(r));
}
catch (Exception ex)
{
System.Diagnostics.Trace.WriteLine(ex);
return(JsonConvert.ExportToString(new InfoPlusResponse(true, true, "发生未知的错误", ex.Message + ex.StackTrace)));
}
}
public static void AddApplicationLog(this Events events, EventTypes type, string description = null)
{
events.Event.AddEventRow(-1, (int)type, description ?? type.ToString(), DateTime.Now);
}
public override string ToString()
{
return(Event.ToString());
}
