From 0e7d1b4582f60ac7dc0f40cb3710a31f465fd86e Mon Sep 17 00:00:00 2001
From: Benjamin Dauvergne <bdauvergne@entrouvert.com>
Date: Sat, 18 May 2019 14:17:33 +0200
Subject: [PATCH 4/7] add new action create-formdata (#33186)

---
 wcs/wf/create_formdata.py | 421 ++++++++++++++++++++++++++++++++++++++
 wcs/workflows.py          |   1 +
 2 files changed, 422 insertions(+)
 create mode 100644 wcs/wf/create_formdata.py

diff --git a/wcs/wf/create_formdata.py b/wcs/wf/create_formdata.py
new file mode 100644
index 00000000..f5e653b4
--- /dev/null
+++ b/wcs/wf/create_formdata.py
@@ -0,0 +1,421 @@
+# w.c.s. - web application for online forms
+# Copyright (C) 2005-2016  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/>.
+
+import collections
+import copy
+import time
+import xml.etree.ElementTree as ET
+
+from quixote import get_request, get_session
+
+from django.utils.functional import cached_property
+
+from wcs.qommon import _
+from wcs.qommon.form import (WidgetListAsTable, CompositeWidget,
+                             SingleSelectWidget, ComputedExpressionWidget,
+                             CheckboxWidget, StringWidget, VarnameWidget)
+
+from wcs.logged_errors import LoggedError
+from wcs.workflows import WorkflowStatusItem, register_item_class
+from wcs.formdef import FormDef
+from wcs.variables import LazyFormData
+
+
+Mapping = collections.namedtuple('Mapping', ['varname', 'expression'])
+
+
+class MappingWidget(CompositeWidget):
+    def __init__(self, name, value=None, to_formdef=None, **kwargs):
+        value = value or Mapping(None, '')
+        super(MappingWidget, self).__init__(name, value, **kwargs)
+
+        to_fields = self._fields_to_options(to_formdef)
+
+        self.add(SingleSelectWidget,
+                 name='varname',
+                 title=_('Field'),
+                 value=value.varname,
+                 options=to_fields)
+
+        self.add(ComputedExpressionWidget,
+                 name='expression',
+                 title=_('Expression'),
+                 value=value.expression)
+
+    def _fields_to_options(self, formdef):
+        return [(None, '---', '')] + [
+            (field.varname, field.label, field.varname) for field in formdef.get_all_varname_fields()]
+
+    def _parse(self, request):
+        super(MappingWidget, self)._parse(request)
+        if self.get('varname') is not None and self.get('expression') is not None:
+            self.value = Mapping(varname=self.get('varname'), expression=self.get('expression'))
+        else:
+            self.value = None
+
+
+class MappingsWidget(WidgetListAsTable):
+    readonly = False
+
+    # widget_list.js does not work with ComputedExpressionWidget,
+    # so we revert to quixote behabiour for adding a line
+    def add_media(self):
+        pass
+
+    def __init__(self, name, to_formdef=None, **kwargs):
+        self.to_formdef = to_formdef
+
+        value = kwargs.get('value')
+        if value:
+            # reorder mappings based on to_formdef fields order
+            value.sort(key=lambda mapping: self.ranks.get(mapping.varname, 9999))
+
+        super(MappingsWidget, self).__init__(
+            name,
+            element_type=MappingWidget,
+            element_kwargs={
+                'to_formdef': to_formdef,
+            },
+            **kwargs)
+
+    @cached_property
+    def ranks(self):
+        return {field.varname: i for i, field in enumerate(
+            field for field in self.to_formdef.get_all_varname_fields())}
+
+    def _parse(self, request):
+        super(MappingsWidget, self)._parse(request)
+
+        if self.value:
+            # prevent many mappings to the same field
+            if len(set(mapping.varname for mapping in self.value)) != len(self.value):
+                self.error = _('Some destination fields are duplicated')
+                return
+
+            # reorder mappings based on to_formdef fields order
+            self.value.sort(key=lambda mapping: self.ranks.get(mapping.varname, 9999))
+
+
+class LazyLinkedFormData(object):
+    def __init__(self, part):
+        self.__part = part
+
+    def __getattr__(self, name):
+        formdata = self.__part.formdata
+        if formdata is not None:
+            return getattr(LazyFormData(self.__part.formdata), name)
+        raise AttributeError(name)
+
+    @property
+    def url(self):
+        formdata = self.__part.formdata
+        if formdata is None:
+            return None
+        if self.__part.formdata.is_draft():
+            return self.__part.url
+        else:
+            return self.__getattr__('url')
+
+
+class LinkedFormdataSubstitutionProxy(object):
+    def __init__(self, parts):
+        self.__parts = parts
+        self.__formdatas = [(part.varname, part, LazyLinkedFormData(part)) for part in parts]
+        self.__formdatas.reverse()
+        self.__varnames = set(varname for varname, _1, _2 in self.__formdatas)
+        self.__varname = None
+
+    def __iter__(self):
+        for varname, part, formdata in self.__formdatas:
+            if self.__varname is None or self.__varname == varname:
+                yield formdata
+
+    def __getitem__(self, idx):
+        return list(self)[idx]
+
+    def __getattr__(self, name):
+        if self.__varname or name not in self.__varnames:
+            try:
+                first = self[0]
+            except KeyError:
+                raise AttributeError(name)
+            return getattr(first, name)
+        elif name in self.__varnames:
+            new_sub = copy.copy(self)
+            new_sub.varname = name
+            return new_sub
+
+    def __repr__(self):
+        s = '<LinkedFormdataSubstitutionProxy'
+        if self.__varname:
+            s += ' varname=%r' % self.__varname
+        else:
+            s += ' varnames=%s' % list(self.__varnames)
+        parts = [part for part in self.__parts if not self.__varname or part.varname == self.__varname]
+        s += ' forms=%s>' % ['%s-%s' % (part.formdef_id, part.formdata_id) for part in parts]
+        return s
+
+
+class LinkedFormdataEvolutionPart(object):
+    def __init__(self, formdata, varname=None, label=None):
+        self.__formdef = formdata.formdef
+        self.__formdata = formdata
+        self.formdef_id = formdata.formdef.id
+        self.formdata_id = formdata.id
+        self.varname = varname
+        self.label = label
+
+    @property
+    def formdef(self):
+        if not hasattr(self, '__formdef'):
+            self.__formdef = FormDef.get(self.formdef_id)
+        return self.__formdef
+
+    @property
+    def formdata(self):
+        if not hasattr(self, '__formdata'):
+            self.__formdata = self.formdef.data_class().get(self.formdata_id, ignore_errors=True)
+        return self.__formdata
+
+    @classmethod
+    def get_substitution_variables(cls, formdata):
+        return {
+            'linked': LinkedFormdataSubstitutionProxy(
+                [part for part in formdata.iter_evolution_parts() if isinstance(part, LinkedFormdataEvolutionPart)]),
+        }
+
+    @property
+    def url(self):
+        if not self.formdata.is_draft():
+            return self.formdata.get_url(backoffice=get_request().is_in_backoffice())
+        elif self.formdata.backoffice_submission:
+            return '%s%s' % (self.formdata.formdef.get_backoffice_submission_url(), self.formdata.id)
+        else:
+            return self.formdata.get_url().rstrip('/')
+
+    def __getstate__(self):
+        # Forget cached values
+        return {k: v for k, v in self.__dict__.items() if not k.startswith('_')}
+
+
+class CreateFormdataWorkflowStatusItem(WorkflowStatusItem):
+    description = N_('New formdata')
+    key = 'create_formdata'
+    category = 'formdata-action'
+    support_substitution_variables = True
+
+    label = None
+    formdef_slug = None
+    draft = True
+    backoffice_submission = False
+    keep_user = True
+    keep_submission_context = False
+    mappings = None
+    varname = None
+
+    def get_line_details(self):
+        if self.label:
+            s = self.label
+            if self.varname:
+                s += ' - %s' % self.varname
+                return s
+        else:
+            return None
+
+    @property
+    def formdef(self):
+        if self.formdef_slug and self.formdef_slug != '_same':
+            try:
+                return FormDef.get_by_urlname(self.formdef_slug)
+            except KeyError:
+                pass
+        return None
+
+    def add_parameters_widgets(self, form, parameters, prefix='', formdef=None):
+        super(CreateFormdataWorkflowStatusItem, self).add_parameters_widgets(
+            form, parameters, prefix=prefix, formdef=formdef)
+        if 'label' in parameters:
+            form.add(StringWidget, '%slabel' % prefix,
+                     title=_('Label'),
+                     value=self.label or _('Create formdata'))
+        if 'formdef_slug' in parameters:
+            list_forms = [(None, '---', '')]
+            list_forms += [(x.url_name, x.name, x.url_name) for x in FormDef.select(order_by='name')]
+            form.add(SingleSelectWidget, 'formdef_slug',
+                     title=_('Form'),
+                     value=self.formdef_slug,
+                     options=list_forms)
+        if 'draft' in parameters:
+            form.add(CheckboxWidget, '%sdraft' % prefix,
+                     title=_('Draft'),
+                     value=self.draft,
+                     advanced=self.draft == CreateFormdataWorkflowStatusItem.draft)
+        if 'backoffice_submission' in parameters:
+            form.add(CheckboxWidget, '%sbackoffice_submission' % prefix,
+                     title=_('Backoffice submission'),
+                     value=self.backoffice_submission,
+                     advanced=self.backoffice_submission == CreateFormdataWorkflowStatusItem.backoffice_submission)
+        if 'keep_user' in parameters:
+            form.add(CheckboxWidget, '%skeep_user' % prefix,
+                     title=_('Keep user'),
+                     value=self.keep_user,
+                     advanced=self.keep_user == CreateFormdataWorkflowStatusItem.keep_user)
+        if 'keep_submission_context' in parameters and self.keep_user:
+            form.add(CheckboxWidget, '%skeep_submission_context' % prefix,
+                     title=_('Keep submission context'),
+                     value=self.keep_submission_context,
+                     advanced=self.keep_submission_context == CreateFormdataWorkflowStatusItem.keep_submission_context)
+        formdef = None
+        if form.get('formdef_slug'):
+            try:
+                formdef = FormDef.get_by_urlname(form.get('formdef_slug'))
+            except KeyError:
+                pass
+        if 'mappings' in parameters and formdef:
+            form.add(MappingsWidget, '%smappings' % prefix,
+                     title=_('Mappings to new form fields'),
+                     to_formdef=formdef,
+                     required=True,
+                     value=self.mappings)
+        if 'varname' in parameters:
+            form.add(VarnameWidget, '%svarname' % prefix,
+                     title=_('Identifier'), value=self.varname,
+                     hint=_('This is used to get generated document in expressions.'),
+                     advanced=not(self.varname))
+
+    def submit_admin_form(self, form):
+        self.mappings = []
+        super(CreateFormdataWorkflowStatusItem, self).submit_admin_form(form)
+
+    def get_parameters(self):
+        return ('label', 'formdef_slug', 'draft', 'backoffice_submission',
+                'keep_user', 'keep_submission_context', 'mappings', 'varname')
+
+    def perform(self, formdata):
+        formdef = self.formdef
+        if not formdef:
+            return
+
+        new_formdata = formdef.data_class()()
+        new_formdata.receipt_time = time.localtime()
+
+        if self.keep_user:
+            new_formdata.user_id = formdata.user_id
+
+        if self.keep_submission_context and self.keep_user:
+            new_formdata.submission_context = formdata.submission_context or {}
+            new_formdata.submission_channel = formdata.submission_channel
+        else:
+            new_formdata.submission_context = {}
+
+        new_formdata.backoffice_submission = self.backoffice_submission
+        if self.backoffice_submission and get_request() and get_request().user is not None:
+            new_formdata.submission_context['agent_id'] = str(get_request().user.id)
+
+        new_formdata.submission_context['orig_formdef_id'] = str(formdata.formdef.id)
+        new_formdata.submission_context['orig_formdata_id'] = str(formdata.id)
+        new_formdata.data = {}
+
+        self.apply_mappings(dest=new_formdata, src=formdata)
+
+        if self.draft:
+            new_formdata.status = 'draft'
+            new_formdata.store()
+        else:
+            new_formdata.just_created()
+            new_formdata.store()
+            new_formdata.perform_workflow()
+            new_formdata.store()
+
+        if new_formdata.user_id is None and not new_formdata.backoffice_submission:
+            get_session().mark_anonymous_formdata(new_formdata)
+
+        evo = formdata.evolution[-1]
+        evo.add_part(LinkedFormdataEvolutionPart(new_formdata, varname=self.varname))
+        formdata.store()
+
+    def apply_mappings(self, dest, src):
+        if not self.mappings:
+            return
+
+        to_id_fields = {field.varname: field for field in self.formdef.get_all_varname_fields()}
+
+        missing_fields = []
+
+        for mapping in self.mappings:
+            try:
+                dest_field = to_id_fields[mapping.varname]
+            except KeyError:
+                missing_fields.append(mapping.varname)
+                continue
+            try:
+                value = self.compute(mapping.expression, formdata=src, raises=True, status_item=self)
+            except Exception:
+                # already logged by self.compute
+                continue
+
+            try:
+                self._set_value(
+                    formdata=dest,
+                    field=dest_field,
+                    value=value)
+            except Exception as e:
+                expression = self.get_expression(mapping.expression)
+                LoggedError.record('Could not assign value to field %s' % dest_field,
+                                   formdata=src, status_item=self,
+                                   expression=expression['value'], expression_type=expression['type'],
+                                   exception=e)
+
+        if missing_fields:
+            summary = _('Missing field %r') % missing_fields
+            LoggedError.record(summary, formdata=src, status_item=self)
+
+    def _set_value(self, formdata, field, value):
+        if field.convert_value_from_anything:
+            old_value = value  # noqa: F841, copy value for debug
+            value = field.convert_value_from_anything(value)
+
+        formdata.data['%s' % field.id] = value
+        if field.store_display_value:
+            display_value = field.store_display_value(
+                formdata.data, field.id)
+            if display_value:
+                formdata.data['%s_display' % field.id] = display_value
+        if value and field.store_structured_value:
+            structured_value = field.store_structured_value(
+                formdata.data, field.id)
+            if structured_value:
+                if isinstance(structured_value, dict) and structured_value.get('id'):
+                    # in case of list field, override id
+                    formdata.data['%s' % field.id] = str(structured_value.get('id'))
+                formdata.data['%s_structured' % field.id] = structured_value
+
+    def mappings_export_to_xml(self, parent, charset, include_id=False):
+        container = ET.SubElement(parent, 'mappings')
+        for mapping in self.mappings or []:
+            item = ET.SubElement(container, 'mapping')
+            item.attrib['varname'] = unicode(mapping.varname, charset, 'replace')
+            item.text = unicode(mapping.expression, charset, 'replace')
+
+    def mappings_init_with_xml(self, container, charset, include_id=False):
+        self.mappings = []
+        for child in container:
+            varname = child.attrib.get('varname', '').encode(charset)
+            expression = child.text.encode(charset)
+            if varname:
+                self.mappings.append(Mapping(varname=varname, expression=expression))
+
+register_item_class(CreateFormdataWorkflowStatusItem)
diff --git a/wcs/workflows.py b/wcs/workflows.py
index 9eddfba1..d3875072 100644
--- a/wcs/workflows.py
+++ b/wcs/workflows.py
@@ -2917,5 +2917,6 @@ def load_extra():
     from .wf import backoffice_fields
     from .wf import redirect_to_url
     from .wf import notification
+    from .wf import create_formdata
 
 from .wf.export_to_model import ExportToModel
-- 
2.24.0