public static async Task <HttpResponseMessage> Run([HttpTrigger(AuthorizationLevel.Function, "get", "post", Route = null)] HttpRequestMessage req, TraceWriter log)
{
using (BotService.Initialize())
{
// Deserialize the incoming activity
string jsonContent = await req.Content.ReadAsStringAsync();
var activity = JsonConvert.DeserializeObject <Activity>(jsonContent);
// authenticate incoming request and add activity.ServiceUrl to MicrosoftAppCredentials.TrustedHostNames
// if request is authenticated
if (!await BotService.Authenticator.TryAuthenticateAsync(req, new[] { activity }, CancellationToken.None))
{
return(BotAuthenticator.GenerateUnauthorizedResponse(req));
}
if (activity != null)
{
// one of these will have an interface and process it
switch (activity.GetActivityType())
{
case ActivityTypes.Message:
await Conversation.SendAsync(activity, () => new JiraDialog());
break;
default:
log.Error($"Unknown activity type ignored: {activity.GetActivityType()}");
break;
}
}
return(req.CreateResponse(HttpStatusCode.Accepted));
}
}
public static async Task <object> Run([HttpTrigger(WebHookType = "genericJson")] HttpRequestMessage req, TraceWriter log)
{
try
{
using (BotService.Initialize())
{
var activity = JsonConvert.DeserializeObject <Activity>(await req.Content.ReadAsStringAsync());
if (!await BotService.Authenticator.TryAuthenticateAsync(req, new[] { activity }, CancellationToken.None))
{
return(BotAuthenticator.GenerateUnauthorizedResponse(req));
}
if (activity != null)
{
switch (activity.GetActivityType())
{
case ActivityTypes.Message:
await Conversation.SendAsync(activity, () => new RootDialog());
break;
case ActivityTypes.ConversationUpdate:
var client = new ConnectorClient(new Uri(activity.ServiceUrl));
IConversationUpdateActivity update = activity;
if (update.MembersAdded.Any())
{
var reply = activity.CreateReply();
var newMembers = update.MembersAdded?.Where(t => t.Id != activity.Recipient.Id);
foreach (var newMember in newMembers)
{
reply.Text = "Welcome";
if (!string.IsNullOrEmpty(newMember.Name))
{
reply.Text += $" {newMember.Name}";
}
reply.Text += "!";
await client.Conversations.ReplyToActivityAsync(reply);
}
}
break;
case ActivityTypes.ContactRelationUpdate:
case ActivityTypes.Typing:
case ActivityTypes.DeleteUserData:
case ActivityTypes.Ping:
default:
log.Error($"Unknown activity type ignored: {activity.GetActivityType()}");
break;
}
}
}
}
catch (Exception ex)
{
log.Error("Error", ex);
throw;
}
return(req.CreateResponse(HttpStatusCode.Accepted));
}
public static async Task <object> Run([HttpTrigger(AuthorizationLevel.Function, "get", "post", Route = "messages")] HttpRequestMessage req, TraceWriter log)
{
log.Info($"Webhook was triggered!");
// Initialize the azure bot
using (BotService.Initialize())
{
// Deserialize the incoming activity
string jsonContent = await req.Content.ReadAsStringAsync();
var activity = JsonConvert.DeserializeObject <Activity>(jsonContent);
// authenticate incoming request and add activity.ServiceUrl to MicrosoftAppCredentials.TrustedHostNames
// if request is authenticated
if (!await BotService.Authenticator.TryAuthenticateAsync(req, new[] { activity }, CancellationToken.None))
{
return(BotAuthenticator.GenerateUnauthorizedResponse(req));
}
if (activity != null)
{
// one of these will have an interface and process it
switch (activity.GetActivityType())
{
case ActivityTypes.Message:
await Conversation.SendAsync(activity, () => new FindMyAgeDialog());
break;
case ActivityTypes.ConversationUpdate:
var client = new ConnectorClient(new Uri(activity.ServiceUrl));
IConversationUpdateActivity update = activity;
if (update.MembersAdded.Any())
{
var reply = activity.CreateReply();
var newMembers = update.MembersAdded?.Where(t => t.Id != activity.Recipient.Id);
foreach (var newMember in newMembers)
{
reply.Text = "Hey there. Welcome to Image Recognition Bot. Send me a photo and I will tell you what it contains!";
await client.Conversations.ReplyToActivityAsync(reply);
}
}
break;
case ActivityTypes.ContactRelationUpdate:
case ActivityTypes.Typing:
case ActivityTypes.DeleteUserData:
case ActivityTypes.Ping:
default:
log.Error($"Unknown activity type ignored: {activity.GetActivityType()}");
break;
}
}
return(req.CreateResponse(HttpStatusCode.Accepted));
}
}
public static async Task <object> Run([HttpTrigger(AuthorizationLevel.Function, "get", "post", Route = null)] HttpRequestMessage req, TraceWriter log)
{
log.Info("PolicyEnquiry was triggered!");
// Initialize the azure bot
using (BotService.Initialize())
{
ConfigureStateStore();
// Deserialize the incoming activity
var activity = JsonConvert.DeserializeObject <Activity>(await req.Content.ReadAsStringAsync());
// authenticate incoming request and add activity.ServiceUrl to MicrosoftAppCredentials.TrustedHostNames
// if request is authenticated
if (!await BotService.Authenticator.TryAuthenticateAsync(req, new[] { activity }, CancellationToken.None))
{
return(BotAuthenticator.GenerateUnauthorizedResponse(req));
}
if (activity != null)
{
// one of these will have an interface and process it
switch (activity.GetActivityType())
{
case ActivityTypes.Message:
await Conversation.SendAsync(activity, () => new RootDialog());
break;
case ActivityTypes.ConversationUpdate:
var client = new ConnectorClient(new Uri(activity.ServiceUrl));
IConversationUpdateActivity update = activity;
if (update.MembersAdded.Any())
{
var reply = activity.CreateReply();
reply.Text = "Hey! I am Polen. I can answer quick questions for your policy.";
await client.Conversations.ReplyToActivityAsync(reply);
}
break;
default:
log.Error($"Unknown activity type ignored: {activity.GetActivityType()}");
break;
}
}
return(req.CreateResponse(HttpStatusCode.Accepted));
}
}
public static async Task <object> BotMessageHandler([HttpTrigger(AuthorizationLevel.Anonymous, "post", Route = "bot/messages", WebHookType = "genericJson")] HttpRequestMessage req, TraceWriter log)
{
// Initialize the azure bot
using (BotService.Initialize())
{
// Deserialize the incoming activity
string jsonContent = await req.Content.ReadAsStringAsync();
var activity = JsonConvert.DeserializeObject <Activity> (jsonContent);
// authenticate incoming request and add activity.ServiceUrl to MicrosoftAppCredentials.TrustedHostNames
// if request is authenticated
if (!await BotService.Authenticator.TryAuthenticateAsync(req, new[] { activity }, CancellationToken.None))
{
return(BotAuthenticator.GenerateUnauthorizedResponse(req));
}
if (activity != null)
{
if (activity.GetActivityType() == ActivityTypes.Message)
{
var typing = activity.CreateReply();
typing.Type = ActivityTypes.Typing;
await activity.ClientForReply().Conversations.ReplyToActivityAsync(typing);
if (SimpleQnAMakerDialog.IsQuestion(activity.Text))
{
await Conversation.SendAsync(activity, () => new SimpleQnAMakerDialog());
}
else
{
await Conversation.SendAsync(activity, () => new FaqDialog());
}
}
else
{
var reply = HandleSystemMessage(activity, log);
if (reply != null)
{
await activity.ClientForReply().Conversations.ReplyToActivityAsync(reply);
}
}
}
return(req.CreateResponse(HttpStatusCode.Accepted));
}
}
public static async Task <bool> AuthenticateBotRequest(HttpRequestMessage req, Activity activity, CancellationToken token)
{
var credProvider = new SettingsCredentialProvider();
var authenticator = new BotAuthenticator(credProvider, JwtConfig.ToBotFromChannelOpenIdMetadataUrl, disableEmulatorTokens: false);
var authenticated = await authenticator.TryAuthenticateAsync(req, new[] { activity }, token);
if (authenticated)
{
MicrosoftAppCredentials.TrustServiceUrl(activity.ServiceUrl);
}
return(authenticated);
}
public override async Task OnActionExecutingAsync(HttpActionContext actionContext, CancellationToken cancellationToken)
{
try
{
if (!VaildAuthorized(actionContext))
{ // 驗證不通過
actionContext.Response = BotAuthenticator.GenerateUnauthorizedResponse(actionContext.Request, $"BotAuthentication failed to authenticate incoming request!");
}
}
catch (Exception e)
{ // 有Exception
actionContext.Response = BotAuthenticator.GenerateUnauthorizedResponse(actionContext.Request, $"Failed authenticating incoming request: {e.ToString()}");
}
await base.OnActionExecutingAsync(actionContext, cancellationToken);
}
public static async Task <HttpResponseMessage> Run(
[HttpTrigger(AuthorizationLevel.Function, "post", Route = "messages")]
HttpRequestMessage request,
TraceWriter log
)
{
log.Info("C# HTTP trigger function processed a request.");
using (BotService.Initialize())
{
using (BotService.Initialize())
{
string jsonContent = await request.Content.ReadAsStringAsync();
var activity = JsonConvert.DeserializeObject <Activity>(jsonContent);
if (!await BotService.Authenticator.TryAuthenticateAsync(request, new[] { activity }, CancellationToken.None))
{
return(BotAuthenticator.GenerateUnauthorizedResponse(request));
}
if (activity != null)
{
switch (activity.GetActivityType())
{
case ActivityTypes.Message:
await Conversation.SendAsync(activity, () => new RootDialog());
break;
case ActivityTypes.ConversationUpdate:
case ActivityTypes.ContactRelationUpdate:
case ActivityTypes.Typing:
case ActivityTypes.DeleteUserData:
case ActivityTypes.Ping:
default:
break;
}
}
return(request.CreateResponse(HttpStatusCode.Accepted));
}
}
}
public override async Task OnActionExecutingAsync(HttpActionContext actionContext, CancellationToken cancellationToken)
{
var authorizationHeader = actionContext.Request.Headers.Authorization;
if (authorizationHeader != null && SkillValidation.IsSkillToken(authorizationHeader.ToString()))
{
var activities = base.GetActivities(actionContext);
if (activities.Any())
{
var authConfiguration = this.GetAuthenticationConfiguration();
var credentialProvider = this.GetCredentialProvider();
try
{
foreach (var activity in activities)
{
var claimsIdentity = await JwtTokenValidation.AuthenticateRequest(activity, authorizationHeader.ToString(), credentialProvider, authConfiguration, _httpClient).ConfigureAwait(false);
// this is done in JwtTokenValidation.AuthenticateRequest, but the oauthScope is not set so we update it here
MicrosoftAppCredentials.TrustServiceUrl(activity.ServiceUrl, oauthScope: JwtTokenValidation.GetAppIdFromClaims(claimsIdentity.Claims));
}
}
catch (UnauthorizedAccessException)
{
actionContext.Response = BotAuthenticator.GenerateUnauthorizedResponse(actionContext.Request, "BotAuthenticator failed to authenticate incoming request!");
return;
}
await base.ContinueOnActionExecutingAsync(actionContext, cancellationToken);
return;
}
}
await base.OnActionExecutingAsync(actionContext, cancellationToken);
}
public static async Task <object> Dispatch <T>(HttpRequestMessage req, IContainer container) where T : ActivityDispatcher
{
using (BotService.Initialize())
{
var jsonContent = await req.Content.ReadAsStringAsync();
var activity = JsonConvert.DeserializeObject <Activity>(jsonContent);
if (!await BotService.Authenticator.TryAuthenticateAsync(req, new[] { activity }, CancellationToken.None))
{
return(BotAuthenticator.GenerateUnauthorizedResponse(req));
}
if (activity == null)
{
return(req.CreateResponse(HttpStatusCode.Accepted));
}
using (var scope = DialogModule.BeginLifetimeScope(container, activity))
{
var dispatcherTarget = scope.Resolve <T>();
switch (activity.GetActivityType())
{
case ActivityTypes.Message:
await dispatcherTarget.OnMessage(activity);
break;
case ActivityTypes.ConversationUpdate:
await dispatcherTarget.OnConversationUpdate(activity);
break;
case ActivityTypes.Trigger:
await dispatcherTarget.OnConversationUpdate(activity);
break;
case ActivityTypes.ContactRelationUpdate:
await dispatcherTarget.OnContactRelationUpdate(activity);
break;
case ActivityTypes.DeleteUserData:
await dispatcherTarget.OnDeleteUserData(activity);
break;
//case ActivityTypes.Typing:
//case ActivityTypes.Ping:
default:
await dispatcherTarget.OnUnknownActivity(activity);
break;
}
return(req.CreateResponse(HttpStatusCode.Accepted));
}
}
}
