# 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

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

from rhodecode.model.user import UserModel

from rhodecode.model.db import User

from rhodecode.model.notification import EmailNotificationModel

from rhodecode.model.meta import Session

from rhodecode.lib.utils2 import str2bool

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)

            h.flash(_('Repositories successfully'

                      ' rescanned added: %s,removed: %s') % (added, 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)

                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

        )

    @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)

        all_repos = Session().query(Repository)\

                     .filter(Repository.user_id == c.user.user_id)\

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

        c.user_repos = ScmModel().get_repos(all_repos)

        path = org_req.environ.get('PATH_INFO')

    return path

class BasicAuth(AuthBasicAuthenticator):

    def __init__(self, realm, authfunc, auth_http_code=None):

        self.realm = realm

        self.authfunc = authfunc

        self._rc_auth_http_code = auth_http_code

    def build_authentication(self):

        head = WWW_AUTHENTICATE.tuples('Basic realm="%s"' % self.realm)

        if self._rc_auth_http_code and self._rc_auth_http_code == '403':

            # return 403 if alternative http return code is specified in

            # RhodeCode config

            return HTTPForbidden(headers=head)

        return HTTPUnauthorized(headers=head)

    def authenticate(self, environ):

        authorization = AUTHORIZATION(environ)

        if not authorization:

            return self.build_authentication()

        (authmeth, auth) = authorization.split(' ', 1)

        if 'basic' != authmeth.lower():

            return self.build_authentication()

        auth = auth.strip().decode('base64')

        _parts = auth.split(':', 1)

        if len(_parts) == 2:

            username, password = _parts

            if self.authfunc(environ, username, password):

                return username

        return self.build_authentication()

    __call__ = authenticate

class BaseVCSController(object):

    def __init__(self, application, config):

        self.application = application

        self.config = config

        # base path of repo locations

        self.basepath = self.config['base_path']

        #authenticate this mercurial request using authfunc

        self.authenticate = BasicAuth('', authfunc,

                                      config.get('auth_ret_code'))

        self.ipaddr = '0.0.0.0'

    def _handle_request(self, environ, start_response):

        raise NotImplementedError()

    def _get_by_id(self, repo_name):

        """

        Get's a special pattern _<ID> from clone url and tries to replace it

        with a repository_name for support of _<ID> non changable urls

        :param repo_name:

        """

        try:

            data = repo_name.split('/')

            if len(data) >= 2:

                by_id = data[1].split('_')

                if len(by_id) == 2 and by_id[1].isdigit():

                    _repo_name = Repository.get(by_id[1]).repo_name

                    data[1] = _repo_name

        except:

            log.debug('Failed to extract repo_name from id %s' % (

                      traceback.format_exc()

                      )

            )

        return '/'.join(data)

    def _invalidate_cache(self, repo_name):

        """

        Set's cache for this repository for invalidation on next access

        :param repo_name: full repo name, also a cache key

        """

        invalidate_cache('get_repo_cached_%s' % repo_name)

    def _check_permission(self, action, user, repo_name):

        """

        Checks permissions using action (push/pull) user and repository

        name

        :param action: push or pull action

        :param user: user instance

        :param repo_name: repository name

        """

        if action == 'push':

            if not HasPermissionAnyMiddleware('repository.write',

                                              'repository.admin')(user,

                                                                  repo_name):

                return False

        else:

            #any other action need at least read permission

            if not HasPermissionAnyMiddleware('repository.read',

                                              'repository.write',

                                              'repository.admin')(user,

                                                                  repo_name):

                return False

        return True

    def _get_ip_addr(self, environ):

        return _get_ip_addr(environ)

    def _check_ssl(self, environ, start_response):

        """

        Checks the SSL check flag and returns False if SSL is not present

        and required True otherwise

        """

        org_proto = environ['wsgi._org_proto']

        #check if we have SSL required  ! if not it's a bad request !

        require_ssl = str2bool(RhodeCodeUi.get_by_key('push_ssl').ui_value)

        if require_ssl and org_proto == 'http':

            log.debug('proto is %s and SSL is required BAD REQUEST !'

                      % org_proto)

            return False

        return True

    def _check_locking_state(self, environ, action, repo, user_id):

        """

        Checks locking on this repository, if locking is enabled and lock is

        present returns a tuple of make_lock, locked, locked_by.

        make_lock can have 3 states None (do nothing) True, make lock

        False release lock, This value is later propagated to hooks, which

        do the locking. Think about this as signals passed to hooks what to do.

        """

        locked = False  # defines that locked error should be thrown to user

        make_lock = None

        repo = Repository.get_by_repo_name(repo)

        user = User.get(user_id)

        # this is kind of hacky, but due to how mercurial handles client-server

        # server see all operation on changeset; bookmarks, phases and

        # obsolescence marker in different transaction, we don't want to check

        # locking on those

        obsolete_call = environ['QUERY_STRING'] in ['cmd=listkeys',]

        locked_by = repo.locked

        if repo and repo.enable_locking and not obsolete_call:

            if action == 'push':

                #check if it's already locked !, if it is compare users

                user_id, _date = repo.locked

                if user.user_id == user_id:

                    log.debug('Got push from user %s, now unlocking' % (user))

                    # unlock if we have push from user who locked

                    make_lock = False

                else:

                    # we're not the same user who locked, ban with 423 !

                    locked = True

            if action == 'pull':

                if repo.locked[0] and repo.locked[1]:

                    locked = True

                else:

                    log.debug('Setting lock on repo %s by %s' % (repo, user))

                    make_lock = True

        else:

            log.debug('Repository %s do not have locking enabled' % (repo))

        log.debug('FINAL locking values make_lock:%s,locked:%s,locked_by:%s'

                  % (make_lock, locked, locked_by))

        return make_lock, locked, locked_by

    def __call__(self, environ, start_response):

        start = time.time()

        try:

            return self._handle_request(environ, start_response)

        finally:

            log = logging.getLogger('rhodecode.' + self.__class__.__name__)

            log.debug('Request time: %.3fs' % (time.time() - start))

            meta.Session.remove()

