bika.lims.browser.header_table.HeaderTableView.render_field_view() - Code Metrics - Inspection of "Sample cleanup (#1180)" - senaite/senaite.core - Measure and Improve Code Quality continuously with Scrutinizer

Completed

Branch — master (9edffc)

by Jordi

created 2019-01-04 23:53 UTC

HeaderTableView.render_field_view() D

↳ Parent: bika.lims.browser.header_table

Complexity

Conditions

Size

Total Lines	75
Code Lines	59

Duplication

Lines	0
Ratio	0 %

Importance

Changes

Metric	Value
eloc	59
dl	0
loc	75
rs	4.2
c	0
b	0
f	0
cc	13
nop	2

How to fix Long Method Complexity

Long Method

Small methods make your code easier to understand, in particular if combined with a good name. Besides, if your method is small, finding a good name is usually much easier.

For example, if you find yourself adding comments to a method's body, this is usually a good sign to extract the commented part to a new method, and use the comment as a starting point when coming up with a good name for this new method.

Commonly applied refactorings include:

If many parameters/temporary variables are present:
- Replace temporary variables with Query
- Introduce parameter object; often combined with preserve whole object
- If the above two are insufficient: Replace method with method object
If you have long conditionals: Decompose Conditional
Otherwise: Extract method

Complexity

Complex classes like bika.lims.browser.header_table.HeaderTableView.render_field_view() often do a lot of different things. To break such a class down, we need to identify a cohesive component within that class. A common approach to find such a component is to look for fields/methods that share the same prefixes, or suffixes.

Once you have determined the fields that belong together, you can apply the Extract Class refactoring. If the component makes sense as a sub-class, Extract Subclass is also a candidate, and is often faster.

# -*- coding: utf-8 -*-
#
# This file is part of SENAITE.CORE
#
# Copyright 2018 by it's authors.
# Some rights reserved. See LICENSE.rst, CONTRIBUTORS.rst.

from AccessControl import getSecurityManager
from AccessControl.Permissions import view
from Products.CMFCore.permissions import ModifyPortalContent
from Products.CMFPlone import PloneMessageFactory as _p
from Products.Five.browser.pagetemplatefile import ViewPageTemplateFile
from bika.lims import bikaMessageFactory as _
from bika.lims import logger
from bika.lims.browser import BrowserView
from bika.lims.interfaces import IHeaderTableFieldRenderer
from bika.lims.utils import t
from zope.component import getAdapter
from zope.component.interfaces import ComponentLookupError


