public StatisticService(
IStatisticRepository statisticRepository, IAccountService accountService, StatisticManager statisticManager,
Dictionary <string, IMt4MySqlRepository> repositories, IClientService clientServise, IService Service,
IMailingService mailingService, ISignalService signalService, StatisticCalculator calculator, ICacheService cacheService
)
{
try
{
ratesServer = ConfigurationManager.AppSettings["RatesServer"];
this.statisticRepository = statisticRepository;
this.accountService = accountService;
this.clientService = clientServise;
this.statisticManager = statisticManager;
this.mt4Repositories = repositories;
this.Service = Service;
this.mailingService = mailingService;
this.cacheService = cacheService;
this.signalService = signalService;
statisticManager.StatisticUpdated += StatisticUpdated;
FirstUpdatingStatistics();
#if !DEBUG
UpdateOpenTradesRatio();
UpdateActivities(Constants.ActivitiesCachingAmount);
#endif
}
catch (Exception ex)
{
Logger.Fatal("Fatal error at init: {0}", ex.ToString());
throw;
}
}
public GViewController(
IApiWorkContext workContext,
IStationService stationService,
IRoomService roomService,
IFsuService fsuService,
IDeviceService deviceService,
IPointService pointService,
ISignalService signalService,
IAMeasureService ameasureService,
IGImageService gimageService,
IGPageService gpageService,
IGTemplateService gtemplateService,
IGroupService groupService,
IPackMgr packMgr)
{
this._workContext = workContext;
this._stationService = stationService;
this._roomService = roomService;
this._fsuService = fsuService;
this._deviceService = deviceService;
this._pointService = pointService;
this._signalService = signalService;
this._ameasureService = ameasureService;
this._gimageService = gimageService;
this._gpageService = gpageService;
this._gtemplateService = gtemplateService;
this._groupService = groupService;
this._packMgr = packMgr;
}
public void Test_EventManager()
{
// Prepare
IEventManager manager = this.GetService <IEventManager>();
manager.Start();
ISignalService signals = this.GetService <ISignalService>();
signals.Truncate();
int countBefore = signals.Count();
// Pre-validate
// Perform
List <string> data = new List <string>();
for (int i = 0; i < 100; i++)
{
data.Add("{ guid: \"" + Guid.NewGuid().ToString() + "\"}");
}
foreach (string signal in data)
{
manager.RegisterEvent(Signal.New("fooDevice", signal, DateTime.Now));
Thread.Sleep(5);
}
Thread.Sleep(10 * 1000); // Wait while manager save data to the end
// Post-validate
int countAfter = signals.Count();
Assert.Equal(0, countAfter);
manager.Stop();
}
public SignalController(
IWorkflowManager workflowManager,
ISignalService genericEventService,
IContentManager contentManager) {
_workflowManager = workflowManager;
_genericEventService = genericEventService;
_contentManager = contentManager;
}
public SignalController(
IWorkflowManager workflowManager,
ISignalService genericEventService,
IContentManager contentManager)
{
_workflowManager = workflowManager;
_genericEventService = genericEventService;
_contentManager = contentManager;
}
public SignalController(
ISignalService signalService,
IMapper mapper,
IHttpContextAccessor httpContextAccessor
)
{
_signalService = signalService;
_mapper = mapper;
userRole = httpContextAccessor.HttpContext.User.FindFirst(ClaimTypes.Role).Value;
}
public EventManager(ISignalService service, ICloudAdapter cloudAdapter, ILogger logger)
{
_Service = service;
_CloudAdapter = cloudAdapter;
_Logger = logger;
if (!Helpers.CheckForInternetConnection())
{
throw new Exception("No internet connection!");
}
}
public void Init(
SignalBus signalBus,
DisposableManager disposableManager,
ISignalService signalService
)
{
SignalBus = signalBus;
SignalService = signalService;
_disposableManager = disposableManager;
}
public static void SetViewActive <TView>(this ISignalService signalService, bool active)
where TView : Component
{
if (active)
{
signalService.Publish <EnableViewSignal <TView> >();
}
else
{
signalService.Publish <DisableViewSignal <TView> >();
}
}
private AnankeSettings(TimeSpan maximumRuntime, ILoggerFactory loggerFactory, TimeSpan exitTimeout,
double randomMaximumRuntimeRelativeDelta,
StdoutParser stdoutParser, IStringLog consoleLog, IExitProcessService exitProcessService,
ISignalService signalService)
{
MaximumRuntime = maximumRuntime;
LoggerFactory = loggerFactory;
ExitTimeout = exitTimeout;
RandomMaximumRuntimeRelativeDelta = randomMaximumRuntimeRelativeDelta;
StdoutParser = stdoutParser;
ConsoleLog = consoleLog;
ExitProcessService = exitProcessService;
SignalService = signalService;
}
public void Init(
ISignalService signalService,
IBuildingInfoContainer buildingInfoContainer)
{
_signalService = signalService;
_buildingInfoContainer = buildingInfoContainer;
_fieldControl.InitField();
InitFinanceControl();
_buildingsControl.ProductionIsFinishedAction += ProductionIsFinished;
_signalService.Receive <TryBuildSignal>()
.Subscribe(TryBuild).AddTo(DisposeOnDestroy);
_signalService.Receive <OnStartBuildingProductionSignal>()
.Subscribe(OnStartBuildingProductionProgress).AddTo(DisposeOnDestroy);
}
public ApiWorkContext(
ICacheManager cacheManager,
IAreaService areaService,
IStationService stationService,
IStationTypeService stationTypeService,
IRoomService roomService,
IRoomTypeService roomTypeService,
IDeviceService deviceService,
IDeviceTypeService deviceTypeService,
IFsuService fsuService,
IPointService pointService,
ILogicTypeService logicTypeService,
ISCVendorService vendorService,
ISignalService signalService,
IAAlarmService aalarmService,
IHAlarmService halarmService,
IAMeasureService ameasureService,
IHMeasureService hmeasureService,
IRoleService roleService,
IEntitiesInRoleService authService,
IUserService userService,
IGroupService groupService)
{
this._cacheManager = cacheManager;
this._areaService = areaService;
this._stationService = stationService;
this._stationTypeService = stationTypeService;
this._roomService = roomService;
this._roomTypeService = roomTypeService;
this._deviceService = deviceService;
this._deviceTypeService = deviceTypeService;
this._fsuService = fsuService;
this._pointService = pointService;
this._logicTypeService = logicTypeService;
this._vendorService = vendorService;
this._signalService = signalService;
this._aalarmService = aalarmService;
this._halarmService = halarmService;
this._ameasureService = ameasureService;
this._hmeasureService = hmeasureService;
this._roleService = roleService;
this._authService = authService;
this._userService = userService;
this._groupService = groupService;
}
public void Test_Service_AddScope()
{
// Prepare
ISignalService signals = this.GetService <ISignalService>();
int countBefore = signals.Count();
// Pre-validate
// Perform
List <Signal> newSignals = new List <Signal>()
{
Signal.New("fooDevice", "foo", DateTime.Now),
Signal.New("barDevice", "bar", DateTime.Now.AddSeconds(1)),
Signal.New("bazDevice", "baz", DateTime.Now.AddSeconds(2))
};
signals.Add(newSignals);
// Post-validate
int countAfter = signals.Count();
Assert.Equal(countBefore + newSignals.Count, countAfter);
}
public void CreateNewPopup(
BigBuildingModel model,
bool buildingIsWorking,
ISignalService signalService,
IGameControl gameControl)
{
BuildingPopupBase prefab = _simplePopup;
if (model.BuildingInfo.GoldProduction == 0 &&
model.BuildingInfo.WoodProduction == 0 &&
model.BuildingInfo.IronProduction == 0)
{
prefab = _simplePopup;
}
else if (buildingIsWorking)
{
prefab = _workinPopup;
}
else
{
prefab = _readyPopup;
}
BuildingPopupBase newPopup = Instantiate(prefab, transform, false);
Vector3 screenPos = _camera.WorldToScreenPoint(model.BuildingGameObject.transform.position);
Vector2 movePos;
RectTransformUtility.ScreenPointToLocalPointInRectangle(parentCanvas.transform as RectTransform, screenPos, parentCanvas.worldCamera, out movePos);
Vector3 viewPos = parentCanvas.transform.TransformPoint(movePos);
newPopup.transform.localPosition = movePos;
newPopup.SetInfo(model);
newPopup.SignalService = signalService;
newPopup.GameControl = gameControl;
}
public void Test_Service_Truncate(int rowCount)
{
// Prepare
ISignalService signals = this.GetService <ISignalService>();
int countBefore = signals.Count();
List <Signal> scope = new List <Signal>();
for (int i = 0; i < rowCount; i++)
{
scope.Add(Signal.New("fooDevice", "foo", DateTime.Now));
}
signals.Add(scope);
// Pre-validate
Assert.Equal(rowCount + countBefore, signals.Count());
// Perform
signals.Truncate();
// Post-validate
Assert.Equal(0, signals.Count());
}
public SmDataProvider()
{
_signalService = Container.Instance.GetUnityContainer().Resolve <ISignalService>("ownservice");
_pbService = Container.Instance.GetUnityContainer().Resolve <IProgressbarService>();
}
public UnitDamageService(ISignalService signalService, DamageSettings settings)
{
_signalService = signalService;
_settings = settings;
ClientOnlyConditionalDebug.Log("hello I am damage service");
}
public BombGenerationService(ISignalService signalService, BombGenerationSettings settings)
{
_signalService = signalService;
_settings = settings;
ClientOnlyConditionalDebug.Log("hello I am unit generation service");
}
public SignalController(ISignalService signalService, IHubContext <SignalHub> hubContext)
{
_signalService = signalService;
_hubContext = hubContext;
}
public BombDetonationService(ISignalService signalService)
{
_signalService = signalService;
}
public UnitSpawnService(ISignalService signalService)
{
_signalService = signalService;
}
public static void EnableView <TView>(this ISignalService signalService)
where TView : Component =>
signalService.Publish <EnableViewSignal <TView> >();
internal static AnankeSettings InternalCreate(TimeSpan?maximumRuntime = null, ILoggerFactory loggerFactory = null,
LoggerIsEnabledFilter loggerIsEnabledFilter = null, LoggerFormatter loggerFormatter = null,
TimeSpan?exitTimeout = null, double?randomMaximumRuntimeRelativeDelta = null, StdoutParser stdoutParser = null,
IStringLog consoleLog = null,
IExitProcessService exitProcessService = null, ISignalService signalService = null)
{
if (signalService == null)
{
if (RuntimeInformation.IsOSPlatform(OSPlatform.Windows))
{
signalService = new WindowsSignalService();
}
else
{
signalService = new UnixSignalService();
}
}
consoleLog = consoleLog ?? new TextWriterStringLog(Console.Out);
loggerFormatter = loggerFormatter ?? AnankeFormatters.FormattedText;
loggerIsEnabledFilter = loggerIsEnabledFilter ?? ((_, __) => true);
var loggerProvider = new AnankeLoggerProvider(consoleLog, loggerFormatter, loggerIsEnabledFilter);
if (loggerFactory == null)
{
loggerFactory = new LoggerFactory();
loggerFactory.AddProvider(loggerProvider);
}
return(new AnankeSettings(maximumRuntime ?? Timeout.InfiniteTimeSpan,
loggerFactory,
exitTimeout ?? TimeSpan.FromSeconds(10),
randomMaximumRuntimeRelativeDelta ?? 0.10,
stdoutParser ?? ((message, provider) => provider.CreateLogger("App").LogInformation(message)),
consoleLog,
exitProcessService ?? new ExitProcessService(),
signalService));
}
public ProductosController(ISignalService signalService, IHubContext <FacturaHub> hubContext)
{
_signalService = signalService;
_hubContext = hubContext;
}
public SignalsController(IHotelService hotelService, ISignalService signalService)
{
this.hotelService = hotelService;
this.signalService = signalService;
}
public BombSpawnService(ISignalService signalService)
{
_signalService = signalService;
}