def test_dict(self):
self.assertEqual(
{
u"foo": True,
u"bar": None,
u"baz": 3
},
json_compatible({
"foo": True,
"bar": None,
"baz": 3
}),
)
self.assertEqual('{"foo": "bar"}',
json.dumps(json_compatible({"foo": "bar"})))
self.assertIsInstance(
json_compatible(list({"foo": "bar"})[0]),
six.text_type,
"Dict keys should be converted recursively.",
)
self.assertIsInstance(
json_compatible(list({"foo": "bar"}.values())[0]),
six.text_type,
"Dict values should be converted recursively.",
)
def __call__(self):
data = []
for value in self.get_value():
if not value:
continue
content = value.to_object
if not content:
continue
if not api.user.has_permission("View", obj=content):
continue
if content.effective().isFuture() and not api.user.has_permission(
"Modify portal content", obj=self.context):
# effective date is in the future.
# Users that can edit current context, should see it because otherwise
# they will not see it in edit form.
continue
summary = getMultiAdapter((content, getRequest()),
ISerializeToJsonSummary)()
if content.effective().Date() != "1969/12/31":
summary["effective"] = json_compatible(content.effective())
else:
summary["effective"] = None
if content.portal_type == "Event":
summary["start"] = json_compatible(
getattr(content, "start", ""))
summary["end"] = json_compatible(getattr(content, "end", ""))
if getattr(content, "icona", ""):
summary["icona"] = content.icona
data.append(json_compatible(summary))
return data
def __call__(self):
result = {
'@context': 'http://www.w3.org/ns/hydra/context.jsonld',
'@id': self.context.absolute_url(),
'@type': self.context.portal_type,
'parent': {
'@id': aq_parent(aq_inner(self.context)).absolute_url(),
'title': aq_parent(aq_inner(self.context)).title,
'description': aq_parent(aq_inner(self.context)).description
},
'created': json_compatible(self.context.created()),
'modified': json_compatible(self.context.modified()),
'UID': self.context.UID(),
}
for schema in iterSchemata(self.context):
read_permissions = mergedTaggedValueDict(
schema, READ_PERMISSIONS_KEY)
for name, field in getFields(schema).items():
if not self.check_permission(read_permissions.get(name)):
continue
serializer = queryMultiAdapter(
(field, self.context, self.request),
IFieldSerializer)
value = serializer()
result[json_compatible(name)] = value
return result
def test_long(self):
def _long(val):
return int(val)
self.assertEqual(_long(10), json_compatible(_long(10)))
self.assertIsInstance(json_compatible(_long(10)), int)
self.assertEqual("10", json.dumps(json_compatible(_long(10))))
def __call__(self):
parent = aq_parent(aq_inner(self.context))
parent_summary = getMultiAdapter(
(parent, self.request), ISerializeToJsonSummary)()
result = {
# '@context': 'http://www.w3.org/ns/hydra/context.jsonld',
'@id': self.context.absolute_url(),
'id': self.context.id,
'@type': self.context.portal_type,
'parent': parent_summary,
'created': json_compatible(self.context.created()),
'modified': json_compatible(self.context.modified()),
'review_state': self._get_workflow_state(),
'UID': self.context.UID(),
}
for schema in iterSchemata(self.context):
read_permissions = mergedTaggedValueDict(
schema, READ_PERMISSIONS_KEY)
for name, field in getFields(schema).items():
if not self.check_permission(read_permissions.get(name)):
continue
serializer = queryMultiAdapter(
(field, self.context, self.request),
IFieldSerializer)
value = serializer()
result[json_compatible(name)] = value
return result
def __call__(self):
field_name = self.field.__name__
if (field_name == 'categories_evenements' or
field_name.startswith('taxonomy_')) and \
field_name != 'taxonomy_category':
lang = self.context.language
taxonomy_ids = self.get_value()
if not taxonomy_ids:
return []
if isinstance(taxonomy_ids, basestring):
taxonomy_ids = [taxonomy_ids]
domain = 'collective.taxonomy.{0}'.format(
field_name.replace('taxonomy_', '').replace('_', ''))
sm = getSiteManager()
utility = sm.queryUtility(ITaxonomy, name=domain)
taxonomy_list = [taxonomy_id for taxonomy_id in taxonomy_ids]
text = []
if len(taxonomy_list) > 0:
for taxonomy_id in taxonomy_list:
text.append(
safe_utf8(
utility.translate(taxonomy_id,
context=self.context,
target_language=lang)))
return json_compatible(text)
else:
return json_compatible(self.get_value())
def __call__(self):
result = {
'@context': 'http://www.w3.org/ns/hydra/context.jsonld',
'@id': self.context.absolute_url(),
'@type': self.context.portal_type,
'parent': {
'@id': aq_parent(aq_inner(self.context)).absolute_url(),
'title': aq_parent(aq_inner(self.context)).title,
'description': aq_parent(aq_inner(self.context)).description
},
'created': json_compatible(self.context.created()),
'modified': json_compatible(self.context.modified()),
'UID': self.context.UID(),
}
for schema in iterSchemata(self.context):
read_permissions = mergedTaggedValueDict(schema,
READ_PERMISSIONS_KEY)
for name, field in getFields(schema).items():
if not self.check_permission(read_permissions.get(name)):
continue
serializer = queryMultiAdapter(
(field, self.context, self.request), IFieldSerializer)
value = serializer()
result[json_compatible(name)] = value
return result
def _include_base_data(self, obj):
""" """
result = {}
if self._get_param("include_base_data", True):
result = {
# '@context': 'http://www.w3.org/ns/hydra/context.jsonld',
"@id":
obj.absolute_url(),
"id":
obj.id,
"@type":
obj.portal_type,
"created":
json_compatible(obj.created()),
"modified":
json_compatible(obj.modified()),
"review_state":
self._get_workflow_state(obj),
"UID":
obj.UID(),
"title":
obj.Title(),
"is_folderish":
bool(getattr(aq_base(obj), 'isPrincipiaFolderish', False)),
}
return result
def __call__(self):
field_name = self.field.__name__
if (field_name == 'categories_evenements' or
field_name.startswith('taxonomy_')) and \
field_name != 'taxonomy_category':
lang = self.context.language
taxonomy_ids = self.get_value()
if not taxonomy_ids:
return []
if isinstance(taxonomy_ids, basestring):
taxonomy_ids = [taxonomy_ids]
domain = 'collective.taxonomy.{0}'.format(
field_name.replace('taxonomy_', '').replace('_', ''))
sm = getSiteManager()
utility = sm.queryUtility(ITaxonomy, name=domain)
taxonomy_list = [taxonomy_id for taxonomy_id in taxonomy_ids]
text = []
if len(taxonomy_list) > 0:
for taxonomy_id in taxonomy_list:
text.append(
safe_utf8(
utility.translate(
taxonomy_id,
context=self.context,
target_language=lang
)
)
)
return json_compatible(text)
else:
return json_compatible(self.get_value())
def test_can_only_add_invitations_with_Workspace_related_roles(self, browser):
self.login(self.workspace_admin, browser=browser)
with browser.expect_http_error(401):
data = json.dumps(json_compatible({
'user': {'token': self.regular_user.id},
'role': {'token': 'Reader'}
}))
browser.open(
self.workspace.absolute_url() + '/@participations/invitations',
method='POST',
data=data,
headers=http_headers(),
)
with browser.expect_http_error(500):
data = json.dumps(json_compatible({
'user': {'token': self.regular_user.id},
'role': {'token': 'Site Administrator'}
}))
browser.open(
self.workspace.absolute_url() + '/@participations/invitations',
method='POST',
data=data,
headers=http_headers(),
)
def __call__(self):
field_list = self.request.form.get('items.fl', '').strip()
if field_list:
field_list = field_list.split(',')
else:
field_list = ['@type', 'title', 'description', 'review_state']
obj = IContentListingObject(self.context)
summary = json_compatible({
'@id': obj.getURL(),
})
for field in field_list:
accessor = FIELD_ACCESSORS.get(field)
if accessor is None:
continue
if isinstance(accessor, str):
value = getattr(obj, accessor, None)
if callable(value):
value = value()
else:
value = accessor(obj)
summary[field] = json_compatible(value)
if ('title' in summary
and ITranslatedTitleSupport.providedBy(self.context)):
# Update title to contain translated title in negotiated language
attr = 'title_{}'.format(get_preferred_language_code())
summary['title'] = getattr(self.context, attr)
return summary
def __call__(self):
parent = aq_parent(aq_inner(self.context))
parent_summary = getMultiAdapter(
(parent, self.request), ISerializeToJsonSummary)()
result = {
# '@context': 'http://www.w3.org/ns/hydra/context.jsonld',
'@id': self.context.absolute_url(),
'id': self.context.id,
'@type': self.context.portal_type,
'parent': parent_summary,
'created': json_compatible(self.context.created()),
'modified': json_compatible(self.context.modified()),
'review_state': self._get_workflow_state(),
'UID': self.context.UID(),
}
for schema in iterSchemata(self.context):
read_permissions = mergedTaggedValueDict(
schema, READ_PERMISSIONS_KEY)
for name, field in getFields(schema).items():
if not self.check_permission(read_permissions.get(name)):
continue
serializer = queryMultiAdapter(
(field, self.context, self.request),
IFieldSerializer)
value = serializer()
result[json_compatible(name)] = value
return result
def __call__(self):
field_list = self.request.form.get('items.fl', '').strip()
if field_list:
field_list = field_list.split(',')
else:
field_list = ['@type', 'title', 'description', 'review_state']
obj = IContentListingObject(self.context)
summary = json_compatible({
'@id': obj.getURL(),
})
for field in field_list:
accessor = FIELD_ACCESSORS.get(field)
if accessor is None:
continue
if isinstance(accessor, str):
value = getattr(obj, accessor, None)
if callable(value):
value = value()
else:
value = accessor(obj)
summary[field] = json_compatible(value)
if ('title' in summary and
ITranslatedTitleSupport.providedBy(self.context)):
# Update title to contain translated title in negotiated language
attr = 'title_{}'.format(get_preferred_language_code())
summary['title'] = getattr(self.context, attr)
return summary
def test_richtext_from_text(self):
value = RichTextValue(u'Hall\xf6chen',
mimeType='text/plain',
outputMimeType='text/html')
self.assertEquals(u'<p>Hallöchen</p>', json_compatible(value))
self.assertEquals(u'"<p>Hall\\u00f6chen</p>"',
json.dumps(json_compatible(value)))
def __call__(self, version=None, include_items=True):
version = "current" if version is None else version
obj = self.getVersion(version)
parent = aq_parent(aq_inner(obj))
parent_summary = getMultiAdapter(
(parent, self.request), ISerializeToJsonSummary
)()
result = {
# '@context': 'http://www.w3.org/ns/hydra/context.jsonld',
"@id": obj.absolute_url(),
"id": obj.id,
"@type": obj.portal_type,
"parent": parent_summary,
"created": json_compatible(obj.created()),
"modified": json_compatible(obj.modified()),
"review_state": self._get_workflow_state(obj),
"UID": obj.UID(),
"version": version,
"layout": self.context.getLayout(),
"is_folderish": False,
}
# Insert next/prev information
nextprevious = NextPrevious(obj)
result.update(
{"previous_item": nextprevious.previous, "next_item": nextprevious.next}
)
# Insert expandable elements
result.update(expandable_elements(self.context, self.request))
# Insert field values
for schema in iterSchemata(self.context):
read_permissions = mergedTaggedValueDict(schema, READ_PERMISSIONS_KEY)
for name, field in getFields(schema).items():
if not self.check_permission(read_permissions.get(name), obj):
continue
# serialize the field
serializer = queryMultiAdapter(
(field, obj, self.request), IFieldSerializer
)
value = serializer()
result[json_compatible(name)] = value
target_url = getMultiAdapter(
(self.context, self.request), IObjectPrimaryFieldTarget
)()
if target_url:
result["targetUrl"] = target_url
result["allow_discussion"] = getMultiAdapter(
(self.context, self.request), name="conversation_view"
).enabled()
return result
def test_persistent_list(self):
value = PersistentList(['foo'])
self.assertEquals(['foo'], json_compatible(value))
self.assertEquals('["foo"]', json.dumps(json_compatible(value)))
self.assertIsInstance(json_compatible(value)[0],
unicode,
'PersistentList values should be converted'
' recursively.')
def test_tuple(self):
# Tuples are converted to list (json would do that anyway and
# it is easier to implement it with map).
self.assertEqual(['foo', None], json_compatible(('foo', None)))
self.assertEqual('["foo"]', json.dumps(json_compatible(('foo', ))))
self.assertIsInstance(
json_compatible(('foo', ))[0], six.text_type,
'Tuple values should be converted recursively.')
def test_persistent_mapping(self):
value = PersistentMapping({'foo': 'bar'})
self.assertEquals({u'foo': u'bar'}, json_compatible(value))
self.assertEquals('{"foo": "bar"}', json.dumps(json_compatible(value)))
self.assertIsInstance(json_compatible(value.keys()[0]), unicode,
'Dict keys should be converted recursively.')
self.assertIsInstance(json_compatible(value.values()[0]), unicode,
'Dict values should be converted recursively.')
def test_persistent_list(self):
value = PersistentList(['foo'])
self.assertEqual(['foo'], json_compatible(value))
self.assertEqual('["foo"]', json.dumps(json_compatible(value)))
self.assertIsInstance(
json_compatible(value)[0], six.text_type,
'PersistentList values should be converted'
' recursively.')
def test_list(self):
self.assertEqual(["foo"], json_compatible(["foo"]))
self.assertEqual('["foo"]', json.dumps(json_compatible(["foo"])))
self.assertIsInstance(
json_compatible(["foo"])[0],
str,
"List values should be converted recursively.",
)
def test_tuple(self):
# Tuples are converted to list (json would do that anyway and
# it is easier to implement it with map).
self.assertEquals(['foo', None], json_compatible(('foo', None)))
self.assertEquals('["foo"]', json.dumps(json_compatible(('foo', ))))
self.assertIsInstance(json_compatible(('foo',))[0],
unicode,
'Tuple values should be converted recursively.')
def __call__(self):
accessor = self.field.getAccessor(self.context)
refs = accessor()
if refs is None:
return None
if self.field.multiValued:
return json_compatible(refs)
else:
return json_compatible(refs)
def test_error_when_type_unknown(self):
err_regex = r'^No converter for making <object object at [^>]*>' + \
r' \(<(class|type) \'object\'>\) JSON compatible.$'
with self.assertRaisesRegexp(TypeError, err_regex):
json_compatible(object())
with self.assertRaisesRegexp(TypeError, err_regex):
json_compatible({'foo': [object()]})
def __call__(self):
accessor = self.field.getAccessor(self.context)
refs = accessor()
if self.field.multiValued:
return [json_compatible(r.absolute_url()) for r in refs]
else:
if refs is None:
return None
return json_compatible(refs.absolute_url())
def __call__(self):
accessor = self.field.getAccessor(self.context)
refs = accessor()
if self.field.multiValued:
return [json_compatible(r.absolute_url()) for r in refs]
else:
if refs is None:
return None
return json_compatible(refs.absolute_url())
def __call__(self):
value = self.get_value()
if value:
output = value.raw
return {
u"data": json_compatible(output),
u"content-type": json_compatible(value.mimeType),
u"encoding": json_compatible(value.encoding),
}
def test_persistent_list(self):
value = PersistentList(["foo"])
self.assertEqual(["foo"], json_compatible(value))
self.assertEqual('["foo"]', json.dumps(json_compatible(value)))
self.assertIsInstance(
json_compatible(value)[0],
str,
"PersistentList values should be converted" " recursively.",
)
def test_error_when_type_unknown(self):
err_regex = r'^No converter for making <object object at [^>]*>' + \
r' \(<type \'object\'>\) JSON compatible.$'
with self.assertRaisesRegexp(TypeError, err_regex):
json_compatible(object())
with self.assertRaisesRegexp(TypeError, err_regex):
json_compatible({'foo': [object()]})
def serialize_item(self, proxy):
json_data = {}
json_schema = {}
fti = proxy.fti
overview = queryMultiAdapter((proxy, self.controlpanel.request),
name='overview')
form = overview.form_instance
json_schema = get_jsonschema_for_controlpanel(
self.controlpanel, self.controlpanel.context,
self.controlpanel.request, form)
for name, item in form.fields.items():
serializer = queryMultiAdapter(
(item.field, fti, self.controlpanel.request), IFieldSerializer)
if serializer:
value = serializer()
else:
value = getattr(fti, name, None)
json_data[json_compatible(name)] = value
behaviors = queryMultiAdapter((proxy, self.controlpanel.request),
name='behaviors')
form = behaviors.form_instance
behaviors_schema = get_jsonschema_for_controlpanel(
self.controlpanel, self.controlpanel.context,
self.controlpanel.request, form)
behaviors_schema['fieldsets'][0]['id'] = 'behaviors'
behaviors_schema['fieldsets'][0]['title'] = translate(
'Behaviors', domain="plone", context=self.controlpanel.request)
json_schema['fieldsets'].extend(behaviors_schema['fieldsets'])
json_schema['properties'].update(behaviors_schema['properties'])
for name, item in form.fields.items():
behaviors = getattr(fti, 'behaviors', [])
json_data[json_compatible(name)] = name in behaviors
# JSON schema
return {
"@id":
"{}/{}/{}/{}".format(self.controlpanel.context.absolute_url(),
SERVICE_ID, self.controlpanel.__name__,
proxy.__name__),
"title":
fti.Title(),
"description":
fti.Description(),
"group":
self.controlpanel.group,
"schema":
json_schema,
"data":
json_data,
"items": []
}
def test_long(self):
def _long(val):
if six.PY2:
return int(val)
else:
return int(val)
self.assertEqual(_long(10), json_compatible(_long(10)))
self.assertIsInstance(json_compatible(_long(10)), int)
self.assertEqual('10', json.dumps(json_compatible(_long(10))))
def test_persistent_mapping(self):
value = PersistentMapping({'foo': 'bar'})
self.assertEquals({u'foo': u'bar'}, json_compatible(value))
self.assertEquals('{"foo": "bar"}', json.dumps(json_compatible(value)))
self.assertIsInstance(json_compatible(value.keys()[0]),
unicode,
'Dict keys should be converted recursively.')
self.assertIsInstance(json_compatible(value.values()[0]),
unicode,
'Dict values should be converted recursively.')
def __call__(self):
mimetypes_registry = getToolByName(self.context, "mimetypes_registry")
data = super(TextFieldSerializer, self).__call__()
content_type = json_compatible(mimetypes_registry(data)[2].normalized())
if content_type == u'text/html':
data = handle_html(self.context, data)
return {
"content-type": json_compatible(content_type),
"data": data,
}
def test_error_when_type_unknown(self):
err_regex = (
r"^No converter for making <object object at [^>]*>"
+ r" \(<(class|type) \'object\'>\) JSON compatible.$"
)
with self.assertRaisesRegex(TypeError, err_regex):
json_compatible(object())
with self.assertRaisesRegex(TypeError, err_regex):
json_compatible({"foo": [object()]})
def __call__(self):
value = self.get_value()
if getattr(value, 'to_object', False):
obj = value.to_object
result = {
'title': obj.title,
'path': '/'.join(obj.getPhysicalPath()),
'phone': obj.phone,
'cell_phone': obj.cell_phone,
}
result.update(get_address(obj))
return json_compatible(result)
return json_compatible(value, self.context)
def __call__(self):
value = self.get_value()
if getattr(value, 'to_object', False):
obj = value.to_object
result = {
'title': obj.title,
'path': '/'.join(obj.getPhysicalPath()),
'phone': obj.phone,
'cell_phone': obj.cell_phone,
}
result.update(get_address(obj))
return json_compatible(result)
return json_compatible(value, self.context)
def get_working_copy_info(self):
baseline = self.baseline()
working_copy = self.working_copy()
sm = getSecurityManager()
# No Working Copy exists
if baseline is None and working_copy is None:
return (None, None)
# Baseline is None (context is the baseline), and working copy exists
if baseline is None and working_copy:
self.ref = working_copy
if (
sm.checkPermission(ModifyPortalContent, self.context)
or sm.checkPermission(CheckoutPermission, self.context)
or sm.checkPermission(ModifyPortalContent, working_copy)
):
return (
None,
{
"@id": working_copy.absolute_url(),
"title": working_copy.title,
"created": json_compatible(self.created()),
"creator_url": self.creator_url(),
"creator_name": self.creator_name(),
},
)
else:
return (None, None)
# Baseline exist (context is the working copy), and working copy exists
if baseline and working_copy:
self.ref = baseline
if sm.checkPermission(
ModifyPortalContent, self.context
) or sm.checkPermission(CheckoutPermission, baseline):
return (
{"@id": baseline.absolute_url(), "title": baseline.title},
{
"@id": working_copy.absolute_url(),
"title": working_copy.title,
"created": json_compatible(self.created()),
"creator_url": self.creator_url(),
"creator_name": self.creator_name(),
},
)
else:
return (None, None)
def test_persistent_mapping(self):
value = PersistentMapping({"foo": "bar"})
self.assertEqual({"foo": "bar"}, json_compatible(value))
self.assertEqual('{"foo": "bar"}', json.dumps(json_compatible(value)))
self.assertIsInstance(
json_compatible(list(value)[0]),
str,
"Dict keys should be converted recursively.",
)
self.assertIsInstance(
json_compatible(list(value.values())[0]),
str,
"Dict values should be converted recursively.",
)
def test_dict(self):
self.assertEquals({u'foo': True,
u'bar': None,
u'baz': 3},
json_compatible({'foo': True,
'bar': None,
'baz': 3}))
self.assertEquals('{"foo": "bar"}',
json.dumps(json_compatible({'foo': 'bar'})))
self.assertIsInstance(json_compatible({'foo': 'bar'}.keys()[0]),
unicode,
'Dict keys should be converted recursively.')
self.assertIsInstance(json_compatible({'foo': 'bar'}.values()[0]),
unicode,
'Dict values should be converted recursively.')
def test_dict(self):
self.assertEquals({u'foo': True,
u'bar': None,
u'baz': 3},
json_compatible({'foo': True,
'bar': None,
'baz': 3}))
self.assertEquals('{"foo": "bar"}',
json.dumps(json_compatible({'foo': 'bar'})))
self.assertIsInstance(json_compatible({'foo': 'bar'}.keys()[0]),
unicode,
'Dict keys should be converted recursively.')
self.assertIsInstance(json_compatible({'foo': 'bar'}.values()[0]),
unicode,
'Dict values should be converted recursively.')
def test_modify_a_users_loca_roles(self, browser):
self.login(self.workspace_admin, browser=browser)
browser.open(
self.workspace.absolute_url() + '/@participations',
method='GET',
headers=http_headers(),
)
entry = get_entry_by_token(browser.json.get('items'), self.workspace_guest.id)
self.assertEquals('WorkspaceGuest', entry.get('role'))
data = json.dumps(json_compatible({
'role': {'token': 'WorkspaceMember'}
}))
browser.open(
entry['@id'],
method='PATCH',
data=data,
headers=http_headers(),
)
browser.open(
self.workspace.absolute_url() + '/@participations',
method='GET',
headers=http_headers(),
)
entry = get_entry_by_token(browser.json.get('items'), self.workspace_guest.id)
self.assertEquals('WorkspaceMember', entry.get('role'))
def reply(self):
if self.transition is None:
self.request.response.setStatus(400)
return dict(error=dict(
type='BadRequest',
message='Missing transition'))
data = json_body(self.request)
if data.keys() not in [[], ['comment']]:
self.request.response.setStatus(400)
return dict(error=dict(
type='BadRequest',
message='Invalid body'))
wftool = getToolByName(self.context, 'portal_workflow')
# Disable CSRF protection
if 'IDisableCSRFProtection' in dir(plone.protect.interfaces):
alsoProvides(self.request,
plone.protect.interfaces.IDisableCSRFProtection)
try:
wftool.doActionFor(self.context, self.transition, **data)
except WorkflowException as e:
self.request.response.setStatus(400)
return dict(error=dict(
type='WorkflowException',
message=translate(e.message, context=self.request)))
history = wftool.getInfoFor(self.context, "review_history")
return json_compatible(history[-1])
def test_modify_role_of_invitation(self, browser):
self.login(self.workspace_admin, browser=browser)
storage = getUtility(IInvitationStorage)
iid = storage.add_invitation(
self.workspace, self.regular_user.getId(),
self.workspace_admin.getId(), 'WorkspaceGuest')
data = json.dumps(json_compatible({
'role': {'token': 'WorkspaceAdmin'}
}))
browser.open(
self.workspace.absolute_url() + '/@participations/invitations/{}'.format(iid),
method='PATCH',
data=data,
headers=http_headers(),
)
browser.open(
self.workspace.absolute_url() + '/@participations',
method='GET',
headers=http_headers(),
)
self.assertEquals(
'WorkspaceAdmin',
get_entry_by_token(browser.json.get('items'), iid).get('role'))
def __call__(self):
return {
'content-type':
json_compatible(self.field.getContentType(self.context)),
'data':
super(TextFieldSerializer, self).__call__()
}
def __call__(self):
image = self.field.get(self.context)
if not image:
return None
width, height = image.getImageSize()
url = get_original_image_url(
self.context,
self.field.__name__,
width,
height,
)
scales = get_scales(self.context, self.field, width, height)
result = {
'filename': image.filename,
'content-type': image.contentType,
'size': image.getSize(),
'download': url,
'width': width,
'height': height,
'scales': scales
}
return json_compatible(result)
def __call__(self):
absolute_url = self.context.absolute_url()
urls = {name: '{0}/@@images/image/{1}'.format(absolute_url, name)
for name in self.get_scale_names()}
urls['original'] = '/'.join((self.context.absolute_url(),
'@@images',
self.field.__name__))
return json_compatible(urls)
def test_richtext(self):
value = RichTextValue(u'<p>Hallöchen</p>',
mimeType='text/html',
outputMimeType='text/html')
self.assertEquals({
u'content-type': u'text/html',
u'data': u'<p>Hallöchen</p>',
u'encoding': u'utf-8'}, json_compatible(value))
def __call__(self):
summary = json_compatible({
'@id': self.context.absolute_url(),
'@type': self.context.portal_type,
'title': self.context.title,
'description': self.context.description
})
return summary
def __call__(self):
obj = IContentListingObject(self.context)
summary = json_compatible({
'@id': obj.getURL(),
'@type': obj.PortalType(),
'title': obj.Title(),
'description': obj.Description()
})
return summary
def __call__(self, *args, **kwargs):
result = {
'date': json_compatible(self.context.date),
'creator': json_compatible(self.context.creator),
'added_object': json_compatible(self.context.added_object),
'changes': json_compatible(self.context.changes),
}
# Add attributes from the response schema
for name, field in getFields(ITaskTransitionResponseFormSchema).items():
if name in self.SKIPPED_FIELDS:
continue
serializer = queryMultiAdapter(
(field, self.context, self.request), IFieldSerializer)
value = serializer()
result[json_compatible(name)] = value
return result
def __call__(self):
obj = self.context
parent = obj.aq_parent
summary = getMultiAdapter((parent, self.request), ISerializeToJson)()
summary['@type'] = obj.portal_type
summary['@id'] = obj.absolute_url(),
summary['start'] = obj.start
summary['end'] = obj.end
summary['recurrence'] = ''
return json_compatible(summary)
def __call__(self):
url = '/'.join((self.context.absolute_url(),
'@@download',
self.field.getName()))
result = {
'filename': self.field.getFilename(self.context),
'content-type': self.field.getContentType(self.context),
'size': self.field.get_size(self.context),
'download': url
}
return json_compatible(result)
def serialize_webaction(action):
"""Serialize a webaction.
`action` can be a PersistentMapping or a dict.
"""
site = getSite()
result = dict(action).copy()
result = json_compatible(result)
url = '/'.join((site.absolute_url(), '@webactions/%s' % action['action_id']))
result.update({'@id': url})
return result
def serialize(self, portal_url):
return {
'@id': self._api_url(portal_url),
'notification_id': self.notification_id,
'created': json_compatible(self.activity.created),
'read': self.is_read,
'title': self.activity.title,
'label': self.activity.label,
'link': self._resolve_notification_link(portal_url),
'summary': self.activity.summary,
}
def _create_items(self, batch):
items = []
for entry in batch:
action = entry.get('action')
item = {}
item['title'] = translate(action.get('title'), context=self.request)
item['time'] = json_compatible(entry.get('time'))
item['actor_id'] = entry.get('actor')
item['actor_fullname'] = display_name(entry.get('actor'))
item['comments'] = entry.get('comments')
items.append(item)
return items
def __call__(self):
namedfile = self.field.get(self.context)
if namedfile is None:
return None
url = "/".join((self.context.absolute_url(), "@@download", self.field.__name__))
result = {
"filename": namedfile.filename,
"content-type": namedfile.contentType,
"size": namedfile.getSize(),
"download": url,
}
return json_compatible(result)
def test_relation_value(self):
portal = self.layer['portal']
doc1 = portal[portal.invokeFactory(
'DXTestDocument', id='doc1',
title='Document 1',
description='Description',
)]
intids = getUtility(IIntIds)
self.assertEquals(
{'@id': 'http://nohost/plone/doc1',
'@type': 'DXTestDocument',
'title': 'Document 1',
'description': 'Description'},
json_compatible(RelationValue(intids.getId(doc1))))
def reply(self):
if self.transition not in self.CUSTOMIZED_TRANSITIONS:
# Delegate to default implementation
return super(GEVERDossierWorkflowTransition, self).reply()
try:
self.perform_custom_transition()
except WorkflowException as e:
self.request.response.setStatus(400)
msg = self.translate(str(e))
return dict(error=dict(
type='WorkflowException',
message=msg))
except PreconditionsViolated as e:
self.request.response.setStatus(400)
return dict(error=dict(
type='PreconditionsViolated',
errors=map(self.translate, e.errors),
message=self.translate(str(e))))
except InvalidDates as e:
# From the REST API's point of view, invalid dates are just
# another violated precondition.
self.request.response.setStatus(400)
msg = self.translate(str(e))
errors = ['The dossier %s has a invalid end_date' % title
for title in e.invalid_dossier_titles]
return dict(error=dict(
type='PreconditionsViolated',
errors=errors,
message=msg))
except AlreadyBeingResolved as e:
self.request.response.setStatus(400)
msg = self.translate(MSG_ALREADY_BEING_RESOLVED)
return dict(error=dict(
type='AlreadyBeingResolved',
message=msg))
except BadRequest as e:
self.request.response.setStatus(400)
return dict(error=dict(
type='Bad Request',
message=str(e)))
action = self.get_latest_wf_action()
return json_compatible(action)
def create_list_item(item, fields):
obj = IContentListingObject(item)
data = {'@id': obj.getURL()}
for field in fields:
if field not in FIELDS:
continue
accessor = FIELDS[field][1]
if isinstance(accessor, str):
value = getattr(obj, accessor, None)
if callable(value):
value = value()
else:
value = accessor(obj)
data[field] = json_compatible(value)
return data
def SerializeToJson(context):
result = {
'@context': 'http://www.w3.org/ns/hydra/context.jsonld',
'@id': context.absolute_url(),
'@type': context.portal_type,
'parent': {
'@id': aq_parent(aq_inner(context)).absolute_url(),
'title': aq_parent(aq_inner(context)).title,
'description': aq_parent(aq_inner(context)).description
}
}
if IFolderish.providedBy(context):
result['member'] = [
{
'@id': member.absolute_url(),
'title': member.title,
'description': member.description
}
for member in context.objectValues()
]
if HAS_PLONE_APP_CONTENTTYPES:
# Conditional import in order to avoid a hard dependency on p.a.ct
from plone.app.contenttypes.interfaces import ICollection
if ICollection.providedBy(context):
portal = getSite()
result['member'] = [
{
'@id': '{0}/{1}'.format(
portal.absolute_url(),
'/'.join(member.getPhysicalPath())
),
'title': member.title,
'description': member.description
}
for member in context.results()
]
for schema in iterSchemata(context):
for field_name, field in getFields(schema).items():
value = lookup_field_serializer(context, field)()
result[json_compatible(field_name)] = value
return result
def __call__(self):
image = self.field.get(self.context)
if not image:
return None
url = "/".join((self.context.absolute_url(), "@@images", self.field.__name__))
width, height = image.getImageSize()
scales = get_scales(self.context, self.field, width, height)
result = {
"filename": image.filename,
"content-type": image.contentType,
"size": image.getSize(),
"download": url,
"width": width,
"height": height,
"scales": scales,
}
return json_compatible(result)
