/// <summary>
/// Runs all steps and user interaction that is required during the conversion
/// </summary>
public WorkflowResult RunWorkflow(Job job)
{
try
{
_stopwatch = new Stopwatch();
_stopwatch.Start();
JobEventsManager.RaiseJobStarted(job, Thread.CurrentThread.ManagedThreadId.ToString());
PrepareAndRun(job);
}
catch (AbortWorkflowException ex)
{
// we need to clean up the job when it was cancelled
_logger.Warn(ex.Message + " No output will be created.");
WorkflowResult = WorkflowResult.AbortedByUser;
SendJobEvents(job);
}
catch (WorkflowException ex)
{
_logger.Error(ex.Message);
WorkflowResult = WorkflowResult.Error;
SendJobEvents(job);
}
catch (ProcessingException ex)
{
var errorMessage = ex.ErrorCode + " / " + ex.Message;
if (ex.InnerException != null)
{
errorMessage += Environment.NewLine + ex.InnerException;
}
_logger.Error(errorMessage);
LastError = ex.ErrorCode;
HandleError(ex.ErrorCode);
WorkflowResult = WorkflowResult.Error;
SendJobEvents(job);
}
catch (ManagePrintJobsException)
{
throw;
}
catch (InterruptWorkflowException)
{
throw;
}
catch (Exception ex)
{
_logger.Error(ex);
WorkflowResult = WorkflowResult.Error;
SendJobEvents(job);
throw;
}
return(WorkflowResult);
}
private void btnSubmit_Click(object sender, EventArgs e)
{
this.btnSubmit.Enabled = false;
WorkflowResult result = null;
if (this.InstanceId == Guid.Empty)
{
this.m_Leave = new Leave();
this.m_Leave.ID = this.tbGuid.Text;
this.m_Leave.Name = this.tbName.Text;
this.m_Leave.Days = (int)this.nudDays.Value;
this.m_Leave.Cause = tbCause.Text;
this.m_Leave.iState = 0;
result = EAS.Application.Instance.WorkflowRuntime.CreateWorkflow(this, this.m_Leave);
this.m_InstanceId = result.InstanceId;
}
else
{
result = EAS.Application.Instance.WorkflowRuntime.Submit(this);
}
this.OnWorkflowResultChaned(result);
this.btnClose_Click(this.btnClose, e);
}
private void PrepareAndRun(Job job)
{
WorkflowResult = WorkflowResult.Init;
_logger.Debug("Starting conversion...");
var originalMetadata = job.JobInfo.Metadata.Copy();
job.InitMetadataWithTemplates();
JobDataUpdater.UpdateTokensAndMetadata(job);
_logger.Debug("Starting PrintJobWindow");
try
{
DoWorkflowWork(job);
WorkflowResult = WorkflowResult.Finished;
}
catch (ManagePrintJobsException)
{
// revert metadata changes and rethrow exception
job.JobInfo.Metadata = originalMetadata;
throw;
}
finally
{
OnJobFinished(EventArgs.Empty);
}
}
public async Task <ActionResult> OnPostAsync([FromServices] BlogEntryComponentFactory blogEntryComponentFactory)
{
if (blogEntryComponentFactory == null)
{
throw new ArgumentNullException(nameof(blogEntryComponentFactory));
}
if (!ModelState.IsValid)
{
return(Page());
}
var component = blogEntryComponentFactory.New();
WorkflowResult result = await component.Create(
BlogEntryUpdateRequest.UriKey,
BlogEntryUpdateRequest.Title,
BlogEntryUpdateRequest.MinutesToRead,
BlogEntryUpdateRequest.TextIntro,
BlogEntryUpdateRequest.TextEntry,
BlogEntryUpdateRequest.KeyWordId
);
if (!result.Success)
{
for (int i = 0; i < result.Errors.Length; i++)
{
ModelState.AddModelError("", result.Errors[i]);
}
return(Page());
}
return(RedirectToPage("./Edit", new { id = BlogEntryUpdateRequest.UriKey }));
}
public async Task <WorkflowResult> CancelAsync(Guid userId)
{
using (TransactionScope transactionScope = new TransactionScope(TransactionScopeAsyncFlowOption.Enabled))
{
try
{
WorkflowResult workflowResult = await _decorated.CancelAsync(userId);
if (workflowResult.Success)
{
transactionScope.Complete();
}
else
{
Transaction.Current.Rollback();
}
return(workflowResult);
}
catch (Exception ex)
{
Transaction.Current.Rollback();
int errorId = await _applicationLog.LogExceptionAsync(ex);
return(new WorkflowResult(
new[] {
Resources.Resource.InternalServerErrorMessage,
string.Format(Resources.Resource.GeneratedErrorIdMessage, errorId)
}));
}
}
}
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);
}
}
}
}
}
public FuncTask <WorkflowResult> Approval(object wfAddIn)
{
FuncTask <WorkflowResult> task = new FuncTask <WorkflowResult>();
WorkflowResult wfResult = this.GetInstanceID(wfAddIn);
if (wfResult.InstanceId != Guid.Empty)
{
WfApprovalWindow wfApproval = new WfApprovalWindow();
wfApproval.Closed += (s, e) =>
{
bool flag = wfApproval.DialogResult.HasValue ? wfApproval.DialogResult.Value : false;
if (flag)
{
task = this.Approval(wfResult.InstanceId, ContextHelper.Account.LoginID, wfApproval.Result, wfApproval.Comment);
}
else
{
task.Complete(wfResult);
}
};
wfApproval.Show();
}
else
{
task.Complete(wfResult);
}
return(task);
}
public WorkflowResult Execute()
{
var results = new WorkflowResult();
this.context.StartTransaction();
foreach (var step in this.steps)
{
// run the step.
var resultObj = step.ExecutionMethod.Invoke(step.WorkflowStep, step.BuildArgs(paramsWithValues));
if (resultObj is WorkflowStepResult)
{
// extract chainable values
this.ExtractAvailableParametersFromResult(resultObj, step.StepNumber);
// add to result set
var stepResult = resultObj as WorkflowStepResult;
// add the step to the results
results.Results.Add(stepResult);
// if the step was not sucessful, break from the running
// and rollback the transaction
if (!stepResult.Success)
{
this.context.Rollback();
break;
}
}
}
// if they were all successful, commit the transaction.
if (results.TotalSuccess)
{
this.context.Commit();
}
return results;
}
public virtual WorkflowResult RunWorkflow(string workflowName, Dictionary<string, object> parameters, object[] extensions = null)
{
var retVal = new WorkflowResult();
parameters["ResultArgument"] = retVal;
var activity = _activityProvider.GetWorkflowActivity(workflowName);
if (activity == null)
{
throw new ArgumentException("Activity (workflow) not found by name: " + workflowName);
}
//var validationResults = ActivityValidationServices.Validate(activity);
//if (validationResults.Errors.Count() == 0)
//{
var invoker = new WorkflowInvoker(activity);
if (extensions != null)
{
foreach (var ext in extensions)
{
invoker.Extensions.Add(ext);
}
}
invoker.Invoke(parameters);
//}
//else
//{
// throw new ValidationException();
//}
//ActivityInvoker.Invoke(activity, parameters, extensions);
return retVal;
}
public static MatchingResultDto[] GetMatchings(string code, string pattern, LanguageFlags analyzedLanguages,
LanguageFlags?patternLanguages = null)
{
var sourceCodeRep = new MemoryCodeRepository(code);
var patternsRep = new MemoryPatternsRepository();
var workflow = new Workflow(sourceCodeRep, analyzedLanguages, patternsRep)
{
Logger = new LoggerMessageCounter()
};
var processor = new DslProcessor();
var patternNode = (PatternNode)processor.Deserialize(pattern, patternLanguages ?? LanguageExt.AllPatternLanguages);
var p = new Pattern
{
Data = patternNode,
DebugInfo = pattern
};
var patternsConverter = new PatternConverter(
new JsonUstNodeSerializer(typeof(UstNode), typeof(PatternVarDef)));
patternsRep.Add(patternsConverter.ConvertBack(new List <Pattern>()
{
p
}));
WorkflowResult workflowResult = workflow.Process();
MatchingResultDto[] matchingResults = workflowResult.MatchingResults.ToDto(workflow.SourceCodeRepository)
.OrderBy(r => r.PatternKey)
.ToArray();
return(matchingResults);
}
public static void ResumeWorkflowTimer(IApplicationHost host, IDbContext dbContext, IMessaging messaging, Int64 processId)
{
AppWorkflow aw = null;
var result = new WorkflowResult
{
InboxIds = new List <Int64>()
};
try
{
var pi = ProcessInfo.Load(dbContext, processId, 0);
var def = WorkflowDefinition.Load(pi);
Activity root = def.LoadFromDefinition();
aw = Create(dbContext, root, null, def.Identity);
aw._application.Extensions.Add(dbContext);
aw._application.Extensions.Add(messaging);
aw._application.Extensions.Add(host);
aw._application.Extensions.Add(result);
WorkflowApplicationInstance instance = WorkflowApplication.GetInstance(pi.WorkflowId, aw._application.InstanceStore);
aw._application.Load(instance, _wfTimeSpan);
aw._application.Run(_wfTimeSpan);
}
catch (Exception ex)
{
if (!CatchWorkflow(aw, ex))
{
throw;
}
}
finally
{
ProcessFinally(aw);
}
}
public void Setup()
{
_workflowResult = WorkflowResult.Finished;
_jobInfoQueue = Substitute.For <IJobInfoQueue>();
_profiles = new ObservableCollection <ConversionProfile>();
_profiles.Add(new ConversionProfile
{
Guid = "SomeGuid"
});
_profiles.Add(new ConversionProfile
{
Guid = "AnotherGuid",
AutoSave = new AutoSave
{
Enabled = true
}
});
_conversionWorkflow = Substitute.For <IConversionWorkflow>();
_conversionWorkflow.RunWorkflow(Arg.Any <Job>())
.Returns(x =>
{
var job = x.Arg <Job>();
job.Completed = true;
return(_workflowResult);
});
}
public void Match_PatternExpressionsInCalls(string patternData, params int[] matchMethodNumbers)
{
var processor = new DslProcessor();
var patternNode = (PatternNode)processor.Deserialize(patternData, LanguageExt.AllPatternLanguages);
Pattern pattern = new Pattern
{
Data = patternNode,
DebugInfo = patternData
};
patternsRep.Add(patternsConverter.ConvertBack(new List <Pattern>()
{
pattern
}));
WorkflowResult workflowResult = workflow.Process();
MatchingResultDto[] matchingResults = workflowResult.MatchingResults.ToDto(workflow.SourceCodeRepository);
patternsRep.Clear();
Assert.AreEqual(matchMethodNumbers.Contains(0) ? 1 : 0, matchingResults.Count(r => r.MatchedCode.StartsWith("test_call_0")));
Assert.AreEqual(matchMethodNumbers.Contains(1) ? 1 : 0, matchingResults.Count(r => r.MatchedCode.StartsWith("test_call_1")));
Assert.AreEqual(matchMethodNumbers.Contains(2) ? 1 : 0, matchingResults.Count(r => r.MatchedCode.StartsWith("test_call_2")));
Assert.AreEqual(matchMethodNumbers.Contains(3) ? 1 : 0, matchingResults.Count(r => r.MatchedCode.StartsWith("test_call_3")));
Assert.AreEqual(matchMethodNumbers.Contains(4) ? 1 : 0, matchingResults.Count(r => r.MatchedCode.StartsWith("test_call_4")));
}
/// <summary>
/// Производит конфигурацию метода и вызов рабочего потока.
/// </summary>
/// <typeparam name="TParameters">Тип параметров.</typeparam>
/// <param name="cfg">Объект рабочего потока для конфигурации вызово..</param>
/// <param name="parameters">Первоначальные параметры.</param>
/// <param name="errorHandler">Хэндлер с ошибкой.</param>
/// <returns>Результат.</returns>
protected async Task <WorkflowResult> Execute <TParameters>(Action <WorkflowArea> cfg, TParameters parameters, Action <MessageOutputBase> errorHandler)
{
WorkflowResult result = null;
try
{
var workFlow = CreateWorkflow();
cfg(workFlow);
result = await workFlow.Start(parameters);
}
catch (Exception e)
{
var logger = StartEnumServer.Instance.GetLogger();
var errorParameters = new List <LoggerParameter>();
errorParameters.Add(new LoggerParameter("IsController", "true"));
errorParameters.Add(new LoggerParameter("UserName", GetCurrentUser()));
errorParameters.Add(new LoggerParameter("UserId", GetCurrentUserId() ?? Guid.Empty));
errorParameters.Add(new LoggerParameter("RequestMethod", Request.Method));
errorParameters.Add(new LoggerParameter("RequestUri", Request.QueryString));
errorParameters.Add(new LoggerParameter("RequestUri", GetClientIp()));
logger.LogError(GetType(), "Во время запроса WebApi произошла ошибка: " + e.GetExceptionDetails(), errorParameters.ToArray());
errorHandler?.Invoke(CreateErrorMessage(e));
}
return(result);
}
public async Task <ServerCommandResult> Execute(RequestCommand cmd, ExpandoObject dataToExec)
{
var swi = new StartWorkflowInfo
{
DataSource = cmd.CurrentSource,
Schema = cmd.CurrentSchema,
Model = cmd.CurrentModel,
ModelId = dataToExec.Get <Int64>("Id"),
ActionBase = cmd.ActionBase
};
if (swi.ModelId == 0)
{
throw new RequestModelException("Id must be specified to 'startProcess' command");
}
if (!String.IsNullOrEmpty(cmd.file))
{
swi.Source = $"file:{cmd.file}";
}
swi.Comment = dataToExec.Get <String>("Comment");
swi.UserId = dataToExec.Get <Int64>("UserId");
if (swi.Source == null)
{
throw new RequestModelException($"File or clrType must be specified to 'startProcess' command");
}
WorkflowResult wr = await _workflowEngine.StartWorkflow(swi);
return(new ServerCommandResult(JsonConvert.SerializeObject(wr, JsonHelpers.StandardSerializerSettings)));
}
private void btnApproval_Click(object sender, EventArgs e)
{
WorkflowResult result = EAS.Application.Instance.WorkflowRuntime.Approval(this);
this.OnWorkflowResultChaned(result);
this.btnClose_Click(this.btnClose, e);
}
public void Match_TestPatternsPhp_MatchedAllDefault()
{
var path = Path.Combine(TestUtility.TestsDataPath, "Patterns.php");
var sourceCodeRep = new FileCodeRepository(path);
var workflow = new Workflow(sourceCodeRep, Global.PatternsRepository);
WorkflowResult workflowResult = workflow.Process();
IEnumerable <MatchResultDto> matchResults = workflowResult.MatchResults
.ToDto()
.OrderBy(r => r.PatternKey);
IEnumerable <PatternDto> patternDtos = Global.PatternsRepository.GetAll()
.Where(patternDto => patternDto.Languages.Contains("Php"));
foreach (PatternDto dto in patternDtos)
{
Assert.Greater(matchResults.Count(p => p.PatternKey == dto.Key), 0, dto.Description);
}
Assert.AreEqual(1, matchResults.Count(r =>
r.MatchedCode.Contains("Configure") &&
r.MatchedCode.Contains("write") &&
r.MatchedCode.Contains("3")));
Assert.AreEqual(0, matchResults.Count(r =>
r.MatchedCode.Contains("Configure") &&
r.MatchedCode.Contains("write") &&
r.MatchedCode.Contains("50")));
}
async Task StartWorkflow(RequestCommand cmd, ExpandoObject dataToStart, TextWriter writer)
{
if (_workflowEngine == null)
{
throw new InvalidOperationException($"Service 'IWorkflowEngine' not registered");
}
var swi = new StartWorkflowInfo
{
DataSource = cmd.CurrentSource,
Schema = cmd.CurrentSchema,
Model = cmd.CurrentModel,
ModelId = dataToStart.Get <Int64>("Id"),
ActionBase = cmd.ActionBase
};
if (swi.ModelId == 0)
{
throw new RequestModelException("Id must be specified to 'startProcess' command");
}
if (!String.IsNullOrEmpty(cmd.file))
{
swi.Source = $"file:{cmd.file}";
}
swi.Comment = dataToStart.Get <String>("Comment");
swi.UserId = dataToStart.Get <Int64>("UserId");
if (swi.Source == null)
{
throw new RequestModelException($"File or clrType must be specified to 'startProcess' command");
}
WorkflowResult wr = await _workflowEngine.StartWorkflow(swi);
WriteJsonResult(writer, wr);
}
public async Task <ActionResult> OnPostDeleteOrderAsync([FromServices] OrderFactory orderFactory)
{
if (orderFactory == null)
{
throw new ArgumentNullException(nameof(orderFactory));
}
ModelState.Clear();
EnaBricks.Generics.Option <IOrder> orderOption = await orderFactory.OrderAsync(Id);
if (!orderOption.Any())
{
return(Redirect("/Error"));
}
IOrder order = orderOption.Single();
WorkflowResult result = await order.CancelAsync(UserId());
if (!result.Success)
{
for (int i = 0; i < result.Errors.Length; i++)
{
ModelState.TryAddModelError("", result.Errors[i]);
}
}
return(await TryLoadViewModelAsync());
}
public async Task <WorkflowResult> DeleteAditionalServiceAsync(int aditionalServiceId)
{
using (TransactionScope transactionScope = new TransactionScope(TransactionScopeAsyncFlowOption.Enabled))
{
try
{
WorkflowResult workflowResult = await _decorated.DeleteAditionalServiceAsync(aditionalServiceId);
if (workflowResult.Success)
{
transactionScope.Complete();
}
else
{
Transaction.Current.Rollback();
}
return(workflowResult);
}
catch
{
Transaction.Current.Rollback();
throw;
}
}
}
public async Task <WorkflowResult> AddPriceDetailAsync(int priceCategoryId, string description, decimal unitPrice)
{
using (TransactionScope transactionScope = new TransactionScope(TransactionScopeAsyncFlowOption.Enabled))
{
try
{
WorkflowResult workflowResult = await _decorated.AddPriceDetailAsync(priceCategoryId, description, unitPrice);
if (workflowResult.Success)
{
transactionScope.Complete();
}
else
{
Transaction.Current.Rollback();
}
return(workflowResult);
}
catch
{
Transaction.Current.Rollback();
throw;
}
}
}
public async Task <WorkflowResult> UpdateDescriptionAsync(string description)
{
using (TransactionScope transactionScope = new TransactionScope(TransactionScopeAsyncFlowOption.Enabled))
{
try
{
WorkflowResult workflowResult = await _decorated.UpdateDescriptionAsync(description);
if (workflowResult.Success)
{
transactionScope.Complete();
}
else
{
Transaction.Current.Rollback();
}
return(workflowResult);
}
catch
{
Transaction.Current.Rollback();
throw;
}
}
}
public async Task <WorkflowResult> CreateAsync(
Guid excursionId,
KeyValuePair <int, int>[] aditionalServices,
KeyValuePair <int, int>[] orderDetails,
Guid userId)
{
using (TransactionScope transactionScope = new TransactionScope(TransactionScopeAsyncFlowOption.Enabled))
{
Exception appException = null;
try
{
WorkflowResult workflowResult = await _decorated.CreateAsync(
excursionId,
aditionalServices,
orderDetails,
userId);
if (workflowResult.Success)
{
transactionScope.Complete();
}
else
{
Transaction.Current.Rollback();
}
return(workflowResult);
}
catch (Exception ex)
{
Transaction.Current.Rollback();
if (ex != null)
{
appException = ex;
}
}
int errorId = 0;
if (appException != null)
{
errorId = await _applicationLog.LogExceptionAsync(appException);
}
if (errorId > 0)
{
return(new WorkflowResult(
new[] {
Resources.Resource.InternalServerErrorMessage,
string.Format(Resources.Resource.GeneratedErrorIdMessage, errorId)
}));
}
return(new WorkflowResult(
new[] {
Resources.Resource.InternalServerErrorMessage
}));
}
}
/// <summary>
/// Starts the specified workflow.
/// </summary>
/// <param name="workflow">The workflow.</param>
public void Start(Models.Domain.Workflow.WorkflowInstance workflow)
{
Log.Debug($"Start({workflow})");
//TODO: Block concurrent calls to Start/Process?
Unloaded.Reset();
Result = new WorkflowResult();
Application = CreateWorkflowApplication(workflow);
Application.Run();
}
/// <summary>
/// Starts the specified workflow.
/// </summary>
/// <param name="workflow">The workflow.</param>
public void Start(IWorkflow workflow)
{
Log.DebugFormat("Start({0})", workflow);
//TODO: Block concurrent calls to Start/Process?
Unloaded.Reset();
Result = new WorkflowResult();
Application = CreateWorkflowApplication(workflow);
Application.Run();
}
static void Main(string[] args)
{
var fileRepository = new FileCodeRepository("code.php");
var patternsRepostiory = new FilePatternsRepository("patterns.json");
var workflow = new Workflow(fileRepository, patternsRepostiory);
workflow.IsIncludeIntermediateResult = true;
WorkflowResult result = workflow.Process();
var lineTokenDict = new Dictionary <int, List <string> >();
foreach (var matchingResult in result.MatchingResults)
{
var matchedNode = matchingResult.Nodes.Last();
UstNode[] descendants = matchedNode.GetAllDescendants();
foreach (UstNode descendant in descendants)
{
string text = null;
if (descendant.NodeType == NodeType.InvocationExpression)
{
text = "Method invocation: " + ((InvocationExpression)descendant).Target;
}
else if (descendant.NodeType == NodeType.IndexerDeclaration)
{
text = "Arrays with user input: " + ((IndexerExpression)descendant).Target;
}
else if (descendant.NodeType == NodeType.CastExpression)
{
text = "Cast to type: " + ((CastExpression)descendant).Type;
}
if (!string.IsNullOrEmpty(text))
{
SourceCodeFile sourceCodeFile = result.SourceCodeFiles.Single(file => file.FullPath == descendant.FileNode.FileName.Text);
LineColumnTextSpan lineColumnTextSpan = sourceCodeFile.GetLineColumnTextSpan(descendant.TextSpan);
List <string> strs;
if (!lineTokenDict.TryGetValue(lineColumnTextSpan.BeginLine, out strs))
{
strs = new List <string>();
lineTokenDict[lineColumnTextSpan.BeginLine] = strs;
}
strs.Add(text);
}
}
}
foreach (var item in lineTokenDict)
{
Console.WriteLine(String.Format("{0}: {1}", item.Key, string.Join(", ", item.Value)));
}
Console.ReadLine();
}
/// <summary>
/// OnWorkflowComplete Callback
/// </summary>
/// <remarks>
/// Runs after everything else complete.
/// </remarks>
/// <param name="context">NativeActivityContext</param>
/// <param name="completedInstance">ActivityInstance</param>
private void OnWorkflowCompleteCallback(NativeActivityContext context, ActivityInstance completedInstance)
{
Logger.Debug("OnWorkflowCompleteCallback -> Start");
var workflowStatus = context.GetExtension <WorkflowStateData>();
WorkflowResult.Set(context, workflowStatus.Result);
Logger.Debug("OnWorkflowCompleteCallback -> End");
}
public void Match_HtmlTestPatterns_MatchedExpected()
{
WorkflowResult result = TestHelper.CheckFile("Patterns.html", Language.Html, Stage.Match,
isIgnoreFilenameWildcards: true);
Assert.AreEqual(3, result.MatchingResults.Count);
Assert.AreEqual(TextSpan.FromBounds(95, 103), result.MatchingResults[0].TextSpan);
Assert.AreEqual(TextSpan.FromBounds(72, 86), result.MatchingResults[1].TextSpan);
Assert.AreEqual(TextSpan.FromBounds(128, 136), result.MatchingResults[2].TextSpan);
}
static void Main(string[] args)
{
var solver = new QuadraticEquationSolver();
WorkflowResult flag = solver.Start(1, 10, 16, out Tuple <Complex, Complex> result);
if (flag == WorkflowResult.Success)
{
// USE result
}
}
public static async Task <WorkflowResult> StartWorkflow(IApplicationHost host, IDbContext dbContext, IMessaging messaging, StartWorkflowInfo info)
{
AppWorkflow aw = null;
var profiler = host.Profiler;
var result = new WorkflowResult
{
InboxIds = new List <Int64>()
};
try
{
WorkflowDefinition def = null;
Activity root = null;
Process process = null;
using (profiler.CurrentRequest.Start(ProfileAction.Workflow, $"Load '{info.Source}'"))
{
def = WorkflowDefinition.Create(info.Source);
root = def.LoadFromSource(host, dbContext);
process = Process.Create(def, info);
}
// workflow arguments
IDictionary <String, Object> args = new Dictionary <String, Object>
{
{ "Process", process },
{ "Comment", info.Comment }
};
aw = Create(dbContext, root, args, def.Identity);
aw._application.Extensions.Add(result);
aw._application.Extensions.Add(dbContext);
aw._application.Extensions.Add(messaging);
aw._application.Extensions.Add(host);
process.DbContext = dbContext;
process.WorkflowId = aw._application.Id;
await process.Start(dbContext);
using (profiler.CurrentRequest.Start(ProfileAction.Workflow, $"Run. Process.Id = {process.Id}, Workflow.Id={process.WorkflowId}"))
{
aw._application.Run(_wfTimeSpan);
result.ProcessId = process.Id;
return(result);
}
}
catch (Exception ex)
{
if (!CatchWorkflow(aw, ex))
{
throw;
}
return(result);
}
finally
{
ProcessFinally(aw);
}
}
async Task StartWorkflowInt()
{
var info = new StartWorkflowInfo()
{
Source = "file:Workflows/SimpleWorkflow_v1",
UserId = 50, // predefined user id
};
WorkflowResult result = await _workflow.StartWorkflow(info);
Assert.AreNotEqual(0, result.ProcessId);
}
public void Check_AllDescendants_HaveParentsAfterPreprocess()
{
WorkflowResult result = TestHelper.CheckFile("AllInOne.cs", Language.CSharp, Stage.Preprocess);
IEnumerable <UstNode> descendantsExceptFirst = result.Usts.First().Root.GetAllDescendants().Skip(1);
foreach (var descendant in descendantsExceptFirst)
{
Assert.IsNotNull(descendant.Parent);
}
}
