params[fileid] += ['C:%s' % ln_ctx]

        ig_ws_key = fileid

        ig_ws_val = 'WS:%s' % 1

    if ig_ws:

        params[ig_ws_key] += [ig_ws_val]

    lbl = _('Increase diff context to %(num)s lines') % {'num': ln_ctx}

    params['anchor'] = fileid

    icon = h.literal('<i class="icon-sort"></i>')

    return h.link_to(icon, h.url.current(**params), title=lbl, class_='tooltip')

class ChangesetController(BaseRepoController):

    def __before__(self):

        super(ChangesetController, self).__before__()

        c.affected_files_cut_off = 60

    def __load_data(self):

        repo_model = RepoModel()

        c.users_array = repo_model.get_users_js()

        c.user_groups_array = repo_model.get_user_groups_js()

    def _index(self, revision, method):

        c.anchor_url = anchor_url

        c.ignorews_url = _ignorews_url

        c.context_url = _context_url

        c.fulldiff = fulldiff = request.GET.get('fulldiff')

        #get ranges of revisions if preset

        rev_range = revision.split('...')[:2]

        enable_comments = True

        c.cs_repo = c.db_repo

        try:

            if len(rev_range) == 2:

                enable_comments = False

                rev_start = rev_range[0]

                rev_end = rev_range[1]

                rev_ranges = c.db_repo_scm_instance.get_changesets(start=rev_start,

                                                             end=rev_end)

            else:

                rev_ranges = [c.db_repo_scm_instance.get_changeset(revision)]

            c.cs_ranges = list(rev_ranges)

            if not c.cs_ranges:

                raise RepositoryError('Changeset range returned empty result')

            log.debug(traceback.format_exc())

            msg = _('Such revision does not exist for this repository')

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

            raise HTTPNotFound()

        c.changes = OrderedDict()

        c.lines_added = 0  # count of lines added

        c.lines_deleted = 0  # count of lines removes

        c.changeset_statuses = ChangesetStatus.STATUSES

        comments = dict()

        c.statuses = []

        c.inline_comments = []

        c.inline_cnt = 0

        # Iterate over ranges (default changeset view is always one changeset)

        for changeset in c.cs_ranges:

            inlines = []

            if method == 'show':

                c.statuses.extend([ChangesetStatusModel().get_status(

                            c.db_repo.repo_id, changeset.raw_id)])

                # Changeset comments

                comments.update((com.comment_id, com)

                                for com in ChangesetCommentsModel()

                                .get_comments(c.db_repo.repo_id,

                                              revision=changeset.raw_id))

                # Status change comments - mostly from pull requests

                comments.update((st.changeset_comment_id, st.comment)

                                for st in ChangesetStatusModel()

                                .get_statuses(c.db_repo.repo_id,

                                              changeset.raw_id, with_revisions=True)

                                if st.changeset_comment_id is not None)

                inlines = ChangesetCommentsModel()\

                            .get_inline_comments(c.db_repo.repo_id,

                                                 revision=changeset.raw_id)

                c.inline_comments.extend(inlines)

            c.changes[changeset.raw_id] = []

            cs2 = changeset.raw_id

            cs1 = changeset.parents[0].raw_id if changeset.parents else EmptyChangeset().raw_id

            context_lcl = get_line_ctx('', request.GET)

            ign_whitespace_lcl = ign_whitespace_lcl = get_ignore_ws('', request.GET)

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

from kallithea.lib.vcs.conf import settings

from kallithea.lib.vcs.exceptions import RepositoryError, \

    ChangesetDoesNotExistError, EmptyRepositoryError, \

    ImproperArchiveTypeError, VCSError, NodeAlreadyExistsError,\

    NodeDoesNotExistError, ChangesetError, NodeError

from kallithea.lib.vcs.nodes import FileNode

from kallithea.model.repo import RepoModel

from kallithea.model.scm import ScmModel

from kallithea.model.db import Repository

