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

"""

    rhodecode.model.__init__

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

    The application's model objects

    :created_on: Nov 25, 2010

    :author: marcink

    :copyright: (C) 2009-2011 Marcin Kuzminski <marcin@python-works.com>

    :license: GPLv3, see COPYING for more details.

    :example:

        .. code-block:: python

           from paste.deploy import appconfig

           from pylons import config

           from sqlalchemy import engine_from_config

           from rhodecode.config.environment import load_environment

           conf = appconfig('config:development.ini', relative_to = './../../')

           load_environment(conf.global_conf, conf.local_conf)

           engine = engine_from_config(config, 'sqlalchemy.')

           init_model(engine)

           # RUN YOUR CODE HERE

"""

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

from rhodecode.model import meta

log = logging.getLogger(__name__)

def init_model(engine):

    """

    Initializes db session, bind the engine with the metadata,

    Call this before using any of the tables or classes in the model,

    preferably once in application start

    :param engine: engine to bind to

    """

    log.info("initializing db for %s", engine)

    meta.Base.metadata.bind = engine

class BaseModel(object):

    """Base Model for all RhodeCode models, it adds sql alchemy session

    into instance of model

    :param sa: If passed it reuses this session instead of creating a new one

    """

    def __init__(self, sa=None):

        if sa is not None:

            self.sa = sa

        else:

