public TimerHandler( IConfigHandler config )
{
this.config = config;
this.TimedEvents = new ObservableCollection<TimedEvent>();
this.clock.Tick += ( se, ea ) =>
{
foreach ( var t in this.TimedEvents.ToList() )
{
t.NotifyOfPropertyChange( "TimeRemaining" );
if ( t.TimeRemaining.Ticks == 0 )
{
if ( this.TimedEventCompleted != null )
{
this.TimedEventCompleted( t, null );
}
this.TimedEvents.Remove( t );
}
}
};
this.clock.Start();
}
public LoginHandler(ILogger logger)
{
_logger = logger;
var custome = FastTunnelGlobal.GetCustomHandler <IConfigHandler>();
_configHandler = custome == null ? new ConfigHandler() : custome;
}
public DynDns53ConsoleClient(IConfigHandler configHandler, IAmazonRoute53 route53Client, IHeartbeatService heartbeatService, ILog logger)
{
this.configHandler = configHandler;
this.route53Client = route53Client;
this.heartbeatService = heartbeatService;
this.logger = logger;
}
internal void CreateLinks(IConsole console, IConfigHandler configHandler, IFileSystem fileSystem, IPathResolver pathResolver, IConfig config, string sourceDirectory, string targetDirectory)
{
if (!linkDirectories)
{
foreach (string file in fileSystem.Directory.GetFiles(pathResolver.GetAbsoluteResolvedPath(sourceDirectory, config.Variables)))
{
TryCreateLink(console, configHandler, fileSystem, pathResolver, config, file, targetDirectory, true);
}
// Recursive - Will create links for all files in sub-dirs as well
if (includeSubdirectories)
{
foreach (string directory in fileSystem.Directory.GetDirectories(pathResolver.GetAbsoluteResolvedPath(sourceDirectory, config.Variables)))
{
CreateLinks(console, configHandler, fileSystem, pathResolver, config, directory, fileSystem.Path.Combine(targetDirectory, fileSystem.Path.GetFileName(directory)));
}
}
}
else
{
foreach (string directory in fileSystem.Directory.GetDirectories(pathResolver.GetAbsoluteResolvedPath(sourceDirectory, config.Variables)))
{
TryCreateLink(console, configHandler, fileSystem, pathResolver, config, directory, targetDirectory, false);
}
}
}
public void Execute(IConsole console, IConfigHandler configHandler, IFileSystem fileSystem)
{
if (!configHandler.DoesConfigExist(path))
{
console.WriteLine($"Config '{ path }' does not exist. Type 'help config' in order to see how you create a config file.", IConsole.ContentType.Negative);
return;
}
IConfig config = configHandler.LoadConfig(path);
Variable existingVariable = config.Variables.FirstOrDefault(variable => variable.name.Equals(name, StringComparison.OrdinalIgnoreCase));
if (existingVariable == null)
{
config.Variables.Add(new Variable(name, value));
console.WriteLine($"Added new variable '{ name }' with value '{ value }'");
configHandler.SaveConfig(config, path);
}
else
{
if (!force)
{
console.WriteLine($"A variable with the name '{ name }' already exists", IConsole.ContentType.Negative);
}
else
{
existingVariable.value = value;
console.WriteLine($"Replaced existing variable value for '{ name }' with '{ value }'");
configHandler.SaveConfig(config, path);
}
}
}
private void InitConfig()
{
AddLog("Loading configuration values...");
_configHandler = new AppConfigHandler();
_config = _configHandler.GetConfig();
_ipChecker = _config.IPChecker;
var _amazonClient = new AmazonRoute53Client(_config.Route53AccessKey, _config.Route53SecretKey, RegionEndpoint.USEast1);
_dnsUpdater = new DnsUpdater(_amazonClient);
AddLog($"Found {_config.DomainList.Count} domain(s)");
foreach (HostedDomainInfo domainInfo in _config.DomainList)
{
AddLog($"{domainInfo.DomainName}");
}
if (_timer != null)
{
// Stop to avoid multiple timer_Tick invocations
_timer.Stop();
}
int interval = _config.UpdateInterval;
_timer = new System.Windows.Threading.DispatcherTimer();
_timer.Tick += timer_Tick;
_timer.Interval = new TimeSpan(0, 0, interval);
_timer.Start();
AddLog($"Time set to update domains every {interval} seconds");
SetAutoStart();
}
public DnsUpdaterTestPad(IConfigHandler configHandler,
IIpChecker ipchecker,
IAmazonRoute53 amazonClient)
{
_configHandler = configHandler;
_ipChecker = ipchecker;
_amazonClient = amazonClient;
}
public UeditorService(UploadDBContext dbContext, INotSupportedHandler NotSupportedHandler, IConfigHandler configHandler, IUploadHandler uploadHandler, IEditorConfig editorConfig, IListFileHandler listFileHandler, ICrawlerHandler crawlerHandler)
{
this._notSupportedHandler = NotSupportedHandler;
this._configHandler = configHandler;
this._uploadHandler = uploadHandler;
this._editorConfig = editorConfig;
this._listFileHandler = listFileHandler;
this._crawlerHandler = crawlerHandler;
}
public HueService(IConfigHandler configHandler)
{
this.configHandler = configHandler;
config = configHandler.LoadFromFile();
baseUrl = config.HueConfig.BridgeUrl;
client = new RestClient(baseUrl);
TryLoadUser();
}
public OAuthWindowView(IStreamingService streamingService, IConfigHandler configHandler)
{
InitializeComponent();
this.streamingService = streamingService ?? throw new ArgumentNullException(nameof(streamingService));
this.configHandler = configHandler ?? throw new ArgumentNullException(nameof(configHandler));
OAuthWebBrowser.Source = new Uri(streamingService.OAuthUrl);
OAuthWebBrowser.NavigationStarting += OAuthWebBrowser_NavigationStarting;
}
public HttpStreamingConfigListener(string bucketName, ClusterOptions clusterOptions, HttpClient httpClient,
IConfigHandler configHandler, ILogger <HttpStreamingConfigListener> logger)
{
_bucketName = bucketName ?? throw new ArgumentNullException(nameof(bucketName));
_clusterOptions = clusterOptions ?? throw new ArgumentNullException(nameof(clusterOptions));
_httpClient = httpClient ?? throw new ArgumentNullException(nameof(httpClient));
_configHandler = configHandler ?? throw new ArgumentNullException(nameof(configHandler));
_logger = logger ?? throw new ArgumentNullException(nameof(logger));
}
internal void Execute(IConsole console, IConfigHandler configHandler, IConfig defaultConfig, IPathResolver pathResolver)
{
if (create)
{
if (configHandler.DoesConfigExist(path))
{
console.WriteLine("Config already exists!", IConsole.ContentType.Negative);
}
else
{
console.WriteLine("Creating config '{0}'", path);
configHandler.SaveConfig(defaultConfig, path);
}
}
else if (delete)
{
if (configHandler.DoesConfigExist(path))
{
console.WriteLine("Deleting config '{0}'", path);
configHandler.DeleteConfig(path);
}
else
{
console.WriteLine($"Config '{path}' does not exist!", IConsole.ContentType.Negative);
}
}
else
{
if (configHandler.DoesConfigExist(path))
{
IConfig config = configHandler.LoadConfig(path);
console.WriteLine();
console.WriteLine("### Metadata info ###", IConsole.ContentType.Header);
console.WriteLine($"Path: {path}");
console.WriteLine($"Full path: {pathResolver.GetAbsoluteResolvedPath(path, config.Variables)}");
console.WriteLine($"Version: {config.Version}");
console.WriteLine();
console.WriteLine("### Variable info ###", IConsole.ContentType.Header);
console.WriteLine("Total variables: " + config.Variables.Count);
console.WriteLine();
console.WriteLine("### Link info ###", IConsole.ContentType.Header);
console.WriteLine("Total links: " + config.LinkList.Count);
console.WriteLine("Junction links: " + config.LinkList.Count(l => l.linkType == ConfigLink.LinkType.Junction));
console.WriteLine("Symbolic links: " + config.LinkList.Count(l => l.linkType == ConfigLink.LinkType.Symbolic));
console.WriteLine("Hard links: " + config.LinkList.Count(l => l.linkType == ConfigLink.LinkType.Hard));
}
else
{
console.WriteLine("Config does not exist. You can create one with the --create option.", IConsole.ContentType.Negative);
}
}
}
public HttpStreamingConfigListener(IBucket bucket, ClusterOptions clusterOptions, ICouchbaseHttpClientFactory httpClientFactory,
IConfigHandler configHandler, ILogger <HttpStreamingConfigListener> logger)
{
_bucket = bucket ?? throw new ArgumentNullException(nameof(bucket));
_streamingUriPath = "/pools/default/bs/" + _bucket.Name;
_clusterOptions = clusterOptions ?? throw new ArgumentNullException(nameof(clusterOptions));
_httpClientFactory = httpClientFactory ?? throw new ArgumentNullException(nameof(httpClientFactory));
_configHandler = configHandler ?? throw new ArgumentNullException(nameof(configHandler));
_logger = logger ?? throw new ArgumentNullException(nameof(logger));
}
public CommandExecutor(IConsole console, IConfigHandler configHandler, IFileSystem fileSystem, IConfig defaultConfig, IArgumentParser argumentHandler, ILinker linker, IPathResolver pathResolver)
{
this.console = console;
this.configHandler = configHandler;
this.fileSystem = fileSystem;
this.defaultConfig = defaultConfig;
this.argumentHandler = argumentHandler;
this.linker = linker;
this.pathResolver = pathResolver;
}
public TwitchService(IConfigHandler configHandler, AppConfiguration appConfiguration)
{
var config = configHandler.Config;
clientId = config.TwitchClientId;
baseUrl = appConfiguration.TwitchApiUrl;
OAuthUrl = baseUrl + $@"kraken/oauth2/authorize?client_id={clientId}&redirect_uri=http://localhost&response_type=token+id_token&scope=user:read:email+chat:read openid";
client = new RestClient(baseUrl);
}
internal void Execute(IConsole console, IConfigHandler configHandler, IFileSystem fileSystem, IPathResolver pathResolver)
{
if (!configHandler.DoesConfigExist(path))
{
console.WriteLine($"Config '{ path }' does not exist. Type 'help config' in order to see how you create a config file.", IConsole.ContentType.Negative);
return;
}
IConfig config = configHandler.LoadConfig(path);
CreateLinks(console, configHandler, fileSystem, pathResolver, config, sourceDirectoryPath, targetDirectoryPath);
}
public ClusterContext(ICluster cluster, CancellationTokenSource tokenSource, ClusterOptions options)
{
Cluster = cluster;
ClusterOptions = options;
_tokenSource = tokenSource;
// Register this instance of ClusterContext
options.AddClusterService(this);
ServiceProvider = options.BuildServiceProvider();
_logger = ServiceProvider.GetRequiredService <ILogger <ClusterContext> >();
_redactor = ServiceProvider.GetRequiredService <IRedactor>();
_configHandler = ServiceProvider.GetRequiredService <IConfigHandler>();
_clusterNodeFactory = ServiceProvider.GetRequiredService <IClusterNodeFactory>();
}
public VoiceCommandHandler( IConfigHandler config, ITimerHandler timerHandler )
{
this.engine = new SpeechRecognitionEngine();
this.timerHandler = timerHandler;
var builder = new GrammarBuilder();
builder.Append( new Choices( config.Config.Verbs.ToArray() ) );
builder.Append( new Choices( config.Commands.ToArray() ) );
this.engine.RequestRecognizerUpdate();
this.engine.LoadGrammar( new Grammar( builder ) );
this.engine.SpeechRecognized += engine_SpeechRecognized;
this.engine.SetInputToDefaultAudioDevice();
this.engine.RecognizeAsync( RecognizeMode.Multiple );
}
internal void Execute(IConsole console, IConfigHandler configHandler, IFileSystem fileSystem, ILinker linker, IPathResolver pathResolver)
{
if (!configHandler.DoesConfigExist(path))
{
console.WriteLine($"Config '{ path }' does not exist. Type 'help config' in order to see how you create a config file.", IConsole.ContentType.Negative);
return;
}
IConfig config = configHandler.LoadConfig(path);
console.WriteLine("\nCreating links based on config...");
int successes = 0;
// Allow linkers verbose output if flag is set for this command
linker.verbose = verbose;
foreach (ConfigLink configLink in config.LinkList)
{
string resolvedSourcePath = pathResolver.GetAbsoluteResolvedPath(configLink.sourcePath, config.Variables);
string resolvedTargetPath = pathResolver.GetAbsoluteResolvedPath(configLink.targetPath, config.Variables);
CreateSubDirectories(console, fileSystem, pathResolver, config, resolvedTargetPath);
if (fileSystem.Directory.Exists(resolvedTargetPath) || fileSystem.File.Exists(resolvedTargetPath))
{
console.Write($"Path '{configLink.targetPath}' already exists", IConsole.ContentType.Negative);
if (verbose)
{
console.Write($" (resolved to '{resolvedTargetPath}')", IConsole.ContentType.Negative);
}
console.WriteLine();
}
else if (linker.CreateLink(resolvedSourcePath, resolvedTargetPath, configLink.linkType))
{
successes++;
}
}
console.WriteLine("\n### Finished! Created {0} / {1} links ###", successes, config.LinkList.Count);
}
internal void Execute(IConsole console, IConfigHandler configHandler, IFileSystem fileSystem, IPathResolver pathResolver)
{
if (!configHandler.DoesConfigExist(path))
{
console.WriteLine($"Config '{ path }' does not exist. Type 'help config' in order to see how you create a config file.", IConsole.ContentType.Negative);
return;
}
IConfig config = configHandler.LoadConfig(path);
if (!displayVariables)
{
foreach (ConfigLink configLink in config.LinkList)
{
string absoluteSourcePathString = "";
string absoluteTargetPathString = "";
if (displayAbsolutePaths)
{
absoluteSourcePathString = $"\n\t\t => { pathResolver.GetAbsoluteResolvedPath(configLink.sourcePath, config.Variables) }";
absoluteTargetPathString = $"\n\t\t => { pathResolver.GetAbsoluteResolvedPath(configLink.targetPath, config.Variables) }";
}
console.WriteLine($"\n" +
$"{ configLink.linkType.ToString() } link:\n" +
$"\t- Source: { configLink.sourcePath }{ absoluteSourcePathString }\n" +
$"\t- Target: { configLink.targetPath }{ absoluteTargetPathString }\n");
}
}
else
{
foreach (Variable variable in config.Variables)
{
console.WriteLine($"\n { variable.ToString() }");
}
}
if (config.LinkList.Count == 0)
{
console.WriteLine("Config is empty");
}
}
public SettingsViewModel(
IWindowService windowService,
IConfigHandler configHandler,
IFavoritesService favoritesService,
IStatusSetter statusSetter,
IHueService hueService)
{
this.windowService = windowService;
this.favoritesService = favoritesService;
this.statusSetter = statusSetter;
this.hueService = hueService;
config = configHandler.LoadFromFile();
StartSkypeAndSteamCommand = new RelayCommand(OnStartSkypeAndSteamCommand);
EditFavoritesCommand = new RelayCommand(OnEditFavoritesCommand);
RegisterHueCommand = new RelayCommand(OnRegisterHueCommand);
AboutCommand = new RelayCommand(OnAboutCommand);
ClearFavoritesCommand = new RelayCommand(OnClearFavoritesCommand);
ExitProgramCommand = new RelayCommand(OnExitProgramCommand);
}
internal void Execute(IConsole console, IConfigHandler configHandler, IFileSystem fileSystem, IPathResolver pathResolver)
{
if (!configHandler.DoesConfigExist(path))
{
console.WriteLine($"Config '{ path }' does not exist. Type 'help config' in order to see how you create a config file.", IConsole.ContentType.Negative);
return;
}
IConfig config = configHandler.LoadConfig(path);
ConfigLink configLink = config.LinkList.FirstOrDefault(link => pathResolver.GetAbsoluteResolvedPath(link.targetPath, config.Variables).Equals(pathResolver.GetAbsoluteResolvedPath(targetPath, config.Variables)));
if (configLink != null)
{
config.LinkList.Remove(configLink);
console.WriteLine("\nSuccessfully removed link with targetPath '{0}'", targetPath);
configHandler.SaveConfig(config, path);
}
else
{
console.WriteLine($"\nThe targetPath '{targetPath}' is invalid because it does not exist in config", IConsole.ContentType.Negative);
}
}
public void Execute(IConsole console, IConfigHandler configHandler, IFileSystem fileSystem)
{
if (!configHandler.DoesConfigExist(path))
{
console.WriteLine($"Config '{ path }' does not exist. Type 'help config' in order to see how you create a config file.", IConsole.ContentType.Negative);
return;
}
IConfig config = configHandler.LoadConfig(path);
Variable existingVariable = config.Variables.FirstOrDefault(variable => variable.name.Equals(name, StringComparison.OrdinalIgnoreCase));
if (existingVariable == null)
{
console.WriteLine($"A variable with name '{ name }' does not exist", IConsole.ContentType.Negative);
}
else
{
config.Variables.Remove(existingVariable);
configHandler.SaveConfig(config, path);
console.WriteLine($"Variable with name '{ name }' has been removed");
}
}
public YoutubeService(IConfigHandler configHandler)
{
this.configHandler = configHandler;
var config = configHandler.Config;
clientId = config.YoutubeClientId;
clientSecret = config.YoutubeClientSecret;
youtubeApiKey = config.YoutubeApiKey;
channelId = config.YoutubeChannelId;
state = RandomDataBase64url(32);
code_verifier = RandomDataBase64url(32);
code_challenge = Base64urlencodeNoPadding(Sha256(code_verifier));
string youtubeAuthScope = "https://www.googleapis.com/auth/youtube.readonly";
OAuthUrl = $"{authorizationEndpoint}?response_type=code&scope={youtubeAuthScope}&redirect_uri=" +
$"{redirectUrl}&client_id={clientId}&state={state}&code_challenge={code_challenge}" +
$"&code_challenge_method={code_challenge_method}";
var baseUrl = "https://www.googleapis.com/";
client = new RestClient(baseUrl);
}
internal void Execute(IConsole console, IConfigHandler configHandler, IFileSystem fileSystem, IPathResolver pathResolver)
{
if (!configHandler.DoesConfigExist(path))
{
console.WriteLine($"Config '{ path }' does not exist. Type 'help config' in order to see how you create a config file.", IConsole.ContentType.Negative);
return;
}
IConfig config = configHandler.LoadConfig(path);
// Force forward slash
sourcePath = sourcePath.Replace('\\', '/');
targetPath = targetPath.Replace('\\', '/');
string formattedSourcePath = pathResolver.GetAbsoluteResolvedPath(sourcePath, config.Variables);
string formattedTargetPath = pathResolver.GetAbsoluteResolvedPath(targetPath, config.Variables);
if (!force && !fileSystem.File.Exists(formattedSourcePath) && !fileSystem.Directory.Exists(formattedSourcePath))
{
console.WriteLine($"\nThe sourcePath '{sourcePath}' is invalid because it does not exist", IConsole.ContentType.Negative);
return;
}
if (!force && config.LinkList.Any(link => pathResolver.GetAbsoluteResolvedPath(link.targetPath, config.Variables).Equals(formattedTargetPath)))
{
console.WriteLine($"\nThe targetPath '{targetPath}' is invalid because it already exists in config file", IConsole.ContentType.Negative);
return;
}
config.LinkList.Add(new ConfigLink(sourcePath, targetPath, linkType));
configHandler.SaveConfig(config, path);
console.WriteLine($"\nAdded new { linkType.ToString() } link to config file: \n" +
$"Source: '{ sourcePath }'\n" +
$"Target: '{ targetPath }'");
}
internal void TryCreateLink(IConsole console, IConfigHandler configHandler, IFileSystem fileSystem, IPathResolver pathResolver, IConfig config, string sourcePath, string targetBasePath, bool isFile)
{
try {
// Check absolute path regex filter first
if (Regex.IsMatch(pathResolver.GetAbsoluteResolvedPath(sourcePath, config.Variables), absoluteRegexFilter))
{
string fileOrDirectoryName = fileSystem.Path.GetFileName(sourcePath);
// Check file / directory name regex filter second
if (Regex.IsMatch(fileOrDirectoryName, regexFilter))
{
AddLinkCommand addLinkCommand = new AddLinkCommand(
sourcePath,
fileSystem.Path.Combine(targetBasePath, fileOrDirectoryName),
linkType,
path);
addLinkCommand.Execute(console, configHandler, fileSystem, pathResolver);
}
}
} catch (ArgumentException) {
console.WriteLine("Regex provided is invalid!", IConsole.ContentType.Negative);
}
}
internal static extern void RunParser(IConfigHandler factory, String fileName);
public HttpStreamingConfigListener Create(IBucket bucket, IConfigHandler configHandler) =>
new HttpStreamingConfigListener(bucket, _clusterOptions,
_serviceProvider.GetRequiredService <ICouchbaseHttpClientFactory>(), // Get each time so it's not a singleton
configHandler, _logger);
public LoginHandler(ILogger <LoginHandler> logger, IConfigHandler configHandler)
{
_logger = logger;
_configHandler = configHandler;
}
internal static extern void RunParser(IConfigHandler factory, String fileName);
public CreateJsonFile(IFileHandler fileHandler, IConfigHandler configHandler)
{
_fileHandler = fileHandler;
_configHandler = configHandler;
}
public ConfigController(IConfigHandler configHandler)
{
_configHandler = configHandler;
}
private void InitConfig()
{
AddLog("Loading configuration values...");
// _configHandler = new AppConfigHandler();
_configHandler = new JsonConfigHandler();
var config = _configHandler.GetConfig();
_ipChecker = new AwsIpChecker();
IAmazonRoute53 _amazonClient = new AmazonRoute53Client(config.Route53AccessKey, config.Route53SecretKey, RegionEndpoint.EUWest1);
_dnsUpdater = new DnsUpdater(_configHandler, _ipChecker, _amazonClient);
AddLog($"Found {config.DomainList.Count} domain(s)");
foreach (HostedDomainInfo domainInfo in config.DomainList)
{
AddLog($"{domainInfo.DomainName}");
}
if (_timer != null)
{
// Stop to avoid multiple timer_Tick invocations
_timer.Stop();
}
int interval = config.UpdateInterval;
_timer = new System.Windows.Threading.DispatcherTimer();
_timer.Tick += timer_Tick;
_timer.Interval = new TimeSpan(0, interval, 0);
_timer.Start();
AddLog($"Time set to update domains every {interval} minutes");
SetAutoStart();
}
internal void Execute(IConsole console, IConfigHandler configHandler, IFileSystem fileSystem, IPathResolver pathResolver)
{
if (!configHandler.DoesConfigExist(path))
{
console.WriteLine($"Config '{ path }' does not exist. Type 'help config' in order to see how you create a config file.", IConsole.ContentType.Negative);
return;
}
IConfig config = configHandler.LoadConfig(path);
bool isValid = true;
foreach (ConfigLink configLink in config.LinkList)
{
string resolvedSourcePath = pathResolver.GetAbsoluteResolvedPath(configLink.sourcePath, config.Variables);
string resolvedTargetPath = pathResolver.GetAbsoluteResolvedPath(configLink.targetPath, config.Variables);
bool validation1 = ValidateExistence(fileSystem, resolvedSourcePath);
bool validation2 = ValidateLinkType(fileSystem, resolvedSourcePath, configLink.linkType);
bool validation3 = ValidateDuplicate(pathResolver, config, resolvedTargetPath);
if (displayAll || !validation1 || !validation2 || !validation3)
{
console.WriteLine($"\n{ configLink.ToString() }");
isValid = false;
}
if (!validation1 || displayAll)
{
console.WriteLine($"\t# Source path exists: { (validation1 ? "Yes" : "No") }",
validation1
? IConsole.ContentType.Positive
: IConsole.ContentType.Negative);
}
if (!validation2 || displayAll)
{
console.WriteLine($"\t# Link type acceptable: { (validation2 ? "Yes" : "No") }",
validation2
? IConsole.ContentType.Positive
: IConsole.ContentType.Negative);
}
if (!validation3 || displayAll)
{
console.WriteLine($"\t# Duplicate target path exists: { (validation3 ? "False" : "True") }",
validation3
? IConsole.ContentType.Positive
: IConsole.ContentType.Negative);
}
}
if (config.LinkList.Count == 0)
{
console.WriteLine("Config is empty");
}
else if (isValid)
{
console.WriteLine("Config is 100% valid");
}
}
public Publisher(IConfigHandler configHandler)
{
_configHandler = configHandler;
InitializeComponent();
}