from kallithea.controllers.changeset import anchor_url, _ignorews_url,\

    _context_url, get_line_ctx, get_ignore_ws

from webob.exc import HTTPNotFound

from kallithea.lib.exceptions import NonRelativePathError

log = logging.getLogger(__name__)

class FilesController(BaseRepoController):

    def __before__(self):

        super(FilesController, self).__before__()

        c.cut_off_limit = self.cut_off_limit

    def __get_cs(self, rev, silent_empty=False):

        """

        Safe way to get changeset if error occur it redirects to tip with

        proper message

        :param rev: revision to fetch

        :silent_empty: return None if repository is empty

        """

        try:

            return c.db_repo_scm_instance.get_changeset(rev)

        except EmptyRepositoryError as e:

            if silent_empty:

                return None

            url_ = url('files_add_home',

                       repo_name=c.repo_name,

                       revision=0, f_path='', anchor='edit')

            add_new = h.link_to(_('Click here to add new file'), url_, class_="alert-link")

            h.flash(h.literal(_('There are no files yet. %s') % add_new),

                    category='warning')

            raise HTTPNotFound()

            msg = _('Such revision does not exist for this repository')

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

            raise HTTPNotFound()

        except RepositoryError as e:

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

            raise HTTPNotFound()

    def __get_filenode(self, cs, path):

        """

        Returns file_node or raise HTTP error.

        :param cs: given changeset

        :param path: path to lookup

        """

        try:

            file_node = cs.get_node(path)

            if file_node.is_dir():

                raise RepositoryError('given path is a directory')

            msg = _('Such revision does not exist for this repository')

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

            raise HTTPNotFound()

        except RepositoryError as e:

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

            raise HTTPNotFound()

        return file_node

    @LoginRequired()

    @HasRepoPermissionAnyDecorator('repository.read', 'repository.write',

                                   'repository.admin')

    def index(self, repo_name, revision, f_path, annotate=False):

        # redirect to given revision from form if given

        post_revision = request.POST.get('at_rev', None)

        if post_revision:

            cs = self.__get_cs(post_revision) # FIXME - unused!

        c.revision = revision

        c.changeset = self.__get_cs(revision)

        c.branch = request.GET.get('branch', None)

        c.f_path = f_path

        c.annotate = annotate

        cur_rev = c.changeset.revision

        c.fulldiff = request.GET.get('fulldiff')

        # prev link

        try:

            prev_rev = c.db_repo_scm_instance.get_changeset(cur_rev).prev(c.branch)

            c.url_prev = url('files_home', repo_name=c.repo_name,

                         revision=prev_rev.raw_id, f_path=f_path)

            if c.branch:

                c.url_prev += '?branch=%s' % c.branch

        except (ChangesetDoesNotExistError, VCSError):

            c.url_prev = '#'

        # next link

        try:

            next_rev = c.db_repo_scm_instance.get_changeset(cur_rev).next(c.branch)

            c.url_next = url('files_home', repo_name=c.repo_name,

                     revision=next_rev.raw_id, f_path=f_path)

            if c.branch:

                c.url_next += '?branch=%s' % c.branch

        except (ChangesetDoesNotExistError, VCSError):

            c.url_next = '#'

        # files or dirs

        try:

                qp = QueryParser(search_type, schema=schema_defn)

                if c.repo_name:

                    cur_query = u'repository:%s %s' % (c.repo_name, cur_query)

                try:

                    query = qp.parse(unicode(cur_query))

                    # extract words for highlight

                    if isinstance(query, Phrase):

                        highlight_items.update(query.words)

                    elif isinstance(query, Prefix):

                        highlight_items.add(query.text)

                    else:

                        for i in query.all_terms():

                            if i[0] in ['content', 'message']:

                                highlight_items.add(i[1])

                    matcher = query.matcher(searcher)

                    log.debug('query: %s', query)

                    log.debug('hl terms: %s', highlight_items)

                    results = searcher.search(query)

                    res_ln = len(results)

                    c.runtime = '%s results (%.3f seconds)' % (

                        res_ln, results.runtime

                    )

                    def url_generator(**kw):

                        q = urllib.quote(safe_str(c.cur_query))

                        return update_params("?q=%s&type=%s" \

                        % (q, safe_str(c.cur_type)), **kw)

                    repo_location = RepoModel().repos_path

                    c.formated_results = Page(

                        WhooshResultWrapper(search_type, searcher, matcher,

                                            highlight_items, repo_location),

                        page=p,

                        item_count=res_ln,

                        items_per_page=10,

                        url=url_generator

                    )

                except QueryParserError:

                    c.runtime = _('Invalid search query. Try quoting it.')

                searcher.close()

            except (EmptyIndexError, IOError):

                log.error(traceback.format_exc())

                log.error('Empty Index data')

                c.runtime = _('There is no index to search in. '

                              'Please run whoosh indexer')

                log.error(traceback.format_exc())

                c.runtime = _('An error occurred during search operation.')

        # Return a rendered template

        return render('/search/search.html')

            'port': settings.get('port'),

            'bind_dn': settings.get('dn_user'),

            'bind_pass': settings.get('dn_pass'),

            'tls_kind': settings.get('tls_kind'),

            'tls_reqcert': settings.get('tls_reqcert'),

            'ldap_filter': settings.get('filter'),

            'search_scope': settings.get('search_scope'),

            'attr_login': settings.get('attr_login'),

            'ldap_version': 3,

        }

        if kwargs['bind_dn'] and not kwargs['bind_pass']:

            log.debug('Using dynamic binding.')

            kwargs['bind_dn'] = kwargs['bind_dn'].replace('$login', username)

            kwargs['bind_pass'] = password

        log.debug('Checking for ldap authentication')

        try:

            aldap = AuthLdap(**kwargs)

            (user_dn, ldap_attrs) = aldap.authenticate_ldap(username, password)

            log.debug('Got ldap DN response %s', user_dn)

            get_ldap_attr = lambda k: ldap_attrs.get(settings.get(k), [''])[0]

            # old attrs fetched from Kallithea database

            admin = getattr(userobj, 'admin', False)

            active = getattr(userobj, 'active', self.user_activation_state())

            email = getattr(userobj, 'email', '')

            firstname = getattr(userobj, 'firstname', '')

            lastname = getattr(userobj, 'lastname', '')

            user_data = {

                'username': username,

                'firstname': safe_unicode(get_ldap_attr('attr_firstname') or firstname),

                'lastname': safe_unicode(get_ldap_attr('attr_lastname') or lastname),

                'groups': [],

                'email': get_ldap_attr('attr_email') or email,

                'admin': admin,

                'active': active,

                "active_from_extern": None,

                'extern_name': user_dn,

            }

            log.info('user %s authenticated correctly', user_data['username'])

            return user_data

        except (LdapUsernameError, LdapPasswordError, LdapImportError):

            log.error(traceback.format_exc())

            return None

            log.error(traceback.format_exc())

            return None

    def get_managed_fields(self):

        return ['username', 'firstname', 'lastname', 'email', 'password']

