private bool IsEventDrivenSubscribed(EventDrivenActivity eventDriven)
{
IEventActivity eventActivity = StateMachineHelpers.GetEventActivity(eventDriven);
EventActivitySubscription subscription = GetSubscription(eventActivity);
return(subscription != null);
}
public static Task <long> Track(
this IEventActivity instance,
string eventName,
DateTime timestamp)
{
return(Track(instance, eventName, timestamp, false));
}
internal void UnsubscribeEventDriven(ActivityExecutionContext context, EventDrivenActivity eventDriven)
{
Debug.Assert(IsEventDrivenSubscribed(eventDriven));
IEventActivity eventActivity = StateMachineHelpers.GetEventActivity(eventDriven);
UnsubscribeEventActivity(context, eventActivity);
}
public static Task <long> Track(
this IEventActivity instance,
string eventName,
bool publishable)
{
return(Track(instance, eventName, DateTime.UtcNow, publishable));
}
public virtual async Task <HttpResponseMessage> Post([FromBody] Activity activity)
{
// es wird geprüft, ob die ankommende Nachricht eine "Message" ist. Messages sind die Nachrichten, die von Chat-Diensten, wie z.B. Skype kommen.
//Anschließend wird diese Nachricht an den Bot gegeben, um diese zu verarbeiten.
if (activity.GetActivityType() == ActivityTypes.Message)
{
activity.Locale = "de-DE";
await Conversation.SendAsync(activity, () => new SuperDialog());
}//Ankommende "Event" Nachrichten, die von den externen Azure Functions an den Bot gesendet werden.
else if (activity.Type == ActivityTypes.Event)
{
IEventActivity triggerEvent = activity;
var message = JsonConvert.DeserializeObject <Message>(((JObject)triggerEvent.Value).GetValue("Message").ToString());
var messageactivity = (Activity)message.RelatesTo.GetPostToBotMessage();
var client = new ConnectorClient(new Uri(messageactivity.ServiceUrl));
var triggerReply = messageactivity.CreateReply();
triggerReply.Text = $"{message.Text}";
await client.Conversations.ReplyToActivityAsync(triggerReply);
}
else
{//Verarbeitung von "Systemnachrichten"
HandleSystemMessage(activity);
}
return(new HttpResponseMessage(System.Net.HttpStatusCode.Accepted));
}
private async Task DigestActionInputAsync <T>(DialogContext dc, IEventActivity ev, CancellationToken cancellationToken)
where T : ActionBaseInput
{
var state = await _stateAccessor.GetAsync(dc.Context, () => new PointOfInterestSkillState(), cancellationToken);
state.IsAction = true;
if (ev.Value is JObject eventValue)
{
T actionData = eventValue.ToObject <T>();
actionData.DigestActionInput(state);
if (!string.IsNullOrEmpty(actionData.Zipcode))
{
var service = _serviceManager.InitAddressMapsService(_settings);
PointOfInterestModel model;
if (string.IsNullOrEmpty(actionData.CountrySet))
{
model = await service.GetZipcodeAsync(actionData.Zipcode);
}
else
{
model = await service.GetZipcodeAsync(actionData.Zipcode, actionData.CountrySet);
}
state.CurrentCoordinates = model?.Geolocation ?? state.CurrentCoordinates;
}
}
}
public virtual async Task <HttpResponseMessage> Post([FromBody] Activity activity)
{
// check if activity is of type message
if (activity.GetActivityType() == ActivityTypes.Message)
{
await Conversation.SendAsync(activity, () => new BrainStormDialog());
//await Conversation.SendAsync(activity, () => new ProactiveDialog());
}
else if (activity.Type == ActivityTypes.Event)
{
IEventActivity triggerEvent = activity;
var message = JsonConvert.DeserializeObject <Message>(((JObject)triggerEvent.Value).GetValue("Message").ToString());
var messageactivity = (Activity)message.RelatesTo.GetPostToBotMessage();
var client = new ConnectorClient(new Uri(messageactivity.ServiceUrl));
if (message.IsTrustedServiceUrl)
{
MicrosoftAppCredentials.TrustServiceUrl(messageactivity.ServiceUrl);
}
var triggerReply = messageactivity.CreateReply();
await client.Conversations.ReplyToActivityAsync(triggerReply);
}
else
{
HandleSystemMessage(activity);
}
return(new HttpResponseMessage(System.Net.HttpStatusCode.Accepted));
}
internal void SubscribeEventDriven(ActivityExecutionContext context, EventDrivenActivity eventDriven)
{
IEventActivity eventActivity = StateMachineHelpers.GetEventActivity(eventDriven);
Activity activity1 = (Activity)eventActivity;
GetQueueName(eventActivity);
this.SubscribeEventActivity(context, eventActivity);
}
internal void SubscribeEventDriven(ActivityExecutionContext context, EventDrivenActivity eventDriven)
{
IEventActivity eventActivity = StateMachineHelpers.GetEventActivity(eventDriven);
Activity activity = (Activity)eventActivity;
IComparable queueName = GetQueueName(eventActivity);
Debug.Assert(!this.Subscriptions.ContainsKey(queueName));
SubscribeEventActivity(context, eventActivity);
}
static internal IEventActivity GetEventActivity(EventDrivenActivity eventDriven)
{
CompositeActivity sequenceActivity = eventDriven as CompositeActivity;
Debug.Assert(eventDriven.EnabledActivities.Count > 0);
IEventActivity eventActivity = sequenceActivity.EnabledActivities[0] as IEventActivity;
Debug.Assert(eventActivity != null);
return(eventActivity);
}
private static bool ValidateMultipleIEventActivity(EventDrivenActivity eventDriven, ValidationErrorCollection validationErrors)
{
IEventActivity firstEventActivity = null;
if (eventDriven.EnabledActivities.Count > 0)
{
firstEventActivity = eventDriven.EnabledActivities[0] as IEventActivity;
}
return(ValidateMultipleIEventActivityInCompositeActivity(eventDriven, firstEventActivity, eventDriven, validationErrors));
}
internal void Subscribe(ActivityExecutionContext context, StateActivity state, IEventActivity eventActivity)
{
eventActivity.Subscribe(context, this);
Activity activity = (Activity) eventActivity;
this._queueName = eventActivity.QueueName;
this._eventActivityName = activity.QualifiedName;
this._stateName = state.QualifiedName;
base.SubscriptionId = Guid.NewGuid();
EventDrivenActivity parentEventDriven = StateMachineHelpers.GetParentEventDriven(eventActivity);
this._eventDrivenName = parentEventDriven.QualifiedName;
}
internal static EventDrivenActivity GetParentEventDriven(IEventActivity eventActivity)
{
for (Activity activity = ((Activity)eventActivity).Parent; activity != null; activity = activity.Parent)
{
EventDrivenActivity activity2 = activity as EventDrivenActivity;
if (activity2 != null)
{
return(activity2);
}
}
return(null);
}
private EventActivitySubscription GetSubscription(IEventActivity eventActivity)
{
IComparable queueName = GetQueueName(eventActivity);
if ((queueName != null) && this.Subscriptions.ContainsKey(queueName))
{
EventActivitySubscription subscription = this.Subscriptions[queueName] as EventActivitySubscription;
Activity activity = (Activity)eventActivity;
if ((subscription != null) && !(subscription.EventActivityName != activity.QualifiedName))
{
return(subscription);
}
}
return(null);
}
internal void Subscribe(ActivityExecutionContext context,
StateActivity state,
IEventActivity eventActivity)
{
eventActivity.Subscribe(context, this);
Activity activity = (Activity)eventActivity;
this._queueName = eventActivity.QueueName;
this._eventActivityName = activity.QualifiedName;
this._stateName = state.QualifiedName;
this.SubscriptionId = Guid.NewGuid();
EventDrivenActivity eventDriven = StateMachineHelpers.GetParentEventDriven(eventActivity);
this._eventDrivenName = eventDriven.QualifiedName;
}
static internal EventDrivenActivity GetParentEventDriven(IEventActivity eventActivity)
{
Activity activity = ((Activity)eventActivity).Parent;
while (activity != null)
{
EventDrivenActivity eventDriven = activity as EventDrivenActivity;
if (eventDriven != null)
{
return(eventDriven);
}
activity = activity.Parent;
}
return(null);
}
internal static void ChangeEventDrivenQueueState(ActivityExecutionContext context, EventDrivenActivity eventDriven, bool enabled)
{
IEventActivity eventActivity = StateMachineHelpers.GetEventActivity(eventDriven);
IComparable queueName = GetQueueName(eventActivity);
if (queueName == null)
{
return; // skip unitialized follower
}
WorkflowQueue workflowQueue = GetWorkflowQueue(context, queueName);
if (workflowQueue != null)
{
workflowQueue.Enabled = enabled;
}
}
public static Task <long[]> Counts(
this IEventActivity instance,
string eventName,
DateTime startTimestamp,
DateTime endTimestamp)
{
if (instance == null)
{
throw new ArgumentNullException("instance");
}
return(instance.Counts(
eventName,
startTimestamp,
endTimestamp,
instance.Settings.Drilldown));
}
public static Task <long> Track(
this IEventActivity instance,
string eventName,
DateTime timestamp,
bool publishable)
{
if (instance == null)
{
throw new ArgumentNullException("instance");
}
return(instance.Track(
eventName,
instance.Settings.Drilldown,
timestamp,
publishable));
}
private ReadOnlyCollection <string> GetPossibleStateTransitions()
{
List <string> targetStates = new List <string>();
ReadOnlyCollection <WorkflowQueueInfo> workflowQueuedInfos = this.WorkflowInstance.GetWorkflowQueueData();
StateMachineWorkflowActivity stateMachineWorkflow = this.StateMachineWorkflow;
foreach (WorkflowQueueInfo queueInfo in workflowQueuedInfos)
{
foreach (string subscribedActivityName in queueInfo.SubscribedActivityNames)
{
Activity subscribedActivity = StateMachineHelpers.FindActivityByName(stateMachineWorkflow, subscribedActivityName);
IEventActivity eventActivity = subscribedActivity as IEventActivity;
if (eventActivity == null)
{
continue;
}
EventDrivenActivity eventDriven = StateMachineHelpers.GetParentEventDriven(eventActivity);
Debug.Assert(eventDriven != null);
Queue <Activity> activities = new Queue <Activity>();
activities.Enqueue(eventDriven);
while (activities.Count > 0)
{
Activity activity = activities.Dequeue();
SetStateActivity setState = activity as SetStateActivity;
if (setState != null)
{
targetStates.Add(setState.TargetStateName);
}
else
{
CompositeActivity compositeActivity = activity as CompositeActivity;
if (compositeActivity != null)
{
foreach (Activity childActivity in compositeActivity.EnabledActivities)
{
activities.Enqueue(childActivity);
}
}
}
}
}
}
return(targetStates.AsReadOnly());
}
public static Task <long> Count(
this IEventActivity instance,
string eventName,
DateTime startTimestamp,
DateTime endTimestamp)
{
if (instance == null)
{
throw new ArgumentNullException("instance");
}
return(Count(
instance,
eventName,
startTimestamp,
endTimestamp,
instance.Settings.Timeframe));
}
private void UnsubscribeEventActivity(ActivityExecutionContext context, IEventActivity eventActivity, EventActivitySubscription subscription)
{
if (context == null)
{
throw new ArgumentNullException("context");
}
if (eventActivity == null)
{
throw new ArgumentNullException("eventActivity");
}
if (subscription == null)
{
throw new ArgumentNullException("subscription");
}
subscription.Unsubscribe(context, eventActivity);
this.RemoveFromQueue(subscription.SubscriptionId);
this.Subscriptions.Remove(subscription.QueueName);
}
private void UnsubscribeEventActivity(ActivityExecutionContext context, IEventActivity eventActivity)
{
if (context == null)
{
throw new ArgumentNullException("context");
}
if (eventActivity == null)
{
throw new ArgumentNullException("eventActivity");
}
EventActivitySubscription subscription = this.GetSubscription(eventActivity);
WorkflowQueue workflowQueue = GetWorkflowQueue(context, subscription.QueueName);
if (workflowQueue != null)
{
workflowQueue.Enabled = false;
}
this.UnsubscribeEventActivity(context, eventActivity, subscription);
}
private StateMachineSubscription SubscribeEventActivity(ActivityExecutionContext context,
IEventActivity eventActivity)
{
EventActivitySubscription subscription = new EventActivitySubscription();
StateActivity state = (StateActivity)context.Activity;
subscription.Subscribe(context, state, eventActivity);
WorkflowQueue workflowQueue = GetWorkflowQueue(context, subscription.QueueName);
if (workflowQueue != null)
{
workflowQueue.Enabled = true;
}
Debug.Assert(subscription.QueueName != null);
this.Subscriptions[subscription.QueueName] = subscription;
return(subscription);
}
private ReadOnlyCollection <string> GetPossibleStateTransitions()
{
List <string> list = new List <string>();
ReadOnlyCollection <WorkflowQueueInfo> workflowQueueData = this.WorkflowInstance.GetWorkflowQueueData();
StateMachineWorkflowActivity stateMachineWorkflow = this.StateMachineWorkflow;
foreach (WorkflowQueueInfo info in workflowQueueData)
{
foreach (string str in info.SubscribedActivityNames)
{
IEventActivity eventActivity = StateMachineHelpers.FindActivityByName(stateMachineWorkflow, str) as IEventActivity;
if (eventActivity != null)
{
EventDrivenActivity parentEventDriven = StateMachineHelpers.GetParentEventDriven(eventActivity);
Queue <Activity> queue = new Queue <Activity>();
queue.Enqueue(parentEventDriven);
while (queue.Count > 0)
{
Activity activity5 = queue.Dequeue();
SetStateActivity activity6 = activity5 as SetStateActivity;
if (activity6 != null)
{
list.Add(activity6.TargetStateName);
}
else
{
CompositeActivity activity7 = activity5 as CompositeActivity;
if (activity7 != null)
{
foreach (Activity activity8 in activity7.EnabledActivities)
{
queue.Enqueue(activity8);
}
continue;
}
}
}
}
}
}
return(list.AsReadOnly());
}
public static async Task <long> Count(
this IEventActivity instance,
string eventName,
DateTime startTimestamp,
DateTime endTimestamp,
ActivityDrilldown drilldown)
{
if (instance == null)
{
throw new ArgumentNullException("instance");
}
var result = await instance.Counts(
eventName,
startTimestamp,
endTimestamp,
drilldown);
return(result.First());
}
internal override void Execute(ActivityExecutionContext context)
{
base.Execute(context);
StateActivity state = this.State;
StateActivity rootState = StateMachineHelpers.GetRootState(state);
Queue <StateActivity> states = new Queue <StateActivity>();
states.Enqueue(rootState);
while (states.Count > 0)
{
state = states.Dequeue();
foreach (Activity activity in state.EnabledActivities)
{
EventDrivenActivity eventDriven = activity as EventDrivenActivity;
if (eventDriven != null)
{
IEventActivity eventActivity = StateMachineHelpers.GetEventActivity(eventDriven);
IComparable queueName = eventActivity.QueueName;
if (queueName != null)
{
WorkflowQueue queue = StateMachineSubscriptionManager.GetWorkflowQueue(context, queueName);
if (queue != null)
{
queue.Enabled = this.SubscriptionManager.Subscriptions.ContainsKey(queueName);
}
}
}
else
{
StateActivity childState = activity as StateActivity;
if (childState != null)
{
states.Enqueue(childState);
}
}
}
}
}
/// <summary>
/// POST: api/Messages
/// Receive a message from a user and reply to it
/// </summary>
public async Task <HttpResponseMessage> Post([FromBody] Activity activity)
{
if (activity.Type == ActivityTypes.Message)
{
if (IsSpellCorrectionEnabled)
{
try
{
activity.Text = await this.spellService.GetCorrectedTextAsync(activity.Text);
}
catch (Exception ex)
{
Trace.TraceError(ex.ToString());
}
}
//await Conversation.SendAsync(activity, () => new RootLuisDialog());
await Conversation.SendAsync(activity, () => new RootDialog());
}
else if (activity.Type == ActivityTypes.Event)
{
IEventActivity triggerEvent = activity;
var message = JsonConvert.DeserializeObject <Message>(((JObject)triggerEvent.Value).GetValue("Message").ToString());
var messageactivity = (Activity)message.RelatesTo.GetPostToBotMessage();
var client = new ConnectorClient(new Uri(messageactivity.ServiceUrl));
var triggerReply = messageactivity.CreateReply();
triggerReply.Text = "Sorry to interupt but I thought I would let you know that your build has finished! Great success!";
await client.Conversations.ReplyToActivityAsync(triggerReply);
}
else
{
this.HandleSystemMessage(activity);
}
var response = Request.CreateResponse(HttpStatusCode.OK);
return(response);
}
public virtual async Task <HttpResponseMessage> Post([FromBody] Activity activity)
{
// check if activity is of type message
if (activity.GetActivityType() == ActivityTypes.Message)
{
await Conversation.SendAsync(activity, () => new SuperDialog());
}
else if (activity.Type == ActivityTypes.Event)
{
IEventActivity triggerEvent = activity;
var message = JsonConvert.DeserializeObject <Message>(((JObject)triggerEvent.Value).GetValue("Message").ToString());
var messageactivity = (Activity)message.RelatesTo.GetPostToBotMessage();
var client = new ConnectorClient(new Uri(messageactivity.ServiceUrl));
var triggerReply = messageactivity.CreateReply();
triggerReply.Text = $"This is coming back from the trigger! {message.Text}";
await client.Conversations.ReplyToActivityAsync(triggerReply);
}
else
{
HandleSystemMessage(activity);
}
return(new HttpResponseMessage(System.Net.HttpStatusCode.Accepted));
}
private void UnsubscribeEventActivity(ActivityExecutionContext context,
IEventActivity eventActivity)
{
if (context == null)
throw new ArgumentNullException("context");
if (eventActivity == null)
throw new ArgumentNullException("eventActivity");
EventActivitySubscription subscription = GetSubscription(eventActivity);
WorkflowQueue workflowQueue = GetWorkflowQueue(context, subscription.QueueName);
if (workflowQueue != null)
workflowQueue.Enabled = false;
UnsubscribeEventActivity(context, eventActivity, subscription);
}
private StateMachineSubscription SubscribeEventActivity(ActivityExecutionContext context,
IEventActivity eventActivity)
{
EventActivitySubscription subscription = new EventActivitySubscription();
StateActivity state = (StateActivity)context.Activity;
subscription.Subscribe(context, state, eventActivity);
WorkflowQueue workflowQueue = GetWorkflowQueue(context, subscription.QueueName);
if (workflowQueue != null)
workflowQueue.Enabled = true;
Debug.Assert(subscription.QueueName != null);
this.Subscriptions[subscription.QueueName] = subscription;
return subscription;
}
internal void Unsubscribe(ActivityExecutionContext context, IEventActivity eventActivity)
{
eventActivity.Unsubscribe(context, this);
}
internal void Unsubscribe(ActivityExecutionContext context, IEventActivity eventActivity)
{
eventActivity.Unsubscribe(context, this);
}
internal static EventDrivenActivity GetParentEventDriven(IEventActivity eventActivity)
{
for (Activity activity = ((Activity) eventActivity).Parent; activity != null; activity = activity.Parent)
{
EventDrivenActivity activity2 = activity as EventDrivenActivity;
if (activity2 != null)
{
return activity2;
}
}
return null;
}
private static bool ValidateMultipleIEventActivityInCompositeActivity(EventDrivenActivity eventDriven, IEventActivity firstEventActivity, CompositeActivity parent, ValidationErrorCollection validationErrors)
{
foreach (Activity activity in parent.Activities)
{
if (activity.Enabled && (activity != firstEventActivity))
{
if (activity is IEventActivity)
{
validationErrors.Add(new ValidationError(SR.GetString("Error_EventDrivenMultipleEventActivity", new object[] { eventDriven.Name, typeof(IEventActivity).FullName, typeof(EventDrivenActivity).Name }), 0x524));
return false;
}
CompositeActivity activity2 = activity as CompositeActivity;
if ((activity2 != null) && !ValidateMultipleIEventActivityInCompositeActivity(eventDriven, firstEventActivity, activity2, validationErrors))
{
return false;
}
}
}
return true;
}
private static IComparable GetQueueName(IEventActivity eventActivity)
{
return eventActivity.QueueName;
}
private void UnsubscribeEventActivity(ActivityExecutionContext context,
IEventActivity eventActivity,
EventActivitySubscription subscription)
{
if (context == null)
throw new ArgumentNullException("context");
if (eventActivity == null)
throw new ArgumentNullException("eventActivity");
if (subscription == null)
throw new ArgumentNullException("subscription");
subscription.Unsubscribe(context, eventActivity);
RemoveFromQueue(subscription.SubscriptionId);
Debug.Assert(subscription.QueueName != null);
this.Subscriptions.Remove(subscription.QueueName);
}
static internal EventDrivenActivity GetParentEventDriven(IEventActivity eventActivity)
{
Activity activity = ((Activity)eventActivity).Parent;
while (activity != null)
{
EventDrivenActivity eventDriven = activity as EventDrivenActivity;
if (eventDriven != null)
return eventDriven;
activity = activity.Parent;
}
return null;
}
private static bool ValidateMultipleIEventActivityInCompositeActivity(EventDrivenActivity eventDriven, IEventActivity firstEventActivity, CompositeActivity parent, ValidationErrorCollection validationErrors)
{
foreach (Activity activity in parent.Activities)
{
// Skip disabled activities or the first IEventActivity
// Note that we don't use EnabledActivities because we want to
// enforce this rule inside Cancellation and Exception Handlers.
if (!activity.Enabled || activity == firstEventActivity)
continue;
if (activity is IEventActivity)
{
validationErrors.Add(new ValidationError(
SR.GetString(SR.Error_EventDrivenMultipleEventActivity, eventDriven.Name, typeof(IEventActivity).FullName, typeof(EventDrivenActivity).Name),
ErrorNumbers.Error_EventDrivenMultipleEventActivity));
return false;
}
else
{
CompositeActivity compositeActivity = activity as CompositeActivity;
if (compositeActivity != null)
{
bool result = ValidateMultipleIEventActivityInCompositeActivity(eventDriven, firstEventActivity, compositeActivity, validationErrors);
if (!result)
return false;
}
}
}
return true;
}
private EventActivitySubscription GetSubscription(IEventActivity eventActivity)
{
IComparable queueName = GetQueueName(eventActivity);
if ((queueName == null) || (!this.Subscriptions.ContainsKey(queueName)))
return null;
EventActivitySubscription subscription = this.Subscriptions[queueName] as EventActivitySubscription;
Activity activity = (Activity)eventActivity;
if (subscription == null ||
subscription.EventActivityName != activity.QualifiedName)
return null;
return subscription;
}
private static IComparable GetQueueName(IEventActivity eventActivity)
{
IComparable queueName = eventActivity.QueueName;
return queueName;
}
private Task <LivePersonConversationRecord> Escalate(ITurnContext turnContext, IEventActivity handoffEvent)
{
var account = _creds.LpAccount;
var clientId = _creds.LpAppId;
var clientSecret = _creds.LpAppSecret;
return(LivePersonConnector.EscalateToAgenAsync(turnContext, handoffEvent, account, clientId, clientSecret, _conversationMap));
}
private EventActivitySubscription GetSubscription(IEventActivity eventActivity)
{
IComparable queueName = GetQueueName(eventActivity);
if ((queueName != null) && this.Subscriptions.ContainsKey(queueName))
{
EventActivitySubscription subscription = this.Subscriptions[queueName] as EventActivitySubscription;
Activity activity = (Activity) eventActivity;
if ((subscription != null) && !(subscription.EventActivityName != activity.QualifiedName))
{
return subscription;
}
}
return null;
}