private void AttachedPeer_MessageReceived(NetworkPeer node, IncomingMessage message)
{
this.logger.LogTrace("({0}:'{1}',{2}:'{3}')", nameof(node), node.RemoteSocketEndpoint, nameof(message), message.Message.Command);
message.Message.IfPayloadIs <VersionPayload>(version =>
{
IPeerConnector peerConnector = null;
if (this.connection.ConnectionSettings.Connect.Any())
{
peerConnector = this.connection.PeerConnectors.First(pc => pc is PeerConnectorConnectNode);
}
else
{
peerConnector = this.connection.PeerConnectors.First(pc => pc is PeerConnectorDiscovery);
}
// Find how much 20% max nodes.
decimal thresholdCount = Math.Round(peerConnector.MaxOutboundConnections * this.dropThreshold, MidpointRounding.ToEven);
if (thresholdCount < this.connection.ConnectedPeers.Count())
{
if (version.StartHeight < this.chain.Height)
{
this.AttachedPeer.Disconnect($"Node at height = {version.StartHeight} too far behind current height");
}
}
});
this.logger.LogTrace("(-)");
}
private IConnectionManager CreateConnectionManager(
NodeSettings nodeSettings,
ConnectionManagerSettings connectionSettings,
IPeerAddressManager peerAddressManager,
IPeerConnector peerConnector,
ISelfEndpointTracker selfEndpointTracker)
{
var networkPeerFactory = new Mock <INetworkPeerFactory>();
var peerDiscovery = new Mock <IPeerDiscovery>();
var connectionManager = new ConnectionManager(
DateTimeProvider.Default,
this.LoggerFactory.Object,
this.Network,
networkPeerFactory.Object,
nodeSettings,
this.nodeLifetime,
this.networkPeerParameters,
peerAddressManager,
new IPeerConnector[] { peerConnector },
peerDiscovery.Object,
selfEndpointTracker,
connectionSettings,
new VersionProvider());
return(connectionManager);
}
private Task OnMessageReceivedAsync(INetworkPeer peer, IncomingMessage message)
{
if (message.Message.Payload is VersionPayload version)
{
IPeerConnector peerConnector = null;
if (this.connection.ConnectionSettings.Connect.Any())
{
peerConnector = this.connection.PeerConnectors.First(pc => pc is PeerConnectorConnectNode);
}
else
{
peerConnector = this.connection.PeerConnectors.First(pc => pc is PeerConnectorDiscovery);
}
// Find how much 20% max nodes.
decimal thresholdCount = Math.Round(peerConnector.MaxOutboundConnections * this.dropThreshold, MidpointRounding.ToEven);
if (thresholdCount < this.connection.ConnectedPeers.Count())
{
if (version.StartHeight < this.chainIndexer.Height)
{
peer.Disconnect($"Node at height = {version.StartHeight} too far behind current height");
}
}
}
return(Task.CompletedTask);
}
/// <summary>
/// Adds a node to the -addnode collection.
/// <para>
/// Usually called via RPC.
/// </para>
/// </summary>
/// <param name="ipEndpoint">The endpoint of the peer to add.</param>
public void AddNodeAddress(IPEndPoint ipEndpoint, bool excludeFromIpRangeFiltering = false)
{
Guard.NotNull(ipEndpoint, nameof(ipEndpoint));
if (excludeFromIpRangeFiltering && !this.ipRangeFilteringEndpointExclusions.Any(ip => ip.Match(ipEndpoint)))
{
this.logger.LogDebug("{0} will be excluded from IP range filtering.", ipEndpoint);
this.ipRangeFilteringEndpointExclusions.Add(ipEndpoint);
}
this.peerAddressManager.AddPeer(ipEndpoint.MapToIpv6(), IPAddress.Loopback);
if (!this.ConnectionSettings.RetrieveAddNodes().Any(p => p.Match(ipEndpoint)))
{
this.ConnectionSettings.AddAddNode(ipEndpoint);
IPeerConnector addNodeConnector = this.PeerConnectors.FirstOrDefault(pc => pc is PeerConnectorAddNode);
if (addNodeConnector != null)
{
addNodeConnector.MaxOutboundConnections++;
}
}
else
{
this.logger.LogDebug("The endpoint already exists in the add node collection.");
}
}
private void CleanupResources(IPeerConnector peerConnector)
{
foreach (var peer in peerConnector.Peers)
{
peerConnector.DisconnectPeer(peer);
}
}
private Task OnMessageReceivedAsync(INetworkPeer peer, IncomingMessage message)
{
this.logger.LogTrace("({0}:'{1}',{2}:'{3}')", nameof(peer), peer.RemoteSocketEndpoint, nameof(message), message.Message.Command);
if (message.Message.Payload is VersionPayload version)
{
IPeerConnector peerConnector = null;
if (this.connection.ConnectionSettings.Connect.Any())
{
peerConnector = this.connection.PeerConnectors.First(pc => pc is PeerConnectorConnectNode);
}
else
{
peerConnector = this.connection.PeerConnectors.First(pc => pc is PeerConnectorDiscovery);
}
// Find how much 20% max nodes.
decimal thresholdCount = Math.Round(peerConnector.MaxOutboundConnections * this.dropThreshold, MidpointRounding.ToEven);
if (thresholdCount < this.connection.ConnectedPeers.Count())
{
if (version.StartHeight < this.chain.Height)
{
peer.Disconnect($"Node at height = {version.StartHeight} too far behind current height");
}
}
}
this.logger.LogTrace("(-)");
return(Task.CompletedTask);
}
private IConnectionManager CreateConnectionManager(
NodeSettings nodeSettings,
ConnectionManagerSettings connectionSettings,
IPeerAddressManager peerAddressManager,
IPeerConnector peerConnector,
ISelfEndpointTracker selfEndpointTracker)
{
var networkPeerFactory = new Mock <INetworkPeerFactory>();
var peerDiscovery = new Mock <IPeerDiscovery>();
var networkPeerParameters = new NetworkPeerConnectionParameters();
var connectionManager = new ConnectionManager(
DateTimeProvider.Default,
this.LoggerFactory.Object,
this.Network,
networkPeerFactory.Object,
nodeSettings,
this.nodeLifetime,
networkPeerParameters,
peerAddressManager,
new IPeerConnector[] { peerConnector },
peerDiscovery.Object,
selfEndpointTracker,
connectionSettings,
new VersionProvider(),
new Mock <INodeStats>().Object,
this.asyncProvider);
networkPeerParameters.TemplateBehaviors.Add(new ConnectionManagerBehavior(connectionManager, this.extendedLoggerFactory));
return(connectionManager);
}
public void Start()
{
this.logger.LogTrace("()");
this.Parameters.UserAgent = $"{this.NodeSettings.Agent}:{this.GetVersion()}";
this.Parameters.Version = this.NodeSettings.ProtocolVersion;
NodeConnectionParameters clonedParameters = this.Parameters.Clone();
clonedParameters.TemplateBehaviors.Add(new ConnectionManagerBehavior(false, this, this.loggerFactory));
// Don't start peer discovery if we have specified any nodes using the -connect arg.
if (!this.connectionManagerSettings.Connect.Any())
{
if (this.Parameters.PeerAddressManagerBehaviour().Mode.HasFlag(PeerAddressManagerBehaviourMode.Discover))
{
this.logger.LogInformation("Starting peer discovery...");
this.peerDiscoveryLoop = new PeerDiscoveryLoop(this.asyncLoopFactory, this.Network, clonedParameters, this.nodeLifetime, this.peerAddressManager);
this.peerDiscoveryLoop.DiscoverPeers();
}
this.DiscoverNodesPeerConnector = this.CreatePeerConnector(clonedParameters, this.discoveredNodeRequiredService, WellKnownPeerConnectorSelectors.ByNetwork, PeerIntroductionType.Discover);
}
else
{
// Use if we have specified any nodes using the -connect arg
var peers = this.connectionManagerSettings.Connect.Select(node => new NetworkAddress(node)).ToArray();
this.peerAddressManager.AddPeers(peers, IPAddress.Loopback, PeerIntroductionType.Connect);
clonedParameters.PeerAddressManagerBehaviour().Mode = PeerAddressManagerBehaviourMode.None;
this.ConnectNodePeerConnector = this.CreatePeerConnector(clonedParameters, NodeServices.Nothing, WellKnownPeerConnectorSelectors.ByEndpoint, PeerIntroductionType.Connect, this.connectionManagerSettings.Connect.Count);
}
{
// Use if we have specified any nodes using the -addnode arg
var peers = this.connectionManagerSettings.AddNode.Select(node => new NetworkAddress(node)).ToArray();
this.peerAddressManager.AddPeers(peers, IPAddress.Loopback, PeerIntroductionType.Add);
clonedParameters.PeerAddressManagerBehaviour().Mode = PeerAddressManagerBehaviourMode.AdvertiseDiscover;
this.AddNodePeerConnector = this.CreatePeerConnector(clonedParameters, NodeServices.Nothing, WellKnownPeerConnectorSelectors.ByEndpoint, PeerIntroductionType.Add, this.connectionManagerSettings.AddNode.Count);
}
// Relate the peer connectors to each other to prevent duplicate connections.
var relatedPeerConnectors = new RelatedPeerConnectors();
relatedPeerConnectors.Register("Discovery", this.DiscoverNodesPeerConnector);
relatedPeerConnectors.Register("Connect", this.ConnectNodePeerConnector);
relatedPeerConnectors.Register("AddNode", this.AddNodePeerConnector);
this.DiscoverNodesPeerConnector?.StartConnectAsync();
this.ConnectNodePeerConnector?.StartConnectAsync();
this.AddNodePeerConnector?.StartConnectAsync();
this.StartNodeServer();
this.logger.LogTrace("(-)");
}
public Home(
INavigation <NavigationModes> navigationService
, IStorage storageService
, ISettings settingsService
, IUxService uxService
, IPeerConnector peerConnector)
: base(navigationService, storageService, settingsService, uxService, peerConnector)
{
Categories.Add(new Models.UI.Category {
IndexOf = 1, Order = 0, Name = "pc", UniqueId = "pc"
});
Categories.Add(new Models.UI.Category {
IndexOf = 1, Order = 1, Name = "electronics", UniqueId = "electronics"
});
Categories.Add(new Models.UI.Category {
IndexOf = 1, Order = 2, Name = "media player", UniqueId = "media player"
});
Categories.Add(new Models.UI.Category {
IndexOf = 1, Order = 3, Name = "computer hardware", UniqueId = "computer hardware"
});
Categories.Add(new Models.UI.Category {
IndexOf = 1, Order = 4, Name = "game console", UniqueId = "game console"
});
Categories.Add(new Models.UI.Category {
IndexOf = 1, Order = 5, Name = "car and truck", UniqueId = "car and truck"
});
Categories.Add(new Models.UI.Category {
IndexOf = 1, Order = 6, Name = "appliance", UniqueId = "appliance"
});
Categories.Add(new Models.UI.Category {
IndexOf = 1, Order = 7, Name = "mac", UniqueId = "mac"
});
Categories.Add(new Models.UI.Category {
IndexOf = 1, Order = 8, Name = "apparel", UniqueId = "apparel"
});
Categories.Add(new Models.UI.Category {
IndexOf = 1, Order = 9, Name = "phone", UniqueId = "phone"
});
Categories.Add(new Models.UI.Category {
IndexOf = 1, Order = 10, Name = "camera", UniqueId = "camera"
});
Categories.Add(new Models.UI.Category {
IndexOf = 1, Order = 11, Name = "vehicle", UniqueId = "vehicle"
});
Categories.Add(new Models.UI.Category {
IndexOf = 1, Order = 12, Name = "tablet", UniqueId = "tablet"
});
Categories.Add(new Models.UI.Category {
IndexOf = 1, Order = 13, Name = "household", UniqueId = "household"
});
Categories.Add(new Models.UI.Category {
IndexOf = 1, Order = 14, Name = "skills", UniqueId = "skills"
});
}
public static FakeAgent GetSnowballAgent(IHashResolver hashResolver, IPeerConnector peerConnector)
{
var agent = new FakeAgent();
var snowball = new SnowballConsensus(new FakeContext(agent), new FakeState());
agent.RegisterFunction("Apocryph-SnowballConsensus", ((IAsyncEnumerable <Message>, string, Chain, IAsyncEnumerable <(Hash <Chain>, Slot?[])>, IAgent)input) => snowball.Start(input, hashResolver));
agent.RegisterFunction("SnowballStream", ((Hash <Chain>, IAgent)input) => snowball.SnowballStream(input, hashResolver, peerConnector, null).Select(x => x));
agent.RegisterFunction("MessagePool", ((IAsyncEnumerable <Message>, Hash <Chain>)input) => snowball.MessagePool(input));
agent.RegisterFunction("KothProcessor", ((Hash <Chain>, IAsyncEnumerable <(Hash <Chain>, Slot?[])>)input) => snowball.KothProcessor(input));
return(agent);
}
private void ConnectNewPeersIfNeeded(IPeerConnector peerConnector, ITracker tracker, Torrent torrent)
{
if (peerConnector.Peers.Count < 25)
{
var trackerResult = tracker.Track(torrent, TrackerEvent.Started).Result;
foreach (var peer in trackerResult.Peers)
{
var t = new Thread(() => peerConnector.TryConnectToPeer(peer, OnPeerEvent));
t.Start();
}
}
}
public void Start()
{
this.logger.LogTrace("()");
this.Parameters.UserAgent = $"{this.NodeSettings.Agent}:{this.GetVersion()}";
this.Parameters.Version = this.NodeSettings.ProtocolVersion;
NetworkPeerConnectionParameters clonedParameters = this.Parameters.Clone();
clonedParameters.TemplateBehaviors.Add(new ConnectionManagerBehavior(false, this, this.loggerFactory));
// Don't start peer discovery if we have specified any nodes using the -connect arg.
if (!this.NodeSettings.ConnectionManager.Connect.Any())
{
if (this.Parameters.PeerAddressManagerBehaviour().Mode.HasFlag(PeerAddressManagerBehaviourMode.Discover))
{
this.logger.LogInformation("Starting peer discovery...");
this.peerDiscoveryLoop = new PeerDiscoveryLoop(this.asyncLoopFactory, this.Network, clonedParameters, this.nodeLifetime, this.peerAddressManager, this.networkPeerFactory);
this.peerDiscoveryLoop.DiscoverPeers();
}
this.DiscoverNodesPeerConnector = new PeerConnectorDiscovery(this.asyncLoopFactory, this.logger, this.Network, this.networkPeerFactory, this.nodeLifetime, this.NodeSettings, clonedParameters, this.peerAddressManager);
}
else
{
// Use if we have specified any nodes using the -connect arg
this.ConnectNodePeerConnector = new PeerConnectorConnectNode(this.asyncLoopFactory, this.logger, this.Network, this.networkPeerFactory, this.nodeLifetime, this.NodeSettings, clonedParameters, this.peerAddressManager);
}
{
// Use if we have specified any nodes using the -addnode arg
this.AddNodePeerConnector = new PeerConnectorAddNode(this.asyncLoopFactory, this.logger, this.Network, this.networkPeerFactory, this.nodeLifetime, this.NodeSettings, clonedParameters, this.peerAddressManager);
}
// Relate the peer connectors to each other to prevent duplicate connections.
var relatedPeerConnectors = new RelatedPeerConnectors();
relatedPeerConnectors.Register("Discovery", this.DiscoverNodesPeerConnector);
relatedPeerConnectors.Register("Connect", this.ConnectNodePeerConnector);
relatedPeerConnectors.Register("AddNode", this.AddNodePeerConnector);
this.DiscoverNodesPeerConnector?.StartConnectAsync();
this.ConnectNodePeerConnector?.StartConnectAsync();
this.AddNodePeerConnector?.StartConnectAsync();
this.StartNodeServer();
this.logger.LogTrace("(-)");
}
public static async Task <IAsyncEnumerable <(Hash <Chain>, Slot?[])> > KoTHProcessor(
[PerperTrigger] object?input,
IState state,
IHashResolver hashResolver,
IPeerConnector peerConnector,
ILogger?logger,
CancellationToken cancellationToken)
{
var output = Channel.CreateUnbounded <(Hash <Chain>, Slot?[])>();
var semaphore = new SemaphoreSlim(1, 1); // NOTE: Should use Perper for locking instead
await peerConnector.ListenPubSub <(Hash <Chain> chain, Slot slot)>(PubSubPath, async (_, message) =>
{
await semaphore.WaitAsync();
var chainState = await state.GetValue <KoTHState?>(message.chain.ToString(), () => default !);
public void AddDiscoveredNodesRequirement(NetworkPeerServices services)
{
IPeerConnector peerConnector = this.PeerConnectors.FirstOrDefault(pc => pc is PeerConnectorDiscovery);
if ((peerConnector != null) && !peerConnector.Requirements.RequiredServices.HasFlag(services))
{
peerConnector.Requirements.RequiredServices |= services;
foreach (INetworkPeer peer in peerConnector.ConnectorPeers)
{
if (peer.Inbound) continue;
if (!peer.PeerVersion.Services.HasFlag(services))
peer.Disconnect("The peer does not support the required services requirement.");
}
}
}
/// <summary>
///
/// </summary>
/// <param name="settings"></param>
/// <param name="dbEngine"></param>
/// <param name="raftSender"></param>
/// <param name="log"></param>
/// <param name="OnCommit"></param>
public RaftStateMachine(RaftEntitySettings settings, string workPath, IPeerConnector raftSender, IWarningLog log, IBusinessHandler handler)
{
this.Log = log ?? throw new Exception("Raft.Net: ILog is not supplied");
network = raftSender;
entitySettings = settings;
//Starting time master
var TM = new TimeMaster(log);
this.timerLoop = new StateMachineTimerLoop(TM, settings, this);
//Starting state logger
NodeStateLog = StateLogFactory.GetLog(this, workPath);
this.logHandler = new StateMachineLogHandler(this, NodeStateLog, handler);
//Adding AddLogEntryAsync cleanup
this.timerLoop.StartClearup();
}
public BaseViewModel(
INavigation <Domain.Interfaces.NavigationModes> navigationService
, IStorage storageService
, ISettings settingsService
, IUxService uxService
, IPeerConnector peerConnector)
{
_navigationService = navigationService;
_storageService = storageService;
_settingsService = settingsService;
_uxService = uxService;
_peerConnector = peerConnector;
Broker = new ServicesEngine.ServiceBroker(_settingsService.AppKey(), _settingsService.AppVersion());
_peerConnector.ConnectionStatusChanged += _peerConnector_ConnectionStatusChanged;
_peerConnector.GuideReceived += _peerConnector_GuideReceived;
}
public Details(
INavigation<Domain.Interfaces.NavigationModes> navigationService
, IStorage storageService
, ISettings settingsService
, IUx uxService
, ILocation locationService
, IPeerConnector peerConnectorService
)
: base(navigationService
, storageService
, settingsService
, uxService
, locationService
, peerConnectorService)
{
this.AppName = International.Translation.AppName;
this.PageTitle = International.Translation.Details_Title;
}
private void AttachedNodeOnMessageReceived(Node node, IncomingMessage message)
{
this.logger.LogTrace("({0}:'{1}',{2}:'{3}')", nameof(node), node.RemoteSocketEndpoint, nameof(message), message.Message.Command);
message.Message.IfPayloadIs <VersionPayload>(version =>
{
IPeerConnector nodeGroup = this.connection.DiscoverNodesPeerConnector ?? this.connection.ConnectNodePeerConnector;
// Find how much 20% max nodes.
decimal thresholdCount = Math.Round(nodeGroup.MaximumNodeConnections * this.dropThreshold, MidpointRounding.ToEven);
if (thresholdCount < this.connection.ConnectedNodes.Count())
{
if (version.StartHeight < this.chain.Height)
{
this.AttachedNode.DisconnectAsync($"Node at height = {version.StartHeight} too far behind current height");
}
}
});
this.logger.LogTrace("(-)");
}
private void FreeBlockedPieces(IPeerConnector peerConnector)
{
lock (_pieceLock)
{
var peers = peerConnector.Peers;
foreach (var pendingPiece in PendingPieces)
{
var piece = pendingPiece.Key;
var peer = pendingPiece.Value;
if (!peers.Contains(peer))
{
_pendingPieces.Remove(piece);
continue;
}
if (peer.AmWaitingForPiece && (DateTime.Now - peer.RequestPieceTime.Value).TotalSeconds > Constants.PieceTimeout)
{
FreeUpPiece(peer);
}
}
}
}
public void AddDiscoveredNodesRequirement(NetworkPeerServices services)
{
this.logger.LogTrace("({0}:{1})", nameof(services), services);
this.discoveredNodeRequiredService |= services;
IPeerConnector peerConnector = this.PeerConnectors.FirstOrDefault(pc => pc is PeerConnectorDiscovery);
if ((peerConnector != null) && !peerConnector.Requirements.RequiredServices.HasFlag(services))
{
peerConnector.Requirements.RequiredServices |= NetworkPeerServices.NODE_WITNESS;
foreach (INetworkPeer peer in peerConnector.ConnectorPeers)
{
if (!peer.PeerVersion.Services.HasFlag(services))
{
peer.Disconnect("The peer does not support the required services requirement.");
}
}
}
this.logger.LogTrace("(-)");
}
public void AddDiscoveredNodesRequirement(NodeServices services)
{
this.logger.LogTrace("({0}:{1})", nameof(services), services);
this.discoveredNodeRequiredService |= services;
IPeerConnector peerConnector = this.DiscoverNodesPeerConnector;
if ((peerConnector != null) && !peerConnector.Requirements.RequiredServices.HasFlag(services))
{
peerConnector.Requirements.RequiredServices |= NodeServices.NODE_WITNESS;
foreach (Node node in peerConnector.ConnectedPeers)
{
if (!node.PeerVersion.Services.HasFlag(services))
{
node.DisconnectAsync("The peer does not support the required services requirement.");
}
}
}
this.logger.LogTrace("(-)");
}
private IConnectionManager CreateConnectionManager(NodeSettings nodeSettings, ConnectionManagerSettings connectionSettings, IPeerAddressManager peerAddressManager, IPeerConnector peerConnector)
{
var connectionManager = new ConnectionManager(
DateTimeProvider.Default,
this.loggerFactory,
this.network,
this.networkPeerFactory,
nodeSettings,
this.nodeLifetime,
this.networkPeerParameters,
peerAddressManager,
new IPeerConnector[] { peerConnector },
null,
connectionSettings);
return(connectionManager);
}
public static async Task Start([PerperTrigger] object?input, IContext context, IHashResolver hashResolver, IPeerConnector peerConnector)
{
var(executorAgent, _) = await context.StartAgentAsync <object?>("Apocryph-Executor", null);
await executorAgent.CallActionAsync("Register", (Hash.From("AgentOne"), context.Agent, "AgentOne"));
await executorAgent.CallActionAsync("Register", (Hash.From("AgentTwo"), context.Agent, "AgentTwo"));
var agentStates = new[] {
new AgentState(0, ReferenceData.From(new AgentOne.AgentOneState()), Hash.From("AgentOne")),
new AgentState(1, ReferenceData.From(new AgentTwo.AgentTwoState()), Hash.From("AgentTwo"))
};
var agentStatesTree = await MerkleTreeBuilder.CreateRootFromValues(hashResolver, agentStates, 2);
Chain chain;
if (Environment.GetEnvironmentVariable("SAMPLE_AGENTS_CONSENSUS") == "Dummy")
{
chain = new Chain(new ChainState(agentStatesTree, agentStates.Length), "Apocryph-DummyConsensus", null, 1);
}
else
{
var snowballParameters = await hashResolver.StoreAsync <object>(new SnowballParameters(15, 0.8, 25));
chain = new Chain(new ChainState(agentStatesTree, agentStates.Length), "Apocryph-SnowballConsensus", snowballParameters, 60);
}
var chainId = await hashResolver.StoreAsync(chain);
var(_, kothStates) = await context.StartAgentAsync <IAsyncEnumerable <(Hash <Chain>, Slot?[])> >("Apocryph-KoTH", null);
var minerAgentTask = context.StartAgentAsync <object?>("Apocryph-KoTH-SimpleMiner", (kothStates, new Hash <Chain>[] { chainId }));
public Login(INavigation <NavigationModes> navigationService, IStorage storageService, ISettings settingsService, IUxService uxService, IPeerConnector peerConnector)
: base(navigationService, storageService, settingsService, uxService, peerConnector)
{
PageTitle = International.Translation.Login;
}
public Device(INavigation<NavigationModes> navigationService, IStorage storageService, ISettings settingsService, IUxService uxService, IPeerConnector peerConnector)
: base(navigationService, storageService, settingsService, uxService, peerConnector)
{
}
public Home(
INavigation<NavigationModes> navigationService
, IStorage storageService
, ISettings settingsService
, IUxService uxService
, IPeerConnector peerConnector)
: base(navigationService, storageService, settingsService, uxService, peerConnector)
{
Categories.Add(new Models.UI.Category { IndexOf = 1, Order = 0, Name = "pc", UniqueId = "pc" });
Categories.Add(new Models.UI.Category { IndexOf = 1, Order = 1, Name = "electronics", UniqueId = "electronics" });
Categories.Add(new Models.UI.Category { IndexOf = 1, Order = 2, Name = "media player", UniqueId = "media player" });
Categories.Add(new Models.UI.Category { IndexOf = 1, Order = 3, Name = "computer hardware", UniqueId = "computer hardware" });
Categories.Add(new Models.UI.Category { IndexOf = 1, Order = 4, Name = "game console", UniqueId = "game console" });
Categories.Add(new Models.UI.Category { IndexOf = 1, Order = 5, Name = "car and truck", UniqueId = "car and truck" });
Categories.Add(new Models.UI.Category { IndexOf = 1, Order = 6, Name = "appliance", UniqueId = "appliance" });
Categories.Add(new Models.UI.Category { IndexOf = 1, Order = 7, Name = "mac", UniqueId = "mac" });
Categories.Add(new Models.UI.Category { IndexOf = 1, Order = 8, Name = "apparel", UniqueId = "apparel" });
Categories.Add(new Models.UI.Category { IndexOf = 1, Order = 9, Name = "phone", UniqueId = "phone" });
Categories.Add(new Models.UI.Category { IndexOf = 1, Order = 10, Name = "camera", UniqueId = "camera" });
Categories.Add(new Models.UI.Category { IndexOf = 1, Order = 11, Name = "vehicle", UniqueId = "vehicle" });
Categories.Add(new Models.UI.Category { IndexOf = 1, Order = 12, Name = "tablet", UniqueId = "tablet" });
Categories.Add(new Models.UI.Category { IndexOf = 1, Order = 13, Name = "household", UniqueId = "household" });
Categories.Add(new Models.UI.Category { IndexOf = 1, Order = 14, Name = "skills", UniqueId = "skills" });
}
public Search(INavigation<Domain.Interfaces.NavigationModes> navigationService, IStorage storageService, ISettings settingsService, IUxService uxService, IPeerConnector peerConnector)
: base(navigationService, storageService, settingsService, uxService, peerConnector)
{
foreach (ServiceBroker.SearchFilters p in Enum.GetValues(typeof(Services.V2_0.ServiceBroker.SearchFilters)))
{
SearchSectionCurrentLoading.Add(p, false);
}
}
public Guide(INavigation <NavigationModes> navigationService, IStorage storageService, ISettings settingsService, IUxService uxService, IPeerConnector peerConnector)
: base(navigationService, storageService, settingsService, uxService, peerConnector)
{
Reset();
}
internal PeerConnectorBehaviour(IPeerConnector peerConnector)
{
this.peerConnector = peerConnector;
}
public Profile(INavigation <Domain.Interfaces.NavigationModes> navigationService, IStorage storageService, ISettings settingsService, IUxService uxService, IPeerConnector peerConnector)
: base(navigationService, storageService, settingsService, uxService, peerConnector)
{
}
public Search(INavigation <Domain.Interfaces.NavigationModes> navigationService, IStorage storageService, ISettings settingsService, IUxService uxService, IPeerConnector peerConnector)
: base(navigationService, storageService, settingsService, uxService, peerConnector)
{
foreach (ServiceBroker.SearchFilters p in Enum.GetValues(typeof(Services.V2_0.ServiceBroker.SearchFilters)))
{
SearchSectionCurrentLoading.Add(p, false);
}
}
public Profile(INavigation<Domain.Interfaces.NavigationModes> navigationService, IStorage storageService, ISettings settingsService, IUxService uxService, IPeerConnector peerConnector)
: base(navigationService, storageService, settingsService, uxService, peerConnector)
{
}
public About(INavigation<NavigationModes> navigationService, IStorage storageService, ISettings settingsService, IUxService uxService, IPeerConnector peerConnector)
: base(navigationService, storageService, settingsService, uxService, peerConnector)
{
PageTitle = International.Translation.About;
}
