async def user_role_update(role_update: api.RoleUpdateIn,
role: schemas.Role = Depends(deps.get_user_role)):
"""Update user's role.
Required permissions:
- `users.write`
- `roles.write`
"""
if not role.users.write or not role.roles.write:
raise exceptions.InsufficientPermissions("users.write, roles.write")
if not await models.Role.get(id=role_update.role_id):
raise exceptions.ResourceNotFound("role", role_update.role_id)
if not (user_db := await models.User.get(id=role_update.user_id)):
raise exceptions.ResourceNotFound("user", role_update.user_id)
async def delete(self,
resource_id: int,
role: Optional[schemas.Role] = None):
"""Delete resource with id `resource_id` from the db."""
self.check_roles(role, "delete")
try:
resource_db = await self.model.get(id=resource_id)
await resource_db.delete()
except DoesNotExist:
raise exceptions.ResourceNotFound(self.resource, resource_id)
async def mget(self,
resource_id: int,
role: Optional[schemas.Role] = None) -> BaseModelTortoise:
"""Get single resource from database and do not convert it to pydantic schema"""
self.check_roles(role, "get")
try:
resource_db = await self.model.get(id=resource_id)
await resource_db.fetch_related(*self.related_fields)
return resource_db
except DoesNotExist:
raise exceptions.ResourceNotFound(self.resource, resource_id)
async def update(self,
resource_id: int,
resource: schemas.BaseModel,
role: Optional[schemas.Role] = None) -> ORMBase:
"""Update resource defined by `resource_id` and schema `resource` in the db and return it"""
self.check_roles(role, "update")
try:
resource_db = await self.model.get(id=resource_id)
await resource_db.fetch_related(*self.related_fields)
except DoesNotExist:
raise exceptions.ResourceNotFound(self.resource, resource_id)
try:
await resource_db.update_from_dict(resource.dict(exclude_none=True)
)
await resource_db.save()
await resource_db.fetch_related(*self.related_fields)
return self.schema.from_orm(resource_db)
except IntegrityError:
raise exceptions.ResourceExistsException(
detail=f"{self.resource} already exists in the database")
async def remove_related(
self,
resource_id: int,
related_id: int,
related_resource: str,
role: Optional[schemas.Role] = None) -> List[ORMBase]:
"""Remove {related_id} from attribute {related_resource} of {resource_id}"""
self.check_roles(role, "update")
related_definition = self.related_fields[related_resource]
rmodel, rschema = related_definition.model, related_definition.schema
try:
related_db = await rmodel.get(id=related_id)
except DoesNotExist:
raise exceptions.ResourceNotFound(str(rmodel), related_id)
resource_db = await self.mget(resource_id)
await getattr(resource_db, related_resource).remove(related_db)
await resource_db.fetch_related(related_resource)
return [
rschema.from_orm(nested)
for nested in getattr(resource_db, related_resource)
]
async def user_delete(user_id: int):
"""Performs all actions needed to completely purge user from database"""
user = await models.User.get(id=user_id)
if not user:
raise exceptions.ResourceNotFound("user", user_id)
await user.delete()