bika.lims.browser.widgets.referenceresultswidget.ReferenceResultsView.__init__() - Code Metrics - Inspection of "New Worksheet blank/control/duplicate listings (#1..." - senaite/senaite.core - Measure and Improve Code Quality continuously with Scrutinizer

Passed

Push — master ( bcbb8c...8785a0 )

by Jordi

created 2018-11-22 19:13 UTC

ReferenceResultsView.init() B

↳ Parent: bika.lims.browser.widgets.referenceresultswidget

Complexity

Conditions

Size

Total Lines	53
Code Lines	44

Duplication

Lines	0
Ratio	0 %

Importance

Changes

Metric	Value
eloc	44
dl	0
loc	53
rs	8.824
c	0
b	0
f	0
cc	2
nop	5

How to fix Long Method

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

import collections

from AccessControl import ClassSecurityInfo
from bika.lims import api
from bika.lims import bikaMessageFactory as _
from bika.lims.browser.bika_listing import BikaListingView
from bika.lims.utils import get_image
from bika.lims.utils import get_link
from plone.memoize import view
from Products.Archetypes.Registry import registerWidget
from Products.Archetypes.Widget import TypesWidget


class ReferenceResultsView(BikaListingView):
    """Listing table to display Reference Results
    """

    def __init__(self, context, request, fieldvalue=[], allow_edit=True):
        super(ReferenceResultsView, self).__init__(context, request)

        self.catalog = "bika_setup_catalog"
        self.contentFilter = {
            "portal_type": "AnalysisService",
            "inactive_state": "active",
            "sort_on": "sortable_title",
            "sort_order": "ascending",
        }
        self.context_actions = {}

        self.show_sort_column = False
        self.show_column_toggles = False
        self.show_select_column = True
        self.show_select_all_checkbox = True
        self.pagesize = 999999
        self.allow_edit = True
        self.show_search = False
        self.omit_form = True

        # Categories
        if self.show_categories_enabled():
            self.categories = []
            self.show_categories = True
            self.expand_all_categories = False
            self.category_index = "getCategoryTitle"

        self.columns = collections.OrderedDict((
            ("Title", {
                "title": _("Service"),
                "sortable": False}),
            ("result", {
                "title": _("Expected Result"),
                "sortable": False}),
            ("error", {
                "title": _("Permitted Error %"),
                "sortable": False}),
            ("min", {
                "title": _("Min"),
                "sortable": False}),
            ("max", {
                "title": _("Max"),
                "sortable": False}),
        ))

        self.review_states = [
            {
                "id": "default",
                "title": _("All"),
                "contentFilter": {},
                "transitions": [{"id": "disallow-all-possible-transitions"}],
                "columns": self.columns.keys(),
            },
        ]

    def update(self):
        """Update hook
        """
        super(ReferenceResultsView, self).update()
        self.categories.sort()
        self.referenceresults = self.get_reference_results()

    @view.memoize
    def show_categories_enabled(self):
        """Check in the setup if categories are enabled
        """
        return self.context.bika_setup.getCategoriseAnalysisServices()

    @view.memoize
    def get_reference_results(self):
        """Return a mapping of Analysis Service -> Reference Results
        """
        referenceresults = self.context.getReferenceResults()
        return dict(map(lambda rr: (rr.get("uid"), rr), referenceresults))

    def get_editable_columns(self):
        """Return editable fields
        """
        columns = ["result", "error", "min", "max"]
        return columns

    def get_required_columns(self):
        """Return required editable fields
        """
        columns = ["result"]
        return columns

    def folderitems(self):
        """TODO: Refactor to non-classic mode
        """
        items = super(ReferenceResultsView, self).folderitems()
        self.categories.sort()
        return items

    def folderitem(self, obj, item, index):
        """Service triggered each time an item is iterated in folderitems.

        The use of this service prevents the extra-loops in child objects.

        :obj: the instance of the class to be foldered
        :item: dict containing the properties of the object to be used by
            the template
        :index: current index of the item
        """
        # ensure we have an object and not a brain
        obj = api.get_object(obj)
        uid = api.get_uid(obj)
        url = api.get_url(obj)
        title = api.get_title(obj)

        # get the category
        if self.show_categories_enabled():
            category = obj.getCategoryTitle()
            if category not in self.categories:
                self.categories.append(category)
            item["category"] = category

        rr = self.referenceresults.get(uid, {})
        item["Title"] = title
        item["replace"]["Title"] = get_link(url, value=title)
        item["allow_edit"] = self.get_editable_columns()
        item["required"] = self.get_required_columns()
        item["selected"] = rr and True or False
        item["result"] = rr.get("result", "")
        item["min"] = rr.get("min", "")
        item["max"] = rr.get("max", "")

        # Icons
        after_icons = ""
        if obj.getAccredited():
            after_icons += get_image(
                "accredited.png", title=_("Accredited"))
        if obj.getAttachmentOption() == "r":
            after_icons += get_image(
                "attach_reqd.png", title=_("Attachment required"))
        if obj.getAttachmentOption() == "n":
            after_icons += get_image(
                "attach_no.png", title=_("Attachment not permitted"))
        if after_icons:
            item["after"]["Title"] = after_icons

        return item


