0001-wf-add-action-to-add-card-39997.patch

     from wcs.wf.register_comment import RegisterCommenterWorkflowStatusItem
     from wcs.wf.resubmit import ResubmitWorkflowStatusItem
     from wcs.wf.create_formdata import CreateFormdataWorkflowStatusItem, Mapping
     from wcs.wf.cards import CardAddWorkflowStatusItem
     from wcs.carddef import CardDef
     from wcs.categories import Category
     from wcs.formdef import FormDef
-...
         pq = resp.pyquery.remove_namespaces()
         assert pq('.field-type-string .value').text() == 'coucou'
         assert pq('.field-type-file .value').text() == 'bar'
     def test_backoffice_create_carddata_from_formdata(pub, studio):
         CardDef.wipe()
         FormDef.wipe()
         user = create_user(pub, is_admin=True)
         user.name = 'Foo Bar'
         user.email = 'foo@example.com'
         user.store()
         carddef = CardDef()
         carddef.name = 'My card'
         carddef.fields = [
             fields.StringField(id='1', label='string'),
             fields.ItemField(id='2', label='List', items=['item1', 'item2']),
             fields.DateField(id='3', label='Date')
+        ]
         carddef.store()
         wf = Workflow(name='create-carddata')
         st1 = wf.add_status('New')
         st2 = wf.add_status('Create card')
         jump = ChoiceWorkflowStatusItem()
         jump.id = '_createcard'
         jump.label = 'Create card'
         jump.by = ['_receiver']
         jump.status = st2.id
         jump.parent = st1
         st1.items.append(jump)
         create_card = CardAddWorkflowStatusItem()
         create_card.label = 'Create Card Data'
         create_card.varname = 'mycard'
         create_card.id = '_create'
         create_card.formdef_slug = carddef.url_name
         create_card.mappings = [
             Mapping(field_id='1', expression='Simple String'),
             Mapping(field_id='2', expression='{{ form_var_list_raw }}'),
             Mapping(field_id='3', expression='{{ form_var_date }}'),
+        ]
         create_card.parent = st2
         st2.items.append(create_card)
         display_message = DisplayMessageWorkflowStatusItem()
         display_message.message = 'Card nr. {{ form_cards_mycard_form_number }} created'
         display_message.parent = st2
         st2.items.append(display_message)
         wf.store()
         formdef = FormDef()
         formdef.name = 'Source form'
         formdef.workflow_roles = {'_receiver': 1}
         formdef.fields = [
             fields.ItemField(id='1', label='List', items=['item1', 'item2'],
                              varname='list'),
             fields.DateField(id='2', label='Date', varname='date')
+        ]
         formdef.workflow_id = wf.id
         formdef.store()
         formdata = formdef.data_class()()
         today = time.strptime('2020-01-01', '%Y-%m-%d')
         formdata.data = {
             '1': 'item2',
             '2': today
+        }
         formdata.user = user
         formdata.just_created()
         formdata.store()
         formdata.perform_workflow()
         app = login(get_app(pub))
         resp = app.get(formdata.get_url(backoffice=True))
         resp = resp.form.submit(name='button_createcard').follow()
         assert 'Card nr. 1-1 created' in resp

     from wcs.qommon.form import *
     from wcs.formdef import FormDef
     from wcs.carddef import CardDef
     from wcs import sessions
     from wcs.fields import (StringField, DateField, MapField, FileField, ItemField,
             ItemsField, CommentField)
