Ticket #575: patch-server-575-A0.diff

docs/framework/index.txt

@@ -40 +40 @@
    webservice
    customizing-webservices
    spatial-databases
+   upgrading
 
 
 -----------
 
-`API References <../reference/index.html#server>`_
- No newline at end of file
+`API References <../reference/index.html#server>`_

(a) /dev/null vs. (b) docs/framework/upgrading.txt

@@ +1 @@
+Upgrading
+---------
+
+This section provides information for upgrading a MapFish application from
+MapFish 1.2 to MapFish 2.0
+
+Pylons 1.0
+~~~~~~~~~~
+
+MapFish 1.2 is based on Pylons 0.9.7, and MapFish 2.0 is based on Pylons 1.0.
+So to upgrade an application from MapFish 1.2 to MapFish 2.0 it is first needed
+to upgrade from Pylons 0.9.7 to Pylons 1.0. For this refer to the `Pylons 1.0
+Upgrading page <http://pylonshq.com/docs/en/1.0/upgrading/>`_, and follow the
+provided indications.
+
+.. note:
+    MapFish 2.0 depending on Pylons 1.0, you will run into dependency issues if
+    you attempt to upgrade to Pylons 0.10. So it is recommended not to attempt
+    it.
+
+The Pylons 1.0 Uprading page doesn't include information for upgrading
+the model and base controller. Here's additional information:
+
+* The ``model.meta`` module no longer stores reference to the ``engine`` and
+  ``metadata`` objects. Edit ``model/meta.py`` and remove these files::
+  
+      from sqlalchemy import MetaData
+      engine = None
+      metadata = MetaData()
+
+* The ``model.meta`` module now creates the ``scoped session`` and the
+  SQLAlchemy ``declarative base`` class. Edit ``model/meta.py``, replace the
+  ``Session = None`` line with::
+    
+      Session = scoped_session(sessionmaker())
+
+  and add the following line at the end of the file::
+
+      Base = declarative_base()
+
+* The ``init_model`` function of the ``model`` module is no longer responsible
+  for creating the ``Session``. Edit ``model/__init__.py`` and remove these
+  three lines from the body of the ``init_model`` function::
+
+      sm = orm.sessionmaker(autoflush=True, autocommit=False, bind=engine)
+      meta.engine = engine
+      meta.Session = orm.scoped_session(sm)
+
+  The ``init_model`` function now just configures the (already-created)
+  Session. Add the following statement to the body of ``init_model``::
+
+      Session.configure(bind=engine)
+
+The application should now be upgraded to Pylons 1.0, and it is now time to do
+MapFish-specific adjusments.
+
+MapFish 2.0
+~~~~~~~~~~~
+
+MapFish 2.0 is based on `GeoAlchemy <http://geoalchemy.org>`_. GeoAlchemy
+provides extensions to SQLAlchemy for use with spatial databases. MapFish 2.0
+no longer defines the ``Geometry`` type, the one defined by GeoAlchemy is to be
+used instead.
+
+With MapFish 1.2 the ``paster mf-layer`` command generated model files that
+looked like this::
+
+    from sqlalchemy import Column, Table, types
+    from sqlalchemy.orm import mapper
+
+    from mapfish.sqlalchemygeom import Geometry
+    from mapfish.sqlalchemygeom import GeometryTableMixIn
+
+    from blonay.model.meta import metadata, engine
+
+    users_table = Table(
+        'users', metadata,
+        Column('the_geom', Geometry(4326)),
+        schema='my_schema',
+        autoload=True, autoload_with=engine)
+
+    class User(GeometryTableMixIn):
+        # for GeometryTableMixIn to do its job the __table__ property
+        # must be set here
+        __table__ = users_table
+
+    mapper(User, users_table)
+
+With MapFish 2.0 the same ``user`` model looks like this::
+
+    from sqlalchemy import Column, types
+
+    from geoalchemy import GeometryColumn, Point
+
+    from mapfish.sqlalchemygeom import GeometryTableMixIn
+    from sample.model.meta import Session, Base
+
+    class User(Base, GeometryTableMixIn):
+        __tablename__ = 'users'
+        __table_args__ = {
+            "schema": 'my_schema',
+            "autoload": True,
+            "autoload_with": Session.bind
+        }
+        the_geom = GeometryColumn(Point(dimension=2, srid=4326))

