from kallithea.lib import diffs

from kallithea.lib import helpers as h

from kallithea.lib.auth import HasRepoPermissionLevelDecorator, LoginRequired

from kallithea.lib.base import BaseRepoController, jsonify, render

from kallithea.lib.exceptions import NonRelativePathError

from kallithea.lib.utils import action_logger

from kallithea.lib.utils2 import asbool, convert_line_endings, detect_mode, safe_str

from kallithea.lib.vcs.backends.base import EmptyChangeset

from kallithea.lib.vcs.conf import settings

from kallithea.lib.vcs.exceptions import (ChangesetDoesNotExistError, ChangesetError, EmptyRepositoryError, ImproperArchiveTypeError, NodeAlreadyExistsError,

                                          NodeDoesNotExistError, NodeError, RepositoryError, VCSError)

from kallithea.lib.vcs.nodes import FileNode

from kallithea.lib.webutils import url

from kallithea.model.repo import RepoModel

from kallithea.model.scm import ScmModel

log = logging.getLogger(__name__)

class FilesController(BaseRepoController):

    def _before(self, *args, **kwargs):

        super(FilesController, self)._before(*args, **kwargs)

            elif c.file.is_file():

                c.load_full_history = False

                # determine if we're on branch head

                _branches = c.db_repo_scm_instance.branches

                c.on_branch_head = revision in _branches or revision in _branches.values()

                _hist = []

                c.file_history = []

                if c.load_full_history:

                    c.file_history, _hist = self._get_node_history(c.changeset, f_path)

                c.authors = []

                for a in set([x.author for x in _hist]):

            else:

                c.authors = c.file_history = []

        except RepositoryError as e:

            h.flash(e, category='error')

            raise HTTPNotFound()

        if request.environ.get('HTTP_X_PARTIAL_XHR'):

            return render('files/files_ypjax.html')

        # TODO: tags and bookmarks?

        c.revision_options = [(c.changeset.raw_id,

                              _('%s at %s') % (b, h.short_id(c.changeset.raw_id))) for b in c.changeset.branches] + \

            }

            return data

    @LoginRequired(allow_default_user=True)

    @HasRepoPermissionLevelDecorator('read')

    def authors(self, repo_name, revision, f_path):

        changeset = self.__get_cs(revision)

        _file = changeset.get_node(f_path)

        if _file.is_file():

            file_history, _hist = self._get_node_history(changeset, f_path)

            c.authors = []

            for a in set([x.author for x in _hist]):

            return render('files/files_history_box.html')

    @LoginRequired(allow_default_user=True)

    @HasRepoPermissionLevelDecorator('read')

    def rawfile(self, repo_name, revision, f_path):

        cs = self.__get_cs(revision)

        file_node = self.__get_filenode(cs, f_path)

        response.content_disposition = \

            'attachment; filename=%s' % f_path.split(kallithea.URL_SEP)[-1]

        response.content_type = file_node.mimetype

def pop_flash_messages():

    """Return all accumulated messages and delete them from the session.

    The return value is a list of ``Message`` objects.

    """

    return [_Message(category, message) for category, message in _session_flash_messages(clear=True)]

def capitalize(x):

    return x.capitalize()

def short_id(x):

    return x[:12]

def hide_credentials(x):

    return ''.join(credentials_filter(x))

def show_id(cs):

    """

    Configurable function that shows ID

    by default it's r123:fffeeefffeee

def person(author, show_attr="username"):

    """Find the user identified by 'author', return one of the users attributes,

    default to the username attribute, None if there is no user"""

    # if author is already an instance use it for extraction

    if isinstance(author, db.User):

        return getattr(author, show_attr)

    value = user_attr_or_none(author, show_attr)

    if value is not None:

        return value

    # Still nothing?  Just pass back the author name if any, else the email

def person_by_id(id_, show_attr="username"):

    # maybe it's an ID ?

    if str(id_).isdigit() or isinstance(id_, int):

        id_ = int(id_)

        user = db.User.get(id_)

        if user is not None:

            return getattr(user, show_attr)

    return id_

from sqlalchemy import Boolean, Column, DateTime, Float, ForeignKey, Index, Integer, LargeBinary, String, Unicode, UnicodeText, UniqueConstraint

from sqlalchemy.ext.hybrid import hybrid_property

from sqlalchemy.orm import class_mapper, joinedload, relationship, validates

from tg.i18n import lazy_ugettext as _

from webob.exc import HTTPNotFound

import kallithea

from kallithea.lib import ext_json, ssh

from kallithea.lib.exceptions import DefaultUserException

from kallithea.lib.utils2 import asbool, ascii_bytes, aslist, get_changeset_safe, get_clone_url, remove_prefix, safe_bytes, safe_int, safe_str, urlreadable

from kallithea.lib.vcs import get_backend

from kallithea.lib.vcs.backends.base import EmptyChangeset

from kallithea.lib.vcs.utils.helpers import get_scm

from kallithea.model import meta

log = logging.getLogger(__name__)

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

# BASE CLASSES

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

class BaseDbModel(object):

    """

            q = UserEmailMap.query()

            # try fetching in alternate email map

            q = q.filter(sqlalchemy.func.lower(UserEmailMap.email) == sqlalchemy.func.lower(email))

            q = q.options(joinedload(UserEmailMap.user))

            ret = getattr(q.scalar(), 'user', None)

        return ret

    @classmethod

    def get_from_cs_author(cls, author):

        """

        Tries to get User objects out of commit author string

        """

        # Valid email in the attribute passed, see if they're in the system

        if _email:

            user = cls.get_by_email(_email)

            if user is not None:

                return user

        # Maybe we can match by username?

        _author = author_name(author)

        user = cls.get_by_username(_author, case_insensitive=True)

        if user is not None:

            return user

    def update_lastlogin(self):

        """Update user lastlogin"""