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

class NotificationsController(BaseController):

    """REST Controller styled on the Atom Publishing Protocol"""

    # To properly map this controller, ensure your config/routing.py

        #    <input type="hidden" name="_method" value="DELETE" />

        # Or using helpers:

        #    h.form(url('notification', notification_id=ID),

        #           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.exceptions import RepositoryError, ChangesetError, \

    ChangesetDoesNotExistError

from vcs.nodes import FileNode

from vcs.utils import diffs as differ

from webob.exc import HTTPForbidden

log = logging.getLogger(__name__)

class ChangesetController(BaseRepoController):

        ChangesetCommentsModel().create(text=request.POST.get('text'),

                                        repo_id=c.rhodecode_db_repo.repo_id,

                                        user_id=c.rhodecode_user.user_id,

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

    @jsonify

    def delete_comment(self, comment_id):

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

# 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

def __get_lem():

    from pygments import lexers

    from string import lower

    from collections import defaultdict

    except Exception, err:

        if not quiet:

            print ("Cannot retrieve rhodecode's revision. Original error "

                   "was: %s" % err)

        return None

from vcs.backends import get_repo

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

    lockkey = __get_lockkey('get_commits_stats', repo_name, ts_min_y,

                            ts_max_y)

    lockkey_path = config['here']

    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 '

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

        co_day_auth_aggr = {}

        skip_date_limit = True

        parse_limit = int(config['app_conf'].get('commit_parse_limit'))

        last_rev = 0

        last_cs = None

        timegetter = itemgetter('time')

        dbrepo = sa.query(Repository)\

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

        cur_stats = sa.query(Statistics)\

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

        if cur_stats is not None:

    """

    def __init__(self, sa=None):

        if sa is not None:

            self.sa = sa

        else:

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

from rhodecode.model.notification import NotificationModel

log = logging.getLogger(__name__)

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

        """

        Creates new comment for changeset

            NotificationModel().create(created_by=user_id, subject=subj,

                                   body = body, recipients = recipients,

                                   type_ = Notification.TYPE_CHANGESET_COMMENT)

            return comment

        """

        Deletes given comment

        :param comment_id:

        """

        self.sa.delete(comment)

        return comment

    def get_comments(self, repo_id, revision):

        return ChangesetComment.query()\

                .filter(ChangesetComment.repo_id == repo_id)\

from rhodecode.lib.exceptions import UsersGroupsAssignedException

from rhodecode.lib.compat import json

from rhodecode.lib.caching_query import FromCache

from rhodecode.model.meta import Base, Session

log = logging.getLogger(__name__)

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

# BASE CLASSES

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

        for k in self._get_keys():

            if k in populate_dict:

                setattr(self, k, populate_dict[k])

    @classmethod

    def query(cls):

    @classmethod

    def get(cls, id_):

        if id_:

            return cls.query().get(id_)

    def getAll(cls):

        return cls.query().all()

    @classmethod

    def delete(cls, id_):

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

class RhodeCodeSetting(Base, BaseModel):

    __tablename__ = 'rhodecode_settings'

    __table_args__ = (UniqueConstraint('app_settings_name'), {'extend_existing':True})

    app_settings_id = Column("app_settings_id", Integer(), nullable=False, unique=True, default=None, primary_key=True)

        new_ui = cls.get_by_key(key).scalar() or cls()

        new_ui.ui_section = 'hooks'

        new_ui.ui_active = True

        new_ui.ui_key = key

        new_ui.ui_value = val

class User(Base, BaseModel):

    __tablename__ = 'users'

    __table_args__ = (UniqueConstraint('username'), UniqueConstraint('email'), {'extend_existing':True})

    user_id = Column("user_id", Integer(), nullable=False, unique=True, default=None, primary_key=True)

    repositories = relationship('Repository')

    user_followers = relationship('UserFollowing', primaryjoin='UserFollowing.follows_user_id==User.user_id', cascade='all')

    repo_to_perm = relationship('UserRepoToPerm', primaryjoin='UserRepoToPerm.user_id==User.user_id', cascade='all')

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

    @property

    def full_contact(self):

        return '%s %s <%s>' % (self.name, self.lastname, self.email)

    @property

        return q.scalar()

    def update_lastlogin(self):

        """Update user lastlogin"""

        self.last_login = datetime.datetime.now()

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

class UserLog(Base, BaseModel):

    __tablename__ = 'user_logs'

    __table_args__ = {'extend_existing':True}

    def create(cls, form_data):

        try:

            new_users_group = cls()

            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

    def update(cls, users_group_id, form_data):

        try:

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

            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

                        for u_id in set(v):

                            member = UsersGroupMember(users_group_id, u_id)

                            members_list.append(member)

                    setattr(users_group, 'members', members_list)

                setattr(users_group, k, v)

        except:

            log.error(traceback.format_exc())

            raise

    @classmethod

    def delete(cls, users_group_id):

        try:

            if assigned_groups:

                raise UsersGroupsAssignedException('RepoGroup assigned to %s' %

                                                   assigned_groups)

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

        except:

            log.error(traceback.format_exc())

            raise

class UsersGroupMember(Base, BaseModel):

    __tablename__ = 'users_groups_members'

    __table_args__ = {'extend_existing':True}

    @staticmethod

    def add_user_to_group(group, user):

        ugm = UsersGroupMember()

        ugm.users_group = group

        ugm.user = user

        return ugm

class Repository(Base, BaseModel):

    __tablename__ = 'repositories'

    __table_args__ = (UniqueConstraint('repo_name'), {'extend_existing':True},)

    @classmethod

    def url_sep(cls):

        return '/'

    @classmethod

    def get_by_repo_name(cls, repo_name):

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

                .options(joinedload(Repository.user))\

                .options(joinedload(Repository.group))

        return q.one()

    @classmethod

    def base_path(cls):

        """

        Returns base path when all repos are stored

        :param cls:

        """

                                              cls.url_sep())

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

        return q.one().ui_value

    @property

    def just_name(self):

    @LazyProperty

    def repo_path(self):

        """

        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

    @property

    def repo_full_path(self):

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

        new = cls()

        new.user_id = user_id

        new.permission = perm

        try:

        except:

    @classmethod

    def revoke_perm(cls, user_id, perm):

        if not isinstance(perm, Permission):

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

        try:

        except:

class UsersGroupRepoToPerm(Base, BaseModel):

    __tablename__ = 'users_group_repo_to_perm'

    __table_args__ = (UniqueConstraint('repository_id', 'users_group_id', 'permission_id'), {'extend_existing':True})

    users_group_to_perm_id = Column("users_group_to_perm_id", Integer(), nullable=False, unique=True, default=None, primary_key=True)

    users_group_id = Column("users_group_id", Integer(), ForeignKey('users_groups.users_group_id'), nullable=False, unique=None, default=None)

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

        new = cls()

        new.users_group_id = users_group_id

        new.permission = perm

        try:

        except:

    @classmethod

    def revoke_perm(cls, users_group_id, perm):

        if not isinstance(perm, Permission):

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

        try:

        except:

class UserRepoGroupToPerm(Base, BaseModel):

    __tablename__ = 'group_to_perm'

    __table_args__ = (UniqueConstraint('group_id', 'permission_id'), {'extend_existing':True})

            inv_obj.cache_active = False

        else:

            log.debug('cache key not found in invalidation db -> creating one')

            inv_obj = CacheInvalidation(key)

        try:

        except Exception:

            log.error(traceback.format_exc())

    @classmethod

    def set_valid(cls, key):

        """

        Mark this cache key as active and currently cached

        :param key:

        """

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

        inv_obj.cache_active = True

class ChangesetComment(Base, BaseModel):

    __tablename__ = 'changeset_comments'

    __table_args__ = ({'extend_existing':True},)

    comment_id = Column('comment_id', Integer(), nullable=False, primary_key=True)

        Returns user associated with this changesetComment. ie those

        who actually commented

        :param cls:

        :param revision:

        """

                .filter(cls.revision == revision)\

                .join(ChangesetComment.author).all()

