root/photobooth/photobooth.py

from twisted.application import service
from twisted.internet import reactor, defer
import simplejson
from datetime import datetime

import fizzjik.input.easyident
import fizzjik.input.sonmicro
import fizzjik.input.basic

import fizzjik.output.basic
import fizzjik.output.lpr

from fizzjik.hub import Hub
from fizzjik.input.sonmicro import SonMicroMifareSensor
from fizzjik.input.basic import LineReceiver
from fizzjik.input.network import NetworkConnectionSensor

from fizzjik.output.basic import Echo
from fizzjik.output.lpr import LPRService

from fizzjik.remote.xmlrpc import XMLRPCService
#from fizzjik.remote.rest import JSONService
from fizzjik.remote.flickr import UploadService


from fizzjik.config import ConfigurableService, if_config
from fizzjik.interfaces import IController, implements
from fizzjik.rfid import TagAddedEvent, TagPresentEvent, TagRemovedEvent
from fizzjik.remote.anymeta import JSONService

import pprint

from twisted.web import client

class PhotoboothController(ConfigurableService):
    implements(IController)
    countdown = None
    delay = 5.0
    remote = None
    flickr = None
    bucket = None
    people = None
    
    def __init__(self, remote, flickr):
        self.bucket = []
        self.people = {}
        self.remote = remote
        self.flickr = flickr
        #self.bucket = [{"id": "1417", "name": "Andy Smit"}]

    @if_config('enabled')
    def startService(self):
        ConfigurableService.startService(self)
        self.test()

    def test(self):
        e = TagAddedEvent('046792D9')
        d = self.getCurrentTags()
        d.addCallback(lambda x: pprint.pprint(x) and x or x)
        d.addCallbacks(lambda x: self.addToBucket(e))
        d.addCallbacks(lambda x: self.getCurrentTags())
        d.addCallback(lambda x: pprint.pprint(x) and x or x)

    def registerObservers(self, hub):
        # tag added, add me to the bucket until timeout
        hub.addObserver(TagAddedEvent, self.addToBucket)

    def addToBucket(self, evt):
        if not self.bucket:
            self.startCountdown()
        #if evt.data in self.bucket:
        #    return

        d = self._tagToPerson(evt.data)
        def _cachePerson(person):
            #pprint.pprint(person)
            self.people[evt.data] = person
            return person

        d.addCallback(_cachePerson)
        d.addCallback(self.makeContacts)
        if not self.bucket:
            d.addCallback(lambda x: self.startCountdown())
        self.bucket.append(evt.data)
        d.addErrback(lambda _: None)
        return d

    def startCountdown(self):
        print "counting down"
        if self.countdown and not self.countdown.called:
            self.countdown.cancel()
        self.countdown = reactor.callLater(self.delay, self.clearBucket)

    def clearBucket(self):
        print "clearing bucket"
        self.bucket = []
        self.people = {}
        #self.bucket = [{"id": "1417", "name": "Andy Smit"}]

    def makeContacts(self, person):
        for tag in self.bucket:
            if tag == person['rfid']:
                print "skip"
                continue
            print "conecting to %s" % tag
            if tag in self.people:
                p = dict(id=person['id'], id2=self.people[tag]['id'])
                pprint.pprint(p)
                d = self.remote.call('picnic.relations.add', p)
                d.addCallback(pprint.pprint)

                d2 = self.remote.call('picnic.relations.add',
                                      dict(id2=person['id'],
                                           id1=self.people[tag]['id']))
                d2.addCallback(pprint.pprint)
        return person

    
    def getCurrentTags(self):
        people = [self.people[tag] for tag in self.bucket if tag in self.people]
        return defer.succeed(people)

    def uploadPhoto(self, path, title=None, tags=None):
        if not title:
            title = datetime.now().strftime("%A, %H:%m")
        d = self.flickr.upload(path, title=title, tags=tags)
        d.addCallback(pprint.pprint)
        return d

    def _tagToPerson(self, tag):
        d = self._getPersonByTag(tag)
        d.addCallback(self._fillContacts)
        def _fillTag(person):
            person['rfid'] = tag
            return person
        d.addCallback(_fillTag)
        return d

    def _getPersonByTag(self, tag):
        d = self.remote.call("identity.search.uri", 
                dict(uri='urn:rfid:%s'%(tag)))
        def _getId(rv):
            print "rv", rv
            if not rv:
                raise NotFoundException("no user found for tag %s"%(tag))
            return rv[0]['thg_id']

        d.addCallback(_getId)
        d.addCallback(self._getPersonByThing)
        return d
    
    def _getPersonByThing(self, thing):
        #if not thing:
        #    return None
        d = self.remote.call("picnic.persons.get",
                dict(id=thing))
        def _translate(rv):
            rv['name'] = rv['name']['full']
            return rv
        d.addCallback(_translate)
        return d

    def _fillContacts(self, person):
        print "rehere"
        #if not person:
        #    return None
        d = self.remote.call("picnic.relations.getList",
                dict(id=person['id']))
        def _really(rv):
            l = []
            for c in rv:
                #pprint.pprint(c)
                if c[1] == person['id']:
                    contact_id = c[0]
                else:
                    contact_id = c[1]
                l.append(self._getPersonByThing(contact_id))
            return defer.gatherResults(l)
        d.addCallback(_really)
        def _fill(rv):
            person['contacts'] = rv
            return person
        d.addCallback(_fill)
        return d

    