class HeaderTableView(BrowserView):
    """Table rendered at the top in AR View
    """
    template = ViewPageTemplateFile("templates/header_table.pt")

    def __call__(self):
        self.errors = {}
        if "header_table_submitted" in self.request:
            schema = self.context.Schema()
            fields = schema.fields()
            form = self.request.form
            for field in fields:
                fieldname = field.getName()
                if fieldname in form:
                    # Handle (multiValued) reference fields
                    # https://github.com/bikalims/bika.lims/issues/2270
                    uid_fieldname = "{}_uid".format(fieldname)
                    if uid_fieldname in form:
                        value = form[uid_fieldname]
                        if field.multiValued:
                            value = value.split(",")
                        field.getMutator(self.context)(value)
                    else:
                        # other fields
                        field.getMutator(self.context)(form[fieldname])
            message = _p("Changes saved.")
            self.context.plone_utils.addPortalMessage(message, "info")
        return self.template()

    def three_column_list(self, input_list):
        list_len = len(input_list)

        # Calculate the length of the sublists
        sublist_len = (list_len % 3 == 0 and list_len / 3 or list_len / 3 + 1)

        def _list_end(num):
            # Calculate the list end point given the list number
            return num == 2 and list_len or (num + 1) * sublist_len

        # Generate only filled columns
        final = []
        for i in range(3):
            column = input_list[i * sublist_len:_list_end(i)]
            if len(column) > 0:
                final.append(column)
        return final

    # TODO Revisit this
    def render_field_view(self, field):
        fieldname = field.getName()
        field = self.context.Schema()[fieldname]
        ret = {"fieldName": fieldname, "mode": "view"}
        try:
            adapter = getAdapter(self.context,
                                 interface=IHeaderTableFieldRenderer,
                                 name=fieldname)

        except ComponentLookupError:
            adapter = None
        if adapter:
            ret = {'fieldName': fieldname,
                   'mode': 'structure',
                   'html': adapter(field)}
        else:
            if field.getWidgetName() == "BooleanWidget":
                value = field.get(self.context)
                ret = {
                    "fieldName": fieldname,
                    "mode": "structure",
                    "html": t(_("Yes")) if value else t(_("No"))
                }
            elif field.getType().find("Reference") > -1:
                # Prioritize method retrieval over schema"s field
                targets = None
                if hasattr(self.context, "get%s" % fieldname):
                    fieldaccessor = getattr(self.context, "get%s" % fieldname)
                    if callable(fieldaccessor):
                        targets = fieldaccessor()
                if not targets:
                    targets = field.get(self.context)

                if targets:
                    if not type(targets) == list:
                        targets = [targets, ]
                    sm = getSecurityManager()
                    if all([sm.checkPermission(view, ta) for ta in targets]):
                        elements = [
                            "<div id='{id}' class='field reference'>"
                            "  <a class='link' uid='{uid}' href='{url}'>"
                            "    {title}"
                            "  </a>"
                            "</div>"
                            .format(id=target.getId(),
                                    uid=target.UID(),
                                    url=target.absolute_url(),
                                    title=target.Title())
                            for target in targets]

                        ret = {
                            "fieldName": fieldname,
                            "mode": "structure",
                            "html": "".join(elements),
                        }
                    else:
                        ret = {
                            "fieldName": fieldname,
                            "mode": "structure",
                            "html": ", ".join([ta.Title() for ta in targets]),
                        }
                else:
                    ret = {
                        "fieldName": fieldname,
                        "mode": "structure",
                        "html": "",
                    }
            elif field.getType().lower().find("datetime") > -1:
                value = field.get(self.context)
                ret = {
                    "fieldName": fieldname,
                    "mode": "structure",
                    "html": self.ulocalized_time(value, long_format=True)
                }
        return ret

    def get_field_visibility_mode(self, field):
        """Returns "view" or "edit" modes, together with the place within where
        this field has to be rendered, based on the permissions the current
        user has for the context and the field passed in
        """
        fallback_mode = ("hidden", "hidden")
        widget = field.widget

        # TODO This needs to be done differently
        # Check where the field has to be located
        layout = widget.isVisible(self.context, "header_table")
        if layout in ["invisible", "hidden"]:
            return fallback_mode

        # Check permissions. We want to display field (either in view or edit
        # modes) only if the current user has enough privileges.
        if field.checkPermission("edit", self.context):
            mode = "edit"
            sm = getSecurityManager()
            if not sm.checkPermission(ModifyPortalContent, self.context):
                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"
        else:
            return fallback_mode

        # Check if the field needs to be displayed or not, even if the user has
        # the permissions for edit or view. This may depend on criteria other
        # than permissions (e.g. visibility depending on a setup setting, etc.)
        if widget.isVisible(self.context, mode, field=field) != "visible":
            if mode == "view":
                return fallback_mode
            # The field cannot be rendered in edit mode, but maybe can be
            # rendered in view mode.
            mode = "view"
            if widget.isVisible(self.context, mode, field=field) != "visible":
                return fallback_mode
        return (mode, layout)

    def get_fields_grouped_by_location(self):
        standard = []
        prominent = []
        for field in self.context.Schema().fields():
            mode, layout = self.get_field_visibility_mode(field)
            if mode == "hidden":
                # Do not render this field
                continue
            field_mapping = {"fieldName": field.getName(), "mode": mode}
            if mode == "view":
                # Special formatting (e.g. links, etc.)
                field_mapping = self.render_field_view(field)
            if layout == "prominent":
                # Add the field at the top of the fields table
                prominent.append(field_mapping)
            else:
                # Add the field at standard location
                standard.append(field_mapping)
        return prominent, self.three_column_list(standard)


