root/tags/amplee-0.5.0/amplee/examples/cooker/core/recipe.py

# -*- coding: utf-8 -*-

import threading
import sha, os, os.path
from StringIO import StringIO
from xml.sax.saxutils import unescape, escape

from bridge import Element as E
from bridge import Document, PI
from amplee.atompub.member.atom import EntryResource
from amplee.atompub.member.generic import MediaResource
from amplee.utils import parse_multiform_data, safe_quote, \
     get_isodate, generate_uuid_uri, parse_query_string
from bridge.common import ATOM10_NS, ATOM10_PREFIX, THR_NS, THR_PREFIX


from core.utils import transform_member_resource

__all__ = ['RecipeEntryMember', 'RecipeEntryHandler',
           'RecipeFormMember', 'RecipeFormHandler',]

###########################################################
# The following two classes handle the
# application/atom+xml;type=entry media-type
###########################################################
class RecipeEntryMember(EntryResource):
    def __init__(self, collection, **kwargs):
        EntryResource.__init__(self, collection, **kwargs)

    def generate_atom_id(self, entry, slug=None):
        return u'tag:%s:%s' % (self.collection.name_or_id,
                               sha.new(slug).hexdigest())

    def generate_resource_id(self, entry, slug=None):
        return slug.replace(' ','_').decode('utf-8')
        
class RecipeEntryHandler(object):
    def __init__(self, member_type):
        # Instance of amplee.handler.MemberType
        self.member_type = member_type

    def on_update_feed(self, member):
        """Called anytime the member is created, edited or deleted,
        so that you can decdie whether or not the collection feed of
        must also be updated.

        Here we always update it:
        * member.collection.feed will force the reconstruction of the
          feed.
        * member.collection.feed_handler.set() will reset the feed
        to its new state.

        Since those two operations can be costly you may decide to avoid
        them here and delay when the collection feed is updated by another
        mean.
        """
        member.collection.feed_handler.set(member.collection.feed)
        
    def on_create(self, member, content):
        """
        Called by the HTTP handler to complete the creation of the
        resource. The ``member`` parameter is an instance of
        RecipeEntryMember and the ``content`` parameter is the POSTed
        entry as a byte string.

        This returns the member itself (that you could therefore alter
        here if needed) and None as no content should be stored in
        addition to the member resource.
        """
        return member, None
    
    def on_created(self, member):
        # In case the POSTed atom entry had the
        # app:control/app:draft set to 'yes'
        # Then we don't want the recipe to appear into the
        # public feed.
        if not member.draft:
            public = transform_member_resource(member)
            if public:
                member.collection.feed_handler.add(public)

    def on_update(self, existing_member, new_member, new_content):
        """
        On an update/edit operation, we receive three arguments.
        The ``existing_parameter`` is the member as it currently
        exists in the store. The ``new_member`` is the member as it was
        generated from the nwly sent content but not yet persisted
        into the store. The ``new_content`` is the content sent with
        the request in case your handler needs to access it.

        It will simply replace the existing member by the new one
        without much more processing. However in a more advanced
        application, one could perform some diff between the two
        and decide whether or not it can realize the operation.
        """
        # We ensure that dates will be modified
        new_member.update_dates()

        # If the entry is a not a draft then we replace the
        # existing one in the collection feed with the new one
        # Otherwise we remove the existing one from the
        # collection feed.
        entry = new_member.atom
        if not new_member.draft:
            public = transform_member_resource(new_member)
            if public:
                new_member.collection.feed_handler.replace(public)
        else:
            new_member.collection.feed_handler.remove(entry)
        
        return new_member, None

    def on_delete(self, member):
        """
        On a delete operatuion we simply remove the atom entry
        from the collection feed.
        """
        member.collection.feed_handler.remove(member.atom)
 
