import sys

import uuid

import logging

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

from rhodecode import __dbversion__

from rhodecode.model import meta

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

from sqlalchemy.engine import create_engine

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

                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 ('TODO:')

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

    def fix_repo_paths(self):

        """

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

        """

                    ('ldap_tls_reqcert', ''), ('ldap_dn_user', ''),

                    ('ldap_dn_pass', ''), ('ldap_base_dn', ''),

                    ('ldap_filter', ''), ('ldap_search_scope', ''),

                    ('ldap_attr_login', ''), ('ldap_attr_firstname', ''),

                    ('ldap_attr_lastname', ''), ('ldap_attr_email', '')]:

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

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

                continue

            setting = RhodeCodeSetting(k, v)

            self.sa.add(setting)

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

        if retries == 3:

            log.info('Setting up repositories config')

        if not self.tests and not test_repo_path:

            path = raw_input(

                 'Enter a valid path to store repositories. '

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

            )

        else:

            path = test_repo_path

        path_ok = True

from webhelpers.text import collapse, remove_formatting, strip_tags

from vcs import get_backend

from vcs.backends.base import BaseChangeset

from vcs.utils.lazy import LazyProperty

from vcs.utils.helpers import get_scm

from vcs.exceptions import VCSError

from rhodecode.lib.caching_query import FromCache

from rhodecode.model import meta

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

from rhodecode.model.meta import Session

from rhodecode.model.repos_group import ReposGroupModel

log = logging.getLogger(__name__)

def recursive_replace(str_, replace=' '):

    """Recursive replace of given sign to just one instance

    :param str_: given string

    :param replace: char to find and replace multiple instances

    :param initial_repo_list: list of repositories found by scanning methods

    :param remove_obsolete: check for obsolete entries in database

    """

    from rhodecode.model.repo import RepoModel

    sa = meta.Session

    rm = RepoModel()

    user = sa.query(User).filter(User.admin == True).first()

    if user is None:

        raise Exception('Missing administrative account !')

    added = []

    for name, repo in initial_repo_list.items():

        group = map_groups(name.split(Repository.url_sep()))

        if not rm.get_by_repo_name(name, cache=False):

            log.info('repository %s not found creating default' % name)

            added.append(name)

            form_data = {

             'repo_name': name,

             'repo_name_full': name,

             'repo_type': repo.alias,

             'description': repo.description \

                if repo.description != 'unknown' else '%s repository' % name,

             'private': False,