class ReferenceResultsWidget(TypesWidget):
    """Reference Results Widget
    """
    _properties = TypesWidget._properties.copy()
    _properties.update({
        "macro": "bika_widgets/referenceresultswidget",
        "helper_js": ("bika_widgets/referenceresultswidget.js",),
        "helper_css": ("bika_widgets/referenceresultswidget.css",)
    })

    security = ClassSecurityInfo()

    security.declarePublic("process_form")

    def process_form(self, instance, field, form,
                     empty_marker=None, emptyReturnsMarker=False):
        """Return a list of dictionaries fit for ReferenceResultsField
        consumption. Only services which have float()able entries in result,min
        and max field will be included. If any of min, max, or result fields
        are blank, the row value is ignored here.
        """
        values = {}

        # Process settings from the reference definition first
        ref_def = form.get("ReferenceDefinition")
        ref_def_uid = ref_def and ref_def[0]
        if ref_def_uid:
            ref_def_obj = api.get_object_by_uid(ref_def_uid)
            ref_results = ref_def_obj.getReferenceResults()
            # store reference results by UID to avoid duplicates
            rr_by_uid = dict(map(lambda r: (r.get("uid"), r), ref_results))
            values.update(rr_by_uid)

        # selected services
        service_uids = form.get("uids", [])

        for uid in service_uids:
            result = self._get_spec_value(form, uid, "result")
            if not result:
                # User has to set a value for result subfield at least
                continue

            # If neither min nor max have been set, assume we only accept a
            # discrete result (like if % of error was 0).
            s_min = self._get_spec_value(form, uid, "min", result)
            s_max = self._get_spec_value(form, uid, "max", result)

            service = api.get_object_by_uid(uid)
            values[uid] = {
                "keyword": service.getKeyword(),
                "uid": uid,
                "result": result,
                "min": s_min,
                "max": s_max
            }

        return values.values(), {}

    def _get_spec_value(self, form, uid, key, default=''):

        """Returns the value assigned to the passed in key for the analysis
        service uid from the passed in form.

        If check_floatable is true, will return the passed in default if the
        obtained value is not floatable
        :param form: form being submitted
        :param uid: uid of the Analysis Service the specification relates
        :param key: id of the specs param to get (e.g. 'min')
        :param check_floatable: check if the value is floatable
        :param default: fallback value that will be returned by default
        :type default: str, None
        """
        if not form or not uid:
            return default
        values = form.get(key, None)
        if not values or len(values) == 0:
            return default
        value = values[0].get(uid, default)
        return api.is_floatable(value) and value or default

    security.declarePublic("ReferenceResults")

    def ReferenceResults(self, field, allow_edit=False):
        """Render Reference Results Table
        """
        instance = getattr(self, "instance", field.aq_parent)
        table = api.get_view("table_reference_results",
                             context=instance,
                             request=self.REQUEST)
        # Call listing hooks
        table.update()
        table.before_render()
        return table.ajax_contents_table()


