# 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/>.

import sys

import platform

VERSION = (1, 3, 0, 'beta')

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

__platform__ = platform.system()

__license__ = 'GPLv3'

__py_version__ = sys.version_info

PLATFORM_WIN = ('Windows')

PLATFORM_OTHERS = ('Linux', 'Darwin', 'FreeBSD', 'OpenBSD', 'SunOS')

requirements = [

    "Pylons==1.0.0",

    "Beaker==1.6.2",

    "WebHelpers>=1.2",

    "formencode==1.2.4",

                (user_dn, ldap_attrs) = aldap.authenticate_ldap(username,

                                                                password)

                log.debug('Got ldap DN response %s' % user_dn)

                get_ldap_attr = lambda k: ldap_attrs.get(ldap_settings\

                                                           .get(k), [''])[0]

                user_attrs = {

                 'name': safe_unicode(get_ldap_attr('ldap_attr_firstname')),

                 'lastname': safe_unicode(get_ldap_attr('ldap_attr_lastname')),

                 'email': get_ldap_attr('ldap_attr_email'),

                }

                # with some random generated password

                _password = PasswordGenerator().gen_password(length=8)

                # create this user on the fly if it doesn't exist in rhodecode

                # database

                if user_model.create_ldap(username, _password, user_dn,

                                          user_attrs):

                    log.info('created new ldap user %s' % username)

                Session.commit()

                return True

            except (LdapUsernameError, LdapPasswordError,):

                pass

                self.klass.fix_default_user()

                log.info('Changing ui settings')

                self.klass.create_ui_settings()

            def step_3(self):

                print ('Adding additional settings into RhodeCode db')

                self.klass.fix_settings()

                print ('Adding ldap defaults')

                self.klass.create_ldap_options(skip_existing=True)

            def step_4(self):

                self.klass.create_permissions()

                self.klass.fixup_groups()

        upgrade_steps = [0] + range(curr_version + 1, __dbversion__ + 1)

        # CALL THE PROPER ORDER OF STEPS TO PERFORM FULL UPGRADE

        for step in upgrade_steps:

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

            getattr(UpgradeSteps(self), 'step_%s' % step)()

            self.sa.commit()

    def fix_repo_paths(self):

        """

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

        """

        paths = self.sa.query(RhodeCodeUi)\

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

                .scalar()

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

        try:

import sqlalchemy as sa

from sqlalchemy.schema import SchemaVisitor

from sqlalchemy.engine.default import DefaultDialect

from sqlalchemy.sql import ClauseElement

from sqlalchemy.schema import (ForeignKeyConstraint,

                               PrimaryKeyConstraint,

                               CheckConstraint,

                               UniqueConstraint,

                               Index)

from rhodecode.lib.dbmigrate.migrate import exceptions

class AlterTableVisitor(SchemaVisitor):

    """Common operations for ``ALTER TABLE`` statements."""

    def append(self, s):

        """Append content to the SchemaIterator's query buffer."""

        self.buffer.write(s)

    def execute(self):

        """Execute the contents of the SchemaIterator's buffer."""

        try:

            return self.connection.execute(self.buffer.getvalue())

        finally:

            self.buffer.truncate(0)

                                        name=column.unique_name).create()

        # SA bounds FK constraints to table, add manually

        for fk in column.foreign_keys:

            self.add_foreignkey(fk.constraint)

        # add primary key constraint if needed

        if column.primary_key_name:

            cons = constraint.PrimaryKeyConstraint(column,

                                                   name=column.primary_key_name)

            cons.create()

class ANSIColumnDropper(AlterTableVisitor, SchemaDropper):

    """Extends ANSI SQL dropper for column dropping (``ALTER TABLE

    DROP COLUMN``).

    """

    def visit_column(self, column):

        """Drop a column from its table.

        :param column: the column object

        :type column: :class:`sqlalchemy.Column`

        """

        else:

            self.append("SET NOT NULL")

    def _visit_column_default(self, table, column, delta):

        default_text = self.get_column_default_string(column)

        if default_text is not None:

            self.append("SET DEFAULT %s" % default_text)

        else:

            self.append("DROP DEFAULT")

    def _visit_column_type(self, table, column, delta):

        type_ = delta['type']

        self.append("TYPE %s" % type_text)

    def _visit_column_name(self, table, column, delta):

        self.start_alter_table(table)

        col_name = self.preparer.quote(delta.current_name, table.quote)

        new_name = self.preparer.format_column(delta.result_column)

        self.append('RENAME COLUMN %s TO %s' % (col_name, new_name))

