def update_group(public_id: int, data: dict):
"""
HTTP `PUT`/`PATCH` route for update a single group resource.
Args:
public_id (int): Public ID of the updatable group.
data (UserGroupModel.SCHEMA): New group data to update.
Raises:
ManagerGetError: When the group with the `public_id` was not found.
ManagerUpdateError: When something went wrong during the update.
Returns:
UpdateSingleResponse: With update result of the new updated group.
"""
group_manager: GroupManager = GroupManager(database_manager=current_app.database_manager,
right_manager=RightManager(rights))
try:
group = UserGroupModel.from_data(data=data, rights=RightManager(rights).rights)
group_dict = UserGroupModel.to_dict(group)
group_dict['rights'] = [right.get('name') for right in group_dict.get('rights', [])]
group_manager.update(public_id=PublicID(public_id), group=group_dict)
api_response = UpdateSingleResponse(result=group_dict, url=request.url,
model=UserGroupModel.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 get_group(self, public_id: int) -> UserGroupModel:
try:
founded_group = self._get(collection=UserGroupModel.COLLECTION,
public_id=public_id)
return UserGroupModel(**founded_group)
except NoDocumentFound as e:
raise UserManagerGetError(e)
def get_group(public_id: int):
"""
HTTP `GET`/`HEAD` route for a single group resource.
Args:
public_id (int): Public ID of the group.
Raises:
ManagerGetError: When the selected group does not exists.
Notes:
Calling the route over HTTP HEAD method will result in an empty body.
Returns:
GetSingleResponse: Which includes the json data of a UserGroupModel.
"""
group_manager: GroupManager = GroupManager(database_manager=current_app.database_manager,
right_manager=RightManager(rights))
try:
group = group_manager.get(public_id)
except ManagerGetError as err:
return abort(404, err.message)
api_response = GetSingleResponse(UserGroupModel.to_dict(group), url=request.url,
model=UserGroupModel.MODEL, body=request.method == 'HEAD')
return api_response.make_response()
def get_groups(params: CollectionParameters):
"""
HTTP `GET`/`HEAD` route for getting a iterable collection of resources.
Args:
params (CollectionParameters): Passed parameters over the http query string
Returns:
GetMultiResponse: Which includes a IterationResult of the UserGroupModel.
Notes:
Calling the route over HTTP HEAD method will result in an empty body.
Raises:
ManagerIterationError: If the collection could not be iterated.
ManagerGetError: If the collection/resources could not be found.
"""
group_manager: GroupManager = GroupManager(database_manager=current_app.database_manager,
right_manager=RightManager(rights))
try:
iteration_result: IterationResult[UserGroupModel] = group_manager.iterate(
filter=params.filter, limit=params.limit, skip=params.skip, sort=params.sort, order=params.order)
groups = [UserGroupModel.to_dict(group) for group in iteration_result.results]
api_response = GetMultiResponse(groups, total=iteration_result.total, params=params,
url=request.url, model=UserGroupModel.MODEL, body=request.method == 'HEAD')
except FrameworkIterationError as err:
return abort(400, err.message)
except ManagerGetError as err:
return abort(404, err.message)
return api_response.make_response()
def insert_group(data: dict):
"""
HTTP `POST` route for insert a single group resource.
Args:
data (UserGroupModel.SCHEMA): Insert data of a new group.
Raises:
ManagerGetError: If the inserted group could not be found after inserting.
ManagerInsertError: If something went wrong during insertion.
Returns:
InsertSingleResponse: Insert response with the new group and its public_id.
"""
group_manager: GroupManager = GroupManager(database_manager=current_app.database_manager,
right_manager=RightManager(rights))
try:
result_id: PublicID = group_manager.insert(data)
group = group_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=result_id, raw=UserGroupModel.to_dict(group), url=request.url,
model=UserGroupModel.MODEL)
return api_response.make_response(prefix='groups')
def get_groups(self) -> list:
group_list = []
for founded_group in self._get_many(collection=UserGroupModel.COLLECTION):
try:
group_list.append(UserGroupModel(**founded_group))
except CMDBError:
LOGGER.debug("Error while group parser: {}".format(founded_group))
continue
return group_list
def delete_group(public_id: int, params: GroupDeletionParameters):
"""
HTTP `DELETE` route for delete a single group resource.
Args:
public_id (int): Public ID of the user.
params (GroupDeletionParameters): Optional action parameters for handling users when the group \
is going to be deleted.
Notes:
Based on the params attribute. Users can be moved or deleted.
Raises:
ManagerGetError: When the group with the `public_id` was not found.
ManagerDeleteError: When something went wrong during the deletion.
Returns:
DeleteSingleResponse: Delete result with the deleted group as data.
"""
group_manager: GroupManager = GroupManager(database_manager=current_app.database_manager,
right_manager=RightManager(rights))
user_manager: UserManager = UserManager(database_manager=current_app.database_manager)
# Check of action is set
if params.action:
users_in_group: List[UserModel] = user_manager.get_many(Query({'group_id': public_id}))
if len(users_in_group) > 0:
if params.action == GroupDeleteMode.MOVE.value:
if params.group_id:
for user in users_in_group:
user.group_id = int(params.group_id)
try:
user_manager.update(user.public_id, user)
except ManagerUpdateError as err:
return abort(400,
f'Could not move user: {user.public_id} to group: {params.group_id} | '
f'Error: {err.message}')
if params.action == GroupDeleteMode.DELETE.value:
for user in users_in_group:
try:
user_manager.delete(user.public_id)
except ManagerDeleteError as err:
return abort(400, f'Could not delete user: {user.public_id} | Error: {err.message}')
try:
deleted_group = group_manager.delete(public_id=PublicID(public_id))
api_response = DeleteSingleResponse(raw=UserGroupModel.to_dict(deleted_group), model=UserGroupModel.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 get_group_by(self, **requirements) -> UserGroupModel:
try:
return UserGroupModel(**self._get_by(
collection=UserGroupModel.COLLECTION, **requirements))
except NoDocumentFound:
raise UserManagerGetError(f'Group not found')
from cmdb.user_management.rights import __all__ as rights
# TODO: Refactor to use with dependency injection
right_manager = RightManager(rights)
__COLLECTIONS__: List = [
UserModel,
UserSettingModel,
UserGroupModel
]
__ADMIN_GROUP_RIGHTS__: List[BaseRight] = [
right_manager.get('base.*')
]
__USER_GROUP_RIGHTS__: List[BaseRight] = [
right_manager.get('base.framework.object.*'),
right_manager.get('base.framework.type.view'),
right_manager.get('base.framework.category.view'),
right_manager.get('base.framework.log.view'),
right_manager.get('base.user-management.user.view'),
right_manager.get('base.user-management.group.view'),
right_manager.get('base.docapi.template.view')
]
__FIXED_GROUPS__: List[UserGroupModel] = [
UserGroupModel(public_id=1, name='admin', label='Administrator', rights=__ADMIN_GROUP_RIGHTS__),
UserGroupModel(public_id=2, name='user', label='User', rights=__USER_GROUP_RIGHTS__)
]