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

"""

    rhodecode.lib.db_manage

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

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

    of database as well as for migration operations

    :created_on: Apr 10, 2010

    :author: marcink

    :copyright: (C) 2010-2012 Marcin Kuzminski <marcin@python-works.com>

    :license: GPLv3, see COPYING for more details.

"""

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

import os

import sys

import uuid

import logging

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

from rhodecode import __dbversion__

from rhodecode.model.user import UserModel

from rhodecode.lib.utils import ask_ok

from rhodecode.model import init_model

from rhodecode.model.db import User, Permission, RhodeCodeUi, \

    RhodeCodeSetting, UserToPerm, DbMigrateVersion, RepoGroup, \

    UserRepoGroupToPerm

from sqlalchemy.engine import create_engine

from sqlalchemy.schema import MetaData

from rhodecode.model.repos_group import ReposGroupModel

#from rhodecode.model import meta

from rhodecode.model.meta import Session, Base

log = logging.getLogger(__name__)

class DbManage(object):

    def __init__(self, log_sql, dbconf, root, tests=False):

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

        self.tests = tests

        self.root = root

        self.dburi = dbconf

        self.log_sql = log_sql

        self.db_exists = False

        self.init_db()

    def init_db(self):

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

        init_model(engine)

        self.sa = Session()

    def create_tables(self, override=False, defaults={}):

        """

        Create a auth database

        """

        quiet = defaults.get('quiet')

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

        if self.tests or quiet:

            destroy = True

        else:

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

        if not destroy:

            sys.exit()

        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_id = 'rhodecode_db_migrations'

        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 rhodecode.lib.dbmigrate.migrate.versioning import api

        from rhodecode.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:

            sys.exit('Nothing done')

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

                             'rhodecode/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)

        print (msg)

        if curr_version == __dbversion__:

            sys.exit('This database is already at the newest version')

        #======================================================================

        # UPGRADE STEPS

        #======================================================================

        class UpgradeSteps(object):

            """

            Those steps follow schema versions so for example schema

            for example schema with seq 002 == step_2 and so on.

            """

            def __init__(self, klass):

                self.klass = klass

            def step_0(self):

                # step 0 is the schema upgrade, and than follow proper upgrades

                print ('attempting to do database upgrade to version %s' \

                                % __dbversion__)

                api.upgrade(db_uri, repository_path, __dbversion__)

                print ('Schema upgrade completed')

            def step_1(self):

                pass

            def step_2(self):

                print ('Patching repo paths for newer version of RhodeCode')

                self.klass.fix_repo_paths()

                print ('Patching default user of RhodeCode')

                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):

                print ('create permissions and fix groups')

                self.klass.create_permissions()

                self.klass.fixup_groups()

            def step_5(self):

                pass

            def step_6(self):

                print ('re-checking permissions')

                self.klass.create_permissions()

                print ('installing new hooks')

                hooks4 = RhodeCodeUi()

                hooks4.ui_key = RhodeCodeUi.HOOK_PRE_PUSH

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

                Session().add(hooks4)

                hooks6 = RhodeCodeUi()

                hooks6.ui_section = 'hooks'

                hooks6.ui_key = RhodeCodeUi.HOOK_PRE_PULL

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

                Session().add(hooks6)

                print ('installing hgsubversion option')

                # enable hgsubversion disabled by default

                hgsubversion = RhodeCodeUi()

                hgsubversion.ui_section = 'extensions'

                hgsubversion.ui_key = 'hgsubversion'

                hgsubversion.ui_value = ''

                hgsubversion.ui_active = False

                Session().add(hgsubversion)

                print ('installing hg git option')

                # enable hggit disabled by default

                hggit = RhodeCodeUi()

                hggit.ui_section = 'extensions'

                hggit.ui_key = 'hggit'

                hggit.ui_value = ''

                hggit.ui_active = False

                Session().add(hggit)

                print ('re-check default permissions')

                self.klass.populate_default_permissions()

        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:

            self.sa.add(paths)

            self.sa.commit()

        except:

            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 == 'default')\

                .one()

        def_user.name = 'Anonymous'

        def_user.lastname = 'User'

        def_user.email = 'anonymous@rhodecode.org'

        try:

            self.sa.add(def_user)

            self.sa.commit()

        except:

            self.sa.rollback()

            raise

    def fix_settings(self):

        """

        Fixes rhodecode settings adds ga_code key for google analytics

        """

        hgsettings3 = RhodeCodeSetting('ga_code', '')

        try:

            self.sa.add(hgsettings3)

            self.sa.commit()

        except:

            self.sa.rollback()

            raise

    def admin_prompt(self, second=False, defaults={}):

        if not self.tests:

            import getpass

            # defaults

            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 rhodecode.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):

        """

        Creates ui settings, fills out hooks

        and disables dotencode

        """

        #HOOKS

        hooks1_key = RhodeCodeUi.HOOK_UPDATE

        hooks1_ = self.sa.query(RhodeCodeUi)\

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

        hooks1 = RhodeCodeUi() 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 = RhodeCodeUi.HOOK_REPO_SIZE

        hooks2_ = self.sa.query(RhodeCodeUi)\

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

        hooks2 = RhodeCodeUi() if hooks2_ is None else hooks2_

        hooks2.ui_section = 'hooks'

        hooks2.ui_key = hooks2_key

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

        self.sa.add(hooks2)

        hooks3 = RhodeCodeUi()

        hooks3.ui_section = 'hooks'

        hooks3.ui_key = RhodeCodeUi.HOOK_PUSH

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

        self.sa.add(hooks3)

        hooks4 = RhodeCodeUi()

        hooks4.ui_section = 'hooks'

        hooks4.ui_key = RhodeCodeUi.HOOK_PRE_PUSH

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

        self.sa.add(hooks4)

        hooks5 = RhodeCodeUi()

        hooks5.ui_section = 'hooks'

        hooks5.ui_key = RhodeCodeUi.HOOK_PULL

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

        self.sa.add(hooks5)

        hooks6 = RhodeCodeUi()

        hooks6.ui_section = 'hooks'

        hooks6.ui_key = RhodeCodeUi.HOOK_PRE_PULL

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

        self.sa.add(hooks6)

