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

# This program is free software: you can redistribute it and/or modify

# it under the terms of the GNU General Public License as published by

# the Free Software Foundation, either version 3 of the License, or

# (at your option) any later version.

#

# This program is distributed in the hope that it will be useful,

# but WITHOUT ANY WARRANTY; without even the implied warranty of

# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the

# GNU General Public License for more details.

#

# You should have received a copy of the GNU General Public License

# along with this program.  If not, see <http://www.gnu.org/licenses/>.

"""

kallithea.__init__

~~~~~~~~~~~~~~~~~~

Kallithea, a web based repository management based on pylons

versioning implementation: http://www.python.org/dev/peps/pep-0386/

This file was forked by the Kallithea project in July 2014.

Original author and date, and relevant copyright and licensing information is below:

:created_on: Apr 9, 2010

:author: marcink

:copyright: (c) 2013 RhodeCode GmbH, (C) 2014 Bradley M. Kuhn, and others.

:license: GPLv3, see LICENSE.md for more details.

"""

import sys

import platform

VERSION = (2, 2, 5)

BACKENDS = {

    'hg': 'Mercurial repository',

    'git': 'Git repository',

}

CELERY_ON = False

CELERY_EAGER = False

# link to config for pylons

CONFIG = {}

# Linked module for extensions

EXTENSIONS = {}

# BRAND controls internal references in database and config to the products

# own name.

#

# NOTE: If you want compatibility with a database that was originally created

#  for use with the RhodeCode software product, change BRAND to "rhodecode",

#  either by editing here or by creating a new file:

#  echo "BRAND = 'rhodecode'" > kallithea/brand.py

BRAND = "kallithea"

try:

    from kallithea.brand import BRAND

except ImportError:

    pass

# Prefix for the ui and settings table names

DB_PREFIX = (BRAND + "_") if BRAND != "kallithea" else ""

# Users.extern_type and .extern_name value for local users

EXTERN_TYPE_INTERNAL = BRAND if BRAND != 'kallithea' else 'internal'

try:

    from kallithea.lib import get_current_revision

    _rev = get_current_revision(quiet=True)

    if _rev and len(VERSION) > 3:

        VERSION += ('%s' % _rev[0],)

except ImportError:

    pass

__version__ = ('.'.join((str(each) for each in VERSION[:3])))

__dbversion__ = 31  # defines current db version for migrations

__platform__ = platform.system()

__license__ = 'GPLv3'

__py_version__ = sys.version_info

__author__ = "Various Authors"

__url__ = 'https://kallithea-scm.org/'

is_windows = __platform__ in ['Windows']

is_unix = not is_windows

if len(VERSION) > 3:

    __version__ += '.'+VERSION[3]

    if len(VERSION) > 4:

        __version__ += VERSION[4]

    else:

        __version__ += '0'

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

# This program is free software: you can redistribute it and/or modify

# it under the terms of the GNU General Public License as published by

# the Free Software Foundation, either version 3 of the License, or

# (at your option) any later version.

#

# This program is distributed in the hope that it will be useful,

# but WITHOUT ANY WARRANTY; without even the implied warranty of

# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the

# GNU General Public License for more details.

#

# You should have received a copy of the GNU General Public License

# along with this program.  If not, see <http://www.gnu.org/licenses/>.

"""

kallithea.lib.db_manage

~~~~~~~~~~~~~~~~~~~~~~~

Database creation, and setup module for Kallithea. Used for creation

of database as well as for migration operations

This file was forked by the Kallithea project in July 2014.

Original author and date, and relevant copyright and licensing information is below:

:created_on: Apr 10, 2010

:author: marcink

:copyright: (c) 2013 RhodeCode GmbH, and others.

:license: GPLv3, see LICENSE.md for more details.

"""

import os

import sys

import time

import uuid

import logging

from os.path import dirname as dn, join as jn

import datetime

from kallithea.model.user import UserModel

from kallithea.lib.utils import ask_ok

from kallithea.model import init_model

from kallithea.model.db import User, Permission, Ui, \

    Setting, UserToPerm, DbMigrateVersion, RepoGroup, \

    UserRepoGroupToPerm, CacheInvalidation, UserGroup, Repository

from sqlalchemy.engine import create_engine

from kallithea.model.repo_group import RepoGroupModel

#from kallithea.model import meta

from kallithea.model.meta import Session, Base

from kallithea.model.repo import RepoModel