registerWidget(ReferenceResultsWidget,
               title="Reference definition results",
               description=("Reference definition results."),)


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		import collections
9
10		from AccessControl import ClassSecurityInfo
11		from bika.lims import api
12		from bika.lims import bikaMessageFactory as _
13		from bika.lims.browser.bika_listing import BikaListingView
14		from bika.lims.utils import get_image
15		from bika.lims.utils import get_link
16		from plone.memoize import view
17		from Products.Archetypes.Registry import registerWidget
18		from Products.Archetypes.Widget import TypesWidget
19
20
21		class ReferenceResultsView(BikaListingView):
22		"""Listing table to display Reference Results
23		"""
24
25		def __init__(self, context, request, fieldvalue=[], allow_edit=True):
26		super(ReferenceResultsView, self).__init__(context, request)
27
28		self.catalog = "bika_setup_catalog"
29		self.contentFilter = {
30		"portal_type": "AnalysisService",
31		"inactive_state": "active",
32		"sort_on": "sortable_title",
33		"sort_order": "ascending",
34		}
35		self.context_actions = {}
36
37		self.show_sort_column = False
38		self.show_column_toggles = False
39		self.show_select_column = True
40		self.show_select_all_checkbox = True
41		self.pagesize = 999999
42		self.allow_edit = True
43		self.show_search = False
44		self.omit_form = True
45
46		# Categories
47		if self.show_categories_enabled():
48		self.categories = []
49		self.show_categories = True
50		self.expand_all_categories = False
51		self.category_index = "getCategoryTitle"
52
53		self.columns = collections.OrderedDict((
54		("Title", {
55		"title": _("Service"),
56		"sortable": False}),
57		("result", {
58		"title": _("Expected Result"),
59		"sortable": False}),
60		("error", {
61		"title": _("Permitted Error %"),
62		"sortable": False}),
63		("min", {
64		"title": _("Min"),
65		"sortable": False}),
66		("max", {
67		"title": _("Max"),
68		"sortable": False}),
69		))
70
71		self.review_states = [
72		{
73		"id": "default",
74		"title": _("All"),
75		"contentFilter": {},
76		"transitions": [{"id": "disallow-all-possible-transitions"}],
77		"columns": self.columns.keys(),
78		},
79		]
80
81		def update(self):
82		"""Update hook
83		"""
84		super(ReferenceResultsView, self).update()
85		self.categories.sort()
86		self.referenceresults = self.get_reference_results()
87
88		@view.memoize
89		def show_categories_enabled(self):
90		"""Check in the setup if categories are enabled
91		"""
92		return self.context.bika_setup.getCategoriseAnalysisServices()
93
94		@view.memoize
95		def get_reference_results(self):
96		"""Return a mapping of Analysis Service -> Reference Results
97		"""
98		referenceresults = self.context.getReferenceResults()
99		return dict(map(lambda rr: (rr.get("uid"), rr), referenceresults))
100
101		def get_editable_columns(self):
102		"""Return editable fields
103		"""
104		columns = ["result", "error", "min", "max"]
105		return columns
106
107		def get_required_columns(self):
108		"""Return required editable fields
109		"""
110		columns = ["result"]
111		return columns
112
113		def folderitems(self):
114		"""TODO: Refactor to non-classic mode
115		"""
116		items = super(ReferenceResultsView, self).folderitems()
117		self.categories.sort()
118		return items
119
120		def folderitem(self, obj, item, index):
121		"""Service triggered each time an item is iterated in folderitems.
122
123		The use of this service prevents the extra-loops in child objects.
124
125		:obj: the instance of the class to be foldered
126		:item: dict containing the properties of the object to be used by
127		the template
128		:index: current index of the item
129		"""
130		# ensure we have an object and not a brain
131		obj = api.get_object(obj)
132		uid = api.get_uid(obj)
133		url = api.get_url(obj)
134		title = api.get_title(obj)
135
136		# get the category
137		if self.show_categories_enabled():
138		category = obj.getCategoryTitle()
139		if category not in self.categories:
140		self.categories.append(category)
141		item["category"] = category
142
143		rr = self.referenceresults.get(uid, {})
144		item["Title"] = title
145		item["replace"]["Title"] = get_link(url, value=title)
146		item["allow_edit"] = self.get_editable_columns()
147		item["required"] = self.get_required_columns()
148		item["selected"] = rr and True or False
149		item["result"] = rr.get("result", "")
150		item["min"] = rr.get("min", "")
151		item["max"] = rr.get("max", "")
152
153		# Icons
154		after_icons = ""
155		if obj.getAccredited():
156		after_icons += get_image(
157		"accredited.png", title=_("Accredited"))
158		if obj.getAttachmentOption() == "r":
159		after_icons += get_image(
160		"attach_reqd.png", title=_("Attachment required"))
161		if obj.getAttachmentOption() == "n":
162		after_icons += get_image(
163		"attach_no.png", title=_("Attachment not permitted"))
164		if after_icons:
165		item["after"]["Title"] = after_icons
166
167		return item
168
169
170		class ReferenceResultsWidget(TypesWidget):
171		"""Reference Results Widget
172		"""
173		_properties = TypesWidget._properties.copy()
174		_properties.update({
175		"macro": "bika_widgets/referenceresultswidget",
176		"helper_js": ("bika_widgets/referenceresultswidget.js",),
177		"helper_css": ("bika_widgets/referenceresultswidget.css",)
178		})
179
180		security = ClassSecurityInfo()
181
182		security.declarePublic("process_form")
183
184		def process_form(self, instance, field, form,
185		empty_marker=None, emptyReturnsMarker=False):
186		"""Return a list of dictionaries fit for ReferenceResultsField
187		consumption. Only services which have float()able entries in result,min
188		and max field will be included. If any of min, max, or result fields
189		are blank, the row value is ignored here.
190		"""
191		values = {}
192
193		# Process settings from the reference definition first
194		ref_def = form.get("ReferenceDefinition")
195		ref_def_uid = ref_def and ref_def[0]
196		if ref_def_uid:
197		ref_def_obj = api.get_object_by_uid(ref_def_uid)
198		ref_results = ref_def_obj.getReferenceResults()
199		# store reference results by UID to avoid duplicates
200		rr_by_uid = dict(map(lambda r: (r.get("uid"), r), ref_results))
201		values.update(rr_by_uid)
202
203		# selected services
204		service_uids = form.get("uids", [])
205
206		for uid in service_uids:
207		result = self._get_spec_value(form, uid, "result")
208		if not result:
209		# User has to set a value for result subfield at least
210		continue
211
212		# If neither min nor max have been set, assume we only accept a
213		# discrete result (like if % of error was 0).
214		s_min = self._get_spec_value(form, uid, "min", result)
215		s_max = self._get_spec_value(form, uid, "max", result)
216
217		service = api.get_object_by_uid(uid)
218		values[uid] = {
219		"keyword": service.getKeyword(),
220		"uid": uid,
221		"result": result,
222		"min": s_min,
223		"max": s_max
224		}
225
226		return values.values(), {}
227
228	View Code Duplication	def _get_spec_value(self, form, uid, key, default=''):
		0 ignored issues – show Duplication introduced 2018-07-25 08:58 UTC by Report Bug Copy Issue Report This code seems to be duplicated in your project. Loading history...
