recursive-include vigigraph/public *

include vigigraph/public/favicon.ico

recursive-include vigigraph/i18n *

recursive-include vigigraph/templates *

NAME := vigigraph

include ../glue/Makefile.common

all: build

MODULE := $(NAME)

CODEPATH := $(NAME)

lint: lint_pylint

tests: tests_tg

This file is for you to describe the vigigraph application. Typically

you would include information such as the information below:

Installation and Setup

======================

Install ``vigigraph`` using the setup.py script::

    $ cd vigigraph

    $ python setup.py install

Create the project database for any model classes defined::

    $ paster setup-app development.ini

Start the paste http server::

    $ paster serve development.ini

While developing you may want the server to reload after changes in package files (or its dependencies) are saved. This can be achieved easily by adding the --reload option::

    $ paster serve --reload development.ini

Then you are ready to go.

[buildout]

extends = ../glue/buildout.cfg

eggs += vigigraph

# vim: set noexpandtab :

#

# vigigraph - Pylons development environment configuration

#

# The %(here)s variable will be replaced with the parent directory of this file

#

# This file is for deployment specific config options -- other configuration

# that is always required for the app is done in the config directory, 

# and generally should not be modified by end users. 

[DEFAULT]

debug = true

# Uncomment and replace with the address which should receive any error reports

#email_to = you@yourdomain.com

smtp_server = localhost

error_email_from = paste@localhost

[server:main]

use = egg:Paste#http

host = 127.0.0.1 

port = 8080

[app:main]

use = egg:vigigraph

full_stack = true

#lang = ru

cache_dir = %(here)s/data

beaker.session.key = vigigraph

beaker.session.secret = somesecret

# If you'd like to fine-tune the individual locations of the cache data dirs

# for the Cache data, or the Session saves, un-comment the desired settings

# here:

#beaker.cache.data_dir = %(here)s/data/cache

#beaker.session.data_dir = %(here)s/data/sessions

# pick the form for your database

# %(here) may include a ':' character on Windows environments; this can

# invalidate the URI when specifying a SQLite db via path name

# sqlalchemy.url=postgres://username:password@hostname:port/databasename 

# sqlalchemy.url=mysql://username:password@hostname:port/databasename

# If you have sqlite, here's a simple default to get you started

# in development

sqlalchemy.url = sqlite:///%(here)s/devdata.db

#echo shouldn't be used together with the logging module.

sqlalchemy.echo = false

sqlalchemy.echo_pool = false

sqlalchemy.pool_recycle = 3600

# if you are using Mako and want to be able to reload

# the mako template from disk during the development phase

# you should say 'true' here

# This option is only used for mako templating engine

# WARNING: if you want to deploy your application using a zipped egg

# (ie: if your application's setup.py defines zip-safe=True, then you

# MUST put "false" for the production environment because there will

# be no disk and real files to compare time with.

# On the contrary if your application defines zip-safe=False and is

# deployed in an unzipped manner, then you can leave this option to true

templating.mako.reloadfromdisk = true

# the compiled template dir is a directory that must be readable by your

# webserver. It will be used to store the resulting templates once compiled

# by the TemplateLookup system.

# During development you generally don't need this option since paste's HTTP

# server will have access to you development directories, but in production

# you'll most certainly want to have apache or nginx to write in a directory

# that does not contain any source code in any form for obvious security reasons.

#

#templating.mako.compiled_templates_dir = /some/dir/where/webserver/has/access

# WARNING: *THE LINE BELOW MUST BE UNCOMMENTED ON A PRODUCTION ENVIRONMENT*

# Debug mode will enable the interactive debugging tool, allowing ANYONE to

# execute malicious code after an exception is raised.

#set debug = false

# Logging configuration

# Add additional loggers, handlers, formatters here

# Uses python's logging config file format

# http://docs.python.org/lib/logging-config-fileformat.html

[loggers]

keys = root, vigigraph, sqlalchemy, auth

[handlers]

keys = console

[formatters]

keys = generic

# If you create additional loggers, add them as a key to [loggers]

[logger_root]

level = INFO

handlers = console

[logger_vigigraph]

level = DEBUG

handlers =

qualname = vigigraph

[logger_sqlalchemy]

level = INFO

handlers =

qualname = sqlalchemy.engine

# "level = INFO" logs SQL queries.

# "level = DEBUG" logs SQL queries and results.

# "level = WARN" logs neither.  (Recommended for production systems.)

# A logger for authentication, identification and authorization -- this is

# repoze.who and repoze.what:

[logger_auth]

level = WARN

handlers = 

qualname = auth

# If you create additional handlers, add them as a key to [handlers]

[handler_console]

class = StreamHandler

args = (sys.stderr,)

level = NOTSET

formatter = generic

# If you create additional formatters, add them as a key to [formatters]

[formatter_generic]

format = %(asctime)s,%(msecs)03d %(levelname)-5.5s [%(name)s] %(message)s

datefmt = %H:%M:%S

This directory exists so that Subversion-based projects can share a single

copy of the ``ez_setup`` bootstrap module for ``setuptools``, and have it

