from webob.exc import HTTPFound

import kallithea

from kallithea.lib import webutils

from kallithea.lib.auth import HasPermissionAnyDecorator, LoginRequired

from kallithea.lib.base import BaseController, render

from kallithea.lib.utils import repo2db_mapper, set_app_settings

from kallithea.lib.utils2 import safe_str

from kallithea.lib.vcs import VCSError

from kallithea.lib.webutils import url

from kallithea.model.forms import ApplicationSettingsForm, ApplicationUiSettingsForm, ApplicationVisualisationForm

from kallithea.model.notification import EmailNotificationModel

from kallithea.model.scm import ScmModel

log = logging.getLogger(__name__)

            test_email_html_body = EmailNotificationModel() \

                .get_email_tmpl(EmailNotificationModel.TYPE_DEFAULT,

                                'html', body=test_body)

            recipients = [test_email] if test_email else None

                             test_email_txt_body, test_email_html_body)

            webutils.flash(_('Send email task created'), category='success')

            raise HTTPFound(location=url('admin_settings_email'))

        defaults = db.Setting.get_app_settings()

    @HasPermissionAnyDecorator('hg.admin')

    def settings_search(self):

        c.active = 'search'

        if request.POST:

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

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

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

            raise HTTPFound(location=url('admin_settings_search'))

        defaults = db.Setting.get_app_settings()

        defaults.update(self._get_hg_ui_settings())

from tg.i18n import ugettext as _

from webob.exc import HTTPBadRequest

from kallithea.lib import ext_json, webutils

from kallithea.lib.auth import HasRepoPermissionLevelDecorator, LoginRequired

from kallithea.lib.base import BaseRepoController, jsonify, render

from kallithea.lib.conf import ALL_EXTS, ALL_READMES, LANGUAGES_EXTENSIONS_MAP

from kallithea.lib.markup_renderer import MarkupRenderer

from kallithea.lib.page import Page

from kallithea.lib.utils2 import safe_int, safe_str

from kallithea.lib.vcs.backends.base import EmptyChangeset

from kallithea.lib.vcs.exceptions import ChangesetError, EmptyRepositoryError, NodeDoesNotExistError

from kallithea.lib.vcs.nodes import FileNode

log = logging.getLogger(__name__)

