conditions=dict(function=check_repo))

    rmap.connect('repo_fork_create_home', '/{repo_name:.*}/fork',

                conditions=dict(function=check_repo, method=["POST"]))

    rmap.connect('repo_fork_home', '/{repo_name:.*}/fork',

                conditions=dict(function=check_repo))

    rmap.connect('repo_followers_home', '/{repo_name:.*}/followers',

                 controller='followers', action='followers',

                 conditions=dict(function=check_repo))

    return rmap

from formencode import htmlfill

from paste.httpexceptions import HTTPInternalServerError

from pylons.i18n.translation import _

from rhodecode.lib import helpers as h

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

from rhodecode.lib.base import BaseController, render

from rhodecode.lib.utils import invalidate_cache, action_logger, repo_name_slug

from rhodecode.lib.helpers import get_token

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

from rhodecode.model.forms import RepoForm

from rhodecode.model.scm import ScmModel

from rhodecode.model.repo import RepoModel

log = logging.getLogger(__name__)

    def __load_defaults(self):

        c.repo_groups = RepoGroup.groups_choices()

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

        repo_model = RepoModel()

        c.users_array = repo_model.get_users_js()

        c.users_groups_array = repo_model.get_users_groups_js()

        """

        POST /repos: Create a new item"""

        # url('repos')

        self.__load_defaults()

        form_result = {}

        try:

            form_result = RepoForm(repo_groups=c.repo_groups_choices)()\

                            .to_python(dict(request.POST))

            if form_result['clone_uri']:

                h.flash(_('created repository %s from %s') \

                    % (form_result['repo_name'], form_result['clone_uri']),

                    category='success')

            if request.POST.get('user_created'):

                action_logger(self.rhodecode_user, 'user_created_repo',

                              form_result['repo_name_full'], '', self.sa)

            else:

                action_logger(self.rhodecode_user, 'admin_created_repo',

                              form_result['repo_name_full'], '', self.sa)

        except formencode.Invalid, errors:

            c.new_repo = errors.value['repo_name']

            changed_name = repo.repo_name

            action_logger(self.rhodecode_user, 'admin_updated_repo',

                              changed_name, '', self.sa)

        except formencode.Invalid, errors:

            defaults = self.__load_data(repo_name)

            defaults.update(errors.value)

            repo_model.delete(repo)

            invalidate_cache('get_repo_cached_%s' % repo_name)

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

        except IntegrityError, e:

            if e.message.find('repositories_fork_id_fkey'):

                log.error(traceback.format_exc())

# 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

from rhodecode.lib.helpers import Page

from rhodecode.lib.base import BaseRepoController, render

log = logging.getLogger(__name__)

class ForksController(BaseRepoController):

    @LoginRequired()

    def __before__(self):

        super(ForksController, self).__before__()

    def forks(self, repo_name):

        p = int(request.params.get('page', 1))

        repo_id = c.rhodecode_db_repo.repo_id

            return c.forks_data

        return render('/forks/forks.html')

# 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

from sqlalchemy import or_

from webhelpers.paginate import Page

from paste.httpexceptions import HTTPBadRequest

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

from pylons.i18n.translation import _

import rhodecode.lib.helpers as h

from rhodecode.lib.auth import LoginRequired, NotAnonymous

from rhodecode.lib.base import BaseController, render

from rhodecode.model.db import UserLog, UserFollowing

log = logging.getLogger(__name__)

                try:

                    self.scm_model.toggle_following_user(user_id,

                                                self.rhodecode_user.user_id)

                    return 'ok'

                except:

                    raise HTTPBadRequest()

                try:

                    self.scm_model.toggle_following_repo(repo_id,

                                                self.rhodecode_user.user_id)

                    return 'ok'

                except:

                    raise HTTPBadRequest()

import rhodecode.lib.helpers as h

from rhodecode.lib.base import BaseRepoController, render

from rhodecode.lib.utils import invalidate_cache, action_logger

from rhodecode.model.repo import RepoModel

from rhodecode.model.db import RepoGroup

log = logging.getLogger(__name__)

    @LoginRequired()

    def __before__(self):

        super(SettingsController, self).__before__()

    def __load_defaults(self):

        c.repo_groups = RepoGroup.groups_choices()

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

        repo_model = RepoModel()

        c.users_array = repo_model.get_users_js()

        c.users_groups_array = repo_model.get_users_groups_js()

    @HasRepoPermissionAllDecorator('repository.admin')

    def index(self, repo_name):

        repo_model = RepoModel()

    def update(self, repo_name):

        repo_model = RepoModel()

        changed_name = repo_name

        self.__load_defaults()

        _form = RepoSettingsForm(edit=True,

                                 old_data={'repo_name': repo_name},

                                 repo_groups=c.repo_groups_choices)()

        try:

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

            repo_model.update(repo_name, form_result)

            invalidate_cache('get_repo_cached_%s' % repo_name)

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

            changed_name = form_result['repo_name_full']

            action_logger(self.rhodecode_user, 'user_updated_repo',

                          changed_name, '', self.sa)

        except formencode.Invalid, errors:

            c.repo_info = repo_model.get_by_repo_name(repo_name)

            c.users_array = repo_model.get_users_js()

            repo_model.delete(repo)

            invalidate_cache('get_repo_cached_%s' % repo_name)

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

        except Exception:

            log.error(traceback.format_exc())

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

                    category='error')

        return redirect(url('home'))

