public AccountsService(IDataAccessService dataAccessService, IExecutionContextManager executionContextManager, IIdentityAttributesService identityAttributesService, IGatewayService gatewayService)
{
_dataAccessService = dataAccessService;
_executionContextManager = executionContextManager;
_identityAttributesService = identityAttributesService;
_gatewayService = gatewayService;
}
private void buttonGenerateAndSaveMasterKeypair_Click(object sender, EventArgs e)
{
try
{
IGatewayService gwProxy = GetServiceProxy();
gwProxy.InitializeSystem(this.myId);
IPreService proxy = GetPreProxy();
this.masterKeypair = proxy.GenerateKeyPair();
string filename = FileDialogs.AskUserForFileNameToSaveIn();
if (!string.IsNullOrEmpty(filename))
{
if (!Path.HasExtension(filename))
{
filename = filename + ".xml";
}
MasterKeys mk = new MasterKeys();
mk.MasterKeyPublicKey = Convert.ToBase64String(this.masterKeypair.Public);
mk.MasterKeyPrivateKey = Convert.ToBase64String(this.masterKeypair.Private);
XmlFile.WriteFile(mk, filename);
MessageBox.Show("Done");
}
}
catch (Exception ex)
{
MessageBox.Show("Error: " + ex.Message);
Logger.LogError("Error generating master keypair", ex);
}
}
public async Task RunShouldNotUpdateSequenceNumberIfEndOfMessageIsReachedButSequenceNumberIsNull(
byte[] bytes,
int sequenceNumber,
[Frozen, Substitute] Stream stream,
[Frozen, Substitute] IChannel <GatewayMessageChunk> channel,
[Frozen, Substitute] IGatewayUtilsFactory factory,
[Frozen, Substitute] IGatewayService gateway,
[Frozen, Substitute] ISerializer serializer,
[Target] DefaultGatewayRxWorker worker
)
{
var message = new GatewayMessage {
SequenceNumber = null
};
serializer.Deserialize <GatewayMessage>(Any <Stream>(), Any <CancellationToken>()).Returns(message);
channel.Read(Any <CancellationToken>()).Returns(new GatewayMessageChunk(bytes, bytes.Length, true));
gateway.SequenceNumber = sequenceNumber;
await worker.Start(gateway);
await worker.Run();
gateway.SequenceNumber.Should().Be(sequenceNumber);
}
public async Task RunShouldWriteBytesToWebSocket(
int sequenceNumber,
byte[] bytes,
[Substitute] IClientWebSocket clientWebSocket,
[Frozen, Substitute] IGatewayService gateway,
[Frozen, Substitute] IChannel <GatewayMessage> channel,
[Frozen, Substitute] ISerializer serializer,
[Frozen, Substitute] IGatewayUtilsFactory factory,
[Target] DefaultGatewayTxWorker worker
)
{
var message = new GatewayMessage {
SequenceNumber = sequenceNumber
};
var cancellationToken = new CancellationToken(false);
serializer.SerializeToBytes(Any <GatewayMessage>()).Returns(bytes);
channel.Read(Any <CancellationToken>()).Returns(new ValueTask <GatewayMessage>(message));
clientWebSocket.State.Returns(WebSocketState.Open);
await worker.Start(gateway, clientWebSocket);
await worker.Run(cancellationToken);
await clientWebSocket.Received().Send(Is <ArraySegment <byte> >(bytes), Is(WebSocketMessageType.Text), Is(true), Is(cancellationToken));
}
protected override void OnStart(OnStartServiceArgs args)
{
TraceLog.Initialize(Logger);
EventLog.Initialize(Logger);
ObjectConfigurator.Configurator.CustomItemTypes.Add(new TokenSelectionConfigurationItemType());
ObjectConfigurator.Configurator.CustomItemTypes.Add(new XrmUriConfigurationItemType());
ObjectConfigurator.Configurator.CustomItemTypes.Add(new UriConfigurationItemType());
broker = new XRouter.Broker.BrokerService();
processor = new XRouter.Processor.ProcessorService();
gateway = new XRouter.Gateway.Gateway();
string processorName = args.Settings[SectionKey_Processor].Parameters[SettingsKey_ComponentName];
string gatewayName = args.Settings[SectionKey_Gateway].Parameters[SettingsKey_ComponentName];
string connectionString = args.Settings[SectionKey_Broker].Parameters[SettingsKey_ConnectionString];
broker.Start(
connectionString,
new[] { new GatewayProvider(gatewayName, gateway) },
new[] { new ProcessorProvider(processorName, processor) }
);
processor.Start(processorName, broker);
gateway.Start(gatewayName, broker);
}
public void Setup()
{
_userService = A.Fake<IUSerService>();
_gatewayService = A.Fake<IGatewayService>();
_paymentService = new PaymentService(_userService, _gatewayService);
}
public async Task RunShouldRouteTheMessageIfEndOfMessageIsReached(
byte[] bytes,
uint interval,
int sequenceNumber,
[Frozen, Substitute] Stream stream,
[Frozen, Substitute] IChannel <GatewayMessageChunk> channel,
[Frozen, Substitute] IGatewayUtilsFactory factory,
[Frozen, Substitute] IGatewayService gateway,
[Frozen, Substitute] ISerializer serializer,
[Frozen, Substitute] IEventRouter router,
[Target] DefaultGatewayRxWorker worker
)
{
var @event = new HelloEvent {
HeartbeatInterval = interval
};
var message = new GatewayMessage {
SequenceNumber = sequenceNumber, Data = @event
};
var cancellationToken = new CancellationToken(false);
serializer.Deserialize <GatewayMessage>(Any <Stream>(), Any <CancellationToken>()).Returns(message);
channel.Read(Any <CancellationToken>()).Returns(new GatewayMessageChunk(bytes, bytes.Length, true));
await worker.Start(gateway);
await worker.Run(cancellationToken);
await router.Received().Route(Is(@event), Is(cancellationToken));
}
public PaymentService(
IUSerService userService,
IGatewayService gatewayService)
{
_userService = userService;
_gatewayService = gatewayService;
}
public async Task RunShouldReadFromChannelIfWaitToReadReturnsTrue(
int sequenceNumber,
[Substitute] IClientWebSocket clientWebSocket,
[Frozen, Substitute] IGatewayService gateway,
[Frozen, Substitute] IChannel <GatewayMessage> channel,
[Frozen, Substitute] IGatewayUtilsFactory factory,
[Target] DefaultGatewayTxWorker worker
)
{
var message = new GatewayMessage {
SequenceNumber = sequenceNumber
};
var cancellationToken = new CancellationToken(false);
channel.Read(Any <CancellationToken>()).Returns(new ValueTask <GatewayMessage>(message));
clientWebSocket.State.Returns(WebSocketState.Open);
await worker.Start(gateway, clientWebSocket);
await worker.Run(cancellationToken);
await channel.Received().WaitToRead(Is(cancellationToken));
await channel.Received().Read(Is(cancellationToken));
}
public async Task RunShouldWaitUntilTheWebSocketIsOpen(
int sequenceNumber,
[Substitute] IClientWebSocket clientWebSocket,
[Frozen, Substitute] IGatewayService gateway,
[Frozen, Substitute] IChannel <GatewayMessage> channel,
[Frozen, Substitute] IGatewayUtilsFactory factory,
[Target] DefaultGatewayTxWorker worker
)
{
var tries = 0;
var message = new GatewayMessage {
SequenceNumber = sequenceNumber
};
var cancellationToken = new CancellationToken(false);
clientWebSocket.State.Returns(WebSocketState.Connecting);
channel.Read(Any <CancellationToken>()).Returns(new ValueTask <GatewayMessage>(message));
channel.WaitToRead(Any <CancellationToken>()).Returns(true);
factory.CreateDelay(Any <uint>(), Any <CancellationToken>()).Returns(async x =>
{
if (++tries == 2)
{
clientWebSocket.State.Returns(WebSocketState.Open);
}
await Task.CompletedTask;
});
await worker.Start(gateway, clientWebSocket);
await worker.Run(cancellationToken);
await factory.Received(2).CreateDelay(100, Is(cancellationToken));
}
/// <summary>
/// Initializes a new instance of the <see cref="MessageCreateEventController" /> class.
/// </summary>
/// <param name="tracingService">Service for doing traces.</param>
/// <param name="userService">Service to manage users with.</param>
/// <param name="emitter">Emitter to emit messages to.</param>
/// <param name="discordUserClient">Client used to send User API requests to Discord.</param>
/// <param name="discordChannelClient">Client used to send Channel API requests to Discord.</param>
/// <param name="strings">Localizer service for retrieving strings.</param>
/// <param name="adapterOptions">Options to use for the adapter.</param>
/// <param name="commandsService">Client for interacting with the commands service.</param>
/// <param name="gateway">Gateway that discord sends events through.</param>
/// <param name="reporter">Reporter to report metrics to.</param>
/// <param name="logger">Logger used to log information to some destination(s).</param>
public MessageCreateEventController(
ITracingService tracingService,
IUserService userService,
IMessageEmitter emitter,
IDiscordUserClient discordUserClient,
IDiscordChannelClient discordChannelClient,
IStringLocalizer <Strings> strings,
IOptions <AdapterOptions> adapterOptions,
IBrighidCommandsService commandsService,
IGatewayService gateway,
IMetricReporter reporter,
ILogger <MessageCreateEventController> logger
)
{
this.tracingService = tracingService;
this.userService = userService;
this.emitter = emitter;
this.discordUserClient = discordUserClient;
this.discordChannelClient = discordChannelClient;
this.strings = strings;
this.adapterOptions = adapterOptions.Value;
this.commandsService = commandsService;
this.gateway = gateway;
this.reporter = reporter;
this.logger = logger;
}
public QuotationController(ILogger <LoggerController> logger, IGatewayService gatewayService, IConfiguration configuration, IUnitOfWork unitOfWork, IMapper mapper, IIdentityService identityService)
{
_logger = logger;
this.unitOfWork = unitOfWork;
this.mapper = mapper;
this.identityService = identityService;
this.configuration = configuration;
}
public CheckoutService(IProductService productService, ICardService cardService, IGatewayService gatewayService, IOrderService orderService, EmailService emailService)
{
_productService = productService;
_cardService = cardService;
_gatewayService = gatewayService;
_orderService = orderService;
_emailService = emailService;
}
public FlightService()
{
// data
searchRepository = new SearchRepository(ConfigurationManager.ConnectionStrings["Destination2"].ConnectionString);
// business
cacheService = new CacheService(MemoryCache.Default);
gatewayService = new GatewayService(InitializeService.Settings, cacheService);
search = new SearchService(searchRepository, gatewayService);
}
public SearchService(ISearchRepository searchRepository, IGatewayService gatewayService)
{
this.searchRepository = searchRepository;
this.gatewayService = gatewayService;
}
public GatewayProvider(string name, IGatewayService gateway)
{
Name = name;
Gateway = gateway;
}
internal bool LoadServerConfiguration(IGatewayService service)
{
Server.ServerConfiguration serverConfiguration;
IDataSyncronize message;
IDataSyncronize contact;
serverConfiguration = ObjectPool.Instance.Resolve<Server.ServerConfiguration>();
message = ObjectPool.Instance.Resolve<MessageCollaborator>();
contact = ObjectPool.Instance.Resolve<DatabaseCollectionViewSource>();
//if (serverConfiguration == null) // comment this if you want refresh connection
{
if (serverConfiguration == null)
serverConfiguration = new Server.ServerConfiguration(service);
if (message == null)
message = new MessageCollaborator();
if (contact == null)
contact = new DatabaseCollectionViewSource();
message.StartSyncronizing();
contact.StartSyncronizing();
ObjectPool.Instance.Register<SMSGatewayWpf.ViewModels.Devices.SMSView>().ImplementedBy(new SMSGatewayWpf.ViewModels.Devices.SMSView());
ObjectPool.Instance.Register<SMSGatewayWpf.ViewModels.Devices.CallView>().ImplementedBy(new SMSGatewayWpf.ViewModels.Devices.CallView());
ObjectPool.Instance.Register<SMSGatewayWpf.ViewModels.Devices.PortView>().ImplementedBy(new SMSGatewayWpf.ViewModels.Devices.PortView());
ObjectPool.Instance.Register<SMSGatewayWpf.ViewModels.Devices.GeneralView>().ImplementedBy(new SMSGatewayWpf.ViewModels.Devices.GeneralView());
}
ObjectPool.Instance.Register<Server.ServerConfiguration>().ImplementedBy(serverConfiguration);
ObjectPool.Instance.Register<MessageCollaborator>().ImplementedBy(message);
ObjectPool.Instance.Register<DatabaseCollectionViewSource>().ImplementedBy(contact);
OnConfigurationLoaded();
// comment due to disabled load configuration server
//if (serverConfiguration.General == null)
// return false;
//else
return true;
}
public GatewayAccessor(string componentName, IGatewayService gateway, ApplicationConfiguration configuration)
: base(componentName, gateway, configuration)
{
this.gateway = gateway;
}
