Produits Entr'ouvert » w.c.s.

# 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):

    __part = None

    def __init__(self, part):

        self.__part = part

    def __getattr__(self, name):

        if name.startswith('__'):

            raise AttributeError(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):

    __varname = None

    def __init__(self, formdata):

        self.formdata = formdata

    @property

    def __parts(self):

        return [part for part in self.formdata.iter_evolution_parts()

                if isinstance(part, LinkedFormdataEvolutionPart)]

    @property

    def __formdatas(self):

        formdatas = [(part.varname, part, LazyLinkedFormData(part)) for part in self.__parts]

        formdatas.reverse()

        return formdatas

    @property

    def __varnames(self):

        return set(varname for varname, _1, _2 in self.__formdatas)

    def __iter__(self):

        for varname, part, formdata in self.__formdatas or []:

            if self.__varname is None or self.__varname == varname:

                yield formdata

    def __getitem__(self, idx):

        return list(self)[idx]

    def __getattr__(self, name):

        if name.startswith('__'):

            raise AttributeError(name)

        if self.__varname or name not in (self.__varnames or []):

            try:

                first = self[0]

            except IndexError:

                raise AttributeError(name)

            return getattr(first, name)

        elif name in (self.__varnames or []):

            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(formdata),

        }

    @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)

    from .wf import create_formdata