README_FILES = [''.join([x[0][0], x[1][0]]) for x in

                    sorted(list(itertools.product(ALL_READMES, ALL_EXTS)),

        else:

            c.commit_data = {}

            c.overview_data = ([[ts_min_y, 0], [ts_max_y, 10]])

            c.trending_languages = []

        recurse_limit = 500  # don't recurse more than 500 times when parsing

        return render('summary/statistics.html')

import tg

import kallithea

class CeleryConfig(object):

    task_always_eager = False

# map from Kallithea .ini Celery 3 config names to Celery 4 config names

celery3_compat = {

    'broker.url': 'broker_url',

    'celery.accept.content': 'accept_content',

# 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/>.

"""

Kallithea task modules, containing all task that suppose to be run

by celery daemon

This file was forked by the Kallithea project in July 2014.

Original author and date, and relevant copyright and licensing information is below:

import kallithea

import kallithea.lib.helpers as h

from kallithea.lib import celerylib, conf, ext_json, hooks

from kallithea.lib.indexers.daemon import WhooshIndexingDaemon

from kallithea.lib.utils2 import asbool, ascii_bytes

from kallithea.lib.vcs.utils import author_email

__all__ = ['whoosh_index', 'get_commits_stats', 'send_email']

log = celery.utils.log.get_task_logger(__name__)

    try:

        lock = celerylib.DaemonLock(os.path.join(lockkey_path, lockkey))

        co_day_auth_aggr = {}

        commits_by_day_aggregate = {}

            return True

        # return if repo have no revisions

        if repo_size < 1:

            lock.release()

            return True

        skip_date_limit = True

        cur_stats = DBS.query(db.Statistics) \

            .filter(db.Statistics.repository == dbrepo).scalar()

        if cur_stats is not None:

            last_rev = cur_stats.stat_on_revision

            # pass silently without any work if we're not on first revision or

            # current state of parsing revision(from db marker) is the

            # last revision

            lock.release()

            return True

        log.debug('starting parsing %s', parse_limit)

        last_rev = last_rev + 1 if last_rev and last_rev >= 0 else 0

        log.debug('Getting revisions from %s to %s',

             last_rev, last_rev + parse_limit

        )

            log.debug('parsing %s', cs)

            last_cs = cs  # remember last parsed changeset

            tt = cs.date.timetuple()

            k = mktime(tt[:3] + (0, 0, 0, 0, 0, 0))

            if akc(cs.author) in co_day_auth_aggr:

                commits_by_day_aggregate[k] = 1

        overview_data = sorted(commits_by_day_aggregate.items(),

                               key=itemgetter(0))

        if not co_day_auth_aggr:

                "data": [0, 1],

                "schema": ["commits"],

            }

        stats = cur_stats if cur_stats else db.Statistics()

        stats.commit_activity = ascii_bytes(ext_json.dumps(co_day_auth_aggr))

        stats.commit_activity_combined = ascii_bytes(ext_json.dumps(overview_data))

        log.debug('last revision %s', last_rev)

        log.debug('revisions to parse %s', leftovers)

        if last_rev == 0 or leftovers < parse_limit:

            log.debug('getting code trending stats')

            stats.languages = ascii_bytes(ext_json.dumps(__get_codes_stats(repo_name)))

            return False

        # final release

        lock.release()

        # execute another task if celery is enabled

            get_commits_stats(repo_name, ts_min_y, ts_max_y, recurse_limit - 1)

        elif recurse_limit <= 0:

            log.debug('Not recursing - limit has been reached')

        else:

            log.debug('Not recursing')

    except celerylib.LockHeld:

    # repo creation defaults, private and repo_type are filled in form

    defs = db.Setting.get_default_repo_settings(strip_prefix=True)

    enable_statistics = defs.get('repo_enable_statistics')

    enable_downloads = defs.get('repo_enable_downloads')

    try:

            repo_name=repo_name_full,

            repo_type=repo_type,

            description=description,

            owner=owner,

            private=private,

            clone_uri=clone_uri,

        userlog.action_logger(cur_user, 'user_created_repo',

                      form_data['repo_name_full'], '')

        DBS.commit()

        # now create this repo on Filesystem

            repo_name=repo_name,

            repo_type=repo_type,

            repo_group=db.RepoGroup.guess_instance(repo_group),

            clone_uri=clone_uri,

        )

        # update repo changeset caches initially

        # set new created state

        DBS.commit()

    except Exception as e:

        log.warning('Exception %s occurred when forking repository, '

                    'doing cleanup...' % e)

        # rollback things manually !

            DBS.commit()

        raise

    return True

@celerylib.task

    landing_rev = form_data['landing_rev']

    copy_fork_permissions = form_data.get('copy_permissions')

    try:

        fork_of = db.Repository.guess_instance(form_data.get('fork_parent_id'))

            repo_name=repo_name_full,

            repo_type=repo_type,

            description=form_data['description'],

            owner=owner,

            private=private,

            clone_uri=clone_uri,

                      fork_of.repo_name, '')

        DBS.commit()

        source_repo_path = os.path.join(base_path, fork_of.repo_name)

        # now create this repo on Filesystem

            repo_name=repo_name,

            repo_type=repo_type,

            repo_group=db.RepoGroup.guess_instance(repo_group),

            clone_uri=source_repo_path,

        )

        # update repo changeset caches initially

        # set new created state

        DBS.commit()

    except Exception as e:

        log.warning('Exception %s occurred when forking repository, '

                    'doing cleanup...' % e)

        # rollback things manually !

            DBS.commit()

        raise

    return True

def __get_codes_stats(repo_name):

    code_stats = {}

    for _topnode, _dirnodes, filenodes in tip.walk('/'):

        for filenode in filenodes:

            ext = filenode.extension.lower()

            if ext in conf.LANGUAGES_EXTENSIONS_MAP and not filenode.is_binary:

from tg import app_globals

from tg import tmpl_context as c

from tg.i18n import ugettext as _

from kallithea.lib.utils2 import fmt_date

log = logging.getLogger(__name__)

class NotificationModel(object):

            is given send to all admins

        :param type_: type of notification

        :param with_email: send email with this notification

        :param email_kwargs: additional dict to pass as args to email template

        """

        import kallithea.lib.helpers as h

        email_kwargs = email_kwargs or {}

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

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

        created_by_obj = db.User.guess_instance(created_by)

            rec_mails.add(created_by_obj.email)

        else:

            rec_mails.discard(created_by_obj.email)

        # send email with notification to participants

        for rec_mail in sorted(rec_mails):

                     email_html_body, headers,

                     from_name=created_by_obj.full_name_or_username)

class EmailNotificationModel(object):

        """

        Create repository using celery tasks

        :param form_data:

        :param cur_user:

        """

    def _update_permissions(self, repo, perms_new=None, perms_updates=None,

                            check_perms=True):

        if not perms_new:

            perms_new = []

        if not perms_updates:

        """

        Simple wrapper into executing celery task for fork creation

        :param form_data:

        :param cur_user:

        """

    def delete(self, repo, forks=None, fs_remove=True, cur_user=None):

        """

        Delete given repository, forks parameter defines what do do with

        attached forks. Throws AttachedForksError if deleted repo has attached

        forks

        Sends email with a password reset token and link to the password

        reset confirmation page with all information (including the token)

        pre-filled. Also returns URL of that page, only without the token,

        allowing users to copy-paste or manually enter the token from the

        email.

        """

        user_email = data['email']

        user = db.User.get_by_email(user_email)

        timestamp = int(time.time())

        if user is not None:

            if self.can_change_password(user):

            html_body = notification.EmailNotificationModel().get_email_tmpl(

                reg_type, 'html',

                user=user.short_contact,

                reset_token=token,

                reset_url=link)

            log.debug('sending email')

            log.info('send new password mail to %s', user_email)

        else:

            log.debug("password reset email %s not found", user_email)

        return webutils.url('reset_password_confirmation',

                     email=user_email,

                                                       webutils.session_csrf_secret_token())

        log.debug('computed password reset token: %s', expected_token)

        log.debug('received password reset token: %s', token)

        return expected_token == token

    def reset_password(self, user_email, new_passwd):

        user = db.User.get_by_email(user_email)

        if user is not None:

            if not self.can_change_password(user):

                raise Exception('trying to change password for external user')

            user.password = get_crypt_password(new_passwd)

            meta.Session().commit()

            log.info('change password for %s', user_email)

        if new_passwd is None:

            raise Exception('unable to set new password')

                 _('Password reset notification'),

                 _('The password to your account %s has been changed using password reset form.') % (user.username,))

        log.info('send password reset mail to %s', user_email)

        return True

import time

import urllib.parse

import mock

from tg.util.webtest import test_context

from kallithea.lib import webutils

from kallithea.lib.utils2 import check_password, generate_api_key

from kallithea.model import db, meta, validators

from kallithea.model.api_key import ApiKeyModel

from kallithea.model.user import UserModel

from kallithea.tests import base

            db.User.get_by_username(username), timestamp, self.session_csrf_secret_token())

        collected = []

        def mock_send_email(recipients, subject, body='', html_body='', headers=None, from_name=None):

            collected.append((recipients, subject, body, html_body))

                mock.patch.object(time, 'time', lambda: timestamp):

            response = self.app.post(base.url(controller='login',

                                         action='password_reset'),

                                     {'email': email,

                                      '_session_csrf_secret_token': self.session_csrf_secret_token()})