class BaseController(WSGIController):

    def __before__(self):

        c.rhodecode_version = __version__

        c.rhodecode_instanceid = config.get('instance_id')

        c.rhodecode_name = config.get('rhodecode_title')

        c.use_gravatar = str2bool(config.get('use_gravatar'))

        c.ga_code = config.get('rhodecode_ga_code')

        # Visual options

        c.visual = AttributeDict({})

        c.visual.show_public_icon = str2bool(config.get('rhodecode_show_public_icon'))

        c.visual.show_private_icon = str2bool(config.get('rhodecode_show_private_icon'))

        c.visual.stylify_metatags = str2bool(config.get('rhodecode_stylify_metatags'))

        c.visual.lightweight_dashboard = str2bool(config.get('rhodecode_lightweight_dashboard'))

        c.repo_name = get_repo_slug(request)

        c.backends = BACKENDS.keys()

        c.unread_notifications = NotificationModel()\

                        .get_unread_cnt_for_user(c.rhodecode_user.user_id)

        self.cut_off_limit = int(config.get('cut_off_limit'))

        self.sa = meta.Session

        self.scm_model = ScmModel(self.sa)

        self.ip_addr = ''

    def __call__(self, environ, start_response):

        """Invoke the Controller"""

        # WSGIController.__call__ dispatches to the Controller method

        # the request is routed to. This routing information is

        # available in environ['pylons.routes_dict']

        start = time.time()

        try:

            self.ip_addr = _get_ip_addr(environ)

            # make sure that we update permissions each time we call controller

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

            cookie_store = CookieStoreWrapper(session.get('rhodecode_user'))

            user_id = cookie_store.get('user_id', None)

            username = get_container_username(environ, config)

            auth_user = AuthUser(user_id, api_key, username)

            request.user = auth_user

            self.rhodecode_user = c.rhodecode_user = auth_user

            if not self.rhodecode_user.is_authenticated and \

                       self.rhodecode_user.user_id is not None:

                self.rhodecode_user.set_authenticated(

                    cookie_store.get('is_authenticated')

                )

            log.info('IP: %s User: %s accessed %s' % (

               self.ip_addr, auth_user, safe_unicode(_get_access_path(environ)))

            )

            return WSGIController.__call__(self, environ, start_response)

        finally:

            log.info('IP: %s Request to %s time: %.3fs' % (

                _get_ip_addr(environ),

                safe_unicode(_get_access_path(environ)), time.time() - start)

            )

            meta.Session.remove()

class BaseRepoController(BaseController):

    """

    Base class for controllers responsible for loading all needed data for

    repository loaded items are

    c.rhodecode_repo: instance of scm repository

    c.rhodecode_db_repo: instance of db

    c.repository_followers: number of followers

    c.repository_forks: number of forks

    """

    def __before__(self):

        super(BaseRepoController, self).__before__()

        if c.repo_name:

            dbr = c.rhodecode_db_repo = Repository.get_by_repo_name(c.repo_name)

            c.rhodecode_repo = c.rhodecode_db_repo.scm_instance

            # update last change according to VCS data

            dbr.update_last_change(c.rhodecode_repo.last_change)

            if c.rhodecode_repo is None:

                log.error('%s this repository is present in database but it '

                          'cannot be created as an scm instance', c.repo_name)

                redirect(url('home'))

            # some globals counter for menu

            c.repository_followers = self.scm_model.get_followers(dbr)

            c.repository_forks = self.scm_model.get_forks(dbr)

            c.repository_pull_requests = self.scm_model.get_pull_requests(dbr)

    cgenerator = gen_color()

    def get_color_string(cs):

        if cs in color_dict:

            col = color_dict[cs]

        else:

            col = color_dict[cs] = cgenerator.next()

        return "color: rgb(%s)! important;" % (', '.join(col))

    def url_func(repo_name):

        def _url_func(changeset):

            author = changeset.author

            date = changeset.date

            message = tooltip(changeset.message)

            tooltip_html = ("<div style='font-size:0.8em'><b>Author:</b>"

                            " %s<br/><b>Date:</b> %s</b><br/><b>Message:"

                            "</b> %s<br/></div>")

            tooltip_html = tooltip_html % (author, date, message)

            lnk_format = '%5s:%s' % ('r%s' % changeset.revision,

                                     short_id(changeset.raw_id))

            uri = link_to(

                    lnk_format,

                    url('changeset_home', repo_name=repo_name,

                        revision=changeset.raw_id),

                    style=get_color_string(changeset.raw_id),

                    class_='tooltip',

                    title=tooltip_html

                  )

            uri += '\n'

            return uri

        return _url_func

    return literal(annotate_highlight(filenode, url_func(repo_name), **kwargs))

