def register():
""" Register custom widgets and content-types
"""
registerWidget(EEAReferenceBrowserWidget,
title='EEA Reference Browser',
description=(('Reference widget that allows you to browse '
'or search the portal for objects to refer to.')),
used_for=('Products.Archetypes.Field.ReferenceField',))
registerType(EEARefBrowserDemo, PROJECTNAME)
def register():
""" Register custom AT widgets
"""
registerWidget(
TagsWidget,
title='EEA Tags',
description=('A Google+/Facebook like replacement '
'for the Plone keywords widget'),
used_for=('Products.Archetypes.Field.LinesField',)
)
def register():
""" Custom AT registrations
"""
registerWidget(
ManagementPlanWidget,
title="EEA Management Plan Code",
description=(
"Renders a HTML selection widget, to" " allow you enter the year and the" " EEA management plan code"
),
used_for=("eea.forms.fields.ManagementPlanField.ManagementPlanField"),
)
registerWidget(
QuickUploadWidget,
title="EEA Quick Upload",
description=("Allows you to drag&drop files directly " "from your computer's Desktop"),
)
'Value': ''})
return conditions
def getUnits(self, units=None):
return (units and "/" in units) and units.split('/') or [units]
def getHeightUnits(self):
field = self.bika_setup.Schema()['PatientConditionsHeightUnits']
return self.getUnits(field.get(self.bika_setup))
def getWeightUnits(self):
field = self.bika_setup.Schema()['PatientConditionsWeightUnits']
return self.getUnits(field.get(self.bika_setup))
def getWaistUnits(self):
field = self.bika_setup.Schema()['PatientConditionsWaistUnits']
return self.getUnits(field.get(self.bika_setup))
def getConditionValue(self, condition, unit):
conditions = self.getPatientCondition()
for cond in conditions:
if cond['Condition'] == condition \
and cond['Unit'] == unit:
return cond['Value']
return ''
registerWidget(CasePatientConditionWidget,
title='CasePatientConditionWidget',
description='Patient Condition information',)
'other' : 'Other',
'addother' : True,
})
security = ClassSecurityInfo()
security.declarePublic('process_form')
def process_form(self, instance, field, form, empty_marker=None,
emptyReturnsMarker=False):
"""
if no value or value equals 'other'
replace it with the optionally entered one
"""
value = form.get(field.getName(), empty_marker)
if value is empty_marker:
return empty_marker
if not value or value.lower() in ('other', u'other'):
# XXX is this generic enough?
other_name = "%s_other" % field.getName()
value = form.get(other_name, empty_marker)
if emptyReturnsMarker and value == '':
return empty_marker
return value, {}
InitializeClass(ComboWidget)
registerWidget(ComboWidget,
title='ComboBox',
description="Select box together with a string field.",
used_for=('Products.Archetypes.Field.StringField',)
)
_properties.update({
'macro_view' : "formattablename_view",
'format' : '%T %F %M %P %L %S',
'formatter' : {},
'abbr' : {},
'join_abbr' : '',
'withURL' : False,
})
_format_properties = ['format', 'formatter', 'abbr',
'join_abbr', 'withURL']
security = ClassSecurityInfo()
security.declarePublic('getKwArgs')
def getKwArgs(self):
"""mapping of all non-empty formatting properties"""
result = {}
for property in self._format_properties:
value = getattr(self, property, None)
if value:
result[property] = value
return result
InitializeClass(FormattableNameWidget)
registerWidget(FormattableNameWidget,
title='FormattableName',
description="Renders a formattable name.",
used_for=('Products.ATExtensions.fields.FormattableNameField',)
)
from AccessControl import ClassSecurityInfo
from Products.ATExtensions.widget import RecordsWidget as ATRecordsWidget
from Products.Archetypes.Registry import registerWidget
class RecordsWidget(ATRecordsWidget):
security = ClassSecurityInfo()
_properties = ATRecordsWidget._properties.copy()
_properties.update({
'macro': "bika_widgets/recordswidget",
'helper_js': ("bika_widgets/recordswidget.js",),
'helper_css': ("bika_widgets/recordswidget.css",),
'allowDelete': True,
})
registerWidget(RecordsWidget,
title = 'RecordsWidget',
description = (''),
)
""" Widget
"""
from Products.Archetypes.Registry import registerWidget
from eea.geotags.widget.location import GeotagsWidget
registerWidget(GeotagsWidget,
title='Geotags Widget',
description='Geotags widget',
used_for=(
'eea.geotags.field.GeotagsStringField',
'eea.geotags.field.GeotagsLinesField',
)
)
if value is empty_marker:
return empty_marker
value = value.split('-')
try:
value = DateTime(datetime(*map(int, value)))
except:
return empty_marker
return value, {}
registerWidget(
DateWidget,
title='Date widget',
description=('Date widget'),
used_for=('Products.Archetypes.Field.DateTimeField',)
)
class DatetimeWidget(DateWidget):
"""Date widget for Archetypes."""
_properties = DateWidget._properties.copy()
_properties.update({
'pattern': 'pickadate',
'pattern_options': {},
})
def _base_args(self, context, field, request):
"""Method which will calculate _base class arguments.
'macro': "bika_widgets/srtemplateartemplateswidget",
})
security = ClassSecurityInfo()
security.declarePublic('process_form')
def process_form(self, instance, field, form, empty_marker = None,
emptyReturnsMarker = False):
bsc = getToolByName(instance, 'bika_setup_catalog')
value = []
service_uids = form.get('uids', None)
return service_uids, {}
security.declarePublic('ARTemplates')
def ARTemplates(self, field, allow_edit = False):
fieldvalue = getattr(field, field.accessor)()
view = SRTemplateARTemplatesView(
self,
self.REQUEST,
fieldvalue = fieldvalue,
allow_edit = allow_edit
)
return view.contents_table(table_only = True)
registerWidget(
SRTemplateARTemplatesWidget,
title = 'SR Template AR Templates Selector',
description = ('SR Template AR Templates Selector'),
)
"""
# a poor workaround for Plone repeating itself.
# XXX this is important XXX
key = field.getName() + "_value"
if key in instance.REQUEST:
return instance.REQUEST[key], {}
value = form.get(field.getName(), empty_marker)
if not value:
return value, {}
if value is empty_marker:
return empty_marker
if emptyReturnsMarker and value == "":
return empty_marker
# we make sure that empty "value" inputs are saved as "" empty string.
for i in range(len(value)):
value[i] = dict(value[i])
if "value" not in value[i]:
value[i]["value"] = ""
instance.REQUEST[key] = value
return value, {}
def jsondumps(self, val):
return json.dumps(val)
registerWidget(RecordsWidget, title="RecordsWidget", description="")
"partition": partitions.get(service_uid, "part-1")
})
hidden = hidden_services.get(service_uid, "") == "on"
as_settings.append({"uid": service_uid, "hidden": hidden})
# set the analysis services settings
instance.setAnalysisServicesSettings(as_settings)
# This returns the value for the Analyses Schema Field
return value, {}
security.declarePublic("Analyses")
def Analyses(self, field, allow_edit=False):
"""Render Analyses Listing Table
"""
instance = getattr(self, "instance", field.aq_parent)
table = api.get_view("table_ar_template_analyses",
context=instance,
request=self.REQUEST)
# Call listing hooks
table.update()
table.before_render()
return table.ajax_contents_table()
registerWidget(ARTemplateAnalysesWidget,
title="Sample Template Analyses Layout",
description=("Sample Template Analyses Layout"))
validating=True):
field_name = field.getName()
volume = form.get("{}_volume".format(field_name), "")
unit = form.get("{}_unit".format(field_name), "")
value = "{} {}".format(volume, unit).strip()
if value is empty_marker:
return empty_marker
if emptyReturnsMarker and value == "":
return empty_marker
return value, {}
def get_unit(self, vocabulary, raw_value):
unit = api.get_unit(raw_value).strip()
if unit not in vocabulary.keys():
return ""
return unit
def get_volume(self, raw_value):
return api.get_leading_number(raw_value).strip()
registerWidget(
VolumeUnitWidget,
title="VolumeUnit",
description=("Renders and input HTML element for volume entry,"
"together with a selection list for unit"),
)
self.edit_button.get('overlay_handler', ''),
'overlay_options':
json.dumps(
self.edit_button.get(
'overlay_options', {
'filter':
'head>*,#content>*:not(div.configlet),dl.portalMessage.error,dl.portalMessage.info',
'formselector': 'form[id$="base-edit"]',
'closeselector': '[name="form.button.cancel"]',
'width': '70%',
'noform': 'close',
}))
}
registerWidget(ReferenceWidget, title='Reference Widget')
class ajaxReferenceWidgetSearch(BrowserView):
""" Source for jquery combo dropdown box
"""
def __call__(self):
plone.protect.CheckAuthenticator(self.request)
page = self.request['page']
nr_rows = self.request['rows']
sord = self.request['sord']
sidx = self.request['sidx']
colModel = json.loads(_u(self.request.get('colModel', '[]')))
discard_empty = json.loads(_c(self.request.get('discard_empty', "[]")))
rows = []
##code-section module-header #fill in your manual code here
##/code-section module-header
from zope.interface import implements
from Products.CompoundField.CompoundWidget import CompoundWidget
from Products.CMFDynamicViewFTI.browserdefault import BrowserDefaultMixin
class ArrayWidget(CompoundWidget):
"""
"""
##code-section class-header #fill in your manual code here
##/code-section class-header
_properties = CompoundWidget._properties.copy()
_properties.update({
'macro': 'ArrayWidget',
##code-section widget-properties #fill in your manual code here
##/code-section widget-properties
})
security = ClassSecurityInfo()
registerWidget(ArrayWidget,
title='ArrayWidget',
description=('no description given'),
used_for=('Products.Archetypes.Field.StringField', ))
##code-section module-footer #fill in your manual code here
##/code-section module-footer
support this, you must use it on a folderish type (derived from BaseFolder)
with 'FileAttachment' in the allowed_content_types. Create a BooleanField
and use this widget. This will display a form at the bottom of your edit
form (presuming it's the last widget, which it probably ought to be) where
you can upload images into your content type. The boolean field itself is
used to select whether an attachment download box should be presented. This
is similar to the "related items" box in Plone.
Content editors may also reference the images directly in their body
text.
Caveats: In the edit macro, the upload button may steal the default
enter-key-press in base_edit.
"""
# Use the base class properties, and add two of our own
_properties = TypesWidget._properties.copy()
_properties.update(
{
'macro': 'widget_attachmentsmanager',
'expanded': False,
}, )
# Register the widget with Archetypes
registerWidget(
AttachmentsManagerWidget,
title='Attachments manager widget',
description=('Renders controls for uploading attachments to documents', ),
used_for=('Products.Archetypes.Field.BooleanField', ))
from Products.Archetypes.Widget import StringWidget
from Products.Archetypes.Registry import registerWidget
class CaptchaWidget(StringWidget):
_properties = StringWidget._properties.copy()
_properties.update( {'macro' : "captchaField_widget"} )
registerWidget(CaptchaWidget,
title = 'Captcha widget',
description= ('Renders captcha image and string input',),
used_for = ('Products.qPloneCaptchaField.content.CaptchaField',)
)
: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)
if not check_floatable:
return value
return api.is_floatable(value) and value or default
security.declarePublic("AnalysisSpecificationResults")
def AnalysisSpecificationResults(self, field, allow_edit=False):
"""Render Analyses Specifications Table
"""
instance = getattr(self, "instance", field.aq_parent)
table = api.get_view("table_analysis_specifications",
context=instance,
request=self.REQUEST)
# Call listing hooks
table.update()
table.before_render()
return table.ajax_contents_table()
registerWidget(AnalysisSpecificationWidget,
title="Analysis Specification Results",
description=("Analysis Specification Results"))
# This file is part of Bika LIMS
#
# Copyright 2011-2016 by it's authors.
# Some rights reserved. See LICENSE.txt, AUTHORS.txt.
from AccessControl import ClassSecurityInfo
from Products.ATExtensions.widget import RecordWidget
from Products.Archetypes.Registry import registerWidget
import datetime
class DurationWidget(RecordWidget):
security = ClassSecurityInfo()
_properties = RecordWidget._properties.copy()
_properties.update({
'macro': "bika_widgets/durationwidget",
})
registerWidget(DurationWidget,
title = 'DurationWidget',
description = (''),
)
# Copyright 2018-2019 by it's authors.
# Some rights reserved, see README and LICENSE.
from Products.Archetypes.Widget import IntegerWidget as _i
from Products.Archetypes.Registry import registerPropertyType
from Products.Archetypes.Registry import registerWidget
from AccessControl import ClassSecurityInfo
_marker = []
class IntegerWidget(_i):
_properties = _i._properties.copy()
_properties.update({
'macro': "bika_widgets/integer",
'unit': '',
})
security = ClassSecurityInfo()
registerWidget(
IntegerWidget,
title='Integer',
description=('Renders a HTML text input box which '
'accepts a integer value'),
)
registerPropertyType('unit', 'string', IntegerWidget)
"""
Defines ImageInnerContentWidget
"""
__docformat__ = 'restructuredtext'
# Zope imports
from AccessControl import ClassSecurityInfo
# Archetypes imports
from Products.Archetypes.Registry import registerWidget
# Products imports
from Products.PloneArticle.widget import BaseInnerContentWidget
class ImageInnerContentWidget(BaseInnerContentWidget):
""""""
_properties = BaseInnerContentWidget._properties.copy()
_properties.update({
'macro' : "pa_imageinnercontentwidget",
})
security = ClassSecurityInfo()
registerWidget(ImageInnerContentWidget,
title='ImageInnerContent',
description=(''),
used_for=('Products.PloneArticle.field.imageinnercontent.ImageInnerContentField',)
)
for uid in service_uids:
hidden = hiddenans.get(uid, "")
hidden = True if hidden == "on" else False
outs.append({"uid": uid, "hidden": hidden})
instance.setAnalysisServicesSettings(outs)
return service_uids, {}
security.declarePublic("Analyses")
def Analyses(self, field, allow_edit=False):
""" Print analyses table
"""
fieldvalue = getattr(field, field.accessor)()
# N.B. we do not want to pass the field as the context to
# AnalysisProfileAnalysesView, but rather the holding instance
instance = getattr(self, "instance", field.aq_parent)
view = AnalysisProfileAnalysesView(instance,
self.REQUEST,
fieldvalue=fieldvalue,
allow_edit=allow_edit)
return view.contents_table(table_only=True)
registerWidget(
AnalysisProfileAnalysesWidget,
title='Analysis Profile Analyses selector',
description=('Analysis Profile Analyses selector'),
)
class SelectDescriptionWidget(SelectionWidget):
# Vocabulary= function should return extra descriptions when
# called with 'extended=True'
security = ClassSecurityInfo()
_properties = SelectionWidget._properties.copy()
_properties.update({
'macro': 'selectdescription',
'format': 'select',
})
registerWidget(SelectDescriptionWidget,
title='Select with Description',
description="Select field which uses javascript to control an extended descriptin.",
used_for=('Products.Archetypes.public.StringField',
'Products.Archetypes.Field.LinesField')
)
# Javascript
JQUERY_ONLOAD = '''\
(function($) { $(function() {
%s
});})(jQuery);
'''
class ManageDescription(BrowserView):
def __call__(self, field, context):
"""render javascript"""
return JQUERY_ONLOAD % self.renderJS(field, context)
fn + "_repeatunit"] or None
repeatPeriod = fn + "_repeatperiodselected" in form and form[
fn + "_repeatperiodselected"] or None
repeatEnabled = (repeatUnit and fn + "_repeatenabled" in form
and form[fn + "_repeatenabled"]
== 'on') and True or False
repeatUntil = fn + "_repeatuntil" in form and form[
fn + "_repeatuntil"] or None
repeatUntilEnabled = (
repeatUntil and fn + "_repeatuntilenabled" in form
and form[fn + "_repeatuntilenabled"] == 'on') and True or False
value.append({
'fromenabled': fromEnabled,
'fromdate': fromDate,
'repeatenabled': repeatEnabled,
'repeatunit': repeatUnit,
'repeatperiod': repeatPeriod,
'repeatuntilenabled': repeatUntilEnabled,
'repeatuntil': repeatUntil
})
return value, {}
registerWidget(
ScheduleInputWidget,
title='ScheduleInputWidget',
description=('Control for scheduling'),
)
form[fname] = res # stick it back in request.form
return res, {}
# TODO: multi inheritance is nasty, when it comes to overriding methods. then
# there is no clearly defined method resolution order.
class DateWidget(base.AbstractDateWidget, AbstractATDattimeWidget):
""" Date widget.
Please note: Archetypes DateTimeFields's values are Zope DateTime
instances.
"""
registerWidget(DateWidget,
title='Date widget',
description=('Date widget'),
used_for=('Products.Archetypes.Field.DateTimeField',)
)
class DatetimeWidget(base.AbstractDatetimeWidget, AbstractATDattimeWidget):
""" DateTime widget """
_properties = DateWidget._properties.copy()
_properties.update({
'macro': 'datetime_input',
})
registerWidget(DatetimeWidget,
title='Datetime widget',
description=('Datetime widget'),
used_for=('Products.Archetypes.Field.DateTimeField',)
)
})
return outvalues, {}
def jsondumps(self, val):
return json.dumps(val)
def getPatientsGender(self):
patient = self.aq_parent
return IPatient.providedBy(patient) and patient.getGender() or "dk"
def getMenstrualStatus(self):
statuses = [{
'Hysterectomy': False,
'HysterectomyYear': '',
'OvariesRemoved': False,
'OvariesRemovedNum': 0,
'OvariesRemovedYear': ''
}]
return len(self.aq_parent.getMenstrualStatus()) > 0 \
and self.aq_parent.getMenstrualStatus() \
or statuses
registerWidget(
PatientMenstrualStatusWidget,
title='PatientMenstrualStatusWidget',
description='Menstrual status information',
)
from Products.Archetypes.public import StringWidget
from Products.Archetypes.public import LinesWidget
from Products.Archetypes.Registry import registerWidget
class LatLngWidget(StringWidget):
_properties = StringWidget._properties.copy()
_properties.update({
'macro' : "latlng_widget",
})
security = ClassSecurityInfo()
#InitializeClass(LatLngWidget)
registerWidget(LatLngWidget,
title='LatLng',
description="Renders latitude and longitude fields.",
used_for=('Products.ATGoogleMaps.field.LatLngField',)
)
class PolylineWidget(LinesWidget):
_properties = LinesWidget._properties.copy()
_properties.update({
'macro' : "polyline_widget",
})
security = ClassSecurityInfo()
#InitializeClass(PolylineWidget)
registerWidget(PolylineWidget,
title='Polyline',
description="Renders polyline fields.",
[a.sort() for a in groupedIndexes.values()]
config['groupedIndexes'] = groupedIndexes
return config
def SearchResults(self, request, context, accessor):
"""search results"""
options = dict(original_context=context)
res = getMultiAdapter((accessor(), request),
name='display_query_results')
return res(**options)
registerWidget(QueryWidget,
title='Query',
description=('Field for storing a query'))
class WidgetTraverse(_WidgetTraverse):
def getConfig(self):
"""get the config"""
registry = getUtility(IRegistry)
# First grab the base config, so we can use the operations
registryreader = IQuerystringRegistryReader(registry)
registryreader.prefix = "plone.app.querystring.operation"
op_config = registryreader.parseRegistry()
# Then combine our fields
registryreader = IQuerystringRegistryReader(registry)
registryreader.prefix = "bika.lims.bika_catalog_query"
config = registryreader.parseRegistry()
# Return a dict with the options defined in the schema whose widget needs an edit button.
return {
'visible': self.edit_button.get('visible', False),
'url': self.edit_button.get('url'),
'return_fields': json.dumps(self.edit_button.get('return_fields')),
'js_controllers': json.dumps(self.edit_button.get('js_controllers',[])),
'overlay_handler': self.edit_button.get('overlay_handler', ''),
'overlay_options': json.dumps(self.edit_button.get('overlay_options',{
'filter': 'head>*,#content>*:not(div.configlet),dl.portalMessage.error,dl.portalMessage.info',
'formselector': 'form[id$="base-edit"]',
'closeselector': '[name="form.button.cancel"]',
'width': '70%',
'noform': 'close',}))
}
registerWidget(ReferenceWidget, title='Reference Widget')
class ajaxReferenceWidgetSearch(BrowserView):
""" Source for jquery combo dropdown box
"""
def __call__(self):
plone.protect.CheckAuthenticator(self.request)
page = self.request['page']
nr_rows = self.request['rows']
sord = self.request['sord']
sidx = self.request['sidx']
colModel = json.loads(_u(self.request.get('colModel', '[]')))
discard_empty = json.loads(_c(self.request.get('discard_empty', "[]")))
rows = []
from Products.Archetypes import Widget
from Products.Archetypes.Registry import registerWidget
from Products.Five.browser import BrowserView
from Products.Five.browser.pagetemplatefile import ViewPageTemplateFile
from Products.ZCatalog.CatalogBrains import AbstractCatalogBrain
from slc.treecategories.interfaces import IInlineTreeView
from zope.component import getMultiAdapter
from zope.interface import implements
class InlineTreeWidget(Widget.InAndOutWidget):
_properties = Widget.InAndOutWidget._properties.copy()
_properties.update({'macro' : 'at_widget_inlinetree'})
registerWidget(InlineTreeWidget,
title='Inline Tree',
description=('Renders a widget with selected items '
'Allows selection of more items via pop up'),
used_for=('Products.Archetypes.Field.LinesField',)
)
def getInlineTreeView(context, brain, request, field):
retval = getMultiAdapter((context, request), name='slc.treecategories.inlinetreeview')
retval.brain = brain
#Oh man, could have kept the code as it was...
retval.realob = brain.getObject()
retval.context_url = brain.getURL()
retval._field = field
return retval
class InlineTreeView(BrowserView):
implements(IInlineTreeView)
class RejectionSetupWidget(TypesWidget):
_properties = TypesWidget._properties.copy()
_properties.update({
'macro':
"bika_widgets/rejectionsetupwidget",
'helper_js': ("bika_widgets/rejectionsetupwidget.js", ),
'helper_css': ("bika_widgets/rejectionsetupwidget.css", ),
})
security = ClassSecurityInfo()
def getSortKeys(self, keys):
# return the option's keys in sorted in order to obtain a sorted set of
# options.
# checkbox object isn't an option
if 'checkbox' in keys:
keys.remove('checkbox')
if len(keys) == 0:
# Doing that in order to get one blank textfield
keys = ['blank']
return sorted(keys)
registerWidget(
RejectionSetupWidget,
title="Setup's Rejection Widget",
description=('Widget to define the rejection reasons'),
)
"""Return a list of services with specs in a category
"""
bsc = getToolByName(self, 'bika_setup_catalog')
services = []
for spec in field.getResultsRange():
service = bsc(portal_type='AnalysisService',
getKeyword=spec['keyword'])[0]
if service.getCategoryTitle == category_title:
services.append(spec)
return services
security.declarePublic('getCategoryUID')
def getCategoryUID(self, category_title):
bsc = getToolByName(self, 'bika_setup_catalog')
cats = bsc(portal_type="AnalysisCategory")
cats = [cat.UID for cat in cats if cat.title == category_title]
if cats:
return cats[0]
else:
return ""
registerWidget(
SpecWidget,
title='Analysis Services',
description=('AnalysisSpec selector.'),
)
#registerPropertyType('default_search_index', 'string', AnalysisSpecsWidget)
'popup_name' : 'mars_refpopup',
})
class MarscatWidget(BReferenceBrowserWidget):
_properties = BReferenceBrowserWidget._properties.copy()
_properties.update({
'macro': 'marscats4browser',
'image_portal_types':['Image',],
'image_method':'image_thumb',
'popup_name' : 'mars_catpopup',
'restrict_browsing_to_startup_directory': True,
})
registerWidget(MarscatWidget,
title='Mars Categories Browser',
description=('Reference widget that allows you to browse or'
'search the portal for categories to refer to.'),
used_for=('Products.marscats.Field.MarscatField',)
)
registerWidget(ReferenceBrowserWidget,
title='Reference Browser',
description=('Reference widget that allows you to browse or '
'search the portal for objects to refer to.'),
used_for=('Products.Archetypes.Field.ReferenceField',)
)
'MenstrualCycleType': MENSTRUAL_STATUSES.keys()[0],
'Pregnant': False,
'MonthOfPregnancy': 0,
'Hysterectomy': False,
'HysterectomyYear': '',
'OvariesRemoved': False,
'OvariesRemovedNum': 0,
'OvariesRemovedYear': ''
}
# Fill with patient's Menstrual status info
patient = self.aq_parent.Schema()['Patient'].get(self.aq_parent)
if patient:
pms = self.aq_parent.Schema()['MenstrualStatus'].get(
self.aq_parent)
if pms:
statuses = dict(statuses.items() + pms[0].items())
cms = self.aq_parent.Schema()['MenstrualStatus'].get(self.aq_parent)
if cms:
statuses = dict(statuses.items() + cms[0].items())
return [statuses]
registerWidget(
CaseMenstrualStatusWidget,
title='CaseMenstrualStatusWidget',
description='Menstrual status information',
)
from Products.Archetypes.Widget import StringWidget
from Products.Archetypes.Registry import registerWidget
CAPTCHA_MACRO = "captchaField_widget"
class CaptchaWidget(StringWidget):
_properties = StringWidget._properties.copy()
_properties.update( {'macro' : CAPTCHA_MACRO} )
registerWidget(CaptchaWidget,
title = 'Captcha widget',
description= ('Renders captcha image and string input',),
used_for = ('quintagroup.pfg.captcha.field.CaptchaField',)
)
as_settings = []
for service in services:
service_uid = api.get_uid(service)
hidden = hidden_services.get(service_uid, "") == "on"
as_settings.append({"uid": service_uid, "hidden": hidden})
# set the analysis services settings
instance.setAnalysisServicesSettings(as_settings)
return map(api.get_uid, services), {}
security.declarePublic("Analyses")
def Analyses(self, field, allow_edit=False):
"""Render Analyses Listing Table
"""
instance = getattr(self, "instance", field.aq_parent)
table = api.get_view("table_analysis_profile_analyses",
context=instance,
request=self.REQUEST)
# Call listing hooks
table.update()
table.before_render()
return table.ajax_contents_table()
registerWidget(AnalysisProfileAnalysesWidget,
title="Analysis Profile Analyses selector",
description=("Analysis Profile Analyses selector"),)
'default_protocol' : 'http',
})
security = ClassSecurityInfo()
security.declarePublic('process_form')
def process_form(self, instance, field, form, empty_marker=None,
emptyReturnsMarker=False):
"""
add the default protocol to the url field if there is none
"""
value = form.get(field.getName(), empty_marker)
if value is empty_marker:
return empty_marker
if emptyReturnsMarker and value in ('', {}):
return empty_marker
url = value.get('url', None)
if url and '://' not in url:
url = self.default_protocol + '://' + url
value.url = url
return value, {}
InitializeClass(LabeledUrlWidget)
registerWidget(LabeledUrlWidget,
title='LabeledUrl',
description="Renders a URL in an anchor tag "
"using label as display text.",
used_for=('Products.ATExtensions.fields.LabeledUrlField',)
)
registerPropertyType('default_protocol', 'string', LabeledUrlWidget)
"""
Returns the expected value saved in the action list object.
:set_idx: it is an integer with the position of the reflex rules set
in the widget's list.
:row_idx: is an integer with the numer of the row from the set
:element: a string with the name of the element of the action to
obtain: 'analysisservice', 'cond_row_idx', 'range0', 'range1',
'discreteresult', and_or
"""
if isinstance(set_idx, str):
set_idx = int(set_idx)
if isinstance(row_idx, str):
row_idx = int(row_idx)
cond = self.getReflexRuleElement(idx=set_idx, element='conditions')
return cond[row_idx].get(element, '')
def getAnalysts(self):
"""
This function returns a displaylist with the available analysts
"""
analysts = getUsers(self, ['Manager', 'LabManager', 'Analyst'])
return analysts.sortedByKey()
registerWidget(
ReflexTestingRulesWidget,
title="Reflex Rule Widget",
description=(
'Widget to define different actions for an analysis services result'),
)
'macro': "bika_widgets/srtemplateartemplateswidget",
})
security = ClassSecurityInfo()
security.declarePublic('process_form')
def process_form(self, instance, field, form, empty_marker = None,
emptyReturnsMarker = False):
bsc = getToolByName(instance, 'bika_setup_catalog')
value = []
service_uids = form.get('uids', None)
return service_uids, {}
security.declarePublic('ARTemplates')
def ARTemplates(self, field, allow_edit = False):
fieldvalue = getattr(field, field.accessor)()
view = SRTemplateARTemplatesView(
self,
self.REQUEST,
fieldvalue = fieldvalue,
allow_edit = allow_edit
)
return view.contents_table(table_only = True)
registerWidget(
SRTemplateARTemplatesWidget,
title = 'SR Template AR Templates Selector',
description = ('SR Template AR Templates Selector'),
)
from Products.Archetypes.Registry import registerPropertyType
from bika.lims.browser import ulocalized_time as ut
class DateTimeWidget(TypesWidget):
_properties = TypesWidget._properties.copy()
_properties.update({
'show_time': False,
'macro': "bika_widgets/datetimewidget",
'helper_js': ("bika_widgets/datetimewidget.js", ),
'helper_css': ("bika_widgets/datetimewidget.css", ),
})
security = ClassSecurityInfo()
def ulocalized_time(self, time, context, request):
val = ut(time,
long_format=self._properties['show_time'],
time_only=False,
context=context,
request=request)
return val
registerWidget(
DateTimeWidget,
title='DateTimeWidget',
description=('Simple text field, with a jquery date widget attached.'))
registerPropertyType('show_time', 'boolean')
if 'service' in form:
for uid, service in form['service'][0].items():
try:
float(form['result'][0][uid])
float(form['min'][0][uid])
float(form['max'][0][uid])
except:
continue
value.append({'uid':uid,
'result':form['result'][0][uid],
'min':form['min'][0][uid],
'max':form['max'][0][uid]})
return value, {}
security.declarePublic('ReferenceResults')
def ReferenceResults(self, field, allow_edit = False):
""" Prints a bika listing with categorized services.
field contains the archetypes field with a list of services in it
"""
fieldvalue = getattr(field, field.accessor)()
view = TableRenderShim(self,
self.REQUEST,
fieldvalue = fieldvalue,
allow_edit = allow_edit)
return view()
registerWidget(ReferenceResultsWidget,
title = 'Reference definition results',
description = ('Reference definition results.'),
)
# -*- coding: utf-8 -*-
#
# This file is part of Bika LIMS
#
# Copyright 2011-2017 by it's authors.
# Some rights reserved. See LICENSE.txt, AUTHORS.txt.
from Products.Archetypes.Widget import SelectionWidget as _s
from Products.Archetypes.Registry import registerWidget
from AccessControl import ClassSecurityInfo
class SelectionWidget(_s):
_properties = _s._properties.copy()
_properties.update({
'macro': "bika_widgets/selection",
})
security = ClassSecurityInfo()
registerWidget(SelectionWidget)
def process_form(self, instance, field, form, empty_marker=None,
emptyReturnsMarker=False):
"""
collect form values into a dictionnary suitable for field
"""
fieldName = field.getName()
value = form.get(fieldName + '_ref_uids', [])
kwargs = {}
# form record are not dictionnaries, we must create a real one
kwargs['search_criterias'] = {}
kwargs['search_criterias'].update(
form.get(fieldName + '_search_criterias', {})
)
kwargs['uids_found'] = form.get(fieldName + '_uids_found', [])
kwargs['auto_reference'] = form.get(fieldName + '_auto_reference',
False)
return value, kwargs
registerWidget(SmartListWidget,
title='SmartList',
description=(''),
used_for=('Products.PloneArticle.field.smartlistfield.SmartListField',)
)
'partition':Partitions[service_uid]})
if instance.portal_type == 'ARTemplate':
# Hidden analyses?
outs = []
hiddenans = form.get('Hidden', {})
if service_uids:
for uid in service_uids:
hidden = hiddenans.get(uid, '')
hidden = True if hidden == 'on' else False
outs.append({'uid':uid, 'hidden':hidden})
instance.setAnalysisServicesSettings(outs)
return value, {}
security.declarePublic('Analyses')
def Analyses(self, field, allow_edit = False):
""" Print analyses table
"""
fieldvalue = getattr(field, field.accessor)()
view = ARTemplateAnalysesView(self,
self.REQUEST,
fieldvalue = fieldvalue,
allow_edit = allow_edit)
return view.contents_table(table_only = True)
registerWidget(ARTemplateAnalysesWidget,
title = 'AR Template Analyses Layout',
description = ('AR Template Analyses Layout'),
)
## def match_handler(mo):
## g = mo.group
## return '="' + (g(1) or '') + (g(2) or '') + '__WIDGET_INDEX_MARKER__' + (g(4) or '') + (g(5) or '') + '"'
#html = FIELD_NAME_INDEX_REGEX.sub(match_handler, html, 0)
html = html.replace('%s000' % config.ARRAY_FIELDNAME_SEPARATOR,
'%s__WIDGET_INDEX_MARKER__' % config.ARRAY_FIELDNAME_SEPARATOR)
return html
def splitArrayFieldName(self, field_name):
# Split an array field name in name part and index part.
# We split at the last ARRAY_FIELDNAME_SEPARATOR.
split_point = field_name.rfind(config.ARRAY_FIELDNAME_SEPARATOR)
fname = field_name[0:split_point]
index = field_name[split_point+1:]
return (fname, index)
registerWidget(EnhancedArrayWidget,
title='EnhancedArrayWidget',
description=('no description given'),
used_for=('Products.Archetypes.Field.StringField',)
)
##code-section module-footer #fill in your manual code here
##/code-section module-footer
# The widget always returns a empty item (strange) when we use the
# multival option.
# Remove the empty items manually
if type(value) is types.ListType:
value = [item for item in value if item]
return value, kwargs
security.declarePublic('getGroupId')
def getGroupId(self, instance):
groupid = self.groupName
try:
translator = IGenericGroupTranslation(instance)
except ComponentLookupError:
pass
except TypeError, e:
if e[0] == 'Could not adapt':
pass
else:
raise
else:
groupid = translator.translateToRealGroupId(self.groupName)
return groupid
registerWidget(
UserAndGroupSelectionWidget,
title='User and Group Selection Widget',
description=('You can select users searched from a popup window.'),
used_for=('Products.Archetypes.Field.LinesField',
'Products.Archetypes.Field.StringField', ))
result = find(tree)
if result is None:
return u'NOT FOUND'
return result
security.declarePublic('process_form')
def process_form(self, instance, field, form, empty_marker=None,
emptyReturnsMarker=False, validating=True):
"""get values from form field"""
value = form.get(field.getName(), empty_marker)
if value is empty_marker:
return empty_marker
if emptyReturnsMarker and value == '':
return empty_marker
if value == '()':
return empty_marker
value = value.strip("|")
if self.selectMode > 1:
value = [_ for _ in value.split('|') if _.strip()]
if not value:
return empty_marker
return value, {}
registerWidget(DynatreeWidget,
title='Dynatree',
description=('Renders a tree with selected items '
'Allows selection of more items via pop up'),
used_for=('Products.Archetypes.Field.StringField',
'Products.Archetypes.Field.LinesField')
)
field,
form,
empty_marker=None,
emptyReturnsMarker=False):
service_uids = form.get('uids', None)
return service_uids, {}
security.declarePublic('Analyses')
def Analyses(self, field, instance, allow_edit=False):
"""Print analyses table
"""
if instance.portal_type == 'SampleType':
field_value = field.getAccessor(instance)()
else:
field_value = getattr(field, field.accessor)()
view = ProjectAnalysesView(self,
self.REQUEST,
field_value=field_value,
allow_edit=allow_edit)
return view.contents_table(table_only=True)
registerWidget(
ProjectAnalysesWidget,
title='Project Analyses selector',
description=('Project Analyses selector', ),
)
name = field.getName()
value = form.get(name, empty_marker)
if value == '' or value == [''] and emptyReturnsMarker:
return empty_marker
return value, {}
def is_keyword_field(self, field, source):
"""Returns whether or not a given field has a corresponding KeywordIndex
in the specified catalog (source).
"""
catalog = getToolByName(self,source)
idxs = catalog.index_objects()
filtered = [idx for idx in idxs if idx.id == field.accessor and
idx.meta_type == 'KeywordIndex' ]
return filtered != []
def makeVocab(self,list):
"""Takes in a list (of keywords) and returns a display list that
is expected by the Vocabulary machinery.
"""
dl = DisplayList()
for i in list:
dl.add(i,i)
return Vocabulary(dl, None, None)
registerWidget(AJAXAddRemoveWidget,
title = 'Add/Remove widget',
description= ('Renders a HTML widget with two list boxes and add/remove buttons',),
used_for = ('Products.Archetypes.Field.LinesField',)
)
for part_id in form['part_id'][0].keys():
value.append({
'part_id':
part_id,
'preservation_uid':
form['preservation_uid'][0][part_id],
'container_uid':
form['container_uid'][0][part_id],
})
if value:
return value, {}
security.declarePublic('Partitions')
def Partitions(self, field, allow_edit=False):
""" Print partitions table
"""
fieldvalue = getattr(field, field.accessor)()
view = ARTemplatePartitionsView(self,
self.REQUEST,
fieldvalue=fieldvalue,
allow_edit=allow_edit)
return view.contents_table(table_only=True)
registerWidget(
ARTemplatePartitionsWidget,
title='AR Template Partition Layout',
description=('AR Template Partition Layout'),
)
"""
from AccessControl import ClassSecurityInfo
from Products.Archetypes.public import StringWidget
from Products.Archetypes.Registry import registerWidget
from Products.Archetypes.Registry import registerPropertyType
class FormAutoFillWidget(StringWidget):
# Vocabulary= function should return extra descriptions when
# called with 'extended=True'
security = ClassSecurityInfo()
_properties = StringWidget._properties.copy()
_properties.update(
{"macro": "formautofill", "helper_url": None, "helper_text": "Open Subform", "icon": "autofill.png"}
)
registerPropertyType("helper_url", "string", FormAutoFillWidget)
registerPropertyType("helper_text", "string", FormAutoFillWidget)
registerPropertyType("icon", "string", FormAutoFillWidget)
registerWidget(
FormAutoFillWidget,
title="Form Auto Fill",
description="A string field which uses javascript to fill the rest of the form.",
used_for=("Products.Archetypes.public.StringField", "Products.Archetypes.Field.LinesField"),
)
# CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF
# USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR
# OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
# PERFORMANCE OF THIS SOFTWARE.
#
#$Id: COREBlogWidgets.py 133 2005-12-21 08:23:15Z ats $
#
##############################################################################
from Products.Archetypes.Widget import TypesWidget
from AccessControl import ClassSecurityInfo
from Products.Archetypes.Registry import registerWidget, registerPropertyType
class CategoryWidget(TypesWidget):
_properties = TypesWidget._properties.copy()
_properties.update({
'macro': 'cbcategory_widget',
'folderid': 'categories', #folder id for category
'helper_css': ('coreblogwidgets.css', ),
})
security = ClassSecurityInfo()
registerWidget(CategoryWidget,
title='Category widgets',
description="This is Category widget.",
used_for=('Used for selecting category.', ))
registerPropertyType('folderid', 'string', CategoryWidget)
def isRejectionEnabled(self, dd):
"""
'd' is a dictionary with the stored data in the widget like:
{u'selected': [u'a', u'b'], u'checkbox': True, u'other': 'dsadas', u'checkbox_other': True}
Return whether the checkbox of the widget is enabled or not
"""
return dd['checkbox'] if 'checkbox' in dd.keys() else False
def getRejectionReasons(self,dd):
"""
'd' is a dictionary with the stored data in the widget like:
{u'selected': [u'a', u'b'], u'checkbox': True, u'other': 'dsadas', u'checkbox_other': True}
Returns a string with the options both from selected and input items
"""
keys = dd.keys()
reasons = []
if not('checkbox' in keys ) or not(dd['checkbox']):
return 0
if 'selected' in keys:
reasons += dd['selected']
if 'other' in keys and dd['checkbox_other']:
reasons.append(dd['other'])
if len(reasons) < 1:
return "Yes, unknow"
return ', '.join(reasons)
registerWidget(RejectionWidget,
title = "Rejection Widget",
description = ('Widget to choose rejection reasons and set the rejection workflow'),
)
: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)
if not check_floatable:
return value
return api.is_floatable(value) and value or default
security.declarePublic('AnalysisSpecificationResults')
def AnalysisSpecificationResults(self, field, allow_edit = False):
""" Prints a bika listing with categorized services.
field contains the archetypes field with a list of services in it
"""
fieldvalue = getattr(field, field.accessor)()
view = AnalysisSpecificationView(self,
self.REQUEST,
fieldvalue = fieldvalue,
allow_edit = allow_edit)
return view.contents_table(table_only = True)
registerWidget(AnalysisSpecificationWidget,
title = 'Analysis Specification Results',
description = ('Analysis Specification Results'))
from Products.Archetypes.Registry import registerWidget
class CaptchaWidget(TypesWidget):
_properties = TypesWidget._properties.copy()
_properties.update({
'modes': ('edit'),
'visible': {'edit': 'visible', 'view': 'invisible'},
'macro': 'captchawidget',
})
InitializeClass(CaptchaWidget)
registerWidget(CaptchaWidget,
title='CaptchaWidget',
description=u'Renders a collective.recaptcha widget',
used_for=('collective.atcaptchavalidation.Field.CaptchaField',)
)
class CaptchaField(Field.ObjectField):
"""A field that stores strings"""
_properties = Field.ObjectField._properties.copy()
_properties.update({
'type': 'captcha',
'required': True,
'widget': CaptchaWidget,
})
security = ClassSecurityInfo()
security.declarePublic('get_template_rows')
def get_template_rows(self, num_positions, current_field_value):
try:
num_pos = int(num_positions)
except ValueError:
num_pos = 10
rows = []
i = 1
if current_field_value:
for row in current_field_value:
if num_pos > 0:
if i > num_pos:
break
rows.append(row)
i = i + 1
for i in range(i, (num_pos + 1)):
row = {
'pos': i,
'type': 'a',
'sub': 1}
rows.append(row)
return rows
registerWidget(
WorksheetTemplateLayoutWidget,
title='WS Template Analyses Layout',
description=('Worksheet analyses layout.'),
)
class AttachmentsManagerWidget(TypesWidget):
"""This widget adds support for uploading attachments into documents. To
support this, you must use it on a folderish type (derived from BaseFolder)
with 'FileAttachment' in the allowed_content_types. Create a BooleanField
and use this widget. This will display a form at the bottom of your edit
form (presuming it's the last widget, which it probably ought to be) where
you can upload images into your content type. The boolean field itself is
used to select whether an attachment download box should be presented. This
is similar to the "related items" box in Plone.
Content editors may also reference the images directly in their body
text.
Caveats: In the edit macro, the upload button may steal the default
enter-key-press in base_edit.
"""
# Use the base class properties, and add two of our own
_properties = TypesWidget._properties.copy()
_properties.update({'macro' : 'widget_attachmentsmanager',
'expanded' : False,
},)
# Register the widget with Archetypes
registerWidget(AttachmentsManagerWidget,
title = 'Attachments manager widget',
description= ('Renders controls for uploading attachments to documents',),
used_for = ('Products.Archetypes.Field.BooleanField',)
)
# 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-2019 by it's authors.
# Some rights reserved, see README and LICENSE.
from AccessControl import ClassSecurityInfo
from Products.ATExtensions.widget import RecordWidget
from Products.Archetypes.Registry import registerWidget
import datetime
class DurationWidget(RecordWidget):
security = ClassSecurityInfo()
_properties = RecordWidget._properties.copy()
_properties.update({
'macro': "bika_widgets/durationwidget",
})
registerWidget(
DurationWidget,
title='DurationWidget',
description=(''),
)
keyval = form[key][0].get(uid, '') if key in form else ''
keyval = keyval if isnumber(keyval) else ''
values[i][j][key] = keyval
return values
security.declarePublic('AnalysisSpecificationResults')
def AnalysisSpecificationResults(self, field, allow_edit=False):
fieldvalue = getattr(field, field.accessor)()
view = AnalysisSpecificationView(self,
self.REQUEST,
fieldvalue=fieldvalue,
allow_edit=allow_edit)
return view.contents_table(table_only=True)
registerWidget(AnalysisSpecificationWidget,
title='Analysis Specification Results',
description=('Analysis Specification Results'))
class AnalysisSpecificationPanicValidator:
implements(IValidator)
name = "analysisspecs_panic_validator"
def __call__(self, value, *args, **kwargs):
instance = kwargs['instance']
ts = getToolByName(instance, 'translation_service').translate
if instance.REQUEST.get('validated', '') == self.name:
return True
else:
instance.REQUEST['validated'] = self.name
newData = newData[:-1]
return (newData, value[1])
def savePostbackData(self, REQUEST, context, field, formData):
""" Gets the value of a cell
We cannot solely rely DataGridField.get which
does ObjectField.get(), since form postback data
can contain custom fields which are not directly mapped
like Zope expects (e.g. fields with more than one <input>)
XXX Need refactoring/clean up
"""
# Column code hook to form data and manipulate
# it propeply where TypesWidget.process_form doesn't
# have required functionality
for columnId in getattr(self, 'columns', {}).keys():
columnDefinition = self.getColumnDefinition(field, columnId)
formData = columnDefinition.processCellData(
REQUEST, formData, context, field, columnId)
__all__ = ('DataGridWidget')
registerWidget(DataGridWidget,
title='Data Grid',
description=('A spreadsheet like table'),
used_for=('Products.DataGridField.DataGridField', ))