import re

import mock

from tg.util.webtest import test_context

import kallithea.lib.celerylib

import kallithea.lib.helpers as h

from kallithea.model import db, meta

from kallithea.model.notification import EmailNotificationModel, NotificationModel

from kallithea.model.user import UserModel

from kallithea.tests import base

            def send_email(recipients, subject, body='', html_body='', headers=None, from_name=None):

                assert recipients == ['u2@example.com']

                assert subject == 'Test Message'

                assert body == "hi there"

                assert '>hi there<' in html_body

                assert from_name == 'u1 u1'

                NotificationModel().create(created_by=self.u1,

                                                   body='hi there',

                                                   recipients=usrs)

    @mock.patch.object(h, 'canonical_url', (lambda arg, **kwargs: 'http://%s/?%s' % (arg, '&'.join('%s=%s' % (k, v) for (k, v) in sorted(kwargs.items())))))

    def test_dump_html_mails(self):

            l.append('<pre>%s</pre>\n' % body)

            l.append('<hr/>\n')

            l.append(html_body)

            l.append('<hr/>\n')

        with test_context(self.app):

                pr_kwargs = dict(

                    pr_nice_id='#7',

                    pr_title='The Title',

                    pr_title_short='The Title',

                    pr_url='http://pr.org/7',

                    pr_target_repo='http://mainline.com/repo',

                                                           body=body, email_kwargs=kwargs,

                                                           recipients=[self.u2], type_=type_)

                # Email type TYPE_PASSWORD_RESET has no corresponding notification type - test it directly:

                desc = 'TYPE_PASSWORD_RESET'

                kwargs = dict(user='John Doe', reset_token='decbf64715098db5b0bd23eab44bd792670ab746', reset_url='http://reset.com/decbf64715098db5b0bd23eab44bd792670ab746')

                    "Password reset link",

                    EmailNotificationModel().get_email_tmpl(EmailNotificationModel.TYPE_PASSWORD_RESET, 'txt', **kwargs),

                    EmailNotificationModel().get_email_tmpl(EmailNotificationModel.TYPE_PASSWORD_RESET, 'html', **kwargs),

                    from_name=db.User.get(self.u1).full_name_or_username)

        out = '<!doctype html>\n<html lang="en">\n<head><title>Notifications</title><meta http-equiv="Content-Type" content="text/html; charset=UTF-8"></head>\n<body>\n%s\n</body>\n</html>\n' % \

    def sendmail(self, sender, dest, msg):

        smtplib_mock.lastsender = sender

        smtplib_mock.lastdest = set(dest)

        smtplib_mock.lastmsg = msg

