Produits Entr'ouvert » w.c.s.

    d.user_id = local_user.id

    d.receipt_time = time.localtime()

    evo = Evolution()

    evo.time = time.localtime()

    evo.status = 'wf-%s' % st_new.id

    evo.who = '_submitter'

    d.evolution = [evo]

    d.store()

    evo.add_part(JournalWsCallErrorPart("summary", "label", "data"))

    evo = Evolution()

    evo.time = time.localtime()

    evo.status = 'wf-%s' % st_finished.id

    evo.who = '_submitter'

    d.evolution.append(evo)

    d.store()

    export = d.get_json_export_dict(anonymise=True)

    assert 'evolution' in export

    assert len(export['evolution']) == 2

    assert export['evolution'][0]['status'] == st_new.id

    assert 'time' in export['evolution'][0]

    assert 'who' not in export['evolution'][0]

    assert 'parts' in export['evolution'][0]

    assert len(export['evolution'][0]['parts']) == 2

    assert export['evolution'][0]['parts'][0]['type'] == 'workflow-comment'

    assert len(export['evolution'][0]['parts'][1]) == 1

    assert export['evolution'][0]['parts'][1]['type'] == 'wscall-error'

    assert export['evolution'][1]['status'] == st_finished.id

    assert 'time' in export['evolution'][1]

    assert 'who' not in export['evolution'][0]

    assert 'parts' not in export['evolution'][1]

        assert len(os.listdir(os.path.join(get_publisher().app_dir, 'attachments', subdir))) == 1

    assert len(formdata.evolution[-1].parts) == 2

    assert isinstance(formdata.evolution[-1].parts[0], AttachmentEvolutionPart)

    assert formdata.evolution[-1].parts[0].orig_filename == upload.orig_filename

    assert isinstance(formdata.evolution[-1].parts[1], JournalEvolutionPart)

    assert len(formdata.evolution[-1].parts[1].content) > 0

    assert comment_view == '<p>%s</p>' % comment_text

    if os.path.exists(os.path.join(get_publisher().app_dir, 'attachments')):

        shutil.rmtree(os.path.join(get_publisher().app_dir, 'attachments'))

    formdata.evolution[-1].parts = []

    formdata.store()

        assert len(os.listdir(os.path.join(get_publisher().app_dir, 'attachments', subdir))) == 1

    assert len(formdata.evolution[-1].parts) == 2

    assert isinstance(formdata.evolution[-1].parts[0], AttachmentEvolutionPart)

    assert formdata.evolution[-1].parts[0].orig_filename == 'hello.txt'

    assert isinstance(formdata.evolution[-1].parts[1], JournalEvolutionPart)

    assert len(formdata.evolution[-1].parts[1].content) > 0

    assert comment_view == '<p>%s</p>' % comment_text