class Notification(Base, BaseModel):

    __tablename__ = 'notifications'

        notification = cls()

        notification.created_by_user = created_by

        notification.subject = subject

        notification.body = body

        notification.type_ = type_

        for u in recipients:

        return notification

    @property

    def description(self):

        from rhodecode.model.notification import NotificationModel

        return NotificationModel().make_description(self)

class UserNotification(Base, BaseModel):

    __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'

    __table_args__ = {'extend_existing':True}

    repository_id = Column('repository_id', String(250), primary_key=True)

    repository_path = Column('repository_path', Text)

            recipients_objs.append(self.__get_user(u))

        recipients_objs = set(recipients_objs)

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

                            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)

        notification = self.__get_notification(notification)

        return UserNotification.query()\

            log.error(traceback.format_exc())

            self.sa.rollback()

            raise

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

            self.sa.rollback()

            raise

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

            self.sa.rollback()

            raise

    def delete_stats(self, repo_name):

        try:

                .filter(Statistics.repository == \

            self.sa.commit()

        except:

            log.error(traceback.format_exc())

            self.sa.rollback()

            raise

        user.permissions['repositories'] = {}

        user.permissions['global'] = set()

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

        # fetch default permissions

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

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

            .join((Repository, UserRepoToPerm.repository_id ==

                   Repository.repo_id))\

            .join((Permission, UserRepoToPerm.permission_id ==

                   Permission.permission_id))\

from rhodecode.model.db import UsersGroupMember, UsersGroup

log = logging.getLogger(__name__)

class UsersGroupModel(BaseModel):

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