web3.ui_section = 'web'

        web3.ui_key = 'allow_push'

        web3.ui_value = '*'

        web4 = RhodeCodeUi()

        web4.ui_section = 'web'

        web4.ui_key = 'baseurl'

        web4.ui_value = '/'

        paths = RhodeCodeUi()

        paths.ui_section = 'paths'

        paths.ui_key = '/'

        paths.ui_value = path

        hgsettings1 = RhodeCodeSetting('realm', 'RhodeCode authentication')

        hgsettings2 = RhodeCodeSetting('title', 'RhodeCode')

        hgsettings3 = RhodeCodeSetting('ga_code', '')

        self.sa.add(web1)

        self.sa.add(web2)

        self.sa.add(web3)

        self.sa.add(web4)

        self.sa.add(paths)

        self.sa.add(hgsettings1)

        self.sa.add(hgsettings2)

        self.sa.add(hgsettings3)

        self.create_ldap_options()

        log.info('created ui config')

    def create_user(self, username, password, email='', admin=False):

        log.info('creating user %s' % username)

        UserModel().create_or_update(username, password, email,

                                     firstname='RhodeCode', lastname='Admin',

                                     active=True, admin=admin)

    def create_default_user(self):

        log.info('creating default user')

        # create default user for handling default permissions.

        UserModel().create_or_update(username='default',

                              password=str(uuid.uuid1())[:8],

                              email='anonymous@rhodecode.org',

                              firstname='Anonymous', lastname='User')

    def create_permissions(self):

        # module.(access|create|change|delete)_[name]

        # module.(none|read|write|admin)

            if not Permission.get_by_key(p[0]):

                new_perm = Permission()

                new_perm.permission_name = p[0]

                self.sa.add(new_perm)

    def populate_default_permissions(self):

        log.info('creating default user permissions')

        default_user = self.sa.query(User)\

        .filter(User.username == 'default').scalar()

        reg_perm = UserToPerm()

        reg_perm.user = default_user

        reg_perm.permission = self.sa.query(Permission)\

        .filter(Permission.permission_name == 'hg.register.manual_activate')\

        .scalar()

        create_repo_perm = UserToPerm()

        create_repo_perm.user = default_user

        create_repo_perm.permission = self.sa.query(Permission)\

        .filter(Permission.permission_name == 'hg.create.repository')\

        .scalar()

        default_repo_perm = UserToPerm()

        default_repo_perm.user = default_user

        default_repo_perm.permission = self.sa.query(Permission)\

        .filter(Permission.permission_name == 'repository.read')\

        .scalar()

        self.sa.add(reg_perm)

        self.sa.add(create_repo_perm)

        self.sa.add(default_repo_perm)

"""Helper functions

Consists of functions to typically be used within templates, but also

available to Controllers. This module is available to both as 'h'.

"""

import random

import hashlib

import StringIO

import urllib

import math

import logging

from datetime import datetime

from pygments.formatters.html import HtmlFormatter

from pygments import highlight as code_highlight

from pylons import url, request, config

from pylons.i18n.translation import _, ungettext

from hashlib import md5

from webhelpers.html import literal, HTML, escape

from webhelpers.html.tools import *

from webhelpers.html.builder import make_tag

from webhelpers.html.tags import auto_discovery_link, checkbox, css_classes, \

    end_form, file, form, hidden, image, javascript_link, link_to, \

    link_to_if, link_to_unless, ol, required_legend, select, stylesheet_link, \

    submit, text, password, textarea, title, ul, xml_declaration, radio

from webhelpers.html.tools import auto_link, button_to, highlight, \

    js_obfuscate, mail_to, strip_links, strip_tags, tag_re

from webhelpers.number import format_byte_size, format_bit_size

from webhelpers.pylonslib import Flash as _Flash

from webhelpers.pylonslib.secure_form import secure_form

from webhelpers.text import chop_at, collapse, convert_accented_entities, \

    convert_misc_entities, lchop, plural, rchop, remove_formatting, \

    replace_whitespace, urlify, truncate, wrap_paragraphs

from webhelpers.date import time_ago_in_words

from webhelpers.paginate import Page

from webhelpers.html.tags import _set_input_attrs, _set_id_attr, \

    convert_boolean_attrs, NotGiven, _make_safe_id_component

