senaite.core.browser.viewlets.sampleheader.SampleHeaderViewlet.is_datetime_field() - Code Metrics - Inspection of "Remove custom date rendering in sample header (#22..." - senaite/senaite.core - Measure and Improve Code Quality continuously with Scrutinizer

Passed

Push — 2.x ( e14db6...c5cce7 )

by Jordi

created 2023-03-27 15:12 UTC

A

↳ Parent: senaite.core.browser.viewlets.sampleheader.SampleHeaderViewlet.can_manage_sample_fields()

Complexity

Conditions

Size

Total Lines	7
Code Lines	5

Duplication

Lines	0
Ratio	0 %

Importance

Changes

Metric	Value
eloc	5
dl	0
loc	7
rs	10
c	0
b	0
f	0
cc	2
nop	2

# -*- coding: utf-8 -*-
#
# This file is part of SENAITE.CORE.
#
# SENAITE.CORE 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, version 2.
#
# 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, write to the Free Software Foundation, Inc., 51
# Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
#
# Copyright 2018-2023 by it's authors.
# Some rights reserved, see README and LICENSE.

from itertools import islice

from bika.lims import api
from bika.lims import senaiteMessageFactory as _
from bika.lims.api.security import check_permission
from bika.lims.api.security import get_roles
from bika.lims.interfaces import IAnalysisRequestWithPartitions
from bika.lims.interfaces import IHeaderTableFieldRenderer
from plone.app.layout.viewlets import ViewletBase
from plone.memoize import view as viewcache
from plone.protect import PostOnly
from Products.Archetypes.event import ObjectEditedEvent
from Products.Archetypes.interfaces import IField as IATField
from Products.CMFCore.permissions import ModifyPortalContent
from Products.Five.browser.pagetemplatefile import ViewPageTemplateFile
from senaite.core import logger
from senaite.core.interfaces import IDataManager
from zope import event
from zope.component import queryAdapter
from zope.schema.interfaces import IField as IDXField

_fieldname_not_in_form = object()