def is_following_repo(repo_name, user_id):

    from rhodecode.model.scm import ScmModel

    return ScmModel().is_following_repo(repo_name, user_id)

flash = _Flash()

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

# SCM FILTERS available via h.

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

from rhodecode.lib.vcs.utils import author_name, author_email

from rhodecode.lib.utils2 import credentials_filter, age as _age

from rhodecode.model.db import User, ChangesetStatus

age = lambda  x: _age(x)

capitalize = lambda x: x.capitalize()

email = author_email

short_id = lambda x: x[:12]

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

def fmt_date(date):

    if date:

        _fmt = _(u"%a, %d %b %Y %H:%M:%S").encode('utf8')

        return date.strftime(_fmt).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

    else:

        _type = repository

    return _type == 'hg'

def email_or_none(author):

    # extract email from the commit string

    _email = email(author)

    if _email != '':

        # check it against RhodeCode database, and use the MAIN email for this

        # user

        user = User.get_by_email(_email, case_insensitive=True, cache=True)

        if user is not None:

            return user.email

        return _email

    # See if it contains a username we can get an email from

    user = User.get_by_username(author_name(author), case_insensitive=True,

                                cache=True)

    if user is not None:

        return user.email

    # No valid email, not a valid user in the system, none!

    return None

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

    # attr to return from fetched user

    person_getter = lambda usr: getattr(usr, show_attr)

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

    _email = email(author)

    if _email != '':

        user = User.get_by_email(_email, case_insensitive=True, cache=True)

        if user is not None:

            return person_getter(user)

        return _email

    # Maybe it's a username?

    _author = author_name(author)

    user = User.get_by_username(_author, case_insensitive=True,

                                cache=True)

    if user is not None:

        return person_getter(user)

    # Still nothing?  Just pass back the author name then

    return _author

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

    # attr to return from fetched user

    person_getter = lambda usr: getattr(usr, show_attr)

    #maybe it's an ID ?

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

        id_ = int(id_)

        user = User.get(id_)

        if user is not None:

            return person_getter(user)

    return id_

def desc_stylize(value):

    """

    converts tags from value into html equivalent

    :param value:

    """

    value = re.sub(r'\[see\ \=\>\ *([a-zA-Z0-9\/\=\?\&\ \:\/\.\-]*)\]',

                   '<div class="metatag" tag="see">see =&gt; \\1 </div>', value)

    value = re.sub(r'\[license\ \=\>\ *([a-zA-Z0-9\/\=\?\&\ \:\/\.\-]*)\]',

                   '<div class="metatag" tag="license"><a href="http:\/\/www.opensource.org/licenses/\\1">\\1</a></div>', value)

    value = re.sub(r'\[(requires|recommends|conflicts|base)\ \=\>\ *([a-zA-Z\-\/]*)\]',

                   '<div class="metatag" tag="\\1">\\1 =&gt; <a href="/\\2">\\2</a></div>', value)

    value = re.sub(r'\[(lang|language)\ \=\>\ *([a-zA-Z\-\/]*)\]',

                   '<div class="metatag" tag="lang">\\2</div>', value)

    value = re.sub(r'\[([a-z]+)\]',

                  '<div class="metatag" tag="\\1">\\1</div>', value)

    return value

def bool2icon(value):

    """Returns True/False values represented as small html image of true/false

    icons

    :param value: bool value

    """

    if value is True:

        return HTML.tag('img', src=url("/images/icons/accept.png"),

                        alt=_('True'))

    if value is False:

        return HTML.tag('img', src=url("/images/icons/cancel.png"),

                        alt=_('False'))

    return value

def action_parser(user_log, feed=False, parse_cs=True):

    """

    This helper will action_map the specified string action into translated

    fancy names with icons and links

    :param user_log: user log instance

    :param feed: use output for feeds (no html and fancy icons)

    :param parse_cs: parse Changesets into VCS instances

    """

        parse_cs = False

    action = user_log.action

    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)