Produits Entr'ouvert » w.c.s. » Au quotidien

import time

from quixote import get_publisher

from quixote.html import htmlescape

from qommon.storage import StorableObject

from qommon import get_cfg, get_logger

from qommon import errors

from qommon import misc

from qommon import emails

from qommon.sms import SMS

from qommon.admin.emails import EmailsDirectory

class AnnounceSubscription(StorableObject):

    _names = 'announce-subscriptions'

    user_id = None

    email = None

    sms = None

    enabled = True

    enabled_sms = False

    def remove(self, type=None):

        """ type (string) : email or sms """

        if type == "email":

            self.email = None

        elif type == "sms":

            self.sms = None

            self.enabled_sms = False

        if not type or (not self.sms and not self.email):

            self.remove_self()

        else:

            self.store()

    def get_user(self):

        if self.user_id:

            return get_publisher().user_class.get(self.user_id)

        return None

    user = property(get_user)

class Announce(StorableObject):

    _names = 'announces'

    title = None

    text = None

    hidden = False

    publication_time = None

    modification_time = None

    sent_by_email_time = None

    sent_by_sms_time = None

    position = None

    def sort_by_position(cls, links):

        def cmp_position(x, y):

            if x.position == y.position:

                return 0

            if x.position is None:

                return 1

            if y.position is None:

                return -1

            return cmp(x.position, y.position)

        links.sort(cmp_position)

    sort_by_position = classmethod(sort_by_position)

    def get_atom_entry(self):

        from pyatom import pyatom

        entry = pyatom.Entry()

        entry.id = self.get_url()

        entry.title = self.title

        entry.content.attrs['type'] = 'html'

        entry.content.text = str('<p>' + htmlescape(

                    unicode(self.text, 'iso-8859-1').encode('utf-8')) + '</p>')

        link = pyatom.Link(self.get_url())

        entry.links.append(link)

        if self.publication_time:

            entry.published = misc.format_time(self.publication_time,

                    '%(year)s-%(month)02d-%(day)02dT%(hour)02d:%(minute)02d:%(second)02dZ',

                    gmtime = True)

        if self.modification_time:

            entry.updated = misc.format_time(self.modification_time,

                    '%(year)s-%(month)02d-%(day)02dT%(hour)02d:%(minute)02d:%(second)02dZ',

                    gmtime = True)

        return entry

    def get_url(self):

        from quixote import get_request

        return '%s://%s%sannounces/%s/' % (

                get_request().get_scheme(), get_request().get_server(),

                get_publisher().get_root_url(), self.id)

    def store(self):

        self.modification_time = time.gmtime()

        StorableObject.store(self)

    def email(self):

        self.sent_by_email_time = time.gmtime()

        StorableObject.store(self)

        data = {

            'title': self.title,

            'text': self.text

        }

        subscribers = AnnounceSubscription.select(lambda x: x.enabled)

        rcpts = []

        for l in subscribers:

            if l.user_id and l.user.email:

                rcpts.append(l.user.email)

            elif l.email:

                rcpts.append(l.email)

        emails.custom_ezt_email('aq-announce', data, email_rcpt = rcpts, hide_recipients = True)

    def sms(self):

        sms = SMS()

        self.sent_by_sms_time = time.gmtime()

        StorableObject.store(self)

        subscribers = AnnounceSubscription.select(lambda x: x.enabled_sms)

        rcpts = []

        for sub in subscribers:

            if sub.sms:

                rcpts.append(sub.sms)

        sms_cfg = get_cfg('sms', {})

        sender = sms_cfg.get('sender', '')[:11]

        message = "%s: %s" % (self.title, self.text)

        try:

            sms.send(rcpts, message[:160], sender)

        except errors.SMSError, e:

            get_logger().error(e)

    def get_published_announces(cls):

        announces = cls.select(lambda x: not x.hidden)

        announces.sort(lambda x,y: cmp(x.publication_time or x.modification_time,

                    y.publication_time or y.modification_time))

        announces = [x for x in announces if x.publication_time < time.gmtime()]

        announces.reverse()

        return announces

    get_published_announces = classmethod(get_published_announces)

EmailsDirectory.register('aq-announce',

        N_('Publication of announce to subscriber'),

        N_('Available variables: title, text'),

        default_subject = N_('Announce: [title]'),

        default_body = N_("""\

[text]

-- 

This is an announce sent to you by your city, you can opt to not receive

those messages anymore on the city website.

"""))