import logging

from rhodecode.lib.base import BaseController, render

from rhodecode.model.db import Notification

from rhodecode.model.notification import NotificationModel

from rhodecode.lib.auth import LoginRequired

from rhodecode.lib import helpers as h

log = logging.getLogger(__name__)

        #           method='delete')

        # url('notification', notification_id=ID)

        no = Notification.get(notification_id)

        if h.HasPermissionAny('hg.admin', 'repository.admin')() or owner:

                return 'ok'

        return 'fail'

    def show(self, notification_id, format='html'):

        """GET /_admin/notifications/id: Show a specific item"""

        # url('notification', notification_id=ID)

        c.user = self.rhodecode_user

        unotification = NotificationModel()\

        if unotification.read is False:

            unotification.mark_as_read()

        return render('admin/notifications/show_notification.html')

    def edit(self, notification_id, format='html'):

        """GET /_admin/notifications/id/edit: Form to edit an existing item"""

        # url('edit_notification', notification_id=ID)

from vcs.nodes import FileNode

from vcs.utils import diffs as differ

from webob.exc import HTTPForbidden

log = logging.getLogger(__name__)

                                        revision=revision,

                                        f_path=request.POST.get('f_path'),

                                        line_no=request.POST.get('line'))

        return redirect(h.url('changeset_home', repo_name=repo_name,

                              revision=revision))

        co = ChangesetComment.get(comment_id)

        owner = lambda : co.author.user_id == c.rhodecode_user.user_id

        if h.HasPermissionAny('hg.admin', 'repository.admin')() or owner:

            return True

        else:

            raise HTTPForbidden()

# along with this program.  If not, see <http://www.gnu.org/licenses/>.

import os

def __get_lem():

    from pygments import lexers

                   "was: %s" % err)

        return None

add_cache(config)

__all__ = ['whoosh_index', 'get_commits_stats',

           'reset_user_password', 'send_email']

    log.info('running task with lockkey %s', lockkey)

    try:

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

        #for js data compatibilty cleans the key for person from '

        last_cs = None

        timegetter = itemgetter('time')

        dbrepo = sa.query(Repository)\

            .filter(Repository.repo_name == repo_name).scalar()

        cur_stats = sa.query(Statistics)\

        if sa is not None:

            self.sa = sa

        else:

# 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

from pylons.i18n.translation import _

from sqlalchemy.util.compat import defaultdict

from rhodecode.lib import helpers as h

from rhodecode.model import BaseModel

from rhodecode.model.db import ChangesetComment, User, Repository, Notification

class ChangesetCommentsModel(BaseModel):

    def _extract_mentions(self, s):

            user_obj = User.get_by_username(username, case_insensitive=True)

            if user_obj:

    def create(self, text, repo_id, user_id, revision, f_path=None,

               line_no=None):

            return comment

        """

        Deletes given comment

        :param comment_id:

        """

        self.sa.delete(comment)

        return comment

from rhodecode.model.meta import Base, Session

log = logging.getLogger(__name__)

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

    @classmethod

    def query(cls):

    @classmethod

    def get(cls, id_):

    @classmethod

    def delete(cls, id_):

        obj = cls.query().get(id_)

class RhodeCodeSetting(Base, BaseModel):

        new_ui.ui_key = key

        new_ui.ui_value = val

class User(Base, BaseModel):

    group_member = relationship('UsersGroupMember', cascade='all')

    @property

    def full_contact(self):

        """Update user lastlogin"""

        self.last_login = datetime.datetime.now()

        log.debug('updated user %s lastlogin', self.username)

            for k, v in form_data.items():

                setattr(new_users_group, k, v)

            return new_users_group

        except:

            log.error(traceback.format_exc())

            raise

    @classmethod

            for k, v in form_data.items():

                if k == 'users_group_members':

                    users_group.members = []

                    members_list = []

                    if v:

                        v = [v] if isinstance(v, basestring) else v

                    setattr(users_group, 'members', members_list)

                setattr(users_group, k, v)

        except:

            log.error(traceback.format_exc())

            raise

    @classmethod

                                                   assigned_groups)

            users_group = cls.get(users_group_id, cache=False)

        except:

            log.error(traceback.format_exc())

            raise

class UsersGroupMember(Base, BaseModel):

        ugm = UsersGroupMember()

        ugm.users_group = group

        ugm.user = user

        return ugm

class Repository(Base, BaseModel):

    @classmethod

    def get_by_repo_name(cls, repo_name):

        q = q.options(joinedload(Repository.fork))\

                .options(joinedload(Repository.user))\

                .options(joinedload(Repository.group))

        :param cls:

        """

                                              cls.url_sep())

        q.options(FromCache("sql_cache_short", "repository_repo_path"))

        return q.one().ui_value

        Returns base full path for that repository means where it actually

        exists on a filesystem

        """

                                              Repository.url_sep())

        q.options(FromCache("sql_cache_short", "repository_repo_path"))

        return q.one().ui_value

        new.user_id = user_id

        new.permission = perm

        try:

        except:

    @classmethod

            raise Exception('perm needs to be an instance of Permission class')

        try:

        except:

class UsersGroupRepoToPerm(Base, BaseModel):

    __tablename__ = 'users_group_repo_to_perm'

        new.users_group_id = users_group_id

        new.permission = perm

        try:

        except:

    @classmethod

            raise Exception('perm needs to be an instance of Permission class')

        try:

        except:

class UserRepoGroupToPerm(Base, BaseModel):

            inv_obj = CacheInvalidation(key)

        try:

        except Exception:

            log.error(traceback.format_exc())

    @classmethod

    def set_valid(cls, key):

        :param key:

        """

            .filter(CacheInvalidation.cache_key == key).scalar()

        inv_obj.cache_active = True

class ChangesetComment(Base, BaseModel):

        :param cls:

        :param revision:

        """

                .filter(cls.revision == revision)\

                .join(ChangesetComment.author).all()

        notification.subject = subject

        notification.body = body

        notification.type_ = type_

        for u in recipients:

        return notification

    @property

    __tablename__ = 'user_to_notification'

    __table_args__ = (UniqueConstraint('user_id', 'notification_id'),

                      {'extend_existing':True})

    read = Column('read', Boolean, default=False)

    sent_on = Column('sent_on', DateTime(timezone=False), nullable=True, unique=None)

    def mark_as_read(self):

        self.read = True

class DbMigrateVersion(Base, BaseModel):

    __tablename__ = 'db_migrate_version'

                            body=body, recipients=recipients_objs,

                            type_=type_)

        try:

                return True

        except Exception:

            log.error(traceback.format_exc())

            raise

        return UserNotification.query()\

                .filter(UserNotification.read == False)\

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

                .filter(UserNotification.read == False)\

    def get_user_notification(self, user, notification):

        user = self.__get_user(user)

    def delete_perm_user(self, form_data, repo_name):

        try:

                .filter(UserRepoToPerm.repository \

                        == self.get_by_repo_name(repo_name))\

            self.sa.commit()

        except:

            log.error(traceback.format_exc())

    def delete_perm_users_group(self, form_data, repo_name):

        try:

                .filter(UsersGroupRepoToPerm.repository \

                        == self.get_by_repo_name(repo_name))\

                .filter(UsersGroupRepoToPerm.users_group_id \

            self.sa.commit()

        except:

            log.error(traceback.format_exc())

    def delete_stats(self, repo_name):

        try:

                .filter(Statistics.repository == \

            self.sa.commit()

        except:

            log.error(traceback.format_exc())

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

        # fetch default permissions

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

        default_perms = self.sa.query(UserRepoToPerm, Repository, Permission)\

            .join((Repository, UserRepoToPerm.repository_id ==

class UsersGroupModel(BaseModel):

    def get(self, users_group_id, cache = False):

    def get_by_name(self, name, cache = False, case_insensitive = False):

    def create(self, form_data):

        try:

            self.sa.rollback()

            raise

    def add_user_to_group(self, users_group, user):

        for m in users_group.members:

            u = m.user

    %>

    <div class="table">

      %for notification in c.notifications:

          <div class="notification-header">

            <div class="gravatar">

            </div>

            </div>

            <div class="delete-notifications">

            </div>

          </div>

        </div>

      %endfor

    </div>

        self.app = TestApp(wsgiapp)

        url._push_object(URLGenerator(config['routes.map'], environ))

        self.index_location = config['app_conf']['index_dir']

        TestCase.__init__(self, *args, **kwargs)

                    'ldap_attr_email':'test@example.com' })

        new_settings = RhodeCodeSetting.get_ldap_settings()

        self.assertEqual(new_settings['ldap_host'], u'dc.example.com',

                         'fail db write compare')

from rhodecode.model.user import UserModel

from rhodecode.model.notification import NotificationModel

class TestNotificationsController(TestController):

    def test_index(self):

        self.log_user()

        u1 = UserModel().create_or_update(username='u1', password='qweqwe',

                                               email='u1@rhodecode.org',

                                               name='u1', lastname='u1').user_id

        response = self.app.get(url('notifications'))

        self.assertTrue('''<div class="table">No notifications here yet</div>'''

        cur_user = self._get_logged_user()

                                   body=u'notification_1',

                                   recipients=[cur_user])

        response = self.app.get(url('notifications'))

#    def test_index_as_xml(self):

#        response = self.app.get(url('formatted_notifications', format='xml'))

                                               email='u2@rhodecode.org',

                                               name='u2', lastname='u2')

        notification = NotificationModel().create(created_by=cur_user,

                                                  subject=u'test',

                                                  body=u'hi there',

                                                  recipients=[cur_user, u1, u2])

        u1 = User.get(u1.user_id)

        u2 = User.get(u2.user_id)

        # check DB

        cur_usr_id = cur_user.user_id

#    def test_delete_browser_fakeout(self):

        notification = NotificationModel().create(created_by=cur_user,

                                                  subject='test',

                                                  recipients=[cur_user, u1, u2])

        response = self.app.get(url('notification',

#

#    def test_edit_as_xml(self):

#        response = self.app.get(url('formatted_edit_notification', notification_id=1, format='xml'))

        self.checkSessionFlash(response, 'created repository %s' % (repo_name))

        #test if the repo was created in the database

                                                    repo_name).one()

        self.assertEqual(new_repo.repo_name, repo_name)

                               'created repository %s' % (repo_name_unicode))

        #test if the repo was created in the database