class SampleHeaderViewlet(ViewletBase):
    """Header table with editable sample fields
    """
    template = ViewPageTemplateFile("templates/sampleheader.pt")

    def render(self):
        """Renders the viewlet and handles form submission
        """
        request = self.request
        submitted = request.form.get("sampleheader_form_submitted", False)
        save = request.form.get("sampleheader_form_save", False)
        errors = {}
        if submitted and save:
            errors = self.handle_form_submit(request=self.request)
            # NOTE: we only redirect if no validation errors occured,
            #       because otherwise the fields are not error-indicated!
            if not errors:
                # redirect needed to show status message
                self.request.response.redirect(self.context.absolute_url())
        return self.template(errors=errors)

    def handle_form_submit(self, request=None):
        """Handle form submission
        """
        PostOnly(request)

        errors = {}
        field_values = {}
        form = request.form

        for name, field in self.fields.items():
            value = self.get_field_value(field, form)

            if value is _fieldname_not_in_form:
                continue

            # Keep track of field-values
            field_values.update({name: value})

            # Validate the field values
            error = field.validate(value, self.context)
            if error:
                errors.update({name: error})

        if errors:
            return errors
        else:
            # we want to set the fields with the data manager
            dm = IDataManager(self.context)

            # Store the field values
            for name, value in field_values.items():
                dm.set(name, value)

            message = _("Changes saved.")
            # reindex the object after save to update all catalog metadata
            self.context.reindexObject()
            # notify object edited event
            event.notify(ObjectEditedEvent(self.context))
            self.add_status_message(message, level="info")

    def get_configuration(self):
        """Return header configuration

        This method retrieves the customized field and column configuration from
        the management view directly.

        :returns: Field and columns configuration dictionary
        """
        mv = api.get_view(name="manage-sample-fields", context=self.context)
        settings = mv.get_configuration()
        visibility = settings.get("field_visibility")

        def is_visible(name):
            return visibility.get(name, True)

        # filter out fields that are configured as invisible
        prominent_fields = filter(is_visible, settings.get("prominent_fields"))
        standard_fields = filter(is_visible, settings.get("standard_fields"))

        config = {}
        config.update(settings)
        config["prominent_fields"] = prominent_fields
        config["standard_fields"] = standard_fields

        return config

    @property
    def fields(self):
        """Returns an ordered dict of all schema fields
        """
        return api.get_fields(self.context)

    def get_field_value(self, field, form):
        """Returns the submitted value for the given field
        """
        fieldname = field.getName()
        if fieldname not in form:
            return _fieldname_not_in_form

        fieldvalue = form[fieldname]

        # Handle (multiValued) reference fields
        # https://github.com/bikalims/bika.lims/issues/2270
        uid_fieldname = "{}_uid".format(fieldname)
        if uid_fieldname in form:
            # get the value from the corresponding `uid_<fieldname>` key
            value = form[uid_fieldname]

            # extract the assigned UIDs for multi-reference fields
            if field.multiValued:
                value = filter(None, value.split(","))

            # allow to flush single reference fields
            if not field.multiValued and not fieldvalue:
                value = ""

            return value

        # other fields
        return fieldvalue

    def grouper(self, iterable, n=3):
        """Splits an iterable into chunks of `n` items
        """
        for chunk in iter(lambda it=iter(iterable): list(islice(it, n)), []):
            yield chunk

    def get_field_info(self, name):
        """Return field information required for the template
        """
        field = self.fields.get(name)
        mode = self.get_field_mode(field)
        html = self.get_field_html(field, mode=mode)
        label = self.get_field_label(field, mode=mode)
        description = self.render_field_description(field, mode=mode)
        required = self.is_field_required(field, mode=mode)
        return {
            "name": name,
            "mode": mode,
            "html": html,
            "field": field,
            "label": label,
            "description": description,
            "required": required,
        }

    def get_field_html(self, field, mode="view"):
        """Render field HTML
        """
        if mode == "view":
            # Lookup custom view adapter
            adapter = queryAdapter(self.context,
                                   interface=IHeaderTableFieldRenderer,
                                   name=field.getName())
            # return immediately if we have an adapter
            if adapter is not None:
                return adapter(field)

        return None

    def get_field_label(self, field, mode="view"):
        """Renders the field label
        """
        widget = self.get_widget(field)
        return getattr(widget, "label", "")

    def render_field_description(self, field, mode="view"):
        """Renders the field description
        """
        widget = self.get_widget(field)
        return getattr(widget, "description", "")

    def render_widget(self, field, mode="view"):
        """Render the field widget
        """
        return self.context.widget(field.getName(), mode=mode)

    def get_field_mode(self, field, default="hidden"):
        """Returns the field mode in the header

        Possible values are:

          - edit: field is rendered in edit mode
          - view: field is rendered in view mode
        """
        mode = "view"
        if field.checkPermission("edit", self.context):
            mode = "edit"
            if not self.is_edit_allowed():
                logger.warn("Permission '{}' granted for the edition of '{}', "
                            "but 'Modify portal content' not granted"
                            .format(field.write_permission, field.getName()))
        elif field.checkPermission("view", self.context):
            mode = "view"

        widget = self.get_widget(field)
        mode_vis = widget.isVisible(self.context, mode=mode, field=field)
        if mode_vis != "visible":
            if mode == "view":
                return default
            # The field cannot be rendered in edit mode, but maybe can be
            # rendered in view mode.
            mode = "view"
            view_vis = widget.isVisible(self.context, mode=mode, field=field)
            if view_vis != "visible":
                return default

        return mode

    def get_widget(self, field):
        """Returns the widget of the field
        """
        if self.is_at_field(field):
            return field.widget
        elif self.is_dx_field(field):
            raise NotImplementedError("DX widgets not yet needed")
        raise TypeError("Field %r is neither a DX nor an AT field")

    def add_status_message(self, message, level="info"):
        """Set a portal status message
        """
        return self.context.plone_utils.addPortalMessage(message, level)

    @viewcache.memoize
    def is_primary_with_partitions(self):
        """Check if the Sample is a primary with partitions
        """
        return IAnalysisRequestWithPartitions.providedBy(self.context)

    def is_primary_bound(self, field):
        """Checks if the field is primary bound
        """
        if not self.is_primary_with_partitions():
            return False
        return getattr(field, "primary_bound", False)

    def is_edit_allowed(self):
        """Check permission 'ModifyPortalContent' on the context
        """
        return check_permission(ModifyPortalContent, self.context)

    def is_field_required(self, field, mode="edit"):
        """Check if the field is required
        """
        if mode == "view":
            return False
        return field.required

    def is_at_field(self, field):
        """Check if the field is an AT field
        """
        return IATField.providedBy(field)

    def is_dx_field(self, field):
        """Check if the field is an DX field
        """
        return IDXField.providedBy(field)

    def can_manage_sample_fields(self):
        """Checks if the user is allowed to manage the sample fields

        TODO: Better use custom permission (same as used for view)
        """
        roles = get_roles()
        if "Manager" in roles:
            return True
        elif "LabManager" in roles:
            return True
        return False


