示例#1
0
def delete_account(clean_data: dict) -> dict:
    """
    {
        'request URL': '/user/delete-account',
        'methods': 'POST',
        'Query Params': {
            'input': {
                'auth_token': {
                    'nullable': False,
                    'type': 'string'
                },
            },
        },
        'Response': {
            "code": '',
            "information": {
                'output': {}
            }
        },
        "message": "",
        "status": ""
    }
    """
    repo = UserRepository()
    tkns = repo.delete(clean_data)
    for tkn in tkns:
        redis_client.delete(tkn.token)
    ret = dict()
    ret['data'] = dict()
    ret['code'] = DELETE_ACCOUNT_CODE
    ret['message'] = DELETE_ACCOUNT_MESSAGE
    ret['status'] = OK_STATUS
    return ret
示例#2
0
def logout(clean_data: dict) -> dict:
    """
    {
        'request URL': '/logout',
        'methods': 'POST',
        'Query Params': {
            'input': {
                'auth_token': {
                    'nullable': False,
                    'type': 'string'
                },
            },
        },
        'Response': {
            "code": '',
            "information": {
                'output': {}
            }
        },
        "message": "",
        "status": ""
    }
    """
    repo = UserRepository()
    tkn = repo.logout(clean_data)
    redis_client.delete(tkn)
    ret = {
        'data': {},
        'code': LOGOUT_CODE,
        'message': LOGOUT_MESSAGE,
        'status': OK_STATUS
    }
    return ret
示例#3
0
def delete_redis_cache_keys(cache_prefix, category=''):
    if not redis_client:
        return
    key = make_redis_cache_key(cache_prefix, category)
    keys_list = redis_client.keys(key)
    for key in keys_list:
        redis_client.delete(key)
示例#4
0
def delete_redis_cache_keys(cache_prefix, category=''):
    """Delete a specific cache key."""
    if not redis_client:
        return
    key = make_redis_cache_key(cache_prefix, category)
    keys_list = redis_client.keys(key)
    for key in keys_list: redis_client.delete(key)
def delete_contact(id):
    _hashed_id = hash_md5(id)
    if redis_client.get(_hashed_id):
        redis_client.delete(_hashed_id)
    if not mongo.contacts.find_one({'_id': ObjectId(id)}):
        return error_response(f'No Contact with Id: `{id}`!', 400)
    mongo.contacts.delete_one({'_id': ObjectId(id)})
    return success_response('Contact successfully deleted!')
示例#6
0
def delete_redis_cache_post(uuid, user_id=None, all_users=False):
    if all_users:
        cache_key = make_template_fragment_key('post', vary_on=[uuid])
    else:
        if user_id:
            user_id = str(user_id)
        else:
            if current_user.is_authenticated():
                user_id = current_user.string_id
            else:
                user_id = "ANONYMOUS"

        cache_key = make_template_fragment_key('post', vary_on=[uuid, user_id])

    # Add prefix to the cache key
    if not redis_client:
        return
    key = '{0}{1}*'.format(app.config['CACHE_KEY_PREFIX'], cache_key)
    keys_list = redis_client.keys(key)
    for key in keys_list:
        redis_client.delete(key)
示例#7
0
def delete_redis_cache_template(template_item,
                                uuid,
                                user_id=None,
                                all_users=True):
    """Delete a redis cached template fragment. Supports various options for
    filtering the right keys.

    :type template_item: string
    :param template_item: Prefix for the template, e.g. 'node_view'

    :type uuid: string
    :param uuid: The unique identifier for the item displayed in the template.
        Usually the string version of the Node ObjectID.

    :type user_id: string
    :param user_id: User ID cache, use for filtering per-user caches (useful to
        display cached rating pages)
    """
    if all_users:
        cache_key = make_template_fragment_key(template_item, vary_on=[uuid])
    else:
        if user_id:
            user_id = str(user_id)
        else:
            if current_user.is_authenticated():
                user_id = current_user.string_id
            else:
                user_id = "ANONYMOUS"

        cache_key = make_template_fragment_key(template_item,
                                               vary_on=[uuid, user_id])

    # Add prefix to the cache key
    if not redis_client:
        return
    key = '{0}{1}*'.format(app.config['CACHE_KEY_PREFIX'], cache_key)
    keys_list = redis_client.keys(key)
    for key in keys_list:
        redis_client.delete(key)
