public Command CreateCommand(SlateBotController controller, CommandFile file)
{
bool moduleParsed = Enum.TryParse(file.Module, out ModuleType module);
if (!moduleParsed)
{
module = ModuleType.General;
}
var dictionary = file.ExtraData;
YouTubeCommandType youTubeCommandType = YouTubeCommandType.YouTube;
bool valid = dictionary.Any();
if (valid)
{
bool hasMirrorType = file.ExtraData.TryGetValue("YouTubeType", out IEnumerable <string> youTubeCommandTypeStr) > 0;
if (hasMirrorType)
{
valid = Enum.TryParse(youTubeCommandTypeStr.First(), out youTubeCommandType);
}
else
{
valid = false;
}
}
else
{
valid = false;
}
return(valid ? (new YouTubeCommand(controller.ErrorLogger, controller.waitHandler, controller, controller.languageHandler, file.Aliases, file.Examples, file.Help, module, youTubeCommandType)) : null);
}
public Command CreateCommand(SlateBotController controller, CommandFile file)
{
bool moduleParsed = Enum.TryParse(file.Module, out ModuleType module);
if (!moduleParsed)
{
module = ModuleType.General;
}
var dictionary = file.ExtraData;
string delimiter = "";
bool valid = dictionary.Any();
if (valid)
{
bool has = file.ExtraData.TryGetValue("Delimiter", out IEnumerable <string> delimiterStr) > 0;
if (has)
{
delimiter = delimiterStr.First();
}
else
{
valid = false;
}
}
else
{
valid = false;
}
return(valid ? (new ChooseCommand(controller.languageHandler, file.Aliases, file.Examples, file.Help, module, delimiter)) : null);
}
public async Task <List <Commands> > GetCommandsAsync(string category)
{
List <Commands> commands = null;
string requestUri = _config.GetSection(AppSettingsSection.CategoryJsonPath).Get <string>().Replace("{category}", category);
var client = _httpClientFactory.CreateClient();
client.DefaultRequestHeaders.Add("User-Agent", "AllCommands");
var response = await client.GetAsync(requestUri);
if (response.IsSuccessStatusCode)
{
var content = await response.Content.ReadAsStringAsync();
JToken contentJToken = JToken.Parse(content);
if (contentJToken.SelectToken("content") != null)
{
byte[] data = Convert.FromBase64String(contentJToken.SelectToken("content").Value <string>());
string decodedString = Encoding.UTF8.GetString(data);
CommandFile commandFile = JsonConvert.DeserializeObject <CommandFile>(decodedString);
commands = commandFile?.Release?.Commands.ToList();
}
return(commands ?? new List <Commands>());
}
else
{
_logger.LogError(response.ReasonPhrase);
return(null);
}
}
public Command CreateCommand(SlateBotController controller, CommandFile file)
{
bool moduleParsed = Enum.TryParse(file.Module, out ModuleType module);
if (!moduleParsed)
{
module = ModuleType.Image;
}
var dictionary = file.ExtraData;
MirrorType mirrorType = MirrorType.LeftOntoRight;
bool valid = dictionary.Any();
if (valid)
{
bool hasMirrorType = file.ExtraData.TryGetValue("MirrorType", out IEnumerable <string> mirrorTypeStr) > 0;
if (hasMirrorType)
{
valid = Enum.TryParse(mirrorTypeStr.First(), out mirrorType);
}
else
{
valid = false;
}
}
else
{
valid = false;
}
return(valid ? (new ObaboCommand(controller.ErrorLogger, controller.waitHandler, controller, controller.languageHandler, file.Aliases, file.Examples, file.Help, module, mirrorType)) : null);
}
public Command CreateCommand(SlateBotController controller, CommandFile file)
{
bool moduleParsed = Enum.TryParse(file.Module, out ModuleType module);
if (!moduleParsed)
{
module = ModuleType.General;
}
bool requiresSymbolParsed = bool.TryParse(file.RequiresSymbol, out bool requiresSymbol);
if (!requiresSymbolParsed)
{
requiresSymbol = true;
}
var dictionary = file.ExtraData;
ResponseType responseType = ResponseType.Default;
string choiceFormat = "";
string[][] choices;
if (dictionary.Any())
{
bool hasResponseType = file.ExtraData.TryGetValue("ResponseType", out IEnumerable <string> responseTypeStr) > 0;
if (hasResponseType)
{
Enum.TryParse(responseTypeStr.First(), out responseType);
// If not parsed then "Default" will be used.
}
bool hasChoiceFormat = file.ExtraData.TryGetValue("ChoiceFormat", out IEnumerable <string> choiceFormats) > 0;
if (hasChoiceFormat)
{
choiceFormat = choiceFormats.First();
}
List <List <string> > temp = new List <List <string> >();
foreach (var pair in file.ExtraData)
{
if (pair.Key.Length == 1)
{
int section = pair.Key[0] - 'A';
if (temp.Count <= section)
{
temp.Add(new List <string>());
}
temp[section].Add(pair.Value);
}
}
choices = temp.Select(l => l.ToArray()).ToArray();
}
else
{
choices = new string[0][];
}
return(new ResponseMessageListCommand(file.Aliases, choices, choiceFormat, file.Examples, file.Help, module, responseType, requiresSymbol));
}
public void CommandFile_ByPath_TestLength()
{
var file = new CommandFile("ABC", testFilePath, null, "DEF", true);
Console.WriteLine(file.Length);
Assert.AreEqual(testFileSize, file.Length);
Assert.IsTrue(file.Aml.Contains(testFileSize.ToString()));
Console.WriteLine(file.Aml);
}
public Command CreateCommand(SlateBotController controller, CommandFile file)
{
bool moduleParsed = Enum.TryParse(file.Module, out ModuleType module);
if (!moduleParsed)
{
module = ModuleType.Translation;
}
return(new TranslateCommand(controller, controller.ErrorLogger, controller.languageHandler, file.Aliases, file.Examples, file.Help, module));
}
public Command CreateCommand(SlateBotController controller, CommandFile file)
{
bool moduleParsed = Enum.TryParse(file.Module, out ModuleType module);
if (!moduleParsed)
{
module = ModuleType.General;
}
return(new PokemonTypeCommand(controller.languageHandler, file.Aliases, file.Examples, file.Help, module));
}
public Command CreateCommand(SlateBotController controller, CommandFile file)
{
bool moduleParsed = Enum.TryParse(file.Module, out ModuleType module);
if (!moduleParsed)
{
module = ModuleType.BotAdmin;
}
return(new SetNameCommand(controller.client, controller.languageHandler, file.Aliases, file.Examples, file.Help, module));
}
public void CommandFile_ByPathAndStream_TestLength()
{
using (var stream = File.OpenRead(testFilePath))
{
var file = new CommandFile("ABC", testFilePath, stream, "DEF", true);
Console.WriteLine(file.Length);
Assert.AreEqual(testFileSize, file.Length);
Assert.IsTrue(file.Aml.Contains(testFileSize.ToString()));
Console.WriteLine(file.Aml);
}
}
public ActionResult Edit(int commandFileId = 0, int providerId = 0)
{
CommandFile commandFile = null;
using (var ae = new AvtoritetEntities())
{
commandFile = ae.CommandFile.FirstOrDefault(t => t.CommandFileId == commandFileId) ?? new CommandFile();
ViewBag.ProviderId = providerId;
return(View(commandFile));
}
}
public Command CreateCommand(SlateBotController controller, CommandFile file)
{
bool moduleParsed = Enum.TryParse(file.Module, out ModuleType module);
if (!moduleParsed)
{
module = ModuleType.General;
}
var dictionary = file.ExtraData;
bool ignoreCase = true;
bool reverse = false;
bool doTTS = false;
string[] old;
string[] @new;
Dictionary <string, string> replacements = new Dictionary <string, string>();
if (dictionary.Any())
{
bool hasIgnoreCase = file.ExtraData.TryGetValue("IgnoreCase", out IEnumerable <string> ignoreCaseStr) > 0;
if (hasIgnoreCase)
{
ignoreCase = bool.Parse(ignoreCaseStr.First());
}
bool hasReverse = file.ExtraData.TryGetValue("Reverse", out IEnumerable <string> reverseStr) > 0;
if (hasReverse)
{
reverse = bool.Parse(reverseStr.First());
}
bool hasDoTTS = file.ExtraData.TryGetValue("DoTTS", out IEnumerable <string> doTTSStr) > 0;
if (hasDoTTS)
{
doTTS = bool.Parse(doTTSStr.First());
}
old = file.ExtraData.Where(pair => pair.Key.Equals("Old")).Select(pair => pair.Value).ToArray();
@new = file.ExtraData.Where(pair => pair.Key.Equals("New")).Select(pair => pair.Value).ToArray();
if (old.Length == @new.Length)
{
for (int i = 0; i < old.Length; i++)
{
replacements.Add(old[i], @new[i]);
}
}
}
return(new ReplaceCommand(file.Aliases, file.Examples, file.Help, module, replacements, ignoreCase, reverse, doTTS));
}
public Command CreateCommand(SlateBotController controller, CommandFile file)
{
bool moduleParsed = Enum.TryParse(file.Module, out ModuleType module);
if (!moduleParsed)
{
module = ModuleType.General;
}
var dictionary = file.ExtraData;
string url, formattedResponseURL, jsonProperty;
if (dictionary.Any())
{
bool hasURL = file.ExtraData.TryGetValue("URL", out IEnumerable <string> urlStr) > 0;
if (hasURL)
{
url = urlStr.First();
}
else
{
url = null;
}
bool hasFormattedResponseURL = file.ExtraData.TryGetValue("FormattedResponseURL", out IEnumerable <string> formattedResponseURLStr) > 0;
if (hasFormattedResponseURL)
{
formattedResponseURL = formattedResponseURLStr.First();
}
else
{
formattedResponseURL = null;
}
bool hasJSONProperty = file.ExtraData.TryGetValue("JSONProperty", out IEnumerable <string> jsonPropertyStr) > 0;
if (hasJSONProperty)
{
jsonProperty = jsonPropertyStr.First();
}
else
{
jsonProperty = null;
}
}
else
{
throw new InvalidOperationException("XML for PullImageCommand is insufficient.");
}
return(new PullImageCommand(controller.languageHandler, controller, file.Aliases, file.Examples, file.Help, module, url, formattedResponseURL, jsonProperty));
}
public Command CreateCommand(SlateBotController controller, CommandFile file)
{
bool moduleParsed = Enum.TryParse(file.Module, out ModuleType module);
if (!moduleParsed)
{
module = ModuleType.General;
}
var dictionary = file.ExtraData;
int fromBase = 0;
int toBase = 0;
bool valid = dictionary.Any();
if (valid)
{
bool hasFromBase = file.ExtraData.TryGetValue("FromBase", out IEnumerable <string> fromBaseStr) > 0;
if (hasFromBase)
{
fromBase = int.Parse(fromBaseStr.First());
}
else
{
valid = false;
}
bool hasToBase = file.ExtraData.TryGetValue("ToBase", out IEnumerable <string> toBaseStr) > 0;
if (hasToBase)
{
toBase = int.Parse(toBaseStr.First());
}
else
{
valid = false;
}
}
else
{
valid = false;
}
return(valid ? (new BaseChangeCommand(controller.languageHandler, file.Aliases, file.Examples, file.Help, module, fromBase, toBase)) : null);
}
public Command CreateCommand(SlateBotController controller, CommandFile file)
{
bool moduleParsed = Enum.TryParse(file.Module, out ModuleType module);
if (!moduleParsed)
{
module = ModuleType.General;
}
bool requiresSymbolParsed = bool.TryParse(file.RequiresSymbol, out bool requiresSymbol);
if (!requiresSymbolParsed)
{
requiresSymbol = true;
}
var dictionary = file.ExtraData;
ResponseType responseType = ResponseType.Default;
IEnumerable <string> choices;
if (dictionary.Any())
{
bool hasResponseType = file.ExtraData.TryGetValue("ResponseType", out IEnumerable <string> responseTypeStr) > 0;
if (hasResponseType)
{
Enum.TryParse(responseTypeStr.First(), out responseType);
// If not parsed then "Default" will be used.
}
choices = file.ExtraData.Where(pair => pair.Key.StartsWith("C")).Select(pair => pair.Value);
}
else
{
choices = new string[0];
}
return(new ResponseMessageCommand(file.Aliases, choices, file.Examples, file.Help, module, responseType, requiresSymbol));
}
public ActionResult Edit(int commandFileId, int ProviderId, FormCollection collection)
{
try
{
using (var ae = new AvtoritetEntities())
{
CommandFile newCommandFile = null;
if (commandFileId == 0)
{
newCommandFile = new CommandFile
{
FileName = collection["filename"],
ProviderId = ProviderId,
FileContent = collection["filecontent"]
};
ae.CommandFile.Add(newCommandFile);
}
else
{
newCommandFile = ae.CommandFile.FirstOrDefault(t => t.CommandFileId == commandFileId);
if (newCommandFile != null)
{
newCommandFile.FileName = collection["FileName"];
newCommandFile.FileContent = collection["FileContent"];
}
}
ae.SaveChanges();
return(RedirectToAction("Index", new { ProviderId = ProviderId }));
}
}
catch
{
return(View());
}
}
public Command CreateCommand(SlateBotController controller, CommandFile file)
{
bool moduleParsed = Enum.TryParse(file.Module, out ModuleType module);
if (!moduleParsed)
{
module = ModuleType.Image;
}
var dictionary = file.ExtraData;
string template = null;
Point topLeft = new Point(), topRight = new Point(), bottomLeft = new Point();
bool valid = dictionary.Any();
bool autoPoints = true;
if (valid)
{
bool hasTemplate = file.ExtraData.TryGetValue("Template", out IEnumerable <string> templateStr) > 0;
if (hasTemplate)
{
template = templateStr.First();
}
else
{
valid = false;
}
bool hasTopLeft = file.ExtraData.TryGetValue("TopLeft", out IEnumerable <string> topLeftStr) > 0;
if (hasTopLeft)
{
var topLeftPointArr = topLeftStr.First().Split(',');
topLeft = new Point(int.Parse(topLeftPointArr[0]), int.Parse(topLeftPointArr[1]));
bool hasTopRight = file.ExtraData.TryGetValue("TopRight", out IEnumerable <string> topRightStr) > 0;
if (hasTopRight)
{
var topRightPointArr = topRightStr.First().Split(',');
topRight = new Point(int.Parse(topRightPointArr[0]), int.Parse(topRightPointArr[1]));
bool hasBottomLeft = file.ExtraData.TryGetValue("BottomLeft", out IEnumerable <string> bottomLeftStr) > 0;
if (hasBottomLeft)
{
var bottomLeftPointArr = bottomLeftStr.First().Split(',');
bottomLeft = new Point(int.Parse(bottomLeftPointArr[0]), int.Parse(bottomLeftPointArr[1]));
autoPoints = false;
}
else
{
valid = false;
}
}
else
{
valid = false;
}
}
}
else
{
valid = false;
}
if (valid)
{
string templatePath = template;
if (!Path.IsPathRooted(template))
{
templatePath = Path.Combine(controller.dal.memeFolder, templatePath);
}
if (autoPoints)
{
return(new MemeCommand(controller.ErrorLogger, controller.waitHandler, controller, controller.languageHandler, file.Aliases, file.Examples, file.Help, module, templatePath));
}
else
{
return(new MemeCommand(controller.ErrorLogger, controller.waitHandler, controller, controller.languageHandler, file.Aliases, file.Examples, file.Help, module, templatePath, topLeft, topRight, bottomLeft));
}
}
else
{
return(null);
}
}
public Command CreateCommand(SlateBotController controller, CommandFile _)
{
return(new ReceiveFileCommand(controller.dal, controller.commandHandlerController, controller));
}
private bool ProcessArgs(bool ignoreCommandFile = false)
{
if (!string.IsNullOrEmpty(PocoyoDataFilePath))
{
if (!File.Exists(PocoyoDataFilePath))
{
LogError($"Missing file: {PocoyoDataFilePath}");
return(false);
}
PocoyoData.LoadFromData(PocoyoDataFilePath);
}
if (!ignoreCommandFile)
{
if (!string.IsNullOrEmpty(CommandFile))
{
if (!File.Exists(CommandFile))
{
LogError($"Missing --commands file: {CommandFile}");
return(false);
}
return(false);
}
}
if (Files.Count == 0)
{
LogError($"Missing input files / folders");
return(false);
}
foreach (var filePath in Files)
{
var inputFile = Path.GetFullPath(filePath);
if (Directory.Exists(inputFile))
{
foreach (var csharpFilePath in Directory.EnumerateFiles(inputFile, "*.cs", SearchOption.AllDirectories))
{
var found = InputFiles.FirstOrDefault(item => string.Equals(item, csharpFilePath));
if (found == null)
{
InputFiles.Add(csharpFilePath);
}
}
}
else if (File.Exists(inputFile))
{
var found = InputFiles.FirstOrDefault(item => string.Equals(item, inputFile));
if (found == null)
{
InputFiles.Add(inputFile);
}
}
else
{
LogError($"Invalid file: {inputFile}");
return(false);
}
}
if (string.IsNullOrEmpty(OutputFile))
{
LogError($"Missing --outputFile");
return(false);
}
var outputFilePath = Path.GetFullPath(OutputFile);
var outputFolder = Path.GetDirectoryName(outputFilePath);
Directory.CreateDirectory(outputFolder);
if (Directory.Exists(outputFilePath))
{
OutputFolder = outputFilePath;
}
else
{
if (File.Exists(outputFilePath))
{
File.Delete(outputFilePath);
}
OutputFile = outputFilePath;
}
if (InputFiles.Count == 0)
{
LogError($"Missing input files / folders");
return(false);
}
if (string.IsNullOrEmpty(CommandFile) || !CommandFile.ToLower().EndsWith(".json"))
{
SerializeToJson();
}
return(true);
}
public static List <LogInfo> ExecuteCommand(EngineState s, CodeCommand cmd)
{
List <LogInfo> logs = new List <LogInfo>();
int curDepth = s.CurDepth;
if (CodeCommand.DeprecatedCodeType.Contains(cmd.Type))
{
logs.Add(new LogInfo(LogState.Warning, $"Command [{cmd.Type}] is deprecated"));
}
try
{
switch (cmd.Type)
{
#region 00 Misc
case CodeType.None:
logs.Add(new LogInfo(LogState.Ignore, string.Empty));
break;
case CodeType.Comment:
{
if (s.LogComment)
{
logs.Add(new LogInfo(LogState.Ignore, string.Empty));
}
}
break;
case CodeType.Error:
{
Debug.Assert(cmd.Info.GetType() == typeof(CodeInfo_Error));
CodeInfo_Error info = cmd.Info as CodeInfo_Error;
logs.Add(new LogInfo(LogState.Error, info.ErrorMessage));
}
break;
#endregion
#region 01 File
case CodeType.FileCopy:
logs.AddRange(CommandFile.FileCopy(s, cmd));
break;
case CodeType.FileDelete:
logs.AddRange(CommandFile.FileDelete(s, cmd));
break;
case CodeType.FileRename:
case CodeType.FileMove:
logs.AddRange(CommandFile.FileRename(s, cmd));
break;
case CodeType.FileCreateBlank:
logs.AddRange(CommandFile.FileCreateBlank(s, cmd));
break;
case CodeType.FileSize:
logs.AddRange(CommandFile.FileSize(s, cmd));
break;
case CodeType.FileVersion:
logs.AddRange(CommandFile.FileVersion(s, cmd));
break;
case CodeType.DirCopy:
logs.AddRange(CommandFile.DirCopy(s, cmd));
break;
case CodeType.DirDelete:
logs.AddRange(CommandFile.DirDelete(s, cmd));
break;
case CodeType.DirMove:
logs.AddRange(CommandFile.DirMove(s, cmd));
break;
case CodeType.DirMake:
logs.AddRange(CommandFile.DirMake(s, cmd));
break;
case CodeType.DirSize:
logs.AddRange(CommandFile.DirSize(s, cmd));
break;
case CodeType.PathMove:
logs.AddRange(CommandFile.PathMove(s, cmd));
break;
#endregion
#region 02 Registry
case CodeType.RegHiveLoad:
logs.AddRange(CommandRegistry.RegHiveLoad(s, cmd));
break;
case CodeType.RegHiveUnload:
logs.AddRange(CommandRegistry.RegHiveUnload(s, cmd));
break;
case CodeType.RegRead:
logs.AddRange(CommandRegistry.RegRead(s, cmd));
break;
case CodeType.RegWrite:
logs.AddRange(CommandRegistry.RegWrite(s, cmd));
break;
case CodeType.RegWriteLegacy: // WB082 Compatibility Shim
logs.AddRange(CommandRegistry.RegWriteLegacy(s, cmd));
break;
case CodeType.RegDelete:
logs.AddRange(CommandRegistry.RegDelete(s, cmd));
break;
case CodeType.RegMulti:
logs.AddRange(CommandRegistry.RegMulti(s, cmd));
break;
case CodeType.RegImport:
logs.AddRange(CommandRegistry.RegImport(s, cmd));
break;
case CodeType.RegExport:
logs.AddRange(CommandRegistry.RegExport(s, cmd));
break;
#endregion
#region 03 Text
case CodeType.TXTAddLine:
logs.AddRange(CommandText.TXTAddLine(s, cmd));
break;
case CodeType.TXTAddLineOp:
logs.AddRange(CommandText.TXTAddLineOp(s, cmd));
break;
case CodeType.TXTReplace:
logs.AddRange(CommandText.TXTReplace(s, cmd));
break;
case CodeType.TXTReplaceOp:
logs.AddRange(CommandText.TXTReplaceOp(s, cmd));
break;
case CodeType.TXTDelLine:
logs.AddRange(CommandText.TXTDelLine(s, cmd));
break;
case CodeType.TXTDelLineOp:
logs.AddRange(CommandText.TXTDelLineOp(s, cmd));
break;
case CodeType.TXTDelSpaces:
logs.AddRange(CommandText.TXTDelSpaces(s, cmd));
break;
case CodeType.TXTDelEmptyLines:
logs.AddRange(CommandText.TXTDelEmptyLines(s, cmd));
break;
#endregion
#region 04 INI
case CodeType.INIRead:
logs.AddRange(CommandIni.IniRead(s, cmd));
break;
case CodeType.INIReadOp:
logs.AddRange(CommandIni.IniReadOp(s, cmd));
break;
case CodeType.INIWrite:
logs.AddRange(CommandIni.IniWrite(s, cmd));
break;
case CodeType.INIWriteOp:
logs.AddRange(CommandIni.IniWriteOp(s, cmd));
break;
case CodeType.INIDelete:
logs.AddRange(CommandIni.IniDelete(s, cmd));
break;
case CodeType.INIDeleteOp:
logs.AddRange(CommandIni.IniDeleteOp(s, cmd));
break;
case CodeType.INIReadSection:
logs.AddRange(CommandIni.IniReadSection(s, cmd));
break;
case CodeType.INIReadSectionOp:
logs.AddRange(CommandIni.IniReadSectionOp(s, cmd));
break;
case CodeType.INIAddSection:
logs.AddRange(CommandIni.IniAddSection(s, cmd));
break;
case CodeType.INIAddSectionOp:
logs.AddRange(CommandIni.IniAddSectionOp(s, cmd));
break;
case CodeType.INIDeleteSection:
logs.AddRange(CommandIni.IniDeleteSection(s, cmd));
break;
case CodeType.INIDeleteSectionOp:
logs.AddRange(CommandIni.IniDeleteSectionOp(s, cmd));
break;
case CodeType.INIWriteTextLine:
logs.AddRange(CommandIni.IniWriteTextLine(s, cmd));
break;
case CodeType.INIWriteTextLineOp:
logs.AddRange(CommandIni.IniWriteTextLineOp(s, cmd));
break;
case CodeType.INIMerge:
logs.AddRange(CommandIni.IniMerge(s, cmd));
break;
#endregion
#region 05 Archive
case CodeType.Compress:
logs.AddRange(CommandArchive.Compress(s, cmd));
break;
case CodeType.Decompress:
logs.AddRange(CommandArchive.Decompress(s, cmd));
break;
case CodeType.Expand:
logs.AddRange(CommandArchive.Expand(s, cmd));
break;
case CodeType.CopyOrExpand:
logs.AddRange(CommandArchive.CopyOrExpand(s, cmd));
break;
#endregion
#region 06 Network
case CodeType.WebGet:
case CodeType.WebGetIfNotExist: // Deprecated
logs.AddRange(CommandNetwork.WebGet(s, cmd));
break;
#endregion
#region 07 Plugin
case CodeType.ExtractFile:
logs.AddRange(CommandPlugin.ExtractFile(s, cmd));
break;
case CodeType.ExtractAndRun:
logs.AddRange(CommandPlugin.ExtractAndRun(s, cmd));
break;
case CodeType.ExtractAllFiles:
logs.AddRange(CommandPlugin.ExtractAllFiles(s, cmd));
break;
case CodeType.Encode:
logs.AddRange(CommandPlugin.Encode(s, cmd));
break;
#endregion
#region 08 Interface
case CodeType.Visible:
logs.AddRange(CommandInterface.Visible(s, cmd));
break;
case CodeType.VisibleOp:
logs.AddRange(CommandInterface.VisibleOp(s, cmd));
break;
case CodeType.Message:
logs.AddRange(CommandInterface.Message(s, cmd));
break;
case CodeType.Echo:
logs.AddRange(CommandInterface.Echo(s, cmd));
break;
case CodeType.EchoFile:
logs.AddRange(CommandInterface.EchoFile(s, cmd));
break;
case CodeType.UserInput:
logs.AddRange(CommandInterface.UserInput(s, cmd));
break;
case CodeType.AddInterface:
logs.AddRange(CommandInterface.AddInterface(s, cmd));
break;
#endregion
#region 09 Hash
case CodeType.Hash:
logs.AddRange(CommandHash.Hash(s, cmd));
break;
#endregion
#region 10 String
case CodeType.StrFormat:
logs.AddRange(CommandString.StrFormat(s, cmd));
break;
#endregion
#region 11 Math
case CodeType.Math:
logs.AddRange(CommandMath.Math(s, cmd));
break;
#endregion
#region 12 System
case CodeType.System:
logs.AddRange(CommandSystem.SystemCmd(s, cmd));
break;
case CodeType.ShellExecute:
case CodeType.ShellExecuteEx:
case CodeType.ShellExecuteDelete:
case CodeType.ShellExecuteSlow:
logs.AddRange(CommandSystem.ShellExecute(s, cmd));
break;
#endregion
#region 13 Branch
case CodeType.Run:
case CodeType.Exec:
CommandBranch.RunExec(s, cmd);
break;
case CodeType.Loop:
CommandBranch.Loop(s, cmd);
break;
case CodeType.If:
CommandBranch.If(s, cmd);
break;
case CodeType.Else:
CommandBranch.Else(s, cmd);
break;
case CodeType.Begin:
throw new InternalParserException("CodeParser Error");
case CodeType.End:
throw new InternalParserException("CodeParser Error");
#endregion
#region 14 Control
case CodeType.Set:
logs.AddRange(CommandControl.Set(s, cmd));
break;
case CodeType.SetMacro:
logs.AddRange(CommandControl.SetMacro(s, cmd));
break;
case CodeType.AddVariables:
logs.AddRange(CommandControl.AddVariables(s, cmd));
break;
case CodeType.Exit:
logs.AddRange(CommandControl.Exit(s, cmd));
break;
case CodeType.Halt:
logs.AddRange(CommandControl.Halt(s, cmd));
break;
case CodeType.Wait:
logs.AddRange(CommandControl.Wait(s, cmd));
break;
case CodeType.Beep:
logs.AddRange(CommandControl.Beep(s, cmd));
break;
case CodeType.GetParam:
logs.AddRange(CommandControl.GetParam(s, cmd));
break;
case CodeType.PackParam:
logs.AddRange(CommandControl.PackParam(s, cmd));
break;
#endregion
#region 15 External Macro
case CodeType.Macro:
CommandMacro.Macro(s, cmd);
break;
#endregion
#region Error
// Error
default:
logs.Add(new LogInfo(LogState.Error, $"Cannot execute [{cmd.Type}] command"));
break;
#endregion
}
}
catch (CriticalErrorException)
{ // Stop Building
logs.Add(new LogInfo(LogState.CriticalError, "Critical Error!", cmd, curDepth));
throw new CriticalErrorException();
}
catch (InvalidCodeCommandException e)
{
logs.Add(new LogInfo(LogState.Error, e, e.Cmd, curDepth));
}
catch (Exception e)
{
logs.Add(new LogInfo(LogState.Error, e, cmd, curDepth));
}
// If ErrorOffCount is on, ignore LogState.Error and LogState.Warning
ProcessErrorOff(s, cmd, logs);
// Stop build on error
if (StopBuildOnError)
{
if (0 < logs.Count(x => x.State == LogState.Error))
{
s.ErrorHaltFlag = true;
}
}
s.Logger.Build_Write(s, LogInfo.AddCommandDepth(logs, cmd, curDepth));
// Increase only if cmd resides in CurrentPlugin.
// So if a setion is from Macro, it will not be count.
if (!s.ProcessedSectionHashes.Contains(cmd.Addr.Section.GetHashCode()) && s.CurrentPlugin.Equals(cmd.Addr.Plugin))
{
s.MainViewModel.BuildPluginProgressBarValue += 1;
}
// Return logs, used in unit test
return(logs);
}
