def validate_parameters(parameters):
for parameter in parameters:
data_format = parameter.get('format')
data_type = parameter.get('dataType')
both = data_format and data_type
none = not data_format and not data_type
if both or none:
raise Conflict('Process parameters only can have format OR dataType')
if data_format and not Format.query.filter_by(name=data_format).one_or_none():
raise Conflict('Invalid format')
if data_type and not DataType.query.filter_by(name=data_type).one_or_none():
raise Conflict('Invalid dataType')
def delete(self, identifier):
try:
instance = self.query.filter_by(id=identifier).one_or_none()
if not instance:
raise NotFound('The process does not exist')
if instance.chains:
raise Conflict(
'The process belongs to a chain, so it cannot be deleted')
# Delete related objects
session.query(ProcessMetadata).filter_by(
process_id=identifier).delete()
session.query(Output).filter_by(process_id=identifier).delete()
session.query(Input).filter_by(process_id=identifier).delete()
# Delete object
session.delete(instance)
# Delete process file
ProcessSerializer.delete_file(instance.identifier)
session.commit()
except:
session.rollback()
raise
def save_file(self, identifier, process_id=None):
process_file = request.files.get(PROCESS_FILE_FIELD)
if not process_id and not process_file:
raise Conflict('The process file is required')
if process_file:
if not ProcessSerializer.is_valid_file(process_file.filename):
raise Conflict('The process file extension is not accepted')
if process_id:
# Delete files for the previous identifier (in case it has been changed)
process = self.query.filter_by(id=process_id).one()
ProcessSerializer.delete_file(process.identifier)
ProcessSerializer.create_file(identifier, process_file)
def validate_type(data, instance):
type_name = data.get('type')
if instance:
if type_name and type_name != instance.type.name:
raise Conflict('The repository type cannot be changed')
repository_type = instance.type
else:
if not type_name:
raise Conflict('Please, specify the repository type')
repository_type = RepositoryType.query.filter_by(name=type_name).one_or_none()
if not repository_type:
raise Conflict('Invalid repository type')
return repository_type
def validate_configurations(data, instance, repository_type):
configurations = data.get('configurations')
if not instance and not configurations:
raise Conflict('Please, specify the repository configurations')
if configurations:
available = set(RepositoryValidator.get_configurations(repository_type))
mandatory = set(RepositoryValidator.get_configurations(repository_type, mandatory=True))
provided = set((name for name, value in configurations.iteritems()))
non_recognized = provided - available
if non_recognized:
raise Conflict('Non recognized configurations: {}'.format(', '.join(non_recognized)))
missing = mandatory - provided
if missing:
raise Conflict(
'Missing mandatory configuration: {}'.format(
', '.join(missing)
)
)
def validate_match(steps, graph):
m = 'The "{}" input of "{}" requires an explicit match, or only one predecessor output with the same identifier'
processes = ChainValidator.get_chain_processes(graph)
for process in processes:
process_identifier = process.identifier
predecessors = graph.predecessors(process_identifier)
if predecessors:
predecessors_outputs = ChainValidator.get_outputs(predecessors)
for process_input in process.inputs:
input_identifier = process_input.identifier
has_match = ChainValidator.has_match(process_identifier, input_identifier, steps)
matchable = ChainValidator.is_matchable(input_identifier, predecessors_outputs)
if not has_match and not matchable:
raise Conflict(m.format(input_identifier, process_identifier))
def _validate_multipart():
if not request.form:
raise Conflict('This endpoint only accepts multipart/form-data')
def validate_unique(data):
identifier = data.get('identifier')
chain = Chain.query.filter_by(identifier=identifier).one_or_none()
if chain:
raise Conflict('Already exists a chain with the given identifier')
def validate_repeated(graph, before, after):
nodes = graph.nodes()
if before in nodes and after in nodes and graph.number_of_edges(before, after):
raise Conflict('{} to {} step is repeated'.format(before, after))
def validate_acyclic(graph):
if not is_directed_acyclic_graph(graph):
raise Conflict('Graph must be directed and acyclic')
def validate_at_least_one_step(steps):
if not steps:
raise Conflict('At least one step is required')
def validate_unique(data):
identifier = data.get('identifier')
process = Process.query.filter_by(identifier=identifier).one_or_none()
if process:
raise Conflict('Already exists a process with the given identifier')