log = logging.getLogger(__name__)

class ReposController(BaseController):

    """

    REST Controller styled on the Atom Publishing Protocol"""

    # To properly map this controller, ensure your config/routing.py

    # file has a resource setup:

    #     map.resource('repo', 'repos')

    @LoginRequired()

    @HasPermissionAnyDecorator('hg.admin', 'hg.create.repository')

    def __before__(self):

        c.admin_user = session.get('admin_user')

        c.admin_username = session.get('admin_username')

        super(ReposController, self).__before__()

    def __load_defaults(self):

        c.repo_groups = RepoGroup.groups_choices()

        c.repo_groups_choices = map(lambda k: unicode(k[0]), c.repo_groups)

        repo_model = RepoModel()

        c.users_array = repo_model.get_users_js()

        c.users_groups_array = repo_model.get_users_groups_js()

    def __load_data(self, repo_name=None):

        """

        Load defaults settings for edit, and update

        :param repo_name:

        """

        self.__load_defaults()

        c.repo_info = db_repo = Repository.get_by_repo_name(repo_name)

        repo = db_repo.scm_instance

        if c.repo_info is None:

            h.flash(_('%s repository is not mapped to db perhaps'

                      ' it was created or renamed from the filesystem'

                      ' please run the application again'

                      ' in order to rescan repositories') % repo_name,

                      category='error')

            return redirect(url('repos'))

        c.default_user_id = User.get_by_username('default').user_id

        c.in_public_journal = UserFollowing.query()\

            .filter(UserFollowing.user_id == c.default_user_id)\

            .filter(UserFollowing.follows_repository == c.repo_info).scalar()

        if c.repo_info.stats:

            # this is on what revision we ended up so we add +1 for count

            last_rev = c.repo_info.stats.stat_on_revision + 1

        else:

            last_rev = 0

        c.stats_revision = last_rev

        c.repo_last_rev = repo.count() if repo.revisions else 0

        if last_rev == 0 or c.repo_last_rev == 0:

            c.stats_percentage = 0

        else:

            c.stats_percentage = '%.2f' % ((float((last_rev)) /

                                            c.repo_last_rev) * 100)

        defaults = RepoModel()._get_defaults(repo_name)

        c.repos_list = [('', _('--REMOVE FORK--'))]

        c.repos_list += [(x.repo_id, x.repo_name) for x in

                   Repository.query().order_by(Repository.repo_name).all()]

        return defaults

    @HasPermissionAllDecorator('hg.admin')

    def index(self, format='html'):

        """GET /repos: All items in the collection"""

        # url('repos')

        c.repos_list = ScmModel().get_repos(Repository.query()

                                            .order_by(Repository.repo_name)

                                            .all(), sort_key='name_sort')

        return render('admin/repos/repos.html')

    @HasPermissionAnyDecorator('hg.admin', 'hg.create.repository')

    def create(self):

        """

        POST /repos: Create a new item"""

        # url('repos')

        self.__load_defaults()

        form_result = {}

        try:

            form_result = RepoForm(repo_groups=c.repo_groups_choices)()\

                            .to_python(dict(request.POST))

            RepoModel().create(form_result, self.rhodecode_user)

                .all()

            c.user_repos = ScmModel().get_repos(all_repos)

            c.form = htmlfill.render(

                render('admin/users/user_edit_my_account_form.html'),

                defaults=errors.value,

                errors=errors.error_dict or {},

                prefix_error=False,

                encoding="UTF-8")

            return render('admin/users/user_edit_my_account.html')

        except Exception:

            log.error(traceback.format_exc())

            h.flash(_('error occurred during update of user %s') \

                    % form_result.get('username'), category='error')

        return redirect(url('my_account'))

    @NotAnonymous()

    @HasPermissionAnyDecorator('hg.admin', 'hg.create.repository')

    def create_repository(self):

        """GET /_admin/create_repository: Form to create a new item"""

        c.repo_groups = RepoGroup.groups_choices()

        c.repo_groups_choices = map(lambda k: unicode(k[0]), c.repo_groups)

        new_repo = request.GET.get('repo', '')

        c.new_repo = repo_name_slug(new_repo)

        return render('admin/repos/repo_add_create_repository.html')

    def get_hg_ui_settings(self):

        ret = self.sa.query(RhodeCodeUi).all()

        if not ret:

            raise Exception('Could not get application ui settings !')

        settings = {}

        for each in ret:

            k = each.ui_key

            v = each.ui_value

            if k == '/':

                k = 'root_path'

            if k.find('.') != -1:

                k = k.replace('.', '_')

            if each.ui_section == 'hooks':

                v = each.ui_active

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

        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,

            }

            rm.create(form_data, user, just_db=True)

    sa.commit()

    removed = []

    if remove_obsolete:

        # remove from database those repositories that are not in the filesystem

        for repo in sa.query(Repository).all():

            if repo.repo_name not in initial_repo_list.keys():

                log.debug("Removing non existing repository found in db %s" %

                          repo.repo_name)

                removed.append(repo.repo_name)

                sa.delete(repo)

                sa.commit()

    # clear cache keys

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

    CacheInvalidation.clear_cache()

    sa.commit()

    return added, removed