from twisted.web2 import iweb, http, resource, stream

class WebRoot(resource.Resource):
    def __init__(self, controller):
        self.controller = controller
        self.child_current_tags = WebCurrentTags(self.controller)
        self.child_upload_photo = WebUploadPhoto(self.controller)


class WebCurrentTags(resource.Resource):
    def __init__(self, controller):
        self.controller = controller

    def render(self, ctx):
        req = iweb.IRequest(ctx)
        s = stream.ProducerStream()

        d = self.controller.getCurrentTags()
        #return http.Response(stream="OK")
        d.addCallback(simplejson.dumps)
        d.addCallback(s.write)
        d.addCallback(s.finish)

        return http.Response(stream=s)

class WebUploadPhoto(resource.Resource):
    def __init__(self, controller):
        self.controller = controller

    def render(self, ctx):
        req = iweb.IRequest(ctx)
        pprint.pprint(req)
        tags = req.args.get("tags", [""])[0].encode("utf-8")
        path = req.args.get("path", [""])[0]
        title = req.args.get("title", [""])[0]
        s = stream.ProducerStream()

        d = self.controller.uploadPhoto(path, tags=tags, title=title)
        return http.Response(stream="[]")
        #d.addCallback(simplejson.dumps)
        #d.addCallback(s.write)
        #d.addCallback(s.finish)

        #return http.Response(stream=s)

    
    


if __name__ == "__builtin__":
    application = service.Application('boozer')

    hub = Hub("photobooth.cfg")
    hub.setServiceParent(application)

    sonmicro = SonMicroMifareSensor()
    sonmicro.setServiceParent(hub)

    #network = NetworkConnectionSensor()
    #network.setServiceParent(hub)

    flickr = UploadService()
    flickr.setServiceParent(hub)

    echo = Echo()
    echo.setServiceParent(hub)

    #dhclient = DHClientController()
    #dhclient.setServiceParent(hub)

    lr = LineReceiver(2336)
    lr.setServiceParent(hub)

    lpr = LPRService()
    lpr.setServiceParent(hub)

    #xmlrpc = XMLRPCService()
    #xmlrpc.setServiceParent(hub)

    json = JSONService()
    json.setServiceParent(hub)

    controller = PhotoboothController(json, flickr)
    controller.setServiceParent(hub)

    from twisted.application import internet
    from twisted.web2 import server, channel
    webroot = WebRoot(controller)
    s = server.Site(webroot)
    w = internet.TCPServer(2567,
                           channel.HTTPFactory(s),
                           interface='0.0.0.0')

    w.setServiceParent(hub)