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

"""

    rhodecode.controllers.home

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

    Home controller for Rhodecode

    :created_on: Feb 18, 2010

    :author: marcink

    :copyright: (C) 2009-2011 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 logging

from pylons import tmpl_context as c, request

from paste.httpexceptions import HTTPBadRequest

from rhodecode.lib.auth import LoginRequired

from rhodecode.lib.base import BaseController, render

from rhodecode.model.db import RepoGroup, Repository

log = logging.getLogger(__name__)

class HomeController(BaseController):

    @LoginRequired()

    def __before__(self):

        super(HomeController, self).__before__()

    def index(self):

        c.repos_list = self.scm_model.get_repos()

        return render('/index.html')

    def repo_switcher(self):

        if request.is_xhr:

            all_repos = Repository.query().order_by(Repository.repo_name).all()

            c.repos_list = self.scm_model.get_repos(all_repos,

                                                    sort_key='name_sort')

            return render('/repo_switcher_list.html')

        else:

            return HTTPBadRequest()

    def branch_tag_switcher(self, repo_name):

        if request.is_xhr:

            c.rhodecode_db_repo = Repository.get_by_repo_name(c.repo_name)

            c.rhodecode_repo = c.rhodecode_db_repo.scm_instance

            return render('/switch_to_list.html')

        else:

            return HTTPBadRequest()

"""caching_query.py

Represent persistence structures which allow the usage of

Beaker caching with SQLAlchemy.

The three new concepts introduced here are:

 * CachingQuery - a Query subclass that caches and

   retrieves results in/from Beaker.

 * FromCache - a query option that establishes caching

   parameters on a Query

 * RelationshipCache - a variant of FromCache which is specific

   to a query invoked during a lazy load.

 * _params_from_query - extracts value parameters from

   a Query.

The rest of what's here are standard SQLAlchemy and

Beaker constructs.

