public async Task <IHttpActionResult> ObtainLocalAccessToken(string provider, string externalAccessToken)
        {
            if (string.IsNullOrWhiteSpace(provider) || string.IsNullOrWhiteSpace(externalAccessToken))
            {
                return(BadRequest("Provider or external access token is not sent"));
            }

            var verifiedAccessToken = await VerifyExternalAccessToken(provider, externalAccessToken);

            if (verifiedAccessToken == null)
            {
                return(BadRequest("Invalid Provider or External Access Token"));
            }

            EXTERNALACCOUNT user = db.EXTERNALACCOUNTs.FirstOrDefault(x => x.PROVIDERKEY == verifiedAccessToken.user_id & x.LOGINPROVIDER == provider);

            bool hasRegistered = user != null;

            if (!hasRegistered)
            {
                return(BadRequest("External user is not registered"));
            }
            ACCOUNT temp = db.ACCOUNTs.FirstOrDefault(x => x.ID == user.IDUSER);
            //generate access token response
            object dbUser;

            //Create token
            var token = CreateTokenLogin(temp, out dbUser);

            var response = Request.CreateResponse(new { dbUser, token });

            //var accessTokenResponse = GenerateLocalAccessTokenResponse(temp.NAME);

            return(Ok(response));
        }
        public async Task <HttpResponseMessage> RegisterExternal(RegisterExternalBindingModel model)
        {
            HttpResponseMessage response;
            string  name     = "";
            string  birthday = "";
            string  gender   = "";
            string  email    = "";
            string  picture  = "";
            dynamic myInfo   = "";
            var     token    = "";

            if (!ModelState.IsValid)
            {
                response = Request.CreateErrorResponse(HttpStatusCode.BadRequest, ModelState);
            }
            var verifiedAccessToken = await VerifyExternalAccessToken(model.Provider, model.ExternalAccessToken);

            if (verifiedAccessToken == null)
            {
                response = Request.CreateErrorResponse(HttpStatusCode.BadRequest, "Invalid Provider or External Access Token");
            }
            EXTERNALACCOUNT user = db.EXTERNALACCOUNTs.FirstOrDefault
                                       (x => x.PROVIDERKEY == verifiedAccessToken.user_id & x.LOGINPROVIDER == model.Provider);
            bool   hasRegistered = user != null;
            object dbUser;

            if (hasRegistered)
            {
                ACCOUNT account1 = db.ACCOUNTs.FirstOrDefault(x => x.ID == user.IDUSER);
                token    = CreateTokenLogin(account1, out dbUser);
                response = Request.CreateResponse(new { dbUser, token });
                return(response);
            }
            if (model.Provider == "Facebook")
            {
                var fb = new FacebookClient(model.ExternalAccessToken);
                myInfo = fb.Get("/me?fields=name,id,gender,birthday,email,picture");
                if (myInfo["email"] != "")
                {
                    email = myInfo["email"];
                }
                if ((myInfo["name"] != ""))
                {
                    name = myInfo["name"];
                }
                try
                { picture = picture = String.Format("https://graph.facebook.com/{0}/picture?width=200&height=200", verifiedAccessToken.user_id); }
                catch (Exception ex)
                { }
            }

            if (model.Provider == "Google")
            {
                HttpClient client     = new HttpClient();
                var        urlProfile = "https://www.googleapis.com/oauth2/v1/userinfo?access_token=" + model.ExternalAccessToken;
                client.CancelPendingRequests();
                HttpResponseMessage output = await client.GetAsync(urlProfile);

                if (output.IsSuccessStatusCode)
                {
                    string outputData = await output.Content.ReadAsStringAsync();

                    GoogleUserOutputData serStatus = JsonConvert.DeserializeObject <GoogleUserOutputData>(outputData);

                    if (serStatus != null)
                    {
                        if (!string.IsNullOrEmpty(serStatus.email))
                        {
                            email = serStatus.email;
                        }
                        if (!string.IsNullOrEmpty(serStatus.name))
                        {
                            name = serStatus.name;
                        }
                        if (!string.IsNullOrEmpty(serStatus.picture))
                        {
                            picture = serStatus.picture;
                        }
                    }
                }
            }

            EXTERNALACCOUNT external = new EXTERNALACCOUNT();
            ACCOUNT         usermain = new ACCOUNT();
            ACCOUNT         acc      = new ACCOUNT();

            acc = db.ACCOUNTs.FirstOrDefault(x => x.EMAIL == email);
            if (acc != null)
            {
                external.PROVIDERKEY   = verifiedAccessToken.user_id;
                external.IDUSER        = acc.ID;
                external.LOGINPROVIDER = model.Provider;
                db.EXTERNALACCOUNTs.Add(external);
                db.SaveChanges();
            }
            else
            {
                external.PROVIDERKEY   = verifiedAccessToken.user_id;
                external.IDUSER        = db.ACCOUNTs.Count() + 1;
                external.LOGINPROVIDER = model.Provider;
                if (!string.IsNullOrEmpty(email))
                {
                    usermain.EMAIL = email;
                }
                if (!string.IsNullOrEmpty(name))
                {
                    usermain.NAME = name;
                }
                usermain.ID = external.IDUSER;
                ACCOUNT_ROLE role = new ACCOUNT_ROLE();
                role.IDUSER = external.IDUSER;
                role.IDROLE = 2;
                if (!string.IsNullOrEmpty(picture))
                {
                    Account account = new Account("dqabuxewl", "198449299438919", "SRASj3YoFcfLsetrHFNNwGVF4qQ");
                    CloudinaryDotNet.Cloudinary cloudinary = new CloudinaryDotNet.Cloudinary(account);

                    var uploadParams = new ImageUploadParams()
                    {
                        File = new FileDescription(picture)
                    };

                    var uploadResult = cloudinary.Upload(uploadParams);
                    usermain.IMAGEACC = uploadResult.Uri.OriginalString;
                }
                else
                {
                    usermain.IMAGEACC = imgnormal;
                }
                DbContextTransaction dt = db.Database.BeginTransaction();
                try
                {
                    db.EXTERNALACCOUNTs.Add(external);
                    db.SaveChanges();
                    db.ACCOUNTs.Add(usermain);
                    db.SaveChanges();
                    db.ACCOUNT_ROLE.Add(role);
                    db.SaveChanges();
                    dt.Commit();
                }
                catch (Exception ex)
                {
                    dt.Rollback();
                    return(Request.CreateErrorResponse(HttpStatusCode.BadRequest, "Error"));
                }
            }

            //Create token
            usermain = new ACCOUNT();
            usermain = db.ACCOUNTs.FirstOrDefault(x => x.EMAIL == email);
            token    = CreateTokenLogin(usermain, out dbUser);
            response = Request.CreateResponse(new { dbUser, token });
            return(response);
        }