'ip_addresses',

     'ldap_dn',

     'email',

     'api_key',

     'last_login',

     'full_name',

     'active',

     'password',

     'emails',

     'inherit_default_permissions'

    """

    from kallithea import EXTENSIONS

    callback = getattr(EXTENSIONS, 'DELETE_USER_HOOK', None)

    if callable(callback):

        return callback(deleted_by=deleted_by, **user_dict)

    return 0

def handle_git_pre_receive(repo_path, revs, env):

    return handle_git_receive(repo_path, revs, env, hook_type='pre')

def handle_git_post_receive(repo_path, revs, env):

    return handle_git_receive(repo_path, revs, env, hook_type='post')

def handle_git_receive(repo_path, revs, env, hook_type):

    """

    A really hacky method that is run by git post-receive hook and logs

    a push action together with pushed revisions. It's executed by subprocess

    thus needs all info to be able to create an on the fly app environment,

    connect to database and run the logging code. Hacky as sh*t but works.

    :param repo_path:

    :param revs:

    :param env:

    """

    from paste.deploy import appconfig

    from sqlalchemy import engine_from_config

    from kallithea.config.environment import load_environment

    from kallithea.model.base import init_model

    from kallithea.model.db import Ui

    from kallithea.lib.utils import make_ui

    extras = _extract_extras(env)

    repo_path = safe_unicode(repo_path)

    path, ini_name = os.path.split(extras['config'])

    conf = appconfig('config:%s' % ini_name, relative_to=path)

                     test_index=False)

    engine = engine_from_config(conf, 'sqlalchemy.')

    init_model(engine)

    baseui = make_ui('db')

    # fix if it's not a bare repo

    if repo_path.endswith(os.sep + '.git'):

        repo_path = repo_path[:-5]

    repo = Repository.get_by_full_path(repo_path)

    if not repo:

        raise OSError('Repository %s not found in database'

                      % (safe_str(repo_path)))

    _hooks = dict(baseui.configitems('hooks')) or {}

    if hook_type == 'pre':

        repo = repo.scm_instance

    else:

        #post push shouldn't use the cached instance never

        repo = repo.scm_instance_no_cache()

    if hook_type == 'pre':

        pre_push(baseui, repo)

    # if push hook is enabled via web interface

    elif hook_type == 'post' and _hooks.get(Ui.HOOK_PUSH):

        rev_data = []

        for l in revs:

            old_rev, new_rev, ref = l.strip().split(' ')

            _ref_data = ref.split('/')

            if _ref_data[1] in ['tags', 'heads']:

                rev_data.append({'old_rev': old_rev,

                                 'new_rev': new_rev,

                                 'ref': ref,

                                 'type': _ref_data[1],

                                 'name': '/'.join(_ref_data[2:])})

        git_revs = []

        for push_ref in rev_data:

            _type = push_ref['type']

            if _type == 'heads':

                if push_ref['old_rev'] == EmptyChangeset().raw_id:

                    # update the symbolic ref if we push new repo

                    if repo.is_empty():

                        repo._repo.refs.set_symbolic_ref('HEAD',