# set cache regions for beaker so celery can utilise it

def add_cache(settings):

    cache_settings = {'regions': None}

    from rhodecode.lib.pidlock import DaemonLock, LockHeld

    repo_location = repo_location

    index_location = os.path.join(config['app_conf']['index_dir'])

    if not os.path.exists(index_location):

        os.makedirs(index_location)

    try:

        l = DaemonLock(file_=jn(dn(index_location), 'make_index.lock'))

        WhooshIndexingDaemon(index_location=index_location,

                             repo_location=repo_location)\

            .run(full_index=full_index)

        l.release()

    except LockHeld:

        pass

def create_test_env(repos_test_path, config):

    """

    Makes a fresh database and

    install test repository into tmp dir

    """

    from rhodecode.lib.db_manage import DbManage

    # PART ONE create db

    dbconf = config['sqlalchemy.db1.url']

    log.debug('making test db %s' % dbconf)

    # create test dir if it doesn't exist

    if not os.path.isdir(repos_test_path):

        log.debug('Creating testdir %s' % repos_test_path)

        os.makedirs(repos_test_path)

    dbmanage = DbManage(log_sql=True, dbconf=dbconf, root=config['here'],

                        tests=True)

    dbmanage.create_tables(override=True)

    dbmanage.create_settings(dbmanage.config_prompt(repos_test_path))

    dbmanage.create_default_user()

    dbmanage.admin_prompt()

    dbmanage.create_permissions()

    dbmanage.populate_default_permissions()

    Session.commit()

    # PART TWO make test repo

    log.debug('making test vcs repositories')

    idx_path = config['app_conf']['index_dir']

    data_path = config['app_conf']['cache_dir']

    #clean index and data

    if idx_path and os.path.exists(idx_path):

        log.debug('remove %s' % idx_path)

        shutil.rmtree(idx_path)

    if data_path and os.path.exists(data_path):

        log.debug('remove %s' % data_path)

        shutil.rmtree(data_path)

    cur_dir = dn(dn(abspath(__file__)))

    tar = tarfile.open(jn(cur_dir, 'tests', "vcs_test_hg.tar.gz"))

    tar.extractall(jn(TESTS_TMP_PATH, HG_REPO))

    tar.close()

    #LOAD VCS test stuff

    from rhodecode.tests.vcs import setup_package

    setup_package()

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

# PASTER COMMANDS

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

class BasePasterCommand(Command):

    """

    Abstract Base Class for paster commands.

    The celery commands are somewhat aggressive about loading

    celery.conf, and since our module sets the `CELERY_LOADER`

    environment variable to our loader, we have to bootstrap a bit and

    make sure we've had a chance to load the pylons config off of the

    command line, otherwise everything fails.

    """

    min_args = 1

    min_args_error = "Please provide a paster config file as an argument."

    takes_config_file = 1

    requires_config_file = True

    def notify_msg(self, msg, log=False):

    @classmethod

    def create_or_update_hook(cls, key, val):

        new_ui = cls.get_by_key(key).scalar() or cls()

        new_ui.ui_section = 'hooks'

        new_ui.ui_active = True

        new_ui.ui_key = key

        new_ui.ui_value = val

        Session.add(new_ui)