class ANSIConstraintCommon(AlterTableVisitor):

    """

    Migrate's constraints require a separate creation function from

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

        self._visit_constraint(*p, **k)

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

        self._visit_constraint(*p, **k)

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

        self._visit_constraint(*p, **k)

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

        self._visit_constraint(*p, **k)

class ANSIDialect(DefaultDialect):

    columngenerator = ANSIColumnGenerator

    columndropper = ANSIColumnDropper

    schemachanger = ANSISchemaChanger

    constraintgenerator = ANSIConstraintGenerator

    constraintdropper = ANSIConstraintDropper

"""

   This module defines standalone schema constraint classes.

"""

from sqlalchemy import schema

from rhodecode.lib.dbmigrate.migrate.exceptions import *

class ConstraintChangeset(object):

    """Base class for Constraint classes."""

    def _normalize_columns(self, cols, table_name=False):

        """Given: column objects or names; return col names and

        (maybe) a table"""

        colnames = []

        table = None

        for col in cols:

            if isinstance(col, schema.Column):

                if col.table is not None and table is None:

    :type cols: strings or Column instances

    """

    __migrate_visit_name__ = 'migrate_primary_key_constraint'

    def __init__(self, *cols, **kwargs):

        colnames, table = self._normalize_columns(cols)

        table = kwargs.pop('table', table)

        super(PrimaryKeyConstraint, self).__init__(*colnames, **kwargs)

        if table is not None:

            self._set_parent(table)

    def autoname(self):

        """Mimic the database's automatic constraint names"""

        return "%s_pkey" % self.table.name

class ForeignKeyConstraint(ConstraintChangeset, schema.ForeignKeyConstraint):

    """Construct ForeignKeyConstraint

    Migrate's additional parameters:

    :param columns: Columns in constraint

    :param refcolumns: Columns that this FK reffers to in another table.

    :type table: Table instance

    :type columns: list of strings or Column instances

    :type refcolumns: list of strings or Column instances

    """

    __migrate_visit_name__ = 'migrate_foreign_key_constraint'

    def __init__(self, columns, refcolumns, *args, **kwargs):

        colnames, table = self._normalize_columns(columns)

        table = kwargs.pop('table', table)

        refcolnames, reftable = self._normalize_columns(refcolumns,

                                                        table_name=True)

        if table is not None:

            self._set_parent(table)

    @property

    def referenced(self):

        return [e.column for e in self.elements]

    @property

    def reftable(self):

        return self.referenced[0].table

    def autoname(self):

    __migrate_visit_name__ = 'migrate_check_constraint'

    def __init__(self, sqltext, *args, **kwargs):

        cols = kwargs.pop('columns', [])

        if not cols and not kwargs.get('name', False):

            raise InvalidConstraintError('You must either set "name"'

                'parameter or "columns" to autogenarate it.')

        colnames, table = self._normalize_columns(cols)

        table = kwargs.pop('table', table)

        schema.CheckConstraint.__init__(self, sqltext, *args, **kwargs)

        if table is not None:

            self._set_parent(table)

        self.colnames = colnames

    def autoname(self):

        return "%(table)s_%(cols)s_check" % \

            dict(table=self.table.name, cols="_".join(self.colnames))

class UniqueConstraint(ConstraintChangeset, schema.UniqueConstraint):

    """Construct UniqueConstraint

    Migrate's additional parameters:

    __migrate_visit_name__ = 'migrate_unique_constraint'

    def __init__(self, *cols, **kwargs):

        self.colnames, table = self._normalize_columns(cols)

        table = kwargs.pop('table', table)

        super(UniqueConstraint, self).__init__(*self.colnames, **kwargs)

        if table is not None:

            self._set_parent(table)

    def autoname(self):

        """Mimic the database's automatic constraint names"""