automatically updated in their projects when ``setuptools`` is updated.

For your convenience, you may use the following svn:externals definition::

    ez_setup svn://svn.eby-sarna.com/svnroot/ez_setup

You can set this by executing this command in your project directory::

    svn propedit svn:externals .

And then adding the line shown above to the file that comes up for editing.

Then, whenever you update your project, ``ez_setup`` will be updated as well.

#!python

"""Bootstrap setuptools installation

If you want to use setuptools in your package's setup.py, just include this

file in the same directory with it, and add this to the top of your setup.py::

    from ez_setup import use_setuptools

    use_setuptools()

If you want to require a specific version of setuptools, set a download

mirror, or use an alternate download directory, you can do so by supplying

the appropriate options to ``use_setuptools()``.

This file can also be run as a script to install or upgrade setuptools.

"""

import sys

DEFAULT_VERSION = "0.6c7"

DEFAULT_URL     = "http://pypi.python.org/packages/%s/s/setuptools/" % sys.version[:3]

md5_data = {

    'setuptools-0.6b1-py2.3.egg': '8822caf901250d848b996b7f25c6e6ca',

    'setuptools-0.6b1-py2.4.egg': 'b79a8a403e4502fbb85ee3f1941735cb',

    'setuptools-0.6b2-py2.3.egg': '5657759d8a6d8fc44070a9d07272d99b',

    'setuptools-0.6b2-py2.4.egg': '4996a8d169d2be661fa32a6e52e4f82a',

    'setuptools-0.6b3-py2.3.egg': 'bb31c0fc7399a63579975cad9f5a0618',

    'setuptools-0.6b3-py2.4.egg': '38a8c6b3d6ecd22247f179f7da669fac',

    'setuptools-0.6b4-py2.3.egg': '62045a24ed4e1ebc77fe039aa4e6f7e5',

    'setuptools-0.6b4-py2.4.egg': '4cb2a185d228dacffb2d17f103b3b1c4',

    'setuptools-0.6c1-py2.3.egg': 'b3f2b5539d65cb7f74ad79127f1a908c',

    'setuptools-0.6c1-py2.4.egg': 'b45adeda0667d2d2ffe14009364f2a4b',

    'setuptools-0.6c2-py2.3.egg': 'f0064bf6aa2b7d0f3ba0b43f20817c27',

    'setuptools-0.6c2-py2.4.egg': '616192eec35f47e8ea16cd6a122b7277',

    'setuptools-0.6c3-py2.3.egg': 'f181fa125dfe85a259c9cd6f1d7b78fa',

    'setuptools-0.6c3-py2.4.egg': 'e0ed74682c998bfb73bf803a50e7b71e',

    'setuptools-0.6c3-py2.5.egg': 'abef16fdd61955514841c7c6bd98965e',

    'setuptools-0.6c4-py2.3.egg': 'b0b9131acab32022bfac7f44c5d7971f',

    'setuptools-0.6c4-py2.4.egg': '2a1f9656d4fbf3c97bf946c0a124e6e2',

    'setuptools-0.6c4-py2.5.egg': '8f5a052e32cdb9c72bcf4b5526f28afc',

    'setuptools-0.6c5-py2.3.egg': 'ee9fd80965da04f2f3e6b3576e9d8167',

    'setuptools-0.6c5-py2.4.egg': 'afe2adf1c01701ee841761f5bcd8aa64',

    'setuptools-0.6c5-py2.5.egg': 'a8d3f61494ccaa8714dfed37bccd3d5d',

    'setuptools-0.6c6-py2.3.egg': '35686b78116a668847237b69d549ec20',

    'setuptools-0.6c6-py2.4.egg': '3c56af57be3225019260a644430065ab',

    'setuptools-0.6c6-py2.5.egg': 'b2f8a7520709a5b34f80946de5f02f53',

    'setuptools-0.6c7-py2.3.egg': '209fdf9adc3a615e5115b725658e13e2',

    'setuptools-0.6c7-py2.4.egg': '5a8f954807d46a0fb67cf1f26c55a82e',

    'setuptools-0.6c7-py2.5.egg': '45d2ad28f9750e7434111fde831e8372',

}

import sys, os

def _validate_md5(egg_name, data):

    if egg_name in md5_data:

        from md5 import md5

        digest = md5(data).hexdigest()

        if digest != md5_data[egg_name]:

            print >>sys.stderr, (

                "md5 validation of %s failed!  (Possible download problem?)"

                % egg_name

            )

            sys.exit(2)

    return data