from kallithea.model.permission import PermissionModel

from kallithea.model.user_group import UserGroupModel

log = logging.getLogger(__name__)

def notify(msg):

    """

    Notification for migrations messages

    """

    ml = len(msg) + (4 * 2)

    print('\n%s\n*** %s ***\n%s' % ('*' * ml, msg, '*' * ml)).upper()

class DbManage(object):

    def __init__(self, log_sql, dbconf, root, tests=False, SESSION=None, cli_args={}):

        self.dbname = dbconf.split('/')[-1]

        self.tests = tests

        self.root = root

        self.dburi = dbconf

        self.log_sql = log_sql

        self.db_exists = False

        self.cli_args = cli_args

        self.init_db(SESSION=SESSION)

        force_ask = self.cli_args.get('force_ask')

        if force_ask is not None:

            global ask_ok

            ask_ok = lambda *args, **kwargs: force_ask

    def init_db(self, SESSION=None):

        if SESSION:

            self.sa = SESSION

        else:

            #init new sessions

            engine = create_engine(self.dburi, echo=self.log_sql)

            init_model(engine)

            self.sa = Session()

    def create_tables(self, override=False):

        """

        Create a auth database

        """

        log.info("Any existing database is going to be destroyed")

        if self.tests:

            destroy = True

        else:

            destroy = ask_ok('Are you sure to destroy old database ? [y/n]')

        if not destroy:

            print 'Nothing done.'

            sys.exit(0)

        if destroy:

            Base.metadata.drop_all()

        checkfirst = not override

        Base.metadata.create_all(checkfirst=checkfirst)

        log.info('Created tables for %s' % self.dbname)

    def set_db_version(self):

        ver = DbMigrateVersion()

        ver.version = __dbversion__

        ver.repository_path = 'versions'

        self.sa.add(ver)

        log.info('db version set to: %s' % __dbversion__)

    def upgrade(self):

        """

        Upgrades given database schema to given revision following

        all needed steps, to perform the upgrade

        """

        from kallithea.lib.dbmigrate.migrate.versioning import api

        from kallithea.lib.dbmigrate.migrate.exceptions import \

            DatabaseNotControlledError

        if 'sqlite' in self.dburi:

            print (

               '********************** WARNING **********************\n'

               'Make sure your version of sqlite is at least 3.7.X.  \n'

               'Earlier versions are known to fail on some migrations\n'

               '*****************************************************\n')

        upgrade = ask_ok('You are about to perform database upgrade, make '

                         'sure You backed up your database before. '

                         'Continue ? [y/n]')

        if not upgrade:

            print 'No upgrade performed'

            sys.exit(0)

        repository_path = jn(dn(dn(dn(os.path.realpath(__file__)))),

                             'kallithea/lib/dbmigrate')

        db_uri = self.dburi

        try:

            curr_version = api.db_version(db_uri, repository_path)

            msg = ('Found current database under version '

                   'control with version %s' % curr_version)

        except (RuntimeError, DatabaseNotControlledError):

            curr_version = 1

            msg = ('Current database is not under version control. Setting '

                   'as version %s' % curr_version)

            api.version_control(db_uri, repository_path, curr_version)

        notify(msg)

        if curr_version == __dbversion__:

            print 'This database is already at the newest version'

            sys.exit(0)

        # clear cache keys

        log.info("Clearing cache keys now...")

        CacheInvalidation.clear_cache()

        upgrade_steps = range(curr_version + 1, __dbversion__ + 1)

        notify('attempting to do database upgrade from '

               'version %s to version %s' % (curr_version, __dbversion__))

        # CALL THE PROPER ORDER OF STEPS TO PERFORM FULL UPGRADE

        _step = None

        for step in upgrade_steps:

            notify('performing upgrade step %s' % step)

            time.sleep(0.5)

            api.upgrade(db_uri, repository_path, step)

            notify('schema upgrade for step %s completed' % (step,))

            _step = step

        notify('upgrade to version %s successful' % _step)

    def fix_repo_paths(self):

        """

        Fixes a old kallithea version path into new one without a '*'

        """

        paths = self.sa.query(Ui)\

                .filter(Ui.ui_key == '/')\

                .scalar()

        paths.ui_value = paths.ui_value.replace('*', '')

        try:

            self.sa.add(paths)

            self.sa.commit()

        except Exception:

            self.sa.rollback()

            raise

    def fix_default_user(self):

        """

        Fixes a old default user with some 'nicer' default values,

        used mostly for anonymous access

        """

        def_user = self.sa.query(User)\

                .filter(User.username == User.DEFAULT_USER)\

                .one()

        def_user.name = 'Anonymous'

        def_user.lastname = 'User'

        def_user.email = 'anonymous@kallithea-scm.org'

        try:

            self.sa.add(def_user)

            self.sa.commit()

        except Exception:

            self.sa.rollback()

            raise

    def fix_settings(self):

        """

        Fixes kallithea settings adds ga_code key for google analytics

        """

        hgsettings3 = Setting('ga_code', '')

        try:

            self.sa.add(hgsettings3)

            self.sa.commit()

        except Exception:

            self.sa.rollback()

            raise

    def admin_prompt(self, second=False):

        if not self.tests:

            import getpass

            # defaults

            defaults = self.cli_args

            username = defaults.get('username')

            password = defaults.get('password')

            email = defaults.get('email')

            def get_password():

                password = getpass.getpass('Specify admin password '

                                           '(min 6 chars):')

                confirm = getpass.getpass('Confirm password:')

                if password != confirm:

                    log.error('passwords mismatch')

                    return False

                if len(password) < 6:

                    log.error('password is to short use at least 6 characters')

                    return False

                return password

            if username is None:

                username = raw_input('Specify admin username:')

            if password is None:

                password = get_password()

                if not password:

                    #second try

                    password = get_password()

                    if not password:

                        sys.exit()

            if email is None:

                email = raw_input('Specify admin email:')

            self.create_user(username, password, email, True)

        else:

            log.info('creating admin and regular test users')

            from kallithea.tests import TEST_USER_ADMIN_LOGIN, \

            TEST_USER_ADMIN_PASS, TEST_USER_ADMIN_EMAIL, \

            TEST_USER_REGULAR_LOGIN, TEST_USER_REGULAR_PASS, \

            TEST_USER_REGULAR_EMAIL, TEST_USER_REGULAR2_LOGIN, \

            TEST_USER_REGULAR2_PASS, TEST_USER_REGULAR2_EMAIL

            self.create_user(TEST_USER_ADMIN_LOGIN, TEST_USER_ADMIN_PASS,

                             TEST_USER_ADMIN_EMAIL, True)

            self.create_user(TEST_USER_REGULAR_LOGIN, TEST_USER_REGULAR_PASS,

                             TEST_USER_REGULAR_EMAIL, False)

            self.create_user(TEST_USER_REGULAR2_LOGIN, TEST_USER_REGULAR2_PASS,

                             TEST_USER_REGULAR2_EMAIL, False)

    def create_ui_settings(self, repo_store_path):

        """

        Creates ui settings, fills out hooks

        and disables dotencode

        """

        #HOOKS

        hooks1_key = Ui.HOOK_UPDATE

        hooks1_ = self.sa.query(Ui)\

            .filter(Ui.ui_key == hooks1_key).scalar()

        hooks1 = Ui() if hooks1_ is None else hooks1_

        hooks1.ui_section = 'hooks'

        hooks1.ui_key = hooks1_key

        hooks1.ui_value = 'hg update >&2'

        hooks1.ui_active = False

        self.sa.add(hooks1)

        hooks2_key = Ui.HOOK_REPO_SIZE

        hooks2_ = self.sa.query(Ui)\

            .filter(Ui.ui_key == hooks2_key).scalar()

        hooks2 = Ui() if hooks2_ is None else hooks2_

        hooks2.ui_section = 'hooks'

        hooks2.ui_key = hooks2_key

        hooks2.ui_value = 'python:kallithea.lib.hooks.repo_size'

        self.sa.add(hooks2)

        hooks3 = Ui()

        hooks3.ui_section = 'hooks'

        hooks3.ui_key = Ui.HOOK_PUSH

        hooks3.ui_value = 'python:kallithea.lib.hooks.log_push_action'

        self.sa.add(hooks3)

        hooks4 = Ui()

        hooks4.ui_section = 'hooks'

        hooks4.ui_key = Ui.HOOK_PRE_PUSH

        hooks4.ui_value = 'python:kallithea.lib.hooks.pre_push'

        self.sa.add(hooks4)

        hooks5 = Ui()

        hooks5.ui_section = 'hooks'

        hooks5.ui_key = Ui.HOOK_PULL

        hooks5.ui_value = 'python:kallithea.lib.hooks.log_pull_action'

        self.sa.add(hooks5)

        hooks6 = Ui()

        hooks6.ui_section = 'hooks'

        hooks6.ui_key = Ui.HOOK_PRE_PULL

        hooks6.ui_value = 'python:kallithea.lib.hooks.pre_pull'

        self.sa.add(hooks6)

        # enable largefiles

        largefiles = Ui()

        largefiles.ui_section = 'extensions'

        largefiles.ui_key = 'largefiles'

        largefiles.ui_value = ''

        self.sa.add(largefiles)

        # set default largefiles cache dir, defaults to

        # /repo location/.cache/largefiles

        largefiles = Ui()

        largefiles.ui_section = 'largefiles'

        largefiles.ui_key = 'usercache'

        largefiles.ui_value = os.path.join(repo_store_path, '.cache',

                                           'largefiles')

        self.sa.add(largefiles)

        # enable hgsubversion disabled by default

        hgsubversion = Ui()

        hgsubversion.ui_section = 'extensions'

        hgsubversion.ui_key = 'hgsubversion'

        hgsubversion.ui_value = ''

        hgsubversion.ui_active = False

        self.sa.add(hgsubversion)

        # enable hggit disabled by default

        hggit = Ui()

        hggit.ui_section = 'extensions'

        hggit.ui_key = 'hggit'

        hggit.ui_value = ''

        hggit.ui_active = False

        self.sa.add(hggit)

    def create_auth_plugin_options(self, skip_existing=False):

        """

        Create default auth plugin settings, and make it active

        :param skip_existing:

        """

        for k, v, t in [('auth_plugins', 'kallithea.lib.auth_modules.auth_internal', 'list'),

                     ('auth_internal_enabled', 'True', 'bool')]:

            if skip_existing and Setting.get_by_name(k) != None:

                log.debug('Skipping option %s' % k)

                continue

            setting = Setting(k, v, t)

            self.sa.add(setting)

    def create_default_options(self, skip_existing=False):

        """Creates default settings"""

        for k, v, t in [

            ('default_repo_enable_locking',  False, 'bool'),

            ('default_repo_enable_downloads', False, 'bool'),

            ('default_repo_enable_statistics', False, 'bool'),

            ('default_repo_private', False, 'bool'),

            ('default_repo_type', 'hg', 'unicode')]:

            if skip_existing and Setting.get_by_name(k) is not None:

                log.debug('Skipping option %s' % k)

                continue

            setting = Setting(k, v, t)

            self.sa.add(setting)

    def fixup_groups(self):

        def_usr = User.get_default_user()

        for g in RepoGroup.query().all():

            g.group_name = g.get_new_name(g.name)

            self.sa.add(g)

            # get default perm

            default = UserRepoGroupToPerm.query()\

                .filter(UserRepoGroupToPerm.group == g)\

                .filter(UserRepoGroupToPerm.user == def_usr)\

                .scalar()

            if default is None:

                log.debug('missing default permission for group %s adding' % g)

                perm_obj = RepoGroupModel()._create_default_perms(g)

                self.sa.add(perm_obj)

    def reset_permissions(self, username):

        """

        Resets permissions to default state, usefull when old systems had

        bad permissions, we must clean them up

        :param username:

        """

        default_user = User.get_by_username(username)

        if not default_user:

            return

        u2p = UserToPerm.query()\

            .filter(UserToPerm.user == default_user).all()

        fixed = False

        if len(u2p) != len(Permission.DEFAULT_USER_PERMISSIONS):

            for p in u2p:

                Session().delete(p)

            fixed = True

            self.populate_default_permissions()

        return fixed

    def update_repo_info(self):

        RepoModel.update_repoinfo()

    def config_prompt(self, test_repo_path='', retries=3):

        defaults = self.cli_args

        _path = defaults.get('repos_location')

        if retries == 3:

            log.info('Setting up repositories config')

        if _path is not None:

            path = _path

        elif not self.tests and not test_repo_path:

            path = raw_input(

                 'Enter a valid absolute path to store repositories. '

                 'All repositories in that path will be added automatically:'

            )

        else:

            path = test_repo_path

        path_ok = True

        # check proper dir

        if not os.path.isdir(path):

            path_ok = False

            log.error('Given path %s is not a valid directory' % (path,))

        elif not os.path.isabs(path):

            path_ok = False

            log.error('Given path %s is not an absolute path' % (path,))

        # check if path is at least readable.

        if not os.access(path, os.R_OK):

            path_ok = False

            log.error('Given path %s is not readable' % (path,))

        # check write access, warn user about non writeable paths

        elif not os.access(path, os.W_OK) and path_ok:

            log.warn('No write permission to given path %s' % (path,))

            if not ask_ok('Given path %s is not writeable, do you want to '

                          'continue with read only mode ? [y/n]' % (path,)):

                log.error('Canceled by user')

                sys.exit(-1)

        if retries == 0:

            sys.exit('max retries reached')

        if not path_ok:

            retries -= 1

            return self.config_prompt(test_repo_path, retries)

        real_path = os.path.normpath(os.path.realpath(path))

        if real_path != os.path.normpath(path):

            if not ask_ok(('Path looks like a symlink, Kallithea will store '

                           'given path as %s ? [y/n]') % (real_path,)):

                log.error('Canceled by user')

                sys.exit(-1)

        return real_path

    def create_settings(self, path):

