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 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 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 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): 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())