# 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

from rhodecode.model import meta

log = logging.getLogger(__name__)

def init_model(engine):

                    raise Exception(

                        'given object must be int, long or Instance of %s '

                        'got %s, no callback provided' % (cls, type(instance))

                    )

                else:

                    return callback(instance)

#

# 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.model import BaseModel

log = logging.getLogger(__name__)

class ChangesetStatusModel(BaseModel):

    def __get_changeset_status(self, changeset_status):

        return self._get_instance(ChangesetStatus, changeset_status)

    def get_status(self, repo, revision):

        """

        Returns status of changeset for given revision and version 0

        versioning makes a history of statuses, and version == 0 is always the

        current one

        :param repo:

        :type repo:

        :param revision: 40char hash

        :type revision: str

        """

        status = ChangesetStatus.query()\

            .filter(ChangesetStatus.repo == repo)\

            .filter(ChangesetStatus.revision == revision)\

            .filter(ChangesetStatus.version == 0).scalar()

        status = status.status if status else status

        :type status:

        :param user:

        :type user:

        :param comment:

        :type comment:

        """

        cur_statuses = ChangesetStatus.query()\

            .filter(ChangesetStatus.repo == repo)\

            .filter(ChangesetStatus.revision == revision)\

            .all()

        if cur_statuses:

            for st in cur_statuses:

                st.version += 1

                self.sa.add(st)

        new_status = ChangesetStatus()

        new_status.status = status

        new_status.revision = revision

        new_status.comment = comment

        self.sa.add(new_status)

        return new_status

log = logging.getLogger(__name__)

class NotificationModel(BaseModel):

    def __get_notification(self, notification):

        if isinstance(notification, Notification):

            return notification

        elif isinstance(notification, (int, long)):

            return Notification.get(notification)

        else:

        """

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

        if recipients:

            recipients_objs = []

            for u in recipients:

                if obj:

                    recipients_objs.append(obj)

            recipients_objs = set(recipients_objs)

            log.debug('sending notifications %s to %s' % (

                type_, recipients_objs)

            )

        return notif

    def delete(self, user, notification):

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

        try:

            notification = self.__get_notification(notification)

            if notification and user:

                obj = UserNotification.query()\

                        .filter(UserNotification.user == user)\

                        .filter(UserNotification.notification

                                == notification)\

                        .one()

                return True

        except Exception:

            log.error(traceback.format_exc())

            raise

    def get_for_user(self, user):

        return user.notifications

    def mark_all_read_for_user(self, user):

        UserNotification.query()\

            .filter(UserNotification.read == False)\

            .update({'read': True})

    def get_unread_cnt_for_user(self, user):

        return UserNotification.query()\

                .filter(UserNotification.read == False)\

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

    def get_unread_for_user(self, 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):

        notification = self.__get_notification(notification)

        return UserNotification.query()\

            .filter(UserNotification.notification == notification)\

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

log = logging.getLogger(__name__)

