public CacheLogicService(IDataProviderService dataProviderService, ISessionRepository sessionRepository, IUserRepository userRepository, IItemRepository itemRepository)
{
this._dataProviderService = dataProviderService;
this._sessionRepo = sessionRepository;
this._userRepository = userRepository;
this._itemRepository = itemRepository;
}
private static TestDrawingWrapper StartDataGeneration(IDataProviderService dataProviderService, int pointsNumber, int linesNumber)
{
var applicationController = GraphControlFactory.CreateController();
var gridView = TestGridView.Create(applicationController, dataProviderService);
var size = new Size(800, 600);
TestDrawingWrapper drawing = null;
int receivedPoints = 0;
using (drawing = new TestDrawingWrapper())
{
var margin = new Margin(100, 5, 5, 60);
var options = new GridDrawOptions(size, true, true, null, new GridState());
var scaleService = applicationController.GetInstance<IScaleService>();
applicationController.GetInstance<IDataService>().DataUpdated += (sender, e) =>
{
scaleService.UpdateScale(options);
drawing.Reset();
gridView.Draw(drawing, options, margin);
receivedPoints += e.Items.Count;
};
dataProviderService.Run();
while (receivedPoints < pointsNumber)
{
Thread.Sleep(0);
}
}
dataProviderService.Dispose();
return drawing;
}
public override Task InitData(IDataProviderService dataProvider)
{
return(Task.Run(() =>
{
dictionary = dictionary ?? new Dictionary <string, int>(dataProvider.GetData());
}));
}
public override Task InitData(IDataProviderService dataProvider)
{
return(Task.Run(() =>
{
sortedDictionary = sortedDictionary ?? dataProvider.GetData().ToList();
}));
}
public NodeUIResolver(
Node node,
IDataProviderService dataProviderService,
IAuthorizationService authorizationService, IHttpContextAccessor httpContextAccessor) : base(dataProviderService, authorizationService, httpContextAccessor)
{
_node = node;
}
/// <summary>
/// Initializes a new instance of the <see cref="WizardController" /> class.
/// </summary>
/// <param name="dataProviderService">The source manager service which is used to communicate with the logic layer.</param>
/// <param name="mapper">The mapper which is used to convert the resources to the models to the resource results.</param>
public WizardController(
IDataProviderService dataProviderService,
IMapper mapper)
{
this.dataProviderService = dataProviderService;
this.mapper = mapper;
}
public override Task InitData(IDataProviderService dataProvider)
{
return(Task.Run(() =>
{
// строим дерево
_tree = _tree ?? TreeHelper.BuildTree(dataProvider.GetData().ToArray());
}));
}
public static IDataView Create(IApplicationController applicationController, IDataProviderService provider, IBufferedDrawingService bufferedDrawingService)
{
TestFactory.CreateBaseServices(applicationController, provider,
out IGridState gridState, out IDataDrawState graphState,
out IItemFormatter itemFormatter, out IMargin margin,
out IDataService dataService, out IScaleService scaleService, ref bufferedDrawingService);
return(new DataView(scaleService, dataService));
}
protected BaseUIResolver(
IDataProviderService dataProviderService,
IAuthorizationService authorizationService,
IHttpContextAccessor httpContextAccessor)
{
_dataProviderService = dataProviderService;
_authorizationService = authorizationService;
_httpContextAccessor = httpContextAccessor;
}
public ConnectionStringBuilderViewModel(
IConnectionStringBuilderController controller
, IDataProviderService dataProviderService)
{
Controller = controller;
DataProviderService = dataProviderService;
Initialize();
AttachCommands();
}
public ApiController(
IHostedService counterService,
IDataProviderService dataProviderService,
IOptions <SaveSettings> settings)
{
this.counterService = counterService;
this.dataProviderService = dataProviderService;
this.saveSettings = settings.Value;
}
public MainPageViewModel(IDataProviderService dataProviderService, IRatesService ratesService)
{
_dataProviderService = dataProviderService;
_ratesService = ratesService;
//TODO: need to get init out of c-tor
InitializeAsync().Wait();
UpdateCommand = new RelayCommand(CanUpdateRates, UpdateRates);
}
public EditorService(
ICollectionProvider collectionProvider,
IDataProviderService dataProviderService,
IAuthorizationService authorizationService,
IHttpContextAccessor httpContextAccessor)
{
_collectionProvider = collectionProvider;
_dataProviderService = dataProviderService;
_authorizationService = authorizationService;
_httpContextAccessor = httpContextAccessor;
}
public AutoCompleteController(IServiceProvider serviceProvider)
{
// инициализация менеджеров
_autoCompleteManagerLine = IoC.Container.ResolveNamed <IAutoCompleteService>("LineSearch");
_autoComplateManagerBinarySearch = IoC.Container.ResolveNamed <IAutoCompleteService>("BinarySearch");
_autoCompleteManagerTree = IoC.Container.ResolveNamed <IAutoCompleteService>("TreeSearch");
_dataProvider = (IDataProviderService)serviceProvider.GetService(typeof(IDataProviderService));
// Инициализация словарей
InitData();
}
public CounterService(
IDataProviderService dataProviderService,
IOptions <SaveSettings> settings,
ILogger <CounterService> logger)
{
this.saveSettings = settings.Value;
this.logger = logger;
this.dataProviderService = dataProviderService;
this.settings = settings;
this.saveFileIntervalSeconds = GetSaveIntervalInSeconds(this.saveSettings.SavePeriod);
this.previousCountersList = Enumerable.Repeat(0, 8).ToList();
}
static void Main(string[] args)
{
ChannelFactory <IDataProviderService> dataChannelFactory = new ChannelFactory <IDataProviderService>(typeof(IDataProviderService).ToString());
sendDataProxy = dataChannelFactory.CreateChannel();
Console.WriteLine("Meteo station Gacko sending the data...");
Thread sendTemp = new Thread(SendTemperature);
Thread sendHum = new Thread(SendHumidity);
sendTemp.Start();
sendHum.Start();
Console.ReadKey(true);
}
/// <summary>
/// Initializes a new instance of the <see cref="DataSourceController" /> class.
/// </summary>
/// <param name="mapper">The mapper which is used to convert the resources to the models to the resource results.</param>
/// <param name="dataSourceModelService">The data source model service which is used to communicate with the logic layer.</param>
/// <param name="fileService">The file service which is used to communicate with the logic layer.</param>
/// <param name="fileUploader">The file uploader service which is used for uploading files.</param>
/// <param name="dataProviderService">The data provider service which is used to communicate with the logic layer.</param>
/// <param name="indexOrderHelper">The index order helper, helps validating the index order of the wizard pages.</param>
/// <param name="wizardPageService">The wizard page service which is used to communicate with the logic layer.</param>
public DataSourceController(IMapper mapper,
IDataSourceModelService dataSourceModelService,
IFileService fileService,
IFileUploader fileUploader,
IDataProviderService dataProviderService,
IIndexOrderHelper <int> indexOrderHelper,
IWizardPageService wizardPageService)
{
this.mapper = mapper;
this.dataSourceModelService = dataSourceModelService;
this.fileService = fileService;
this.fileUploader = fileUploader;
this.dataProviderService = dataProviderService;
this.indexOrderHelper = indexOrderHelper;
this.wizardPageService = wizardPageService;
}
public void Initialize()
{
dataSourceMock = new Mock <IDataSourceAdaptee>();
dataSourceMock.As <IAuthorizedDataSourceAdaptee>();
dataSourceMock.As <IPublicDataSourceAdaptee>();
dataSources = new List <IDataSourceAdaptee>();
loaderMock = new Mock <IDataProviderLoader>();
loaderMock.Setup(_ => _.GetDataSourceByGuid(It.IsAny <string>()))
.ReturnsAsync(dataSourceMock.Object);
loaderMock.Setup(_ => _.GetDataSourceByName(It.IsAny <string>()))
.ReturnsAsync(dataSourceMock.Object);
loaderMock.Setup(_ => _.GetAllDataSources())
.ReturnsAsync(dataSources);
service = new DataProviderService(loaderMock.Object);
}
public ListUIResolver(
List list,
Collection collection,
IDataProviderService dataProviderService,
IAuthorizationService authorizationService,
IHttpContextAccessor httpContextAccessor) : base(dataProviderService, authorizationService, httpContextAccessor)
{
_list = list;
_collection = collection;
_list.Panes?.ForEach(pane =>
{
if (!_fieldsPerType.ContainsKey(pane.VariantType) && pane.Fields != null)
{
_fieldsPerType.Add(pane.VariantType, pane.Fields.Select(x => x.ToUI()));
}
});
}
public static void CreateBaseServices(IApplicationController applicationController, IDataProviderService provider,
out IGridState gridState, out IDataDrawState graphState,
out IItemFormatter itemFormatter, out IMargin margin,
out IDataService dataService, out IScaleService scaleService, ref IBufferedDrawingService bufferedDrawingService)
{
var formView = new TestGraphControlFormView();
margin = formView.GraphMargin;
itemFormatter = formView.ItemFormatter;
var labelMargin = formView.LabelMargin;
// Set property and Reset()
formView.LabelMargin = labelMargin;
formView.Reset();
TestFactory.CreateStateInstancees(applicationController,
out IBackgroundState backgroundState, out gridState, out IScaleState scaleState, out graphState, out IGraphControlFormState graphControlFormState);
TestFactory.CreateServiceInstances(applicationController,
margin, scaleState,
out dataService, out scaleService, ref bufferedDrawingService);
if (provider != null)
{
dataService.RegisterDataProvider(provider);
}
}
static Globals()
{
MainWindow = null;
DialogStyleInUse = DialogStyle.Standard;
DataProviderService = null;
}
public static void Initialize(Window mainWindow)
{
MainWindow = mainWindow;
DataProviderService = new DialogDataProvider(MainWindow, DialogStyleInUse);
}
public virtual Task InitData(IDataProviderService dataProvider)
{
throw new NotImplementedException();
}
static void Main(string[] args)
{
try
{
var container = BuildIOCContainer();
AutofacHostFactory.Container = container;
var loggerService = container.Resolve <ILoggerService>();
_logger = loggerService;
// self service installer/uninstaller
if (args != null && args.Length == 1 &&
(args[0][0] == '-' || args[0][0] == '/'))
{
switch (args[0].Substring(1).ToLower())
{
case "install":
case "i":
if (!ServiceInstallerUtility.InstallMe())
{
_logger.LogMessage("Failed to install service", LogLevel.Fatal);
}
break;
case "uninstall":
case "u":
if (!ServiceInstallerUtility.UninstallMe())
{
_logger.LogMessage("Failed to uninstall service", LogLevel.Fatal);
}
break;
default:
_logger.LogMessage(
"Unrecognized parameters (allowed: /install and /uninstall, shorten /i and /u)",
LogLevel.Error);
break;
}
}
ServiceBase[] ServicesToRun;
_cacheService = container.Resolve <CacheService>();
var dataProviderService = container.Resolve <IDataProviderService>();
_dataProviderService = dataProviderService;
//AppDomain.CurrentDomain.UnhandledException += MainHandler;
ServicesToRun = new ServiceBase[]
{
_cacheService
};
if (!Environment.UserInteractive)
{
ServiceBase.Run(ServicesToRun);
}
else
{
// register console close event
//_consoleHandler = ConsoleEventHandler;
//SetConsoleCtrlHandler(_consoleHandler, true);
_cacheService.Start();
GetData(_dataProviderService);
//var file = File.ReadAllBytes("C:/Users/Artur/Desktop/pexels-photo-247885.jpeg");
//Users users = new Users();
//users.Username = "******";
//users.Password = "******";
//users.Photo = file;
//_dataProviderService.AddUser(users);
Console.Title = AppDomain.CurrentDomain.FriendlyName;
Console.WriteLine("Press any key to stop...");
Console.ReadKey(true);
_cacheService.Stop();
//AppDomain.CurrentDomain.UnhandledException -= MainHandler;
}
}
catch (Exception ex)
{
var sb = new StringBuilder();
sb.Append(@"Failed starting up the application in console mode\n");
sb.Append(ex.Message);
if (Environment.UserInteractive)
{
Console.WriteLine(sb);
}
_logger.LogMessage(sb.ToString(), LogLevel.Fatal);
_logger.LogMessage(ex.StackTrace, LogLevel.Trace);
}
Environment.Exit(0);
}
private static async Task GetData(IDataProviderService dataProviderService)
{
await _dataProviderService.GetUsers();
_dataProviderService.GetItems();
}
private static IDrawing StartCreateAndDrawDataLines(int pointsNumber, bool drawInBitmap, bool runProvider)
{
var linesNumber = pointsNumber - 1;
var linesToDraw = 0;
IDataProviderService provider = null;
TestDrawingWrapper drawingTester = null;
DrawingBuffer buffer = null;
Drawing2DWrapper drawingBitmap = null;
IDrawing drawing = null;
var size = new Size(800, 600);
if (drawInBitmap)
{
size = new Size(8000, 4500);
buffer = new DrawingBuffer(size);
drawingBitmap = new Drawing2DWrapper(buffer.Graphics);
drawing = drawingBitmap;
}
else
{
drawingTester = new TestDrawingWrapper(100);
drawing = drawingTester;
}
IScaleService scaleService = null;
IDataService dataService = null;
var controller = GraphControlFactory.CreateController();
IBufferedDrawingService bufferedDrawingService = new BufferedDrawingService();
int receivedPoints = 0;
try
{
// Create all services
provider = TestSinusDataProviderService.Create(pointsNumber);
var view = TestDataView.Create(controller, provider, bufferedDrawingService);
var margin = new Margin(100, 5, 5, 60);
var options = new DataDrawOptions(size, true, true, null, new DataDrawState());
scaleService = controller.GetInstance <IScaleService>();
scaleService.UpdateScale(options); // to prepare scaling service without presenter
dataService = controller.GetInstance <IDataService>();
dataService.DataUpdated += (sender, e) =>
{
scaleService.UpdateScale(options);
drawingTester?.Reset();
view.Draw(drawing, options, margin);
receivedPoints += e.Items.Count;
};
if (pointsNumber > 0)
{
provider.Run();
// Wait to draw at least test points
while (receivedPoints < pointsNumber)
{
Thread.Sleep(0);
}
}
else
{
view.Draw(drawing, options, margin);
}
linesToDraw = dataService.GetItems(scaleService.State.X1, scaleService.State.X2).Count();
}
finally
{
bufferedDrawingService.Dispose();
}
Assert.IsTrue(bufferedDrawingService.LastQueueOverflow.Ticks == 0, $"drawing queue overflow, last time: {bufferedDrawingService.LastQueueOverflow.ToLongTimeString()}");
Assert.IsTrue(linesToDraw == pointsNumber,
$"dataService.GetItems({new DateTime((long)scaleService.State.X1 * TimeSpan.TicksPerMillisecond).ToString("HH:mm:ss.fff")}"
+ $", {new DateTime((long)scaleService.State.X1 * TimeSpan.TicksPerMillisecond).ToString("HH:mm:ss.fff")}) {linesToDraw} ({dataService.ItemCount}) != generated points {pointsNumber}");
if (!drawInBitmap)
{
Assert.IsTrue(drawingTester.Lines.Count >= linesNumber, $"lines count is {drawingTester.Lines.Count} less than {linesNumber}");
}
return(drawing);
}
public MultiKinoToCommonDataService(IDataProviderService dataProviderService)
{
_dataProviderService = dataProviderService;
}
public RatesService(IDataProviderService dataProviderService)
{
_dataProviderService = dataProviderService;
}
public FrontendDataQueryHandler(IDataProviderService dataService, ILogger <FrontendDataQueryHandler> logger)
{
_dataService = dataService;
_logger = logger;
}
public GraphControlTestFormPresenter(IApplicationController controller, IGraphControlTestFormView view, IDataProviderService dataProviderService) : base(controller, view)
{
this.dataProviderService = dataProviderService;
}
