private async Task queueRecentMatchPages(string gamertag, int pages)
{
_logger.LogInformation($"Queueing {gamertag}'s recent matches");
var queueMessages = new QueueEvent[pages];
for (var i = 0; i < pages; i++)
{
queueMessages[i] = new QueueEvent
{
Type = QueueEventTypes.CacheRecentMatches,
Payload = new MatchHistoryPayload
{
Gamertag = gamertag,
Page = i + 1,
},
};
}
var tasks = new List <Task>();
var chunkyChunks = queueMessages.Split(10);
foreach (var chunk in chunkyChunks)
{
tasks.Add(_sqsClient.SendMessageBatchAsync(chunk));
}
_logger.LogInformation($"{gamertag} has {pages} pages of recent matches over {tasks.Count} tasks");
await Task.WhenAll(tasks.ToArray());
}
/// <summary>
/// Activates the next Event and keeps the queue running until it is empty
/// </summary>
private void NextQueueEvent()
{
// if the queue is empty, stop
if (_queue.Count <= 0)
{
Running = false;
OnQueueFinished?.Invoke();
return;
}
Running = true;
// get the next event and remove it from the queue
QueueEvent evt = _queue[0];
_queue.RemoveAt(0);
// set the timer to the duration of the event so it can trigger the next one after this is finished and invoke the event
_queueTimer.Duration = evt.Data.Duration;
_queueTimer.OnTimeElapsed = NextQueueEvent;
evt.Action?.Invoke(evt.Data);
// Start the timer
_queueTimer.Reset();
_queueTimer.Start();
}
public void BuildRoom()
{
// Game Objects
this.objects = new Dictionary <byte, Dictionary <int, GameObject> > {
[(byte)LoadOrder.Platform] = new Dictionary <int, GameObject>(),
[(byte)LoadOrder.Enemy] = new Dictionary <int, GameObject>(),
[(byte)LoadOrder.Item] = new Dictionary <int, GameObject>(),
[(byte)LoadOrder.TrailingItem] = new Dictionary <int, GameObject>(),
[(byte)LoadOrder.Character] = new Dictionary <int, GameObject>(),
[(byte)LoadOrder.Projectile] = new Dictionary <int, GameObject>()
};
// Object Coordination and Cleanup
this.markedForAddition = new List <GameObject>();
this.markedForRemoval = new List <GameObject>();
// Build Tilemap with Correct Dimensions
short xCount, yCount;
RoomGenerate.DetectRoomSize(Systems.handler.levelContent.data.rooms[roomID], out xCount, out yCount);
this.tilemap = new TilemapLevel(xCount, yCount);
// Additional Components
this.colors = new ColorToggles();
this.trackSys = new TrackSystem();
this.roomExits = new RoomExits();
this.queueEvents = new QueueEvent(this);
// Generate Room Content (Tiles, Objects)
RoomGenerate.GenerateRoom(this, Systems.handler.levelContent, roomID);
// Prepare the Full Track System
this.trackSys.SetupTrackSystem();
}
private async Task StoreCommand(QueueEvent <CommandRequestWrapper> request)
{
if (this.storage != null)
{
// optionaly store the command/response so it can later be retrieved by the client (because the command was queued with no direct response)
await this.storage.SaveAsync(request.Item.Data).AnyContext();
}
}
public override async Task <bool> Handle(QueueEvent <CommandRequestWrapper> request, CancellationToken cancellationToken)
{
if (request?.Item?.Data?.Command != null)
{
using (this.logger.BeginScope(new Dictionary <string, object>
{
[LogPropertyKeys.CorrelationId] = request.Item.Data.CorrelationId
}))
{
// as this handler is called inside a singleton scope (due to CommandRequestQueueProcessor:ProcessItems)
// any ctor injections are also singleton. We need scoped commandhandlers (mediator default), so
// that is achieved by creating a scope explicity
using (var scope = this.serviceScopeFactory.CreateScope())
{
this.logger.LogInformation($"{{LogKey:l}} command request dequeued (name={request.Item.Data.Command.GetType().PrettyName()}, id={request.Item.Data.Command?.Id}, type=queue)", LogKeys.AppCommand);
var mediator = scope.ServiceProvider.GetService <IMediator>(); // =scoped
try
{
request.Item.Data.Started = DateTimeOffset.UtcNow;
await this.StoreCommand(request).AnyContext();
// TODO: use for new tracer scope request.Item.Data.ParentSpanId
var response = await mediator.Send(request.Item.Data.Command, cancellationToken).AnyContext(); // handler will be scoped too
request.Item.Data.Completed = DateTimeOffset.UtcNow;
request.Item.Data.Status = CommandRequestStatus.Finished;
if (response != null)
{
var jResponse = JObject.FromObject(response);
if (!jResponse.GetValueByPath <bool>("cancelled"))
{
var resultToken = jResponse.SelectToken("result") ?? jResponse.SelectToken("Result");
request.Item.Data.Response = resultToken?.ToObject <object>();
}
else
{
request.Item.Data.Status = CommandRequestStatus.Cancelled;
request.Item.Data.StatusDescription = jResponse.GetValueByPath <string>("cancelledReason");
}
}
}
catch (Exception ex)
{
request.Item.Data.Status = CommandRequestStatus.Failed;
request.Item.Data.StatusDescription = ex.GetFullMessage();
this.logger.LogCritical(ex, ex.Message);
}
await this.StoreCommand(request).AnyContext();
}
}
}
return(true);
}
public QueueEvent CreateQueueEvent(string name, MyEventHandler listener)
{
QueueEvent ret = null;
ret = new QueueEvent(name, listener, QueueEventFinished, DeleteEvent);
queue_events.Add(ret);
return(ret);
}
private void AddQueueEvent(QueueEvent.Type queueType, int minSeconds = 0, int maxSeconds = 0, int bnetError = 0, GameServerInfo gsInfo = null)
{
QueueEvent item = new QueueEvent(queueType, minSeconds, maxSeconds, bnetError, gsInfo);
object queueEvents = this.m_queueEvents;
lock (queueEvents)
{
this.m_queueEvents.Enqueue(item);
}
}
public void PushEventForced(QueueEvent ev)
{
if (ev != null)
{
curr_events.Add(ev);
ev.CallOnEventStart();
ev.OnStart();
last_pushed = ev;
}
}
public void ClearEvents()
{
for (int i = 0; i < curr_events.Count;)
{
QueueEvent curr_event = curr_events[i];
curr_event.OnFinish();
curr_event.CallOnEventFinish();
}
curr_events.Clear();
}
public void PushEvent(QueueEvent ev, bool start_with_last = false)
{
if (ev != null)
{
if (start_with_last)
{
ev.PushWithLastEvent();
}
events_to_push.Add(ev);
last_pushed = ev;
}
}
public QueueEvent GetQueueEvent()
{
QueueEvent result = null;
object queueEvents = this.m_queueEvents;
lock (queueEvents)
{
if (this.m_queueEvents.Count > 0)
{
result = this.m_queueEvents.Dequeue();
}
}
return(result);
}
public override async Task <bool> Handle(QueueEvent <CountriesExportData> request, CancellationToken cancellationToken)
{
using (var scope = this.tracer?.BuildSpan("process export", LogKey, SpanKind.Internal).Activate(this.logger))
{
await Task.Run(() => this.logger.LogInformation($"{{LogKey:l}} countries data {request.Item.Data.Timestamp:o} (id={request.Item.Id}, type={this.GetType().PrettyName()})", LogKey), cancellationToken).AnyContext();
if (RandomGenerator.GenerateInt(0, 100) % 3 == 0) // divides by 3 and checks for the remainder. A number that is divisable by 3 has no remainder (and thus ==0 and the exception will be thrown)
{
throw new NaosException("Oops, the export processing randomly failed");
}
return(true);
}
}
public QueueEvent GetQueueEvent()
{
QueueEvent result = null;
Queue <QueueEvent> queueEvents = this.m_queueEvents;
lock (queueEvents)
{
if (this.m_queueEvents.get_Count() > 0)
{
result = this.m_queueEvents.Dequeue();
}
}
return(result);
}
private void AddQueueEvent(QueueEvent.Type queueType, int minSeconds = 0, int maxSeconds = 0, int bnetError = 0, GameServerInfo gsInfo = null)
{
QueueEvent queueEvent = new QueueEvent(queueType, minSeconds, maxSeconds, bnetError, gsInfo);
object mQueueEvents = this.m_queueEvents;
Monitor.Enter(mQueueEvents);
try
{
this.m_queueEvents.Enqueue(queueEvent);
}
finally
{
Monitor.Exit(mQueueEvents);
}
}
// ######################## FUNCTIONALITY ######################## //
/// <summary>
/// Adds a new Event to the Queue. If the queue was empty before, it is executed immediately
/// </summary>
/// <param name="action">Delegate for starting the event</param>
/// <param name="data">Data object derived from EventData containing all the information the event needs</param>
public void AddEvent(Action <EventData> action, EventData data)
{
// create the event and add it to the queue
QueueEvent evt = new QueueEvent()
{
Action = action,
Data = data
};
_queue.Add(evt);
// if the queue is not running we need to start it
if (_autoplay && !Running)
{
NextQueueEvent();
}
}
public void AddQueueEvent(QueueEvent qEvent)
{
switch (qEvent)
{
case QueueEvent.Enqueue:
this.counters.CurrentQueueLength.Increment();
break;
case QueueEvent.Dequeue:
this.counters.CurrentQueueLength.Decrement();
break;
}
if (this.queueLength.AddValue(this.counters.CurrentQueueLength.RawValue))
{
this.UpdateQueueSizePercentileCounters();
}
}
public QueueEvent GetQueueEvent()
{
QueueEvent queueEvent = null;
object mQueueEvents = this.m_queueEvents;
Monitor.Enter(mQueueEvents);
try
{
if (this.m_queueEvents.Count > 0)
{
queueEvent = this.m_queueEvents.Dequeue();
}
}
finally
{
Monitor.Exit(mQueueEvents);
}
return(queueEvent);
}
/// <summary>
/// 增加一个延迟事件到编辑器更新队列中
/// </summary>
/// <param name="handler"></param>
/// <param name="delay"></param>
/// <param name="frameDelay">是否使用帧延时，使用帧延时，则 delay 被当作帧数处理</param>
public static void QueueDelayEvent <T0, T1, T2, T3>(Action <T0, T1, T2, T3> handler, T0 arg0, T1 arg1, T2 arg2, T3 arg3, float delay, string name = null, bool frameDelay = false)
{
if (name != null)
{
var n = update.GetInvocationList();
foreach (var i in n)
{
var qe = i.Target as QueueEvent;
if (qe == null || qe.name == null || qe.name != name)
{
continue;
}
qe.Set(handler, timeSinceStartup, delay, name, arg0, arg1, arg2, arg3, frameDelay);
return;
}
}
var e = new QueueEvent(handler, timeSinceStartup, delay, name, 4, arg0, arg1, arg2, arg3, frameDelay);
update += e.Update;
}
public async Task PublishAsync(
string queueName,
QueueEvent @event,
CancellationToken cancellationToken = default)
{
var eventName = @event.GetType().Name.Replace(_QUEUEEVENTSUFFIX, string.Empty);
var jsonMessage = JsonConvert.SerializeObject(@event);
var body = Encoding.UTF8.GetBytes(jsonMessage);
var message = new Message
{
MessageId = Guid.NewGuid().ToString(),
Body = body,
Label = eventName,
};
var client = _connection.CreateClient(queueName);
cancellationToken.ThrowIfCancellationRequested();
await client.SendAsync(message);
}
public void UpdateEvents()
{
if (curr_events.Count > 0)
{
for (int i = 0; i < curr_events.Count;)
{
QueueEvent curr_event = curr_events[i];
if (!curr_event.GetFinished())
{
curr_event.OnUpdate();
++i;
}
else
{
curr_event.OnFinish();
curr_event.CallOnEventFinish();
curr_events.RemoveAt(i);
}
}
}
else
{
if (events_to_push.Count > 0)
{
bool first = true;
for (int i = 0; i < events_to_push.Count;)
{
QueueEvent curr_event = events_to_push[i];
bool add = false;
if (first)
{
add = true;
first = false;
}
else if (curr_event.GetPushWithLastEvent())
{
add = true;
}
if (add)
{
curr_events.Add(curr_event);
events_to_push.RemoveAt(i);
curr_event.CallOnEventStart();
curr_event.OnStart();
}
else
{
break;
}
}
}
}
}
void manager_UnhandledEvent(object sender, ManagerEvent e)
{
log.Debug("New unhandled event received: " + e.GetType().Name);
LineControl lc = null;
//StateServer
switch (e.GetType().Name)
{
case "AGIExecEvent":
AGIExecEvent agievent = e as AGIExecEvent;
break;
case "AlarmClearEvent":
AlarmClearEvent alarmclear = e as AlarmClearEvent;
break;
case "AlarmEvent":
AlarmEvent alarmevent = e as AlarmEvent;
break;
case "AsyncAGIEvent":
AsyncAGIEvent asyncagievent = e as AsyncAGIEvent;
break;
case "BridgeEvent":
BridgeEvent bridgeevent = e as BridgeEvent;
break;
case "CdrEvent":
CdrEvent cdrevent = e as CdrEvent;
break;
case "ChannelReloadEvent":
ChannelReloadEvent channelreload = e as ChannelReloadEvent;
break;
case "ChannelUpdateEvent":
ChannelUpdateEvent channelupdate = e as ChannelUpdateEvent;
break;
case "ConnectEvent":
ConnectEvent connectevent = e as ConnectEvent;
break;
case "ConnectionStateEvent":
ConnectionStateEvent connectionstate = e as ConnectionStateEvent;
break;
case "DBGetResponseEvent":
DBGetResponseEvent dbget = e as DBGetResponseEvent;
log.Debug("DBGet response: " + dbget.ToString());
switch (dbget.Family)
{
case "DND":
ss.SetLineControl(setLineControlDND(dbget.Key, true));
break;
case "CF":
ss.SetLineControl(setLineControlForward(dbget.Key, dbget.Val));
break;
}
break;
case "DialEvent":
DialEvent dial = e as DialEvent;
log.Debug("Dial event: " + dial.ToString());
break;
case "DisconnectEvent":
DisconnectEvent disconnect = e as DisconnectEvent;
log.Debug("Disconnect event: " + disconnect.ToString());
break;
case "DNDStateEvent":
DNDStateEvent dndstate = e as DNDStateEvent;
log.Debug("DND state event: " + dndstate.ToString());
break;
case "ExtensionStatusEvent":
ExtensionStatusEvent extensionstatus = e as ExtensionStatusEvent;
log.Debug("Extension status event: " + extensionstatus.ToString() + ", status: " + extensionstatus.Status + ", hint: " + extensionstatus.Hint);
ss.SetLineControl(getLineControlFromExtensionStatusEvent(extensionstatus));
break;
case "FaxReceivedEvent":
FaxReceivedEvent faxreceived = e as FaxReceivedEvent;
break;
case "HangupEvent":
HangupEvent hangup = e as HangupEvent;
log.Debug("Hangup event: " + hangup.ToString() + " callerid: " + hangup.CallerId + " calleridnum: " + hangup.CallerIdNum);
//line control
if (channels.Contains(hangup.Channel))
{
lc = getLineControl((string)channels[hangup.Channel]);
int hi = 0;
LineControlConnection[] newLCC = null;
if (lc.lineControlConnection.Length > 1)
{
newLCC = new LineControlConnection[lc.lineControlConnection.Length - 1];
foreach (LineControlConnection hlcc in lc.lineControlConnection)
{
if (hlcc.callid != hangup.Channel)
{
newLCC[hi] = hlcc;
hi++;
}
}
}
lc.lineControlConnection = newLCC;
ss.SetLineControl(lc);
channels.Remove(hangup.Channel);
}
//missed calls
callToFind = hangup.UniqueId.Substring(0, 6) + "," + hangup.UniqueId.Substring(6);
Call mCall = missedCalls.Find(FindCall);
if (mCall != null)
{
log.Debug("Missed call finded for callid: " + hangup.UniqueId);
AddCallLogs(mCall.callee, mCall);
if (missedCalls.Remove(mCall))
{
log.Debug("Call " + mCall.callId + " successfully removed from missedcall cache");
}
else
{
log.Debug("Call " + mCall.callId + " cannot be removed from missedcall cache");
}
}
break;
case "HoldedCallEvent":
HoldedCallEvent holdedcall = e as HoldedCallEvent;
break;
case "HoldEvent":
HoldEvent holdevent = e as HoldEvent;
break;
case "JabberEvent":
JabberEvent jabberevent = e as JabberEvent;
break;
case "JitterBufStatsEvent":
JitterBufStatsEvent jitter = e as JitterBufStatsEvent;
break;
case "JoinEvent":
JoinEvent join = e as JoinEvent;
break;
case "LeaveEvent":
LeaveEvent leave = e as LeaveEvent;
break;
case "LinkEvent":
LinkEvent link = e as LinkEvent;
log.Debug("Link event: " + link.ToString());
lc = getLineControl(link.CallerId1);
if (lc != null)
{
foreach (LineControlConnection linklcc in lc.lineControlConnection)
{
if (linklcc.callid == link.Channel1)
{
linklcc.contact = link.CallerId2;
ss.SetLineControl(lc);
break;
}
}
}
lc = getLineControl(link.CallerId2);
if (lc != null)
{
foreach (LineControlConnection linklcc in lc.lineControlConnection)
{
if (linklcc.callid == link.Channel2)
{
linklcc.contact = link.CallerId1;
ss.SetLineControl(lc);
break;
}
}
}
break;
case "LogChannelEvent":
LogChannelEvent logchannel = e as LogChannelEvent;
break;
case "ManagerEvent":
ManagerEvent managerevent = e;
break;
case "MeetmeEndEvent":
MeetmeEndEvent meetmeend = e as MeetmeEndEvent;
break;
case "MeetmeJoinEvent":
MeetmeJoinEvent meetmejoin = e as MeetmeJoinEvent;
break;
case "MeetmeLeaveEvent":
MeetmeLeaveEvent meetmeleave = e as MeetmeLeaveEvent;
break;
case "MeetmeMuteEvent":
MeetmeMuteEvent meetmemute = e as MeetmeMuteEvent;
break;
case "MeetmeStopTalkingEvent":
MeetmeStopTalkingEvent meetmestoptalking = e as MeetmeStopTalkingEvent;
break;
case "MeetmeTalkingEvent":
MeetmeTalkingEvent meetmetalking = e as MeetmeTalkingEvent;
break;
case "MeetmeTalkRequestEvent":
MeetmeTalkRequestEvent meetmetalkrequest = e as MeetmeTalkRequestEvent;
break;
case "MessageWaitingEvent":
MessageWaitingEvent messagewaiting = e as MessageWaitingEvent;
log.Debug("Message waiting event: " + messagewaiting.ToString());
lc = getLineControl(messagewaiting.Mailbox.Substring(0, messagewaiting.Mailbox.IndexOf("@")));
if (lc != null)
{
if (messagewaiting.Waiting > 0)
{
lc.mwiOn = true;
}
else
{
lc.mwiOn = false;
}
ss.SetLineControl(lc);
}
break;
case "MobileStatusEvent":
MobileStatusEvent mobilestatus = e as MobileStatusEvent;
break;
case "ModuleLoadReportEvent":
ModuleLoadReportEvent moduleload = e as ModuleLoadReportEvent;
break;
case "MonitorStartEvent":
MonitorStartEvent monitorstart = e as MonitorStartEvent;
break;
case "MonitorStopEvent":
MonitorStopEvent monitorstop = e as MonitorStopEvent;
break;
case "NewAccountCodeEvent":
NewAccountCodeEvent newaccountcode = e as NewAccountCodeEvent;
break;
case "NewCallerIdEvent":
NewCallerIdEvent newcallerid = e as NewCallerIdEvent;
log.Debug("New caller id envent: " + newcallerid.ToString());
break;
case "NewChannelEvent":
NewChannelEvent newchannel = e as NewChannelEvent;
log.Debug("New Channel event: " + newchannel.ToString());
CommandAction ca = new CommandAction("core show channel " + newchannel.Channel);
CommandResponse cr = (CommandResponse)manager.SendAction(ca, 10000);
log.Debug("Channel info: " + cr.ToString());
string dn = newchannel.CallerIdNum;
log.Debug("Retreive call information...");
bool callerIdUnknown = true;
if (newchannel.CallerIdNum != "<unknown>")
{
callerIdUnknown = false;
}
else
{
foreach (string s in cr.Result)
{
if (s.Contains("Caller ID:"))
{
dn = s.Substring(s.LastIndexOf(" "));
break;
}
}
}
Call newOutboundCall = getOutboundCallFromChannelInfo(cr.Result, callerIdUnknown);
if (newOutboundCall != null)
{
Call missedCall = newOutboundCall;
AddCallLogs(dn, newOutboundCall);
dnToFind = newOutboundCall.callee;
if (linecontrols.Find(FindLineControl) != null)
{
log.Debug("This call will be put in missedcall cache: " + missedCall.callId);
missedCall.type = CallType.missed;
missedCalls.Add(missedCall);
}
}
break;
case "NewExtenEvent":
NewExtenEvent newexten = e as NewExtenEvent;
log.Debug("New exten event: " + newexten.ToString());
string channel = "";
char[] splitter = { '/' };
string[] splitchannel = newexten.Channel.Split(splitter);
splitter[0] = '-';
splitchannel = splitchannel[1].Split(splitter);
channel = splitchannel[0];
//DND?
if (newexten.Extension == Properties.Settings.Default.FeatureCodeDNDToggle && newexten.Application == "Playback")
{
switch (newexten.AppData)
{
case "do-not-disturb&activated":
log.Debug("Successfully activate dnd for channel: " + channel);
ss.SetLineControl(setLineControlDND(channel, true));
break;
case "do-not-disturb&de-activated":
log.Debug("Successfully deactivate dnd for channel: " + channel);
ss.SetLineControl(setLineControlDND(channel, false));
break;
}
}
//Forward all?
else if (newexten.Extension.Contains(Properties.Settings.Default.FeatureCodeCallForwardAllActivate) && newexten.Application == "Playback" && newexten.AppData == "call-fwd-unconditional&for&extension")
{
string forward = newexten.Extension.Substring(Properties.Settings.Default.FeatureCodeCallForwardAllActivate.Length);
log.Debug("Call forward all from channel: " + channel + " to " + forward);
ss.SetLineControl(setLineControlForward(channel, forward));
}
// UnForwardAll
else if (newexten.Extension == Properties.Settings.Default.FeatureCodeCallForwardAllDeactivate && newexten.Application == "Playback" && newexten.AppData == "call-fwd-unconditional&de-activated")
{
log.Debug("Call unforward all from channel: " + channel);
ss.SetLineControl(setLineControlForward(channel, ""));
}
break;
case "NewStateEvent":
NewStateEvent newstate = e as NewStateEvent;
log.Debug("New State event: " + newstate.ToString());
LineControl newstateLc = getLineControl(newstate.CallerId);
LineControlConnection[] newStateLccs = null;
int i = 0;
if (newstateLc.lineControlConnection != null)
{
bool isContained = false;
foreach (LineControlConnection elcc in newstateLc.lineControlConnection)
{
if (elcc.callid == newstate.Channel)
{
isContained = true;
newStateLccs = newstateLc.lineControlConnection;
break;
}
i++;
}
if (!isContained)
{
i = 0;
newStateLccs = new LineControlConnection[newstateLc.lineControlConnection.Length + 1];
foreach (LineControlConnection newstateLcc in newstateLc.lineControlConnection)
{
newStateLccs[i] = newstateLcc;
i++;
}
}
}
else
{
newStateLccs = new LineControlConnection[1];
newStateLccs[0] = new LineControlConnection();
}
try
{
switch (newstate.State)
{
case "Up":
//received call?
callToFind = newstate.UniqueId;
Call rCall = missedCalls.Find(FindCall);
if (rCall != null)
{
log.Debug("Missed call finded: " + callToFind + ", this call will be received");
rCall.type = CallType.received;
AddCallLogs(rCall.callee, rCall);
missedCalls.Remove(rCall);
}
if (newStateLccs != null)
{
if (!channels.Contains(newstate.Channel))
{
channels.Add(newstate.Channel, newstate.CallerId);
}
newStateLccs[i].callid = newstate.Channel;
newStateLccs[i].remoteState = Wybecom.TalkPortal.CTI.Proxy.ConnectionState.established;
newStateLccs[i].state = Wybecom.TalkPortal.CTI.Proxy.ConnectionState.established;
newStateLccs[i].terminalState = TerminalState.talking;
}
break;
case "Ringing":
if (newStateLccs != null)
{
if (!channels.Contains(newstate.Channel))
{
channels.Add(newstate.Channel, newstate.CallerId);
}
newStateLccs[i].callid = newstate.Channel;
newStateLccs[i].remoteState = Wybecom.TalkPortal.CTI.Proxy.ConnectionState.established;
newStateLccs[i].state = Wybecom.TalkPortal.CTI.Proxy.ConnectionState.alerting;
newStateLccs[i].terminalState = TerminalState.ringing;
}
break;
case "Ring":
if (newStateLccs != null)
{
if (!channels.Contains(newstate.Channel))
{
channels.Add(newstate.Channel, newstate.CallerId);
}
newStateLccs[i].callid = newstate.Channel;
newStateLccs[i].remoteState = Wybecom.TalkPortal.CTI.Proxy.ConnectionState.alerting;
newStateLccs[i].state = Wybecom.TalkPortal.CTI.Proxy.ConnectionState.dialing;
newStateLccs[i].terminalState = TerminalState.inuse;
}
break;
}
}
catch (Exception stateException)
{
log.Debug("NewState exception: " + stateException.Message);
}
if (newstateLc != null)
{
newstateLc.lineControlConnection = newStateLccs;
ss.SetLineControl(newstateLc);
}
break;
case "OriginateResponseEvent":
OriginateResponseEvent originateresponse = e as OriginateResponseEvent;
break;
case "ParkedCallEvent":
ParkedCallEvent parkedcall = e as ParkedCallEvent;
break;
case "ParkedCallGiveUpEvent":
ParkedCallGiveUpEvent parkedcallgiveup = e as ParkedCallGiveUpEvent;
break;
case "ParkedCallsCompleteEvent":
ParkedCallsCompleteEvent parkedcallscomplete = e as ParkedCallsCompleteEvent;
break;
case "ParkedCallTimeOutEvent":
ParkedCallTimeOutEvent parkedcalltimeout = e as ParkedCallTimeOutEvent;
break;
case "PeerEntryEvent":
log.Debug("SipAction: one peer entry event received, " + e.ToString());
PeerEntryEvent peerentry = e as PeerEntryEvent;
peers.Add(peerentry);
ss.SetLineControl(getLineControlFromPeerEntry(peerentry));
break;
case "PeerlistCompleteEvent":
log.Debug("SipAction: peer list completed " + e.ToString());
PeerlistCompleteEvent peerlistcomplete = e as PeerlistCompleteEvent;
acs.setPeers(peers);
break;
case "PeerStatusEvent":
PeerStatusEvent peerstatus = e as PeerStatusEvent;
log.Debug("Peer status: " + peerstatus.ToString());
break;
case "PRIEvent":
PRIEvent pri = e as PRIEvent;
break;
case "RegistryEvent":
RegistryEvent registry = e as RegistryEvent;
break;
case "ReloadEvent":
ReloadEvent reload = e as ReloadEvent;
break;
case "RenameEvent":
RenameEvent rename = e as RenameEvent;
break;
case "ResponseEvent":
ResponseEvent response = e as ResponseEvent;
break;
case "RTCPReceivedEvent":
RTCPReceivedEvent rtcpreceived = e as RTCPReceivedEvent;
break;
case "RTCPSentEvent":
RTCPSentEvent rtcpsent = e as RTCPSentEvent;
break;
case "RTPReceiverStatEvent":
RTPReceiverStatEvent rtpreceiver = e as RTPReceiverStatEvent;
break;
case "RTPSenderStatEvent":
RTPSenderStatEvent rtpsender = e as RTPSenderStatEvent;
break;
case "ShowDialPlanCompleteEvent":
ShowDialPlanCompleteEvent showdialplan = e as ShowDialPlanCompleteEvent;
break;
case "ShutdownEvent":
ShutdownEvent shutdown = e as ShutdownEvent;
break;
case "StatusCompleteEvent":
StatusCompleteEvent statuscomplete = e as StatusCompleteEvent;
break;
case "StatusEvent":
StatusEvent status = e as StatusEvent;
break;
case "TransferEvent":
TransferEvent transfer = e as TransferEvent;
break;
case "UnholdEvent":
UnholdEvent unhold = e as UnholdEvent;
break;
case "UnknownEvent":
UnknownEvent unknown = e as UnknownEvent;
break;
case "UnlinkEvent":
UnlinkEvent unlink = e as UnlinkEvent;
log.Debug("Unlink event : " + unlink.ToString());
LineControlConnection[] lccs = null;
i = 0;
lc = getLineControl(unlink.CallerId1);
if (lc != null)
{
if (lc.lineControlConnection.Length > 1)
{
lccs = new LineControlConnection[lc.lineControlConnection.Length - 1];
foreach (LineControlConnection linklcc in lc.lineControlConnection)
{
if (linklcc.callid != unlink.Channel1)
{
lccs[i] = linklcc;
i++;
break;
}
}
}
else
{
lc.lineControlConnection = null;
}
ss.SetLineControl(lc);
}
i = 0;
lc = getLineControl(unlink.CallerId2);
if (lc != null)
{
if (lc.lineControlConnection.Length > 1)
{
lccs = new LineControlConnection[lc.lineControlConnection.Length - 1];
foreach (LineControlConnection linklcc in lc.lineControlConnection)
{
if (linklcc.callid != unlink.Channel2)
{
lccs[i] = linklcc;
i++;
break;
}
}
}
else
{
lc.lineControlConnection = null;
}
ss.SetLineControl(lc);
}
break;
case "UnparkedCallEvent":
UnparkedCallEvent unparked = e as UnparkedCallEvent;
break;
case "UserEvent":
UserEvent user = e as UserEvent;
break;
case "VarSetEvent":
VarSetEvent varset = e as VarSetEvent;
break;
case "ZapShowChannelsCompleteEvent":
ZapShowChannelsCompleteEvent zapshowchannelscomplete = e as ZapShowChannelsCompleteEvent;
break;
case "ZapShowChannelsEvent":
ZapShowChannelsEvent zapshowchannels = e as ZapShowChannelsEvent;
break;
}
//ACDConnector
switch (e.GetType().Name)
{
case "AgentCallbackLoginEvent":
AgentCallbackLoginEvent agentcallbacklogin = e as AgentCallbackLoginEvent;
break;
case "AgentCallbackLogoffEvent":
AgentCallbackLogoffEvent agentcallbacklogoff = e as AgentCallbackLogoffEvent;
break;
case "AgentCalledEvent":
AgentCalledEvent agentcalled = e as AgentCalledEvent;
break;
case "AgentCompleteEvent":
AgentCompleteEvent agentcomplete = e as AgentCompleteEvent;
break;
case "AgentConnectEvent":
AgentConnectEvent agentconnect = e as AgentConnectEvent;
break;
case "AgentDumpEvent":
AgentDumpEvent agentdump = e as AgentDumpEvent;
break;
case "AgentLoginEvent":
AgentLoginEvent agentlogin = e as AgentLoginEvent;
break;
case "AgentLogoffEvent":
AgentLogoffEvent agentlogoff = e as AgentLogoffEvent;
break;
case "AgentsCompleteEvent":
AgentsCompleteEvent agentscomplete = e as AgentsCompleteEvent;
break;
case "AgentsEvent":
AgentsEvent agentevent = e as AgentsEvent;
break;
case "QueueCallerAbandonEvent":
QueueCallerAbandonEvent queuecallerabandon = e as QueueCallerAbandonEvent;
break;
case "QueueEntryEvent":
QueueEntryEvent queueentry = e as QueueEntryEvent;
break;
case "QueueEvent":
QueueEvent queue = e as QueueEvent;
break;
case "QueueMemberEvent":
QueueMemberEvent queuemember = e as QueueMemberEvent;
break;
case "QueueMemberPausedEvent":
QueueMemberPausedEvent queuememberpaused = e as QueueMemberPausedEvent;
break;
case "QueueMemberPenaltyEvent":
QueueMemberPenaltyEvent queuememberpenalty = e as QueueMemberPenaltyEvent;
break;
case "QueueMemberRemovedEvent":
QueueMemberRemovedEvent queuememberremoved = e as QueueMemberRemovedEvent;
break;
case "QueueMemberStatusEvent":
QueueMemberStatusEvent queuememberstatus = e as QueueMemberStatusEvent;
break;
case "QueueParamsEvent":
QueueParamsEvent queueparams = e as QueueParamsEvent;
break;
case "QueueStatusCompleteEvent":
QueueStatusCompleteEvent queuestatuscomplete = e as QueueStatusCompleteEvent;
break;
}
}
private void OnController3Stoped(QueueEvent ev)
{
controller_3_moving = false;
}
public QueueItem(QueueEvent method)
{
this.method = method;
}
private void OnSelectingGamepadsLoad(QueueEvent ev)
{
ControllerSelectionUI.Instance.SetSelectingGamepads(true);
}
/// <summary>
/// Add a method to be queued. The method will be called when the event (traveling at c) has reached the camera.
/// </summary>
/// <param name="method">The method to be called</param>
public void QueueMethod(QueueEvent method)
{
eventQueue.Add(new QueueItem(method));
}
/// <summary>
/// Deserialize the message
/// </summary>
/// <param name="map">An <see cref="OSDMap"/> containing the data</param>
public override void Deserialize(OSDMap map)
{
Sequence = map["id"].AsInteger();
OSDArray arrayEvents = (OSDArray)map["events"];
MessageEvents = new QueueEvent[arrayEvents.Count];
for (int i = 0; i < arrayEvents.Count; i++)
{
OSDMap eventMap = (OSDMap)arrayEvents[i];
QueueEvent ev = new QueueEvent();
ev.MessageKey = eventMap["message"].AsString();
ev.EventMessage = MessageUtils.DecodeEvent(ev.MessageKey, (OSDMap)eventMap["body"]);
MessageEvents[i] = ev;
}
}
public static long Solve(int[] a, int[] b, int[] c, int[] d)
{
SortedDictionary <int, QueueEvent> events = new SortedDictionary <int, QueueEvent>();
QueueEvent evt;
for (int i = 0; i < a.Length; i++)
{
if (!events.TryGetValue(a[i], out evt))
{
evt = new QueueEvent();
events[a[i]] = evt;
}
evt.NewShots++;
}
for (int i = 0; i < b.Length; i++)
{
if (!events.TryGetValue(b[i], out evt))
{
evt = new QueueEvent();
events[b[i]] = evt;
}
evt.LeaveShots++;
}
for (int i = 0; i < c.Length; i++)
{
if (!events.TryGetValue(c[i], out evt))
{
evt = new QueueEvent();
events[c[i]] = evt;
}
evt.NewPlayers++;
}
for (int i = 0; i < d.Length; i++)
{
if (!events.TryGetValue(d[i], out evt))
{
evt = new QueueEvent();
events[d[i]] = evt;
}
evt.LeavePlayers++;
}
int result = 0;
int shots = 0;
int players = 0;
foreach (var kv in events)
{
evt = kv.Value;
result += evt.NewShots * (players + evt.NewPlayers) + shots * evt.NewPlayers;
shots += evt.NewShots - evt.LeaveShots;
players += evt.NewPlayers - evt.LeavePlayers;
}
return(result);
}