class User(Base, BaseModel):

    __tablename__ = 'users'

    __table_args__ = (

        UniqueConstraint('username'), UniqueConstraint('email'),

        {'extend_existing': True, 'mysql_engine': 'InnoDB',

         'mysql_charset': 'utf8'}

    )

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

    username = Column("username", String(length=255, convert_unicode=False, assert_unicode=None), nullable=True, unique=None, default=None)

    password = Column("password", String(length=255, convert_unicode=False, assert_unicode=None), nullable=True, unique=None, default=None)

    active = Column("active", Boolean(), nullable=True, unique=None, default=None)

    admin = Column("admin", Boolean(), nullable=True, unique=None, default=False)

    lastname = Column("lastname", String(length=255, convert_unicode=False, assert_unicode=None), nullable=True, unique=None, default=None)

    _email = Column("email", String(length=255, convert_unicode=False, assert_unicode=None), nullable=True, unique=None, default=None)

    last_login = Column("last_login", DateTime(timezone=False), nullable=True, unique=None, default=None)

    ldap_dn = Column("ldap_dn", String(length=255, convert_unicode=False, assert_unicode=None), nullable=True, unique=None, default=None)

    api_key = Column("api_key", String(length=255, convert_unicode=False, assert_unicode=None), nullable=True, unique=None, default=None)

    user_log = relationship('UserLog', cascade='all')

    user_perms = relationship('UserToPerm', primaryjoin="User.user_id==UserToPerm.user_id", cascade='all')

    repositories = relationship('Repository')

    user_followers = relationship('UserFollowing', primaryjoin='UserFollowing.follows_user_id==User.user_id', cascade='all')

    repo_to_perm = relationship('UserRepoToPerm', primaryjoin='UserRepoToPerm.user_id==User.user_id', cascade='all')

    repo_group_to_perm = relationship('UserRepoGroupToPerm', primaryjoin='UserRepoGroupToPerm.user_id==User.user_id', cascade='all')

    group_member = relationship('UsersGroupMember', cascade='all')

    notifications = relationship('UserNotification', cascade='all')

    # notifications assigned to this user

    user_created_notifications = relationship('Notification', cascade='all')

    # comments created by this user

    user_comments = relationship('ChangesetComment', cascade='all')

    @hybrid_property

    def email(self):

    users_group_member_id = Column("users_group_member_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)

    user_id = Column("user_id", Integer(), ForeignKey('users.user_id'), nullable=False, unique=None, default=None)

    user = relationship('User', lazy='joined')

    users_group = relationship('UsersGroup')

    def __init__(self, gr_id='', u_id=''):

        self.users_group_id = gr_id

        self.user_id = u_id

class Repository(Base, BaseModel):

    __tablename__ = 'repositories'

    __table_args__ = (

        UniqueConstraint('repo_name'),

        {'extend_existing': True, 'mysql_engine': 'InnoDB',

         'mysql_charset': 'utf8'},

    )

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

    repo_name = Column("repo_name", String(length=255, convert_unicode=False, assert_unicode=None), nullable=False, unique=True, default=None)

    clone_uri = Column("clone_uri", String(length=255, convert_unicode=False, assert_unicode=None), nullable=True, unique=False, default=None)

    user_id = Column("user_id", Integer(), ForeignKey('users.user_id'), nullable=False, unique=False, default=None)

    private = Column("private", Boolean(), nullable=True, unique=None, default=None)

    enable_statistics = Column("statistics", Boolean(), nullable=True, unique=None, default=True)

    enable_downloads = Column("downloads", Boolean(), nullable=True, unique=None, default=True)

    description = Column("description", String(length=10000, convert_unicode=False, assert_unicode=None), nullable=True, unique=None, default=None)

    created_on = Column('created_on', DateTime(timezone=False), nullable=True, unique=None, default=datetime.datetime.now)

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

    group_id = Column("group_id", Integer(), ForeignKey('groups.group_id'), nullable=True, unique=False, default=None)

    user = relationship('User')

    fork = relationship('Repository', remote_side=repo_id)

    group = relationship('RepoGroup')

    repo_to_perm = relationship('UserRepoToPerm', cascade='all', order_by='UserRepoToPerm.repo_to_perm_id')

    users_group_to_perm = relationship('UsersGroupRepoToPerm', cascade='all')

    stats = relationship('Statistics', cascade='all', uselist=False)

    followers = relationship('UserFollowing', primaryjoin='UserFollowing.follows_repo_id==Repository.repo_id', cascade='all')

    logs = relationship('UserLog')

    def __unicode__(self):

                                   self.repo_name)

    @classmethod

    def url_sep(cls):

        return URL_SEP

    @classmethod

    def get_by_repo_name(cls, repo_name):

        q = Session.query(cls).filter(cls.repo_name == repo_name)

        q = q.options(joinedload(Repository.fork))\

                .options(joinedload(Repository.user))\

                .options(joinedload(Repository.group))

        return q.scalar()

    @classmethod

    def get_by_full_path(cls, repo_full_path):

        repo_name = repo_full_path.split(cls.base_path(), 1)[-1]

        return cls.get_by_repo_name(repo_name.strip(URL_SEP))

    @classmethod

    def get_repo_forks(cls, repo_id):

        return cls.query().filter(Repository.fork_id == repo_id)

    @classmethod

        chained_validators = [ValidPasswordsMatch, ValidPassword]

    return _RegisterForm