def test_email(pub, emails):

    pub.substitutions.feed(MockSubstitutionVariables())

    formdef = FormDef()

    formdef.name = 'baz'

    formdef.fields = []

    formdef.store()

    formdata.workflow_data = None

    item = WebserviceCallStatusItem()

    item.url = 'http://remote.example.net/400-json'

    item.record_errors = True

    item.action_on_4xx = ':stop'

    with pytest.raises(AbortActionException):

        item.perform(formdata)

    assert not rendered # empty if not in backoffice

    req = HTTPRequest(None, {'SERVER_NAME': 'example.net', 'SCRIPT_NAME': '/backoffice/'})

    pub._set_request(req)

    assert 'Error during webservice call' in str(rendered)

    assert 'Error Code: 1' in str(rendered)

    assert 'Error Description: :(' in str(rendered)

    item.label = 'do that'

    with pytest.raises(AbortActionException):

        item.perform(formdata)

    assert 'Error during webservice call "do that"' in str(rendered)

    item = WebserviceCallStatusItem()

    item.method = 'GET'

    item.url = 'http://remote.example.net?in_url=1'

    item.qs_data = {

        'str': 'abcd',

        'one': '=1',

        if not self.parts:

            return []

        l = []

        for p in self.parts:

            if not hasattr(p, 'view'):

                continue

            if text:

                l.append(text)

        self._display_parts = l

        return self._display_parts

    def get_json_export_dict(self, user, anonymise=False):

        data = {

            'time': datetime.datetime(*self.time[:6]) if self.time else None,

                elif type(value) in (tuple, list):

                    fts_strings.extend(value)

        if self._evolution:

            for evo in self._evolution:

                if evo.comment:

                    fts_strings.append(evo.comment)

                for part in evo.parts or []:

                    if hasattr(part, 'view'):

                        if html_part:

                            fts_strings.append(qommon.misc.html2text(html_part))

        user = self.get_user()

        if user:

            fts_strings.append(user.get_display_name())

        sql_statement = '''UPDATE %s SET fts = to_tsvector( %%(fts)s)

                            WHERE id = %%(id)s''' % self._table_name

        d = {}

        for part in formdata.iter_evolution_parts():

            if not isinstance(part, cls):

                continue

            if part.formdata:

                d['form_links_%s' % (part.varname or '*')] = part

        return d

        if self.attach_to_history:

            return htmltext('<p class="wf-links">%s <a href="%s">%s %s</a>') % (

                _('Created new form'),

                self.formdata and self.formdata.get_url(

                    backoffice=bool(get_request() and get_request().is_in_backoffice())),

                self.formdef.name if self.formdef else _('Deleted'),

                self.formdata_id)

        else:

# This program is distributed in the hope that it will be useful,

# but WITHOUT ANY WARRANTY; without even the implied warranty of

# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the

# GNU General Public License for more details.

#

# You should have received a copy of the GNU General Public License

# along with this program; if not, see <http://www.gnu.org/licenses/>.

from ..qommon import _, N_, ezt

from ..qommon.form import *

from ..qommon.template import TemplateError

from ..qommon import get_logger

from wcs.workflows import (WorkflowStatusItem, register_item_class, template_on_formdata,

import sys

class JournalEvolutionPart: #pylint: disable=C1001

    content = None

        if not message:

            return

        if '{{' in message or '{%' in message:

            # django template

            content = template_on_formdata(formdata, message)

            if content and not content.startswith('<'):

                # add <div> to mark the string as processed as HTML

                content = '<div>%s</div>' % content

            self.content = content

            return

            # treat it as html, escape strings from ezt variables

            self.content = template_on_formdata(formdata, message,

                    ezt_format=ezt.FORMAT_HTML)

            return

        # treat is as text/plain

        self.content = template_on_formdata(formdata, message)

            return ''

        if self.content.startswith('<'):

            return htmltext(self.content)

        else:

            # use empty lines to mark paragraphs

            return htmltext('<p>') + \

                   htmltext('\n').join(

                            [(x or htmltext('</p><p>')) for x in self.content.splitlines()]) + \

                   htmltext('</p>')

    def get_json_export_dict(self, anonymise=False):

        d = {

            'type': 'workflow-comment',

        }

        if not anonymise:

            d['content'] = self.content

        return d

class RegisterCommenterWorkflowStatusItem(WorkflowStatusItem):

    description = N_('History Message')

    key = 'register-comment'

    category = 'interaction'

    comment = None

    attachments = None

    def add_parameters_widgets(self, form, parameters, prefix='', formdef=None):

        super(RegisterCommenterWorkflowStatusItem, self).add_parameters_widgets(

                form, parameters, prefix=prefix, formdef=formdef)

        if 'comment' in parameters:

            form.add(TextWidget, '%scomment' % prefix, title=_('Message'),

                value=self.comment, cols=80, rows=10)

    def get_parameters(self):

    def attach_uploads_to_formdata(self, formdata, uploads):

        if not formdata.evolution[-1].parts:

            formdata.evolution[-1].parts = []

        for upload in uploads:

            try:

                # useless but required to restore upload.fp from serialized state,

                # needed by AttachmentEvolutionPart.from_upload()

        # (with substitution vars)

        if self.attachments:

            uploads = self.convert_attachments_to_uploads()

            self.attach_uploads_to_formdata(formdata, uploads)

            formdata.store()  # store and invalidate cache, so references can be used in the comment message.

        # the comment can use attachments done above

        try:

            formdata.store()

        except TemplateError as e:

            url = formdata.get_url()

            get_logger().error('error in template for comment [%s], '

                               'comment could not be generated: %s' % (url, str(e)))

register_item_class(RegisterCommenterWorkflowStatusItem)

    label = None

    def __init__(self, summary, label=None, data=None):

        self.summary = summary

        self.label = label

        if data:

            self.data = data[:10000] # beware of huge responses

        if not (get_request() and get_request().get_path().startswith('/backoffice/')):

            return ''

        r = TemplateIO(html=True)

        r += htmltext('<div class="ws-error">')

        r += htmltext('<h4 class="foldable folded">')

        if self.label:

            r += _('Error during webservice call "%s"') % self.label

        else:

            if not os.path.exists(dirname):

                os.mkdir(dirname)

            odict['filename'] = os.path.join(dirname, filename)

            self.filename = odict['filename']

            self.fp.seek(0)

            atomic_write(self.filename, self.fp)

        return odict

        show_link = True

        if self.has_redirect_url():

            is_in_backoffice = bool(get_request() and get_request().is_in_backoffice())

            show_link = bool(self.get_redirect_url(backoffice=is_in_backoffice))

        if show_link:

            return htmltext('<p class="wf-attachment"><a href="attachment?f=%s">%s</a></p>' % (

                        os.path.basename(self.filename), self.orig_filename))

        else: