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

from modules import announces_ui

rdb.register_directory('announces', announces_ui.AnnouncesDirectory())

rdb.register_menu_item('announces/', _('Announces'))

    _q_exports = ['', 'update', 'announces', 'permissions',

            'announce_themes', 'strongbox', 'domino']

    def announces(self):

        announces_cfg = get_cfg('announces', {})

        sms_cfg = get_cfg('sms', {})

        form = Form(enctype='multipart/form-data')

        hint = ""

        if sms_cfg.get('mode','') in ("none",""):

            hint = htmltext(_('You must also <a href="%s">configure your SMS provider</a>') % "../settings/sms")

        form.add(CheckboxWidget, 'sms_support', title = _('SMS support'),

                hint = hint, value = announces_cfg.get('sms_support', 0))

        form.add(StringWidget, 'mobile_mask', title = _('Mask for mobile numbers'),

                hint = _('example: 06XXXXXXXX'),

                value = announces_cfg.get('mobile_mask',''))

        form.add_submit('submit', _('Submit'))

        form.add_submit('cancel', _('Cancel'))

        self._verify_mask(form)

        if form.get_widget('cancel').parse():

            return redirect('..')

        if not form.is_submitted() or form.has_errors():

            get_response().breadcrumb.append(('aq/announces', _('Announces Options')))

            html_top('settings', _('Announces Options'))

            r = TemplateIO(html=True)

            r += htmltext('<h2>%s</h2>') % _('Announces Options')

            r += form.render()

            return r.getvalue()

        else:

            from wcs.admin.settings import cfg_submit

            cfg_submit(form, 'announces', ('sms_support','mobile_mask'))

            return redirect('..')

        if get_publisher().has_site_option('auquotidien-announces'):

            form.add(SingleSelectWidget, 'announces', title = _('Admin role for announces'),

                    value = permissions_cfg.get('announces', None),

                    options = [(None, _('Nobody'), None)] + get_user_roles())

                        ('forms', 'announces', 'payments', 'strongbox'))

            return redirect('..')

    def announce_themes(self):

        misc_cfg = get_cfg('misc', {})

        form = Form(enctype='multipart/form-data')

        form.add(WidgetList, 'announce_themes', title = _('Announce Themes'),

                value = misc_cfg.get('announce_themes', []),

                elemnt_type = StringWidget,

                add_element_label = _('Add Theme'),

                element_kwargs = {str('render_br'): False, str('size'): 30})

        form.add_submit('submit', _('Submit'))

        form.add_submit('cancel', _('Cancel'))

        if form.get_widget('cancel').parse():

            return redirect('..')

        if not form.is_submitted() or form.has_errors():

            get_response().breadcrumb.append(('aq/announce_themes', _('Announce Themes')))

            html_top('settings', _('Announce Themes'))

            r = TemplateIO(html=True)

            r += htmltext('<h2>%s</h2>') % _('Announce Themes')

            r += form.render()

            return r.getvalue()

        else:

            from wcs.admin.settings import cfg_submit

            cfg_submit(form, 'misc', ('announce_themes',))

        if not (get_publisher().has_site_option('auquotidien-announces') or

                get_publisher().has_site_option('auquotidien-payments') or

        if get_publisher().has_site_option('auquotidien-announces'):

            r += htmltext('<li><a href="aq/announces">%s</a></li>') % _('Announces Options')

        if get_publisher().has_site_option('auquotidien-announces'):

            r += htmltext('<li><a href="aq/announce_themes">%s</a></li>') % _('Announce Themes')

import time

from quixote import get_publisher

from quixote.html import htmlescape

from wcs.qommon import _

from wcs.qommon.storage import StorableObject

from wcs.qommon import get_cfg, get_logger

from wcs.qommon import errors

from wcs.qommon import misc

from wcs.qommon import emails

from wcs.qommon.sms import SMS

from wcs.qommon.admin.emails import EmailsDirectory

class AnnounceSubscription(StorableObject):

    _names = 'announce-subscriptions'

    _indexes = ['user_id']

    user_id = None

    email = None

    sms = None

    enabled = True

    enabled_sms = False

    enabled_themes = None

    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:

            try:

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

            except KeyError:

                return None

        return None

    user = property(get_user)

class Announce(StorableObject):

    _names = 'announces'

    title = None

    text = None

    hidden = False

    publication_time = None

    modification_time = None

    expiration_time = None

    sent_by_email_time = None

    sent_by_sms_time = None

    theme = 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, get_publisher().site_charset).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):

        return '%s/announces/%s/' % (get_publisher().get_frontoffice_url(), self.id)

    def store(self):

        self.modification_time = time.gmtime()

        StorableObject.store(self)

    def email(self, job=None):

        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 self.theme:

                if l.enabled_themes is not None:

                    if self.theme not in l.enabled_themes:

                        continue

            if l.user and l.user.email:

                rcpts.append(l.user.email)

            elif l.email:

                rcpts.append(l.email)

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

    def sms(self, job=None):

        self.sent_by_sms_time = time.gmtime()

        StorableObject.store(self)

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

        rcpts = []

        for sub in subscribers:

            if self.theme:

                if sub.enabled_themes is not None:

                    if self.theme not in sub.enabled_themes:

                        continue

            if sub.sms:

                rcpts.append(sub.sms)

        sms_cfg = get_cfg('sms', {})

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

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

        mode = sms_cfg.get('mode', 'none')

        sms = SMS.get_sms_class(mode)

        try:

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

        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()

                     and (x.expiration_time is None or x.expiration_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.

"""))

from quixote import get_request, get_response, get_session, redirect

from quixote.directory import Directory, AccessControlled

from quixote.html import htmltext, TemplateIO

import wcs

from wcs.qommon import _

from wcs.qommon.backoffice.menu import html_top

from wcs.qommon.admin.menu import command_icon

from wcs.qommon import get_cfg

from wcs.qommon import errors

from wcs.qommon.form import *

from wcs.qommon.afterjobs import AfterJob

from .announces import Announce, AnnounceSubscription

class SubscriptionDirectory(Directory):

    _q_exports = ['delete_email', "delete_sms"]

    def __init__(self, subscription):

        self.subscription = subscription

    def delete_email(self):

        form = Form(enctype='multipart/form-data')

        form.widgets.append(HtmlWidget('<p>%s</p>' % _(

                        'You are about to delete this subscription.')))

        form.add_submit('submit', _('Submit'))

        form.add_submit('cancel', _('Cancel'))

        if form.get_submit() == 'cancel':

            return redirect('..')

        if not form.is_submitted() or form.has_errors():

            get_response().breadcrumb.append(('delete', _('Delete')))

            html_top('announces', title = _('Delete Subscription'))

            r = TemplateIO(html=True)

            r += htmltext('<h2>%s</h2>') % _('Deleting Subscription')

            r += form.render()

            return r.getvalue()

        else:

            self.subscription.remove("email")

            return redirect('..')

    def delete_sms(self):

        form = Form(enctype='multipart/form-data')

        form.widgets.append(HtmlWidget('<p>%s</p>' % _(

                        'You are about to delete this subscription.')))

        form.add_submit('submit', _('Submit'))

        form.add_submit('cancel', _('Cancel'))

        if form.get_submit() == 'cancel':

            return redirect('..')

        if not form.is_submitted() or form.has_errors():

            get_response().breadcrumb.append(('delete', _('Delete')))

            html_top('announces', title = _('Delete Subscription'))

            r = TemplateIO(html=True)

            r += htmltext('<h2>%s</h2>') % _('Deleting Subscription')

            r += form.render()

            return r.getvalue()

        else:

            self.subscription.remove("sms")

            return redirect('..')

class SubscriptionsDirectory(Directory):

    _q_exports = ['']

    def _q_traverse(self, path):

        get_response().breadcrumb.append(('subscriptions', _('Subscriptions')))

        return Directory._q_traverse(self, path)

    def _q_index(self):

        html_top('announces', _('Announces Subscribers'))

        r = TemplateIO(html=True)

        r += htmltext('<h2>%s</h2>') % _('Announces Subscribers')

        subscribers = AnnounceSubscription.select()

        r += htmltext('<ul class="biglist" id="subscribers-list">')

        for l in subscribers:

            if l.email:

                if l.enabled is False:

                    r += htmltext('<li class="disabled">')

                else:

                    r += htmltext('<li>')

                r += htmltext('<strong class="label">')

                if l.user:

                    r += l.user.display_name

                elif l.email:

                    r += l.email

                r += htmltext('</strong>')

                r += htmltext('<p class="details">')

                if l.user:

                    r += l.user.email

                r += htmltext('</p>')

                r += htmltext('<p class="commands">')

                r += command_icon('%s/delete_email' % l.id, 'remove', popup = True)

                r += htmltext('</p></li>')

                r += htmltext('</li>')

            if l.sms:

                if l.enabled_sms is False:

                    r += htmltext('<li class="disabled">')

                else:

                    r += htmltext('<li>')

                r += htmltext('<strong class="label">')

                if l.user:

                    r += l.user.display_name

                elif l.email:

                    r += l.email

                r += htmltext('</strong>')

                r += htmltext('<p class="details">')

                r += l.sms

                r += htmltext('</p>')

                r += htmltext('<p class="commands">')

                r += command_icon('%s/delete_sms' % l.id, 'remove', popup = True)

                r += htmltext('</p></li>')

                r += htmltext('</li>')

        r += htmltext('</ul>')

        return r.getvalue()

    def _q_lookup(self, component):

        try:

            sub = AnnounceSubscription.get(component)

        except KeyError:

            raise errors.TraversalError()

        get_response().breadcrumb.append((str(sub.id), str(sub.id)))

        return SubscriptionDirectory(sub)

    def listing(self):

        return redirect('.')

class AnnounceDirectory(Directory):

    _q_exports = ['', 'edit', 'delete', 'email', 'sms']

    def __init__(self, announce):

        self.announce = announce

    def _q_index(self):

        form = Form(enctype='multipart/form-data')

        get_response().filter['sidebar'] = self.get_sidebar()

        if self.announce.sent_by_email_time is None:

            form.add_submit('email', _('Send email'))

        announces_cfg = get_cfg('announces', {})

        if announces_cfg.get('sms_support', 0) and self.announce.sent_by_sms_time is None:

            form.add_submit('sms', _('Send SMS'))

        if form.get_submit() == 'edit':

            return redirect('edit')

        if form.get_submit() == 'delete':

            return redirect('delete')

        if form.get_submit() == 'email':

            return redirect('email')

        if form.get_submit() == 'sms':

            return redirect('sms')

        html_top('announces', title = _('Announce: %s') % self.announce.title)

        r = TemplateIO(html=True)

        r += htmltext('<h2>%s</h2>') % _('Announce: %s') % self.announce.title

        r += htmltext('<div class="bo-block">')

        r += htmltext('<p>')

        r += self.announce.text

        r += htmltext('</p>')

        r += htmltext('</div>')

        if form.get_submit_widgets():

            r += form.render()

        return r.getvalue()

    def get_sidebar(self):

        r = TemplateIO(html=True)

        r += htmltext('<ul>')

        r += htmltext('<li><a href="edit">%s</a></li>') % _('Edit')

        r += htmltext('<li><a href="delete">%s</a></li>') % _('Delete')

        r += htmltext('</ul>')

        return r.getvalue()

    def email(self):

        if get_request().form.get('job'):

            try:

                job = AfterJob.get(get_request().form.get('job'))

            except KeyError:

                return redirect('..')

            html_top('announces', title = _('Announce: %s') % self.announce.title)

            r = TemplateIO(html=True)

            get_response().add_javascript(['jquery.js', 'afterjob.js'])

            r += htmltext('<dl class="job-status">')

            r += htmltext('<dt>')

            r += _(job.label)

            r += htmltext('</dt>')

            r += htmltext('<dd>')

            r += htmltext('<span class="afterjob" id="%s">') % job.id

            r += _(job.status)

            r += htmltext('</span>')

            r += htmltext('</dd>')

            r += htmltext('</dl>')

            r += htmltext('<div class="done">')

            r += htmltext('<a href="../">%s</a>') % _('Back')

            r += htmltext('</div>')

            return r.getvalue()

        else:

            job = get_response().add_after_job(

                    str(N_('Sending emails for announce')),

                    self.announce.email)

            return redirect('email?job=%s' % job.id)

    def sms(self):

        if get_request().form.get('job'):

            try:

                job = AfterJob.get(get_request().form.get('job'))

            except KeyError:

                return redirect('..')

            html_top('announces', title = _('Announce: %s') % self.announce.title)

            get_response().add_javascript(['jquery.js', 'afterjob.js'])

            r = TemplateIO(html=True)

            r += htmltext('<dl class="job-status">')

            r += htmltext('<dt>')

            r += _(job.label)

            r += htmltext('</dt>')

            r += htmltext('<dd>')

            r += htmltext('<span class="afterjob" id="%s">') % job.id

            r += _(job.status)

            r += htmltext('</span>')

            r += htmltext('</dd>')

            r += htmltext('</dl>')

            r += htmltext('<div class="done">')

            r += htmltext('<a href="../">%s</a>') % _('Back')

            r += htmltext('</div>')

            return r.getvalue()

        else:

            job = get_response().add_after_job(

                    str(N_('Sending sms for announce')),

                    self.announce.sms)

            return redirect('sms?job=%s' % job.id)

    def edit(self):

        form = self.form()

        if form.get_submit() == 'cancel':

            return redirect('.')

        if form.is_submitted() and not form.has_errors():

            self.submit(form)

            return redirect('..')

        html_top('announces', title = _('Edit Announce: %s') % self.announce.title)

        r = TemplateIO(html=True)

        r += htmltext('<h2>%s</h2>') % _('Edit Announce: %s') % self.announce.title

        r += form.render()

        return r.getvalue()

    def form(self):

        form = Form(enctype='multipart/form-data')

        form.add(StringWidget, 'title', title = _('Title'), required = True,

                value = self.announce.title)

        if self.announce.publication_time:

            pub_time = time.strftime(misc.date_format(), self.announce.publication_time)

        else:

            pub_time = None

        form.add(DateWidget, 'publication_time', title = _('Publication Time'),

                value = pub_time)

        if self.announce.expiration_time:

            exp_time = time.strftime(misc.date_format(), self.announce.expiration_time)

        else:

            exp_time = None

        form.add(DateWidget, 'expiration_time', title = _('Expiration Time'),

                value = exp_time)

        form.add(TextWidget, 'text', title = _('Text'), required = True,

                value = self.announce.text, rows = 10, cols = 70)

        if get_cfg('misc', {}).get('announce_themes'):

            form.add(SingleSelectWidget, 'theme', title = _('Announce Theme'),

                    value = self.announce.theme,

                    options = get_cfg('misc', {}).get('announce_themes'))

        form.add(CheckboxWidget, 'hidden', title = _('Hidden'),

                value = self.announce.hidden)

        form.add_submit('submit', _('Submit'))

        form.add_submit('cancel', _('Cancel'))

        return form

    def submit(self, form):

        for k in ('title', 'text', 'hidden', 'theme'):

            widget = form.get_widget(k)

            if widget:

                setattr(self.announce, k, widget.parse())

        for k in ('publication_time', 'expiration_time'):

            widget = form.get_widget(k)

            if widget:

                wid_time = widget.parse()

                if wid_time:

                    setattr(self.announce, k, time.strptime(wid_time, misc.date_format()))

                else:

                    setattr(self.announce, k, None)

        self.announce.store()

    def delete(self):

        form = Form(enctype='multipart/form-data')

        form.widgets.append(HtmlWidget('<p>%s</p>' % _(

                        'You are about to irrevocably delete this announce.')))

        form.add_submit('submit', _('Submit'))

        form.add_submit('cancel', _('Cancel'))

        if form.get_submit() == 'cancel':

            return redirect('..')

        if not form.is_submitted() or form.has_errors():

            get_response().breadcrumb.append(('delete', _('Delete')))

            html_top('announces', title = _('Delete Announce'))

            r = TemplateIO(html=True)

            r += htmltext('<h2>%s</h2>') % _('Deleting Announce: %s') % self.announce.title

            r += form.render()

            return r.getvalue()

        else:

            self.announce.remove_self()

            return redirect('..')

class AnnouncesDirectory(AccessControlled, Directory):

    _q_exports = ['', 'new', 'listing', 'subscriptions', 'update_order', 'log']

    label = N_('Announces')

    subscriptions = SubscriptionsDirectory()

    def is_accessible(self, user):

        from .backoffice import check_visibility

        return check_visibility('announces', user)

    def _q_access(self):

        user = get_request().user

        if not user:

            raise errors.AccessUnauthorizedError()

        if not self.is_accessible(user):

            raise errors.AccessForbiddenError(

                    public_msg = _('You are not allowed to access Announces Management'),

                    location_hint = 'backoffice')

        get_response().breadcrumb.append(('announces/', _('Announces')))

    def _q_index(self):

        html_top('announces', _('Announces'))

        r = TemplateIO(html=True)

        get_response().filter['sidebar'] = self.get_sidebar()

        announces = Announce.select()

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

                    y.publication_time or y.modification_time))

        announces.reverse()

        r += htmltext('<ul class="biglist" id="announces-list">')

        for l in announces:

            announce_id = l.id

            if l.hidden:

                r += htmltext('<li class="disabled" class="biglistitem" id="itemId_%s">') % announce_id

            else:

                r += htmltext('<li class="biglistitem" id="itemId_%s">') % announce_id

            r += htmltext('<strong class="label"><a href="%s/">%s</a></strong>') % (l.id, l.title)

            if l.publication_time:

                r += htmltext('<p class="details">')

                r += time.strftime(misc.date_format(), l.publication_time)

                r += htmltext('</p>')

            r += htmltext('</li>')

        r += htmltext('</ul>')

        return r.getvalue()

    def get_sidebar(self):

        r = TemplateIO(html=True)

        r += htmltext('<ul id="sidebar-actions">')

        r += htmltext(' <li><a class="new-item" href="new">%s</a></li>') % _('New')

        r += htmltext(' <li><a href="subscriptions/">%s</a></li>') % _('Subscriptions')

        r += htmltext(' <li><a href="log">%s</a></li>') % _('Log')

        r += htmltext('</ul>')

        return r.getvalue()

    def log(self):

        announces = Announce.select()

        log = []

        for l in announces:

            if l.publication_time:

                log.append((l.publication_time, _('Publication'), l))

            if l.sent_by_email_time:

                log.append((l.sent_by_email_time, _('Email'), l))

            if l.sent_by_sms_time:

                log.append((l.sent_by_sms_time, _('SMS'), l))

        log.sort()

        get_response().breadcrumb.append(('log', _('Log')))

        html_top('announces', title = _('Log'))

        r = TemplateIO(html=True)

        r += htmltext('<table>')

        r += htmltext('<thead>')

        r += htmltext('<tr>')

        r += htmltext('<th>%s</th>') % _('Time')

        r += htmltext('<th>%s</th>') % _('Type')

        r += htmltext('<td></td>')

        r += htmltext('</tr>')

        r += htmltext('</thead>')

        r += htmltext('<tbody>')

        for log_time, log_type, log_announce in log:

            r += htmltext('<tr>')

            r += htmltext('<td>')

            r += misc.localstrftime(log_time)

            r += htmltext('</td>')

            r += htmltext('<td>')

            r += log_type

            r += htmltext('</td>')

            r += htmltext('<td>')

            r += htmltext('<a href="%s">%s</a>') % (log_announce.id, log_announce.title)

            r += htmltext('</td>')

            r += htmltext('</tr>')

        r += htmltext('</tbody>')

        r += htmltext('</table>')

        return r.getvalue()

    def update_order(self):

        request = get_request()

        new_order = request.form['order'].strip(';').split(';')

        announces = Announce.select()

        dict = {}

        for l in announces:

            dict[str(l.id)] = l

        for i, o in enumerate(new_order):

            dict[o].position = i + 1

            dict[o].store()

        return 'ok'

    def new(self):

        announce = Announce()

        announce.publication_time = time.gmtime()

        announce_ui = AnnounceDirectory(announce)

        form = announce_ui.form()

        if form.get_submit() == 'cancel':

            return redirect('.')

        if form.is_submitted() and not form.has_errors():

            announce_ui.submit(form)

            return redirect('%s/' % announce_ui.announce.id)

        get_response().breadcrumb.append(('new', _('New Announce')))

        html_top('announces', title = _('New Announce'))

        r = TemplateIO(html=True)

        r += htmltext('<h2>%s</h2>') % _('New Announce')

        r += form.render()

        return r.getvalue()

    def _q_lookup(self, component):

        try:

            announce = Announce.get(component)

        except KeyError:

            raise errors.TraversalError()

        get_response().breadcrumb.append((str(announce.id), announce.title))

        return AnnounceDirectory(announce)

    def listing(self):

        return redirect('.')

from .announces import AnnounceSubscription

            'announces', 'strongbox', 'invoices', 'json']

        options = get_cfg('misc', {}).get('announce_themes')

        if options:

            try:

                subscription = AnnounceSubscription.get_on_index(

                        get_request().user.id, str('user_id'))

            except KeyError:

                pass

            else:

                r += htmltext('<p class="command"><a href="announces">%s</a></p>') % _(

                        'Edit my Subscription to Announces')

    def announces(self):

        options = get_cfg('misc', {}).get('announce_themes')

        if not options:

            raise errors.TraversalError()

        user = get_request().user

        if not user or user.anonymous:

            raise errors.AccessUnauthorizedError()

        subscription = AnnounceSubscription.get_on_index(get_request().user.id, str('user_id'))

        if not subscription:

            raise errors.TraversalError()

        if subscription.enabled_themes is None:

            enabled_themes = options

        else:

            enabled_themes = subscription.enabled_themes

        form = Form(enctype = 'multipart/form-data')

        form.add(CheckboxesWidget, 'themes', title=_('Announce Themes'),

                value=enabled_themes, options=[(x, x, x) for x in options],

                inline=False, required=False)

        form.add_submit('submit', _('Apply Changes'))

        form.add_submit('cancel', _('Cancel'))

        if form.get_submit() == 'cancel':

            return redirect('.')

        if form.is_submitted() and not form.has_errors():

            chosen_themes = form.get_widget('themes').parse()

            if chosen_themes == options:

                chosen_themes = None

            subscription.enabled_themes = chosen_themes

            subscription.store()

            return redirect('.')

        template.html_top()

        get_response().breadcrumb.append(('announces', _('Announce Subscription')))

        return form.render()

# Larry Rosen has ceased to use or recommend any version

# of the Academic Free License below version 2.1

The Academic Free License

v. 2.1

This Academic Free License (the "License") applies to any original work of authorship (the "Original Work") whose owner (the "Licensor") has placed the following notice immediately following the copyright notice for the Original Work:

Licensed under the Academic Free License version 2.1

1) Grant of Copyright License. Licensor hereby grants You a world-wide, royalty-free, non-exclusive, perpetual, sublicenseable license to do the following:

a) to reproduce the Original Work in copies;

b) to prepare derivative works ("Derivative Works") based upon the Original Work;

c) to distribute copies of the Original Work and Derivative Works to the public;

d) to perform the Original Work publicly; and

e) to display the Original Work publicly.

2) Grant of Patent License. Licensor hereby grants You a world-wide, royalty-free, non-exclusive, perpetual, sublicenseable license, under patent claims owned or controlled by the Licensor that are embodied in the Original Work as furnished by the Licensor, to make, use, sell and offer for sale the Original Work and Derivative Works.

3) Grant of Source Code License. The term "Source Code" means the preferred form of the Original Work for making modifications to it and all available documentation describing how to modify the Original Work. Licensor hereby agrees to provide a machine-readable copy of the Source Code of the Original Work along with each copy of the Original Work that Licensor distributes. Licensor reserves the right to satisfy this obligation by placing a machine-readable copy of the Source Code in an information repository reasonably calculated to permit inexpensive and convenient access by You for as long as Licensor continues to distribute the Original Work, and by publishing the address of that information repository in a notice immediately following the copyright notice that applies to the Original Work.

4) Exclusions From License Grant. Neither the names of Licensor, nor the names of any contributors to the Original Work, nor any of their trademarks or service marks, may be used to endorse or promote products derived from this Original Work without express prior written permission of the Licensor. Nothing in this License shall be deemed to grant any rights to trademarks, copyrights, patents, trade secrets or any other intellectual property of Licensor except as expressly stated herein. No patent license is granted to make, use, sell or offer to sell embodiments of any patent claims other than the licensed claims defined in Section 2. No right is granted to the trademarks of Licensor even if such marks are included in the Original Work. Nothing in this License shall be interpreted to prohibit Licensor from licensing under different terms from this License any Original Work that Licensor otherwise would have a right to license.

5) This section intentionally omitted.

6) Attribution Rights. You must retain, in the Source Code of any Derivative Works that You create, all copyright, patent or trademark notices from the Source Code of the Original Work, as well as any notices of licensing and any descriptive text identified therein as an "Attribution Notice." You must cause the Source Code for any Derivative Works that You create to carry a prominent Attribution Notice reasonably calculated to inform recipients that You have modified the Original Work.

7) Warranty of Provenance and Disclaimer of Warranty. Licensor warrants that the copyright in and to the Original Work and the patent rights granted herein by Licensor are owned by the Licensor or are sublicensed to You under the terms of this License with the permission of the contributor(s) of those copyrights and patent rights. Except as expressly stated in the immediately proceeding sentence, the Original Work is provided under this License on an "AS IS" BASIS and WITHOUT WARRANTY, either express or implied, including, without limitation, the warranties of NON-INFRINGEMENT, MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. THE ENTIRE RISK AS TO THE QUALITY OF THE ORIGINAL WORK IS WITH YOU. This DISCLAIMER OF WARRANTY constitutes an essential part of this License. No license to Original Work is granted hereunder except under this disclaimer.

8) Limitation of Liability. Under no circumstances and under no legal theory, whether in tort (including negligence), contract, or otherwise, shall the Licensor be liable to any person for any direct, indirect, special, incidental, or consequential damages of any character arising as a result of this License or the use of the Original Work including, without limitation, damages for loss of goodwill, work stoppage, computer failure or malfunction, or any and all other commercial damages or losses. This limitation of liability shall not apply to liability for death or personal injury resulting from Licensor's negligence to the extent applicable law prohibits such limitation. Some jurisdictions do not allow the exclusion or limitation of incidental or consequential damages, so this exclusion and limitation may not apply to You.

9) Acceptance and Termination. If You distribute copies of the Original Work or a Derivative Work, You must make a reasonable effort under the circumstances to obtain the express assent of recipients to the terms of this License. Nothing else but this License (or another written agreement between Licensor and You) grants You permission to create Derivative Works based upon the Original Work or to exercise any of the rights granted in Section 1 herein, and any attempt to do so except under the terms of this License (or another written agreement between Licensor and You) is expressly prohibited by U.S. copyright law, the equivalent laws of other countries, and by international treaty. Therefore, by exercising any of the rights granted to You in Section 1 herein, You indicate Your acceptance of this License and all of its terms and conditions.

10) Termination for Patent Action. This License shall terminate automatically and You may no longer exercise any of the rights granted to You by this License as of the date You commence an action, including a cross-claim or counterclaim, against Licensor or any licensee alleging that the Original Work infringes a patent. This termination provision shall not apply for an action alleging patent infringement by combinations of the Original Work with other software or hardware.

11) Jurisdiction, Venue and Governing Law. Any action or suit relating to this License may be brought only in the courts of a jurisdiction wherein the Licensor resides or in which Licensor conducts its primary business, and under the laws of that jurisdiction excluding its conflict-of-law provisions. The application of the United Nations Convention on Contracts for the International Sale of Goods is expressly excluded. Any use of the Original Work outside the scope of this License or after its termination shall be subject to the requirements and penalties of the U.S. Copyright Act, 17 U.S.C. § 101 et seq., the equivalent laws of other countries, and international treaty. This section shall survive the termination of this License.

12) Attorneys Fees. In any action to enforce the terms of this License or seeking damages relating thereto, the prevailing party shall be entitled to recover its costs and expenses, including, without limitation, reasonable attorneys' fees and costs incurred in connection with such action, including any appeal of such action. This section shall survive the termination of this License.

13) Miscellaneous. This License represents the complete agreement concerning the subject matter hereof. If any provision of this License is held to be unenforceable, such provision shall be reformed only to the extent necessary to make it enforceable.

14) Definition of "You" in This License. "You" throughout this License, whether in upper or lower case, means an individual or a legal entity exercising rights under, and complying with all of the terms of, this License. For legal entities, "You" includes any entity that controls, is controlled by, or is under common control with you. For purposes of this definition, "control" means (i) the power, direct or indirect, to cause the direction or management of such entity, whether by contract or otherwise, or (ii) ownership of fifty percent (50%) or more of the outstanding shares, or (iii) beneficial ownership of such entity.

15) Right to Use. You may use the Original Work in all ways not otherwise restricted or conditioned by this License or by law, and Licensor promises not to interfere with or be responsible for such uses by You.

This license is Copyright (C) 2003-2004 Lawrence E. Rosen. All rights reserved. Permission is hereby granted to copy and distribute this license without modification. This license may not be modified without the express written permission of its copyright owner.

# pyatom.py -- PyAtom library module

"""

PyAtom

Module to make it really easy to create Atom syndication feeds.

This module is Copyright (C) 2006 Steve R. Hastings.

Licensed under the Academic Free License version 2.1

You might want to start with the test cases at the end; see how they

work, and then go back and look at the code in the module.

I hope you find this useful!

Steve R. Hastings

Please send your questions or comments to this email address:

pyatom@langri.com

"""

import re

import sys

import time

s_pyatom_name = "PyAtom"

s_pyatom_ver = "0.3.9"

s_pyatom_name_ver = "%s version %s" % (s_pyatom_name, s_pyatom_ver)

# string constants

# These string values are used in more than one place.

s_version = "version"

s_encoding = "encoding"

s_standalone = "standalone"

s_href = "href"

s_lang = "xml:lang"

s_link = "link"

s_term = "term"

s_type = "type"

def set_s_indent(s):

	"""

	Set up the globals PyAtom uses to indent its output:

	s_indent, and s_indent_big

	s_indent is the string to indent one level; default is \\t.

	s_indent_big is s_indent concatenated many times.  PyAtom uses slice

	copies to get indent strings from s_indent_big.

	"""

	global s_indent

	global s_indent_big

	s_indent = s

	s_indent_big = s*256

set_s_indent("\t")

class TFC(object):

	"""

	class TFC: Tag Format Control.

	Controls how tags are converted to strings.

	Arguments to __init__():

		level	Specifies what indent level to start at for output.  Default 0.

		mode	Specifies how to format the output:

				mode_terse -- minimal output (no indenting)

				mode_normal -- default

				mode_verbose -- normal, plus some XML comments

	Normally, if an XML item has no data, nothing is printed, but with

	mode_verbose you may get a comment like "Collection with 0 entries".

	Methods:

		b_print_all()

			Return True if TFC set for full printing.

		b_print_terse()

			Return True if TFC set for terse printing.

		b_print_verbose()

			Return True if TFC set for verbose printing.

		indent_by(incr)

			Return a TFC instance that indents by incr columns.

		s_indent(extra_indent=0)

			Return an indent string.

	"""

	mode_terse, mode_normal, mode_verbose = range(3)

	def __init__(self, level=0, mode=mode_normal):

		"""

Arguments:

	level	Specifies what indent level to start at for output.  Default 0.

	mode	Specifies how to format the output:

			mode_terse -- minimal output (no indenting)

			mode_normal -- default

			mode_verbose -- normal, plus some XML comments

Normally, if an XML item has no data, nothing is printed, but with

mode_verbose you may get a comment like "Collection with 0 entries".

		"""

		self.level = level

		self.mode = mode

	def b_print_all(self):

		"""

		Return True if TFC set for full printing.

		Some optional things are usually suppressed, but will be printed

		if the current level is 0.  And everything gets printed when

		mode_verbose is set.

		"""

		return self.level == 0 or self.mode == TFC.mode_verbose

	def b_print_terse(self):

		"""

		Return True if TFC set for terse printing.

		"""

		return self.mode == TFC.mode_terse

	def b_print_verbose(self):

		"""

		Return True if TFC set for verbose printing.

		"""

		return self.mode == TFC.mode_verbose

	def indent_by(self, incr):

		"""

		Return a TFC instance that indents by incr columns.

		Pass this to a function that takes a TFC to get a temporary indent.

		"""

		return TFC(self.level + incr, self.mode)

	def s_indent(self, extra_indent=0):

		"""

		Return an indent string.

		Return a string of white space that indents correctly for the 

		current TFC settings.  If specified, extra_indent will be added

		to the current indent level.

		"""

		if self.mode == TFC.mode_terse:

			return ""

		level = self.level + extra_indent

		return s_indent_big[0:level]

pat_nbsp = re.compile(r' ')

def s_entities_to_ws(s):

	"""

	Return a copy of s with HTML whitespace entities replaced by a space.

	Currently just gets rid of HTML non-breaking spaces (" ").

	"""

	if not s:

		return s

	s = re.sub(pat_nbsp, " ", s)

	return s

def s_normalize_ws(s):

	"""

	Return a copy of string s with each run of whitespace replaced by one space.

	>>> s = "and    now\n\n\nfor \t  something\v   completely\r\n  different"

	>>> print s_normalize_ws(s)

	and now for something completely different

	>>>

	"""

	lst = s.split()

	s = " ".join(lst)

	return s

def s_escape_html(s):

	"""

	Return a copy of string s with HTML codes escaped.

	This is useful when you want HTML tags printed literally, rather than

	interpreted.

	>>> print s_escape_html("<head>")

	<head>

	>>> print s_escape_html(" ")

	 

	"""

	s = s.replace("&", "&")

	s = s.replace("<", "&lt;")

	s = s.replace(">", ">")

	return s

def s_create_atom_id(t, domain_name, uri=""):

	"""

	Create ID using Mark Pilgrim's algorithm.

	Algorithm taken from here:

	http://diveintomark.org/archives/2004/05/28/howto-atom-id

	"""

	# ymd (year-month-day) example: 2003-12-13

	ymd = time.strftime("%Y-%m-%d", t)

	if uri == "":

		# mush (all mushed together) example: 20031213083000

		mush = time.strftime("%Y%m%d%H%M%S", t)

		uri = "/weblog/" + mush

	# s = "tag:" + domain_name + "," + ymd + ":" + uri

	s = "tag:%s,%s:%s" % (domain_name, ymd, uri)

	s = s.replace("#", "/")

	return s

s_copyright_multiyear = "Copyright %s %d-%d by %s."

s_copyright_oneyear = "Copyright %s %d by %s."

def s_copyright(s_owner, s_csym="(C)", end_year=None, start_year=None):

	"""

	Return a string with a copyright notice.

	s_owner

		string with copyright owner's name.

	s_csym

		string with copyright symbol. (An HTML entity might be good here.)

	end_year

		last year of the copyright.  Default is the current year.

	start_year

		first year of the copyright.

	If only end_year is specified, only print one year; if both end_year and

	start_year are specified, print a range.

	To localize the entire copyright message into another language, change

	the global variables with the copyright template:

		s_copyright_multiyear: for a year range

		s_copyright_oneyear: for a single year

	"""

	if not end_year:

		end_year = time.localtime().tm_year

	if start_year:

		return s_copyright_multiyear % (s_csym, start_year, end_year, s_owner)

	return s_copyright_oneyear % (s_csym, end_year, s_owner)

# Here are all of the possible XML items.

#

# Supported by PyAtom:

# XML Declaration: <?xml ... ?>

# Comments: <!-- ... -->

# Elements: <tag_name>...</tag_name>

#

# Minimal support:

# Markup Declarations: <!KEYWORD ... >

# Processing Instructions (PIs): <?KEYWORD ... ?>

#

# Not currently supported:

# INCLUDE and IGNORE directives: <!KEYWORD[ ... ]]>

# CDATA sections: <![CDATA[ ... ]]>

#

class XMLItem(object):

	"""

	All PyAtom classes inherit from this class.  All it does is provide a

	few default methods, and be a root for the inheritance tree.

	An XMLItem has several methods that return an XML tag representation of

	its contents.  Each XMLItem knows how to make a tag for itself.  An

	XMLItem that contains other XMLItems will ask each one to make a tag;

	so asking the top-level XMLItem for a tag will cause the entire tree

	of XMLItems to recursively make tags, and you get a full XML

	representation with tags appropriately nested and indented.

	"""

	def _s_tag(self, tfc):

		"""

		A stub which must always be overridden by child classes.

		"""

		assert False, "XMLItem instance is too abstract to print."

	def s_tag(self, level):

		"""

		Return the item as a string containing an XML tag declaration.

		The XML tag will be indented.

		Will return an empty string if the item is empty.

		"""

		tfc = TFC(level, TFC.mode_normal)

		return self._s_tag(tfc)

	def s_tag_verbose(self, level):

		"""

		Return the item as a string containing an XML tag declaration.

		The XML tag will be indented.

		May return an XML Comment if the item is empty.

		"""

		tfc = TFC(level, TFC.mode_verbose)

		return self._s_tag(tfc)

	def s_tag_terse(self, level):

		"""

		Return the item as a string containing an XML tag declaration.

		The XML tag will not be indented.

		Will return an empty string if the item is empty.

		"""

		tfc = TFC(level, TFC.mode_terse)

		return self._s_tag(tfc)

	def __str__(self):

		return self.s_tag(0)

	def level(self):

		"""

		Return an integer describing what level this tag is.

		The root tag of an XML document is level 0; document-level comments

		or other document-level declarations are also level 0.  Tags nested

		inside the root tag are level 1, tags nested inside those tags are

		level 2, and so on.

		This is currently only used by the s_tree() functions.  When

		printing tags normally, the code that walks the tree keeps track of

		what level is current.

		"""

		level = 0

		while self._parent != None:

			self = self._parent

			if self.is_element():

				level += 1

		return level

	def s_name(self):

		"""

		Return a name for the current item.

		Used only by the s_tree() functions.

		"""

		if self._name:

			return self._name

		return "unnamed_instance_of_" + type(self).__name__

	def s_tree(self):

		"""

		Return a verbose tree showing the current tag and its children.

		This is for debugging; it's not valid XML syntax.

		"""

		level = self.level()

		return "%2d) %s\t%s" % (level, self.s_name(), str(self))

class DocItem(XMLItem):

	"""

	A document-level XML item (appearing above root element).

	Items that can be document-level inherit from this class.

	"""

	pass

class ElementItem(XMLItem):

	"""

	An item that may be nested inside an element.

	Items that can be nested inside other elements inherit from this class.

	"""

	pass

class Comment(DocItem,ElementItem):

	"""

	An XML comment.

	Attributes:

		text

			set the text of the comment

	"""

	def __init__(self, text=""):

		"""

		text: set the text of the comment

		"""

		self._parent = None

		self._name = ""

		self.tag_name = "comment"

		self.text = text

	def _s_tag(self, tfc):

		if not self:

			if tfc.b_print_all():

				return tfc.s_indent() + "<!-- -->"

			else:

				return ""

		else:

			if self.text.find("\n") >= 0:

				lst = []

				lst.append(tfc.s_indent() + "<!--")

				lst.append(self.text)

				lst.append(tfc.s_indent() + "-->")

				return "\n".join(lst)

			else:

				s = "%s%s%s%s" % (tfc.s_indent(), "<!-- ", self.text, " -->")

				return s

		assert False, "not possible to reach this line."

	def __nonzero__(self):

		# Returns True if there is any comment text.

		# Returns False otherwise.

		return not not self.text

	def is_element(self):

		return True

# REVIEW: can a PI be an ElementItem?

class PI(DocItem):

	"""

	XML Processing Instruction (PI).

	Attributes:

		keyword

		text

	"""

	def __init__(self):

		self._parent = None

		self._name = ""

		self.keyword = ""

		self.text = ""

	def _s_tag(self, tfc):

		if not self:

			return ""

		else:

			if self.text.find("\n") >= 0:

				lst = []

				lst.append("%s%s%s" % (tfc.s_indent(), "<?", self.keyword))

				lst.append(self.text)

				lst.append("%s%s" % (tfc.s_indent(), "?>"))

				return "\n".join(lst)

			else:

				s = "%s%s%s %s%s"% \

						(tfc.s_indent(), "<?", self.keyword, self.text, "?>")

				return s

		assert False, "not possible to reach this line."

	def __nonzero__(self):

		# Returns True if there is any keyword.

		# Returns False otherwise.

		return not not self.keyword

# REVIEW: can a MarkupDecl be an ElementItem?

class MarkupDecl(DocItem):

	"""

	XML Markup Declaration.

	Attributes:

		keyword

		text

	"""

	def __init__(self):

		self._parent = None

		self._name = ""

		self.keyword = ""

		self.text = ""

	def _s_tag(self, tfc):

		if not self:

			return ""

		else:

			if self.text.find("\n") >= 0:

				lst = []

				lst.append("%s%s%s" % (tfc.s_indent(), "<!", self.keyword))

				lst.append(self.text)

				lst.append("%s%s" % (tfc.s_indent(), ">"))

				return "\n".join(lst)

			else:

				s = "%s%s%s %s%s" % \

						(tfc.s_indent(), "<!", self.keyword, self.text, ">")

				return s

		assert False, "not possible to reach this line."

	def __nonzero__(self):

		# Returns True if there is any keyword.

		# Returns False otherwise.

		return not not self.keyword

class CoreElement(ElementItem):

	"""

	This is an abstract class.

	All of the XML element classes inherit from this.

	"""

	def __init__(self, tag_name, def_attr, def_attr_value, attr_names = []):

		# dictionary of attributes and their values

		self.lock = False

		self._parent = None

		self._name = ""

		self.tag_name = tag_name

		self.def_attr = def_attr

		self.attrs = {}

		if def_attr and def_attr_value:

			self.attrs[def_attr] = def_attr_value

		self.attr_names = attr_names

		self.lock = True

	def __nonzero__(self):

		# Returns True if any attrs are set or there are any contents.

		# Returns False otherwise.

		return not not self.attrs or self.has_contents()

	def text_check(self):

		"""

		Raise an exception, unless element has text contents.

		Child classes that have text must override this to do nothing.

		"""

		raise TypeError, "element does not have text contents"

	def nest_check(self):

		"""

		Raise an exception, unless element can nest other elements.

		Child classes that can nest must override this to do nothing.

		"""

		raise TypeError, "element cannot nest other elements"

	def __delattr__(self, name):

		# REVIEW: this should be made to work!

		raise TypeError, "cannot delete elements"

	def __getattr__(self, name):

		if name == "lock":

			# If the "lock" hasn't been created yet, we always want it

			# to be False, i.e. we are not locked.

			return False

		else:

			raise AttributeError, name

	def __setattr__(self, name, value):

		# Here's how this works:

		#

		# 0) "self.lock" is a boolean, set to False during __init__()

		# but turned True afterwards.  When it's False, you can add new

		# members to the class instance without any sort of checks; once

		# it's set True, __setattr__() starts checking assignments.

		# By default, when lock is True, you cannot add a new member to

		# the class instance, and any assignment to an old member has to

		# be of matching type.  So if you say "a.text = string", the

		# .text member has to exist and be a string member.

		#

		# This is the default __setattr__() for all element types.  It

		# gets overloaded by the __setattr__() in NestElement, because

		# for nested elments, it makes sense to be able to add new

		# elements nested inside.

		#

		# This is moderately nice.  But later in NestElement there is a

		# version of __setattr__() that is *very* nice; check it out.

		#

		# 1) This checks assignments to _parent, and makes sure they are

		# plausible (either an XMLItem, or None).

		try:

			lock = self.lock

		except AttributeError:

			lock = False

		if not lock:

			self.__dict__[name] = value

			return

		dict = self.__dict__

		if not name in dict:

			# brand-new item

			if lock:

				raise TypeError, "element cannot nest other elements"

		if name == "_parent":

			if not (isinstance(value, XMLItem) or value is None):

				raise TypeError, "only XMLItem or None is permitted"

			self.__dict__[name] = value

			return

		# locked item so do checks

		if not type(self.__dict__[name]) is type(value):

			raise TypeError, "value is not the same type"

		self.__dict__[name] = value

	def has_contents(self):

		return False

	def multiline_contents(self):

		return False

	def s_contents(self, tfc):

		assert False, "CoreElement is an abstract class; it has no contents."

	def _s_start_tag_name_attrs(self, tfc):

		"""

		Return a string with the start tag name, and any attributes.

		Wrap this in correct punctuation to get a start tag.

		"""

		def attr_newline(tfc):

			if tfc.b_print_terse():

				return " "

			else:

				return "\n" + tfc.s_indent(2)

		lst = []

		lst.append(self.tag_name)

		if len(self.attrs) == 1:

			# just one attr so do on one line

			attr = self.attrs.keys()[0]

			s_attr = '%s="%s"' % (attr, self.attrs[attr])

			lst.append(" " + s_attr)

		elif len(self.attrs) > 1:

			# more than one attr so do a nice nested tag

			# 0) show all attrs in the order of attr_names

			for attr in self.attr_names:

				if attr in self.attrs.keys():

					s_attr = '%s="%s"' % (attr, self.attrs[attr])

					lst.append(attr_newline(tfc) + s_attr)

			# 1) any attrs not in attr_names?  list them, too

			for attr in self.attrs:

				if not attr in self.attr_names:

					s_attr = '%s="%s"' % (attr, self.attrs[attr])

					lst.append(attr_newline(tfc) + s_attr)

		return "".join(lst)

	def _s_tag(self, tfc):

		if not self:

			if not tfc.b_print_all():

				return ""