private void OnCommandExecuted <TResult>(TCommand command, TResult result, AddonInvoker invoker)
{
if (ShouldLog(LogCategory.CommandExecuted))
{
WriteCommandExecuted(command, result, invoker);
}
}
private void LogCommand(TCommand command)
{
if (ShouldLog(LogCategory.CommandText))
{
WriteCommand(command);
}
}
// starting depth can be non-zero for nested behaviour trees
internal BehaviourTree(BTNode root, int startingDepth)
{
this.root = root;
data = default;
command = default;
allNodes = new List <BTNode>();
GatherNodeInfoRecursively(root, startingDepth);
tickedLastFrame = new bool[allNodes.Count];
tickedThisFrame = new bool[allNodes.Count];
lastTickResult = new BTState[allNodes.Count];
for (int i = 0; i < allNodes.Count; i++)
{
allNodes[i].index = i;
allNodes[i].tree = this;
lastTickResult[i] = BTState.Failure;
}
void GatherNodeInfoRecursively(BTNode childNode, int depth)
{
allNodes.Add(childNode);
childNode.debugDepth = depth;
if (childNode is INodeWithChildren branch)
{
foreach (var child in branch.Children())
{
GatherNodeInfoRecursively(child, depth + 1);
}
}
}
}
/// <summary>
/// Writes logging message for command executed.
/// </summary>
/// <typeparam name="TResult">Type of the command result.</typeparam>
/// <param name="command">The command.</param>
/// <param name="result">The command result.</param>
/// <param name="invoker">The invoker.</param>
protected virtual void WriteCommandExecuted <TResult>(TCommand command, TResult result, AddonInvoker invoker)
{
Debug.Assert(ShouldLog(LogCategory.CommandExecuted));
var exception = invoker.Exception;
if (exception != null)
{
Write(LogCategory.CommandExecuted, DiagnosticMessages.DbLogger_CommandFailed(Stopwatch.ElapsedMilliseconds, exception.Message));
}
else if (invoker.TaskStatus.HasFlag(TaskStatus.Canceled))
{
Write(LogCategory.CommandExecuted, DiagnosticMessages.DbLogger_CommandCanceled(Stopwatch.ElapsedMilliseconds));
}
else
{
var resultString = (object)result == null
? "null"
: (result is DbReader)
? result.GetType().Name
: result.ToString();
Write(LogCategory.CommandExecuted, DiagnosticMessages.DbLogger_CommandComplete(Stopwatch.ElapsedMilliseconds, resultString));
}
Write(LogCategory.CommandExecuted, Environment.NewLine);
Write(LogCategory.CommandExecuted, Environment.NewLine);
}
protected async Task <IActionResult> ExecuteCommand <TCommand, TResult>() where TCommand : class, ICommand <CommandResponse <TResult> >, new()
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
TCommand command = CreateCommand <TCommand>();
CommandResponse <TResult> response;
try
{
response = await Dispatcher.DispatchAsync(command);
}
catch (DispatcherException ex)
{
ex.AddToModelState(ModelState);
return(BadRequest(ModelState));
}
if (response.IsSuccess)
{
return(Ok(response.Result));
}
response.AddToModelState(ModelState);
return(BadRequest(ModelState));
}
public void SendCommand <TCommand>() where TCommand : ICommand, new()
{
var command = new TCommand();
command.SetArchitecture(this);
command.Execute();
}
/// <summary>
/// Handles command handler exceptions.
/// </summary>
/// <param name="command">The command on which the exception occurred.</param>
/// <param name="AContext">The context on which the exception happened.</param>
/// <param name="exception">The exception.</param>
protected virtual void CommandHandler_OnException(TCommand command, TContext AContext, Exception exception)
{
if (mOnCommandHandlersException != null)
{
mOnCommandHandlersException(command, AContext, exception);
}
}
public static List <TEntity> SelectEntity <TEntity, TCommand>() where TCommand : DbCommand, new()
{
List <TEntity> list = new List <TEntity>();
using (TCommand command = new TCommand())
{
var TEntityAttribute = (TableManagerAttribute)typeof(TEntity).GetCustomAttributes(typeof(TableManagerAttribute), false).FirstOrDefault();
command.Connection = Connection.Conn ?? throw new NullReferenceException();
command.CommandType = CommandType.Text;
command.CommandText = $"SELECT * FROM {TEntityAttribute.SchemeName}{(TEntityAttribute.SchemeName == null ? "" : ".")}{TEntityAttribute.TableName ?? typeof(TEntity).Name}";
Connection.Check();
var reader = command.ExecuteReader() ?? throw new NullReferenceException();
int count = reader.FieldCount;
var p0 = typeof(TEntity).GetProperties(BindingFlags.Public | BindingFlags.Instance);
while (reader.Read())
{
var ins = Activator.CreateInstance <TEntity>();
for (int i = 0; i < count; i++)
{
var p = p0.FirstOrDefault(x => x.Name.ToUpper() == reader.GetName(i).ToUpper());
p.SetValue(ins, Convert.ChangeType(Convert.ChangeType(reader.GetValue(i), p.PropertyType), p.PropertyType), null);
}
list.Add(ins);
}
}
return(list);
}
/// <summary>
/// Writes command into logging.
/// </summary>
/// <param name="command">The command.</param>
protected virtual void WriteCommand(TCommand command)
{
Debug.Assert(ShouldLog(LogCategory.CommandText));
Debug.Assert(command != null);
var commandText = command.CommandText ?? "<null>";
if (commandText.EndsWith(Environment.NewLine, StringComparison.Ordinal))
{
Write(LogCategory.CommandText, commandText);
}
else
{
Write(LogCategory.CommandText, commandText);
Write(LogCategory.CommandText, Environment.NewLine);
}
if (command.Parameters != null)
{
foreach (var parameter in command.Parameters.OfType <DbParameter>())
{
WriteParameter(parameter);
}
}
Write(LogCategory.CommandText, Environment.NewLine);
}
public TCommand Build <TCommand>() where TCommand : ICommand, new()
{
TCommand command = new TCommand();
OnNewCommand(command);
return(command);
}
public T ExecuteCommand <TCommand, T>() where TCommand : SqlCommand, new()
{
var command = new TCommand();
command.SetUnitOfWork();
return(command.Execute <T>());
}
public TCommand Build <TCommand>() where TCommand : ICommand, new()
{
TCommand command = new TCommand();
container.Inject(command);
return(command);
}
/// <summary>
/// Writes logging message for command executing.
/// </summary>
/// <param name="command">The command.</param>
/// <param name="invoker">The invoker.</param>
protected virtual void WriteCommandExecuting(TCommand command, AddonInvoker invoker)
{
Debug.Assert(ShouldLog(LogCategory.CommandExecuting));
Write(LogCategory.CommandExecuting, Environment.NewLine);
LogCommand(command);
Write(LogCategory.CommandExecuting, invoker.IsAsync ? DiagnosticMessages.DbLogger_CommandExecutingAsync(DateTimeOffset.Now) : DiagnosticMessages.DbLogger_CommandExecuting(DateTimeOffset.Now));
Write(LogCategory.CommandExecuting, Environment.NewLine);
}
public static TCommand Execute <TCommand>(params object[] args)
where TCommand : MonoCommand, new()
{
GameObject mgGameObject = MonoSingleton.GetMGGameObject();
object[] attibutes = typeof(TCommand).GetCustomAttributes(true);
bool oneItemOnScene = false;
CommandScope scope = CommandScope.Application;
foreach (Attribute eachAttribute in attibutes)
{
if (eachAttribute is SingletoneAttribute)
{
oneItemOnScene = true;
}
else if (eachAttribute is MonoCommandScopeAttribute)
{
MonoCommandScopeAttribute monoCommandScopeAttribute = (MonoCommandScopeAttribute)eachAttribute;
scope = monoCommandScopeAttribute.IsApplication ? CommandScope.Application : CommandScope.Scene;
}
}
if (oneItemOnScene)
{
TCommand command = (TCommand)UnityEngine.Object.FindObjectOfType(typeof(TCommand));
if (command != null)
{
MonoLog.Log(MonoLogChannel.Core, "Found existing command " + command);
return(command);
}
}
GameObject target = null;
if (scope == CommandScope.Application)
{
target = new GameObject(typeof(TCommand).Name);
target.transform.parent = mgGameObject.transform;
UnityEngine.Object.DontDestroyOnLoad(target);
}
else
{
target = UIManager.CurrentSceneController.gameObject;
}
TCommand result = ExecuteOn <TCommand>(target, args);
result.Scope = scope;
return(result);
}
protected async Task <IActionResult> ExecuteCommand <TCommand>() where TCommand : class, ICommand <CommandResponse>, new()
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
TCommand command = CreateCommand <TCommand>();
return(await ExecuteCommand(command));
}
public TCommand Build <TCommand>(params object[] args) where TCommand : ICommand, new()
{
Type commandClass = typeof(TCommand);
TCommand command = (TCommand)Activator.CreateInstance(commandClass, args);
container.Inject(command);
return(command);
}
private TCommand CreateCommand <TCommand>() where TCommand : class, new()
{
TCommand command = new TCommand();
if (command is IUserContextCommand userContextCommand)
{
userContextCommand.AuthenticatedUserId = this.GetUserId();
}
return(command);
}
public Closure(CommandBehaviours <TCommand> context, TCommand command, CancellationToken cancellationToken)
{
_context = context;
_command = command;
_cancellationToken = cancellationToken;
_next = Execute;
_position = 0;
}
protected async Task <IActionResult> ExecuteCommand <TCommand, TResult>() where TCommand : class, ICommand <CommandResponse <TResult> >, new()
{
TCommand command = CreateCommand <TCommand>();
CommandResponse <TResult> response = await Dispatcher.DispatchAsync(command);
if (response.IsSuccess)
{
return(Ok(response.Result));
}
return(BadRequest(response.ErrorMessage));
}
public Task Execute(TCommand command, CancellationToken cancellationToken)
{
Closure closure = _closure ?? new Closure(this);
_closure = null;
closure.CancellationToken = cancellationToken;
closure.Command = command;
return(closure.Execute());
}
private void LogCommandExecuting(TCommand command, AddonInvoker invoker)
{
if (ShouldLog(LogCategory.CommandExecuting))
{
WriteCommandExecuting(command, invoker);
}
else
{
LogCommand(command);
}
}
public TCommand Build <TCommand>(params object[] args) where TCommand : ICommand
{
Type commandClass = typeof(TCommand);
TCommand command = (TCommand)Activator.CreateInstance(commandClass, args);
_commandPool.AddCommand(command);
OnNewCommand(command);
return(command);
}
/// <inheritdoc />
public TCommand GetCommand <TCommand>() where TCommand : CompositeCommand, new()
{
lock (commands)
{
if (!commands.ContainsKey(typeof(TCommand)))
{
commands[typeof(TCommand)] = new TCommand();
}
return((TCommand)commands[typeof(TCommand)]);
}
}
public TCommand CreateCommand <TCommand>() where TCommand : CommandBase
{
try
{
TCommand command = this.unityContainer.Resolve <TCommand>();
return(command);
}
catch (Exception ex)
{
this.logger.Fatal($"Error while creating the command {typeof(TCommand).Name}.", ex);
throw;
}
}
public virtual TBaseCommand CreateInstance <TBaseCommand, TCommand>() where TCommand : TBaseCommand, IDataEngineCommand, new()
{
if (this.DataStorage == null)
{
throw new InvalidOperationException(ExceptionText);
}
var command = new TCommand();
command.Initialize(this.DataStorage);
return(command);
}
private TCommand getOrCreate <TCommand>()
where TCommand : ButtonCommand, new()
{
ButtonCommand command;
if (_commands.TryGetValue(typeof(TCommand), out command))
{
return((TCommand)command);
}
command = new TCommand();
command.Application = _application;
_commands[typeof(TCommand)] = command;
return((TCommand)command);
}
private void RunBadRequestFromCommandTest <TCommand>()
where TCommand : BaseCommand <string>, ITestCommand
{
TCommand command = Activator.CreateInstance <TCommand>();
command.ExceptionToThrow = new BadRequestException("test", "Bad Request");
CommandResult <string> result = this.Execute(command).Result;
result.IsSuccessful.Should().BeFalse();
result.Exception.Should().NotBeNull();
result.Exception.Should().BeOfType <BadRequestException>();
result.Events.Should().HaveCount(1);
result.Events.Single().ShouldBeEquivalentTo(CommandExecutionEventType.BadRequest);
}
public static Boolean RegisterCommandType <TCommand>() where TCommand : INetCommand, new()
{
var inst = new TCommand();
Type type = inst.GetType();
Int32 hash = GetNetworkCoreHash(type);
if (netCommands.ContainsKey(hash))
{
Log.Error("Tried to register a command type with a duplicate hash");
return(false);
}
else
{
netCommands[hash] = inst;
return(true);
}
}
private void RunExecuteCommandWithSuccessfulResultTest <TCommand>()
where TCommand : BaseCommand <string>, ITestCommand
{
TCommand command = Activator.CreateInstance <TCommand>();
const string value = "test value";
command.Response = value;
CommandResult <string> result = this.Execute(command).Result;
result.IsSuccessful.Should().BeTrue();
result.Response.ShouldBeEquivalentTo(value);
result.Exception.Should().BeNull();
result.Events.Should().HaveCount(1);
result.Events.Single().ShouldBeEquivalentTo(CommandExecutionEventType.Success);
}
/// <summary>
/// Gets or creates an instance of a command by type.
/// </summary>
/// <typeparam name = "TCommand">The type of command to get or create.</typeparam>
/// <returns>An instance of <typeparamref name = "TCommand" />.</returns>
public static ICommand GetCommandInstance <TCommand>() where TCommand : ICommand, new()
{
ICommand cmd;
if (CommandCache.ContainsKey(typeof(TCommand)))
{
cmd = CommandCache[typeof(TCommand)];
}
else
{
cmd = new TCommand();
cmd.Services = ApplicationServices.Instance;
cmd.Settings = ApplicationServices.Instance.Settings;
CommandCache[typeof(TCommand)] = cmd;
}
return(cmd);
}