class TestMail(base.TestController):

    def test_send_mail_trivial(self):

        mailserver = 'smtp.mailserver.org'

        recipients = ['rcpt1', 'rcpt2']

        envelope_from = 'noreply@mailserver.org'

        html_body = 'html_body'

        config_mock = {

            'smtp_server': mailserver,

            'app_email_from': envelope_from,

        }

        assert smtplib_mock.lastdest == set(recipients)

        assert smtplib_mock.lastsender == envelope_from

        assert 'From: %s' % envelope_from in smtplib_mock.lastmsg

        assert 'Subject: %s' % subject in smtplib_mock.lastmsg

        assert body in smtplib_mock.lastmsg

        config_mock = {

            'smtp_server': mailserver,

            'app_email_from': envelope_from,

            'email_to': email_to,

        }

        assert smtplib_mock.lastdest == set([base.TEST_USER_ADMIN_EMAIL, email_to])

        assert smtplib_mock.lastsender == envelope_from

        assert 'From: %s' % envelope_from in smtplib_mock.lastmsg

        assert 'Subject: %s' % subject in smtplib_mock.lastmsg

        assert body in smtplib_mock.lastmsg

        config_mock = {

            'smtp_server': mailserver,

            'app_email_from': envelope_from,

            'email_to': email_to,

        }

        assert smtplib_mock.lastdest == set([base.TEST_USER_ADMIN_EMAIL] + email_to.split(','))

        assert smtplib_mock.lastsender == envelope_from

        assert 'From: %s' % envelope_from in smtplib_mock.lastmsg

        assert 'Subject: %s' % subject in smtplib_mock.lastmsg

        assert body in smtplib_mock.lastmsg

        html_body = 'html_body'

        config_mock = {

            'smtp_server': mailserver,

            'app_email_from': envelope_from,

        }

        assert smtplib_mock.lastdest == set([base.TEST_USER_ADMIN_EMAIL])

        assert smtplib_mock.lastsender == envelope_from

        assert 'From: %s' % envelope_from in smtplib_mock.lastmsg

        assert 'Subject: %s' % subject in smtplib_mock.lastmsg

        assert body in smtplib_mock.lastmsg

        author = db.User.get_by_username(base.TEST_USER_REGULAR_LOGIN)

        config_mock = {

            'smtp_server': mailserver,

            'app_email_from': envelope_from,

        }

        assert smtplib_mock.lastdest == set(recipients)

        assert smtplib_mock.lastsender == envelope_from

        assert 'From: "Kallithea Admin (no-reply)" <%s>' % envelope_from in smtplib_mock.lastmsg

        assert 'Subject: %s' % subject in smtplib_mock.lastmsg

        assert body in smtplib_mock.lastmsg

        author = db.User.get_by_username(base.TEST_USER_REGULAR_LOGIN)

        config_mock = {

            'smtp_server': mailserver,

            'app_email_from': envelope_from,

        }

        assert smtplib_mock.lastdest == set(recipients)

        assert smtplib_mock.lastsender == envelope_from

        assert 'From: "Kallithea Admin (no-reply)" <%s>' % envelope_addr in smtplib_mock.lastmsg

        assert 'Subject: %s' % subject in smtplib_mock.lastmsg

        assert body in smtplib_mock.lastmsg

        headers = {'extra': 'yes'}

        config_mock = {

            'smtp_server': mailserver,

            'app_email_from': envelope_from,

        }

                                                     from_name=author.full_name_or_username, headers=headers)

        assert smtplib_mock.lastdest == set(recipients)

        assert smtplib_mock.lastsender == envelope_from

        assert r'From: "foo (fubar) \"baz\" (no-reply)" <%s>' % envelope_from in smtplib_mock.lastmsg

        assert 'Subject: %s' % subject in smtplib_mock.lastmsg

