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

"""

    rhodecode.controllers.admin.settings

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

    settings controller for rhodecode admin

    :created_on: Jul 14, 2010

    :author: marcink

    :copyright: (C) 2010-2012 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

import traceback

import formencode

import pkg_resources

import platform

from sqlalchemy import func

from formencode import htmlfill

from pylons import request, session, tmpl_context as c, url, config

from pylons.controllers.util import abort, redirect

from pylons.i18n.translation import _

from rhodecode.lib import helpers as h

from rhodecode.lib.auth import LoginRequired, HasPermissionAllDecorator, \

    HasPermissionAnyDecorator, NotAnonymous, HasPermissionAny,\

    HasReposGroupPermissionAll, HasReposGroupPermissionAny

from rhodecode.lib.base import BaseController, render

from rhodecode.lib.celerylib import tasks, run_task

from rhodecode.lib.utils import repo2db_mapper, invalidate_cache, \

    set_rhodecode_config, repo_name_slug, check_git_version

from rhodecode.model.db import RhodeCodeUi, Repository, RepoGroup, \

    RhodeCodeSetting, PullRequest, PullRequestReviewers

from rhodecode.model.forms import UserForm, ApplicationSettingsForm, \

    ApplicationUiSettingsForm, ApplicationVisualisationForm

from rhodecode.model.scm import ScmModel, GroupList

from rhodecode.model.user import UserModel

from rhodecode.model.repo import RepoModel

from rhodecode.model.db import User

from rhodecode.model.notification import EmailNotificationModel

from rhodecode.model.meta import Session

from rhodecode.lib.utils2 import str2bool, safe_unicode

from rhodecode.lib.compat import json

from webob.exc import HTTPForbidden

log = logging.getLogger(__name__)

class SettingsController(BaseController):

    """REST Controller styled on the Atom Publishing Protocol"""

    # To properly map this controller, ensure your config/routing.py

    # file has a resource setup:

    #     map.resource('setting', 'settings', controller='admin/settings',

    #         path_prefix='/admin', name_prefix='admin_')

    @LoginRequired()

    def __before__(self):

        c.admin_user = session.get('admin_user')

        c.admin_username = session.get('admin_username')

        c.modules = sorted([(p.project_name, p.version)

                            for p in pkg_resources.working_set]

                           + [('git', check_git_version())],

                           key=lambda k: k[0].lower())

        c.py_version = platform.python_version()

        c.platform = platform.platform()

        super(SettingsController, self).__before__()

    @HasPermissionAllDecorator('hg.admin')

    def index(self, format='html'):

        """GET /admin/settings: All items in the collection"""

        # url('admin_settings')

        defaults = RhodeCodeSetting.get_app_settings()

        defaults.update(self._get_hg_ui_settings())

        return htmlfill.render(

            render('admin/settings/settings.html'),

            defaults=defaults,

            encoding="UTF-8",

            force_defaults=False

        )

    @HasPermissionAllDecorator('hg.admin')

    def create(self):

        """POST /admin/settings: Create a new item"""

        # url('admin_settings')

    @HasPermissionAllDecorator('hg.admin')

    def new(self, format='html'):

        """GET /admin/settings/new: Form to create a new item"""

        # url('admin_new_setting')

    @HasPermissionAllDecorator('hg.admin')

    def update(self, setting_id):

        """PUT /admin/settings/setting_id: Update an existing item"""

        # Forms posted to this method should contain a hidden field:

        #    <input type="hidden" name="_method" value="PUT" />

        # Or using helpers:

        #    h.form(url('admin_setting', setting_id=ID),

        #           method='put')

        # url('admin_setting', setting_id=ID)

        if setting_id == 'mapping':

            rm_obsolete = request.POST.get('destroy', False)

            log.debug('Rescanning directories with destroy=%s' % rm_obsolete)

            initial = ScmModel().repo_scan()

            log.debug('invalidating all repositories')

            for repo_name in initial.keys():

                invalidate_cache('get_repo_cached_%s' % repo_name)

            added, removed = repo2db_mapper(initial, rm_obsolete)

            _repr = lambda l: ', '.join(map(safe_unicode, l)) or '-'

            h.flash(_('Repositories successfully '

                      'rescanned added: %s ; removed: %s') %

                    (_repr(added), _repr(removed)),

                    category='success')

        if setting_id == 'whoosh':

            repo_location = self._get_hg_ui_settings()['paths_root_path']

            full_index = request.POST.get('full_index', False)

            run_task(tasks.whoosh_index, repo_location, full_index)

            h.flash(_('Whoosh reindex task scheduled'), category='success')

        if setting_id == 'global':

            application_form = ApplicationSettingsForm()()

            try:

                form_result = application_form.to_python(dict(request.POST))

            except formencode.Invalid, errors:

                return htmlfill.render(

                     render('admin/settings/settings.html'),

                     defaults=errors.value,

                     errors=errors.error_dict or {},

                     prefix_error=False,

                     encoding="UTF-8"

                )

            try:

                sett1 = RhodeCodeSetting.get_by_name_or_create('title')

                sett1.app_settings_value = form_result['rhodecode_title']

                Session().add(sett1)

                sett2 = RhodeCodeSetting.get_by_name_or_create('realm')

                sett2.app_settings_value = form_result['rhodecode_realm']

                Session().add(sett2)

                sett3 = RhodeCodeSetting.get_by_name_or_create('ga_code')

                sett3.app_settings_value = form_result['rhodecode_ga_code']

                Session().add(sett3)

                Session().commit()

                set_rhodecode_config(config)

                h.flash(_('Updated application settings'), category='success')

            except Exception:

                log.error(traceback.format_exc())

                h.flash(_('error occurred during updating '

                          'application settings'),

                          category='error')

        if setting_id == 'visual':

            application_form = ApplicationVisualisationForm()()

            try:

                form_result = application_form.to_python(dict(request.POST))

            except formencode.Invalid, errors:

                return htmlfill.render(

                     render('admin/settings/settings.html'),

                     defaults=errors.value,

                     errors=errors.error_dict or {},

                     prefix_error=False,

                     encoding="UTF-8"

                )

            try:

                sett1 = RhodeCodeSetting.get_by_name_or_create('show_public_icon')

                sett1.app_settings_value = \

                    form_result['rhodecode_show_public_icon']

                Session().add(sett1)

                sett2 = RhodeCodeSetting.get_by_name_or_create('show_private_icon')

                sett2.app_settings_value = \

                    form_result['rhodecode_show_private_icon']

                Session().add(sett2)

                sett3 = RhodeCodeSetting.get_by_name_or_create('stylify_metatags')

                sett3.app_settings_value = \

                    form_result['rhodecode_stylify_metatags']

                Session().add(sett3)

                sett4 = RhodeCodeSetting.get_by_name_or_create('lightweight_dashboard')

                sett4.app_settings_value = \

                    form_result['rhodecode_lightweight_dashboard']

                Session().add(sett4)

                sett4 = RhodeCodeSetting.get_by_name_or_create('repository_fields')

                sett4.app_settings_value = \

                    form_result['rhodecode_repository_fields']

                Session().add(sett4)

                Session().commit()

                set_rhodecode_config(config)

                h.flash(_('Updated visualisation settings'),

                        category='success')

            except Exception:

                log.error(traceback.format_exc())

                h.flash(_('error occurred during updating '

                          'visualisation settings'),

                        category='error')

        if setting_id == 'vcs':

            application_form = ApplicationUiSettingsForm()()

            try:

                form_result = application_form.to_python(dict(request.POST))

            except formencode.Invalid, errors:

                return htmlfill.render(

                     render('admin/settings/settings.html'),

                     defaults=errors.value,

                     errors=errors.error_dict or {},

                     prefix_error=False,

                     encoding="UTF-8"

                )

            try:

                # fix namespaces for hooks and extensions

                _f = lambda s: s.replace('.', '_')

                sett = RhodeCodeUi.get_by_key('push_ssl')

                sett.ui_value = form_result['web_push_ssl']

                Session().add(sett)

                sett = RhodeCodeUi.get_by_key('/')

                sett.ui_value = form_result['paths_root_path']

                Session().add(sett)

                #HOOKS

                sett = RhodeCodeUi.get_by_key(RhodeCodeUi.HOOK_UPDATE)

                sett.ui_active = form_result[_f('hooks_%s' %

                                                RhodeCodeUi.HOOK_UPDATE)]

                Session().add(sett)

                sett = RhodeCodeUi.get_by_key(RhodeCodeUi.HOOK_REPO_SIZE)

                sett.ui_active = form_result[_f('hooks_%s' %

                                                RhodeCodeUi.HOOK_REPO_SIZE)]

                Session().add(sett)

                sett = RhodeCodeUi.get_by_key(RhodeCodeUi.HOOK_PUSH)

                sett.ui_active = form_result[_f('hooks_%s' %

                                                RhodeCodeUi.HOOK_PUSH)]

                Session().add(sett)

                sett = RhodeCodeUi.get_by_key(RhodeCodeUi.HOOK_PULL)

                sett.ui_active = form_result[_f('hooks_%s' %

                                                 RhodeCodeUi.HOOK_PULL)]

                Session().add(sett)

                ## EXTENSIONS

                sett = RhodeCodeUi.get_by_key('largefiles')

                if not sett:

                    #make one if it's not there !

                    sett = RhodeCodeUi()

                    sett.ui_key = 'largefiles'

                    sett.ui_section = 'extensions'

                sett.ui_active = form_result[_f('extensions_largefiles')]

                Session().add(sett)

                sett = RhodeCodeUi.get_by_key('hgsubversion')

                if not sett:

                    #make one if it's not there !

                    sett = RhodeCodeUi()

                    sett.ui_key = 'hgsubversion'

                    sett.ui_section = 'extensions'

                sett.ui_active = form_result[_f('extensions_hgsubversion')]

                Session().add(sett)

#                sett = RhodeCodeUi.get_by_key('hggit')

#                if not sett:

#                    #make one if it's not there !

#                    sett = RhodeCodeUi()

#                    sett.ui_key = 'hggit'

#                    sett.ui_section = 'extensions'

#

#                sett.ui_active = form_result[_f('extensions_hggit')]

#                Session().add(sett)

                Session().commit()

                h.flash(_('Updated VCS settings'), category='success')

            except Exception:

                log.error(traceback.format_exc())

                h.flash(_('error occurred during updating '

                          'application settings'), category='error')

        if setting_id == 'hooks':

            ui_key = request.POST.get('new_hook_ui_key')

            ui_value = request.POST.get('new_hook_ui_value')

            try:

                if ui_value and ui_key:

                    RhodeCodeUi.create_or_update_hook(ui_key, ui_value)

                    h.flash(_('Added new hook'),

                            category='success')

                # check for edits

                update = False

                _d = request.POST.dict_of_lists()

                for k, v in zip(_d.get('hook_ui_key', []),

                                _d.get('hook_ui_value_new', [])):

                    RhodeCodeUi.create_or_update_hook(k, v)

                    update = True

                if update:

                    h.flash(_('Updated hooks'), category='success')

                Session().commit()

            except Exception:

                log.error(traceback.format_exc())

                h.flash(_('error occurred during hook creation'),

                        category='error')

            return redirect(url('admin_edit_setting', setting_id='hooks'))

        if setting_id == 'email':

            test_email = request.POST.get('test_email')

            test_email_subj = 'RhodeCode TestEmail'

            test_email_body = 'RhodeCode Email test'

            test_email_html_body = EmailNotificationModel()\

                .get_email_tmpl(EmailNotificationModel.TYPE_DEFAULT,

                                body=test_email_body)

            recipients = [test_email] if test_email else None

            run_task(tasks.send_email, recipients, test_email_subj,

                     test_email_body, test_email_html_body)

            h.flash(_('Email task created'), category='success')

        return redirect(url('admin_settings'))

    @HasPermissionAllDecorator('hg.admin')

    def delete(self, setting_id):

        """DELETE /admin/settings/setting_id: Delete an existing item"""

        # Forms posted to this method should contain a hidden field:

        #    <input type="hidden" name="_method" value="DELETE" />

        # Or using helpers:

        #    h.form(url('admin_setting', setting_id=ID),

        #           method='delete')

        # url('admin_setting', setting_id=ID)

        if setting_id == 'hooks':

            hook_id = request.POST.get('hook_id')

            RhodeCodeUi.delete(hook_id)

            Session().commit()

    @HasPermissionAllDecorator('hg.admin')

    def show(self, setting_id, format='html'):

        """

        GET /admin/settings/setting_id: Show a specific item"""

        # url('admin_setting', setting_id=ID)

    @HasPermissionAllDecorator('hg.admin')

    def edit(self, setting_id, format='html'):

        """

        GET /admin/settings/setting_id/edit: Form to

        edit an existing item"""

        # url('admin_edit_setting', setting_id=ID)

        c.hooks = RhodeCodeUi.get_builtin_hooks()

        c.custom_hooks = RhodeCodeUi.get_custom_hooks()

        return htmlfill.render(

            render('admin/settings/hooks.html'),

            defaults={},

            encoding="UTF-8",

            force_defaults=False

        )

    def _load_my_repos_data(self):

        repos_list = Session().query(Repository)\

                     .filter(Repository.user_id ==

                             self.rhodecode_user.user_id)\

                     .order_by(func.lower(Repository.repo_name)).all()

        repos_data = RepoModel().get_repos_as_dict(repos_list=repos_list,

                                                   admin=True)

        #json used to render the grid

        return json.dumps(repos_data)

    @NotAnonymous()

    def my_account(self):

        """

        GET /_admin/my_account Displays info about my account

        """

        # url('admin_settings_my_account')

        c.user = User.get(self.rhodecode_user.user_id)

        c.ldap_dn = c.user.ldap_dn

        if c.user.username == 'default':

            h.flash(_("You can't edit this user since it's"

              " crucial for entire application"), category='warning')

            return redirect(url('users'))

        #json used to render the grid

        c.data = self._load_my_repos_data()

        defaults = c.user.get_dict()

        c.form = htmlfill.render(

            render('admin/users/user_edit_my_account_form.html'),

            defaults=defaults,

            encoding="UTF-8",

            force_defaults=False

        )

        return render('admin/users/user_edit_my_account.html')

    @NotAnonymous()

    def my_account_update(self):

        """PUT /_admin/my_account_update: Update an existing item"""

        # Forms posted to this method should contain a hidden field:

        #    <input type="hidden" name="_method" value="PUT" />

        # Or using helpers:

        #    h.form(url('admin_settings_my_account_update'),

        #           method='put')

        # url('admin_settings_my_account_update', id=ID)

        uid = self.rhodecode_user.user_id

        c.user = User.get(self.rhodecode_user.user_id)

        c.ldap_dn = c.user.ldap_dn

        email = self.rhodecode_user.email

        _form = UserForm(edit=True,

                         old_data={'user_id': uid, 'email': email})()

        form_result = {}

        try:

            form_result = _form.to_python(dict(request.POST))

            skip_attrs = ['admin', 'active']  # skip attr for my account

            if c.ldap_dn:

                #forbid updating username for ldap accounts

                skip_attrs.append('username')

            UserModel().update(uid, form_result, skip_attrs=skip_attrs)

            h.flash(_('Your account was updated successfully'),

                    category='success')

            Session().commit()

        except formencode.Invalid, errors:

            #json used to render the grid

            c.data = self._load_my_repos_data()

            c.form = htmlfill.render(

                render('admin/users/user_edit_my_account_form.html'),

                defaults=errors.value,

                errors=errors.error_dict or {},

                prefix_error=False,

                encoding="UTF-8")

            return render('admin/users/user_edit_my_account.html')

        except Exception:

            log.error(traceback.format_exc())

            h.flash(_('error occurred during update of user %s') \

                    % form_result.get('username'), category='error')

        return redirect(url('my_account'))

    @NotAnonymous()

    def my_account_my_pullrequests(self):

                                .filter(PullRequest.user_id ==

                                        self.rhodecode_user.user_id)\

        return render('admin/users/user_edit_my_account_pullrequests.html')

    @NotAnonymous()

    def create_repository(self):

        """GET /_admin/create_repository: Form to create a new item"""

        new_repo = request.GET.get('repo', '')

        parent_group = request.GET.get('parent_group')

        if not HasPermissionAny('hg.admin', 'hg.create.repository')():

            #you're not super admin nor have global create permissions,

            #but maybe you have at least write permission to a parent group ?

            _gr = RepoGroup.get(parent_group)

            gr_name = _gr.group_name if _gr else None

            if not HasReposGroupPermissionAny('group.admin', 'group.write')(group_name=gr_name):

                raise HTTPForbidden

        acl_groups = GroupList(RepoGroup.query().all(),

                               perm_set=['group.write', 'group.admin'])

        c.repo_groups = RepoGroup.groups_choices(groups=acl_groups)

        c.repo_groups_choices = map(lambda k: unicode(k[0]), c.repo_groups)

        choices, c.landing_revs = ScmModel().get_repo_landing_revs()

        c.new_repo = repo_name_slug(new_repo)

        ## apply the defaults from defaults page

        defaults = RhodeCodeSetting.get_default_repo_settings(strip_prefix=True)

        if parent_group:

            defaults.update({'repo_group': parent_group})

        return htmlfill.render(

            render('admin/repos/repo_add.html'),

            defaults=defaults,

            errors={},

            prefix_error=False,

            encoding="UTF-8"

        )

    def _get_hg_ui_settings(self):

        ret = RhodeCodeUi.query().all()

        if not ret:

            raise Exception('Could not get application ui settings !')

        settings = {}

        for each in ret:

            k = each.ui_key

            v = each.ui_value

            if k == '/':

                k = 'root_path'

            if k == 'push_ssl':

                v = str2bool(v)

            if k.find('.') != -1:

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

            if each.ui_section in ['hooks', 'extensions']:

                v = each.ui_active

            settings[each.ui_section + '_' + k] = v

        return settings

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

<%inherit file="/base/base.html"/>

<%def name="title()">

    ${_('My account')} ${c.rhodecode_user.username} - ${c.rhodecode_name}

</%def>

<%def name="breadcrumbs_links()">

    ${_('My Account')}

</%def>

<%def name="page_nav()">

    ${self.menu('admin')}

</%def>

<%def name="main()">

<div class="box box-left">

    <!-- box / title -->

    <div class="title">

        ${self.breadcrumbs()}

    </div>

    <!-- end box / title -->

    ${c.form|n}

</div>

<div class="box box-right">

    <!-- box / title -->

    <div class="title">

        <h5>

        <input class="q_filter_box" id="q_filter" size="15" type="text" name="filter" value="${_('quick filter...')}" style="display: none"/>

        </h5>

         <ul class="links" style="color:#DADADA">

           <li>

             <span><a id="show_perms" class="link-white current" href="#perms">${_('My permissions')}</a> </span>

           </li>

           <li>

             <span><a id="show_my" class="link-white" href="#my">${_('My repos')}</a> </span>

           </li>

           <li>

             <span><a id="show_pullrequests" class="link-white" href="#pullrequests">${_('My pull requests')}</a> </span>

           </li>

         </ul>

    </div>

    <!-- end box / title -->

    <div id="perms_container">

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

           %for section in sorted(c.rhodecode_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.rhodecode_user.permissions[section]:

           <%

           if section != 'global':

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

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

           else:

               _perm = section_perm = None

           %>

            %if _perm not in ['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:

                            ${k}

                        %endif

                    </td>

                    <td>

                        %if section == 'global':

                         ${h.bool2icon(True)}

                        %else:

                        <span class="perm_tag ${_perm}">${section_perm}</span>

                        %endif

                     </td>

                </tr>

             %endif

            %endfor

            </tbody>

            </table>

            </div>

           %endfor

        </div>

    </div>

    <div id="my_container" style="display:none">

        <div class="table yui-skin-sam" id="repos_list_wrap"></div>

        <div id="user-paginator" style="padding: 0px 0px 0px 20px"></div>

    </div>

    <div id="pullrequests_container" class="table" style="display:none">

        ## loaded via AJAX

        ${_('Loading...')}

    </div>

</div>

<script type="text/javascript">

var show_perms = function(e){

    YUD.addClass('show_perms', 'current');

    YUD.removeClass('show_my','current');

    YUD.removeClass('show_pullrequests','current');

    YUD.setStyle('my_container','display','none');

    YUD.setStyle('pullrequests_container','display','none');

    YUD.setStyle('perms_container','display','');

    YUD.setStyle('q_filter','display','none');

}

YUE.on('show_perms','click',function(e){

    show_perms();

})

var show_my = function(e){

    YUD.addClass('show_my', 'current');

    YUD.removeClass('show_perms','current');

    YUD.removeClass('show_pullrequests','current');

    YUD.setStyle('perms_container','display','none');

    YUD.setStyle('pullrequests_container','display','none');

    YUD.setStyle('my_container','display','');

    YUD.setStyle('q_filter','display','');

    if(!YUD.hasClass('show_my', 'loaded')){

        table_renderer(${c.data |n});

        YUD.addClass('show_my', 'loaded');

    }

}

YUE.on('show_my','click',function(e){

    show_my(e);

})

var show_pullrequests = function(e){

    YUD.addClass('show_pullrequests', 'current');

    YUD.removeClass('show_my','current');

    YUD.removeClass('show_perms','current');

    YUD.setStyle('my_container','display','none');

    YUD.setStyle('perms_container','display','none');

    YUD.setStyle('pullrequests_container','display','');

    YUD.setStyle('q_filter','display','none');

}

YUE.on('show_pullrequests','click',function(e){

    show_pullrequests(e)

})

var tabs = {

    'perms': show_perms,

    'my': show_my,

    'pullrequests': show_pullrequests

}

var url = location.href.split('#');

if (url[1]) {

    //We have a hash

    var tabHash = url[1];

    var func = tabs[tabHash]

    if (func){

        func();

    }

}

function table_renderer(data){

    var myDataSource = new YAHOO.util.DataSource(data);

    myDataSource.responseType = YAHOO.util.DataSource.TYPE_JSON;

    myDataSource.responseSchema = {

        resultsList: "records",

        fields: [

            {key:"menu"},

            {key:"raw_name"},

            {key:"name"},

            {key:"last_changeset"},

            {key:"action"},

            ]

        };

    myDataSource.doBeforeCallback = function(req,raw,res,cb) {

        // This is the filter function

        var data     = res.results || [],

            filtered = [],

            i,l;

        if (req) {

            req = req.toLowerCase();

            for (i = 0; i<data.length; i++) {

                var pos = data[i].raw_name.toLowerCase().indexOf(req)

                if (pos != -1) {

                    filtered.push(data[i]);

                }

            }

            res.results = filtered;

        }

        return res;

    }

      // main table sorting

      var myColumnDefs = [

          {key:"menu",label:"",sortable:false,className:"quick_repo_menu hidden"},

          {key:"name",label:"${_('Name')}",sortable:true,

              sortOptions: { sortFunction: nameSort }},

          {key:"last_changeset",label:"${_('Tip')}",sortable:true,

              sortOptions: { sortFunction: revisionSort }},

          {key:"action",label:"${_('Action')}",sortable:false},

      ];

      var myDataTable = new YAHOO.widget.DataTable("repos_list_wrap", myColumnDefs, myDataSource,{

        sortedBy:{key:"name",dir:"asc"},

        paginator: new YAHOO.widget.Paginator({

            rowsPerPage: 50,

            alwaysVisible: false,

            template : "{PreviousPageLink} {FirstPageLink} {PageLinks} {LastPageLink} {NextPageLink}",

            pageLinks: 5,

            containerClass: 'pagination-wh',

            currentPageClass: 'pager_curpage',

            pageLinkClass: 'pager_link',

            nextPageLinkLabel: '>',

            previousPageLinkLabel: '<',

            firstPageLinkLabel: '<<',

            lastPageLinkLabel: '>>',

            containers:['user-paginator']

        }),

        MSG_SORTASC:"${_('Click to sort ascending')}",

        MSG_SORTDESC:"${_('Click to sort descending')}",

        MSG_EMPTY:"${_('No records found.')}",

        MSG_ERROR:"${_('Data error.')}",

        MSG_LOADING:"${_('Loading...')}",

      }

      );

      myDataTable.subscribe('postRenderEvent',function(oArgs) {

          tooltip_activate();

          quick_repo_menu();

      });

      var filterTimeout = null;

      updateFilter = function() {

          // Reset timeout

          filterTimeout = null;

          // Reset sort

          var state = myDataTable.getState();

          state.sortedBy = {key:'name', dir:YAHOO.widget.DataTable.CLASS_ASC};

          // Get filtered data

          myDataSource.sendRequest(YUD.get('q_filter').value,{

              success : myDataTable.onDataReturnInitializeTable,

              failure : myDataTable.onDataReturnInitializeTable,

              scope   : myDataTable,

              argument: state

          });

      };

      YUE.on('q_filter','click',function(){

          if(!YUD.hasClass('q_filter', 'loaded')){

              YUD.get('q_filter').value = '';

              //TODO: load here full list later to do search within groups

              YUD.addClass('q_filter', 'loaded');

          }

       });

      YUE.on('q_filter','keyup',function (e) {

          clearTimeout(filterTimeout);

          filterTimeout = setTimeout(updateFilter,600);

      });

    }

</script>

</%def>

<div class="pullrequests_section_head">${_('Opened by me')}</div>

<ul>

    %if c.my_pull_requests:

      %for pull_request in c.my_pull_requests:

      <li>

        <div style="height: 12px">

          <div style="float:left">

          %if pull_request.is_closed():

              <img src="${h.url('/images/icons/lock_go.png')}" title="${_('Closed')}"/>

          %endif

          <img src="${h.url('/images/icons/flag_status_%s.png' % str(pull_request.last_review_status))}" />

          <a href="${h.url('pullrequest_show',repo_name=pull_request.other_repo.repo_name,pull_request_id=pull_request.pull_request_id)}">

          ${_('Pull request #%s opened on %s') % (pull_request.pull_request_id, h.fmt_date(pull_request.created_on))}

          </a>

          </div>

          <div style="float:left;margin-top: -5px">