def use_setuptools(

    version=DEFAULT_VERSION, download_base=DEFAULT_URL, to_dir=os.curdir,

    download_delay=15

):

    """Automatically find/download setuptools and make it available on sys.path

    `version` should be a valid setuptools version number that is available

    as an egg for download under the `download_base` URL (which should end with

    a '/').  `to_dir` is the directory where setuptools will be downloaded, if

    it is not already available.  If `download_delay` is specified, it should

    be the number of seconds that will be paused before initiating a download,

    should one be required.  If an older version of setuptools is installed,

    this routine will print a message to ``sys.stderr`` and raise SystemExit in

    an attempt to abort the calling script.

    """

    try:

        import setuptools

        if setuptools.__version__ == '0.0.1':

            print >>sys.stderr, (

            "You have an obsolete version of setuptools installed.  Please\n"

            "remove it from your system entirely before rerunning this script."

            )

            sys.exit(2)

    except ImportError:

        egg = download_setuptools(version, download_base, to_dir, download_delay)

        sys.path.insert(0, egg)

        import setuptools; setuptools.bootstrap_install_from = egg

    import pkg_resources

    try:

        pkg_resources.require("setuptools>="+version)

    except pkg_resources.VersionConflict, e:

        # XXX could we install in a subprocess here?

        print >>sys.stderr, (

            "The required version of setuptools (>=%s) is not available, and\n"

            "can't be installed while this script is running. Please install\n"

            " a more recent version first.\n\n(Currently using %r)"

        ) % (version, e.args[0])

        sys.exit(2)

def download_setuptools(

    version=DEFAULT_VERSION, download_base=DEFAULT_URL, to_dir=os.curdir,

    delay = 15

):

    """Download setuptools from a specified location and return its filename

    `version` should be a valid setuptools version number that is available

    as an egg for download under the `download_base` URL (which should end

    with a '/'). `to_dir` is the directory where the egg will be downloaded.

    `delay` is the number of seconds to pause before an actual download attempt.

    """

    import urllib2, shutil

    egg_name = "setuptools-%s-py%s.egg" % (version,sys.version[:3])

    url = download_base + egg_name

    saveto = os.path.join(to_dir, egg_name)

    src = dst = None

    if not os.path.exists(saveto):  # Avoid repeated downloads

        try:

            from distutils import log

            if delay:

                log.warn("""

---------------------------------------------------------------------------

This script requires setuptools version %s to run (even to display

help).  I will attempt to download it for you (from

%s), but

you may need to enable firewall access for this script first.

I will start the download in %d seconds.

(Note: if this machine does not have network access, please obtain the file

   %s

and place it in this directory before rerunning this script.)

---------------------------------------------------------------------------""",

                    version, download_base, delay, url

                ); from time import sleep; sleep(delay)

            log.warn("Downloading %s", url)

            src = urllib2.urlopen(url)

            # Read/write all in one block, so we don't create a corrupt file

            # if the download is interrupted.

            data = _validate_md5(egg_name, src.read())

            dst = open(saveto,"wb"); dst.write(data)

        finally:

            if src: src.close()

            if dst: dst.close()

    return os.path.realpath(saveto)

def main(argv, version=DEFAULT_VERSION):

    """Install or upgrade setuptools and EasyInstall"""

    try:

        import setuptools

    except ImportError:

        egg = None

        try:

            egg = download_setuptools(version, delay=0)

            sys.path.insert(0,egg)

            from setuptools.command.easy_install import main

            return main(list(argv)+[egg])   # we're done here

        finally:

            if egg and os.path.exists(egg):

                os.unlink(egg)

    else:

        if setuptools.__version__ == '0.0.1':

            # tell the user to uninstall obsolete version

            use_setuptools(version)

    req = "setuptools>="+version

    import pkg_resources

    try:

        pkg_resources.require(req)

    except pkg_resources.VersionConflict:

        try:

            from setuptools.command.easy_install import main

        except ImportError:

            from easy_install import main

        main(list(argv)+[download_setuptools(delay=0)])

        sys.exit(0) # try to force an exit

    else:

        if argv:

            from setuptools.command.easy_install import main

            main(argv)

        else:

            print "Setuptools version",version,"or greater has been installed."

            print '(Run "ez_setup.py -U setuptools" to reinstall or upgrade.)'

def update_md5(filenames):

    """Update our built-in md5 registry"""

    import re

    from md5 import md5

    for name in filenames:

        base = os.path.basename(name)

        f = open(name,'rb')

        md5_data[base] = md5(f.read()).hexdigest()

        f.close()

    data = ["    %r: %r,\n" % it for it in md5_data.items()]

    data.sort()

    repl = "".join(data)

    import inspect

    srcfile = inspect.getsourcefile(sys.modules[__name__])

    f = open(srcfile, 'rb'); src = f.read(); f.close()

    match = re.search("\nmd5_data = {\n([^}]+)}", src)

    if not match:

        print >>sys.stderr, "Internal error!"

        sys.exit(2)

    src = src[:match.start(1)] + repl + src[match.end(1):]

    f = open(srcfile,'w')

    f.write(src)

    f.close()

if __name__=='__main__':

    if len(sys.argv)>2 and sys.argv[1]=='--md5update':

        update_md5(sys.argv[2:])

    else:

        main(sys.argv[1:])

[egg_info]

tag_build = dev

tag_svn_revision = true

[easy_install]

find_links = http://vigilo-dev.si.c-s.fr/python/eggs

allow_hosts = *.si.c-s.fr

#find_links = http://www.pylonshq.com/download/

[nosetests]

with-pylons=test.ini

# Babel configuration

[compile_catalog]

