public void StartTaskTest2()
{
DateTime startDateTime = DateTime.Now;
CommandExecuter.StartTask(list4StartTask, "name2", startDateTime);
Task startedTask = list4StartTask.Find(e => e.Name == "name2");
Task haltedTask = list4StartTask.Find(e => e.Name == "name3");
Task restaredTask = list4StartTask.Find(e => e.Name == "name4");
Task completedTask = list4StartTask.Find(e => e.Name == "name5");
Task deletedTask = list4StartTask.Find(e => e.Name == "name6");
Assert.Equal(TaskState.Started, startedTask.State);
Assert.Null(startedTask.StartTime);
Assert.Equal(TaskState.Halted, haltedTask.State);
Assert.Null(haltedTask.StartTime);
Assert.Equal(TaskState.Restarted, restaredTask.State);
Assert.Null(restaredTask.StartTime);
Assert.Equal(TaskState.Comleted, completedTask.State);
Assert.Null(completedTask.StartTime);
Assert.Equal(TaskState.Deleted, deletedTask.State);
Assert.Null(deletedTask.StartTime);
}
public void Process(WorkflowPipelineArgs args)
{
Item item = args.DataItem;
string stateId = item.State.GetWorkflowState().StateID;
ProcessorItem workflowItem = args.ProcessorItem;
string langs = workflowItem.InnerItem.Fields["LanguagesToWaitFor"].Value;
string commandID = workflowItem.InnerItem.Fields["CommandToExecute"].Value;
if (commandID == "")
{
Log.Error("WaitForLanguage action failed. The field 'CommandToExecute' value is not set.", this);
return;
}
Item command = item.Database.Items[commandID];
if (command["Next state"] == "")
{
Log.Error("WaitForLanguage action failed. The field 'Next State' value of the command is not set.", this);
return;
}
bool result = true;
foreach (Language lang in item.Languages)
{
if (langs != "")
{
if (langs.IndexOf(lang.GetItem(item.Database).ID.ToString()) == -1)
{
continue;
}
}
if (lang.Name == item.Language.Name)
{
continue;
}
Item langItem = item.Database.Items[item.Paths.FullPath, lang, item.Version];
WorkflowState workflowState = langItem.State.GetWorkflowState();
result = result && (workflowState.StateID == stateId || workflowState.FinalState);
}
if (result)
{
foreach (Language lang in item.Languages)
{
Item langItem = item.Database.Items[item.Paths.FullPath, lang, item.Version];
WorkflowState state = langItem.State.GetWorkflowState();
if (workflowItem.InnerItem.Parent.ID.ToString() == state.StateID)
{
WorkflowResult execute = CommandExecuter.Execute(commandID, langItem, "", true);
if (!execute.Succeeded)
{
Log.Error("WaitForLanguage action failed: " + execute.Message, this);
}
}
}
}
}
private void Start()
{
gameData = GetComponent <wwwFormGameData>();
commandExecuter = FindObjectOfType <CommandExecuter>();
levelName = SceneManager.GetActiveScene().name.Replace(" ", "/"); // Get the name of the scene and replace the space with a /
level.text = levelName;
}
public void Setup()
{
if (String.IsNullOrEmpty(ConfigPath))
{
ConfigPath = Consts.DEFAULT_SMARTSQL_CONFIG_PATH;
}
if (String.IsNullOrEmpty(Alias))
{
Alias = ConfigPath;
}
if (LoggerFactory == null)
{
LoggerFactory = NoneLoggerFactory.Instance;
}
if (ConfigLoader == null)
{
ConfigLoader = new LocalFileConfigLoader(ConfigPath, LoggerFactory);
}
var sqlMapConfig = ConfigLoader.Load();
SmartSqlContext = new SmartSqlContext(LoggerFactory.CreateLogger <SmartSqlContext>(), sqlMapConfig);
if (DbSessionStore == null)
{
DbSessionStore = new DbConnectionSessionStore(LoggerFactory, SmartSqlContext.DbProvider.Factory);
}
if (DataSourceFilter == null)
{
DataSourceFilter = new DataSourceFilter(LoggerFactory.CreateLogger <DataSourceFilter>(), DbSessionStore, SmartSqlContext);
}
if (SqlBuilder == null)
{
SqlBuilder = new SqlBuilder(LoggerFactory.CreateLogger <SqlBuilder>());
}
if (PreparedCommand == null)
{
PreparedCommand = new PreparedCommand(LoggerFactory.CreateLogger <PreparedCommand>(), SmartSqlContext);
}
if (CommandExecuter == null)
{
CommandExecuter = new CommandExecuter(LoggerFactory.CreateLogger <CommandExecuter>(), PreparedCommand);
}
if (DataReaderDeserializerFactory == null)
{
DataReaderDeserializerFactory = new EmitDataReaderDeserializerFactory();
}
if (CacheManager == null)
{
if (SmartSqlContext.IsCacheEnabled)
{
CacheManager = new CacheManager(LoggerFactory.CreateLogger <CacheManager>(), SmartSqlContext, DbSessionStore);
}
else
{
CacheManager = new NoneCacheManager();
}
}
ConfigLoader.OnChanged += ConfigLoader_OnChanged;
}
private static void Init()
{
while (true)
{
var inputCommandText = Read();
if (string.IsNullOrWhiteSpace(inputCommandText))
{
continue;
}
try
{
//Parse command class data.
var cmdClassData = CommandParser.ParseClassData(Constants.Commands.CommandNamespace);
//Parse input command data.
var cmdInputData = CommandParser.ParseInputData(inputCommandText, Constants.Commands.CommandClassName);
//Validate input command data against existing class command data.
CommandValidator.Validate(cmdClassData, cmdInputData);
var classData = cmdClassData.FirstOrDefault(c => c.Name == cmdInputData.ClassName);
//Execute command method based on input.
var result = CommandExecuter.ExecuteMethod(classData, cmdInputData, typeof(Commands).Assembly);
//Write command result.
Write(result);
}
catch (InputException inputException)
{
Write(inputException.Message);
}
catch (FatalException fatalException)
{
Write($"{fatalException.Message} \n {fatalException.InnerExceptionMessages}");
}
}
}
//带参数的初始化
public void controlInit(SpreadsheetControl spreadsheetMain, Dictionary <String, SimpleButton> buttons, Dictionary <String, Label> labels, String path, Dictionary <String, PopupMenu> menus, BarManager barmanager, XtraForm form, AlertControl alert, XSheetUser user)
{
this.buttons = buttons;
this.labels = labels;
this.spreadsheetMain = spreadsheetMain;
this.menus = menus;
this.rightClickBarManager = barmanager;
AlertUtil.setAlert(alert, form);
this.user = user;
this.form = form;
this.alert = alert;
//CELLCHANGE
executer = new CommandExecuter(user);
executer.Attach(this);
executeState = "OK";
/*加载文档，后续根据不同设置配置，待修改TODO*/
try
{
DateTime date = new DateTime();
StreamWriter sw = new StreamWriter(@"ConsoleOutput.txt", true);
date = DateTime.Now;
sw.WriteLine("beforeLoadDoc:" + date.ToString());
if (path.Length > 0)
{
spreadsheetMain.Document.LoadDocument(path);
}
sw.Flush();
sw.Close();
}
catch (Exception e)
{
MessageBox.Show(e.ToString());
spreadsheetMain.Dispose();
}
}
public void Process(WorkflowPipelineArgs args)
{
Item item = args.DataItem;
ProcessorItem workflowItem = args.ProcessorItem;
string commandToExecute = workflowItem.InnerItem["CommandToExecute"];
if (commandToExecute == "" || item.Database.Items[commandToExecute] == null || item.Database.Items[commandToExecute]["Next state"] == "")
{
Log.Error("Action SetStateByLanguage is failed: 'CommandToExecute' field is not set properly", this);
return;
}
foreach (Language language in item.Languages)
{
if (language.Name == item.Language.Name)
{
continue;
}
Item langItem = item.Database.Items[item.Paths.FullPath, language, item.Version];
if (GetIsAllowToChangeState(langItem, workflowItem))
{
using (new EditContext(langItem))
{
CommandExecuter.Execute(commandToExecute, langItem, "", true);
}
}
}
}
public Task <int> ExecuteAsync(RequestContext context)
{
return(ExecuteWrapAsync((dbSession) =>
{
return CommandExecuter.ExecuteNonQueryAsync(dbSession, context);
}, context));
}
public int Execute(RequestContext context)
{
return(ExecuteWrap((dbSession) =>
{
return CommandExecuter.ExecuteNonQuery(dbSession, context);
}, context));
}
public async Task MissingCommandActorsThrowsException()
{
// Arrange
Mock <ICommandHandlerFactory> handlerFactory = new Mock <ICommandHandlerFactory>();
Mock <ICommandRegistry> registry = new Mock <ICommandRegistry>();
Mock <ICommandHandlerExecuter> commandHandlerExecuter = new Mock <ICommandHandlerExecuter>();
Mock <IPipelineAwareCommandHandlerExecuter> commandHandlerChainExecuter = new Mock <IPipelineAwareCommandHandlerExecuter>();
Mock <ICommandScopeManager> scopeManager = new Mock <ICommandScopeManager>();
Mock <ICommandExecutionExceptionHandler> commandExecutionExceptionHandler = new Mock <ICommandExecutionExceptionHandler>();
Mock <ICommandAuditPipeline> commandAuditPipeline = new Mock <ICommandAuditPipeline>();
Mock <IOptionsProvider> optionsProvider = new Mock <IOptionsProvider>();
optionsProvider.Setup(x => x.Options).Returns(new Options());
handlerFactory.Setup(x => x.Create(typeof(SimpleCommandHandler))).Returns(new SimpleCommandHandler());
registry.Setup(x => x.GetPrioritisedCommandHandlers(It.IsAny <ICommand>())).Returns <List <PrioritisedCommandHandler> >(null);
CommandExecuter executer = new CommandExecuter(registry.Object,
handlerFactory.Object,
scopeManager.Object,
commandHandlerExecuter.Object,
commandHandlerChainExecuter.Object,
commandExecutionExceptionHandler.Object,
commandAuditPipeline.Object,
optionsProvider.Object);
// Act and assert
MissingCommandHandlerRegistrationException ex = await Assert.ThrowsAsync <MissingCommandHandlerRegistrationException>(async() => await executer.ExecuteAsync(new SimpleCommand(), default(CancellationToken)));
Assert.Equal(typeof(SimpleCommand), ex.CommandType);
}
public List <Customers> GetCustomerByID(Int32 CustomerID)
{
List <Customers> customers = null;
try
{
customers = new List <Customers>();
SqliteParameter[] parameters = new SqliteParameter[]
{
new SqliteParameter("", SqliteType.Integer)
{
Value = CustomerID
}
};
//SQLitePCL.raw.SetProvider(new SQLitePCL.SQLite3Provider_whatever());
connection.Open();
cmd = CommandExecuter.QueryCommand(SQLQuery.GetCustomerByID, connection, parameters, 60);
SqliteDataReader reader = cmd.ExecuteReader();
while (reader.Read())
{
Customers cust = new Customers();
cust.FirstName = (reader["FirstName"] != DBNull.Value)?reader.GetString(reader.GetOrdinal("FirstName")):null;
}
return(customers);
}
catch (Exception ex)
{
throw ex;
}
}
public LastFm()
{
var executer = new CommandExecuter<ILastFmCredentials>();
this.User = new UserCommands(executer);
this.Auth = new AuthCommands(executer);
}
public T ExecuteScalar <T>(RequestContext context)
{
return(ExecuteWrap((dbSession) =>
{
var result = CommandExecuter.ExecuteScalar(dbSession, context);
return (T)Convert.ChangeType(result, typeof(T));
}, context));
}
public async Task <long> GetLastItemIdAsync()
{
string selectStatement = "select gen_id(gen_item_id, 0) from RDB$DATABASE;";
long nextItemId = await CommandExecuter.SelectGenericAsync <long>(selectStatement);
return(nextItemId);
}
public async Task <T> ExecuteScalarAsync <T>(RequestContext context)
{
return(await ExecuteWrapAsync(async (dbSession) =>
{
var result = await CommandExecuter.ExecuteScalarAsync(dbSession, context);
return (T)Convert.ChangeType(result, typeof(T));
}, context));
}
public LoginViewModel()
{
_bl = new UserBL();
LoginUserCommand = new CommandExecuter(LoginUser, () => { return(!string.IsNullOrWhiteSpace(UserName) && !string.IsNullOrWhiteSpace(Password)); });
RegisterUserCommand = new CommandExecuter(NavigateToRegisterUser);
}
public T QuerySingle <T>(RequestContext context)
{
return(ExecuteWrap((dbSession) =>
{
var dataReader = CommandExecuter.ExecuteReader(dbSession, context);
return _dataReaderDeserializer.ToSingle <T>(context, dataReader);
}, context, DataSourceChoice.Read));
}
private async Task <long> GetLastCenaIdAsync()
{
string selectStatement = "select gen_id(gen_cena_id, 0) from RDB$DATABASE;";
long lastInsertedCenaId = await CommandExecuter.SelectGenericAsync <long>(selectStatement);
return(lastInsertedCenaId);
}
public T ExecuteScalar <T>(RequestContext context)
{
return(ExecuteWrap((dbSession) =>
{
var result = CommandExecuter.ExecuteScalar(dbSession, context);
return ReturnValue <T>(result);
}, context));
}
public async Task AddCategoryAsync(string inputModel)
{
AddCategoryInputModel model = JsonConvert.DeserializeObject <AddCategoryInputModel>(inputModel);
string insertStatement = $"insert into category(is_del, name)values(0, '{model.Name}')";
await CommandExecuter.ExecuteNonQuaryAsync(insertStatement);
}
public async Task <T> QuerySingleAsync <T>(RequestContext context)
{
return(await ExecuteWrapAsync(async (dbSession) =>
{
var dataReader = await CommandExecuter.ExecuteReaderAsync(dbSession, context);
return await _dataReaderDeserializer.ToSingleAsync <T>(context, dataReader);
}, context, DataSourceChoice.Read));
}
public LogInVM()
{
userBl = UserBL.Instance;
CreateUserCommand = new CommandExecuter
(Register, () => { return(!string.IsNullOrWhiteSpace(UserName) && !string.IsNullOrWhiteSpace(Password)); });
LoginCommand = new CommandExecuter(
Login, () => { return(!string.IsNullOrWhiteSpace(UserName) && !string.IsNullOrWhiteSpace(Password)); });
}
public async Task <T> ExecuteScalarAsync <T>(RequestContext context)
{
return(await ExecuteWrapAsync(async (dbSession) =>
{
var result = await CommandExecuter.ExecuteScalarAsync(dbSession, context);
return ReturnValue <T>(result);
}, context));
}
public void NamedCommandExecuted()
{
_context.CommandContext.RegisterCommand <TestCommand>();
var parseResult = PowerParser.ParseInput("Test-Command \"Hello World\" -SubstringIndex 6");
var result = CommandExecuter.Execute(parseResult.Value as pstudio.PowerConsole.Parser.Command, _context, _host);
Assert.AreEqual("World", result);
}
public T QuerySingle <T>(RequestContext context)
{
return(ExecuteWrap((dbSession) =>
{
var dataReader = CommandExecuter.ExecuteReader(dbSession, context);
var deser = DeserializerFactory.Create();
return deser.ToSingle <T>(context, dataReader);
}, context));
}
public async Task InsertApplicationUserAsync(string inputModelJson)
{
ApplicationUserInputModel inputModel = JsonConvert.DeserializeObject <ApplicationUserInputModel>(inputModelJson);
string currentDate = DateTime.Now.ToString("dd.MM.yyyy");
string insertStatement = $"insert into application_user(is_del, username, created_on)values(0,'{inputModel.UserName}', '{currentDate}')";
await CommandExecuter.ExecuteNonQuaryAsync(insertStatement);
}
private async Task InsertCenaItemAsync(CenaItemInputModel inputModel)
{
long cenaId = inputModel.CenaId;
long itemId = inputModel.ItemId;
string insertStatement = $"insert into cena_item(cena_id, item_id)values({cenaId},{itemId})";
await CommandExecuter.ExecuteNonQuaryAsync(insertStatement);
}
public async Task <T> QuerySingleAsync <T>(RequestContext context)
{
return(await ExecuteWrapAsync(async (dbSession) =>
{
var dataReader = await CommandExecuter.ExecuteReaderAsync(dbSession, context);
var deser = DeserializerFactory.Create();
return await deser.ToSingleAsync <T>(context, dataReader);
}, context));
}
public RegisterViewModel()
{
_bl = new UserBL();
Users = new ObservableCollection <string>();
_bl.ConnectToServer(OnCreatedUser);
Task loadUsers = LoadUsers();
CreateUserCommand = new CommandExecuter(RegisterUser, () => { return(!string.IsNullOrWhiteSpace(UserName) && !string.IsNullOrWhiteSpace(Password)); });
}
public static void Main(string[] args)
{
var raceTower = new RaceTower();
var commandExecutor = new CommandExecuter(raceTower);
var engine = new Engine(commandExecutor, raceTower);
engine.Run();
}
public static SmartSqlBuilder UseOracleCommandExecuter(this SmartSqlBuilder smartSqlBuilder,
ILoggerFactory loggerFactory)
{
var cmdExe = new CommandExecuter(loggerFactory.CreateLogger <CommandExecuter>());
cmdExe.DbCommandCreated += OnDbCommandCreated;
smartSqlBuilder.UseCommandExecuter(cmdExe);
return(smartSqlBuilder);
}
public static void Main()
{
commandExecuter = new CommandExecuter(new UserService(new UserFileRepo()));
string command=Console.ReadLine();
while (command != "exit")
{
commandExecuter.ExecuteCommand(command);
command = Console.ReadLine();
}
}
public ExecuteState(ICommandScheduler scheduler, CommandExecuter executer)
{
this.scheduler = scheduler;
this.executer = executer;
}
private Engine(CommandExecuter ex)
{
this.executer = ex;
}
public void Execute(CommandExecuter executer)
{
executer.DispatchCommand(this);
}
