private async Task TryRunCommand(SocketGuild guild, ISocketMessageChannel channel, IUserMessage message)
{
if (channel is IDMChannel && message.Content.StartsWith(DefaultPrefix, StringComparison.Ordinal))
{
var sw = Stopwatch.StartNew();
ExecuteCommandResult result = await ExecuteCommandAsync(new CommandContext(_client, message),
message.Content[DefaultPrefix.Length..], _services, MultiMatchHandling.Best)
private static ExecuteCommandResult RunTexturePacker(string pngFilesDir, string outputPngFile, string outputDataFile, List <string> arg)
{
List <string> defaultPar = new List <string>()
{
"--format unity",
"--trim-mode Trim",
"--disable-rotation",
"--trim-sprite-names",
"--reduce-border-artifacts",
"--algorithm MaxRects",
};
foreach (string s in arg)
{
defaultPar.Add(s);
}
#if UNITY_IOS
string texturePackerExe = "/usr/local/bin/TexturePacker";
#else
string texturePackerExe = FileTools.getProjectPath("CommonTool/TexturePacker/TexturePacker.exe");
#endif
defaultPar.Add(string.Format("--sheet \"{0}\" --data \"{1}\"", outputPngFile, outputDataFile));
defaultPar.Add(pngFilesDir);
string argStr = string.Join(" ", defaultPar.ToArray());
ExecuteCommandResult result = XGEditorUtils.excute(texturePackerExe, argStr);
return(result);
}
private static CheckBindingResult ParseCheckBind(ExecuteCommandResult executionResult)
{
if (executionResult.ExitCode == 1)
{
return new CheckBindingResult {
Status = CheckBindingStatus.Empty
}
}
;
var matches = GuidPattern.Matches(executionResult.Output);
if (matches.Count > 0)
{
return(new CheckBindingResult
{
Status = CheckBindingStatus.Binded,
BindedAppliction = matches[0].Value
});
}
return(new CheckBindingResult {
Status = CheckBindingStatus.Error
});
}
// Execute a command using text input from the user
public static void ExecuteUserCommandAsync(string text, Action <ExecuteCommandResult> onComplete)
{
var result = new ExecuteCommandResult();
result.Text = text;
Async.DoWork(() => Thread_ExecuteUserCommand(result), () => onComplete(result));
}
private async Task CommandOnError(ExecuteCommandResult result)
{
if (result.Context.Channel is not IDMChannel && !(await _config.GetGuildConfigAsync(result.Context.Guild.Id)).ShowHelpOnError)
{
return;
}
string errorMessage;
var showUsage = true;
var showOptions = true;
switch (result.Result.Error)
{
case CommandError.UnmetPrecondition:
showUsage = false;
showOptions = false;
if (result.Result.ErrorReason.Contains("context", StringComparison.Ordinal))
{
errorMessage = "This command can only be run in Servers";
}
else if (result.Result.ErrorReason.Contains("permissions"))
{
errorMessage = result.Result.ErrorReason.Replace("guild", "server", StringComparison.Ordinal);
}
else
{
errorMessage = result.Result.ErrorReason;
}
break;
case CommandError.BadArgCount:
errorMessage = result.Result.ErrorReason;
break;
case CommandError.ObjectNotFound:
showUsage = false;
showOptions = false;
errorMessage = result.Result.ErrorReason;
break;
case CommandError.ParseFailed:
errorMessage = "Invalid arguments provided.";
break;
default:
return;
}
if (result.Context.Channel is IDMChannel)
{
await SendErrorInfo(result, Roki.Properties.Prefix, errorMessage, showUsage, showOptions);
}
else
{
await SendErrorInfo(result, await _config.GetGuildPrefix(result.Context.Guild.Id), errorMessage, showUsage, showOptions);
}
}
static void Thread_ExecuteUserCommand(ExecuteCommandResult result)
{
try
{
result.Success = ExecuteUserCommand(result.Text);
}
catch (Exception ex)
{
result.Exception = ex;
}
}
private async Task LogSuccessfulExecution(SocketUserMessage usrMsg, ExecuteCommandResult exec, SocketTextChannel channel, int ticks)
{
await CommandExecuted(usrMsg, exec.CommandInfo).ConfigureAwait(false);
_log.Info("Command Executed after {4}s\n\t" +
"User: {0}\n\t" +
"Server: {1}\n\t" +
"Channel: {2}\n\t" +
"Message: {3}",
usrMsg.Author + " [" + usrMsg.Author.Id + "]", // {0}
(channel == null ? "PRIVATE" : channel.Guild.Name + " [" + channel.Guild.Id + "]"), // {1}
(channel == null ? "PRIVATE" : channel.Name + " [" + channel.Id + "]"), // {2}
usrMsg.Content, // {3}
ticks * oneThousandth);
}
private void LogErroredExecution(SocketUserMessage usrMsg, ExecuteCommandResult exec, SocketTextChannel channel, int ticks)
{
_log.Warn("Command Errored after {5}s\n\t" +
"User: {0}\n\t" +
"Server: {1}\n\t" +
"Channel: {2}\n\t" +
"Message: {3}\n\t" +
"Error: {4}",
usrMsg.Author + " [" + usrMsg.Author.Id + "]", // {0}
(channel == null ? "PRIVATE" : channel.Guild.Name + " [" + channel.Guild.Id + "]"), // {1}
(channel == null ? "PRIVATE" : channel.Name + " [" + channel.Id + "]"), // {2}
usrMsg.Content, // {3}
exec.Result.ErrorReason, // {4}
ticks * oneThousandth // {5}
);
}
protected override async Task <ExecuteCommandResult <IEvent> > ExecuteCommand(IEvent[] given, ICommand cmd)
{
var repository = new BDDAggregateRepository();
repository.Preload(cmd.Id, given);
var svc = new PersonAggregateInteractor(repository); //inject interactor specific dependencies here
await svc.Execute(cmd);
var publishedEvents = svc.GetPublishedEvents();
var arr = (repository.Appended != null) ? repository.Appended.Cast <IEvent>().ToArray() : null;
var res = new ExecuteCommandResult <IEvent> {
ProducedEvents = arr ?? new IEvent[0], PublishedEvents = publishedEvents.Cast <IEvent>().ToArray()
};
return(res);
}
private Task LogSuccessfulExecution(IUserMessage usrMsg, ExecuteCommandResult exec, ITextChannel channel, int exec1, int exec2, int exec3, int total)
{
_log.Info("Command Executed after {4}/{5}/{6}/{7}s\n\t" +
"User: {0}\n\t" +
"Server: {1}\n\t" +
"Channel: {2}\n\t" +
"Message: {3}",
usrMsg.Author + " [" + usrMsg.Author.Id + "]", // {0}
(channel == null ? "PRIVATE" : channel.Guild.Name + " [" + channel.Guild.Id + "]"), // {1}
(channel == null ? "PRIVATE" : channel.Name + " [" + channel.Id + "]"), // {2}
usrMsg.Content, // {3}
exec1 * _oneThousandth, // {4}
exec2 * _oneThousandth, // {5}
exec3 * _oneThousandth, // {6}
total * _oneThousandth // {7}
);
return(Task.CompletedTask);
}
private void LogErroredExecution(IUserMessage usrMsg, ExecuteCommandResult exec, ITextChannel channel, int exec1, int exec2, int exec3, int total)
{
_log.Warn("Command Errored after {5}/{6}/{7}/{8}s\n\t" +
"User: {0}\n\t" +
"Server: {1}\n\t" +
"Channel: {2}\n\t" +
"Message: {3}\n\t" +
"Error: {4}",
usrMsg.Author + " [" + usrMsg.Author.Id + "]", // {0}
(channel == null ? "PRIVATE" : channel.Guild.Name + " [" + channel.Guild.Id + "]"), // {1}
(channel == null ? "PRIVATE" : channel.Name + " [" + channel.Id + "]"), // {2}
usrMsg.Content, // {3}
exec.Result.ErrorReason, // {4}
exec1 * _oneThousandth, // {5}
exec2 * _oneThousandth, // {6}
exec3 * _oneThousandth, // {7}
total * _oneThousandth // {8}
);
}
public override ExecuteCommandResult Execute(DelayedEvent delayedEvent)
{
var masterFilename = delayedEvent.FileSystemEvent.FullPath;
var followerFilename = ModuleTools.FormatCommand(followerFilenameFormat, masterFilename);
Util.WriteLog(string.Format("FollowMasterFileModule.Execute() followerFilename = {0}", followerFilename));
var result = new ExecuteCommandResult();
// master file exists, follower file exists and is newer than original file - the condition is false
if (File.Exists(masterFilename) && File.Exists(followerFilename) && File.GetLastWriteTime(followerFilename) >= File.GetLastWriteTime(masterFilename))
{
result.ExitCode = 1;
Util.WriteLog(string.Format("FollowMasterFileModule.Execute() ExitCode = {0}", result.ExitCode));
return(result);
}
// master file does not exist, follower file does not exist
if (!File.Exists(masterFilename) && !File.Exists(followerFilename))
{
result.ExitCode = 2;
Util.WriteLog(string.Format("FollowMasterFileModule.Execute() ExitCode = {0}", result.ExitCode));
return(result);
}
if (allowAutoDelete)
{
File.Delete(followerFilename);
Util.WriteLog(string.Format("FollowMasterFileModule.Execute() Deleted follower {0}", followerFilename));
result.ExitCode = 3;
Util.WriteLog(string.Format("FollowMasterFileModule.Execute() ExitCode = {0}", result.ExitCode));
return(result);
}
if (createFolder)
{
var fileInfo = new FileInfo(followerFilename);
Directory.CreateDirectory(fileInfo.Directory.FullName);
}
Util.WriteLog(string.Format("FollowMasterFileModule.Execute() ExitCode = {0}", result.ExitCode));
return(result);
}
private static async Task SendErrorInfo(ExecuteCommandResult result, string prefix, string customError, bool showUsage, bool showOptions)
{
var str = $"**`{prefix + result.CommandInfo.Aliases[0]}`**";
string aliases = string.Join("/", result.CommandInfo.Aliases.Skip(1).Select(a => $"`{a}`"));
if (!string.IsNullOrWhiteSpace(aliases))
{
str += $"/{aliases}";
}
EmbedBuilder embed = new EmbedBuilder().WithTitle(str)
.WithErrorColor()
.WithDescription($"```\nError: {customError}```")
.WithFooter($"Module: {result.CommandInfo.Module.GetTopLevelModule().Name}");
if (showUsage)
{
string[] remarks = result.CommandInfo.Remarks.Deserialize <string[]>().Select(x => string.Format(x, prefix)).ToArray();
embed.AddField("Correct Usage", $"```\n{remarks[0]}```");
if (remarks.Length > 1)
{
embed.AddField("Examples", $"```\n{string.Join('\n', remarks[1..])}```");
/// <summary>
/// execute single command
/// </summary>
/// <param name="conn">db connection</param>
/// <param name="cmd">command</param>
/// <param name="tran">transaction</param>
/// <returns></returns>
int ExecuteSingleCommand(IQueryTranslator queryTranslator, IDbConnection conn, RdbCommand cmd, IDbTransaction tran = null)
{
int resultValue = 0;
#region query object translate
IDictionary <string, object> queryParameters = null;
var tranResult = queryTranslator.Translate(cmd.Query);
string conditionString = string.Empty;
if (!tranResult.ConditionString.IsNullOrEmpty())
{
conditionString += "WHERE " + tranResult.ConditionString;
}
if (tranResult.Parameters != null)
{
if (tranResult.Parameters is IDictionary <string, object> )
{
queryParameters = tranResult.Parameters as IDictionary <string, object>;
}
else
{
queryParameters = tranResult.Parameters.ObjectToDcitionary();
}
}
#endregion
#region execute
StringBuilder cmdText = new StringBuilder();
object newParameters = cmd.Parameters;
ExecuteCommandResult executeCmdResult = cmd.CommandResultType;
if (cmd.ExecuteMode == CommandExecuteMode.CommandText)
{
cmdText.Append(cmd.CommandText);
}
else
{
switch (cmd.Operate)
{
case OperateType.Insert:
cmdText.AppendFormat("INSERT INTO `{0}` ({1}) VALUES ({2})", cmd.ObjectName, string.Join(",", FormatFields(cmd.Fields)), string.Join(",", cmd.Fields.Select(c => "?" + c)));
break;
case OperateType.Update:
IDictionary <string, dynamic> oldCmdParameterDic = null;
IDictionary <string, dynamic> newCmdParameterDic = new Dictionary <string, dynamic>();
if (cmd.Parameters is IDictionary <string, dynamic> )
{
oldCmdParameterDic = cmd.Parameters as IDictionary <string, dynamic>;
}
else
{
oldCmdParameterDic = cmd.Parameters.ObjectToDcitionary();
}
List <string> updateSetArray = new List <string>();
foreach (var field in cmd.Fields)
{
if (oldCmdParameterDic == null || !oldCmdParameterDic.ContainsKey(field) || !(oldCmdParameterDic[field] is CalculateModify))
{
updateSetArray.Add(string.Format("{0}.`{1}`=?{2}", queryTranslator.ObjectPetName, field, field));
if (oldCmdParameterDic != null && oldCmdParameterDic.ContainsKey(field))
{
newCmdParameterDic.Add(field, oldCmdParameterDic[field]);
}
}
else if (oldCmdParameterDic[field] is CalculateModify)
{
CalculateModify calModify = oldCmdParameterDic[field] as CalculateModify;
newCmdParameterDic.Add(field, calModify.Value);
string calChar = GetCalculateChar(calModify.Calculate);
updateSetArray.Add(string.Format("{0}.`{1}`={0}.`{1}`{2}?{3}", queryTranslator.ObjectPetName, field, calChar, field));
}
}
newParameters = newCmdParameterDic;
cmdText.AppendFormat("{4}UPDATE `{2}` AS {0} SET {1} {3}", queryTranslator.ObjectPetName, string.Join(",", updateSetArray.ToArray()), cmd.ObjectName, conditionString, tranResult.PreScript);
break;
case OperateType.Delete:
cmdText.AppendFormat("{3}DELETE {0} FROM `{1}` AS {0} {2}", queryTranslator.ObjectPetName, cmd.ObjectName, conditionString, tranResult.PreScript);
break;
case OperateType.Exist:
cmdText.AppendFormat("SELECT EXISTS(SELECT {0}.`{1}` FROM `{2}` AS {0} {3})", queryTranslator.ObjectPetName, cmd.Fields.ElementAt(0), cmd.ObjectName, conditionString);
executeCmdResult = ExecuteCommandResult.ExecuteScalar;
break;
default:
break;
}
}
if (cmdText.Length <= 0)
{
return(0);
}
#endregion
#region parameter opertion
object parameters = queryParameters;
if (newParameters != null)
{
CmdParameters cmdParameters = newParameters as CmdParameters;
if (cmdParameters != null)
{
DynamicParameters dynamicParameters = new DynamicParameters();
foreach (var item in cmdParameters.Parameters)
{
dynamicParameters.Add(item.Key, item.Value.Value, item.Value.DbType, item.Value.ParameterDirection, item.Value.Size, item.Value.Precision, item.Value.Scale);
}
if (queryParameters != null)
{
foreach (var parameter in queryParameters)
{
dynamicParameters.Add(parameter.Key, parameter.Value);
}
}
parameters = dynamicParameters;
}
else if (newParameters is IDictionary <string, dynamic> )
{
IDictionary <string, dynamic> cmdParametersDic = newParameters as IDictionary <string, dynamic>;
if (queryParameters != null)
{
foreach (var queryParaItem in queryParameters)
{
cmdParametersDic.Add(queryParaItem.Key, queryParaItem.Value);
}
}
parameters = cmdParametersDic;
}
else
{
IDictionary <string, object> cmdParametersDic = newParameters.ObjectToDcitionary();
if (queryParameters != null)
{
foreach (var queryParaItem in queryParameters)
{
cmdParametersDic.Add(queryParaItem.Key, queryParaItem.Value);
}
}
parameters = cmdParametersDic;
}
}
#endregion
switch (executeCmdResult)
{
case ExecuteCommandResult.ExecuteScalar:
resultValue = conn.ExecuteScalar <int>(cmdText.ToString(), parameters, transaction: tran, commandType: GetCommandType(cmd));
break;
case ExecuteCommandResult.ExecuteRows:
resultValue = conn.Execute(cmdText.ToString(), parameters, transaction: tran, commandType: GetCommandType(cmd));
break;
}
return(resultValue);
}
public ExecuteCommandResult ExecuteCommand(string commandText, ILogger logger)
{
var result = new ExecuteCommandResult();
// just a simple command interpreter here
if (commandText.ToUpperInvariant() == "UP")
{
this.Up(logger);
}
else if (commandText.ToUpperInvariant() == "DOWN")
{
this.Down(logger);
}
else if (commandText.ToUpperInvariant() == "STOP")
{
this.Stop(logger);
}
else if (commandText.ToUpperInvariant()
.StartsWith("SETHEIGHT "))
{
var commandParts = commandText.Split(" ");
if (commandParts.Length != 2)
{
result.IsError = true;
result.Message = "The setheight command should have a single parameter between 29.5 and 47 inclusive";
logger.LogWarning(result.Message);
return(result);
}
var heightPart = commandParts[1];
if (!float.TryParse(heightPart, out var height))
{
result.IsError = true;
result.Message = $"Could not parse the height value {heightPart} as a float";
logger.LogWarning(result.Message);
return(result);
}
if (height < 29.5f ||
height > 47f)
{
result.IsError = true;
result.Message = $"The height value {height} is outside the acceptable range of 29.5 to 47";
logger.LogWarning(result.Message);
return(result);
}
this.SetHeight(logger, height);
result.Message = $"Height changed to {height}";
logger.LogWarning(result.Message);
return(result);
}
else
{
result.IsError = true;
result.Message = $"Unknown command: {commandText}";
logger.LogWarning(result.Message);
}
return(result);
}
private static UIAtlasInfo GenParticularAtlas(string atlasDir, string atlasOutputDir, bool isSaveJsonData = false)
{
UIAtlasInfo atlasInfo = new UIAtlasInfo();
Dictionary <string, string> pngPathDict = new Dictionary <string, string>();
foreach (string filePath in FileTools.getAllFilesInFolder(atlasDir))
{
if (!filePath.EndsWith(".png", System.StringComparison.CurrentCultureIgnoreCase))
{
Debug.LogWarningFormat("[{0}]中含非png格式的文件：{1}", atlasDir, filePath);
continue;
}
pngPathDict.Add(FileTools.getBaseNameWithoutExt(filePath), filePath);
atlasInfo.AddPng(filePath);
}
if (pngPathDict.Keys.Count <= 0)
{
Debug.LogWarningFormat("目录中{0}中不含png,不生成图集", atlasDir);
return(atlasInfo);
}
string rgbaFilePath = string.Format("{0}.png", atlasOutputDir);
string atlasDataFilePath = string.Format("{0}_data.json", atlasOutputDir);
string tmpRGBAFilePath = string.Format("{0}_t.png", atlasOutputDir);
string tmpAtlasDataFilePath = string.Format("{0}_data_t.json", atlasOutputDir);
List <string> par = new List <string>()
{
"--opt RGBA8888",
"--border-padding 0",
"--shape-padding 0",
};
ExecuteCommandResult packRes = RunTexturePacker(atlasDir, tmpRGBAFilePath, tmpAtlasDataFilePath, par);
if (packRes != null && !packRes.success)
{
Debug.LogErrorFormat("!!!散图合成图集失败，信息{}", packRes.msg);
return(atlasInfo);
}
string dataContent = FileTools.readFile(tmpAtlasDataFilePath);
dataContent = ModifyContentLine(dataContent, dataContent.IndexOf("$TexturePacker:SmartUpdate:"), "$TexturePacker:SmartUpdate:111111111111111111111111111111$\"");
FileTools.deleteFileOrFolder(tmpAtlasDataFilePath);
FileTools.writeFile(tmpAtlasDataFilePath, dataContent);
if (!File.Exists(rgbaFilePath) || !FileTools.getFileMd5(tmpRGBAFilePath).Equals(FileTools.getFileMd5(rgbaFilePath)) || !File.Exists(atlasDataFilePath) || !FileTools.getFileMd5(tmpAtlasDataFilePath).Equals(FileTools.getFileMd5(atlasDataFilePath)))
{
FileTools.deleteFileOrFolder(rgbaFilePath);
FileTools.deleteFileOrFolder(atlasDataFilePath);
File.Move(tmpRGBAFilePath, rgbaFilePath);
File.Move(tmpAtlasDataFilePath, atlasDataFilePath);
AssetDatabase.SaveAssets();
AssetDatabase.Refresh();
Debug.LogFormat("生成图集成功:{0}", rgbaFilePath);
}
else
{
FileTools.deleteFileOrFolder(tmpRGBAFilePath);
FileTools.deleteFileOrFolder(tmpAtlasDataFilePath);
AssetDatabase.SaveAssets();
AssetDatabase.Refresh();
Debug.LogFormat("图集不需要更新:{0}", rgbaFilePath);
}
atlasInfo.atlasFullPath = rgbaFilePath;
atlasInfo.atlasDataFullPath = atlasDataFilePath;
SetAtlasPngProps(rgbaFilePath, atlasDataFilePath, pngPathDict, ref atlasInfo);
FileTools.deleteFileOrFolder(atlasDataFilePath);
AssetDatabase.SaveAssets();
AssetDatabase.Refresh();
return(atlasInfo);
}
