public async Task <IActionResult> RaiseEvent(
[HttpTrigger(AuthorizationLevel.Anonymous, "post", Route = "statemachine/{instanceId}/event")] HttpRequest req,
[DurableClient] IDurableClient client,
string instanceId,
ILogger log)
{
if (req.ContentLength == 0)
{
return(new BadRequestObjectResult($"The request payload must contain a valid cloud event JSON object."));
}
var json = JObject.Parse(await req.ReadAsStringAsync());
var eventData = json.ToObject <WorkflowEvent>();
if (eventData == null || eventData.EventType == null || eventData.EventName == null)
{
return(new BadRequestObjectResult($"The request payload must be a valid cloud event JSON object."));
}
await client.RaiseWorkflowEventAsync(instanceId, eventData);
log.LogInformation($"Raised event of type '{eventData.EventType}' to workflow ID = '{instanceId}.");
return(client.CreateCheckStatusResponse(req, instanceId));
}
public async Task <HttpResponseMessage> SendEmailWithTemplateHttp([HttpTrigger(AuthorizationLevel.Function, "POST")] HttpRequestMessage request, [DurableClient] IDurableClient client)
{
Dictionary <string, string> data = null;
var json = await request.Content.ReadAsStringAsync();
if (!string.IsNullOrEmpty(json))
{
data = JsonConvert.DeserializeObject <Dictionary <string, string> >(json);
}
var query = request.RequestUri.ParseQueryString();
var sendRequest = new SendEmailWithTemplateRequest
{
From = query.Get("from"),
FromName = query.Get("fromname"),
TemplateData = data,
TemplateId = query.Get("templateid"),
To = query.Get("to"),
ToName = query.Get("toname")
};
var instanceId = await client.StartNewAsync(Names.SendEmailWithTemplateOrch, sendRequest);
return(client.CreateCheckStatusResponse(request, instanceId));
}
public async Task <IActionResult> AddCertificate_HttpStart(
[HttpTrigger(AuthorizationLevel.Anonymous, "post", Route = "add-certificate")] HttpRequest req,
[DurableClient] IDurableClient starter,
ILogger log)
{
if (!req.HttpContext.User.Identity.IsAuthenticated)
{
return(new UnauthorizedResult());
}
var request = JsonConvert.DeserializeObject <AddCertificateRequest>(await req.ReadAsStringAsync());
if (string.IsNullOrEmpty(request.ResourceGroupName))
{
return(new BadRequestObjectResult($"{nameof(request.ResourceGroupName)} is empty."));
}
if (string.IsNullOrEmpty(request.SiteName))
{
return(new BadRequestObjectResult($"{nameof(request.SiteName)} is empty."));
}
if (request.Domains == null || request.Domains.Length == 0)
{
return(new BadRequestObjectResult($"{nameof(request.Domains)} is empty."));
}
// Function input comes from the request content.
var instanceId = await starter.StartNewAsync(nameof(AddCertificate), request);
log.LogInformation($"Started orchestration with ID = '{instanceId}'.");
return(starter.CreateCheckStatusResponse(req, instanceId, true));
}
public async Task <HttpResponseMessage> Run(
[HttpTrigger(AuthorizationLevel.Function, "post", Route = "start/{orchestratorName}/{id?}")] HttpRequestMessage req,
[DurableClient] IDurableClient orchestratorClient,
string orchestratorName,
string id,
ILogger log)
{
var orchestratorInput = await req.Content.ReadAsAsync <object>();
string instanceId = id;
if (string.IsNullOrEmpty(instanceId))
{
// Start a new Orchestrator and let Durable Functions generate the instance id.
instanceId = await orchestratorClient.StartNewAsync(
orchestratorName,
orchestratorInput);
}
else
{
// Start a new Orchestrator and use your own instance id.
instanceId = await orchestratorClient.StartNewAsync(
orchestratorName,
instanceId,
orchestratorInput);
}
log.LogInformation($"Started Orchestrator with ID = '{instanceId}'...");
return(orchestratorClient.CreateCheckStatusResponse(req, instanceId));
}
public async Task <IActionResult> StartStateMachine(
[HttpTrigger(AuthorizationLevel.Anonymous, "post", Route = "statemachine/{instanceId}")] HttpRequest req,
[DurableClient] IDurableClient client,
string instanceId,
ILogger log)
{
StateMachine?workflow = null;
JObject? input = null;
ObservableAction[]? actions = null;
if (req.ContentLength != 0)
{
var json = JObject.Parse(await req.ReadAsStringAsync());
workflow = json.Property("workflow")?.Value.ToObject <StateMachine>();
input = (JObject)(json.Property("input")?.Value ?? new JObject());
actions = json.Property("actions")?.Value.ToObject <ObservableAction[]>();
}
if (workflow == null)
{
return(new BadRequestObjectResult("Unable to deserialize state machine definition in request payload."));
}
var args = new StartWorkflowArgs(workflow, input, actions, _config["TELEMETRY_URI"]);
await client.StartWorkflowAsync(args, instanceId);
log.LogInformation($"Started new workflow '{workflow.Name}' with ID = '{instanceId}.");
return(client.CreateCheckStatusResponse(req, instanceId));
}
public static async Task <HttpResponseMessage> Client_StartDurableHttp(
[HttpTrigger(AuthorizationLevel.Anonymous, "get")] HttpRequestMessage request,
[DurableClient] IDurableClient starter)
{
string instanceId = await starter.StartNewAsync(nameof(Orchestrator_CallDurableHttp));
return(starter.CreateCheckStatusResponse(request, instanceId));
}
public static async Task <IActionResult> Http(
[HttpTrigger(AuthorizationLevel.Anonymous, "get", "post")] HttpRequest req,
[DurableClient] IDurableClient client)
{
string id = await client.StartNewAsync("Orchestration", null);
return(client.CreateCheckStatusResponse(req, id));
}
public async Task <IActionResult> Run(
[HttpTrigger(AuthorizationLevel.Anonymous, "get", "post", Route = "monitoring-manager")] HttpRequest req,
[DurableClient] IDurableClient durableClient)
{
var instance = await durableClient.StartNewAsync(nameof(MonitoringOrchestrator));
return(durableClient.CreateCheckStatusResponse(req, instance));
}
public static async Task <IActionResult> Run(
[HttpTrigger(AuthorizationLevel.Anonymous, "get", "post", Route = null)] HttpRequest req,
[DurableClient] IDurableClient starter,
ILogger log)
{
string instanceId = await starter.StartNewAsync("process-proposal-orchestration");
return(starter.CreateCheckStatusResponse(req, instanceId));
}
public async Task <HttpResponseMessage> Run(
[HttpTrigger(AuthorizationLevel.Function, nameof(HttpMethod.Get))] HttpRequestMessage requestMessage,
[DurableClient] IDurableClient client,
ILogger logger)
{
var instanceId = await client.StartNewAsync(
nameof(OrchestratorWithDF1xxWarnings));
return(client.CreateCheckStatusResponse(requestMessage, instanceId));
}
public static async Task <IActionResult> ClientFunctionHttp(
[HttpTrigger(AuthorizationLevel.Anonymous, "get", Route = "activities/{activity}")] HttpRequest req,
[DurableClient] IDurableClient starter,
string activity,
ILogger log)
{
string instanceId = await starter.StartNewAsync(activity);
return(starter.CreateCheckStatusResponse(req, instanceId));
}
public static async Task <HttpResponseMessage> StartMapReduce(
[HttpTrigger(AuthorizationLevel.Function, methods: "post", Route = "StartMapReduce")] HttpRequestMessage req,
[DurableClient] IDurableClient starter,
ILogger log)
{
string instanceId = (await req.Content.ReadAsAsync <dynamic>())?.InstanceId ?? Guid.NewGuid().ToString("N");
await starter.StartNewAsync <object>("MapReduceOrchestration", instanceId, null);
log.LogWarning("Started FanOutFanIn orchestration with ID = '" + instanceId + "'.");
return(starter.CreateCheckStatusResponse(req, instanceId));
}
public async Task <HttpResponseMessage> Run([HttpTrigger(AuthorizationLevel.Function, "POST", Route = "start")] HttpRequestMessage message,
[DurableClient] IDurableClient orchestrationClient,
ILogger logger)
{
var detectedEvent = await message.Content.ReadAsAsync <MyMessage>();
var messages = await orchestrationClient.StartNewAsync(nameof(EventProcessingOrchestrator), detectedEvent);
logger.LogInformation($"HTTP started orchestration with ID {messages}.");
return(orchestrationClient.CreateCheckStatusResponse(message, messages));
}
public static async Task <HttpResponseMessage> HttpStart(
[HttpTrigger(AuthorizationLevel.Anonymous, "GET")] HttpRequestMessage req,
[DurableClient] IDurableClient starter,
ILogger log)
{
// Function input comes from the request content.
string instanceId = await starter.StartNewAsync(nameof(RunOrchestrator), null);
log.LogInformation($"Started orchestration with ID = '{instanceId}'.");
return(starter.CreateCheckStatusResponse(req, instanceId));
}
public static async Task <HttpResponseMessage> ClientFunctionHttp(
[HttpTrigger(AuthorizationLevel.Anonymous, "get", "post", Route = "activities/{activity}")] HttpRequestMessage req,
[DurableClient] IDurableClient starter,
string activity,
ILogger log)
{
object eventData = await req.Content.ReadAsAsync <object>();
string instanceId = await starter.StartNewAsync(activity, eventData);
return(starter.CreateCheckStatusResponse(req, instanceId));
}
public async Task <HttpResponseMessage> HttpStart(
[HttpTrigger(AuthorizationLevel.Anonymous, "get", "post")] HttpRequestMessage req,
[DurableClient] IDurableClient starter,
ILogger log)
{
string instanceId = await starter.StartNewAsync("DurableFunctionsOrchestrationCSharp1", null);
// string instanceId = await starter.StartNewAsync(nameof(LongRunningFunction), null);
log.LogInformation($"Started orchestration with ID = '{instanceId}'.");
return(starter.CreateCheckStatusResponse(req, instanceId));
}
public static async Task <HttpResponseMessage> Client_SayHello(
[HttpTrigger(AuthorizationLevel.Anonymous, "post")] HttpRequestMessage request,
[DurableClient] IDurableClient starter,
ILogger log)
{
var sayHelloRequest = await request.Content.ReadAsAsync <SayHelloRequest>();
string instanceId = await starter.StartNewAsync(nameof(Orchestrator_SayHello), sayHelloRequest);
log.LogInformation($"Started orchestration with ID = '{instanceId}'.");
return(starter.CreateCheckStatusResponse(request, instanceId));
}
public async Task <HttpResponseMessage> Run([HttpTrigger(AuthorizationLevel.Function, methods: "post", Route = "orchestrators/{functionName}")] HttpRequestMessage req,
[DurableClient] IDurableClient starter,
string functionName)
{
// Function input comes from the request content.
object eventData = await req.Content.ReadAsAsync <object>();
string instanceId = await starter.StartNewAsync(functionName, eventData);
logger.LogInformation($"Started orchestration with ID = '{instanceId}'.");
return(starter.CreateCheckStatusResponse(req, instanceId));
}
public static async Task <HttpResponseMessage> Run(
[HttpTrigger(AuthorizationLevel.Function, "post", Route = null)] HttpRequestMessage message,
[DurableClient] IDurableClient client,
ILogger log)
{
var transaction = await message.Content.ReadAsAsync <Transaction>();
var instanceId = await client.StartNewAsync(
nameof(FraudDetectionOrchestrator),
transaction);
return(client.CreateCheckStatusResponse(message, instanceId));
}
public static async Task <IActionResult> Run(
[HttpTrigger(AuthorizationLevel.Anonymous, "get", "post", Route = null)] HttpRequest req,
[DurableClient(TaskHub = "%MyTaskHub%")] IDurableClient starter,
ILogger log)
{
string requestBody = await new StreamReader(req.Body).ReadToEndAsync();
string preInstanceId = JsonConvert.DeserializeObject <string>(requestBody);
string instanceId = await starter.StartNewAsync("ChainPatternExample", preInstanceId);
log.LogInformation($"Started orchestration with ID = '{instanceId}'.");
return(starter.CreateCheckStatusResponse(req, instanceId));
}
public static async Task <IActionResult> HttpStart(
[HttpTrigger(AuthorizationLevel.Anonymous, "get", "post")] HttpRequest req,
[DurableClient] IDurableClient starter,
ILogger log)
{
string requestBody = await new StreamReader(req.Body).ReadToEndAsync();
dynamic data = JsonConvert.DeserializeObject <dynamic>(requestBody);
// Function input comes from the request content.
string instanceId = await starter.StartNewAsync("RoomOrchestration", null, data);
log.LogInformation($"Started orchestration with ID = '{instanceId}'.");
return(starter.CreateCheckStatusResponse(req, instanceId));
}
public static async Task <IActionResult> Run(
[HttpTrigger(AuthorizationLevel.Function, "get", "post", Route = null)] HttpRequest req,
[DurableClient(TaskHub = "MprTaskHub")] IDurableClient starter,
ILogger log)
{
string requestBody = await new StreamReader(req.Body).ReadToEndAsync();
GreetingsRequest data = JsonConvert.DeserializeObject <GreetingsRequest>(requestBody);
string instanceId = await starter.StartNewAsync("FanOutInOrchestrator", data);
log.LogInformation($"Started orchestration with ID = '{instanceId}'.");
return(starter.CreateCheckStatusResponse(req, instanceId));
}
public static async Task <HttpResponseMessage> CounterClient(
[HttpTrigger(AuthorizationLevel.Anonymous, "GET", Route = "CounterClient/{entityKey}/{amount}")] HttpRequestMessage request,
[DurableClient] IDurableClient client,
string entityKey,
int amount)
{
var input = new CounterOrchestratorInput {
EntityKey = entityKey, Amount = amount
};
string instanceId = await client.StartNewAsync(nameof(CounterOrchestrator), input);
return(client.CreateCheckStatusResponse(request, instanceId));
}
public async Task <HttpResponseMessage> Run(
[HttpTrigger(AuthorizationLevel.Function, "POST", Route = "start")] HttpRequestMessage message,
[DurableClient] IDurableClient durableClient,
ILogger log)
{
var detectedNeoEvent = await message.Content.ReadAsAsync <DetectedNeoEvent>();
var instanceId = await durableClient.StartNewAsync(nameof(NeoEventProcessingOrchestrator),
detectedNeoEvent);
log.LogInformation($"HTTP started orchestration with ID {instanceId}.");
return(durableClient.CreateCheckStatusResponse(message, instanceId));
}
public static async Task <IActionResult> Run(
[HttpTrigger(AuthorizationLevel.Anonymous, "get", "post", Route = null)] HttpRequest req,
[DurableClient] IDurableClient starter,
ILogger log)
{
string requestBody = await new StreamReader(req.Body).ReadToEndAsync();
dynamic data = JsonConvert.DeserializeObject <dynamic>(requestBody);
string fileName = data.FileName;
string instanceId = await starter.StartNewAsync("MonitorPatternExample", fileName);
return(starter.CreateCheckStatusResponse(req, instanceId));
}
public async Task <HttpResponseMessage> Run(
[HttpTrigger(AuthorizationLevel.Function, "post", Route = "start/{orchestratorName}/")]
HttpRequestMessage req,
[DurableClient] IDurableClient orchestrationClient,
string orchestratorName,
ILogger log)
{
var orchestratorInput = await req.Content.ReadAsAsync <object>();
var instanceId = await orchestrationClient.StartNewAsync(
orchestratorName,
orchestratorInput);
return(orchestrationClient.CreateCheckStatusResponse(req, instanceId));
}
public static async Task <HttpResponseMessage> Run(
[HttpTrigger(AuthorizationLevel.Function, methods: "post", Route = "newrfp")] HttpRequestMessage req,
[DurableClient] IDurableClient starter,
ILogger log)
{
log.LogInformation("HTTP trigger received for function");
// Function input comes from the request content.
object eventData = await req.Content.ReadAsAsync <object>();
string instanceId = await starter.StartNewAsync("RFPNotificationOrchestrator", eventData);
log.LogInformation($"Started orchestration with ID = '{instanceId}'.");
return(starter.CreateCheckStatusResponse(req, instanceId));
}
public async Task <IActionResult> Run(
[HttpTrigger(AuthorizationLevel.Anonymous, "get", "post", Route = "appointment-manager")] HttpRequest req,
[DurableClient] IDurableClient durableClient,
ILogger log)
{
var clientAppointment = new ClientAppointment
{
ClientId = Guid.NewGuid(),
AppointmentId = Guid.NewGuid(),
PhoneNumber = "+00011112222"
};
string instanceId = await durableClient.StartNewAsync(nameof(AppointmentSchedulingOrchestrator), clientAppointment);
return(durableClient.CreateCheckStatusResponse(req, instanceId));
}
public static async Task <IActionResult> StartManySequences(
[HttpTrigger(AuthorizationLevel.Anonymous, "post", Route = null)] HttpRequest req,
[DurableClient] IDurableClient starter,
ILogger log)
{
if (!int.TryParse(req.Query["count"], out int count) || count < 1)
{
return(new BadRequestObjectResult("A 'count' query string parameter is required and it must contain a positive number."));
}
string orchestratorName = nameof(ManySequencesOrchestrator);
string instanceId = $"{orchestratorName}-{DateTime.UtcNow:yyyyMMdd-hhmmss}";
await starter.StartNewAsync(orchestratorName, instanceId, count);
return(starter.CreateCheckStatusResponse(req, instanceId));
}
public static async Task <HttpResponseMessage> Start(
[HttpTrigger(AuthorizationLevel.Function, methods: "post", Route = "StartSubOrchestrationFanOutFanIn")] HttpRequestMessage req,
[DurableClient] IDurableClient starter,
ILogger log)
{
int num = await req.Content.ReadAsAsync <int>();
if (num <= 0)
{
return(req.CreateErrorResponse(HttpStatusCode.BadRequest, "A positive integer was expected in the request body."));
}
string instanceId = await starter.StartNewAsync("FanOutFanInOrchestration", (object)num);
log.LogWarning("Started FanOutFanInOrchestration orchestration with ID = '" + instanceId + "'.");
return(starter.CreateCheckStatusResponse(req, instanceId));
}