def get(self, root_node_id): args = self.get_parser.parse_args() max_depth = args['max_depth'] specific_resources_filter = jsonify_argument(args['sections_filter']) or {} annotations_filter = jsonify_argument(args['annotations_filter']) or {} root_node_projection = projection_helper.modified_projection( jsonify_argument(args['root_node_projection']), mandatory_attrs=['_id']) _validate_projection(root_node_projection) specific_resources_projection = projection_helper.modified_projection( jsonify_argument(args['sections_projection']), mandatory_attrs=['_id']) _validate_projection(specific_resources_projection) annotations_projection = projection_helper.modified_projection( jsonify_argument(args['annotations_projection']), mandatory_attrs=['_id']) _validate_projection(annotations_projection) try: tree = objstore_helper.read_tree( g.objstore_colln, root_node_id, max_depth, current_token.user_id, current_token.group_ids, specific_resources_filter=specific_resources_filter, annotations_filter=annotations_filter, root_node_projection=root_node_projection, specific_resources_projection=specific_resources_projection, annotations_projection=annotations_projection ) except ObjModelException as e: return error_response(message=e.message, code=e.http_response_code) return tree
def get(self, user_id): args = self.get_parser.parse_args() user_selector_doc = users_helper.get_user_selector_doc(_id=user_id) projection = jsonify_argument(args.get('projection', None), key='projection') check_argument_type(projection, (dict, ), key='projection', allow_none=True) _validate_projection(projection) projection = projection_helper.modified_projection( projection, mandatory_attrs=["_id", "jsonClass"]) user = JsonObject.make_from_dict( g.users_colln.find_one(user_selector_doc, projection=None)) if user is None: return error_response(message='user not found', code=404) if not PermissionResolver.resolve_permission( user, ObjectPermissions.READ, current_token.user_id, current_token.group_ids, g.users_colln): return error_response(message='permission denied', code=403) user_json = user.to_json_map() projected_user_json = users_helper.project_user_json( user_json, projection=projection) return projected_user_json
def post(self): args = self.post_parser.parse_args() if g.current_user_id: return error_response(message='you are already registered', code=403) user_json = jsonify_argument(args['user_json'], key='user_json') # type: dict check_argument_type(user_json, (dict, ), key='user_json') return_projection = jsonify_argument(args.get('return_projection', None), key='return_projection') check_argument_type(return_projection, (dict, ), key='return_projection', allow_none=True) _validate_projection(return_projection) return_projection = projection_helper.modified_projection( return_projection, mandatory_attrs=['_id', 'jsonClass']) try: new_user_id = users_helper.create_new_user( g.users_colln, user_json, initial_agents=g.initial_agents) except ObjModelException as e: return error_response(message=e.message, code=e.http_response_code) except ValidationError as e: return error_response(message='invalid schema for user_json', code=403, details={"error": str(e)}) new_user_json = g.users_colln.get(new_user_id, projection=return_projection) return new_user_json
def get(self): args = self.get_parser.parse_args() projection = jsonify_argument(args.get('projection', None), key='projection') check_argument_type(projection, (dict, ), key='projection', allow_none=True) _validate_projection(projection) projection = projection_helper.modified_projection( projection, mandatory_attrs=["_id", "jsonClass"]) args_copy = args.copy() args_copy.pop('projection', None) user_jsons = get_requested_agents(args_copy, g.users_colln, current_token.user_id, current_token.group_ids, filter_doc={"jsonClass": "User"}) projected_user_jsons = [ users_helper.project_user_json(uj, projection=projection) for uj in user_jsons ] return projected_user_jsons
def post(self): args = self.post_parser.parse_args() args = parse_json_args(args, self.post_json_parse_directives) resource_jsons = args['resource_jsons'] return_projection = args['return_projection'] created_resource_jsons = [] for n, rj in enumerate(resource_jsons): try: if 'jsonClass' not in rj: raise ObjModelException('jsonClass attribute should exist for update/creation', 403) created_resource_id = objstore_helper.create_or_update( g.objstore_colln, rj, current_token.user_id, current_token.group_ids, initial_agents=g.initial_agents) if created_resource_id is None: created_resource_jsons.append(None) continue created_resource_json = g.objstore_colln.get( created_resource_id, projection=projection_helper.modified_projection(return_projection, ["_id", "jsonClass"])) created_resource_jsons.append(created_resource_json) except ObjModelException as e: return error_response( message='action not allowed at resource {}'.format(n), code=e.http_response_code, details={"error": e.message}) except (ValidationError, TypeError) as e: return error_response( message='schema validation error at resource {}'.format(n), code=400, details={"error": str(e)}) return created_resource_jsons
def get(self, group_identifier): args = self.get_parser.parse_args() identifier_type = args.get('identifier_type', '_id') group_selector_doc = self._group_selector_doc(group_identifier, identifier_type) projection = jsonify_argument(args.get('projection', None), key='projection') check_argument_type(projection, (dict, ), key='projection', allow_none=True) _validate_projection(projection) projection = projection_helper.modified_projection( projection, mandatory_attrs=["_id", "jsonClass"]) group = JsonObject.make_from_dict( g.users_colln.find_one(group_selector_doc, projection=None)) if group is None: return error_response(message='group not found', code=404) if not PermissionResolver.resolve_permission( group, ObjectPermissions.READ, current_token.user_id, current_token.group_ids, g.users_colln): return error_response(message='permission denied', code=403) group_json = group.to_json_map() projected_group_json = projection_helper.project_doc( group_json, projection) return projected_group_json
def post(self, group_identifier): args = self.get_parser.parse_args() identifier_type = args.get('identifier_type', '_id') group_selector_doc = self._group_selector_doc(group_identifier, identifier_type) update_doc = jsonify_argument(args['update_doc'], key='update_doc') check_argument_type(update_doc, (dict, ), key='update_doc') if 'jsonClass' not in update_doc: update_doc['jsonClass'] = 'UsersGroup' if update_doc['jsonClass'] != 'UsersGroup': return error_response(message='invalid jsonClass', code=403) if identifier_type == '_id': update_doc.pop('groupName', None) if update_doc['_id'] != group_identifier: return error_response(message='invalid user_id', code=403) else: group_id = groups_helper.get_group_id(g.users_colln, group_identifier) if not group_id: return error_response(message='no group with group_name {}'. format(group_identifier)) update_doc['_id'] = group_id return_projection = jsonify_argument(args.get('return_projection', None), key='return_projection') check_argument_type(return_projection, (dict, ), key='return_projection', allow_none=True) _validate_projection(return_projection) return_projection = projection_helper.modified_projection( return_projection, mandatory_attrs=['_id', 'jsonClass']) try: group_update = JsonObject.make_from_dict(update_doc) updated_group_id = objstore_helper.update_resource( g.users_colln, group_update.to_json_map(), current_token.user_id, current_token.group_ids, not_allowed_attributes=['members', 'groupName']) if updated_group_id is None: raise ObjModelException('group not exist', 404) except ObjModelException as e: return error_response(message=e.message, code=e.http_response_code) except ValueError as e: return error_response(message='schema validation error', code=403, details={"error": str(e)}) group_json = g.users_colln.find_one(group_selector_doc, projection=return_projection) return group_json
def project_user_json(user_json, projection=None): user_exposed_projection = projection_helper.modified_projection( user_json.get('exposed_projection', None), mandatory_attrs=['_id', 'jsonClass']) or {} user_exposed_projection = projection_helper.get_restricted_projection( user_exposed_projection, {"hashedPassword": 0} ) projected_user_json = projection_helper.project_doc( user_json, projection_helper.get_restricted_projection(projection, user_exposed_projection)) return projected_user_json
def get_requested_agents(args, colln, user_id, group_ids, filter_doc=None): selector_doc = jsonify_argument(args.get('selector_doc', None), key='selector_doc') or {} check_argument_type(selector_doc, (dict, ), key='selector_doc') if filter_doc is not None: selector_doc.update(filter_doc) projection = jsonify_argument(args.get('projection', None), key='projection') check_argument_type(projection, (dict, ), key='projection', allow_none=True) _validate_projection(projection) projection = projection_helper.modified_projection( projection, mandatory_attrs=["_id", "jsonClass"]) lrs_request_doc = jsonify_argument(args.get('linked_resources', None), 'linked_resources') check_argument_type(lrs_request_doc, (dict, ), key='linked_resources', allow_none=True) sort_doc = jsonify_argument(args.get('sort_doc', None), key='sort_doc') check_argument_type(sort_doc, (dict, list), key='sort_doc', allow_none=True) ops = OrderedDict() if sort_doc is not None: ops['sort'] = [sort_doc] if args.get('start', None) is not None and args.get('count', None) is not None: ops['skip'] = [args['start']] ops['limit'] = [args['count']] try: resource_repr_jsons = objstore_helper.get_read_permitted_resource_jsons( colln, user_id, group_ids, selector_doc, projection=projection, ops=ops) except (TypeError, ValueError): error = error_response(message='arguments to operations seems invalid', code=400) abort_with_error_response(error) if lrs_request_doc is not None: # noinspection PyUnboundLocalVariable for rj in resource_repr_jsons: linked_resources = objstore_helper.get_linked_resource_ids( colln, rj['_id'], lrs_request_doc) rj['linked_resources'] = linked_resources return resource_repr_jsons
def post(self, user_id): ''' if not current_token.user_id: return error_response(message='not authorized', code=401) ''' args = self.post_parser.parse_args() user_selector_doc = users_helper.get_user_selector_doc(_id=user_id) update_doc = jsonify_argument(args['update_doc'], key='update_doc') check_argument_type(update_doc, (dict, ), key='update_doc') if '_id' not in update_doc: update_doc['_id'] = user_id if 'jsonClass' not in update_doc: update_doc['jsonClass'] = 'User' if update_doc['_id'] != user_id: return error_response(message='invalid user_id', code=403) if update_doc['jsonClass'] != 'User': return error_response(message='invalid jsonClass', code=403) return_projection = jsonify_argument(args.get('return_projection', None), key='return_projection') check_argument_type(return_projection, (dict, ), key='return_projection', allow_none=True) _validate_projection(return_projection) return_projection = projection_helper.modified_projection( return_projection, mandatory_attrs=['_id', 'jsonClass']) try: user_update = JsonObject.make_from_dict(update_doc) updated_user_id = objstore_helper.update_resource( g.users_colln, user_update.to_json_map(), current_token.user_id, current_token.group_ids, not_allowed_attributes=[ 'hashedPassword', 'externalAuthentications', 'password' ]) if updated_user_id is None: raise ObjModelException('user not exist', 404) except ObjModelException as e: return error_response(message=e.message, code=e.http_response_code) except (ValueError, ValidationError, TypeError) as e: return error_response(message='schema validation error', code=403, details={"error": str(e)}) user_json = g.users_colln.find_one(user_selector_doc, projection=return_projection) return user_json
def post(self): args = self.post_parser.parse_args() root_node_return_projection = projection_helper.modified_projection( jsonify_argument(args['root_node_return_projection']), mandatory_attrs=['_id']) _validate_projection(root_node_return_projection) specific_resources_return_projection = projection_helper.modified_projection( jsonify_argument(args['sections_return_projection']), mandatory_attrs=['_id']) _validate_projection(specific_resources_return_projection) annotations_return_projection = projection_helper.modified_projection( jsonify_argument(args['annotations_return_projection']), mandatory_attrs=['_id']) _validate_projection(annotations_return_projection) trees = jsonify_argument(args['trees'], key='trees') check_argument_type(trees, (list,), key='trees') result_trees = [] try: for i, tree in enumerate(trees): result_tree = objstore_helper.update_tree( g.objstore_colln, current_token.user_id, current_token.group_ids, tree, 'tree{}'.format(i), None, root_node_return_projection=root_node_return_projection, specific_resources_return_projection=specific_resources_return_projection, annotations_return_projection=annotations_return_projection, initial_agents=g.initial_agents) result_trees.append(result_tree) except objstore_helper.TreeValidationError as e: return error_response( message="error in posting tree", code=e.http_status_code, invalid_node_path=e.invalid_node_path, invalid_node_json=e.invalid_node_json, error=str(e.error), succeded_trees=result_trees ) except (ValidationError, TypeError) as e: return error_response(message='schema validation error', error=str(e), code=400) return result_trees
def get(self): user_id = resolve_user_id() args = self.get_parser.parse_args() projection = jsonify_argument(args.get('projection', None), key='projection') check_argument_type(projection, (dict,), key='projection', allow_none=True) _validate_projection(projection) projection = projection_helper.modified_projection(projection, mandatory_attrs=["_id", "jsonClass"]) current_user_json = g.users_colln.find_one( users_helper.get_user_selector_doc(_id=user_id), projection=projection) if current_user_json is None: sign_out_user(g.current_org_name) return error_response(message='not authorized', code=401) return current_user_json, 200
def get_user_groups(groups_colln, user_id, groups_projection=None): groups_projection = projection_helper.modified_projection( groups_projection, mandatory_attrs=["_id", "source"] ) group_id_jsons_map = {} explicit_group_jsons = groups_colln.find( {"jsonClass": UsersGroup.json_class, "members": user_id}, projection=groups_projection ) group_id_jsons_map.update(dict((group_json['_id'], group_json) for group_json in explicit_group_jsons)) for group_json in explicit_group_jsons: group_hierarchy = get_group_hierarchy(groups_colln, group_json, groups_projection=groups_projection) group_id_jsons_map.update(dict((group_json['_id'], group_json) for group_json in group_hierarchy)) return list(group_id_jsons_map.values())
def post(self): user_id = resolve_user_id() group_ids = [ group['_id'] for group in groups_helper.get_user_groups( g.users_colln, user_id, groups_projection={"_id": 1}) ] args = self.post_parser.parse_args() update_doc = jsonify_argument(args['update_doc'], key='update_doc') check_argument_type(update_doc, (dict,), key='update_doc') if '_id' not in update_doc: update_doc['_id'] = user_id if 'jsonClass' not in update_doc: update_doc['jsonClass'] = 'User' if update_doc['_id'] != user_id: return error_response(message='invalid _id', code=403) if update_doc['jsonClass'] != 'User': return error_response(message='invalid jsonClass', code=403) if 'password' in update_doc: update_doc['hashedPassword'] = bcrypt.hashpw( update_doc['password'].encode('utf-8'), bcrypt.gensalt()).decode('utf-8') update_doc.pop('password') return_projection = jsonify_argument(args.get('return_projection', None), key='return_projection') check_argument_type(return_projection, (dict,), key='return_projection', allow_none=True) _validate_projection(return_projection) return_projection = projection_helper.modified_projection( return_projection, mandatory_attrs=['_id', 'jsonClass']) try: user_update = JsonObject.make_from_dict(update_doc) updated_user_id = objstore_helper.update_resource( g.users_colln, user_update.to_json_map(), user_id, group_ids, not_allowed_attributes=('externalAuthentications', 'password')) if updated_user_id is None: raise ObjModelException('user not exist', 404) except ObjModelException as e: return error_response(message=e.message, code=e.http_response_code) except ValueError as e: return error_response(message='schema validation error', code=403, details={"error": str(e)}) user_json = g.users_colln.get(user_id, projection=return_projection) return user_json
def get_group_hierarchy(groups_colln, group_json, groups_projection=None): groups_projection = projection_helper.modified_projection( groups_projection, mandatory_attrs=["_id", "source"] ) group_hierarchy = [] parent_group_id = group_json.get('source', None) if not parent_group_id: return group_hierarchy parent_group_json = groups_colln.find_one( get_group_selector_doc(_id=parent_group_id), projection=groups_projection) if parent_group_json is None: return group_hierarchy group_hierarchy.append(parent_group_json) parent_group_hierarchy = get_group_hierarchy( groups_colln, parent_group_json, groups_projection=groups_projection) group_hierarchy.extend(parent_group_hierarchy) return group_hierarchy
def get_group(groups_colln, group_selector_doc, projection=None): projection = projection_helper.modified_projection(projection, mandatory_attrs=['jsonClass']) group_json = groups_colln.find_one(group_selector_doc, projection=projection) return JsonObject.make_from_dict(group_json)
def get_client(oauth_colln, client_selector_doc, projection=None): projection = projection_helper.modified_projection( projection, mandatory_attrs=["jsonClass"]) user_json = oauth_colln.find_one(client_selector_doc, projection=projection) return JsonObject.make_from_dict(user_json)