mapfish/templates/controller.py_tmpl

@@ -1 +1 @@
 from pylons import request, response, session, tmpl_context as c
-from pylons.controllers.util import abort, redirect_to
+from pylons.controllers.util import abort, redirect
 
 from {{basePkg}}.lib.base import BaseController
 from {{basePkg}}.model.{{modName}} import {{modelClass}}

mapfish/templates/model.py_tmpl

@@ -3 +3 @@
 from geoalchemy import GeometryColumn, {{geomType}}
 
 from mapfish.sqlalchemygeom import GeometryTableMixIn
-from {{basePkg}}.model.meta import engine, Base
+from {{basePkg}}.model.meta import Session, Base
 
 class {{modelClass}}(Base, GeometryTableMixIn):
     __tablename__ = '{{table}}'
@@ -12 +12 @@
         "schema": '{{schema}}',
     {{endif}}
         "autoload": True,
-        "autoload_with": engine
+        "autoload_with": Session.bind
     }
     {{geomColName}} = GeometryColumn({{geomType}}(dimension=2, srid={{epsg}}))

(a) mapfish/templates/project/+package+/model/__init__.py_tmpl vs. (b) /dev/null

@@ -1 @@
-{{if sqlalchemy}}
-"""The application's model objects"""
-import sqlalchemy as sa
-from sqlalchemy import orm
-
-from {{package}}.model import meta
-
-def init_model(engine):
-    """Call me before using any of the tables or classes in the model"""
-    ## Reflected tables must be defined and mapped here
-    #global reflected_table
-    #reflected_table = sa.Table("Reflected", meta.metadata, autoload=True,
-    #                           autoload_with=engine)
-    #orm.mapper(Reflected, reflected_table)
-
-    sm = orm.sessionmaker(autoflush=True, autocommit=False, bind=engine)
-
-    meta.engine = engine
-    meta.Session = orm.scoped_session(sm)
-
-
-## Non-reflected tables may be defined and mapped at module level
-#foo_table = sa.Table("Foo", meta.metadata,
-#    sa.Column("id", sa.types.Integer, primary_key=True),
-#    sa.Column("bar", sa.types.String(255), nullable=False),
-#    )
-#
-#class Foo(object):
-#    pass
-#
-#orm.mapper(Foo, foo_table)
-
-
-## Classes for reflected tables may be defined here, but the table and
-## mapping itself must be done in the init_model function
-#reflected_table = None
-#
-#class Reflected(object):
-#    pass
-{{endif}}

(a) mapfish/templates/project/+package+/model/meta.py_tmpl vs. (b) /dev/null

@@ -1 @@
-{{if sqlalchemy}}
-"""SQLAlchemy Metadata and Session object"""
-from sqlalchemy import MetaData
-from sqlalchemy.orm import scoped_session, sessionmaker
-from sqlalchemy.ext.declarative import declarative_base
-
-__all__ = ['Session', 'engine', 'metadata', 'Base']
-
-# SQLAlchemy database engine. Updated by model.init_model()
-engine = None
-
-# SQLAlchemy session manager. Updated by model.init_model()
-Session = scoped_session(sessionmaker())
-
-# Global metadata. If you have multiple databases with overlapping table
-# names, you'll need a metadata for each database
-metadata = MetaData()
-
-# The base class for declarative mappings
-Base = declarative_base(metadata=metadata)
-{{endif}}

mapfish/templates/test_controller.py_tmpl

@@ -2 +2 @@
 
 class Test{{contrClass}}Controller(TestController):
     def test_index(self):
-        response = self.app.get(url_for(controller='{{fullModName}}'))
+        response = self.app.get(url(controller='{{fullModName}}'))
         # Test response...