//unsubscribe this event from event matching eventType
public void Unsubscribe(IObserver listener, EventTypes eventType)
{
if (listenerTable.Keys.Contains(eventType))
{
listenerTable[eventType].Remove(listener);
}
}
public void SaveAuditEvent(AuditLoggingEvent info)
{
try
{
EventTypes type = (EventTypes)Enum.Parse(typeof(EventTypes), info.Level.ToString());
using (var unit = ServiceLocator.Current.GetInstance <IUnitOfWork>())
{
Event evt = new Event()
{
TypeID = (int)type,
ProcessName = info.FriendlyProcessName,
Message = info.Message.ToString(),
ExceptionMessage = info.ExceptionObject == null ? string.Empty : info.ExceptionObject.Message,
StackTrace = info.ExceptionObject == null ? string.Empty : info.ExceptionObject.StackTrace
};
unit.Scope.Repository <Event>().Add(evt);
unit.Save();
}
}
catch (Exception)
{
Console.WriteLine("Could not log exception to db. Exception was @0", info.Message.ToString());
}
}
public IOWatcher(IntPtr fd, EventTypes types, Loop loop, Action<IOWatcher, EventTypes> callback)
: base(loop)
{
this.fd = fd;
this.callback = callback;
watcher_ptr = manos_io_watcher_create (fd.ToInt32 (), types, watcherCallback, GCHandle.ToIntPtr (gc_handle));
}
public void Add()
{
CreateDate = DateTime.Now;
UpdateDate = null;
Status = RecordStatuses.ACTIVE;
EventType = EventTypes.ADDED;
}
public MainEvent()
{
InitializeComponent();
List<string> hours = new List<string>();
for (int i = 0; i < 24; i++)
{
hours.Add(i.ToString("00"));
}
cbFromHour.ItemsSource = hours;
cbFromHour.SelectedIndex = 0;
cbUntilHour.ItemsSource = hours;
cbUntilHour.SelectedIndex = 0;
List<string> minutes = new List<string>();
for (int i = 0; i < 12; i++)
{
minutes.Add((i * 5).ToString("00"));
}
cbFromMin.ItemsSource = minutes;
cbFromMin.SelectedIndex = 0;
cbUntilMin.ItemsSource = minutes;
cbUntilMin.SelectedIndex = 0;
dpFromDate.SelectedDate = DateTime.Now.Date;
dpUntilDate.SelectedDate = DateTime.Now.AddHours(1).Date;
mEventTypes = new EventTypes();
cbEventTypes.ItemsSource = mEventTypes;
}
public void Notify(EventTypes eventTypeFilter, string message)
{
foreach (var listner in _listners.Where(x => x.Subscriptions.Contains(eventTypeFilter)))
{
listner.Alert(message);
}
}
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);
}
private void ProcessWork(Loop loop, IAsyncWatcher watcher, EventTypes revents)
{
int remaining = maxWorkPerLoop + 1;
while (--remaining > 0)
{
Action action;
if (workQueue.TryDequeue(out action))
{
try {
action();
}
catch (Exception ex) {
Console.WriteLine("Error in processing synchronized action");
Console.WriteLine(ex);
}
}
else
{
break;
}
}
if (remaining == 0)
{
asyncWatcher.Send();
}
}
internal virtual void HandleEnd(Loop loop, IAsyncWatcher watcher, EventTypes revents)
{
if (OnEnd != null)
{
OnEnd();
}
}
public static void RaiseEventMessage(object sender, string Message, EventTypes type)
{
if (EventMessage != null)
{
EventMessage(sender, Message, type);
}
}
/// <summary>
/// add user selected event types
/// </summary>
/// <param name="evt"></param>
public void AddEventType(EventTypes evt)
{
if (_eventSelectors.All(e => e != evt))
{
_eventSelectors.Add(evt);
}
}
/*
Subscribers/listeners register with the event system
*/
public void Subscribe(IObserver listener, EventTypes eventType)
{
if (!listenerTable.Keys.Contains(eventType))
{
listenerTable[eventType] = new HashSet<IObserver>();
}
listenerTable[eventType].Add(listener);
}
public UniEvent(EventTypes type)
{
Type = type;
Actions = new List<UniAction>();
Options = new JSONObject();
Options.AddField("type", Type.ToString());
}
public string GetEventTypeName(EventTypes eventType)
{
#if !NET20
return GetInteropDelegate<GetEventTypeName>().Invoke(eventType).ToStringAnsi();
#else
return IntPtrExtensions.ToStringAnsi(GetInteropDelegate<GetEventTypeName>().Invoke(eventType));
#endif
}
void HandleReadReady(Loop loop, IOWatcher watcher, EventTypes revents)
{
if (readTimeoutContinuation == null)
{
readTimeoutContinuation = DateTime.Now;
}
HandleRead();
}
/// <summary>
/// Creates new instance.
/// </summary>
/// <param name="message">Message.</param>
/// <param name="endpoint">Endpoint.</param>
/// <param name="type">Event type.</param>
/// <param name="exception">Exception.</param>
public MessageLogEventArgs(string message, string endpoint, EventTypes type, Exception exception) :
this(message)
{
Endpoint = endpoint;
EventType = type;
Exception = exception;
Time = InternalDate.Now;
}
static OfflineAwardHandler()
{
EventTypes.RegistRequestType("area.offlineAwardHandler.queryAllAreasRequest", typeof(QueryAllAreasRequest), typeof(QueryAllAreasResponse));
EventTypes.RegistRequestType("area.offlineAwardHandler.setOfflineAreaIdRequest", typeof(SetOfflineAreaIdRequest), typeof(SetOfflineAreaIdResponse));
EventTypes.RegistRequestType("area.offlineAwardHandler.queryOfflineAwardRequest", typeof(QueryOfflineAwardRequest), typeof(QueryOfflineAwardResponse));
EventTypes.RegistRequestType("area.offlineAwardHandler.getOfflineAwardRequest", typeof(GetOfflineAwardRequest), typeof(GetOfflineAwardResponse));
EventTypes.RegistRequestType("area.offlineAwardHandler.getCurrentOfflineAreaRequest", typeof(GetCurrentOfflineAreaRequest), typeof(GetCurrentOfflineAreaResponse));
}
static GuildBlessHandler()
{
EventTypes.RegistPushType("area.guildBlessPush.blessRefreshPush", typeof(BlessRefreshPush));
EventTypes.RegistRequestType("area.guildBlessHandler.getMyBlessInfoRequest", typeof(GetMyBlessInfoRequest), typeof(GetMyBlessInfoResponse));
EventTypes.RegistRequestType("area.guildBlessHandler.blessActionRequest", typeof(BlessActionRequest), typeof(BlessActionResponse));
EventTypes.RegistRequestType("area.guildBlessHandler.receiveBlessGiftRequest", typeof(ReceiveBlessGiftRequest), typeof(ReceiveBlessGiftResponse));
EventTypes.RegistRequestType("area.guildBlessHandler.upgradeBlessRequest", typeof(UpgradeBlessRequest), typeof(UpgradeBlessResponse));
}
static ShopMallHandler()
{
EventTypes.RegistRequestType("area.shopMallHandler.getMallTabsRequest", typeof(GetMallTabsRequest), typeof(GetMallTabsResponse));
EventTypes.RegistRequestType("area.shopMallHandler.getMallScoreItemListRequest", typeof(GetMallScoreItemListRequest), typeof(GetMallScoreItemListResponse));
EventTypes.RegistRequestType("area.shopMallHandler.buyMallItemRequest", typeof(BuyMallItemRequest), typeof(BuyMallItemResponse));
EventTypes.RegistRequestType("area.shopMallHandler.getMallItemListRequest", typeof(GetMallItemListRequest), typeof(GetMallItemListResponse));
EventTypes.RegistRequestType("area.shopMallHandler.buyMallScoreItemRequest", typeof(BuyMallScoreItemRequest), typeof(BuyMallScoreItemResponse));
}
void HandleWriteReady(Loop loop, IOWatcher watcher, EventTypes revents)
{
if (writeTimeoutContinuation == null)
{
writeTimeoutContinuation = DateTime.Now;
}
HandleWrite();
}
public Outing(EventTypes eventType, int numPeople, DateTime date, decimal totalCost)
{
EventType = eventType;
NumPeople = numPeople;
Date_ = date;
TotalCost = totalCost;
TotalCostPerPerson = Math.Round(totalCost / numPeople, 2);
}
public IEventValidator Create(EventTypes eventType)
{
//Получаем тип валидатора по его имени
var validatorType = Type.GetType($"{_ns}.{eventType}Validation", true);
//создаем экземпляр валидатора
return((IEventValidator)Activator.CreateInstance(validatorType));
}
public static void Subscribe(EventTypes evT, EventHandler <MessageEventArgs> handler)
{
if (!handlers.ContainsKey(evT))
{
handlers.Add(evT, new List <EventHandler <MessageEventArgs> >());
}
handlers[evT].Add(handler);
}
public EventAggregate(EventTypes eventType, string eventName, int eventCount)
{
EventType = eventType;
EventName = eventName;
EventCount = eventCount;
}
public EventBuilder Type(EventTypes Value)
{
if (!this.IsLocked)
{
this.vType = Value;
}
return(this);
}
/// <summary>
/// 添加事件监听
/// </summary>
public static void AddListener(EventTypes eventType, Action <object> callback)
{
if (!m_EventDict.ContainsKey(eventType))
{
m_EventDict.Add(eventType, null);
}
m_EventDict[eventType] += callback;
}
static AchievementHandler()
{
EventTypes.RegistPushType("area.achievementPush.onAchievementPush", typeof(OnAchievementPush));
EventTypes.RegistRequestType("area.achievementHandler.achievementGetTypeElementRequest", typeof(AchievementGetTypeElementRequest), typeof(AchievementGetTypeElementResponse));
EventTypes.RegistRequestType("area.achievementHandler.achievementGetAwardRequest", typeof(AchievementGetAwardRequest), typeof(AchievementGetAwardResponse));
EventTypes.RegistRequestType("area.achievementHandler.getHolyArmorsRequest", typeof(GetHolyArmorsRequest), typeof(GetHolyArmorsResponse));
EventTypes.RegistRequestType("area.achievementHandler.activateHolyArmorRequest", typeof(ActivateHolyArmorRequest), typeof(ActivateHolyArmorResponse));
}
public int AttachEvent(VlcEventManagerInstance eventManagerInstance, EventTypes eventType, EventCallback callback)
{
if (eventManagerInstance == IntPtr.Zero)
throw new ArgumentException("Event manager instance is not initialized.");
if (callback == null)
throw new ArgumentException("Callback for event is not initialized.");
return GetInteropDelegate<AttachEvent>().Invoke(eventManagerInstance, eventType, callback, IntPtr.Zero);
}
static RewardHandler()
{
EventTypes.RegistRequestType("area.rewardHandler.rewardDeskRequest", typeof(RewardDeskRequest), typeof(RewardDeskResponse));
EventTypes.RegistRequestType("area.rewardHandler.rewardRequest", typeof(RewardRequest), typeof(RewardResponse));
EventTypes.RegistRequestType("area.rewardHandler.checkBountyRequest", typeof(CheckBountyRequest), typeof(CheckBountyResponse));
EventTypes.RegistRequestType("area.rewardHandler.getHasFinishRequest", typeof(FinishRewardRequest), typeof(FinishRewardResponse));
EventTypes.RegistRequestType("area.rewardHandler.getAwardBountyRequest", typeof(GetAwardBountyRequest), typeof(GetAwardBountyResponse));
}
/// <summary>
/// 触发事件
/// </summary>
/// <param name="eventType">事件类型</param>
/// <param name="args">参数列表</param>
public void TriggerEvent(EventTypes eventType, params object[] args)
{
eventCollection.TryGetValue(eventType, out Delegate eventValue);
if (eventValue != null)
{
eventValue.DynamicInvoke(args);
}
}
private void HandlePrepareEvent(Loop loop, PrepareWatcher watcher, EventTypes revents)
{
if (!running)
{
loop.Unloop(UnloopType.All);
prepare_watcher.Stop();
}
}
static SaleHandler()
{
EventTypes.RegistRequestType("area.saleHandler.buyPageRequest", typeof(BuyPageRequest), typeof(BuyPageResponse));
EventTypes.RegistRequestType("area.saleHandler.buyItemRequest", typeof(BuyItemRequest), typeof(BuyItemResponse));
EventTypes.RegistRequestType("area.saleHandler.autoBuyItemByCodeRequest", typeof(AutoBuyItemByCodeRequest), typeof(AutoBuyItemByCodeResponse));
EventTypes.RegistRequestType("area.saleHandler.sellItemsRequest", typeof(SellItemsRequest), typeof(SellItemsResponse));
EventTypes.RegistRequestType("area.saleHandler.rebuyItemRequest", typeof(RebuyItemRequest), typeof(RebuyItemResponse));
}
public ActionResult DeleteConfirmed(int id)
{
EventTypes eventTypes = db.EventTypes.Find(id);
db.EventTypes.Remove(eventTypes);
db.SaveChanges();
return(RedirectToAction("Index"));
}
static FunctionOpenHandler()
{
EventTypes.RegistPushType("area.functionOpenPush.functionOpenListPush", typeof(FunctionOpenListPush));
EventTypes.RegistPushType("area.functionOpenPush.functionAwardListPush", typeof(FunctionAwardListPush));
EventTypes.RegistRequestType("area.functionOpenHandler.getFunctionListRequest", typeof(GetFunctionListRequest), typeof(GetFunctionListResponse));
EventTypes.RegistRequestType("area.functionOpenHandler.setFunctionPlayedRequest", typeof(SetFunctionPlayedRequest), typeof(SetFunctionPlayedResponse));
EventTypes.RegistRequestType("area.functionOpenHandler.receiveFunctionAwardRequest", typeof(ReceiveFunctionAwardRequest), typeof(ReceiveFunctionAwardResponse));
}
private void OnDonePoll(Loop loop, AsyncWatcher watcher, EventTypes revents)
{
if (eio_poll() != -1)
{
Console.WriteLine("OnDonePoll: starting idle watcher");
idle_watcher.Stop();
}
}
void PrimSetEventHandlerAttr(EventTypes type, string script)
{
if (_handlerAttrs == null)
{
_handlerAttrs = new Dictionary <EventTypes, string>();
}
_handlerAttrs[type] = script;
}
public TimelineEvent(string target, EventTypes eventType, bool isVisible, string description, string path)
{
Target = target;
IsVisible = isVisible;
EventType = eventType;
DisplayedText = description;
Arguments = path;
}
public string GetEventTypeName(EventTypes eventType)
{
#if !NET20
return(GetInteropDelegate <GetEventTypeName>().Invoke(eventType).ToStringAnsi());
#else
return(IntPtrExtensions.ToStringAnsi(GetInteropDelegate <GetEventTypeName>().Invoke(eventType)));
#endif
}
public IOWatcher(IntPtr fd, EventTypes types, LibEvLoop loop, IOWatcherCallback callback)
: base(loop)
{
this.fd = fd;
this.callback = callback;
watcher_ptr = manos_io_watcher_create(fd.ToInt32(), types | EventTypes.EV__IOFDSET,
watcherCallback, GCHandle.ToIntPtr(gc_handle));
}
private static void StaticCallback(IntPtr loop, IntPtr watcher, EventTypes revents)
{
UnmanagedPrepareWatcher iow = (UnmanagedPrepareWatcher) Marshal.PtrToStructure (watcher, typeof (UnmanagedPrepareWatcher));
GCHandle gchandle = GCHandle.FromIntPtr (iow.data);
PrepareWatcher w = (PrepareWatcher) gchandle.Target;
w.callback (w.Loop, w, revents);
}
private static void StaticCallback(IntPtr data, EventTypes revents)
{
try {
var handle = GCHandle.FromIntPtr (data);
var watcher = (IOWatcher) handle.Target;
watcher.callback (watcher, revents);
} catch (Exception e) {
Console.Error.WriteLine ("Error handling IO readyness event: {0}", e.Message);
Console.Error.WriteLine (e.StackTrace);
}
}
// all event handler attribute accessors should eventually call these
public static string GetEventHandlerAttr(mdr.DObject obj, EventTypes type, string name)
{
#if ENABLE_RR
if (RecordReplayManager.Instance != null && RecordReplayManager.Instance.RecordEnabled)
{
mwr.RecordReplayManager.Instance.Record("Element", null, "GetEventHandlerAttr", false, obj, type, name);
}
#endif
var targetElement = obj.FirstInPrototypeChainAs<HTMLElement>();
var s = targetElement.PrimGetEventHandlerAttr(type);
Debug.WriteLine("GetEventHandlerAttr({0}) = '{1}'", name, s);
return s;
}
public bool EventIsActive(Bands b, int c, EventTypes e)
{
if (e == EventTypes.BEAT)
{
return bandData[bandOffsets[c, (int) b]].Beat;
}
else if (e == EventTypes.VIBRATION)
{
return bandData[bandOffsets[c, (int) b]].Vibration;
}
return false;
}
static void StaticCallback(IntPtr data, EventTypes revents)
{
Error.Log.Call<System.Exception>(() =>
{
var handle = GCHandle.FromIntPtr(data);
var watcher = (IOWatcher)handle.Target;
watcher.callback(watcher, revents);
}, e =>
{
Console.Error.WriteLine("Error handling IO readyness event: {0}", e.Message);
Console.Error.WriteLine(e.StackTrace);
});
}
/// <summary>
/// Gets event list models by event type
/// </summary>
/// <param name="eventType">Event type to get by</param>
/// <returns>An event list model</returns>
private EventListModel FetchFromRedis(EventTypes eventType)
{
try
{
var redisClient = new RedisClient("localhost");
var eventClient = redisClient.As<EventListModel>();
return eventClient.GetById((int)eventType);
}
catch (Exception)
{
return new EventListModel();
}
}
public IOWatcher(IntPtr fd, EventTypes types, Loop loop, IOWatcherCallback callback)
: base(loop)
{
this.fd = fd;
this.callback = callback;
unmanaged_watcher = new UnmanagedIOWatcher ();
unmanaged_watcher.fd = fd.ToInt32 ();
unmanaged_watcher.events = types | EventTypes.EV__IOFDSET;
unmanaged_watcher.callback = CallbackFunctionPtr;
InitializeUnmanagedWatcher (unmanaged_watcher);
}
public void LogEvent(string message, EventTypes eType)
{
log4net.Config.XmlConfigurator.Configure(GetTestConfig());
if (eType==EventTypes.Info)
{
Log.Info(message);
}else if (eType==EventTypes.Warn)
{
Log.Warn(message);
}else if (eType==EventTypes.Error)
{
Log.Error(message);
}
else if (eType == EventTypes.Fatal)
{
Log.Fatal(message);
}
else
{ Log.Info(message); }
}
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 UserControl(EventTypes eventType, int streamId = 1, int bufferlength = 1000, int pingTime = 0)
: base(4)
{
var memory = new MemoryStream();
var writer = new EndianBinaryWriter(EndianBitConverter.Big, memory);
writer.Write((ushort) eventType);
switch (eventType)
{
case EventTypes.StreamBegin:
writer.Write(streamId);
break;
case EventTypes.StreamEOF:
writer.Write(streamId);
break;
case EventTypes.StreamDry:
writer.Write(streamId);
break;
case EventTypes.SetBufferLength:
writer.Write(streamId);
writer.Write(bufferlength);
break;
case EventTypes.StreamIsRecorded:
writer.Write(streamId);
break;
case EventTypes.PingRequest:
writer.Write(pingTime);
break;
case EventTypes.PingResponse:
writer.Write(pingTime);
break;
default:
break;
}
Data = memory.ToArray();
}
protected override void UnmanagedCallbackHandler(IntPtr _loop, IntPtr _watcher, EventTypes revents)
{
// Maybe I should verify the pointers?
callback (Loop, this, revents);
}
public EventPacket(EventTypes type, byte[] data)
{
Type = type;
Data = data;
}
private static extern IntPtr manos_io_watcher_create(int fd, EventTypes revents, UnmanagedWatcherCallback callback, IntPtr data);
private void HandleIOEvents(Loop loop, IOWatcher watcher, EventTypes revents)
{
while (true) {
Socket s = null;
try {
s = Socket.Accept ();
} catch (SocketException se) {
if (se.SocketErrorCode == SocketError.WouldBlock || se.SocketErrorCode == SocketError.TryAgain)
return;
Console.WriteLine ("Socket exception in Accept handler");
Console.WriteLine (se);
return;
} catch (Exception e) {
Console.WriteLine ("Exception in Accept handler");
Console.WriteLine (e);
return;
}
IOStream iostream = new IOStream (s, IOLoop);
transactions.Add (HttpTransaction.BeginTransaction (this, iostream, s, callback));
}
}
public EventKeyDown(EventTypes type)
: base(type)
{
Priority = 10;
}
public MyEventArgs(EventTypes type)
{
Type = type;
}
public BIEventTestDatabaseRow(int eventId, EventTypes eventType, DateTime eventDate)
{
AddGetInt32ColumnValue("EventId", eventId);
AddGetInt32ColumnValue("EventType", (int)eventType);
AddGetDateTimeColumnValue("EventDate", eventDate);
}
private void HandleIOEvents(Loop loop, IOWatcher watcher, EventTypes revents)
{
while (true) {
Socket s = null;
try {
s = Socket.Accept ();
} catch (SocketException se) {
if (se.SocketErrorCode == SocketError.WouldBlock || se.SocketErrorCode == SocketError.TryAgain)
return;
throw se;
} catch {
throw;
}
IOStream iostream = new IOStream (s, IOLoop);
transactions.Add (HttpTransaction.BeginTransaction (this, iostream, s, callback));
}
}
public static string GetEventReference(EventTypes en)
{
return referenceBase.GetReference(en);
}
/// <summary>
/// Get event type name.
/// </summary>
/// <param name="type"></param>
/// <returns></returns>
public static String GetEventTypeName(EventTypes type)
{
return InteropHelper.PtrToString(_getTypeNameFunction.Delegate(type));
}
/// <summary>
/// Deattach a event with a callback.
/// </summary>
/// <param name="type">event type</param>
/// <param name="callback">callback which will be called when event case</param>
/// <param name="userData">some custom data</param>
public void Detach(EventTypes type, LibVlcEventCallBack callback, IntPtr userData)
{
_eventDetachFunction.Delegate(InstancePointer, type, callback, userData);
}