class RepoModel(BaseModel):

    def __get_users_group(self, users_group):

        return self._get_instance(UsersGroup, users_group,

                                  callback=UsersGroup.get_by_group_name)

    def __get_repos_group(self, repos_group):

        return self._get_instance(RepoGroup, repos_group,

                                  callback=RepoGroup.get_by_group_name)

    @LazyProperty

    def repos_path(self):

        """

        Get's the repositories root path from database

        """

        if cache:

            repo = repo.options(FromCache("sql_cache_short",

                                          "get_repo_%s" % repo_id))

        return repo.scalar()

    def get_repo(self, repository):

    def get_by_repo_name(self, repo_name, cache=False):

        repo = self.sa.query(Repository)\

            .filter(Repository.repo_name == repo_name)

        if cache:

        :param cur_user:

        """

        from rhodecode.lib.celerylib import tasks, run_task

        run_task(tasks.create_repo_fork, form_data, cur_user)

    def delete(self, repo):

        try:

            self.sa.delete(repo)

            self.__delete_repo(repo)

        except:

            log.error(traceback.format_exc())

            raise

        if found

        :param repo: Instance of Repository, repository_id, or repository name

        :param user: Instance of User, user_id or username

        :param perm: Instance of Permission, or permission_name

        """

        # check if we have that permission already

        obj = self.sa.query(UserRepoToPerm)\

            .filter(UserRepoToPerm.user == user)\

            .filter(UserRepoToPerm.repository == repo)\

            .scalar()

        Revoke permission for user on given repository

        :param repo: Instance of Repository, repository_id, or repository name

        :param user: Instance of User, user_id or username

        """

        obj = self.sa.query(UserRepoToPerm)\

            .filter(UserRepoToPerm.repository == repo)\

            .filter(UserRepoToPerm.user == user)\

            .one()

        self.sa.delete(obj)

        :param repo: Instance of Repository, repository_id, or repository name

        :param group_name: Instance of UserGroup, users_group_id,

            or users group name

        :param perm: Instance of Permission, or permission_name

        """

        group_name = self.__get_users_group(group_name)

        # check if we have that permission already

        obj = self.sa.query(UsersGroupRepoToPerm)\

            .filter(UsersGroupRepoToPerm.users_group == group_name)\

            .filter(UsersGroupRepoToPerm.repository == repo)\

            .scalar()

        Revoke permission for users group on given repository

        :param repo: Instance of Repository, repository_id, or repository name

        :param group_name: Instance of UserGroup, users_group_id,

            or users group name

        """

        group_name = self.__get_users_group(group_name)

        obj = self.sa.query(UsersGroupRepoToPerm)\

            .filter(UsersGroupRepoToPerm.repository == repo)\

            .filter(UsersGroupRepoToPerm.users_group == group_name)\

            .one()

#

# 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.model import BaseModel

log = logging.getLogger(__name__)

class RepositoryPermissionModel(BaseModel):

    def get_user_permission(self, repository, user):

        return UserRepoToPerm.query() \

                .filter(UserRepoToPerm.user == user) \

                .filter(UserRepoToPerm.repository == repository) \

                .scalar()

log = logging.getLogger(__name__)

class ReposGroupModel(BaseModel):

    def __get_users_group(self, users_group):

        return self._get_instance(UsersGroup, users_group,

                                  callback=UsersGroup.get_by_group_name)

    def __get_repos_group(self, repos_group):

        return self._get_instance(RepoGroup, repos_group,

                                  callback=RepoGroup.get_by_group_name)

    @LazyProperty

    def repos_path(self):

        """

        Get's the repositories root path from database

        """

            or repositories_group name

        :param user: Instance of User, user_id or username

        :param perm: Instance of Permission, or permission_name

        """

        repos_group = self.__get_repos_group(repos_group)

        # check if we have that permission already

        obj = self.sa.query(UserRepoGroupToPerm)\

            .filter(UserRepoGroupToPerm.user == user)\

            .filter(UserRepoGroupToPerm.group == repos_group)\

            .scalar()

        :param repos_group: Instance of ReposGroup, repositories_group_id,

            or repositories_group name

        :param user: Instance of User, user_id or username

        """

        repos_group = self.__get_repos_group(repos_group)

        obj = self.sa.query(UserRepoGroupToPerm)\

            .filter(UserRepoGroupToPerm.user == user)\

            .filter(UserRepoGroupToPerm.group == repos_group)\

            .one()

        self.sa.delete(obj)

        :param group_name: Instance of UserGroup, users_group_id,

            or users group name

        :param perm: Instance of Permission, or permission_name

        """

        repos_group = self.__get_repos_group(repos_group)

        group_name = self.__get_users_group(group_name)

        # check if we have that permission already

        obj = self.sa.query(UsersGroupRepoGroupToPerm)\

            .filter(UsersGroupRepoGroupToPerm.group == repos_group)\

            .filter(UsersGroupRepoGroupToPerm.users_group == group_name)\

            .scalar()

from rhodecode.lib.utils2 import safe_unicode, generate_api_key

from rhodecode.lib.caching_query import FromCache