def PasswordResetForm():

    class _PasswordResetForm(formencode.Schema):

        allow_extra_fields = True

        filter_extra_fields = True

        email = All(ValidSystemEmail(), Email(not_empty=True))

    return _PasswordResetForm

def RepoForm(edit=False, old_data={}, supported_backends=BACKENDS.keys(),

             repo_groups=[]):

    class _RepoForm(formencode.Schema):

        allow_extra_fields = True

        filter_extra_fields = False

        repo_name = All(UnicodeString(strip=True, min=1, not_empty=True),

                        SlugifyName())

        clone_uri = All(UnicodeString(strip=True, min=1, not_empty=False))

        repo_group = OneOf(repo_groups, hideList=True)

        repo_type = OneOf(supported_backends)

        private = StringBoolean(if_missing=False)

        enable_statistics = StringBoolean(if_missing=False)

        enable_downloads = StringBoolean(if_missing=False)

        if edit:

            #this is repo owner

            user = All(UnicodeString(not_empty=True), ValidRepoUser)

        chained_validators = [ValidCloneUri()(),

                              ValidRepoName(edit, old_data),

                              ValidPerms()]

    return _RepoForm

    class _RepoForkForm(formencode.Schema):

        allow_extra_fields = True

        filter_extra_fields = False

        repo_name = All(UnicodeString(strip=True, min=1, not_empty=True),

                        SlugifyName())

        repo_group = OneOf(repo_groups, hideList=True)

        repo_type = All(ValidForkType(old_data), OneOf(supported_backends))

        description = UnicodeString(strip=True, min=1, not_empty=True)

        private = StringBoolean(if_missing=False)

        copy_permissions = StringBoolean(if_missing=False)

        update_after_clone = StringBoolean(if_missing=False)

        fork_parent_id = UnicodeString()

        chained_validators = [ValidForkName(edit, old_data)]

    return _RepoForkForm

    class _RepoForm(formencode.Schema):

        allow_extra_fields = True

        filter_extra_fields = False

        repo_name = All(UnicodeString(strip=True, min=1, not_empty=True),

                        SlugifyName())

        description = UnicodeString(strip=True, min=1, not_empty=True)

        repo_group = OneOf(repo_groups, hideList=True)

        private = StringBoolean(if_missing=False)

        chained_validators = [ValidRepoName(edit, old_data), ValidPerms(),

                              ValidSettings]

    return _RepoForm