domain = vigigraph

directory = vigigraph/i18n

statistics = true

[extract_messages]

add_comments = TRANSLATORS:

msgid_bugs_address = contact@projet-vigilo.org

output_file = vigigraph/i18n/vigigraph.pot

width = 80

keywords = l_

[init_catalog]

domain = vigigraph

input_file = vigigraph/i18n/vigigraph.pot

output_dir = vigigraph/i18n

[update_catalog]

domain = vigigraph

input_file = vigigraph/i18n/vigigraph.pot

output_dir = vigigraph/i18n

previous = true

# -*- coding: utf-8 -*-

try:

    from setuptools import setup, find_packages

except ImportError:

    from ez_setup import use_setuptools

    use_setuptools()

    from setuptools import setup, find_packages

setup(

    name='vigigraph',

    version='0.1',

    description='',

    author='',

    author_email='',

    #url='',

    install_requires=[

        "TurboGears2 >= 2.0b7",

        "Catwalk >= 2.0.2",

        "Babel >=0.9.4",

        #can be removed iif use_toscawidgets = False

        "toscawidgets >= 0.9.7.1",

        "zope.sqlalchemy >= 0.4 ",

        "repoze.tm2 >= 1.0a4",

        "repoze.what-quickstart >= 1.0",

                ],

    paster_plugins=['PasteScript', 'Pylons', 'TurboGears2', 'tg.devtools'],

    packages=find_packages(exclude=['ez_setup']),

    include_package_data=True,

    test_suite='nose.collector',

    tests_require=['WebTest', 'BeautifulSoup'],

    package_data={'vigigraph': ['i18n/*/LC_MESSAGES/*.mo',

                                 'templates/*/*',

                                 'public/*/*']},

    message_extractors={'vigigraph': [

            ('**.py', 'python', None),

            ('templates/**.mako', 'mako', None),

            ('templates/**.html', 'genshi', None),

            ('public/**', 'ignore', None)]},

    entry_points="""

    [paste.app_factory]

    main = vigigraph.config.middleware:make_app

    [paste.app_install]

    main = pylons.util:PylonsInstaller

    """,

)

#

# vigigraph - TurboGears 2 testing environment configuration

#

# The %(here)s variable will be replaced with the parent directory of this file

#

[DEFAULT]

debug = true

# Uncomment and replace with the address which should receive any error reports

# email_to = you@yourdomain.com

smtp_server = localhost

error_email_from = paste@localhost

[server:main]

use = egg:Paste#http

host = 0.0.0.0

port = 5000

[app:main]

sqlalchemy.url = sqlite:///:memory:

use = config:development.ini

[app:main_without_authn]

use = main

skip_authentication = True

# Add additional test specific configuration options as necessary.

# -*- coding: utf-8 -*-

"""The vigigraph package"""

# -*- coding: utf-8 -*-

# -*- coding: utf-8 -*-

"""

Global configuration file for TG2-specific settings in vigigraph.

This file complements development/deployment.ini.

Please note that **all the argument values are strings**. If you want to

convert them into boolean, for example, you should use the

:func:`paste.deploy.converters.asbool` function, as in::

    from paste.deploy.converters import asbool

    setting = asbool(global_conf.get('the_setting'))

"""

from tg.configuration import AppConfig

import vigigraph

from vigigraph import model

from vigigraph.lib import app_globals, helpers 

base_config = AppConfig()

base_config.renderers = []

base_config.package = vigigraph

#Set the default renderer

base_config.default_renderer = 'genshi'

base_config.renderers.append('genshi')

# if you want raw speed and have installed chameleon.genshi

# you should try to use this renderer instead.

# warning: for the moment chameleon does not handle i18n translations

#base_config.renderers.append('chameleon_genshi')

#Configure the base SQLALchemy Setup

base_config.use_sqlalchemy = True

base_config.model = vigigraph.model

base_config.DBSession = vigigraph.model.DBSession

# Configure the authentication backend

base_config.auth_backend = 'sqlalchemy'

base_config.sa_auth.dbsession = model.DBSession

# what is the class you want to use to search for users in the database

base_config.sa_auth.user_class = model.User

# what is the class you want to use to search for groups in the database

base_config.sa_auth.group_class = model.Group

# what is the class you want to use to search for permissions in the database

base_config.sa_auth.permission_class = model.Permission

# override this if you would like to provide a different who plugin for

# managing login and logout of your application

base_config.sa_auth.form_plugin = None

# You may optionally define a page where you want users to be redirected to

# on login:

base_config.sa_auth.post_login_url = '/post_login'

# You may optionally define a page where you want users to be redirected to

# on logout:

base_config.sa_auth.post_logout_url = '/post_logout'

#

# vigigraph - TurboGears configuration

#

# The %(here)s variable will be replaced with the parent directory of this file

#

[DEFAULT]

# WARGING == If debug is not set to false, you'll get the interactive

# debugger on production, which is a huge security hole. 

debug = false

email_to = you@yourdomain.com

smtp_server = localhost

error_email_from = paste@localhost

[server:main]

use = egg:Paste#http

host = 0.0.0.0

