xref: /aosp_15_r20/development/samples/SampleSyncAdapter/samplesyncadapter_server/web_services.py (revision 90c8c64db3049935a07c6143d7fd006e26f8ecca)

#!/usr/bin/python2.5

# Copyright (C) 2010 The Android Open Source Project
#
# Licensed under the Apache License, Version 2.0 (the "License"); you may not
# use this file except in compliance with the License. You may obtain a copy of
# the License at
#
# http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
# WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
# License for the specific language governing permissions and limitations under
# the License.

"""
Handlers for Sample SyncAdapter services.

Contains several RequestHandler subclasses used to handle post operations.
This script is designed to be run directly as a WSGI application.

"""

import cgi
import logging
import time as _time
from datetime import datetime
from django.utils import simplejson
from google.appengine.api import users
from google.appengine.ext import db
from google.appengine.ext import webapp
from model import datastore
import wsgiref.handlers


class BaseWebServiceHandler(webapp.RequestHandler):
    """
    Base class for our web services. We put some common helper
    functions here.
    """

    """
    Since we're only simulating a single user account, declare our
    hard-coded credentials here, so that they're easy to see/find.
    We actually accept any and all usernames that start with this
    hard-coded values. So if ACCT_USER_NAME is 'user', then we'll
    accept 'user', 'user75', 'userbuddy', etc, all as legal account
    usernames.
    """
    ACCT_USER_NAME  = 'user'
    ACCT_PASSWORD   = 'test'
    ACCT_AUTH_TOKEN = 'xyzzy'

    DATE_TIME_FORMAT = '%Y/%m/%d %H:%M'

    """
    Process a request to authenticate a client.  We assume that the username
    and password will be included in the request. If successful, we'll return
    an authtoken as the only content.  If auth fails, we'll send an "invalid
    credentials" error.
    We return a boolean indicating whether we were successful (true) or not (false).
    In the event that this call fails, we will setup the response, so callers just
    need to RETURN in the error case.
    """
    def authenticate(self):
        self.username = self.request.get('username')
        self.password = self.request.get('password')

        logging.info('Authenticatng username: ' + self.username)

        if ((self.username != None) and
                (self.username.startswith(BaseWebServiceHandler.ACCT_USER_NAME)) and
                (self.password == BaseWebServiceHandler.ACCT_PASSWORD)):
            # Authentication was successful - return our hard-coded
            # auth-token as the only response.
            self.response.set_status(200, 'OK')
            self.response.out.write(BaseWebServiceHandler.ACCT_AUTH_TOKEN)
            return True
        else:
            # Authentication failed. Return the standard HTTP auth failure
            # response to let the client know.
            self.response.set_status(401, 'Invalid Credentials')
            return False

    """
    Validate the credentials of the client for a web service request.
    The request should include username/password parameters that correspond
    to our hard-coded single account values.
    We return a boolean indicating whether we were successful (true) or not (false).
    In the event that this call fails, we will setup the response, so callers just
    need to RETURN in the error case.
    """
    def validate(self):
        self.username = self.request.get('username')
        self.authtoken = self.request.get('authtoken')

        logging.info('Validating username: ' + self.username)

        if ((self.username != None) and
                (self.username.startswith(BaseWebServiceHandler.ACCT_USER_NAME)) and
                (self.authtoken == BaseWebServiceHandler.ACCT_AUTH_TOKEN)):
            return True
        else:
            self.response.set_status(401, 'Invalid Credentials')
            return False


class Authenticate(BaseWebServiceHandler):
    """
    Handles requests for login and authentication.

    UpdateHandler only accepts post events. It expects each
    request to include username and password fields. It returns authtoken
    after successful authentication and "invalid credentials" error otherwise.
    """

    def post(self):
        self.authenticate()

    def get(self):
        """Used for debugging in a browser..."""
        self.post()