def ApplicationSettingsForm():

    class _ApplicationSettingsForm(formencode.Schema):

        allow_extra_fields = True

        filter_extra_fields = False

        rhodecode_title = UnicodeString(strip=True, min=1, not_empty=True)

        rhodecode_realm = UnicodeString(strip=True, min=1, not_empty=True)

        rhodecode_ga_code = UnicodeString(strip=True, min=1, not_empty=False)

    return _ApplicationSettingsForm

def ApplicationUiSettingsForm():

    class _ApplicationUiSettingsForm(formencode.Schema):

        allow_extra_fields = True

        filter_extra_fields = False

        web_push_ssl = OneOf(['true', 'false'], if_missing='false')

        paths_root_path = All(ValidPath(), UnicodeString(strip=True, min=1, not_empty=True))

        hooks_changegroup_update = OneOf(['True', 'False'], if_missing=False)

        hooks_changegroup_repo_size = OneOf(['True', 'False'], if_missing=False)

    :created_on: Apr 9, 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 time

import traceback

import logging

import cStringIO

from sqlalchemy import func

from rhodecode.lib.vcs import get_backend

from rhodecode.lib.vcs.exceptions import RepositoryError

from rhodecode.lib.vcs.utils.lazy import LazyProperty

from rhodecode.lib.vcs.nodes import FileNode

from rhodecode import BACKENDS

from rhodecode.lib import helpers as h

from rhodecode.lib.utils2 import safe_str, safe_unicode

from rhodecode.lib.auth import HasRepoPermissionAny, HasReposGroupPermissionAny

from rhodecode.lib.utils import get_repos as get_filesystem_repos, make_ui, \

    action_logger, EmptyChangeset, REMOVED_REPO_PAT

from rhodecode.model import BaseModel

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

    UserFollowing, UserLog, User, RepoGroup

log = logging.getLogger(__name__)

