def _create_task(self, context, with_docs=False, return_docs=False):
# task
task = createContentInContainer(
context,
'opengever.task.task',
title="Task1", task_type='correction',
checkConstraints=False)
task.responsible = TEST_USER_ID
if not with_docs:
return task
documents = []
# containing documents
documents.append(set_defaults(createContentInContainer(
task, 'opengever.document.document', title=u'Doc 1')))
documents.append(set_defaults(createContentInContainer(
task, 'opengever.document.document', title=u'Doc 2')))
# related documents
documents.append(set_defaults(createContentInContainer(
context, 'opengever.document.document', title=u'Doc 3')))
documents.append(set_defaults(createContentInContainer(
context, 'opengever.document.document', title=u'Doc 4')))
intids = getUtility(IIntIds)
ITask(task).relatedItems = [
RelationValue(intids.getId(documents[2]))]
if return_docs:
return task, documents
return task
def handleAdd(self, action):
data, errors = self.extractData()
if errors:
self.status = self.formErrorsMessage
return
self.checkISBN(data)
# newEPublication = data.get('epublication_uid') and api.content.get(UID=data['epublication_uid']) \
# or self.addEPublication(data)
newEPublication = self.addEPublication(data)
newOriginalFile = self.addOriginalFile(newEPublication, data)
# poslat zadost na vygenerovani ohlasovaciho listku - je na to
# amqp sluzba
if not data.get('epublication_uid'):
authors = [data[key] for key in ['author1','author2','author3'] if data[key]]
for author in authors:
createContentInContainer(newEPublication, 'edeposit.content.author', fullname=author, title=author)
messages = IStatusMessage(self.request)
messages.addStatusMessage(u"ePublikace byla ohlášena.", type="info")
fti = getUtility(IDexterityFTI, name=newOriginalFile.portal_type)
#returnURL = "/".join([container.absolute_url(), newEPublication.id, newOriginalFile.id, fti.immediate_view])
self.request.response.redirect(newOriginalFile.absolute_url())
def test_validateIndexValueUniqueness(self):
imail1 = createContentInContainer(self.portal, 'dmsincomingmail', **{'internal_reference_no': '12345',
'title': 'Test 1'})
#test with container as context, value doesn't exist
self.assertEquals(dmsmail.validateIndexValueUniqueness(self.portal, 'dmsincomingmail',
'internal_reference_number', '54321'), None)
#test with container as context, value exists
self.assertRaisesRegexp(Invalid, u"This value is already used", dmsmail.validateIndexValueUniqueness,
*[self.portal, 'dmsincomingmail', 'internal_reference_number', '12345'])
#test with object as context, value doesn't exist
self.assertEquals(dmsmail.validateIndexValueUniqueness(imail1, 'dmsincomingmail',
'internal_reference_number', '54321'), None)
#test with object as context, value exists on the same object
self.assertEquals(dmsmail.validateIndexValueUniqueness(imail1, 'dmsincomingmail',
'internal_reference_number', '12345'), None)
#test with object as context and a sub element in the folder, value exists on the same object
createContentInContainer(imail1, 'dmsmainfile', **{'title': 'File 1'})
self.assertEquals(dmsmail.validateIndexValueUniqueness(imail1, 'dmsincomingmail',
'internal_reference_number', '12345'), None)
#test with object as context, value exists on a different object too
imail2 = createContentInContainer(self.portal, 'dmsincomingmail',
**{'internal_reference_no': '12345', 'title': 'Test 2'})
self.assertRaisesRegexp(Invalid, u"This value is already used", dmsmail.validateIndexValueUniqueness,
*[imail2, 'dmsincomingmail', 'internal_reference_number', '12345'])
#test with empty value
imail3 = createContentInContainer(self.portal, 'dmsincomingmail',
**{'internal_reference_no': '', 'title': 'Test 2'})
self.assertEquals(dmsmail.validateIndexValueUniqueness(self.portal, 'dmsincomingmail',
'internal_reference_number', ''), None)
self.assertEquals(dmsmail.validateIndexValueUniqueness(imail3, 'dmsincomingmail',
'internal_reference_number', ''), None)
def test_objects_marked_as_BaseDocuments_use_same_counter(self):
seqNumb = getUtility(ISequenceNumber)
d1 = createContentInContainer(self.portal, "opengever.document.document")
b1 = createContentInContainer(self.portal, "SimpleDocument")
d2 = createContentInContainer(self.portal, "opengever.document.document")
self.assertEquals([1, 2, 3], [seqNumb.get_number(d1), seqNumb.get_number(b1), seqNumb.get_number(d2)])
def addHidewhen(self):
""" Add a hide-when to the form.
"""
hidewhenid = self.request.get("hidewhenid", None)
hidewhenformula = self.request.get("hidewhenformula", '')
hidewhentype = self.request.get("hidewhentype", 'static')
isdynamic = hidewhentype=='dynamic',
# self.context is the current form
if hidewhenid:
if not hasattr(self.context, hidewhenid):
createContentInContainer(
self.context,
'PlominoHidewhen',
title=hidewhenid,
id=hidewhenid,
formula=hidewhenformula,
isDynamicHidewhen=isdynamic,
)
self.request.RESPONSE.redirect(self.context.absolute_url() + "/@@tinymceplominoform/valid_page?type=hidewhen&value=" + hidewhenid)
else:
self.request.RESPONSE.redirect(self.context.absolute_url() + "/@@tinymceplominoform/error_page?error=object_exists")
else:
self.request.RESPONSE.redirect(self.context.absolute_url() + "/@@tinymceplominoform/error_page?error=no_hidewhen")
def _createCompaniesGroups(home, company, username,
mtool, auth_user, request):
private_group = createContentInContainer(
home,
'collective.rcse.group',
title=translate(_(u"${company}'s private group",
mapping={'company': company.title}),
context=request
)
)
private_group.manage_delLocalRoles([auth_user])
private_group.changeOwnership(mtool.getMemberById(username))
private_group.manage_setLocalRoles(username, ['Owner'])
private_group.setCreators([username])
private_group.reindexObjectSecurity()
company.private_group = private_group.id
public_group = createContentInContainer(
home,
'collective.rcse.group',
title=translate(_(u"${company}'s public group",
mapping={'company': company.title}),
context=request
)
)
public_group.manage_delLocalRoles([auth_user])
public_group.changeOwnership(mtool.getMemberById(username))
public_group.manage_setLocalRoles(username, ['Owner'])
public_group.setCreators([username])
public_group.reindexObjectSecurity()
wtool = getToolByName(company, 'portal_workflow')
wtool.doActionFor(public_group, 'show_internally')
company.public_group = public_group.id
def setUp(self):
layer = self.globs['layer']
browser = Browser(layer['app'])
portal = layer['portal']
self.globs.update({
'TEST_USER_NAME': TEST_USER_NAME,
'TEST_USER_PASSWORD': TEST_USER_PASSWORD,
'browser': browser,
'portal': portal,
})
browser.setBaseUrl(portal.absolute_url())
browser.handleErrors = True
portal.error_log._ignored_exceptions = ()
setRoles(portal, TEST_USER_ID, ['Manager'])
alsoProvides(portal, IShoppingSiteRoot)
portal.reindexObject()
container = createContentInContainer(
portal, 'collective.cart.core.OrderContainer', checkConstraints=False, id='order-container', title='Örder Cöntäiner')
modified(container)
order1 = createContentInContainer(container, 'collective.cart.core.Order', checkConstraints=False, id='1')
modified(order1)
transaction.commit()
def test_portlet_event_renderer__recurring(self):
tz = pytz.timezone(TZNAME)
start = tz.localize(datetime.now()) + timedelta(days=1)
e1 = createContentInContainer(
self.portal, PTYPE, id='e1', title='Event 1', start=start,
recurrence='RRULE:FREQ=WEEKLY;COUNT=10')
createContentInContainer(
self.portal, PTYPE, id='e1', title='Event 1', start=start,
recurrence='RRULE:FREQ=DAILY;COUNT=3')
self.portal.portal_workflow.doActionFor(e1, 'publish')
r = self.renderer(
assignment=portlet_events.Assignment(count=5,
state=('published',)))
events = r.events
self.assertEqual(5, len(events))
self.assertTrue('Event 2' not in [x.title for x in events])
rd = r.render()
occ1dt = start + timedelta(days=7)
# The first occurrence of the event itself should show up. It should
# link to the event and not an occurrence.
self.assertTrue('http://nohost/plone/e1"' in rd)
# Occurrences should link to the Occurrence.
self.assertTrue(
'http://nohost/plone/e1/%s-%02d-%02d' %
(occ1dt.year, occ1dt.month, occ1dt.day) in rd
)
def __call__(self):
req_file = self.request.get('file')
c_type = req_file.headers.get('content-type', '')
file_data = req_file.read()
file_name = safe_unicode(req_file.filename)
media_container = self.get_media_container()
behavior = IRelatedMedia(self.context)
if c_type.startswith("image/"):
blob = NamedBlobImage(data=file_data, filename=file_name)
img = createContentInContainer(
media_container, "Image", image=blob)
# safe image as leadImage if none exists
if ILeadImage.providedBy(self.context) and \
ILeadImage(self.context).image is None:
ILeadImage(self.context).image = blob
else:
to_id = self.intids.getId(img)
imgs = behavior.related_images and \
list(behavior.related_images) or []
imgs.append(RelationValue(to_id))
behavior.related_images = imgs
else:
blob = NamedBlobFile(data=file_data, filename=file_name)
att = createContentInContainer(media_container, "File", file=blob)
to_id = self.intids.getId(att)
atts = behavior.related_attachments and \
list(behavior.related_attachments) or []
atts.append(RelationValue(to_id))
behavior.related_attachments = atts
return json.dumps(dict(
status=u"done",
))
def createDocument(context, folder, portal_type, title, file_object, owner=None, metadata=None):
if owner is None:
owner = api.user.get_current().id
if not metadata:
metadata = {}
if 'title' not in metadata and title:
metadata['title'] = title
if portal_type == 'dmsincomingmail':
if 'internal_reference_no' not in metadata:
metadata['internal_reference_no'] = internalReferenceIncomingMailDefaultValue(context)
if 'reception_date' not in metadata:
metadata['reception_date'] = receptionDateDefaultValue(context)
elif portal_type == 'dmsoutgoingmail':
if 'internal_reference_no' not in metadata:
metadata['internal_reference_no'] = internalReferenceOutgoingMailDefaultValue(context)
file_title = _('Scanned Mail')
if 'file_title' in metadata:
file_title = metadata['file_title']
del metadata['file_title']
with api.env.adopt_user(username=owner):
document = createContentInContainer(folder, portal_type, **metadata)
log.info('document has been created (id: %s)' % document.id)
if IDeadline and IDeadline.providedBy(document):
document.deadline = deadlineDefaultValue(None)
version = createContentInContainer(document, 'dmsmainfile', title=file_title,
file=file_object)
log.info('file document has been created (id: %s)' % version.id)
return (document, version)
def test_extended_path_index_depth_limiting(self):
lvl1 = createContentInContainer(self.portal, u'Folder', id=u'lvl1')
lvl2 = createContentInContainer(lvl1, u'Folder', id=u'lvl2')
createContentInContainer(lvl2, u'Folder', id=u'lvl3')
transaction.commit()
path = '/plone/lvl1'
# Depth 0 - only object identified by path
query = {'path.query': path, 'path.depth': 0}
response = self.api_session.get('/search', params=query)
self.assertEqual(
[u'/plone/lvl1'],
result_paths(response.json()))
# Depth 1 - immediate children
query = {'path.query': path, 'path.depth': 1}
response = self.api_session.get('/search', params=query)
self.assertEqual(
[u'/plone/lvl1/lvl2'],
result_paths(response.json()))
# No depth - object itself and all children
query = {'path': path}
response = self.api_session.get('/search', params=query)
self.assertSetEqual(
{u'/plone/lvl1', u'/plone/lvl1/lvl2', u'/plone/lvl1/lvl2/lvl3'},
set(result_paths(response.json())))
def create_order(self, order_id=None):
"""Create order into order container from cart in session
:param order_id: Order ID
:type order_id: str
:rtype: collective.cart.core.Order
"""
container = self.order_container()
articles = self.cart_articles()
if container and articles:
if order_id is None:
order_id = str(container.next_order_id)
order = createContentInContainer(
container, "collective.cart.core.Order", id=order_id, checkConstraints=False
)
modified(order)
self.update_next_order_id()
for uuid in articles:
article = createContentInContainer(
order, "collective.cart.core.OrderArticle", checkConstraints=False, **articles[uuid]
)
modified(article)
return order
def update_mimic(self, *args, **kwargs):
req = self.request
mimic = req.get('existing-charts', None)
mimic = self.context.get(mimic, None)
if not mimic:
self.status.addStatusMessage(
'Unable to locate existing chart',
type='warning'
)
return
linecount = len(mimic.objectIds())
title = self._stylebook_title()
stylebook = createContentInContainer(
self.context,
STYLEBOOK_TYPE,
title=title,
)
for i in range(linecount):
createContentInContainer(
stylebook,
LINESTYLE_TYPE,
title=u'Line style %s' % i + 1,
)
clone_chart_styles(source=mimic, target=stylebook)
self._contained = self._stylebooks = None # un-cache now outdated
self.status.addStatusMessage(
'Created a new stylebook "%s" based on styles of existing chart '
'"%s".' % (title, mimic.Title()),
type='info',
)
def loadSecretome(portal):
if portal._p_jar is not None and isinstance(portal._p_jar.db()._storage, DemoStorage):
# Don't bother if we're just testing
return
try:
resources = portal['resources']
except KeyError:
resources = portal[portal.invokeFactory('Folder', 'resrouces')]
resources.title = u'Resources'
try:
secretome = resources['secretome']
except KeyError:
secretome = createContentInContainer(resources, 'eke.secretome.secretomefolder', title=u'Secretome')
ids = secretome.keys()
if len(ids) > 0:
secretome.manage_delObjects(list(ids))
with pkg_resources.resource_stream(__name__, 'data/uniqueIDs.csv') as infile:
rows = csv.DictReader(infile)
for row in rows:
probesetID, hgnc, timesMapped = row['hgu133plus2ID'], row['HGNC.symbol'], int(row['times.mapped.to'])
databases = row['databases.foundin'].split(u'|')
_logger.info('Creating probeset %s', probesetID)
createContentInContainer(
secretome,
'eke.secretome.probeset',
title=probesetID,
hgncSymbol=hgnc,
databaseNames=databases,
timesMapped=timesMapped
)
transaction.commit()
with pkg_resources.resource_stream(__name__, 'data/mappedIDs.csv') as infile:
rows = csv.DictReader(infile)
mappings = {}
class Mapping(object):
def __init__(self):
self.databases, self.probesets = set(), set()
for row in rows:
database, gene, probesets = row['database'], row['beforemapping'], row['hgu133plus2.ID']
if probesets == 'none':
probesets = set()
else:
probesets = set(probesets.split(u'|'))
mapping = mappings.get(gene, Mapping())
mapping.databases.add(database)
mapping.probesets = mapping.probesets | probesets
mappings[gene] = mapping
for gene, mapping in mappings.iteritems():
_logger.info('Creating gene/protein %s', gene)
createContentInContainer(
secretome,
'eke.secretome.geneprotein',
title=gene,
databaseNames=list(mapping.databases),
probesetMappings=list(mapping.probesets)
)
transaction.commit()
_logger.info('Publishing everything')
publish(resources)
transaction.commit()
def test_integration_mail_events(self):
""" Trigger every event of a mail at least one times
and check the journalentries.
"""
portal = self.layer['portal']
dossier = createContentInContainer(
portal, 'opengever.dossier.businesscasedossier', 'd1')
fti = getUtility(IDexterityFTI, name='ftw.mail.mail')
schema = fti.lookupSchema()
field_type = getFields(schema)['message']._type
msgtxt = 'Subject: mail-test\n'
mail = createContentInContainer(
dossier, 'ftw.mail.mail',
message=field_type(data=msgtxt,
contentType=u'message/rfc822', filename=u'attachment.txt'))
# The journal of a mail is always on the parents dossier and not
# on the mail
self.check_annotation(
dossier,
action_type='Mail added',
action_title='Mail added: %s' % mail.title_or_id(),
check_entry=-2, )
def update(self):
try:
from plone.protect.interfaces import IDisableCSRFProtection
alsoProvides(self.request, IDisableCSRFProtection)
except:
pass
if self.request.environ['REQUEST_METHOD'] == 'POST':
portal = api.portal.get()
folder_name = self.request.get("folder")
local_file = self.request.get("local_file")
f = open(local_file, 'r')
content = f.read()
f.close()
for folder_name_part in folder_name.split('/'):
if portal.get(folder_name_part) is None:
makeFolder(portal, folder_name_part)
portal = portal.get(folder_name_part)
file = NamedBlobFile(
data=content,
filename=u'{}'.format(local_file),
contentType='application/xls'
)
createContentInContainer(
portal,
'AppFile',
id='{}'.format(local_file.split('/')[-1]),
title='{}'.format(local_file.split('/')[-1]),
file=file,
checkConstraints=False
)
def _find_container(self, industry_cluster, industry_cluster_title,
job_grouping, job_grouping_title):
site = getSite()
if not 'cluster' in site.keys():
site.invokeFactory(type_name='Folder', id='cluster')
obj = site['cluster']
obj.setTitle('Clusters')
obj.reindexObject()
repo = site['cluster']
if not repo.has_key(industry_cluster):
obj = createContentInContainer(repo,
'dkiscm.jobmatrix.industrycluster',
title=industry_cluster
)
obj.setTitle(industry_cluster_title)
obj.reindexObject()
cluster = repo[industry_cluster]
if not cluster.has_key(job_grouping):
obj = createContentInContainer(cluster,
'dkiscm.jobmatrix.jobgroup',
title=job_grouping
)
obj.setTitle(job_grouping_title)
obj.reindexObject()
container = cluster[job_grouping]
return container
def test_registering_translation(self):
a_ca = createContentInContainer(self.portal["ca"], "Document", title=u"Test document")
b_ca = createContentInContainer(self.portal["ca"], "Document", title=u"Test document")
transaction.commit()
# Register translation
self.browser.open(a_ca.absolute_url() + "/add_translations")
self.assertEqual(self.browser.getControl(name="form.widgets.language:list").options, ["en", "es"])
# Fill in form
form = self.browser.getForm(index=1)
form.mech_form.new_control(
type="radio",
name="form.widgets.content:list",
attrs=dict(checked="checked", value="%s" % "/".join(b_ca.getPhysicalPath()), id="form-widgets-content-0"),
)
self.browser.getControl(name="form.widgets.language:list").value = ["en"]
self.browser.getControl(name="form.buttons.add_translations").click()
# Language is removed from nontranslated languages
self.assertEqual(self.browser.getControl(name="form.widgets.language:list").options, ["es"])
# And translation can be unregistered
self.browser.open(a_ca.absolute_url() + "/remove_translations")
self.assertEqual(self.browser.getControl(name="form.widgets.languages:list").value, ["en"])
def addedEPeriodicalPartsFolder(context, event):
periodicity = context.aq_parent.cetnost_vydani
nums = getNumOfPartsAYear(periodicity)
for num in range(1,nums+1):
title = getPeriodicityLabel(num)
createContentInContainer(context, 'edeposit.content.eperiodicalpart', title=title)
pass
def test_update_all_categorized_elements(self):
document1 = createContentInContainer(
container=self.portal,
portal_type='Document',
title='doc1',
content_category='config_-_group-1_-_category-1-1',
to_print=False,
confidential=False,
)
document1UID = document1.UID()
document2 = createContentInContainer(
container=self.portal,
portal_type='Document',
title='doc2',
content_category='config_-_group-1_-_category-1-1',
to_print=False,
confidential=False,
)
document2UID = document2.UID()
self.assertEqual(len(self.portal.categorized_elements), 2)
self.assertTrue(document1UID in self.portal.categorized_elements)
self.assertTrue(document2UID in self.portal.categorized_elements)
self.portal.categorized_elements = OrderedDict()
self.assertEqual(len(self.portal.categorized_elements), 0)
utils.update_all_categorized_elements(self.portal)
self.assertEqual(len(self.portal.categorized_elements), 2)
self.assertTrue(document1UID in self.portal.categorized_elements)
self.assertTrue(document2UID in self.portal.categorized_elements)
# if a content_category is wrong, element is no more stored in categorized_elements
document1.content_category = 'some_wrong_category_id'
utils.update_all_categorized_elements(self.portal)
self.assertEqual(len(self.portal.categorized_elements), 1)
self.assertTrue(document2UID in self.portal.categorized_elements)
def testCloneNamedFileBlobsInSchema(self):
file_fti = DexterityFTI(
'BlobFile',
model_source="""
<model xmlns="http://namespaces.plone.org/supermodel/schema">
<schema>
<field name="file" type="plone.namedfile.field.NamedBlobFile">
<title>File</title>
<required>True</required>
</field>
</schema>
</model>
""")
self.portal.portal_types._setObject('BlobFile', file_fti)
file1 = createContentInContainer(self.portal, 'BlobFile')
file1.file = NamedBlobFile('dummy test data', filename=u'test.txt')
modifier = CloneNamedFileBlobs('modifier', 'Modifier')
attrs_dict = modifier.getReferencedAttributes(file1)
self.assertTrue(
'plone.dexterity.schema.generated.plone_0_BlobFile.file'
in attrs_dict)
blob = attrs_dict.values()[0]
self.assertTrue(IBlob.providedBy(blob))
file2 = createContentInContainer(self.portal, 'BlobFile')
file2.file = NamedBlobFile('dummy test data', filename=u'test.txt')
modifier.reattachReferencedAttributes(file2, attrs_dict)
self.assertTrue(file2.file._blob is blob)
def __call__(self):
"""
Return the view template; handle form posts
"""
add_another_question = False
if self.request.method == 'POST':
questions = []
items = self.request.form.items() # XXX Why not use .get()?
for item, text in items: # Add another question?
if item != 'new-question': # No
questions.append((item, text))
else: # Yes
add_another_question = True
security_manager = getSecurityManager()
userid = security_manager.getUser().getId()
annotation = createContentInContainer(
self.context, 'annotation', title='%s-annotation' % userid)
for uid, text in questions: # Process questions
if text is not '':
question = uuidToObject(uid)
question = question.Title()
title = "Response to %s"
response = createContentInContainer(
annotation, 'response', title=title % question)
storage = IStorage(response)
storage[uid] = question
response.description = text
if add_another_question:
portal = self.context.portal_url()
self.request.response.redirect("%s/++add++question" % portal)
return self.artifact_view()
def test_modify_translations_delete(self):
createContentInContainer(
self.portal['ca'], 'Folder', title=u"Test folder")
a_ca = createContentInContainer(
self.portal['ca']['test-folder'],
'Document', title=u"Test document")
a_en = api.translate(a_ca, 'en')
view = a_en.restrictedTraverse('modify_translations')()
self.assertIn(
'href="http://nohost/plone/ca/test-folder/test-document/delete_confirmation" ' # noqa§
'title="Delete translated item"',
view,
'modify_translations was missing delete link for translation'
)
# Test https://github.com/plone/plone.app.multilingual/pull/283
self.assertNotIn(
'href="http://nohost/plone/en/test-document/delete_confirmation" ' # noqa§
'title="Delete translated item"',
view,
'modify_translations contained delete link for the context'
)
def test_create_richtextval(self):
imail = createContentInContainer(self.portal['incoming-mail'], 'dmsincomingmail',
task_description=create_richtextval('Text content'))
self.assertEqual(imail.task_description.output, 'Text content')
imail = createContentInContainer(self.portal['incoming-mail'], 'dmsincomingmail',
task_description=create_richtextval(u'Text content'))
self.assertEqual(imail.task_description.output, 'Text content')
def test_AssignedGroupColumn(self):
registry = getUtility(IRegistry)
group0 = registry[ORGANIZATIONS_REGISTRY][0]
imail = createContentInContainer(self.portal['incoming-mail'], 'dmsincomingmail')
task = createContentInContainer(imail, 'task', id='testid1', assigned_group=group0)
col = AssignedGroupColumn(self.portal, self.portal.REQUEST, None)
self.assertEqual(col.renderCell(task).encode('utf8'), "Direction générale")
def test_integration_task_events(self):
""" Trigger every event of a task at least one times
and check the journalentries.
"""
portal = self.layer['portal']
dossier = createContentInContainer(
portal, 'opengever.dossier.businesscasedossier', 'd1')
# Add-Event
task = createContentInContainer(
dossier, 'opengever.task.task', 'd1')
self.check_annotation(
dossier,
action_type='Task added',
action_title='Task added: %s' % task.title_or_id(),
check_entry=-2, )
# Modified-Event
notify(ObjectModifiedEvent(task))
self.check_annotation(
dossier,
action_type='Task modified',
action_title='Task modified: %s' % task.title_or_id(), )
def test_relations_with_RelationValue_objects(self):
foo = createContentInContainer(self.portal, 'ExampleDxType', title=u'Foo')
source = createContentInContainer(self.portal, 'ExampleDxType', title=u'Item')
IRelatedItems(source).relatedItems = [utils.create_relation_for(foo)]
data = self._get_field_data(source, json=True)
target = createContentInContainer(self.portal, 'ExampleDxType')
self._set_field_data(target, data, json=True)
self.assertEquals(1, len(target.relatedItems),
'Relation missing')
self._set_field_data(target, data, json=True)
self.assertEquals(1, len(target.relatedItems),
'Publishing twice should not add more relations.')
relation, = target.relatedItems
self.assertEquals(foo, relation.to_object)
# Test that the relation is in the catalog.
catalog = getUtility(ICatalog)
intids = getUtility(IIntIds)
target_id = intids.getId(aq_inner(target))
foo_id = intids.getId(aq_inner(foo))
relations = tuple(catalog.findRelations({'from_id': target_id, 'to_id': foo_id}))
self.assertEqual(1, len(relations))
self.assertEqual(
target,
intids.queryObject(relations[0].from_id)
)
self.assertEqual(
foo,
intids.queryObject(relations[0].to_id)
)
def setUp(self):
self.portal = self.layer['portal']
self.folder = createContentInContainer(
self.portal['ca'], 'Folder', title=u"Folder")
self.document = createContentInContainer(
self.portal['ca'], 'Document', title=u"Document")
self.request = self.layer['request']
def handleOk(self, action):
data, errors = self.extractData()
if errors:
self.status = self.formErrorsMessage
return
data['title'] = '%s %s - One-time Offline Donation' % (
data['first_name'],
data['last_name'])
data['secret_key'] = build_secret_key()
data['stage'] = 'Pledged'
data['products'] = []
data['campaign_sf_id'] = self.context.sf_object_id
data['payment_date'] = datetime.date.today()
data['transaction_id'] = 'offline:' + data['secret_key']
data['offline'] = True
# Add a donation in the current context,
# using the data from the form
parent_campaign = self.context
createContentInContainer(
parent_campaign,
'collective.salesforce.fundraising.donation',
checkConstraints=False, **data)
# Add the donation to the campaign totals
# self.context.add_donation(data['amount'])
IStatusMessage(self.request).add(u'Your offline gift was entered and '
'will be counted in your total '
'raised. The gift and donor contact '
'information will appear in '
'"My Donors" shortly.')
self.request.response.redirect(parent_campaign.absolute_url())
def __call__(self):
#from Products.ATContentTypes.content.base import ATCTFolder
#self.stub("sbo.inkstain.content.guestbook.Guestbook", "Guestbook", ATCTFolder)
old_path = self.request.form.get('old', "")
portal_url = getToolByName(self.context, "portal_url")
portal = portal_url.getPortalObject()
old_guestbook = portal.restrictedTraverse(old_path)
entries = old_guestbook.objectValues()
entries.sort(key=lambda entry: entry.date)
for entry in entries:
date = entry.date.asdatetime()
date = date.replace(tzinfo=None)
createContentInContainer(self.context, 'sbo.inkstain.guestbookentry',
entry_date=date,
author=entry.name,
email_address=entry.email_address,
homepage_address=entry.homepage_address,
message=entry.message,
moderation_state='published',
ip='unknown'
)
self.request.response.redirect(self.context.absolute_url())
return ''
def setUp(self):
self.portal = self.layer["portal"]
self.portal_url = self.portal.absolute_url()
self.request = self.layer["request"]
alsoProvides(self.layer["request"], IPloneAppMultilingualInstalled)
login(self.portal, SITE_OWNER_NAME)
self.es_content = createContentInContainer(self.portal["es"],
"Document",
title=u"Test document")
transaction.commit()
def __call__(self):
req_file = self.request.get("file")
c_type = req_file.headers.get("content-type", "")
file_data = req_file.read()
file_name = safe_unicode(req_file.filename)
media_container = get_media_root(self.context)
behavior = self.behavior
if not behavior:
return json.dumps(
dict(
status=u"error",
message=u"IRelatedMedia behavior not activated for this context",
)
)
intids = getUtility(IIntIds)
if c_type.startswith("image/"):
blob = NamedBlobImage(data=file_data, filename=file_name)
img = createContentInContainer(media_container, "Image", image=blob)
to_id = intids.getId(img)
imgs = behavior.related_images and list(behavior.related_images) or []
imgs.append(RelationValue(to_id))
behavior.related_images = imgs
update_leadimage(self.context, None)
else:
blob = NamedBlobFile(data=file_data, filename=file_name)
att = createContentInContainer(media_container, "File", file=blob)
to_id = intids.getId(att)
atts = (
behavior.related_attachments
and list(behavior.related_attachments)
or []
)
atts.append(RelationValue(to_id))
behavior.related_attachments = atts
return json.dumps(
dict(
status=u"done",
)
)
def _upload_file(self, document, obj_file):
extra_data = self._upload_file_extra_data()
new_file = createContentInContainer(
document,
self.creation_file_portal_type,
title=self.metadata.get('file_title'),
file=obj_file,
**extra_data
)
return new_file
def setUp(self):
from plone.dexterity.utils import createContentInContainer
portal = self.layer['portal']
data = {
'id':
'example-roster',
'groups': [
u'Title only',
u'Alfa|Alfa coders',
u'Beta|Beta testers',
u'gamma-tester|Gamma Tester',
u'delta tester|Delta Tester',
]
}
createContentInContainer(portal,
'collective.roster.roster',
checkConstraints=False,
**data)
self.roster = portal['example-roster']
def test_accessors(self):
"""Test title and descprition accessors."""
self.grant('Contributor')
portal = self.layer['portal']
d1 = createContentInContainer(
portal, 'opengever.dossier.businesscasedossier',
title=u'Test title', description=u'Lorem ipsum')
self.assertEquals(d1.Title(), 'Test title')
self.assertEquals(d1.Description(), 'Lorem ipsum')
def setUp(self):
self.portal = self.layer['portal']
self.request = self.layer['request']
self.catalog = getToolByName(self.portal, 'portal_catalog')
self.doc1 = createContentInContainer(self.portal,
u'DXTestDocument',
id=u'doc1',
title=u'Lorem Ipsum',
description=u'Description')
def test_indexer_picks_correct_doc_indexer_adapter_by_default(self):
sample_file = NamedBlobFile('foo', filename=u'test.txt')
doc1 = createContentInContainer(self.portal,
'opengever.document.document',
title=u"Doc One",
document_author=u'Hugo Boss',
file=sample_file)
fulltext_indexer = getAdapter(doc1, IDocumentIndexer)
self.assertEquals(fulltext_indexer.__class__, DefaultDocumentIndexer)
def test_move_children(self):
from plone.dexterity.utils import createContentInContainer
self.loginAsPortalOwner()
survey = self.create_survey()
question = createContentInContainer(survey, 'euphorie.profilequestion')
question.invokeFactory('euphorie.risk', '3')
question.invokeFactory('euphorie.risk', '2')
question.invokeFactory('euphorie.risk', '4')
module = self._convert_to_module(question)
self.assertEqual(module.keys(), ['3', '2', '4'])
def setUp(self):
super(TestBatchingCollections, self).setUp()
folder = createContentInContainer(self.portal, u'Folder', id=u'folder')
for i in range(5):
self._create_doc(folder, i)
collection = createContentInContainer(self.portal,
u'Collection',
id='collection')
collection.query = [
{
"i": "path",
"o": "plone.app.querystring.operation.string.path",
"v": "/plone/folder/"
},
]
transaction.commit()
def setUp(self):
super(TestBatchingSearch, self).setUp()
folder = createContentInContainer(
self.portal, u'Folder',
id=u'folder')
for i in range(5):
self._create_doc(folder, i)
transaction.commit()
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.folder = createContentInContainer(self.portal,
u'Folder',
id=u'folder',
title=u'Some Folder')
createContentInContainer(self.folder,
u'Document',
id=u'doc1',
title=u'A document')
transaction.commit()
def test_copied_to_assets_folder(self):
"""When an object is copied from within one Language Root Folder into
the Language Independent Folder (named 'Assets') it becomes language
independent, and it should be visible from the assets folder accessed
from within other Language Root Folders
"""
a_ca = createContentInContainer(self.portal['ca'],
'Document',
title=u"Test document")
# Test a paste into a subfolder to be ultra cautious
ca_assets_subfolder = createContentInContainer(
self.portal['ca']['assets'], 'Folder', title=u"A Folder")
subfolder_name = ca_assets_subfolder.id
id_ = self.portal['ca'].manage_copyObjects(a_ca.id)
ca_assets_subfolder.manage_pasteObjects(id_)
# Get both assets folders afresh
ca_assets_subfolder = self.portal['ca']['assets'][subfolder_name]
en_assets_subfolder = self.portal['en']['assets'][subfolder_name]
# Check it is in both folder listings
self.assertTrue(a_ca.id in ca_assets_subfolder)
self.assertTrue(a_ca.id in en_assets_subfolder)
# Check it is language independent
copy_in_en = en_assets_subfolder[a_ca.id]
self.assertEqual(ILanguage(copy_in_en).get_language(), '')
copy_in_ca = ca_assets_subfolder[a_ca.id]
self.assertEqual(ILanguage(copy_in_ca).get_language(), '')
# Check it is returned in catalog search
catalog = getToolByName(self.portal, 'portal_catalog')
ca_subfolder_path = '/'.join(ca_assets_subfolder.getPhysicalPath())
ca_folder_contents = [r.id for r in catalog(path=ca_subfolder_path)]
self.assertTrue(a_ca.id in ca_folder_contents)
en_subfolder_path = '/'.join(en_assets_subfolder.getPhysicalPath())
en_folder_contents = [r.id for r in catalog(path=en_subfolder_path)]
self.assertTrue(a_ca.id in en_folder_contents)
def test_navigation_expanded_with_depth(self):
createContentInContainer(
self.portal, u"Folder", id=u"folder2", title=u"Some Folder 2"
)
subfolder1 = createContentInContainer(
self.folder, u"Folder", id=u"subfolder1", title=u"SubFolder 1"
)
createContentInContainer(
self.folder, u"Folder", id=u"subfolder2", title=u"SubFolder 2"
)
thirdlevelfolder = createContentInContainer(
subfolder1, u"Folder", id=u"thirdlevelfolder", title=u"Third Level Folder"
)
createContentInContainer(
thirdlevelfolder,
u"Folder",
id=u"fourthlevelfolder",
title=u"Fourth Level Folder",
)
createContentInContainer(
self.folder, u"Document", id=u"doc1", title=u"A document"
)
transaction.commit()
response = self.api_session.get(
"/folder", params={"expand": "navigation", "expand.navigation.depth": 3}
)
self.assertEqual(response.status_code, 200)
self.assertEqual(len(response.json()["@components"]["navigation"]["items"]), 3)
self.assertEqual(
len(response.json()["@components"]["navigation"]["items"][1]["items"]),
3, # noqa
)
self.assertEqual(
len(
response.json()["@components"]["navigation"]["items"][1]["items"][0][
"items"
]
),
1, # noqa
)
def test_move_content_existing_translation_inside(self):
f_ca = createContentInContainer(self.portal['ca'],
'Folder',
title=u"Test folder")
a_ca = createContentInContainer(self.portal['ca']['test-folder'],
'Document',
title=u"Test document")
a_en = api.translate(a_ca, 'en')
translations = ITranslationManager(self.portal['en'][a_en.id])
self.assertEqual(
translations.get_translations(), {
'ca': self.portal['ca'][f_ca.id][a_ca.id],
'en': self.portal['en'][a_ca.id]
})
self.assertIn(a_en.id, self.portal['en'].objectIds())
self.assertEqual(a_en, self.portal['en'][a_en.id])
# Change the content language of the created folder to 'en'
multilingualMoveObject(f_ca, 'en')
self.assertIn(f_ca.id, self.portal['en'].objectIds())
self.assertEqual(f_ca, self.portal['en'][f_ca.id])
self.assertIn(a_ca.id, self.portal['en'][f_ca.id].objectIds())
self.assertEqual(a_ca, self.portal['en'][f_ca.id][a_ca.id])
adapter = ILanguage(self.portal['en'][f_ca.id])
self.assertEqual(adapter.get_language(), 'en')
adapter = ILanguage(self.portal['en'][f_ca.id][a_ca.id])
self.assertEqual(adapter.get_language(), 'en')
translations = ITranslationManager(self.portal['en'][f_ca.id][a_ca.id])
self.assertEqual(translations.get_translations(),
{'en': self.portal['en'][f_ca.id][a_ca.id]})
translations = ITranslationManager(self.portal['en'][a_en.id])
self.assertEqual(translations.get_translations(),
{'en': self.portal['en'][a_en.id]})
def populate_multimeasure_chart(self, measures, datasets):
"""
Given UID lists of measures, datasets, create one multi-measure
chart.
"""
_value = lambda key: self.request.get(key)
title = _value('onechart-title')
if title is None:
msg = u'You must provide a title for a multi-measure chart.'
self.status.addStatusMessage(msg, type='error')
return
if not measures:
msg = u'You must select at least one measure'
self.status.addStatusMessage(msg, type='error')
return
kw = self._multi_measure_chart_info()
chart = createContentInContainer(self.context, **kw)
self._set_date_settings(chart)
for measure_uid, ds_uid in itertools.product(measures, datasets):
m_title = _value('title-%s' % measure_uid)
ds_title = _value('title-%s' % ds_uid)
if not m_title and ds_title:
msg = u'You must provide legend label information for measure'\
u'and dataset.'
self.status.addStatusMessage(msg, type='error')
return
legend_label = '%s -- %s' % (ds_title, m_title)
series_info = {
'title': legend_label,
'portal_type': MEASURESERIES_DATA,
}
mseries = createContentInContainer(chart, **series_info)
mseries.measure = measure_uid
mseries.dataset = ds_uid
mseries.display_precision = kw.get('display_precision', 1)
mseries.reindexObject()
self.status.addStatusMessage(
'Created a multi-measure chart with %s series and %s '
'data-sets' % (len(measures), len(datasets)),
type='info',
)
return chart
def setUp(self):
super(TestAttachmentExtraction, self).setUp()
self.grant('Owner', 'Editor', 'Contributor', 'Manager')
self.dossier = createContentInContainer(
self.portal,
'opengever.dossier.businesscasedossier',
title=u'Dossier 1')
transaction.commit()
def test_full_text_indexing_with_plain_text(self):
sample_file = NamedBlobFile('foobar barfoo', filename=u'test.txt')
doc1 = createContentInContainer(self.portal,
'opengever.document.document',
title=u"Doc One",
document_author=u'Hugo Boss',
file=sample_file)
searchable_text = index_data_for(doc1).get('SearchableText')
self.assertIn('foobar', searchable_text)
self.assertIn('barfoo', searchable_text)
def setUpPartiallyTranslatedContent(self):
wftool = getToolByName(self.portal, 'portal_workflow')
f_en = createContentInContainer(
self.portal['en'], 'Folder', title=u"Test folder"
)
wftool.doActionFor(f_en, 'publish')
a_en = createContentInContainer(
self.portal['en']['test-folder'],
'Document',
title=u"Test document",
)
wftool.doActionFor(a_en, 'publish')
f_ca = api.translate(f_en, 'ca')
f_ca.setTitle(u"Test folder CA")
wftool.doActionFor(f_ca, 'publish')
transaction.commit()
def test_all_translation_links_are_shown(self):
a_ca = createContentInContainer(self.portal['ca'],
'Document',
title=u"Test document")
transaction.commit()
self.browser.open(a_ca.absolute_url())
self.assertIn('plone-contentmenu-multilingual', self.browser.contents)
self.assertIn('translate_into_es', self.browser.contents)
self.assertIn('translate_into_en', self.browser.contents)
def test_shared_content(self):
# Create shared document
createContentInContainer(self.portal.en.assets,
'Document',
title=u"Test document")
# Check shared document is there
self.assertEqual(self.portal.en.assets['test-document'],
self.portal.ca.recursos['test-document'])
self.assertEqual(self.portal.en.assets['test-document'],
self.portal.es.recursos['test-document'])
# Delete shared document
notify(ObjectWillBeRemovedEvent(
self.portal.en.assets['test-document']))
self.portal.en.assets.manage_delObjects('test-document')
# Check that it is not available in LRFs
self.assertNotIn('test-document', self.portal.ca.recursos.objectIds())
self.assertNotIn('test-document', self.portal.es.recursos.objectIds())
def test_content_in_folders_can_be_translated(self):
af_ca = createContentInContainer(
self.portal['ca'], 'Folder', title=u"Test folder")
b_ca = createContentInContainer(
self.portal['ca']['test-folder'],
'Document', title=u"Test document")
transaction.commit()
self.browser.open(af_ca.absolute_url() + '/' + b_ca.id +
'/@@create_translation?language=en')
self.browser.getControl(
name="form.widgets.IDublinCore.title").value = u"Test folder"
self.browser.getControl(name="form.buttons.save").click()
self.portal._p_jar.sync()
self.assertIn('test-folder', self.portal['en'].objectIds())
def test_full_objects_retrieval_collections(self):
self.collection = createContentInContainer(self.folder,
u"Collection",
id="collection")
transaction.commit()
query = {"portal_type": "Collection", "fullobjects": True}
response = self.api_session.get("/@search", params=query)
self.assertEqual(response.status_code, 200)
self.assertEqual(len(response.json()["items"]), 1)
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)
alsoProvides(self.layer['request'], IPloneAppMultilingualInstalled)
login(self.portal, SITE_OWNER_NAME)
self.en_content = createContentInContainer(
self.portal['en'], 'Document', title=u'Test document')
self.es_content = createContentInContainer(
self.portal['es'], 'Document', title=u'Test document')
ITranslationManager(self.en_content).register_translation(
'es', self.es_content)
transaction.commit()
def save_indicator(indicator, site, data):
print("=============================================")
print(indicator["theme"])
portal_catalog = site.portal_catalog
brains = portal_catalog.unrestrictedSearchResults(
**{
"portal_type": "eea.climateadapt.c3sindicator",
"c3s_identifier": indicator["identifier"],
})
indicatorFound = False
for brain in brains:
obj = brain.getObject()
try:
if indicator["identifier"] == obj.c3s_identifier:
indicatorFound = True
update_object(obj, indicator)
print(" UPDATE OBJECT")
except Exception:
pass
# print("C3S Identifier NOT SET")
folder_path = "knowledge/european-climate-data-explorer/"
folder = site.restrictedTraverse(folder_path)
#for theme_name in indicator["theme"]:
# folder_indicator_id = theme_name.lower().replace(" ", "-")
# if folder_indicator_id not in folder.contentIds():
# print("Create indicator folder", theme_name)
# folder_indicator = createContentInContainer(
# folder, "Folder", title=theme_name
# )
# folder_indicator.manage_addProperty(
# id="layout", value="c3s_indicators_listing", type="string"
# )
# api.content.transition(folder_indicator, "publish")
# folder_indicator._p_changed
if not indicatorFound:
folder_path = "metadata/indicators/"
folder = site.restrictedTraverse(folder_path)
obj = createContentInContainer(
#folder_indicator,
folder,
"eea.climateadapt.c3sindicator",
title=indicator["page_title"],
)
obj.c3s_identifier = indicator["identifier"]
update_object(obj, indicator)
def test_AdviceCategoryCorrectlyIndexed(self):
"""When an advice_category is defined, it is correctly indexed
it's parent after add/modify/delete."""
catalog = self.portal.portal_catalog
cfg = self.meetingConfig
self.changeUser('siteadmin')
self._configureFinancesAdvice(cfg)
# put users in finances group
self._setupFinancesGroup()
self.changeUser('pmCreator1')
item = self.create('MeetingItem', title='The first item')
# ask finances advice
item.setOptionalAdvisers(
('{0}__rowid__unique_id_002'.format(finance_group_uid()), ))
self.proposeItem(item)
self.changeUser('pmReviewer1')
self.do(item, 'wait_advices_from_prevalidated')
# now act as the finances users
# advice may be added/edit when item is considered 'complete'
self.changeUser('pmFinController')
changeCompleteness = item.restrictedTraverse(
'@@change-item-completeness')
self.request.set('new_completeness_value', 'completeness_complete')
self.request.form['form.submitted'] = True
changeCompleteness()
# add advice
advice = createContentInContainer(
item, 'meetingadvicefinances', **{
'advice_group': finance_group_uid(),
'advice_type': u'positive_finance',
'advice_comment': RichTextValue(u'My comment finances'),
'advice_category': u'acquisitions'
})
# reindexed when advice added
itemUID = item.UID()
self.assertEqual(
catalog(meta_type='MeetingItem',
financesAdviceCategory=advice.advice_category)[0].UID,
itemUID)
# reindexed when advice edited
advice.advice_category = u'attributions'
# notify modified
notify(ObjectModifiedEvent(advice))
self.assertEqual(
catalog(meta_type='MeetingItem',
financesAdviceCategory=advice.advice_category)[0].UID,
itemUID)
# reindexed when advice deleted
self.portal.restrictedTraverse('@@delete_givenuid')(advice.UID())
self.assertEqual(
len(
catalog(meta_type='MeetingItem',
financesAdviceCategory=advice.advice_category)), 0)
def test_content_is_not_translated_to_any_language(self):
a_ac = createContentInContainer(self.portal,
'Document',
title=u"Test document")
languages = untranslated_languages(a_ac).by_token.keys()
self.assertEqual(len(languages), 3)
self.assertIn('ca', languages)
self.assertIn('es', languages)
self.assertIn('en', languages)
def test_convert_optional_question(self):
import mock
from plone.dexterity.utils import createContentInContainer
self.loginAsPortalOwner()
survey = self.create_survey()
question = createContentInContainer(survey, 'euphorie.profilequestion')
question.type = 'optional'
with mock.patch('euphorie.deployment.upgrade.v6._convert_to_module') \
as mock_convert:
self._convert_optional_profiles(survey, False)
mock_convert.assert_called_once_with(question)
def test_create_content_in_container(self):
with freeze(FROZEN_NOW):
mail = createContentInContainer(
self.portal,
'ftw.mail.mail',
message=self.sample_msg)
persisted_values = get_persisted_values_for_obj(mail)
expected = self.get_type_defaults()
self.assertDictEqual(expected, persisted_values)
def test_AssignedGroupColumn(self):
group0 = get_registry_organizations()[0]
imail = sub_create(self.portal['incoming-mail'], 'dmsincomingmail',
datetime.now(), 'my-id')
task = createContentInContainer(imail,
'task',
id='testid1',
assigned_group=group0)
col = AssignedGroupColumn(self.portal, self.portal.REQUEST, None)
self.assertEqual(
col.renderCell(task).encode('utf8'), "Direction générale")
def setUp(self):
self.app = self.layer['app']
self.portal = self.layer['portal']
self.request = self.portal.REQUEST
self.catalog = getToolByName(self.portal, 'portal_catalog')
# /plone/my-folder
self.folder = createContentInContainer(self.portal,
u'Folder',
title=u'My Folder')
# /plone/my-folder/my-document
self.doc = createContentInContainer(self.folder,
u'Document',
creation_date=DateTime(
2015, 12, 31, 23, 45),
title=u'My Document')
IMutableUUID(self.doc).set('77779ffa110e45afb1ba502f75f77777')
self.doc.reindexObject()
