private ID2LUserContext GetUserContext(Dictionary <string, object> licenseSettings, string userId, string userKey, string hostUrl) { var host = new HostSpec("https", hostUrl, 443); var context = InitializeAppContext(licenseSettings); return(context.CreateUserContext(userId, userKey, host)); }
public Uri GetTokenRedirectUrl(Uri returnUrl, string hostUrl, Dictionary <string, object> licenseSettings) { var m_valenceHost = new HostSpec("https", hostUrl, 443); var context = InitializeAppContext(licenseSettings); return(context.CreateUrlForAuthentication(m_valenceHost, returnUrl)); }
Uri ID2LAppContext.CreateUrlForAuthentication( HostSpec authenticatingHost, Uri landingUri ) { var uriBuilder = authenticatingHost.ToUriBuilder(); uriBuilder.Path = AUTHENTICATION_SERVICE_URI_PATH; uriBuilder.Query = BuildAuthenticationUriQueryString( landingUri ); return uriBuilder.Uri; }
private static ID2LUserContext InterceptUserTokens(HostSpec host, ID2LAppContext appContext) { // Start HTTP server and listen for the redirect after a successful auth var httpListener = new HttpListener(); httpListener.Prefixes.Add("http://localhost:31337/result/"); httpListener.Start(); // This call blocks until we get a response var ctx = httpListener.GetContext(); // The LMS returns the user tokens via query parameters to the value provided originally in x_target // TODO: deal with "failed to login" case var userContext = appContext.CreateUserContext(ctx.Request.Url, host); // Send some JavaScript to close the browser popup // This is not 100% effective: for example, Firefox will ignore this. const string RESPONSE = "<!doctype html><meta charset=\"utf-8\"><script>window.close();</script><h1>You may now close your window</h1><p>You may or may not see this message, depending on your browser</p>"; byte[] buffer = System.Text.Encoding.UTF8.GetBytes(RESPONSE); ctx.Response.ContentType = "text/html"; ctx.Response.ContentLength64 = buffer.Length; ctx.Response.OutputStream.Write(buffer, 0, buffer.Length); ctx.Response.OutputStream.Close(); httpListener.Stop(); return(userContext); }
public HomeController( ) { var appFactory = new D2LAppContextFactory(); m_valenceAppContext = appFactory.Create(APP_ID, APP_KEY); m_valenceHost = new HostSpec("https", LMS_URL, 443); }
private ID2LUserContext CreateUserOperationContext() { var apiHost = new HostSpec(m_scheme, m_host, m_port); var opContext = m_appContext.CreateUserContext(m_userId, m_userKey, apiHost); return(opContext); }
static void Main() { // This is the LMS we will interact with var host = new HostSpec("https", "lms.valence.desire2learn.com", 443); // The appId/appKey come from our app.config - it is good to seperate access keys from the code that uses them. // Ideally you wouldn't have production keys committed to source control. string appId = ConfigurationManager.AppSettings["appId"]; string appKey = ConfigurationManager.AppSettings["appKey"]; // This is the port we will temporarily host a server on to intercept the user tokens after a successful login int port = int.Parse(ConfigurationManager.AppSettings["serverPort"]); // Create url for the user to login. If they have already done so they will not actually have to type their password (maybe). var appContextFactory = new D2LAppContextFactory(); var appContext = appContextFactory.Create(appId, appKey); var authUrl = appContext.CreateUrlForAuthentication(host, new Uri("http://localhost:" + port + "/result/")); OpenBrowser(authUrl); // This call will block until we have a result // TODO: you'll want better control flow and error handling here var userContext = InterceptUserTokens(host, appContext); // Now we can call Valence DoApiStuff(host.Scheme + "://" + host.Host + ":" + host.Port, userContext); // Pause the terminal Console.ReadKey(); }
public ActionResult Index() { var param = Session[SESSION_KEY] as SessionParameters; if (param == null) { ViewBag.ErrorMessage = "Unable to retrieve required session param."; return(View("BookError")); } if (param.LtiUri == null) { ViewBag.ErrorMessage = "LTI param are not valid."; return(View("BookError")); } // retrieve the required version information from the LMS var factory = new D2LAppContextFactory(); var appContext = factory.Create(m_defaultAppId, m_defaultAppKey); var hostInfo = new HostSpec(param.LtiUri.Scheme, param.LtiUri.Host, param.LtiUri.Port); ID2LUserContext context = appContext.CreateUserContext(Request.Url, hostInfo); if (context == null) { ViewBag.ErrorMessage = "Unable to create user context."; return(View("BookError")); } param.UserContext = context; return(RedirectToAction("Assigned")); }
public HomeController( ) { var appFactory = new D2LAppContextFactory(); m_valenceAppContext = appFactory.Create(m_appId, m_appKey); m_valenceHost = new HostSpec("https", LMS_URL, 443); }
public void AppContext_CreateUrlForAuth_IfHostSpecSaysHttps_ReturnsUri_WhereSchemeIsHttps() { var hostSpec = new HostSpec( "https", TestConstants.HOST_NAME, 443 ); Uri uri = m_appContext.CreateUrlForAuthentication( hostSpec, m_landingUri ); Assert.AreEqual( "https", uri.Scheme ); }
public void AppContext_CreateUrlForAuth_ReturnsUri_WherePortNumber_MatchesInput() { const int expectedPortNumber = 44480; var hostSpec = new HostSpec( "https", TestConstants.HOST_NAME, expectedPortNumber ); Uri uri = m_appContext.CreateUrlForAuthentication( hostSpec, m_landingUri ); Assert.AreEqual( expectedPortNumber, uri.Port ); }
public void AppContext_CreateUrlForAuth_ReturnsUri_WhereHost_MatchesInput() { const string expectedHost = "asdf.com"; var hostSpec = new HostSpec( "https", expectedHost, TestConstants.PORT ); Uri uri = m_appContext.CreateUrlForAuthentication( hostSpec, m_landingUri ); Assert.AreEqual( expectedHost, uri.Host ); }
public void AppContext_CreateUrlForAuth_IfHostSpecSaysHttps_ReturnsUri_WhereSchemeIsHttps() { var hostSpec = new HostSpec("https", TestConstants.HOST_NAME, 443); Uri uri = m_appContext.CreateUrlForAuthentication(hostSpec, m_landingUri); Assert.AreEqual("https", uri.Scheme); }
Uri ID2LAppContext.CreateUrlForAuthentication(HostSpec authenticatingHost, Uri landingUri) { var uriBuilder = authenticatingHost.ToUriBuilder(); uriBuilder.Path = AUTHENTICATION_SERVICE_URI_PATH; uriBuilder.Query = BuildAuthenticationUriQueryString(landingUri); return(uriBuilder.Uri); }
public void SendRequest_WhenBadHostSpec_UnhandledException() { var badApiHost = new HostSpec(ChangeScheme(m_scheme), m_host, m_port); var badAnonContext = m_appContext.CreateAnonymousUserContext(badApiHost); var request = PrepareApiRequest(badAnonContext, GET_VERSIONS_ROUTE); Assert.Throws <WebException>(() => request.GetResponse()); }
public void SendRequest_WhenBadHostSpec_UnhandledException() { HostSpec badApiHost = new HostSpec(ChangeScheme(ConfigHelper.Scheme), ConfigHelper.Host, ConfigHelper.Port); ID2LUserContext badAnonContext = ContextProvider.AnonUserContext(badApiHost); HttpWebRequest request = RequestProvider.PrepareApiRequest(badAnonContext, RouteProvider.VersionsRoute); Assert.Throws <WebException>(() => { using (HttpWebResponse response = request.GetResponse() as HttpWebResponse) { } }); }
public void AppContext_CreateUrlForAuth_ReturnsUri_WhereHost_MatchesInput() { const string expectedHost = "asdf.com"; var hostSpec = new HostSpec("https", expectedHost, TestConstants.PORT); Uri uri = m_appContext.CreateUrlForAuthentication(hostSpec, m_landingUri); Assert.AreEqual(expectedHost, uri.Host); }
/// <summary> /// Constructs a D2LUserContext with the parameters provided /// </summary> /// <param name="timestampProvider">The system timestamp provider</param> /// <param name="appId">The D2L app ID</param> /// <param name="appKey">The D2L app key</param> /// <param name="userId">The D2L user ID to be used</param> /// <param name="userKey">The D2L user key to be used</param> /// <param name="apiHost">The host information of the server to make API calls to</param> internal D2LUserContext( ITimestampProvider timestampProvider, string appId, string appKey, string userId, string userKey, HostSpec apiHost ) { m_appId = appId; m_appKey = appKey; m_userId = userId; m_userKey = userKey; m_apiHost = apiHost; m_timestampProvider = timestampProvider; }
public void AppContext_CreateUrlForAuth_ReturnsUri_WherePortNumber_MatchesInput() { const int expectedPortNumber = 44480; var hostSpec = new HostSpec("https", TestConstants.HOST_NAME, expectedPortNumber); Uri uri = m_appContext.CreateUrlForAuthentication(hostSpec, m_landingUri); Assert.AreEqual(expectedPortNumber, uri.Port); }
public ValenceAuthenticator CreateAuthenticator() { D2LAppContextFactory contextFactory = new D2LAppContextFactory(); ID2LAppContext appContext = contextFactory.Create(m_appId, m_appKey); HostSpec valenceHost = new HostSpec("https", m_lmsUrl, 443); ID2LUserContext userContext = appContext.CreateUserContext(m_userId, m_userKey, valenceHost); return(new ValenceAuthenticator(userContext)); }
public void AppContext_CreateUserContext_FromAuthCallbackUri_SaveProps_HostMatches() { const string expectedHost = "univ.edu"; var apiHost = new HostSpec( "https", expectedHost, 443 ); var userContext = m_appContext.CreateUserContext( m_authCallbackUri, apiHost ); var savedProps = userContext.SaveUserContextProperties(); Assert.AreEqual( expectedHost, savedProps.HostName ); }
/// <summary> /// Constructs a D2LUserContext with the parameters provided /// </summary> /// <param name="timestampProvider">The system timestamp provider</param> /// <param name="appId">The D2L app ID</param> /// <param name="appKey">The D2L app key</param> /// <param name="userId">The D2L user ID to be used</param> /// <param name="userKey">The D2L user key to be used</param> /// <param name="apiHost">The host information of the server to make API calls to</param> internal D2LUserContext(ITimestampProvider timestampProvider, string appId, string appKey, string userId, string userKey, HostSpec apiHost) { m_appId = appId; m_appKey = appKey; m_userId = userId; m_userKey = userKey; m_apiHost = apiHost; m_timestampProvider = timestampProvider; }
public void AppContext_CreateUserContext_FromAuthCallbackUri_SaveProps_PortMatches() { const int expectedPort = 2228; var apiHost = new HostSpec( "https", TestConstants.HOST_NAME, expectedPort ); var userContext = m_appContext.CreateUserContext( m_authCallbackUri, apiHost ); var savedProps = userContext.SaveUserContextProperties(); Assert.AreEqual( expectedPort, savedProps.Port ); }
/* * Creates a new ID2LUserContext object * * @return * an instance of a ID2LUserContext */ public static ID2LUserContext GetD2LUserContext() { D2LAppContextFactory factory = new D2LAppContextFactory(); ID2LAppContext appContext = factory.Create(Utility.GetAppIdValence(), Utility.GetAppKeyValence()); HostSpec hostInfo = new HostSpec(Utility.GetSchemaValence(), Utility.GetHostValence(), Utility.GetPortValence()); ID2LUserContext userContext = appContext.CreateUserContext(Utility.GetUserIdValence(), Utility.GetUserKeyValence(), hostInfo); return(userContext); }
public void SendRequest_AtUrlForAuthentication_ResponseReceived() { var hostSpec = new HostSpec(m_scheme, m_host, m_port); var landingUrl = new UriBuilder(m_scheme, m_host, m_port, GET_ORGANIZATION_INFO_ROUTE).Uri; var uri = m_appContext.CreateUrlForAuthentication(hostSpec, landingUrl); var request = CreateRequest(uri); Assert.DoesNotThrow(() => request.GetResponse()); }
public void UserContext_CreateAuthUri_SchemeMatches() { const string expectedScheme = "spdy"; var apiHost = new HostSpec( expectedScheme, TestConstants.HOST_NAME, TestConstants.PORT ); var userContext = m_appContext.CreateUserContext( TestConstants.USER_ID, TestConstants.USER_KEY, apiHost ); Uri authUri = userContext.CreateAuthenticatedUri( TestConstants.API_PATH, "GET" ); Assert.AreEqual( expectedScheme, authUri.Scheme ); }
public void AppContext_CreateUserContext_FromAuthCallbackUri_SaveProps_SchemeMatches() { const string expectedScheme = "foo"; var apiHost = new HostSpec(expectedScheme, TestConstants.HOST_NAME, TestConstants.PORT); var userContext = m_appContext.CreateUserContext(m_authCallbackUri, apiHost); var savedProps = userContext.SaveUserContextProperties(); Assert.AreEqual(expectedScheme, savedProps.Scheme); }
public void AppContext_CreateUserContext_FromAuthCallbackUri_SaveProps_HostMatches() { const string expectedHost = "univ.edu"; var apiHost = new HostSpec("https", expectedHost, 443); var userContext = m_appContext.CreateUserContext(m_authCallbackUri, apiHost); var savedProps = userContext.SaveUserContextProperties(); Assert.AreEqual(expectedHost, savedProps.HostName); }
public void AppContext_CreateUserContext_FromAuthCallbackUri_SaveProps_PortMatches() { const int expectedPort = 2228; var apiHost = new HostSpec("https", TestConstants.HOST_NAME, expectedPort); var userContext = m_appContext.CreateUserContext(m_authCallbackUri, apiHost); var savedProps = userContext.SaveUserContextProperties(); Assert.AreEqual(expectedPort, savedProps.Port); }
public void UserContext_CreateAuthUri_PortMatches() { const int expectedPort = 1905; var apiHost = new HostSpec("https", TestConstants.HOST_NAME, expectedPort); var userContext = m_appContext.CreateUserContext( TestConstants.USER_ID, TestConstants.USER_KEY, apiHost); Uri authUri = userContext.CreateAuthenticatedUri(TestConstants.API_PATH, "GET"); Assert.AreEqual(expectedPort, authUri.Port); }
public void UserContext_CreateAuthUri_HostNameMatches() { const string expectedHost = "myuniv.edu"; var apiHost = new HostSpec("https", expectedHost, TestConstants.PORT); var userContext = m_appContext.CreateUserContext( TestConstants.USER_ID, TestConstants.USER_KEY, apiHost); Uri authUri = userContext.CreateAuthenticatedUri(TestConstants.API_PATH, "GET"); Assert.AreEqual(expectedHost, authUri.Host); }
public void UserContext_CreateAuthUri_SchemeMatches() { const string expectedScheme = "spdy"; var apiHost = new HostSpec(expectedScheme, TestConstants.HOST_NAME, TestConstants.PORT); var userContext = m_appContext.CreateUserContext( TestConstants.USER_ID, TestConstants.USER_KEY, apiHost); Uri authUri = userContext.CreateAuthenticatedUri(TestConstants.API_PATH, "GET"); Assert.AreEqual(expectedScheme, authUri.Scheme); }
ID2LUserContext ID2LAppContext.CreateUserContext( Uri authenticationCallbackUri, HostSpec apiHost ) { var parsingResult = HttpUtility.ParseQueryString( authenticationCallbackUri.Query ); string userId = parsingResult[USER_ID_CALLBACK_PARAMETER]; string userKey = parsingResult[USER_KEY_CALLBACK_PARAMETER]; if( userId == null || userKey == null ) { return null; } return new D2LUserContext( m_appId, m_appKey, userId, userKey, apiHost ); }
public void AppContext_CreateUrlForAuth_RespectsURIEncodingInCallbackURL() { var hostSpec = new HostSpec( "https", TestConstants.HOST_NAME, 443 ); Uri uri = m_appContext.CreateUrlForAuthentication( hostSpec, new Uri(TestConstants.ESCAPED_CALLBACK) ); var regex = new Regex(@"x_target=([^&]*)"); var match = regex.Match( uri.AbsoluteUri ); Assert.IsTrue( match.Success ); string val = match.Groups[1].Value; Assert.AreEqual(Uri.EscapeDataString(TestConstants.ESCAPED_CALLBACK).ToLower(), val.ToLower(), "Full Uri: " + uri.AbsoluteUri); }
public void AppContext_CreateWebUrlForAuth_LandingUriHasSpecialChars_ReturnsUri_AndQueryParam_x_target_MatchesEncodedLandingUrl() { const string unencodedUrl = "http://univ.edu/d2l/api/resource?foo=bar"; string encodedUrl = HttpUtility.UrlEncode(unencodedUrl); var hostSpec = new HostSpec("https", TestConstants.HOST_NAME, TestConstants.PORT); Uri uri = m_appContext.CreateUrlForAuthentication(hostSpec, new Uri(unencodedUrl)); string parameter = GetUriQueryParameter(uri, "x_target"); Assert.AreEqual(encodedUrl, parameter); }
public void SendRequest_AtUrlForAuthentication_StatusCodeIs200() { var hostSpec = new HostSpec(m_scheme, m_host, m_port); var landingUrl = new UriBuilder(m_scheme, m_host, m_port, GET_ORGANIZATION_INFO_ROUTE).Uri; var uri = m_appContext.CreateUrlForAuthentication(hostSpec, landingUrl); var request = CreateRequest(uri); using (var response = request.GetResponse() as HttpWebResponse) { Assert.AreEqual(HttpStatusCode.OK, response.StatusCode); } }
public void AppContext_CreateUrlForAuth_RespectsURIEncodingInCallbackURL() { var hostSpec = new HostSpec("https", TestConstants.HOST_NAME, 443); Uri uri = m_appContext.CreateUrlForAuthentication(hostSpec, new Uri(TestConstants.ESCAPED_CALLBACK)); var regex = new Regex(@"x_target=([^&]*)"); var match = regex.Match(uri.AbsoluteUri); Assert.IsTrue(match.Success); string val = match.Groups[1].Value; Assert.AreEqual(Uri.EscapeDataString(TestConstants.ESCAPED_CALLBACK).ToLower(), val.ToLower(), "Full Uri: " + uri.AbsoluteUri); }
ID2LUserContext ID2LAppContext.CreateUserContext( Uri authenticationCallbackUri, HostSpec apiHost) { var parsingResult = HttpUtility.ParseQueryString(authenticationCallbackUri.Query); string userId = parsingResult[USER_ID_CALLBACK_PARAMETER]; string userKey = parsingResult[USER_KEY_CALLBACK_PARAMETER]; if (userId == null || userKey == null) { return(null); } return(new D2LUserContext(m_timestampProvider, m_appId, m_appKey, userId, userKey, apiHost)); }
public Context(Configuration config) { var appFactory = new D2LAppContextFactory(); ValenceAppContext = appFactory.Create(config["appId"], config["appKey"]); ValenceHost = new HostSpec("https", config["lmsUrl"], 443); Client = new RestClient("https://" + config["lmsUrl"]); if (File.Exists(".bs-auth")) { ValenceUserContext = ValenceAppContext.CreateUserContext(new Uri(File.ReadAllText(".bs-auth")), ValenceHost); } else { ValenceUserContext = null; } }
private Uri GenerateAuthRedirect(Uri returnUri, Uri requestUri) { if ((requestUri == null) || (returnUri == null)) { throw new ArgumentNullException(); } var factory = new D2LAppContextFactory(); var appContext = factory.Create(m_defaultAppId, m_defaultAppKey); var resultUri = new UriBuilder(requestUri.Scheme, requestUri.Host, requestUri.Port, requestUri.AbsolutePath).Uri; var host = new HostSpec(returnUri.Scheme, returnUri.Host, returnUri.Port); var redirectUri = appContext.CreateUrlForAuthentication(host, resultUri); return(redirectUri); }
ID2LUserContext ID2LAppContext.CreateUserContext( string userId, string userKey, HostSpec apiHost ) { return new D2LUserContext( m_appId, m_appKey, userId, userKey, apiHost ); }
public void SetUpTestObjects() { m_testHostSpec = new HostSpec( "https", TestConstants.HOST_NAME, TestConstants.PORT ); m_landingUri = new Uri( TestConstants.API_URL ); }
public void AppContext_CreateWebUrlForAuth_LandingUriHasSpecialChars_ReturnsUri_AndQueryParam_x_target_MatchesEncodedLandingUrl() { const string unencodedUrl = "http://univ.edu/d2l/api/resource?foo=bar"; string encodedUrl = HttpUtility.UrlEncode( unencodedUrl ); var hostSpec = new HostSpec( "https", TestConstants.HOST_NAME, TestConstants.PORT ); Uri uri = m_appContext.CreateUrlForAuthentication( hostSpec, new Uri( unencodedUrl ) ); string parameter = GetUriQueryParameter( uri, "x_target" ); Assert.AreEqual( encodedUrl, parameter ); }
/// <summary> /// Constructs a D2LUserContext with the parameters provided /// </summary> /// <param name="appId">The D2L app ID</param> /// <param name="appKey">The D2L app key</param> /// <param name="userId">The D2L user ID to be used</param> /// <param name="userKey">The D2L user key to be used</param> /// <param name="apiHost">The host information of the server to make API calls to</param> internal D2LUserContext( string appId, string appKey, string userId, string userKey, HostSpec apiHost ) { m_appId = appId; m_appKey = appKey; m_userId = userId; m_userKey = userKey; m_apiHost = apiHost; m_timestampProvider = ObjectFactory.GetInstance<ITimestampProvider>(); }
ID2LUserContext ID2LAppContext.CreateAnonymousUserContext( HostSpec apiHost ) { return new D2LUserContext( m_appId, m_appKey, null, null, apiHost ); }
ID2LUserContext ID2LAppContext.CreateUserContext( UserContextProperties savedProps ) { var apiHost = new HostSpec( savedProps.Scheme, savedProps.HostName, savedProps.Port ); return new D2LUserContext( m_appId, m_appKey, savedProps.UserId, savedProps.UserKey, apiHost ); }
public void AppContext_CreateUserContext_FromAuthCallbackUri_SaveProps_SchemeMatches() { const string expectedScheme = "foo"; var apiHost = new HostSpec( expectedScheme, TestConstants.HOST_NAME, TestConstants.PORT ); var userContext = m_appContext.CreateUserContext( m_authCallbackUri, apiHost ); var savedProps = userContext.SaveUserContextProperties(); Assert.AreEqual( expectedScheme, savedProps.Scheme ); }
public void UserContext_CreateAuthUri_HostNameMatches() { const string expectedHost = "myuniv.edu"; var apiHost = new HostSpec( "https", expectedHost, TestConstants.PORT ); var userContext = m_appContext.CreateUserContext( TestConstants.USER_ID, TestConstants.USER_KEY, apiHost ); Uri authUri = userContext.CreateAuthenticatedUri( TestConstants.API_PATH, "GET" ); Assert.AreEqual( expectedHost, authUri.Host ); }
public void SendRequest_WhenBadHostSpec_UnhandledException() { HostSpec badApiHost = new HostSpec( ChangeScheme( ConfigHelper.Scheme ), ConfigHelper.Host, ConfigHelper.Port ); ID2LUserContext badAnonContext = ContextProvider.AnonUserContext( badApiHost ); HttpWebRequest request = RequestProvider.PrepareApiRequest( badAnonContext, RouteProvider.VersionsRoute ); Assert.Throws<WebException>( () => { using( HttpWebResponse response = request.GetResponse() as HttpWebResponse ) { } } ); }
public void SetUpTestObjects() { m_authCallbackUri = TestUtils.CreateTestAuthenticationCallbackUri( TestConstants.USER_ID, TestConstants.USER_KEY ); m_apiHost = new HostSpec( "https", TestConstants.HOST_NAME, TestConstants.PORT ); }
public void UserContext_CreateAuthUri_PortMatches() { const int expectedPort = 1905; var apiHost = new HostSpec( "https", TestConstants.HOST_NAME, expectedPort ); var userContext = m_appContext.CreateUserContext( TestConstants.USER_ID, TestConstants.USER_KEY, apiHost ); Uri authUri = userContext.CreateAuthenticatedUri( TestConstants.API_PATH, "GET" ); Assert.AreEqual( expectedPort, authUri.Port ); }