"""

import beaker

from beaker.exceptions import BeakerException

from sqlalchemy.orm.interfaces import MapperOption

from sqlalchemy.orm.query import Query

from sqlalchemy.sql import visitors

class CachingQuery(Query):

    """A Query subclass which optionally loads full results from a Beaker

    cache region.

    The CachingQuery stores additional state that allows it to consult

    a Beaker cache before accessing the database:

    * A "region", which is a cache region argument passed to a

      Beaker CacheManager, specifies a particular cache configuration

      (including backend implementation, expiration times, etc.)

    * A "namespace", which is a qualifying name that identifies a

      group of keys within the cache.  A query that filters on a name

      might use the name "by_name", a query that filters on a date range

      to a joined table might use the name "related_date_range".

    When the above state is present, a Beaker cache is retrieved.

    The "namespace" name is first concatenated with

    a string composed of the individual entities and columns the Query

    requests, i.e. such as ``Query(User.id, User.name)``.

    The Beaker cache is then loaded from the cache manager based

    on the region and composed namespace.  The key within the cache

    itself is then constructed against the bind parameters specified

    by this query, which are usually literals defined in the

    WHERE clause.

    The FromCache and RelationshipCache mapper options below represent

    the "public" method of configuring this state upon the CachingQuery.

    """

    def __init__(self, manager, *args, **kw):

        self.cache_manager = manager

        Query.__init__(self, *args, **kw)

    def __iter__(self):

        """override __iter__ to pull results from Beaker

           if particular attributes have been configured.

           Note that this approach does *not* detach the loaded objects from

           the current session. If the cache backend is an in-process cache

           (like "memory") and lives beyond the scope of the current session's

           transaction, those objects may be expired. The method here can be

           modified to first expunge() each loaded item from the current

           session before returning the list of items, so that the items

           in the cache are not the same ones in the current Session.

        """

        if hasattr(self, '_cache_parameters'):

            return self.get_value(createfunc=lambda:

                                  list(Query.__iter__(self)))

        else:

            return Query.__iter__(self)

    def invalidate(self):

        """Invalidate the value represented by this Query."""

        cache, cache_key = _get_cache_parameters(self)

        cache.remove(cache_key)

    def get_value(self, merge=True, createfunc=None):

        """Return the value from the cache for this query.

        Raise KeyError if no value present and no

        createfunc specified.

        """

        cache, cache_key = _get_cache_parameters(self)

        ret = cache.get_value(cache_key, createfunc=createfunc)

        if merge:

            ret = self.merge_result(ret, load=False)

        return ret

    def set_value(self, value):

        """Set the value in the cache for this query."""

        cache, cache_key = _get_cache_parameters(self)

        cache.put(cache_key, value)

def query_callable(manager, query_cls=CachingQuery):

    def query(*arg, **kw):

        return query_cls(manager, *arg, **kw)

    return query

def get_cache_region(name, region):

    if region not in beaker.cache.cache_regions:

        raise BeakerException('Cache region `%s` not configured '

            'Check if proper cache settings are in the .ini files' % region)

    kw = beaker.cache.cache_regions[region]

    return beaker.cache.Cache._get_cache(name, kw)

def _get_cache_parameters(query):

    """For a query with cache_region and cache_namespace configured,

    return the correspoinding Cache instance and cache key, based

    on this query's current criterion and parameter values.

    """

    if not hasattr(query, '_cache_parameters'):

        raise ValueError("This Query does not have caching "

                         "parameters configured.")

    region, namespace, cache_key = query._cache_parameters

    namespace = _namespace_from_query(namespace, query)

    if cache_key is None:

        # cache key - the value arguments from this query's parameters.

    # get cache

    #cache = query.cache_manager.get_cache_region(namespace, region)

    cache = get_cache_region(namespace, region)

    # optional - hash the cache_key too for consistent length

    # import uuid

    # cache_key= str(uuid.uuid5(uuid.NAMESPACE_DNS, cache_key))

    return cache, cache_key

def _namespace_from_query(namespace, query):

    # cache namespace - the token handed in by the

    # option + class we're querying against

    namespace = " ".join([namespace] + [str(x) for x in query._entities])

    # memcached wants this

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

    return namespace

def _set_cache_parameters(query, region, namespace, cache_key):

    if hasattr(query, '_cache_parameters'):

        region, namespace, cache_key = query._cache_parameters

        raise ValueError("This query is already configured "

                        "for region %r namespace %r" %

                        (region, namespace)

                    )

    query._cache_parameters = region, namespace, cache_key

class FromCache(MapperOption):

    """Specifies that a Query should load results from a cache."""

    propagate_to_loaders = False

    def __init__(self, region, namespace, cache_key=None):

        """Construct a new FromCache.

        :param region: the cache region.  Should be a

        region configured in the Beaker CacheManager.

        :param namespace: the cache namespace.  Should

        be a name uniquely describing the target Query's

        lexical structure.

        :param cache_key: optional.  A string cache key

        that will serve as the key to the query.   Use this

        if your query has a huge amount of parameters (such

        as when using in_()) which correspond more simply to

        some other identifier.

        """

        self.region = region

        self.namespace = namespace

        self.cache_key = cache_key

    def process_query(self, query):

        """Process a Query during normal loading operation."""

        _set_cache_parameters(query, self.region, self.namespace,

                              self.cache_key)

class RelationshipCache(MapperOption):

    """Specifies that a Query as called within a "lazy load"

       should load results from a cache."""

    propagate_to_loaders = True

    def __init__(self, region, namespace, attribute):

        """Construct a new RelationshipCache.

        :param region: the cache region.  Should be a

        region configured in the Beaker CacheManager.

        :param namespace: the cache namespace.  Should

        be a name uniquely describing the target Query's

        lexical structure.

        :param attribute: A Class.attribute which

        indicates a particular class relationship() whose

        lazy loader should be pulled from the cache.

        """

        self.region = region

        self.namespace = namespace

        self._relationship_options = {

            (attribute.property.parent.class_, attribute.property.key): self

        }

    def process_query_conditionally(self, query):

        """Process a Query that is used within a lazy loader.

        (the process_query_conditionally() method is a SQLAlchemy

        hook invoked only within lazyload.)

        """

        if query._current_path:

            mapper, key = query._current_path[-2:]

            for cls in mapper.class_.__mro__:

                if (cls, key) in self._relationship_options:

                    relationship_option = \

                        self._relationship_options[(cls, key)]

                    _set_cache_parameters(

                            query,

                            relationship_option.region,

                            relationship_option.namespace,

                            None)

    def and_(self, option):

        """Chain another RelationshipCache option to this one.

        While many RelationshipCache objects can be specified on a single

        Query separately, chaining them together allows for a more efficient

        lookup during load.

        """

        self._relationship_options.update(option._relationship_options)

        return self

def _params_from_query(query):

    """Pull the bind parameter values from a query.

    This takes into account any scalar attribute bindparam set up.

    E.g. params_from_query(query.filter(Cls.foo==5).filter(Cls.bar==7)))

    would return [5, 7].

    """

    v = []

    def visit_bindparam(bind):

        # lazyloader may dig a callable in here, intended

        # to late-evaluate params after autoflush is called.

        # convert to a scalar value.

        v.append(value)

    if query._criterion is not None:

        visitors.traverse(query._criterion, {}, {'bindparam':visit_bindparam})

    return v

        return gr.scalar()

    @classmethod

    def get(cls, users_group_id, cache=False):

        users_group = cls.query()

        if cache:

            users_group = users_group.options(FromCache("sql_cache_short",

                                    "get_users_group_%s" % users_group_id))

        return users_group.get(users_group_id)

    @classmethod

    def create(cls, form_data):

        try:

            new_users_group = cls()

            for k, v in form_data.items():

                setattr(new_users_group, k, v)

            Session().add(new_users_group)

            Session().commit()

            return new_users_group

        except:

            log.error(traceback.format_exc())

            Session().rollback()

            raise

    @classmethod

    def update(cls, users_group_id, form_data):

        try:

            users_group = cls.get(users_group_id, cache=False)

            for k, v in form_data.items():

                if k == 'users_group_members':

                    users_group.members = []

                    Session().flush()

                    members_list = []

                    if v:

                        v = [v] if isinstance(v, basestring) else v

                        for u_id in set(v):

                            member = UsersGroupMember(users_group_id, u_id)

                            members_list.append(member)

                    setattr(users_group, 'members', members_list)

                setattr(users_group, k, v)

            Session().add(users_group)

            Session().commit()

        except:

            log.error(traceback.format_exc())

            Session().rollback()

            raise

    @classmethod

    def delete(cls, users_group_id):

        try:

            # check if this group is not assigned to repo

            assigned_groups = UsersGroupRepoToPerm.query()\

                .filter(UsersGroupRepoToPerm.users_group_id ==

                        users_group_id).all()

            if assigned_groups:

                raise UsersGroupsAssignedException('RepoGroup assigned to %s' %

                                                   assigned_groups)

            users_group = cls.get(users_group_id, cache=False)

            Session().delete(users_group)

            Session().commit()

        except:

            log.error(traceback.format_exc())

            Session().rollback()

            raise

class UsersGroupMember(Base, BaseModel):

    __tablename__ = 'users_groups_members'

    __table_args__ = {'extend_existing':True}

    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

    @staticmethod

    def add_user_to_group(group, user):

        ugm = UsersGroupMember()

        ugm.users_group = group

        ugm.user = user

        Session().add(ugm)

        Session().commit()

        return ugm

class Repository(Base, BaseModel):

    __tablename__ = 'repositories'

    __table_args__ = (UniqueConstraint('repo_name'), {'extend_existing':True},)

    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)

    repo_type = Column("repo_type", String(length=255, convert_unicode=False, assert_unicode=None), nullable=False, unique=False, default='hg')

    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', cascade='all')

    def __repr__(self):

        return "<%s('%s:%s')>" % (self.__class__.__name__,

                                  self.repo_id, self.repo_name)

    @classmethod

    def url_sep(cls):

        return '/'

    @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.one()

    @classmethod

    def get_repo_forks(cls, repo_id):

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

    @classmethod

    def base_path(cls):

        """

        Returns base path when all repos are stored

        :param cls:

        """

        q = Session().query(RhodeCodeUi).filter(RhodeCodeUi.ui_key ==

                                              cls.url_sep())

        q.options(FromCache("sql_cache_short", "repository_repo_path"))

        return q.one().ui_value

    @property

    def just_name(self):

        return self.repo_name.split(Repository.url_sep())[-1]

    @property

    def groups_with_parents(self):

        groups = []

        if self.group is None:

            return groups

        cur_gr = self.group

        groups.insert(0, cur_gr)

        while 1:

            gr = getattr(cur_gr, 'parent_group', None)

            cur_gr = cur_gr.parent_group

            if gr is None:

                break

            groups.insert(0, gr)

        return groups

    @property

    def groups_and_repo(self):

        return self.groups_with_parents, self.just_name

    @LazyProperty

    def repo_path(self):

        """

        Returns base full path for that repository means where it actually

        exists on a filesystem

        """

        q = Session().query(RhodeCodeUi).filter(RhodeCodeUi.ui_key ==

                                              Repository.url_sep())

        return q.one().ui_value

    @property

    def repo_full_path(self):

        p = [self.repo_path]

        # we need to split the name by / since this is how we store the

        # names in the database, but that eventually needs to be converted

        # into a valid system path

        p += self.repo_name.split(Repository.url_sep())

        return os.path.join(*p)

    def get_new_name(self, repo_name):

        """

        returns new full repository name based on assigned group and new new

        :param group_name:

        """

        path_prefix = self.group.full_path_splitted if self.group else []

        return Repository.url_sep().join(path_prefix + [repo_name])

    @property

    def _ui(self):

        """

        Creates an db based ui object for this repository

        """

        from mercurial import ui

        from mercurial import config

        baseui = ui.ui()

        #clean the baseui object

        baseui._ocfg = config.config()

        baseui._ucfg = config.config()

        baseui._tcfg = config.config()

        ret = RhodeCodeUi.query()\

            .options(FromCache("sql_cache_short", "repository_repo_ui")).all()

        hg_ui = ret

        for ui_ in hg_ui:

            if ui_.ui_active:

                log.debug('settings ui from db[%s]%s:%s', ui_.ui_section,

                          ui_.ui_key, ui_.ui_value)

                baseui.setconfig(ui_.ui_section, ui_.ui_key, ui_.ui_value)

        return baseui

    @classmethod

    def is_valid(cls, repo_name):

        """

        returns True if given repo name is a valid filesystem repository

        @param cls:

        @param repo_name:

        """

        from rhodecode.lib.utils import is_valid_repo

        return is_valid_repo(repo_name, cls.base_path())

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

    # SCM PROPERTIES

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

    def get_changeset(self, rev):

        return get_changeset_safe(self.scm_instance, rev)

    @property

    def tip(self):

        return self.get_changeset('tip')

    @property

    def author(self):

        return self.tip.author

    @property

    def last_change(self):

        return self.scm_instance.last_change

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

    # SCM CACHE INSTANCE

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

    @property

    def invalidate(self):

        return CacheInvalidation.invalidate(self.repo_name)

    def set_invalidate(self):

        """

        set a cache for invalidation for this instance

        """

        CacheInvalidation.set_invalidate(self.repo_name)

    @LazyProperty

    def scm_instance(self):

        return self.__get_instance()

    @property

    def scm_instance_cached(self):

        @cache_region('long_term')

        def _c(repo_name):

            return self.__get_instance()

        rn = self.repo_name

        inv = self.invalidate

        if inv is not None:

            region_invalidate(_c, None, rn)

            # update our cache

            CacheInvalidation.set_valid(inv.cache_key)

        return _c(rn)

    def __get_instance(self):

        repo_full_path = self.repo_full_path

        try:

            alias = get_scm(repo_full_path)[0]

            log.debug('Creating instance of %s repository', alias)

            backend = get_backend(alias)

        except VCSError:

            log.error(traceback.format_exc())

            log.error('Perhaps this repository is in db and not in '

                      'filesystem run rescan repositories with '

                      '"destroy old data " option from admin panel')

            return

        if alias == 'hg':

            repo = backend(safe_str(repo_full_path), create=False,

                           baseui=self._ui)

            # skip hidden web repository

            if repo._get_hidden():

                return

        else:

            repo = backend(repo_full_path, create=False)

        return repo

class RepoGroup(Base, BaseModel):

    __tablename__ = 'groups'

    __table_args__ = (UniqueConstraint('group_name', 'group_parent_id'),

                      CheckConstraint('group_id != group_parent_id'), {'extend_existing':True},)

    __mapper_args__ = {'order_by':'group_name'}

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

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

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

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

    parent_group = relationship('RepoGroup', remote_side=group_id)

    def __init__(self, group_name='', parent_group=None):

        self.group_name = group_name

        self.parent_group = parent_group

    def __repr__(self):

        return "<%s('%s:%s')>" % (self.__class__.__name__, self.group_id,

                                  self.group_name)

    @classmethod

    def groups_choices(cls):

        from webhelpers.html import literal as _literal

        repo_groups = [('', '')]

        sep = ' » '

        _name = lambda k: _literal(sep.join(k))

        repo_groups.extend([(x.group_id, _name(x.full_path_splitted))

                              for x in cls.query().all()])

        repo_groups = sorted(repo_groups, key=lambda t: t[1].split(sep)[0])

        return repo_groups

    @classmethod

    def url_sep(cls):

        return '/'

    @classmethod

    def get_by_group_name(cls, group_name, cache=False, case_insensitive=False):

        if case_insensitive:

            gr = cls.query()\

                .filter(cls.group_name.ilike(group_name))

        else:

            gr = cls.query()\

                .filter(cls.group_name == group_name)

        if cache:

            gr = gr.options(FromCache("sql_cache_short",

                                          "get_group_%s" % group_name))

        return gr.scalar()

    @property