def validate(self) -> None:
# Validate/populate model exists
self._models = AnnotationLayerDAO.find_by_ids(self._model_ids)
if not self._models or len(self._models) != len(self._model_ids):
raise AnnotationLayerNotFoundError()
if AnnotationLayerDAO.has_annotations(self._model_ids):
raise AnnotationLayerBulkDeleteIntegrityError()
def validate(self) -> None:
# Validate/populate model exists
self._model = AnnotationLayerDAO.find_by_id(self._model_id)
if not self._model:
raise AnnotationLayerNotFoundError()
if AnnotationLayerDAO.has_annotations(self._model.id):
raise AnnotationLayerDeleteIntegrityError()
def run(self) -> None:
self.validate()
try:
AnnotationLayerDAO.bulk_delete(self._models)
return None
except DAODeleteFailedError as ex:
logger.exception(ex.exception)
raise AnnotationLayerBulkDeleteFailedError()
def get_native_annotation_data(query_obj: QueryObject) -> Dict[str, Any]:
annotation_data = {}
annotation_layers = [
layer
for layer in query_obj.annotation_layers
if layer["sourceType"] == "NATIVE"
]
layer_ids = [layer["value"] for layer in annotation_layers]
layer_objects = {
layer_object.id: layer_object
for layer_object in AnnotationLayerDAO.find_by_ids(layer_ids)
}
# annotations
for layer in annotation_layers:
layer_id = layer["value"]
layer_name = layer["name"]
columns = [
"start_dttm",
"end_dttm",
"short_descr",
"long_descr",
"json_metadata",
]
layer_object = layer_objects[layer_id]
records = [
{column: getattr(annotation, column) for column in columns}
for annotation in layer_object.annotation
]
result = {"columns": columns, "records": records}
annotation_data[layer_name] = result
return annotation_data
def validate(self) -> None:
exceptions: List[ValidationError] = list()
name = self._properties.get("name", "")
self._model = AnnotationLayerDAO.find_by_id(self._model_id)
if not self._model:
raise AnnotationLayerNotFoundError()
if not AnnotationLayerDAO.validate_update_uniqueness(
name, layer_id=self._model_id):
exceptions.append(AnnotationLayerNameUniquenessValidationError())
if exceptions:
exception = AnnotationLayerInvalidError()
exception.add_list(exceptions)
raise exception
def validate(self) -> None:
exceptions: List[ValidationError] = []
layer_id: Optional[int] = self._properties.get("layer")
start_dttm: Optional[datetime] = self._properties.get("start_dttm")
end_dttm: Optional[datetime] = self._properties.get("end_dttm")
short_descr = self._properties.get("short_descr", "")
# Validate/populate model exists
if not layer_id and not isinstance(layer_id, int):
raise AnnotationLayerNotFoundError()
annotation_layer = AnnotationLayerDAO.find_by_id(layer_id)
if not annotation_layer:
raise AnnotationLayerNotFoundError()
self._properties["layer"] = annotation_layer
# Validate short descr uniqueness on this layer
if not AnnotationDAO.validate_update_uniqueness(layer_id, short_descr):
exceptions.append(AnnotationUniquenessValidationError())
# validate date time sanity
if start_dttm and end_dttm and end_dttm < start_dttm:
exceptions.append(AnnotationDatesValidationError)
if exceptions:
exception = AnnotationInvalidError()
exception.add_list(exceptions)
raise exception
def validate(self) -> None:
exceptions: List[ValidationError] = list()
layer_id: Optional[int] = self._properties.get("layer")
short_descr: str = self._properties.get("short_descr", "")
# Validate/populate model exists
self._model = AnnotationDAO.find_by_id(self._model_id)
if not self._model:
raise AnnotationNotFoundError()
# Validate/populate layer exists
if layer_id:
annotation_layer = AnnotationLayerDAO.find_by_id(layer_id)
if not annotation_layer:
raise AnnotationLayerNotFoundError()
self._properties["layer"] = annotation_layer
# Validate short descr uniqueness on this layer
if not AnnotationDAO.validate_update_uniqueness(
layer_id, short_descr, annotation_id=self._model_id,
):
exceptions.append(AnnotationUniquenessValidationError())
else:
self._properties["layer"] = self._model.layer
# validate date time sanity
start_dttm: Optional[datetime] = self._properties.get("start_dttm")
end_dttm: Optional[datetime] = self._properties.get("end_dttm")
if start_dttm and end_dttm and end_dttm < start_dttm:
exceptions.append(AnnotationDatesValidationError())
if exceptions:
exception = AnnotationInvalidError()
exception.add_list(exceptions)
raise exception
def run(self) -> Model:
self.validate()
try:
annotation_layer = AnnotationLayerDAO.delete(self._model)
except DAODeleteFailedError as ex:
logger.exception(ex.exception)
raise AnnotationLayerDeleteFailedError() from ex
return annotation_layer
def run(self) -> Model:
self.validate()
try:
annotation_layer = AnnotationLayerDAO.create(self._properties)
except DAOCreateFailedError as ex:
logger.exception(ex.exception)
raise AnnotationLayerCreateFailedError()
return annotation_layer
def run(self) -> Model:
self.validate()
try:
annotation_layer = AnnotationLayerDAO.update(self._model, self._properties)
except DAOUpdateFailedError as ex:
logger.exception(ex.exception)
raise AnnotationLayerUpdateFailedError() from ex
return annotation_layer
def validate(self) -> None:
exceptions: List[ValidationError] = list()
name = self._properties.get("name", "")
if not AnnotationLayerDAO.validate_update_uniqueness(name):
exceptions.append(AnnotationLayerNameUniquenessValidationError())
if exceptions:
exception = AnnotationLayerInvalidError()
exception.add_list(exceptions)
raise exception