###########################################################
# The following two classes handle the
# multipart/form-data
###########################################################
class RecipeFormMember(MediaResource):
    def __init__(self, collection, **kwargs):
        MediaResource.__init__(self, collection, **kwargs)

    def generate_atom_id(self, entry=None, slug=None):
        return u'tag:%s:%s' % (self.collection.name_or_id,
                               sha.new(slug).hexdigest())

    def generate_resource_id(self, entry=None, slug=None):
        return slug.replace(' ','_').decode('utf-8')

    def _generate_atom_entry(self, source, slug, params):
        # We initialize the entry by calling the built-in
        # handler for media resource
        # This will at least generate the basis we need
        MediaResource.create(self, source, slug)

        # Now we can set the correct values for the entry created right above
        title = self.entry.get_child('title', self.entry.xml_ns)
        title.xml_text = params.get('title', '').decode('utf-8')

        author = self.entry.get_child('author', self.entry.xml_ns)
        name = author.get_child('name', self.entry.xml_ns)
        name.xml_text = params.get('author', '').decode('utf-8')

        tags = params.get('tags', '').split(',')
        for tag in tags:
            tag = tag.decode('utf-8')
            E(u'category', attributes={u'term': tag, u'label': tag},
              namespace=self.entry.xml_ns, prefix=self.entry.xml_prefix,
              parent=self.entry)

    def _generate_replies_feed(self, params):    
        # Next we create the feed which will host the comments for this
        # recipe.
        replies_path = os.path.join('static/replies', self.media_id)
        if not os.path.exists(replies_path):
            d = Document()
            PI(target=u'xml-stylesheet', data=u'href="/static/replies.xsl" type="text/xsl"', parent=d)
            replies = E(u'feed', namespace=ATOM10_NS, prefix=ATOM10_PREFIX, parent=d)

            # We generate a dummy id seeding the title of the recipe
            replies_id = u'tag:replies:%s' % (sha.new(params.get('title', '')).hexdigest())
            E(u'id', content=replies_id,
              namespace=ATOM10_NS, prefix=ATOM10_PREFIX, parent=replies)
            E(u'title', content=params.get('title', '').decode('utf-8'),
              namespace=ATOM10_NS, prefix=ATOM10_PREFIX, parent=replies)
            E(u'updated', content=get_isodate(),
              namespace=ATOM10_NS, prefix=ATOM10_PREFIX, parent=replies)
            author = E(u'author', namespace=ATOM10_NS, prefix=ATOM10_PREFIX, parent=replies)
            E(u'name', content=params.get('author', '').decode('utf-8'),
              namespace=ATOM10_NS, prefix=ATOM10_PREFIX, parent=author)
            E(u'link', attributes={u'rel': u'self', u'type': u'application/atom+xml;type=feed',
                                   u'href': u'%s/comments' % self.public_uri},
              namespace=ATOM10_NS, prefix=ATOM10_PREFIX, parent=replies)

            # This may allow aggregators that don't handle RFC 4685 to know where
            # they could find the entry the comments are relating to
            E(u'link', attributes={u'rel': u'related', u'type': u'application/atom+xml;type=entry',
                                   u'href': u'%s.atom' % self.public_uri},
              namespace=ATOM10_NS, prefix=ATOM10_PREFIX, parent=replies)

            # We finally set the thr:in-reply-to element as per RFC 4685 to explain
            # what this feed relates to
            resource_id = self.entry.get_child('id', ATOM10_NS).xml_text
            E(u'in-reply-to', attributes={u'ref': resource_id, u'type': u'application/atom+xml;type=entry',
                                          u'href': u'%s.atom' % self.public_uri},
              namespace=THR_NS, prefix=THR_PREFIX, parent=replies)
                                             
            file(replies_path, 'w').write(d.xml())
                               
    def create(self, source, slug=None):
        """
        We reimplement the amplee.atompub.member.generic.MediaResource
        class 'create' method to process the request as per our specific
        requirements for this application.
        """
        # First we parse the request body as a multiform/data
        # This returns a dictionnary where the keys are the
        # names of each form elements
        # The content associated is always a string or, in
        # case of a file upload, it is a cgi.FieldStorage
        # The self.raw_headers contain a copy of the request
        # headers as they will be needed to parse the request body.
        params = parse_multiform_data(source, self.raw_headers)

        # If the slug was not provided we use the title sent
        # with the request. Some say it's not recommended but
        # I haven't yet understood why so we'll leave with it.
        if not slug:
            slug = params.get('title', '')

        slug = slug.replace(' ','_')

        self._generate_atom_entry(source, slug, params)
        self._generate_replies_feed(params)

        # The content we return at this point will be propagated as-is
        # to the RecipeFormHandler instance below during the
        # request processing
        return params

    def update(self, source, existing_member):
        """
        We reimplement the amplee.atompub.member.generic.MediaResource
        class 'update' method to process the request as per our specific
        requirements for this application.
        """
        # Update operations are similar to create operations
        # except that we don't regenerate the comments feed and
        # we remove the existing atom:category elements to
        # replace them with the new submitted tags.
        params = parse_multiform_data(source, self.raw_headers)

        # No slug needed in this case but we use the
        # existing member that the AtomPub store holds already
        MediaResource.update(self, source, existing_member)

        title = self.entry.get_child('title', self.entry.xml_ns)
        title.xml_text = params.get('title', '').decode('utf-8')

        author = self.entry.get_child('author', self.entry.xml_ns)
        name = author.get_child('name', self.entry.xml_ns)
        name.xml_text = params.get('author', '').decode('utf-8')

        categories = self.entry.get_children('category', self.entry.xml_ns)[:]
        for cat in categories:
            cat.forget()
            
        tags = params.get('tags', '').split(',')
        for tag in tags:
            tag = tag.decode('utf-8')
            E(u'category', attributes={u'term': tag, u'label': tag},
              namespace=self.entry.xml_ns, prefix=self.entry.xml_prefix,
              parent=self.entry)

        return params
    
