//[ChildActionOnly]
        public ActionResult IdentityProvidersWithClientSideCode()
        {
            WSFederationAuthenticationModule fam = FederatedAuthentication.WSFederationAuthenticationModule;
            HrdRequest request = new HrdRequest(fam.Issuer, fam.Realm, context: Request.Url.AbsoluteUri);

            return(PartialView("_IdentityProvidersWithClientSideCode", request));
        }
        //[ChildActionOnly]
        public ActionResult IdentityProvidersWithServerSideCode()
        {
            WSFederationAuthenticationModule fam = FederatedAuthentication.WSFederationAuthenticationModule;
            HrdRequest request = new HrdRequest(fam.Issuer, fam.Realm, context: Request.Url.AbsoluteUri);

            IEnumerable <HrdIdentityProvider> hrdIdentityProviders = hrdClient.GetHrdResponse(request);

            return(PartialView("_IdentityProvidersWithServerSideCode", hrdIdentityProviders));
        }
        public virtual IEnumerable<HrdIdentityProvider> GetHrdResponse(HrdRequest request)
        {
            var client = new WebClient {Encoding = Encoding.UTF8};

            var response = client.DownloadString(request.GetUrlWithQueryString());

            var serializer = new JavaScriptSerializer();
            return serializer.Deserialize<List<HrdIdentityProvider>>(response);
        }
        public PartialViewResult IdentityProvidersWithClientSideCode()
        {
            WSFederationAuthenticationModule fam = FederatedAuthentication.WSFederationAuthenticationModule;
            // The code below doesn't work on the emulator because the port number in Request.Url is incorrect
            // HrdRequest request = new HrdRequest(fam.Issuer, fam.Realm, context: Request.Url.AbsoluteUri);
            // This is a hack workaround because the correct URI is actually in the Realm:
            HrdRequest request = new HrdRequest(fam.Issuer, fam.Realm, context: fam.Realm);

            return(PartialView("_IdentityProvidersWithClientSideCode", request));
        }
Example #5
0
        public List <HrdIdentityProvider> GetProviders(string contextUri)
        {
            WSFederationAuthenticationModule fam = FederatedAuthentication.WSFederationAuthenticationModule;
            HrdRequest request = new HrdRequest(fam.Issuer, fam.Realm, context: contextUri);

            WebClient client = new WebClient();

            client.Encoding = System.Text.Encoding.UTF8;

            string response = client.DownloadString(request.GetUrlWithQueryString());

            JavaScriptSerializer serializer = new JavaScriptSerializer();
            var providers = serializer.Deserialize <List <HrdIdentityProvider> >(response);

            foreach (var item in providers)
            {
                if (item.Name.StartsWith("Windows Live"))
                {
                    item.Name = "Windows Live";
                }
            }

            return(providers);
        }
        public ActionResult LogOn(LogOnModel model, string returnUrl)
        {
            if (ModelState.IsValid)
            {
                
                
                if (Membership.ValidateUser(model.UserName, model.Password))
                {

                    var user = Membership.GetUser(model.UserName);

                    //Find user if the user is allready registered
                    var identity = _userManager.GetUser(user.ProviderUserKey.ToString());
                        //UsersStorage.UserIdentities.Find(u => u.Id == user.ProviderUserKey.ToString());


                    if (identity != null)
                    {
                        FormsAuthentication.SetAuthCookie(model.UserName, model.RememberMe);
                        _userManager.SetCurrentUser(identity);

                        if (Url.IsLocalUrl(returnUrl) && returnUrl.Length > 1 && returnUrl.StartsWith("/")
                            && !returnUrl.StartsWith("//") && !returnUrl.StartsWith("/\\"))
                        {
                            return Redirect(returnUrl);
                        }
                        else
                        {
                            return RedirectToAction("Index", "Home");
                        }
                    }
                    else
                    {
                        ModelState.AddModelError("", "User is not allowed to login.");
                    }
                    
                }
                else
                {
                    ModelState.AddModelError("", "The user name or password provided is incorrect.");
                }
            }

            //get Providers
            var hrdClient = new HrdClient();
            var fam = FederatedAuthentication.WSFederationAuthenticationModule;
            var request = new HrdRequest(fam.Issuer, fam.Realm, context: Request.QueryString["ReturnUrl"]);
            var hrdIdentityProviders = hrdClient.GetHrdResponse(request);
            model.Providers = hrdIdentityProviders
                                    .Select(hrd => new IdentityProviderModel()
                                                       {
                                                           Name = hrd.Name,
                                                           LoginUrl = hrd.LoginUrl,
                                                           LogoutUrl = hrd.LogoutUrl
                                                       });

            // If we got this far, something failed, redisplay form
            return View(model);
        }
        //
        // GET: /Account/LogOn

        public ActionResult LogOn()
        {
            var hrdClient = new HrdClient();


            //get Providers
            var fam = FederatedAuthentication.WSFederationAuthenticationModule;
            var request = new HrdRequest(fam.Issuer, fam.Realm, context: Request.QueryString["ReturnUrl"]);
            var hrdIdentityProviders = hrdClient.GetHrdResponse(request);

            var logon = new LogOnModel()
                            {
                                Providers = hrdIdentityProviders
                                    .Select(hrd => new IdentityProviderModel()
                                                       {
                                                           Name = hrd.Name,
                                                           LoginUrl = hrd.LoginUrl,
                                                           LogoutUrl = hrd.LogoutUrl
                                                       })
                            };

            return View(logon);
        }