port = 8080

[app:main]

use = egg:vigigraph

full_stack = true

cache_dir = %(here)s/data

beaker.session.key = vigigraph

beaker.session.secret = ${app_instance_secret}

app_instance_uuid = ${app_instance_uuid}

# If you'd like to fine-tune the individual locations of the cache data dirs

# for the Cache data, or the Session saves, un-comment the desired settings

# here:

#beaker.cache.data_dir = %(here)s/data/cache

#beaker.session.data_dir = %(here)s/data/sessions

# Specify the database for SQLAlchemy to use via

# turbogears.database

# %(here) may include a ':' character on Windows environments; this can

# invalidate the URI when specifying a SQLite db via path name

sqlalchemy.url = sqlite:///%(here)s/somedb.db

sqlalchemy.echo = False

# WARNING: *THE LINE BELOW MUST BE UNCOMMENTED ON A PRODUCTION ENVIRONMENT*

# Debug mode will enable the interactive debugging tool, allowing ANYONE to

# execute malicious code after an exception is raised.

#set debug = false

# Logging configuration

# Add additional loggers, handlers, formatters here

# Uses python's logging config file format

# http://docs.python.org/lib/logging-config-fileformat.html

[loggers]

keys = root, vigigraph, sqlalchemy, auth

[handlers]

keys = console

[formatters]

keys = generic

# If you create additional loggers, add them as a key to [loggers]

[logger_root]

level = INFO

handlers = console

[logger_vigigraph]

level = INFO

handlers =

qualname = vigigraph

[logger_sqlalchemy]

level = WARN

handlers =

qualname = sqlalchemy.engine

# "level = INFO" logs SQL queries.

# "level = DEBUG" logs SQL queries and results.

# "level = WARN" logs neither.  (Recommended for production systems.)

# A logger for authentication, identification and authorization -- this is

# repoze.who and repoze.what:

[logger_auth]

level = WARN

handlers = 

qualname = auth

# If you create additional handlers, add them as a key to [handlers]

[handler_console]

class = StreamHandler

args = (sys.stderr,)

level = NOTSET

formatter = generic

# If you create additional formatters, add them as a key to [formatters]

[formatter_generic]

format = %(asctime)s,%(msecs)03d %(levelname)-5.5s [%(name)s] %(message)s

datefmt = %H:%M:%S

# -*- coding: utf-8 -*-

"""WSGI environment setup for vigigraph."""

from vigigraph.config.app_cfg import base_config

__all__ = ['load_environment']

#Use base_config to setup the environment loader function

load_environment = base_config.make_load_environment()

# -*- coding: utf-8 -*-

"""WSGI middleware initialization for the vigigraph application."""

from vigigraph.config.app_cfg import base_config

from vigigraph.config.environment import load_environment

__all__ = ['make_app']

# Use base_config to setup the necessary PasteDeploy application factory. 

# make_base_app will wrap the TG2 app with all the middleware it needs. 

make_base_app = base_config.setup_tg_wsgi_app(load_environment)

def make_app(global_conf, full_stack=True, **app_conf):

    """

    Set vigigraph up with the settings found in the PasteDeploy configuration

    file used.

    :param global_conf: The global settings for vigigraph (those

        defined under the ``[DEFAULT]`` section).

    :type global_conf: dict

    :param full_stack: Should the whole TG2 stack be set up?

    :type full_stack: str or bool

    :return: The vigigraph application with all the relevant middleware

        loaded.

    This is the PasteDeploy factory for the vigigraph application.

    ``app_conf`` contains all the application-specific settings (those defined

    under ``[app:main]``.

    """

    app = make_base_app(global_conf, full_stack=True, **app_conf)

    # Wrap your base TurboGears 2 application with custom middleware here

    return app

# -*- coding: utf-8 -*-

"""Controllers for the vigigraph application."""

# -*- coding: utf-8 -*-

"""Sample controller module"""

# turbogears imports

from tg import expose

#from tg import redirect, validate, flash

# third party imports

#from pylons.i18n import ugettext as _

#from repoze.what import predicates

# project specific imports

from vigigraph.lib.base import BaseController

#from vigigraph.model import DBSession, metadata

class SampleController(BaseController):

    #Uncomment this line if your controller requires an authenticated user

    #allow_only = authorize.not_anonymous()

    @expose('vigigraph.templates.index')

    def index(self):

        return dict(page='index')

# -*- coding: utf-8 -*-

"""Error controller"""

from tg import request, expose

__all__ = ['ErrorController']

class ErrorController(object):

    """

    Generates error documents as and when they are required.

    The ErrorDocuments middleware forwards to ErrorController when error

    related status codes are returned from the application.

    This behaviour can be altered by changing the parameters to the

    ErrorDocuments middleware in your config/middleware.py file.

    """

    @expose('vigigraph.templates.error')

    def document(self, *args, **kwargs):

        """Render the error document"""

        resp = request.environ.get('pylons.original_response')

        default_message = ("<p>We're sorry but we weren't able to process "

                           " this request.</p>")

        values = dict(prefix=request.environ.get('SCRIPT_NAME', ''),

                      code=request.params.get('code', resp.status_int),

                      message=request.params.get('message', default_message))

        return values