class SyncContacts(BaseWebServiceHandler):
    """Handles requests for fetching user's contacts.

    UpdateHandler only accepts post events. It expects each
    request to include username and authtoken. If the authtoken is valid
    it returns user's contact info in JSON format.
    """

    def get(self):
        """Used for debugging in a browser..."""
        self.post()

    def post(self):
        logging.info('*** Starting contact sync ***')
        if (not self.validate()):
            return

        updated_contacts = []

        # Process any client-side changes sent up in the request.
        # Any new contacts that were added are included in the
        # updated_contacts list, so that we return them to the
        # client. That way, the client can see the serverId of
        # the newly added contact.
        client_buffer = self.request.get('contacts')
        if ((client_buffer != None) and (client_buffer != '')):
            self.process_client_changes(client_buffer, updated_contacts)

        # Add any contacts that have been updated on the server-side
        # since the last sync by this client.
        client_state = self.request.get('syncstate')
        self.get_updated_contacts(client_state, updated_contacts)

        logging.info('Returning ' + str(len(updated_contacts)) + ' contact records')

        # Return the list of updated contacts to the client
        self.response.set_status(200)
        self.response.out.write(toJSON(updated_contacts))

    def get_updated_contacts(self, client_state, updated_contacts):
        logging.info('* Processing server changes')
        timestamp = None

        base_url = self.request.host_url

        # The client sends the last high-water-mark that they successfully
        # sync'd to in the syncstate parameter.  It's opaque to them, but
        # its actually a seconds-in-unix-epoch timestamp that we use
        # as a baseline.
        if client_state:
            logging.info('Client sync state: ' + client_state)
            timestamp = datetime.utcfromtimestamp(float(client_state))

        # Keep track of the update/delete counts, so we can log it
        # below.  Makes debugging easier...
        update_count = 0
        delete_count = 0

        contacts = datastore.Contact.all()
        if contacts:
            # Find the high-water mark for the most recently updated friend.
            # We'll return this as the syncstate (x) value for all the friends
            # we return from this function.
            high_water_date = datetime.min
            for contact in contacts:
                if (contact.updated > high_water_date):
                    high_water_date = contact.updated
            high_water_mark = str(long(_time.mktime(high_water_date.utctimetuple())) + 1)
            logging.info('New sync state: ' + high_water_mark)

            # Now build the updated_contacts containing all the friends that have been
            # changed since the last sync
            for contact in contacts:
                # If our list of contacts we're returning already contains this
                # contact (for example, it's a contact just uploaded from the client)
                # then don't bother processing it any further...
                if (self.list_contains_contact(updated_contacts, contact)):
                    continue

                handle = contact.handle

                if timestamp is None or contact.updated > timestamp:
                    if contact.deleted == True:
                        delete_count = delete_count + 1
                        DeletedContactData(updated_contacts, handle, high_water_mark)
                    else:
                        update_count = update_count + 1
                        UpdatedContactData(updated_contacts, handle, None, base_url, high_water_mark)

        logging.info('Server-side updates: ' + str(update_count))
        logging.info('Server-side deletes: ' + str(delete_count))

    def process_client_changes(self, contacts_buffer, updated_contacts):
        logging.info('* Processing client changes: ' + self.username)

        base_url = self.request.host_url

        # Build an array of generic objects containing contact data,
        # using the Django built-in JSON parser
        logging.info('Uploaded contacts buffer: ' + contacts_buffer)
        json_list = simplejson.loads(contacts_buffer)
        logging.info('Client-side updates: ' + str(len(json_list)))

        # Keep track of the number of new contacts the client sent to us,
        # so that we can log it below.
        new_contact_count = 0

        for jcontact in json_list:
            new_contact = False
            id = self.safe_attr(jcontact, 'i')
            if (id != None):
                logging.info('Updating contact: ' + str(id))
                contact = datastore.Contact.get(db.Key.from_path('Contact', id))
            else:
                logging.info('Creating new contact record')
                new_contact = True
                contact = datastore.Contact(handle='temp')

            # If the 'change' for this contact is that they were deleted
            # on the client-side, all we want to do is set the deleted
            # flag here, and we're done.
            if (self.safe_attr(jcontact, 'd') == True):
                contact.deleted = True
                contact.put()
                logging.info('Deleted contact: ' + contact.handle)
                continue

            contact.firstname = self.safe_attr(jcontact, 'f')
            contact.lastname = self.safe_attr(jcontact, 'l')
            contact.phone_home = self.safe_attr(jcontact, 'h')
            contact.phone_office = self.safe_attr(jcontact, 'o')
            contact.phone_mobile = self.safe_attr(jcontact, 'm')
            contact.email = self.safe_attr(jcontact, 'e')
            contact.deleted = (self.safe_attr(jcontact, 'd') == 'true')
            if (new_contact):
                # New record - add them to db...
                new_contact_count = new_contact_count + 1
                contact.handle = contact.firstname + '_' + contact.lastname
                logging.info('Created new contact handle: ' + contact.handle)
            contact.put()
            logging.info('Saved contact: ' + contact.handle)

            # We don't save off the client_id value (thus we add it after
            # the "put"), but we want it to be in the JSON object we
            # serialize out, so that the client can match this contact
            # up with the client version.
            client_id = self.safe_attr(jcontact, 'c')

            # Create a high-water-mark for sync-state from the 'updated' time
            # for this contact, so we return the correct value to the client.
            high_water = str(long(_time.mktime(contact.updated.utctimetuple())) + 1)

            # Add new contacts to our updated_contacts, so that we return them
            # to the client (so the client gets the serverId for the
            # added contact)
            if (new_contact):
                UpdatedContactData(updated_contacts, contact.handle, client_id, base_url,
                        high_water)

        logging.info('Client-side adds: ' + str(new_contact_count))

    def list_contains_contact(self, contact_list, contact):
        if (contact is None):
            return False
        contact_id = str(contact.key().id())
        for next in contact_list:
            if ((next != None) and (next['i'] == contact_id)):
                return True
        return False

    def safe_attr(self, obj, attr_name):
        if attr_name in obj:
            return obj[attr_name]
        return None

