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

"""

    rhodecode.model.notification

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

    Model for notifications

    :created_on: Nov 20, 2011

    :author: marcink

    :copyright: (C) 2009-2011 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 os

import logging

import traceback

import datetime

from pylons.i18n.translation import _

import rhodecode

from rhodecode.lib import helpers as h

from rhodecode.model import BaseModel

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

log = logging.getLogger(__name__)

class NotificationModel(BaseModel):

    def __get_user(self, user):

        if isinstance(user, basestring):

            return User.get_by_username(username=user)

        else:

            return self._get_instance(User, user)

    def __get_notification(self, notification):

        if isinstance(notification, Notification):

            return notification

        elif isinstance(notification, int):

            return Notification.get(notification)

        else:

            if notification:

                raise Exception('notification must be int or Instance'

                                ' of Notification got %s' % type(notification))

    def create(self, created_by, subject, body, recipients=None,

               type_=Notification.TYPE_MESSAGE, with_email=True,

               email_kwargs={}):

        """

        Creates notification of given type

        :param created_by: int, str or User instance. User who created this

            notification

        :param subject:

        :param body:

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

            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

        """

        from rhodecode.lib.celerylib import tasks, run_task

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

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

        created_by_obj = self.__get_user(created_by)

        if recipients:

            recipients_objs = []

            for u in recipients:

                obj = self.__get_user(u)

                if obj:

                    recipients_objs.append(obj)

            recipients_objs = set(recipients_objs)

        else:

            # empty recipients means to all admins

            recipients_objs = User.query().filter(User.admin == True).all()

        notif = Notification.create(created_by=created_by_obj, subject=subject,

                                    body=body, recipients=recipients_objs,

                                    type_=type_)

        if with_email is False:

            return notif

        # send email with notification

        for rec in recipients_objs:

            email_subject = NotificationModel().make_description(notif, False)

            type_ = type_

            email_body = body

            kwargs = {'subject':subject, 'body':h.rst(body)}

            kwargs.update(email_kwargs)

            email_body_html = EmailNotificationModel()\

                                .get_email_tmpl(type_, **kwargs)

            run_task(tasks.send_email, rec.email, email_subject, email_body,

                     email_body_html)

        return notif

    def delete(self, user, notification):

        # we don't want to remove actual notification just the assignment

        try:

            notification = self.__get_notification(notification)

            user = self.__get_user(user)

            if notification and user:

                obj = UserNotification.query()\

                        .filter(UserNotification.user == user)\

                        .filter(UserNotification.notification

                                == notification)\

                        .one()

                self.sa.delete(obj)

                return True

        except Exception:

            log.error(traceback.format_exc())

            raise

    def get_for_user(self, user):

        user = self.__get_user(user)

        return user.notifications

    def get_unread_cnt_for_user(self, user):

        user = self.__get_user(user)

        return UserNotification.query()\

                .filter(UserNotification.read == False)\

                .filter(UserNotification.user == user).count()

    def get_unread_for_user(self, user):

        user = self.__get_user(user)

        return [x.notification for x in UserNotification.query()\

                .filter(UserNotification.read == False)\

                .filter(UserNotification.user == user).all()]

    def get_user_notification(self, user, notification):

        user = self.__get_user(user)

        notification = self.__get_notification(notification)

        return UserNotification.query()\

            .filter(UserNotification.notification == notification)\

            .filter(UserNotification.user == user).scalar()

    def make_description(self, notification, show_age=True):

        """

        Creates a human readable description based on properties

        of notification object

        """

        _map = {notification.TYPE_CHANGESET_COMMENT:_('commented on commit'),

                notification.TYPE_MESSAGE:_('sent message'),

                notification.TYPE_MENTION:_('mentioned you'),

                notification.TYPE_REGISTRATION:_('registered in RhodeCode')}

        DATETIME_FORMAT = "%Y-%m-%d %H:%M:%S"

        tmpl = "%(user)s %(action)s %(when)s"

        if show_age:

            when = h.age(notification.created_on)

        else:

            DTF = lambda d: datetime.datetime.strftime(d, DATETIME_FORMAT)

            when = DTF(notification.created_on)

        data = dict(user=notification.created_by_user.username,

                    action=_map[notification.type_],

                    when=when)

        return tmpl % data

class EmailNotificationModel(BaseModel):

    TYPE_PASSWORD_RESET = 'passoword_link'

    TYPE_DEFAULT = 'default'

    def __init__(self):

        self._template_root = rhodecode.CONFIG['pylons.paths']['templates'][0]

        self._tmpl_lookup = rhodecode.CONFIG['pylons.app_globals'].mako_lookup

        self.email_types = {

            self.TYPE_CHANGESET_COMMENT:'email_templates/changeset_comment.html',

            self.TYPE_PASSWORD_RESET:'email_templates/password_reset.html',

            self.TYPE_REGISTRATION:'email_templates/registration.html',

            self.TYPE_DEFAULT:'email_templates/default.html'

        }

    def get_email_tmpl(self, type_, **kwargs):

        """

        return generated template for email based on given type

        :param type_:

        """

        email_template = self._tmpl_lookup.get_template(base)

        # translator inject

        _kwargs = {'_':_}

        _kwargs.update(kwargs)

        log.debug('rendering tmpl %s with kwargs %s' % (base, _kwargs))

        return email_template.render(**_kwargs)

from rhodecode.tests import *

from rhodecode.model.db import Repository

class TestForksController(TestController):

    def test_index(self):

        self.log_user()

        repo_name = HG_REPO

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

                                    repo_name=repo_name))

        self.assertTrue("""There are no forks yet""" in response.body)

    def test_index_with_fork(self):

        self.log_user()

        # create a fork

        fork_name = HG_FORK

        description = 'fork of vcs test'

        repo_name = HG_REPO

        org_repo = Repository.get_by_repo_name(repo_name)

        response = self.app.post(url(controller='forks',

                                     action='fork_create',

                                    repo_name=repo_name),

                                    {'repo_name':fork_name,

                                     'repo_group':'',

                                     'fork_parent_id':org_repo.repo_id,

                                     'repo_type':'hg',

                                     'description':description,

                                     'private':'False'})

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

                                    repo_name=repo_name))

        self.assertTrue("""<a href="/%s/summary">"""

                         """vcs_test_hg_fork</a>""" % fork_name

                         in response.body)

        #remove this fork

        response = self.app.delete(url('repo', repo_name=fork_name))

    def test_z_fork_create(self):

        self.log_user()

        fork_name = HG_FORK

        description = 'fork of vcs test'

        repo_name = HG_REPO

        org_repo = Repository.get_by_repo_name(repo_name)

        response = self.app.post(url(controller='forks', action='fork_create',

                                    repo_name=repo_name),

                                    {'repo_name':fork_name,

                                     'repo_group':'',

                                     'fork_parent_id':org_repo.repo_id,

                                     'repo_type':'hg',

                                     'description':description,

                                     'private':'False'})

        #test if we have a message that fork is ok

        self.assertTrue('forked %s repository as %s' \

                      % (repo_name, fork_name) in response.session['flash'][0])

        #test if the fork was created in the database

        fork_repo = self.Session().query(Repository)\

            .filter(Repository.repo_name == fork_name).one()

        self.assertEqual(fork_repo.repo_name, fork_name)

        self.assertEqual(fork_repo.fork.repo_name, repo_name)

        #test if fork is visible in the list ?

        response = response.follow()

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

                                    repo_name=fork_name))

        self.assertTrue('Fork of %s' % repo_name in response.body)

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

from rhodecode.tests import *

from rhodecode.lib import generate_api_key

from rhodecode.lib.auth import check_password

class TestLoginController(TestController):

    def test_index(self):

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

        self.assertEqual(response.status, '200 OK')

        # Test response...

    def test_login_admin_ok(self):

        response = self.app.post(url(controller='login', action='index'),

                                 {'username':'test_admin',

                                  'password':'test12'})

        self.assertEqual(response.status, '302 Found')

        self.assertEqual(response.session['rhodecode_user'].get('username') ,

                         'test_admin')

        response = response.follow()

        self.assertTrue('%s repository' % HG_REPO in response.body)

    def test_login_regular_ok(self):

        response = self.app.post(url(controller='login', action='index'),

                                 {'username':'test_regular',

                                  'password':'test12'})

        self.assertEqual(response.status, '302 Found')

        self.assertEqual(response.session['rhodecode_user'].get('username') ,

                         'test_regular')

        response = response.follow()

        self.assertTrue('%s repository' % HG_REPO in response.body)

        self.assertTrue('<a title="Admin" href="/_admin">' not in response.body)

    def test_login_ok_came_from(self):

        test_came_from = '/_admin/users'

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

                                     came_from=test_came_from),

                                 {'username':'test_admin',

                                  'password':'test12'})

        self.assertEqual(response.status, '302 Found')

        response = response.follow()

        self.assertEqual(response.status, '200 OK')

        self.assertTrue('Users administration' in response.body)

    def test_login_short_password(self):

        response = self.app.post(url(controller='login', action='index'),

                                 {'username':'test_admin',

                                  'password':'as'})

        self.assertEqual(response.status, '200 OK')

        self.assertTrue('Enter 3 characters or more' in response.body)

    def test_login_wrong_username_password(self):

        response = self.app.post(url(controller='login', action='index'),

                                 {'username':'error',

                                  'password':'test12'})

        self.assertEqual(response.status , '200 OK')

        self.assertTrue('invalid user name' in response.body)

        self.assertTrue('invalid password' in response.body)

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

    # REGISTRATIONS

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

    def test_register(self):

        response = self.app.get(url(controller='login', action='register'))

        self.assertTrue('Sign Up to RhodeCode' in response.body)

    def test_register_err_same_username(self):

        response = self.app.post(url(controller='login', action='register'),

                                            {'username':'test_admin',

                                             'password':'test12',

                                             'password_confirmation':'test12',

                                             'email':'goodmail@domain.com',

                                             'name':'test',

                                             'lastname':'test'})

        self.assertEqual(response.status , '200 OK')

        self.assertTrue('This username already exists' in response.body)

    def test_register_err_same_email(self):

        response = self.app.post(url(controller='login', action='register'),

                                            {'username':'test_admin_0',

                                             'password':'test12',

                                             'password_confirmation':'test12',

                                             'email':'test_admin@mail.com',

                                             'name':'test',

                                             'lastname':'test'})

        self.assertEqual(response.status , '200 OK')

        assert 'This e-mail address is already taken' in response.body

    def test_register_err_same_email_case_sensitive(self):

        response = self.app.post(url(controller='login', action='register'),

                                            {'username':'test_admin_1',

                                             'password':'test12',

                                             'password_confirmation':'test12',

                                             'email':'TesT_Admin@mail.COM',

                                             'name':'test',

                                             'lastname':'test'})

        self.assertEqual(response.status , '200 OK')

        assert 'This e-mail address is already taken' in response.body

    def test_register_err_wrong_data(self):

        response = self.app.post(url(controller='login', action='register'),

                                            {'username':'xs',

                                             'password':'test',

                                             'password_confirmation':'test',

                                             'email':'goodmailm',

                                             'name':'test',

                                             'lastname':'test'})

        self.assertEqual(response.status , '200 OK')

        assert 'An email address must contain a single @' in response.body

        assert 'Enter a value 6 characters long or more' in response.body

    def test_register_err_username(self):

        response = self.app.post(url(controller='login', action='register'),

                                            {'username':'error user',

                                             'password':'test12',

                                             'password_confirmation':'test12',

                                             'email':'goodmailm',

                                             'name':'test',

                                             'lastname':'test'})

        self.assertEqual(response.status , '200 OK')

        assert 'An email address must contain a single @' in response.body

        assert ('Username may only contain '

                'alphanumeric characters underscores, '

                'periods or dashes and must begin with '

                'alphanumeric character') in response.body

    def test_register_err_case_sensitive(self):

        response = self.app.post(url(controller='login', action='register'),

                                            {'username':'Test_Admin',

                                             'password':'test12',

                                             'password_confirmation':'test12',

                                             'email':'goodmailm',

                                             'name':'test',

                                             'lastname':'test'})

        self.assertEqual(response.status , '200 OK')

        self.assertTrue('An email address must contain a single @' in response.body)

        self.assertTrue('This username already exists' in response.body)

    def test_register_special_chars(self):

        response = self.app.post(url(controller='login', action='register'),

                                            {'username':'xxxaxn',

                                             'password':'ąćźżąśśśś',

                                             'password_confirmation':'ąćźżąśśśś',

                                             'email':'goodmailm@test.plx',

                                             'name':'test',

                                             'lastname':'test'})

        self.assertEqual(response.status , '200 OK')

        self.assertTrue('Invalid characters in password' in response.body)

    def test_register_password_mismatch(self):

        response = self.app.post(url(controller='login', action='register'),

                                            {'username':'xs',

                                             'password':'123qwe',

                                             'password_confirmation':'qwe123',

                                             'email':'goodmailm@test.plxa',

                                             'name':'test',

                                             'lastname':'test'})

        self.assertEqual(response.status , '200 OK')

        assert 'Passwords do not match' in response.body

    def test_register_ok(self):

        username = 'test_regular4'

        password = 'qweqwe'

        email = 'marcin@test.com'

        name = 'testname'

        lastname = 'testlastname'

        response = self.app.post(url(controller='login', action='register'),

                                            {'username':username,

                                             'password':password,

                                             'password_confirmation':password,

                                             'email':email,

                                             'name':name,

                                             'lastname':lastname})

        self.assertEqual(response.status , '302 Found')

        assert 'You have successfully registered into rhodecode' in response.session['flash'][0], 'No flash message about user registration'

        ret = self.Session().query(User).filter(User.username == 'test_regular4').one()

        assert ret.username == username , 'field mismatch %s %s' % (ret.username, username)

        assert check_password(password, ret.password) == True , 'password mismatch'

        assert ret.email == email , 'field mismatch %s %s' % (ret.email, email)

        assert ret.name == name , 'field mismatch %s %s' % (ret.name, name)

        assert ret.lastname == lastname , 'field mismatch %s %s' % (ret.lastname, lastname)

    def test_forgot_password_wrong_mail(self):

        response = self.app.post(url(controller='login', action='password_reset'),

                                            {'email':'marcin@wrongmail.org', })

        assert "This e-mail address doesn't exist" in response.body, 'Missing error message about wrong email'

    def test_forgot_password(self):

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

                                    action='password_reset'))

        self.assertEqual(response.status , '200 OK')

        username = 'test_password_reset_1'

        password = 'qweqwe'

        email = 'marcin@python-works.com'

        name = 'passwd'

        lastname = 'reset'

        new = User()

        new.username = username

        new.password = password

        new.email = email

        new.name = name

        new.lastname = lastname

        new.api_key = generate_api_key(username)

        self.Session().add(new)

        self.Session().commit()

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

                                     action='password_reset'),

                                 {'email':email, })

        self.checkSessionFlash(response, 'Your password reset link was sent')

        response = response.follow()

        # BAD KEY

        key = "bad"

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

                                    action='password_reset_confirmation',

                                    key=key))

        self.assertEqual(response.status, '302 Found')

        self.assertTrue(response.location.endswith(url('reset_password')))

        # GOOD KEY

        key = User.get_by_username(username).api_key

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

                                    action='password_reset_confirmation',

                                    key=key))

        self.assertEqual(response.status, '302 Found')

        self.assertTrue(response.location.endswith(url('login_home')))

        self.checkSessionFlash(response,

                               ('Your password reset was successful, '

                                'new password has been sent to your email'))

        response = response.follow()