def update_category(public_id: int, data: dict): """ HTTP `PUT`/`PATCH` route for update a single category resource. Args: public_id (int): Public ID of the updatable category data (CategoryModel.SCHEMA): New category data to update Raises: ManagerGetError: When the category with the `public_id` was not found. ManagerUpdateError: When something went wrong during the update. Returns: UpdateSingleResponse: With update result of the new updated category. """ category_manager: CategoryManager = CategoryManager( database_manager=current_app.database_manager) try: category = CategoryModel.from_data(data=data) category_manager.update(public_id=PublicID(public_id), category=CategoryModel.to_json(category)) api_response = UpdateSingleResponse(result=data, url=request.url, model=CategoryModel.MODEL) except ManagerGetError as err: return abort(404, err.message) except ManagerUpdateError as err: return abort(400, err.message) return api_response.make_response()
def update_category(self, category: CategoryModel): """Update a existing category into the database""" try: return self._update(collection=CategoryModel.COLLECTION, public_id=category.get_public_id(), data=CategoryModel.to_json(category)) except Exception as err: raise ObjectManagerUpdateError(err=err)
def delete_category(public_id: int): """ HTTP `DELETE` route for delete a single category resource. Args: public_id (int): Public ID of the deletable category Raises: ManagerGetError: When the category with the `public_id` was not found. ManagerDeleteError: When something went wrong during the deletion. Returns: DeleteSingleResponse: Delete result with the deleted category as data. """ category_manager: CategoryManager = CategoryManager( database_manager=current_app.database_manager) try: deleted_category = category_manager.delete( public_id=PublicID(public_id)) api_response = DeleteSingleResponse( raw=CategoryModel.to_json(deleted_category), model=CategoryModel.MODEL) except ManagerGetError as err: return abort(404, err.message) except ManagerDeleteError as err: return abort(404, err.message) return api_response.make_response()
def insert_category(data: dict): """ HTTP `POST` route for insert a single category resource. Args: data (CategoryModel.SCHEMA): Insert data of a new category. Raises: ManagerGetError: If the inserted resource could not be found after inserting. ManagerInsertError: If something went wrong during insertion. Returns: InsertSingleResponse: Insert response with the new category and its public_id. """ category_manager: CategoryManager = CategoryManager( database_manager=current_app.database_manager) data.setdefault('creation_time', datetime.utcnow()) try: result_id: PublicID = category_manager.insert(data) raw_doc = category_manager.get(public_id=result_id) except ManagerGetError as err: return abort(404, err.message) except ManagerInsertError as err: return abort(400, err.message) api_response = InsertSingleResponse(result_id, raw=CategoryModel.to_json(raw_doc), url=request.url, model=CategoryModel.MODEL) return api_response.make_response(prefix='categories')
def get_category(public_id: int): """ HTTP `GET`/`HEAD` route for a single category resource. Args: public_id (int): Public ID of the category. Raises: ManagerGetError: When the selected category does not exists. Returns: GetSingleResponse: Which includes the json data of a CategoryModel. """ category_manager: CategoryManager = CategoryManager( database_manager=current_app.database_manager) body = True if not request.method != 'HEAD' else False try: category_instance = category_manager.get(public_id) except ManagerGetError as err: return abort(404, err.message) api_response = GetSingleResponse(CategoryModel.to_json(category_instance), url=request.url, model=CategoryModel.MODEL, body=body) return api_response.make_response()
def insert_category(self, category: CategoryModel): """Add a new category into the database or add the children list an existing category""" try: return self._insert(collection=CategoryModel.COLLECTION, data=CategoryModel.to_json(category)) except Exception as err: raise ObjectManagerInsertError(err=err)
def get_category(self, public_id: int) -> CategoryModel: """Get a category from the database""" try: raw_category: dict = self._get(collection=CategoryModel.COLLECTION, public_id=public_id) return CategoryModel.from_data(raw_category) except Exception as err: raise ObjectManagerGetError(err=err)
def get_categories(params: CollectionParameters): """ HTTP `GET`/`HEAD` route for getting a iterable collection of resources. Args: params (CollectionParameters): Passed parameters over the http query string + optional `view` parameter. Returns: GetMultiResponse: Which includes a IterationResult of the CategoryModel. If the view parameter with tree was set the route returns a GetMultiResponse<CategoryTree>. Example: You can pass any parameter based on the CollectionParameters. Optional parameters are passed over the function declaration. The `view` parameter is optional and default `list`, but can be `tree` for the category tree view. Raises: FrameworkIterationError: If the collection could not be iterated. ManagerGetError: If the collection could not be found. """ category_manager: CategoryManager = CategoryManager( database_manager=current_app.database_manager) body = True if not request.method != 'HEAD' else False try: if params.optional['view'] == 'tree': tree: CategoryTree = category_manager.tree api_response = GetMultiResponse(CategoryTree.to_json(tree), total=len(tree), params=params, url=request.url, model=CategoryTree.MODEL, body=body) return api_response.make_response(pagination=False) else: iteration_result: IterationResult[ CategoryModel] = category_manager.iterate(filter=params.filter, limit=params.limit, skip=params.skip, sort=params.sort, order=params.order) category_list = [ CategoryModel.to_json(category) for category in iteration_result.results ] api_response = GetMultiResponse(category_list, total=iteration_result.total, params=params, url=request.url, model=CategoryModel.MODEL, body=body) except FrameworkIterationError as err: return abort(400, err.message) except ManagerGetError as err: return abort(404, err.message) return api_response.make_response()
def get_categories_by(self, sort='public_id', **requirements: dict) -> List[CategoryModel]: """Get a list of categories by special requirements""" try: raw_categories = self._get_many(collection=CategoryModel.COLLECTION, sort=sort, **requirements) except Exception as err: raise ObjectManagerGetError(err) try: return [CategoryModel.from_data(category) for category in raw_categories] except Exception as err: raise ObjectManagerInitError(err)
def get_categories(self) -> List[CategoryModel]: """Get all categories as nested list""" try: raw_categories = self._get_many(collection=CategoryModel.COLLECTION, sort='public_id') except Exception as err: raise ObjectManagerGetError(err) try: return [CategoryModel.from_data(category) for category in raw_categories] except Exception as err: raise ObjectManagerInitError(err)
def get_category_by(self, **requirements) -> CategoryModel: """Get a single category by requirements Notes: Even if multiple categories match the requirements only the first matched will be returned """ try: raw_category = self._get_by(collection=CategoryModel.COLLECTION, **requirements) except Exception as err: raise ObjectManagerGetError(err) try: return CategoryModel.from_data(raw_category) except Exception as err: raise ObjectManagerInitError(err)