public HttpResponseMessage Operations(string op, string woid, string wcode, [FromBody] IEnumerable <WfProperty> props)
{
Guid oid;
if (!string.IsNullOrWhiteSpace(woid) && !Guid.TryParse(woid, out oid))
{
throw new HttpResponseException(HttpStatusCode.BadRequest);
}
try
{
if (op.Equals(WorkflowOperation.Start.ToString(), StringComparison.OrdinalIgnoreCase))
{
var startWorkflowRequest = new StartWorkflowRequest
{
Domain = ConfigHelper.WorkflowDomain,
WorkflowCode = wcode,
WfRuntimeValues = props.ToArray()
};
TasksService.StartWorkflow(startWorkflowRequest);
}
else
{
return(Request.CreateResponse(HttpStatusCode.BadRequest));
}
}
catch (Exception ex)
{
return(Request.CreateResponse(HttpStatusCode.InternalServerError));
}
return(Request.CreateResponse(HttpStatusCode.OK));
}
public async Task Send_workflow_start_request_to_amazon_swf()
{
var response = new StartWorkflowExecutionResponse()
{
Run = new Run()
};
_amazonWorkflowClient.Setup(c => c.StartWorkflowExecutionAsync(
It.IsAny <StartWorkflowExecutionRequest>(),
It.IsAny <CancellationToken>()))
.Returns(Task.FromResult(response));
var startRequest = new StartWorkflowRequest("workflowName", "version", "workflowId")
{
ChildPolicy = ChildPolicy.Abandon,
TaskListName = "tlist",
ExecutionStartToCloseTimeout = TimeSpan.FromSeconds(10),
Input = "input",
LambdaRole = "lrole",
Tags = new List <string> {
"tag1", "tag2"
},
TaskPriority = 2,
TaskStartToCloseTimeout = TimeSpan.FromSeconds(23)
};
await _domain.StartWorkflowAsync(startRequest);
AssertThatAmazonSwfIsSend(startRequest);
}
public void Invalid_argument_tests()
{
Assert.Throws <ArgumentException>(() => new StartWorkflowRequest("", "1.0", "id"));
Assert.Throws <ArgumentException>(() => new StartWorkflowRequest("name", "", "id"));
Assert.Throws <ArgumentException>(() => new StartWorkflowRequest("name", "1.0", ""));
Assert.Throws <ArgumentException>(() => StartWorkflowRequest.For <TestWorkflow>(null));
}
private static string Start(string workflowCode)
{
string workflowId;
var startWorkflowRequest = new StartWorkflowRequest
{
Domain = "google",
WorkflowCode = workflowCode,
WfRuntimeValues = new[]
{
new WfProperty
{
Name = "Prop1",
Type = "S",
Value = "Val1"
}
}
};
StartWorkflowResponse startWorkflowResponse = null;
using (var src = new FlowTasksService())
{
startWorkflowResponse = src.StartWorkflow(startWorkflowRequest);
}
System.Threading.Thread.Sleep(1000);
workflowId = startWorkflowResponse.WorkflowId;
return(workflowId);
}
/// <summary>
/// Start a workflow in Amazon SWF. This workflow must be already registered with Amazon SWF.
/// </summary>
/// <param name="startRequest"></param>
/// <returns></returns>
public async Task <string> StartWorkflowAsync(StartWorkflowRequest startRequest)
{
Ensure.NotNull(startRequest, nameof(startRequest));
var response = await _simpleWorkflowClient.StartWorkflowExecutionAsync(startRequest.SwfFormat(_name));
return(response.Run.RunId);
}
public void Populates_properties_from_workflow_description()
{
var request = StartWorkflowRequest.For <TestWorkflow>("workflowId");
Assert.That(request.WorkflowName, Is.EqualTo("TestWorkflow"));
Assert.That(request.Version, Is.EqualTo("1.0"));
Assert.That(request.WorkflowId, Is.EqualTo("workflowId"));
}
public void Serialize_complex_input_to_json_format()
{
var request = StartWorkflowRequest.For <TestWorkflow>("workflowId");
request.Input = new { Id = 10 };
var swfRequest = request.SwfFormat("domain");
Assert.That(swfRequest.Input, Is.EqualTo("{\"Id\":10}"));
}
public async Task <string> StartWorkflow <TWorkflow>(string input, string taskListName) where TWorkflow : Workflow
{
var workflowId = Guid.NewGuid().ToString();
var startRequest = StartWorkflowRequest.For <TWorkflow>(workflowId);
startRequest.TaskListName = taskListName;
startRequest.Input = input;
await _domain.StartWorkflowAsync(startRequest);
return(workflowId);
}
public HttpResponseMessage Deploy(string fname)
{
try
{
//return new HttpResponseMessage(HttpStatusCode.Created);
var sketches = TasksService.GetSketchForFilter(new GetSketchForFilterRequest
{
Name = fname,
Statuses = new[] { SketchStatusType.Saved }
});
if (sketches.Sketches.Any())
{
var startWorkflowRequest = new StartWorkflowRequest
{
Domain = ConfigHelper.WorkflowDomain,
WorkflowCode = ConfigHelper.WorkflowCodeSketch,
WfRuntimeValues = new[]
{
new WfProperty
{
Name = ConfigHelper.WorkflowPropertyDocumentOid,
Type = PropertyType.FlowDoc.ToString(),
Value = sketches.Sketches[0].XamlxOid.ToString()
},
new WfProperty
{
Name = ConfigHelper.WorkflowPropertyCode,
Type = PropertyType.String.ToString(),
Value = fname
}
}
};
TasksService.StartWorkflow(startWorkflowRequest);
}
TasksService.SketchWorkflow(new SketchWorkflowRequest
{
Name = fname,
ChangedBy = User.Identity.Name,
Status = SketchStatusType.DeployedDev
});
return(new HttpResponseMessage(HttpStatusCode.Created));
}
catch (Exception ex)
{
return(Request.CreateResponse(HttpStatusCode.InternalServerError, ex));
}
}
/// <summary>
/// Start Workflow
/// </summary>
/// <param name="request">Request</param>
/// <returns>StartWorkflowResponse</returns>
public StartWorkflowResponse StartWorkflow(StartWorkflowRequest request)
{
var proxy = _proxyManager.GetProxyForWorkflow(request.WorkflowCode);
var resp = proxy.StartWorkflow1(request);
var toDispose = proxy as System.ServiceModel.ClientBase <IFlowTasksOperations>;
if (toDispose != null)
{
toDispose.Close();
}
return(resp);
}
[HttpPost] //
public ActionResult DeployWorkflow(string fname, string content)
{
if (ModelState.IsValid)
{
var sketches = TasksService.GetSketchForFilter(new GetSketchForFilterRequest
{
Name = fname,
Statuses = new[] { SketchStatusType.Saved }
});
if (sketches.Sketches.Any())
{
var startWorkflowRequest = new StartWorkflowRequest
{
Domain = ConfigHelper.WorkflowDomain,
WorkflowCode = ConfigHelper.WorkflowCodeSketch,
WfRuntimeValues = new[]
{
new WfProperty
{
Name = ConfigHelper.WorkflowPropertyDocumentOid,
Type = PropertyType.FlowDoc.ToString(),
Value = sketches.Sketches[0].XamlxOid.ToString()
},
new WfProperty
{
Name = ConfigHelper.WorkflowPropertyCode,
Type = PropertyType.String.ToString(),
Value = fname
}
}
};
TasksService.StartWorkflow(startWorkflowRequest);
}
TasksService.SketchWorkflow(new SketchWorkflowRequest
{
Name = fname,
ChangedBy = User.Identity.Name,
Status = SketchStatusType.DeployedDev
});
return(Json("WorkFlow Deployed!"));
}
return(Json("Error"));
}
/// <summary>
/// Get Parameters From Request
/// </summary>
/// <param name="request">StartWorkflowRequest</param>
/// <returns>List of PropertyInfo</returns>
private IEnumerable <Contract.Message.PropertyInfo> GetParametersFromRequest(StartWorkflowRequest request)
{
var res = new List <Contract.Message.PropertyInfo>();
if (request.WfRuntimeValues == null)
{
return(res);
}
foreach (var d in request.WfRuntimeValues)
{
res.Add(new Contract.Message.PropertyInfo {
Name = d.Name, Value = d.Value, Type = d.Type
});
}
return(res);
}
public string UploadFile()
{
try
{
var info = new DocumentInfo {
DocumentName = Path.GetFileName(FileName), Path = Path.GetDirectoryName(FileName), Description = "desc-test", Owner = "owner", Version = 1
};
var oid = _processDocs.UploadDocument(info, FileName, DocumentUploadMode.NewVersion);
var startWorkflowRequest = new StartWorkflowRequest
{
Domain = ConfigHelper.WorkflowDomain,
WorkflowCode = ConfigHelper.WorkflowCode,
WfRuntimeValues = new WfProperty[]
{
new WfProperty
{
Name = ConfigHelper.WorkflowProperty,
Type = PropertyType.FlowDoc.ToString(),
Value = oid.ToString()
}
}
};
if (_serviceTasks != null)
{
_serviceTasks.StartWorkflow(startWorkflowRequest);
}
else
{
using (FlowTasksService proxy = new FlowTasksService())
{
var startWorkflowResponse = proxy.StartWorkflow(startWorkflowRequest);
}
}
return(null);
}
catch (Exception e)
{
return(e.Message);
}
}
public async Task RunAction(
[ActivityTrigger] IDurableActivityContext context,
ILogger logger)
{
WorkflowMessageEnvelope envelope =
context.GetInputWithCustomSerializationSettings <WorkflowMessageEnvelope>(this.serializerSettingsProvider.Instance);
logger.LogInformation(
$"Making function call for StartWorkflowInstanceRequest {envelope.StartWorkflowInstanceRequest.RequestId}");
var body = new StartWorkflowRequest
{
Context = envelope.StartWorkflowInstanceRequest.Context,
WorkflowId = envelope.StartWorkflowInstanceRequest.WorkflowId,
WorkflowInstanceId = envelope.StartWorkflowInstanceRequest.WorkflowInstanceId,
RequestId = envelope.StartWorkflowInstanceRequest.RequestId,
};
await this.engineClient.StartWorkflowInstanceAsync(envelope.TenantId, body);
}
/// <summary>
/// Invoke Workflow
/// </summary>
/// <remarks>
/// Start a new WorkflowCode workflow.
/// </remarks>
/// <param name="parentWorkflowId">Parent Workflow Id</param>
/// <param name="workflowCode">Workflow Code</param>
/// <param name="domain">Domain</param>
/// <param name="properties">Properties</param>
/// <param name="async">async</param>
/// <returns>Workflow Id</returns>
private string InvokeWorkflow(Guid parentWorkflowId, string workflowCode, string domain, Dictionary <string, string> properties, bool async)
{
var startWorkflowRequest = new StartWorkflowRequest
{
ParentWorkflowId = parentWorkflowId.ToString(),
Domain = domain,
WorkflowCode = workflowCode,
WfRuntimeValues = CreatePropertiesFromDictionary(properties),
CorrelationId = CorrelationId,
WaitForChild = !async
};
StartWorkflowResponse startWorkflowResponse;
using (var proxy = new Proxy.FlowTasksService())
{
startWorkflowResponse = proxy.StartWorkflow(startWorkflowRequest);
}
string workflowId = startWorkflowResponse.WorkflowId;
return(workflowId);
}
private void AssertThatAmazonSwfIsSend(StartWorkflowRequest request)
{
Func <StartWorkflowExecutionRequest, bool> startRequest = s =>
{
Assert.That(request.WorkflowId, Is.EqualTo(s.WorkflowId));
Assert.That(request.WorkflowName, Is.EqualTo(s.WorkflowType.Name));
Assert.That(request.Version, Is.EqualTo(s.WorkflowType.Version));
Assert.That(request.Input, Is.EqualTo(s.Input));
Assert.That(request.ChildPolicy, Is.EqualTo(s.ChildPolicy.Value));
Assert.That(request.LambdaRole, Is.EqualTo(s.LambdaRole));
Assert.That(request.TaskListName, Is.EqualTo(s.TaskList.Name));
Assert.That(request.TaskPriority, Is.EqualTo(int.Parse(s.TaskPriority)));
Assert.That(request.Tags, Is.EqualTo(s.TagList));
Assert.That(request.TaskStartToCloseTimeout, Is.EqualTo(TimeSpan.FromSeconds(int.Parse(s.TaskStartToCloseTimeout))));
Assert.That(request.ExecutionStartToCloseTimeout, Is.EqualTo(TimeSpan.FromSeconds(int.Parse(s.ExecutionStartToCloseTimeout))));
Assert.That(_domainName, Is.EqualTo(s.Domain));
return(true);
};
_amazonWorkflowClient.Verify(c => c.StartWorkflowExecutionAsync(
It.Is <StartWorkflowExecutionRequest>((start) => startRequest(start)),
It.IsAny <CancellationToken>()),
Times.Once);
}
/// <summary>
/// Start Workflow
/// </summary>
/// <param name="request">Request</param>
/// <returns>StartWorkflowResponse</returns>
public StartWorkflowResponse StartWorkflow(StartWorkflowRequest request)
{
return(Channel.StartWorkflow(request));
}
/// <summary>
/// Start a new instance of a workflow
/// </summary>
/// <param name='operations'>
/// The operations group for this extension method.
/// </param>
/// <param name='tenantId'>
/// The tenant within which the request should operate
/// </param>
/// <param name='body'>
/// </param>
public static void StartWorkflowInstance(this IMarainWorkflowEngine operations, string tenantId, StartWorkflowRequest body)
{
operations.StartWorkflowInstanceAsync(tenantId, body).GetAwaiter().GetResult();
}
public void DoProcess()
{
DateTime last;
try
{
var tweets = _tweet.GetLatestTwitterForWorkflow(out last);
DateTime lastRun = DateTime.MinValue;
foreach (var t in tweets)
{
var startWorkflowRequest = new StartWorkflowRequest
{
Domain = ConfigHelper.WorkflowDomain,
WorkflowCode = ConfigHelper.WorkflowCode,
WfRuntimeValues = new WfProperty[]
{
new WfProperty
{
Name = ConfigHelper.WorkflowProperty,
Type = "S",
Value = t.Text
}
}
};
StartWorkflowResponse startWorkflowResponse = null;
if (_flowTasksService == null)
{
using (FlowTasksService proxy = new FlowTasksService())
{
startWorkflowResponse = proxy.StartWorkflow(startWorkflowRequest);
}
}
else
{
startWorkflowResponse = _flowTasksService.StartWorkflow(startWorkflowRequest);
}
// check for errors
if (string.IsNullOrWhiteSpace(startWorkflowResponse.WorkflowId) ||
startWorkflowResponse.WorkflowId == Guid.Empty.ToString())
{
if (lastRun != DateTime.MinValue)
{
_tweet.SetLastTweetData(lastRun);
}
_log.Error("DoProcess: Start workflow failed!");
return;
}
// last tweet processed
lastRun = t.CreatedDate;
}
_tweet.SetLastTweetData(last);
}
catch (Exception e)
{
// log the error
_log.Error("DoProcess: exception. ", e);
}
}
/// <summary>
/// Start a new instance of a workflow
/// </summary>
/// <param name='operations'>
/// The operations group for this extension method.
/// </param>
/// <param name='tenantId'>
/// The tenant within which the request should operate
/// </param>
/// <param name='body'>
/// </param>
/// <param name='cancellationToken'>
/// The cancellation token.
/// </param>
public static async Task StartWorkflowInstanceAsync(this IMarainWorkflowEngine operations, string tenantId, StartWorkflowRequest body, CancellationToken cancellationToken = default(CancellationToken))
{
(await operations.StartWorkflowInstanceWithHttpMessagesAsync(tenantId, body, null, cancellationToken).ConfigureAwait(false)).Dispose();
}
/// <summary>
/// ReStart Workflow
/// </summary>
/// <param name="request">Request</param>
/// <returns>ReStartWorkflowResponse</returns>
public ReStartWorkflowResponse ReStartWorkflow(ReStartWorkflowRequest request)
{
// Cancell workflow
var resp = CancelWorkflow(new ControlWorkflowRequest
{
WorkflowOid = request.OldWorkflowId
});
if (resp.Message != Library.Properties.Resources.SUCCESS_RESULT)
{
return(new ReStartWorkflowResponse
{
Message = resp.Message,
WorkflowId = request.OldWorkflowId
});
}
// Wait for workflow to terminate
WorkflowInfo oldWf = WaitForWorkflowTerminate(request);
if (oldWf == null || oldWf.Status == WorkflowStatusType.InProgress.ToString())
{
return(new ReStartWorkflowResponse
{
Message = "Workflow still running",
WorkflowId = request.OldWorkflowId
});
}
// Get workflow parameters
var props = _workflow.GetWorkflowParameters(Guid.Parse(request.OldWorkflowId));
var startWorkflowRequest = new StartWorkflowRequest
{
Domain = oldWf.Domain,
WorkflowCode = oldWf.WorkflowCode,
WfRuntimeValues = props.Select(p => new WfProperty
{
Name = p.Name,
Type = p.Type,
Value = p.Value
}).ToArray()
};
// Restart workflow
var startWorkflowResponse = StartWorkflow(startWorkflowRequest);
#if RESTART_SAME_AS_OLD
// The code below can be used when we want to restart a workflow and forward its
// execution till the existing one.
// Usefull when we make changes which are not back compatible. We need to terminate all
// the existing workflows and start new ones without having users to start from the begin
// the process.
// TODO:
// can go till the old point of execution
if (request.RestartMode == "SAME_AS_OLD")
{
// TODO: need to find the way to wait until wf activity finishes.
System.Threading.Thread.Sleep(3000);
var traces = _workflow.GetTraceForWorkflow(new[] { Guid.Parse(request.OldWorkflowId) })
.Where(t => t.Action == ActionTrace.TaskCompleted.ToString());
foreach (var trace in traces)
{
var task = _task.GetNextTasksForWorkflow(Guid.Parse(startWorkflowResponse.WorkflowId))
.Where(t => t.TaskCode == trace.Code)
.FirstOrDefault();
if (task != null)
{
ApproveTask(new ApproveTaskRequest
{
TaskId = task.TaskOid.ToString(),
CorrelationId = task.TaskCorrelationId,
Result = trace.Result,
TaskCode = trace.Code,
WorkflowId = task.WorkflowOid.ToString()
});
}
}
}
#endif
return(new ReStartWorkflowResponse
{
WorkflowId = startWorkflowResponse.WorkflowId,
Message = Library.Properties.Resources.SUCCESS_RESULT
});
}
public StartWorkflowResponse StartWorkflow5(StartWorkflowRequest request)
{
return(new StartWorkflowResponse {
WorkflowId = ""
});
}