How to use the eve.methods.post.post_internal function in Eve

@manager.command
def setup_db(admin_email):
    """Setup the database
    - Create admin, subscriber and demo Group collection
    - Create admin user (must use valid blender-id credentials)
    - Create one project
    """

    # Create default groups
    groups_list = []
    for group in ['admin', 'subscriber', 'demo']:
        g = {'name': group}
        g = post_internal('groups', g)
        groups_list.append(g[0]['_id'])
        print("Creating group {0}".format(group))

    # Create admin user
    user = {'username': admin_email,
            'groups': groups_list,
            'roles': ['admin', 'subscriber', 'demo'],
            'settings': {'email_communications': 1},
            'auth': [],
            'full_name': admin_email,
            'email': admin_email}
    result, _, _, status = post_internal('users', user)
    if status != 201:
        raise SystemExit('Error creating user {}: {}'.format(admin_email, result))
    user.update(result)
    print("Created user {0}".format(user['_id']))

# code, oui = _sendGetRequest(OUI_URL, {}, {})
    # print "IEEE Response Code was a " + str(code)
    count = 1
    for totalcount, line in enumerate(oui, start=1):
        macHexVendor = re.match("^.*(" + OUI_HEX_REGEX + ").*"
                                + "hex" + ".*?([A-Z].*)$", line)
        if macHexVendor:
            count += 1
            macEntry = {
                "base16": macHexVendor.group(1).replace(OUI_MATCH,
                                                        ""),
                "hex": macHexVendor.group(1).replace(OUI_MATCH,
                                                     OUI_REPLACE),
                "organization": macHexVendor.group(2)
            }
            post_internal("mac", macEntry)
            if not VCAP_CONFIG:
                print(macHexVendor.group(1).replace(OUI_MATCH,
                                                    OUI_REPLACE) + ", " +
                      macHexVendor.group(2))
    print("Number of MAC Entries matched: " + str(count))
    return ""

# files = current_app.data.driver.db['files']
    # file_doc = files.find_one({'project': project_id,
    #                            'name': internal_filename})
    file_doc = None

    # TODO: at some point do name-based and content-based content-type sniffing.
    new_props = {'filename': uploaded_file.filename,
                 'content_type': uploaded_file.mimetype,
                 'length': uploaded_file.content_length,
                 'project': project_id,
                 'status': 'uploading'}

    if file_doc is None:
        # Create a file document on MongoDB for this file.
        file_doc = create_file_doc(name=internal_filename, **new_props)
        file_fields, _, _, status = post_internal('files', file_doc)
    else:
        file_doc.update(new_props)
        file_fields, _, _, status = put_internal('files', remove_private_keys(file_doc))

    if status not in (200, 201):
        log.error('Unable to create new file document in MongoDB, status=%i: %s',
                  status, file_fields)
        raise InternalServerError()

    return file_fields['_id'], internal_filename, status

def create_local_user(email, password):
    """For internal user only. Given username and password, create a user."""
    # Hash the password
    hashed_password = hash_password(password, bcrypt.gensalt())
    db_user = create_new_user_document(email, '', email, provider='local',
                                       token=hashed_password)
    # Make username unique
    db_user['username'] = make_unique_username(email)
    # Create the user
    r, _, _, status = post_internal('users', db_user)
    if status != 201:
        log.error('internal response: %r %r', status, r)
        return abort(500)
    # Return user ID
    return r['_id']

def post_internal(self, resource: str, payl=None, skip_validation=False):
        """Workaround for Eve issue https://github.com/pyeve/eve/issues/810"""
        from eve.methods.post import post_internal

        url = self.config['URLS'][resource]
        path = '%s/%s' % (self.api_prefix, url)

        with self.__fake_request_url_rule('POST', path):
            return post_internal(resource, payl=payl, skip_validation=skip_validation)[:4]

