protected override async Task OnInitAsync()
{
_sendHandle = SignalService.Register <string>("Send", addItem);
await SignalService.Connect();
forecasts = await ForecastService.GetForecastAsync(DateTime.Now);
}
public async Task SetsSignalsOnUpdate()
{
//arrange
var reader = Substitute.For <ISignalReader <string> >();
var parser = Substitute.For <ISignalParser <string> >();
var hub = Substitute.For <ISignalHub>();
var signals = new List <Signal>
{
new Signal
{
SSID = "UnitTest",
Frequency = Frequency._2_4_GHz,
Strength = -30
}
};
parser.Parse(Arg.Any <string>()).Returns(signals);
var logger = Substitute.For <ILogger>();
var service = new SignalService <string>(reader, parser, hub, logger);
//act
await service.StartAsync(CancellationToken.None);
//assert
await hub.Received().SendMessage(Arg.Is <Message>(m => m.Signals.Equals(signals)));
}
private void BuildingSelected(BigBuildingModel model)
{
SignalService.Publish(new SowBuildingInfoSignal()
{
Value = model
});
}
protected override void OnMediatorInitialize()
{
SignalService.Receive <RegularModeSelected>()
.Subscribe(RegularMode).AddTo(DisposeOnDestroy);
SignalService.Receive <BuildModeSelected>()
.Subscribe(BuildMode).AddTo(DisposeOnDestroy);
RegularMode();
}
public void StartProduce()
{
SignalService.Publish(new OnStartBuildingProductionSignal()
{
Value = Model.Id
});
Finish();
}
public void SetStatus_Should_Set_Status_Of_Given_Signal()
{
var service = new SignalService();
var signal = new Signal(1);
service.SetStatus(signal, SignalStatus.Red);
signal.Status.Equals(SignalStatus.Red);
}
protected override void OnMediatorInitialize()
{
SignalService.Receive <UpdateGoldSignal>()
.Subscribe(UpdateGold).AddTo(DisposeOnDestroy);
SignalService.Receive <UpdateWoodSignal>()
.Subscribe(UpdateWood).AddTo(DisposeOnDestroy);
SignalService.Receive <UpdateIronSignal>()
.Subscribe(UpdateIron).AddTo(DisposeOnDestroy);
}
public async Task GetSignals(string tocken, string login)
{
signalService = new SignalService();
var signals = await signalService.GetSignalAsync(tocken, login);
adapter = new Adapter();
signalList = adapter.ConvertSignals(signals);
//if (signalList == null)
// signalList = new List<TradingSignal>();
// return signalList;
}
protected override void OnMediatorInitialize()
{
SignalService.Receive <RegularModeSelected>()
.Subscribe(RegularMode).AddTo(DisposeOnDestroy);
SignalService.Receive <BuildModeSelected>()
.Subscribe(BuildMode).AddTo(DisposeOnDestroy);
SignalService.Receive <BuildBuildingIsSelectedSignal>()
.Subscribe(BuildBuildingIsSelected).AddTo(DisposeOnDestroy);
View.TryBuildAction += TryBuild;
}
public FollowingManager(
ILogger logger,
MasterUserSettingService masterSettingsService,
FollowerService followerService,
SignalService signalService, MT4Manager mt4Manager,
MasterUserService masterUserService)
{
m_ptrLogger = new ServerLogger(logger, nameof(FollowingManager));
_masterSettingsService = masterSettingsService;
_followerService = followerService;
_signalService = signalService;
_mt4Manager = mt4Manager;
_masterUserService = masterUserService;
}
protected override void OnMediatorInitialize()
{
SignalService.Receive <RegularModeSelected>()
.Subscribe(RegularMode).AddTo(DisposeOnDestroy);
SignalService.Receive <BuildModeSelected>()
.Subscribe(BuildMode).AddTo(DisposeOnDestroy);
_regularMode = true;
SignalService.Receive <CreateBuildingViewSignal>()
.Subscribe(CreateBuildingView).AddTo(DisposeOnDestroy);
View.BuildingSelectedAction += BuildingSelected;
}
public void AddWorkingSignal(string userLogin, Signal signal, string processorID)
{
lock (_userWorkingSignals)
{
var ss = new SignalService(signal, processorID);
if (_userWorkingSignals.TryGetValue(userLogin, out var list))
{
list.Add(ss);
}
else
{
_userWorkingSignals[userLogin] = new List <SignalService> {
ss
}
};
}
}
public async Task SetsStatusOnException()
{
//arrange
var reader = Substitute.For <ISignalReader <string> >();
reader.When(r => r.Read()).Throw(new Exception("unit test exception"));
var parser = Substitute.For <ISignalParser <string> >();
var hub = Substitute.For <ISignalHub>();
var logger = Substitute.For <ILogger>();
var service = new SignalService <string>(reader, parser, hub, logger);
//act
await service.StartAsync(CancellationToken.None);
//assert
await hub.Received().SendMessage(Arg.Is <Message>(m => m.Status == "unit test exception"));
}
public async Task StopsReadingOnCancel()
{
//arrange
var reader = Substitute.For <ISignalReader <string> >();
var parser = Substitute.For <ISignalParser <string> >();
var hub = Substitute.For <ISignalHub>();
var logger = Substitute.For <ILogger>();
var service = new SignalService <string>(reader, parser, hub, logger);
var source = new CancellationTokenSource();
var task = service.StartAsync(source.Token);
//act
source.Cancel();
await task;
//assert
Assert.True(task.IsCompletedSuccessfully);
}
private void TryBuild(int x, int y)
{
if (_buildingInfo == null)
{
return;
}
BigBuildingModel model = new BigBuildingModel()
{
X = x,
Y = y,
BuildingInfo = _buildingInfo
};
SignalService.Publish(new TryBuildSignal()
{
Value = model
});
}
private async Task Connect()
{
try
{
logTable = await CloudService.GetTableAsync <Log>();
ICollection <Log> logs = await logTable.ReadAllItemsAsync();
Items.AddRange(logs.OrderByDescending(x => x.CreatedAt));
if (SynthesizerSettings == null || string.IsNullOrWhiteSpace(SynthesizerSettings.AppServiceUrl) ||
string.IsNullOrWhiteSpace(SynthesizerSettings.SynthesizerApiUrl))
{
LogAction("Settings are not configured");
return;
}
LogAction($"Connecting to {SynthesizerSettings.AppServiceUrl}");
signalService = new SignalService(SynthesizerSettings.AppServiceUrl);
signalService.MessageReceived += SignalMessageReceived;
LogAction($"Connected to {SynthesizerSettings.AppServiceUrl}");
string connectResponse = await signalService.Connect();
LogAction(connectResponse);
UserId = GetCurrentUserId();
string joinGroupResponse = await signalService.JoinGroup(UserId);
LogAction(joinGroupResponse);
valveRestService = new ValveRestService(SynthesizerSettings.SynthesizerApiUrl);
oligoSynthesizerRestService = new OligoSynthesizerRestService(SynthesizerSettings.SynthesizerApiUrl, LogAction);
}
catch (Exception ex)
{
LogAction($"Connection failed: {ex.Message}");
}
}
public MT4Manager(
ILogger logger, Lazy <OrderManager> orderManager, MT4AccountService mt4AccountService,
SignalService signalService, MasterUserSettingService masterSettingsService,
IMessageEvents connectionMgr, MT4SymbolInfoService mt4SymbolInfoService,
MarketDataService marketDataService, MarketDataWorker marketDataWorker,
OrderService orderService, Func <eMT4ServerType, MT4UpdateWorker> updateWorkerFactory,
WorkerManager workerManager)
{
m_ptrLogger = new ServerLogger(_baseLogger = logger, nameof(MT4Manager));
_orderManager = orderManager;
_mt4AccountService = mt4AccountService;
_signalService = signalService;
_masterSettingsService = masterSettingsService;
_connectionMgr = connectionMgr;
_mt4SymbolInfoService = mt4SymbolInfoService;
_marketDataService = marketDataService;
_marketDataWorker = marketDataWorker;
_orderService = orderService;
_updateWorkerFactory = updateWorkerFactory;
_workerManager = workerManager;
}
internal async Task SendToOthers()
{
await SignalService.Invoke("SendToOthers", _toEverybody);
}
internal async Task Broadcast()
{
await SignalService.Invoke("Send", _toEverybody);
}
public SignalController(SignalService signalService, ILogger <SignalController> logger)
{
_signalService = signalService;
_logger = logger;
}
public SignalController(SignalService signalService)
{
Service = signalService;
}
private void RegularModeSelected()
{
SignalService.Publish(new RegularModeSelected());
}
public PanelController(ApplicationDbContext db, SignalService signalService)
{
_db = db;
_signalService = signalService;
}
public void TrainCrossesSignalOne()
{
var signalService = new SignalService();
signalService.SetStatus(this.Signals[0], SignalStatus.Red);
}
private void BuildModeSelected()
{
SignalService.Publish(new BuildModeSelected());
}