[db_settings]

# Used to identify which repository this database is versioned under.

# You can use the name of your project.

# The name of the database table used to track the schema version.

# This name shouldn't already be used by your project.

# If this is changed once a database is under version control, you'll need to 

# change the table name in each database too. 

version_table=db_migrate_version

# When committing a change script, Migrate will attempt to generate the 

# sql for all supported databases; normally, if one of them fails - probably

# because you don't have that database installed - it is ignored and the 

# commit continues, perhaps ending successfully. 

# Databases in this list MUST compile successfully during a commit, or the 

# entire commit will fail. List the databases your application will actually 

# be using to ensure your updates to that database work properly.

# This must be a list; example: ['postgres','sqlite']

required_dbs=['sqlite']

"""

   SQLAlchemy migrate repository management.

"""

import os

import shutil

import string

import logging

from pkg_resources import resource_filename

from tempita import Template as TempitaTemplate

from kallithea.lib.dbmigrate.migrate import exceptions

from kallithea.lib.dbmigrate.migrate.versioning import version, pathed, cfgparse

from kallithea.lib.dbmigrate.migrate.versioning.template import Template

from kallithea.lib.dbmigrate.migrate.versioning.config import *

log = logging.getLogger(__name__)

class Changeset(dict):

    """A collection of changes to be applied to a database.

    Changesets are bound to a repository and manage a set of

    scripts from that repository.

    Behaves like a dict, for the most part. Keys are ordered based on step value.

    """

    def __init__(self, start, *changes, **k):

        """

        Give a start version; step must be explicitly stated.

        """

        self.step = k.pop('step', 1)

        self.start = version.VerNum(start)

        self.end = self.start

        for change in changes:

            self.add(change)

    def __iter__(self):

        return iter(self.items())

    def keys(self):

        """

        In a series of upgrades x -> y, keys are version x. Sorted.

        """

        ret = super(Changeset, self).keys()

        # Reverse order if downgrading

        ret.sort(reverse=(self.step < 1))

        return ret

    def values(self):

        return [self[k] for k in self.keys()]

    def items(self):

        return zip(self.keys(), self.values())

    def add(self, change):

        """Add new change to changeset"""

        key = self.end

        self.end += self.step

        self[key] = change

    def run(self, *p, **k):

        """Run the changeset scripts"""

        for version, script in self:

            script.run(*p, **k)

