Produits Entr'ouvert » w.c.s.

from wcs.forms.backoffice import FormDefUI

from wcs.forms.common import FormStatusPage

from wcs.admin.settings import UserFieldsFormDef

from wcs.categories import Category

from wcs.formdata import FormData

from wcs.formdef import FormDef

from wcs.roles import logged_users_role, Role

from wcs.variables import LazyFieldVar

from .submission import FormFillPage

def geojson_formdatas(formdatas, geoloc_key='base', fields=None):

    geojson = {'type': 'FeatureCollection', 'features': []}

    for formdata in formdatas:

        # assigned functions

        if self.formdef.workflow.roles:

            workflow = self.formdef.workflow

            r += htmltext('<div id="inspect-functions" class="section">')

            r += htmltext('<h2>%s</h2></li>\n') % _('Functions')

            r += htmltext('<ul class="form-inspector biglist">')

            for key, label in (workflow.roles or {}).items():

                r += htmltext('<li><span class="label">%s</span>') % label

                if acting_role_id:

                    try:

                        acting_role = Role.get(acting_role_id)

                        r += htmltext('<div class="value"><span>%s</span></div>') % acting_role.name

                    except KeyError:

                        r += htmltext('<div class="value"><span>%s %s</span></div>') % (

                            acting_role_id,

                            _('(deleted)'),

        return self.get_url(backoffice=True)

    def get_api_url(self):

        return '%s%s/' % (self.formdef.get_api_url(), self.id)

    def get_display_id(self):

        return str(self.id_display or self.id)

    def get_handling_role_id(self):

        # TODO: look at current status and return the role(s) actually

        # concerned by the handling of the formdata

    def get_handling_role(self):

        try:

            return Role.get(self.get_handling_role_id())

        except KeyError:

            return None

    def get_field_view_value(self, field, max_length=None):

            # drafts are only visible to submitter

            return ['_submitter']

        status_action_roles = set()

        # make sure the handling roles always gets access to the formdata, till

        # the very end (where it may be that there is no workflow status item

        # at all).

        for function_key in self.formdef.workflow.roles.keys():

            if handling_role:

                status_action_roles.add(handling_role)

        wf_status = self.get_status()

        if not wf_status:

            status_action_roles.add('_submitter')

        else:

            status_action_roles |= set(self.get_actions_roles())

    def get_actions_roles(self):

        if self.is_draft():

            return []

        wf_status = self.get_status()

        if not wf_status:

            return []

        status_action_roles = set()

        for item in wf_status.items or []:

            if not hasattr(item, 'by') or not item.by:

                continue

            with get_publisher().substitutions.temporary_feed(self):

                if not item.check_condition(self):

                    continue

            for role in item.by:

                if role == '_submitter':

                    status_action_roles.add(role)

                else:

                    if real_role:

                        status_action_roles.add(real_role)

        return status_action_roles

    actions_roles = property(get_actions_roles)

    def get_last_update_time(self):

from quixote import get_request, get_response

from quixote.directory import Directory

from ..qommon import errors

from wcs.api import get_user_from_api_query_string, is_url_signed

from wcs.roles import logged_users_role

class HookDirectory(Directory):

    _q_exports = ['']

    def __init__(self, formdata, action, trigger):

        self.formdata = formdata

        self.action = action

        if self.trigger.roles:

            for role in self.trigger.roles:

                if role == logged_users_role().id and (user or is_url_signed()):

                    break

                if role == '_submitter' and self.formdata.is_submitter(user):

                    break

                if not user:

                    continue

                    break

            else:

                raise errors.AccessForbiddenError('insufficient roles')

        if hasattr(get_request(), '_json'):

            workflow_data = {self.trigger.identifier: get_request().json}

            self.formdata.update_workflow_data(workflow_data)

            self.formdata.store()

from ..qommon import _, N_

from ..qommon.publisher import get_publisher_class

from ..qommon.storage import StorableObject

from ..qommon.form import *

from ..qommon.cron import CronJob

from ..qommon import emails

from wcs.roles import Role

class AggregationEmailWorkflowStatusItem(WorkflowStatusItem):

    description = N_('Daily Summary Email')

    key = 'aggregationemail'

    category = 'interaction'

    ok_in_global_action = False

    def get_parameters(self):

        return ('to', 'condition')

    def perform(self, formdata):

        if not self.to:

            return

        for dest in self.to:

            try:

                aggregate = AggregationEmail.get(dest)

            except KeyError:

                aggregate = AggregationEmail(id=dest)

            aggregate.append(

                {'formdef': formdata.formdef.id, 'formdata': formdata.id, 'formurl': formdata.get_url()}

            )

from quixote import get_publisher

from ..qommon import _, N_, ezt

from ..qommon.form import *

from ..qommon.template import TemplateError

from ..qommon import get_logger

from wcs.roles import Role

from .wscall import WebserviceCallStatusItem

class SendNotificationWorkflowStatusItem(WebserviceCallStatusItem):

    description = N_('User Notification')

    key = 'notification'

    category = 'interaction'

    support_substitution_variables = True

        self.url = self.get_api_url()

        users = []

        for dest in self.to:

            if dest == '_submitter':

                users.append(formdata.get_user())

                continue

            try:

                role = Role.get(dest)

            except KeyError:

                continue

            users.extend(get_publisher().user_class.get_users_with_role(role.id))

        for user in users:

            if not user or not user.is_active:

        actions = []

        for action in self.global_actions or []:

            for trigger in action.triggers or []:

                if isinstance(trigger, WorkflowGlobalActionManualTrigger):

                    if '_submitter' in (trigger.roles or []) and formdata.is_submitter(user):

                        actions.append(action)

                        break

                    roles = [

                    ]

                    if set(roles).intersection(user.get_roles()):

                        actions.append(action)

                        break

        return actions

    def get_subdirectories(self, formdata):

        wf_status = formdata.get_status()

                        break

                    if role == '_submitter':

                        if filled.is_submitter(user):

                            break

                        else:

                            continue

                    if user is None:

                        continue

                    if role in user.get_roles():

                        break

                else:

                    continue

            if not item.check_condition(filled):

                continue

            yield item

        visibility_roles = self.visibility[:]

        for item in self.items or []:

            if not hasattr(item, 'by') or not item.by:

                continue

            visibility_roles.extend(item.by)

        for role in visibility_roles:

            if role != '_submitter':

            if role in user_roles:

                return True

        return False

    def is_endpoint(self):

        # an endpoint status is a status that marks the end of the workflow; it

        # can either be computed automatically (if there's no way out of the

        # status) or be set manually (to mark the expected end while still

                return True

            if role == '_submitter':

                t = formdata.is_submitter(user)

                if t is True:

                    return True

                continue

            if not user:

                continue

            if role in user.get_roles():

                return True

        return False

    def check_condition(self, formdata):

        context = {'formdata': formdata, 'status_item': self}

        try:

                markers_stack = []

            markers_stack.append({'status_id': formdata.status[3:]})

            formdata.update_workflow_data({'_markers_stack': markers_stack})

    def get_parameters(self):

        return ('status', 'set_marker_on_status', 'condition')

def get_role_translation_label(workflow, role_id):

    if role_id == logged_users_role().id:

        return logged_users_role().name

    if role_id == '_submitter':

        return C_('role|User')

    if str(role_id).startswith('_'):

        return workflow.roles.get(role_id)

    else:

                continue

            if dest == '_submitter':

                submitter_email = formdata.formdef.get_submitter_email(formdata)

                if submitter_email:

                    addresses.append(submitter_email)

                continue

            try:

                role = Role.get(dest)

            except KeyError:

                continue

            addresses.extend(role.get_emails())

        if not addresses:

        if not get_request():

            return False

        user = get_request().user

        for role in self.to or []:

            if role == '_submitter':

                if filled.is_submitter(user):

                    return True

            elif user:

                if role in user.get_roles():

                    return True

        return False

    def get_message(self, filled, position='top'):

        if not (self.message and self.position == position and self.is_for_current_user(filled)):

            return ''