public bool CheckIfFacebookAuthResponseIsValid(FacebookAuthResponse authResponse)
 {
     return authResponse.IsValid
            &&
            facebookProfileProxy.IsAccessTokenValid(
                authResponse.AccessToken, authResponse.UserID).Result;
 }
        public void IsValidModelFailureTest()
        {
            FacebookAuthResponse authResponse = new FacebookAuthResponse
                {
                    AccessToken = string.Empty,
                    ExpiresIn = -1,
                    SignedRequest = string.Empty,
                    UserID = -1
                };

            Assert.IsFalse(authResponse.IsValid);
        }
        public ActionResult Authenticate(FacebookAuthResponse facebookAuthResponse, string returnUrl)
        {
            if (loginService.CheckIfFacebookAuthResponseIsValid(facebookAuthResponse))
            {
                UserProfile profile = userProfileService.GetProfileByUserId(facebookAuthResponse.UserID);
                if (!IsUserRegistered(profile))
                {
                    profile = CreateNewUserProfile(facebookAuthResponse);
                }

                InstallVerseEngineeringAuthCookie(facebookAuthResponse, profile.Name);
                return new RedirectResult(returnUrl);
            }

            return View("Index");
        }
 private UserProfile CreateNewUserProfile(FacebookAuthResponse facebookAuthResponse)
 {
     return facebookProfileProxy.GetFacebookPublicProfileAsync(facebookAuthResponse.UserID).ContinueWith(
         task =>
             {
                 var profile = task.Result;
                 return userProfileService.CreateUserProfile<UnderWaterAuthorityType>(
                     profile.Id,
                     profile.FirstName,
                     profile.LastName,
                     profile.MiddleName,
                     profile.Name,
                     profile.Gender,
                     profile.Locale);
             },
         TaskContinuationOptions.ExecuteSynchronously).Result;
 }
        public void CheckIfFacebookAuthResponseIsValidsSuccessfulTest()
        {
            const string AccessToken = "12345678";
            const long UserId = 123456789;
            FacebookAuthResponse authResponse = new FacebookAuthResponse
                {
                    AccessToken = AccessToken,
                    ExpiresIn = (long)DateTime.Now.AddDays(30).UnixTicks(),
                    SignedRequest = "Sample Signed Request",
                    UserID = UserId
                };

            var mocked = new Mock<IFacebookProfileProxy>();

            mocked.Setup((proxy) => proxy.IsAccessTokenValid(AccessToken, UserId)).Returns(
                Task.Factory.StartNew(() => true));

            ILoginService loginService = new LoginService(mocked.Object);

            Assert.IsTrue(loginService.CheckIfFacebookAuthResponseIsValid(authResponse));
            mocked.VerifyAll();
        }
        private void InstallVerseEngineeringAuthCookie(FacebookAuthResponse facebookAuthResponse, string userName)
        {
            VerseEngineeringUserToken token = new VerseEngineeringUserToken
                {
                    UserId = facebookAuthResponse.UserID,
                    Expires = facebookAuthResponse.ExpiresIn,
                    FacebookAccessToken = facebookAuthResponse.AccessToken,
                    Name = userName
                };

            string encrypted = cryptoService.Encrypt(token);
            HttpCookie cookie = new HttpCookie(AuthCookieName, encrypted)
                { Expires = DateTime.UtcNow + expirationPeriod };
            ControllerContext.HttpContext.Response.Cookies.Add(cookie);
        }