# NOTE: If you want compatibility with a database that was originally created

#  for use with the RhodeCode software product, change BRAND to "rhodecode",

#  either by editing here or by creating a new file:

#  echo "BRAND = 'rhodecode'" > kallithea/brand.py

BRAND = "kallithea"

try:

    from kallithea.brand import BRAND

except ImportError:

    pass

# Prefix for the ui and settings table names

DB_PREFIX = (BRAND + "_") if BRAND != "kallithea" else ""

# Users.extern_type and .extern_name value for local users

EXTERN_TYPE_INTERNAL = BRAND if BRAND != 'kallithea' else 'internal'

# db_migrate_version.repository_id value, same as kallithea/lib/dbmigrate/migrate.cfg

DB_MIGRATIONS = BRAND + "_db_migrations"

try:

    from kallithea.lib import get_current_revision

    _rev = get_current_revision(quiet=True)

    if _rev and len(VERSION) > 3:

except ImportError:

    pass

__version__ = ('.'.join((str(each) for each in VERSION[:3])))

__dbversion__ = 31  # defines current db version for migrations

__platform__ = platform.system()

__license__ = 'GPLv3'

__py_version__ = sys.version_info

__author__ = "Various Authors"

__url__ = 'https://kallithea-scm.org/'

is_windows = __platform__ in ['Windows']

is_unix = not is_windows

if len(VERSION) > 3:

    __version__ += '.'+VERSION[3]

    if len(VERSION) > 4:

        __version__ += VERSION[4]

    else:

        __version__ += '0'

log = logging.getLogger(__name__)

