by on SWiK

[hibernate-issues] [Hibernate-JIRA] Commented: (HHH-2381) Criteria

Fri, 10 Oct 2008 11:06:51 -0700

Grok-by-Example: Demosite

Thu, 09 Oct 2008 18:05:01 -0700

One possible setup is to create the demosite as a Grok app on its own. You just construct the basic app layout (or let $ svn co svn://svn.zope.org/repos/main/grokapps/gbedemosite $ cd gbedemosite $ virtualenv --no-site-packages . $ source bin/activate

install_requires=[... 'gbeguestbook', 'gbe99bottles', 'gbewiki', 'gbepastebin', ... ],

svn co svn://svn.zope.org/repos/main/grokapps/gbeguestbook svn co svn://svn.zope.org/repos/main/grokapps/gbe99bottles svn co svn://svn.zope.org/repos/main/grokapps/gbewiki svn co svn://svn.zope.org/repos/main/grokapps/gbepastebin

[buildout] develop = . gbeguestbook gbe99bottles gbewiki gbepastebin

$ bin/python bootstrap.py $ bin/buildout

You basically only need to change the ‘app.py’ template file. Lets assume you created the app by running “grokproject Demosite”, you already have a ‘Demosite’ application class, with an Index view and the associated ‘app_templates/index.pt’ template file.

@grok.subscribe(Demosite, grok.IObjectAddedEvent) def handle(obj, event): applications=(('gbeguestbook.app.Application','Guestbook'), ('gbe99bottles.app.Song','Song'), ('gbewiki.app.WikiPage','Wiki'), ('gbepastebin.app.Application','Pastebin'), ) for application, name in applications: app = zope.component.getUtility(grok.interfaces.IApplication, name=application) try: obj[name] = app() except DuplicationError: pass

If you want to serve your apps to the public, your site also should provide a ‘robots.txt’ file for the webcrawlers.

class Robots(grok.View): grok.name('robots.txt')

ServerName your.server.name ... RewriteEngine On RewriteRule ^/(.*) http://127.0.0.1:8080/<demosite>/++vh++http:your.server.name:80/++/$1 [P,L] </VirtualHost>

Finally you want to debug the running demosite. Some of the example apps have no means to delete existing objects - you can simply delete objects from the debugger too.

[buildout] ... parts = ... zodb server instance2

[zodb] recipe = zc.recipe.egg:script eggs = ZODB3

[server] recipe = zc.zodbrecipes:server zeo.conf = <zeo> address 8100 </zeo> <filestorage 1> path ${buildout:parts-directory}/data/ZEOData.fs </filestorage>

[zopectl] recipe = zc.zope3recipes:instance application = app address = 8080 zope.conf = devmode on <zodb> <zeoclient> server 8100 </zeoclient> </zodb> site-definition ${buildout:parts-directory}/app/site.zcml

<accesslog> <logfile> path ${buildout:parts-directory}/zopectl/access.log </logfile> </accesslog>

<eventlog> <logfile> formatter zope.exceptions.log.Formatter path STDOUT </logfile> </eventlog>

[instance2] recipe = zc.zope3recipes:instance extends = zopectl address = 9080

Run buildout again, run the tests, start the server, start the client: $ bin/buildout $ bin/test $ bin/server start $ bin/zopectl fg

$ sudo a2ensite your-vhost-id $ sudo /etc/init.d/apachectl restart

Hope that gets you up and running in record time - creating the demosite application was done in an hour. As always writing the docs took a bit longer ;)

GBE demo site

Tue, 07 Oct 2008 10:51:51 -0700

applications. I’ll add the source for this multi-app site to the GBE apps at a later date.

Webservice development with the Eclipse Web Tool Platform (WTP) - Tutorial

Tue, 30 Sep 2008 04:17:00 -0700

eclipse step by step tutorials

Firefox 3: 8 Things You Didn't Know You Could Do - Solutions by PC Magazine

Mon, 29 Sep 2008 18:15:05 -0700

RIA Frameworks | commadot.com

Mon, 29 Sep 2008 14:18:16 -0700

login by code - Spring Community Forums

Thu, 25 Sep 2008 11:14:03 -0700

A generic acegi login interface | Wookets Wove

Thu, 25 Sep 2008 11:14:03 -0700

