public RecordController(IRecordManager recordManager, ApplicationDbContext context, IInternshipManager internshipManager, RazorViewToStringRenderer razorViewToStringRenderer)
{
_context = context;
_recordManager = recordManager;
_internshipManager = internshipManager;
_razorViewToStringRenderer = razorViewToStringRenderer;
}
protected bool initImageRecorder()
{
if (mRecorder == null)
{
if (mConfig.IsRecord)
{
if (mConfig.RecordLimit <= 0)
{
mConfig.RecordLimit = mConfig.FPS * 10;
}
//mRecorder = new CImageRecorder(Name, mConfig.RecordLimit);
mRecorder = new CRecordManager(Name, mConfig.RecordLimit);
mRecorder.OnRecordProgress += new RECORD_PROGRESS(DoRecordProgress);
return(true);
}
else
{
return(false);
}
}
else
{
return(true);
}
}
internal EmptyRecordIndex(
Session session,
IRecordManager recordManager,
string indexName,
IObjectSerializer <Node <EmptyRecordIndexKey> > serializer
) : base(session, recordManager, indexName, serializer)
{
}
public NetworkMessageDispatcher(int msgTypeLength, IRecordManager record = null)
{
this.msgTypeLength = msgTypeLength;
laterMessageType2Handlers = new CompositeNetworkMessageHandler[msgTypeLength];
immediateMessageType2Handler = new CompositeNetworkMessageHandler[msgTypeLength];
_record = record;
}
internal RecordBTreeDataProvider(
Session session,
IRecordManager recordManager,
IObjectSerializer <Node <TNodeKey> > serializer,
string rootRecordName
) : base(session)
{
this.RecordManager = recordManager;
this.Serializer = serializer;
this.NodeCache = new Dictionary <long, Node <TNodeKey> >();
this.RootRecordName = rootRecordName;
this.Initialize();
}
public virtual void Dispose()
{
KernelCleanup();
Close();
if (mRecorder != null)
{
mRecorder.Dispose();
mRecorder = null;
}
GC.SuppressFinalize(this);
}
public OverlayService(IStatisticProvider statisticProvider,
ISensorService sensorService,
IOverlayEntryProvider overlayEntryProvider,
IAppConfiguration appConfiguration,
ILogger <OverlayService> logger,
IRecordManager recordManager,
IRTSSService rTSSService)
{
_statisticProvider = statisticProvider;
_overlayEntryProvider = overlayEntryProvider;
_appConfiguration = appConfiguration;
_logger = logger;
_recordManager = recordManager;
_rTSSService = rTSSService;
_numberOfRuns = _appConfiguration.SelectedHistoryRuns;
SecondMetric = _appConfiguration.SecondMetricOverlay;
ThirdMetric = _appConfiguration.ThirdMetricOverlay;
IsOverlayActiveStream = new BehaviorSubject <bool>(_appConfiguration.IsOverlayActive);
_runHistoryOutlierFlags = Enumerable.Repeat(false, _numberOfRuns).ToArray();
_logger.LogDebug("{componentName} Ready", this.GetType().Name);
IsOverlayActiveStream.AsObservable()
.Select(isActive =>
{
if (isActive)
{
_rTSSService.ResetOSD();
return(sensorService.OnDictionaryUpdated
.SelectMany(_ => _overlayEntryProvider.GetOverlayEntries()));
}
else
{
_rTSSService.ReleaseOSD();
return(Observable.Empty <IOverlayEntry[]>());
}
}).Switch()
.Subscribe(entries =>
{
_rTSSService.SetOverlayEntries(entries);
_rTSSService.CheckRTSSRunningAndRefresh();
});
_runHistory = Enumerable.Repeat("N/A", _numberOfRuns).ToList();
_rTSSService.SetRunHistory(_runHistory.ToArray());
_rTSSService.SetRunHistoryAggregation(string.Empty);
_rTSSService.SetRunHistoryOutlierFlags(_runHistoryOutlierFlags);
_rTSSService.SetIsCaptureTimerActive(false);
}
public ControlViewModel(IRecordDirectoryObserver recordObserver,
IEventAggregator eventAggregator,
IAppConfiguration appConfiguration, RecordManager recordManager,
ISystemInfo systemInfo,
ProcessList processList,
ILogger <ControlViewModel> logger,
ApplicationState applicationState)
{
Stopwatch stopwatch = new Stopwatch();
stopwatch.Start();
_recordObserver = recordObserver;
_eventAggregator = eventAggregator;
_appConfiguration = appConfiguration;
_recordManager = recordManager;
_systemInfo = systemInfo;
_processList = processList;
_logger = logger;
_applicationState = applicationState;
//Commands
DeleteRecordFileCommand = new DelegateCommand(OnDeleteRecordFile);
MoveRecordFileCommand = new DelegateCommand(OnMoveRecordFile);
DuplicateRecordFileCommand = new DelegateCommand(OnDuplicateRecordFile);
AcceptEditingDialogCommand = new DelegateCommand(OnAcceptEditingDialog);
CancelEditingDialogCommand = new DelegateCommand(OnCancelEditingDialog);
AddCpuInfoCommand = new DelegateCommand(OnAddCpuInfo);
AddGpuInfoCommand = new DelegateCommand(OnAddGpuInfo);
AddRamInfoCommand = new DelegateCommand(OnAddRamInfo);
DeleteRecordCommand = new DelegateCommand(OnPressDeleteKey);
OpenObservedFolderCommand = new DelegateCommand(OnOpenObservedFolder);
DeleteFolderCommand = new DelegateCommand(OnDeleteFolder);
OpenCreateSubFolderDialogCommand = new DelegateCommand(() =>
{
CreateFolderDialogIsOpen = true;
TreeViewSubFolderName = string.Empty;
CreateFolderdialogIsOpenStream.OnNext(true);
});
SelectedRecordingsCommand = new DelegateCommand <object>(OnSelectedRecordings);
CreateFolderCommand = new DelegateCommand(OnCreateSubFolder);
CloseCreateFolderDialogCommand = new DelegateCommand(() =>
{
CreateFolderDialogIsOpen = false;
CreateFolderdialogIsOpenStream.OnNext(false);
}
);
ReloadRootFolderCommand = new DelegateCommand(() => TreeViewUpdateStream.OnNext(default));
public AggregationViewModel(IStatisticProvider statisticProvider,
IEventAggregator eventAggregator, IAppConfiguration appConfiguration, IRecordManager recordManager)
{
_statisticProvider = statisticProvider;
_eventAggregator = eventAggregator;
_appConfiguration = appConfiguration;
_recordManager = recordManager;
ClearTableCommand = new DelegateCommand(OnClearTable);
AggregateIncludeCommand = new DelegateCommand(OnAggregateInclude);
AggregateExcludeCommand = new DelegateCommand(OnAggregateExclude);
SubscribeToUpdateSession();
AggregationEntries.CollectionChanged += new NotifyCollectionChangedEventHandler
((sender, eventArg) => OnAggregationEntriesChanged());
}
public CloudViewModel(IStatisticProvider statisticProvider, IRecordManager recordManager,
IEventAggregator eventAggregator, IAppConfiguration appConfiguration, ILogger <CloudViewModel> logger, IAppVersionProvider appVersionProvider, LoginManager loginManager)
{
Stopwatch stopwatch = new Stopwatch();
stopwatch.Start();
_statisticProvider = statisticProvider;
_recordManager = recordManager;
_eventAggregator = eventAggregator;
_appConfiguration = appConfiguration;
_logger = logger;
_appVersionProvider = appVersionProvider;
_loginManager = loginManager;
ClearTableCommand = new DelegateCommand(OnClearTable);
CopyURLCommand = new DelegateCommand(() => Clipboard.SetText(_shareUrl));
SwitchToDownloadDirectoryCommand = new DelegateCommand(OnSwitchToDownloadDirectory);
_cloudFolderChanged = eventAggregator.GetEvent <PubSubEvent <AppMessages.CloudFolderChanged> >();
_selectCloudFolder = eventAggregator.GetEvent <PubSubEvent <AppMessages.SelectCloudFolder> >();
UploadRecordsCommand = new DelegateCommand(async() =>
{
await UploadRecords();
OnClearTable();
});
DownloadRecordsCommand = new DelegateCommand(async() =>
{
await DownloadCaptureCollection(DownloadIDString);
});
SubscribeToUpdateSession();
CloudEntries.CollectionChanged += new NotifyCollectionChangedEventHandler
((sender, eventArg) => OnCloudEntriesChanged());
IsLoggedIn = loginManager.State.Token != null;
_eventAggregator.GetEvent <PubSubEvent <AppMessages.LoginState> >().Subscribe(state =>
{
IsLoggedIn = state.IsLoggedIn;
RaisePropertyChanged(nameof(IsLoggedIn));
});
stopwatch.Stop();
_logger.LogInformation(this.GetType().Name + " {initializationTime}s initialization time", Math.Round(stopwatch.ElapsedMilliseconds * 1E-03, 1));
}
public CaptureManager(ICaptureService presentMonCaptureService,
ISensorService sensorService,
IOverlayService overlayService,
SoundManager soundManager,
IRecordManager recordManager,
ILogger <CaptureManager> logger,
IAppConfiguration appConfiguration)
{
_presentMonCaptureService = presentMonCaptureService;
_sensorService = sensorService;
_overlayService = overlayService;
_soundManager = soundManager;
_recordManager = recordManager;
_logger = logger;
_appConfiguration = appConfiguration;
_presentMonCaptureService.IsCaptureModeActiveStream.OnNext(false);
}
public TableIO(IGui gui, IRecordManager recordManager)
{
m_gui = gui;
m_recordManager = recordManager;
m_state = State.Unknown;
m_listControlsEnabledOnlyOnAdd = new List<Control>();
m_listControlsEnabledOnlyOnView = new List<Control>();
m_listControlsNeverEnabled = new List<Control>();
m_dataRow = null;
m_connection = null;
m_sqlDataAdapter = null;
m_dataSet = null;
m_tableName = "";
m_suspendValueChanged = false;
m_suspendGuiChanged = false;
listDataBinding = new List<DataBinding>();
m_recordIsOptional = false;
}
public TableIO(IGui gui, IRecordManager recordManager)
{
m_gui = gui;
m_recordManager = recordManager;
m_state = State.Unknown;
m_listControlsEnabledOnlyOnAdd = new List <Control>();
m_listControlsEnabledOnlyOnView = new List <Control>();
m_listControlsNeverEnabled = new List <Control>();
m_dataRow = null;
m_connection = null;
m_sqlDataAdapter = null;
m_dataSet = null;
m_tableName = "";
m_suspendValueChanged = false;
m_suspendGuiChanged = false;
listDataBinding = new List <DataBinding>();
m_recordIsOptional = false;
}
private void PostVoucher()
{
if (_postStatus != PostStatus.Postable)
{
ShowFinancialYearIsNotOpenedMessage();
return;
}
IRecordManager recordManager = BLLCoreFactory.GetRecordManager();
recordManager.SetRecords(TemporaryRecords);
bool isSuccess = recordManager.Save();
Message message = MessageService.Instance.GetLatestMessage();
ShowMessage(message);
if (isSuccess)
{
Reset(false);
}
}
public CloudViewModel(IStatisticProvider statisticProvider, IRecordManager recordManager,
IEventAggregator eventAggregator, IAppConfiguration appConfiguration, ILogger <CloudViewModel> logger, IAppVersionProvider appVersionProvider, LoginManager loginManager)
{
_statisticProvider = statisticProvider;
_recordManager = recordManager;
_eventAggregator = eventAggregator;
_appConfiguration = appConfiguration;
_logger = logger;
_appVersionProvider = appVersionProvider;
_loginManager = loginManager;
ClearTableCommand = new DelegateCommand(OnClearTable);
CopyURLCommand = new DelegateCommand(() => Clipboard.SetText(_shareUrl));
_cloudFolderChanged = eventAggregator.GetEvent <PubSubEvent <AppMessages.CloudFolderChanged> >();
UploadRecordsCommand = new DelegateCommand(async() =>
{
await UploadRecords();
OnClearTable();
});
DownloadRecordsCommand = new DelegateCommand(async() =>
{
await DownloadCaptureCollection(DownloadIDString);
});
SubscribeToUpdateSession();
CloudEntries.CollectionChanged += new NotifyCollectionChangedEventHandler
((sender, eventArg) => OnCloudEntriesChanged());
IsLoggedIn = loginManager.State.Token != null;
_eventAggregator.GetEvent <PubSubEvent <AppMessages.LoginState> >().Subscribe(state =>
{
IsLoggedIn = state.IsLoggedIn;
RaisePropertyChanged(nameof(IsLoggedIn));
});
}
public static IRecordManager GetRecordManager(Dictionary <ConfigKey, object> config = null)
{
if (recordManager == null)
{
Debug.WriteLine("Using default TextRecordManager");
recordManager = new TextRecordManager();
}
if (config?.ContainsKey(ConfigKey.TextRecordManagerFilePath) ?? false)
{
Debug.WriteLine("ConfigKey.TextRecordManagerFilePath is provided");
var filePath = config[ConfigKey.TextRecordManagerFilePath] as string;
if (String.IsNullOrWhiteSpace(filePath))
{
throw new Exception("TextRecordManagerFilePath is empty!");
}
(recordManager as TextRecordManager).SetFilePath(filePath);
}
return(recordManager);
}
public OverlayService(IStatisticProvider statisticProvider,
ISensorService sensorService,
IOverlayEntryProvider overlayEntryProvider,
IAppConfiguration appConfiguration,
ILogger <OverlayService> logger,
IRecordManager recordManager,
IRTSSService rTSSService)
{
Stopwatch stopwatch = new Stopwatch();
stopwatch.Start();
_statisticProvider = statisticProvider;
_overlayEntryProvider = overlayEntryProvider;
_appConfiguration = appConfiguration;
_logger = logger;
_recordManager = recordManager;
_rTSSService = rTSSService;
_numberOfRuns = _appConfiguration.SelectedHistoryRuns;
SecondMetric = _appConfiguration.SecondMetricOverlay;
ThirdMetric = _appConfiguration.ThirdMetricOverlay;
IsOverlayActiveStream = new BehaviorSubject <bool>(_appConfiguration.IsOverlayActive);
_runHistoryOutlierFlags = Enumerable.Repeat(false, _numberOfRuns).ToArray();
_logger.LogDebug("{componentName} Ready", this.GetType().Name);
IsOverlayActiveStream.AsObservable()
.Select(isActive =>
{
if (isActive)
{
TryCloseRTSS();
_rTSSService.CheckRTSSRunning().Wait();
_rTSSService.ResetOSD();
return(sensorService.OnDictionaryUpdated
.SelectMany(_ => _overlayEntryProvider.GetOverlayEntries()));
}
else
{
// OSD status logging
Task.Run(async() =>
{
var processId = await _rTSSService.ProcessIdStream.Take(1);
try
{
_logger.LogInformation("Is process {detectedProcess} detected: {isDetected}", processId, _rTSSService.IsProcessDetected(processId));
}
catch
{
_logger.LogError("Error while checking RTSS core process detection");
}
//try
//{
// _logger.LogInformation("Is OS locked: {isLocked}", _rTSSService.IsOSDLocked());
//}
//catch
//{
// _logger.LogError("Error while checking RTSS core OSD lock status");
//}
}).Wait();
_rTSSService.ReleaseOSD();
return(Observable.Empty <IOverlayEntry[]>());
}
}).Switch()
.SubscribeOn(Scheduler.Default)
.Subscribe(async entries =>
{
_rTSSService.SetOverlayEntries(entries);
await _rTSSService.CheckRTSSRunningAndRefresh();
});
_runHistory = Enumerable.Repeat("N/A", _numberOfRuns).ToList();
_rTSSService.SetRunHistory(_runHistory.ToArray());
_rTSSService.SetRunHistoryAggregation(string.Empty);
_rTSSService.SetRunHistoryOutlierFlags(_runHistoryOutlierFlags);
_rTSSService.SetIsCaptureTimerActive(false);
stopwatch.Stop();
_logger.LogInformation(GetType().Name + " {initializationTime}s initialization time", Math.Round(stopwatch.ElapsedMilliseconds * 1E-03, 1));
}
public CommandExecutor(IRecordManager recordManager, ConsoleInput console)
{
this.recordManager = recordManager;
this.console = console;
}
/// <summary>
/// Allows population of a specific RecordManager instance into the cache.
/// </summary>
/// <typeparam name="TManager"></typeparam>
/// <param name="instance"></param>
public static void SetManager <TManager>(IRecordManager instance)
{
lock (_managers) {
_managers[typeof(TManager)] = instance;
}
}
internal NodePersistence(Session session, IRecordManager recordManager) : base(session)
{
this.RecordManager = recordManager;
}
public OverlayService(IStatisticProvider statisticProvider,
ISensorService sensorService,
IOverlayEntryProvider overlayEntryProvider,
IAppConfiguration appConfiguration,
ILogger <OverlayService> logger,
IRecordManager recordManager,
IRTSSService rTSSService,
IOverlayEntryCore overlayEntryCore)
{
Stopwatch stopwatch = new Stopwatch();
stopwatch.Start();
_statisticProvider = statisticProvider;
_overlayEntryProvider = overlayEntryProvider;
_appConfiguration = appConfiguration;
_logger = logger;
_recordManager = recordManager;
_sensorService = sensorService;
_rTSSService = rTSSService;
_overlayEntryCore = overlayEntryCore;
_numberOfRuns = _appConfiguration.SelectedHistoryRuns;
SecondMetric = _appConfiguration.RunHistorySecondMetric;
ThirdMetric = _appConfiguration.RunHistoryThirdMetric;
IsOverlayActiveStream = new BehaviorSubject <bool>(_appConfiguration.IsOverlayActive);
_runHistoryOutlierFlags = Enumerable.Repeat(false, _numberOfRuns).ToArray();
_logger.LogDebug("{componentName} Ready", this.GetType().Name);
Task.Run(async() => await InitializeOverlayEntryDict())
.ContinueWith(t =>
{
IsOverlayActiveStream
.AsObservable()
.Select(isActive =>
{
if (isActive)
{
_rTSSService.CheckRTSSRunning().Wait();
_rTSSService.OnOSDOn();
_rTSSService.ClearOSD();
return(_onDictionaryUpdated.
SelectMany(_ => _overlayEntryProvider.GetOverlayEntries()));
}
else
{
_rTSSService.ReleaseOSD();
return(Observable.Empty <IOverlayEntry[]>());
}
})
.Switch()
.Subscribe(async entries =>
{
_rTSSService.SetOverlayEntries(entries);
await _rTSSService.CheckRTSSRunningAndRefresh();
});
});
_sensorService.SensorSnapshotStream
.Sample(_sensorService.OsdUpdateStream.Select(timespan => Observable.Concat(Observable.Return(-1L), Observable.Interval(timespan))).Switch())
.Where((_, idx) => idx == 0 || IsOverlayActive)
.SubscribeOn(Scheduler.Default)
.Subscribe(sensorData =>
{
UpdateOverlayEntries(sensorData.Item2);
_onDictionaryUpdated.OnNext(_overlayEntryCore.OverlayEntryDict.Values.ToArray());
});
_runHistory = Enumerable.Repeat("N/A", _numberOfRuns).ToList();
_rTSSService.SetRunHistory(_runHistory.ToArray());
_rTSSService.SetRunHistoryAggregation(string.Empty);
_rTSSService.SetRunHistoryOutlierFlags(_runHistoryOutlierFlags);
_rTSSService.SetIsCaptureTimerActive(false);
stopwatch.Stop();
_logger.LogInformation(GetType().Name + " {initializationTime}s initialization time", Math.Round(stopwatch.ElapsedMilliseconds * 1E-03, 1));
}
public DatabaseController(IInterpreter interpreter, ICatalogManager catalogManager, IRecordManager recordManager)
{
_catalogManager = catalogManager;
_interpreter = interpreter;
_recordManager = recordManager;
}
