def createHostObject(self, parent, hostDict):
"""helper methode to create host instance
"""
dateNow = datetime.utcnow()
newHost = createObject(u'org.ict_ok.components.host.host.Host')
notify(ObjectCreatedEvent(newHost))
parent.__setitem__(newHost.getObjectId(), newHost)
dc = IZopeDublinCore(newHost, None)
dc.creators = [u'ikportscan']
newHost.ikComment += u"scanner: %s" % (dateNow)
if hostDict.has_key('hostname'):
newHost.__setattr__("ikName", hostDict['hostname'])
newHost.__setattr__("hostname", hostDict['hostname'])
dc.title = hostDict['hostname']
else:
newHost.__setattr__("ikName", hostDict['ipAddress'])
dc.title = hostDict['ipAddress']
for i_os in hostDict['oss']:
os_string = u"%s %s (%s) (%s)" % (i_os['osfamily'], i_os['osgen'],
i_os['type'], i_os['vendor'])
newHost.osList.append(os_string)
newHost.__setattr__("genNagios", True)
dc.created = dateNow
if hostDict.has_key("interfaces") and len(hostDict['interfaces']) > 0:
for interfaceDict in hostDict['interfaces']:
self.createInterfaceObject(newHost, interfaceDict)
notify(ObjectCreatedEvent(newHost))
def test_attribute_uuid_create_handler(self):
from zope.interface import implementer
from zope.event import notify
from zope.lifecycleevent import ObjectCreatedEvent
from zope.lifecycleevent import ObjectCopiedEvent
from plone.uuid.interfaces import IAttributeUUID
from plone.uuid.interfaces import IUUID
from plone.uuid.interfaces import ATTRIBUTE_NAME
@implementer(IAttributeUUID)
class Context(object):
pass
context = Context()
notify(ObjectCreatedEvent(context))
uuid = IUUID(context, None)
self.assertNotEqual(uuid, None)
self.assertTrue(isinstance(uuid, str))
# calling handler again won't change if UUID already present:
notify(ObjectCreatedEvent(context))
self.assertEqual(uuid, IUUID(context, None))
# ...except when the UUID attribute was the result of a copy
copied = Context()
setattr(copied, ATTRIBUTE_NAME, IUUID(context, None))
self.assertNotEqual(IUUID(copied, None), None) # mimic copied state
self.assertEqual(uuid, IUUID(copied, None)) # before handler
notify(ObjectCopiedEvent(copied, original=context))
self.assertNotEqual(uuid, None)
self.assertNotEqual(uuid, IUUID(copied, None)) # copy has new UID
def createAndAdd(self, data):
obj = self.create(data)
notify(ObjectCreatedEvent(obj))
self.add(obj)
uidutil = queryUtility(IIntIds)
oneParent = None
for (oid, oobj) in uidutil.items():
if IPatchPortFolder.providedBy(oobj.object):
oneParent = oobj.object
break
if oneParent is not None:
for i in range(1, obj.portCount+1):
dataVect = {}
dataVect['ikName'] = u'%s-%02d' % (obj.ikName, i)
dataVect['patchpanel'] = obj
if obj.room is not None:
dataVect['room'] = obj.room
newObj = PatchPort(**dataVect)
newObj.__post_init__()
IBrwsOverview(newObj).setTitle(dataVect['ikName'])
oneParent[newObj.objectID] = newObj
if hasattr(newObj, "store_refs"):
newObj.store_refs(**dataVect)
notify(ObjectCreatedEvent(newObj))
return obj
def handle_insert(self, action, data):
session = Session()
sitting = domain.GroupSitting()
trusted = removeSecurityProxy(ISchedulingContext(self.context))
group = session.query(domain.Group).get(trusted.group_id)
if ("rec_type" not in data.keys()) or (data["rec_type"] == ""):
sitting.start_date = datetime.datetime.strptime(data["start_date"], '%Y-%m-%d %H:%M')
sitting.end_date = datetime.datetime.strptime(data["end_date"], '%Y-%m-%d %H:%M')
sitting.group_id = trusted.group_id
if "language" in data.keys():
sitting.language = data["language"]
if "venue" in data.keys():
sitting.venue_id = data["venue"]
session.add(sitting)
notify(ObjectCreatedEvent(sitting))
session.commit()
self.request.response.setHeader('Content-type', 'text/xml')
return '<data><action type="inserted" sid="'+str(data["ids"])+'" tid="'+str(sitting.sitting_id)+'" /></data>'
else:
try:
recurrence_start_date = datetime.datetime.strptime(data["start_date"], '%Y-%m-%d %H:%M')
recurrence_end_date = datetime.datetime.strptime(data["end_date"], '%Y-%m-%d %H:%M')
except:
print "Date is not in the correct format"
year = timedelta(days=365)
#max end date is one year from now or end_date of the group whichever is sooner
if (group is not None) and (group.end_date is not None):
if (datetime.datetime.now() + year) < group.end_date:
end = datetime.datetime.now() + year
else:
end = group.end_date
if recurrence_end_date > end:
recurrence_end_date = end
else:
if recurrence_end_date > (datetime.datetime.now() + year):
recurrence_end_date = datetime.datetime.now() + year
recurrence_type = data["rec_type"]
length = data["event_length"]
sitting_length = timedelta(seconds=int(length))
dates = self.generate_recurrence_dates(recurrence_start_date, recurrence_end_date, recurrence_type)
output = '<data>'
for date in dates:
sitting = domain.GroupSitting()
sitting.group_id = trusted.group_id
sitting.start_date = date
sitting.end_date = date + sitting_length
sitting.status = None
if "language" in data.keys():
sitting.language = data["language"]
if "venue" in data.keys():
sitting.venue_id = data["venue"]
session.add(sitting)
notify(ObjectCreatedEvent(sitting))
output = output+'<action type="inserted" sid="'+str(data["ids"])+'" tid="'+str(sitting.sitting_id)+'" />'
session.commit()
output = output + '</data>'
self.request.response.setHeader('Content-type', 'text/xml')
return output
def setUp(test):
functional.FunctionalTestSetup().setUp()
newInteraction()
def fake_utcnow(self):
return datetime.datetime(2015, 7, 30, 8, 0, 0)
curse(datetime.datetime, 'utcnow', classmethod(fake_utcnow))
root = functional.getRootFolder()
setSite(root)
sm = root.getSiteManager()
# IIntIds
root['intids'] = IntIds()
sm.registerUtility(root['intids'], IIntIds)
root['intids'].register(root)
# catalog
root['catalog'] = Catalog()
sm.registerUtility(root['catalog'], ICatalog)
# PluggableAuthentication
pau = PluggableAuthentication(u'')
event.notify(ObjectCreatedEvent(pau))
sm[u'auth'] = pau
sm.registerUtility(pau, IAuthentication)
# Credentials Plugin
defaultCreds.install()
defaultCreds.activate()
# people
people = PersonalSpaceManager(title=u'People')
event.notify(ObjectCreatedEvent(people))
root['people'] = people
sm.registerUtility(root['people'], IPersonalSpaceManager)
user = sm.getUtility(IAuthentication).getPrincipal('zope.mgr')
people.assignPersonalSpace(user)
user = sm.getUtility(IAuthentication).getPrincipal('zope.user')
people.assignPersonalSpace(user)
# default content
content = Content(u'Content1', u'Some Content1')
event.notify(ObjectCreatedEvent(content))
IOwnership(content).ownerId = 'zope.user'
root['content1'] = content
content = Content(u'Content2', u'Some Content2')
event.notify(ObjectCreatedEvent(content))
IOwnership(content).ownerId = 'zope.user'
root['content2'] = content
endInteraction()
def test_multi_valued(self):
from zope.event import notify
from zope.interface import implements
from zope.lifecycleevent import ObjectCreatedEvent
from plone.uuid.interfaces import IUUID
from plone.uuid.interfaces import IAttributeUUID
from Products.Archetypes.Widget import RelatedItemsWidget
class ExampleContent(object):
implements(IAttributeUUID)
with mock.patch('plone.app.widgets.utils.getUtility') as mock_method:
registry = Mock()
registry.get.return_value = ['SomeType']
mock_method.return_value = registry
obj1 = ExampleContent()
obj2 = ExampleContent()
notify(ObjectCreatedEvent(obj1))
notify(ObjectCreatedEvent(obj2))
self.field.getName.return_value = 'fieldname'
self.field.getAccessor.return_value = lambda: [obj1, obj2]
self.field.multiValued = True
self.context.portal_registry.get.return_value = ['SomeType']
widget = RelatedItemsWidget()
self.assertEqual(
{
'name': 'fieldname',
'value': '{};{}'.format(IUUID(obj1), IUUID(obj2)),
'pattern': 'relateditems',
'pattern_options': {
'folderTypes': ['SomeType'],
'homeText':
u'Home',
'searchAllText':
u'Entire site',
'searchText':
u'Search',
'separator':
';',
'orderable':
True,
'maximumSelectionSize':
-1,
'vocabularyUrl':
'/@@getVocabulary?name='
'plone.app.vocabularies.Catalog'
'&field=fieldname',
},
},
widget._base_args(self.context, self.field, self.request),
)
def _create_document(registry, folder):
"""Create new document and version"""
document = Document()
registry.notify(ObjectCreatedEvent(document))
locate(document, folder)
version = DocumentVersion()
registry.notify(ObjectCreatedEvent(version))
# add version to document
versions = IWorkflowVersions(document)
versions.add_version(version, None)
IWorkflowInfo(version).fire_transition('init')
return document, version
def test_multi_valued(self):
from zope.event import notify
from zope.interface import implementer
from zope.lifecycleevent import ObjectCreatedEvent
from plone.uuid.interfaces import IUUID
from plone.uuid.interfaces import IAttributeUUID
from Products.Archetypes.Widget import RelatedItemsWidget
@implementer(IAttributeUUID)
class ExampleContent(object):
pass
obj1 = ExampleContent()
obj2 = ExampleContent()
notify(ObjectCreatedEvent(obj1))
notify(ObjectCreatedEvent(obj2))
self.field.getName.return_value = 'fieldname'
self.field.getAccessor.return_value = lambda: [obj1, obj2]
self.field.multiValued = True
widget = RelatedItemsWidget()
base_args = widget._base_args(self.context, self.field, self.request)
self.assertDictContainsSubset(
{
'name': 'fieldname',
'value': '{};{}'.format(IUUID(obj1), IUUID(obj2)),
'pattern': 'relateditems',
}, base_args)
self.assertDictContainsSubset(
{
'separator':
';',
'orderable':
True,
'maximumSelectionSize':
-1,
'vocabularyUrl':
'/@@getVocabulary?name='
'plone.app.vocabularies.Catalog'
'&field=fieldname',
'basePath':
'/Plone/doc',
'contextPath':
'/Plone/doc',
'rootPath':
'/',
'rootUrl':
''
}, base_args.get('pattern_options', {}))
def test_widget(self):
from zope.event import notify
from zope.interface import implements
from zope.lifecycleevent import ObjectCreatedEvent
from plone.uuid.interfaces import IUUID
from plone.uuid.interfaces import IAttributeUUID
from plone.app.widgets.at import RelatedItemsWidget
class ExampleContent(object):
implements(IAttributeUUID)
obj1 = ExampleContent()
obj2 = ExampleContent()
notify(ObjectCreatedEvent(obj1))
notify(ObjectCreatedEvent(obj2))
self.field.getName.return_value = 'fieldname'
self.field.getAccessor.return_value = lambda: [obj1, obj2]
self.context.portal_properties.site_properties\
.getProperty.return_value = ['SomeType']
widget = RelatedItemsWidget()
self.assertEqual(
{
'name': 'fieldname',
'value': '{};{}'.format(IUUID(obj1), IUUID(obj2)),
'pattern': 'relateditems',
'pattern_options': {
'folderTypes': ['SomeType'],
'homeText':
u'home',
'searchAllText':
u'entire site',
'searchText':
u'Search',
'separator':
';',
'orderable':
True,
'vocabularyUrl':
'/@@getVocabulary?name='
'plone.app.vocabularies.Catalog'
'&field=fieldname',
},
},
widget._base_args(self.context, self.field, self.request),
)
def create_application(factory, container, name):
"""Creates an application and triggers the events from
the application lifecycle.
"""
# Check the factory.
assert IApplication.implementedBy(factory)
# Check the availability of the name in the container.
if name in container:
raise KeyError(name)
# Instanciate the application
application = factory()
# Trigger the creation event.
notify(ObjectCreatedEvent(application))
# Persist the application.
# This may raise a KeyError.
container[name] = application
# Trigger the initialization event.
notify(ApplicationInitializedEvent(application))
return application
def handleCreate(self, action):
"""create was pressed"""
data, errors = self.extractData()
if errors:
self.status = self.formErrorsMessage
return
objList = data['connectors']
if len(objList) < 2:
self.status = _('insufficient connectors')
return
else:
uidutil = queryUtility(IIntIds)
con1 = objList.pop(0)
con1_id = uidutil.getId(con1)
while len(objList) > 0:
con2 = objList.pop(0)
con2_id = uidutil.getId(con2)
print "conn: %s - %s" % (con1.ikName, con2.ikName)
dataVect = {}
dataVect['ikName'] = u'%s -/- %s' % (con1.ikName, con2.ikName)
dataVect['connectors'] = [con1, con2]
dataVect['requirements'] = []
newObj = PhysicalLink(**dataVect)
newObj.__post_init__()
IBrwsOverview(newObj).setTitle(dataVect['ikName'])
self.context[newObj.objectID] = newObj
if hasattr(newObj, "store_refs"):
newObj.store_refs(**dataVect)
notify(ObjectCreatedEvent(newObj))
con1 = con2
con1_id = con2_id
url = absoluteURL(self.context, self.request) + u'/wz_create.html'
self.request.response.redirect(url)
def create_or_modify_content(self, tus_upload):
metadata = tus_upload.metadata()
filename = metadata.get("filename", "")
content_type = metadata.get("content-type", "application/octet-stream")
mode = metadata.get("mode", "create")
fieldname = metadata.get("fieldname")
if mode == "create":
type_ = metadata.get("@type")
if type_ is None:
ctr = getToolByName(self.context, "content_type_registry")
type_ = ctr.findTypeName(filename.lower(), content_type,
"") or "File"
obj = create(self.context, type_)
else:
obj = self.context
if not fieldname:
info = IPrimaryFieldInfo(obj, None)
if info is not None:
fieldname = info.fieldname
elif base_hasattr(obj, "getPrimaryField"):
field = obj.getPrimaryField()
fieldname = field.getName()
if not fieldname:
return self.error("Bad Request", "Fieldname required", 400)
# Acquisition wrap temporarily for deserialization
temporarily_wrapped = False
if IAcquirer.providedBy(obj) and not safe_hasattr(obj, "aq_base"):
obj = obj.__of__(self.context)
temporarily_wrapped = True
# Update field with file data
deserializer = queryMultiAdapter((obj, self.request),
IDeserializeFromJson)
if deserializer is None:
return self.error(
"Not Implemented",
f"Cannot deserialize type {obj.portal_type}",
501,
)
try:
deserializer(data={fieldname: tus_upload}, create=mode == "create")
except DeserializationError as e:
return self.error("Deserialization Error", str(e), 400)
if temporarily_wrapped:
obj = aq_base(obj)
if mode == "create":
if not getattr(deserializer, "notifies_create", False):
notify(ObjectCreatedEvent(obj))
obj = add(self.context, obj)
tus_upload.close()
tus_upload.cleanup()
self.request.response.setHeader("Location", obj.absolute_url())
def create(self, message, manual=False):
"""Store the existing state of the adapted context as a new version.
"""
context = self.__parent__
if manual:
if not self.has_write_permission(context):
raise Unauthorized
version = self.domain_model()
trusted = removeSecurityProxy(context)
# set values on version from context
self._copyFields(trusted, version)
# content domain ids are typically not in the interfaces
# manually inspect and look for one, by hand to save on the new version
mapper = orm.object_mapper(trusted)
version.content_id = mapper.primary_key_from_instance(trusted)[0]
version.status = None
version.manual = manual
# we rely on change handler to attach the change object to the version
event.notify(
interfaces.VersionCreated(context, self, version, message))
session = Session()
session.add(version)
version.context = context
event.notify(ObjectCreatedEvent(version))
return version
def create_main_task(self, templatefolder, selected_templates):
highest_deadline = max(
[template.deadline for template in selected_templates])
deadline_timedelta = api.portal.get_registry_record(
'deadline_timedelta', interface=ITaskSettings)
data = dict(
title=templatefolder.title,
issuer=self.replace_interactive_user('current_user'),
responsible=self.replace_interactive_user('current_user'),
responsible_client=get_current_org_unit().id(),
task_type='direct-execution',
deadline=date.today() +
timedelta(highest_deadline + deadline_timedelta),
)
main_task = createContent('opengever.task.task', **data)
notify(ObjectCreatedEvent(main_task))
main_task = addContentToContainer(self.context,
main_task,
checkConstraints=True)
self.mark_as_generated_from_tasktemplate(main_task)
# set the main_task in to the in progress state
api.content.transition(obj=main_task,
transition='task-transition-open-in-progress')
return main_task
def __call__(self, data):
for name in self.schema:
field = self.schema[name]
if IMethod.providedBy(field):
continue
if data.get(name) is None:
data[name] = self.schema[name].default
name = data.get('name')
site = self.context
# we just wanna have one
util = component.queryUtility(interfaces.IMemcachedClient,
context=site,
name=name)
if util is not None:
return
# needed to be called TTW
sm = removeSecurityProxy(site.getSiteManager())
default = sm['default']
util = utility.MemcachedClient()
zope.event.notify(ObjectCreatedEvent(util))
for attr in ['trackKeys', 'defaultNS', 'servers', 'defaultLifetime']:
setattr(util, attr, data[attr])
default[u'memcachedclient_' + name] = util
sm.registerUtility(util, interfaces.IMemcachedClient, name=name)
def createAndAdd(self, data):
domain_model = self.domain_model
# create the object, inspect data for constructor args
try:
ob = createInstance(domain_model, data)
except TypeError:
ob = domain_model()
# apply any context values
self.finishConstruction(ob)
# apply extra form values
form.applyChanges(ob, self.form_fields, data, self.adapters)
# save the object, id is generated by db on flush
self.context[""] = ob
# flush so we have database id
bungeni.alchemist.Session().flush()
# fire an object created event
notify(ObjectCreatedEvent(ob))
# signal to add form machinery to go to next url
self._finished_add = True
mapper = orm.object_mapper(ob)
# TODO single primary key (need changes to base container)
oid = mapper.primary_key_from_instance(ob)
# retrieve the object with location and security information
return self.context[oid]
def create_task(parent, **kwargs):
createContent('opengever.task.task')
task = createContent('opengever.task.task', **kwargs)
notify(ObjectCreatedEvent(task))
task = addContentToContainer(parent, task, checkConstraints=False)
notify(ObjectAddedEvent(task))
return task
def create(self, container=None):
"""
Create content in the given container and return url.
Uses dexterity_update to set the
appropriate fields after creation.
"""
if not self.validate():
# BBB: do something clever that works with pat-inject
# at the moment the @@add_something form is not a complete page
# but just some markup,
# so we cannot show that one here
pass
new = self.get_new_object(container)
modified, errors = self.update(new)
if not errors:
api.portal.show_message(
_("Item created."),
request=self.request,
type="success"
)
new.reindexObject()
notify(ObjectCreatedEvent(new))
else:
api.portal.show_message(
_("There was a problem: %s." % errors),
request=self.request,
type="error",
)
return new.absolute_url()
def manage_addImage(context, identifier, title=None, file=None):
"""Add an Image.
"""
if file is not None:
validate_image(file)
filename = None
if hasattr(file, 'name'):
filename = os.path.basename(file.name)
container = context
if ISilvaFactoryDispatcher.providedBy(container):
container = container.Destination()
name_chooser = ISilvaNameChooser(container)
identifier = name_chooser.chooseName(identifier or filename,
None,
file=file,
interface=interfaces.IAsset)
try:
name_chooser.checkName(identifier, None)
except ContentError as e:
raise ValueError(
_(u"Please provide a unique id: ${reason}",
mapping=dict(reason=e.reason)))
context._setObject(identifier, Image(identifier))
content = context._getOb(identifier)
if title is not None:
content.set_title(title)
if file is not None:
content.set_image(file)
notify(ObjectCreatedEvent(content))
return content
def __call__(self):
self.request.response.setHeader(
'Content-type', 'application/vnd.oasis.opendocument.text')
self.request.response.setHeader(
'Content-disposition', 'inline;filename="' +
removeSecurityProxy(self.report.report_type) + "_" +
removeSecurityProxy(self.report.start_date).strftime('%Y-%m-%d') +
'.odt"')
session = Session()
report = session.query(domain.Report).get(self.report.report_id)
d = dict([(f.file_title, f.file_data) for f in report.attached_files])
if "odt" not in d.keys():
params = {}
params['body_text'] = self.cleanupText()
renderer = Renderer(self.odt_file, params, self.tempFileName)
renderer.run()
f = open(self.tempFileName, 'rb')
doc = f.read()
f.close()
os.remove(self.tempFileName)
attached_file = domain.AttachedFile()
attached_file.file_title = "odt"
attached_file.file_data = doc
attached_file.language = report.language
report.attached_files.append(attached_file)
notify(ObjectCreatedEvent(attached_file))
session.add(report)
session.commit()
return doc
else:
return d["odt"].__str__()
def createAndAdd(self, data):
domain_model = self.domain_model
# create the object, inspect data for constructor args
try:
ob = createInstance(domain_model, data)
except TypeError:
log.error("Failure: createInstance(%s, %s)", domain_model, data)
probing.log_exc(sys.exc_info(), log_handler=log.error)
ob = domain_model()
# apply any context values
self.finishConstruction(ob)
# apply extra form values
formlib.form.applyChanges(ob, self.form_fields, data, self.adapters)
# set the object in container context, causing autosetting of
# constrained values e.g. one2many attributes, by triggering call to
# _ManagedContainer.constraints.setConstrainedValues()
self.context[""] = ob
# flush so we have database id
Session().flush()
# !+DataError reload form and display this error?
# fire an object created event
notify(ObjectCreatedEvent(
ob)) # !+ would set doc_id (if session not flushed) !!
# signal to add form machinery to go to next url
self._finished_add = True
# retrieve the object with location and security information
oid = self.get_oid(ob)
return self.context[oid]
def handleAdd(self, action):
data, errors = self.extractData()
if errors:
self.status = self.formErrorsMessage
return
typeName = self.tileType.__name__
generator = getUtility(IUUIDGenerator)
tileId = generator()
# Traverse to a new tile in the context, with no data
tile = self.context.restrictedTraverse('@@%s/%s' % (
typeName,
tileId,
))
dataManager = ITileDataManager(tile)
dataManager.set(data)
# Look up the URL - we need to do this after we've set the data to
# correctly account for transient tiles
tileURL = absoluteURL(tile, self.request)
notify(ObjectCreatedEvent(tile))
notify(ObjectAddedEvent(tile, self.context, tileId))
self.request.response.redirect(tileURL)
def createContent(portal_type, **kw):
fti = getUtility(IDexterityFTI, name=portal_type)
content = createObject(fti.factory)
# Note: The factory may have done this already, but we want to be sure
# that the created type has the right portal type. It is possible
# to re-define a type through the web that uses the factory from an
# existing type, but wants a unique portal_type!
content.portal_type = fti.getId()
schemas = iterSchemataForType(portal_type)
fields = dict(kw) # create a copy
for schema in schemas:
# schema.names() doesn't return attributes from superclasses in derived
# schemas. therefore we have to iterate over all items from the passed
# keywords arguments and set it, if the behavior has the questioned
# attribute.
behavior = schema(content)
for name, value in fields.items():
try:
# hasattr swallows exceptions.
getattr(behavior, name)
except AttributeError:
# fieldname not available
continue
setattr(behavior, name, value)
del fields[name]
for (key, value) in fields.items():
setattr(content, key, value)
notify(ObjectCreatedEvent(content))
return content
def saveDiscussions(self):
session = Session()
new_record_keys = []
domain_model = removeSecurityProxy(self.context.domain_model)
for record in self.data:
discussion_text = record.get("body", "")
object_id = record.get("object_id", None)
if object_id:
current_record = removeSecurityProxy(
self.context.get(getItemKey(object_id)))
current_record.body = discussion_text
session.add(current_record)
session.flush()
notify(ObjectModifiedEvent(current_record))
new_record_keys.append(stringKey(current_record))
else:
new_record = domain_model(body=discussion_text,
language=get_default_language())
new_record.scheduled_item = removeSecurityProxy(
self.context.__parent__)
session.add(new_record)
session.flush()
notify(ObjectCreatedEvent(new_record))
new_record_keys.append(stringKey(new_record))
records_to_delete = [
removeSecurityProxy(self.context.get(key))
for key in self.context.keys() if key not in new_record_keys
]
map(session.delete, records_to_delete)
map(lambda deleted: notify(ObjectRemovedEvent(deleted)),
records_to_delete)
def appendSlave(self, msgHeader, nodename=None):
"""
append oid to slave list
"""
if nodename:
if nodename in zapi.getRoot(self):
newSlaveNode = zapi.getRoot(self)[nodename]
else:
#self.oidSlave = msgHeader['from_oid']
newSlaveNode = createObject(\
u"org.ict_ok.slave.slave.Slave")
ISlave['objectID'].readonly = False
newSlaveNode.objectID = msgHeader['from_oid']
ISlave['objectID'].readonly = True
newSlaveNode.ikName = unicode(nodename)
notify(ObjectCreatedEvent(newSlaveNode))
zapi.getRoot(self)[nodename] = newSlaveNode
slaveSupervisor = zapi.queryUtility(IAdmUtilSupervisor,
context=newSlaveNode)
if slaveSupervisor:
#slaveSupervisor.ipv4Master = msgHeader['to_ip']
#slaveSupervisor.oidMaster = msgHeader['to_oid']
slaveSupervisor.status2Master = u"connected"
slaveSupervisor.ipv4Slave = msgHeader['from_ip']
slaveSupervisor.oidSlave = msgHeader['from_oid']
slaveSupervisor.lastSeenSlave = datetime.now(berlinTZ)
self._p_changed = True
mq_utility = zapi.queryUtility(IAdmUtilObjMQ)
if mq_utility:
my_data = {'cmd': 'connected'}
my_data['header'] = mq_utility.switchFromTo(msgHeader)
mq_utility.sendPerMq(my_data)
def manage_addFile(self, id, file='', title='', precondition='',
content_type='', REQUEST=None):
"""Add a new File object.
Creates a new File object 'id' with the contents of 'file'"""
id = str(id)
title = str(title)
content_type = str(content_type)
precondition = str(precondition)
id, title = cookId(id, title, file)
self=self.this()
# First, we create the file without data:
self._setObject(id, File(id,title,'',content_type, precondition))
newFile = self._getOb(id)
# Now we "upload" the data. By doing this in two steps, we
# can use a database trick to make the upload more efficient.
if file:
newFile.manage_upload(file)
if content_type:
newFile.content_type=content_type
notify(ObjectCreatedEvent(newFile))
if REQUEST is not None:
REQUEST['RESPONSE'].redirect(self.absolute_url()+'/manage_main')
def handle_publish(self, action, data):
self.generated_content = self.generateContent(data)
if IWorkspaceScheduling.providedBy(self.request):
if not hasattr(self.context, "group_id"):
context_group_id = ISchedulingContext(self.context).group_id
else:
context_group_id = self.context.group_id
else:
#get the chamber id
context_group_id = get_chamber_for_context(
self.context).parliament_id
report = domain.Report(
title=self.title,
start_date=self.start_date,
end_date=self.end_date,
body=self.generated_content,
owner_id=get_login_user().user_id, # !+GROUP_AS_OWNER
language=self.language,
group_id=context_group_id)
session = Session()
session.add(report)
session.flush()
notify(ObjectCreatedEvent(report))
self.status = _(u"Report has been processed and saved")
return self.template()
def __call__(self):
self.request.response.setHeader("Content-type", "application/pdf")
self.request.response.setHeader(
"Content-disposition", 'inline;filename="' +
removeSecurityProxy(self.report.report_type) + "_" +
removeSecurityProxy(self.report.start_date).strftime("%Y-%m-%d") +
'.pdf"')
session = Session()
report = session.query(domain.Report).get(self.report.report_id)
d = dict([(f.file_title, f.file_data) for f in report.attached_files])
if "pdf" not in d.keys():
params = {}
params["body_text"] = self.cleanupText()
openofficepath = getUtility(IOpenOfficeConfig).getPath()
renderer = Renderer(self.odt_file,
params,
self.tempFileName,
pythonWithUnoPath=openofficepath)
renderer.run()
f = open(self.tempFileName, "rb")
doc = f.read()
f.close()
os.remove(self.tempFileName)
attached_file = domain.AttachedFile()
attached_file.file_title = "pdf"
attached_file.file_data = doc
attached_file.language = report.language
report.attached_files.append(attached_file)
notify(ObjectCreatedEvent(attached_file))
session.add(report)
session.commit()
return doc
else:
return d["pdf"].__str__()
def action(self, type_name='', id=''):
if not type_name:
raise UserError(_(u"You must select the type of object to add."))
if type_name.startswith('@@'):
type_name = type_name[2:]
if '/' in type_name:
view_name = type_name.split('/', 1)[0]
else:
view_name = type_name
if queryMultiAdapter((self, self.request), name=view_name) is not None:
url = "%s/%s=%s" % (absoluteURL(self, self.request), type_name, id)
self.request.response.redirect(url)
return
if not self.contentName:
self.contentName = id
factory = getUtility(IFactory, type_name)
content = factory()
notify(ObjectCreatedEvent(content))
self.add(content)
self.request.response.redirect(self.nextURL())
def check_required_utilities(site, utilities):
"""Utility function to check for required utilities
:param ISite site: the site manager into which configuration may be checked
:param tuple utilities: each element of the tuple is another tuple made of the utility
interface, the utility registration name, the utility factory and the object name when
creating the utility, as in:
.. code-block:: python
REQUIRED_UTILITIES = ((ISecurityManager, '', SecurityManager, 'Security manager'),
(IPrincipalAnnotationUtility, '', PrincipalAnnotationUtility,
'User profiles'))
"""
registry = get_current_registry()
for interface, name, factory, default_id in utilities:
utility = query_utility(interface, name=name)
if utility is None:
lsm = site.getSiteManager()
if default_id in lsm:
continue
if factory is None:
factory = get_object_factory(interface)
utility = factory()
registry.notify(ObjectCreatedEvent(utility))
lsm[default_id] = utility
lsm.registerUtility(utility, interface, name=name)