# -*- coding: utf-8 -*-

"""Main Controller"""

from tg import expose, flash, require, url, request, redirect

from pylons.i18n import ugettext as _, lazy_ugettext as l_

from catwalk.tg2 import Catwalk

from repoze.what import predicates

from vigigraph.lib.base import BaseController

from vigigraph.model import DBSession, metadata

from vigigraph.controllers.error import ErrorController

from vigigraph import model

from vigigraph.controllers.secure import SecureController

__all__ = ['RootController']

class RootController(BaseController):

    """

    The root controller for the vigigraph application.

    All the other controllers and WSGI applications should be mounted on this

    controller. For example::

        panel = ControlPanelController()

        another_app = AnotherWSGIApplication()

    Keep in mind that WSGI applications shouldn't be mounted directly: They

    must be wrapped around with :class:`tg.controllers.WSGIAppController`.

    """

    secc = SecureController()

    admin = Catwalk(model, DBSession)

    error = ErrorController()

    @expose('vigigraph.templates.index')

    def index(self):

        """Handle the front-page."""

        return dict(page='index')

    @expose('vigigraph.templates.about')

    def about(self):

        """Handle the 'about' page."""

        return dict(page='about')

    @expose('vigigraph.templates.authentication')

    def auth(self):

        """Display some information about auth* on this application."""

        return dict(page='auth')

    @expose('vigigraph.templates.index')

    @require(predicates.has_permission('manage', msg=l_('Only for managers')))

    def manage_permission_only(self, **kw):

        """Illustrate how a page for managers only works."""

        return dict(page='managers stuff')

    @expose('vigigraph.templates.index')

    @require(predicates.is_user('editor', msg=l_('Only for the editor')))

    def editor_user_only(self, **kw):

        """Illustrate how a page exclusive for the editor works."""

        return dict(page='editor stuff')

    @expose('vigigraph.templates.login')

    def login(self, came_from=url('/')):

        """Start the user login."""

        login_counter = request.environ['repoze.who.logins']

        if login_counter > 0:

            flash(_('Wrong credentials'), 'warning')

        return dict(page='login', login_counter=str(login_counter),

                    came_from=came_from)

    @expose()

    def post_login(self, came_from=url('/')):

        """

        Redirect the user to the initially requested page on successful

        authentication or redirect her back to the login page if login failed.

        """

        if not request.identity:

            login_counter = request.environ['repoze.who.logins'] + 1

            redirect(url('/login', came_from=came_from, __logins=login_counter))

        userid = request.identity['repoze.who.userid']

        flash(_('Welcome back, %s!') % userid)

        redirect(came_from)

    @expose()

    def post_logout(self, came_from=url('/')):

        """

        Redirect the user to the initially requested page on logout and say

        goodbye as well.

        """

        flash(_('We hope to see you soon!'))

        redirect(came_from)

# -*- coding: utf-8 -*-

"""Sample controller with all its actions protected."""

from tg import expose, flash

from pylons.i18n import ugettext as _, lazy_ugettext as l_

from repoze.what.predicates import has_permission

#from dbsprockets.dbmechanic.frameworks.tg2 import DBMechanic

#from dbsprockets.saprovider import SAProvider

from vigigraph.lib.base import BaseController

#from vigigraph.model import DBSession, metadata

__all__ = ['SecureController']

class SecureController(BaseController):

    """Sample controller-wide authorization"""

    # The predicate that must be met for all the actions in this controller:

    allow_only = has_permission('manage',

                                msg=l_('Only for people with the "manage" permission'))

    @expose('vigigraph.templates.index')

    def index(self):

        """Let the user know that's visiting a protected controller."""

        flash(_("Secure Controller here"))

        return dict(page='index')

    @expose('vigigraph.templates.index')

    def some_where(self):

        """Let the user know that this action is protected too."""

        return dict(page='some_where')

# -*- coding: utf-8 -*-

"""Fallback controller."""

from vigigraph.lib.base import BaseController

__all__ = ['TemplateController']

class TemplateController(BaseController):

    """

    The fallback controller for vigigraph.

    By default, the final controller tried to fulfill the request

    when no other routes match. It may be used to display a template

    when all else fails, e.g.::

        def view(self, url):

            return render('/%s' % url)

    Or if you're using Mako and want to explicitly send a 404 (Not

    Found) response code when the requested template doesn't exist::

        import mako.exceptions

        def view(self, url):

            try:

                return render('/%s' % url)

            except mako.exceptions.TopLevelLookupException:

                abort(404)

    """

    def view(self, url):

        """Abort the request with a 404 HTTP status code."""

        abort(404)

# Russian translations for ${package}.

# Copyright (C) 2008 ORGANIZATION

# This file is distributed under the same license as the ${package} project.

# FIRST AUTHOR <EMAIL@ADDRESS>, 2008.

#

msgid ""

msgstr ""

"Project-Id-Version: ${package} 0.0.0\n"

