tv service

tvservice.py

from webob.dec import wsgify
from webob import Response
import roaf
from roaf.micro import App, Data
from roaf.data.dictcollection import DictCollection
from roaf.resources.collections import CollectionResource
from roaf.middleware.default import DefaultMiddleware
from roaf.serializers import jsoncodec as json
from formencode import Schema, validators
from pyquery import PyQuery
from static import Cling
import xml.etree.ElementTree as ET
import re

default_config = {
    'show-collection': None,
}

FEED_URL=""

class ShowSchema(Schema):
    title = validators.String()


class ShowsCollection(CollectionResource):
    def member_uri_allows(self, request):
        if request.remote_user:
            return ["GET", "PUT", "DELETE"]
        else:
            return ["GET"]        

    def collection_uri_allows(self, request):
        if request.remote_user:
            return ["GET", "POST"]
        else:
            return ["GET"]

    def parse(self, request):
        if request.content_type == "application/json":
            member = json.loads(request.body)
        elif request.content_type == "text/plain":
            member = {'title': request.body}

        member = roaf.validate(request, ShowSchema(), member)

        return member

    def render(self, request, resource, response):
        response.content_type = "application/json"
        response.body = json.dumps(resource, indent=4)
        return response

    def _render_member(self, uri, member):
        doc = {}
        doc.update(member)
        doc['id'] = uri
        return doc

    def index(self, request):
        shows = self.collection[request.path]
        
        resource = {
            "title": u"TV Shows",
            "links": {},
            "members": [],
            }

        for uri, member in shows.items():
            doc = self._render_member(uri, member)
            doc['id'] = self.collection.relative(request.path, doc['id'])
            resource['members'].append(doc)
            
        response = Response()
        response.cache_expires = 0
        return self.render(request, resource, response)

class EpisodeFeed(object):
    def __init__(self, collection):
        self.collection = collection

    @wsgify
    def __call__(self, request):
        shows = [s['title'] for s in self.collection['/shows/'].values()]
        show_pats = [re.compile(r"\b%s\b" % re.escape(show), re.I) for  show in shows]
    
        d = PyQuery(url=FEED_URL)

        def shows_to_remove(i):
            title = PyQuery(this).find("title").text()
            for pat in show_pats:
                if pat.search(title):
                    return False
            return True

        d("item").filter(shows_to_remove).remove()

        response = Response()
        response.content_type = "application/xml"
        response.ubody = unicode(d)
        response.cache_control = "no-cache"
        return response

__version__ = "0.1"

class DummyAuth(object):
    def __init__(self, app):
        self.app = app

    def __call__(self, environ, start_response):
        environ['REMOTE_USER'] = 'eric'
        return self.app(environ, start_response)

def make_app(global_config, **local_config):
    config = {}
    config.update(default_config)
    config.update(global_config)
    config.update(local_config)

    app = App()
    app.collection = Data()

    shows_collection = config['show-collection']
    shows_resource = ShowsCollection(app.collection)

    app.collection.route("/shows/{path_info:.*}", "shows", shows_collection)
    app.route("/shows/{path_info:.*}{.format:json|txt}", "shows")(shows_resource)
    app.route("/feed/", "feed")(EpisodeFeed(app.collection))
    app = DefaultMiddleware(app)
    app = DummyAuth(app)
    return app