from pylons import config, url

from pylons.i18n.translation import _

from rhodecode.lib import LANGUAGES_EXTENSIONS_MAP, safe_str

from rhodecode.lib.celerylib import run_task, locked_task, str2bool, \

    __get_lockkey, LockHeld, DaemonLock

from rhodecode.lib.helpers import person

from rhodecode.lib.rcmail.smtp_mailer import SmtpMailer

from rhodecode.lib.compat import json, OrderedDict

from rhodecode.model import init_model

from rhodecode.model import meta

from sqlalchemy import engine_from_config

add_cache(config)

__all__ = ['whoosh_index', 'get_commits_stats',

           'reset_user_password', 'send_email']

CELERY_ON = str2bool(config['app_conf'].get('use_celery'))

    return log

@task(ignore_result=True)

@locked_task

def whoosh_index(repo_location, full_index):

    #log = whoosh_index.get_logger()

    index_location = config['index_dir']

    WhooshIndexingDaemon(index_location=index_location,

                         repo_location=repo_location, sa=get_session())\

        sa = get_session()

        lock = l = DaemonLock(file_=jn(lockkey_path, lockkey))

        akc = lambda k: person(k).replace('"', "")

        co_day_auth_aggr = {}

        commits_by_day_aggregate = {}

        repo_size = len(repo.revisions)

        #return if repo have no revisions

        if repo_size < 1:

            last_rev = cur_stats.stat_on_revision

        if last_rev == repo.get_changeset().revision and repo_size > 1:

            lock.release()

            return True

@task(ignore_result=True)

def send_password_link(user_email):

    log = get_logger(send_password_link)

    try:

        sa = get_session()

        user = User.get_by_email(user_email)

        if user:

@task(ignore_result=True)

def reset_user_password(user_email):

    try:

        try:

@task(ignore_result=True)

def create_repo_fork(form_data, cur_user):

    log = get_logger(create_repo_fork)

    backend = get_backend(alias)

def __get_codes_stats(repo_name):

    tip = repo.get_changeset()

    code_stats = {}

def repo_size(ui, repo, hooktype=None, **kwargs):

    :param ui:

    :param repo:

def log_pull_action(ui, repo, **kwargs):

    :param ui:

    :param repo:

    repository = extra_params['repository']

    action = 'pull'

    return 0

def log_push_action(ui, repo, **kwargs):

    :param ui:

    :param repo:

    action = action % ','.join(revs)

    return 0

    return request.environ['pylons.routes_dict'].get('repo_name')

    """

    Action logger for various actions made by users

        user_log.action_date = datetime.datetime.now()

        user_log.user_ip = ipaddr

        sa.add(user_log)

        log.info('Adding user %s, action %s on %s', user_obj, action, repo)

    except:

        log.error(traceback.format_exc())

def get_repos(path, recursive=False):

class ValidPasswordsMatch(formencode.validators.FancyValidator):

    def validate_python(self, value, state):

        pass_val = value.get('password') or value.get('new_password')

        if pass_val != value['password_confirmation']:

            e_dict = {'password_confirmation':

        'invalid_login':_('invalid user name'),

        'disabled_account':_('Your account is disabled')

    }

    # error mapping

    e_dict = {'username':messages['invalid_login'],

              'password':messages['invalid_password']}

        password = value['password']

        username = value['username']

        user = User.get_by_username(username)

        if authenticate(username, password):

            return value

        else:

                # db key This is an actual just the name to store in the

                # database

                repo_name_full = group_path + RepoGroup.url_sep() + repo_name

            else:

                group_path = ''

                repo_name_full = repo_name

    return _ValidRepoName

def SlugifyName():

        else:

            password = All(UnicodeString(strip=True, min=6, not_empty=True))

            password_confirmation = All(UnicodeString(strip=True, min=6, not_empty=False))

        active = StringBoolean(if_missing=False)

        name = UnicodeString(strip=True, min=1, not_empty=True)

        lastname = UnicodeString(strip=True, min=1, not_empty=True)

        chained_validators = [ValidRepoName(edit, old_data), ValidPerms]

    return _RepoForm

    class _RepoForkForm(formencode.Schema):

        allow_extra_fields = True

        filter_extra_fields = False

                        SlugifyName())

        description = UnicodeString(strip=True, min=1, not_empty=True)

        private = StringBoolean(if_missing=False)

    return _RepoForkForm

        repo_group = OneOf(repo_groups, hideList=True)

        private = StringBoolean(if_missing=False)

                              ValidSettings]

    return _RepoForm

from rhodecode.lib import helpers as h

from rhodecode.model import BaseModel

from rhodecode.model.db import Notification, User, UserNotification

log = logging.getLogger(__name__)

        :param recipients: list of int, str or User objects

        :param type_: type of notification

        """

        if not getattr(recipients, '__iter__', False):

            raise Exception('recipients must be a list of iterable')

            email_body_html = EmailNotificationModel()\

                            .get_email_tmpl(type_, **{'subject':subject,

                                                      'body':h.rst(body)})

                     email_body_html)

        return notif

            raise

    def create(self, form_data, cur_user, just_db=False, fork=False):

        try:

            if fork:

            new_repo = Repository()

            new_repo.enable_statistics = False

            for k, v in form_data.items():

                if k == 'repo_name':

                if k == 'repo_group':

                    k = 'group_id'

                if k == 'description':

                    v = v or repo_name

                setattr(new_repo, k, v)