"Report-Msgid-Bugs-To: EMAIL@ADDRESS\n"

"POT-Creation-Date: 2008-01-13 14:00+0200\n"

"PO-Revision-Date: 2008-01-13 14:00+0200\n"

"Last-Translator: FULL NAME <EMAIL@ADDRESS>\n"

"Language-Team: ru <LL@li.org>\n"

"Plural-Forms: nplurals=3; plural=(n%10==1 && n%100!=11 ? 0 : n%10>=2 && "

"n%10<=4 && (n%100<10 || n%100>=20) ? 1 : 2)\n"

"MIME-Version: 1.0\n"

"Content-Type: text/plain; charset=utf-8\n"

"Content-Transfer-Encoding: 8bit\n"

"Generated-By: Babel 0.9.1\n"

#: ${package}/controllers/root.py:13

msgid "Your application is now running"

msgstr "Ваши приложение успешно запущено"

# -*- coding: utf-8 -*-

# -*- coding: utf-8 -*-

"""The application's Globals object"""

__all__ = ['Globals']

class Globals(object):

    """Container for objects available throughout the life of the application.

    One instance of Globals is created during application initialization and

    is available during requests via the 'app_globals' variable.

    """

    def __init__(self):

        """Do nothing, by default."""

        pass

# -*- coding: utf-8 -*-

"""The base Controller API."""

from tg import TGController, tmpl_context

from tg.render import render

from tg import request

from pylons.i18n import _, ungettext, N_

from tw.api import WidgetBunch

import vigigraph.model as model

__all__ = ['Controller', 'BaseController']

class BaseController(TGController):

    """

    Base class for the controllers in the application.

    Your web application should have one of these. The root of

    your application is used to compute URLs used by your app.

    """

    def __call__(self, environ, start_response):

        """Invoke the Controller"""

        # TGController.__call__ dispatches to the Controller method

        # the request is routed to. This routing information is

        # available in environ['pylons.routes_dict']

        request.identity = request.environ.get('repoze.who.identity')

        tmpl_context.identity = request.identity

        return TGController.__call__(self, environ, start_response)

# -*- coding: utf-8 -*-

"""WebHelpers used in vigigraph."""

from webhelpers import date, feedgenerator, html, number, misc, text

# -*- coding: utf-8 -*-

"""The application's model objects"""

from zope.sqlalchemy import ZopeTransactionExtension

from sqlalchemy.orm import scoped_session, sessionmaker

#from sqlalchemy import MetaData

from sqlalchemy.ext.declarative import declarative_base

# Global session manager: DBSession() returns the Thread-local

# session object appropriate for the current web request.

maker = sessionmaker(autoflush=True, autocommit=False,

                     extension=ZopeTransactionExtension())

DBSession = scoped_session(maker)

# Base class for all of our model classes: By default, the data model is

# defined with SQLAlchemy's declarative extension, but if you need more

# control, you can switch to the traditional method.

DeclarativeBase = declarative_base()

# There are two convenient ways for you to spare some typing.

# You can have a query property on all your model classes by doing this:

# DeclarativeBase.query = DBSession.query_property()

# Or you can use a session-aware mapper as it was used in TurboGears 1:

# DeclarativeBase = declarative_base(mapper=DBSession.mapper)

# Global metadata.

# The default metadata is the one from the declarative base.

metadata = DeclarativeBase.metadata

# If you have multiple databases with overlapping table names, you'll need a

# metadata for each database. Feel free to rename 'metadata2'.

#metadata2 = MetaData()

#####

# Generally you will not want to define your table's mappers, and data objects

# here in __init__ but will want to create modules them in the model directory

# and import them at the bottom of this file.

#

######

def init_model(engine):

    """Call me before using any of the tables or classes in the model."""

    DBSession.configure(bind=engine)

    # If you are using reflection to introspect your database and create

    # table objects for you, your tables must be defined and mapped inside

    # the init_model function, so that the engine is available if you

    # use the model outside tg2, you need to make sure this is called before

    # you use the model.

    #

    # See the following example:

    #global t_reflected

    #t_reflected = Table("Reflected", metadata,

    #    autoload=True, autoload_with=engine)

    #mapper(Reflected, t_reflected)

# Import your model modules here.

from vigigraph.model.auth import User, Group, Permission

# -*- coding: utf-8 -*-

"""

Auth* related model.

This is where the models used by :mod:`repoze.who` and :mod:`repoze.what` are

defined.

It's perfectly fine to re-use this definition in the vigigraph application,

though.

"""

import os

from datetime import datetime

import sys

try:

    from hashlib import sha1

except ImportError:

    sys.exit('ImportError: No module named hashlib\n'

             'If you are on python2.4 this library is not part of python. '

             'Please install it. Example: easy_install hashlib')

from sqlalchemy import Table, ForeignKey, Column

from sqlalchemy.types import Unicode, Integer, DateTime

from sqlalchemy.orm import relation, synonym

from vigigraph.model import DeclarativeBase, metadata, DBSession

__all__ = ['User', 'Group', 'Permission']

#{ Association tables

# This is the association table for the many-to-many relationship between