"""

   Firebird database specific implementations of changeset classes.

"""

from sqlalchemy.databases import firebird as sa_base

from sqlalchemy.schema import PrimaryKeyConstraint

from rhodecode.lib.dbmigrate.migrate import exceptions

class FBColumnGenerator(FBSchemaGenerator, ansisql.ANSIColumnGenerator):

    """Firebird column generator implementation."""

class FBColumnDropper(ansisql.ANSIColumnDropper):

    """Firebird column dropper implementation."""

    def visit_column(self, column):

        """Firebird supports 'DROP col' instead of 'DROP COLUMN col' syntax

        Drop primary key and unique constraints if dropped column is referencing it."""

            # "column in index.columns" causes problems as all

            # column objects compare equal and return a SQL expression

            if column.name in [col.name for col in index.columns]:

                index.drop()

                # TODO: recreate index if it references more than this column

        for cons in column.table.constraints:

            if isinstance(cons,PrimaryKeyConstraint):

                # will be deleted only when the column its on

                # is deleted!

                continue

            if should_drop:

                self.start_alter_table(column)

                self.append("DROP CONSTRAINT ")

                self.append(self.preparer.format_constraint(cons))

                self.execute()

            # TODO: recreate unique constraint if it refenrences more than this column

        self.start_alter_table(column)

        self.append('DROP %s' % self.preparer.format_column(column))

        self.execute()

"""

   MySQL database specific implementations of changeset classes.

"""

from sqlalchemy.databases import mysql as sa_base

from sqlalchemy import types as sqltypes

from rhodecode.lib.dbmigrate.migrate import exceptions

class MySQLColumnGenerator(MySQLSchemaGenerator, ansisql.ANSIColumnGenerator):

    pass

class MySQLColumnDropper(ansisql.ANSIColumnDropper):

    pass

class MySQLSchemaChanger(MySQLSchemaGenerator, ansisql.ANSISchemaChanger):

    def visit_column(self, delta):

        self.append("CHANGE COLUMN %s " % old_col_name)

        self.append(colspec)

        self.execute()

    def visit_index(self, param):

        # If MySQL can do this, I can't find how

        raise exceptions.NotSupportedError("MySQL cannot rename indexes")

class MySQLConstraintGenerator(ansisql.ANSIConstraintGenerator):

    pass

class MySQLDialect(ansisql.ANSIDialect):

    columngenerator = MySQLColumnGenerator

    columndropper = MySQLColumnDropper

    schemachanger = MySQLSchemaChanger

    constraintgenerator = MySQLConstraintGenerator

    constraintdropper = MySQLConstraintDropper

"""

   `PostgreSQL`_ database specific implementations of changeset classes.

   .. _`PostgreSQL`: http://www.postgresql.org/

"""

class PGColumnGenerator(PGSchemaGenerator, ansisql.ANSIColumnGenerator):

    """PostgreSQL column generator implementation."""

    pass

class PGColumnDropper(ansisql.ANSIColumnDropper):

    """PostgreSQL column dropper implementation."""

    pass

   `SQLite`_ database specific implementations of changeset classes.

   .. _`SQLite`: http://www.sqlite.org/

