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

"""

kallithea.model.changeset_status

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

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: Apr 30, 2012

:author: marcink

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

_hash_key = lambda k: hashlib.md5(safe_str(k)).hexdigest()

class BaseModel(object):

    """

    """

    @classmethod

    def _get_keys(cls):

        """return column names for this model """

        return class_mapper(cls).c.keys()

                _json_attr = _json_attr()

            for k, val in _json_attr.iteritems():

                d[k] = val

        return d

    def get_appstruct(self):

        to this model data """

        l = []

        for k in self._get_keys():

            l.append((k, getattr(self, k),))

        return l

        return URL_SEP

    @classmethod

    def normalize_repo_name(cls, repo_name):

        """

        Normalizes os specific repo_name to the format internally stored inside

        :param cls:

        :param repo_name:

        """

        return cls.url_sep().join(repo_name.split(os.sep))

            cnt += 1

            gr = getattr(cur_gr, 'parent_group', None)

            cur_gr = cur_gr.parent_group

            if gr is None:

                break

            if cnt == parents_recursion_limit:

                log.error(('more than %s parents found for group %s, stopping '

                           'recursive parent fetching' % (parents_recursion_limit, self)))

                break

            groups.insert(0, gr)

        return groups

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

"""

http://formencode.org/module-formencode.validators.html

we can create our own validators

The table below outlines the options which can be used in a schema in addition to the validators themselves

pre_validators          []     These validators will be applied before the schema

chained_validators      []     These validators will be applied after the schema

    def _handle_push(self, repo, username, action, repo_name, revisions):

        """

        Triggers push action hooks

        :param repo: SCM repo

        :param username: username who pushes

        :param repo_name: name of repo

        :param revisions: list of revisions that we pushed

        """

        self._handle_rc_scm_extras(username, repo_name, repo_alias=repo.alias)

        _scm_repo = repo._repo

        # trigger push hook

    def create_nodes(self, user, repo, message, nodes, parent_cs=None,

                     author=None, trigger_push_hook=True):

        """

        Commits specified nodes to repo.

        :param repo: Kallithea Repository object

        :param message: commit message

        :param nodes: mapping {filename:{'content':content},...}

        :param parent_cs: parent changeset, can be empty than it's initial commit

        :param trigger_push_hook: trigger push hooks

        """

        user = self._get_user(user)

        scm_instance = repo.scm_instance_no_cache()

        processed_nodes = []

                raise Exception('Content is of unrecognized type %s' % (

                    type(content)

                ))

            processed_nodes.append((f_path, content))

        message = safe_unicode(message)

        IMC = self._get_IMC_module(scm_instance.alias)

        imc = IMC(scm_instance)

        if not parent_cs:

            parent_cs = EmptyChangeset(alias=scm_instance.alias)

    def update_nodes(self, user, repo, message, nodes, parent_cs=None,

                     author=None, trigger_push_hook=True):

        user = self._get_user(user)

        scm_instance = repo.scm_instance_no_cache()

        message = safe_unicode(message)

        imc_class = self._get_IMC_module(scm_instance.alias)

        imc = imc_class(scm_instance)

        if not parent_cs:

            parent_cs = EmptyChangeset(alias=scm_instance.alias)

    def delete_nodes(self, user, repo, message, nodes, parent_cs=None,

                     author=None, trigger_push_hook=True):

        """

        Deletes specified nodes from repo.

        :param repo: Kallithea Repository object

        :param message: commit message

        :param nodes: mapping {filename:{'content':content},...}

        :param parent_cs: parent changeset, can be empty than it's initial commit

        :param trigger_push_hook: trigger push hooks

        """

        user = self._get_user(user)

        scm_instance = repo.scm_instance_no_cache()

        processed_nodes = []

            # content can be empty but for compatibility it allows same dicts

            # structure as add_nodes

            content = nodes[f_path].get('content')

            processed_nodes.append((f_path, content))

        message = safe_unicode(message)

        IMC = self._get_IMC_module(scm_instance.alias)

        imc = IMC(scm_instance)

        if not parent_cs:

            parent_cs = EmptyChangeset(alias=scm_instance.alias)

        return True

    def fill_data(self, auth_user, user_id=None, api_key=None, username=None):

        """

        Fetches auth_user by user_id,or api_key if present.

        Fills auth_user attributes with those taken from database.

        present in database

        :param auth_user: instance of user to set attributes

        :param user_id: user id to fetch by

        :param api_key: api key to fetch by

        :param username: username to fetch by

                    t = {'u': 'user',

                         'g': 'users_group'

                    }[k[0]]

                    if member == User.DEFAULT_USER:

                        if str2bool(value.get('repo_private')):

                            # set none for default when updating to

                            v = EMPTY_PERM

                    perms_update.add((member, v, t))

            value['perms_updates'] = list(perms_update)

            value['perms_new'] = list(perms_new)