def create_user(user: dict):
# create a user model from user data.
user_model = UserModel.create_user(user, current_user.id)
# Check if user with the same username don't exist.
if __is_username_taken(user_model.username):
return response.bool_to_response(False)
created = user_model.save()
return response.bool_to_response(created)
def delete_target_folder(target_folder_id):
ft: TargetFolderModel = TargetFolderModel.find_by_id(target_folder_id)
if not ft:
raise EntityNotFound(
"The target folder id {} doesn't exist".format(target_folder_id))
return response.bool_to_response(ft.delete())
def update_location(location: dict):
updated_location = LocationModel.update(location)
if not updated_location:
raise EntityNotFound("This location doesn't exist.")
return response.bool_to_response(updated_location.save())
def update_channel(channel: dict):
updated_channel = ChannelModel.update(channel)
if not updated_channel:
raise EntityNotFound("This channel doesn't exist.")
return response.bool_to_response(updated_channel.save())
def update_user(user: dict):
# update user
updated_user = UserModel.update_user(user, current_user.id)
if not updated_user:
raise UserNotFound("The user doesn't exist.")
# return response.bool_to_response(True)
return response.bool_to_response(updated_user.save())
def is_folder_online(param_id: str):
app_param: AppParamsModel = AppParamsModel.find_by_id(param_id)
if not app_param:
raise EntityNotFound(
"The param_id = {} is not valid.".format(param_id))
folder_path = app_param.param_value
is_online = file_utils.is_dir_online(folder_path)
return response.bool_to_response(is_online)
def delete_data(data_id):
sd: SeismicDataModel = SeismicDataModel.find_by_id(data_id)
if not sd:
raise EntityNotFound(
"The file with id {} doesn't exist".format(data_id))
# deleting this entity will trigger events to delete the mseed files from storage attached to it.
deleted = sd.delete()
return response.bool_to_response(deleted)
def delete_user(user_id):
user: UserModel = UserModel.find_by_id(user_id)
if not user:
raise UserNotFound("The user id {} doesn't exist".format(user_id))
deleted = user.delete()
if deleted:
app_logger.info("User {} has been deleted".format(user.username))
else:
app_logger.warning("User {} could't be deleted.".format(user.username))
return response.bool_to_response(deleted)
def delete_location(loc_id):
loc: LocationModel = LocationModel.find_by_id(loc_id)
if not loc:
raise EntityNotFound("The location id {} doesn't exist".format(loc_id))
deleted = loc.delete()
if deleted:
app_logger.info("Location {} has been deleted at station {}.".format(
loc.name, loc.station_id))
else:
app_logger.warning(
"Location {} could't be deleted at station {}.".format(
loc.name, loc.station_id))
return response.bool_to_response(deleted)
def delete_station(station_id):
station: StationModel = StationModel.find_by_id(station_id)
if not station:
raise EntityNotFound(
"The station id {} doesn't exist".format(station_id))
deleted = station.delete()
if deleted:
app_logger.info("Station {} - {} has been deleted".format(
station.name, station.creation_date))
else:
app_logger.warning("Station {} - {} could't be deleted.".format(
station.name, station.creation_date))
return response.bool_to_response(deleted)
def delete_attached_file(attached_id):
attached: StationAttachedFileModel = StationAttachedFileModel.find_by_id(
attached_id)
if not attached:
raise EntityNotFound(
"The file id {} doesn't exist".format(attached_id))
deleted = attached.delete()
if deleted:
app_logger.info("Attached file {} has been deleted".format(
attached.filename))
else:
app_logger.warning("Channel {} could't be deleted.".format(
attached.filename))
return response.bool_to_response(deleted)
def delete_channel(channel_id):
channel: ChannelModel = ChannelModel.find_by_id(channel_id)
if not channel:
raise EntityNotFound(
"The channel id {} doesn't exist".format(channel_id))
deleted = channel.delete()
if deleted:
app_logger.info("Channel {}-{}-{} has been deleted".format(
channel.get_station().name, channel.name,
DateUtils.convert_datetime_to_utc(channel.start_time)))
else:
app_logger.warning("Channel {}-{}-{} could't be deleted.".format(
channel.get_station().name, channel.name,
DateUtils.convert_datetime_to_utc(channel.start_time)))
return response.bool_to_response(deleted)
def update_app_params(param: dict):
return response.bool_to_response(AppParamsModel.update(param))
def is_network_taken(id: str):
network_exist = NetworkModel.find_by_id(id)
if network_exist:
return response.bool_to_response(True)
return response.bool_to_response(False)
def create_station(station_dict: dict):
was_created = StationModel.create_station(station_dict)
return response.bool_to_response(was_created)
def create_equipment(equipment_dict: dict):
was_created = EquipmentModel.create_equipments(equipment_dict)
return response.bool_to_response(was_created)
def create_location(location_dict: dict):
was_created = LocationModel.create_location(location_dict)
return response.bool_to_response(was_created)
def create_channel(channel_dict: dict):
was_created = ChannelModel.create_channel(channel_dict)
return response.bool_to_response(was_created)
def is_taken(username: str):
user_exist = __is_username_taken(username)
return response.bool_to_response(user_exist)
def create_network(network_dict: dict):
network: NetworkModel = NetworkModel.from_dict(network_dict)
network.id = network.id.upper().strip()
return response.bool_to_response(network.save())