class ControlledSchema(object):

    """A database under version control"""

    def __init__(self, engine, repository):

        if isinstance(repository, basestring):

            repository = Repository(repository)

        self.engine = engine

        self.repository = repository

        self.meta = MetaData(engine)

        self.load()

    def __eq__(self, other):

        """Compare two schemas by repositories and versions"""

        return (self.repository is other.repository \

            and self.version == other.version)

    def load(self):

        """Load controlled schema version info from DB"""

        tname = self.repository.version_table

        try:

            if not hasattr(self, 'table') or self.table is None:

                    self.table = Table(tname, self.meta, autoload=True)

            result = self.engine.execute(self.table.select(

                self.table.c.repository_id == str(self.repository.id)))

            data = list(result)[0]

        except:

            cls, exc, tb = sys.exc_info()

            raise exceptions.DatabaseNotControlledError, exc.__str__(), tb

        self.version = data['version']

        return data

    def drop(self):

        """

        Remove version control from a database.

        """

        if SQLA_07:

            try:

                self.table.drop()

            except sa_exceptions.DatabaseError:

                raise exceptions.DatabaseNotControlledError(str(self.table))

        else:

            try:

                self.table.drop()

                raise exceptions.DatabaseNotControlledError(str(self.table))

    def changeset(self, version=None):

        """API to Changeset creation.

        Uses self.version for start version and engine.name

        to get database name.

        """

        database = self.engine.name

        start_ver = self.version

        changeset = self.repository.changeset(database, start_ver, version)

        return changeset

    def runchange(self, ver, change, step):

        startver = ver

        endver = ver + step

        # Current database version must be correct! Don't run if corrupt!

        if self.version != startver:

            raise exceptions.InvalidVersionError("%s is not %s" % \

                                                     (self.version, startver))

        # Run the change

        change.run(self.engine, step)

        # Update/refresh database version

        self.update_repository_table(startver, endver)

        self.load()

    def update_repository_table(self, startver, endver):

        """Update version_table with new information"""

        update = self.table.update(and_(self.table.c.version == int(startver),

             self.table.c.repository_id == str(self.repository.id)))

        self.engine.execute(update, version=int(endver))

    def upgrade(self, version=None):

        """

        Upgrade (or downgrade) to a specified version, or latest version.

        """

        changeset = self.changeset(version)

        for ver, change in changeset:

            self.runchange(ver, change, changeset.step)

    def update_db_from_model(self, model):

        """

        Modify the database to match the structure of the current Python model.

        """

        model = load_model(model)

        diff = schemadiff.getDiffOfModelAgainstDatabase(

                                                self.app_settings_value)

