def add_license_to_db(object_license):
neo_license = LicenseModel.nodes.get_or_none(
hashed_sets=object_license.hash())
if neo_license:
# update of labels list if needed
neo_license.labels = list(
set(object_license.get_labels()).union(neo_license.labels))
neo_license.save()
else:
# license does not exists in db
license_leaves = get_leaf_licenses()
neo_license = NeoFactory.NeoLicense(object_license)
neo_license.save()
for neo_license_leaf in license_leaves:
object_license_leaf = ObjectFactory.objectLicense(neo_license_leaf)
if object_license.is_preceding(object_license_leaf):
if Constraints.is_compatibility_viable(object_license,
object_license_leaf):
neo_license_leaf.precedings.connect(neo_license)
else:
update_licenses_relations_rec(neo_license, object_license,
neo_license_leaf,
object_license_leaf)
for dataset in object_license.get_datasets():
neo_dataset = DatasetModel.nodes.get_or_none(hashed_uri=dataset.hash())
if not neo_dataset:
neo_dataset = NeoFactory.NeoDataset(dataset)
neo_dataset.save()
neo_license.datasets.connect(neo_dataset)
object_license = ObjectFactory.objectLicense(neo_license)
return object_license
def add_license_to_db(object_license,
method='infimum',
license_levels=[],
viability_check=True,
nb_visit=0,
graph='ld'):
neo_license = LicenseModel.nodes.filter(graph__exact=graph).get_or_none(
hashed_sets=object_license.hash())
if neo_license:
# update of labels list if needed
neo_license.labels = list(
set(object_license.get_labels()).union(neo_license.labels))
neo_license.save()
else:
# license does not exists in db
if method == 'infimum':
neo_license, nb_visit = update_licenses_relations_infimum(
object_license, viability_check, nb_visit, graph)
else:
neo_license, nb_visit = update_licenses_relations_supremum(
object_license, viability_check, nb_visit, graph)
license_levels.append(object_license.get_level())
for dataset in object_license.get_datasets():
neo_dataset = DatasetModel.nodes.filter(
graph__exact=graph).get_or_none(hashed_uri=dataset.hash())
if not neo_dataset:
neo_dataset = NeoFactory.NeoDataset(dataset, graph)
neo_dataset.save()
neo_license.datasets.connect(neo_dataset)
object_license = ObjectFactory.objectLicense(neo_license)
return object_license, nb_visit
def add_dataset(request, graph):
json_dataset = json.loads(request.body)
object_dataset = Dataset()
object_dataset.from_json(json_dataset)
neo_dataset = NeoFactory.NeoDataset(object_dataset, graph)
object_dataset = ObjectFactory.objectDataset(neo_dataset)
try:
neo_dataset.save()
response = HttpResponse(
json.dumps(object_dataset.to_json()),
content_type='application/json',
status=201,
)
except UniqueProperty:
response = HttpResponse(
json.dumps(object_dataset.to_json()),
content_type='application/json',
status=409,
)
response['Access-Control-Allow-Origin'] = '*'
return response
def update_licenses_relations_supremum(object_license,
viability_check,
nb_visit,
graph='ld'):
tested_licenses = [object_license]
license_roots = get_root_licenses(graph)
neo_license = NeoFactory.NeoLicense(object_license, graph)
neo_license.save()
for neo_license_root in license_roots:
object_license_root = ObjectFactory.objectLicense(neo_license_root)
if object_license.is_following(object_license_root) and (
Constraints.is_compatibility_viable(object_license_root,
object_license)
or not viability_check):
update_transitivity_preceder(neo_license, object_license_root)
neo_license_root.followings.connect(neo_license)
else:
nb_visit = update_licenses_relations_supremum_rec(
neo_license, object_license, neo_license_root,
object_license_root, viability_check, nb_visit,
tested_licenses)
return neo_license, nb_visit
def update_licenses_relations_infimum(object_license,
viability_check,
nb_visit,
graph='ld'):
tested_licenses = [object_license]
license_leaves = get_leaf_licenses(graph)
neo_license = NeoFactory.NeoLicense(object_license, graph)
neo_license.save()
for neo_license_leaf in license_leaves:
object_license_leaf = ObjectFactory.objectLicense(neo_license_leaf)
if object_license.is_preceding(object_license_leaf) and (
Constraints.is_compatibility_viable(object_license,
object_license_leaf)
or not viability_check):
update_transitivity_follower(neo_license, object_license_leaf)
neo_license_leaf.precedings.connect(neo_license)
else:
nb_visit = update_licenses_relations_infimum_rec(
neo_license, object_license, neo_license_leaf,
object_license_leaf, viability_check, nb_visit,
tested_licenses)
return neo_license, nb_visit