def get_changed_objects_since(timestamp: int, request_user: User):
request_date = datetime.fromtimestamp(timestamp, pytz.utc)
query = {
'last_edit_time': {
'$gt': request_date,
'$ne': None
}
}
try:
object_list = object_manager.get_objects_by(sort="creation_time", **query)
except ObjectManagerGetError as err:
LOGGER.error(err)
return abort(400)
if len(object_list) < 1:
return make_response(object_list, 204)
rendered_list = RenderList(object_list, request_user).render_result_list()
return make_response(rendered_list)
def get_importer():
importer_response = []
for importer in __OBJECT_IMPORTER__:
importer_response.append({
'name': __OBJECT_IMPORTER__.get(importer).FILE_TYPE,
'content_type': __OBJECT_IMPORTER__.get(importer).CONTENT_TYPE,
'icon': __OBJECT_IMPORTER__.get(importer).ICON
})
return make_response(importer_response)
def get_provider_config(provider_class: str, request_user: UserModel):
auth_module = AuthModule(
system_settings_reader.get_all_values_from_section(
'auth', default=AuthModule.__DEFAULT_SETTINGS__))
try:
provider_class_config = auth_module.get_provider(
provider_class).get_config()
except StopIteration:
return abort(404, 'Provider not found')
return make_response(provider_class_config)
def delete_template(public_id: int, request_user: User):
try:
ack = docapi_tpl_manager.delete_template(public_id=public_id,
request_user=request_user)
except DocapiTemplateManagerDeleteError:
return abort(400)
except CMDBError:
return abort(500)
resp = make_response(ack)
return resp
def insert_object(request_user: User):
from bson import json_util
from datetime import datetime
add_data_dump = json.dumps(request.json)
try:
new_object_data = json.loads(add_data_dump, object_hook=json_util.object_hook)
if not 'public_id' in new_object_data:
new_object_data['public_id'] = object_manager.get_new_id(CmdbObject.COLLECTION)
if not 'active' in new_object_data:
new_object_data['active'] = True
new_object_data['creation_time'] = datetime.utcnow()
new_object_data['views'] = 0
new_object_data['version'] = '1.0.0' # default init version
except TypeError as e:
LOGGER.warning(e)
abort(400)
try:
new_object_id = object_manager.insert_object(new_object_data)
except ObjectInsertError as oie:
LOGGER.error(oie)
return abort(500)
# get current object state
try:
current_type_instance = object_manager.get_type(new_object_data['type_id'])
current_object = object_manager.get_object(new_object_id)
current_object_render_result = CmdbRender(object_instance=current_object,
type_instance=current_type_instance,
render_user=request_user,
user_list=user_manager.get_users()).result()
except ObjectManagerGetError as err:
LOGGER.error(err)
return abort(404)
except RenderError as err:
LOGGER.error(err)
return abort(500)
# Generate new insert log
try:
log_params = {
'object_id': new_object_id,
'user_id': request_user.get_public_id(),
'user_name': request_user.get_name(),
'comment': 'Object was created',
'render_state': json.dumps(current_object_render_result, default=default).encode('UTF-8'),
'version': current_object.version
}
log_ack = log_manager.insert_log(action=LogAction.CREATE, log_type=CmdbObjectLog.__name__, **log_params)
except LogManagerInsertError as err:
LOGGER.error(err)
resp = make_response(new_object_id)
return resp
def get_latest(request_user: UserModel):
"""
get object with newest last edit time
Args:
request_user: auto inserted user who made the request.
Returns:
list of rendered objects
"""
last_objects_list = object_manager.get_objects_by(
sort='last_edit_time',
limit=10,
active={"$eq": True},
last_edit_time={'$ne': None},
user=request_user,
permission=AccessControlPermission.READ)
rendered_list = RenderList(last_objects_list,
request_user).render_result_list()
if len(rendered_list) < 1:
return make_response(rendered_list, 204)
return make_response(rendered_list)
def add_link(request_user: UserModel):
try:
new_link_params = {**request.json}
except TypeError:
return abort(400)
try:
ack = object_manager.insert_link(new_link_params)
except ObjectManagerInsertError:
return abort(400)
return make_response(ack)
def get_installed_providers(request_user: UserModel):
provider_names: List[dict] = []
auth_module = AuthModule(
system_settings_reader.get_all_values_from_section(
'auth', default=AuthModule.__DEFAULT_SETTINGS__))
for provider in auth_module.providers:
provider_names.append({
'class_name': provider.get_name(),
'external': provider.EXTERNAL_PROVIDER
})
return make_response(provider_names)
def edit_group(public_id: int, request_user: User):
updated_group_params = json.dumps(request.json)
try:
response = user_manager.update_group(
public_id,
json.loads(updated_group_params,
object_hook=json_util.object_hook))
except UserManagerUpdateError as umue:
LOGGER.error(umue)
return abort(400)
return make_response(response.acknowledged)
def get_external_system_variables(class_external_system):
try:
external_system_class = load_class(
"cmdb.exportd.externals.external_systems.{}".format(
class_external_system))
list_of_parameters = external_system_class.variables
except CMDBError as e:
return abort(404, jsonify(message='Not Found', error=str(e)))
except Exception as e:
return abort(400, e)
return make_response(list_of_parameters)
def quick_search_result_counter(request_user: User):
regex = request.args.get('searchValue', Search.DEFAULT_REGEX, str)
plb = PipelineBuilder()
regex = plb.regex_('fields.value', f'{regex}', 'ims')
pipe_match = plb.match_(regex)
plb.add_pipe(pipe_match)
pipe_count = plb.count_('count')
plb.add_pipe(pipe_count)
pipeline = plb.pipeline
try:
result = list(
object_manager.aggregate(collection='framework.objects',
pipeline=pipeline))
except Exception as err:
LOGGER.error(f'[Search count]: {err}')
return abort(400)
if len(result) > 0:
return make_response(result[0]['count'])
else:
return make_response(0)
def parse_objects(request_user: UserModel):
# Check if file exists
request_file: FileStorage = get_file_in_request('file', request.files)
# Load parser config
parser_config: dict = get_element_from_data_request('parser_config', request) or {}
# Load file format
file_format = request.form.get('file_format', None)
try:
parsed_output = generate_parsed_output(request_file, file_format, parser_config).output()
except ParserRuntimeError as pre:
return abort(500, pre.message)
return make_response(parsed_output)
def get_run_job_manual(public_id, request_user: User):
"""
run job manual
"""
try:
ack = exportd_manager.run_job_manual(public_id, request_user)
except Exception as err:
LOGGER.error(err)
return abort(404)
resp = make_response(ack)
return resp
def update_file(request_user: UserModel):
""" This method updates a file to the specified section in the document.
Any existing value that matches the file name and metadata is taken into account.
Furthermore, it is checked whether the current file name already exists in the directory.
If this is the case, 'copy_(index)_' is appended as prefix. The method is executed recursively.
Exception, if the parameter 'attachment' is passed with the value '{reference':true}', the name is not checked.
Note:
Create a unique media file element:
- Folders in the same directory are unique.
- The folder name can exist in different directories
Create sub-folders:
- Selected folder is considered as parent folder
This also applies to files
Changes:
Is stored under 'request.json'
Raises:
MediaFileManagerUpdateError: If something went wrong during update.
Args:
Args:
request_user (User): the instance of the started user (last modifier)
Returns: MediaFile as JSON
"""
try:
add_data_dump = json.dumps(request.json)
new_file_data = json.loads(add_data_dump, object_hook=json_util.object_hook)
reference_attachment = json.loads(request.args.get('attachment'))
data = media_file_manager.get_file(metadata={'public_id': new_file_data['public_id']})
data['public_id'] = new_file_data['public_id']
data['filename'] = new_file_data['filename']
data['metadata'] = new_file_data['metadata']
data['metadata']['author_id'] = new_file_data['metadata']['author_id'] = request_user.get_public_id()
# Check if file / folder exist in folder
if not reference_attachment['reference']:
checker = {'filename': new_file_data['filename'], 'metadata.parent': new_file_data['metadata']['parent']}
copied_name = create_attachment_name(new_file_data['filename'], 0, checker, media_file_manager)
data['filename'] = copied_name
media_file_manager.updata_file(data)
except MediaFileManagerUpdateError:
return abort(500)
resp = make_response(data)
return resp
def update_date_settings():
new_auth_settings_values = request.get_json()
if not new_auth_settings_values:
return abort(400, 'No new data was provided')
try:
new_auth_setting_instance = DateSettingsDAO(**new_auth_settings_values)
except Exception as err:
return abort(400, err)
update_result = system_setting_writer.write(_id='date', data=new_auth_setting_instance.__dict__)
if update_result.acknowledged:
return make_response(system_settings_reader.get_section('date'))
return abort(400, 'Could not update date settings')
def delete_user(public_id: int, request_user: User):
if public_id == request_user.get_public_id():
return abort(403, 'You cant delete yourself!')
try:
user_manager.get_user(public_id)
except UserManagerGetError:
return abort(404)
try:
ack = user_manager.delete_user(public_id=public_id)
except UserManagerDeleteError:
return abort(400)
return make_response(ack)
def get_corresponding_object_logs(public_id: int, request_user: User):
try:
selected_log = log_manager.get_log(public_id=public_id)
query = {
'log_type': CmdbObjectLog.__name__,
'object_id': selected_log.object_id,
'action': LogAction.EDIT.value,
'$nor': [{
'public_id': public_id
}]
}
LOGGER.debug(f'Corresponding query: {query}')
corresponding_logs = log_manager.get_logs_by(**query)
except LogManagerGetError as err:
LOGGER.error(err)
return abort(404)
LOGGER.debug(f'Corresponding logs: {corresponding_logs}')
if len(corresponding_logs) < 1:
return make_response(corresponding_logs, 204)
return make_response(corresponding_logs)
def get_intro_starter():
try:
steps = []
categories_total = len(object_manager.get_all_categories())
types_total = object_manager.count_types()
objects_total = object_manager.count_objects()
if _fetch_only_active_objs():
result = []
cursor = object_manager.group_objects_by_value(
'active', {'active': {
"$eq": True
}})
for document in cursor:
result.append(document)
objects_total = result[0]['count'] if result else 0
steps.append({
'step': 1,
'label': 'Category',
'icon': 'check-circle',
'link': '/framework/category/add',
'state': categories_total > 0
})
steps.append({
'step': 2,
'label': 'Type',
'icon': 'check-circle',
'link': '/framework/type/add',
'state': types_total > 0
})
steps.append({
'step': 3,
'label': 'Object',
'icon': 'check-circle',
'link': '/framework/object/add',
'state': objects_total > 0
})
intro_instance = {
'steps':
steps,
'execute': (types_total > 0 and categories_total > 0
and objects_total > 0)
}
resp = make_response(intro_instance)
except CMDBError:
return abort(400)
return resp
def add_status():
new_status_params = {
**request.json,
**{
'public_id': int(
object_manager.get_new_id(CmdbStatus.COLLECTION) + 1)
}
}
try:
ack = object_manager.insert_status(new_status_params)
except ObjectManagerInsertError:
return abort(400)
return make_response(ack)
def delete_group(public_id: int, request_user: User):
action = request.args.get('action')
options = None
if request.args.get('options'):
options = json.loads(request.args.get('options'))
if action is None:
return abort(400)
try:
ack = user_manager.delete_group(public_id, action, options=options)
except UserManagerDeleteError as err:
LOGGER.error(err)
return abort(500)
return make_response(ack)
def add_collection_template(request_user: User):
collection_template_data = request.json
if not collection_template_data:
return abort(400, 'No data was provided')
try:
inserted_collection_id: int = object_manager.insert_collection_template(
collection_template_data)
except ObjectManagerInsertError as err:
LOGGER.error(
f'[CollectionTemplate] Error while adding a new collection template: {err.message}'
)
return abort(400, err.message)
return make_response(inserted_collection_id)
def get_native_object(public_id: int, request_user: UserModel):
try:
object_instance = object_manager.get_object(
public_id,
user=request_user,
permission=AccessControlPermission.READ)
except ObjectManagerGetError:
return abort(404)
except AccessDeniedError as err:
return abort(403, err.message)
resp = make_response(object_instance)
return resp
def get_objects_by_type(public_id, request_user: User):
"""Return all objects by type_id"""
try:
filter_state = {'type_id': public_id}
if _fetch_only_active_objs():
filter_state['active'] = {"$eq": True}
object_list = object_manager.get_objects_by(sort="type_id", **filter_state)
except CMDBError:
return abort(400)
if request.args.get('start') is not None:
start = int(request.args.get('start'))
length = int(request.args.get('length'))
object_list = object_list[start:start + length]
if len(object_list) < 1:
return make_response(object_list, 204)
rendered_list = RenderList(object_list, request_user).render_result_list()
resp = make_response(rendered_list)
return resp
def change_user_password(public_id: int, request_user: User):
try:
user_manager.get_user(public_id=public_id)
except UserManagerGetError as e:
LOGGER.error(f'User was not found: {e}')
return abort(404, f'User with Public ID: {public_id} not found!')
password = security_manager.generate_hmac(request.json.get('password'))
try:
ack = user_manager.update_user(public_id, {'password': password}).acknowledged
except UserManagerUpdateError as e:
LOGGER.error(f'Error while setting a new password for user: {e}')
return abort(500, 'Could not update user')
return make_response(ack)
def count_objects():
try:
count = object_manager.count_objects()
if _fetch_only_active_objs():
result = []
cursor = object_manager.group_objects_by_value('active', {'active': {"$eq": True}})
for document in cursor:
result.append(document)
count = result[0]['count'] if result else 0
resp = make_response(count)
except CMDBError:
return abort(400)
return resp
def get_log(public_id: int, request_user: UserModel):
manager = CmdbLogManager(database_manager=database_manager)
try:
selected_log: CmdbObjectLog = manager.get(public_id=public_id)
ObjectManager(database_manager=database_manager).get(
selected_log.object_id,
user=request_user,
permission=AccessControlPermission.READ)
except ManagerGetError as err:
return abort(404, err.message)
except AccessDeniedError as err:
return abort(403, err.message)
return make_response(selected_log)
def get_exportd_job(public_id, request_user: UserModel):
"""
get job in database
Returns:
exportd job
"""
try:
job = exportd_manager.get_job(public_id)
except ExportdJobManagerGetError as err:
LOGGER.error(err)
return abort(404)
resp = make_response(job)
return resp
def get_template(public_id, request_user: UserModel):
"""
get template in database
Returns:
docapi template
"""
try:
tpl = docapi_tpl_manager.get_template(public_id)
except DocapiTemplateManagerGetError as err:
LOGGER.error(err)
return abort(404)
resp = make_response(tpl)
return resp
def search_framework(request_user: UserModel):
try:
limit = request.args.get('limit', Search.DEFAULT_LIMIT, int)
skip = request.args.get('skip', Search.DEFAULT_SKIP, int)
only_active = _fetch_only_active_objs()
search_params: dict = request.args.get('query') or '{}'
resolve_object_references: bool = request.args.get('resolve', False)
except ValueError as err:
return abort(400, err)
try:
if request.method == 'GET':
search_params = json.loads(search_params)
elif request.method == 'POST':
search_params = json.loads(request.data)
else:
return abort(405)
except Exception as err:
LOGGER.error(f'[Search Framework]: {err}')
return abort(400, err)
try:
builder = PipelineBuilder()
search_parameters = SearchParam.from_request(search_params)
query: Pipeline = builder.build(search_parameters, object_manager,
only_active)
searcher = SearcherFramework(manager=object_manager)
result = searcher.aggregate(pipeline=query,
request_user=request_user,
limit=limit,
skip=skip,
resolve=resolve_object_references,
active=only_active)
except Exception as err:
LOGGER.error(f'[Search Framework Rest]: {err}')
return make_response([], 204)
return make_response(result)
def add_category(request_user: User):
http_post_request_data = json.dumps(request.json)
try:
modified_category_data = json.loads(http_post_request_data,
object_hook=json_util.object_hook)
except TypeError as e:
return abort(400)
try:
modified_category_data['public_id'] = int(
object_manager.get_new_id(CmdbCategory.COLLECTION))
ack = object_manager.insert_category(modified_category_data)
except ObjectManagerInsertError:
return abort(400)
return make_response(ack)
