private ChannelMetadataRecord ToChannelMetadataRecord(ChannelMetadataRecord record, IndexMetadataRecord indexMetadata)
{
var uri = GetChannelUri(record.ChannelName);
var channel = new ChannelMetadataRecord()
{
ChannelUri = uri,
ContentType = uri.ContentType,
ChannelId = record.ChannelId,
ChannelName = record.ChannelName,
Uom = record.Uom,
MeasureClass = record.MeasureClass,
DataType = record.DataType,
Description = record.Description,
Uuid = record.Uuid,
Status = record.Status,
Source = record.Source,
Indexes = new[]
{
indexMetadata
},
CustomData = new Dictionary <string, DataValue>()
};
Channels.Add(channel);
return(channel);
}
private void OnChannelMetadata(object sender, ProtocolEventArgs <ChannelMetadata> e)
{
if (!e.Message.Channels.Any())
{
Parent.Details.Append(Environment.NewLine + "// No channels were described");
return;
}
// add to channel metadata collection
e.Message.Channels.ForEach(x =>
{
if (Channels.Any(c => c.ChannelUri.EqualsIgnoreCase(x.ChannelUri)))
{
return;
}
Channels.Add(x);
ChannelStreamingInfos.Add(ToChannelStreamingInfo(x));
});
if (e.Header.MessageFlags != (int)MessageFlags.MultiPart)
{
LogChannelMetadata(Channels);
}
}
public void Execute(SendReminderRequest sendReminderRequest)
{
Called = true;
CountCalled++;
Channels.Add(sendReminderRequest.Channel);
Text = sendReminderRequest.Text;
}
public void SubscribeChannel(FizzChannelMeta channelMeta)
{
if (Client.State == FizzClientState.Closed)
{
FizzLogger.W("FizzClient should be opened before subscribing channel.");
return;
}
if (channelMeta == null)
{
FizzLogger.E("FizzClient unable to subscribe, channel meta is null.");
return;
}
if (channelLookup.ContainsKey(channelMeta.Id))
{
FizzLogger.W("FizzClient channel is already subscribed.");
return;
}
FizzChannelModel channel = new FizzChannelModel(channelMeta);
Channels.Add(channel);
channelLookup.Add(channel.Id, channel);
channel.SubscribeAndQueryLatest();
}
/// <summary>
/// Generate the Channels section of an AsyncApi schema.
/// </summary>
private Channels GenerateChannels(IEnumerable <TypeInfo> asyncApiTypes, ISchemaRepository schemaRepository)
{
var channels = new Channels();
var methodsWithChannelAttribute = asyncApiTypes
.SelectMany(type => type.DeclaredMethods)
.Select(method => new
{
Channel = method.GetCustomAttribute <ChannelAttribute>(),
Method = method,
})
.Where(mc => mc.Channel != null);
foreach (var mc in methodsWithChannelAttribute)
{
var channelItem = new ChannelItem
{
Description = mc.Channel.Description,
Parameters = mc.Channel.Parameters,
Publish = GenerateOperation(mc.Method, schemaRepository, OperationType.Publish),
Subscribe = GenerateOperation(mc.Method, schemaRepository, OperationType.Subscribe),
};
channels.Add(mc.Channel.Name, channelItem);
var context = new ChannelItemFilterContext(mc.Method, schemaRepository, mc.Channel);
foreach (var filter in _options.ChannelItemFilters)
{
filter.Apply(channelItem, context);
}
}
return(channels);
}
private void fillChannels(IPsnMeter psnMeter)
{
foreach (var channel in psnMeter.Channels)
{
Channels.Add(new PsnChannelViewModel(channel, this));
}
}
private async Task RefreshChannels(bool force = false)
{
if (!force && Channels.Any())
{
return;
}
if (BusyStart != null)
{
BusyStart();
}
Channels.Clear();
var channels = await _slackClient.GetChannels(new ChannelQuery { IncludeArchived = false, MyChannelsOnly = true });
foreach (var c in channels)
{
Channels.Add(
new SlackItem(c.id, "#{0}".FormatWith(c.name), c.purpose.value, "#{0}".FormatWith(c.name)));
}
if (BusyStop != null)
{
BusyStop();
}
}
public async Task <Channel> AddChannel(Channel channel, params ChannelMember[] members)
{
bool saved = false;
do
{
try
{
long id = SkynetRandom.Id();
channel.ChannelId = id;
Channels.Add(channel);
foreach (ChannelMember member in members)
{
member.ChannelId = id;
}
ChannelMembers.AddRange(members);
await SaveChangesAsync().ConfigureAwait(false);
saved = true;
}
catch (DbUpdateException ex) when(ex?.InnerException is MySqlException mex && mex.Number == 1062)
{
}
} while (!saved);
return(channel);
}
#endregion
}
private async void _device_DataReceived(object sender, BeaconInfoEventArgs e)
{
if (e.Info == null)
{
return;
}
DataReceived?.Invoke(this, e);
if (Dispatcher == null)
{
return;
}
await Dispatcher.RunAsync(Windows.UI.Core.CoreDispatcherPriority.Normal,
() =>
{
var net = NetworkInfo.Where(x => x.Ssid == e.Info.ssid && x.Mac == e.Info.mac).FirstOrDefault();
if (net == null)
{
net = new Data.NetworkInfo(e.Info);
NetworkInfo.Add(net);
}
if (net.AddChannel(e.Info) && net.Ssid == _selectedSsid && net.Mac == _selectedMac)
{
Channels.Add(net.Channels.Last());
}
if (_selectedChannel == e.Info.wifiChan && net.Ssid == _selectedSsid && net.Mac == _selectedMac)
{
_calculator.HandleInfo(e.Info);
PropertyChanged?.Invoke(this, new PropertyChangedEventArgs(nameof(Diff)));
PropertyChanged?.Invoke(this, new PropertyChangedEventArgs(nameof(Level)));
}
});
}
private void _usb_DataReceived(object sender, BeaconInfoEventArgs e)
{
if (e.Info == null)
{
return;
}
var net = NetworkInfo.Where(x => x.Ssid == e.Info.ssid && x.Mac == e.Info.mac).FirstOrDefault();
if (net == null)
{
net = new Data.NetworkInfo(e.Info);
NetworkInfo.Add(net);
}
if (net.AddChannel(e.Info) && net.Ssid == _selectedSsid && net.Mac == _selectedMac)
{
Channels.Add(net.Channels.Last());
}
if (_selectedChannel == e.Info.wifiChan && net.Ssid == _selectedSsid && net.Mac == _selectedMac)
{
if (_calculator.HandleInfo(e.Info))
{
var level = _calculator.GetAvg();
_cameraFragment.SetLevel(level);
}
//PropertyChanged?.Invoke(this, new PropertyChangedEventArgs(nameof(Diff)));
//PropertyChanged?.Invoke(this, new PropertyChangedEventArgs(nameof(Level)));
}
}
/// <summary>
/// 取得栏目及其下属文章
/// </summary>
public void LoadArticlesOfChannels()
{
Channels = GetChannels();
ShowFields = ArticleShowFields;
ConstructFelds();
while (Channels.Count % ColumnCount != 0)
{
Channels.Add(new Channel());
}
foreach (Channel ch in Channels)
{
if (ch.ID != null)
{
if ((TypeOfChannel)int.Parse(ch.Type) == TypeOfChannel.RssOriginal)
{
RssDataProvider rssProvider = new RssDataProvider();
rssProvider.PageSize = PageSize;
ch.Articles = rssProvider.ProcessRSSItem(ch.ReturnUrl);
}
else
{
ch.Articles = FormatArticlesData(GetArticleList(ch));
}
}
else
{
ch.Articles = new List <Article>();
}
}
}
protected override void LoadAllAvailableChannels()
{
// The 2D Laser Scanner only yields a single channel of equally-spaced distance values
Channels.Clear();
Channels.Add(ChannelRegistry.Instance.RegisterChannel(ChannelNames.Distance));
Channels.Add(ChannelRegistry.Instance.RegisterChannel(ChannelNames.Point3DImage));
}
private void GuildsOnCollectionChanged(object sender, NotifyCollectionChangedEventArgs e)
{
// ReSharper disable once SwitchStatementMissingSomeCases
switch (e.Action)
{
case NotifyCollectionChangedAction.Add:
foreach (TestGuild guild in e.NewItems)
{
foreach (var channel in guild.Channels)
{
if (!Channels.Contains(channel))
{
Channels.Add(channel);
}
}
}
break;
case NotifyCollectionChangedAction.Reset:
case NotifyCollectionChangedAction.Remove:
foreach (TestGuild guild in e.NewItems)
{
foreach (var channel in guild.Channels)
{
Channels.Remove(channel);
}
}
break;
}
}
void fillChannels()
{
foreach (var chan in Meter.Channels)
{
Channels.Add(new RpdChannelViewModel(chan, this, rpdConfigurator, connectionPointsViewModel));
}
}
public async Task DownloadFromMarsAsync()
{
var request = WebRequest.CreateHttp(MarsList);
request.Method = "GET";
using var response = await request.GetResponseAsync();
using var reader = new StreamReader(response.GetResponseStream());
string temp = await reader.ReadToEndAsync();
ChannelList list = Json.Deserialize <ChannelList>(temp);
foreach (var channel in list.Items)
{
var c = Channels.Find(s => s.Equals(channel));
if (c != null)
{
c.CopyFrom(channel);
}
else
{
Channels.Add(new AresChannel()
{
Name = channel.Name,
Topic = channel.Topic,
Port = (ushort)channel.Port,
ExternalIp = IPAddress.Parse(channel.ExternalIP),
LocalIp = IPAddress.Parse(channel.LocalIP),
WebSockets = true
});
}
}
}
/// <summary>
/// Generate the Channels section of the AsyncApi schema from the <see cref="ChannelAttribute"/> on classes.
/// </summary>
private Channels GenerateChannelsFromClasses(IEnumerable <TypeInfo> asyncApiTypes, ISchemaRepository schemaRepository)
{
var channels = new Channels();
var classesWithChannelAttribute = asyncApiTypes
.Select(type => new
{
Channel = type.GetCustomAttribute <ChannelAttribute>(),
Type = type,
})
.Where(cc => cc.Channel != null);
foreach (var cc in classesWithChannelAttribute)
{
var channelItem = new ChannelItem
{
Description = cc.Channel.Description,
Parameters = cc.Channel.Parameters,
Publish = GenerateOperationFromClass(cc.Type, schemaRepository, OperationType.Publish),
Subscribe = GenerateOperationFromClass(cc.Type, schemaRepository, OperationType.Subscribe),
};
channels.Add(cc.Channel.Name, channelItem);
var context = new ChannelItemFilterContext(cc.Type, schemaRepository, cc.Channel);
foreach (var filter in _options.ChannelItemFilters)
{
filter.Apply(channelItem, context);
}
}
return(channels);
}
public async Task Initialize()
{
Channels.Add(new ChannelViewModel("#Main", ChannelType.Const));
Channels.Add(new ChannelViewModel("#noPrivacy", ChannelType.Const));
SelectedChannel = Channels.First();
await _messenger.SendAsync(new ConnectMessage(SelectedChannel.Id, Nickname));
}
public MonitorBarEntityViewModel(Monitor monitor) : base(monitor)
{
foreach (var channel in Monitor.Channels)
{
Channels.Add(new ChannelBarEntityViewModel(channel));
}
}
void HandlePrivateMessage(PrivateMessage m)
{
var channel = Channels.SingleOrDefault(ch => (ch.Id == m.Receiver && m.Sender == Nickname) || (ch.Id == m.Sender && m.Receiver == Nickname));
if (channel == null && m.Receiver == Nickname)
{
channel = new ChannelViewModel(m.Sender, ChannelType.Private);
Channels.Add(channel);
}
else if (channel == null)
{
return;
}
if (Users.SingleOrDefault(u => u.Name == m.Sender) == null)
{
Users.Add(new User {
Name = m.Sender
});
}
if (m.Sender != Nickname)
{
channel?.Messages.Add(m);
}
else
{
channel?.Messages.Add(new MyMessage(m));
}
}
private Channels GenerateChannels(SchemaRepository schemaRepository, MessageRepository messageRepository)
{
var channels = new Channels();
var asyncApiTypeInfos = GetAsyncApiTypeInfos();
foreach (var asyncApiTypeInfo in asyncApiTypeInfos)
{
var channelAttribute = (ChannelAttribute)asyncApiTypeInfo.GetCustomAttribute(typeof(ChannelAttribute), true);
// OperationAttribute with class
var publishAttribute = (PublishAttribute)asyncApiTypeInfo.GetCustomAttribute(typeof(PublishAttribute), true);
var subscribeAttribute = (SubscribeAttribute)asyncApiTypeInfo.GetCustomAttribute(typeof(SubscribeAttribute), true);
// OperationAttribute with method
var publishMethods = asyncApiTypeInfo.DeclaredMethods.Where(m => m.GetCustomAttribute(typeof(PublishAttribute), true) != null).ToList();
var subscribeMethods = asyncApiTypeInfo.DeclaredMethods.Where(m => m.GetCustomAttribute(typeof(SubscribeAttribute), true) != null).ToList();
// Map to OperationAttribute
var mapToPublishMethods = asyncApiTypeInfo.DeclaredMethods.Where(m => m.GetCustomAttribute(typeof(MapToPublishAttribute), true) != null).ToList();
var mapToSubscribeMethods = asyncApiTypeInfo.DeclaredMethods.Where(m => m.GetCustomAttribute(typeof(MapToSubscribeAttribute), true) != null).ToList();
var channelItem = new ChannelItem();
channelItem.Description = channelAttribute.Description ?? asyncApiTypeInfo.GetXmlDocsSummary();
channelItem.Publish = GenerateOperation(asyncApiTypeInfo, publishAttribute, publishMethods, mapToPublishMethods, schemaRepository, messageRepository);
channelItem.Subscribe = GenerateOperation(asyncApiTypeInfo, subscribeAttribute, subscribeMethods, mapToSubscribeMethods, schemaRepository, messageRepository);
channels.Add(channelAttribute.Uri, channelItem);
}
return(channels);
}
public ChannelContext(DbContextOptions <ChannelContext> options)
: base(options)
{
Database.EnsureCreated();
if (!Channels.Any())
{
Channels.Add(new Channel {
Name = "Great New Channel", UserId = 1, Date = DateTime.Now, Description = "Great and New"
});
Channels.Add(new Channel {
Name = "Not great Channel", UserId = 1, Date = DateTime.Now, Description = "not great at all"
});
SaveChanges();
}
if (!Subscriptions.Any())
{
Subscriptions.Add(new Subscription {
UserId = 2, ChannelId = 1
});
SaveChanges();
}
if (!ChannelImages.Any())
{
ChannelImages.Add(new ChannelImage {
ChannelId = 1, Description = "Hey guys, it's a great new channel", Date = DateTime.Now, ImageId = 1
});
SaveChanges();
}
}
public async Task Initialise()
{
Channels.Add(new Channel(Connection.Address));
ChannelMessaged += SortMessage;
Initialised = await InitializeStream();
}
void FillChannels()
{
for (int i = 0; i < _meter.Channels.Count; ++i)
{
Channels.Add(new RpdChannelViewModel(_meter.Channels[i], this));
}
}
private void LoadData()
{
Channels.Clear();
var service = Proxy.CreateProxy();
this.ShowCCPK = string.Compare(service.GetParameterValue(eGlobalParameter.Menu_CCPK_Visible), "true", true) == 0;
OnPropertyChanged("ShowCCPK");
var list = service.GetAllChannels();
foreach (var c in list)
{
var cvm = new ChannelItemViewModel(c);
cvm.PropertyChanged += ChannelVM_PropertyChanged;
Channels.Add(cvm);
}
this.AllContacts = new List <KeyValuePair <int?, string> >();
this.AllContacts.Add(new KeyValuePair <int?, string>(null, string.Empty));
foreach (var item in service.GetAllContacts())
{
this.AllContacts.Add(new KeyValuePair <int?, string>(item.PhoneNumberId, string.Format("{0}-{1}{2}", item.UnitName, item.AreaCode, item.Number)));
}
}
public void EnsureChannelExists(KgsChannel channel)
{
if (!Channels.ContainsKey(channel.ChannelId))
{
Channels.Add(channel.ChannelId, channel);
}
}
private void AddInputChannels()
{
Channels.Add(DeviceWrapper.LSx);
Channels.Add(DeviceWrapper.LSy);
Channels.Add(DeviceWrapper.RSx);
Channels.Add(DeviceWrapper.RSy);
Channels.Add(DeviceWrapper.LS);
Channels.Add(DeviceWrapper.RS);
Channels.Add(DeviceWrapper.L1);
Channels.Add(DeviceWrapper.R1);
Channels.Add(DeviceWrapper.L2);
Channels.Add(DeviceWrapper.R2);
Channels.Add(DeviceWrapper.L2Digital);
Channels.Add(DeviceWrapper.R2Digital);
Channels.Add(DeviceWrapper.DUp);
Channels.Add(DeviceWrapper.DDown);
Channels.Add(DeviceWrapper.DLeft);
Channels.Add(DeviceWrapper.DRight);
Channels.Add(DeviceWrapper.A);
Channels.Add(DeviceWrapper.B);
Channels.Add(DeviceWrapper.X);
Channels.Add(DeviceWrapper.Y);
Channels.Add(DeviceWrapper.Start);
Channels.Add(DeviceWrapper.Back);
Channels.Add(DeviceWrapper.Mi);
Channels.Add(DeviceWrapper.BatteryLevel);
Channels.Add(DeviceWrapper.GX);
Channels.Add(DeviceWrapper.GY);
Channels.Add(DeviceWrapper.GZ);
}
protected void RaiseChannelAdded(ActorChannel channel)
{
Channels.Add(channel);
var channelAddedEvent = new ChannelAddedEvent(channel);
InputQueue.Add(channelAddedEvent);
}
private void SetChannels()
{
foreach (var channel in channels)
{
Channels.Add(channel.Id, channel.Caption, channel.IconIdx);
}
}
public async Task UpdateChannelSystemIsModerator(string channelName, bool systemIsModerator)
{
var model = new UpdateSystemIsModeratorStatusModel {
SystemIsModerator = systemIsModerator
};
var channel = await apiGateway.Post <ChannelModel, UpdateSystemIsModeratorStatusModel>(model, "channels", routeValues : new string[] { channelName, "systemIsModerator" }).ConfigureAwait(false);
var existingChannel = Channels.Find(x => string.Equals(x.ChannelName, channelName, StringComparison.OrdinalIgnoreCase));
if (existingChannel != null)
{
Channels.Remove(existingChannel);
Channels.Add(channel);
}
var existingChannelWithoutUser = ChannelsWithoutUser.Find(x => string.Equals(x.ChannelName, channelName, StringComparison.OrdinalIgnoreCase));
if (existingChannelWithoutUser != null)
{
ChannelsWithoutUser.Remove(existingChannelWithoutUser);
ChannelsWithoutUser.Add(channel);
}
NotifyStateChanged();
}
protected override void LoadAllAvailableChannels()
{
ChannelRegistry cr = ChannelRegistry.Instance;
Channels.Clear();
Channels.Add(cr.RegisterChannel(ChannelNames.Color));
}