1			# -- coding: utf-8 --
2			#
3			# This file is part of SENAITE.CORE
4			#
5			# Copyright 2018 by it's authors.
6			# Some rights reserved. See LICENSE.rst, CONTRIBUTORS.rst.
7
8			from AccessControl import getSecurityManager
9			from AccessControl.Permissions import view
10			from Products.CMFCore.permissions import ModifyPortalContent
11			from Products.CMFPlone import PloneMessageFactory as _p
12			from Products.Five.browser.pagetemplatefile import ViewPageTemplateFile
13			from bika.lims import bikaMessageFactory as _
14			from bika.lims import logger
15			from bika.lims.browser import BrowserView
16			from bika.lims.interfaces import IHeaderTableFieldRenderer
17			from bika.lims.utils import t
18			from zope.component import getAdapter
19			from zope.component.interfaces import ComponentLookupError
20
21
22			class HeaderTableView(BrowserView):
23			"""Table rendered at the top in AR View
24			"""
25			template = ViewPageTemplateFile("templates/header_table.pt")
26
27			def __call__(self):
28			self.errors = {}
29			if "header_table_submitted" in self.request:
30			schema = self.context.Schema()
31			fields = schema.fields()
32			form = self.request.form
33			for field in fields:
34			fieldname = field.getName()
35			if fieldname in form:
36			# Handle (multiValued) reference fields
37			# https://github.com/bikalims/bika.lims/issues/2270
38			uid_fieldname = "{}_uid".format(fieldname)
39			if uid_fieldname in form:
40			value = form[uid_fieldname]
41			if field.multiValued:
42			value = value.split(",")
43			field.getMutator(self.context)(value)
44			else:
45			# other fields
46			field.getMutator(self.context)(form[fieldname])
47			message = _p("Changes saved.")
48			self.context.plone_utils.addPortalMessage(message, "info")
49			return self.template()
50
51			def three_column_list(self, input_list):
52			list_len = len(input_list)
53
54			# Calculate the length of the sublists
55			sublist_len = (list_len % 3 == 0 and list_len / 3 or list_len / 3 + 1)
56
57			def _list_end(num):
58			# Calculate the list end point given the list number
59			return num == 2 and list_len or (num + 1) * sublist_len
60
61			# Generate only filled columns
62			final = []
63			for i in range(3):
64			column = input_list[i * sublist_len:_list_end(i)]
65			if len(column) > 0:
66			final.append(column)
67			return final
68
69			# TODO Revisit this
70			def render_field_view(self, field):
71			fieldname = field.getName()
72			field = self.context.Schema()[fieldname]
73			ret = {"fieldName": fieldname, "mode": "view"}
74			try:
75			adapter = getAdapter(self.context,
76			interface=IHeaderTableFieldRenderer,
77			name=fieldname)
78
79			except ComponentLookupError:
80			adapter = None
81			if adapter:
82			ret = {'fieldName': fieldname,
83			'mode': 'structure',
84			'html': adapter(field)}
85			else:
86			if field.getWidgetName() == "BooleanWidget":
87			value = field.get(self.context)
88			ret = {
89			"fieldName": fieldname,
90			"mode": "structure",
91			"html": t(_("Yes")) if value else t(_("No"))
92			}
93			elif field.getType().find("Reference") > -1:
94			# Prioritize method retrieval over schema"s field
95			targets = None
96			if hasattr(self.context, "get%s" % fieldname):
97			fieldaccessor = getattr(self.context, "get%s" % fieldname)
98			if callable(fieldaccessor):
99			targets = fieldaccessor()
100			if not targets:
101			targets = field.get(self.context)
102
103			if targets:
104			if not type(targets) == list:
105			targets = [targets, ]
106			sm = getSecurityManager()
107			if all([sm.checkPermission(view, ta) for ta in targets]):
108			elements = [
109			"<div id='{id}' class='field reference'>"
110			" <a class='link' uid='{uid}' href='{url}'>"
111			" {title}"
112			" </a>"
113			"</div>"
114			.format(id=target.getId(),
115			uid=target.UID(),
116			url=target.absolute_url(),
117			title=target.Title())
118			for target in targets]
119
120			ret = {
121			"fieldName": fieldname,
122			"mode": "structure",
123			"html": "".join(elements),
124			}
125			else:
126			ret = {
127			"fieldName": fieldname,
128			"mode": "structure",
129			"html": ", ".join([ta.Title() for ta in targets]),
130			}
131			else:
132			ret = {
133			"fieldName": fieldname,
134			"mode": "structure",
135			"html": "",
136			}
137			elif field.getType().lower().find("datetime") > -1:
138			value = field.get(self.context)
139			ret = {
140			"fieldName": fieldname,
141			"mode": "structure",
142			"html": self.ulocalized_time(value, long_format=True)
143			}
144			return ret
145
146			def get_field_visibility_mode(self, field):
147			"""Returns "view" or "edit" modes, together with the place within where
148			this field has to be rendered, based on the permissions the current
149			user has for the context and the field passed in
150			"""
151			fallback_mode = ("hidden", "hidden")
152			widget = field.widget
153
154			# TODO This needs to be done differently
155			# Check where the field has to be located
156			layout = widget.isVisible(self.context, "header_table")
157			if layout in ["invisible", "hidden"]:
158			return fallback_mode
159
160			# Check permissions. We want to display field (either in view or edit
161			# modes) only if the current user has enough privileges.
162			if field.checkPermission("edit", self.context):
163			mode = "edit"
164			sm = getSecurityManager()
165			if not sm.checkPermission(ModifyPortalContent, self.context):
166			logger.warn("Permission '{}' granted for the edition of '{}', "
167			"but 'Modify portal content' not granted"
168			.format(field.write_permission, field.getName()))
169			elif field.checkPermission("view", self.context):
170			mode = "view"
171			else:
172			return fallback_mode
173
174			# Check if the field needs to be displayed or not, even if the user has
175			# the permissions for edit or view. This may depend on criteria other
176			# than permissions (e.g. visibility depending on a setup setting, etc.)
177			if widget.isVisible(self.context, mode, field=field) != "visible":
178			if mode == "view":
179			return fallback_mode
180			# The field cannot be rendered in edit mode, but maybe can be
181			# rendered in view mode.
182			mode = "view"
183			if widget.isVisible(self.context, mode, field=field) != "visible":
184			return fallback_mode
185			return (mode, layout)
186
187			def get_fields_grouped_by_location(self):
188			standard = []
189			prominent = []
190			for field in self.context.Schema().fields():
191			mode, layout = self.get_field_visibility_mode(field)
192			if mode == "hidden":
193			# Do not render this field
194			continue
195			field_mapping = {"fieldName": field.getName(), "mode": mode}
196			if mode == "view":
197			# Special formatting (e.g. links, etc.)
198			field_mapping = self.render_field_view(field)
199			if layout == "prominent":
200			# Add the field at the top of the fields table
201			prominent.append(field_mapping)
202			else:
203			# Add the field at standard location
204			standard.append(field_mapping)
205			return prominent, self.three_column_list(standard)
206

senaite / senaite.core

Branch — master (9edffc)

HeaderTableView.render_field_view() D

Complexity

Size

Duplication

Importance

How to fix Long Method Complexity

Long Method

Complexity

Duplication Side-by-Side

Filter issues like