def __init__(self):
super(StartupDrinks, self).__init__()
#Add banner
self['banner'] = Banner()
grok.notify(grok.ObjectCreatedEvent(self['banner']))
#Add Gallery
self['gallery'] = Gallery()
grok.notify(grok.ObjectCreatedEvent(self['gallery']))
#Add Map
self['map'] = Map()
grok.notify(grok.ObjectCreatedEvent(self['map']))
#Add Pages
self['pages'] = PageFolder()
grok.notify(grok.ObjectCreatedEvent(self['pages']))
self['pages']['asistentes'] = Page(title=u'Asistentes', body=u'Editame')
self['pages']['acerca-de'] = Page(title=u'Acerca de...', body=u'Editame')
self['pages']['ciudades'] = Page(title=u'Ciudades', body=u'Editame')
# Add Sponsors
self['sponsors'] = SponsorsContainer()
grok.notify(grok.ObjectCreatedEvent(self['gallery']))
def __call__(self, authentication):
principal = Principal(authentication.prefix + self.info.id,
self.info.description)
grok.notify(
interfaces.AuthenticatedPrincipalCreated(authentication, principal,
self.info, self.request))
return principal
def reply_letter(self, data):
account = self.manager.get(data['az'])
user = self.manager.get(data['az'])
if user is not None:
info = data.by_schema[IMessage]
message = Message()
grok.notify(grok.ObjectCreatedEvent(message))
from dolmen.forms.base import set_fields_data
if 'attachment' in info.keys():
from StringIO import StringIO
f = StringIO(decodestring(info['attachment']))
# f.filename="download"
f.filename = info['filename']
info['attachment'] = f
set_fields_data(IMessage, message, info)
directlyProvides(message, IAnswer)
user['nachrichten'][info['doc_id']].add(message)
print "I ADDED A MESSAGE"
# with transaction.manager as t:
# print t
grok.notify(AfterSaveEvent(message, self.request))
#import pdb; pdb.set_trace()
#IWorkflowInfo(message).fireTransition('finish')
self.request.response.setStatus(202)
return
raise KeyError('Unknown user.')
def __call__(self, form):
if form.current.actions['save'](form.current) is SUCCESS:
if super(MySaveAction, self).__call__(form) is SUCCESS:
grok.notify(AfterSaveEvent(form.context, form.request))
form.redirect(form.url(self.redirect_url))
return SUCCESS
return FAILURE
def __init__(self, settings):
# register instance as global utility.
gsm = getGlobalSiteManager()
gsm.registerUtility(self, IDbUtility)
self.settings = settings
connection_string = self.getConnectionString()
self.engine = create_engine(
connection_string,
echo=False,
encoding='utf-8',
convert_unicode=True,
)
# Make a test query and at the same time, obtain max_allowed_packet
self.max_allowed_packet = self.engine.scalar(max_allowed_packet_sql())
# bind engine to the metadata
metadata.bind = self.engine
# We'll have to stick with scoped sesssions because of threading
# See: http://www.mail-archive.com/[email protected]/msg25090.html
self.Session = scoped_session(sessionmaker(
bind=self.engine,
autoflush=False,
autocommit=False,
))
grok.notify(RelationalDatabaseOpened())
def __call__(self, authentication):
principal = UVCPrincipal(authentication.prefix + self.info.id,
self.info.title,
self.info.description)
grok.notify(AuthenticatedPrincipalCreated(
authentication, principal, self.info, self.request))
return principal
def __call__(self, form):
if form.current.actions['save'](form.current) is SUCCESS:
if super(MySaveAction, self).__call__(form) is SUCCESS:
grok.notify(AfterSaveEvent(form.context, form.request))
form.redirect(form.url(self.redirect_url))
return SUCCESS
return FAILURE
def create_application(factory, container, name):
"""Creates an application and triggers the events from
the application lifecycle.
"""
# Check the factory.
if not grok.interfaces.IApplication.implementedBy(factory):
raise WrongType(factory)
# Check the availability of the name in the container.
if name in container:
raise DuplicationError(name)
# Instanciate the application
application = factory()
# Trigger the creation event.
grok.notify(grok.ObjectCreatedEvent(application))
# Persist the application.
# This may raise a DuplicationError.
container[name] = application
# Trigger the initialization event.
grok.notify(grok.ApplicationInitializedEvent(application))
return application
def _touchEvent(self, keyName):
if keyName in self:
return self[keyName]
else:
event = Event(keyName, None, None, None)
self[keyName] = event
grok.notify(grok.ObjectCreatedEvent(event))
return event
def checkAuth(self, user, password, gebdate):
plugin = getUtility(IAuthenticatorPlugin, 'users')
principal = plugin.authenticateCredentials(
dict(login=user, password=password, gebdate=gebdate))
if principal:
grok.notify(UserLoginEvent(factories.Principal(user)))
return 1
return 0
def install(self, site):
try:
grok.notify(self.trigger(site))
except Exception as exc:
print(f'An error occured ({exc}). This should be logged.')
if self.get(site) is None:
raise uvcsite.plugins.PluginError(
self.title, 'Catalog registration was unsuccessful.')
def update(self, code=None, state=None, **args):
''' Either code or error is defined here if this is in response to Authorization '''
super(V2TokenView, self).update(**args)
oauth = self.context.__parent__.__parent__
self.context.__parent__.__parent__.error_msg = None
if self.error is None:
if code is not None:
token = self.context.__parent__
if token.state == state:
self.context.code = code
data = urlencode(self.context.parms)
print "----------------------------------------------------"
print "url=[%s]; data=[%s]" % (self.context.uri, data)
req = Request(self.context.uri)
req.add_header(
'User-Agent',
'Python urlib2 (grok.zopefoundation.org, Python 2.7)')
req.add_header('Content-Type',
'application/x-www-form-urlencoded')
req.add_header('Accept', 'application/json')
req.add_data(data)
try:
res = urlopen(req).read() # should be doing a post
self.context.info = json.loads(res)
try:
# Update session information with auth info
session = ISession(self.request)['OAuth2']
session['info'] = self.context.info
service = self.context.__parent__.service
principal = component.queryAdapter(self.context,
IOAuthPrincipal,
name=service)
session[
'principal'] = principal if principal else None
# If we get here, we can notify subscribers.
grok.notify(
OAuthenticatedEvent(session['principal']))
self.redirect(self.url(grok.getApplication()))
except Exception as e:
print "Problem in adapter for service: {}".format(
str(e))
self.error = str(e)
except HTTPError as e:
print "Error while exchanging tokens: {}".format(
str(e))
self.error = str(e)
else:
self.error = 'State Mismatch'
else:
self.error = 'Invalid code'
if type(self.error) is str and len(self.error):
print "-------------------------------------------------"
print "Error [%s] in token exchange" % self.error
oauth.error_msg = self._render_template()
self.redirect(self.url(grok.getApplication()))
def evolve(site):
"""Describe changes here"""
if ifaces.IMainApp.providedBy(site):
nw_obj = Page(title=u'Ciudades', body=u'Editame')
site['pages']['ciudades'] = nw_obj
grok.notify(grok.ObjectCreatedEvent(nw_obj))
logger.info("Generations: 1 (%r)" % site)
def handleAdd(self):
data, errors = self.extractData()
if errors:
self.flash('Es sind Fehler aufgetreten')
return
obj = self.createAndAdd(data)
if obj is not None:
# mark only as finished if we get the new object
self._finishedAdd = True
grok.notify(AfterSaveEvent(obj, self.request))
def handleAdd(self):
data, errors = self.extractData()
if errors:
self.flash('Es sind Fehler aufgetreten')
return
obj = self.createAndAdd(data)
if obj is not None:
# mark only as finished if we get the new object
self._finishedAdd = True
grok.notify(AfterSaveEvent(obj, self.request))
def install(self, site):
try:
grok.notify(self.trigger(site))
except:
# should log
raise
if self.get(site) is None:
raise uvcsite.plugins.PluginError(
self.title,
u'Catalog registration was unsuccessful.')
def replace(self, element, result):
self.validate(element)
for field_el in element:
dummy, field_name = field_el.tag.split('}')
field = result[field_name]
if field.read_only:
continue
IXml(field).replace(field_el)
# notify parent object of changes
grok.notify(grok.ObjectModifiedEvent(result.__parent__))
def __call__(self, authentication):
principal = TemporaryPrincipal(authentication.prefix + self.info.id,
self.info.title,
self.info.description,
document=self.info.document)
grok.notify(
interfaces.AuthenticatedPrincipalCreated(authentication, principal,
self.info, self.request))
applySkin(self.request, ITemporarySkin)
return principal
def fset(self, new_state):
grok.notify(
StateChanged(
self.context,
principal=self.request.principal,
old_state=self.context.state,
new_state=new_state,
transition=new_state.action))
utils.notify_changes(self.context, {ITask: ['state']})
self.context.state = new_state
def test_content_creation_modification(self):
import datetime
import zope.security
from zope.publisher.browser import TestRequest
from zope.pluggableauth.factories import Principal
from zope.lifecycleevent import ObjectCreatedEvent
with uvcsite.testing.AuthenticatedRequest('0101010001') as request:
content = uvcsite.content.components.Content()
self.assertEqual(content.principal, request.principal)
grok.notify(ObjectCreatedEvent(content))
self.assertTrue(content.modtime, datetime.datetime)
def handle_apply(self):
data, errors = self.extractData()
#import pdb; pdb.set_trace()
if errors:
self.flash('Es sind Fehler aufgetreten', type="error")
return
changes = uvcsite.browser.forms.apply_data_event(self.fields, self.context, data)
if changes:
grok.notify(AfterSaveEvent(self.context, self.request))
self.flash(u'Ihre Daten wurden erfolgreich gendert', type="info")
return
else:
self.flash('Kein Änderung', type="info")
def worker():
print '################################################################'
print 'Start...'
print '################################################################'
uvcsite = root['app']
component.hooks.setSite(uvcsite)
hfm = component.getUtility(IHomeFolderManager).homeFolderBase
for homefolder in hfm.values():
#for item in homefolder:
# print item
if 'Sunfallanzeigen' in homefolder:
for item in homefolder['Sunfallanzeigen'].values():
#pid = str(item.principal.id)
#print pid
#print IWorkflowState(item).getState()
if IWorkflowState(item).getState() == 2:
print '################################################################'
print 'Fehlerhafte Unfallanzeige gefunden:'
print "%s/%s" % (homefolder.__name__, item.title)
print '################################################################'
print 'Bitte Dokument anschauen und Fehler beheben !'
print 'Dann Code der Nachverarbeitung aendern:'
print '1. Dokument neu erstellen und versenden, NICHT fixen !!!'
print '2. Dokument fixen, OHNE Erstellung !!!'
print '################################################################'
##### Status: 0 = Nur schauen, was laeuft falsch
##### 1 = Dokument neu erstellen
##### 2 = Dokument fixen (Status gesendet)
##### Nachfolgenden Status setzen:
status = 0 # <----- Dort: 0, 1 oder 2
if status == 0:
print "-----> Es wurde noch keine Aktion ausgeführt"
print "Status: ", status
elif status == 1:
modprincipal = item.principal
alsoProvides(modprincipal, MoE)
event_obj = geteventobject(modprincipal)
try:
grok.notify(AfterSaveEvent(item, event_obj))
except InvalidTransitionError:
print "-----> Dokumente wurden erstellt, Status umstellen zum fixen !!!"
print "Status: ", status
except Exception, e:
print e
pass
elif status == 2:
IWorkflowInfo(item).fireTransition('fix')
print "-----> Dokumente gefixt !!!"
print " Status umstellen auf --> 0 <--"
print "Status: ", status
print 'FIX of object %s' % item
def render(self, application, name):
if name is None or name == "":
self.redirect(self.url(self.context, 'applications'))
return
app = getUtility(grok.interfaces.IApplication, name=application)
try:
new_app = app()
grok.notify(grok.ObjectCreatedEvent(new_app))
self.context.root[name] = new_app
self.flash(u'Added %s `%s`.' % (application, name))
except (DuplicationError, KeyError):
self.flash(u'Name `%s` already in use. '
u'Please choose another name.' % (name,))
self.redirect(self.url(self.context, 'applications'))
def PUT(self):
errors = []
content = self.context.getContentType()()
interface = content.schema[0]
serializer = IJSONSerializer(content)
serializer.work(self.body, interface, errors)
if not errors:
self.context.add(content)
result = dict(result='success',
name=content.meta_type,
id=content.__name__)
grok.notify(AfterSaveEvent(content, self.request))
else:
result = errors
return json.dumps(result)
def render(self, **kw):
access = self.context.access
acecss.parms.update(kw)
session = ISession(self.request)['OAuth2']
session['info'] = access.info
service = self.context.__parent__.service
principal = component.queryAdapter(access,
IOAuthPrincipal,
name=service)
session['principal'] = principal if principal else None
grok.notify(OAuthenticatedEvent(self.context.access))
self.redirect(self.url(grok.getApplication()))
def setObjectAttributesFromDict(obj, newValues, attributes):
modified = False
for name in attributes:
if isinstance(name, tuple):
attribute, key = name
else:
attribute, key = (name, name)
oldValue = getattr(obj, attribute)
if key in newValues:
newValue = newValues.get(key, oldValue)
if oldValue != newValue:
modified = True
setattr(obj, attribute, newValue)
if modified:
grok.notify(grok.ObjectModifiedEvent(obj))
return obj
def test_reindexing_and_searching_parties(self):
person = self.createAPerson()
organisation = self.createAOrganisation()
demographics = self.oship['demographics']
person.defineRelationship(organisation)
demographics[person.uid.value] = person
demographics[organisation.uid.value] = organisation
person.removeRelationship(organisation)
grok.notify(grok.ObjectModifiedEvent(person))
grok.notify(grok.ObjectModifiedEvent(organisation))
results = Query().searchResults(AnyOf(('actor_catalog','relationships'),
[organisation.uid.value]))
self.assertEquals(len(results), 0)
results = Query().searchResults(AnyOf(('actor_catalog','reverse_relationships'),
[person.uid.value]))
results = list(results)
self.assertEquals(len(results), 0)
def PUT(self):
errors = []
content = self.context.getContentType()()
interface = content.schema[0]
serializer = IJSONSerializer(content)
serializer.work(self.body, interface, errors)
if not errors:
self.context.add(content)
result = dict(
result='success',
name=content.meta_type,
id=content.__name__
)
grok.notify(AfterSaveEvent(content, self.request))
else:
result = errors
return json.dumps(result)
def generate_map(event):
# Ensure we only operate on archive sites
if asmarchive not in event.site.getSiteManager().__bases__:
return
years = filter(lambda x: YEAR_MATCH.match(x.__name__),
list(event.site.subpages))
for homepage in event.site.editions:
gallery_map = homepage.gallery_map
for year in years:
for year_edition in year.editions:
if not year_edition in event.imported_editions:
continue
year_name = year.page.__name__
gallery_map[year_name] = generate_year_map(
year, homepage.parameters)
homepage.gallery_map = gallery_map
grok.notify(grok.ObjectModifiedEvent(homepage))
def PUT(self):
errors = []
content = self.context.getContentType()()
interface = content.schema[0]
serializer = uvcsite.content.interfaces.ISerializer(content)
serializer.work(self.body, interface, errors)
if not errors:
self.context.add(content)
result = etree.Element('success',
name=content.meta_type,
id=content.__name__)
grok.notify(AfterSaveEvent(content, self.request))
else:
result = etree.Element('failure')
result.extend(errors)
return etree.tostring(result, encoding='UTF-8', pretty_print=True)
def PUT(self):
errors = []
content = self.context.getContentType()()
interface = content.schema[0]
serializer = ISerializer(content)
serializer.work(self.body, interface, errors)
if not errors:
self.context.add(content)
result = etree.Element(
'success',
name=content.meta_type,
id=content.__name__
)
grok.notify(AfterSaveEvent(content, self.request))
else:
result = etree.Element('failure')
result.extend(errors)
return etree.tostring(result, encoding='UTF-8', pretty_print=True)
def submit_letter(self, data):
account = self.manager.get(data['az'])
user = self.manager.get(data['az'])
if user is not None:
info = data.by_schema[IMessage]
message = Message()
grok.notify(grok.ObjectCreatedEvent(message))
from dolmen.forms.base import set_fields_data
if 'attachment' in info.keys():
from StringIO import StringIO
f = StringIO(decodestring(info['attachment']))
# f.filename="download"
f.filename = info['filename']
info['attachment'] = f
set_fields_data(IMessage, message, info)
directlyProvides(message, IQuestion)
user['nachrichten'].add(message)
grok.notify(AfterSaveEvent(message, self.request))
self.request.response.setStatus(202)
return
raise KeyError('Unknown user.')
def login(self):
data, errors = self.extractData()
if errors:
return FAILURE
principal = self.request.principal
if IUnauthenticatedPrincipal.providedBy(principal):
self.status = _("Login failed")
return FAILURE
self.flash(
_("You are now logged in as ${name}",
mapping={"name": principal.id}))
grok.notify(UserLoggedInEvent(principal))
camefrom = self.request.get("camefrom", None)
if not camefrom:
if ILocation.providedBy(principal):
camefrom = absoluteURL(principal, self.request)
else:
camefrom = absoluteURL(self.context, self.request)
self.redirect(camefrom)
return SUCCESS
def update(self, tags=None):
if tags is None:
return
tags = set(tags.split(' '))
self.context['metadata']['tags'].value = tags
grok.notify(grok.ObjectModifiedEvent(self.context))
def createAndAdd(self, data):
obj = self.create(data)
grok.notify(zope.lifecycleevent.ObjectCreatedEvent(obj))
self.add(obj)
return obj
def evolve(site):
"""Add sponsors as a gallery"""
site['sponsors'] = SponsorsContainer()
grok.notify(grok.ObjectCreatedEvent(site['gallery']))
logger.info("generations: 3 (%r) Ready" % site)
def createAndAdd(self, data):
obj = self.create(data)
grok.notify(zope.lifecycleevent.ObjectCreatedEvent(obj))
self.add(obj)
return obj
def update(self):
self.uaz = uaz = Unfallanzeige()
grok.notify(ObjectCreatedEvent(uaz))
self.context.add(uaz)
def object_modified(self):
grok.notify(grok.ObjectModifiedEvent(self.context.__parent__.__parent__))
def update(self):
self.uaz = uaz = Unfallanzeige()
grok.notify(ObjectCreatedEvent(uaz))
self.context.add(uaz)
def update(self):
uaz = Unfallanzeige()
alsoProvides(uaz, ISUnfallanzeige)
self.uaz = uaz
grok.notify(ObjectCreatedEvent(uaz))
self.context.add(uaz)
def add_camera(self, **data):
self.applyData(self.context, **data)
grok.notify(grok.ObjectModifiedEvent(self.context))
self.flash(_(u'Changes were saved'))
return self.redirect(self.application_url())