-...
     from wcs.wf.redirect_to_url import RedirectToUrlWorkflowStatusItem
     from wcs.wf.notification import SendNotificationWorkflowStatusItem
     from wcs.wf.create_formdata import CreateFormdataWorkflowStatusItem, Mapping
     from wcs.wf.cards import CardAddWorkflowStatusItem
     from utilities import (create_temporary_pub, MockSubstitutionVariables,
-...
         assert len(errors) == 2
         assert any('form_var_toto_string' in (error.exception_message or '') for error in errors)
         assert any('Missing field' in error.summary for error in errors)
     def test_create_carddata(pub):
         CardDef.wipe()
         FormDef.wipe()
         LoggedError.wipe()
         carddef = CardDef()
         carddef.name = 'My card'
         carddef.fields = [
             StringField(id='1', label='string'),
             ItemField(id='2', label='List', items=['item1', 'item2'],
                       varname='clist'),
             DateField(id='3', label='Date', varname='cdate')
+        ]
         carddef.store()
         wf = Workflow(name='create-carddata')
         wf.possible_status = Workflow.get_default_workflow().possible_status[:]
         create = CardAddWorkflowStatusItem()
         create.label = 'Create CardDef'
         create.varname = 'mycard'
         create.id = '_create'
         create.formdef_slug = carddef.url_name
         create.mappings = [
             Mapping(field_id='1', expression='=form_var_undefined'),
             Mapping(field_id='2', expression='{{ form_var_list }}'),
             Mapping(field_id='3', expression='{{ form_var_date }}'),
+        ]
         create.parent = wf.possible_status[1]
         wf.possible_status[1].items.insert(0, create)
         wf.store()
         formdef = FormDef()
         formdef.name = 'source form'
         formdef.fields = [
             ItemField(id='1', label='List', items=['item1', 'item2'],
                       varname='list'),
             DateField(id='2', label='Date', varname='date')
+        ]
         formdef.workflow_id = wf.id
         formdef.store()
         formdata = formdef.data_class()()
         formdata.data = {}
         formdata.just_created()
         assert carddef.data_class().count() == 0
         formdata = formdef.data_class()()
         formdata.data = {}
         formdata.just_created()
         formdata.perform_workflow()
         assert carddef.data_class().count() == 1
         errors = LoggedError.select()
         assert len(errors) == 2
         assert any('form_var_undefined' in (error.exception_message or '') for error in errors)
         assert any('invalid date value' in (error.exception_message or '') for error in errors)
         formdata = formdef.data_class()()
         today = datetime.date.today()
         formdata.data = {'1': 'item1',
                          '1_display': 'item1',
                          '2': today}
         formdata.just_created()
         formdata.perform_workflow()
         assert formdata.get_substitution_variables()['form_cards_mycard_form_number'] == '1-2'
         carddata = carddef.data_class().get(id=2)
         assert carddata.get_substitution_variables()['form_var_cdate'] == today
         print(carddata.get_substitution_variables()['form_var_clist'])
         assert carddata.get_substitution_variables()['form_var_clist'] == 'item1'

             return LazyFormDataLinks(self._formdata)
         @property
         def cards(self):
             from .wf.cards import LazyCardDataLinks
             return LazyCardDataLinks(self._formdata)
         def export_to_json(self, include_files=True):
             # this gets used to generate an email attachment :/
             return self._formdata.export_to_json(include_files=include_files)

     # w.c.s. - web application for online forms
     # Copyright (C) 2005-2020  Entr'ouvert
+    #
     # This program is free software; you can redistribute it and/or modify
     # it under the terms of the GNU General Public License as published by
     # the Free Software Foundation; either version 2 of the License, or
     # (at your option) any later version.
+    #
     # 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 quixote import get_publisher
     from ..qommon import _
     from wcs.workflows import register_item_class
     from wcs.carddef import CardDef
     from wcs.wf.create_formdata import (CreateFormdataWorkflowStatusItem,
                                         LinkedFormdataEvolutionPart,
                                         LazyFormDataLinks)
     class LinkedCardDataEvolutionPart(LinkedFormdataEvolutionPart):
         formdef_class = CardDef
         form_property_name = 'cards'
     class LazyCardDataLinks(LazyFormDataLinks):
         evolution_part_class = LinkedCardDataEvolutionPart
     class CardManagement(object):
         @classmethod
         def is_available(cls, workflow=None):
             return get_publisher().has_site_option('studio')
     class CardAddWorkflowStatusItem(CardManagement, CreateFormdataWorkflowStatusItem):
         description = N_('Add Card')
         key = 'add-card'
         category = 'formdata-action'
         ok_in_global_action = True
         formdef_class = CardDef
         evolution_part_class = LinkedCardDataEvolutionPart
         formdef_label = N_('Card')
         mappings_label = N_('Mappings to card fields')
         varname_hint = N_('Used to get linked card in expressions.')
         def get_parameters(self):
             return ('formdef_slug', 'mappings', 'keep_user', 'varname')
     register_item_class(CardAddWorkflowStatusItem)

     class LinkedFormdataEvolutionPart(object):
         formdef_class = FormDef
         form_property_name = 'links'
         def __init__(self, formdata, varname=None):
             self._formdef = formdata.formdef
-...
             return {k: v for k, v in self.__dict__.items() if not k.startswith('_')}
         def __repr__(self):
             return '<Link "%s-%s">' % (self.formdef_id, self.formdata_id)
             return '<Linked %s "%s-%s">' % (self.formdef_class.__name__,
                                             self.formdef_id, self.formdata_id)
         @classmethod
         def get_substitution_variables(cls, formdata):
             d = {}
             for part in formdata.iter_evolution_parts():
                 if not isinstance(part, LinkedFormdataEvolutionPart):
                 if not isinstance(part, cls):
                     continue
                 if part.formdata:
                     d['form_links_%s' % (part.varname or '*')] = part
                     d['form_%s_%s' % (cls.form_property_name, part.varname or '*')] = part
             return d
     class LazyFormDataLinks(object):
         evolution_part_class = LinkedFormdataEvolutionPart
         def __init__(self, formdata):
             self._formdata = formdata
         def __getattr__(self, varname):
             for part in self._formdata.iter_evolution_parts():
                 if not isinstance(part, LinkedFormdataEvolutionPart):
                 if not isinstance(part, self.evolution_part_class):
                     continue
                 if part.varname == varname and part.formdata:
                     return part.formdata.get_substitution_variables()
-...
         evolution_part_class = LinkedFormdataEvolutionPart
         formdef_slug = None
         formdef_label = _('Form')
         mappings_label = _('Mappings to new form fields')
         varname_hint = _('This is used to get linked forms in expressions.')
         draft = False
         backoffice_submission = False
         keep_user = True
-...
                 list_forms = [(None, '---', '')]
                 list_forms += [(x.url_name, x.name, x.url_name) for x in self.formdef_class.select(order_by='name')]
                 form.add(SingleSelectWidget, 'formdef_slug',
                          title=_('Form'),
                          title=self.formdef_label,
                          value=self.formdef_slug,
                          options=list_forms)
             if 'draft' in parameters:
-...
             formdef = self._resolve_formdef_slug(form.get('formdef_slug'))
             if 'mappings' in parameters and formdef:
                 form.add(MappingsWidget, '%smappings' % prefix,
                          title=_('Mappings to new form fields'),
                          title=self.mappings_label,
                          to_formdef=formdef,
                          value=self.mappings)
             if 'varname' in parameters:
                 form.add(VarnameWidget, '%svarname' % prefix,
                          title=_('Identifier'), value=self.varname,
                          hint=_('This is used to get linked forms in expressions.'),
                          hint=self.varname_hint,
                          advanced=not(bool(self.varname)))
         def submit_admin_form(self, form):

wcs/workflows.py
2912	2912	from .wf import redirect_to_url
2913	2913	from .wf import notification
2914	2914	from .wf import create_formdata
	2915	from .wf import cards
2915	2916
2916	2917	from .wf.export_to_model import ExportToModel
2917		-

Projet

Général

Profil

Produits Entr'ouvert » w.c.s.