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

from quixote import get_publisher, redirect, get_request

from quixote.directory import Directory, AccessControlled

from quixote.html import TemplateIO, htmltext

from qommon import get_cfg, get_logger

from qommon.form import Form, StringWidget, CheckboxWidget, SingleSelectWidget

from qommon.backoffice.menu import html_top

from quixote.html import htmltext

from payments import Regie

# constants

ABELIUM_DOMINO = 'abelium_domino'

ACTIVATED = 'activated'

WSDL_URL = 'wsdl_url'

SERVICE_URL = 'service_url'

DOMAIN = 'domain'

LOGIN = 'login'

PASSWORD = 'password'

INVOICE_REGIE = 'invoice_regie'

try:

    import abelium_domino_ws

except ImportError, e:

    abelium_domino_ws = None

    import_error = e

def get_abelium_cfg(publisher):

    if not publisher:

        publisher = get_publisher()

    return publisher.cfg.get(ABELIUM_DOMINO, {})

def is_activated(publisher=None):

    cfg = get_abelium_cfg(publisher)

    return cfg.get(ACTIVATED, False) and abelium_domino_ws is not None

def get_client(publisher=None):

    publisher = publisher or get_publisher()

    cfg = get_abelium_cfg(publisher)

    try:

        publisher._ws_cache = abelium_domino_ws.DominoWs(

            url=cfg.get(WSDL_URL, ''),

            domain=cfg.get(DOMAIN,''),

            login=cfg.get(LOGIN, ''),

            password=cfg.get(PASSWORD, ''),

            location=cfg.get(SERVICE_URL),

            logger=get_logger())

    except IOError:

        return None

    return publisher._ws_cache

def get_family(user, publisher=None):

    family = None

    if user is None:

        return None

    client = get_client(publisher)

    if not client:

        return None

    if hasattr(user, 'abelium_domino_code_famille'):

        family = client.get_family_by_code_interne(

            user.abelium_domino_code_famille)

    if family is None and user.email:

        family = client.get_family_by_mail(user.email)

    return family

def get_invoice_regie(publisher=None):

    cfg = get_abelium_cfg(publisher)

    regie_id = cfg.get(INVOICE_REGIE)

    if not regie_id:

        return None

    return Regie.get(regie_id, ignore_errors=True)

class AbeliumDominoDirectory(Directory):

    _q_exports = [ '' , 'debug' ]

    label = N_('Domino')

    def debug(self):

        from abelium_domino_vars import SESSION_CACHE

        html_top(ABELIUM_DOMINO)

        r = TemplateIO(html=True)

        r += htmltext('<form method="post"><button>Lancer le cron</button></form>')

        if get_request().get_method() == 'POST':

            try:

                from abelium_domino_synchro import synchronize_domino

                synchronize_domino(get_publisher())

            except Exception, e:

                r += htmltext('<pre>%s</pre>') % repr(e)

        r += htmltext('<p>code interne: %s</p>') % getattr(get_request().user, str('abelium_domino_code_famille'), None)

        r += htmltext('<dl>')

        context = get_publisher().substitutions.get_context_variables()

        for var in sorted(context.keys()):

            value = context[var]

            if value:

                r += htmltext('<dt>%s</dt>') % var

                r += htmltext('<dd>%s</dt>') % value

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

        delattr(get_request().session, SESSION_CACHE)

    def _q_index(self):

        publisher = get_publisher()

        cfg = get_cfg(ABELIUM_DOMINO, {})

        form = self.form(cfg)

        title = _('Abelium Domino')

        html_top(ABELIUM_DOMINO, title = title)

        r = TemplateIO(html=True)

        r += htmltext('<h2>%s</h2>') % title

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

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

                return redirect('..')

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

                for name in [f[0] for f in self.form_desc] + [INVOICE_REGIE]:

                    widget = form.get_widget(name)

                    if widget:

                        cfg[name] = widget.parse()

                publisher.cfg[ABELIUM_DOMINO] = cfg

                publisher.write_cfg()

                return redirect('.')

        if abelium_domino_ws:

            r += form.render()

        else:

            message = _('The Abelium Domino module is not '

                    'activated because of this error when '

                    'loading it: %r') % import_error

            r += htmltext('<p class="errornotice">%s</p>') % message

        r += htmltext('<dl style="display: none">')

        context = get_publisher().substitutions.get_context_variables()

        for var in sorted(context.keys()):

            value = context[var]

            if value:

                r += htmltext('<dt>%s</dt>') % var

                r += htmltext('<dd>%s</dt>') % value

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

        return r.getvalue()

    form_desc = (

            # name, required, title, kind

            (ACTIVATED, False, _('Activated'), bool),

            (WSDL_URL, True, _('WSDL URL'), str),

            (SERVICE_URL, False, _('Service URL'), str),

            (DOMAIN, True, _('Domain'), str),

            (LOGIN, True, _('Login'), str),

            (PASSWORD, True, _('Password'), str),

    )

    def form(self, initial_value={}):

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

        kinds = { str: StringWidget, bool: CheckboxWidget }

        for name, required, title, kind in self.form_desc:

            widget = kinds[kind]

            form.add(widget, name, required=required, title=title,

                    value=initial_value.get(name, ''))

        options = [(regie.id, regie.label) \

                        for regie in Regie.values()]

        options.insert(0, (None, _('None')))

        form.add(SingleSelectWidget, INVOICE_REGIE,

                title=_('Regie which will receive payments'),

                value=initial_value.get(INVOICE_REGIE),

                options=options)

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

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

        return form