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

# Alembic migration environment (configuration).

import logging

from logging.config import fileConfig

from alembic import context

from sqlalchemy import engine_from_config, pool

from kallithea.model import db

# The alembic.config.Config object, which wraps the current .ini file.

config = context.config

# Default to use the main Kallithea database string in [app:main].

# For advanced uses, this can be overridden by specifying an explicit

# [alembic] sqlalchemy.url.

database_url = (

    config.get_main_option('sqlalchemy.url') or

    config.get_section_option('app:main', 'sqlalchemy.db1.url')

)

# Configure default logging for Alembic. (This can be overriden by the

# config file, but usually isn't.)

logging.getLogger('alembic').setLevel(logging.WARNING)

# Setup Python loggers based on the config file provided to the alembic

def include_in_autogeneration(object, name, type, reflected, compare_to):

    """Filter changes subject to autogeneration of migrations. """

    # Don't include changes to sqlite_sequence.

    if type == 'table' and name == 'sqlite_sequence':

        return False

    return True

def run_migrations_offline():

    """Run migrations in 'offline' (--sql) mode.

    This produces an SQL script instead of directly applying the changes.

    Some migrations may not run in offline mode.

    """

    context.configure(

        url=database_url,

        literal_binds=True,

    )

    with context.begin_transaction():

        context.run_migrations()

def run_migrations_online():

    """Run migrations in 'online' mode.

    Connects to the database and directly applies the necessary

    migrations.

    """

    cfg = config.get_section(config.config_ini_section)

    cfg['sqlalchemy.url'] = database_url

    connectable = engine_from_config(

        cfg,

        prefix='sqlalchemy.',

        poolclass=pool.NullPool)

    with connectable.connect() as connection:

        context.configure(

            connection=connection,

            # Support autogeneration of migration scripts based on "diff" between

            # current database schema and kallithea.model.db schema.

            target_metadata=db.Base.metadata,

            include_object=include_in_autogeneration,

            render_as_batch=True, # batch mode is needed for SQLite support

        )

        with context.begin_transaction():

            context.run_migrations()

if context.is_offline_mode():

    run_migrations_offline()

else:

    run_migrations_online()

# -*- 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

from kallithea import __dbversion__, __py_version__, EXTERN_TYPE_INTERNAL

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, RepoGroup, \

    UserRepoGroupToPerm, CacheInvalidation, 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

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

        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 or {}

        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 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('*', '')

        self.sa.add(paths)

        self.sa.commit()

    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'

        self.sa.add(def_user)

        self.sa.commit()

    def fix_settings(self):

        """

        Fixes kallithea settings adds ga_code key for google analytics

        """

        hgsettings3 = Setting('ga_code', '')

        self.sa.add(hgsettings3)

        self.sa.commit()

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

        """