class FeedController(BaseRepoController):

    @LoginRequired(api_access=True)

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

                                   'repository.admin')

    def __before__(self):

        super(FeedController, self).__before__()

        #common values for feeds

        self.description = _('Changes on %s repository')

        self.title = self.title = _('%s %s feed') % (c.site_name, '%s')

        self.language = 'en-us'

        self.ttl = "5"

        import kallithea

        CONF = kallithea.CONFIG

        self.include_diff = str2bool(CONF.get('rss_include_diff', False))

        self.feed_nr = safe_int(CONF.get('rss_items_per_page', 20))

        # we need to protect from parsing huge diffs here other way

        # we can kill the server

        self.feed_diff_limit = safe_int(CONF.get('rss_cut_off_limit', 32 * 1024))

    def _get_title(self, cs):

    def __changes(self, cs):

        changes = []

        diff_processor = DiffProcessor(cs.diff(),

                                       diff_limit=self.feed_diff_limit)

        _parsed = diff_processor.prepare(inline_diff=False)

        limited_diff = False

        if isinstance(_parsed, LimitedDiffContainer):

            limited_diff = True

        for st in _parsed:

            st.update({'added': st['stats']['added'],

                       'removed': st['stats']['deleted']})

            changes.append('\n %(operation)s %(filename)s '

                           '(%(added)s lines added, %(removed)s lines removed)'

                            % st)

        if limited_diff:

            changes = changes + ['\n ' +

                                 _('Changeset was too big and was cut off...')]

        return diff_processor, changes

    def __get_desc(self, cs):

        desc_msg = [(_('%s committed on %s')

                     % (h.person(cs.author), h.fmt_date(cs.date))) + '<br/>']

                        raise Exception('error parsing diff - more than %s "+" lines at -%s+%s' % (new_end, old_line, new_line))

        except StopIteration:

            pass

        if old_line != old_end or new_line != new_end:

            raise Exception('diff processing broken when old %s<>%s or new %s<>%s line %r' % (old_line, old_end, new_line, new_end, line))

        return chunks, stats

    def _safe_id(self, idstring):

        """Make a string safe for including in an id attribute.

        The HTML spec says that id attributes 'must begin with

        a letter ([A-Za-z]) and may be followed by any number

        of letters, digits ([0-9]), hyphens ("-"), underscores

        ("_"), colons (":"), and periods (".")'. These regexps

        are slightly over-zealous, in that they remove colons

        and periods unnecessarily.

        Whitespace is transformed into underscores, and then

        anything which is not a hyphen or a character that

        matches \w (alphanumerics and underscore) is removed.

        """

        # Transform all whitespace to underscore

        # Remove everything that is not a hyphen or a member of \w

        idstring = re.sub(r'(?!-)\W', "", idstring).lower()

        return idstring

    def prepare(self, inline_diff=True):

        """

        Prepare the passed udiff for HTML rendering. It'l return a list

        of dicts with diff information

        """

        parsed = self._parser(inline_diff=inline_diff)

        self.parsed = True

        self.parsed_diff = parsed

        return parsed

    def as_raw(self, diff_lines=None):

        """

        Returns raw string diff

        """

        return self._diff

        #return u''.join(imap(self._line_counter, self._diff.splitlines(1)))

    def as_html(self, table_class='code-difftable', line_class='line',

                old_lineno_class='lineno old', new_lineno_class='lineno new',

                no_lineno_class='lineno',

from kallithea.model.db import User, ChangesetStatus, PullRequest

age = lambda  x, y=False: _age(x, y)

capitalize = lambda x: x.capitalize()

email = author_email

short_id = lambda x: x[:12]

hide_credentials = lambda x: ''.join(credentials_filter(x))

def show_id(cs):

    """

    Configurable function that shows ID

    by default it's r123:fffeeefffeee

    :param cs: changeset instance

    """

    from kallithea import CONFIG

    def_len = safe_int(CONFIG.get('show_sha_length', 12))

    show_rev = str2bool(CONFIG.get('show_revision_number', False))

    raw_id = cs.raw_id[:def_len]

    if show_rev:

        return 'r%s:%s' % (cs.revision, raw_id)

    else:

def fmt_date(date):

    if date:

        return date.strftime("%Y-%m-%d %H:%M:%S").decode('utf8')

    return ""

def is_git(repository):

    if hasattr(repository, 'alias'):

        _type = repository.alias

    elif hasattr(repository, 'repo_type'):

        _type = repository.repo_type

    else:

        _type = repository

    return _type == 'git'

def is_hg(repository):

    if hasattr(repository, 'alias'):

        _type = repository.alias

    elif hasattr(repository, 'repo_type'):

        _type = repository.repo_type

    action_params = ' '

    x = action.split(':')

    if len(x) > 1:

        action, action_params = x

    def get_cs_links():

        revs_limit = 3  # display this amount always

        revs_top_limit = 50  # show upto this amount of changesets hidden

        revs_ids = action_params.split(',')

        deleted = user_log.repository is None

        if deleted:

            return ','.join(revs_ids)

        repo_name = user_log.repository.repo_name

        def lnk(rev, repo_name):

            lazy_cs = False

            title = None

            _url = '#'

            if isinstance(rev, BaseChangeset) or isinstance(rev, AttributeDict):

                if rev.op and rev.ref_name:

                    if rev.op == 'delete_branch':

                    elif rev.op == 'tag':

                    else:

                        lbl = 'Unknown operation %s' % rev.op

                else:

                    lazy_cs = True

                    lbl = rev.short_id[:8]

                    _url = url('changeset_home', repo_name=repo_name,

                               revision=rev.raw_id)

            else:

                # changeset cannot be found - it might have been stripped or removed

                title = _('Changeset not found')

            if parse_cs:

                return link_to(lbl, _url, title=title, class_='tooltip')

            return link_to(lbl, _url, raw_id=rev.raw_id, repo_name=repo_name,

                           class_='lazy-cs' if lazy_cs else '')

        def _get_op(rev_txt):

            _op = None

            _name = rev_txt

            if len(rev_txt.split('=>')) == 2:

                _op, _name = rev_txt.split('=>')

            return _op, _name

        revs = []

        if len(filter(lambda v: v != '', revs_ids)) > 0:

            repo = None

            for rev in revs_ids[:revs_top_limit]:

                _op, _name = _get_op(rev)

                # we want parsed changesets, or new log store format is bad

                if parse_cs:

                    try:

                        if repo is None:

                            repo = user_log.repository.scm_instance

        # e.g. '1 .. 5 6 [7] 8 9 .. 12'

        # -> leftmost_page  = 5

        # -> rightmost_page = 9

        leftmost_page, _cur, rightmost_page = self._get_pos(self.page,

                                                            self.last_page,

                                                            (radius * 2) + 1)

        nav_items = []

        # Create a link to the first page (unless we are on the first page

        # or there would be no need to insert '..' spacers)

        if self.page != self.first_page and self.first_page < leftmost_page:

            nav_items.append(self._pagerlink(self.first_page, self.first_page))

        # Insert dots if there are pages between the first page

        # and the currently displayed page range

        if leftmost_page - self.first_page > 1:

            # Wrap in a SPAN tag if nolink_attr is set

            text = '..'

            if self.dotdot_attr:

                text = HTML.span(c=text, **self.dotdot_attr)

            nav_items.append(text)

        for thispage in xrange(leftmost_page, rightmost_page + 1):

            # Highlight the current page number and do not use a link

            if thispage == self.page:

                # Wrap in a SPAN tag if nolink_attr is set

                if self.curpage_attr:

                    text = HTML.span(c=text, **self.curpage_attr)

                nav_items.append(text)

            # Otherwise create just a link to that page

            else:

                nav_items.append(self._pagerlink(thispage, text))

        # Insert dots if there are pages between the displayed

        # page numbers and the end of the page range

        if self.last_page - rightmost_page > 1:

            text = '..'

            # Wrap in a SPAN tag if nolink_attr is set

            if self.dotdot_attr:

                text = HTML.span(c=text, **self.dotdot_attr)

            nav_items.append(text)

        # Create a link to the very last page (unless we are on the last

        # page or there would be no need to insert '..' spacers)

        if self.page != self.last_page and rightmost_page < self.last_page:

            nav_items.append(self._pagerlink(self.last_page, self.last_page))

        #_page_link = url.current()

        #nav_items.append(literal('<link rel="prerender" href="%s?page=%s">' % (_page_link, str(int(self.page)+1))))

        #nav_items.append(literal('<link rel="prefetch" href="%s?page=%s">' % (_page_link, str(int(self.page)+1))))

        return self.separator.join(nav_items)

    def pager(self, format='~2~', page_param='page', partial_param='partial',

        show_if_single_page=False, separator=' ', onclick=None,

        symbol_first='<<', symbol_last='>>',

def urlify_issues(newtext, repository, link_=None):

    from kallithea import CONFIG as conf

    # allow multiple issue servers to be used

    valid_indices = [

        x.group(1)

        for x in map(lambda x: re.match(r'issue_pat(.*)', x), conf.keys())

        if x and 'issue_server_link%s' % x.group(1) in conf

        and 'issue_prefix%s' % x.group(1) in conf

    ]

    if valid_indices:

        log.debug('found issue server suffixes `%s` during valuation of: %s'

                  % (','.join(valid_indices), newtext))

    for pattern_index in valid_indices:

        ISSUE_PATTERN = conf.get('issue_pat%s' % pattern_index)

        ISSUE_SERVER_LNK = conf.get('issue_server_link%s' % pattern_index)

        ISSUE_PREFIX = conf.get('issue_prefix%s' % pattern_index)

        log.debug('pattern suffix `%s` PAT:%s SERVER_LINK:%s PREFIX:%s'

                  % (pattern_index, ISSUE_PATTERN, ISSUE_SERVER_LNK,

                     ISSUE_PREFIX))

        def url_func(match_obj):

            pref = ''

            if match_obj.group().startswith(' '):

                pref = ' '

            issue_id = ''.join(match_obj.groups())

            issue_url = ISSUE_SERVER_LNK.replace('{id}', issue_id)

            if repository:

                issue_url = issue_url.replace('{repo}', repository)

                repo_name = repository.split(URL_SEP)[-1]

                issue_url = issue_url.replace('{repo_name}', repo_name)

            return (

                '%(pref)s<a class="%(cls)s" href="%(url)s">'

                '%(issue-prefix)s%(id-repr)s'

                '</a>'

                ) % {

                 'pref': pref,

                 'cls': 'issue-tracker-link',

                 'url': issue_url,

                 'id-repr': issue_id,

                 'issue-prefix': ISSUE_PREFIX,

                 'serv': ISSUE_SERVER_LNK,

                    str(self), str(other)))

        if not isinstance(other, _BaseIP):

            raise TypeError('%s and %s are not of the same type' % (

                    str(self), str(other)))

        if self._ip != other._ip:

            return self._ip > other._ip

        return False

    # Shorthand for Integer addition and subtraction. This is not

    # meant to ever support addition/subtraction of addresses.

    def __add__(self, other):

        if not isinstance(other, int):

            return NotImplemented

        return IPAddress(int(self) + other, version=self._version)

    def __sub__(self, other):

        if not isinstance(other, int):

            return NotImplemented

        return IPAddress(int(self) - other, version=self._version)

    def __repr__(self):

        return '%s(%r)' % (self.__class__.__name__, str(self))

    def __str__(self):

    def __hash__(self):

        return hash(hex(long(self._ip)))

    def _get_address_key(self):

        return (self._version, self)

    @property

    def version(self):

        raise NotImplementedError('BaseIP has no version')

class _BaseNet(_IPAddrBase):

    """A generic IP object.

    This IP class contains the version independent methods which are

    used by networks.

    """

    def __init__(self, address):

        self._cache = {}

        lock_name = os.path.join(os.path.dirname(__file__), 'running.lock')

        self.pidfile = file_ if file_ else lock_name

        self.callbackfn = callbackfn

        self.desc = desc

        self.debug = debug

        self.held = False

        #run the lock automatically !

        self.lock()

        self._finalize = Finalize(self, DaemonLock._on_finalize,

                                  args=(self, debug), exitpriority=10)

    @staticmethod

    def _on_finalize(lock, debug):

        if lock.held:

            if debug:

                print 'lock held finalizing and running lock.release()'

            lock.release()

    def lock(self):

        """

        locking function, if lock is present it

        will raise LockHeld exception

        """

        if self.debug:

            print 'running lock'

        self.trylock()

        self.makelock(lockname, self.pidfile)

        return True

    def trylock(self):

        running_pid = False

        if self.debug:

            print 'checking for already running process'

        try:

            with open(self.pidfile, 'r') as f:

                try:

                    running_pid = int(f.readline())

                except ValueError:

                    running_pid = -1

            if self.debug:

                print ('lock file present running_pid: %s, '

                       'checking for execution' % (running_pid,))

            # Now we check the PID from lock file matches to the current

            # process PID

            if running_pid:

                try:

            out = ''.join(bg_out)

            bg_err.stop()

            err = ''.join(bg_err)

            if (err.strip() == 'fatal: The remote end hung up unexpectedly' and

                out.startswith('0034shallow ')):

                # hack inspired by https://github.com/schacon/grack/pull/7

                bg_out = iter([out])

                _p = None

            elif err:

                raise EnvironmentError(

                    "Subprocess exited due to an error:\n" + err)

            else:

                raise EnvironmentError(

                    "Subprocess exited with non 0 ret code:%s" % _returncode)

        self.process = _p

        self.output = bg_out

        self.error = bg_err

        self.inputstream = inputstream

    def __iter__(self):

        return self

    def next(self):

        if self.process and self.process.poll():

            raise EnvironmentError("Subprocess exited due to an error:\n" + err)

        return self.output.next()

    def throw(self, type, value=None, traceback=None):

        if self.output.length or not self.output.done_reading:

            raise type(value)

    def close(self):

        try:

            self.process.terminate()

        except:

            pass

        try:

            self.output.close()

        except:

            pass

        try:

            self.error.close()

        except:

            pass

        try:

            os.close(self.inputstream)

        except:

            pass

    def prepare(self):

        """

        Prepare the passed udiff for HTML rendering. It'l return a list

        of dicts

        """

        return self._parse_udiff()

    def _safe_id(self, idstring):

        """Make a string safe for including in an id attribute.

        The HTML spec says that id attributes 'must begin with

        a letter ([A-Za-z]) and may be followed by any number

        of letters, digits ([0-9]), hyphens ("-"), underscores

        ("_"), colons (":"), and periods (".")'. These regexps

        are slightly over-zealous, in that they remove colons

        and periods unnecessarily.

        Whitespace is transformed into underscores, and then

        anything which is not a hyphen or a character that

        matches \w (alphanumerics and underscore) is removed.

        """

        # Transform all whitespace to underscore

        # Remove everything that is not a hyphen or a member of \w

        idstring = re.sub(r'(?!-)\W', "", idstring).lower()

        return idstring

    def raw_diff(self):

        """

        Returns raw string as udiff

        """

        udiff_copy = self.copy_iterator()

        if self.__format == 'gitdiff':

            udiff_copy = self._parse_gitdiff(udiff_copy)

        return u''.join(udiff_copy)

    def as_html(self, table_class='code-difftable', line_class='line',

                new_lineno_class='lineno old', old_lineno_class='lineno new',

                code_class='code'):

        """

        Return udiff as html table with customized css classes

        """

        def _link_to_if(condition, label, url):

            """

            Generates a link if condition is meet or just the label if not.

            """

    def _extract_mentions(self, s):

        user_objects = []

        for username in extract_mentioned_users(s):

            user_obj = User.get_by_username(username, case_insensitive=True)

            if user_obj:

                user_objects.append(user_obj)

        return user_objects

    def _get_notification_data(self, repo, comment, user, comment_text,

                               line_no=None, revision=None, pull_request=None,

                               status_change=None, closing_pr=False):

        """

        :returns: tuple (subj,body,recipients,notification_type,email_kwargs)

        """

        # make notification

        body = comment_text  # text of the comment

        line = ''

        if line_no:

            line = _('on line %s') % line_no

        #changeset

        if revision:

            notification_type = Notification.TYPE_CHANGESET_COMMENT

            cs = repo.scm_instance.get_changeset(revision)

            threading = ['%s-rev-%s@%s' % (repo.repo_name, revision, h.canonical_hostname())]

            if line_no: # TODO: url to file _and_ line number

                threading.append('%s-rev-%s-line-%s@%s' % (repo.repo_name, revision, line_no,

                                                           h.canonical_hostname()))

            comment_url = h.canonical_url('changeset_home',

                repo_name=repo.repo_name,

                revision=revision,

                anchor='comment-%s' % comment.comment_id)

            subj = safe_unicode(

                h.link_to('Re changeset: %(desc)s %(line)s' % \

                          {'desc': desc, 'line': line},

                          comment_url)

            )

            # get the current participants of this changeset

            recipients = ChangesetComment.get_users(revision=revision)

            # add changeset author if it's in kallithea system

            cs_author = User.get_from_cs_author(cs.author)

            if not cs_author:

                #use repo owner if we cannot extract the author correctly

                cs_author = repo.user

            recipients += [cs_author]

            email_kwargs = {

                'status_change': status_change,

                                    _authentication_token=self.authentication_token())

                                )

        response.mustcontain('This e-mail address is already in use')

    def test_my_account_update_err(self):

        self.log_user(TEST_USER_REGULAR2_LOGIN, TEST_USER_REGULAR2_PASS)

        new_email = 'newmail.pl'

        response = self.app.post(url('my_account'),

                                 params=dict(

                                            username=TEST_USER_ADMIN_LOGIN,

                                            new_password=TEST_USER_ADMIN_PASS,

                                            password_confirmation='test122',

                                            firstname='NewName',

                                            lastname='NewLastname',

                                            email=new_email,

                                            _authentication_token=self.authentication_token()))

        response.mustcontain('An email address must contain a single @')

        from kallithea.model import validators

        msg = validators.ValidUsername(edit=False, old_data={})\

                ._messages['username_exists']

        msg = h.html_escape(msg % {'username': TEST_USER_ADMIN_LOGIN})

    def test_my_account_api_keys(self):

        usr = self.log_user(TEST_USER_REGULAR2_LOGIN, TEST_USER_REGULAR2_PASS)

        user = User.get(usr['user_id'])

        response = self.app.get(url('my_account_api_keys'))

        response.mustcontain(user.api_key)

        response.mustcontain('Expires: Never')

    @parameterized.expand([

        ('forever', -1),

        ('5mins', 60*5),

        ('30days', 60*60*24*30),

    ])

    def test_my_account_add_api_keys(self, desc, lifetime):

        usr = self.log_user(TEST_USER_REGULAR2_LOGIN, TEST_USER_REGULAR2_PASS)

        user = User.get(usr['user_id'])

        response = self.app.post(url('my_account_api_keys'),

                                 {'description': desc, 'lifetime': lifetime, '_authentication_token': self.authentication_token()})

        self.checkSessionFlash(response, 'API key successfully created')

        try:

            response = response.follow()

            user = User.get(usr['user_id'])

            for api_key in user.api_keys:

                response.mustcontain(api_key)