# groups and permissions. This is required by repoze.what.

group_permission_table = Table('tg_group_permission', metadata,

    Column('group_id', Integer, ForeignKey('tg_group.group_id',

        onupdate="CASCADE", ondelete="CASCADE")),

    Column('permission_id', Integer, ForeignKey('tg_permission.permission_id',

        onupdate="CASCADE", ondelete="CASCADE"))

)

# This is the association table for the many-to-many relationship between

# groups and members - this is, the memberships. It's required by repoze.what.

user_group_table = Table('tg_user_group', metadata,

    Column('user_id', Integer, ForeignKey('tg_user.user_id',

        onupdate="CASCADE", ondelete="CASCADE")),

    Column('group_id', Integer, ForeignKey('tg_group.group_id',

        onupdate="CASCADE", ondelete="CASCADE"))

)

#{ The auth* model itself

class Group(DeclarativeBase):

    """

    Group definition for :mod:`repoze.what`.

    Only the ``group_name`` column is required by :mod:`repoze.what`.

    """

    __tablename__ = 'tg_group'

    #{ Columns

    group_id = Column(Integer, autoincrement=True, primary_key=True)

    group_name = Column(Unicode(16), unique=True, nullable=False)

    display_name = Column(Unicode(255))

    created = Column(DateTime, default=datetime.now)

    #{ Relations

    users = relation('User', secondary=user_group_table, backref='groups')

    #{ Special methods

    def __repr__(self):

        return '<Group: name=%s>' % self.group_name

    def __unicode__(self):

        return self.group_name

    #}

# The 'info' argument we're passing to the email_address and password columns

# contain metadata that Rum (http://python-rum.org/) can use generate an

# admin interface for your models.

class User(DeclarativeBase):

    """

    User definition.

    This is the user definition used by :mod:`repoze.who`, which requires at

    least the ``user_name`` column.

    """

    __tablename__ = 'tg_user'

    #{ Columns

    user_id = Column(Integer, autoincrement=True, primary_key=True)

    user_name = Column(Unicode(16), unique=True, nullable=False)

    email_address = Column(Unicode(255), unique=True, nullable=False,

                           info={'rum': {'field':'Email'}})

    display_name = Column(Unicode(255))

    _password = Column('password', Unicode(80),

                       info={'rum': {'field':'Password'}})

    created = Column(DateTime, default=datetime.now)

    #{ Special methods

    def __repr__(self):

        return '<User: email="%s", display name="%s">' % (

                self.email_address, self.display_name)

    def __unicode__(self):

        return self.display_name or self.user_name

    #{ Getters and setters

    @property

    def permissions(self):

        """Return a set of strings for the permissions granted."""

        perms = set()

        for g in self.groups:

            perms = perms | set(g.permissions)

        return perms

    @classmethod

    def by_email_address(cls, email):

        """Return the user object whose email address is ``email``."""

        return DBSession.query(cls).filter(cls.email_address==email).first()

    @classmethod

    def by_user_name(cls, username):

        """Return the user object whose user name is ``username``."""

        return DBSession.query(cls).filter(cls.user_name==username).first()

    def _set_password(self, password):

        """Hash ``password`` on the fly and store its hashed version."""

        hashed_password = password

        if isinstance(password, unicode):

            password_8bit = password.encode('UTF-8')

        else:

            password_8bit = password

        salt = sha1()

        salt.update(os.urandom(60))

        hash = sha1()

        hash.update(password_8bit + salt.hexdigest())

        hashed_password = salt.hexdigest() + hash.hexdigest()

        # Make sure the hashed password is an UTF-8 object at the end of the

        # process because SQLAlchemy _wants_ a unicode object for Unicode

        # columns

        if not isinstance(hashed_password, unicode):

            hashed_password = hashed_password.decode('UTF-8')

        self._password = hashed_password

    def _get_password(self):

        """Return the hashed version of the password."""

        return self._password

    password = synonym('_password', descriptor=property(_get_password,

                                                        _set_password))

    #}

    def validate_password(self, password):

        """

        Check the password against existing credentials.

        :param password: the password that was provided by the user to

            try and authenticate. This is the clear text version that we will

            need to match against the hashed one in the database.

        :type password: unicode object.

        :return: Whether the password is valid.

        :rtype: bool

        """

        hashed_pass = sha1()

        hashed_pass.update(password + self.password[:40])

        return self.password[40:] == hashed_pass.hexdigest()

class Permission(DeclarativeBase):

    """

    Permission definition for :mod:`repoze.what`.

    Only the ``permission_name`` column is required by :mod:`repoze.what`.

    """

    __tablename__ = 'tg_permission'

    #{ Columns

    permission_id = Column(Integer, autoincrement=True, primary_key=True)

    permission_name = Column(Unicode(16), unique=True, nullable=False)

    description = Column(Unicode(255))

    #{ Relations

    groups = relation(Group, secondary=group_permission_table,

                      backref='permissions')

    #{ Special methods

    def __repr__(self):

        return '<Permission: name=%s>' % self.permission_name

    def __unicode__(self):

        return self.permission_name

    #}