class UserTemp(object):

    def __init__(self, user_id):

        self.user_id = user_id

    def __repr__(self):

        :param flat: return as a list, if False returns a dict with decription

        """

        _files = list()

        _dirs = list()

        try:

            _repo = self.__get_repo(repo_name)

            changeset = _repo.scm_instance.get_changeset(revision)

            root_path = root_path.lstrip('/')

            for topnode, dirs, files in changeset.walk(root_path):

                for f in files:

                    _files.append(f.path if flat else {"name": f.path,

                                                       "type": "file"})

                for d in dirs:

                    _dirs.append(d.path if flat else {"name": d.path,

                                                      "type": "dir"})

        except RepositoryError:

            log.debug(traceback.format_exc())

            raise

        return _dirs, _files

    def get_unread_journal(self):

        return self.sa.query(UserLog).count()

            </div>

            <div class="input">

                ${h.text('clone_uri',class_="small")}

                <span class="help-block">${_('Optional http[s] url from which repository should be cloned.')}</span>

            </div>

         </div>

         <div class="field">

             <div class="label">

                 <label for="repo_group">${_('Repository group')}:</label>

             </div>

             <div class="input">

                 ${h.select('repo_group',request.GET.get('parent_group'),c.repo_groups,class_="medium")}

                 <span class="help-block">${_('Optional select a group to put this repository into.')}</span>

             </div>

         </div>

        <div class="field">

            <div class="label">

                <label for="repo_type">${_('Type')}:</label>

            </div>

            <div class="input">

                ${h.select('repo_type','hg',c.backends,class_="small")}

                <span class="help-block">${_('Type of repository to create.')}</span>

            </div>

         </div>

        <div class="field">

            <div class="label label-textarea">

                <label for="description">${_('Description')}:</label>

            </div>

            <div class="textarea text-area editor">

                ${h.textarea('description')}

                <span class="help-block">${_('Keep it short and to the point. Use a README file for longer descriptions.')}</span>

            </div>

         </div>

        <div class="field">

            <div class="label label-checkbox">

                <label for="private">${_('Private repository')}:</label>

            </div>

            <div class="checkboxes">

                ${h.checkbox('private',value="True")}

                <span class="help-block">${_('Private repositories are only visible to people explicitly added as collaborators.')}</span>

            </div>

         </div>

        <div class="buttons">

          ${h.submit('add',_('add'),class_="ui-button")}

        </div>

    </div>

</div>

${h.end_form()}

	           </div>

	           <div class="input">

	               ${h.text('clone_uri',class_="medium")}

                 <span class="help-block">${_('Optional http[s] url from which repository should be cloned.')}</span>

	           </div>

	        </div>

	        <div class="field">

	            <div class="label">

	                <label for="repo_group">${_('Repository group')}:</label>

	            </div>

	            <div class="input">

	                ${h.select('repo_group','',c.repo_groups,class_="medium")}

                    <span class="help-block">${_('Optional select a group to put this repository into.')}</span>

	            </div>

	        </div>

            <div class="field">

                <div class="label">

                    <label for="repo_type">${_('Type')}:</label>

                </div>

                <div class="input">

                    ${h.select('repo_type','hg',c.backends,class_="medium")}

                </div>

            </div>

            <div class="field">

                <div class="label label-textarea">

                    <label for="description">${_('Description')}:</label>

                </div>

                <div class="textarea text-area editor">

                    ${h.textarea('description')}

                    <span class="help-block">${_('Keep it short and to the point. Use a README file for longer descriptions.')}</span>

                </div>

            </div>

            <div class="field">

                <div class="label label-checkbox">

                    <label for="private">${_('Private repository')}:</label>

                </div>

                <div class="checkboxes">

                    ${h.checkbox('private',value="True")}

                    <span class="help-block">${_('Private repositories are only visible to people explicitly added as collaborators.')}</span>

                </div>

            </div>

            <div class="field">

                <div class="label label-checkbox">

                    <label for="enable_statistics">${_('Enable statistics')}:</label>

                </div>

                <div class="checkboxes">

                    ${h.checkbox('enable_statistics',value="True")}

               <ul>

                    <li>${_('''All actions made on this repository will be accessible to everyone in public journal''')}

                    </li>

               </ul>

               </div>

        </div>

        ${h.end_form()}

        <h3>${_('Delete')}</h3>

        ${h.form(url('repo', repo_name=c.repo_info.repo_name),method='delete')}

        <div class="form">

           <div class="fields">

               ${h.submit('remove_%s' % c.repo_info.repo_name,_('Remove this repository'),class_="ui-btn red",onclick="return confirm('"+_('Confirm to delete this repository')+"');")}

           </div>

           <div class="field" style="border:none;color:#888">

           <ul>

                <li>${_('''This repository will be renamed in a special way in order to be unaccesible for RhodeCode and VCS systems.

                         If you need fully delete it from filesystem please do it manually''')}

                </li>

           </ul>

           </div>

        </div>

        ${h.end_form()}

        ${h.form(url('repo_as_fork', repo_name=c.repo_info.repo_name),method='put')}

        <div class="form">

           <div class="fields">

               ${h.select('id_fork_of','',c.repos_list,class_="medium")}

               ${h.submit('set_as_fork_%s' % c.repo_info.repo_name,_('set'),class_="ui-btn",)}

           </div>

               <div class="field" style="border:none;color:#888">

               <ul>

               </ul>

               </div>

        </div>

        ${h.end_form()}

</div>

</%def>

from unittest import TestCase

from tempfile import _RandomNameSequence

from paste.deploy import loadapp

from paste.script.appinstall import SetupCommand

from pylons import config, url

from routes.util import URLGenerator

from webtest import TestApp

from rhodecode import is_windows

from rhodecode.model.meta import Session

from rhodecode.model.db import User

import pylons.test

os.environ['TZ'] = 'UTC'

if not is_windows:

    time.tzset()

log = logging.getLogger(__name__)

__all__ = [

    'TEST_USER_REGULAR_PASS', 'TEST_USER_REGULAR_EMAIL',

    'TEST_USER_REGULAR2_LOGIN', 'TEST_USER_REGULAR2_PASS',

]

# Invoke websetup with the current config file

# SetupCommand('setup-app').run([config_file])

##RUNNING DESIRED TESTS

# nosetests -x rhodecode.tests.functional.test_admin_settings:TestSettingsController.test_my_account

# nosetests --pdb --pdb-failures