public TokenData Get(IpData data)
        {
            // Try to validate token
            var service = new VkClient();
            service.AuthenticateWith(data.Token);

            dynamic result;

            try
            {
                result = service.Get("users.get", new
                {
                    fields = "screen_name"
                });
            }
            catch (Exception e)
            {
                throw new BadGatewayException(e);
            }

            if (result.error != null)
            {
                dynamic message = result.error.error_msg ?? string.Empty;
                throw new BadRequestException(message.ToString());
            }

            try
            {
                dynamic user = result.response[0];
                return new TokenData
                {
                    IdentityProvider = ProviderType.Vk,
                    Name = string.Format("{0} {1}", user.first_name, user.last_name),
                    UserIdentifier = user.uid.ToString(),
                    Token = data.Token,
                    TokenSecret = data.TokenSecret
                };
            }
            catch (Exception e)
            {
                string message = string.Format("Unable to receive VK profile: {0}", e);
                throw new InternalServerErrorException(message);
            }
        }
        public TokenData Get(IpData data)
        {
            // Pass your credentials to the service
            string consumerKey = _settings.TwitterConsumerKey;
            string consumerSecret = _settings.TwitterConsumerSecret;

            // Try to validate token
            var service = new TwitterService(consumerKey, consumerSecret);
            service.AuthenticateWith(data.Token, data.TokenSecret);

            TwitterUser user = service.GetUserProfile(new GetUserProfileOptions());
            if (user != null)
            {
                return new TokenData
                {
                    IdentityProvider = ProviderType.Twitter,
                    Name = user.Name,
                    UserIdentifier = string.Format(TwitterAccountPage, user.Id),
                    Token = data.Token,
                    TokenSecret = data.TokenSecret
                };
            }

            // Check response status code
            switch (service.Response.StatusCode)
            {
                case HttpStatusCode.Unauthorized:
                case HttpStatusCode.BadRequest:
                    throw new BadRequestException();

                case (HttpStatusCode)429:
                    throw new TooManyRequestsException();
            }

            // Twitter internal errors
            if ((int)service.Response.StatusCode >= 500)
            {
                throw new BadGatewayException(service.Response.Response);
            }

            string message = string.Format("Unable to receive twitter profile. Status code {0}: {1}", service.Response.StatusCode, service.Response.InnerException);
            throw new InternalServerErrorException(message);
        }
        public TokenData Get(IpData data)
        {
            JObject claims = JObject.Parse(data.Token);

            var provider = (string)claims[CommonClaims.AcsIdentityProvider];
            var identifier = (string)claims[CommonClaims.NameIdentifier];
            var name = (string)claims[CommonClaims.Name];
            var email = (string)claims[CommonClaims.Email];

            return new TokenData
            {
                Email = email,
                Name = name,
                IdentityProvider = IdentityTypeParser.ParseProviderType(provider),
                UserIdentifier = identifier,
                Token = GetToken(claims),
                TokenSecret = GetTokenSecret(claims)
            };
        }
        public TokenData Get(IpData data)
        {
            var client = new FacebookClient(data.Token);
            var result = new TokenData();

            dynamic userData;

            try
            {
                userData = client.Get("me");
            }
            catch (FacebookOAuthException e)
            {
                throw new BadRequestException(e);
            }
            catch (WebExceptionWrapper e)
            {
                throw new BadGatewayException(e);
            }

            result.IdentityProvider = ProviderType.Facebook;
            result.Name = userData.name;
            result.UserIdentifier = userData.id;
            result.Token = data.Token;
            result.TokenSecret = data.TokenSecret;

            // If email was not requested
            try
            {
                result.Email = userData.email;
            }
            catch
            {
                result.Email = null;
            }

            return result;
        }
        public TokenData Get(IpData data)
        {
            // Try to validate token
            _service.AuthenticateWith(data.Token);

            dynamic user;

            try
            {
                user = _service.Get("users.getCurrentUser");
            }
            catch (Exception e)
            {
                throw new BadGatewayException(e);
            }

            if (user.error_msg != null)
            {
                throw new BadRequestException(user.error_msg.ToString());
            }

            try
            {
                return new TokenData
                {
                    IdentityProvider = ProviderType.Odnoklassniki,
                    Name = user.name.ToString(),
                    UserIdentifier = user.uid.ToString(),
                    Token = data.Token,
                    TokenSecret = data.TokenSecret
                };
            }
            catch (Exception e)
            {
                string message = string.Format("Unable to receive Odnoklassniki profile: {0}", e);
                throw new InternalServerErrorException(message);
            }
        }
        public TokenData Get(IpData data)
        {
            // Validate security token
            var validator = new SimpleWebTokenValidator
            {
                SharedKeyBase64 = "ZY+lm6+MQeWVSeMdV+apXAaaIGNTZT7ztfBskldOMn0="
            };

            Dictionary<string, string> claims;

            try
            {
                claims = validator.ValidateToken(data.Token).Claims;
            }
            catch (HttpException e)
            {
                throw new BadRequestException(e);
            }
            catch (InvalidSecurityTokenException e)
            {
                throw new BadRequestException(e);
            }

            // Get values
            string identityProvider = claims.Single(p => p.Key == CommonClaims.AcsIdentityProvider).Value;

            return new TokenData
            {
                UserIdentifier = claims.Single(p => p.Key == CommonClaims.NameIdentifier).Value,
                Name = claims.SingleOrDefault(p => p.Key == CommonClaims.Name).Value,
                Email = claims.SingleOrDefault(p => p.Key == CommonClaims.Email).Value,
                IdentityProvider = IdentityTypeParser.ParseProviderType(identityProvider),
                Token = GetToken(claims),
                TokenSecret = GetTokenSecret(claims)
            };
        }