public TestsService(ILoadingProgressController loadingProgressController, IConfigSerializer configSerializer, ILoggingService loggingService, IFarmIntegrator farmIntegrator) { this.loadingProgressController = loadingProgressController; this.configSerializer = configSerializer; this.loggingService = loggingService; this.farmIntegrator = farmIntegrator; }
public static Config GenerateDefault(IConfigSerializer configSerializer) { var result = Validate(new Config()); configSerializer.SaveConfig(result); return(result); }
public void Save(IConfigSerializer serializer) { if (!string.IsNullOrWhiteSpace(_filePath)) { Save(_filePath, serializer); } }
public static Config Load(Stream stream, IConfigSerializer serializer) { Config config; using (stream) config = serializer.Deserialize(stream); return(config); }
public TestsService(ILoadingProgressController loadingProgressController, IConfigSerializer configSerializer, ILoggingService loggingService, IMinioWorker minioWorker, INotificationService notificationService) { this.loadingProgressController = loadingProgressController; this.configSerializer = configSerializer; this.loggingService = loggingService; this.minioWorker = minioWorker; this.notificationService = notificationService; platformProvider = ServiceLocator.Current.GetInstance <IPlatformProvider>(); }
public SettingsViewModel(IConfigSerializer configSerializer) { Title = "Settings"; this.configSerializer = configSerializer; Config = configSerializer.GetConfig(); Commands = UICommand.GenerateFromMessageButton(MessageButton.OKCancel, new DialogService(), MessageResult.OK, MessageResult.Cancel); Commands.Where(c => c.IsDefault).Single().Command = new DelegateCommand(Save, () => !IsAnyRepositoryDownloading()); Commands.Where(c => c.IsCancel).Single().Command = new DelegateCommand(Cancel, () => !IsAnyRepositoryDownloading()); }
internal IFeatureManager features; //Used to access features exposed by other plugins, such as the steamcmdhelper from the SteamCMD plugin //ModuleMain is the entry point for a module, it's the first thing that gets called when AMP loads the module. public ModuleMain(ILogger log, IConfigSerializer config, SupportedOS currentPlatform, IRunningTasksManager taskManager, IFeatureManager features) { this.log = log; taskmgr = taskManager; this.config = config; os = currentPlatform; this.features = features; settings = config.Load <FiveMConfig>(); //This will also automatically save your settings for you when the user changes them. You don't need to do anything }
/// <summary> /// Static configuration loader /// </summary> /// <param name="serializer"></param> /// <param name="fileName"></param> /// <returns></returns> protected static TConfig Current(IConfigSerializer serializer, string fileName) { var serialized = LoadFromFile(fileName); if (string.IsNullOrEmpty(serialized)) { return(default(TConfig)); } return(serializer.DeserializeObject <TConfig>(serialized)); }
public SettingsViewModel(IConfigSerializer configSerializer) { Title = "Settings"; _dispatcher = Dispatcher.CurrentDispatcher; _configSerializer = configSerializer; _platformProvider = ServiceLocator.Current.GetInstance <IPlatformProvider>(); Config = configSerializer.GetConfig(); Commands = UICommand.GenerateFromMessageButton(MessageButton.OKCancel, new DialogService(), MessageResult.OK, MessageResult.Cancel); Commands.Single(c => c.IsDefault).Command = new DelegateCommand(Save, AllowDialogButtons); Commands.Single(c => c.IsCancel).Command = new DelegateCommand(Cancel, AllowDialogButtons); }
/// <summary>Save the given object into a file</summary> /// <param name="ConfigObject">The object to save</param> /// <param name="Filename">The filename the objects should get</param> /// <exception cref="ArgumentException" /> /// <exception cref="ArgumentNullException" /> /// <exception cref="ArgumentOutOfRangeException" /> /// <exception cref="DirectoryNotFoundException" /> /// <exception cref="FileNotFoundException" /> /// <exception cref="IOException" /> /// <exception cref="InvalidOperationException" /> /// <exception cref="NotSupportedException" /> /// <exception cref="PathTooLongException" /> /// <exception cref="UnauthorizedAccessException" /> /// <exception cref="System.Security.SecurityException" /> public static void SaveConfig(Object ConfigObject, String Filename) { //Get file info on the file to save to String Filepath = ConfigOptions.ConfigFolder + Filename + ConfigOptions.ConfigExtension; var FI = new FileInfo(Filepath); EventWaitHandle Lock = ConfigLoader.GetLock(Filepath); //Check parent directory DirectoryInfo DI = FI.Directory; //Create if missing if (!DI.Exists) { DI.Create(); } //Setup IConfigSerializer <Object> serializer = null; FileStream writer = null; Lock.WaitOne(); #if !DEBUG try { #endif //Assign serializer and stream serializer = ConfigLoader._SerializerFactory.GetSerializer(ConfigObject.GetType()); writer = new FileStream(FI.FullName, FileMode.Create); //Serialize object serializer.Serialize(ConfigObject, writer); //Flush and close writer.Flush(); writer.Close(); #if !DEBUG } #pragma warning disable 168 catch (Exception ex) { #pragma warning restore 168 //Close stream if open if (writer != null) { writer.Close(); } ErrorSaving(Filepath, ex); } #endif Lock.Set(); }
/// <summary> /// Creates a new instance of <see cref="ConfigService"/> /// </summary> /// <param name="provider">The provider which will be used to load and store the configurations.</param> /// <param name="serializer">The serializer which will be used to serialize and deserialize the configurations.</param> public ConfigService(IConfigProvider provider, IConfigSerializer serializer) { if (provider == null) { throw new ArgumentNullException(nameof(provider)); } if (serializer == null) { throw new ArgumentNullException(nameof(serializer)); } this.provider = provider; this.serializer = serializer; }
public static Config Load(string fileName, IConfigSerializer serializer) { Config config; if (File.Exists(fileName)) { using (var fs = new FileStream(fileName, FileMode.Open, FileAccess.Read, FileShare.Read)) config = serializer.Deserialize(fs); } else { config = new Config(); } config._filePath = fileName; return(config); }
public MainViewModel(INotificationService notificationService, IRegionManager regionManager, ILoggingService loggingService, IFarmIntegrator farmIntegrator, IConfigSerializer configSerializer, ILoadingProgressController loadingProgressController, ITestsService testsService, IGitWorker gitWorker) { Dispatcher = Dispatcher.CurrentDispatcher; this.notificationService = notificationService; this.regionManager = regionManager; this.loggingService = loggingService; this.farmIntegrator = farmIntegrator; this.configSerializer = configSerializer; LoadingProgressController = loadingProgressController; TestService = testsService; _GitWorker = gitWorker; TestService.PropertyChanged += TestService_PropertyChanged; loggingService.MessageReserved += OnLoggingMessageReserved; UpdateConfig(); }
public MainViewModel(INotificationService notificationService, ILoggingService loggingService, IConfigSerializer configSerializer, ILoadingProgressController loadingProgressController, ITestsService testsService, IGitWorker gitWorker, IPlatformProvider platformProvider, IActiveService isActiveService, ITestsService testService) { dispatcher = Dispatcher.CurrentDispatcher; this.notificationService = notificationService; this.loggingService = loggingService; this.configSerializer = configSerializer; this.platformProvider = platformProvider; this.isActiveService = isActiveService; this.testService = testService; this.gitWorker = gitWorker; obsolescenceTracker = new RepositoryObsolescenceTracker(this.gitWorker, () => _config.Repositories, NoticeRepositoryObsolescenceAsync); LoadingProgressController = loadingProgressController; testService = testsService; testService.PropertyChanged += TestService_PropertyChanged; loggingService.MessageReserved += OnLoggingMessageReserved; }
public ConfigHandler(IFileSystem fileSystem, IConfigSerializer configSerializer) { this.fileSystem = fileSystem; this.configSerializer = configSerializer; }
/// <summary> /// Deserializes a string to a configuration. /// </summary> /// <typeparam name="T">The type of the configuration.</typeparam> /// <param name="serializer"></param> /// <param name="config">The string representation of the configuration.</param> /// <returns>The deserialized configuration.</returns> public static T Deserialize <T>(this IConfigSerializer serializer, string config) where T : class, IConfig => (T)serializer.Deserialize(config, typeof(T));
public void Save(string fileName, IConfigSerializer serializer) { using (var fs = new FileStream(fileName, FileMode.Create, FileAccess.Write, FileShare.None)) serializer.Serialize(fs, this); }
public AppSettings(IConfigSerializer serializer, ICacheService cacheService) : base(serializer, cacheService) { }
public AppSettingsManagerBase(IConfigSerializer <T> serializer) { _serializer = serializer; }
protected Configuration(IConfigSerializer serializer, ICacheService cacheService) : base(serializer, cacheService) { }
public OverlayAuraModelBase( [NotNull] ISharedContext sharedContext, [NotNull] IAuraRepository repository, [NotNull] IConfigSerializer configSerializer, [NotNull] IUniqueIdGenerator idGenerator, [NotNull] IFactory <IEyeOverlayViewModel, IOverlayWindowController, IAuraModelController> overlayViewModelFactory, [NotNull] IFactory <IOverlayWindowController, IWindowTracker> overlayWindowControllerFactory, [NotNull] IFactory <WindowTracker, IStringMatcher> windowTrackerFactory, [NotNull][Dependency(WellKnownSchedulers.UI)] IScheduler uiScheduler, [NotNull][Dependency(WellKnownSchedulers.Background)] IScheduler bgScheduler) { defaultAuraName = $"Aura #{Interlocked.Increment(ref GlobalAuraIdx)}"; Name = defaultAuraName; Id = idGenerator.Next(); using var sw = new BenchmarkTimer($"[{Name}({Id})] OverlayAuraModel initialization", Log, nameof(OverlayAuraModelBase)); var auraTriggers = new ComplexAuraTrigger(); Triggers = auraTriggers.Triggers; var auraActions = new ComplexAuraAction(); OnEnterActions = auraActions.Actions; this.repository = repository; this.configSerializer = configSerializer; var matcher = new RegexStringMatcher().AddToWhitelist(".*"); var windowTracker = windowTrackerFactory .Create(matcher) .AddTo(Anchors); var overlayController = overlayWindowControllerFactory .Create(windowTracker) .AddTo(Anchors); sw.Step($"Overlay controller created: {overlayController}"); var overlayViewModel = overlayViewModelFactory .Create(overlayController, this) .AddTo(Anchors); sw.Step($"Overlay view model created: {overlayViewModel}"); Overlay = overlayViewModel; Observable.Merge( overlayViewModel.WhenValueChanged(x => x.AttachedWindow, false).ToUnit(), overlayViewModel.WhenValueChanged(x => x.IsLocked, false).ToUnit(), this.WhenValueChanged(x => x.IsActive, false).ToUnit()) .StartWithDefault() .Select( () => new { OverlayShouldBeShown = IsActive || !overlayViewModel.IsLocked, WindowIsAttached = overlayViewModel.AttachedWindow != null }) .Subscribe(x => overlayController.IsEnabled = x.OverlayShouldBeShown && x.WindowIsAttached) .AddTo(Anchors); sw.Step($"Overlay view model initialized: {overlayViewModel}"); Observable.CombineLatest( auraTriggers.WhenAnyValue(x => x.IsActive), sharedContext.SystemTrigger.WhenValueChanged(x => x.IsActive)) .DistinctUntilChanged() .Subscribe(x => IsActive = x.All(isActive => isActive), Log.HandleException) .AddTo(Anchors); auraTriggers.WhenAnyValue(x => x.IsActive) .WithPrevious((prev, curr) => new { prev, curr }) .Where(x => x.prev == false && x.curr) .Subscribe(ExecuteOnEnterActions, Log.HandleException) .AddTo(Anchors); this.repository.KnownEntities .ToObservableChangeSet() .SkipInitial() .Throttle(ModelsReloadTimeout, bgScheduler) .ObserveOn(uiScheduler) .Subscribe( () => { var properties = Properties; ReloadCollections(properties); }) .AddTo(Anchors); var modelPropertiesToIgnore = new[] { nameof(IAuraTrigger.IsActive), nameof(IAuraTrigger.TriggerDescription), nameof(IAuraTrigger.TriggerName), }.ToImmutableHashSet(); //FIXME Properties mechanism should have inverted logic - only important parameters must matter Observable.Merge( this.WhenAnyProperty(x => x.Name, x => x.TargetWindow, x => x.IsEnabled).Select(x => $"[{Name}].{x.EventArgs.PropertyName} property changed"), Overlay.WhenAnyProperty().Where(x => !modelPropertiesToIgnore.Contains(x.EventArgs.PropertyName)).Select(x => $"[{Name}].{nameof(Overlay)}.{x.EventArgs.PropertyName} property changed"), Triggers.ToObservableChangeSet().Select(x => $"[{Name}({Id})] Trigger list changed, item count: {Triggers.Count}"), Triggers.ToObservableChangeSet().WhenPropertyChanged().Where(x => !modelPropertiesToIgnore.Contains(x.EventArgs.PropertyName)).Select(x => $"[{Name}].{x.Sender}.{x.EventArgs.PropertyName} Trigger property changed"), OnEnterActions.ToObservableChangeSet().Select(x => $"[{Name}({Id})] Action list changed, item count: {OnEnterActions.Count}"), OnEnterActions.ToObservableChangeSet().WhenPropertyChanged().Where(x => !modelPropertiesToIgnore.Contains(x.EventArgs.PropertyName)).Select(x => $"[{Name}].{x.Sender}.{x.EventArgs.PropertyName} Action property changed")) .Subscribe(reason => RaisePropertyChanged(nameof(Properties))) .AddTo(Anchors); Disposable.Create(() => { Log.Debug( $"Disposed Aura {Name}({Id}) (aka {defaultAuraName}), triggers: {Triggers.Count}, actions: {OnEnterActions.Count}"); OnEnterActions.Clear(); Triggers.Clear(); }).AddTo(Anchors); sw.Step($"Overlay model properties initialized"); overlayController.RegisterChild(overlayViewModel).AddTo(Anchors); sw.Step($"Overlay registration completed: {this}"); }
public AppConfig(IConfigSerializer serializer, ICacheService cacheService) : base(serializer, cacheService) { }
public ConfigManager(IConfigSerializer configSerializer, IConfigDeserializer configDeserializer) { this.configSerializer = configSerializer; this.configDeserializer = configDeserializer; }
public AppSettingsManager(IConfigSerializer <AppSettings> serializer) : base(serializer) { }
public EnvModeSettingsManager(IConfigSerializer serializer, ICacheService cacheService) : base(serializer, cacheService) { }
public AppConfig(string configFileName, IConfigSerializer serializer, ICacheService cacheService) : base(configFileName, serializer, cacheService) { }
public MainWindowViewModel( [NotNull] IFactory <IOverlayAuraViewModel, OverlayAuraProperties> auraViewModelFactory, [NotNull] IApplicationUpdaterViewModel appUpdater, [NotNull] IClipboardManager clipboardManager, [NotNull] IConfigSerializer configSerializer, [NotNull] IGenericSettingsViewModel settingsViewModel, [NotNull] IMessageBoxViewModel messageBox, [NotNull] IHotkeyConverter hotkeyConverter, [NotNull] IFactory <HotkeyIsActiveTrigger> hotkeyTriggerFactory, [NotNull] IConfigProvider <EyeAurasConfig> configProvider, [NotNull] IConfigProvider rootConfigProvider, [NotNull] IPrismModuleStatusViewModel moduleStatus, [NotNull] IMainWindowBlocksProvider mainWindowBlocksProvider, [NotNull] IFactory <IRegionSelectorService> regionSelectorServiceFactory, [NotNull] ISharedContext sharedContext, [NotNull] IComparisonService comparisonService, [NotNull][Dependency(WellKnownSchedulers.UI)] IScheduler uiScheduler) { using var unused = new OperationTimer(elapsed => Log.Debug($"{nameof(MainWindowViewModel)} initialization took {elapsed.TotalMilliseconds:F0}ms")); TabsList = new ReadOnlyObservableCollection <IEyeAuraViewModel>(sharedContext.AuraList); ModuleStatus = moduleStatus.AddTo(Anchors); var executingAssemblyName = Assembly.GetExecutingAssembly().GetName(); Title = $"{(AppArguments.Instance.IsDebugMode ? "[D]" : "")} {executingAssemblyName.Name} v{executingAssemblyName.Version}"; Disposable.Create(() => Log.Info("Disposing Main view model")).AddTo(Anchors); ApplicationUpdater = appUpdater.AddTo(Anchors); MessageBox = messageBox.AddTo(Anchors); Settings = settingsViewModel.AddTo(Anchors); StatusBarItems = mainWindowBlocksProvider.StatusBarItems; this.auraViewModelFactory = auraViewModelFactory; this.configProvider = configProvider; this.sharedContext = sharedContext; this.regionSelectorService = regionSelectorServiceFactory.Create(); this.clipboardManager = clipboardManager; this.configSerializer = configSerializer; this.hotkeyConverter = hotkeyConverter; this.hotkeyTriggerFactory = hotkeyTriggerFactory; CreateNewTabCommand = CommandWrapper.Create(() => AddNewCommandExecuted(OverlayAuraProperties.Default)); CloseTabCommand = CommandWrapper .Create <IOverlayAuraViewModel>(CloseTabCommandExecuted, CloseTabCommandCanExecute) .RaiseCanExecuteChangedWhen(this.WhenAnyProperty(x => x.SelectedTab)); DuplicateTabCommand = CommandWrapper .Create(DuplicateTabCommandExecuted, DuplicateTabCommandCanExecute) .RaiseCanExecuteChangedWhen(this.WhenAnyProperty(x => x.SelectedTab)); CopyTabToClipboardCommand = CommandWrapper .Create(CopyTabToClipboardExecuted, CopyTabToClipboardCommandCanExecute) .RaiseCanExecuteChangedWhen(this.WhenAnyProperty(x => x.SelectedTab).Select(x => x)); PasteTabCommand = CommandWrapper.Create(PasteTabCommandExecuted); UndoCloseTabCommand = CommandWrapper.Create(UndoCloseTabCommandExecuted, UndoCloseTabCommandCanExecute); OpenAppDataDirectoryCommand = CommandWrapper.Create(OpenAppDataDirectory); SelectRegionCommand = CommandWrapper.Create(SelectRegionCommandExecuted); Observable .FromEventPattern <OrderChangedEventArgs>(h => positionMonitor.OrderChanged += h, h => positionMonitor.OrderChanged -= h) .Select(x => x.EventArgs) .Subscribe(OnTabOrderChanged, Log.HandleUiException) .AddTo(Anchors); sharedContext .AuraList .ToObservableChangeSet() .ObserveOn(uiScheduler) .OnItemAdded(x => SelectedTab = x) .Subscribe() .AddTo(Anchors); this.WhenAnyValue(x => x.SelectedTab) .Subscribe(x => Log.Debug($"Selected tab: {x}")) .AddTo(Anchors); LoadConfig(); rootConfigProvider.Save(); if (sharedContext.AuraList.Count == 0) { CreateNewTabCommand.Execute(null); } configUpdateSubject .Sample(ConfigSaveSamplingTimeout) .Subscribe(SaveConfig, Log.HandleException) .AddTo(Anchors); Observable.Merge( this.WhenAnyProperty(x => x.Left, x => x.Top, x => x.Width, x => x.Height) .Sample(ConfigSaveSamplingTimeout) .Select(x => $"[{x.Sender}] Main window property change: {x.EventArgs.PropertyName}"), sharedContext.AuraList.ToObservableChangeSet() .Sample(ConfigSaveSamplingTimeout) .Select(x => "Tabs list change"), sharedContext.AuraList.ToObservableChangeSet() .WhenPropertyChanged(x => x.Properties) .Sample(ConfigSaveSamplingTimeout) .WithPrevious((prev, curr) => new { prev, curr }) .Select(x => new { x.curr.Sender, ComparisonResult = comparisonService.Compare(x.prev?.Value, x.curr.Value) }) .Where(x => !x.ComparisonResult.AreEqual) .Select(x => $"[{x.Sender.TabName}] Tab properties change: {x.ComparisonResult.DifferencesString}")) .Buffer(ConfigSaveSamplingTimeout) .Where(x => x.Count > 0) .Subscribe( reasons => { const int maxReasonsToOutput = 50; Log.Debug( $"Config Save reasons{(reasons.Count <= maxReasonsToOutput ? string.Empty : $"first {maxReasonsToOutput} of {reasons.Count} items")}:\r\n\t{reasons.Take(maxReasonsToOutput).DumpToTable()}"); configUpdateSubject.OnNext(Unit.Default); },
protected ConfigurationReader(IConfigSerializer serializer, ICacheService cacheService) { _serializer = serializer; _cacheService = cacheService; }