verb=verb,
            object_type=object_type,
            object=object_id,
            context_object_type=context_object_type,
            context_object=context_object_id
        )

        activity = post_internal('activities', activity)
        if activity[3] != 201:
            # If creation failed for any reason, do not create a any notifcation
            return
        for subscription in subscriptions:
            notification = dict(
                user=subscription['user'],
                activity=activity[0]['_id'])
            post_internal('notifications', notification)

r = {}
    for retry in range(5):
        if '_id' in db_user:
            # Update the existing user
            attempted_eve_method = 'PUT'
            db_id = db_user['_id']
            r, _, _, status = put_internal('users', remove_private_keys(db_user),
                                           _id=db_id)
            if status == 422:
                log.error('Status %i trying to PUT user %s with values %s, should not happen! %s',
                          status, db_id, remove_private_keys(db_user), r)
        else:
            # Create a new user, retry for non-unique usernames.
            attempted_eve_method = 'POST'
            r, _, _, status = post_internal('users', db_user)

            if status not in {200, 201}:
                log.error('Status %i trying to create user for BlenderID %s with values %s: %s',
                          status, blender_id_user_id, db_user, r)
                raise wz_exceptions.InternalServerError()

            db_id = r['_id']
            db_user.update(r)  # update with database/eve-generated fields.

        if status == 422:
            # Probably non-unique username, so retry a few times with different usernames.
            log.info('Error creating new user: %s', r)
            username_issue = r.get('_issues', {}).get(u'username', '')
            if u'not unique' in username_issue:
                # Retry
                db_user['username'] = authentication.make_unique_username(db_user['email'])

original = get_document(
        resource,
        concurrency_check,
        check_auth_value=False,
        force_auth_field_projection=True,
        **lookup
    )
    if not original:
        if config.UPSERT_ON_PUT:
            id = lookup[resource_def["id_field"]]
            # this guard avoids a bson dependency, which would be needed if we
            # wanted to use 'isinstance'. Should also be slightly faster.
            if schema[resource_def["id_field"]].get("type", "") == "objectid":
                id = str(id)
            payload[resource_def["id_field"]] = id
            return post_internal(resource, payl=payload)
        else:
            abort(404)

    # If the document exists, but is owned by someone else, return
    # 403 Forbidden
    auth_field, request_auth_value = auth_field_and_value(resource)
    if auth_field and original.get(auth_field) != request_auth_value:
        abort(403)

    last_modified = None
    etag = None
    issues = {}
    object_id = original[resource_def["id_field"]]

    response = {}

def after_inserting_project(project, db_user):
    project_id = project['_id']
    user_id = db_user['_id']

    # Create a project-specific admin group (with name matching the project id)
    result, _, _, status = post_internal('groups', {'name': str(project_id)})
    if status != 201:
        log.error('Unable to create admin group for new project %s: %s',
                  project_id, result)
        return abort_with_error(status)

    admin_group_id = result['_id']
    log.debug('Created admin group %s for project %s', admin_group_id, project_id)

    # Assign the current user to the group
    db_user.setdefault('groups', []).append(admin_group_id)

    result, _, _, status = patch_internal('users', {'groups': db_user['groups']}, _id=user_id)
    if status != 200:
        log.error('Unable to add user %s as member of admin group %s for new project %s: %s',
                  user_id, admin_group_id, project_id, result)
        return abort_with_error(status)

def store_token(user_id, token, token_expiry, oauth_subclient_id=False):
    """Stores an authentication token.

    :returns: the token document from MongoDB
    """

    token_data = {
        'user': user_id,
        'token': token,
        'expire_time': token_expiry,
    }
    if oauth_subclient_id:
        token_data['is_subclient_token'] = True

    r, _, _, status = post_internal('tokens', token_data)

    if status not in {200, 201}:
        log.error('Unable to store authentication token: %s', r)
        raise RuntimeError('Unable to store authentication token.')

    token_data.update(r)
    return token_data