from rhodecode.lib.annotate import annotate_highlight

from rhodecode.lib.utils import repo_name_slug

from rhodecode.lib.utils2 import str2bool, safe_unicode, safe_str, \

    get_changeset_safe

from rhodecode.lib.markup_renderer import MarkupRenderer

from rhodecode.lib.vcs.exceptions import ChangesetDoesNotExistError

from rhodecode.lib.vcs.backends.base import BaseChangeset

from rhodecode.config.conf import DATE_FORMAT, DATETIME_FORMAT

from rhodecode.model.changeset_status import ChangesetStatusModel

log = logging.getLogger(__name__)

html_escape_table = {

    "&": "&",

    '"': """,

    "'": "'",

    ">": ">",

    "<": "&lt;",

}

def html_escape(text):

    """Produce entities within text."""

    return "".join(html_escape_table.get(c,c) for c in text)

def shorter(text, size=20):

    postfix = '...'

    if len(text) > size:

        return text[:size - len(postfix)] + postfix

    return text

def _reset(name, value=None, id=NotGiven, type="reset", **attrs):

    """

    Reset button

    """

    _set_input_attrs(attrs, type, name, value)

    _set_id_attr(attrs, id, name)

    convert_boolean_attrs(attrs, ["disabled"])

    return HTML.input(**attrs)

reset = _reset

safeid = _make_safe_id_component

def FID(raw_id, path):

    """

    Creates a uniqe ID for filenode based on it's hash of path and revision

    it's safe to use in urls

    :param raw_id:

    :param path:

    """

    return 'C-%s-%s' % (short_id(raw_id), md5(safe_str(path)).hexdigest()[:12])

                if repository:

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

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

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

                return tmpl % {

                     'pref': pref,

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

                     'url': url,

                     'id-repr': issue_id,

                     'issue-prefix': ISSUE_PREFIX,

                     'serv': ISSUE_SERVER_LNK,

                }

            newtext = URL_PAT.sub(url_func, text_)

            if link_:

                # wrap not links into final link => link_

                newtext = linkify_others(newtext, link_)

            return literal(newtext)

    except:

        log.error(traceback.format_exc())

        pass

    return text_

def rst(source):

    return literal('<div class="rst-block">%s</div>' %

                   MarkupRenderer.rst(source))

def rst_w_mentions(source):

    """

    Wrapped rst renderer with @mention highlighting

    :param source:

    """

    return literal('<div class="rst-block">%s</div>' %

                   MarkupRenderer.rst_with_mentions(source))

def changeset_status(repo, revision):

    return ChangesetStatusModel().get_status(repo, revision)

def changeset_status_lbl(changeset_status):

    return dict(ChangesetStatus.STATUSES).get(changeset_status)

    def name(self):

        return self.group_name.split(RepoGroup.url_sep())[-1]

    @property

    def full_path(self):

        return self.group_name

    @property

    def full_path_splitted(self):

        return self.group_name.split(RepoGroup.url_sep())

    @property

    def repositories(self):

        return Repository.query()\

                .filter(Repository.group == self)\

                .order_by(Repository.repo_name)

    @property

    def repositories_recursive_count(self):

        cnt = self.repositories.count()

        def children_count(group):

            cnt = 0

            for child in group.children:

                cnt += child.repositories.count()

                cnt += children_count(child)

            return cnt

        return cnt + children_count(self)

    def get_new_name(self, group_name):

        """

        returns new full group name based on parent and new name

        :param group_name:

        """

        path_prefix = (self.parent_group.full_path_splitted if

                       self.parent_group else [])

        return RepoGroup.url_sep().join(path_prefix + [group_name])

class Permission(Base, BaseModel):

    __tablename__ = 'permissions'

    __table_args__ = (

        Index('p_perm_name_idx', 'permission_name'),

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

         'mysql_charset': 'utf8'},

    )

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

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

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

    def __unicode__(self):

        return u"<%s('%s:%s')>" % (

            self.__class__.__name__, self.permission_id, self.permission_name

        )

    @classmethod

    def get_by_key(cls, key):

        return cls.query().filter(cls.permission_name == key).scalar()

    @classmethod

    def get_default_perms(cls, default_user_id):

        q = Session().query(UserRepoToPerm, Repository, cls)\

         .join((Repository, UserRepoToPerm.repository_id == Repository.repo_id))\

         .join((cls, UserRepoToPerm.permission_id == cls.permission_id))\

         .filter(UserRepoToPerm.user_id == default_user_id)

        return q.all()

    @classmethod

    def get_default_group_perms(cls, default_user_id):

        q = Session().query(UserRepoGroupToPerm, RepoGroup, cls)\

         .join((RepoGroup, UserRepoGroupToPerm.group_id == RepoGroup.group_id))\

         .join((cls, UserRepoGroupToPerm.permission_id == cls.permission_id))\

         .filter(UserRepoGroupToPerm.user_id == default_user_id)

        return q.all()

class UserRepoToPerm(Base, BaseModel):

    __tablename__ = 'repo_to_perm'

    __table_args__ = (

        UniqueConstraint('user_id', 'repository_id', 'permission_id'),

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

         'mysql_charset': 'utf8'}

    )

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

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

    permission_id = Column("permission_id", Integer(), ForeignKey('permissions.permission_id'), nullable=False, unique=None, default=None)

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

    user = relationship('User')

    repository = relationship('Repository')

    permission = relationship('Permission')

    ${h.form(url('user_perm', id=c.user.user_id),method='put')}

    <div class="form">

        <!-- fields -->

        <div class="fields">

             <div class="field">

                <div class="label label-checkbox">

                    <label for="create_repo_perm">${_('Create repositories')}:</label>

                </div>

                <div class="checkboxes">

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

                </div>

             </div>

            <div class="buttons">

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

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

            </div>

        </div>

    </div>

    ${h.end_form()}

    ## permissions overview

    <div id="perms" class="table">

           %for section in sorted(c.perm_user.permissions.keys()):

              <div class="perms_section_head">${section.replace("_"," ").capitalize()}</div>

              <div id='tbl_list_wrap_${section}' class="yui-skin-sam">

               <table id="tbl_list_${section}">

                <thead>

                    <tr>

                    <th class="left">${_('Name')}</th>

                    <th class="left">${_('Permission')}</th>

                </thead>

                <tbody>

                %for k in c.perm_user.permissions[section]:

                     <%

                     if section != 'global':

                         section_perm = c.perm_user.permissions[section].get(k)

                         _perm = section_perm.split('.')[-1]

                     else:

                         _perm = section_perm = None

                     %>

                    <tr>

                        <td>

                            %if section == 'repositories':

                                <a href="${h.url('summary_home',repo_name=k)}">${k}</a>

                            %elif section == 'repositories_groups':

                                <a href="${h.url('repos_group_home',group_name=k)}">${k}</a>

                            %else:

                            %endif

                        </td>

                        <td>

                            %if section == 'global':

                            %else:

                            %endif

                         </td>

                    </tr>

                %endfor

                </tbody>

               </table>

              </div>

           %endfor

    </div>

</div>

    <!-- box / title -->

    <div class="title">

        <h5>${_('Email addresses')}</h5>

    </div>

    <div class="emails_wrap">

      <table class="noborder">

      %for em in c.user_email_map:

        <tr>

            <td><div class="gravatar"><img alt="gravatar" src="${h.gravatar_url(em.user.email,16)}"/> </div></td>

            <td><div class="email">${em.email}</div></td>

            <td>

              ${h.form(url('user_emails_delete', id=c.user.user_id),method='delete')}

                  ${h.hidden('del_email',em.email_id)}

                  ${h.submit('remove_',_('delete'),id="remove_email_%s" % em.email_id,

                  class_="delete_icon action_button", onclick="return  confirm('"+_('Confirm to delete this email: %s') % em.email+"');")}

              ${h.end_form()}

            </td>

        </tr>

      %endfor

      </table>

    </div>

    ${h.form(url('user_emails', id=c.user.user_id),method='put')}

    <div class="form">

        <!-- fields -->

        <div class="fields">

             <div class="field">

                <div class="label">

                    <label for="email">${_('New email address')}:</label>

                </div>

                <div class="input">

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

                </div>

             </div>

            <div class="buttons">

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

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

            </div>

        </div>

    </div>

    ${h.end_form()}

</div>

</%def>