"""

    rhodecode.model.repo

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

    Repository model for rhodecode

    :created_on: Jun 5, 2010

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

import logging

import traceback

from datetime import datetime

from sqlalchemy.orm import joinedload, make_transient

from vcs.utils.lazy import LazyProperty

from vcs.backends import get_backend

from rhodecode.model import BaseModel

from rhodecode.model.caching_query import FromCache

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

    Statistics, UsersGroup, UsersGroupRepoToPerm, RhodeCodeUi, Group

from rhodecode.model.user import UserModel

log = logging.getLogger(__name__)

class RepoModel(BaseModel):

    @LazyProperty

    def repos_path(self):

        """Get's the repositories root path from database

        """

        q = self.sa.query(RhodeCodeUi).filter(RhodeCodeUi.ui_key == '/').one()

        return q.ui_value

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

        repo = self.sa.query(Repository)\

            .filter(Repository.repo_id == repo_id)

        if cache:

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

                                          "get_repo_%s" % repo_id))

        return repo.scalar()

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

        repo = self.sa.query(Repository)\

            .filter(Repository.repo_name == repo_name)

        if cache:

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

                                          "get_repo_%s" % repo_name))

        return repo.scalar()

    def get_users_js(self):

        users = self.sa.query(User).filter(User.active == True).all()

        u_tmpl = '''{id:%s, fname:"%s", lname:"%s", nname:"%s"},'''

        users_array = '[%s]' % '\n'.join([u_tmpl % (u.user_id, u.name,

                                                    u.lastname, u.username)

                                        for u in users])

        return users_array

    def get_users_groups_js(self):

        users_groups = self.sa.query(UsersGroup)\

            .filter(UsersGroup.users_group_active == True).all()

        g_tmpl = '''{id:%s, grname:"%s",grmembers:"%s"},'''

        users_groups_array = '[%s]' % '\n'.join([g_tmpl % \

                                    (gr.users_group_id, gr.users_group_name,

                                     len(gr.members))

                                        for gr in users_groups])

        return users_groups_array

    def update(self, repo_name, form_data):

        try:

            cur_repo = self.get_by_repo_name(repo_name, cache=False)

            #update permissions

            for member, perm, member_type in form_data['perms_updates']:

                if member_type == 'user':

                    r2p = self.sa.query(RepoToPerm)\

                            .filter(RepoToPerm.repository == cur_repo)\

                            .one()

                    r2p.permission = self.sa.query(Permission)\

                                        .filter(Permission.permission_name ==

                                                perm).scalar()

                    self.sa.add(r2p)

                else:

                    g2p = self.sa.query(UsersGroupRepoToPerm)\

                            .filter(UsersGroupRepoToPerm.users_group ==

                                    UsersGroup.get_by_group_name(member))\

                            .filter(UsersGroupRepoToPerm.repository ==

                                    cur_repo).one()

                    g2p.permission = self.sa.query(Permission)\

                                        .filter(Permission.permission_name ==

                                                perm).scalar()

                    self.sa.add(g2p)

            #set new permissions

            for member, perm, member_type in form_data['perms_new']:

                if member_type == 'user':

                    r2p = RepoToPerm()

                    r2p.repository = cur_repo

                    r2p.permission = self.sa.query(Permission)\

                                        .filter(Permission.

                                                permission_name == perm)\

                                                .scalar()

                    self.sa.add(r2p)

                else:

                    g2p = UsersGroupRepoToPerm()

                    g2p.repository = cur_repo

                    g2p.users_group = UsersGroup.get_by_group_name(member)

                    g2p.permission = self.sa.query(Permission)\

                                        .filter(Permission.

                                                permission_name == perm)\

                                                .scalar()

                    self.sa.add(g2p)

            #update current repo

            for k, v in form_data.items():

                if k == 'user':

                elif k == 'repo_name':

                    cur_repo.repo_name = form_data['repo_name_full']

                elif k == 'repo_group':

                    cur_repo.group_id = v

                else:

                    setattr(cur_repo, k, v)

            self.sa.add(cur_repo)

            if repo_name != form_data['repo_name_full']:

                # rename repository

                self.__rename_repo(old=repo_name,

                                   new=form_data['repo_name_full'])

            self.sa.commit()

        except:

            log.error(traceback.format_exc())

            self.sa.rollback()

            raise

    def create(self, form_data, cur_user, just_db=False, fork=False):

        try:

            if fork:

                #force str since hg doesn't go with unicode

                repo_name = str(form_data['fork_name'])

                org_name = str(form_data['repo_name'])

                org_full_name = org_name#str(form_data['fork_name_full'])

            else:

                org_name = repo_name = str(form_data['repo_name'])

                repo_name_full = form_data['repo_name_full']

            new_repo = Repository()

            new_repo.enable_statistics = False

            for k, v in form_data.items():

                if k == 'repo_name':

                    if fork:

                        v = repo_name

                    else:

                        v = repo_name_full

                if k == 'repo_group':

                    k = 'group_id'

                setattr(new_repo, k, v)

            if fork:

                parent_repo = self.sa.query(Repository)\

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

                new_repo.fork = parent_repo

            new_repo.user_id = cur_user.user_id

            self.sa.add(new_repo)

            #create default permission

            repo_to_perm = RepoToPerm()

            default = 'repository.read'

            for p in UserModel(self.sa).get_by_username('default',

                                                    cache=False).user_perms:

                if p.permission.permission_name.startswith('repository.'):

                    default = p.permission.permission_name

                    break

            default_perm = 'repository.none' if form_data['private'] else default

            repo_to_perm.permission_id = self.sa.query(Permission)\

                    .filter(Permission.permission_name == default_perm)\

                    .one().permission_id

            repo_to_perm.repository = new_repo

            repo_to_perm.user_id = UserModel(self.sa)\

                .get_by_username('default', cache=False).user_id

            self.sa.add(repo_to_perm)

            if not just_db:

                self.__create_repo(repo_name, form_data['repo_type'],

                                   form_data['repo_group'],

                                   form_data['clone_uri'])

            self.sa.commit()

            #now automatically start following this repository as owner

            from rhodecode.model.scm import ScmModel

            ScmModel(self.sa).toggle_following_repo(new_repo.repo_id,

                                             cur_user.user_id)

        except:

            log.error(traceback.format_exc())

            self.sa.rollback()

            raise

    def create_fork(self, form_data, cur_user):

        from rhodecode.lib.celerylib import tasks, run_task

        run_task(tasks.create_repo_fork, form_data, cur_user)