from rhodecode.model import BaseModel

from rhodecode.model.db import User, UserRepoToPerm, Repository, Permission, \

    UserToPerm, UsersGroupRepoToPerm, UsersGroupToPerm, UsersGroupMember, \

from rhodecode.lib.exceptions import DefaultUserException, \

    UserOwnsReposException

from sqlalchemy.exc import DatabaseError

from sqlalchemy.orm import joinedload

    'group.admin': 4,

}

class UserModel(BaseModel):

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

        user = self.sa.query(User)

        if cache:

            user = user.options(FromCache("sql_cache_short",

                                          "get_user_%s" % user_id))

        return user.get(user_id)

    def get_user(self, user):

    def get_by_username(self, username, cache=False, case_insensitive=False):

        if case_insensitive:

            user = self.sa.query(User).filter(User.username.ilike(username))

        else:

            self.sa.add(user)

        except:

            log.error(traceback.format_exc())

            raise

    def delete(self, user):

        try:

            if user.username == 'default':

                raise DefaultUserException(

                    _(u"You can't remove this user since it's"

                      " crucial for entire application")

    def has_perm(self, user, perm):

        if not isinstance(perm, Permission):

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

                            'got %s instead' % type(perm))

        return UserToPerm.query().filter(UserToPerm.user == user)\

            .filter(UserToPerm.permission == perm).scalar() is not None

    def grant_perm(self, user, perm):

        """

        Grant user global permissions

        :param user:

        :param perm:

        """

        # if this permission is already granted skip it

        _perm = UserToPerm.query()\

            .filter(UserToPerm.user == user)\

            .filter(UserToPerm.permission == perm)\

            .scalar()

        if _perm:

        """

        Revoke users global permissions

        :param user:

        :param perm:

        """

        obj = UserToPerm.query()\

                .filter(UserToPerm.user == user)\

                .filter(UserToPerm.permission == perm)\

                .scalar()

        if obj:

        """

        Adds email address to UserEmailMap

        :param user:

        :param email:

        """

        obj = UserEmailMap()

        obj.user = user

        obj.email = email

        self.sa.add(obj)

        return obj

        """

        Removes email address from UserEmailMap

        :param user:

        :param email_id:

        """

        obj = UserEmailMap.query().get(email_id)

        if obj:

            self.sa.delete(obj)

log = logging.getLogger(__name__)

class UsersGroupModel(BaseModel):

    def __get_users_group(self, users_group):

        return self._get_instance(UsersGroup, users_group,

                                  callback=UsersGroup.get_by_group_name)

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

        return UsersGroup.get(users_group_id)

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

        return UsersGroup.get_by_group_name(name, cache, case_insensitive)

        except:

            log.error(traceback.format_exc())

            raise

    def add_user_to_group(self, users_group, user):

        users_group = self.__get_users_group(users_group)

        for m in users_group.members:

            u = m.user

            if u.user_id == user.user_id:

                return True

        except:

            log.error(traceback.format_exc())

            raise

    def remove_user_from_group(self, users_group, user):

        users_group = self.__get_users_group(users_group)

        users_group_member = None

        for m in users_group.members:

            if m.user.user_id == user.user_id:

                # Found this user's membership row

                users_group_member = m

        else:

            # User isn't in that group

            return False

    def has_perm(self, users_group, perm):

        users_group = self.__get_users_group(users_group)

        return UsersGroupToPerm.query()\

            .filter(UsersGroupToPerm.users_group == users_group)\

            .filter(UsersGroupToPerm.permission == perm).scalar() is not None

    def grant_perm(self, users_group, perm):

        new.users_group = users_group

        new.permission = perm

        self.sa.add(new)

    def revoke_perm(self, users_group, perm):

        users_group = self.__get_users_group(users_group)

        obj = UsersGroupToPerm.query()\

            .filter(UsersGroupToPerm.users_group == users_group)\

            .filter(UsersGroupToPerm.permission == perm).scalar()

        if obj:

            self.sa.delete(obj)