public void CopyAllFilesInADirectory_CopiesTheFiles()
{
_configs = ConfigFileHandler.LoadConfiguration();
List <string> targetFolders = ListParser.GetSection(TV_FOLDERS, _configs);
FileProcessor.CopyAllFilesInADirectory("N:\\Torrents\\complete", targetFolders);
}
static void Main(string[] args)
{
Console.WriteLine("MASTODON FOLLOW BOT");
Console.WriteLine("Please use this for testing purpose");
Console.WriteLine();
//Read Config File
var configFileHandler = new ConfigFileHandler("MastodonFollowBot", "appconfig.json");
var config = GetAppSettings(configFileHandler);
//Launch follow bot
var followBot = new FollowBot(config);
followBot.Run();
Console.ReadLine();
}
private void SaveSettings()
{
string branch = Branch.Text;
string release = Release.Text;
string build = Build.Text;
string serviceTargetPath = ServiceWebsite.Text;
string websiteTargetPath = ClientWebsite.Text;
string crmServiceTargetPath = CrmWebsite.Text;
_configs = ListParser.Set("BRANCH", branch, _configs);
_configs = ListParser.Set("RELEASE", release, _configs);
_configs = ListParser.Set("BUILD", build, _configs);
_configs = ListParser.Set("SERVICE-TARGET-PATH", serviceTargetPath, _configs);
_configs = ListParser.Set("WEBSITE-TARGET-PATH", websiteTargetPath, _configs);
_configs = ListParser.Set("CRM-SERVICE-TARGET-PATH", crmServiceTargetPath, _configs);
ConfigFileHandler.SaveConfiguration(_configs);
}
private static AppSettings GetAppSettings(ConfigFileHandler configFileHandler)
{
try
{
var config = configFileHandler.ReadConfigFile <AppSettings>();
return(config);
}
catch (Exception e)
{
var settings = new AppSettings()
{
Source = new AppAccount(),
Target = new AppAccount(),
};
configFileHandler.WriteConfigFile(settings);
Console.WriteLine("Please set your config file in AppData\\Local\\MastodonFollowBot");
Console.ReadLine();
throw;
}
}
public static void Initialize()
{
configFileHandler = new ConfigFileHandler(ConstDef.WEDO_MSGR_DIR, ConstDef.WEDO_CLIENT_EXE);
serverIp = configFileHandler.GetValue("ServerIp");
socketPortCrm = Convert.ToInt16(configFileHandler.GetValue("SocketPortCrm"));
socketPortFtp = Convert.ToInt16(configFileHandler.GetValue("SocketPortFtp"));
socketPortMsgr = Convert.ToInt16(configFileHandler.GetValue("SocketPortMsgr"));
id = configFileHandler.GetValue("MyId");
extension = configFileHandler.GetValue("PhoneExtension");
pass = configFileHandler.GetValue("MyPass");
customColor = configFileHandler.GetValue("CustomColor");
customFont = configFileHandler.GetValue("CustomFont");
savePass = (configFileHandler.GetValue("SaveMyPass").Equals(CommonDef.TRUE));
noPopOutBound = (configFileHandler.GetValue("NoPopUpOnCallOutBound").Equals(CommonDef.TRUE));
topMost = (configFileHandler.GetValue("TopMost").Equals(CommonDef.TRUE));
noPop = (configFileHandler.GetValue("NoPopUpOnCall").Equals(CommonDef.TRUE));
autoStart = (configFileHandler.GetValue("AutoStart").Equals(CommonDef.TRUE));
dbServerIp = configFileHandler.GetValue("DbServerIp");
dbPort = Convert.ToInt16(configFileHandler.GetValue("DbPort"));
promotionUrl = configFileHandler.GetValue("PromotionUrl");
}
private void Window_Loaded(object sender, RoutedEventArgs e)
{
_configs = ConfigFileHandler.LoadConfiguration();
LoadSettings();
}
private void LoadContentPacks(IEnumerable <RawContentPack> contentPacks)
{
// load content packs
ConfigFileHandler configFileHandler = new ConfigFileHandler(this.ConfigFileName, this.ParseCommaDelimitedField, (pack, label, reason) => this.Monitor.Log($"Ignored {pack.Manifest.Name} > {label}: {reason}"));
foreach (RawContentPack current in contentPacks)
{
this.Monitor.VerboseLog($"Loading content pack '{current.Manifest.Name}'...");
try
{
ContentConfig content = current.Content;
// load tokens
ModTokenContext tokenContext = this.TokenManager.TrackLocalTokens(current.ManagedPack.Pack);
{
// load config.json
InvariantDictionary <ConfigField> config = configFileHandler.Read(current.ManagedPack, content.ConfigSchema);
configFileHandler.Save(current.ManagedPack, config, this.Helper);
if (config.Any())
{
this.Monitor.VerboseLog($" found config.json with {config.Count} fields...");
}
// load config tokens
foreach (KeyValuePair <string, ConfigField> pair in config)
{
ConfigField field = pair.Value;
tokenContext.Add(new ImmutableToken(pair.Key, field.Value, allowedValues: field.AllowValues, canHaveMultipleValues: field.AllowMultiple));
}
// load dynamic tokens
foreach (DynamicTokenConfig entry in content.DynamicTokens ?? new DynamicTokenConfig[0])
{
void LogSkip(string reason) => this.Monitor.Log($"Ignored {current.Manifest.Name} > dynamic token '{entry.Name}': {reason}", LogLevel.Warn);
// validate token key
if (!TokenName.TryParse(entry.Name, out TokenName name))
{
LogSkip("the name could not be parsed as a token key.");
continue;
}
if (name.HasSubkey())
{
LogSkip("the token name cannot contain a subkey (:).");
continue;
}
if (name.TryGetConditionType(out ConditionType conflictingType))
{
LogSkip($"conflicts with global token '{conflictingType}'.");
continue;
}
if (config.ContainsKey(name.Key))
{
LogSkip($"conflicts with player config token '{conflictingType}'.");
continue;
}
// parse values
InvariantHashSet values = entry.Value != null?this.ParseCommaDelimitedField(entry.Value) : new InvariantHashSet();
// parse conditions
ConditionDictionary conditions;
{
if (!this.TryParseConditions(entry.When, tokenContext, current.Migrator, out conditions, out string error))
{
this.Monitor.Log($"Ignored {current.Manifest.Name} > '{entry.Name}' token: its {nameof(DynamicTokenConfig.When)} field is invalid: {error}.", LogLevel.Warn);
continue;
}
}
// add token
tokenContext.Add(new DynamicTokenValue(name, values, conditions));
}
}
// load patches
content.Changes = this.SplitPatches(content.Changes).ToArray();
this.NamePatches(current.ManagedPack, content.Changes);
foreach (PatchConfig patch in content.Changes)
{
this.Monitor.VerboseLog($" loading {patch.LogName}...");
this.LoadPatch(current.ManagedPack, patch, tokenContext, current.Migrator, logSkip: reasonPhrase => this.Monitor.Log($"Ignored {patch.LogName}: {reasonPhrase}", LogLevel.Warn));
}
}
catch (Exception ex)
{
this.Monitor.Log($"Error loading content pack '{current.Manifest.Name}'. Technical details:\n{ex}", LogLevel.Error);
continue;
}
}
}
private void LoadContentPacks(IEnumerable <RawContentPack> contentPacks)
{
// load content packs
ConfigFileHandler configFileHandler = new ConfigFileHandler(this.ConfigFileName, this.ParseCommaDelimitedField, (pack, label, reason) => this.Monitor.Log($"Ignored {pack.Manifest.Name} > {label}: {reason}", LogLevel.Warn));
foreach (RawContentPack current in contentPacks)
{
this.Monitor.VerboseLog($"Loading content pack '{current.Manifest.Name}'...");
try
{
ContentConfig content = current.Content;
// load tokens
ModTokenContext modContext = this.TokenManager.TrackLocalTokens(current.ManagedPack.Pack);
{
// load config.json
InvariantDictionary <ConfigField> config = configFileHandler.Read(current.ManagedPack, content.ConfigSchema, current.Content.Format);
configFileHandler.Save(current.ManagedPack, config, this.Helper);
if (config.Any())
{
this.Monitor.VerboseLog($" found config.json with {config.Count} fields...");
}
// load config tokens
foreach (KeyValuePair <string, ConfigField> pair in config)
{
ConfigField field = pair.Value;
modContext.Add(new ImmutableToken(pair.Key, field.Value, scope: current.Manifest.UniqueID, allowedValues: field.AllowValues, canHaveMultipleValues: field.AllowMultiple));
}
// load dynamic tokens
foreach (DynamicTokenConfig entry in content.DynamicTokens ?? new DynamicTokenConfig[0])
{
void LogSkip(string reason) => this.Monitor.Log($"Ignored {current.Manifest.Name} > dynamic token '{entry.Name}': {reason}", LogLevel.Warn);
// validate token key
if (string.IsNullOrWhiteSpace(entry.Name))
{
LogSkip("the token name can't be empty.");
continue;
}
if (entry.Name.Contains(InternalConstants.InputArgSeparator))
{
LogSkip($"the token name can't have an input argument ({InternalConstants.InputArgSeparator} character).");
continue;
}
if (Enum.TryParse <ConditionType>(entry.Name, true, out _))
{
LogSkip("the token name is already used by a global token.");
continue;
}
if (config.ContainsKey(entry.Name))
{
LogSkip("the token name is already used by a config token.");
continue;
}
// parse values
ITokenString values;
if (!string.IsNullOrWhiteSpace(entry.Value))
{
if (!this.TryParseStringTokens(entry.Value, modContext, current.Migrator, out string valueError, out values))
{
LogSkip($"the token value is invalid: {valueError}");
continue;
}
}
else
{
values = new LiteralString("");
}
// parse conditions
IList <Condition> conditions;
{
if (!this.TryParseConditions(entry.When, modContext, current.Migrator, out conditions, out string conditionError))
{
this.Monitor.Log($"Ignored {current.Manifest.Name} > '{entry.Name}' token: its {nameof(DynamicTokenConfig.When)} field is invalid: {conditionError}.", LogLevel.Warn);
continue;
}
}
// add token
modContext.Add(new DynamicTokenValue(entry.Name, values, conditions));
}
}
// load patches
IContext patchTokenContext = new SinglePatchContext(current.Manifest.UniqueID, parentContext: modContext); // make patch tokens available to patches
content.Changes = this.SplitPatches(content.Changes).ToArray();
this.NamePatches(current.ManagedPack, content.Changes);
foreach (PatchConfig patch in content.Changes)
{
this.Monitor.VerboseLog($" loading {patch.LogName}...");
this.LoadPatch(current.ManagedPack, patch, patchTokenContext, current.Migrator, logSkip: reasonPhrase => this.Monitor.Log($"Ignored {patch.LogName}: {reasonPhrase}", LogLevel.Warn));
}
}
catch (Exception ex)
{
this.Monitor.Log($"Error loading content pack '{current.Manifest.Name}'. Technical details:\n{ex}", LogLevel.Error);
continue;
}
}
}
private void LoadContentPacks()
{
ConfigFileHandler configFileHandler = new ConfigFileHandler(this.ConfigFileName, this.PatchManager.ParseCommaDelimitedField, (pack, label, reason) => this.Monitor.Log($"Ignored {pack.Manifest.Name} > {label}: {reason}"));
foreach (IContentPack pack in this.Helper.GetContentPacks())
{
this.VerboseLog($"Loading content pack '{pack.Manifest.Name}'...");
try
{
// read changes file
ContentConfig content = pack.ReadJsonFile <ContentConfig>(this.PatchFileName);
if (content == null)
{
this.Monitor.Log($"Ignored content pack '{pack.Manifest.Name}' because it has no {this.PatchFileName} file.", LogLevel.Error);
continue;
}
if (content.Format == null || content.Changes == null)
{
this.Monitor.Log($"Ignored content pack '{pack.Manifest.Name}' because it doesn't specify the required {nameof(ContentConfig.Format)} or {nameof(ContentConfig.Changes)} fields.", LogLevel.Error);
continue;
}
// validate version
if (!this.SupportedFormatVersions.Contains(content.Format.ToString()))
{
this.Monitor.Log($"Ignored content pack '{pack.Manifest.Name}' because it uses unsupported format {content.Format} (supported version: {string.Join(", ", this.SupportedFormatVersions)}).", LogLevel.Error);
continue;
}
// load config.json
InvariantDictionary <ConfigField> config = configFileHandler.Read(pack, content.ConfigSchema);
configFileHandler.Save(pack, config, this.Helper);
if (config.Any())
{
this.VerboseLog($" found config.json with {config.Count} fields...");
}
// validate features
if (content.Format.IsOlderThan("1.3"))
{
if (config.Any())
{
this.Monitor.Log($"Loading content pack '{pack.Manifest.Name}' failed. It specifies format version {content.Format}, but uses the {nameof(ContentConfig.ConfigSchema)} field added in 1.3.", LogLevel.Error);
continue;
}
if (content.Changes.Any(p => p.FromFile != null && p.FromFile.Contains("{{")))
{
this.Monitor.Log($"Loading content pack '{pack.Manifest.Name}' failed. It specifies format version {content.Format}, but uses the {{{{token}}}} feature added in 1.3.", LogLevel.Error);
continue;
}
if (content.Changes.Any(p => p.When != null && p.When.Any()))
{
this.Monitor.Log($"Loading content pack '{pack.Manifest.Name}' failed. It specifies format version {content.Format}, but uses the condition feature ({nameof(ContentConfig.Changes)}.{nameof(PatchConfig.When)} field) added in 1.3.", LogLevel.Error);
continue;
}
}
// load patches
this.NamePatches(pack, content.Changes);
foreach (PatchConfig patch in content.Changes)
{
this.VerboseLog($" loading {patch.LogName}...");
this.LoadPatch(pack, patch, config, logSkip: reasonPhrase => this.Monitor.Log($"Ignored {patch.LogName}: {reasonPhrase}", LogLevel.Warn));
}
}
catch (Exception ex)
{
this.Monitor.Log($"Error loading content pack '{pack.Manifest.Name}'. Technical details:\n{ex}", LogLevel.Error);
}
}
}
public ServerConfigController()
{
configFileHandler = new ConfigFileHandler(ConstDef.WEDO_SERVER_DIR, ConstDef.WEDO_SERVER_EXE);
}
