def __init__(self, context, request):
self.context = context
self.request = request
self.portal = getSite()
self.definition = IFormDefinition(self.context)
self.series = context.__parent__ # assumes series <>--- form
self.title = '%s: %s' % (self.series.Title().strip(), context.Title())
self.seriesinfo = dict([
(k, v) for k, v in self.series.__dict__.items()
if v is not None and k in getFieldNamesInOrder(IFormSeries)
])
def cleanup_stored_schemas(site):
print '\t=== SITE: %s ===' % site.getId()
# get schema saver:
saver = queryUtility(ISchemaSaver)
size_before = len(saver)
# calculate in-use schema signatures:
actively_used = set() # in-use md5 schema signatures
content = map(get, search(site, TYPEQUERY))
for context in content:
assert IDefinitionBase.providedBy(context)
if context.signature is None:
context.signature = saver.add(context.entry_schema)
# consider the current schema (signature) used now by definition
# or field group in question:
actively_used.add(context.signature)
if IFormDefinition.providedBy(context):
# consider any past schema signatures on records now marked as
# having schema immutability when definition is modified:
actively_used.update(all_forms_signatures(context))
# enumerate through schema saver:
for signature in list(saver.keys()):
if signature == DEFAULT_SIGNATURE:
continue # leave this alone, attempting to remove --> exception
if signature not in actively_used:
del (saver[signature])
size_after = len(saver)
removed = size_before - size_after
if removed:
print('\t\tRemoved %s (of %s) orphaned schemas from local storage.' % (
removed,
size_before,
))
verify(site)
commit(site, 'Cleaned up orphaned schemas')
def __call__(self, *args, **kwargs):
definition = IFormDefinition(self.context)
data = getattr(definition, 'field_rules', '{}').strip()
setHeader = self.request.response.setHeader
setHeader('Content-type', 'application/json')
setHeader('Content-length', len(data))
return data
def __init__(self, context, request=None):
self.context = context
self.request = request
self.datasets = []
self.datapoints = {}
self.schema = IFormDefinition(self.context).schema
self.fieldnames = getFieldNamesInOrder(self.schema)
def cleanup_stored_schemas(site):
print '\t=== SITE: %s ===' % site.getId()
# get schema saver:
saver = queryUtility(ISchemaSaver)
size_before = len(saver)
# calculate in-use schema signatures:
actively_used = set() # in-use md5 schema signatures
content = map(get, search(site, TYPEQUERY))
for context in content:
assert IDefinitionBase.providedBy(context)
assert context.signature is not None
# consider the current schema (signature) used now by definition
# or field group in question:
actively_used.add(context.signature)
if IFormDefinition.providedBy(context):
# consider any past schema signatures on records now marked as
# having schema immutability when definition is modified:
actively_used.update(all_forms_signatures(context))
# enumerate through schema saver:
for signature in list(saver.keys()):
if signature == DEFAULT_SIGNATURE:
continue # leave this alone, attempting to remove --> exception
if signature not in actively_used:
del(saver[signature])
size_after = len(saver)
removed = size_before - size_after
if removed:
print (
'\t\tRemoved %s (of %s) orphaned schemas from local storage.' % (
removed,
size_before,
)
)
verify(site)
commit(site, 'Cleaned up orphaned schemas')
def _handleSave(self, action, msg='Saved form data'):
self.save_attempt = True
data, errors = self.extractData()
if errors or IFormDefinition.providedBy(self.context) or self.saved:
return False # just validate if errors, or if context if defn
if not self.saved:
result = {} # submitted data. k: group name; v: dict of name/value
group_keys = []
for group in self.groups:
groupdata = {}
form_group_data = group.extractData()[0]
for name, _field in group.fields.items():
group_keys.append(name)
fieldname = _field.field.__name__
default = getattr(_field.field, 'default', None)
field_data = form_group_data.get(name, default)
if ICollection.providedBy(_field.field):
if isinstance(_field.field.value_type, DictRow):
is_nonempty_row = lambda v: any(v.values())
field_data = filter(is_nonempty_row, field_data)
groupdata[fieldname] = field_data
result[group.__name__] = groupdata
# filter default fieldset values, ignore group values in data dict:
result[''] = dict([(k, v) for k, v in data.items()
if k not in group_keys])
self._saveResult(result)
self.saved = True
history_log(self.context, message=msg, set_modified=True)
notify(ObjectModifiedEvent(self.context))
transaction.get().note(msg)
self._status.addStatusMessage('Saved form data', type='info')
return True
def _handleSave(self, action, msg='Saved form data'):
self.save_attempt = True
data, errors = self.extractData()
if errors or IFormDefinition.providedBy(self.context) or self.saved:
return False # just validate if errors, or if context if defn
if not self.saved:
result = {} # submitted data. k: group name; v: dict of name/value
group_keys = []
for group in self.groups:
groupdata = {}
form_group_data = group.extractData()[0]
for name, _field in group.fields.items():
group_keys.append(name)
fieldname = _field.field.__name__
default = getattr(_field.field, 'default', None)
field_data = form_group_data.get(name, default)
if ICollection.providedBy(_field.field):
if isinstance(_field.field.value_type, DictRow):
is_nonempty_row = lambda v: any(v.values())
field_data = filter(is_nonempty_row, field_data)
groupdata[fieldname] = field_data
result[group.__name__] = groupdata
# filter default fieldset values, ignore group values in data dict:
result[''] = dict([(k, v) for k, v in data.items()
if k not in group_keys])
self._saveResult(result)
self.saved = True
history_log(self.context, message=msg, set_modified=True)
notify(ObjectModifiedEvent(self.context))
transaction.get().note(msg)
self._status.addStatusMessage('Saved form data', type='info')
return True
def metadata_form_definition(form):
"""Named adapter for metadata"""
try:
primary = IFormDefinition(form)
return form_definition(primary, attr='metadata_definition')
except ValueError:
return None # since metadata definition is optional
def __init__(self, context, request):
self.context = context
self.request = request
self.portal = getSite()
self.comparators = Comparators(request)
self.status = IStatusMessage(self.request)
self.schema = IFormDefinition(self.context).schema
def updateWidgets(self):
common_widget_updates(self)
for group in self.groups:
common_widget_updates(group)
super(ComposedForm, self).updateWidgets()
# # finally, if non-defintion context, set widget values via group data
if not IFormDefinition.providedBy(self.context):
self._load_widget_data()
def __init__(self, context, request=None):
## context should be context of API view, not API view itself
self.context = context
self.__parent__ = context # may be re-parented by API to view
self.request = getRequest() if request is None else request
self.definition = IFormDefinition(self.context)
self._schema = self.definition.schema
self._fieldnames = getFieldNamesInOrder(self._schema)
def updateWidgets(self):
common_widget_updates(self)
for group in self.groups:
common_widget_updates(group)
super(ComposedForm, self).updateWidgets()
# # finally, if non-defintion context, set widget values via group data
if not IFormDefinition.providedBy(self.context):
self._load_widget_data()
def migrate_filter(measure, queryname):
schema = IFormDefinition(measure).schema
rfilter = premigrate_filter(measure, queryname)
composed = queryAdapter(measure, IComposedQuery, name=queryname)
destination = query_filters(composed)[0]
copy_filter(rfilter, destination)
verify_filter(rfilter, destination, schema)
remove_content_filter(rfilter)
def __init__(self, context, *args, **kwargs):
if not IFormDefinition.providedBy(context):
raise ValueError('context must provide IFormDefinition')
self.context = context # form definition
self.namespace = kwargs.get('namespace', '')
self.signature = kwargs.get('signature', None)
self.modified = kwargs.get('modified', datetime.now())
self.modification = kwargs.get('modification', 'modified')
self.note = kwargs.get('note', None)
def __init__(self, context, *args, **kwargs):
if not IFormDefinition.providedBy(context):
raise ValueError('context must provide IFormDefinition')
self.context = context # form definition
self.namespace = kwargs.get('namespace', '')
self.signature = kwargs.get('signature', None)
self.modified = kwargs.get('modified', datetime.now())
self.modification = kwargs.get('modification', 'modified')
self.note = kwargs.get('note', None)
def migrate_measures(site):
migrated = 0
all_count = 0
prior_incomplete = premigrate_incomplete_measures(site) # UIDs incomplete
q = {'portal_type': MEASURE_DEFINITION_TYPE}
for brain in _search(site, q):
measure = _get(brain)
group = measure.__parent__
if group.source_type == 'uu.formlibrary.simpleform':
continue # ignore SimpleForm-based measure, no queries to migrate
migrated += migrate_measure(measure)
all_count += 1
print 'Migrated %s measures from legacy RecordFilter(s), of %s' % (
migrated,
all_count,
)
print 'Cleaning up remaining legacy RecordFilter entries from catalog'
incomplete_cleanups(site)
# VERIFY / assertions:
# 1. NO RecordFilter content cataloged any more:
q = {'portal_type': 'uu.formlibrary.recordfilter'}
assert len(_search(site, q)) == 0
# 2. For all measures, things look good:
q = {'portal_type': MEASURE_DEFINITION_TYPE}
for brain in _search(site, q):
measure = _get(brain)
schema = IFormDefinition(measure).schema
group = measure.__parent__
if group.source_type == 'uu.formlibrary.simpleform':
continue # ignore SimpleForm-based measure, no queries to migrate
# 2.a. NO _tree; since MeasureDefinition
# is not subclasing plone.dexterity.content.Container any more
# in favor of Item, we need to directly access tree:
try:
assert getattr(aq_base(measure), '_tree', None) is None
except AssertionError:
# likely a tree with no filters, so clean up here:
assert len(aq_base(measure)._tree) == 0
delattr(aq_base(measure), '_tree')
# 2.b. IComposedQuery for measure configuration looks okay, for
# numerator, denominator as configured.
if group.source_type == 'uu.formlibrary.simpleform':
continue # ignore SimpleForm-based measures, no queries!
else:
# get whether num, den...
# build query for each:
# assert is_query_complete(q.build())
adapter = lambda name: queryAdapter(measure, IComposedQuery, name)
if IUUID(measure) not in prior_incomplete:
if measure.numerator_type == 'multi_filter':
composed = adapter(u'numerator')
assert is_query_complete(composed.build(schema))
if measure.denominator_type == 'multi_filter':
composed = adapter(u'denominator')
assert is_query_complete(composed.build(schema))
def __init__(self, context, request):
self.context = context
self.request = request
self.portal = getSite()
self.definition = IFormDefinition(self.context)
self.series = context.__parent__ # assumes series <>--- form
self.title = '%s: %s' % (self.series.Title().strip(), context.Title())
self.seriesinfo = dict(
[(k, v) for k, v in self.series.__dict__.items()
if v is not None and k in getFieldNamesInOrder(IFormSeries)]
)
def __init__(self, worksheet, group, origin):
primary = IFormDefinition.providedBy(group)
self.worksheet = worksheet # IFormWorksheet
self.context = worksheet.context # ISimpleForm
self.group = group
data = self.context.data
self.data = data.get('') if primary else data.get(self.group.getId())
self.field_schema = group.schema
self.title = u'Primary fields' if primary else group.title
self.origin = origin # origin/start row
self.size = 0
self.cursor = self.origin
def __init__(self, worksheet, group, origin):
primary = IFormDefinition.providedBy(group)
self.worksheet = worksheet # IFormWorksheet
self.context = worksheet.context # ISimpleForm
self.group = group
data = self.context.data
self.data = data.get('') if primary else data.get(self.group.getId())
self.field_schema = group.schema
self.title = u'Primary fields' if primary else group.title
self.origin = origin # origin/start row
self.size = 0
self.cursor = self.origin
def __init__(self, context):
if not IFormDefinition.providedBy(context):
raise ValueError(
'context %s does not provide IFormDefinition' % context)
BaseFormSet.__init__(self, context, name=u'definition')
r = self.catalog.unrestrictedSearchResults({
'references': IUUID(self.context),
'portal_type': {
'query': (MULTI_FORM_TYPE, SIMPLE_FORM_TYPE),
'operator': 'or',
},
})
self.contents = set([b.UID for b in r])
def prior_incomplete_measure(measure):
group = measure.__parent__
schema = IFormDefinition(measure).schema
if group.source_type == 'uu.formlibrary.simpleform':
return False # ignore SimpleForm-based measures, no queries!
if measure.numerator_type == 'multi_filter':
rfilter = premigrate_filter(measure, 'numerator')
if rfilter is None or not is_query_complete(rfilter.build(schema)):
return True
if measure.denominator_type == 'multi_filter':
rfilter = premigrate_filter(measure, 'denominator')
if rfilter is None or not is_query_complete(rfilter.build(schema)):
return True
return False
def __init__(self, context):
if not IFormDefinition.providedBy(context):
raise ValueError('context %s does not provide IFormDefinition' %
context)
BaseFormSet.__init__(self, context, name=u'definition')
r = self.catalog.unrestrictedSearchResults({
'references':
IUUID(self.context),
'portal_type': {
'query': (MULTI_FORM_TYPE, SIMPLE_FORM_TYPE),
'operator': 'or',
},
})
self.contents = set([b.UID for b in r])
def reserialize(context, schema):
if not IDefinitionBase.providedBy(context.__parent__):
return # not an event we care about
definition = context.__parent__
saver = queryUtility(ISchemaSaver)
new_signature = saver.add(schema)
new_xml = saver.get(new_signature)
definition.entry_schema = new_xml
definition.signature = new_signature
if IFormDefinition.providedBy(definition):
update_form_entries(definition)
# TODO: deal with nested groups and associated data objects contained
if hasattr(aq_base(definition), '_v_schema'):
delattr(aq_base(definition), '_v_schema') # invalidate previous schema
definition.reindexObject()
def definition_field_source(context, field_ifaces=(IField,)):
if isinstance(context, dict):
context = find_context(getRequest())
definition = IFormDefinition(context)
meta_defn = queryAdapter(definition, IFormDefinition, name='metadata')
if meta_defn is not None:
definition = meta_defn
unspecified = SimpleTerm(
value='',
title=u'Unused / no field specified',
)
return SimpleVocabulary(
[unspecified] + [
SimpleTerm(value, title=title) for value, title in
definition_field_list(definition, field_ifaces)
])
class BaseFormView(object):
VIEWNAME = 'edit'
def __init__(self, context, request):
self.context = context
self.request = request
self.portal = getSite()
self.definition = IFormDefinition(self.context)
self.series = context.__parent__ # assumes series <>--- form
self.title = '%s: %s' % (self.series.Title().strip(), context.Title())
self.seriesinfo = dict(
[(k, v) for k, v in self.series.__dict__.items()
if v is not None and k in getFieldNamesInOrder(IFormSeries)]
)
def instructions(self):
_instructions = getattr(self.definition, 'instructions')
if not _instructions:
return u''
return getattr(_instructions, 'output', None) or u''
def portalurl(self):
return getSite().absolute_url()
def logourl(self):
filename = getattr(self.definition.logo, 'filename', None)
if filename is None:
return None
base = self.definition.absolute_url()
return '%s/@@download/logo/%s' % (base, filename)
def browserDefault(self, request):
# the response does not have access to request; we copy user-agent
# information to the response for customized handling of exceptions
# based on user-agent (see uu.formlibrary.patch) with a monkey patch
# designed to work around Microsoft Office Protocol Discovery,
# which has MSOffice probe the server first when a hyperlink inside
# an office document is clicked.
request.response._req_user_agent = request.get('HTTP_USER_AGENT')
return self, ()
def __call__(self, *args, **kwargs):
self.update(*args, **kwargs)
return self.index(*args, **kwargs)
class BaseFormView(object):
VIEWNAME = 'edit'
def __init__(self, context, request):
self.context = context
self.request = request
self.portal = getSite()
self.definition = IFormDefinition(self.context)
self.series = context.__parent__ # assumes series <>--- form
self.title = '%s: %s' % (self.series.Title().strip(), context.Title())
self.seriesinfo = dict([
(k, v) for k, v in self.series.__dict__.items()
if v is not None and k in getFieldNamesInOrder(IFormSeries)
])
def instructions(self):
_instructions = getattr(self.definition, 'instructions')
if not _instructions:
return u''
return getattr(_instructions, 'output', None) or u''
def portalurl(self):
return getSite().absolute_url()
def logourl(self):
filename = getattr(self.definition.logo, 'filename', None)
if filename is None:
return None
base = self.definition.absolute_url()
return '%s/@@download/logo/%s' % (base, filename)
def browserDefault(self, request):
# the response does not have access to request; we copy user-agent
# information to the response for customized handling of exceptions
# based on user-agent (see uu.formlibrary.patch) with a monkey patch
# designed to work around Microsoft Office Protocol Discovery,
# which has MSOffice probe the server first when a hyperlink inside
# an office document is clicked.
request.response._req_user_agent = request.get('HTTP_USER_AGENT')
return self, ()
def __call__(self, *args, **kwargs):
self.update(*args, **kwargs)
return self.index(*args, **kwargs)
def __init__(self, context, request, name=None):
"""
Construct composed form given (default) schema an a tuple
of ordered additional schema key/value pairs of (string)
component name keys to schema values.
"""
self.context = context
self.request = request
# form definition will either be context, or adaptation of context.
# see uu.formlibrary.definition.form_definition for adapter example.
if name is None:
self.definition = IFormDefinition(self.context)
else:
self.definition = queryAdapter(
self.context,
IFormDefinition,
name=name,
)
self._schema = self.definition.schema
self.groups = [] # modified by updateFieldsFromSchemata()
self.components = IFormComponents(self.definition)
self.group_schemas = self._group_schemas()
self.group_titles = self._group_titles()
# mapping: schema to names:
self.schema_names = dict(invert(self.group_schemas))
# ordered list of additional schema for AutoExtensibleForm:
self._additionalSchemata = tuple(
[t[1] for t in self.group_schemas if t[0]])
# super(ComposedForm, self).__init__(self, context, request)
form.Form.__init__(self, context, request)
self.saved = False # initial value: no duplication of save...
self.save_attempt = False # flag for save attempt, success or not
self._status = IStatusMessage(self.request)
def definition(self):
if self._definition is None:
self._definition = IFormDefinition(self.context)
return self._definition
def _datagroups(self, form):
definition = IFormDefinition(form)
groups = {'': definition}
groups.update(IFormComponents(definition).groups)
return groups
def _file_field_name(self):
schema = IFormDefinition(self.context).schema
for (name, field) in getFieldsInOrder(schema):
if INamedFileField.providedBy(field):
return name
def form_definition(self):
if not getattr(self, '_v_definition', None):
self._v_definition = IFormDefinition(self)
return self._v_definition
def _definition(self):
try:
definition = IFormDefinition(self) # get definition
except ValueError:
return None
return definition
