class IMockCollection(Interface):
query = schema.List(value_type=schema.Dict(value_type=schema.Field(),
key_type=schema.TextLine()), )
query_invalid = schema.List(value_type=schema.Dict(
value_type=schema.Field(), key_type=schema.TextLine()), )
sort_reversed = schema.Bool()
sort_on = schema.TextLine()
class IPFGSharePointConfig(Interface):
"""Interface to configure the collective.pfgsharepoint
"""
clientid = schema.TextLine(
title=_(u"Microsoft App Client ID"),
description=
_(u'Register app with Microsoft and get a Client ID here: https://apps.dev.microsoft.com/.'
),
required=False,
)
clientsecret = schema.Password(
title=_(u"Microsoft App Client Secret"),
description=
_(u'You can generate a new password here: https://apps.dev.microsoft.com/.'
),
required=False,
)
tenants = schema.Dict(
title=_(u"SharePoint Tenants"),
description=
_(u"This setting should only be modified by visiting the @@sharepoint-permissions page"
),
required=False,
key_type=schema.TextLine(title=_(u"Tenant GUID")),
value_type=schema.Dict(
title=_("Tenant Properties"),
key_type=schema.TextLine(title=_(u"Tenant Property")),
value_type=schema.TextLine(title=_(u"Tenant Property Value"),
required=False),
),
)
class IDestaqueTile(IListTile):
uuids = schema.Dict(
title=_(u'Elements'),
key_type=schema.TextLine(),
value_type=schema.Dict(
key_type=schema.TextLine(),
value_type=schema.TextLine(),
),
required=False,
)
title = schema.List(
title=_(u'Title'),
required=False,
readonly=True,
)
description = schema.Text(
title=_(u'Description'),
required=False,
readonly=True,
)
image = NamedImage(
title=_(u'Image'),
required=False,
readonly=True,
)
class INECDVocabularies(Interface):
projection_pollutants = schema.Dict(
title=_(u"Projection pollutants vocabulary"),
description=_(u"Registers the values for pollutants in the context of "
u"a Projection ReviewFolder"),
key_type=schema.TextLine(title=_(u"Pollutant key")),
value_type=schema.TextLine(title=_(u"Pollutant value"),),
)
projection_parameter = schema.Dict(
title=_(u"Projection parameter vocabulary"),
description=_(u"Registers the values for parameter in the context of "
u"a Projection ReviewFolder"),
key_type=schema.TextLine(title=_(u"Parameter key")),
value_type=schema.TextLine(title=_(u"Parameter value"),),
)
activity_data = schema.Dict(
title=_(u"Activity data"),
description=_(u"Registers the activity data"),
key_type=schema.TextLine(title=_(u"Activity data type")),
value_type=schema.List(value_type=schema.TextLine(
title=_(u"Activity data"),
),)
)
class IErgebnisdaten(model.Schema):
""" Marker interface and Dexterity Python Schema for Ergebnisdaten
"""
maschnr = schema.TextLine(title=u"Maschinen-Nummer", required=False)
hersteller = schema.TextLine(title=u"Hersteller der Maschine",
required=False)
fragebogen = schema.TextLine(title=u"ID des Frageboges", required=True)
fortschritt = schema.Float(title=u"Fortschritt des Fragebogens",
required=False)
notizen = schema.Dict(
title=u"Notizen des Fragebogens",
required=False,
key_type=schema.TextLine(),
value_type=schema.Text(),
)
history = schema.List(title=u"Historie der aufgerufenen Fragen",
required=True,
value_type=schema.TextLine())
daten = schema.Dict(title=u"Daten des Fragebogens",
required=False,
key_type=schema.TextLine(),
value_type=schema.Dict(key_type=schema.TextLine(),
value_type=schema.TextLine()))
class ICrowdsUtility(Interface):
"""Crowds Utility holds registered security information"""
factories = schema.Dict(title=u"Crowd Factories",
description=u"Maps crowd names to crowd factories")
crowds = schema.Dict(
title=u"Permission Crowds",
description=u"Maps (permission, interface)s to crowd names")
class ICatalogTableSourceConfig(ITableSourceConfig):
"""Marker interface for table source configurations used by the
portal_catalog table source.
See: catalog_source.py
"""
filter_path = schema.TextLine(
title=u'Path filter',
description=u'Only show objects within this path. If the path is None '
'no path filter will be applied (all objects are shown). See also '
'the `depth` attribute.',
default=None)
depth = schema.Int(
title=u'Recursivity depth',
description=u'Defines the recursivity depth, how depth the contents '
'should be searched. If it set to -1 (default) the recursivity is '
'infinite, that means all direct or indirect children are found. If '
'set to 1 it will only find direct children. If set to 0 it will only '
'find the current context if it matches the other criterias.',
default=-1)
types = schema.List(title=u'Portal types filter',
description=u'Filter results by portal type.',
value_type=schema.TextLine(),
default=[])
object_provides = schema.TextLine(
title=u'Object provides interface dotted name',
description=u'Interface name which the objects have to provide.')
search_options = schema.Dict(
title=u'Additional search options',
description=u'Additional options for filtering results.',
key_type=schema.TextLine(),
value_type=schema.Field(),
default={})
custom_sort_indexes = schema.Dict(
title=u'Custom sort indexes',
description=u'Provides custom sort mechanisms for certain '
'index types.',
key_type=schema.TextLine(
title=u'portal_catalog index type',
description=u'Name of a portal_catalog index type '
'(e.g. Products.PluginIndexes.DateIndex.DateIndex)'),
value_type=schema.Field(
title=u'custom sort method',
description=u'pointer to a custom sort method (e.g. '
'lambda results, sort_on, reverse: ...)'))
search_index = schema.TextLine(
title=u'Search index',
description=u'Search the `filter_text` in this index.',
default=u'SearchableText')
class IDraftStorage(Interface):
"""Persistent draft storage.
Normally available as a local utility.
"""
enabled = schema.Bool(
title=u'Whether drafting is enabled',
default=True,
)
drafts = schema.Dict(
title=u'Drafts',
description=u'Use the methods below to inspect and manipulate this',
key_type=schema.TextLine(title=u'User id'),
value_type=schema.Dict(
key_type=schema.TextLine(title=u'Draft target key'),
value_type=schema.Dict(
key_type=schema.TextLine(title=u'Draft name'),
value_type=schema.Object(schema=IDraft),
),
),
)
def createDraft(userId, targetKey, factory=None):
"""Create a new draft for the given user id and target, indicated by
a string key (normally a string representation for an uuid, but may be
more complex). Returns the new draft.
The ``factory`` parameter can be used to pass a custom factory to
create the draft object. It should be callable that takes two
arguments: userId and soruceKey. The factory may set the ``__name__``
attribute on the returned draft. This will be used, but may have a
numeric suffix appended to ensure uniqueness.
If ``factory`` is omitted, a basic, annotatable ``IDraft`` object will
be created.
"""
def discardDrafts(userId, targetKey=None):
"""Discard all drafts under the given userId and target key. If
``targetKey`` is not given, discard all drafts for the given user.
"""
def discardDraft(draft):
"""Discard a particular draft.
"""
def getDrafts(userId, targetKey):
"""Get a list mappping of all drafts under the given userId and
target key. The returned mapping should not be modified directly.
"""
def getDraft(userId, targetKey, draftName, default=None):
"""Get a particular named draft. If not found, the default is
class IPloneCacheSettings(Interface):
"""Settings stored in the registry.
Basic cache settings are represented by
``plone.caching.interfaces.ICacheSettings``. These are additional,
Plone-specific settings.
"""
enableCompression = schema.Bool(
title=_(u"Enable GZip compression"),
description=_(u"Determine whether GZip compression should be "
u"enabled for standard responses"),
default=False,
required=True,
)
templateRulesetMapping = schema.Dict(
title=_(u"Page template/ruleset mapping"),
description=_(u"Maps skin layer page template names to ruleset names"),
key_type=schema.ASCIILine(title=_(u"Page template name")),
value_type=schema.DottedName(title=_(u"Ruleset name")),
)
contentTypeRulesetMapping = schema.Dict(
title=_(u"Content type/ruleset mapping"),
description=_(u"Maps content type names to ruleset names"),
key_type=schema.ASCIILine(title=_(u"Content type name")),
value_type=schema.DottedName(title=_(u"Ruleset name")),
)
purgedContentTypes = schema.Tuple(
title=_(u"Content types to purge"),
description=_(
u"List content types which should be purged when modified"),
value_type=schema.ASCIILine(title=_(u"Content type name")),
default=(
'File',
'Image',
'News Item',
),
)
cacheStopRequestVariables = schema.Tuple(
title=_(u"Request variables that prevent caching"),
description=_(
u"Variables in the request that prevent caching if present"),
value_type=schema.ASCIILine(title=_(u"Request variables")),
default=(
'statusmessages',
'SearchableText',
),
)
class IImagesTileSchema(model.Schema):
form.widget(use_query=UseQueryWidget)
use_query = schema.Bool(title=u'Use dynamic query', default=False)
form.widget('images', ImageRelatedItemsFieldWidget)
images = schema.List(
title=u"Images",
description=u"Select images or folders of images to display in "
u"gallery",
value_type=schema.Choice(vocabulary='plone.app.vocabularies.Catalog'),
required=False)
form.widget(query=QueryFieldWidget)
query = schema.List(
title=u'Search terms',
description=u"Define the search terms for the images you want to use. "
u"The list of results will be dynamically updated",
value_type=schema.Dict(value_type=schema.Field(),
key_type=schema.TextLine()),
required=False)
sort_on = schema.TextLine(
title=u'Sort on',
description=u"Sort on this index",
required=False,
)
sort_reversed = schema.Bool(
title=u'Reversed order',
description=u'Sort the results in reversed order',
required=False,
)
class IAggregateDescription(Interface):
"""
Mixin of fields related to aggregating multiple data points into
a single descriptive aggretate point. All fields optional, and
only considered relevant to aggregation of data from multiple
sources or samples.
'distribution' attribute would have values that look like:
[{ "value": 75.0, "sample_size": 8 }, { "value": 80, "sample_size": 10}]
This data is sufficient to compute:
- The sum of sample sizes.
- The weighted mean.
- The original numerator values as value/100.0 * sample_size
- Presuming the value looks like a percentage.
- The arithmetic mean.
- Distribution plot.
- Median, quartile boundary, and therefore box plot.
"""
distribution = schema.List(
title=_(u'Distribution data'),
description=_(u'List of dict containing value, sample size for each '
u'sample in aggregation.'),
required=False,
value_type=schema.Dict(key_type=schema.BytesLine(),
value_type=schema.Object(
schema=Interface,
description=u'Value, may be int or float')))
class IGeoTags(Interface):
""" Accessor/Mutator for geo tags annotations
"""
tags = schema.Dict(title=u"Geojson tags")
def getPoints(self):
""" Returns a list of points as lat,long pairs in
class IQueryChoice(IChoice):
query = schema.List(
title=u'Query',
value_type=schema.Dict(value_type=schema.Field(),
key_type=schema.TextLine()),
required=False
)
sort_on = schema.TextLine(
title=u'Sort on',
required=False,
default=u'effective'
)
sort_reversed = schema.Bool(
title=u'Reversed order',
required=False,
default=True
)
limit = schema.Int(
title=u'Limit',
required=False,
default=15,
min=1,
)
class ISettingsClustering(Interface):
nClusters = schema.Int(
title=_(u"Number of clusters"),
description=_(u"Maximum number of clusters"),
)
clusteringFile = schema.TextLine(
title=_(u"Cluster model file name"),
description=_(
u"The filename that will be stored into directory storage"),
)
clustersTerms = schema.Dict(
title=_(u"Top terms per cluster"),
description=_(u"Learned clusters and top terms for each. "
u"Needs Vectorizer remembering."),
required=False,
readonly=True,
key_type=schema.Int(required=False),
value_type=schema.List(
value_type=schema.TextLine(required=False),
required=False,
),
)
class IEtcConfigSection(Interface):
""" Representation of a [section] within *.conf files """
section = schema.TextLine(title=u"Section", min_length=1, readonly=True)
settings = schema.Dict(title=u'Settings',
key_type=schema.TextLine(),
value_type=schema.TextLine(),
readonly=True)
class IContentSettings(Interface):
file_upload_fields = schema.List(
title=u'File upload fields',
description=
u'These fields will map to content field values after uploaded.',
value_type=schema.Dict(key_type=schema.TextLine(),
value_type=schema.TextLine()))
class IFormComponents(Interface):
"""
Adapter interface for an object providing access to the respective
components making up the form definition:
* An ordered tuple of names of fieldsets made up from the
definition itself and field groups contained.
* An (unordered) mapping / dict of name to group (IFieldGroup
or IFieldDefinition -- anything providing either) values.
Titles and schema for the groups should be obtained by calling
code using this adapter, and are not provided by the adapter
interface itself. This also means the responsibility to wrap
field group schema declared as a grid aslo is ommitted from the
scope of this adapter.
"""
names = schema.Tuple(
title=u'Fieldset names',
value_type=schema.BytesLine(),
defaultFactory=list, # req zope.schema > 3.8.0
readonly=True, # read-only property
)
groups = schema.Dict(
title=u'Fieldset groups',
key_type=schema.BytesLine(),
value_type=schema.Object(schema=IDefinitionBase),
defaultFactory=dict, # req zope.schema > 3.8.0
readonly=True, # read-only dict, though groups are mutable
)
class IPasterConfiguration(Interface):
name = schema.BytesLine(
title=u"name",
description=u"This is a configuration of paster templates",
required=True)
templates = schema.Dict(title=u"templates", )
plugins = schema.List(title=u"plugins", )
class ICalendarTileSchema(Interface):
form.widget(query=QueryFieldWidget)
query = schema.List(
title=u'Base query',
description=u"This query can be customized base on user selection",
value_type=schema.Dict(value_type=schema.Field(),
key_type=schema.TextLine()),
required=False,
default=[{
u'i': u'portal_type',
u'v': [u'Event'],
u'o': u'plone.app.querystring.operation.selection.any'
}])
sort_on = schema.TextLine(
title=u'Sort on',
description=u"Sort on this index",
required=False,
)
sort_reversed = schema.Bool(
title=u'Reversed order',
description=u'Sort the results in reversed order',
required=False,
)
limit = schema.Int(
title=u'Limit',
description=u'Limit Search Results',
required=False,
default=250,
min=1,
)
class IEvaluation(model.Schema):
directives.omitted('evaluations')
# show debug tab
# from plone import api
# if api.env.debug_mode():
# directives.no_omit(IEditForm, 'evaluations')
fieldset(
'debug',
label=u'debug',
fields=('evaluations', )
)
evaluations = schema.Dict(
title=u'Evaluation info',
key_type=schema.TextLine(title=u'User ID'),
value_type=schema.TextLine(title=u'Evaluation'),
required=False)
def evaluate(evaluation, userid):
"""
Store the evaluation information, store the user id to ensure
that the user does not vote twice
"""
def already_evaluated(userid):
"""
Return the information wether a person already evaluated.
"""
def clear():
"""
class ITimeSeriesChart(IBaseChart, ITimeSeriesCollection):
"""Chart content item; container for sequences"""
form.order_after(auto_crop='frequency')
auto_crop = schema.Bool(
title=u'Auto-crop to completed data?',
description=u'If data contains sequential null values (incomplete '
u'or no data calculable) on the right-hand of a '
u'time-series plot, should that right-hand side '
u'be cropped to only show the latest meaningful '
u'data? The default is to crop automatically.',
default=True,
)
form.order_after(force_crop='auto_crop')
force_crop = schema.Bool(
title=u'Forced crop of data?',
description=u'If data points are available before a specified '
u'start date or after a specified end-date, should '
u'those points be excluded from the visualization?',
default=False,
)
form.omitted('label_overrides')
label_overrides = schema.Dict(
key_type=schema.Date(),
value_type=schema.BytesLine(),
required=False,
)
def series():
"""
class IPortletRenderer(IContentProvider):
"""A special implementation of a content provider which is managed
by an IPortletManager.
Any object providing IPortletDataProvider should be adaptable to
IPortletRenderer in order to be renderable as a portlet. (In fact,
the return value of IPortletAssignment.data needs to have such an
adapter, regardless of whether it actually implements IPortletDataProvider)
"""
__portlet_metadata__ = schema.Dict(
title=u"Metadata",
description=
u"Information about the portlet set during portlet retrieval",
required=True,
readonly=True,
key_type=schema.ASCIILine(),
value_type=schema.TextLine(),
)
available = schema.Bool(
title=u'Available',
description=u'Whether or not this portlet shuld be rendered',
required=True,
readonly=True)
class ISchemaFormData(model.Schema):
"""Center of Responsibility (CDR)
"""
directives.widget('schema_form_data', RawDictWidgetFactory)
schema_form_data = schema.Dict(
title=_(u'Schema form data'),
readonly=True, # to make the field readonly, and possible to set using some event based code or method. that is normally the use case
required=False)
class IUser(Form.Schema):
promoCode = schema.Dict(
title=_(u'Exist PromoCode'),
key_type=schema.ASCIILine(),
value_type=schema.ASCIILine(),
required=False,
)
def test_nested_dicts(self):
field = schema.Dict(
key_type=schema.Int(),
value_type=schema.Dict(
key_type=schema.Int(),
value_type=schema.TextLine(),
),
)
value = {}
self._assertSerialized(field, value, '<value />')
value = {1: {2: 'two'}, 3: {4: 'four', 5: 'five'}, 6: {}}
self._assertSerialized(
field, value, '<value>'
'<element key="1"><element key="2">two</element></element>'
'<element key="3"><element key="4">four</element><element key="5">five</element></element>'
'<element key="6" />'
'</value>')
class IMembershipModifications(Interface):
"""
User modifications adapter: an unordered queue for bulk changes that
are applied to a workspace context:
* context is workspace, which is adapted to IMembershipModifications;
* Each assignment or un-assignment is role-group specific, and is
queued until self.apply() is called.
"""
planned_assign = schema.Dict(
description=u'Queue of additions to assigned users, to be '
'applied to context when self.apply() is called. '
'Should be emptied on successful self.apply(). '
'Keys are role names like "viewers"; values are '
'each a set of string user names.',
key_type=schema.BytesLine(),
value_type=schema.Set(value_type=schema.BytesLine()),
)
planned_unassign = schema.Dict(
description=u'Queue of additions to assigned users, to be '
'applied to context when self.apply() is called. '
'Should be emptied on successful self.apply(). '
'Keys are role names like "viewers"; values are '
'each a set of string user names.',
key_type=schema.BytesLine(),
value_type=schema.Set(value_type=schema.BytesLine()),
)
def assign(username, group=BASE_GROUPNAME):
"""
Queue an assignment of a user to a role group, or confirm existing
assignment if already assigned to that group.
"""
def unassign(username, group=BASE_GROUPNAME):
"""
Queue an removal of a user from a role group, or confirm existing
assignment if already assigned to that group.
"""
def apply():
"""
class IBaseView(interface.Interface):
"""Base view for group, has builtin feature like filter"""
filter_type = schema.ASCIILine(title=u"Filter on portal_type")
query = schema.Dict(title=u"query for the catalog")
catalog = schema.Object(title=u"Portal catalog", schema=ICatalogTool)
def get_items():
"""return catalog query results"""
class IResourceRegistriesSettings(Interface):
"""Settings stored in portal_registry
"""
resourceBundlesForThemes = schema.Dict(
title=_(u"Resource bundles for themes"),
description=_(u"Maps skin names to lists of resource bundle names"),
key_type=schema.ASCIILine(),
value_type=schema.List(value_type=schema.ASCIILine()))
class IPloneCacheSettings(Interface):
"""Settings stored in the registry.
Basic cache settings are represented by
``plone.caching.interfaces.ICacheSettings``. These are additional,
Plone-specific settings.
"""
templateRulesetMapping = schema.Dict(
title=_(u'Page template/ruleset mapping'),
description=_(u'Maps skin layer page template names to ruleset names'),
key_type=schema.ASCIILine(title=_(u'Page template name')),
value_type=schema.DottedName(title=_(u'Ruleset name')),
)
contentTypeRulesetMapping = schema.Dict(
title=_(u'Content type/ruleset mapping'),
description=_(u'Maps content type names to ruleset names'),
key_type=schema.ASCIILine(title=_(u'Content type name')),
value_type=schema.DottedName(title=_(u'Ruleset name')),
)
purgedContentTypes = schema.Tuple(
title=_(u'Content types to purge'),
description=_(
u'List content types which should be purged when modified'),
value_type=schema.ASCIILine(title=_(u'Content type name')),
default=(
'File',
'Image',
'News Item',
),
)
cacheStopRequestVariables = schema.Tuple(
title=_(u'Request variables that prevent caching'),
description=_(
u'Variables in the request that prevent caching if present'),
value_type=schema.ASCIILine(title=_(u'Request variables')),
default=(
'statusmessages',
'SearchableText',
),
)
class INavigationTileSchema(model.Schema):
display_type = schema.Choice(title=u"Display Type",
source=TileViewsSource('navigation'),
default='horizontal')
form.widget(content=RelatedItemsFieldWidget)
content = schema.List(
title=u"Navigation items",
description=u"Select items for navigation",
required=False,
default=[],
value_type=schema.Choice(vocabulary='plone.app.vocabularies.Catalog'))
form.widget(query=QueryFieldWidget)
query = schema.List(
title=u'Search terms',
description=u"Define the search terms for the items you want "
u"to list by choosing what to match on. "
u"The list of results will be dynamically updated.",
value_type=schema.Dict(value_type=schema.Field(),
key_type=schema.TextLine()),
required=False)
sort_on = schema.TextLine(
title=u'Sort on',
description=u"Sort on this index",
required=False,
)
sort_reversed = schema.Bool(
title=u'Reversed order',
description=u'Sort the results in reversed order',
required=False,
)
form.widget(nav_type=NavigationTypeWidget)
nav_type = schema.Choice(
title=u'Use dynamic query to populate this menu',
description=
u'Otherwise, the navigation will be built from site section',
vocabulary=SimpleVocabulary([
SimpleVocabulary.createTerm('query', 'query', u'Query'),
SimpleVocabulary.createTerm('content', 'content', u'Select items'),
SimpleVocabulary.createTerm('currentlocation', 'currentlocation',
u'Build from here'),
SimpleVocabulary.createTerm(
'secondlevel', 'secondlevel',
u'Build from second level from site root'),
]),
default=u'currentlocation')
limit = schema.Int(title=u'Limit',
description=u'Limited number of items',
required=True,
default=10)
