source: main/waeup.ikoba/branches/uli-payments/src/waeup/ikoba/browser/async.py @ 12696

import grok
from zc.async.interfaces import COMPLETED, NEW
from zope.interface import Interface
from waeup.ikoba.async import IJob, IJobManager
from waeup.ikoba.browser.layout import IkobaPage
from waeup.ikoba.interfaces import IIkobaObject, IDataCenter
from waeup.ikoba.interfaces import MessageFactory as _

grok.templatedir('templates')
grok.context(IIkobaObject)

loadingbar_template = '''
<input id="status_url" type="hidden" name="status_url" value="%s" />
<div id="loadbar">%%s</div>
'''

class LoadingBar(grok.ViewletManager):
    grok.name('loadingbar')

class LoadingBarViewlet(grok.Viewlet):
    grok.context(Interface)
    grok.viewletmanager(LoadingBar)

    _running_exports = None

    def getRunningExports(self):
        """Returns running exports as list of tuples.

        Only exports triggered by the current user (identified by
        principal.id) are returned.

        Each tuple has the form (<STATUS>, <STATUS_TITLE>, <EXPORTER_NAME>).

        ``STATUS``:
           the status as machine readable string (something like
           ``'completed'``)

        ``STATUS_TITLE``:
           status of export as translated string.

        ``EXPORTER_NAME``:
           string representing the exporter title used when triggering
           the export job.
        """
        result = self.context.get_export_jobs_status(self.user_id)
        return result

    def update(self):
        self.user_id = self.request.principal.id
        self.exports = self.getRunningExports()
        self.uncompleted = [x for x in self.exports if x[0] != 'completed']

    def render(self):
        status_url = self.view.url('status')
        template = loadingbar_template % (status_url,)
        content = ''
        return template % content

class DataCenterJSON(grok.JSON):
    grok.context(IDataCenter)

    def status(self):
        """Get status of currently handled export jobs for users.

        The result is a set of valus useful for JavaScript handlers to
        update some page handling data center exports.

        Returns a mapping::

          {html=<string>, interval=<int>, reload=<bool>}

        where `html` is some HTML code that might be shown in a
        loading bar section.

        `interval` is the time in microseconds after which the loading
        bar should be reloaded (by a new JSON call). If the value is
        zero, then the loading bar should not be renewed and further
        JSON calls be canceled.

        `reload` is a hint to tell, whether the complete page should
        be reloaded or not. Reloading is neccessary, if the export
        file creation finished and download buttons or similar should
        appear.
        """
        user_id = self.request.principal.id
        jobs = self.context.get_export_jobs_status(user_id)
        uncompleted = [x for x in jobs if x[0] != 'completed']
        result = dict(
            html='', interval=0, reload=False)
        if len(uncompleted):
            html = '<em>%s</em>' % (_("Please wait..."),)
            result.update(interval=500, html=html)
        else:
            if len(jobs):
                result.update(reload=True)
        return result


class JobManagerView(IkobaPage):
    """The main view for the job container.
    """
    grok.name('index.html')
    grok.context(IJobManager)
    grok.template('virtjobscontainerindex')
    grok.require('waeup.manageJobs')

    def jobs(self):
        for job_id, job in sorted(self.context.jobs(),
                                  cmp=lambda x, y: cmp(int(x[0]), int(y[0]))):
            link = self.url(self.context, job_id)
            removable = job.status in (COMPLETED, NEW)
            yield dict(
                job_id = job_id,
                job = job,
                link = link,
                status = job.status,
                begin_after = job.begin_after,
                begin_by = job.begin_by,
                annotations = '%r' % [
                    (x, y) for x, y in job.annotations.items()],
                removable = removable,
                failure = '%r' % getattr(job, 'traceback', None),
                )

    def update(self, START_NEW=None, REMOVE=None, job_id=None):
        if REMOVE and job_id:
            self.context.remove(job_id)
            self.flash('Removed job "%s"' % job_id)
        if START_NEW:
            self.context.start_test_job()                    #pragma NO COVER
            self.flash('Started new test job "%s"' % job_id) #pragma NO COVER
        return

class JobView(grok.View):
    grok.name('index.html')
    grok.context(IJob)
    grok.template('jobindex')
    grok.require('waeup.manageJobs')

    def percent(self):
        value = self.context.annotations.get('percent', None)
        if not value:
            return
        value = int(value+0.5)
        return min(value, 100)

    def update(self):
        pass