229		"""Returns the value assigned to the passed in key for the analysis
230		service uid from the passed in form.
231
232		If check_floatable is true, will return the passed in default if the
233		obtained value is not floatable
234		:param form: form being submitted
235		:param uid: uid of the Analysis Service the specification relates
236		:param key: id of the specs param to get (e.g. 'min')
237		:param check_floatable: check if the value is floatable
238		:param default: fallback value that will be returned by default
239		:type default: str, None
240		"""
241		if not form or not uid:
242		return default
243		values = form.get(key, None)
244		if not values or len(values) == 0:
245		return default
246		value = values[0].get(uid, default)
247		return api.is_floatable(value) and value or default
248
249		security.declarePublic("ReferenceResults")
250
251		def ReferenceResults(self, field, allow_edit=False):
252		"""Render Reference Results Table
253		"""
254		instance = getattr(self, "instance", field.aq_parent)
255		table = api.get_view("table_reference_results",
256		context=instance,
257		request=self.REQUEST)
258		# Call listing hooks
259		table.update()
260		table.before_render()
261		return table.ajax_contents_table()
262
263
264		registerWidget(ReferenceResultsWidget,
265		title="Reference definition results",
266		description=("Reference definition results."),)
267

senaite / senaite.core

Push — master ( bcbb8c...8785a0 )

ReferenceResultsView.__init__() B

Complexity

Size

Duplication

Importance

How to fix Long Method

Long Method

Duplication Side-by-Side

Filter issues like

ReferenceResultsView.init() B