protected override async Task <ActivityExecutionResult> OnExecuteAsync(HttpResponseAction activity, WorkflowExecutionContext workflowContext, CancellationToken cancellationToken)
{
var response = httpContextAccessor.HttpContext.Response;
response.StatusCode = (int)activity.StatusCode;
response.ContentType = await expressionEvaluator.EvaluateAsync(activity.ContentType, workflowContext, cancellationToken);
var headersText = await expressionEvaluator.EvaluateAsync(activity.ResponseHeaders, workflowContext, cancellationToken);
if (headersText != null)
{
var headersQuery =
from line in Regex.Split(headersText, "\\n", RegexOptions.Multiline)
let pair = line.Split(':', '=')
select new KeyValuePair <string, string>(pair[0], pair[1]);
foreach (var header in headersQuery)
{
var headerValueExpression = new WorkflowExpression <string>(activity.ResponseHeaders.Syntax, header.Value);
response.Headers[header.Key] = await expressionEvaluator.EvaluateAsync(headerValueExpression, workflowContext, cancellationToken);
}
}
var bodyText = await expressionEvaluator.EvaluateAsync(activity.Body, workflowContext, cancellationToken);
if (!string.IsNullOrWhiteSpace(bodyText))
{
await response.WriteAsync(bodyText, cancellationToken);
}
return(TriggerEndpoint("Done"));
}
public async Task <T> EvaluateAsync <T>(WorkflowExpression <T> expression, WorkflowExecutionContext workflowContext)
{
var templateContext = CreateTemplateContext(workflowContext);
var expressionContext = new WorkflowExecutionExpressionContext(templateContext, workflowContext);
await _workflowContextHandlers.InvokeAsync(x => x.EvaluatingExpressionAsync(expressionContext), _logger);
var result = await _liquidTemplateManager.RenderAsync(expression.Expression, System.Text.Encodings.Web.JavaScriptEncoder.Default, templateContext);
return(string.IsNullOrWhiteSpace(result) ? default(T) : (T)Convert.ChangeType(result, typeof(T)));
}
public async Task <T> EvaluateAsync <T>(WorkflowExpression <T> expression, WorkflowExecutionContext workflowContext, params IGlobalMethodProvider[] scopedMethodProviders)
{
var workflowType = workflowContext.WorkflowType;
var directive = $"js:{expression}";
var expressionContext = new WorkflowExecutionScriptContext(workflowContext);
await _workflowContextHandlers.InvokeAsync(async x => await x.EvaluatingScriptAsync(expressionContext), _logger);
var methodProviders = scopedMethodProviders.Concat(expressionContext.ScopedMethodProviders);
return((T)_scriptingManager.Evaluate(directive, null, null, methodProviders));
}
public async Task <T> EvaluateAsync <T>(WorkflowExpression <T> expression, WorkflowExecutionContext workflowContext, TextEncoder encoder)
{
var templateContext = CreateTemplateContext(workflowContext);
var expressionContext = new WorkflowExecutionExpressionContext(templateContext, workflowContext);
await _workflowContextHandlers.InvokeAsync((h, expressionContext) => h.EvaluatingExpressionAsync(expressionContext), expressionContext, _logger);
// Set WorkflowContext as a local scope property.
var result = await _liquidTemplateManager.RenderAsync(
expression.Expression,
encoder ?? NullEncoder.Default,
scope => scope.SetValue("Workflow", workflowContext)
);
return(string.IsNullOrWhiteSpace(result) ? default(T) : (T)Convert.ChangeType(result, typeof(T)));
}
public async Task <T> EvaluateAsync <T>(WorkflowExpression <T> expression, WorkflowExecutionContext workflowContext, TextEncoder encoder)
{
var templateContext = new TemplateContext(_templateOptions);
var expressionContext = new WorkflowExecutionExpressionContext(templateContext, workflowContext);
await _workflowContextHandlers.InvokeAsync((h, expressionContext) => h.EvaluatingExpressionAsync(expressionContext), expressionContext, _logger);
// Set WorkflowContext as a local scope property.
var result = await _liquidTemplateManager.RenderStringAsync(
expression.Expression,
encoder ?? NullEncoder.Default,
new Dictionary <string, FluidValue>() { ["Workflow"] = new ObjectValue(workflowContext) }
);
return(String.IsNullOrWhiteSpace(result) ? default : (T)Convert.ChangeType(result, typeof(T)));
}
public async Task <T> EvaluateAsync <T>(WorkflowExpression <T> expression, WorkflowExecutionContext workflowContext, params IGlobalMethodProvider[] scopedMethodProviders)
{
if (String.IsNullOrWhiteSpace(expression.Expression))
{
return(await Task.FromResult <T>(default(T)));
}
var workflowType = workflowContext.WorkflowType;
var directive = $"js:{expression}";
var expressionContext = new WorkflowExecutionScriptContext(workflowContext);
await _workflowContextHandlers.InvokeAsync((h, expressionContext) => h.EvaluatingScriptAsync(expressionContext), expressionContext, _logger);
var methodProviders = scopedMethodProviders.Concat(expressionContext.ScopedMethodProviders);
return((T)_scriptingManager.Evaluate(directive, null, null, methodProviders));
}
public ActionResult ContentModeratorWorkflowCreate(string teamName, string workflowName)
{
//only text or numbers. no special characters
if (!workflowName.All(char.IsLetterOrDigit))
{
return(ContentModeratorWorkflow());
}
WorkflowExpression we = new WorkflowExpression()
{
Description = $"New Sample Workflow: {workflowName}",
Type = ContentModeratorReviewType.Image,
Expression = new Condition
{
Operator = "ge",
OutputName = "adultscore",
Value = "0.1"
}
};
var result = ContentModeratorService.CreateOrUpdateWorkflow(teamName, workflowName, we);
if (!result)
{
return(ContentModeratorWorkflow());
}
var wer = new WorkflowExpressionResponse()
{
Description = we.Description,
Name = workflowName
};
return(View("ContentModerator/Workflow", new WorkflowResult()
{
Workflow = wer
}));
}
public virtual bool CreateOrUpdateWorkflow(string teamName, string workflowName, WorkflowExpression expression)
{
try
{
var result = Task.Run(async() => await ContentModeratorRepository.CreateOrUpdateWorkflowAsync(teamName, workflowName, expression)).Result;
return(result);
}
catch (Exception ex)
{
Logger.Error("ContentModeratorService.CreateOrUpdateWorkflow failed", this, ex);
}
return(false);
}
public WriteLine(string text)
{
TextExpression = new WorkflowExpression <string>(PlainTextEvaluator.SyntaxName, text);
}
public async Task <T> EvaluateAsync <T>(WorkflowExpression <T> expression, WorkflowExecutionContext workflowContext, params IGlobalMethodProvider[] scopedMethodProviders)
{
if (String.IsNullOrWhiteSpace(expression.Expression))
{
return(default);
public virtual async Task <bool> CreateOrUpdateWorkflowAsync(string teamName, string workflowName, WorkflowExpression expression)
{
var data = JsonConvert.SerializeObject(expression);
var response = await RepositoryClient.SendAsync(
ApiKeys.ContentModerator,
$"{ApiKeys.ContentModeratorEndpoint}{reviewUrl}{teamName}/workflows/{workflowName}",
RepositoryClient.GetByteArray(data),
"application/json",
"PUT",
GetToken());
return(JsonConvert.DeserializeObject <bool>(response));
}
public ExpressionViewModel(WorkflowExpression workflowExpression)
{
Expression = workflowExpression?.Expression;
Syntax = workflowExpression?.Syntax;
}
public virtual bool CreateOrUpdateWorkflow(string teamName, string workflowName, WorkflowExpression expression)
{
return(PolicyService.ExecuteRetryAndCapture400Errors(
"ContentModeratorService.CreateOrUpdateWorkflow",
ApiKeys.ContentModeratorRetryInSeconds,
() =>
{
var result = ContentModeratorRepository.CreateOrUpdateWorkflow(teamName, workflowName, expression);
return result;
},
false));
}
public ExpressionViewModel(WorkflowExpression workflowExpression)
: this(workflowExpression?.Expression, workflowExpression?.Syntax)
{
}