"""

from UserDict import DictMixin

from copy import copy

from sqlalchemy.databases import sqlite as sa_base

from rhodecode.lib.dbmigrate.migrate import exceptions

from rhodecode.lib.dbmigrate.migrate.changeset import ansisql, SQLA_06

class SQLiteCommon(object):

    def _not_supported(self, op):

        raise exceptions.NotSupportedError("SQLite does not support "

            "%s; see http://www.sqlite.org/lang_altertable.html" % op)

class SQLiteHelper(SQLiteCommon):

    def recreate_table(self,table,column=None,delta=None):

        table_name = self.preparer.format_table(table)

            else:

                break

        if len(p):

            new_col = column.copy_fixed()

            new_col._init_items(*p)

            k = self.compare_2_columns(column, new_col, **k)

        return k

    def process_column(self, column):

        """Processes default values for column"""

        # XXX: this is a snippet from SA processing of positional parameters

        if column.server_default is not None:

            if isinstance(column.server_default, sqlalchemy.FetchedValue):

                toinit.append(column.server_default)

            else:

                toinit.append(sqlalchemy.DefaultClause(column.server_default))

        if column.server_onupdate is not None:

            if isinstance(column.server_onupdate, FetchedValue):

                toinit.append(column.server_default)

            else:

                toinit.append(sqlalchemy.DefaultClause(column.server_onupdate,

                                            for_update=True))

        if toinit:

            column._init_items(*toinit)

    def _get_table(self):

        return getattr(self, '_table', None)

    def _set_table(self, table):

        if isinstance(table, basestring):

            if self.alter_metadata:

                if not self.meta:

                    raise ValueError("metadata must be specified for table"

                        " reflection when using alter_metadata")

                meta = self.meta

                if self.engine:

                    meta.bind = self.engine

        """

        engine = self.bind

        self.new_name = name

        visitorcallable = get_engine_visitor(engine, 'schemachanger')

        run_single_visitor(engine, visitorcallable, self, connection, **kwargs)

        # Fix metadata registration

        self.name = name

        self.deregister()

        self._set_parent(self.metadata)

    def _meta_key(self):

        return sqlalchemy.schema._get_table_key(self.name, self.schema)

    def deregister(self):

        """Remove this table from its metadata"""

class ChangesetColumn(object):

    """Changeset extensions to SQLAlchemy columns."""

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

        """Makes a call to :func:`alter_column` for the column this

        method is called on.

        """

        if 'table' not in k:

            k['table'] = self.table

        if 'engine' not in k:

                      labelA='model',

                      labelB='database',

                      excludeTables=excludeTables)

def getDiffOfModelAgainstModel(metadataA, metadataB, excludeTables=None):

    """

    Return differences of model against another model.

    :return: object which will evaluate to :keyword:`True` if there \

      are differences else :keyword:`False`.

    """

class ColDiff(object):

    """

    Container for differences in one :class:`~sqlalchemy.schema.Column`

    between two :class:`~sqlalchemy.schema.Table` instances, ``A``

    and ``B``.

    .. attribute:: col_A

      The :class:`~sqlalchemy.schema.Column` object for A.

    Engine is disposed after wrapped function is executed.

    .. versionadded: 0.6.0

    """

    url = a[0]

    engine = construct_engine(url, **kw)

    try:

        kw['engine'] = engine

        return f(*a, **kw)

    finally:

            engine.dispose()

class Memoize:

    """Memoize(fn) - an instance which acts like fn but memoizes its arguments

       Will only work on functions with non-mutable arguments

       ActiveState Code 52201

    """

    def __init__(self, fn):

        self.fn = fn

        self.memo = {}

    permission_id = Column("permission_id", Integer(), ForeignKey('permissions.permission_id'), nullable=False, unique=None, default=None)

    repository_id = Column("repository_id", Integer(), ForeignKey('repositories.repo_id'), nullable=False, unique=None, default=None)

    users_group = relationship('UsersGroup')

    permission = relationship('Permission')

    repository = relationship('Repository')

    def __repr__(self):

        return '<userGroup:%s => %s >' % (self.users_group, self.repository)

class UsersGroupToPerm(Base, BaseModel):

    __tablename__ = 'users_group_to_perm'

    users_group_to_perm_id = Column("users_group_to_perm_id", Integer(), nullable=False, unique=True, default=None, primary_key=True)

    users_group_id = Column("users_group_id", Integer(), ForeignKey('users_groups.users_group_id'), nullable=False, unique=None, default=None)

    permission_id = Column("permission_id", Integer(), ForeignKey('permissions.permission_id'), nullable=False, unique=None, default=None)

    users_group = relationship('UsersGroup')

    permission = relationship('Permission')

    @classmethod

    def has_perm(cls, users_group_id, perm):

        if not isinstance(perm, Permission):

            raise Exception('perm needs to be an instance of Permission class')

# 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/>.

from sqlalchemy import *

from sqlalchemy.exc import DatabaseError

from sqlalchemy.orm import relation, backref, class_mapper

from sqlalchemy.orm.session import Session

from rhodecode.model.meta import Base