senaite.core.z3cform.widgets.uidreference.UIDReferenceWidget.get_context() - Code Metrics - Inspection of "Support for ReferenceWidget as a subfield (subform..." - senaite/senaite.core - Measure and Improve Code Quality continuously with Scrutinizer

Passed

Pull Request — 2.x (#1879)

by Jordi

created 2021-11-18 13:14 UTC

UIDReferenceWidget.get_context() B

↳ Parent: senaite.core.z3cform.widgets.uidreference

Complexity

Conditions

Size

Total Lines	31
Code Lines	18

Duplication

Lines	0
Ratio	0 %

Importance

Changes

Metric	Value
eloc	18
dl	0
loc	31
rs	8.5666
c	0
b	0
f	0
cc	6
nop	1

# -*- coding: utf-8 -*-

import json
import string

import six

from bika.lims import api
from Products.CMFPlone.utils import base_hasattr
from senaite.app.supermodel import SuperModel
from senaite.core.interfaces import ISenaiteFormLayer
from senaite.core.schema.interfaces import IUIDReferenceField
from senaite.core.z3cform.interfaces import IUIDReferenceWidget
from plone.z3cform.fieldsets.interfaces import IDescriptiveGroup
from z3c.form import interfaces
from z3c.form.browser import widget
from z3c.form.browser.textlines import TextLinesWidget
from z3c.form.converter import TextLinesConverter
from z3c.form.interfaces import IDataConverter
from z3c.form.interfaces import IFieldWidget
from z3c.form.interfaces import ISubForm
from z3c.form.widget import FieldWidget
from zope.component import adapter
from zope.component import getUtility
from zope.component.interfaces import IFactory
from zope.interface import implementer

DISPLAY_TEMPLATE = "<a href='${url}' _target='blank'>${title}</a>"

_marker = object


@adapter(IUIDReferenceField, interfaces.IWidget)
class UIDReferenceDataConverter(TextLinesConverter):
    """Converts the raw field data for widget/field usage
    """

    def toWidgetValue(self, value):
        """Return the value w/o changes

        Note:

        All widget templates use the `get_value` method,
        which ensures a list of UIDs.

        However, `toWidgetValue` is called by `widget.update()` implicitly for
        `self.value`, which is then used by the `get_value` method again.
        """
        return value

    def toFieldValue(self, value):
        """Converts a unicode string to a list of UIDs
        """
        # remove any blank lines at the end
        value = value.rstrip("\r\n")
        return super(UIDReferenceDataConverter, self).toFieldValue(value)


@implementer(IUIDReferenceWidget)
class UIDReferenceWidget(TextLinesWidget):
    """Senaite UID reference widget
    """
    klass = u"senaite-uidreference-widget"

    def __init__(self, request, *args, **kw):
        super(UIDReferenceWidget, self).__init__(request)
        self.request = request

    def update(self):
        super(UIDReferenceWidget, self).update()
        widget.addFieldClass(self)

    def get_form(self):
        """Return the current form of the widget
        """
        form = self.form
        # form is a fieldset group
        if IDescriptiveGroup.providedBy(form):
            form = form.parentForm
        # form is a subform (e.g. DataGridFieldObjectSubForm)
        if ISubForm.providedBy(form):
            form = form.parentForm
        return form

    def get_context(self):
        """Get the current context

        NOTE: If we are in the ++add++ form, `self.context` is the container!
              Therefore, we create one here to have access to the methods.
        """
        schema_iface = self.field.interface
        if schema_iface and schema_iface.providedBy(self.context):
            return self.context

        # we might be in a subform, so try first to retrieve the object from
        # the base form itself first
        form = self.get_form()
        portal_type = getattr(form, "portal_type", None)
        context = getattr(form, "context", None)
        if api.is_object(context):
            if api.get_portal_type(context) == portal_type:
                return context

        # Hack alert!
        # we are in ++add++ form and have no context!
        # Create a temporary object to be able to access class methods
        if not portal_type:
            portal_type = api.get_portal_type(self.context)
        portal_types = api.get_tool("portal_types")
        fti = portal_types[portal_type]
        factory = getUtility(IFactory, fti.factory)
        context = factory("temporary")
        # hook into acquisition chain
        context = context.__of__(self.context)
        return context

    def attr(self, name, default=None):
        """Get the named attribute of the widget or the field
        """
        value = getattr(self, name, _marker)
        if value is _marker:
            return default
        if isinstance(value, six.string_types):
            context = self.get_context()
            if base_hasattr(context, value):
                attr = getattr(context, value)
                if callable(attr):
                    value = attr()
                else:
                    value = attr
        return value

    def get_value(self):
        """Extract the value from the request or get it from the field
        """
        # get the processed value from the `update` method
        value = self.value
        # the value might come from the request, e.g. on object creation
        if isinstance(value, six.string_types):
            value = IDataConverter(self).toFieldValue(value)
        # we handle always lists in the templates
        if value is None:
            return []
        if not isinstance(value, (list, tuple)):
            value = [value]
        # just to be sure (paranoid)
        return [uid for uid in value if api.is_uid(uid)]

    def get_api_url(self):
        portal = api.get_portal()
        portal_url = api.get_url(portal)
        api_url = "{}/@@API/senaite/v1".format(portal_url)
        return api_url

    def get_display_template(self):
        return self.attr("display_template", DISPLAY_TEMPLATE)

    def get_catalog(self):
        return self.attr("catalog", "portal_catalog")

    def get_query(self):
        return self.attr("query", {})

    def get_columns(self):
        return self.attr("columns", [])

    def get_limit(self):
        return self.attr("limit", 25)

    def is_multi_valued(self):
        return getattr(self.field, "multi_valued", False)

    def get_input_widget_attributes(self):
        """Return input widget attributes for the ReactJS component
        """
        uids = self.get_value()
        attributes = {
            "data-id": self.id,
            "data-name": self.name,
            "data-uids": uids,
            "data-api_url": self.get_api_url(),
            "data-records": dict(zip(uids, map(self.get_obj_info, uids))),
            "data-query": self.get_query(),
            "data-catalog": self.get_catalog(),
            "data-columns": self.get_columns(),
            "data-display_template": self.get_display_template(),
            "data-limit": self.get_limit(),
            "data-multi_valued": self.is_multi_valued(),
            "data-disabled": self.disabled or False,
            "data-readonly": self.readonly or False,
        }

        # convert all attributes to JSON
        for key, value in attributes.items():
            attributes[key] = json.dumps(value)

        return attributes

    def get_obj_info(self, uid):
        """Returns a dictionary with the object info
        """
        model = SuperModel(uid)
        obj_info = model.to_dict()
        obj_info["uid"] = uid
        obj_info["url"] = api.get_url(model)
        return obj_info

    def render_reference(self, uid):
        """Returns a rendered HTML element for the reference
        """
        template = string.Template(self.get_display_template())
        obj_info = self.get_obj_info(uid)
        return template.safe_substitute(obj_info)


@adapter(IUIDReferenceField, ISenaiteFormLayer)
@implementer(IFieldWidget)
def UIDReferenceWidgetFactory(field, request):
    """Widget factory for UIDReferenceField
    """
    return FieldWidget(field, UIDReferenceWidget(request))


1			# -- coding: utf-8 --
2
3			import json
4			import string
5
6			import six
7
8			from bika.lims import api
9			from Products.CMFPlone.utils import base_hasattr
10			from senaite.app.supermodel import SuperModel
11			from senaite.core.interfaces import ISenaiteFormLayer
12			from senaite.core.schema.interfaces import IUIDReferenceField
13			from senaite.core.z3cform.interfaces import IUIDReferenceWidget
14			from plone.z3cform.fieldsets.interfaces import IDescriptiveGroup
15			from z3c.form import interfaces
16			from z3c.form.browser import widget
17			from z3c.form.browser.textlines import TextLinesWidget
18			from z3c.form.converter import TextLinesConverter
19			from z3c.form.interfaces import IDataConverter
20			from z3c.form.interfaces import IFieldWidget
21			from z3c.form.interfaces import ISubForm
22			from z3c.form.widget import FieldWidget
23			from zope.component import adapter
24			from zope.component import getUtility
25			from zope.component.interfaces import IFactory
26			from zope.interface import implementer
27
28			DISPLAY_TEMPLATE = "<a href='${url}' _target='blank'>${title}</a>"
29
30			_marker = object
31
32
33			@adapter(IUIDReferenceField, interfaces.IWidget)
34			class UIDReferenceDataConverter(TextLinesConverter):
35			"""Converts the raw field data for widget/field usage
36			"""
37
38			def toWidgetValue(self, value):
39			"""Return the value w/o changes
40
41			Note:
42
43			All widget templates use the `get_value` method,
44			which ensures a list of UIDs.
45
46			However, `toWidgetValue` is called by `widget.update()` implicitly for
47			`self.value`, which is then used by the `get_value` method again.
48			"""
49			return value
50
51			def toFieldValue(self, value):
52			"""Converts a unicode string to a list of UIDs
53			"""
54			# remove any blank lines at the end
55			value = value.rstrip("\r\n")
56			return super(UIDReferenceDataConverter, self).toFieldValue(value)
57
58
59			@implementer(IUIDReferenceWidget)
60			class UIDReferenceWidget(TextLinesWidget):
61			"""Senaite UID reference widget
62			"""
63			klass = u"senaite-uidreference-widget"
64
65			def __init__(self, request, args, *kw):
66			super(UIDReferenceWidget, self).__init__(request)
67			self.request = request
68
69			def update(self):
70			super(UIDReferenceWidget, self).update()
71			widget.addFieldClass(self)
72
73			def get_form(self):
74			"""Return the current form of the widget
75			"""
76			form = self.form
77			# form is a fieldset group
78			if IDescriptiveGroup.providedBy(form):
79			form = form.parentForm
80			# form is a subform (e.g. DataGridFieldObjectSubForm)
81			if ISubForm.providedBy(form):
82			form = form.parentForm
83			return form
84
85			def get_context(self):
86			"""Get the current context
87
88			NOTE: If we are in the ++add++ form, `self.context` is the container!
89			Therefore, we create one here to have access to the methods.
90			"""
91			schema_iface = self.field.interface
92			if schema_iface and schema_iface.providedBy(self.context):
93			return self.context
94
95			# we might be in a subform, so try first to retrieve the object from
96			# the base form itself first
97			form = self.get_form()
98			portal_type = getattr(form, "portal_type", None)
99			context = getattr(form, "context", None)
100			if api.is_object(context):
101			if api.get_portal_type(context) == portal_type:
102			return context
103
104			# Hack alert!
105			# we are in ++add++ form and have no context!
106			# Create a temporary object to be able to access class methods
107			if not portal_type:
108			portal_type = api.get_portal_type(self.context)
109			portal_types = api.get_tool("portal_types")
110			fti = portal_types[portal_type]
111			factory = getUtility(IFactory, fti.factory)
112			context = factory("temporary")
113			# hook into acquisition chain
114			context = context.__of__(self.context)
115			return context
116
117			def attr(self, name, default=None):
118			"""Get the named attribute of the widget or the field
119			"""
120			value = getattr(self, name, _marker)
121			if value is _marker:
122			return default
123			if isinstance(value, six.string_types):
124			context = self.get_context()
125			if base_hasattr(context, value):
126			attr = getattr(context, value)
127			if callable(attr):
128			value = attr()
129			else:
130			value = attr
131			return value
132
133			def get_value(self):
134			"""Extract the value from the request or get it from the field
135			"""
136			# get the processed value from the `update` method
137			value = self.value
138			# the value might come from the request, e.g. on object creation
139			if isinstance(value, six.string_types):
140			value = IDataConverter(self).toFieldValue(value)
141			# we handle always lists in the templates
142			if value is None:
143			return []
144			if not isinstance(value, (list, tuple)):
145			value = [value]
146			# just to be sure (paranoid)
147			return [uid for uid in value if api.is_uid(uid)]
148
149			def get_api_url(self):
150			portal = api.get_portal()
151			portal_url = api.get_url(portal)
152			api_url = "{}/@@API/senaite/v1".format(portal_url)
153			return api_url
154
155			def get_display_template(self):
156			return self.attr("display_template", DISPLAY_TEMPLATE)
157
158			def get_catalog(self):
159			return self.attr("catalog", "portal_catalog")
160
161			def get_query(self):
162			return self.attr("query", {})
163
164			def get_columns(self):
165			return self.attr("columns", [])
166
167			def get_limit(self):
168			return self.attr("limit", 25)
169
170			def is_multi_valued(self):
171			return getattr(self.field, "multi_valued", False)
172
173			def get_input_widget_attributes(self):
174			"""Return input widget attributes for the ReactJS component
175			"""
176			uids = self.get_value()
177			attributes = {
178			"data-id": self.id,
179			"data-name": self.name,
180			"data-uids": uids,
181			"data-api_url": self.get_api_url(),
182			"data-records": dict(zip(uids, map(self.get_obj_info, uids))),
183			"data-query": self.get_query(),
184			"data-catalog": self.get_catalog(),
185			"data-columns": self.get_columns(),
186			"data-display_template": self.get_display_template(),
187			"data-limit": self.get_limit(),
188			"data-multi_valued": self.is_multi_valued(),
189			"data-disabled": self.disabled or False,
190			"data-readonly": self.readonly or False,
191			}
192
193			# convert all attributes to JSON
194			for key, value in attributes.items():
195			attributes[key] = json.dumps(value)
196
197			return attributes
198
199			def get_obj_info(self, uid):
200			"""Returns a dictionary with the object info
201			"""
202			model = SuperModel(uid)
203			obj_info = model.to_dict()
204			obj_info["uid"] = uid
205			obj_info["url"] = api.get_url(model)
206			return obj_info
207
208			def render_reference(self, uid):
209			"""Returns a rendered HTML element for the reference
210			"""
211			template = string.Template(self.get_display_template())
212			obj_info = self.get_obj_info(uid)
213			return template.safe_substitute(obj_info)
214
215
216			@adapter(IUIDReferenceField, ISenaiteFormLayer)
217			@implementer(IFieldWidget)
218			def UIDReferenceWidgetFactory(field, request):
219			"""Widget factory for UIDReferenceField
220			"""
221			return FieldWidget(field, UIDReferenceWidget(request))
222

senaite / senaite.core

Pull Request — 2.x (#1879)

UIDReferenceWidget.get_context() B

Complexity

Size

Duplication

Importance

Duplication Side-by-Side

Filter issues like