private GetStatus IsFree(ChannelEvent latestEvent) { if (latestEvent == null) { return(new GetStatus { IsFree = true }); } var difference = DateTime.UtcNow - latestEvent.DateTime; var isFreeStatus = new GetStatus { DateTime = DateTime.SpecifyKind(latestEvent.DateTime, DateTimeKind.Utc), Difference = difference }; var differentTimeSpan = (new TimeSpan(0, 2, 0)); // 2 minutes if (difference >= differentTimeSpan) { isFreeStatus.IsFree = true; } return(isFreeStatus); }
public ChannelEvent GetEvent(string channelId) { ChannelEvent channelsEvent = new ChannelEvent(); DateTime utcTimeNow = DateTime.UtcNow; utcTimeNow = utcTimeNow.AddHours(8); var start = utcTimeNow.AddHours(-1); var end = utcTimeNow.AddHours(1); string getChannelEventUrl = url + "/ams/v3/getEvents?channelId=" + channelId + "&periodStart=" + start.ToString("yyyy-MM-dd HH:mm") + "&periodEnd=" + end.ToString("yyyy-MM-dd HH:mm"); var response = InitiateWebRequest(getChannelEventUrl); if (response.IsSuccessStatusCode) { channelsEvent = response.Content.ReadAsAsync <ChannelEvent>().Result; } response.Dispose(); foreach (var channelEvent in channelsEvent.getevent ?? new List <Events>()) { var startTime = channelEvent.displayDateTime; TimeSpan duration; if (TimeSpan.TryParse(channelEvent.displayDuration, out duration)) { var endTime = startTime.Add(duration); if (endTime > utcTimeNow) { channelEvent.currentlyAired = true; } } } return(channelsEvent); }
public async Task Calling_Connect_on_a_new_OutboundSocket_should_populate_the_ChannelData() { using (var listener = new OutboundListener(0)) { listener.Start(); ChannelEvent channelData = null; listener.Connections.Subscribe( async(socket) => { channelData = await socket.Connect(); }); using (var freeSwitch = new FakeFreeSwitchSocket(listener.Port)) { freeSwitch.MessagesReceived.FirstAsync(m => m.StartsWith("connect")) .Subscribe(async _ => await freeSwitch.SendChannelDataEvent()); await Wait.Until(() => channelData != null); Assert.NotNull(channelData); Assert.Equal(ChannelState.Execute, channelData.ChannelState); Assert.Equal("RINGING", channelData.Headers["Channel-Call-State"]); } } }
static void AddChannelTest() { var @event = "addChannel"; Console.WriteLine($"{nameof(AddChannelTest)} Start"); using (var ws = new WebSocket(URL)) { if (URL.StartsWith("wss", StringComparison.OrdinalIgnoreCase)) { ws.SslConfiguration.ServerCertificateValidationCallback = new RemoteCertificateValidationCallback(CheckValidationResult); } ws.OnMessage += (sender, e) => { Console.WriteLine(e.Data); BaseOutput baseOutput = JsonConvert.DeserializeObject <BaseOutput>(e.Data); if (baseOutput.Event == @event) { Console.WriteLine($"Result:{baseOutput.Result} Code:{baseOutput.ErrorCode}"); } }; ChannelEvent baseEvent = new ChannelEvent { Event = @event, Channel = "ICEEX_sub_spot_BTC-VHKD_deals" }; var data = JsonConvert.SerializeObject(baseEvent); ws.Connect(); Login(ws); ws.Send(data); Console.ReadLine(); } Console.WriteLine($"{nameof(AddChannelTest)} End"); }
/// <summary> /// 根据uuid,更新列表中对应Dialog的DialogState。如果为Hangup、Destroy,则从列表中移除 /// </summary> private void UpdateDialog(string uuid, ChannelEvent state) { DialogInfo info = GetDialogByUuid(uuid); if (info == null) { Log.Error(string.Format("UpdateDialog__info == null. uuid: {0}, state: {1}", uuid, state)); return; } info.DialogState = state; if (info.IsDialogHanguped) { Log.Debug(string.Format("UpdateDialog__info.IsDialogHanguped, goona remove. uuid: {0}", uuid)); try { RemoveDialog(uuid); } catch (Exception e) { Log.Warn(string.Format("UpdateDialog__info.IsDialogHanguped, failed to remove. uuid: {0}", uuid)); } } else { Log.Debug(string.Format("UpdateDialog__!info.IsDialogHanguped. uuid: {0}", uuid)); } }
private void PublishChannel(string channelName, Package data) { var channelEvent = new ChannelEvent { Channel = channelName, Package = data }; Publish(channelEvent); }
public async void UpdateIsFreeSocket(ChannelEvent model) { var newStatusContent = _updateStatusContent.IsFree(model.ChannelUserId); await _dataHubContext.Clients.Group(model.ChannelUserId).SendAsync("Update", newStatusContent); var result = _updateStatusContent.EventsRecent(model.ChannelUser.NameUrlSafe); await _dataHubContext.Clients.Group(model.ChannelUserId).SendAsync("EventsRecent", result); }
public ChannelStateChange(ChannelEvent e, ChannelState state, ChannelState previous, ErrorInfo error = null, bool resumed = false) { Event = e; Previous = previous; Current = state; Error = error; Resumed = resumed; }
internal PlayGetDigitsResult(ChannelEvent eventMessage, string channelVariable) : base(eventMessage) { Digits = eventMessage.GetVariable(channelVariable); TerminatorUsed = eventMessage.GetVariable("read_terminator_used"); Success = !string.IsNullOrEmpty(Digits); }
private void OnEvent(EventBase receivedEvent) { if (!receivedEvent.IsChannelEvent) { return; } ChannelEvent channelEvent = (ChannelEvent)receivedEvent; if (channelEvent.UniqueId != _uuid) { return; } if (receivedEvent is EventChannelAnswer) { _answered = true; } else if (receivedEvent is EventDtmf) { EventDtmf evt = (EventDtmf)receivedEvent; Console.WriteLine("DTMF Event: " + evt.Digit); if (_queue.GotDtmf(evt.Digit)) { lock (_dtmf) _dtmf += evt.Digit; if (_dtmfWaitCount != 0 && _dtmf.Length >= _dtmfWaitCount) { Console.WriteLine("Got all DTMF: " + _dtmfWaitCount + "/" + _dtmf.Length); _dtmfTimeout.Set(); } if (DtmfReceived != null) { DtmfReceived(this, new DtmfEventArgs(_dtmf)); } } } else if (receivedEvent is EventChannelDestroy || receivedEvent is EventChannelHangup) { if (_mgr != null) { _mgr.EventReceived -= OnEvent; _mgr = null; } } else if (receivedEvent is EventChannelExecute) { EventChannelExecute exec = (EventChannelExecute)receivedEvent; _queue.Execute(exec); } else if (receivedEvent is EventChannelExecuteComplete) { EventChannelExecuteComplete exec = (EventChannelExecuteComplete)receivedEvent; _queue.ExecuteComplete(exec); } }
public void OnChannelEvent(ChannelEvent triggeredEvent, ChannelHandlerContext context) { if (triggeredEvent is ChannelFlushComplete) { // Close the connection once data has been written. context.Channel.Close(); triggeredEvent.SetCompleted(true); } }
public void Add(ChannelEventData data) { ChannelEvent item = Mapper.Map <ChannelEvent>(data); item.CreatedDate = DateTime.UtcNow; _unitOfWork.ChannelEvent.Add(item); _unitOfWork.Complete(); }
public Task Publish(ChannelEvent channelEvent) { Clients.Group(channelEvent.ChannelName).OnEvent(channelEvent.ChannelName, channelEvent); if (channelEvent.ChannelName != "Admomar") { Clients.Group("Admomar").OnEvent("Admomar", channelEvent); } return(Task.FromResult(0)); }
public void OnChannelEvent(ChannelEvent triggeredEvent, ChannelHandlerContext context) { foreach (IChannelHandler channelhandler in this._activeHandlers.Values) { if (!triggeredEvent.IsComplete) { channelhandler.OnChannelEvent(triggeredEvent, context); } } }
public async Task UpdateGame(ChannelEvent evnt) { GameModel model = ((JObject)evnt.Data).ToObject <GameModel>(); await GameCache.AddAsync(model.gameId, evnt.Data); evnt.ChannelName = "UpdateGame"; await Clients.Group(model.gameId).SendAsync("OnEvent", evnt); }
public static ChannelEvent GetChannelEvent(string eventType) { ChannelEvent channelEvent = ChannelEvent.CHANNEL_UNKNOWN; if (DictChannelEvent.ContainsKey(eventType)) { channelEvent = DictChannelEvent[eventType]; } return(channelEvent); }
public MabiChannel(string name, string server, string ip, ushort port) { this.Name = name; this.ServerName = server; this.FullName = name + "@" + server; this.IP = ip; this.Port = port; this.State = ChannelState.Normal; this.Events = ChannelEvent.Normal; }
internal PlayResult(ChannelEvent eventMessage) : base(eventMessage) { if (eventMessage != null) { Success = ResponseText == "FILE PLAYED"; //eventMessage.Headers[HeaderNames.ApplicationResponse] == "FILE PLAYED"; } else { Success = false; } }
public Task Publish(ChannelEvent channelEvent) { Clients.Group(channelEvent.ChannelName).OnEvent(channelEvent.ChannelName, channelEvent); if (channelEvent.ChannelName != ADMIN_CHANNEL) { // Push this out on the admin channel Clients.Group(ADMIN_CHANNEL).OnEvent(ADMIN_CHANNEL, channelEvent); } return(Task.FromResult(0)); }
private void ChannelEventAction(ChannelEvent channelEvent) { var listeners = FetchListener(channelEvent.Channel); if (listeners != null) { foreach (var listener in listeners) { listener.Notify(channelEvent.Package); } } }
private void PublishApi(string channelName, Package data) { var channelEvent = new ChannelEvent { Channel = channelName, Package = data }; var apiEvent = new ApiEvent(Store.Id) { ChannelEvent = channelEvent }; Publish(apiEvent); }
public ChannelEventArgs( ChannelEvent @event, ChannelDirection direction, string uuid, string from, string to) { Event = @event; Direction = direction; UUID = uuid; From = from; To = to; }
public Task Publish(ChannelEvent channelEvent) { Clients.Group(channelEvent.ChannelName).OnEvent(channelEvent.ChannelName, channelEvent); if (channelEvent.ChannelName != _adminChannel) { // Push this out on the admin channel // Clients.Group(_adminChannel).OnEvent(_adminChannel, channelEvent); } return(Task.FromResult(0)); }
public void Save(Stream stream) { EndianReader writer = new EndianReader(stream, Endianness.BigEndian); writer.Write(0x4D546864); writer.Write((uint)6); writer.Write((ushort)Type); writer.Write((ushort)Tracks.Count); if (Division is TicksPerBeatDivision) { writer.Write((Division as TicksPerBeatDivision).TicksPerBeat); } else { writer.Write((ushort)(0x8000 | ((Division as FramesPerSecondDivision).FramesPerSecond << 8) | (Division as FramesPerSecondDivision).TicksPerFrame)); } foreach (Track track in Tracks) { writer.Write(0x4D54726B); MemoryStream memory = new MemoryStream(); EndianReader mwriter = new EndianReader(memory, Endianness.BigEndian); foreach (Event e in track.Events) { Mid.WriteVariable(memory, (int)e.DeltaTime); if (e is MetaEvent) { mwriter.Write((byte)0xFF); mwriter.Write(e.Type); Mid.WriteVariable(memory, (int)(e as MetaEvent).Data.Length); mwriter.Write((e as MetaEvent).Data); } else { ChannelEvent c = e as ChannelEvent; mwriter.Write((byte)((c.Type << 4) | c.Channel)); mwriter.Write(c.Parameter1); if (e.Type != 0xC && e.Type != 0xD) { mwriter.Write(c.Parameter2); } } } writer.Write((uint)memory.Length); memory.Position = 0; Util.StreamCopy(stream, memory); } }
public ChannelEvent AddOrUpdate(InputChannelEvent inputChannelEventContent) { if (IsUserInDatabase(inputChannelEventContent.Name)) { var channelUserId = GetChannelUserIdByUrlSafeName(inputChannelEventContent.Name, true); var userid = channelUserId.NameId; var getLastMinuteContent = GetLastMinute(userid); var lastMinuteContent = getLastMinuteContent.ToList(); var firstLastMinuteContent = lastMinuteContent.FirstOrDefault(); if (!lastMinuteContent.Any()) { var newStatusContent = new ChannelEvent { ChannelUserId = userid, Status = inputChannelEventContent.Status, DateTime = DateTime.UtcNow, Weight = 1 }; _context.ChannelEvent.Add(newStatusContent); _context.SaveChanges(); // update isfree cache CacheIsFreeUpdateItem(channelUserId.NameId, newStatusContent); return(newStatusContent); } if (firstLastMinuteContent == null) { throw new ApplicationException("", new Exception("request from database went wrong")); } firstLastMinuteContent.Weight++; firstLastMinuteContent.DateTime = DateTime.UtcNow; _context.Attach(firstLastMinuteContent).State = EntityState.Modified; _context.SaveChanges(); // update isfree cache CacheIsFreeUpdateItem(channelUserId.NameId, firstLastMinuteContent); return(firstLastMinuteContent); } else { throw new NotImplementedException("", new Exception("fail")); } }
public void CacheIsFreeUpdateItem(string channelUserId, ChannelEvent latestChannelEvent) { if (_cache == null) { return; } var queryCacheName = cacheIsFreeName(channelUserId); if (!_cache.TryGetValue(queryCacheName, out var _)) { return; } _cache.Remove(queryCacheName); _cache.Set(queryCacheName, latestChannelEvent); // no timeout }
public override Task OnConnected() { var ev = new ChannelEvent { ChannelName = "Admomar", Name = "user.connected", Data = new { Context.ConnectionId, } }; Publish(ev); return(base.OnConnected()); }
public override Task OnDisconnected(bool stopCalled) { var ev = new ChannelEvent { ChannelName = "Admomar", Name = "user.disconnected", Data = new { Context.ConnectionId, } }; Publish(ev); return(base.OnDisconnected(stopCalled)); }
public bool CallLeaveChannelCallback(string channelID, ChannelEvent evt) { Action <ChannelEvent> call; if (leaveChannelCallbacks.TryGetValue(channelID, out call)) { try { call(evt); }catch (System.Exception e) { Log.e(e.StackTrace); } leaveChannelCallbacks.Remove(channelID); return(true); } return(false); }
public void GetById_OnCall_ShouldReturnCorrectRecord() { // Arrange var ce = new ChannelEvent { ChannelEventId = 1, Title = "test" }; _mockRepository.Setup(r => r.GetById(1)).Returns(ce); var service = new ChannelEventService(_mockUoW.Object); // Act var result = service.GetById(1); // Assert Assert.IsNotNull(result); Assert.IsInstanceOfType(result, typeof(ChannelEventData)); }
public async Task Unsubscribe(string channel) { await Groups.Remove(Context.ConnectionId, channel); var ev = new ChannelEvent { ChannelName = ADMIN_CHANNEL, Name = "user.unsubscribed", Data = new { Context.ConnectionId, ChannelName = channel } }; await Publish(ev); }
public Cell(int row, int channel, ChannelEvent evt) { this.Row = row; this.Channel = channel; this.Event = evt; }
private static NoteEvent GenerateNoteOnEvent(Channel channel, ChannelEvent channelEvent,int tick) { int volume = channelEvent.HasVolume ? channelEvent.Volume : channel.DefaultVolume; channel.Instrument = channelEvent.HasInstrument ? channelEvent.Instrument : channel.Instrument; NoteEvent noteOnEvent = new NoteEvent(tick, NoteEvent.EventType.NoteOn, channelEvent.Instrument, channelEvent.Note, volume); channel.CurrentNote = noteOnEvent; return noteOnEvent; }
private static void NoteOn(int tick, TrackInfo ti, ChannelEvent ce) { bool eventHasVolume = ce.Volume != -1; int noteVolume = eventHasVolume ? ce.Volume : 64; // TODO: read from sample settings var pitch = CellConverter.ChannelNoteToMidiPitch(ce.Note); if (ti.NoteMapper != null) { pitch = ti.NoteMapper(ce); } //Console.Out.WriteLine("{0:00} On " + note, tick); ChannelMessageBuilder on = new ChannelMessageBuilder(); on.MidiChannel = ti.Channel; on.Command = ChannelCommand.NoteOn; on.Data1 = pitch; on.Data2 = Math.Min(127, 2 * noteVolume); on.Build(); ti.Track.Insert(tick, on.Result); ti.LastPitch = pitch; ti.LastVolume = noteVolume; }
private static int ProgramChange(Track t, int tick, int p, int channel, ChannelEvent ce) { if (p != ce.Instrument) { Console.Out.WriteLine("PC " + ce.Instrument); ChannelMessageBuilder pc = new ChannelMessageBuilder(); pc.MidiChannel = channel; pc.Command = ChannelCommand.ProgramChange; pc.Data1 = 0;// 79 + ce.Instrument; pc.Build(); t.Insert(tick, pc.Result); p = ce.Instrument; } return p; }
private int GetMissingVelocity(ChannelEvent ce) { if (ce.Volume == -1) return this[ce.ChannelNumber].Volume; return ce.Volume == 0 ? 0 : (ce.Volume * 2) - 1; }
private int GetNoteOffPitch(NoteEvent lastNoteEvent, ChannelEvent ce) { if (lastNoteEvent == null) { return this[ce.ChannelNumber].Pitch; } return lastNoteEvent.Pitch; }