class RecipeFormHandler(object):
    def __init__(self, member_type):
        self.member_type = member_type
        self.lock = threading.Lock()

    def on_update_feed(self, member):
        member.collection.feed_handler.set(member.collection.feed)
        
    def on_create(self, member, content):
        entry = member.atom

        # Note that at this stage the content is the parsed
        # request body from  RecipeFormMember.create
        # So it's a dictionnary mapping the multipart/form-data items
        image = content.get('image', '')
        if image != '':
            image = image.file.read()
            if image:
                try:
                    # We also store the image sent out of the AtomPub
                    # storage repository so that we can access it from
                    # a public URI more easily
                    self.lock.acquire()
                    file(os.path.join(self.member_type.params['photos_path'],
                                      member.media_id), 'wb').write(image)
                finally:
                    self.lock.release()

        title = content.get('title', '')
        author = content.get('author', '')
        tags = content.get('tags', '')
        recipe = content.get('content', '')

        # The TarFileStorage we are using expects the content to be
        # of the form [('some_name', content_string, content_length)]
        return member, [('title', title, len(title)),
                        ('author', author, len(author)),
                        ('tags', tags, len(tags)),
                        ('recipe', recipe, len(recipe)),
                        ('image', image, len(image))]

    def on_created(self, member):
        if not member.draft:
            public = transform_member_resource(member)
            if public:
                member.collection.feed_handler.add(public)
        
    def on_update(self, existing_member, new_member, new_content):
        new_member.update_dates()
        
        image = new_content.get('image', '')
        if image != '':
            image = image.file.read()
            if image:
                try:
                    self.lock.acquire()
                    file(os.path.join(self.member_type.params['photos_path'],
                                      member.media_id), 'wb').write(image)
                finally:
                    self.lock.release()
        else:
            try:
                self.lock.acquire()
                try:
                    os.unlink(os.path.join(self.member_type.params['photos_path'],
                                           member.media_id))
                except OSError:
                    pass
            finally:
                self.lock.release()

        title = new_content.get('title', '')
        author = new_content.get('author', '')
        tags = new_content.get('tags', '')
        recipe = new_content.get('content', '')
        
        return new_member, [('title', title, len(title)),
                            ('author', author, len(author)),
                            ('tags', tags, len(tags)),
                            ('recipe', recipe, len(recipe)),
                            ('image', image, len(image))]

    def on_updated(self, member):
        if not member.draft:
            public = transform_member_resource(member)
            member.collection.feed_handler.replace(public)
        else:
            member.collection.feed_handler.remove(member.atom)
        

    def on_delete(self, member):
        member.collection.feed_handler.remove(member.atom)
        try:
            self.lock.acquire()
            try:
                os.unlink(os.path.join(self.member_type.params['photos_path'],
                                       member.media_id))
            except OSError:
                pass
        finally:
            self.lock.release()
         
###########################################################
# The following two classes handle the
# application/x-www-form-urlencoded
###########################################################   
class RecipeFormUrlEncodedMember(MediaResource):
    def __init__(self, collection, **kwargs):
        MediaResource.__init__(self, collection, **kwargs)

    def generate_atom_id(self, entry, slug=None):
        return u'tag:%s:%s' % (self.collection.name_or_id,
                               sha.new(slug).hexdigest())

    def generate_resource_id(self, entry, slug=None):
        return slug.replace(' ','_').decode('utf-8')

    def update(self, source, existing_member):
        length = int(self.raw_headers['content-length'])
        query = source.read(length)
        
        params = parse_query_string(query)
        
        MediaResource.update(self, source, existing_member)
        title = self.entry.get_child('title', self.entry.xml_ns)
        title.xml_text = params.get('title', '').decode('utf-8')

        return params
        
class RecipeFormUrlEncodedHandler(object):
    def __init__(self, member_type):
        self.member_type = member_type
        
    def on_update_feed(self, member):
        member.collection.feed_handler.set(member.collection.feed)
        
    def on_update(self, existing_member, new_member, new_content):
        new_member.update_dates()
        
        title = new_content.get('title', '')
        author = new_content.get('author', '')
        recipe = new_content.get('recipe', '')

        path = existing_member.collection.get_content_info(existing_member.media_id)
        
        path.archive_sub_path = 'image'
        image = existing_member.collection.get_content(path)[0][1]
        
        path.archive_sub_path = 'tags'
        tags = existing_member.collection.get_content(path)[0][1]
        
        return new_member, [('title', title, len(title)),
                            ('author', author, len(author)),
                            ('tags', tags, len(tags)),
                            ('recipe', recipe, len(recipe)),
                            ('image', image, len(image))]


    def on_updated(self, member):
        if not member.draft:
            public = transform_member_resource(member)
            member.collection.feed_handler.replace(public)
        else:
            member.collection.feed_handler.remove(member.atom)
        
    def on_delete(self, member):
        member.collection.feed_handler.remove(member.atom)
        try:
            os.unlink(os.path.join(self.member_type.params['photos_path'],
                                   member.media_id))
        except OSError:
            pass