from webob.exc import HTTPInternalServerError, HTTPForbidden

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

from pylons.controllers.util import redirect

from pylons.i18n.translation import _

from sqlalchemy.exc import IntegrityError

import rhodecode

from rhodecode.lib import helpers as h

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

    HasPermissionAnyDecorator, HasRepoPermissionAllDecorator, NotAnonymous,\

    HasPermissionAny, HasReposGroupPermissionAny, HasRepoPermissionAnyDecorator

from rhodecode.lib.base import BaseRepoController, render

from rhodecode.lib.helpers import get_token

from rhodecode.model.meta import Session

from rhodecode.model.db import User, Repository, UserFollowing, RepoGroup,\

    RhodeCodeSetting, RepositoryField

from rhodecode.model.forms import RepoForm, RepoFieldForm, RepoPermsForm

from rhodecode.model.scm import ScmModel, GroupList

from rhodecode.model.repo import RepoModel

from rhodecode.lib.compat import json

from sqlalchemy.sql.expression import func

from rhodecode.lib.exceptions import AttachedForksError

log = logging.getLogger(__name__)

        #override the choices with extracted revisions !

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

        c.landing_revs_choices = choices

        repo = Repository.get_by_repo_name(repo_name)

        _form = RepoForm(edit=True, old_data={'repo_name': repo_name,

                                              'repo_group': repo.group.get_dict() \

                                              if repo.group else {}},

                         repo_groups=c.repo_groups_choices,

                         landing_revs=c.landing_revs_choices)()

        try:

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

            repo = repo_model.update(repo_name, **form_result)

            h.flash(_('Repository %s updated successfully') % repo_name,

                    category='success')

            changed_name = repo.repo_name

            action_logger(self.rhodecode_user, 'admin_updated_repo',

                              changed_name, self.ip_addr, self.sa)

            Session().commit()

        except formencode.Invalid, errors:

            defaults = self.__load_data(repo_name)

            defaults.update(errors.value)

            return htmlfill.render(

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

                defaults=defaults,

            handle_forks = None

            if _forks and request.POST.get('forks'):

                do = request.POST['forks']

                if do == 'detach_forks':

                    handle_forks = 'detach'

                    h.flash(_('Detached %s forks') % _forks, category='success')

                elif do == 'delete_forks':

                    handle_forks = 'delete'

                    h.flash(_('Deleted %s forks') % _forks, category='success')

            repo_model.delete(repo, forks=handle_forks)

            action_logger(self.rhodecode_user, 'admin_deleted_repo',

                  repo_name, self.ip_addr, self.sa)

            h.flash(_('Deleted repository %s') % repo_name, category='success')

            Session().commit()

        except AttachedForksError:

            h.flash(_('Cannot delete %s it still contains attached forks')

                        % repo_name, category='warning')

        except Exception:

            log.error(traceback.format_exc())

            h.flash(_('An error occurred during deletion of %s') % repo_name,

                    category='error')

        return redirect(url('repos'))

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, AuthUser

from rhodecode.lib.base import BaseController, render

from rhodecode.lib.celerylib import tasks, run_task

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

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

        #    <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():

            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)

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

from pylons.controllers import WSGIController

from pylons.controllers.util import redirect

from pylons.templating import render_mako as render

from rhodecode import __version__, BACKENDS

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

    safe_str, safe_int

from rhodecode.lib.auth import AuthUser, get_container_username, authfunc,\

    HasPermissionAnyMiddleware, CookieStoreWrapper

from rhodecode.model import meta

from rhodecode.model.db import Repository, RhodeCodeUi, User, RhodeCodeSetting

from rhodecode.model.notification import NotificationModel

from rhodecode.model.scm import ScmModel

from rhodecode.model.meta import Session

log = logging.getLogger(__name__)

def _filter_proxy(ip):

    """

                      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

        """

    def _check_permission(self, action, user, repo_name, ip_addr=None):

        """

        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

        """

        #check IP

        authuser = AuthUser(user_id=user.user_id, ip_addr=ip_addr)

def set_rhodecode_config(config):

    """

    Updates pylons config with new settings from database

    :param config:

    """

    hgsettings = RhodeCodeSetting.get_app_settings()

    for k, v in hgsettings.items():

        config[k] = v

def map_groups(path):

    """

    Given a full path to a repository, create all nested groups that this

    repo is inside. This function creates parent-child relationships between

    groups and creates default perms for all new groups.

    :param paths: full path to repository

    """

    sa = meta.Session()

    groups = path.split(Repository.url_sep())

    parent = None

    group = None

from rhodecode.tests import *

from rhodecode.tests.fixture import Fixture

from rhodecode.model.db import Repository

from rhodecode.model.repo import RepoModel

from rhodecode.model.meta import Session

fixture = Fixture()

class TestSummaryController(TestController):

    def test_index(self):

        self.log_user()

        ID = Repository.get_by_repo_name(HG_REPO).repo_id

        response = self.app.get(url(controller='summary',

                                    action='index',

                                    repo_name=HG_REPO))

            """title="Mercurial repository" alt="Mercurial repository" """

            """src="/images/icons/hgicon.png"/>"""

        )

        response.mustcontain(

            """<img style="margin-bottom:2px" class="icon" """

            """title="Public repository" alt="Public """

            """repository" src="/images/icons/lock_open.png"/>"""

        )

        #codes stats

        self._enable_stats()

        response = self.app.get(url(controller='summary', action='index',

                                    repo_name=HG_REPO))

        response.mustcontain(

            """var data = [["py", {"count": 42, "desc": ["Python"]}], """

            """["rst", {"count": 11, "desc": ["Rst"]}], """

            """["sh", {"count": 2, "desc": ["Bash"]}], """

            """["makefile", {"count": 1, "desc": ["Makefile", "Makefile"]}],"""

            """ ["cfg", {"count": 1, "desc": ["Ini"]}], """

            """["css", {"count": 1, "desc": ["Css"]}], """

            """["bat", {"count": 1, "desc": ["Batch"]}]];"""

        )