setup

conftest

'''.split())

normal_modules = set('''

kallithea

kallithea.lib

kallithea.lib.auth

kallithea.lib.auth_modules

kallithea.lib.base

kallithea.lib.celerylib

kallithea.lib.db_manage

kallithea.lib.indexers

kallithea.lib.utils

kallithea.lib.utils2

kallithea.lib.vcs

kallithea.lib.webutils

kallithea.model

kallithea.model.scm

kallithea.templates.py

'''.split())

shown_modules = normal_modules | top_modules

# break the chains somehow - this is a cleanup TODO list

known_violations = [

('kallithea.lib.auth_modules', 'kallithea.lib.auth'),  # needs base&facade

('kallithea.lib.utils', 'kallithea.model'),  # clean up utils

('kallithea.lib.utils', 'kallithea.model.db'),

('kallithea.lib.utils', 'kallithea.model.scm'),

('kallithea.model', 'kallithea.lib.auth'),  # auth.HasXXX

('kallithea.model', 'kallithea.lib.auth_modules'),  # validators

('kallithea.model', 'kallithea.lib.helpers'),

('kallithea.model', 'kallithea.lib.hooks'),  # clean up hooks

('kallithea.model', 'kallithea.model.scm'),

('kallithea.model.scm', 'kallithea.lib.hooks'),