def del_dataformat():
to_delete = request.json.get('to_delete')
res = []
if to_delete:
for d in to_delete:
name = from_dict(d, 'name')
dataformat_id = from_dict(d, 'dataformat_id')
try:
df = DataFormat.get(dataformat_id, name)
dataformat_id = df.id
name = df.name
message = DataFormat.delete(df)
# db.session.delete(df)
# db.session.commit()
# message = df.to_dict()
res.append(message)
except Exception as e:
err = {"error": str(e)}
if dataformat_id:
err['dataformat_id'] = dataformat_id
if name:
err['name'] = name
res.append(err)
else:
res.append({"error": "Request must provide list 'to_delete' of objects with 'dataformat_id' or 'name'."})
return jsonify({"deleted": res})
def validate(self):
if self.title is None:
raise Exception("Title not provided.")
if self.data_format is None:
raise Exception("Data Format not provided.")
if self.data is None:
raise Exception("Data not provided.")
df = DataFormat.get(self.data_format, None)
if df is None:
raise DataFormat("Data Format not available.")
instance = self.data.decode("utf-8")
format = df.format
format_name = df.name
schema = df.schema
title = self.title
validation = True
if format == DataFormats.json:
validation = validate_json(schema, instance)
elif format == DataFormats.xml:
validation = validate_xml(schema, instance)
if validation is not True:
raise Exception("File '{}' does not match '{}' format: {}.".format(
title, format_name, validation))
def post_dataformat():
to_post = request.json.get('to_post')
res = []
if to_post:
for p in to_post:
name = from_dict(p, 'name')
format = from_dict(p, 'file_format')
schema_uri = from_dict(p, 'schema_uri')
try:
df = DataFormat.create(name, format, schema_uri, g.user)
db.session.add(df)
db.session.commit()
res.append(df.to_dict())
except Exception as e:
err = {"error": str(e)}
if name:
err['name'] = name
res.append(err)
else:
res.append({"error": "Request must provide list 'to_post' of objects"
" with 'name', 'file_format' and 'schema_uri'."})
return jsonify({"posted": res})
def upd_dataformat():
to_update = request.json.get('to_update')
res = []
if to_update:
for u in to_update:
name = from_dict(u, 'name')
dataformat_id = from_dict(u, 'dataformat_id')
new_name = from_dict(u, 'new_name')
new_format = from_dict(u, 'new_file_format')
new_schema_uri = from_dict(u, 'new_schema_uri')
try:
df = DataFormat.get(dataformat_id, name)
df.update(new_name, new_format, new_schema_uri)
dataformat_id = df.id
name = df.name
db.session.commit()
res.append(df.to_dict())
except Exception as e:
err = {"error": str(e)}
if dataformat_id:
err['dataformat_id'] = dataformat_id
if name:
err['name'] = name
res.append(err)
else:
res.append({"error": "Request must provide list 'to_update' of objects with 'dataformat_id' or 'name' "
"and data to update ('new_name','new_file_format','new_schema_uri')."})
return jsonify({"updated": res})
def get_dataformat():
to_get = request.json.get('to_get')
res = {"response": []}
incomplete_description = {"error":"Request must provide list 'to_get' of objects with 'dataformat_id' or 'name'."}
if to_get:
for g in to_get:
name = from_dict(g, 'name')
dataformat_id = from_dict(g, 'dataformat_id')
if (dataformat_id is not None) or (name is not None):
try:
df = DataFormat.get(dataformat_id, name)
res["response"].append(df.to_dict())
except Exception as e:
err = {"error": str(e)}
if dataformat_id:
err['dataformat_id'] = dataformat_id
if name:
err['name'] = name
res["response"].append(err)
else:
res['response'].append(incomplete_description)
else:
res['response'].append(incomplete_description)
return jsonify(res)
def to_dict_light(self):
df = DataFormat.get(self.data_format, None)
d = super().to_dict()
d["dataset_id"] = self.id
d["title"] = self.title
d["format_name"] = df.name
d["format_id"] = df.id
return d
def set_result_format(self, dataformat_id, name):
df = None
try:
df = DataFormat.get(dataformat_id, name)
except:
raise Exception("No valid Result Format provided! "
"You must provide 'result_format_id' or 'result_format_name'.")
self.result_format = df.id
def set_output(self, format_id, format_name):
df = DataFormat.get(format_id, format_name)
self.output = df.id
def set_data_format(self, dataformat_id, name):
df = DataFormat.get(dataformat_id, name)
self.data_format = df.id
def get_result_format(self):
return DataFormat.get(self.result_format, None)