示例#8
0
文件: __init__.py 项目: Fweeb/dillo
def delete_redis_cache_post(uuid, user_id=None, all_users=False):
    if all_users:
        cache_key = make_template_fragment_key('post',
            vary_on=[uuid])
    else:
        if user_id:
            user_id = str(user_id)
        else:
            if current_user.is_authenticated():
                user_id = current_user.string_id
            else:
                user_id = "ANONYMOUS"

        cache_key = make_template_fragment_key('post',
            vary_on=[uuid, user_id])

    # Add prefix to the cache key
    if not redis_client:
        return
    key = '{0}{1}*'.format(app.config['CACHE_KEY_PREFIX'], cache_key)
    keys_list = redis_client.keys(key)
    for key in keys_list: redis_client.delete(key)
示例#9
0
def delete_session(clean_data: dict) -> dict:
    """
    {
        'request URL': '/user/delete-session',
        'methods': 'POST',
        'Query Params': {
            'input': {
                'auth_token': {
                    'nullable': False,
                    'type': 'string'
                },
                'session': {
                    'nullable': False,
                    'type': 'string'
                }
            },
        },
        'Response': {
            "code": '',
            "information": {
                'output': {}
            }
        },
        "message": "",
        "status": ""
    }
    """
    repo = UserRepository()
    repo.delete_session(clean_data)
    redis_client.delete(clean_data['session'])
    ret = dict()
    ret['data'] = {}
    ret['code'] = DEL_SESSION_CODE
    ret['message'] = DEL_SESSION_MESSAGE
    ret['status'] = OK_STATUS
    return ret
示例#10
0
def delete_redis_cache_template(template_item, uuid, user_id=None, all_users=True):
    """Delete a redis cached template fragment. Supports various options for
    filtering the right keys.

    :type template_item: string
    :param template_item: Prefix for the template, e.g. 'node_view'

    :type uuid: string
    :param uuid: The unique identifier for the item displayed in the template.
        Usually the string version of the Node ObjectID.

    :type user_id: string
    :param user_id: User ID cache, use for filtering per-user caches (useful to
        display cached rating pages)
    """
    if all_users:
        cache_key = make_template_fragment_key(template_item,
            vary_on=[uuid])
    else:
        if user_id:
            user_id = str(user_id)
        else:
            if current_user.is_authenticated():
                user_id = current_user.string_id
            else:
                user_id = "ANONYMOUS"

        cache_key = make_template_fragment_key(template_item,
            vary_on=[uuid, user_id])

    # Add prefix to the cache key
    if not redis_client:
        return
    key = '{0}{1}*'.format(app.config['CACHE_KEY_PREFIX'], cache_key)
    keys_list = redis_client.keys(key)
    for key in keys_list: redis_client.delete(key)
示例#11
0
def update_password(clean_data: dict) -> dict:
    """
    {
        'request URL': '/user/update/password',
        'methods': 'POST',
        'Query Params': {
            'input': {
                'auth_token': {
                    'nullable': False,
                    'type': 'string'
                },
                'password': {
                    'nullable': False,
                    'max_length': 128,
                    'min_length': 8,
                    'type': 'string'
                },
            },
        },
        'Response': {
            "code": '',
            "information": {
                'output': {
                    'auth_token': {
                        'nullable': False,
                        'type': 'string'
                    },
                    'role': {
                        'nullable': False,
                        'type': 'string'
                    },
                    'real_or_legal': {
                        'nullable': False,
                        'type': 'string'
                    },
                    'phone_number': {
                        'nullable': False,
                        'type': 'numerical string'
                    },
                    'email': {
                        'nullable': True,
                        'type': 'email'
                    },
                    'user_information': {
                        'nullable': True,
                        'type': 'json'
                    },
                    'company_information': {
                        'nullable': True,
                        'type': 'string'
                    },
                    'configurations': {
                        'nullable': True,
                        'type': 'json'
                    },
                }
            }
        },
        "message": "",
        "status": ""
    }
    """
    repo = UserRepository()
    tkns, user_name = repo.update(clean_data, 'update_password')
    for tkn in tkns:
        redis_client.delete(tkn.token)
    rkey, rval, ret = repo.login({
        'user_name':
        user_name,
        'password':
        clean_data['password'],
        'device_information':
        clean_data['auth_token_info_extract']['device_information']
    })
    redis_client.set(rkey, rval)
    ret['code'] = UPDATE_PASSWORD_CODE
    ret['message'] = UPDATE_PASSWORD_MESSAGE
    ret['status'] = OK_STATUS
    return ret
示例#12
0
def delete_token(token: bytes):
    logger.info('Delete token: "{}"'.format(token))
    redis_client.delete(token)