class Ui(Base):

    __tablename__ = DB_PREFIX + 'ui'

    __table_args__ = {'useexisting':True}

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

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

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

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

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

class User(Base):

    __tablename__ = 'users'

    __table_args__ = (UniqueConstraint('username'), UniqueConstraint('email'), {'useexisting':True})

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

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

    password = Column("password", String(length=None, 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)

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

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

    email = Column("email", String(length=None, 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)

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

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

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

    repositories = relation('Repository')

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

    @property

    def full_contact(self):

        return '%s %s <%s>' % (self.name, self.lastname, self.email)

    def __repr__(self):

        return "<User('id:%s:%s')>" % (self.user_id, self.username)

    def update_lastlogin(self):

        """Update user lastlogin"""

        try:

            session = Session.object_session(self)

            self.last_login = datetime.datetime.now()

            session.add(self)

            session.commit()

            log.debug('updated user %s lastlogin', self.username)

            session.rollback()

class UserLog(Base):

    __tablename__ = 'user_logs'

    __table_args__ = {'useexisting':True}

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

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

    repository_id = Column("repository_id", Integer(length=None, convert_unicode=False, assert_unicode=None), ForeignKey(u'repositories.repo_id'), nullable=False, unique=None, default=None)

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

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

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

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

    user = relation('User')

    repository = relation('Repository')

class Repository(Base):

    __tablename__ = 'repositories'

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

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

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

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

    user_id = Column("user_id", Integer(), ForeignKey(u'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)

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

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

    user = relation('User')

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

    repo_to_perm = relation('UserRepoToPerm', cascade='all')

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

    repo_followers = relation('UserFollowing', primaryjoin='UserFollowing.follows_repo_id==Repository.repo_id', cascade='all')

    def __repr__(self):

        return "<Repository('%s:%s')>" % (self.repo_id, self.repo_name)

class Permission(Base):

    __tablename__ = 'permissions'

    __table_args__ = {'useexisting':True}

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

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

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

    def __repr__(self):