def setUp(self):
"""Custom shared utility setup for following tests."""
self.catalog = self.layer['portal']['portal_catalog']
# install index
from collective.es.index.esproxyindex import ElasticSearchProxyIndex
from plone.app.textfield.value import RichTextValue
from collective.es.index.utils import get_query_client
client = get_query_client()
client.indices.create('testing_plone')
espi = ElasticSearchProxyIndex(
'espi',
caller=self.catalog,
)
self.catalog.addIndex('espi', espi)
portal = self.layer['portal']
setRoles(portal, TEST_USER_ID, ['Manager'])
login(portal, TEST_USER_NAME)
portal.invokeFactory('Document', 'd1', title='Test one')
portal.d1.text = RichTextValue('Blah Blah Blah', 'text/plain',
'text/html')
portal.invokeFactory('Document', 'd2', title='Test two')
portal.d2.text = RichTextValue('Yada Yada Yada', 'text/plain',
'text/html')
portal.invokeFactory('Document', 'd3', title='Test three')
portal.d3.text = RichTextValue('Something completely different',
'text/plain', 'text/html')
# give es time to index documents
time.sleep(2)
def _create_content(self):
user = create(Builder('user'))
noticeboard = create(Builder('noticeboard').titled(u'Noticeboard'))
category1 = create(
Builder('noticecategory').having(conditions=RichTextValue(
'Something')).titled(u'Category 1').within(noticeboard))
category2 = create(
Builder('noticecategory').having(conditions=RichTextValue(
'Something')).titled(u'Category 2').within(noticeboard))
for number in range(1, 4):
create(
Builder('notice').titled(u'Notice {0}'.format(
str(number))).having(accept_conditions=True,
text=RichTextValue('Something'),
price='100',
expires=datetime.now() -
timedelta(days=10)).within(category1))
login(self.portal, user.getId())
for number in range(1, 2):
create(
Builder('notice').titled(u'Notice {0}'.format(
str(number))).having(accept_conditions=True,
text=RichTextValue('Something'),
price='100',
expires=datetime.now() -
timedelta(days=10)).within(category2))
logout()
return noticeboard, user
def test_text_in_searchable_text_index(self):
self.document.text = RichTextValue(
u'Lorem ipsum',
'text/plain',
'text/html'
)
self.news_item.text = RichTextValue(
u'Lorem ipsum',
'text/plain',
'text/html'
)
self.document.reindexObject()
self.news_item.reindexObject()
brains = self.catalog.searchResults(dict(
SearchableText=u'Lorem ipsum',
))
self.assertEqual(len(brains), 2)
self.assertEqual(
brains[0].getPath(),
'/plone/folder/news_item'
)
self.assertEqual(
brains[1].getPath(),
'/plone/folder/document'
)
def setUp(self):
portal = self.layer['portal']
setRoles(portal, TEST_USER_ID, ('Manager', ))
portal.invokeFactory('emc.memberArea.workspace', 'work1')
portal['work1'].invokeFactory('emc.memberArea.messagebox', 'folder1')
portal['work1'].invokeFactory('emc.memberArea.myfolder', 'my1')
portal['work1'].invokeFactory('emc.memberArea.todo',
'to1',
title="todo container")
portal['work1']['to1'].invokeFactory('emc.memberArea.todoitem',
'item1',
title="item1",
text=RichTextValue(
u"todoitem one", 'text/plain',
'text/html'))
portal['work1']['to1'].invokeFactory('emc.memberArea.todoitem',
'item2',
title="item2",
text=RichTextValue(
u"todoitem two", 'text/plain',
'text/html'))
portal['work1'].invokeFactory('emc.memberArea.favorite',
'fa1',
title="favorite items")
portal['work1']['folder1'].invokeFactory('emc.memberArea.inputbox',
'input1')
portal['work1']['folder1'].invokeFactory('emc.memberArea.outputbox',
'output1')
portal['work1']['folder1']['input1'].invokeFactory(
'emc.memberArea.message', 'message1')
portal['work1']['folder1']['output1'].invokeFactory(
'emc.memberArea.message', 'message1')
self.portal = portal
def testNewsItem(self):
self.folder.invokeFactory('News Item', id='news_one')
portal_repository = self.portal_repository
content = self.folder.news_one
content.text = RichTextValue(u'text v1', 'text/plain', 'text/plain')
content.title = u'content'
content.subject = [u'content']
content.description = u'content'
content.contributors = [u'content']
content.language = 'content'
content.rights = u'content'
portal_repository.applyVersionControl(content, comment='save no 1')
content.text = RichTextValue(u'text v2', 'text/plain', 'text/plain')
content.title = u'contentOK'
content.subject = [u'contentOK']
content.description = u'contentOK'
content.contributors = [u'contentOK']
content.language = 'contentOK'
content.rights = u'contentOK'
portal_repository.save(content, comment='save no 2')
obj = portal_repository.retrieve(content, 0).object
self.assertEqual(obj.text.raw, 'text v1')
self.metadata_test_one(obj)
obj = portal_repository.retrieve(content, 1).object
self.assertEqual(obj.text.raw, 'text v2')
self.metadata_test_two(obj)
portal_repository.revert(content, 0)
self.assertEqual(content.text.raw, 'text v1')
self.metadata_test_one(content)
def test_text_in_searchable_text_index(self):
self.document.text = RichTextValue(
u'Lorem ipsum',
'text/plain',
'text/html'
)
self.news_item.text = RichTextValue(
u'Lorem ipsum',
'text/plain',
'text/html'
)
self.collection.text = RichTextValue(
u'Lorem ipsum',
'text/plain',
'text/html'
)
self.document.reindexObject()
self.news_item.reindexObject()
self.collection.reindexObject()
brains = self.catalog.searchResults(dict(
SearchableText=u'Lorem ipsum',
))
self.assertEqual(len(brains), 3)
paths = [it.getPath() for it in brains]
self.assertTrue(
'/plone/folder/news_item' in paths
)
self.assertTrue(
'/plone/folder/document' in paths
)
self.assertTrue(
'/plone/folder/collection' in paths
)
def test13_revertUpdatesCatalog(self):
portal_repo = self.portal.portal_repository
cat = self.portal.portal_catalog
doc = self.portal.doc
doc.text = RichTextValue(u'Plain text', 'text/plain', 'text/plain')
portal_repo.applyVersionControl(doc)
doc.text = RichTextValue(u'blahblah', 'text/plain', 'text/plain')
portal_repo.save(doc)
# Test that catalog has current value
results = cat(SearchableText='Plain Text')
self.assertEqual(len(results), 0)
results = cat(SearchableText='blahblah')
self.assertEqual(len(results), 1)
self.assertEqual(results[0].getObject(), doc)
retrieved_data = portal_repo.retrieve(
doc, 0, preserve=['_Access_contents_information_Permission'])
retrieved_doc = retrieved_data.object
self.assertTrue('Plain text' in retrieved_doc.text.raw)
# Test that basic retrieval did not alter the catalog
results = cat(SearchableText='Plain Text')
self.assertEqual(len(results), 0)
results = cat(SearchableText='blahblah')
self.assertEqual(len(results), 1)
self.assertEqual(results[0].getObject(), doc)
portal_repo.revert(doc, 0)
# Test that the catalog is updated on revert
results = cat(SearchableText='blahblah')
self.assertEqual(len(results), 0)
results = cat(SearchableText='Plain Text')
self.assertEqual(len(results), 1)
self.assertEqual(results[0].getObject().text.raw, 'Plain text')
def _transform_ranks(self, performance, fieldname, fieldvalue):
html_value = ""
if len(fieldvalue) > 1:
html_value = "<strong>Prijzen</strong>"
for rank in fieldvalue:
rankDescription = rank.get('rankDescription')
prices = self._transform_ranks_generate_prices(rank, True)
html_value += "<h6>%s</h6><div>%s</div>" % (rankDescription,
prices)
final_value = RichTextValue(html_value, 'text/html', 'text/html')
setattr(performance, 'price', final_value)
elif len(fieldvalue) == 1:
rank = fieldvalue[0]
prices = self._transform_ranks_generate_prices(rank)
html_value += "<div>%s</div>" % (prices)
final_value = RichTextValue(html_value, 'text/html', 'text/html')
setattr(performance, 'price', final_value)
else:
html_value = ""
final_value = RichTextValue(html_value, 'text/html', 'text/html')
return final_value
final_value = RichTextValue(html_value, 'text/html', 'text/html')
return final_value
def test_inline_diff_different(self):
old_value = RichTextValue(u'foo')
new_value = RichTextValue(u'foo bar')
diff = CMFDTHtmlDiff(DummyType(old_value), DummyType(new_value),
'body')
inline_diff = diff.inline_diff()
self.assertTrue(IDifference.providedBy(diff))
self.assertEqual(diff.same, False)
self.assertEqual(inline_diff, u'foo <span class="insert">bar </span> ')
def testSearchableText(self):
self.item.formatted_title = RichTextValue("<p>test_title</p>",
"text/html", "text/html")
self.item.decision = RichTextValue("test_decision", "text/html",
"text/html")
self.item.reindexObject()
brain = api.content.find(context=self.meeting, portal_type="Item")[0]
indexes = self.catalog.getIndexDataForRID(brain.getRID())
searchable_text = indexes.get("SearchableText")
self.assertTrue("test_title" in searchable_text)
self.assertTrue("test_decision" in searchable_text)
def setUpPloneSite(self, portal):
applyProfile(portal, 'plone.app.mosaic:default')
applyProfile(portal, 'collective.geolocationbehavior:default')
applyProfile(portal, 'collective.collectionfilter:default')
applyProfile(portal, 'collective.collectionfilter.tests:testing')
catalog = api.portal.get_tool(name='portal_catalog')
if 'exclude_from_nav' not in catalog.indexes():
catalog.addIndex(
'exclude_from_nav',
BooleanIndex('exclude_from_nav'),
)
with api.env.adopt_roles(['Manager']):
portal.invokeFactory(
'Collection',
id='testcollection',
title=u'Test Collection',
query=[{
'i': 'portal_type',
'o': 'plone.app.querystring.operation.selection.any',
'v': ['Document', 'Event']
}],
)
portal.invokeFactory(
'Event',
id='testevent',
title=u'Test Event',
start=datetime.now() + timedelta(days=1),
end=datetime.now() + timedelta(days=2),
subject=[u'Süper', u'Evänt'],
exclude_from_nav=False,
)
portal.invokeFactory(
'Document',
id='testdoc',
title=u'Test Document 😉',
text=RichTextValue(u'Ein heißes Test Dokument'),
subject=[u'Süper', u'Dokumänt'],
exclude_from_nav=False,
)
portal.invokeFactory(
'Document',
id='testdoc2',
title=u'Page 😉',
text=RichTextValue(u'Ein heißes Test Dokument'),
subject=[u'Dokumänt'],
exclude_from_nav=True,
)
doc = portal['testdoc']
# doc.geolocation.latitude = 47.4048832
# doc.geolocation.longitude = 9.7587760701108
doc.reindexObject()
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)
image_file = os.path.join(os.path.dirname(__file__), u"image.png")
with open(image_file, "rb") as f:
image_data = f.read()
self.folder = api.content.create(container=self.portal,
type="Folder",
title="Normal folder")
self.subsite = api.content.create(
container=self.portal,
type="Subsite",
title="Subsite",
subsite_header=RichTextValue(
raw="<p>header</p>",
mimeType="text/html",
outputMimeType="text/html",
encoding="utf-8",
),
subsite_footer=RichTextValue(
raw="<p>footer</p>",
mimeType="text/html",
outputMimeType="text/html",
encoding="utf-8",
),
subsite_css_class="red",
image=NamedBlobImage(data=image_data,
contentType="image/png",
filename=u"image.png"),
subsite_logo=NamedBlobImage(data=image_data,
contentType="image/png",
filename=u"image.png"),
)
self.document_in_subsite = api.content.create(
container=self.subsite,
type="Document",
title="Document in subsite",
)
self.document_outside_subsite = api.content.create(
container=self.folder,
type="Document",
title="Document outside subsite",
)
commit()
def create_block(self, portlet, manager, type_):
config = IPageConfiguration(self.new)
normalizer = getUtility(IFileNameNormalizer).normalize
if type_ == 'teaser':
block = create(
Builder('sl textblock').within(self.new).titled(
portlet.teasertitle).having(
text=RichTextValue(portlet.teaserdesc),
image=NamedBlobImage(filename=normalizer(
portlet.image.filename).decode('utf-8'),
data=portlet.image.data)))
blockconfig = IBlockConfiguration(block)
blockconfigdata = blockconfig.load()
blockconfigdata['scale'] = 'large'
blockconfigdata['imagefloat'] = 'no-float'
blockconfig.store(blockconfigdata)
if portlet.internal_target:
teaser = ITeaser(block)
target = uuidToObject(portlet.internal_target)
if target:
intids = getUtility(IIntIds)
teaser.internal_link = RelationValue(intids.getId(target))
elif type_ == 'static':
block = create(
Builder('sl textblock').within(self.new).titled(
portlet.header).having(text=RichTextValue(portlet.text)))
else:
return
uid = IUUID(block)
page_state = config.load()
if manager == 'ftw.subsite.front1':
page_state['default'][0]['cols'][0]['blocks'].append({'uid': uid})
elif manager == 'ftw.subsite.front2':
page_state['default'][0]['cols'][1]['blocks'].append({'uid': uid})
elif manager == 'ftw.subsite.front3':
page_state['default'][0]['cols'][2]['blocks'].append({'uid': uid})
elif manager == 'ftw.subsite.front4':
page_state['default'][0]['cols'][3]['blocks'].append({'uid': uid})
elif manager == 'ftw.subsite.front5':
page_state['default'][1]['cols'][0]['blocks'].append({'uid': uid})
elif manager == 'ftw.subsite.front6':
page_state['default'][1]['cols'][1]['blocks'].append({'uid': uid})
# Don't know where manager 7 belongs
elif manager == 'ftw.subsite.front7':
page_state['default'][1]['cols'][0]['blocks'].append({'uid': uid})
config.store(page_state)
def setUp(self):
self.portal = self.layer['portal']
self.request = self.layer['request']
setRoles(self.portal, TEST_USER_ID, ['Manager'])
self.portal.invokeFactory(
'EmbeddedPage',
id='epage',
title='Embedded Page',
before=RichTextValue('Before', 'text/html', 'text/html'),
after=RichTextValue('After', 'text/html', 'text/html'),
)
self.portal.epage.url = 'https://plone.org'
self.epage = self.portal.epage
def _create_content(self):
noticeboard = create(Builder('noticeboard').titled(u'Noticeboard'))
category = create(Builder('noticecategory')
.having(conditions=RichTextValue('Something'))
.titled(u'Category')
.within(noticeboard))
notice = create(Builder('notice')
.titled(u'This is a N\xf6tice')
.having(accept_conditions=True,
text=RichTextValue(u'S\xf6mething'),
price='100')
.within(category))
return notice
def generate_arrangement_list_html(self, arrangement_list):
if arrangement_list:
arrangements_html = [
self.get_arrangement_html(arrangement)
for arrangement in arrangement_list
]
final_arrangements_list = "<h3>Arrangementen</h3>"
final_arrangements_list += "".join(arrangements_html)
final_value = RichTextValue(final_arrangements_list, 'text/html',
'text/html')
return final_value
else:
final_value = RichTextValue("", 'text/html', 'text/html')
return final_value
def testRichTextAreaWidgetConverter(self):
from zope.interface import Interface
from plone.app.textfield import RichText
from zope.publisher.browser import TestRequest
from plone.app.textfield.value import RichTextValue
from plone.app.textfield.widget import RichTextWidget
from plone.app.textfield.widget import RichTextAreaConverter
from z3c.form.widget import FieldWidget
_marker = object()
class IWithText(Interface):
text = RichText(title=u"Text",
default_mime_type='text/structured',
output_mime_type='text/html',
missing_value=_marker)
request = TestRequest()
widget = FieldWidget(IWithText['text'], RichTextWidget(request))
widget.update()
converter = RichTextAreaConverter(IWithText['text'], widget)
# Test with None input.
self.assertRaises(ValueError, converter.toFieldValue, None)
self.assertTrue(converter.toWidgetValue(None) is None)
# Test with string input.
self.assertTrue(converter.toFieldValue('') is _marker)
self.assertRaises(ValueError, converter.toFieldValue, b'Foo')
self.assertRaises(ValueError, converter.toWidgetValue, b'')
self.assertRaises(ValueError, converter.toWidgetValue, b'Foo')
# Test with unicode input.
self.assertTrue(converter.toFieldValue(u'') is _marker)
self.assertEqual(converter.toFieldValue(u'Foo').raw, u'Foo')
self.assertTrue(
isinstance(converter.toFieldValue(u'Foo'), RichTextValue))
self.assertEqual(converter.toWidgetValue(u''), u'')
self.assertEqual(converter.toWidgetValue(u'Foo'), u'Foo')
# Test with RichTextValue input.
self.assertTrue(converter.toFieldValue(RichTextValue(u'')) is _marker)
rich_text = RichTextValue(u'Foo')
self.assertEqual(converter.toFieldValue(rich_text), rich_text)
self.assertEqual(converter.toFieldValue(rich_text).raw, u'Foo')
self.assertEqual(converter.toWidgetValue(rich_text), u'Foo')
def writeTeX(self, lines):
def rtConvert(obj, newMimeType):
"""Create new RichTextValue with outputMimeType we want"""
for l in lines:
if hasattr(l, 'raw_encoded'):
l = RichTextValue(
raw=l.raw,
mimeType=l.mimeType,
outputMimeType='text/x-tex',
encoding=l.encoding,
).output
if isinstance(l, unicode):
l = l.encode('utf-8')
if l is not None:
self._tex += l + "\n"
def test_cookies_file_view(self):
view = api.content.get_view(
name="cookies-view",
context=self.portal,
request=self.portal.REQUEST,
)
called_view = view()
self.assertIn("<h1>Politique d'utilisation des cookies", called_view)
roles_before = api.user.get_roles(TEST_USER_ID)
setRoles(self.portal, TEST_USER_ID, ["Manager"])
gdpr_file = api.content.create(
type="Document",
title="My Content",
container=self.portal,
id="cookies-policy",
language="en",
)
rtv = RichTextValue("My New Cookies text")
gdpr_file.text = rtv
gdpr_file.reindexObject()
setRoles(self.portal, TEST_USER_ID, roles_before)
view = api.content.get_view(
name="cookies-view",
context=self.portal,
request=self.portal.REQUEST,
)
called_view = view()
self.assertEqual(called_view, "http://nohost/plone/cookies-policy")
def setUp(self):
self.app = self.layer['app']
self.portal = self.layer['portal']
setRoles(self.portal, TEST_USER_ID, ['Member'])
login(self.portal, SITE_OWNER_NAME)
self.portal.invokeFactory('Folder', id='folder1', title='My Folder')
self.portal.folder1.invokeFactory('Document',
id='doc1',
title='My Document')
self.portal.folder1.doc1.text = RichTextValue(u"Lorem ipsum.",
'text/plain',
'text/html')
self.portal.folder1.invokeFactory('Folder',
id='folder2',
title='My Folder 2')
self.portal.folder1.folder2.invokeFactory('Document',
id='doc2',
title='My Document 2')
self.portal.folder1.invokeFactory('Collection',
id='collection',
title='My collection')
wftool = getToolByName(self.portal, 'portal_workflow')
wftool.doActionFor(self.portal.folder1, 'publish')
wftool.doActionFor(self.portal.folder1.doc1, 'publish')
wftool.doActionFor(self.portal.folder1.folder2, 'publish')
wftool.doActionFor(self.portal.folder1.folder2.doc2, 'publish')
transaction.commit()
def create_entry(self, folder, dictNews):
''' Cria news item, realiza transição '''
oId = str(dictNews.get('id'))
if not oId in folder.objectIds():
api.content.create(folder,
'News Item',
oId,
title=dictNews.get('title'),
description=dictNews.get('description'))
else:
return folder[oId]
log.info(' - Cria item %s' % (oId))
o = folder[oId]
if not o:
return
for k, v in dictNews.items():
if k in ['title', 'id', 'anexos']:
continue
if k in ['text']:
v = RichTextValue(v, 'text/html', 'text/html')
o.text = v
if k in ['image']:
data = v[0]
content_type = v[1]
filename = u'image.%s' % (content_type.split('/')[1])
v = NamedBlobImage(data, content_type, filename)
o.image = v
if v and hasattr(o, k):
setattr(o, k, v)
o.exclude_from_nav = True
api.content.transition(o, 'publish')
o.reindexObject()
return o
def importElementFromJSON(self, container, id, element):
"""
"""
element_type = element['type']
if id in container.objectIds():
ob = getattr(container, id)
if wl_isLocked(ob):
ob.wl_clearLocks()
container.manage_delObjects([id])
params = element['params']
container.invokeFactory(element_type, id=id, **params)
obj = getattr(container, id)
obj.title = element['title']
if element_type == 'PlominoForm':
obj.form_layout = RichTextValue(params.get('form_layout', ''),
'text/plain', 'text/html')
obj.reindexObject()
if element_type == "PlominoField":
# some params comes from the type-specific schema
# they must be re-set
for param in params:
setattr(obj, param, params[param])
if 'elements' in element:
for (child_id, child) in element['elements'].items():
self.importElementFromJSON(obj, child_id, child)
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, ["Member"])
login(self.portal, SITE_OWNER_NAME)
self.portal.invokeFactory("Folder", id="folder1", title="My Folder")
self.portal.folder1.invokeFactory("Document",
id="doc1",
title="My Document")
self.portal.folder1.doc1.text = RichTextValue("Lorem ipsum.",
"text/plain",
"text/html")
self.portal.folder1.invokeFactory("Folder",
id="folder2",
title="My Folder 2")
self.portal.folder1.folder2.invokeFactory("Document",
id="doc2",
title="My Document 2")
self.portal.folder1.invokeFactory("Collection",
id="collection",
title="My collection")
wftool = getToolByName(self.portal, "portal_workflow")
wftool.doActionFor(self.portal.folder1, "publish")
wftool.doActionFor(self.portal.folder1.doc1, "publish")
wftool.doActionFor(self.portal.folder1.folder2, "publish")
wftool.doActionFor(self.portal.folder1.folder2.doc2, "publish")
transaction.commit()
def import_content(self):
v = BaseView(self.context, self.request)
for context in self.publication_listings:
self.log(u"Populating publications listing for %s." %
context.absolute_url())
people = []
# People Publication listing specifies people
if IPersonPublicationListing.providedBy(context):
people = context.people()
# All people
else:
people = [x.getObject() for x in self.people]
if people:
publications = self.get_publications_for_people(people)
if publications:
html = v.publications_html(publications=publications)
context.text = RichTextValue(
raw=html,
mimeType=u'text/html',
outputMimeType='text/x-html-safe')
context.reindexObject()
transaction.commit()
def testWidgetConverter(self):
from zope.interface import Interface
from plone.app.textfield import RichText
from zope.publisher.browser import TestRequest
from plone.app.textfield.value import RichTextValue
from plone.app.textfield.widget import RichTextWidget
from plone.app.textfield.widget import RichTextConverter
from z3c.form.widget import FieldWidget
_marker = object()
class IWithText(Interface):
text = RichText(title=u"Text",
default_mime_type='text/structured',
output_mime_type='text/html',
missing_value=_marker)
request = TestRequest()
widget = FieldWidget(IWithText['text'], RichTextWidget(request))
widget.update()
converter = RichTextConverter(IWithText['text'], widget)
self.assertTrue(converter.toFieldValue(u'') is _marker)
self.assertTrue(converter.toFieldValue(RichTextValue(u'')) is _marker)
def testTransformNoneView(self):
from zope.interface import Interface, implements
from plone.app.textfield import RichText
from plone.app.textfield.value import RichTextValue
from Products.CMFCore.PortalContent import PortalContent
class IWithText(Interface):
text = RichText(title=u"Text",
default_mime_type='text/structured',
output_mime_type='text/html')
class Context(PortalContent):
implements(IWithText)
id = 'context'
text = None
context = Context()
# None as value should not lead to errors.
context.text = RichTextValue()
self.portal._setObject('context', context)
context = self.portal['context']
output = context.restrictedTraverse('@@text-transform/text')()
self.assertEquals(u'', output.strip())
output = context.restrictedTraverse(
'@@text-transform/text/text/plain')()
self.assertEquals(u'', output.strip())
def test_gdpr_file_view(self):
view = api.content.get_view(
name="gdpr-view",
context=self.portal,
request=self.portal.REQUEST,
)
called_view = view()
self.assertIn("<h2>D\xe9claration relative", called_view) # noqa
roles_before = api.user.get_roles(TEST_USER_ID)
setRoles(self.portal, TEST_USER_ID, ["Manager"])
gdpr_file = api.content.create(
type="Document",
title="My Content",
container=self.portal,
id="mentions-legales",
language="en",
)
rtv = RichTextValue("My New GDPR text")
gdpr_file.text = rtv
gdpr_file.reindexObject()
setRoles(self.portal, TEST_USER_ID, roles_before)
view = api.content.get_view(
name="gdpr-view",
context=self.portal,
request=self.portal.REQUEST,
)
called_view = view()
self.assertEqual(called_view, "http://nohost/plone/mentions-legales")
class IRegistrationActions(model.Schema):
""""""
mailer = actions.Mailer(
title=_(u"Email response"),
description=_(u"Email based on form inputs"),
body_pt=DEFAULT_MAIL_BODY,
to_field=u"email",
replyto_field=None,
subject_field=None,
includeEmpties=False,
body_pre=RichTextValue(
_(u"Informations about your subscription"),
"text/plain",
"text/html",
),
)
sub_script = actions.CustomScript(
title=_(u"Subscription adding"),
ProxyRole="Manager",
ScriptBody=SUBSCRIPTION_SCRIPT,
)
save = actions.SaveData(
title=_(u"Subscription saving"),
UseColumnNames=True,
ExtraData=["dt"],
)
def __call__(self, field_name):
"""Load appy_pod.html into context's p_field_name XHTML field."""
plone_utils = api.portal.get_tool('plone_utils')
file_path = path.join(path.dirname(__file__), 'appy_pod.html')
data = open(file_path, 'r')
filled = False
if IDexterityContent.providedBy(self.context):
# dexterity
portal_types = api.portal.get_tool('portal_types')
fti = portal_types[self.context.portal_type]
schema = fti.lookupSchema()
field = schema.get(field_name)
if field and isinstance(field, RichText):
setattr(self.context, field_name, RichTextValue(data.read()))
filled = True
else:
# Archetypes
field = self.context.getField(field_name)
if field and field.widget.getName() == 'RichWidget':
field.getMutator(self.context)(data.read(),
content_type='text/html')
filled = True
data.close()
if filled:
plone_utils.addPortalMessage(
"Field '{0}' has been filled.".format(field_name))
else:
plone_utils.addPortalMessage(
"Field named '{0}' is not a field to store XHTML content!".
format(field_name),
type="error")
self.request.RESPONSE.redirect(self.context.absolute_url())
def setUpPloneSite(self, portal):
applyProfile(portal, 'Products.CMFPlomino:default')
setRoles(portal, TEST_USER_ID, ['Manager', 'Member'])
login(portal, TEST_USER_NAME)
db = api.content.create(type='PlominoDatabase',
id='mydb',
title='mydb',
container=portal)
frm_test = api.content.create(type='PlominoForm',
id='frm_test',
title='Form 1',
container=db)
frm_test.form_layout = RichTextValue(
"""<p>please enter a value for field_1: <span class="plominoFieldClass">field_1</span></p>""",
'text/plain', 'text/html')
field_1 = api.content.create(type='PlominoField',
id='field_1',
title='field_1',
container=frm_test)
field_1.field_type = "TEXT"
field_1.field_mode = "EDITABLE"
db.createDocument("doc1")
def set_text(obj):
if IDexterityContent.providedBy(obj):
obj.text = RichTextValue(
LOREMIPSUM_HTML_10_PARAGRAPHS, "text/html", "text/x-html-safe"
)
else:
obj.setText(LOREMIPSUM_HTML_10_PARAGRAPHS)
def test_getSize(self):
from plone.app.textfield.value import RichTextValue
value = RichTextValue(u'\u2603')
self.assertEqual(3, value.getSize())
