Google Cloud Endpoints Authentication (Google App Engine, Python) - getting user profile from Google+

queue.yaml

total_storage_limit: 200M

queue:
- name: registration
  rate: 20/s
  bucket_size: 40
  max_concurrent_requests: 10
  retry_parameters:
    task_age_limit: 10h
    min_backoff_seconds: 10
    max_backoff_seconds: 300
    max_doublings: 1

tasks.py

# -*- coding: utf-8 -*-
import logging
import webapp2

# http://localhost:8001/_ah/api/discovery/v1/apis/
# https://cloud.google.com/appengine/docs/python/endpoints/create_api#defining_the_api_endpointsapi

from lib.googleapiclient.discovery import build
from private import SERVICE_ACCOUNT


class RegisterUser(webapp2.RequestHandler):

    def _reject(self, reason=None):
        # TODO: notify user registration failed
        logging.error(reason)

    def post(self):
        post_dict = dict(self.request.POST)
        token = post_dict.get('token')

        service = build('oauth2', 'v2')
        response = service.tokeninfo(
            access_token=token, key=SERVICE_ACCOUNT_ID).execute()

        if response:
            info = dict(response.items())
            email = info.get('email')
            user_id = info.get('user_id')

            logging.info('register user task %s', info)

            service = build('plus', 'v1')
            response = service.people().get(userId=user_id, key=SERVICE_ACCOUNT_ID).execute()

            if not response:
                return self._reject("Bad things happened...")
                
            user_info = dict(self.response.POST)


APPLICATION = webapp2.WSGIApplication([
    ('/tasks/register', RegisterUser)
], debug=True)

users.py

# -*- coding: utf-8 -*-
import endpoints
import logging
import os

from api import ccms

from models.core.base import BaseModel
from google.appengine.api import taskqueue
from google.appengine.ext import ndb

from protorpc import remote
from endpoints_proto_datastore.ndb import EndpointsModel
from endpoints_proto_datastore.ndb import EndpointsAliasProperty


class User(EndpointsModel):

    # _message_fields_schema = ('id', 'name', 'created')

    created = ndb.DateTimeProperty(auto_now_add=True)
    email = ndb.StringProperty(required=True)
    first_name = ndb.StringProperty()
    last_name = ndb.StringProperty()
    role = ndb.StringProperty()
    updated = ndb.DateTimeProperty(auto_now=True)

    @EndpointsAliasProperty
    def name(self):
        if self.first_name and self.last_name:
            return self.first_name + " " + self.last_name


@ccms.api_class(resource_name="user")
class UsersApi(remote.Service):

    @User.method(http_method="GET",
                 user_required=True,
                 request_fields=('id',),
                 response_fields=('id', 'name'),
                 name="get",
                 path="users/{id}")
    def UserGet(self, instance):
        if not instance.from_datastore:
            raise endpoints.NotFoundException("User not found.")
        return instance

    @User.method(http_method="POST",
                 auth_level=endpoints.AUTH_LEVEL.REQUIRED,
                 allowed_client_ids=[
                     endpoints.API_EXPLORER_CLIENT_ID
                 ],
                 scopes=[
                     'https://www.googleapis.com/auth/userinfo.email',
                     'https://www.googleapis.com/auth/userinfo.profile',
                     'https://www.googleapis.com/auth/plus.me',
                 ],
                 user_required=True,
                 request_fields=('email',),
                 response_fields=('id',),
                 name="register",
                 path="users")
    def UserRegister(self, instance):
        user_exists = User.query(User.email == instance.email).count() != 0
        if user_exists:
            raise endpoints.ConflictException(
                "User with this email already exists.")

        token = os.getenv('HTTP_AUTHORIZATION').split(" ")[1]
        if not token:
            raise endpoints.InternalServerErrorException(
                "Server Error: Authentication could not complete.")

        taskqueue.add(url="/tasks/register",
                      queue_name='registration',
                      params={{'token': token})

        instance.put()
        return instance

    @User.query_method(http_method="GET",
                       user_required=True,
                       query_fields=('limit', 'order', 'pageToken'),
                       name="list",
                       path="users")
    def UserList(self, query):
        return query