public CredentialsCommand(AppCredentials appCreds)
{
this.Method = "credentials";
this.Data = new Dictionary <string, string>();
this.Data["id"] = appCreds.id;
this.Data["secret"] = appCreds.secret;
}
public RetrieveSecureAppCredentials()
{
var configs = GetConfiguration.GetConfigs;
AppCredentials = configs.Configuration.GetSection("AppCredentials")
.Get <AppCredentials>();
}
public ToDoApiShould()
{
var credentials = new AppCredentials
{
AppId = "5b9ed3b6-652c-4ba5-b6cd-5438dba1ac15",
AppSecret = "U4byxd0fsqYjTopaem6a2YV"
};
// I need to create own `TestServer` because default `TestServer`
// doesn't allow you to configure the client created by testserver.
// For example adding other delegating handler
_server = new CustomTestServer(new WebHostBuilder()
.UseStartup <Startup>());
// This creates test http client with RefreshTokenHandler,
// so when you get `Unauthorized` the handler will try to get new access_token and refresh_token
// and store them using `token store`
_client = _server.CreateClient(TokenStore, credentials);
_testEventModels = new List <EventModel>();
_testTaskModels = new List <TaskModel>();
TestDataClient.DefaultRequestHeaders.Authorization =
new AuthenticationHeaderValue("Bearer", TokenStore.AccessToken);
CreateTestData().Wait();
}
//吳家寶
private async Task <ConversationResourceResponse> NewConversationAsync(string teamsChannelId, Attachment card)
{
//teamsChannelId: Teams channel id in which to create the post.
//The Bot Service Url needs to be dynamically fetched (and stored) from the Team. Recommendation is to capture the serviceUrl from the bot Payload and later re-use it to send proactive messages.
string serviceUrl = "https://smba.trafficmanager.net/emea/";
//From the Bot Channel Registration
string botClientID = "81459ba9-bf90-4527-bad4-b8cace1c47f3";
string botClientSecret = "td-Yft_qf-~OIucKnMEB_fb-2k.xS89Wc4";
AppCredentials.TrustServiceUrl(serviceUrl);
var connectorClient = new ConnectorClient(new Uri(serviceUrl), new MicrosoftAppCredentials(botClientID, botClientSecret));
var topLevelMessageActivity = MessageFactory.Attachment(card);
var conversationParameters = new ConversationParameters
{
IsGroup = true,
ChannelData = new TeamsChannelData
{
Channel = new ChannelInfo(teamsChannelId),
},
Activity = (Activity)topLevelMessageActivity
};
return(await connectorClient.Conversations.CreateConversationAsync(conversationParameters));
// await connectorClient.Conversations.CreateConversationAsync(conversationParameters);
}
/// <summary>
/// Creates the connector client asynchronous.
/// </summary>
/// <param name="serviceUrl">The service URL.</param>
/// <param name="claimsIdentity">The claims identity.</param>
/// <param name="cancellationToken">Cancellation token.</param>
/// <returns>ConnectorClient instance.</returns>
/// <exception cref="NotSupportedException">ClaimsIdentity cannot be null. Pass Anonymous ClaimsIdentity if authentication is turned off.</exception>
private async Task <IConnectorClient> CreateConnectorClientAsync(string serviceUrl, ClaimsIdentity claimsIdentity, CancellationToken cancellationToken)
{
if (claimsIdentity == null)
{
throw new NotSupportedException("ClaimsIdentity cannot be null. Pass Anonymous ClaimsIdentity if authentication is turned off.");
}
// For requests from channel App Id is in Audience claim of JWT token. For emulator it is in AppId claim. For
// unauthenticated requests we have anonymous identity provided auth is disabled.
// For Activities coming from Emulator AppId claim contains the Bot's AAD AppId.
var botAppIdClaim = claimsIdentity.Claims?.SingleOrDefault(claim => claim.Type == AuthenticationConstants.AudienceClaim);
if (botAppIdClaim == null)
{
botAppIdClaim = claimsIdentity.Claims?.SingleOrDefault(claim => claim.Type == AuthenticationConstants.AppIdClaim);
}
// For anonymous requests (requests with no header) appId is not set in claims.
AppCredentials appCredentials = null;
if (botAppIdClaim != null)
{
var botId = botAppIdClaim.Value;
string scope = null;
if (SkillValidation.IsSkillClaim(claimsIdentity.Claims))
{
// The skill connector has the target skill in the OAuthScope.
scope = JwtTokenValidation.GetAppIdFromClaims(claimsIdentity.Claims);
}
appCredentials = await GetAppCredentialsAsync(botId, scope, cancellationToken).ConfigureAwait(false);
}
return(CreateConnectorClient(serviceUrl, appCredentials));
}
public PhoneSkillDialogBase(
string dialogId,
IServiceProvider serviceProvider)
: base(dialogId)
{
Settings = serviceProvider.GetService <BotSettings>();
Services = serviceProvider.GetService <BotServices>();
TemplateManager = serviceProvider.GetService <LocaleTemplateManager>();
var conversationState = serviceProvider.GetService <ConversationState>();
PhoneStateAccessor = conversationState.CreateProperty <PhoneSkillState>(nameof(PhoneSkillState));
DialogStateAccessor = conversationState.CreateProperty <DialogState>(nameof(DialogState));
ServiceManager = serviceProvider.GetService <IServiceManager>();
if (!Settings.OAuthConnections.Any())
{
throw new Exception("You must configure an authentication connection in your bot file before using this component.");
}
AppCredentials oauthCredentials = null;
if (Settings.OAuthCredentials != null &&
!string.IsNullOrWhiteSpace(Settings.OAuthCredentials.MicrosoftAppId) &&
!string.IsNullOrWhiteSpace(Settings.OAuthCredentials.MicrosoftAppPassword))
{
oauthCredentials = new MicrosoftAppCredentials(Settings.OAuthCredentials.MicrosoftAppId, Settings.OAuthCredentials.MicrosoftAppPassword);
}
AddDialog(new MultiProviderAuthDialog(Settings.OAuthConnections, null, oauthCredentials));
AddDialog(new EventPrompt(DialogIds.SkillModeAuth, "tokens/response", TokenResponseValidator));
}
/// <summary>
/// Creates the connector client.
/// </summary>
/// <param name="serviceUrl">The service URL.</param>
/// <param name="appCredentials">The application credentials for the bot.</param>
/// <returns>Connector client instance.</returns>
private IConnectorClient CreateConnectorClient(string serviceUrl, AppCredentials appCredentials = null)
{
var clientKey = $"{serviceUrl}{appCredentials?.MicrosoftAppId ?? string.Empty}";
return(_connectorClients.GetOrAdd(clientKey, (key) =>
{
ConnectorClient connectorClient;
if (appCredentials != null)
{
connectorClient = new ConnectorClient(new Uri(serviceUrl), appCredentials, customHttpClient: _httpClient);
}
else
{
var emptyCredentials = _channelProvider != null && _channelProvider.IsGovernment() ? MicrosoftGovernmentAppCredentials.Empty : MicrosoftAppCredentials.Empty;
connectorClient = new ConnectorClient(new Uri(serviceUrl), emptyCredentials, customHttpClient: _httpClient);
}
if (_connectorClientRetryPolicy != null)
{
connectorClient.SetRetryPolicy(_connectorClientRetryPolicy);
}
return connectorClient;
}));
}
private async Task BotCallback(ITurnContext turnContext, CancellationToken cancellationToken)
{
AppCredentials.TrustServiceUrl(turnContext.Activity.ServiceUrl);
// If you encounter permission-related errors when sending this message, see
// https://aka.ms/BotTrustServiceUrl
await turnContext.SendActivityAsync("proactive hello");
}
public MultiProviderAuthDialog(
List <OAuthConnection> authenticationConnections,
List <OAuthPromptSettings> promptSettings = null,
AppCredentials oauthCredentials = null)
: base(nameof(MultiProviderAuthDialog))
{
_authenticationConnections = authenticationConnections ?? throw new ArgumentNullException(nameof(authenticationConnections));
_oauthCredentials = oauthCredentials;
_responseManager = new ResponseManager(
AcceptedLocales,
new AuthenticationResponses());
var firstStep = new WaterfallStep[]
{
FirstStepAsync,
};
var authSteps = new WaterfallStep[]
{
PromptForProviderAsync,
PromptForAuthAsync,
HandleTokenResponseAsync,
};
AddDialog(new WaterfallDialog(DialogIds.FirstStepPrompt, firstStep));
if (_authenticationConnections != null &&
_authenticationConnections.Count > 0 &&
_authenticationConnections.Any(c => !string.IsNullOrWhiteSpace(c.Name)))
{
for (int i = 0; i < _authenticationConnections.Count; ++i)
{
var connection = _authenticationConnections[i];
foreach (var locale in AcceptedLocales)
{
// We ignore placeholder connections in config that don't have a Name
if (!string.IsNullOrWhiteSpace(connection.Name))
{
AddDialog(GetLocalizedDialog(locale, connection.Name, promptSettings?[i]));
}
}
}
AddDialog(new WaterfallDialog(DialogIds.AuthPrompt, authSteps));
AddDialog(new ChoicePrompt(DialogIds.ProviderPrompt));
}
else
{
throw new ArgumentNullException(nameof(authenticationConnections));
}
}
public async void Channel_MsaHeader_Valid_ServiceUrlShouldBeTrusted()
{
string header = $"Bearer {await new MicrosoftAppCredentials("2cd87869-38a0-4182-9251-d056e8f0ac24", "2.30Vs3VQLKt974F").GetTokenAsync()}";
var credentials = new SimpleCredentialProvider("2cd87869-38a0-4182-9251-d056e8f0ac24", string.Empty);
await JwtTokenValidation.AuthenticateRequest(
new Activity { ServiceUrl = "https://smba.trafficmanager.net/amer-client-ss.msg/" },
header,
credentials,
new SimpleChannelProvider(),
emptyClient);
Assert.True(AppCredentials.IsTrustedServiceUrl("https://smba.trafficmanager.net/amer-client-ss.msg/"));
}
/// <summary>
/// Initializes a new instance of the <see cref="MeetingService"/> class.
/// </summary>
/// <param name="httpClientFactory">The Http client factory.</param>
/// <param name="botCredentials">The Bot credentials.</param>
/// <param name="botAdapter">The Bot Framework HTTP adapter.</param>
/// <param name="tenantInfoRepository">The TenantInfo repository.</param>
/// <param name="meetingServiceOptions">App options related to the meetings service.</param>
public MeetingService(
IHttpClientFactory httpClientFactory,
AppCredentials botCredentials,
IBotFrameworkHttpAdapter botAdapter,
ITenantInfoRepository tenantInfoRepository,
IOptions <MeetingServiceOptions> meetingServiceOptions)
{
this.botCredentials = botCredentials;
this.botAdapter = (BotFrameworkHttpAdapter)botAdapter;
this.httpClient = httpClientFactory.CreateClient();
this.tenantInfoRepository = tenantInfoRepository;
this.teamsAppId = meetingServiceOptions.Value.TeamsAppId;
this.contentBubbleUrl = meetingServiceOptions.Value.ContentBubbleUrl;
}
private async void UpdateCardInTeams(BlobDataDeserializer blobData, Attachment adaptiveCardAttachment)
{
using var connector = new ConnectorClient(new Uri(Constants.ServiceUrl), Constants.MicrosoftAppId, Constants.MicrosoftAppPassword);
AppCredentials.TrustServiceUrl(Constants.ServiceUrl, DateTime.MaxValue);
var updateActivity = new Activity();
updateActivity.Id = blobData.messageId;
updateActivity.Type = "message";
updateActivity.Attachments = new List <Attachment> {
adaptiveCardAttachment
};
updateActivity.Conversation = new ConversationAccount(id: blobData.conversationId);
await connector.Conversations.UpdateActivityAsync(updateActivity);
}
private async Task SendMessageAsync(string message, NotificationDetails notification)
{
var activity = MessageFactory.Text(message);
activity.Summary = message;
activity.TeamsNotifyUser();
AppCredentials.TrustServiceUrl(ServiceUrl);
var credentials = new MicrosoftAppCredentials(appId, appPassword);
var connectorClient = new ConnectorClient(new Uri(ServiceUrl), credentials);
await connectorClient.Conversations.SendToConversationAsync(notification.ChannelId, activity);
}
public JsonResponseClient(IWebRequestCreator webRequestCreator, IWebRequestInvoker webRequestInvoker)
{
_appCredentials = new AppCredentials();
_customHeaders = new NameValueCollection();
if (_appCredentials.ApplicationKey != null)
{
SetAppKeyHeader(_appCredentials.ApplicationKey);
}
_argumentsAdder = new ArgumentsAdder <T>();
_urlSuffixGetter = new UrlSuffixGetter <T>();
_webRequestCreator = webRequestCreator;
_webRequestInvoker = webRequestInvoker;
}
/// <summary>
/// Validates the auth header for WebSocket upgrade requests.
/// </summary>
/// <remarks>
/// Returns a ClaimsIdentity for successful auth and when auth is disabled. Returns null for failed auth.
/// </remarks>
/// <param name="httpRequest">The connection request.</param>
private async Task <ClaimsIdentity> AuthenticateRequestAsync(HttpRequest httpRequest)
{
try
{
if (!await CredentialProvider.IsAuthenticationDisabledAsync().ConfigureAwait(false))
{
var authHeader = httpRequest.Headers.First(x => string.Equals(x.Key, AuthHeaderName, StringComparison.OrdinalIgnoreCase)).Value.FirstOrDefault();
var channelId = httpRequest.Headers.First(x => string.Equals(x.Key, ChannelIdHeaderName, StringComparison.OrdinalIgnoreCase)).Value.FirstOrDefault();
if (string.IsNullOrWhiteSpace(authHeader))
{
await WriteUnauthorizedResponseAsync(AuthHeaderName, httpRequest).ConfigureAwait(false);
return(null);
}
if (string.IsNullOrWhiteSpace(channelId))
{
await WriteUnauthorizedResponseAsync(ChannelIdHeaderName, httpRequest).ConfigureAwait(false);
return(null);
}
var claimsIdentity = await JwtTokenValidation.ValidateAuthHeader(authHeader, CredentialProvider, ChannelProvider, channelId).ConfigureAwait(false);
if (!claimsIdentity.IsAuthenticated)
{
httpRequest.HttpContext.Response.StatusCode = (int)HttpStatusCode.Unauthorized;
return(null);
}
// Add ServiceURL to the cache of trusted sites in order to allow token refreshing.
AppCredentials.TrustServiceUrl(claimsIdentity.FindFirst(AuthenticationConstants.ServiceUrlClaim).Value);
ClaimsIdentity = claimsIdentity;
return(claimsIdentity);
}
// Authentication is not enabled, therefore return an anonymous ClaimsIdentity.
return(new ClaimsIdentity(new List <Claim>(), "anonymous"));
}
catch (Exception)
{
httpRequest.HttpContext.Response.StatusCode = (int)HttpStatusCode.InternalServerError;
await httpRequest.HttpContext.Response.WriteAsync("Error while attempting to authorize connection.").ConfigureAwait(false);
throw;
}
}
private async Task <bool> AuthenticateRequestAsync(HttpRequest httpRequest)
{
try
{
if (!await CredentialProvider.IsAuthenticationDisabledAsync().ConfigureAwait(false))
{
var authHeader = httpRequest.Headers.First(x => x.Key.ToLower() == AuthHeaderName).Value.FirstOrDefault();
var channelId = httpRequest.Headers.First(x => x.Key.ToLower() == ChannelIdHeaderName).Value.FirstOrDefault();
if (string.IsNullOrWhiteSpace(authHeader))
{
await WriteUnauthorizedResponseAsync(AuthHeaderName, httpRequest).ConfigureAwait(false);
return(false);
}
if (string.IsNullOrWhiteSpace(channelId))
{
await WriteUnauthorizedResponseAsync(ChannelIdHeaderName, httpRequest).ConfigureAwait(false);
return(false);
}
var claimsIdentity = await JwtTokenValidation.ValidateAuthHeader(authHeader, CredentialProvider, ChannelProvider, channelId).ConfigureAwait(false);
if (!claimsIdentity.IsAuthenticated)
{
httpRequest.HttpContext.Response.StatusCode = (int)HttpStatusCode.Unauthorized;
return(false);
}
// Add ServiceURL to the cache of trusted sites in order to allow token refreshing.
AppCredentials.TrustServiceUrl(claimsIdentity.FindFirst(AuthenticationConstants.ServiceUrlClaim).Value);
ClaimsIdentity = claimsIdentity;
}
return(true);
}
catch (Exception ex)
{
httpRequest.HttpContext.Response.StatusCode = (int)HttpStatusCode.InternalServerError;
await httpRequest.HttpContext.Response.WriteAsync("Error while attempting to authorize connection.").ConfigureAwait(false);
throw ex;
}
}
private async Task <bool> AuthenticateRequestAsync(HttpRequestMessage httpRequest, HttpResponseMessage httpResponse)
{
try
{
if (!await CredentialProvider.IsAuthenticationDisabledAsync().ConfigureAwait(false))
{
#pragma warning disable CA1308 // Normalize strings to uppercase (header names come in lowercase, ignoring)
var authHeader = httpRequest.Headers.GetValues(AuthHeaderName.ToLowerInvariant()).FirstOrDefault();
var channelId = httpRequest.Headers.GetValues(ChannelIdHeaderName.ToLowerInvariant()).FirstOrDefault();
#pragma warning restore CA1308 // Normalize strings to uppercase
if (string.IsNullOrWhiteSpace(authHeader))
{
WriteUnauthorizedResponse(AuthHeaderName, httpResponse);
return(false);
}
if (string.IsNullOrWhiteSpace(channelId))
{
WriteUnauthorizedResponse(ChannelIdHeaderName, httpResponse);
return(false);
}
var claimsIdentity = await JwtTokenValidation.ValidateAuthHeader(authHeader, CredentialProvider, ChannelProvider, channelId).ConfigureAwait(false);
if (!claimsIdentity.IsAuthenticated)
{
httpResponse.StatusCode = HttpStatusCode.Unauthorized;
return(false);
}
// Add ServiceURL to the cache of trusted sites in order to allow token refreshing.
AppCredentials.TrustServiceUrl(claimsIdentity.FindFirst(AuthenticationConstants.ServiceUrlClaim).Value);
ClaimsIdentity = claimsIdentity;
}
return(true);
}
catch (Exception)
{
httpResponse.StatusCode = HttpStatusCode.InternalServerError;
httpResponse.Content = new StringContent("Error while attempting to authorize connection.");
throw;
}
}
// This method gets called by the runtime. Use this method to add services to the container.
public void ConfigureServices(IServiceCollection services)
{
services.AddControllers().AddNewtonsoftJson(x => x.SerializerSettings.ReferenceLoopHandling = ReferenceLoopHandling.Ignore);
services.AddSwaggerGen(c =>
{
c.SwaggerDoc("v1", new OpenApiInfo {
Title = "WebApp", Version = "v1"
});
});
services.AddHttpClient();
services.AddMindSphereSdkService(options =>
{
options.Credentials = AppCredentials.FromJsonFile(@"..\..\mdspcreds.json");
});
}
/// <summary>
/// Initializes a new instance of the <see cref="BotFrameworkSkillHostAdapter"/> class,
/// using a credential provider.
/// </summary>
/// <param name="adapter">adapter that this skillAdapter is bound to.</param>
/// <param name="credentials">The credentials to be used for token acquisition.</param>
/// <param name="authConfig">The authentication configuration.</param>
/// <param name="channelProvider">The channel provider.</param>
/// <param name="connectorClientRetryPolicy">Retry policy for retrying HTTP operations.</param>
/// <param name="customHttpClient">The HTTP client.</param>
/// <param name="logger">The ILogger implementation this adapter should use.</param>
/// <exception cref="ArgumentNullException">throw ArgumentNullException.</exception>
/// <remarks>Use a <see cref="MiddlewareSet"/> object to add multiple middleware
/// components in the constructor. Use the Use(<see cref="IMiddleware"/>) method to
/// add additional middleware to the adapter after construction.
/// </remarks>
public BotFrameworkSkillHostAdapter(
BotAdapter adapter,
AppCredentials credentials,
AuthenticationConfiguration authConfig,
IChannelProvider channelProvider = null,
RetryPolicy connectorClientRetryPolicy = null,
HttpClient customHttpClient = null,
ILogger logger = null)
: base(adapter, logger)
{
_appCredentials = credentials ?? throw new ArgumentNullException(nameof(credentials));
_channelProvider = channelProvider;
_httpClient = customHttpClient ?? _defaultHttpClient;
_connectorClientRetryPolicy = connectorClientRetryPolicy;
_logger = logger ?? NullLogger.Instance;
_authConfiguration = authConfig ?? throw new ArgumentNullException(nameof(authConfig));
// DefaultRequestHeaders are not thread safe so set them up here because this adapter should be a singleton.
ConnectorClient.AddDefaultRequestHeaders(_httpClient);
}
public GameStart(IConfiguration configuration, IAdaptiveTemplateLoader loader, Dictionary <string, string> convos)
{
_appId = configuration["MicrosoftAppId"];
_appPassword = configuration["MicrosoftAppPassword"];
AppCredentials.TrustServiceUrl("https://smba.trafficmanager.net/amer/");
this.client = new ConnectorClient(new Uri("https://smba.trafficmanager.net/amer/"), microsoftAppId: this._appId, microsoftAppPassword: this._appPassword);
IConfidentialClientApplication confidentialClientApplication = ConfidentialClientApplicationBuilder
.Create(this._appId)
.WithTenantId("72f988bf-86f1-41af-91ab-2d7cd011db47")
.WithClientSecret(this._appPassword)
.Build();
ClientCredentialProvider authProvider = new ClientCredentialProvider(confidentialClientApplication);
this.graphClient = new GraphServiceClient(authProvider);
this.convos = convos;
this.gameStartTemplate = loader.InitializeAdaptiveTemplate("MatchStart.json");
this.gameUpdateTemplate = loader.InitializeAdaptiveTemplate("MatchUpdate.json");
}
static async Task Main(string[] args)
{
AppCredentials appCredentials = AppCredentials.FromJsonFile(@"..\..\..\..\..\mdspcreds.json");
HttpClient httpClient = new HttpClient();
AssetManagementClient assetClient = new AssetManagementClient(appCredentials, httpClient);
ListAssetsRequest request = new ListAssetsRequest()
{
Size = 200
};
List <Asset> test = (await assetClient.ListAssetsAsync(request)).ToList();
foreach (var item in test)
{
Console.WriteLine(item.AssetId);
}
Console.ReadKey();
}
public ToDoSkillDialogBase(
string dialogId,
IServiceProvider serviceProvider,
IHttpContextAccessor httpContext)
: base(dialogId)
{
_httpContext = httpContext;
Settings = serviceProvider.GetService <BotSettings>();
Services = serviceProvider.GetService <BotServices>();
TemplateManager = serviceProvider.GetService <LocaleTemplateManager>();
// Initialize state accessor
var conversationState = serviceProvider.GetService <ConversationState>();
ToDoStateAccessor = conversationState.CreateProperty <ToDoSkillState>(nameof(ToDoSkillState));
var userState = serviceProvider.GetService <UserState>();
UserStateAccessor = userState.CreateProperty <ToDoSkillUserState>(nameof(ToDoSkillUserState));
ServiceManager = serviceProvider.GetService <IServiceManager>();
AppCredentials oauthCredentials = null;
if (Settings.OAuthCredentials != null &&
!string.IsNullOrWhiteSpace(Settings.OAuthCredentials.MicrosoftAppId) &&
!string.IsNullOrWhiteSpace(Settings.OAuthCredentials.MicrosoftAppPassword))
{
oauthCredentials = new MicrosoftAppCredentials(Settings.OAuthCredentials.MicrosoftAppId, Settings.OAuthCredentials.MicrosoftAppPassword);
}
AddDialog(new MultiProviderAuthDialog(Settings.OAuthConnections, null, oauthCredentials));
AddDialog(new TextPrompt(Actions.Prompt));
AddDialog(new ConfirmPrompt(Actions.ConfirmPrompt, null, Culture.English)
{
Style = ListStyle.SuggestedAction
});
}
public async Task <Activity> GetDayActivityAsync(string Currentdate, string userId)
{
var appCredentials = AppCredentials.ToString();
var oAuth_params = OAuthUtility.BuildBasicParameters(AppCredentials.ConsumerKey, AppCredentials.ConsumerSecret, "https://wbsapi.withings.net", HttpMethod.Get, this.AccessToken)
.Where(p => p.Key != "oauth_signature")
.OrderBy(p => p.Key);
string startdate = ("2017-02-30");
string date = ("2017-03-24");
string requestUri = $"https://wbsapi.withings.net/v2/measure?action=getactivity&userid={userId}&date={date}&";
requestUri += string.Join("&", oAuth_params.Select(kvp => kvp.Key + "=" + kvp.Value));
var signature = OAuthUtility.BuildBasicParameters(AppCredentials.ConsumerKey, AppCredentials.ConsumerSecret, requestUri, HttpMethod.Get, this.AccessToken)
.First((KeyValuePair <string, string> p) => p.Key == "oauth_signature").Value;
string json = await HttpClient.GetStringAsync(requestUri + "&oauth_signature=" + signature);
var o = JObject.Parse(json);
return(new Activity
{
Calories = (float)o["body"]["calories"],
Date = (string)o["body"]["date"],
Distance = (float)o["body"]["distance"],
Elevation = (float)o["body"]["elevation"],
Intense = (int)o["body"]["intense"],
Moderate = (int)o["body"]["moderate"],
Soft = (int)o["body"]["soft"],
Steps = (int)o["body"]["steps"],
TimeZone = (string)o["body"]["timezone"],
TotalCalories = (float)o["body"]["totalcalories"]
});
}
public async Task <IEnumerable <MeasureGroup> > GetBodyMeasureAsync(string userId, string deviceType)
{
var appCredentials = AppCredentials.ToString();
var oAuth_params = OAuthUtility.BuildBasicParameters(AppCredentials.ConsumerKey, AppCredentials.ConsumerSecret, "https://wbsapi.withings.net", HttpMethod.Get, this.AccessToken)
.Where(p => p.Key != "oauth_signature")
.OrderBy(p => p.Key);
string requestUri = $"https://wbsapi.withings.net/measure?action=getmeas&userid={userId}&devtype={deviceType}&";
requestUri += string.Join("&", oAuth_params.Select(kvp => kvp.Key + "=" + kvp.Value));
var signature = OAuthUtility.BuildBasicParameters(AppCredentials.ConsumerKey, AppCredentials.ConsumerSecret, requestUri, HttpMethod.Get, this.AccessToken)
.First((KeyValuePair <string, string> p) => p.Key == "oauth_signature").Value;
string json = await HttpClient.GetStringAsync(requestUri + "&oauth_signature=" + signature);
var o = JObject.Parse(json);
return(JsonConvert.DeserializeObject <IEnumerable <MeasureGroup> >(o["body"]["measuregrps"].ToString()));
}
private static void AssertCredentialsValues(AppCredentials creds, string expectedAppId, string expectedScope = AuthenticationConstants.ToChannelFromBotOAuthScope)
{
Assert.AreEqual(expectedAppId, creds.MicrosoftAppId);
Assert.AreEqual(expectedScope, creds.OAuthScope);
}
public IActionResult SendCC([FromQuery] int studentDetailId)
{
Log.Information($"Sending CC email to {studentDetailId}");
string username = User.Identity.Name.Split('\\')[User.Identity.Name.Split('\\').Length - 1];
var CCPermission = Context.ProSolutionPermissions.Where(i => i.UserName == username && i.IsAllowed == true && i.ObjectName == Config["CCProSolutionSecurityObject:ObjectName"] && i.ActionName == Config["CCProSolutionSecurityObject:ActionName"] && i.ObjectType == Config["CCProSolutionSecurityObject:ObjectType"]).FirstOrDefault();
var harrogateLetterPermission = Context.ProSolutionPermissions.Where(i => i.UserName == username && i.IsAllowed == true && i.ObjectName == Config["HOfferProSolutionSecurityObject:ObjectName"] && i.ActionName == Config["HOfferProSolutionSecurityObject:ActionName"] && i.ObjectType == Config["HOfferProSolutionSecurityObject:ObjectType"]).FirstOrDefault();
var generalLetterPermission = Context.ProSolutionPermissions.Where(i => i.UserName == username && i.IsAllowed == true && i.ObjectName == Config["GOfferProSolutionSecurityObject:ObjectName"] && i.ActionName == Config["GOfferProSolutionSecurityObject:ActionName"] && i.ObjectType == Config["GOfferProSolutionSecurityObject:ObjectType"]).FirstOrDefault();
StudentDetail student = Context.StudentDetail.Where(i => i.StudentDetailId == studentDetailId).SingleOrDefault();
if (student == null)
{
ModelState.AddModelError("", "No Student specified - close this window and try again");
Log.Error("No Student specified");
return(View("Index", new StudentView()));
}
//var str = Request.Query["studentData"].FirstOrDefault();
var sDetail = Context.StudentDetail.Where(i => i.StudentDetailId == studentDetailId).SingleOrDefault();
try
{
if (sDetail.CriminalConvictionId != 2)
{
ModelState.AddModelError("", $"Student {sDetail.RefNo} does not have a criminal conviction");
return(View("Index", MapStudentView(sDetail, true, CCPermission != null, harrogateLetterPermission != null, generalLetterPermission != null)));
}
var sentEmailControl = Context.CcsentMailControl.Where(i => i.StudentDetailId == sDetail.StudentDetailId).SingleOrDefault();
if (sentEmailControl == null)
{
sentEmailControl = new CcsentMailControl()
{
StudentDetailId = sDetail.StudentDetailId,
DateSent = DateTime.Now,
Receipiant = sDetail.Email,
Attempts = 1
};
Context.Add(sentEmailControl);
}
else
{
if (sentEmailControl.Attempts > 0)
{
sentEmailControl.Attempts++;
}
sentEmailControl.DateSent = DateTime.Now;
Context.Update(sentEmailControl);
}
Context.SaveChanges();
var appCredential = Context.AppCredentials.Where(i => i.IdentityKey == sDetail.StudentDetailId.ToString() && i.SystemRef == "CC").SingleOrDefault();
if (appCredential == null)
{
appCredential = new AppCredentials()
{
ActivationWord = getRandString(50),
IdentityKey = sDetail.StudentDetailId.ToString(),
Expiry = null,
SystemRef = "CC",
ProtectionString = getRandString(10)
};
Context.Add(appCredential);
}
else
{
}
Context.SaveChanges();
var dispQueue = Context.CcdispatchQueue.Where(i => i.StudentDetailId == sDetail.StudentDetailId && i.SystemRef == "CC").SingleOrDefault();
if (dispQueue == null)
{
dispQueue = new CcdispatchQueue()
{
StudentDetailId = sDetail.StudentDetailId,
AddedBy = User.Identity.Name,
DateStamp = DateTime.Now,
Status = 0,
SystemRef = "CC"
};
Context.Add(dispQueue);
}
else
{
dispQueue.DateStamp = DateTime.Now;
dispQueue.AddedBy = User.Identity.Name;
dispQueue.Status = 0;
Context.Update(dispQueue);
}
Context.SaveChanges();
Log.Information($"Finished SendCC for {sDetail.RefNo} {ModelState.IsValid}");
if (!ModelState.IsValid)
{
foreach (var error in ModelState)
{
Log.Error($"{error}");
}
}
return(View("Index", MapStudentView(sDetail, true, CCPermission != null, harrogateLetterPermission != null, generalLetterPermission != null)));
}
catch (Exception ex)
{
ModelState.AddModelError("", "An error has occurred");
Log.Error(ex.Message);
return(View("Index", MapStudentView(sDetail, true, CCPermission != null, harrogateLetterPermission != null, generalLetterPermission != null)));
}
}
private async Task CreateConversationAsync(ITurnContext turnContext, string channelId, string serviceUrl, AppCredentials credentials, ConversationParameters conversationParameters, BotCallbackHandler callback, CancellationToken cancellationToken)
{
using (var connectorClient = new ConnectorClient(new Uri(serviceUrl), credentials))
{
var result = await connectorClient.Conversations.CreateConversationAsync(conversationParameters, cancellationToken).ConfigureAwait(false);
// Create a conversation update activity to represent the result.
var eventActivity = Activity.CreateEventActivity();
eventActivity.Name = ActivityEventNames.CreateConversation;
eventActivity.ChannelId = channelId;
eventActivity.ServiceUrl = serviceUrl;
eventActivity.Id = result.ActivityId ?? Guid.NewGuid().ToString("n");
eventActivity.Conversation = new ConversationAccount(id: result.Id, tenantId: conversationParameters.TenantId);
eventActivity.ChannelData = conversationParameters.ChannelData;
eventActivity.Recipient = conversationParameters.Bot;
using (var context = new TurnContext(turnContext.Adapter, (Activity)eventActivity))
{
var claimsIdentity = new ClaimsIdentity();
claimsIdentity.AddClaim(new Claim(AuthenticationConstants.AudienceClaim, credentials.MicrosoftAppId));
claimsIdentity.AddClaim(new Claim(AuthenticationConstants.AppIdClaim, credentials.MicrosoftAppId));
claimsIdentity.AddClaim(new Claim(AuthenticationConstants.ServiceUrlClaim, serviceUrl));
//context.TurnState.Add<IIdentity>(BotIdentityKey, claimsIdentity);
//context.TurnState.Add(connectorClient);
//Middleware? Forget about it in this little hack.
//await RunPipelineAsync(context, callback, cancellationToken).ConfigureAwait(false);
await callback(turnContext, cancellationToken).ConfigureAwait(false);
// Cleanup disposable resources in case other code kept a reference to it.
//context.TurnState.Set<IConnectorClient>(null);
}
}
}
public override Task <TokenResponse> GetUserTokenAsync(ITurnContext turnContext, AppCredentials appCredentials, string connectionName, string magicCode, CancellationToken cancellationToken)
{
return(Task.FromResult(_getUserTokenAction()));
}
public IActionResult SendCCee(string p1)
{
try
{
var f = Request.Query["studentId"];
var sDetail = ImmediateDB.StudentDetail.Where(i => i.RefNo == "").SingleOrDefault();
var sentEmailControl = ImmediateDB.CcsentMailControl.Where(i => i.StudentDetailId == sDetail.StudentDetailId).SingleOrDefault();
if (sentEmailControl == null)
{
sentEmailControl = new CcsentMailControl()
{
StudentDetailId = sDetail.StudentDetailId,
DateSent = DateTime.Now,
Receipiant = sDetail.Email,
Attempts = 1
};
ImmediateDB.Add(sentEmailControl);
}
else
{
sentEmailControl.Attempts++;
sentEmailControl.DateSent = DateTime.Now;
ImmediateDB.Update(sentEmailControl);
}
ImmediateDB.SaveChanges();
var appCredential = ImmediateDB.AppCredentials.Where(i => i.IdentityKey == sDetail.StudentDetailId.ToString() && i.SystemRef == "CC").SingleOrDefault();
if (appCredential == null)
{
appCredential = new AppCredentials()
{
ActivationWord = getRandString(50),
IdentityKey = sDetail.StudentDetailId.ToString(),
Expiry = null,
SystemRef = "CC",
ProtectionString = getRandString(10)
};
ImmediateDB.Add(appCredential);
}
else
{
}
ImmediateDB.SaveChanges();
var dispQueue = ImmediateDB.CcdispatchQueue.Where(i => i.StudentDetailId == sDetail.StudentDetailId).SingleOrDefault();
if (dispQueue == null)
{
dispQueue = new CcdispatchQueue()
{
StudentDetailId = sDetail.StudentDetailId,
AddedBy = "",
DateStamp = DateTime.Now,
Status = 0
};
ImmediateDB.Add(dispQueue);
}
else
{
dispQueue.DateStamp = DateTime.Now;
dispQueue.Status = 0;
ImmediateDB.Update(dispQueue);
}
ImmediateDB.SaveChanges();
return(View());
}
catch (Exception ex)
{
return(BadRequest(ex.Message));
}
}
public HomeController(IConfiguration configuration, IHttpClientFactory httpClientFactory, AppCredentials botCredentials)
{
_configuration = configuration;
this.botCredentials = botCredentials;
this.httpClient = httpClientFactory.CreateClient();
}