request.getSession().setAttribute( HttpSessionCont

Issues with JSF and Acegi with JdbcDaoImpl controller - Spring Community Forums

Thu, 25 Sep 2008 11:14:03 -0700

Pregnancy Week By Week

Thu, 25 Sep 2008 05:22:59 -0700

Read this to know what’s happening inside you during pregnancy week by week.

Home

Tue, 23 Sep 2008 00:10:13 -0700

Eclipse 40mm semi-auto revolver by Solar

How to install and setup Apache, MySQL and PHP in Windows - Simple Help

Wed, 17 Sep 2008 17:03:15 -0700

Manual:FAQ - MediaWiki

Tue, 16 Sep 2008 11:08:21 -0700

Wholesale Property – DiscountedProperties.com

Tue, 16 Sep 2008 00:38:08 -0700

Wholesale Property listing service. DiscountedProperties.com offers fixer upper homes, pre foreclosure real estate, and investment property.

Slide TOC

Mon, 15 Sep 2008 22:00:44 -0700

Joomla installation web help and step by step guide

Lists

Fri, 12 Sep 2008 12:59:55 -0700

Check Writer Program| The Advantage is Yours!

Fri, 12 Sep 2008 11:31:33 -0700

Accepting check by Phone, E-Mail, Fax or Online is absolutely possible with Check Writer Program with its innovative and lucrative advantageous features.

for more info visit: http://www.checkwriterprogram.com

Flipping Houses – DiscountedProperties.com

Thu, 11 Sep 2008 19:52:45 -0700

Flipping Houses and Wholesale Property listings. DiscountedProperties.com offers fixer upper homes, rehab homes, and homes for sale by owner for real estate investors.

MyVocal

Thu, 11 Sep 2008 04:59:54 -0700

Investment Property - DiscountedProperties.com

Thu, 11 Sep 2008 01:06:37 -0700

Investment Property and Fixer Upper Homes listings. DiscountedProperties.com is a unique real estate investment property listing service offering Investment Property for sale. http://www.discountedproperties.com

Extensions for Joomla!

Thu, 11 Sep 2008 00:59:27 -0700

Joomlaspan - Home of free Joomla Extensions and other resources

Grok-by-Example: Wiki

Sat, 30 Aug 2008 04:51:55 -0700

install_requires=['setuptools', 'grok', ... 'megrok.tinymce', ],

GAE uses the webapp.WSGIApplication and already configures the URL dispatching as a wildcard pattern:

class WikiPage(grok.Application, grok.Container): ... def traverse(self, page_name=default_page_name): ...

While GAE webapp.RequestHandler classes understand HTTP methods and dispatch accordingly, Grok uses grok.View classes that ‘render’ the representation of the current context object.

Here both frameworks use templating to render the context object and return the result.

class BaseRequestHandler(webapp.RequestHandler): def generate(self, template_name, template_values={}): ... self.response.out.write(template.render(path, values, debug=_DEBUG))

In this example GAE uses the low-level ‘datastore’ API to store and retrieve Page objects to and from the appengine datastore: def load(name): query = datastore.Query('Page') ...

def save(self): datastore.Put(entity)

def dc(self): return IZopeDublinCore(self.context)

GAE uses the appengine ‘users’ API to handle the posting of new or editing existing wiki pages. The user must be logged in with her google account: def post(self, page_name): if not users.get_current_user(): self.redirect(users.create_login_url(self.request.uri)) ...

class WikiPage(grok.Application, grok.Container): grok.local_utility(PluggableAuthentication, IAuthentication, setup=setup_pau_principal)

class PermissionEditPage(grok.Permission): grok.name('wiki.EditPage')

class PermissionAddPage(grok.Permission): grok.name('wiki.AddPage')

permission_mngr = IPrincipalPermissionManager(grok.getSite()) permission_mngr.grantPermissionToPrincipal( 'wiki.AddPage', principals.prefix + login) permission_mngr.grantPermissionToPrincipal( 'wiki.EditPage', principals.prefix + login)

class Login(Master): def update(self, login_submit=None): ...

Before returning the rendered Page (@@index view) to the user, the page content gets wikified. In our example a list of transformations is applied to the ‘content’ by adapting the view object itself: class Index(Master):

def wikified_content(self): self.content = self.context.content ...

transforms = [ 'wiki.AutoLink', 'wiki.ListOfPages', 'wiki.WikiWords', ]

for transform in transforms: self.content = getAdapter(self, ITransform, transform).run() return self.content

class ITransform(Interface): pass

class WikiWords(grok.Adapter): grok.implements(ITransform) grok.name('wiki.WikiWords') grok.context(grok.View) ...

Several actions return a feedback message to the user which is displayed above the content on the next response page.

Porting this application took quite some time (about 1 day), mostly because of implementing the user management (again) and getting megrok.tinymce working. The wiki app is usable as is and also works fine when used inside an existing grok application. Transformation/Wikification of page contents through adapters could easily be made into a plugin-like configuration (using a distinct admin form). Also the renderer (TinyMCE and HTML) could be pluggable replaced by a RestructuredText based engine.

Grok-by-Example

Thu, 28 Aug 2008 17:57:22 -0700

Motivation is that you can look at the original source and the grok code side-by-side and deduce from both. Source is available from

Grok-by-Example: Guestbook

Thu, 28 Aug 2008 17:57:21 -0700

Both frameworks use the ‘Application’ concept. Grok subclasses from both grok.Application and grok.Container: class Application(grok.Application, grok.Container): pass

application = webapp.WSGIApplication([ ('/', MainPage), ('/sign', Guestbook) ], debug=True)

The application accepts 2 possible requests: the default view and the action to post the form contents to.

class MainPage(grok.View): grok.context(Application) grok.name('index') ...

class MainPage(webapp.RequestHandler): def get(self): ...

Grok has a ‘grok.REST’ class that supports HTTP method dispatching, but it is not used in the example: class Guestbook(grok.View): ... def render(self): if self.request.method.upper() != 'POST': return self.redirect(self.application_url()) ...

class Guestbook(webapp.RequestHandler): def post(self): ...

Grok output is collected and returned from the view ‘render’ method: def render(self): out=['<html><body>'] ... return ''.join(out)

Grok content objects are subclassed from grok.Model. Properties are defined in an Interface class which the object implements: class IGreeting(Interface): author = schema.Field(title=u'Author') ...

class Greeting(grok.Model): grok.implements(IGreeting)

class Greeting(db.Model): author = db.UserProperty()

Grok content objects are instantiated, modified and finally inserted into a container (which here is the application object itself). A local-unique name must be provided on insertion. Existing objects must be deleted and reinserted. Properties are not validated by default: id=str(uuid.uuid4()) self.context[id]=greeting

Grok uses python to locate objects and create a result listing: greetings=[(x.date, x) for x in self.context.values()] greetings=list(reversed(sorted(greetings))) for date,greeting in greetings[:10]: ...

greetings = db.GqlQuery("SELECT * " "FROM Greeting " "ORDER BY date DESC LIMIT 10") for greeting in greetings: ...

Grok has no fixed ‘user’ API, user management depends on loaded authentication plugins: greeting.author = self.request.principal ... if IUnauthenticatedPrincipal.providedBy(greeting.author): ...

if users.get_current_user(): greeting.author = users.get_current_user() ... if greeting.author: ...

Grok is a long-running process. Requests are processed, the object graph is traversed to a final context object and the result of calling the view on the context object is returned.

def main(): wsgiref.handlers.CGIHandler().run(application)

The number of lines of code is about the same. For this small example GAE is simpler with respect to the number of APIs and concepts used and richer with respect to debugging and datasecurity.

Grok-by-Example: 99 Bottles

Thu, 28 Aug 2008 17:57:20 -0700

When we create the ‘Song’ Application object, we want to set it to an initial state, like creating a Wall, creating a number of Bottles and adding them to the Wall.

@grok.subscribe(Song, grok.IObjectAddedEvent) def handle(obj, event): obj['wall']=wall=Wall() wall.add_99_bottles()

The application accepts only one distinct request: the default view.

class Index(grok.View): grok.context(Song)

The view classes are created and called for each Request. The ‘update’ and ‘render’ methods are essential parts of rendering a Response from a view class.

def update(self): self.wall=self.context['wall']

Grok content objects are subclassed from grok.Model or grok.Container. class Bottle(grok.Model): pass

class Wall(grok.Container): ...

class Song(grok.Application,grok.Container): pass

When a Response is created by the view class, Bottle objects are removed from and added to the Wall container by calling methods of the Wall instance object: def remove_a_bottle(self): bottles=list(self.keys()) del self[bottles[-1]]

def add_99_bottles(self): for n in range(1,100): self[str(n)]=Bottle()

The objects can simply be queried using python: def contents(self): return len(self.items())

A functional doctest (’app.txt’) is added to ensure correct operations.

It was fun and easy to implement the ‘99 Bottles’ Song using persistent objects. Functional testing made development even simpler.

Mac OSX Software - MultiFirefox 2.0 | Code Contortionist

Thu, 24 Jul 2008 01:51:41 -0700

Complete Hibernate Tutorial, HibernateStep by Step with Code Example ,Hibernate A to Z, download the code and test your self

Tue, 08 Jul 2008 02:48:05 -0700

Git merging by example

Wed, 18 Jun 2008 06:17:58 -0700

Beryl Cook Prints

Fri, 06 Jun 2008 04:53:47 -0700

Buy some of the most sought-after Beryl Cook prints available on the Web. We have fantastic Beryl Cook prints from throughout her career.

Beryl Cook Art

Wed, 04 Jun 2008 13:50:38 -0700

Buy Beryl Cook art from BerylCookUK.com. Our selection includes some of the most sought-after Beryl Cook works available on the Web.