1			# -- coding: utf-8 --
2			#
3			# This file is part of SENAITE.CORE.
4			#
5			# SENAITE.CORE is free software: you can redistribute it and/or modify it under
6			# the terms of the GNU General Public License as published by the Free Software
7			# Foundation, version 2.
8			#
9			# This program is distributed in the hope that it will be useful, but WITHOUT
10			# ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
11			# FOR A PARTICULAR PURPOSE. See the GNU General Public License for more
12			# details.
13			#
14			# You should have received a copy of the GNU General Public License along with
15			# this program; if not, write to the Free Software Foundation, Inc., 51
16			# Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
17			#
18			# Copyright 2018-2023 by it's authors.
19			# Some rights reserved, see README and LICENSE.
20
21			from itertools import islice
22
23			from bika.lims import api
24			from bika.lims import senaiteMessageFactory as _
25			from bika.lims.api.security import check_permission
26			from bika.lims.api.security import get_roles
27			from bika.lims.interfaces import IAnalysisRequestWithPartitions
28			from bika.lims.interfaces import IHeaderTableFieldRenderer
29			from plone.app.layout.viewlets import ViewletBase
30			from plone.memoize import view as viewcache
31			from plone.protect import PostOnly
32			from Products.Archetypes.event import ObjectEditedEvent
33			from Products.Archetypes.interfaces import IField as IATField
34			from Products.CMFCore.permissions import ModifyPortalContent
35			from Products.Five.browser.pagetemplatefile import ViewPageTemplateFile
36			from senaite.core import logger
37			from senaite.core.interfaces import IDataManager
38			from zope import event
39			from zope.component import queryAdapter
40			from zope.schema.interfaces import IField as IDXField
41
42			_fieldname_not_in_form = object()
43
44
45			class SampleHeaderViewlet(ViewletBase):
46			"""Header table with editable sample fields
47			"""
48			template = ViewPageTemplateFile("templates/sampleheader.pt")
49
50			def render(self):
51			"""Renders the viewlet and handles form submission
52			"""
53			request = self.request
54			submitted = request.form.get("sampleheader_form_submitted", False)
55			save = request.form.get("sampleheader_form_save", False)
56			errors = {}
57			if submitted and save:
58			errors = self.handle_form_submit(request=self.request)
59			# NOTE: we only redirect if no validation errors occured,
60			# because otherwise the fields are not error-indicated!
61			if not errors:
62			# redirect needed to show status message
63			self.request.response.redirect(self.context.absolute_url())
64			return self.template(errors=errors)
65
66			def handle_form_submit(self, request=None):
67			"""Handle form submission
68			"""
69			PostOnly(request)
70
71			errors = {}
72			field_values = {}
73			form = request.form
74
75			for name, field in self.fields.items():
76			value = self.get_field_value(field, form)
77
78			if value is _fieldname_not_in_form:
79			continue
80
81			# Keep track of field-values
82			field_values.update({name: value})
83
84			# Validate the field values
85			error = field.validate(value, self.context)
86			if error:
87			errors.update({name: error})
88
89			if errors:
90			return errors
91			else:
92			# we want to set the fields with the data manager
93			dm = IDataManager(self.context)
94
95			# Store the field values
96			for name, value in field_values.items():
97			dm.set(name, value)
98
99			message = _("Changes saved.")
100			# reindex the object after save to update all catalog metadata
101			self.context.reindexObject()
102			# notify object edited event
103			event.notify(ObjectEditedEvent(self.context))
104			self.add_status_message(message, level="info")
105
106			def get_configuration(self):
107			"""Return header configuration
108
109			This method retrieves the customized field and column configuration from
110			the management view directly.
111
112			:returns: Field and columns configuration dictionary
113			"""
114			mv = api.get_view(name="manage-sample-fields", context=self.context)
115			settings = mv.get_configuration()
116			visibility = settings.get("field_visibility")
117
118			def is_visible(name):
119			return visibility.get(name, True)
120
121			# filter out fields that are configured as invisible
122			prominent_fields = filter(is_visible, settings.get("prominent_fields"))
123			standard_fields = filter(is_visible, settings.get("standard_fields"))
124
125			config = {}
126			config.update(settings)
127			config["prominent_fields"] = prominent_fields
128			config["standard_fields"] = standard_fields
129
130			return config
131
132			@property
133			def fields(self):
134			"""Returns an ordered dict of all schema fields
135			"""
136			return api.get_fields(self.context)
137
138			def get_field_value(self, field, form):
139			"""Returns the submitted value for the given field
140			"""
141			fieldname = field.getName()
142			if fieldname not in form:
143			return _fieldname_not_in_form
144
145			fieldvalue = form[fieldname]
146
147			# Handle (multiValued) reference fields
148			# https://github.com/bikalims/bika.lims/issues/2270
149			uid_fieldname = "{}_uid".format(fieldname)
150			if uid_fieldname in form:
151			# get the value from the corresponding `uid_<fieldname>` key
152			value = form[uid_fieldname]
153
154			# extract the assigned UIDs for multi-reference fields
155			if field.multiValued:
156			value = filter(None, value.split(","))
157
158			# allow to flush single reference fields
159			if not field.multiValued and not fieldvalue:
160			value = ""
161
162			return value
163
164			# other fields
165			return fieldvalue
166
167			def grouper(self, iterable, n=3):
168			"""Splits an iterable into chunks of `n` items
169			"""
170			for chunk in iter(lambda it=iter(iterable): list(islice(it, n)), []):
171			yield chunk
172
173			def get_field_info(self, name):
174			"""Return field information required for the template
175			"""
176			field = self.fields.get(name)
177			mode = self.get_field_mode(field)
178			html = self.get_field_html(field, mode=mode)
179			label = self.get_field_label(field, mode=mode)
180			description = self.render_field_description(field, mode=mode)
181			required = self.is_field_required(field, mode=mode)
182			return {
183			"name": name,
184			"mode": mode,
185			"html": html,
186			"field": field,
187			"label": label,
188			"description": description,
189			"required": required,
190			}
191
192			def get_field_html(self, field, mode="view"):
193			"""Render field HTML
194			"""
195			if mode == "view":
196			# Lookup custom view adapter
197			adapter = queryAdapter(self.context,
198			interface=IHeaderTableFieldRenderer,
199			name=field.getName())
200			# return immediately if we have an adapter
201			if adapter is not None:
202			return adapter(field)
203
204			return None
205
206			def get_field_label(self, field, mode="view"):
207			"""Renders the field label
208			"""
209			widget = self.get_widget(field)
210			return getattr(widget, "label", "")
211
212			def render_field_description(self, field, mode="view"):
213			"""Renders the field description
214			"""
215			widget = self.get_widget(field)
216			return getattr(widget, "description", "")
217
218			def render_widget(self, field, mode="view"):
219			"""Render the field widget
220			"""
221			return self.context.widget(field.getName(), mode=mode)
222
223			def get_field_mode(self, field, default="hidden"):
224			"""Returns the field mode in the header
225
226			Possible values are:
227
228			- edit: field is rendered in edit mode
229			- view: field is rendered in view mode
230			"""
231			mode = "view"
232			if field.checkPermission("edit", self.context):
233			mode = "edit"
234			if not self.is_edit_allowed():
235			logger.warn("Permission '{}' granted for the edition of '{}', "
236			"but 'Modify portal content' not granted"
237			.format(field.write_permission, field.getName()))
238			elif field.checkPermission("view", self.context):
239			mode = "view"
240
241			widget = self.get_widget(field)
242			mode_vis = widget.isVisible(self.context, mode=mode, field=field)
243			if mode_vis != "visible":
244			if mode == "view":
245			return default
246			# The field cannot be rendered in edit mode, but maybe can be
247			# rendered in view mode.
248			mode = "view"
249			view_vis = widget.isVisible(self.context, mode=mode, field=field)
250			if view_vis != "visible":
251			return default
252
253			return mode
254
255			def get_widget(self, field):
256			"""Returns the widget of the field
257			"""
258			if self.is_at_field(field):
259			return field.widget
260			elif self.is_dx_field(field):
261			raise NotImplementedError("DX widgets not yet needed")
262			raise TypeError("Field %r is neither a DX nor an AT field")
263
264			def add_status_message(self, message, level="info"):
265			"""Set a portal status message
266			"""
267			return self.context.plone_utils.addPortalMessage(message, level)
268
269			@viewcache.memoize
270			def is_primary_with_partitions(self):
271			"""Check if the Sample is a primary with partitions
272			"""
273			return IAnalysisRequestWithPartitions.providedBy(self.context)
274
275			def is_primary_bound(self, field):
276			"""Checks if the field is primary bound
277			"""
278			if not self.is_primary_with_partitions():
279			return False
280			return getattr(field, "primary_bound", False)
281
282			def is_edit_allowed(self):
283			"""Check permission 'ModifyPortalContent' on the context
284			"""
285			return check_permission(ModifyPortalContent, self.context)
286
287			def is_field_required(self, field, mode="edit"):
288			"""Check if the field is required
289			"""
290			if mode == "view":
291			return False
292			return field.required
293
294			def is_at_field(self, field):
295			"""Check if the field is an AT field
296			"""
297			return IATField.providedBy(field)
298
299			def is_dx_field(self, field):
300			"""Check if the field is an DX field
301			"""
302			return IDXField.providedBy(field)
303
304			def can_manage_sample_fields(self):
305			"""Checks if the user is allowed to manage the sample fields
306
307			TODO: Better use custom permission (same as used for view)
308			"""
309			roles = get_roles()
310			if "Manager" in roles:
311			return True
312			elif "LabManager" in roles:
313			return True
314			return False
315

senaite / senaite.core

Push — 2.x ( e14db6...c5cce7 )

A

Complexity

Size

Duplication

Importance

Duplication Side-by-Side

Filter issues like