class Repository(pathed.Pathed):

    """A project's change script repository"""

    _config = 'migrate.cfg'

    _versions = 'versions'

    def __init__(self, path):

        log.debug('Loading repository %s...' % path)

        self.verify(path)

        super(Repository, self).__init__(path)

        self.config = cfgparse.Config(os.path.join(self.path, self._config))

        self.versions = version.Collection(os.path.join(self.path,

                                                      self._versions))

        log.debug('Repository %s loaded successfully' % path)

        log.debug('Config: %r' % self.config.to_dict())

    @classmethod

    def verify(cls, path):

        """

        Ensure the target path is a valid repository.

        :raises: :exc:`InvalidRepositoryError <migrate.exceptions.InvalidRepositoryError>`

        """

        # Ensure the existence of required files

        try:

            cls.require_found(path)

            cls.require_found(os.path.join(path, cls._config))

            cls.require_found(os.path.join(path, cls._versions))

        except exceptions.PathNotFoundError, e:

            raise exceptions.InvalidRepositoryError(path)

    @classmethod

    def prepare_config(cls, tmpl_dir, name, options=None):

        """

        Prepare a project configuration file for a new project.

        :param tmpl_dir: Path to Repository template

        :param config_file: Name of the config file in Repository template

        :param name: Repository name

        :type tmpl_dir: string

        :type config_file: string

        :type name: string

        :returns: Populated config file

        """

        if options is None:

            options = {}

        options.setdefault('version_table', 'migrate_version')

        options.setdefault('repository_id', name)

        options.setdefault('required_dbs', [])

        options.setdefault('use_timestamp_numbering', False)

        tmpl = open(os.path.join(tmpl_dir, cls._config)).read()

        ret = TempitaTemplate(tmpl).substitute(options)

        # cleanup

        del options['__template_name__']

        return ret

    @classmethod

    def create(cls, path, name, **opts):

        """Create a repository at a specified path"""

        cls.require_notfound(path)

        theme = opts.pop('templates_theme', None)

        t_path = opts.pop('templates_path', None)

        # Create repository

        tmpl_dir = Template(t_path).get_repository(theme=theme)

        shutil.copytree(tmpl_dir, path)

        # Edit config defaults

        config_text = cls.prepare_config(tmpl_dir, name, options=opts)

        fd = open(os.path.join(path, cls._config), 'w')

        fd.write(config_text)

        fd.close()

        opts['repository_name'] = name

        # Create a management script

        manager = os.path.join(path, 'manage.py')

        Repository.create_manage_file(manager, templates_theme=theme,

            templates_path=t_path, **opts)

        return cls(path)

    def create_script(self, description, **k):

        """API to :meth:`migrate.versioning.version.Collection.create_new_python_version`"""

        k['use_timestamp_numbering'] = self.use_timestamp_numbering

        self.versions.create_new_python_version(description, **k)

    def create_script_sql(self, database, description, **k):

        """API to :meth:`migrate.versioning.version.Collection.create_new_sql_version`"""

        k['use_timestamp_numbering'] = self.use_timestamp_numbering

        self.versions.create_new_sql_version(database, description, **k)

    @property

    def latest(self):

        """API to :attr:`migrate.versioning.version.Collection.latest`"""

        return self.versions.latest

    @property

    def version_table(self):

        """Returns version_table name specified in config"""

        return self.config.get('db_settings', 'version_table')

    @property

    def id(self):

        """Returns repository id specified in config"""

    @property

    def use_timestamp_numbering(self):

        """Returns use_timestamp_numbering specified in config"""

        if self.config.has_option('db_settings', 'use_timestamp_numbering'):

            return self.config.getboolean('db_settings', 'use_timestamp_numbering')

        return False

    def version(self, *p, **k):

        """API to :attr:`migrate.versioning.version.Collection.version`"""

        return self.versions.version(*p, **k)

    @classmethod

    def clear(cls):

        # TODO: deletes repo

        super(Repository, cls).clear()

        version.Collection.clear()

    def changeset(self, database, start, end=None):

        """Create a changeset to migrate this database from ver. start to end/latest.

        :param database: name of database to generate changeset

        :param start: version to start at

        :param end: version to end at (latest if None given)

        :type database: string

        :type start: int

        :type end: int

        :returns: :class:`Changeset instance <migration.versioning.repository.Changeset>`

        """

        start = version.VerNum(start)

        if end is None:

            end = self.latest

        else:

            end = version.VerNum(end)

        if start <= end:

            step = 1

            range_mod = 1

            op = 'upgrade'

        else:

            step = -1

            range_mod = 0

            op = 'downgrade'

        versions = range(start + range_mod, end + range_mod, step)

        changes = [self.version(v).script(database, op) for v in versions]

        ret = Changeset(start, step=step, *changes)

        return ret

    @classmethod

    def create_manage_file(cls, file_, **opts):

        """Create a project management script (manage.py)

        :param file_: Destination file to be written

        :param opts: Options that are passed to :func:`migrate.versioning.shell.main`

        """

        mng_file = Template(opts.pop('templates_path', None))\

            .get_manage(theme=opts.pop('templates_theme', None))

        tmpl = open(mng_file).read()

        fd = open(file_, 'w')

        fd.write(TempitaTemplate(tmpl).substitute(opts))

        fd.close()