bika.lims.browser.worksheet.views.folder.FolderView.__init__() - Code Metrics - Inspection of "Fix Mine button from worksheets listing does not f..." - senaite/senaite.core - Measure and Improve Code Quality continuously with Scrutinizer

Passed

Push — 2.x ( f3c998...7cfc3d )

by Ramon

created 2023-12-12 09:19 UTC

FolderView.init() B

↳ Parent: bika.lims.browser.worksheet.views.folder

Complexity

Conditions

Size

Total Lines	149
Code Lines	122

Duplication

Lines	0
Ratio	0 %

Importance

Changes

Metric	Value
eloc	122
dl	0
loc	149
rs	7
c	0
b	0
f	0
cc	2
nop	3

How to fix Long Method

# -*- 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-2021 by it's authors.
# Some rights reserved, see README and LICENSE.

import collections
import json

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_display_list
from bika.lims.utils import get_link
from bika.lims.utils import get_progress_bar_html
from bika.lims.utils import getUsers
from bika.lims.utils import user_fullname
from Products.Archetypes.config import REFERENCE_CATALOG
from Products.CMFCore.utils import getToolByName
from Products.Five.browser.pagetemplatefile import ViewPageTemplateFile
from senaite.core.catalog import WORKSHEET_CATALOG
from senaite.core.permissions import AddWorksheet
from senaite.core.permissions.worksheet import can_add_worksheet
from senaite.core.permissions.worksheet import can_edit_worksheet
from senaite.core.permissions.worksheet import can_manage_worksheets
from plone.memoize.view import memoize