class ResetDatabase(BaseWebServiceHandler):
    """
    Handles cron request to reset the contact database.

    We have a weekly cron task that resets the database back to a
    few contacts, so that it doesn't grow to an absurd size.
    """

    def get(self):
        # Delete all the existing contacts from the database
        contacts = datastore.Contact.all()
        for contact in contacts:
            contact.delete()

        # Now create three sample contacts
        contact1 = datastore.Contact(handle = 'juliet',
                firstname = 'Juliet',
                lastname = 'Capulet',
                phone_mobile = '(650) 555-1000',
                phone_home = '(650) 555-1001',
                status = 'Wherefore art thou Romeo?')
        contact1.put()

        contact2 = datastore.Contact(handle = 'romeo',
                firstname = 'Romeo',
                lastname = 'Montague',
                phone_mobile = '(650) 555-2000',
                phone_home = '(650) 555-2001',
                status = 'I dream\'d a dream to-night')
        contact2.put()

        contact3 = datastore.Contact(handle = 'tybalt',
                firstname = 'Tybalt',
                lastname = 'Capulet',
                phone_mobile = '(650) 555-3000',
                phone_home = '(650) 555-3001',
                status = 'Have at thee, coward')
        contact3.put()




def toJSON(object):
    """Dumps the data represented by the object to JSON for wire transfer."""
    return simplejson.dumps(object)

class UpdatedContactData(object):
    """Holds data for user's contacts.

    This class knows how to serialize itself to JSON.
    """
    __FIELD_MAP = {
        'handle': 'u',
        'firstname': 'f',
        'lastname': 'l',
        'status': 's',
        'phone_home': 'h',
        'phone_office': 'o',
        'phone_mobile': 'm',
        'email': 'e',
        'client_id': 'c'
    }

    def __init__(self, contact_list, username, client_id, host_url, high_water_mark):
        obj = datastore.Contact.get_contact_info(username)
        contact = {}
        for obj_name, json_name in self.__FIELD_MAP.items():
            if hasattr(obj, obj_name):
              v = getattr(obj, obj_name)
              if (v != None):
                  contact[json_name] = str(v)
              else:
                  contact[json_name] = None
        contact['i'] = str(obj.key().id())
        contact['a'] = host_url + "/avatar?id=" + str(obj.key().id())
        contact['x'] = high_water_mark
        if (client_id != None):
            contact['c'] = str(client_id)
        contact_list.append(contact)

class DeletedContactData(object):
    def __init__(self, contact_list, username, high_water_mark):
        obj = datastore.Contact.get_contact_info(username)
        contact = {}
        contact['d'] = 'true'
        contact['i'] = str(obj.key().id())
        contact['x'] = high_water_mark
        contact_list.append(contact)

def main():
    application = webapp.WSGIApplication(
            [('/auth', Authenticate),
             ('/sync', SyncContacts),
             ('/reset_database', ResetDatabase),
            ],
            debug=True)
    wsgiref.handlers.CGIHandler().run(application)

if __name__ == "__main__":
    main()