def set_deferred_uids(self):
""" Set given `uid` on current context object """
data = json.loads(self.request.BODY)
catalog = plone.api.portal.get_tool("portal_catalog")
intids = getUtility(IIntIds)
for field, uid_or_uids in data.items():
if not uid_or_uids:
continue
# Single RelationValue
if not isinstance(uid_or_uids, (list, tuple)):
brains = catalog(UID=uid_or_uids)
if brains:
rv = RelationValue(intids.getId(brains[0].getObject()))
setattr(self.context, field, rv)
else:
# RelationList
result = []
for uid in uid_or_uids:
brains = catalog(UID=uid)
if brains:
rv = RelationValue(intids.getId(brains[0].getObject()))
result.append(rv)
setattr(self.context, field, result)
self.request.response.setStatus(204)
def test_related_items_tiles(self):
self.browser.open(self.pageURL +
'/@@plone.app.standardtiles.related_items')
self.assertNotIn('relatedItems', self.browser.contents)
root = fromstring(self.browser.contents)
nodes = root.xpath('//body//*[@class="relatedItems"]')
self.assertEqual(len(nodes), 0)
self.portal.invokeFactory('Document', 'doc1', title='Document 1')
self.portal.invokeFactory('Document', 'doc2', title='Document 2')
int_ids = getUtility(IIntIds)
self.page.relatedItems = [
RelationValue(int_ids.getId(self.portal.doc1)),
RelationValue(int_ids.getId(self.portal.doc2))
]
transaction.commit()
self.browser.open(self.pageURL +
'/@@plone.app.standardtiles.related_items')
self.assertIn('relatedItems', self.browser.contents)
self.assertIn('Document 1', self.browser.contents)
self.assertIn('Document 2', self.browser.contents)
root = fromstring(self.browser.contents)
nodes = root.xpath('//body//*[@class="relatedItems"]')
self.assertEqual(len(nodes), 1)
nodes = root.xpath('//body//*[@class="relatedItems"]//ul/li')
self.assertEqual(len(nodes), 2)
def test_api_do_not_return_related_items_with_effective_date_in_future_for_anon(
self,
):
present = api.content.create(
container=self.portal, type="Document", title="present"
)
future = api.content.create(
container=self.portal, type="Document", title="future"
)
present.setEffectiveDate(DateTime())
future.setEffectiveDate(DateTime() + 1)
api.content.transition(obj=present, transition="publish")
api.content.transition(obj=future, transition="publish")
page = api.content.create(
container=self.portal,
type="Document",
title="Page",
relatedItems=[
RelationValue(self.intids.getId(present)),
RelationValue(self.intids.getId(future)),
],
)
api.content.transition(obj=page, transition="publish")
commit()
res = self.api_session.get(page.absolute_url()).json()
relatedItems = res.get("relatedItems", [])
self.assertEqual(len(relatedItems), 2)
res_anon = self.api_session_anon.get(page.absolute_url()).json()
self.assertEqual(len(res_anon["relatedItems"]), 1)
def afterSetUp(self):
""" create some sample content to test with """
if not HAS_DEXTERITY:
return
self.setRoles(('Manager', ))
fti = DexterityFTI('Dexterity Item with relatedItems behavior')
self.portal.portal_types._setObject(
'Dexterity Item with relatedItems behavior', fti)
fti.klass = 'plone.dexterity.content.Item'
test_module = 'plone.app.layout.viewlets.tests.test_content'
fti.schema = test_module + '.IMyDexterityItem'
fti.behaviors = ('plone.app.relationfield.behavior.IRelatedItems', )
fti = DexterityFTI('Dexterity Item without relatedItems behavior')
self.portal.portal_types._setObject(
'Dexterity Item without relatedItems behavior', fti)
fti.klass = 'plone.dexterity.content.Item'
fti.schema = test_module + '.IMyDexterityItem'
self.folder.invokeFactory('Document', 'doc1', title='Document 1')
self.folder.invokeFactory('Document', 'doc2', title='Document 2')
self.folder.invokeFactory('Dexterity Item with relatedItems behavior',
'dex1')
self.folder.invokeFactory('Dexterity Item with relatedItems behavior',
'dex2')
self.folder.invokeFactory(
'Dexterity Item without relatedItems behavior', 'dex3')
self.portal.portal_quickinstaller.installProduct('plone.app.intid')
intids = getUtility(IIntIds)
self.folder.dex1.relatedItems = [
RelationValue(intids.getId(self.folder.doc1)),
RelationValue(intids.getId(self.folder.doc2)),
]
def setUp(self):
super(TestDexterityRelatedItemsViewlet, self).setUp()
""" create some sample content to test with """
from Products.CMFPlone.utils import get_installer
setRoles(self.portal, TEST_USER_ID, ['Manager'])
fti = DexterityFTI('Dexterity Item with relatedItems behavior')
self.portal.portal_types._setObject(
'Dexterity Item with relatedItems behavior', fti)
fti.klass = 'plone.dexterity.content.Item'
test_module = 'plone.app.layout.viewlets.tests.test_content'
fti.schema = test_module + '.IMyDexterityItem'
fti.behaviors = ('plone.app.relationfield.behavior.IRelatedItems', )
fti = DexterityFTI('Dexterity Item without relatedItems behavior')
self.portal.portal_types._setObject(
'Dexterity Item without relatedItems behavior', fti)
fti.klass = 'plone.dexterity.content.Item'
fti.schema = test_module + '.IMyDexterityItem'
self.folder.invokeFactory('Document', 'doc1', title='Document 1')
self.folder.invokeFactory('Document', 'doc2', title='Document 2')
self.folder.invokeFactory('Dexterity Item with relatedItems behavior',
'dex1')
self.folder.invokeFactory('Dexterity Item with relatedItems behavior',
'dex2')
self.folder.invokeFactory(
'Dexterity Item without relatedItems behavior', 'dex3')
qi = get_installer(self.portal)
qi.install_product('plone.app.intid')
intids = getUtility(IIntIds)
self.folder.dex1.relatedItems = [
RelationValue(intids.getId(self.folder.doc1)),
RelationValue(intids.getId(self.folder.doc2)),
]
def test_encode(self):
values = [
'hello'
'hell\xc3\xb6', u'helllo',
datetime(2012, 1, 1),
DateTime(2012, 1, 1),
RelationValue(1111), ['hello', u'hello', 'hell\xc3\xb6'],
PersistentList(['hello', u'hello']),
[RelationValue(1111),
RelationValue(3333),
RelationValue(5555)]
]
task = self.providing_stub([ITask])
self.replay()
transporter = IResponseTransporter(task)
transporter.intids_mapping = {1111: 2222, 3333: 5555, 5555: 3333}
for value in values:
encoded_value = json.dumps(transporter._encode(value))
decoded_value = transporter._decode(json.loads(encoded_value))
# compare the value with the de- and encoded value
if isinstance(value, list):
for i in range(len(value)):
self._compare(value[i], decoded_value[i],
transporter.intids_mapping)
else:
self._compare(value, decoded_value, transporter.intids_mapping)
def setUp(self):
self.app = self.layer["app"]
self.portal = self.layer["portal"]
self.portal_url = self.portal.absolute_url()
setRoles(self.portal, TEST_USER_ID, ["Manager"])
self.api_session = RelativeSession(self.portal_url)
self.api_session.headers.update({"Accept": "application/json"})
self.api_session.auth = (SITE_OWNER_NAME, SITE_OWNER_PASSWORD)
self.intids = getUtility(IIntIds)
self.news = api.content.create(
container=self.portal, type="News Item", title="TestNews"
)
self.luogo = api.content.create(
container=self.portal,
type="Venue",
title="Luogo",
)
sede = RelationValue(self.intids.getId(self.luogo))
self.uo = api.content.create(
container=self.portal,
type="UnitaOrganizzativa",
title="TestUO",
sede=[sede],
city="Metropolis",
zip_code="1234",
street="whatever",
contact_info={"blocks": {"xxx": {"foo": "bar"}}},
)
self.uo_child = api.content.create(
container=self.uo,
type="UnitaOrganizzativa",
title="Child uo",
city="Gotham City",
zip_code="5678",
street="somewhere",
contact_info={"blocks": {"yyy": {"foo": "bar"}}},
)
self.service = api.content.create(
container=self.portal,
type="Servizio",
title="TestService",
ufficio_responsabile=[RelationValue(self.intids.getId(self.uo))],
)
self.bando = api.content.create(
container=self.portal,
type="Bando",
title="TestBando",
ufficio_responsabile=[RelationValue(self.intids.getId(self.uo))],
)
self.news.a_cura_di = [RelationValue(self.intids.getId(self.uo))]
pcatalog = getToolByName(self.portal, "portal_catalog")
pcatalog.manage_reindexIndex(ids=["ufficio_responsabile", "news_uo"])
commit()
def test_uo_locations_vocabulary_populated(self):
# create another uo and a venue
luogo_bis = api.content.create(
container=self.portal,
type="Venue",
title="Luogo bis",
)
api.content.create(
container=self.portal,
type="UnitaOrganizzativa",
title="Second UO",
sede=[RelationValue(self.intids.getId(self.luogo))],
sedi_secondarie=[RelationValue(self.intids.getId(luogo_bis))],
)
factory = getUtility(
IVocabularyFactory, "design.plone.vocabularies.uo_locations"
)
vocabulary = factory(self.portal)
self.assertIn(self.luogo.UID(), vocabulary)
self.assertIn(luogo_bis.UID(), vocabulary)
self.assertEqual(len(vocabulary), 2)
self.assertEqual(vocabulary.getTerm(self.luogo.UID()).title, self.luogo.Title())
self.assertEqual(vocabulary.getTerm(luogo_bis.UID()).title, luogo_bis.Title())
def test_related_items(self):
from z3c.relationfield import RelationValue
from zope.component import getUtility
from zope.intid.interfaces import IIntIds
with api.env.adopt_roles(['Manager']):
r1 = api.content.create(container=self.portal,
type='News Item',
title='foo')
r2 = api.content.create(container=self.portal,
type='Image',
title='bar')
intids = getUtility(IIntIds)
self.newsitem.relatedItems = [
RelationValue(intids.getId(r1)),
RelationValue(intids.getId(r2))
]
amp = etree.HTML(self.view())
relations = amp.findall('.//div[@class="amp-related"]//a')
self.assertEqual(len(relations), 2)
self.assertEqual(relations[0].text, 'foo')
self.assertTrue(relations[0].attrib['href'].endswith('foo'))
self.assertEqual(relations[1].text, 'bar')
self.assertTrue(relations[1].attrib['href'].endswith('bar/view'))
def copy_relation(self, relation_value, target_language):
obj = relation_value.to_object
intids = getUtility(IIntIds)
translation = ITranslationManager(obj).get_translation(target_language)
if translation:
return RelationValue(intids.getId(translation))
else:
return RelationValue(intids.getId(obj))
def test_relationvalue_encoding_decoding(self):
with self.login(self.regular_user):
transporter = IResponseTransporter(self.task)
transporter.intids_mapping = {111: 222}
value = RelationValue(111)
self.assertEquals(
RelationValue(222).to_id,
transporter._decode(transporter._encode(value)).to_id)
def setUp(self):
self.app = self.layer["app"]
self.portal = self.layer["portal"]
self.portal_url = self.portal.absolute_url()
self.api_session = RelativeSession(self.portal_url)
self.api_session.headers.update({"Accept": "application/json"})
self.anon_api_session = RelativeSession(self.portal_url)
self.anon_api_session.headers.update({"Accept": "application/json"})
self.api_session.auth = (SITE_OWNER_NAME, SITE_OWNER_PASSWORD)
setRoles(self.portal, TEST_USER_ID, ["Manager"])
intids = getUtility(IIntIds)
self.uo_public_1 = api.content.create(container=self.portal,
type="UnitaOrganizzativa",
title="UO 1")
self.uo_public_2 = api.content.create(container=self.portal,
type="UnitaOrganizzativa",
title="UO 2")
self.uo_private = api.content.create(container=self.portal,
type="UnitaOrganizzativa",
title="UO 3")
self.bando_public_1 = api.content.create(
container=self.portal,
type="Bando",
title="Bando 1",
subjects=["foo"],
ufficio_responsabile=[
RelationValue(intids.getId(self.uo_public_1))
],
)
self.bando_public_2 = api.content.create(
container=self.portal,
type="Bando",
title="Bando 2",
subjects=["foo", "bar"],
ufficio_responsabile=[
RelationValue(intids.getId(self.uo_public_2)),
RelationValue(intids.getId(self.uo_private)),
],
)
self.bando_private = api.content.create(
container=self.portal,
type="Bando",
title="Bando 3",
subjects=["foo", "baz"],
ufficio_responsabile=RelationValue(intids.getId(self.uo_public_1)),
)
api.content.transition(obj=self.uo_public_1, transition="publish")
api.content.transition(obj=self.uo_public_2, transition="publish")
api.content.transition(obj=self.bando_public_1, transition="publish")
api.content.transition(obj=self.bando_public_2, transition="publish")
commit()
def setUp(self):
super(TestRelatedItemsViewlet, self).setUp()
self.folder.invokeFactory('Document', 'doc1', title='Document 1')
self.folder.invokeFactory('Document', 'doc2', title='Document 2')
self.folder.invokeFactory('Document', 'doc3', title='Document 3')
intids = getUtility(IIntIds)
self.folder.doc1.relatedItems = [
RelationValue(intids.getId(self.folder.doc2)),
RelationValue(intids.getId(self.folder.doc3)),
]
def migrate(context):
intids = component.getUtility(IIntIds)
portal = api.portal.get()
with open('acteurs.csv') as csv_file:
csv_reader = csv.DictReader(csv_file, delimiter='|')
for row in csv_reader:
piece = row['piece']
acteur = row['acteur']
prenom = acteur.split(' ')[0]
nom = ' '.join(acteur.split(' ')[1:])
dbpiece = [
i for i in api.content.find(portal_type='troupedu8.Piece')
if i.Title == piece
]
dbacteur = [
i for i in api.content.find(portal_type='troupedu8.Acteur')
if i.Title == acteur
]
if not dbpiece:
raise Exception("%s n'existe pas" % piece)
elif len(dbpiece) > 1:
raise Exception("%s existe plusieurs fois" % piece)
else:
dbpiece = dbpiece[0].getObject()
if not dbacteur:
dbacteur = api.content.create(
type='troupedu8.Acteur',
title=acteur.decode('utf8'),
firstname=prenom.decode('utf8'),
lastname=nom.decode('utf8'),
container=api.content.get('/acteurs'))
api.content.transition(dbacteur, transition='publish')
elif len(dbacteur) > 1:
raise Exception("%s existe plusieurs fois" % acteur)
else:
dbacteur = dbacteur[0].getObject()
if not dbpiece.acteurs:
dbpiece.acteurs = [RelationValue(intids.getId(dbacteur))]
else:
if intids.getId(dbacteur) not in [
i.to_id for i in dbpiece.acteurs
]:
dbpiece.acteurs.append(
RelationValue(intids.getId(dbacteur)))
updateRelations(dbpiece, None)
updateRelations(dbacteur, None)
dbpiece.reindexObject()
brains = portal.portal_catalog(
portal_type=['troupedu8.Acteur', 'troupedu8.Piece'])
for brain in brains:
collection = brain.getObject()
updateRelations(collection, None)
collection.reindexObject()
def test_relations_export(self):
image = api.content.create(self.portal, 'Image', 'image1',
u'❤︎ly Pløne Image')
image.description = "This is my image."
image.image = dummy_image()
file1 = api.content.create(self.portal, 'File', 'file1',
u'❤︎ly Pløne File')
file1.description = "This is my file."
file1.file = dummy_image()
file_without_blob = api.content.create(self.portal, 'File',
'file-without-blob',
u'Pløne File without a blob')
# Add relations
doc = self.portal['doc1']
intids = getUtility(IIntIds)
doc.relatedItems = PersistentList()
doc.relatedItems.append(RelationValue(intids.getId(image)))
doc.relatedItems.append(RelationValue(intids.getId(file1)))
doc.relatedItems.append(RelationValue(intids.getId(file_without_blob)))
modified(doc)
view = api.content.get_view('collective_contentexport_view',
self.portal, self.request)
view(export_type='related', portal_type='Document')
self.assertEqual(view.request.response.headers['content-disposition'],
'attachment; filename="related.zip"')
size = int(view.request.response.headers['content-length'])
self.assertTrue(2750 < size < 2800)
view = api.content.get_view('collective_contentexport_view',
self.portal, self.request)
results = view(export_type='json', portal_type='Document')
results = json.loads(results)
related = results[0]['relatedItems']
self.assertEquals(len(related.split(',')), 3)
self.assertIn('http://nohost/plone/image1/@@download/image', related)
self.assertIn('http://nohost/plone/file1/@@download/file', related)
# TODO: Fix this
self.assertIn('http://nohost/plone/file-without-blob/@@download/file',
related)
# make sure blacklist and whitelist work for related
results = view(export_type='related',
portal_type='Document',
blacklist=['relatedItems'])
self.assertEqual('No related found', results)
results = view(export_type='related',
portal_type='Document',
whitelist=['relatedItems'])
self.assertIsNone(results)
self.assertEqual(view.request.response.headers['content-disposition'],
'attachment; filename="related.zip"')
size = int(view.request.response.headers['content-length'])
self.assertTrue(2750 < size < 2800)
def create(name=None, email=None, church=None, message=None,
video=None, sound=None, doc_data=None, doc_name=None,
step=None):
folder = utils.get_folder_unrestricted('resources/user-resources-uploads')
id = utils.create_id('resource_upload')
item = _createObjectByType('resource_upload', folder, id)
intids = component.getUtility(IIntIds)
item.title = u'{name} uploaded {count} resource(s) on {date}'.format(
name=name,
count=len(filter(lambda x: x, [bool(video), bool(sound), bool(doc_data) and bool(doc_name)])),
date=datetime.datetime.now().strftime('%A %d. %B %Y, %H:%M')
)
item.name = name
item.email = email
item.church = church
item.message = message
if video is not None:
video_obj = scheme.video.Video.create(
title='Video uploaded by {user}'.format(user=name),
description='',
url_youtube=video,
step=step
)
video_id = intids.getId(video_obj)
item.video = [RelationValue(video_id)]
notify(ObjectModifiedEvent(item))
if sound is not None:
sound_obj = scheme.sound.Sound.create(
title='Sound uploaded by {user}'.format(user=name),
description='',
soundcloud_id=sound,
step=step
)
sound_id = intids.getId(sound_obj)
item.sound = [RelationValue(sound_id)]
notify(ObjectModifiedEvent(item))
if doc_data is not None and doc_name is not None:
doc_obj = scheme.staticdocument.StaticDocument.create(
title='Document uploaded by {user}'.format(user=name),
description='',
doc_data=doc_data,
doc_name=doc_name,
step=step
)
doc_id = intids.getId(doc_obj)
item.document = [RelationValue(doc_id)]
notify(ObjectModifiedEvent(item))
return item
def test_find_ids_multiple(self):
relation = RelationValue(self.intids.getId(self.folder['d1']))
self.folder.invokeFactory('collective.alias', 'a1', _aliasTarget=relation)
relation = RelationValue(self.intids.getId(self.folder['d1']))
self.folder.invokeFactory('collective.alias', 'a2', _aliasTarget=relation)
info = IAliasInformation(self.folder['d1'])
aliases = list(info.findAliasIds())
self.assertEquals(2, len(aliases))
self.assertEquals(self.intids.getId(self.folder['a1']), aliases[0])
self.assertEquals(self.intids.getId(self.folder['a2']), aliases[1])
def add_simple_response(task,
text='',
field_changes=None,
added_object=None,
successor_oguid=None,
**kwargs):
"""Add a simple response which does (not change the task itself).
`task`: task context
`text`: fulltext
`added_object`: an object which was added to the task
`successor_oguid`: an OGUID to a (remote) object which was referenced.
"""
response = opengever.task.adapters.Response(text)
response.type = 'additional'
for key, value in kwargs.items():
setattr(response, key, value)
if field_changes:
for field, new_value in field_changes:
old_value = field.get(field.interface(task))
if old_value != new_value:
response.add_change(field.__name__, field.title, old_value,
new_value)
if added_object:
intids = getUtility(IIntIds)
if isinstance(added_object, types.ListType) or \
isinstance(added_object, types.TupleType) or \
isinstance(added_object, types.GeneratorType):
response.added_object = PersistentList()
for obj in added_object:
iid = intids.getId(obj)
response.added_object.append(RelationValue(iid))
else:
iid = intids.getId(added_object)
response.added_object = RelationValue(iid)
if successor_oguid:
response.successor_oguid = successor_oguid
container = opengever.task.adapters.IResponseContainer(task)
container.add(response)
notify(ObjectModifiedEvent(task))
TaskTransitionActivity(task, task.REQUEST, response).record()
return response
def test_broken_relation(self):
folder = create(Builder('folder').titled(u'The Folder'))
intids = getUtility(IIntIds)
folder_intid = intids.getId(folder)
input_relation_value = RelationValue(folder_intid)
input_relation_value.from_attribute = 'bar'
input = [{
'foo': input_relation_value,
}]
api.content.delete(folder)
output = self.transport(input)
self.assertEqual([{'foo': None}], output)
def update_references(object, event=None):
"""Get list of Related Issues set here, and relate them back
Then check the getBRefs to remove references that have been removed
Sort the issues in descending id order
"""
catalog = getUtility(ICatalog)
intids = getUtility(IIntIds)
objintid = intids.getId(aq_inner(object))
if object.related_issue is None:
return
# sort the relationvalues on this object by id
relatedIssues = sorted(object.related_issue,
key=lambda issue: int(issue.to_object.id),
reverse=True)
object.related_issue = relatedIssues
# add this issue to its related issues where needed
for issue in relatedIssues:
others_related = issue.to_object.related_issue
if not others_related:
others_related = []
for other in others_related:
if objintid == other.to_id:
break
else:
rv = RelationValue(objintid)
others_related.append(rv)
issue.to_object.related_issue = sorted(
others_related,
key=lambda issue: int(issue.to_id),
reverse=True)
# find other issues related to this one
issuesRelated = []
for rel in catalog.findRelations(
dict(to_id=objintid, from_attribute='related_issue')):
issuesRelated.append(RelationValue(rel.from_id))
# remove relations from those issues to this one if neeeded
for issue in issuesRelated:
if issue.to_id in [r.to_id for r in object.related_issue]:
continue
issue_object = intids.queryObject(issue.to_id)
others_related = issue_object.related_issue
if objintid not in [r.to_id for r in others_related]:
continue
others_related = [x for x in others_related if x.to_id != objintid]
issue_object.related_issue = others_related
def test_relation_value(self):
folder = create(Builder('folder').titled(u'The Folder'))
intids = getUtility(IIntIds)
folder_intid = intids.getId(folder)
input_relation_value = RelationValue(folder_intid)
input_relation_value.from_attribute = 'bar'
input = [{
'foo': input_relation_value,
}]
output = self.transport(input)
self.assertEqual(RelationValue, type(output[0]['foo']))
self.assertEqual(folder_intid, output[0]['foo'].to_id)
self.assertEqual('bar', output[0]['foo'].from_attribute)
def test_api_do_not_return_related_items_with_effective_date_in_future_for_users_that_cant_edit_context(
self,
):
api.user.create(
email="*****@*****.**",
username="******",
password="******",
)
api_session = RelativeSession(self.portal_url)
api_session.headers.update({"Accept": "application/json"})
api_session.auth = ("foo", "secret")
present = api.content.create(
container=self.portal, type="Document", title="present"
)
future = api.content.create(
container=self.portal, type="Document", title="future"
)
present.setEffectiveDate(DateTime())
future.setEffectiveDate(DateTime() + 1)
api.content.transition(obj=present, transition="publish")
api.content.transition(obj=future, transition="publish")
page = api.content.create(
container=self.portal,
type="Document",
title="Page",
relatedItems=[
RelationValue(self.intids.getId(present)),
RelationValue(self.intids.getId(future)),
],
)
api.content.transition(obj=page, transition="publish")
commit()
setRoles(self.portal, "foo", ["Reader"])
commit()
res = api_session.get(page.absolute_url()).json()
relatedItems = res.get("relatedItems", [])
self.assertEqual(len(relatedItems), 1)
setRoles(self.portal, "foo", ["Editor"])
commit()
res = api_session.get(page.absolute_url()).json()
relatedItems = res.get("relatedItems", [])
self.assertEqual(len(relatedItems), 2)
class RelationFieldMarshaler(BaseFieldMarshaler):
ascii = True
def encode(self, value, charset='utf-8', primary=False):
if value is None:
return None
if value.to_object is None:
return None
return IUUID(value.to_object)
def decode(self,
value,
message=None,
charset='utf-8',
contentType=None,
primary=False):
try:
uuid = value.decode(charset)
except TypeError, e:
raise ValueError(e)
intids = getUtility(IIntIds)
portal_catalog = api.portal.get_tool('portal_catalog')
for brain in portal_catalog.unrestrictedSearchResults(UID=uuid):
# noinspection PyProtectedMember
ob = brain._unrestrictedGetObject()
intid = intids.queryId(ob)
if intid is None:
intid = intids.register(ob)
return RelationValue(intid)
return None
def test_get_file(self): # pragma: no cover
self.portal.invokeFactory('File', id='file1')
self.portal.file1.title = 'File'
self.portal.file1.description = u'A file'
pdf_file = os.path.join(
os.path.dirname(__file__), u'file.pdf'
)
self.portal.file1.file = NamedBlobFile(
data=open(pdf_file, 'r').read(),
contentType='application/pdf',
filename=u'file.pdf'
)
intids = getUtility(IIntIds)
file_id = intids.getId(self.portal.file1)
self.portal.file1.file = RelationValue(file_id)
transaction.commit()
response = self.api_session.get(self.portal.file1.absolute_url())
self.assertEqual(response.status_code, 200)
self.assertEqual(
response.headers.get('Content-Type'),
'application/json',
'When sending a GET request with Content-Type: application/json ' +
'the server should respond with sending back application/json.'
)
self.assertEqual(
response.json()['@id'],
self.portal.file1.absolute_url()
)
def updateRelatedItems(wfStateInfo):
logger.info("updateRelatedItems")
print "update related items for original file"
originalfile = wfStateInfo.object
epublication = aq_parent(aq_inner(originalfile))
intids = getUtility(IIntIds)
originalfile.relatedItems = [RelationValue(intids.getId(epublication))]
def test_get_content_related_items_without_workflow(self):
intids = getUtility(IIntIds)
self.portal.invokeFactory("Image", id="imagewf")
self.portal.imagewf.title = "Image without workflow"
self.portal.imagewf.description = "This is an image"
image_file = os.path.join(os.path.dirname(__file__), "image.png")
with open(image_file, "rb") as f:
image_data = f.read()
self.portal.imagewf.image = NamedBlobImage(data=image_data,
contentType="image/png",
filename="image.png")
transaction.commit()
self.portal.folder1.doc1.relatedItems = [
RelationValue(intids.getId(self.portal.imagewf))
]
transaction.commit()
response = requests.get(
self.portal.folder1.doc1.absolute_url(),
headers={"Accept": "application/json"},
auth=(SITE_OWNER_NAME, SITE_OWNER_PASSWORD),
)
self.assertEqual(response.status_code, 200)
self.assertEqual(1, len(response.json()["relatedItems"]))
self.assertEqual(
[{
"@id": self.portal_url + "/imagewf",
"@type": "Image",
"description": "This is an image",
"review_state": None,
"title": "Image without workflow",
}],
response.json()["relatedItems"],
)
def get_content_links(obj):
refs = set()
if ILayoutAware.providedBy(obj):
behavior_data = ILayoutAware(obj)
# get data from tile data
annotations = IAnnotations(obj)
for key in annotations.keys():
if key.startswith(ANNOTATIONS_KEY_PREFIX):
data = annotations[key]
refs |= get_tile_data_links(obj, data)
if not behavior_data.contentLayout and behavior_data.content:
dom = fromstring(behavior_data.content)
for el in dom.cssselect('.mosaic-text-tile .mosaic-tile-content'):
links = extractLinks(tostring(el))
refs |= li.getObjectsFromLinks(obj, links)
try:
# scan more than just this we probably should...
value = obj.text.raw
links = extractLinks(value)
refs |= li.getObjectsFromLinks(obj, links)
except AttributeError:
pass
if getattr(obj, 'image'):
if IReferenceNamedImage.providedBy(obj.image):
sub_obj = uuidToObject(obj.image.reference)
if sub_obj:
objid = get_ref(obj)
if objid:
refs.add(RelationValue(objid))
return refs
def restore_backrefs(portal, obj):
"""Restore backreferences stored in the attribute _backrefs.
"""
intids = getUtility(IIntIds)
uid_catalog = getToolByName(portal, 'uid_catalog')
try:
backrefobjs = [uuidToObject(uuid) for uuid in obj._backrefs]
for backrefobj in backrefobjs:
# Dexterity and
if IDexterityContent.providedBy(backrefobj):
relitems = getattr(backrefobj, 'relatedItems', None)
if not relitems:
backrefobj.relatedItems = PersistentList()
elif not isinstance(obj.relatedItems, PersistentList):
backrefobj.relatedItems = PersistentList(obj.relatedItems)
to_id = intids.getId(obj)
backrefobj.relatedItems.append(RelationValue(to_id))
# Archetypes
elif IATContentType.providedBy(backrefobj):
# reindex UID so we are able to set the reference
path = '/'.join(obj.getPhysicalPath())
uid_catalog.catalog_object(obj, path)
backrefobj.setRelatedItems(obj)
logger.info('Restored BackRelation from %s to %s' %
(backrefobj, obj))
except AttributeError:
pass
def get_learner(self, classlist, code, name, gender_code, language_code):
""" Look if the learner exists in the system.
If we can't find them there, we create a new one and set its
properties to those specified in the import data.
Note: At this stage the code will not overwrite existing learners.
It just skips them.
IMPORTANT - This assumes that a learner can only be in one classlist
at a time.
"""
learner = None
# Now try to find the learner in the system
# better make sure we search with 'None' or we get false positives
if code == '': code = None
query = {'portal_type': 'upfront.classlist.content.learner',
'id': code}
pc = getToolByName(self, 'portal_catalog')
brains = pc(**query)
# For the moment we assume there can be only one...
learner = len(brains) > 0 and brains[0].getObject() or None
# We found her, no need to recreate.
if learner is not None:
message = _("Skipping existing learner") + ': %s' % name
return message, learner
# We could not find the learner, so we will create one, but first
# get our data ducks in a row.
if gender_code not in self.genders():
msgid = _(u"learners_gender_not_recognized",
default=u"Learner: ${name} gender: ${gender} not recognized",
mapping={ u"name" : name, u"gender" : gender_code})
msg = self.context.translate(msgid)
return msg, None
if language_code not in self.languages()[0]:
msgid = _(u"learners_language_not_recognized",
default=u"Learner: ${name} language: ${language} not recognized",
mapping={ u"name" : name, u"language" : language_code})
msg = self.context.translate(msgid)
return msg, None
# create learner
classlist.invokeFactory('upfront.classlist.content.learner',
code,
title=name)
new_learner = classlist._getOb(code)
new_learner.code = code
new_learner.name = name
new_learner.gender = gender_code
# get position of language in language vocab, using index get its
# corresponding intid from initid list
index = self.languages()[0].index(language_code)
lang_intid = self.languages()[1][index]
new_learner.home_language = RelationValue(lang_intid)
notify(ObjectModifiedEvent(new_learner))
return None, new_learner
def test_get_file(self): # pragma: no cover
self.portal.invokeFactory("File", id="file1")
self.portal.file1.title = "File"
self.portal.file1.description = "A file"
pdf_file = os.path.join(os.path.dirname(__file__), "file.pdf")
with open(pdf_file, "rb") as f:
pdf_data = f.read()
self.portal.file1.file = NamedBlobFile(data=pdf_data,
contentType="application/pdf",
filename="file.pdf")
intids = getUtility(IIntIds)
file_id = intids.getId(self.portal.file1)
self.portal.file1.file = RelationValue(file_id)
transaction.commit()
response = self.api_session.get(self.portal.file1.absolute_url())
self.assertEqual(response.status_code, 200)
self.assertEqual(
response.headers.get("Content-Type"),
"application/json",
"When sending a GET request with Content-Type: application/json " +
"the server should respond with sending back application/json.",
)
self.assertEqual(response.json()["@id"],
self.portal.file1.absolute_url())
def set_field_value(self, uid, field, value, field_type):
"""Set field value with a specific type
XXX: Only dexterity fields are supported
"""
pc = getToolByName(self, 'portal_catalog')
results = pc.unrestrictedSearchResults(UID=uid)
obj = results[0]._unrestrictedGetObject()
if field_type == 'float':
value = float(value)
if field_type == 'int':
value = int(value)
if field_type == 'list':
value = eval(value)
if field_type.startswith('datetime'):
# field_type must begin with 'datetime'
# followed by optional format 'datetime%Y%m%d%H%M'
# without format: %Y%m%d%H%M is used
field_type = field_type[8:]
fmt = field_type and field_type or '%Y%m%d%H%M'
value = datetime.strptime(value, fmt)
if field_type.startswith('date'):
# field_type must begin with 'date'
# followed by optional format 'date%Y%m%d'
# without format: %Y%m%d is used
field_type = field_type[4:]
fmt = field_type and field_type or '%Y%m%d'
value = datetime.strptime(value, fmt).date()
if field_type == 'reference' and HAS_DEXTERITY_RELATIONS:
results_referenced = pc.unrestrictedSearchResults(UID=value)
referenced_obj = results_referenced[0]._unrestrictedGetObject()
intids = getUtility(IIntIds)
referenced_obj_intid = intids.getId(referenced_obj)
value = RelationValue(referenced_obj_intid)
if field_type == 'references' and HAS_DEXTERITY_RELATIONS:
values = eval(value)
intids = getUtility(IIntIds)
value = []
for uid in values:
results_referenced = pc.unrestrictedSearchResults(UID=uid)
referenced_obj = results_referenced[0]._unrestrictedGetObject()
referenced_obj_intid = intids.getId(referenced_obj)
value.append(RelationValue(referenced_obj_intid))
if field_type == 'text/html':
value = RichTextValue(
value,
'text/html',
'text/html'
)
obj.text = value
if field_type == 'file':
pdf_file = os.path.join(
os.path.dirname(__file__), 'content', u'file.pdf')
with open(pdf_file, 'rb') as f:
file_data = f.read()
value = NamedBlobFile(
data=file_data,
contentType='application/pdf',
filename=u'file.pdf'
)
if field_type == 'image':
image_file = os.path.join(
os.path.dirname(__file__), u'image.jpg')
with open(image_file, 'rb') as f:
image_data = f.read()
value = NamedBlobImage(
data=image_data,
contentType='image/jpg',
filename=u'image.jpg'
)
setattr(obj, field, value)
obj.reindexObject()
notify(ObjectModifiedEvent(obj))