class FolderView(BikaListingView):
    """Listing view for Worksheets
    """
    template = ViewPageTemplateFile("../templates/worksheets.pt")

    def __init__(self, context, request):
        super(FolderView, self).__init__(context, request)

        self.catalog = WORKSHEET_CATALOG
        self.contentFilter = {
            "review_state": ["open", "to_be_verified", "verified", "rejected"],
            "sort_on": "created",
            "sort_order": "reverse"
        }

        self.title = self.context.translate(_("Worksheets"))
        self.description = ""

        self.icon = "{}/{}".format(
            self.portal_url,
            "++plone++senaite.core.static/assets/icons/worksheet.svg"
        )

        self.context_actions = {
            _("Add"): {
                "url": "worksheet_add",
                "icon": "++resource++bika.lims.images/add.png",
                "class": "worksheet_add",
                "permission": AddWorksheet,
            }
        }

        self.show_select_column = True
        self.show_select_all_checkbox = True
        self.selected_state = ""
        self.analyst_choices = []
        self.can_reassign = False
        self.can_manage = False

        self.rc = getToolByName(self, REFERENCE_CATALOG)

        # this is a property of self, because self.getAnalysts returns it
        self.analysts = getUsers(self, ["Manager", "LabManager", "Analyst"])
        self.analysts = self.analysts.sortedByValue()
        self.analyst_choices = []
        for a in self.analysts:
            self.analyst_choices.append({
                "ResultValue": a,
                "ResultText": self.analysts.getValue(a),
            })

        self.columns = collections.OrderedDict((
            ("getProgressPercentage", {
               "title": _("Progress")}),
            ("Title", {
                "title": _("Worksheet"),
                "index": "getId"}),
            ("Analyst", {
                "title": _("Analyst"),
                "index": "getAnalyst"}),
            ("getWorksheetTemplateTitle", {
                "title": _("Template"),
                "replace_url": "getWorksheetTemplateURL"}),
            ("getNumberOfRegularSamples", {
                "title": _("Samples")}),
            ("getNumberOfQCAnalyses", {
                "title": _("QC Analyses")}),
            ("getNumberOfRegularAnalyses", {
                "title": _("Routine Analyses")}),
            ("CreationDate", {
                "title": _("Created"),
                "index": "created"}),
            ("state_title", {
                "title": _("State"),
                "index": "review_state",
                "attr": "state_title"}),
        ))
        self.review_states = [
            {
                "id": "default",
                "title": _("Active"),
                "contentFilter": {
                    "review_state": [
                        "open",
                        "to_be_verified",
                    ],
                    "sort_on": "CreationDate",
                    "sort_order": "reverse"},
                "transitions": [],
                "custom_transitions": [],
                "columns": self.columns.keys(),
            }, {
                "id": "open",
                "title": _("Open"),
                "contentFilter": {
                    "review_state": "open",
                    "sort_on": "CreationDate",
                    "sort_order": "reverse"},
                "transitions": [],
                "custom_transitions": [],
                "columns": self.columns.keys(),
            }, {
                "id": "to_be_verified",
                "title": _("To be verified"),
                "contentFilter": {
                    "review_state": "to_be_verified",
                    "sort_on": "CreationDate",
                    "sort_order": "reverse"},
                "transitions": [],
                "custom_transitions": [],
                "columns": self.columns.keys()
            }, {
                "id": "verified",
                "title": _("Verified"),
                "contentFilter": {
                    "review_state": "verified",
                    "sort_on": "CreationDate",
                    "sort_order": "reverse"
                },
                "transitions": [],
                "custom_transitions": [],
                "columns": self.columns.keys(),
            }, {
                "id": "all",
                "title": _("All"),
                "contentFilter": {
                    "review_state": [
                        "open",
                        "to_be_verified",
                        "verified",
                        "rejected",
                    ],
                    "sort_on":"CreationDate",
                    "sort_order": "reverse"},
                "transitions":[],
                "custom_transitions": [],
                "columns": self.columns.keys(),
            }, {
                # getAuthenticatedMember does not work in __init__ so "mine" is
                # configured further in "folderitems" below.
                "id": "mine",
                "title": _("Mine"),
                "contentFilter": {
                    "review_state": [
                        "open",
                        "to_be_verified",
                        "verified",
                        "rejected"
                    ],
                    "sort_on":"CreationDate",
                    "sort_order": "reverse"},
                "transitions":[],
                "custom_transitions": [],
                "columns": self.columns.keys(),
            }
        ]

    def before_render(self):
        """Before render hook of the listing base view
        """
        super(FolderView, self).before_render()

        # disable the editable border of the Add-, Display- and Workflow menu
        self.request.set("disable_border", 1)

        # the current selected WF state
        self.selected_state = self.get_selected_state()

        self.allow_edit = self.is_edit_allowed()
        self.can_manage = self.is_manage_allowed()

        # Check if analysts can be assigned
        if self.is_analyst_assignment_allowed():
            self.can_reassign = True
            self.allow_analyst_reassignment()

        if not self.can_manage:
            # The current has no prvileges to manage WS.
            # Remove the add button
            self.context_actions = {}

        # Update the "Mine" review status with current user id
        mine = self.get_review_state("mine")
        mine["contentFilter"]["getAnalyst"] = self.member.id

        if self.show_only_mine():
            # Remove 'Mine' button and hide 'Analyst' column
            self.remove_review_state("mine")
            self.columns["Analyst"]["toggle"] = False
            self.contentFilter["getAnalyst"] = self.member.id
            for rvw in self.review_states:
                rvw["contentFilter"]["getAnalyst"] = self.member.id

    def remove_review_state(self, id):
        """Removes the review status button with the given id
        """
        ids = [review_state["id"] for review_state in self.review_states]
        if id not in ids:
            return
        index = ids.index(id)
        del self.review_states[index]

    def is_privileged_user(self):
        """Returns whether the current user is a privileged member
        """
        privileged = ["Manager", "LabManager", "RegulatoryInspector"]
        user_roles = self.member.getRoles()
        if set(privileged).intersection(user_roles):
            return True
        return False

    @memoize
    def show_only_mine(self):
        """Returns whether only the worksheets assigned to current user have
        to be displayed or not
        """
        # do not filter if user is a privileged member
        if self.is_privileged_user():
            return False

        # rely on setup's setting
        setup = api.get_setup()
        return setup.getRestrictWorksheetUsersAccess()

    def is_analyst_assignment_allowed(self):
        """Check if the analyst can be assigned
        """
        if not self.allow_edit:
            return False
        if not self.can_manage:
            return False
        if self.show_only_mine():
            return False
        return True

    def allow_analyst_reassignment(self):
        """Allow the Analyst reassignment
        """
        reassing_analyst_transition = {
            "id": "reassign",
            "title": _("Reassign")}
        for rs in self.review_states:
            if rs["id"] not in ["default", "mine", "open", "all"]:
                continue
            rs["custom_transitions"].append(reassing_analyst_transition)
        self.show_select_column = True
        self.show_workflow_action_buttons = True

    def can_add(self):
        """Check if the user is allowed to add a worksheet
        """
        return can_add_worksheet(self.context)

    def is_manage_allowed(self):
        """Check if the User is allowed to manage
        """
        return can_manage_worksheets(self.context)

    def is_edit_allowed(self):
        """Check if edit is allowed
        """
        return can_edit_worksheet(self.context)

    def get_selected_state(self):
        """Returns the current selected state
        """
        form_key = "{}_review_state".format(self.form_id)
        return self.request.get(form_key, "default")

    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
        """

        title = api.get_title(obj)
        url = api.get_url(obj)

        item["CreationDate"] = self.ulocalized_time(obj.created)

        title_link = "{}/{}".format(url, "add_analyses")
        if len(obj.getAnalysesUIDs) > 0:
            title_link = "{}/{}".format(url, "manage_results")

        item["Title"] = title
        item["replace"]["Title"] = get_link(title_link, value=title)

        # Total QC Analyses
        item["getNumberOfQCAnalyses"] = str(
            obj.getNumberOfQCAnalyses)
        # Total Routine Analyses
        item["getNumberOfRegularAnalyses"] = str(
            obj.getNumberOfRegularAnalyses)
        # Total Number of Samples
        item["getNumberOfRegularSamples"] = str(
            obj.getNumberOfRegularSamples)

        # Progress
        progress = obj.getProgressPercentage
        progress_bar_html = get_progress_bar_html(progress)
        item["replace"]["getProgressPercentage"] = progress_bar_html

        review_state = item["review_state"]
        if self.can_reassign and review_state == "open":
            item["Analyst"] = obj.getAnalyst
            item["allow_edit"] = ["Analyst"]
            item["required"] = ["Analyst"]
            item["choices"] = {"Analyst": self.analyst_choices}
        else:
            fullname = user_fullname(self.context, obj.getAnalyst)
            item["Analyst"] = fullname

        return item

    def getAnalysts(self):
        """Returns all analysts
        """
        return self.analysts

    def getWorksheetTemplates(self):
        """Returns a DisplayList with all active worksheet templates

        :return: DisplayList of worksheet templates (uid, title)
        :rtype: DisplayList
        """
        brains = self._get_worksheet_templates_brains()
        return get_display_list(brains)

    def getInstruments(self):
        """Returns a DisplayList with all active Instruments

        :return: DisplayList of worksheet templates (uid, title)
        :rtype: DisplayList
        """
        brains = self._get_instruments_brains()
        return get_display_list(brains)

    def getTemplateInstruments(self):
        """Returns worksheet templates as JSON
        """
        items = dict()
        templates = self._get_worksheet_templates_brains()
        for template in templates:
            template_obj = api.get_object(template)
            uid_template = api.get_uid(template_obj)
            instrument = template_obj.getInstrument()
            uid_instrument = ""
            if instrument:
                uid_instrument = api.get_uid(instrument)
            items[uid_template] = uid_instrument

        return json.dumps(items)

    def _get_worksheet_templates_brains(self):
        """Returns all active worksheet templates

        :returns: list of worksheet template brains
        """
        query = {
            "portal_type": "WorksheetTemplate",
            "is_active": True,
        }
        return api.search(query, "senaite_catalog_setup")

    def _get_instruments_brains(self):
        """Returns all active Instruments

        :returns: list of brains
        """
        query = {
            "portal_type": "Instrument",
            "is_active": True
        }
        return api.search(query, "senaite_catalog_setup")


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-2021 by it's authors.
19			# Some rights reserved, see README and LICENSE.
20
21			import collections
22			import json
23
24			from bika.lims import api
25			from bika.lims import bikaMessageFactory as _
26			from bika.lims.browser.bika_listing import BikaListingView
27			from bika.lims.utils import get_display_list
28			from bika.lims.utils import get_link
29			from bika.lims.utils import get_progress_bar_html
30			from bika.lims.utils import getUsers
31			from bika.lims.utils import user_fullname
32			from Products.Archetypes.config import REFERENCE_CATALOG
33			from Products.CMFCore.utils import getToolByName
34			from Products.Five.browser.pagetemplatefile import ViewPageTemplateFile
35			from senaite.core.catalog import WORKSHEET_CATALOG
36			from senaite.core.permissions import AddWorksheet
37			from senaite.core.permissions.worksheet import can_add_worksheet
38			from senaite.core.permissions.worksheet import can_edit_worksheet
39			from senaite.core.permissions.worksheet import can_manage_worksheets
40			from plone.memoize.view import memoize
41
42
43			class FolderView(BikaListingView):
44			"""Listing view for Worksheets
45			"""
46			template = ViewPageTemplateFile("../templates/worksheets.pt")
47
48			def __init__(self, context, request):
49			super(FolderView, self).__init__(context, request)
50
51			self.catalog = WORKSHEET_CATALOG
52			self.contentFilter = {
53			"review_state": ["open", "to_be_verified", "verified", "rejected"],
54			"sort_on": "created",
55			"sort_order": "reverse"
56			}
57
58			self.title = self.context.translate(_("Worksheets"))
59			self.description = ""
60
61			self.icon = "{}/{}".format(
62			self.portal_url,
63			"++plone++senaite.core.static/assets/icons/worksheet.svg"
64			)
65
66			self.context_actions = {
67			_("Add"): {
68			"url": "worksheet_add",
69			"icon": "++resource++bika.lims.images/add.png",
70			"class": "worksheet_add",
71			"permission": AddWorksheet,
72			}
73			}
74
75			self.show_select_column = True
76			self.show_select_all_checkbox = True
77			self.selected_state = ""
78			self.analyst_choices = []
79			self.can_reassign = False
80			self.can_manage = False
81
82			self.rc = getToolByName(self, REFERENCE_CATALOG)
83
84			# this is a property of self, because self.getAnalysts returns it
85			self.analysts = getUsers(self, ["Manager", "LabManager", "Analyst"])
86			self.analysts = self.analysts.sortedByValue()
87			self.analyst_choices = []
88			for a in self.analysts:
89			self.analyst_choices.append({
90			"ResultValue": a,
91			"ResultText": self.analysts.getValue(a),
92			})
93
94			self.columns = collections.OrderedDict((
95			("getProgressPercentage", {
96			"title": _("Progress")}),
97			("Title", {
98			"title": _("Worksheet"),
99			"index": "getId"}),
100			("Analyst", {
101			"title": _("Analyst"),
102			"index": "getAnalyst"}),
103			("getWorksheetTemplateTitle", {
104			"title": _("Template"),
105			"replace_url": "getWorksheetTemplateURL"}),
106			("getNumberOfRegularSamples", {
107			"title": _("Samples")}),
108			("getNumberOfQCAnalyses", {
109			"title": _("QC Analyses")}),
110			("getNumberOfRegularAnalyses", {
111			"title": _("Routine Analyses")}),
112			("CreationDate", {
113			"title": _("Created"),
114			"index": "created"}),
115			("state_title", {
116			"title": _("State"),
117			"index": "review_state",
118			"attr": "state_title"}),
119			))
120			self.review_states = [
121			{
122			"id": "default",
123			"title": _("Active"),
124			"contentFilter": {
125			"review_state": [
126			"open",
127			"to_be_verified",
128			],
129			"sort_on": "CreationDate",
130			"sort_order": "reverse"},
131			"transitions": [],
132			"custom_transitions": [],
133			"columns": self.columns.keys(),
134			}, {
135			"id": "open",
136			"title": _("Open"),
137			"contentFilter": {
138			"review_state": "open",
139			"sort_on": "CreationDate",
140			"sort_order": "reverse"},
141			"transitions": [],
142			"custom_transitions": [],
143			"columns": self.columns.keys(),
144			}, {
145			"id": "to_be_verified",
146			"title": _("To be verified"),
147			"contentFilter": {
148			"review_state": "to_be_verified",
149			"sort_on": "CreationDate",
150			"sort_order": "reverse"},
151			"transitions": [],
152			"custom_transitions": [],
153			"columns": self.columns.keys()
154			}, {
155			"id": "verified",
156			"title": _("Verified"),
157			"contentFilter": {
158			"review_state": "verified",
159			"sort_on": "CreationDate",
160			"sort_order": "reverse"
161			},
162			"transitions": [],
163			"custom_transitions": [],
164			"columns": self.columns.keys(),
165			}, {
166			"id": "all",
167			"title": _("All"),
168			"contentFilter": {
169			"review_state": [
170			"open",
171			"to_be_verified",
172			"verified",
173			"rejected",
174			],
175			"sort_on":"CreationDate",
176			"sort_order": "reverse"},
177			"transitions":[],
178			"custom_transitions": [],
179			"columns": self.columns.keys(),
180			}, {
181			# getAuthenticatedMember does not work in __init__ so "mine" is
182			# configured further in "folderitems" below.
183			"id": "mine",
184			"title": _("Mine"),
185			"contentFilter": {
186			"review_state": [
187			"open",
188			"to_be_verified",
189			"verified",
190			"rejected"
191			],
192			"sort_on":"CreationDate",
193			"sort_order": "reverse"},
194			"transitions":[],
195			"custom_transitions": [],
196			"columns": self.columns.keys(),
197			}
198			]
199
200			def before_render(self):
201			"""Before render hook of the listing base view
202			"""
203			super(FolderView, self).before_render()
204
205			# disable the editable border of the Add-, Display- and Workflow menu
206			self.request.set("disable_border", 1)
207
208			# the current selected WF state
209			self.selected_state = self.get_selected_state()
210
211			self.allow_edit = self.is_edit_allowed()
212			self.can_manage = self.is_manage_allowed()
213
214			# Check if analysts can be assigned
215			if self.is_analyst_assignment_allowed():
216			self.can_reassign = True
217			self.allow_analyst_reassignment()
218
219			if not self.can_manage:
220			# The current has no prvileges to manage WS.
221			# Remove the add button
222			self.context_actions = {}
223
224			# Update the "Mine" review status with current user id
225			mine = self.get_review_state("mine")
226			mine["contentFilter"]["getAnalyst"] = self.member.id
227
228			if self.show_only_mine():
229			# Remove 'Mine' button and hide 'Analyst' column
230			self.remove_review_state("mine")
231			self.columns["Analyst"]["toggle"] = False
232			self.contentFilter["getAnalyst"] = self.member.id
233			for rvw in self.review_states:
234			rvw["contentFilter"]["getAnalyst"] = self.member.id
235
236			def remove_review_state(self, id):
237			"""Removes the review status button with the given id
238			"""
239			ids = [review_state["id"] for review_state in self.review_states]
240			if id not in ids:
241			return
242			index = ids.index(id)
243			del self.review_states[index]
244
245			def is_privileged_user(self):
246			"""Returns whether the current user is a privileged member
247			"""
248			privileged = ["Manager", "LabManager", "RegulatoryInspector"]
249			user_roles = self.member.getRoles()
250			if set(privileged).intersection(user_roles):
251			return True
252			return False
253
254			@memoize
255			def show_only_mine(self):
256			"""Returns whether only the worksheets assigned to current user have
257			to be displayed or not
258			"""
259			# do not filter if user is a privileged member
260			if self.is_privileged_user():
261			return False
262
263			# rely on setup's setting
264			setup = api.get_setup()
265			return setup.getRestrictWorksheetUsersAccess()
266
267			def is_analyst_assignment_allowed(self):
268			"""Check if the analyst can be assigned
269			"""
270			if not self.allow_edit:
271			return False
272			if not self.can_manage:
273			return False
274			if self.show_only_mine():
275			return False
276			return True
277
278			def allow_analyst_reassignment(self):
279			"""Allow the Analyst reassignment
280			"""
281			reassing_analyst_transition = {
282			"id": "reassign",
283			"title": _("Reassign")}
284			for rs in self.review_states:
285			if rs["id"] not in ["default", "mine", "open", "all"]:
286			continue
287			rs["custom_transitions"].append(reassing_analyst_transition)
288			self.show_select_column = True
289			self.show_workflow_action_buttons = True
290
291			def can_add(self):
292			"""Check if the user is allowed to add a worksheet
293			"""
294			return can_add_worksheet(self.context)
295
296			def is_manage_allowed(self):
297			"""Check if the User is allowed to manage
298			"""
299			return can_manage_worksheets(self.context)
300
301			def is_edit_allowed(self):
302			"""Check if edit is allowed
303			"""
304			return can_edit_worksheet(self.context)
305
306			def get_selected_state(self):
307			"""Returns the current selected state
308			"""
309			form_key = "{}_review_state".format(self.form_id)
310			return self.request.get(form_key, "default")
311
312			def folderitem(self, obj, item, index):
313			"""Service triggered each time an item is iterated in folderitems.
314
315			The use of this service prevents the extra-loops in child objects.
316
317			:obj: the instance of the class to be foldered
318			:item: dict containing the properties of the object to be used by
319			the template
320			:index: current index of the item
321			"""
322
323			title = api.get_title(obj)
324			url = api.get_url(obj)
325
326			item["CreationDate"] = self.ulocalized_time(obj.created)
327
328			title_link = "{}/{}".format(url, "add_analyses")
329			if len(obj.getAnalysesUIDs) > 0:
330			title_link = "{}/{}".format(url, "manage_results")
331
332			item["Title"] = title
333			item["replace"]["Title"] = get_link(title_link, value=title)
334
335			# Total QC Analyses
336			item["getNumberOfQCAnalyses"] = str(
337			obj.getNumberOfQCAnalyses)
338			# Total Routine Analyses
339			item["getNumberOfRegularAnalyses"] = str(
340			obj.getNumberOfRegularAnalyses)
341			# Total Number of Samples
342			item["getNumberOfRegularSamples"] = str(
343			obj.getNumberOfRegularSamples)
344
345			# Progress
346			progress = obj.getProgressPercentage
347			progress_bar_html = get_progress_bar_html(progress)
348			item["replace"]["getProgressPercentage"] = progress_bar_html
349
350			review_state = item["review_state"]
351			if self.can_reassign and review_state == "open":
352			item["Analyst"] = obj.getAnalyst
353			item["allow_edit"] = ["Analyst"]
354			item["required"] = ["Analyst"]
355			item["choices"] = {"Analyst": self.analyst_choices}
356			else:
357			fullname = user_fullname(self.context, obj.getAnalyst)
358			item["Analyst"] = fullname
359
360			return item
361
362			def getAnalysts(self):
363			"""Returns all analysts
364			"""
365			return self.analysts
366
367			def getWorksheetTemplates(self):
368			"""Returns a DisplayList with all active worksheet templates
369
370			:return: DisplayList of worksheet templates (uid, title)
371			:rtype: DisplayList
372			"""
373			brains = self._get_worksheet_templates_brains()
374			return get_display_list(brains)
375
376			def getInstruments(self):
377			"""Returns a DisplayList with all active Instruments
378
379			:return: DisplayList of worksheet templates (uid, title)
380			:rtype: DisplayList
381			"""
382			brains = self._get_instruments_brains()
383			return get_display_list(brains)
384
385			def getTemplateInstruments(self):
386			"""Returns worksheet templates as JSON
387			"""
388			items = dict()
389			templates = self._get_worksheet_templates_brains()
390			for template in templates:
391			template_obj = api.get_object(template)
392			uid_template = api.get_uid(template_obj)
393			instrument = template_obj.getInstrument()
394			uid_instrument = ""
395			if instrument:
396			uid_instrument = api.get_uid(instrument)
397			items[uid_template] = uid_instrument
398
399			return json.dumps(items)
400
401			def _get_worksheet_templates_brains(self):
402			"""Returns all active worksheet templates
403
404			:returns: list of worksheet template brains
405			"""
406			query = {
407			"portal_type": "WorksheetTemplate",
408			"is_active": True,
409			}
410			return api.search(query, "senaite_catalog_setup")
411
412			def _get_instruments_brains(self):
413			"""Returns all active Instruments
414
415			:returns: list of brains
416			"""
417			query = {
418			"portal_type": "Instrument",
419			"is_active": True
420			}
421			return api.search(query, "senaite_catalog_setup")
422

senaite / senaite.core

Push — 2.x ( f3c998...7cfc3d )

FolderView.__init__() B

Complexity

Size

Duplication

Importance

How to fix Long Method

Long Method

Duplication Side-by-Side

Filter issues like

FolderView.init() B