import logging

import datetime

from sqlalchemy import *

from sqlalchemy.exc import DatabaseError

from sqlalchemy.orm import relation, backref, class_mapper

from sqlalchemy.orm.session import Session

from sqlalchemy.ext.declarative import declarative_base

from rhodecode.lib.dbmigrate.migrate import *

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

from rhodecode.model.meta import Base

from rhodecode.model import meta

log = logging.getLogger(__name__)

def upgrade(migrate_engine):

    """

    Upgrade operations go here.

    Don't create your own engine; bind migrate_engine to your metadata

    """

    #==========================================================================

    # USEREMAILMAP

    #==========================================================================

    from rhodecode.lib.dbmigrate.schema.db_1_4_0 import UserEmailMap

    tbl = UserEmailMap.__table__

    tbl.create()

    #==========================================================================

    # PULL REQUEST

    #==========================================================================

    from rhodecode.lib.dbmigrate.schema.db_1_4_0 import PullRequest

    tbl = PullRequest.__table__

    tbl.create()

    #==========================================================================

    # PULL REQUEST REVIEWERS

    #==========================================================================

    from rhodecode.lib.dbmigrate.schema.db_1_4_0 import PullRequestReviewers

    tbl = PullRequestReviewers.__table__

    tbl.create()

    #==========================================================================

    # CHANGESET STATUS

    #==========================================================================

    from rhodecode.lib.dbmigrate.schema.db_1_4_0 import ChangesetStatus

    tbl = ChangesetStatus.__table__

    tbl.create()

    ## RESET COMPLETLY THE metadata for sqlalchemy to use the 1_3_0 Base 

    Base = declarative_base()

    Base.metadata.clear()

    Base.metadata = MetaData()

    Base.metadata.bind = migrate_engine

    meta.Base = Base

    #==========================================================================

    # USERS TABLE

    #==========================================================================

    from rhodecode.lib.dbmigrate.schema.db_1_3_0 import User

    tbl = User.__table__

    # change column name -> firstname

    col = User.__table__.columns.name

    col.alter(index=Index('u_username_idx', 'username'))

    col.alter(index=Index('u_email_idx', 'email'))

    col.alter(name="firstname", table=tbl)

    inherit_default_permissions = Column("inherit_default_permissions",

                                         Boolean(), nullable=True, unique=None,

                                         default=True)

    inherit_default_permissions.create(table=tbl)

    inherit_default_permissions.alter(nullable=False, default=True, table=tbl)

    #==========================================================================

    # REPOSITORIES

    #==========================================================================

    from rhodecode.lib.dbmigrate.schema.db_1_3_0 import Repository

    tbl = Repository.__table__

    enable_locking = Column("enable_locking", Boolean(), nullable=True,

                            unique=None, default=False)

    enable_locking.create(table=tbl)

    enable_locking.alter(nullable=False, default=False, table=tbl)

    _locked = Column("locked", String(255), nullable=True, unique=False,

                     default=None)

    _locked.create(table=tbl)

    landing_rev = Column("landing_revision", String(255), nullable=True,

                         unique=False, default='tip')

    landing_rev.create(table=tbl)

    landing_rev.alter(nullable=False, default='tip', table=tbl)

    #==========================================================================

    # GROUPS

    #==========================================================================

    from rhodecode.lib.dbmigrate.schema.db_1_3_0 import RepoGroup

    tbl = RepoGroup.__table__

    enable_locking = Column("enable_locking", Boolean(), nullable=True,

                            unique=None, default=False)

    enable_locking.create(table=tbl)

    enable_locking.alter(nullable=False, default=False)

    #==========================================================================

    # CACHE INVALIDATION

    #==========================================================================

    from rhodecode.lib.dbmigrate.schema.db_1_3_0 import CacheInvalidation

    tbl = CacheInvalidation.__table__

    # change column name -> firstname

    col = CacheInvalidation.__table__.columns.cache_key

    col.alter(index=Index('key_idx', 'cache_key'))

    #==========================================================================

    # NOTIFICATION

    #==========================================================================

    from rhodecode.lib.dbmigrate.schema.db_1_3_0 import Notification

    tbl = Notification.__table__

    # change column name -> firstname

    col = Notification.__table__.columns.type

    col.alter(index=Index('notification_type_idx', 'type'),)

    #==========================================================================

    # CHANGESET_COMMENTS

    #==========================================================================

    from rhodecode.lib.dbmigrate.schema.db_1_3_0 import ChangesetComment

    tbl = ChangesetComment.__table__

    col = ChangesetComment.__table__.columns.revision

    col.alter(index=Index('cc_revision_idx', 'revision'),)

    hl_lines = Column('hl_lines', Unicode(512), nullable=True)

    hl_lines.create(table=tbl)

    created_on = Column('created_on', DateTime(timezone=False), nullable=True,

                        default=datetime.datetime.now)

    created_on.create(table=tbl)

    created_on.alter(nullable=False, default=datetime.datetime.now)

    modified_at = Column('modified_at', DateTime(timezone=False), nullable=False,

                         default=datetime.datetime.now)

    modified_at.alter(type=DateTime(timezone=False), table=tbl)

    pull_request_id = Column("pull_request_id", Integer(),

                             ForeignKey('pull_requests.pull_request_id'),

                             nullable=True)

    pull_request_id.create(table=tbl)

    ## RESET COMPLETLY THE metadata for sqlalchemy back after using 1_3_0

    Base = declarative_base()

    Base.metadata.clear()

    Base.metadata = MetaData()

    Base.metadata.bind = migrate_engine

    meta.Base = Base

def downgrade(migrate_engine):

    meta = MetaData()

    meta.bind = migrate_engine