.. _models:

========================

The :mod:`models` module

========================

.. automodule:: kallithea.model

   :members:

.. automodule:: kallithea.model.comment

   :members:

.. automodule:: kallithea.model.permission

   :members:

.. automodule:: kallithea.model.repo

   :members:

.. automodule:: kallithea.model.repo_group

   :members:

.. automodule:: kallithea.model.scm

   :members:

.. automodule:: kallithea.model.user

   :members:

.. automodule:: kallithea.model.user_group

   :members:

        # fill repository group users

        for p in repo_group.repo_group_to_perm:

            data.update({'u_perm_%s' % p.user.username:

                             p.permission.permission_name})

        # fill repository group groups

        for p in repo_group.users_group_to_perm:

            data.update({'g_perm_%s' % p.users_group.users_group_name:

                             p.permission.permission_name})

        return data

    def _revoke_perms_on_yourself(self, form_result):

        _up = [u for u in form_result['perms_updates'] if request.authuser.username == u[0]]

        _new = [u for u in form_result['perms_new'] if request.authuser.username == u[0]]

        if _new and _new[0][1] != 'group.admin' or _up and _up[0][1] != 'group.admin':

            return True

        return False

    def index(self, format='html'):

        _list = RepoGroup.query(sorted=True).all()

        group_iter = RepoGroupList(_list, perm_level='admin')

        repo_groups_data = []

        _tmpl_lookup = app_globals.mako_lookup

        template = _tmpl_lookup.get_template('data_table/_dt_elements.html')

        repo_group_name = lambda repo_group_name, children_groups: (

            template.get_def("repo_group_name")

            .render_unicode(repo_group_name, children_groups, _=_, h=h, c=c)

        )

        repo_group_actions = lambda repo_group_id, repo_group_name, gr_count: (

            template.get_def("repo_group_actions")

            .render_unicode(repo_group_id, repo_group_name, gr_count, _=_, h=h, c=c,

                    ungettext=ungettext)

        )

        for repo_gr in group_iter:

            children_groups = [g.name for g in repo_gr.parents] + [repo_gr.name]

            repo_count = repo_gr.repositories.count()

            repo_groups_data.append({

                "raw_name": repo_gr.group_name,

                "group_name": repo_group_name(repo_gr.group_name, children_groups),

                "desc": h.escape(repo_gr.group_description),

                "repos": repo_count,

                "owner": h.person(repo_gr.owner),

                "action": repo_group_actions(repo_gr.group_id, repo_gr.group_name,

                                             repo_count)

        c.group_members_obj = sorted((x.user for x in c.user_group.members),

                                     key=lambda u: u.username.lower())

        c.group_members = [(x.user_id, x.username) for x in c.group_members_obj]

        c.available_members = sorted(((x.user_id, x.username) for x in

                                      User.query().all()),

                                     key=lambda u: u[1].lower())

    def __load_defaults(self, user_group_id):

        """

        Load defaults settings for edit, and update

        :param user_group_id:

        """

        user_group = UserGroup.get_or_404(user_group_id)

        data = user_group.get_dict()

        return data

    def index(self, format='html'):

        _list = UserGroup.query() \

                        .order_by(func.lower(UserGroup.users_group_name)) \

                        .all()

        group_iter = UserGroupList(_list, perm_level='admin')

        user_groups_data = []

        _tmpl_lookup = app_globals.mako_lookup

        template = _tmpl_lookup.get_template('data_table/_dt_elements.html')

        user_group_name = lambda user_group_id, user_group_name: (

            template.get_def("user_group_name")

            .render_unicode(user_group_id, user_group_name, _=_, h=h, c=c)

        )

        user_group_actions = lambda user_group_id, user_group_name: (

            template.get_def("user_group_actions")

            .render_unicode(user_group_id, user_group_name, _=_, h=h, c=c)

        )

        for user_gr in group_iter:

            user_groups_data.append({

                "raw_name": user_gr.users_group_name,

                "group_name": user_group_name(user_gr.users_group_id,

                                              user_gr.users_group_name),

                "desc": h.escape(user_gr.user_group_description),

                "members": len(user_gr.members),

                "active": h.boolicon(user_gr.users_group_active),

                "owner": h.person(user_gr.owner.username),

                "action": user_group_actions(user_gr.users_group_id, user_gr.users_group_name)

            })

from kallithea.model.forms import CustomDefaultPermissionsForm, UserForm

from kallithea.model.meta import Session

from kallithea.model.ssh_key import SshKeyModel, SshKeyModelException

from kallithea.model.user import UserModel

log = logging.getLogger(__name__)

class UsersController(BaseController):

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

    @LoginRequired()

    @HasPermissionAnyDecorator('hg.admin')

    def _before(self, *args, **kwargs):

        super(UsersController, self)._before(*args, **kwargs)

    def index(self, format='html'):

        c.users_list = User.query().order_by(User.username) \

                        .filter_by(is_default_user=False) \

                        .order_by(func.lower(User.username)) \

                        .all()

        users_data = []

        _tmpl_lookup = app_globals.mako_lookup

        template = _tmpl_lookup.get_template('data_table/_dt_elements.html')

        grav_tmpl = '<div class="gravatar">%s</div>'

        username = lambda user_id, username: (

                template.get_def("user_name")

                .render_unicode(user_id, username, _=_, h=h, c=c))

        user_actions = lambda user_id, username: (

                template.get_def("user_actions")

                .render_unicode(user_id, username, _=_, h=h, c=c))

        for user in c.users_list:

            users_data.append({

                "gravatar": grav_tmpl % h.gravatar(user.email, size=20),

                "raw_name": user.username,

                "username": username(user.user_id, user.username),

                "firstname": h.escape(user.name),

                "lastname": h.escape(user.lastname),

                "last_login": h.fmt_date(user.last_login),

                "last_login_raw": datetime_to_time(user.last_login),

                "active": h.boolicon(user.active),

                "admin": h.boolicon(user.admin),

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

    if (status or close_pr or delete) and (f_path or line_no):

        # status votes and closing is only possible in general comments

        raise HTTPBadRequest()

    if not allowed_to_change_status:

        if status or close_pr:

            h.flash(_('No permission to change status'), 'error')

            raise HTTPForbidden()

    if pull_request and delete == "delete":

        if (pull_request.owner_id == request.authuser.user_id or

            h.HasPermissionAny('hg.admin')() or

            h.HasRepoPermissionLevel('admin')(pull_request.org_repo.repo_name) or

            h.HasRepoPermissionLevel('admin')(pull_request.other_repo.repo_name)

        ) and not pull_request.is_closed():

            PullRequestModel().delete(pull_request)

            Session().commit()

            h.flash(_('Successfully deleted pull request %s') % pull_request_id,

                    category='success')

            return {

               'location': h.url('my_pullrequests'), # or repo pr list?

            }

        raise HTTPForbidden()

    text = request.POST.get('text', '').strip()

    comment = ChangesetCommentsModel().create(

        text=text,

        repo=c.db_repo.repo_id,

        author=request.authuser.user_id,

        revision=revision,

        pull_request=pull_request_id,

        f_path=f_path or None,

        line_no=line_no or None,

        status_change=ChangesetStatus.get_status_lbl(status) if status else None,

        closing_pr=close_pr,

    )

    if status:

        ChangesetStatusModel().set_status(

            c.db_repo.repo_id,

            status,

            request.authuser.user_id,

            comment,

            revision=revision,

            pull_request=pull_request_id,

import alembic.command

import alembic.config

import sqlalchemy

from sqlalchemy.engine import create_engine

from kallithea.model.base import init_model

from kallithea.model.db import Permission, RepoGroup, Repository, Setting, Ui, User, UserRepoGroupToPerm, UserToPerm

#from kallithea.model import meta

from kallithea.model.meta import Base, Session

from kallithea.model.permission import PermissionModel

from kallithea.model.repo_group import RepoGroupModel

from kallithea.model.user import UserModel

log = logging.getLogger(__name__)

class DbManage(object):

    def __init__(self, dbconf, root, tests=False, SESSION=None, cli_args=None):

        self.dbname = dbconf.split('/')[-1]

        self.tests = tests

        self.root = root

        self.dburi = dbconf

        self.cli_args = cli_args or {}

        self.init_db(SESSION=SESSION)

    def _ask_ok(self, msg):

        """Invoke ask_ok unless the force_ask option provides the answer"""

        force_ask = self.cli_args.get('force_ask')

        if force_ask is not None:

            return force_ask

        from kallithea.lib.utils2 import ask_ok

        return ask_ok(msg)

    def init_db(self, SESSION=None):

        if SESSION:

            self.sa = SESSION

        else:

            # init new sessions

            engine = create_engine(self.dburi)

            init_model(engine)

            self.sa = Session()

    def create_tables(self, override=False):

        """

        Create a auth database

        """

class UserGroupsAssignedException(Exception):

    pass

class AttachedForksError(Exception):

    pass

class RepoGroupAssignmentError(Exception):

    pass

class NonRelativePathError(Exception):

    pass

class IMCCommitError(Exception):

    pass

class UserCreationError(Exception):

    pass

class HgsubversionImportError(Exception):

    pass

from kallithea.lib.rcmail.exceptions import BadHeaders, InvalidMessage

from kallithea.lib.rcmail.response import MailResponse

class Message(object):

    """

    Encapsulates an email message.

    :param subject: email subject header

    :param recipients: list of email addresses

    :param body: plain text message

    :param html: HTML message

    :param sender: email sender address

    :param cc: CC list

    :param bcc: BCC list

    :param extra_headers: dict of extra email headers

    :param attachments: list of Attachment instances

    :param recipients_separator: alternative separator for any of

        'From', 'To', 'Delivered-To', 'Cc', 'Bcc' fields

    """

    def __init__(self,

                 subject=None,

                 recipients=None,

                 body=None,

                 html=None,

                 sender=None,

                 cc=None,

    A reimplementation of nearly everything in email.mime to be more useful

    for actually attaching things.  Rather than one class for every type of

    thing you'd encode, there's just this one, and it figures out how to

    encode what you ask it.

    """

    def __init__(self, type, **params):

        self.maintype, self.subtype = type.split('/')

        MIMEBase.__init__(self, self.maintype, self.subtype, **params)

    def add_text(self, content):

        # this is text, so encode it in canonical form

        try:

            encoded = content.encode('ascii')

            charset = 'ascii'

        except UnicodeError:

            encoded = content.encode('utf-8')

            charset = 'utf-8'

        self.set_payload(encoded, charset=charset)

    def extract_payload(self, mail):

        if mail.body is None:

            return  # only None, '' is still ok

        cdisp, cdisp_params = mail.content_encoding['Content-Disposition']

        assert ctype, ("Extract payload requires that mail.content_encoding "

                       "have a valid Content-Type.")

        if ctype.startswith("text/"):

            self.add_text(mail.body)

        else:

            if cdisp:

                # replicate the content-disposition settings

                self.add_header('Content-Disposition', cdisp, **cdisp_params)

            self.set_payload(mail.body)

            encoders.encode_base64(self)

    def __repr__(self):

        return "<MIMEPart '%s/%s': %r, %r, multipart=%r>" % (

            self.subtype,

            self.maintype,

            self['Content-Type'],

            self['Content-Disposition'],

            self.is_multipart())

        Commit api function that will add given ``FileNode`` into this

        repository.

        :raises ``NodeAlreadyExistsError``: if there is a file with same path

          already in repository

        :raises ``NodeAlreadyAddedError``: if given node is already marked as

          *added*

        """

        raise NotImplementedError

    def remove(self, filenode, **kwargs):

        """

        Commit api function that will remove given ``FileNode`` into this

        repository.

        :raises ``EmptyRepositoryError``: if there are no changesets yet

        :raises ``NodeDoesNotExistError``: if there is no file with given path

        """

        raise NotImplementedError

    def commit(self, message, **kwargs):

        """

        Persists current changes made on this repository and returns newly

        created changeset.

        """

        raise NotImplementedError

    def get_state(self):

        """

        Returns dictionary with ``added``, ``changed`` and ``removed`` lists

        containing ``FileNode`` objects.

        """

        raise NotImplementedError

    def get_config_value(self, section, name, config_file=None):

        """

        Returns configuration value for a given [``section``] and ``name``.

        :param section: Section we want to retrieve value from

        :param name: Name of configuration we want to retrieve

        :param config_file: A path to file which should be used to retrieve

          configuration from (might also be a list of file paths)

        """

        raise NotImplementedError

    def get_user_name(self, config_file=None):

        """

        Returns user's name from global configuration file.

    :copyright: (c) 2010-2011 by Marcin Kuzminski, Lukasz Balcerzak.

"""

class VCSError(Exception):

    pass

class RepositoryError(VCSError):

    pass

class EmptyRepositoryError(RepositoryError):

    pass

class TagAlreadyExistError(RepositoryError):

    pass

class TagDoesNotExistError(RepositoryError):

    pass

class BranchDoesNotExistError(RepositoryError):

    pass

class ChangesetError(RepositoryError):

    pass

class ChangesetDoesNotExistError(ChangesetError):

    pass

class CommitError(RepositoryError):

    pass

class NodeError(VCSError):

    pass

class RemovedFileNodeError(NodeError):

    pass

class NodeAlreadyExistsError(CommitError):

    pass

class NodeAlreadyChangedError(CommitError):

    pass

class NodeDoesNotExistError(CommitError):

    pass

class NodeNotChangedError(CommitError):

    pass

class NodeAlreadyAddedError(CommitError):

    pass

class NodeAlreadyRemovedError(CommitError):

    pass

class ImproperArchiveTypeError(VCSError):

    pass

            self.throw(GeneratorExit)

        except (GeneratorExit, StopIteration):

            pass

    ####################

    # Threaded reader's infrastructure.

    ####################

    @property

    def input(self):

        return self.worker.w

    @property

    def data_added_event(self):

        return self.worker.data_added

    @property

    def data_added(self):

        return self.worker.data_added.is_set()

    @property

    def reading_paused(self):

        return not self.worker.keep_reading.is_set()

    @property

    def done_reading(self):

        """

        Done_reading does not mean that the iterator's buffer is empty.

        Iterator might have done reading from underlying source, but the read

        chunks might still be available for serving through .next() method.

        :returns: An Bool value.

        """

        return self.worker.EOF.is_set()

    @property

    def length(self):

        """

        returns int.

        This is the length of the queue of chunks, not the length of

        the combined contents in those chunks.

        __len__() cannot be meaningfully implemented because this

        reader is just flying through a bottomless pit content and

        can only know the length of what it already saw.

        If __len__() on WSGI server per PEP 3333 returns a value,

        the response's length will be set to that. In order not to

class _Missing(object):

    def __repr__(self):

        return 'no value'

    def __reduce__(self):

        return '_missing'

_missing = _Missing()

class LazyProperty(object):

    """

    Decorator for easier creation of ``property`` from potentially expensive to

    calculate attribute of the class.

    Usage::

      class Foo(object):

          @LazyProperty

          def bar(self):

              print 'Calculating self._bar'

              return 42

    Taken from http://blog.pythonisito.com/2008/08/lazy-descriptors.html and

    used widely.

    """

    def __init__(self, func):

        self._func = func

        self.__module__ = func.__module__

        self.__name__ = func.__name__

        self.__doc__ = func.__doc__

    def __get__(self, obj, klass=None):

        if obj is None:

            return self

        value = obj.__dict__.get(self.__name__, _missing)

        if value is _missing:

            value = self._func(obj)

            obj.__dict__[self.__name__] = value

        return value

import os

abspath = lambda * p: os.path.abspath(os.path.join(*p))

def get_dirs_for_path(*paths):

    """

    Returns list of directories, including intermediate.

    """

    for path in paths:

        head = path

        while head:

            if head:

                yield head

            else:

                # We don't need to yield empty path

                break

def get_dir_size(path):

    root_path = path

    size = 0

    for path, dirs, files in os.walk(root_path):

        for f in files:

            try:

                size += os.path.getsize(os.path.join(path, f))

            except OSError:

                pass

    return size

def get_user_home():

    """

    Returns home path of the user.

    """

    return os.getenv('HOME', os.getenv('USERPROFILE')) or ''

# 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.model.notification

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

Model for notifications

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

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

:created_on: Nov 20, 2011

:author: marcink

:copyright: (c) 2013 RhodeCode GmbH, and others.

:license: GPLv3, see LICENSE.md for more details.

"""

import datetime

import logging

from tg import app_globals

from tg import tmpl_context as c

from tg.i18n import ugettext as _

from kallithea.lib import helpers as h

from kallithea.model.db import User

log = logging.getLogger(__name__)

class NotificationModel(object):

    TYPE_CHANGESET_COMMENT = 'cs_comment'

    TYPE_MESSAGE = 'message'

    TYPE_MENTION = 'mention' # not used

    TYPE_REGISTRATION = 'registration'

    TYPE_PULL_REQUEST = 'pull_request'

    TYPE_PULL_REQUEST_COMMENT = 'pull_request_comment'

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

               type_=TYPE_MESSAGE, with_email=True,

               email_kwargs=None, repo_name=None):

        """

        Creates notification of given type

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

                            .get_email_tmpl(type_, 'html', **html_kwargs)

        # don't send email to person who created this comment

        rec_objs = set(recipients_objs).difference(set([created_by_obj]))

        # send email with notification to all other participants

        for rec in rec_objs:

            tasks.send_email([rec.email], email_subject, email_txt_body,

                     email_html_body, headers, author=created_by_obj)

class EmailNotificationModel(object):

    TYPE_CHANGESET_COMMENT = NotificationModel.TYPE_CHANGESET_COMMENT

    TYPE_MESSAGE = NotificationModel.TYPE_MESSAGE # only used for testing

    # NotificationModel.TYPE_MENTION is not used

    TYPE_PASSWORD_RESET = 'password_link'

    TYPE_REGISTRATION = NotificationModel.TYPE_REGISTRATION

    TYPE_PULL_REQUEST = NotificationModel.TYPE_PULL_REQUEST

    TYPE_PULL_REQUEST_COMMENT = NotificationModel.TYPE_PULL_REQUEST_COMMENT

    TYPE_DEFAULT = 'default'

    def __init__(self):

        super(EmailNotificationModel, self).__init__()

        self._tmpl_lookup = app_globals.mako_lookup

        self.email_types = {

            self.TYPE_CHANGESET_COMMENT: 'changeset_comment',

            self.TYPE_PASSWORD_RESET: 'password_reset',

            self.TYPE_REGISTRATION: 'registration',

            self.TYPE_DEFAULT: 'default',

            self.TYPE_PULL_REQUEST: 'pull_request',

            self.TYPE_PULL_REQUEST_COMMENT: 'pull_request_comment',

        }

        self._subj_map = {

            self.TYPE_CHANGESET_COMMENT: _('[Comment] %(repo_name)s changeset %(short_id)s "%(message_short)s" on %(branch)s'),

            self.TYPE_MESSAGE: 'Test Message',

            # self.TYPE_PASSWORD_RESET

            self.TYPE_REGISTRATION: _('New user %(new_username)s registered'),

            # self.TYPE_DEFAULT

            self.TYPE_PULL_REQUEST: _('[Review] %(repo_name)s PR %(pr_nice_id)s "%(pr_title_short)s" from %(pr_source_branch)s by %(pr_owner_username)s'),

            self.TYPE_PULL_REQUEST_COMMENT: _('[Comment] %(repo_name)s PR %(pr_nice_id)s "%(pr_title_short)s" from %(pr_source_branch)s by %(pr_owner_username)s'),

        }

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