def report(request, resourceid):
lang = request.GET.get('lang', settings.LANGUAGE_CODE)
se = SearchEngineFactory().create()
report_info = se.search(index='resource', id=resourceid)
report_info['source'] = report_info['_source']
report_info['type'] = report_info['_type']
report_info['source']['graph'] = report_info['source']['graph']
del report_info['_source']
del report_info['_type']
def get_evaluation_path(valueid):
value = models.Values.objects.get(pk=valueid)
concept_graph = Concept().get(id=value.conceptid_id, include_subconcepts=False,
include_parentconcepts=True, include_relatedconcepts=False, up_depth_limit=None, lang=lang)
paths = []
for path in concept_graph.get_paths(lang=lang)[0]:
if path['label'] != 'Arches' and path['label'] != 'Evaluation Criteria Type':
paths.append(path['label'])
return '; '.join(paths)
concept_label_ids = set()
uuid_regex = re.compile('[0-9a-fA-F]{8}-[0-9a-fA-F]{4}-[0-9a-fA-F]{4}-[0-9a-fA-F]{4}-[0-9a-fA-F]{12}')
# gather together all uuid's referenced in the resource graph
def crawl(items):
for item in items:
for key in item:
if isinstance(item[key], list):
crawl(item[key])
else:
if isinstance(item[key], basestring) and uuid_regex.match(item[key]):
if key == 'EVALUATION_CRITERIA_TYPE_E55__value':
item[key] = get_evaluation_path(item[key])
concept_label_ids.add(item[key])
crawl([report_info['source']['graph']])
# get all the concept labels from the uuid's
concept_labels = se.search(index='concept_labels', id=list(concept_label_ids))
# convert all labels to their localized prefLabel
temp = {}
if concept_labels != None:
for concept_label in concept_labels['docs']:
#temp[concept_label['_id']] = concept_label
if concept_label['found']:
# the resource graph already referenced the preferred label in the desired language
if concept_label['_source']['type'] == 'prefLabel' and concept_label['_source']['language'] == lang:
temp[concept_label['_id']] = concept_label['_source']
else:
# the resource graph referenced a non-preferred label or a label not in our target language, so we need to get the right label
temp[concept_label['_id']] = get_preflabel_from_conceptid(concept_label['_source']['conceptid'], lang)
# replace the uuid's in the resource graph with their preferred and localized label
def crawl_again(items):
for item in items:
for key in item:
if isinstance(item[key], list):
crawl_again(item[key])
else:
if isinstance(item[key], basestring) and uuid_regex.match(item[key]):
try:
item[key] = temp[item[key]]['value']
except:
pass
crawl_again([report_info['source']['graph']])
#return JSONResponse(report_info, indent=4)
related_resource_dict = {
'HERITAGE_RESOURCE': [],
'HERITAGE_RESOURCE_GROUP': [],
'ACTIVITY': [],
'ACTOR': [],
'HISTORICAL_EVENT': [],
'INFORMATION_RESOURCE_IMAGE': [],
'INFORMATION_RESOURCE_DOCUMENT': []
}
related_resource_info = get_related_resources(resourceid, lang)
# parse the related entities into a dictionary by resource type
for related_resource in related_resource_info['related_resources']:
information_resource_type = 'DOCUMENT'
related_resource['relationship'] = []
if related_resource['entitytypeid'] == 'HERITAGE_RESOURCE.E18':
for entity in related_resource['domains']:
if entity['entitytypeid'] == 'RESOURCE_TYPE_CLASSIFICATION.E55':
related_resource['relationship'].append(get_preflabel_from_valueid(entity['value'], lang)['value'])
elif related_resource['entitytypeid'] == 'HERITAGE_RESOURCE_GROUP.E27':
for entity in related_resource['domains']:
if entity['entitytypeid'] == 'RESOURCE_TYPE_CLASSIFICATION.E55':
related_resource['relationship'].append(get_preflabel_from_valueid(entity['value'], lang)['value'])
elif related_resource['entitytypeid'] == 'ACTIVITY.E7':
for entity in related_resource['domains']:
if entity['entitytypeid'] == 'ACTIVITY_TYPE.E55':
related_resource['relationship'].append(get_preflabel_from_valueid(entity['value'], lang)['value'])
elif related_resource['entitytypeid'] == 'ACTOR.E39':
for entity in related_resource['domains']:
if entity['entitytypeid'] == 'ACTOR_TYPE.E55':
related_resource['relationship'].append(get_preflabel_from_conceptid(entity['conceptid'], lang)['value'])
related_resource['actor_relationshiptype'] = ''
elif related_resource['entitytypeid'] == 'HISTORICAL_EVENT.E5':
for entity in related_resource['domains']:
if entity['entitytypeid'] == 'HISTORICAL_EVENT_TYPE.E55':
related_resource['relationship'].append(get_preflabel_from_conceptid(entity['conceptid'], lang)['value'])
elif related_resource['entitytypeid'] == 'INFORMATION_RESOURCE.E73':
for entity in related_resource['domains']:
if entity['entitytypeid'] == 'INFORMATION_RESOURCE_TYPE.E55':
related_resource['relationship'].append(get_preflabel_from_valueid(entity['value'], lang)['value'])
for entity in related_resource['child_entities']:
if entity['entitytypeid'] == 'FILE_PATH.E62':
related_resource['file_path'] = settings.MEDIA_URL + entity['label']
if entity['entitytypeid'] == 'THUMBNAIL.E62':
related_resource['thumbnail'] = settings.MEDIA_URL + entity['label']
information_resource_type = 'IMAGE'
# get the relationship between the two entities
for relationship in related_resource_info['resource_relationships']:
if relationship['entityid1'] == related_resource['entityid'] or relationship['entityid2'] == related_resource['entityid']:
related_resource['relationship'].append(get_preflabel_from_valueid(relationship['relationshiptype'], lang)['value'])
entitytypeidkey = related_resource['entitytypeid'].split('.')[0]
if entitytypeidkey == 'INFORMATION_RESOURCE':
entitytypeidkey = '%s_%s' % (entitytypeidkey, information_resource_type)
related_resource_dict[entitytypeidkey].append(related_resource)
# To hide Related Resource block in report page if no related resources present
no_related_resources = False
if all(len(value) == 0 for value in related_resource_dict.values()):
no_related_resources = True
return render_to_response('resource-report.htm', {
'geometry': JSONSerializer().serialize(report_info['source']['geometry']),
'resourceid': resourceid,
'report_template': 'views/reports/' + report_info['type'] + '.htm',
'report_info': report_info,
'related_resource_dict': related_resource_dict,
'no_related_resources': no_related_resources,
'main_script': 'resource-report',
'active_page': 'ResourceReport'
},
context_instance=RequestContext(request))
def post(self, request):
showform = True
confirmation_message = ""
postdata = request.POST.copy()
postdata["ts"] = int(time.time())
form = ArchesUserCreationForm(postdata,
enable_captcha=settings.ENABLE_CAPTCHA)
if form.is_valid():
AES = AESCipher(settings.SECRET_KEY)
userinfo = JSONSerializer().serialize(form.cleaned_data)
encrypted_userinfo = AES.encrypt(userinfo)
url_encrypted_userinfo = urlencode({"link": encrypted_userinfo})
admin_email = settings.ADMINS[0][1] if settings.ADMINS else ""
email_context = {
"button_text":
_("Signup for Arches"),
"link":
request.build_absolute_uri(
reverse("confirm_signup") + "?" + url_encrypted_userinfo),
"greeting":
_("Thanks for your interest in Arches. Click on link below \
to confirm your email address! Use your email address to login."
),
"closing":
_("This link expires in 24 hours. If you can't get to it before then, \
don't worry, you can always try again with the same email address."
),
}
html_content = render_to_string("email/general_notification.htm",
email_context) # ...
text_content = strip_tags(
html_content
) # this strips the html, so people will have the text as well.
# create the email, and attach the HTML version as well.
msg = EmailMultiAlternatives(_("Welcome to Arches!"), text_content,
admin_email,
[form.cleaned_data["email"]])
msg.attach_alternative(html_content, "text/html")
msg.send()
confirmation_message = _(
"An email has been sent to <br><strong>%s</strong><br> with a link to activate your account"
% form.cleaned_data["email"])
showform = False
return render(
request,
"signup.htm",
{
"enable_captcha": settings.ENABLE_CAPTCHA,
"form": form,
"postdata": postdata,
"showform": showform,
"confirmation_message": confirmation_message,
"validation_help": validation.password_validators_help_texts(),
},
)
def get(self, request, resourceid=None, view_template="views/resource/edit-log.htm"):
if resourceid is None:
recent_edits = (
models.EditLog.objects.all()
.exclude(resourceclassid=settings.SYSTEM_SETTINGS_RESOURCE_MODEL_ID)
.order_by("-timestamp")[:100]
)
edited_ids = list({edit.resourceinstanceid for edit in recent_edits})
resources = Resource.objects.filter(resourceinstanceid__in=edited_ids)
edit_type_lookup = {
"create": _("Resource Created"),
"delete": _("Resource Deleted"),
"tile delete": _("Tile Deleted"),
"tile create": _("Tile Created"),
"tile edit": _("Tile Updated"),
"delete edit": _("Edit Deleted"),
"bulk_create": _("Resource Created"),
}
deleted_instances = [e.resourceinstanceid for e in recent_edits if e.edittype == "delete"]
graph_name_lookup = {str(r.resourceinstanceid): r.graph.name for r in resources}
for edit in recent_edits:
edit.friendly_edittype = edit_type_lookup[edit.edittype]
edit.resource_model_name = None
edit.deleted = edit.resourceinstanceid in deleted_instances
if edit.resourceinstanceid in graph_name_lookup:
edit.resource_model_name = graph_name_lookup[edit.resourceinstanceid]
edit.displayname = edit.note
if edit.resource_model_name is None:
try:
edit.resource_model_name = models.GraphModel.objects.get(pk=edit.resourceclassid).name
except Exception:
pass
context = self.get_context_data(main_script="views/edit-history", recent_edits=recent_edits)
context["nav"]["title"] = _("Recent Edits")
return render(request, "views/edit-history.htm", context)
else:
resource_instance = models.ResourceInstance.objects.get(pk=resourceid)
edits = models.EditLog.objects.filter(resourceinstanceid=resourceid)
permitted_edits = []
for edit in edits:
if edit.nodegroupid is not None:
nodegroup = models.NodeGroup.objects.get(pk=edit.nodegroupid)
if request.user.has_perm("read_nodegroup", edit.nodegroupid):
if edit.newvalue is not None:
self.getEditConceptValue(edit.newvalue)
if edit.oldvalue is not None:
self.getEditConceptValue(edit.oldvalue)
permitted_edits.append(edit)
else:
permitted_edits.append(edit)
resource = Resource.objects.get(pk=resourceid)
displayname = resource.displayname
displaydescription = resource.displaydescription
cards = Card.objects.filter(nodegroup__parentnodegroup=None, graph=resource_instance.graph)
graph_name = resource_instance.graph.name
if displayname == "undefined":
displayname = _("Unnamed Resource")
context = self.get_context_data(
main_script="views/resource/edit-log",
cards=JSONSerializer().serialize(cards),
resource_type=graph_name,
resource_description=displaydescription,
iconclass=resource_instance.graph.iconclass,
edits=JSONSerializer().serialize(permitted_edits),
resourceid=resourceid,
displayname=displayname,
)
context["nav"]["res_edit"] = True
context["nav"]["icon"] = resource_instance.graph.iconclass
context["nav"]["title"] = graph_name
return render(request, view_template, context)
return HttpResponseNotFound()
def get(self, request):
def get_last_login(date):
result = _("Not yet logged in")
try:
if date is not None:
result = datetime.strftime(date, '%Y-%m-%d %H:%M')
except TypeError as e:
print e
return result
identities = []
for group in Group.objects.all():
users = group.user_set.all()
if len(users) > 0:
groupUsers = [{'id': user.id, 'first_name': user.first_name, 'last_name': user.last_name, 'email': user.email, 'last_login': get_last_login(user.last_login), 'username': user.username, 'groups': [g.id for g in user.groups.all()], 'group_names': ', '.join([g.name for g in user.groups.all()]) } for user in users]
identities.append({'name': group.name, 'type': 'group', 'id': group.pk, 'users': groupUsers, 'default_permissions': group.permissions.all()})
for user in User.objects.filter():
groups = []
group_ids = []
default_perms = []
for group in user.groups.all():
groups.append(group.name)
group_ids.append(group.id)
default_perms = default_perms + list(group.permissions.all())
identities.append({'name': user.email or user.username, 'groups': ', '.join(groups), 'type': 'user', 'id': user.pk, 'default_permissions': set(default_perms), 'is_superuser':user.is_superuser, 'group_ids': group_ids, 'first_name': user.first_name, 'last_name': user.last_name, 'email': user.email})
map_layers = models.MapLayer.objects.all()
map_markers = models.MapMarker.objects.all()
map_sources = models.MapSource.objects.all()
geocoding_providers = models.Geocoder.objects.all()
mobile_survey_models = models.MobileSurveyModel.objects.order_by('name')
mobile_surveys, resources = self.get_survey_resources(mobile_survey_models)
for mobile_survey in mobile_surveys:
try:
mobile_survey['datadownloadconfig'] = json.loads(mobile_survey['datadownloadconfig'])
except TypeError:
pass
multipart = mobile_survey['bounds']
singlepart = GeoUtils().convert_multipart_to_singlepart(multipart)
mobile_survey['bounds'] = singlepart
serializer = JSONSerializer()
context = self.get_context_data(
map_layers=map_layers,
map_markers=map_markers,
map_sources=map_sources,
geocoding_providers=geocoding_providers,
mobile_surveys=serializer.serialize(mobile_surveys, sort_keys=False),
identities=serializer.serialize(identities, sort_keys=False),
resources=serializer.serialize(resources, sort_keys=False),
resource_download_limit=settings.MOBILE_DOWNLOAD_RESOURCE_LIMIT,
main_script='views/mobile-survey-manager',
)
context['nav']['title'] = _('Mobile Survey Manager')
context['nav']['icon'] = 'fa-server'
context['nav']['help'] = {
'title': _('Mobile Survey Manager'),
'template': 'mobile-survey-manager-help',
}
return render(request, 'views/mobile-survey-manager.htm', context)
def toJSON(self):
from arches.app.utils.betterJSONSerializer import JSONSerializer, JSONDeserializer
return JSONSerializer().serialize(self)
def get(self, request, cardid):
try:
card = Card.objects.get(cardid=cardid)
self.graph = Graph.objects.get(graphid=card.graph_id)
except (Card.DoesNotExist):
# assume the cardid is actually a graph id
card = Card.objects.get(cardid=Graph.objects.get(graphid=cardid).get_root_card().cardid)
self.graph = Graph.objects.get(graphid=card.graph_id)
if self.graph.isresource is True:
return redirect("card_manager", graphid=cardid)
card.confirm_enabled_state(request.user, card.nodegroup)
for c in card.cards:
c.confirm_enabled_state(request.user, c.nodegroup)
datatypes = models.DDataType.objects.all()
widgets = models.Widget.objects.all()
geocoding_providers = models.Geocoder.objects.all()
map_layers = models.MapLayer.objects.all()
map_markers = models.MapMarker.objects.all()
map_sources = models.MapSource.objects.all()
resource_graphs = (
Graph.objects.exclude(pk=card.graph_id)
.exclude(pk=settings.SYSTEM_SETTINGS_RESOURCE_MODEL_ID)
.exclude(isresource=False)
.exclude(isactive=False)
)
lang = request.GET.get("lang", settings.LANGUAGE_CODE)
concept_collections = Concept().concept_tree(mode="collections", lang=lang)
ontology_properties = []
card_root_node = models.Node.objects.get(nodeid=card.nodegroup_id)
for item in self.graph.get_valid_ontology_classes(nodeid=card.nodegroup_id):
if card_root_node.ontologyclass in item["ontology_classes"]:
ontology_properties.append(item["ontology_property"])
ontology_properties = sorted(ontology_properties, key=lambda item: item)
context = self.get_context_data(
main_script="views/graph/card-configuration-manager",
graph_id=self.graph.graphid,
card=JSONSerializer().serialize(card),
datatypes_json=JSONSerializer().serialize(datatypes),
geocoding_providers=geocoding_providers,
datatypes=datatypes,
widgets=widgets,
widgets_json=JSONSerializer().serialize(widgets),
map_layers=map_layers,
map_markers=map_markers,
map_sources=map_sources,
resource_graphs=resource_graphs,
concept_collections=concept_collections,
ontology_properties=JSONSerializer().serialize(ontology_properties),
)
context["graphid"] = self.graph.graphid
context["graph"] = JSONSerializer().serializeToPython(self.graph)
context["graph_json"] = json.dumps(context["graph"])
context["root_node"] = self.graph.node_set.get(istopnode=True)
context["nav"]["title"] = self.graph.name
context["nav"]["menu"] = True
context["nav"]["help"] = {"title": _("Configuring Cards and Widgets"), "template": "card-designer-help"}
return render(request, "views/graph/card-configuration-manager.htm", context)
def write_to_file(self, data, data_dir): data['metadata'] = self.export_metadata with open(os.path.join(data_dir), 'w') as export_json: json.dump(JSONDeserializer().deserialize(JSONSerializer().serialize(data)), export_json, sort_keys=True, indent=4)
def get(self, request):
se = SearchEngineFactory().create()
datatype_factory = DataTypeFactory()
datatypes = models.DDataType.objects.all()
widgets = models.Widget.objects.all()
map_layers = models.MapLayer.objects.all()
map_markers = models.MapMarker.objects.all()
map_sources = models.MapSource.objects.all()
icons = models.Icon.objects.order_by('name')
context = self.get_context_data(
icons=JSONSerializer().serialize(icons),
datatypes=datatypes,
widgets=widgets,
map_layers=map_layers,
map_markers=map_markers,
map_sources=map_sources,
datatypes_json=JSONSerializer().serialize(datatypes),
main_script='views/map-layer-manager',
)
def get_resource_bounds(node):
query = Query(se, start=0, limit=0)
search_query = Bool()
query.add_query(search_query)
query.add_aggregation(
GeoBoundsAgg(field='points.point', name='bounds'))
query.add_query(
Term(field='graph_id', term=str(node.graph.graphid)))
results = query.search(index='resources')
bounds = results['aggregations']['bounds'][
'bounds'] if 'bounds' in results['aggregations'][
'bounds'] else None
return bounds
context['geom_nodes_json'] = JSONSerializer().serialize(
context['geom_nodes'])
resource_layers = []
resource_sources = []
permissions = {}
for node in context['geom_nodes']:
datatype = datatype_factory.get_instance(node.datatype)
map_layer = datatype.get_map_layer(node=node, preview=True)
if map_layer is not None:
count = models.TileModel.objects.filter(
data__has_key=str(node.nodeid)).count()
if count > 0:
map_layer['bounds'] = get_resource_bounds(node)
else:
map_layer['bounds'] = None
resource_layers.append(map_layer)
map_source = datatype.get_map_source(node=node, preview=True)
if map_source is not None:
resource_sources.append(map_source)
permissions[str(node.pk)] = {
"users":
sorted([
user.email
or user.username for user in get_users_for_object(
'read_nodegroup', node.nodegroup)
]),
"groups":
sorted([
group.name for group in get_groups_for_object(
'read_nodegroup', node.nodegroup)
])
}
context['resource_map_layers_json'] = JSONSerializer().serialize(
resource_layers)
context['resource_map_sources_json'] = JSONSerializer().serialize(
resource_sources)
context['node_permissions'] = JSONSerializer().serialize(permissions)
context['nav']['title'] = _('Map Layer Manager')
context['nav']['icon'] = 'fa-server'
context['nav']['help'] = {
'title': _('Map Layer Manager'),
'template': 'map-manager-help',
}
return render(request, 'views/map-layer-manager.htm', context)
def get(self, request, resourceid=None):
lang = request.GET.get("lang", settings.LANGUAGE_CODE)
resource = Resource.objects.get(pk=resourceid)
displayname = resource.displayname
resource_models = (
models.GraphModel.objects.filter(isresource=True).exclude(isactive=False).exclude(pk=settings.SYSTEM_SETTINGS_RESOURCE_MODEL_ID)
)
related_resource_summary = [{"graphid": str(g.graphid), "name": g.name, "resources": []} for g in resource_models]
related_resources_search_results = resource.get_related_resources(lang=lang, start=0, limit=1000)
related_resources = related_resources_search_results["related_resources"]
relationships = related_resources_search_results["resource_relationships"]
resource_relationship_type_values = {i["id"]: i["text"] for i in get_resource_relationship_types()["values"]}
for rr in related_resources:
for summary in related_resource_summary:
if rr["graph_id"] == summary["graphid"]:
relationship_summary = []
for relationship in relationships:
if rr["resourceinstanceid"] in (relationship["resourceinstanceidto"], relationship["resourceinstanceidfrom"]):
rr_type = (
resource_relationship_type_values[relationship["relationshiptype"]]
if relationship["relationshiptype"] in resource_relationship_type_values
else relationship["relationshiptype"]
)
relationship_summary.append(rr_type)
summary["resources"].append(
{"instance_id": rr["resourceinstanceid"], "displayname": rr["displayname"], "relationships": relationship_summary}
)
tiles = Tile.objects.filter(resourceinstance=resource).order_by("sortorder")
permitted_tiles = []
perm = "read_nodegroup"
for tile in tiles:
if request.user.has_perm(perm, tile.nodegroup):
tile.filter_by_perm(request.user, perm)
permitted_tiles.append(tile)
if request.GET.get("json", False) and request.GET.get("exclude_graph", False):
return JSONResponse(
{
"tiles": permitted_tiles,
"related_resources": related_resource_summary,
"displayname": displayname,
"resourceid": resourceid,
}
)
datatypes = models.DDataType.objects.all()
graph = Graph.objects.get(graphid=resource.graph_id)
cards = Card.objects.filter(graph_id=resource.graph_id).order_by("sortorder")
permitted_cards = []
for card in cards:
if request.user.has_perm(perm, card.nodegroup):
card.filter_by_perm(request.user, perm)
permitted_cards.append(card)
cardwidgets = [
widget for widgets in [card.cardxnodexwidget_set.order_by("sortorder").all() for card in permitted_cards] for widget in widgets
]
if request.GET.get("json", False) and not request.GET.get("exclude_graph", False):
return JSONResponse(
{
"datatypes": datatypes,
"cards": permitted_cards,
"tiles": permitted_tiles,
"graph": graph,
"related_resources": related_resource_summary,
"displayname": displayname,
"resourceid": resourceid,
"cardwidgets": cardwidgets,
}
)
widgets = models.Widget.objects.all()
templates = models.ReportTemplate.objects.all()
card_components = models.CardComponent.objects.all()
try:
map_layers = models.MapLayer.objects.all()
map_markers = models.MapMarker.objects.all()
map_sources = models.MapSource.objects.all()
geocoding_providers = models.Geocoder.objects.all()
except AttributeError:
raise Http404(_("No active report template is available for this resource."))
context = self.get_context_data(
main_script="views/resource/report",
report_templates=templates,
templates_json=JSONSerializer().serialize(templates, sort_keys=False, exclude=["name", "description"]),
card_components=card_components,
card_components_json=JSONSerializer().serialize(card_components),
cardwidgets=JSONSerializer().serialize(cardwidgets),
tiles=JSONSerializer().serialize(permitted_tiles, sort_keys=False),
cards=JSONSerializer().serialize(
permitted_cards,
sort_keys=False,
exclude=["is_editable", "description", "instructions", "helpenabled", "helptext", "helptitle", "ontologyproperty"],
),
datatypes_json=JSONSerializer().serialize(
datatypes, exclude=["modulename", "issearchable", "configcomponent", "configname", "iconclass"]
),
geocoding_providers=geocoding_providers,
related_resources=JSONSerializer().serialize(related_resource_summary, sort_keys=False),
widgets=widgets,
map_layers=map_layers,
map_markers=map_markers,
map_sources=map_sources,
graph_id=graph.graphid,
graph_name=graph.name,
graph_json=JSONSerializer().serialize(
graph,
sort_keys=False,
exclude=[
"functions",
"relatable_resource_model_ids",
"domain_connections",
"edges",
"is_editable",
"description",
"iconclass",
"subtitle",
"author",
],
),
resourceid=resourceid,
displayname=displayname,
)
if graph.iconclass:
context["nav"]["icon"] = graph.iconclass
context["nav"]["title"] = graph.name
context["nav"]["res_edit"] = True
context["nav"]["print"] = True
context["nav"]["print"] = True
return render(request, "views/resource/report.htm", context)
def to_json(self):
return JSONSerializer().serialize(self)
def get_e55_domain(self, entitytypeid):
"""
For a given entitytypeid creates a dictionary representing that entitytypeid's concept graph (member pathway) formatted to support
select2 dropdowns
"""
cursor = connection.cursor()
entitytype = models.EntityTypes.objects.get(pk=entitytypeid)
sql = """
WITH RECURSIVE children AS (
SELECT d.conceptidfrom, d.conceptidto, c2.value, c2.valueid as valueid, c.value as valueto, c.valueid as valueidto, c.valuetype as vtype, 1 AS depth, array[d.conceptidto] AS conceptpath, array[c.valueid] AS idpath ---|NonRecursive Part
FROM concepts.relations d
JOIN concepts.values c ON(c.conceptid = d.conceptidto)
JOIN concepts.values c2 ON(c2.conceptid = d.conceptidfrom)
WHERE d.conceptidfrom = '{0}'
and c2.valuetype = 'prefLabel'
and c.valuetype in ('prefLabel', 'sortorder', 'collector')
and (d.relationtype = 'member' or d.relationtype = 'hasTopConcept')
UNION
SELECT d.conceptidfrom, d.conceptidto, v2.value, v2.valueid as valueid, v.value as valueto, v.valueid as valueidto, v.valuetype as vtype, depth+1, (conceptpath || d.conceptidto), (idpath || v.valueid) ---|RecursivePart
FROM concepts.relations d
JOIN children b ON(b.conceptidto = d.conceptidfrom)
JOIN concepts.values v ON(v.conceptid = d.conceptidto)
JOIN concepts.values v2 ON(v2.conceptid = d.conceptidfrom)
WHERE v2.valuetype = 'prefLabel'
and v.valuetype in ('prefLabel','sortorder', 'collector')
and (d.relationtype = 'member' or d.relationtype = 'hasTopConcept')
) SELECT conceptidfrom::text, conceptidto::text, value, valueid::text, valueto, valueidto::text, depth, idpath::text, conceptpath::text, vtype FROM children ORDER BY depth, conceptpath;
""".format(entitytype.conceptid_id)
column_names = [
'conceptidfrom', 'conceptidto', 'value', 'valueid', 'valueto',
'valueidto', 'depth', 'idpath', 'conceptpath', 'vtype'
]
cursor.execute(sql)
rows = cursor.fetchall()
class Val(object):
def __init__(self, conceptid):
self.text = ''
self.conceptid = conceptid
self.id = ''
self.sortorder = ''
self.collector = ''
self.children = []
self.entitytypeid = entitytypeid
result = Val(entitytype.conceptid_id)
def _findNarrower(val, path, rec):
for conceptid in path:
childids = [child.conceptid for child in val.children]
if conceptid not in childids:
new_val = Val(rec['conceptidto'])
if rec['vtype'] == 'sortorder':
new_val.sortorder = rec['valueto']
elif rec['vtype'] == 'prefLabel':
new_val.text = rec['valueto']
new_val.id = rec['valueidto']
elif rec['vtype'] == 'collector':
new_val.collector = 'collector'
val.children.append(new_val)
else:
for child in val.children:
if conceptid == child.conceptid:
if conceptid == path[-1]:
if rec['vtype'] == 'sortorder':
child.sortorder = rec['valueto']
elif rec['vtype'] == 'prefLabel':
child.text = rec['valueto']
child.id = rec['valueidto']
elif rec['vtype'] == 'collector':
child.collector = 'collector'
path.pop(0)
_findNarrower(child, path, rec)
val.children.sort(key=lambda x: (x.sortorder, x.text))
for row in rows:
rec = dict(zip(column_names, row))
path = rec['conceptpath'][1:-1].split(',')
_findNarrower(result, path, rec)
return JSONSerializer().serializeToPython(result)['children']
def __repr__(self):
return ('%s: %s of type %s with value %s') % (self.__class__, self.entityid, self.entitytypeid, JSONSerializer().serialize(self.value))
def get(self, request, resourceid):
try:
resource_instance = Resource.objects.get(pk=resourceid)
graph = resource_instance.graph
except Resource.DoesNotExist:
graph = models.GraphModel.objects.get(pk=resourceid)
resourceid = None
resource_instance = None
pass
nodes = graph.node_set.all()
nodegroups = []
editable_nodegroups = []
for node in nodes:
if node.is_collector:
added = False
if request.user.has_perm("write_nodegroup", node.nodegroup):
editable_nodegroups.append(node.nodegroup)
nodegroups.append(node.nodegroup)
added = True
if not added and request.user.has_perm("read_nodegroup",
node.nodegroup):
nodegroups.append(node.nodegroup)
nodes = nodes.filter(nodegroup__in=nodegroups)
cards = graph.cardmodel_set.order_by("sortorder").filter(
nodegroup__in=nodegroups).prefetch_related("cardxnodexwidget_set")
cardwidgets = [
widget for widgets in [
card.cardxnodexwidget_set.order_by("sortorder").all()
for card in cards
] for widget in widgets
]
datatypes = models.DDataType.objects.all()
user_is_reviewer = request.user.groups.filter(
name="Resource Reviewer").exists()
widgets = models.Widget.objects.all()
card_components = models.CardComponent.objects.all()
if resource_instance is None:
tiles = []
displayname = _("New Resource")
else:
displayname = resource_instance.displayname
if displayname == "undefined":
displayname = _("Unnamed Resource")
if str(resource_instance.graph_id
) == settings.SYSTEM_SETTINGS_RESOURCE_MODEL_ID:
displayname = _("System Settings")
tiles = resource_instance.tilemodel_set.order_by(
"sortorder").filter(nodegroup__in=nodegroups)
provisionaltiles = []
for tile in tiles:
append_tile = True
isfullyprovisional = False
if tile.provisionaledits is not None:
if len(list(tile.provisionaledits.keys())) > 0:
if len(tile.data) == 0:
isfullyprovisional = True
if user_is_reviewer is False:
if str(request.user.id) in tile.provisionaledits:
tile.provisionaledits = {
str(request.user.id):
tile.provisionaledits[str(request.user.id)]
}
tile.data = tile.provisionaledits[str(
request.user.id)]["value"]
else:
if isfullyprovisional is True:
# if the tile IS fully provisional and the current user is not the owner,
# we don't send that tile back to the client.
append_tile = False
else:
# if the tile has authoritaive data and the current user is not the owner,
# we don't send the provisional data of other users back to the client.
tile.provisionaledits = None
if append_tile is True:
provisionaltiles.append(tile)
tiles = provisionaltiles
cards = JSONSerializer().serializeToPython(cards)
editable_nodegroup_ids = [
str(nodegroup.pk) for nodegroup in editable_nodegroups
]
for card in cards:
card["is_writable"] = False
if str(card["nodegroup_id"]) in editable_nodegroup_ids:
card["is_writable"] = True
context = {
"resourceid": resourceid,
"displayname": displayname,
"tiles": tiles,
"cards": cards,
"nodegroups": nodegroups,
"nodes": nodes,
"cardwidgets": cardwidgets,
"datatypes": datatypes,
"userisreviewer": user_is_reviewer,
"widgets": widgets,
"card_components": card_components,
}
return JSONResponse(context, indent=4)
def get(
self,
request,
graphid=None,
resourceid=None,
view_template="views/resource/editor.htm",
main_script="views/resource/editor",
nav_menu=True,
):
if self.action == "copy":
return self.copy(request, resourceid)
resource_instance_exists = False
try:
resource_instance = Resource.objects.get(pk=resourceid)
resource_instance_exists = True
graphid = resource_instance.graph_id
except ObjectDoesNotExist:
resource_instance = Resource()
resource_instance.resourceinstanceid = resourceid
resource_instance.graph_id = graphid
if resourceid is not None:
resource_graphs = (models.GraphModel.objects.exclude(
pk=settings.SYSTEM_SETTINGS_RESOURCE_MODEL_ID).exclude(
isresource=False).exclude(isactive=False))
graph = Graph.objects.get(graphid=graphid)
relationship_type_values = get_resource_relationship_types()
datatypes = models.DDataType.objects.all()
widgets = models.Widget.objects.all()
map_layers = models.MapLayer.objects.all()
map_markers = models.MapMarker.objects.all()
map_sources = models.MapSource.objects.all()
geocoding_providers = models.Geocoder.objects.all()
required_widgets = []
widget_datatypes = [v.datatype for k, v in graph.nodes.items()]
widgets = widgets.filter(datatype__in=widget_datatypes)
if resource_instance_exists == True:
displayname = Resource.objects.get(pk=resourceid).displayname
if displayname == "undefined":
displayname = "Unnamed Resource"
else:
displayname = "Unnamed Resource"
date_nodes = models.Node.objects.filter(datatype="date",
graph__isresource=True,
graph__isactive=True)
searchable_datatypes = [
d.pk
for d in models.DDataType.objects.filter(issearchable=True)
]
searchable_nodes = models.Node.objects.filter(
graph__isresource=True,
graph__isactive=True,
datatype__in=searchable_datatypes,
issearchable=True)
resource_cards = models.CardModel.objects.filter(
graph__isresource=True, graph__isactive=True)
context = self.get_context_data(
main_script=main_script,
resource_type=graph.name,
relationship_types=relationship_type_values,
iconclass=graph.iconclass,
datatypes_json=JSONSerializer().serialize(
datatypes,
exclude=["iconclass", "modulename", "classname"]),
datatypes=datatypes,
widgets=widgets,
date_nodes=date_nodes,
map_layers=map_layers,
map_markers=map_markers,
map_sources=map_sources,
geocoding_providers=geocoding_providers,
widgets_json=JSONSerializer().serialize(widgets),
resourceid=resourceid,
resource_graphs=resource_graphs,
graph_json=JSONSerializer().serialize(
graph,
exclude=[
"iconclass",
"functions",
"functions_x_graphs",
"name",
"description",
"deploymentfile",
"author",
"deploymentdate",
"version",
"isresource",
"isactive",
"iconclass",
"ontology",
],
),
displayname=displayname,
resource_cards=JSONSerializer().serialize(resource_cards,
exclude=[
"description",
"instructions",
"active",
"isvisible"
]),
searchable_nodes=JSONSerializer().serialize(
searchable_nodes,
exclude=[
"description", "ontologyclass", "isrequired",
"issearchable", "istopnode"
]),
saved_searches=JSONSerializer().serialize(
settings.SAVED_SEARCHES),
resource_instance_exists=resource_instance_exists,
user_is_reviewer=json.dumps(
request.user.groups.filter(
name="Resource Reviewer").exists()),
userid=request.user.id,
)
if graph.iconclass:
context["nav"]["icon"] = graph.iconclass
context["nav"]["title"] = graph.name
context["nav"]["menu"] = nav_menu
if resourceid == settings.RESOURCE_INSTANCE_ID:
context["nav"]["help"] = (_("Managing System Settings"),
"help/base-help.htm")
context["help"] = "system-settings-help"
else:
context["nav"]["help"] = (_("Using the Resource Editor"),
"help/base-help.htm")
context["help"] = "resource-editor-help"
return render(request, view_template, context)
return HttpResponseNotFound()
def get(self, request, graphid):
self.graph = Graph.objects.get(graphid=graphid)
ontologies = models.Ontology.objects.filter(parentontology=None)
ontology_classes = models.OntologyClass.objects.values("source", "ontology_id")
datatypes = models.DDataType.objects.all()
datatypes_json = JSONSerializer().serialize(datatypes, exclude=["modulename", "isgeometric"])
branch_graphs = Graph.objects.exclude(pk=graphid).exclude(isresource=True)
applied_functions = JSONSerializer().serialize(models.FunctionXGraph.objects.filter(graph=self.graph))
cards = self.graph.cardmodel_set.order_by("sortorder").prefetch_related("cardxnodexwidget_set")
constraints = []
for card in cards:
if models.ConstraintModel.objects.filter(card=card).count() > 0:
constraints += models.ConstraintModel.objects.filter(card=card)
cardwidgets = [
widget for widgets in [card.cardxnodexwidget_set.order_by("sortorder").all() for card in cards] for widget in widgets
]
widgets = models.Widget.objects.all()
nodegroups = cards.values_list("nodegroup_id", flat=True)
if settings.OVERRIDE_RESOURCE_MODEL_LOCK:
restricted_nodegroups = []
else:
restricted_nodegroups = (
models.TileModel.objects.filter(nodegroup__in=nodegroups).values_list("nodegroup_id", flat=True).distinct()
)
card_components = models.CardComponent.objects.all()
map_layers = models.MapLayer.objects.all()
map_markers = models.MapMarker.objects.all()
map_sources = models.MapSource.objects.all()
templates = models.ReportTemplate.objects.all()
card_components = models.CardComponent.objects.all()
geocoding_providers = models.Geocoder.objects.all()
if self.graph.ontology is not None:
branch_graphs = branch_graphs.filter(ontology=self.graph.ontology)
context = self.get_context_data(
main_script="views/graph-designer",
datatypes_json=datatypes_json,
datatypes=datatypes,
ontology_namespaces=self.get_ontology_namespaces(),
branches=JSONSerializer().serialize(
branch_graphs, exclude=["cards", "domain_connections", "functions", "cards", "deploymentfile", "deploymentdate"]
),
branch_list={"title": _("Branch Library"), "search_placeholder": _("Find a graph branch")},
widgets=widgets,
widgets_json=JSONSerializer().serialize(widgets),
card_components=card_components,
card_components_json=JSONSerializer().serialize(card_components),
cards=JSONSerializer().serialize(cards),
cardwidgets=JSONSerializer().serialize(cardwidgets),
map_layers=map_layers,
map_markers=map_markers,
map_sources=map_sources,
applied_functions=applied_functions,
geocoding_providers=geocoding_providers,
report_templates=templates,
restricted_nodegroups=[str(nodegroup) for nodegroup in restricted_nodegroups],
)
context["ontologies"] = JSONSerializer().serialize(ontologies, exclude=["version", "path"])
context["ontology_classes"] = JSONSerializer().serialize(ontology_classes)
context["graph"] = JSONSerializer().serialize(
self.graph, exclude=["functions", "cards", "deploymentfile", "deploymentdate", "_nodegroups_to_delete", "_functions"]
)
context["graph_models"] = models.GraphModel.objects.all().exclude(graphid=settings.SYSTEM_SETTINGS_RESOURCE_MODEL_ID)
context["graphs"] = JSONSerializer().serialize(context["graph_models"], exclude=["functions"])
context["nav"]["title"] = self.graph.name
context["nav"]["menu"] = True
help_title = _("Designing a Resource Model")
if not self.graph.isresource:
help_title = _("Designing a Branch")
context["nav"]["help"] = {"title": help_title, "template": "graph-tab-help"}
context["constraints"] = JSONSerializer().serialize(constraints)
return render(request, "views/graph-designer.htm", context)
def import_business_data(self, business_data, mapping=None):
reporter = ResourceImportReporter(business_data)
try:
if mapping == None or mapping == '':
self.import_business_data_without_mapping(
business_data, reporter)
else:
blanktilecache = {}
target_nodegroup_cardinalities = {}
for nodegroup in JSONSerializer().serializeToPython(
NodeGroup.objects.all()):
target_nodegroup_cardinalities[
nodegroup['nodegroupid']] = nodegroup['cardinality']
for resource in business_data['resources']:
reporter.update_tiles(len(resource['tiles']))
parenttileids = []
populated_tiles = []
resourceinstanceid = uuid.uuid4()
populated_nodegroups = []
target_resource_model = mapping['resource_model_id']
for tile in resource['tiles']:
if tile['data'] != {}:
def get_tiles(tile):
if tile['parenttile_id'] != None:
if tile['parenttile_id'] not in parenttileids:
parenttileids.append(
tile['parenttile_id'])
ret = []
for sibling_tile in resource['tiles']:
if sibling_tile[
'parenttile_id'] == tile[
'parenttile_id']:
ret.append(sibling_tile)
else:
ret = None
else:
ret = [tile]
#deletes nodes that don't have values
if ret is not None:
for tile in ret:
for key, value in tile[
'data'].iteritems():
if value == "":
del tile['data'][key]
return ret
tiles = get_tiles(tile)
if tiles is not None:
mapped_tiles = self.replace_source_nodeid(
tiles, mapping)
blank_tile = self.get_blank_tile(
tiles, blanktilecache, tiles,
resourceinstanceid)
def populate_tile(sourcetilegroup,
target_tile):
need_new_tile = False
target_tile_cardinality = target_nodegroup_cardinalities[
str(target_tile.nodegroup_id)]
if str(target_tile.nodegroup_id
) not in populated_nodegroups:
if target_tile.data != {}:
for source_tile in sourcetilegroup:
for tiledata in source_tile[
'data']:
for nodeid in tiledata.keys(
):
if nodeid in target_tile.data:
if target_tile.data[
nodeid] == None:
target_tile.data[
nodeid] = tiledata[
nodeid]
for key in tiledata.keys(
):
if key == nodeid:
del tiledata[
nodeid]
for tiledata in source_tile[
'data']:
if tiledata == {}:
source_tile[
'data'].remove(
tiledata)
elif target_tile.tiles != None:
populated_child_nodegroups = []
for nodegroupid, childtile in target_tile.tiles.iteritems(
):
childtile_empty = True
child_tile_cardinality = target_nodegroup_cardinalities[
str(childtile[0].
nodegroup_id)]
if str(
childtile[0].
nodegroup_id
) not in populated_child_nodegroups:
prototype_tile = childtile.pop(
)
prototype_tile.tileid = None
for source_tile in sourcetilegroup:
if prototype_tile.nodegroup_id not in populated_child_nodegroups:
prototype_tile_copy = deepcopy(
prototype_tile)
for data in source_tile[
'data']:
for nodeid in data.keys(
):
if nodeid in prototype_tile.data.keys(
):
if prototype_tile.data[
nodeid] == None:
prototype_tile_copy.data[
nodeid] = data[
nodeid]
for key in data.keys(
):
if key == nodeid:
del data[
nodeid]
if child_tile_cardinality == '1':
populated_child_nodegroups.append(
prototype_tile
.
nodegroup_id
)
for data in source_tile[
'data']:
if data == {}:
source_tile[
'data'].remove(
data
)
for key in prototype_tile_copy.data.keys(
):
if prototype_tile_copy.data[
key] != None:
childtile_empty = False
if prototype_tile_copy.data == {} or childtile_empty:
prototype_tile_copy = None
if prototype_tile_copy is not None:
childtile.append(
prototype_tile_copy
)
else:
break
if target_tile.data:
if target_tile.data == {} and target_tile.tiles == {}:
target_tile = None
populated_tiles.append(target_tile)
for source_tile in sourcetilegroup:
if source_tile['data']:
for data in source_tile[
'data']:
if len(data) > 0:
need_new_tile = True
if need_new_tile:
if self.get_blank_tile(
sourcetilegroup,
blanktilecache, tiles,
resourceinstanceid
) != None:
populate_tile(
sourcetilegroup,
self.get_blank_tile(
sourcetilegroup,
blanktilecache, tiles,
resourceinstanceid))
if target_tile_cardinality == '1':
populated_nodegroups.append(
str(target_tile.nodegroup_id))
else:
target_tile = None
if blank_tile != None:
populate_tile(mapped_tiles, blank_tile)
newresourceinstance = ResourceInstance.objects.create(
resourceinstanceid=resourceinstanceid,
graph_id=target_resource_model,
legacyid=None)
if len(
ResourceInstance.objects.filter(
resourceinstanceid=resourceinstanceid)) == 1:
reporter.update_resources_saved()
# print JSONSerializer().serialize(populated_tiles)
for populated_tile in populated_tiles:
populated_tile.resourceinstance = newresourceinstance
saved_tile = populated_tile.save()
# tile_saved = count parent tile and count of tile array if tile array != {}
# reporter.update_tiles_saved(tile_saved)
except (KeyError, TypeError) as e:
print e
finally:
reporter.report_results()
def post(self, request, graphid=None):
ret = {}
try:
if self.action == "import_graph":
graph_file = request.FILES.get("importedGraph").read()
graphs = JSONDeserializer().deserialize(graph_file)["graph"]
ret = GraphImporter.import_graph(graphs)
else:
if graphid is not None:
graph = Graph.objects.get(graphid=graphid)
data = JSONDeserializer().deserialize(request.body)
if self.action == "new_graph":
isresource = data["isresource"] if "isresource" in data else False
name = _("New Resource Model") if isresource else _("New Branch")
author = request.user.first_name + " " + request.user.last_name
ret = Graph.new(name=name, is_resource=isresource, author=author)
elif self.action == "update_node":
updated_values = graph.update_node(data)
graph.save()
ret = JSONSerializer().serializeToPython(graph)
ret["updated_values"] = updated_values
ret["default_card_name"] = graph.temp_node_name
elif self.action == "update_node_layer":
nodeid = uuid.UUID(str(data.get("nodeid")))
node = graph.nodes[nodeid]
node.config = data["config"]
ret = graph
node.save()
elif self.action == "append_branch":
ret = graph.append_branch(data["property"], nodeid=data["nodeid"], graphid=data["graphid"])
ret = ret.serialize()
ret["nodegroups"] = graph.get_nodegroups()
ret["cards"] = graph.get_cards()
ret["widgets"] = graph.get_widgets()
graph.save()
elif self.action == "append_node":
ret = graph.append_node(nodeid=data["nodeid"])
graph.save()
elif self.action == "move_node":
ret = graph.move_node(data["nodeid"], data["property"], data["newparentnodeid"])
graph.save()
elif self.action == "export_branch":
clone_data = graph.copy(root=data)
clone_data["copy"].save()
ret = {"success": True, "graphid": clone_data["copy"].pk}
elif self.action == "clone_graph":
clone_data = graph.copy()
ret = clone_data["copy"]
ret.save()
ret.copy_functions(graph, [clone_data["nodes"], clone_data["nodegroups"]])
elif self.action == "reorder_nodes":
json = request.body
if json is not None:
data = JSONDeserializer().deserialize(json)
if "nodes" in data and len(data["nodes"]) > 0:
sortorder = 0
with transaction.atomic():
for node in data["nodes"]:
no = models.Node.objects.get(pk=node["nodeid"])
no.sortorder = sortorder
no.save()
sortorder = sortorder + 1
ret = data
return JSONResponse(ret)
except GraphValidationError as e:
return JSONErrorResponse(e.title, e.message, {"status": "Failed"})
except ModelInactiveError as e:
return JSONErrorResponse(e.title, e.message)
except RequestError as e:
return JSONErrorResponse(
_("Elasticsearch indexing error"),
_(
"""If you want to change the datatype of an existing node.
Delete and then re-create the node, or export the branch then edit the datatype and re-import the branch."""
),
)
def report(request, resourceid):
logging.warning("Viewing Report. User=%s", request.user)
# Redirect non-logged-in users to the login screen
if request.user.is_anonymous:
redirect('/auth')
lang = request.GET.get('lang', request.LANGUAGE_CODE)
page = request.GET.get('page', 1)
se = SearchEngineFactory().create()
report_info = se.search(index='resource', id=resourceid)
primaryname = se.search(index='entity', id=resourceid)
report_info['source'] = report_info['_source']
report_info['type'] = report_info['_type']
report_info['source']['graph'] = report_info['source']['graph']
if primaryname['_source']['primaryname']:
report_info['source']['primaryname'] = primaryname['_source'][
'primaryname']
del report_info['_source']
del report_info['_type']
geometry = JSONSerializer().serialize(report_info['source']['geometry'])
GeoCrypt = Crypter(settings.ENCODING_KEY)
iv, encrypted = GeoCrypt.encrypt(geometry, GeoCrypt.KEY)
ciphertext = binascii.b2a_base64(encrypted).rstrip()
if geometry != 'null':
result = {
'editor':
'true' if 'edit' in request.user.user_groups else 'false',
'key': GeoCrypt.KEY,
'iv': iv,
'ciphertext': ciphertext
}
else:
result = None
if report_info[
'type'] == "INFORMATION_RESOURCE.E73": # These clauses produce subtypes for Imagery, Shared Dataset and Cartography Info Resources, with the aim of producing different Report pages for each of these Resource Types
report_info['subtype'] = ''
report_info['filepath'] = ''
report_info['has_image'] = ''
if 'ACQUISITION_ASSIGNMENT_E17' in report_info['source'][
'graph'] or 'CATALOGUE_ID_E42' in report_info['source'][
'graph']:
report_info['subtype'] = 'Imagery'
if 'RESOURCE_CREATION_EVENT_E65' in report_info['source']['graph']:
for value in report_info['source']['graph'][
'RESOURCE_CREATION_EVENT_E65']:
if 'CREATOR_E39' in value:
for subvalue in value['CREATOR_E39']:
if 'IMAGERY_CREATOR_APPELLATION_E82' in subvalue:
report_info['subtype'] = 'Imagery'
elif 'SHARED_DATA_SOURCE_CREATOR_APPELLATION_E82' in subvalue:
report_info['subtype'] = 'Shared'
if 'SHARED_DATA_SOURCE_SHARER_E39' in value:
report_info['subtype'] = 'Shared'
if 'PUBLICATION_EVENT_E12' in report_info['source']['graph']:
for value in report_info['source']['graph'][
'PUBLICATION_EVENT_E12']:
if 'PUBLICATION_ASSIGNMENT_E17' in value:
for subvalue in value['PUBLICATION_ASSIGNMENT_E17']:
if 'TILE_SQUARE_APPELLATION_E44' in subvalue or 'TILE_SQUARE_DETAILS_E44' in subvalue:
report_info['subtype'] = 'Cartography'
elif 'IMAGERY_SOURCE_TYPE_E55' in subvalue:
report_info['subtype'] = 'Imagery'
if 'FILE_PATH_E62' in report_info['source']['graph']:
report_info['filepath'] = report_info['source']['graph'][
'FILE_PATH_E62'][0]
if 'THUMBNAIL_E62' in report_info['source']['graph']:
report_info['has_image'] = report_info['source']['graph'][
'THUMBNAIL_E62'][0]
if 'URL_E51' in report_info['source'][
'graph']: #If the resource has a URL, it verifies that it is an APAAME json string, in which case it retrieves the url of the photo from the json string and passes it to the report
flickr_feed = report_info['source']['graph']['URL_E51'][0][
'URL_E51__value'][:-1] if report_info['source']['graph'][
'URL_E51'][0]['URL_E51__value'].endswith(
'/') else report_info['source']['graph']['URL_E51'][0][
'URL_E51__value']
try:
response = urllib.urlopen(
'https://www.flickr.com/services/oembed?url=' +
flickr_feed + '&format=json')
data = response.read().decode("utf-8")
flickr_feed = json.loads(data)
report_info['filepath'], report_info[
'has_image'] = flickr_feed['url'], True
except:
pass
def get_evaluation_path(valueid):
value = models.Values.objects.get(pk=valueid)
concept_graph = Concept().get(id=value.conceptid_id,
include_subconcepts=False,
include_parentconcepts=True,
include_relatedconcepts=False,
up_depth_limit=None,
lang=lang)
paths = []
for path in concept_graph.get_paths(lang=lang)[0]:
if path['label'] != 'Arches' and path[
'label'] != 'Evaluation Criteria Type':
paths.append(path['label'])
return '; '.join(paths)
concept_label_ids = set()
uuid_regex = re.compile(
'[0-9a-fA-F]{8}-[0-9a-fA-F]{4}-[0-9a-fA-F]{4}-[0-9a-fA-F]{4}-[0-9a-fA-F]{12}'
)
# gather together all uuid's referenced in the resource graph
def crawl(items):
for item in items:
for key in item:
if isinstance(item[key], list):
crawl(item[key])
else:
if isinstance(item[key], basestring) and uuid_regex.match(
item[key]):
if key == 'EVALUATION_CRITERIA_TYPE_E55__value':
item[key] = get_evaluation_path(item[key])
concept_label_ids.add(item[key])
crawl([report_info['source']['graph']])
# get all the concept labels from the uuid's
concept_labels = se.search(index='concept_labels',
id=list(concept_label_ids))
# convert all labels to their localized prefLabel
temp = {}
if concept_labels != None:
for concept_label in concept_labels['docs']:
#temp[concept_label['_id']] = concept_label
if concept_label['found']:
# the resource graph already referenced the preferred label in the desired language
if concept_label['_source'][
'type'] == 'prefLabel' and concept_label['_source'][
'language'] == lang:
temp[concept_label['_id']] = concept_label['_source']
else:
# the resource graph referenced a non-preferred label or a label not in our target language, so we need to get the right label
temp[concept_label['_id']] = get_preflabel_from_conceptid(
concept_label['_source']['conceptid'], lang)
# replace the uuid's in the resource graph with their preferred and localized label
def crawl_again(items):
for item in items:
for key in item:
if isinstance(item[key], list):
crawl_again(item[key])
else:
if isinstance(item[key], basestring) and uuid_regex.match(
item[key]):
try:
item[key] = temp[item[key]]['value']
except:
pass
crawl_again([report_info['source']['graph']])
#return JSONResponse(report_info, indent=4)
related_resource_dict = {
'HERITAGE_RESOURCE': [],
'HERITAGE_RESOURCE_GROUP': [],
'HERITAGE_FEATURE': [],
'HERITAGE_COMPONENT': [],
'ACTIVITY': [],
'ACTOR': [],
'HISTORICAL_EVENT': [],
'INFORMATION_RESOURCE_IMAGE': [],
'INFORMATION_RESOURCE_DOCUMENT': [],
'INFORMATION_RESOURCE_MAP': [],
'INFORMATION_RESOURCE_SATELLITE': [],
'INFORMATION_RESOURCE_SHARED': []
}
related_resource_info = get_related_resources(resourceid, lang)
# parse the related entities into a dictionary by resource type
for related_resource in related_resource_info['related_resources']:
VirtualGlobeName = []
OtherImageryName = []
SharedDataset = []
VirtualGlobe = False
OtherImagery = True
information_resource_type = 'DOCUMENT'
related_res = {}
related_res['relationship'] = []
related_res['datefrom'] = []
related_res['dateto'] = []
related_res['notes'] = []
related_res['date'] = []
related_res['identifier'] = []
related_res['entitytypeid'] = related_resource['entitytypeid']
related_res['entityid'] = related_resource['entityid']
related_res['primaryname'] = related_resource['primaryname']
if related_resource['entitytypeid'] == 'HERITAGE_PLACE.E27':
print JSONResponse(related_resource, indent=4)
for entity in related_resource['child_entities']:
if entity['entitytypeid'] == 'NAME.E41':
related_res['identifier'].append(entity['value'])
elif related_resource['entitytypeid'] == 'HERITAGE_FEATURE.E24':
for entity in related_resource['domains']:
if entity['entitytypeid'] == 'INTERPRETATION_TYPE.I4':
related_res['identifier'].append(
get_preflabel_from_valueid(entity['value'],
lang)['value'])
elif related_resource['entitytypeid'] == 'HERITAGE_COMPONENT.B2':
for entity in related_resource['domains']:
if entity['entitytypeid'] == 'COMPONENT_TYPE.E55':
related_res['identifier'].append(
get_preflabel_from_valueid(entity['value'],
lang)['value'])
elif related_resource['entitytypeid'] == 'ACTIVITY.E7':
for entity in related_resource['domains']:
if entity['entitytypeid'] == 'ACTIVITY_TYPE.E55':
related_res['relationship'].append(
get_preflabel_from_valueid(entity['value'],
lang)['value'])
elif related_resource['entitytypeid'] == 'ACTOR.E39':
for entity in related_resource['domains']:
if entity['entitytypeid'] == 'ACTOR_TYPE.E55':
related_res['relationship'].append(
get_preflabel_from_conceptid(entity['conceptid'],
lang)['value'])
related_resource['actor_relationshiptype'] = ''
for entity in related_resource['child_entities']:
if entity['entitytypeid'] == 'ACTOR_APPELLATION.E82':
related_resource['primaryname'] = entity['value']
elif related_resource['entitytypeid'] == 'HISTORICAL_EVENT.E5':
for entity in related_resource['domains']:
if entity['entitytypeid'] == 'HISTORICAL_EVENT_TYPE.E55':
related_res['relationship'].append(
get_preflabel_from_conceptid(entity['conceptid'],
lang)['value'])
elif related_resource['entitytypeid'] == 'INFORMATION_RESOURCE.E73':
for entity in related_resource['domains']:
if entity['entitytypeid'] == 'INFORMATION_RESOURCE_TYPE.E55':
related_res['relationship'].append(
get_preflabel_from_valueid(entity['value'],
lang)['value'])
for entity in related_resource['child_entities']:
if entity['entitytypeid'] == 'FILE_PATH.E62':
related_res[
'file_path'] = settings.MEDIA_URL + entity['label']
if entity['entitytypeid'] == 'THUMBNAIL.E62':
related_res[
'thumbnail'] = settings.MEDIA_URL + entity['label']
information_resource_type = 'IMAGE'
if entity['entitytypeid'] == 'TILE_SQUARE_DETAILS.E44' or entity[
'entitytypeid'] == 'TILE_SQUARE_APPELLATION.E44': #If this node is populated, the Info resource is assumed to be a Map and its default name is set to Sheet Name
related_res['primaryname'] = entity['label']
information_resource_type = 'MAP'
elif entity['entitytypeid'] == 'SHARED_DATA_SOURCE_APPELLATION.E82' or entity[
'entitytypeid'] == 'SHARED_DATA_SOURCE_AFFILIATION.E82' or entity[
'entitytypeid'] == 'SHARED_DATA_SOURCE_CREATOR_APPELLATION.E82': #If this node is populated, the Info resource is assumed to be a Shared Dataset and its default name is set to Shared Dated Source
SharedDataset.append(entity['label'])
information_resource_type = 'SHARED'
elif entity[
'entitytypeid'] == 'CATALOGUE_ID.E42': #If this node is populated, the Info resource is assumed to be Imagery other than VirtualGlobe type
OtherImageryName.append(entity['label'])
OtherImagery = False
information_resource_type = 'SATELLITE'
elif entity[
'entitytypeid'] == 'IMAGERY_CREATOR_APPELLATION.E82': #If this node is populated, and Catalogue_ID.E42 is not (checked by bool OtherImagery), the Info resource is assumed to be a VirtualGlobe
VirtualGlobe = True
VirtualGlobeName.append(entity['label'])
information_resource_type = 'SATELLITE'
elif entity['entitytypeid'] == 'TITLE.E41':
related_res['primaryname'] = entity['value']
for entity in related_resource['dates']:
if entity['entitytypeid'] == 'DATE_OF_ACQUISITION.E50':
related_res['date'] = validatedates(entity['label'])
if VirtualGlobe == True and OtherImagery == True: #This routine creates the concatenated primary name for a Virtual Globe related resource
for entity in related_resource['domains']:
if entity['entitytypeid'] == 'IMAGERY_SOURCE_TYPE.E55':
VirtualGlobeName.append(entity['label'])
for entity in related_resource['dates']:
if entity['entitytypeid'] == 'DATE_OF_ACQUISITION.E50':
VirtualGlobeName.append(entity['label'])
related_res['primaryname'] = " - ".join(VirtualGlobeName)
elif OtherImagery == False: #This routine creates the concatenated primary name for Imagery related resource
for entity in related_resource['dates']:
if entity['entitytypeid'] == 'DATE_OF_ACQUISITION.E50':
OtherImageryName.append(entity['label'])
related_res['primaryname'] = " - ".join(OtherImageryName)
if information_resource_type == 'SHARED': #This routine creates the concatenated primary name for a Shared dataset
related_res['primaryname'] = " - ".join(SharedDataset)
# get the relationship between the two entities as well as the notes and dates, if the exist
for relationship in related_resource_info['resource_relationships']:
if relationship['entityid1'] == related_resource[
'entityid'] or relationship[
'entityid2'] == related_resource['entityid']:
related_res['relationship'].append(
get_preflabel_from_valueid(
relationship['relationshiptype'], lang)['value'])
if relationship['datestarted']:
related_res['datefrom'] = relationship['datestarted']
if relationship['dateended']:
related_res['dateto'] = relationship['dateended']
if relationship['notes']:
related_res['notes'] = relationship['notes']
entitytypeidkey = related_resource['entitytypeid'].split('.')[0]
if entitytypeidkey == 'INFORMATION_RESOURCE':
entitytypeidkey = '%s_%s' % (entitytypeidkey,
information_resource_type)
related_resource_dict[entitytypeidkey].append(related_res)
return render_to_response(
'resource-report.htm',
{
'geometry': JSONSerializer().serialize(result),
# 'geometry': JSONSerializer().serialize(report_info['source']['geometry']),
'resourceid': resourceid,
'report_template': 'views/reports/' + report_info['type'] + '.htm',
'report_info': report_info,
'related_resource_dict': related_resource_dict,
'main_script': 'resource-report',
'active_page': 'ResourceReport',
'BingDates': getdates(report_info['source']['geometry']
) # Retrieving the dates of Bing Imagery
},
context_instance=RequestContext(request))
def get(self, request):
icons = models.Icon.objects.order_by("name")
data = {"icons": JSONSerializer().serializeToPython(icons)}
return JSONResponse(data)
def __str__(self):
return JSONSerializer().serialize(self.dsl, indent=4)
def build_base_search_results_dsl(request):
term_filter = request.GET.get('termFilter', '')
spatial_filter = JSONDeserializer().deserialize(request.GET.get('spatialFilter', None))
export = request.GET.get('export', None)
page = 1 if request.GET.get('page') == '' else int(request.GET.get('page', 1))
temporal_filter = JSONDeserializer().deserialize(request.GET.get('temporalFilter', None))
se = SearchEngineFactory().create()
if export != None:
limit = settings.SEARCH_EXPORT_ITEMS_PER_PAGE
else:
limit = settings.SEARCH_ITEMS_PER_PAGE
query = Query(se, start=limit*int(page-1), limit=limit)
boolquery = Bool()
boolfilter = Bool()
if term_filter != '':
# Ce uporabnik ni avtenticiran, prikazemo le veljavne (to je verjetno potrebno se dodelati (mogoce da vidijo le svoje???)!!!)
if (request.user.username == 'anonymous'):
auto_filter = []
for item in JSONDeserializer().deserialize(term_filter):
auto_filter.append(item)
# Poiscimo concept id in context za Published status
AUTO_TERM_FILTER = get_auto_filter(request)
auto_filter.append(AUTO_TERM_FILTER)
term_filter = JSONSerializer().serialize(auto_filter)
print 'term_filter'
if term_filter != '':
for term in JSONDeserializer().deserialize(term_filter):
print term
if term['type'] == 'term':
entitytype = models.EntityTypes.objects.get(conceptid_id=term['context'])
boolfilter_nested = Bool()
boolfilter_nested.must(Terms(field='child_entities.entitytypeid', terms=[entitytype.pk]))
boolfilter_nested.must(Match(field='child_entities.value', query=term['value'], type='phrase'))
nested = Nested(path='child_entities', query=boolfilter_nested)
if term['inverted']:
boolfilter.must_not(nested)
else:
boolfilter.must(nested)
elif term['type'] == 'concept':
concept_ids = _get_child_concepts(term['value'])
terms = Terms(field='domains.conceptid', terms=concept_ids)
nested = Nested(path='domains', query=terms)
if term['inverted']:
boolfilter.must_not(nested)
else:
boolfilter.must(nested)
elif term['type'] == 'string':
boolfilter_folded = Bool()
boolfilter_folded.should(Match(field='child_entities.value', query=term['value'], type='phrase_prefix'))
boolfilter_folded.should(Match(field='child_entities.value.folded', query=term['value'], type='phrase_prefix'))
nested = Nested(path='child_entities', query=boolfilter_folded)
if term['inverted']:
boolquery.must_not(nested)
else:
boolquery.must(nested)
if 'geometry' in spatial_filter and 'type' in spatial_filter['geometry'] and spatial_filter['geometry']['type'] != '':
geojson = spatial_filter['geometry']
if geojson['type'] == 'bbox':
coordinates = [[geojson['coordinates'][0],geojson['coordinates'][3]], [geojson['coordinates'][2],geojson['coordinates'][1]]]
geoshape = GeoShape(field='geometries.value', type='envelope', coordinates=coordinates )
nested = Nested(path='geometries', query=geoshape)
else:
buffer = spatial_filter['buffer']
geojson = JSONDeserializer().deserialize(_buffer(geojson,buffer['width'],buffer['unit']).json)
geoshape = GeoShape(field='geometries.value', type=geojson['type'], coordinates=geojson['coordinates'] )
nested = Nested(path='geometries', query=geoshape)
if 'inverted' not in spatial_filter:
spatial_filter['inverted'] = False
if spatial_filter['inverted']:
boolfilter.must_not(nested)
else:
boolfilter.must(nested)
if 'year_min_max' in temporal_filter and len(temporal_filter['year_min_max']) == 2:
start_date = date(temporal_filter['year_min_max'][0], 1, 1)
end_date = date(temporal_filter['year_min_max'][1], 12, 31)
if start_date:
start_date = start_date.isoformat()
if end_date:
end_date = end_date.isoformat()
range = Range(field='dates.value', gte=start_date, lte=end_date)
nested = Nested(path='dates', query=range)
if 'inverted' not in temporal_filter:
temporal_filter['inverted'] = False
if temporal_filter['inverted']:
boolfilter.must_not(nested)
else:
boolfilter.must(nested)
if not boolquery.empty:
query.add_query(boolquery)
if not boolfilter.empty:
query.add_filter(boolfilter)
return query
def import_business_data(self, business_data, mapping=None):
reporter = ResourceImportReporter(business_data)
try:
if mapping == None or mapping == '':
for resource in business_data['resources']:
if resource['resourceinstance'] != None:
resourceinstance, created = ResourceInstance.objects.update_or_create(
resourceinstanceid=uuid.UUID(
str(resource['resourceinstance']
['resourceinstanceid'])),
graph_id=uuid.UUID(
str(resource['resourceinstance']['graph_id'])),
legacyid=resource['resourceinstance']['legacyid'])
if len(
ResourceInstance.objects.filter(
resourceinstanceid=resource[
'resourceinstance']
['resourceinstanceid'])) == 1:
reporter.update_resources_saved()
if resource['tiles'] != []:
reporter.update_tiles(len(resource['tiles']))
for tile in resource['tiles']:
tile['parenttile_id'] = uuid.UUID(
str(tile['parenttile_id'])
) if tile['parenttile_id'] else None
tile, created = Tile.objects.update_or_create(
resourceinstance=resourceinstance,
parenttile=Tile(
uuid.UUID(str(tile['parenttile_id'])))
if tile['parenttile_id'] else None,
nodegroup=NodeGroup(
uuid.UUID(str(tile['nodegroup_id'])))
if tile['nodegroup_id'] else None,
tileid=uuid.UUID(str(tile['tileid'])),
data=tile['data'])
if len(Tile.objects.filter(
tileid=tile.tileid)) == 1:
reporter.update_tiles_saved()
for relation in business_data['relations']:
relation = ResourceXResource.objects.update_or_create(
resourcexid=uuid.UUID(str(relation['resourcexid'])),
resourceinstanceidfrom=ResourceInstance(
uuid.UUID(str(
relation['resourceinstanceidfrom']))),
resourceinstanceidto=ResourceInstance(
uuid.UUID(str(relation['resourceinstanceidto']))),
notes=relation['notes'],
relationshiptype=uuid.UUID(
str(relation['relationshiptype'])),
datestarted=relation['datestarted'],
dateended=relation['dateended'])
if len(
ResourceXResource.objects.filter(
resourcexid=relation['resourcexid'])) == 1:
reporter.update_relations_saved()
else:
blanktilecache = {}
target_nodegroup_cardinalities = {}
for nodegroup in JSONSerializer().serializeToPython(
NodeGroup.objects.all()):
target_nodegroup_cardinalities[
nodegroup['nodegroupid']] = nodegroup['cardinality']
def replace_source_nodeid(tiles, mapping):
for tile in tiles:
new_data = []
for sourcekey in tile['data'].keys():
for row in mapping['nodes']:
if row['file_field_name'] == sourcekey:
d = {}
d[row['arches_nodeid']] = tile['data'][
sourcekey]
new_data.append(d)
# tile['data'][row['targetnodeid']] = tile['data'][sourcekey]
# del tile['data'][sourcekey]
tile['data'] = new_data
return tiles
def cache(blank_tile):
if blank_tile.data != {}:
for tile in blank_tile.tiles.values():
if isinstance(tile, Tile):
for key in tile.data.keys():
blanktilecache[key] = blank_tile
# else:
# print blank_tile
for resource in business_data['resources']:
reporter.update_tiles(len(resource['tiles']))
parenttileids = []
populated_tiles = []
resourceinstanceid = uuid.uuid4()
populated_nodegroups = []
target_resource_model = mapping['resource_model_id']
for tile in resource['tiles']:
if tile['data'] != {}:
def get_tiles(tile):
if tile['parenttile_id'] != None:
if tile['parenttile_id'] not in parenttileids:
parenttileids.append(
tile['parenttile_id'])
ret = []
for sibling_tile in resource['tiles']:
if sibling_tile[
'parenttile_id'] == tile[
'parenttile_id']:
ret.append(sibling_tile)
else:
ret = None
else:
ret = [tile]
#deletes nodes that don't have values
if ret is not None:
for tile in ret:
for key, value in tile[
'data'].iteritems():
if value == "":
del tile['data'][key]
return ret
def get_blank_tile(sourcetilegroup):
if len(sourcetilegroup[0]['data']) > 0:
if sourcetilegroup[0]['data'][0] != {}:
if sourcetilegroup[0]['data'][0].keys(
)[0] not in blanktilecache:
blank_tile = Tile.get_blank_tile(
tiles[0]['data'][0].keys()[0],
resourceid=resourceinstanceid)
cache(blank_tile)
else:
blank_tile = blanktilecache[
tiles[0]['data'][0].keys()[0]]
else:
blank_tile = None
else:
blank_tile = None
return blank_tile
tiles = get_tiles(tile)
if tiles is not None:
mapped_tiles = replace_source_nodeid(
tiles, mapping)
blank_tile = get_blank_tile(tiles)
def populate_tile(sourcetilegroup,
target_tile):
need_new_tile = False
target_tile_cardinality = target_nodegroup_cardinalities[
str(target_tile.nodegroup_id)]
if str(target_tile.nodegroup_id
) not in populated_nodegroups:
if target_tile.data != {}:
for source_tile in sourcetilegroup:
for tiledata in source_tile[
'data']:
for nodeid in tiledata.keys(
):
if nodeid in target_tile.data:
if target_tile.data[
nodeid] == None:
target_tile.data[
nodeid] = tiledata[
nodeid]
for key in tiledata.keys(
):
if key == nodeid:
del tiledata[
nodeid]
for tiledata in source_tile[
'data']:
if tiledata == {}:
source_tile[
'data'].remove(
tiledata)
elif target_tile.tiles != None:
populated_child_nodegroups = []
for nodegroupid, childtile in target_tile.tiles.iteritems(
):
childtile_empty = True
child_tile_cardinality = target_nodegroup_cardinalities[
str(childtile[0].
nodegroup_id)]
if str(
childtile[0].
nodegroup_id
) not in populated_child_nodegroups:
prototype_tile = childtile.pop(
)
prototype_tile.tileid = None
for source_tile in sourcetilegroup:
if prototype_tile.nodegroup_id not in populated_child_nodegroups:
prototype_tile_copy = deepcopy(
prototype_tile)
for data in source_tile[
'data']:
for nodeid in data.keys(
):
if nodeid in prototype_tile.data.keys(
):
if prototype_tile.data[
nodeid] == None:
prototype_tile_copy.data[
nodeid] = data[
nodeid]
for key in data.keys(
):
if key == nodeid:
del data[
nodeid]
if child_tile_cardinality == '1':
populated_child_nodegroups.append(
prototype_tile
.
nodegroup_id
)
for data in source_tile[
'data']:
if data == {}:
source_tile[
'data'].remove(
data
)
for key in prototype_tile_copy.data.keys(
):
if prototype_tile_copy.data[
key] != None:
childtile_empty = False
if prototype_tile_copy.data == {} or childtile_empty:
prototype_tile_copy = None
if prototype_tile_copy is not None:
childtile.append(
prototype_tile_copy
)
else:
break
if target_tile.data:
if target_tile.data == {} and target_tile.tiles == {}:
target_tile = None
populated_tiles.append(target_tile)
for source_tile in sourcetilegroup:
if source_tile['data']:
for data in source_tile[
'data']:
if len(data) > 0:
need_new_tile = True
if need_new_tile:
if get_blank_tile(
sourcetilegroup) != None:
populate_tile(
sourcetilegroup,
get_blank_tile(
sourcetilegroup))
if target_tile_cardinality == '1':
populated_nodegroups.append(
str(target_tile.nodegroup_id))
else:
target_tile = None
if blank_tile != None:
populate_tile(mapped_tiles, blank_tile)
newresourceinstance = ResourceInstance.objects.create(
resourceinstanceid=resourceinstanceid,
graph_id=target_resource_model,
legacyid=None)
if len(
ResourceInstance.objects.filter(
resourceinstanceid=resourceinstanceid)) == 1:
reporter.update_resources_saved()
# print JSONSerializer().serialize(populated_tiles)
for populated_tile in populated_tiles:
populated_tile.resourceinstance = newresourceinstance
saved_tile = populated_tile.save()
# tile_saved = count parent tile and count of tile array if tile array != {}
# reporter.update_tiles_saved(tile_saved)
except (KeyError, TypeError) as e:
print e
finally:
reporter.report_results()
def concept(request, conceptid):
f = request.GET.get('f', 'json')
mode = request.GET.get('mode', '')
lang = request.GET.get('lang', settings.LANGUAGE_CODE)
pretty = request.GET.get('pretty', False)
if request.method == 'GET':
include_subconcepts = request.GET.get('include_subconcepts', 'true') == 'true'
include_parentconcepts = request.GET.get('include_parentconcepts', 'true') == 'true'
include_relatedconcepts = request.GET.get('include_relatedconcepts', 'true') == 'true'
emulate_elastic_search = request.GET.get('emulate_elastic_search', 'false') == 'true'
depth_limit = request.GET.get('depth_limit', None)
if f == 'html':
depth_limit = 1
if not conceptid:
return render(request, 'views/rdm/concept-report.htm', {
'lang': lang,
'concept_count': models.Concept.objects.filter(nodetype='Concept').count(),
'collection_count': models.Concept.objects.filter(nodetype='Collection').count(),
'scheme_count': models.Concept.objects.filter(nodetype='ConceptScheme').count(),
'entitytype_count': models.Concept.objects.filter(nodetype='EntityType').count(),
'default_report': True
})
ret = []
labels = []
this_concept = Concept().get(id=conceptid)
if f == 'html':
if mode == '' and (this_concept.nodetype == 'Concept' or this_concept.nodetype == 'ConceptScheme' or this_concept.nodetype == 'EntityType'):
concept_graph = Concept().get(id=conceptid, include_subconcepts=include_subconcepts,
include_parentconcepts=include_parentconcepts, include_relatedconcepts=include_relatedconcepts,
depth_limit=depth_limit, up_depth_limit=None, lang=lang)
else:
concept_graph = Concept().get(id=conceptid, include_subconcepts=include_subconcepts,
include_parentconcepts=include_parentconcepts, include_relatedconcepts=include_relatedconcepts,
depth_limit=depth_limit, up_depth_limit=None, lang=lang, semantic=False)
languages = models.DLanguage.objects.all()
valuetypes = models.DValueType.objects.all()
relationtypes = models.DRelationType.objects.all()
prefLabel = concept_graph.get_preflabel(lang=lang)
for subconcept in concept_graph.subconcepts:
subconcept.prefLabel = subconcept.get_preflabel(lang=lang)
for relatedconcept in concept_graph.relatedconcepts:
relatedconcept.prefLabel = relatedconcept.get_preflabel(lang=lang)
for value in concept_graph.values:
if value.category == 'label':
labels.append(value)
if mode == '' and (this_concept.nodetype == 'Concept' or this_concept.nodetype == 'ConceptScheme' or this_concept.nodetype == 'EntityType'):
if concept_graph.nodetype == 'ConceptScheme':
parent_relations = relationtypes.filter(category='Properties')
else:
parent_relations = relationtypes.filter(category='Semantic Relations').exclude(relationtype = 'related').exclude(relationtype='broader').exclude(relationtype='broaderTransitive')
return render(request, 'views/rdm/concept-report.htm', {
'lang': lang,
'prefLabel': prefLabel,
'labels': labels,
'concept': concept_graph,
'languages': languages,
'sparql_providers': get_sparql_providers(),
'valuetype_labels': valuetypes.filter(category='label'),
'valuetype_notes': valuetypes.filter(category='note'),
'valuetype_related_values': valuetypes.filter(category='undefined'),
'parent_relations': parent_relations,
'related_relations': relationtypes.filter(Q(category='Mapping Properties') | Q(relationtype = 'related')),
'concept_paths': concept_graph.get_paths(lang=lang),
'graph_json': JSONSerializer().serialize(concept_graph.get_node_and_links(lang=lang)),
'direct_parents': [parent.get_preflabel(lang=lang) for parent in concept_graph.parentconcepts]
})
else:
return render(request, 'views/rdm/entitytype-report.htm', {
'lang': lang,
'prefLabel': prefLabel,
'labels': labels,
'concept': concept_graph,
'languages': languages,
'valuetype_labels': valuetypes.filter(category='label'),
'valuetype_notes': valuetypes.filter(category='note'),
'valuetype_related_values': valuetypes.filter(category='undefined'),
'related_relations': relationtypes.filter(relationtype = 'member'),
'concept_paths': concept_graph.get_paths(lang=lang)
})
concept_graph = Concept().get(id=conceptid, include_subconcepts=include_subconcepts,
include_parentconcepts=include_parentconcepts, include_relatedconcepts=include_relatedconcepts,
depth_limit=depth_limit, up_depth_limit=None, lang=lang)
if f == 'skos':
include_parentconcepts = False
include_subconcepts = True
depth_limit = None
skos = SKOSWriter()
return HttpResponse(skos.write(concept_graph, format="pretty-xml"), content_type="application/xml")
if emulate_elastic_search:
ret.append({'_type': id, '_source': concept_graph})
else:
ret.append(concept_graph)
if emulate_elastic_search:
ret = {'hits':{'hits':ret}}
return JSONResponse(ret, indent=4 if pretty else None)
if request.method == 'POST':
if len(request.FILES) > 0:
skosfile = request.FILES.get('skosfile', None)
imagefile = request.FILES.get('file', None)
if imagefile:
value = models.FileValue(valueid = str(uuid.uuid4()), value = request.FILES.get('file', None), concept_id = conceptid, valuetype_id = 'image',language_id = settings.LANGUAGE_CODE)
value.save()
return JSONResponse(value)
elif skosfile:
overwrite_options = request.POST.get('overwrite_options', None)
skos = SKOSReader()
rdf = skos.read_file(skosfile)
ret = skos.save_concepts_from_skos(rdf, overwrite_options)
return JSONResponse(ret)
else:
data = JSONDeserializer().deserialize(request.body)
if data:
with transaction.atomic():
concept = Concept(data)
concept.save()
concept.index()
return JSONResponse(concept)
if request.method == 'DELETE':
data = JSONDeserializer().deserialize(request.body)
if data:
with transaction.atomic():
concept = Concept(data)
delete_self = data['delete_self'] if 'delete_self' in data else False
if not (delete_self and concept.id in CORE_CONCEPTS):
in_use = False
if delete_self:
check_concept = Concept().get(data['id'], include_subconcepts=True)
in_use = check_concept.check_if_concept_in_use()
if 'subconcepts' in data:
for subconcept in data['subconcepts']:
if in_use == False:
check_concept = Concept().get(subconcept['id'], include_subconcepts=True)
in_use = check_concept.check_if_concept_in_use()
if in_use == False:
concept.delete_index(delete_self=delete_self)
concept.delete(delete_self=delete_self)
else:
return JSONResponse({"in_use": in_use})
return JSONResponse(concept)
return HttpResponseNotFound
def serialize_for_mobile(self):
"""
serialize to a different form than used by the internal class structure
used to append additional values (like parent ontology properties) that
internal objects (like models.Nodes) don't support
"""
serializer = JSONSerializer()
serializer.geom_format = 'geojson'
obj = serializer.handle_model(self)
ordered_cards = self.get_ordered_cards()
expired = False
try:
expired = (datetime.strptime(str(self.enddate), '%Y-%m-%d') -
datetime.now() + timedelta(hours=24)).days < 0
except ValueError:
pass
ret = JSONSerializer().serializeToPython(obj)
if expired is True:
self.active = False
super(MobileSurvey, self).save()
ret['active'] = False
graphs = []
card_lookup = {}
for card in self.cards.all():
if str(card.graph_id) in card_lookup:
card_lookup[str(card.graph_id)].append(card)
else:
card_lookup[str(card.graph_id)] = [card]
for graphid, cards in iter(list(card_lookup.items())):
graph = Graph.objects.get(pk=graphid)
graph_obj = graph.serialize(exclude=[
'domain_connections', 'edges', 'relatable_resource_model_ids'
])
graph_obj['widgets'] = list(
models.CardXNodeXWidget.objects.filter(
card__graph=graph).distinct())
nodegroupids = []
for card in cards:
topcard = Card.objects.get(pk=card.cardid)
self.collect_card_widget_node_data(graph_obj, graph, topcard,
nodegroupids)
graph_obj['widgets'] = serializer.serializeToPython(
graph_obj['widgets'])
nodegroup_filters = {
'nodes': 'nodegroup_id',
'cards': 'nodegroup_id',
'nodegroups': 'nodegroupid'
}
for prop, id in iter(list(nodegroup_filters.items())):
relevant_items = [
item for item in graph_obj[prop]
if item[id] in nodegroupids
]
graph_obj[prop] = relevant_items
relevant_cardids = [card['cardid'] for card in graph_obj['cards']]
relevant_widgets = [
widget for widget in graph_obj['widgets']
if str(widget['card_id']) in relevant_cardids
]
graph_obj['widgets'] = relevant_widgets
graphs.append(serializer.serializeToPython(graph_obj))
ret['graphs'] = graphs
ret['cards'] = ordered_cards
try:
bounds = json.loads(ret['bounds'])
ret['bounds'] = bounds
if (bounds['type'] == 'MultiPolygon'):
singlepart = GeoUtils().convert_multipart_to_singlepart(bounds)
ret['bounds'] = singlepart
except TypeError as e:
logger.error('Could not parse {0}, {1}'.format(ret['bounds'], e))
return ret
def get(self, request):
if self.action == 'tile_history':
start = request.GET.get('start')
end = request.GET.get('end')
edits = EditLog.objects.filter(
provisional_userid=request.user.id).filter(
timestamp__range=[start, end]).order_by(
'tileinstanceid', 'timestamp')
resourceinstanceids = [
e['resourceinstanceid']
for e in edits.values('resourceinstanceid')
]
deleted_resource_edits = EditLog.objects.filter(
resourceinstanceid__in=resourceinstanceids).filter(
edittype='delete')
deleted_resource_instances = [
e['resourceinstanceid']
for e in deleted_resource_edits.values('resourceinstanceid')
]
summary = {}
for edit in edits:
if edit.tileinstanceid not in summary:
summary[edit.tileinstanceid] = {
'pending': False,
'tileid': edit.tileinstanceid
}
summary[edit.tileinstanceid]['lasttimestamp'] = edit.timestamp
summary[edit.tileinstanceid][
'lastedittype'] = edit.provisional_edittype
summary[edit.tileinstanceid]['reviewer'] = ''
summary[edit.tileinstanceid][
'resourceinstanceid'] = edit.resourceinstanceid
summary[edit.tileinstanceid][
'resourcedisplayname'] = edit.resourcedisplayname
summary[edit.tileinstanceid][
'resourcemodelid'] = edit.resourceclassid
summary[edit.tileinstanceid]['nodegroupid'] = edit.nodegroupid
summary[edit.tileinstanceid][
'resource_deleted'] = True if edit.resourceinstanceid in deleted_resource_instances else False
if edit.provisional_edittype in ['accept edit', 'delete edit']:
summary[
edit.tileinstanceid]['reviewer'] = edit.user_username
chronological_summary = []
resource_models = models.GraphModel.objects.filter(
isresource=True).exclude(
graphid=settings.SYSTEM_SETTINGS_RESOURCE_MODEL_ID).values(
'iconclass', 'color', 'graphid', 'name')
cards = models.CardModel.objects.all().values(
'name', 'nodegroup_id')
card_lookup = {str(card['nodegroup_id']): card for card in cards}
resource_model_lookup = {
str(graph['graphid']): graph
for graph in resource_models
}
for k, v in summary.iteritems():
if v['lastedittype'] not in ['accept edit', 'delete edit']:
if models.TileModel.objects.filter(pk=k).exists():
tile = models.TileModel.objects.get(pk=k)
if tile.provisionaledits is not None and str(
request.user.id) in tile.provisionaledits:
v['pending'] = True
v['resourcemodel'] = resource_model_lookup[
v['resourcemodelid']]
v['card'] = card_lookup[v['nodegroupid']]
if 'graphid' in v['resourcemodel']:
v['resourcemodel'].pop('graphid')
if 'nodegroup_id' in v['card']:
v['card'].pop('nodegroup_id')
chronological_summary.append(v)
return JSONResponse(JSONSerializer().serialize(
sorted(chronological_summary,
key=lambda k: k['lasttimestamp'],
reverse=True)))
def search_results(request):
try:
search_results_dsl = build_search_results_dsl(request)
except Exception as err:
return JSONResponse(err.message, status=500)
dsl = search_results_dsl['query']
search_buffer = search_results_dsl['search_buffer']
dsl.include('graph_id')
dsl.include('root_ontology_class')
dsl.include('resourceinstanceid')
dsl.include('points')
dsl.include('geometries')
dsl.include('displayname')
dsl.include('displaydescription')
dsl.include('map_popup')
dsl.include('provisional_resource')
results = dsl.search(index='resource', doc_type=get_doc_type(request))
if results is not None:
user_is_reviewer = request.user.groups.filter(
name='Resource Reviewer').exists()
total = results['hits']['total']
page = 1 if request.GET.get('page') == '' else int(
request.GET.get('page', 1))
paginator, pages = get_paginator(request, results, total, page,
settings.SEARCH_ITEMS_PER_PAGE)
page = paginator.page(page)
# only reuturn points and geometries a user is allowed to view
geojson_nodes = get_nodegroups_by_datatype_and_perm(
request, 'geojson-feature-collection', 'read_nodegroup')
for result in results['hits']['hits']:
result['_source']['points'] = select_geoms_for_results(
result['_source']['points'], geojson_nodes, user_is_reviewer)
result['_source']['geometries'] = select_geoms_for_results(
result['_source']['geometries'], geojson_nodes,
user_is_reviewer)
ret = {}
ret['results'] = results
ret['search_buffer'] = JSONSerializer().serialize(
search_buffer) if search_buffer != None else None
ret['paginator'] = {}
ret['paginator']['current_page'] = page.number
ret['paginator']['has_next'] = page.has_next()
ret['paginator']['has_previous'] = page.has_previous()
ret['paginator']['has_other_pages'] = page.has_other_pages()
ret['paginator']['next_page_number'] = page.next_page_number(
) if page.has_next() else None
ret['paginator']['previous_page_number'] = page.previous_page_number(
) if page.has_previous() else None
ret['paginator']['start_index'] = page.start_index()
ret['paginator']['end_index'] = page.end_index()
ret['paginator']['pages'] = pages
ret['reviewer'] = user_is_reviewer
return JSONResponse(ret)
else:
return HttpResponseNotFound(
_("There was an error retrieving the search results"))
def get(
self,
request,
graphid=None,
resourceid=None,
view_template="views/resource/editor.htm",
main_script="views/resource/editor",
nav_menu=True,
):
if self.action == "copy":
return self.copy(request, resourceid)
creator = None
user_created_instance = None
if resourceid is None:
resource_instance = None
graph = models.GraphModel.objects.get(pk=graphid)
resourceid = ""
else:
resource_instance = Resource.objects.get(pk=resourceid)
graph = resource_instance.graph
instance_creator = get_instance_creator(resource_instance, request.user)
creator = instance_creator["creatorid"]
user_created_instance = instance_creator["user_can_edit_instance_permissions"]
nodes = graph.node_set.all()
resource_graphs = (
models.GraphModel.objects.exclude(pk=settings.SYSTEM_SETTINGS_RESOURCE_MODEL_ID)
.exclude(isresource=False)
.exclude(isactive=False)
)
ontologyclass = [node for node in nodes if node.istopnode is True][0].ontologyclass or ""
relationship_type_values = get_resource_relationship_types()
nodegroups = []
editable_nodegroups = []
for node in nodes:
if node.is_collector:
added = False
if request.user.has_perm("write_nodegroup", node.nodegroup):
editable_nodegroups.append(node.nodegroup)
nodegroups.append(node.nodegroup)
added = True
if not added and request.user.has_perm("read_nodegroup", node.nodegroup):
nodegroups.append(node.nodegroup)
nodes = nodes.filter(nodegroup__in=nodegroups)
cards = graph.cardmodel_set.order_by("sortorder").filter(nodegroup__in=nodegroups).prefetch_related("cardxnodexwidget_set")
cardwidgets = [
widget for widgets in [card.cardxnodexwidget_set.order_by("sortorder").all() for card in cards] for widget in widgets
]
widgets = models.Widget.objects.all()
card_components = models.CardComponent.objects.all()
applied_functions = JSONSerializer().serialize(models.FunctionXGraph.objects.filter(graph=graph))
datatypes = models.DDataType.objects.all()
user_is_reviewer = user_is_resource_reviewer(request.user)
is_system_settings = False
if resource_instance is None:
tiles = []
displayname = _("New Resource")
else:
displayname = resource_instance.displayname
if displayname == "undefined":
displayname = _("Unnamed Resource")
if str(resource_instance.graph_id) == settings.SYSTEM_SETTINGS_RESOURCE_MODEL_ID:
is_system_settings = True
displayname = _("System Settings")
tiles = resource_instance.tilemodel_set.order_by("sortorder").filter(nodegroup__in=nodegroups)
provisionaltiles = []
for tile in tiles:
append_tile = True
isfullyprovisional = False
if tile.provisionaledits is not None:
if len(list(tile.provisionaledits.keys())) > 0:
if len(tile.data) == 0:
isfullyprovisional = True
if user_is_reviewer is False:
if str(request.user.id) in tile.provisionaledits:
tile.provisionaledits = {str(request.user.id): tile.provisionaledits[str(request.user.id)]}
tile.data = tile.provisionaledits[str(request.user.id)]["value"]
else:
if isfullyprovisional is True:
# if the tile IS fully provisional and the current user is not the owner,
# we don't send that tile back to the client.
append_tile = False
else:
# if the tile has authoritaive data and the current user is not the owner,
# we don't send the provisional data of other users back to the client.
tile.provisionaledits = None
if append_tile is True:
provisionaltiles.append(tile)
tiles = provisionaltiles
map_layers = models.MapLayer.objects.all()
map_markers = models.MapMarker.objects.all()
map_sources = models.MapSource.objects.all()
geocoding_providers = models.Geocoder.objects.all()
templates = models.ReportTemplate.objects.all()
cards = JSONSerializer().serializeToPython(cards)
editable_nodegroup_ids = [str(nodegroup.pk) for nodegroup in editable_nodegroups]
for card in cards:
card["is_writable"] = False
if str(card["nodegroup_id"]) in editable_nodegroup_ids:
card["is_writable"] = True
can_delete = user_can_delete_resource(request.user, resourceid)
context = self.get_context_data(
main_script=main_script,
resourceid=resourceid,
displayname=displayname,
graphid=graph.graphid,
graphiconclass=graph.iconclass,
graphname=graph.name,
ontologyclass=ontologyclass,
resource_graphs=resource_graphs,
relationship_types=relationship_type_values,
widgets=widgets,
widgets_json=JSONSerializer().serialize(widgets),
card_components=card_components,
card_components_json=JSONSerializer().serialize(card_components),
tiles=JSONSerializer().serialize(tiles),
cards=JSONSerializer().serialize(cards),
applied_functions=applied_functions,
nodegroups=JSONSerializer().serialize(nodegroups),
nodes=JSONSerializer().serialize(nodes),
cardwidgets=JSONSerializer().serialize(cardwidgets),
datatypes_json=JSONSerializer().serialize(datatypes, exclude=["iconclass", "modulename", "classname"]),
map_layers=map_layers,
map_markers=map_markers,
map_sources=map_sources,
geocoding_providers=geocoding_providers,
user_is_reviewer=json.dumps(user_is_reviewer),
user_can_delete_resource=can_delete,
creator=json.dumps(creator),
user_created_instance=json.dumps(user_created_instance),
report_templates=templates,
templates_json=JSONSerializer().serialize(templates, sort_keys=False, exclude=["name", "description"]),
graph_json=JSONSerializer().serialize(graph),
is_system_settings=is_system_settings,
)
context["nav"]["title"] = ""
context["nav"]["menu"] = nav_menu
if resourceid == settings.RESOURCE_INSTANCE_ID:
context["nav"]["help"] = {"title": _("Managing System Settings"), "template": "system-settings-help"}
else:
context["nav"]["help"] = {"title": _("Using the Resource Editor"), "template": "resource-editor-help"}
return render(request, view_template, context)
def get(self, request):
saved_searches = JSONSerializer().serialize(settings.SAVED_SEARCHES)
map_layers = models.MapLayer.objects.all()
map_markers = models.MapMarker.objects.all()
map_sources = models.MapSource.objects.all()
date_nodes = models.Node.objects.filter(Q(datatype='date')
| Q(datatype='edtf'),
graph__isresource=True,
graph__isactive=True)
resource_graphs = models.GraphModel.objects.exclude(
pk=settings.SYSTEM_SETTINGS_RESOURCE_MODEL_ID).exclude(
isresource=False).exclude(isactive=False)
searchable_datatypes = [
d.pk for d in models.DDataType.objects.filter(issearchable=True)
]
searchable_nodes = models.Node.objects.filter(
graph__isresource=True,
graph__isactive=True,
datatype__in=searchable_datatypes,
issearchable=True)
resource_cards = models.CardModel.objects.filter(
graph__isresource=True, graph__isactive=True)
datatypes = models.DDataType.objects.all()
geocoding_providers = models.Geocoder.objects.all()
# only allow cards that the user has permission to read
searchable_cards = []
for card in resource_cards:
if request.user.has_perm('read_nodegroup', card.nodegroup):
searchable_cards.append(card)
# only allow date nodes that the user has permission to read
searchable_date_nodes = []
for node in date_nodes:
if request.user.has_perm('read_nodegroup', node.nodegroup):
searchable_date_nodes.append(node)
context = self.get_context_data(
resource_cards=JSONSerializer().serialize(searchable_cards),
searchable_nodes=JSONSerializer().serialize(searchable_nodes),
saved_searches=saved_searches,
date_nodes=searchable_date_nodes,
map_layers=map_layers,
map_markers=map_markers,
map_sources=map_sources,
geocoding_providers=geocoding_providers,
main_script='views/search',
resource_graphs=resource_graphs,
datatypes=datatypes,
datatypes_json=JSONSerializer().serialize(datatypes),
user_is_reviewer=request.user.groups.filter(
name='Resource Reviewer').exists())
graphs = JSONSerializer().serialize(
context['resource_graphs'],
exclude=[
'functions', 'author', 'deploymentdate', 'deploymentfile',
'version', 'subtitle', 'description',
'disable_instance_creation', 'ontology_id'
])
context['graphs'] = graphs
context['graph_models'] = models.GraphModel.objects.all().exclude(
graphid=settings.SYSTEM_SETTINGS_RESOURCE_MODEL_ID)
context['nav']['title'] = _('Search')
context['nav']['icon'] = 'fa-search'
context['nav']['search'] = False
context['nav']['help'] = {
'title': _('Searching the Database'),
'template': 'search-help',
}
return render(request, 'views/search.htm', context)
def get(self, request, resourceid=None):
resource = Resource.objects.get(pk=resourceid)
resource_models = (
models.GraphModel.objects.filter(isresource=True).exclude(isactive=False).exclude(pk=settings.SYSTEM_SETTINGS_RESOURCE_MODEL_ID)
)
if strtobool(request.GET.get("json", "false")):
get_params = request.GET.copy()
get_params.update({"paginate": "false"})
request.GET = get_params
related_resources_response = RelatedResourcesView().get(request, resourceid)
related_resources = json.loads(related_resources_response.content)
related_resources_summary = self._generate_related_resources_summary(
related_resources=related_resources["related_resources"],
resource_relationships=related_resources["resource_relationships"],
resource_models=resource_models,
)
else:
related_resources_summary = {}
for resource_model in resource_models:
get_params = request.GET.copy()
get_params.update({"resourceinstance_graphid": str(resource_model.graphid)})
request.GET = get_params
related_resources_response = RelatedResourcesView().get(request, resourceid).content
related_resources_summary[str(resource_model.pk)] = json.loads(related_resources_response)
permitted_tiles = []
perm = "read_nodegroup"
for tile in Tile.objects.filter(resourceinstance=resource).order_by("sortorder"):
if request.user.has_perm(perm, tile.nodegroup):
tile.filter_by_perm(request.user, perm)
permitted_tiles.append(tile)
if strtobool(request.GET.get("json", "false")) and strtobool(request.GET.get("exclude_graph", "false")):
return JSONResponse(
{
"tiles": permitted_tiles,
"related_resources": related_resources_summary,
"displayname": resource.displayname,
"resourceid": resourceid,
}
)
datatypes = models.DDataType.objects.all()
graph = Graph.objects.get(graphid=resource.graph_id)
permitted_cards = []
for card in Card.objects.filter(graph_id=resource.graph_id).order_by("sortorder"):
if request.user.has_perm(perm, card.nodegroup):
card.filter_by_perm(request.user, perm)
permitted_cards.append(card)
cardwidgets = [
widget for widgets in [card.cardxnodexwidget_set.order_by("sortorder").all() for card in permitted_cards] for widget in widgets
]
if strtobool(request.GET.get("json", "false")) and not strtobool(request.GET.get("exclude_graph", "false")):
return JSONResponse(
{
"datatypes": datatypes,
"cards": permitted_cards,
"tiles": permitted_tiles,
"graph": graph,
"related_resources": related_resources_summary,
"displayname": resource.displayname,
"resourceid": resourceid,
"cardwidgets": cardwidgets,
}
)
widgets = models.Widget.objects.all()
templates = models.ReportTemplate.objects.all()
card_components = models.CardComponent.objects.all()
try:
map_layers = models.MapLayer.objects.all()
map_markers = models.MapMarker.objects.all()
map_sources = models.MapSource.objects.all()
geocoding_providers = models.Geocoder.objects.all()
except AttributeError:
raise Http404(_("No active report template is available for this resource."))
context = self.get_context_data(
main_script="views/resource/report",
report_templates=templates,
templates_json=JSONSerializer().serialize(templates, sort_keys=False, exclude=["name", "description"]),
card_components=card_components,
card_components_json=JSONSerializer().serialize(card_components),
cardwidgets=JSONSerializer().serialize(cardwidgets),
tiles=JSONSerializer().serialize(permitted_tiles, sort_keys=False),
cards=JSONSerializer().serialize(
permitted_cards,
sort_keys=False,
exclude=["is_editable", "description", "instructions", "helpenabled", "helptext", "helptitle", "ontologyproperty"],
),
datatypes_json=JSONSerializer().serialize(
datatypes, exclude=["modulename", "issearchable", "configcomponent", "configname", "iconclass"]
),
geocoding_providers=geocoding_providers,
related_resources=JSONSerializer().serialize(related_resources_summary, sort_keys=False),
widgets=widgets,
map_layers=map_layers,
map_markers=map_markers,
map_sources=map_sources,
graph_id=graph.graphid,
graph_name=graph.name,
graph_json=JSONSerializer().serialize(
graph,
sort_keys=False,
exclude=[
"functions",
"relatable_resource_model_ids",
"domain_connections",
"edges",
"is_editable",
"description",
"iconclass",
"subtitle",
"author",
],
),
resourceid=resourceid,
version=__version__,
hide_empty_nodes=settings.HIDE_EMPTY_NODES_IN_REPORT,
)
if graph.iconclass:
context["nav"]["icon"] = graph.iconclass
context["nav"]["title"] = graph.name
context["nav"]["res_edit"] = True
context["nav"]["print"] = True
context["nav"]["print"] = True
return render(request, "views/resource/report.htm", context)
def setUpClass(cls):
delete_terms_index()
delete_concepts_index()
delete_search_index()
prepare_terms_index(create=True)
prepare_concepts_index(create=True)
prepare_search_index(create=True)
cls.client = Client()
cls.client.login(username="******", password="******")
models.ResourceInstance.objects.all().delete()
with open(
os.path.join(
"tests/fixtures/resource_graphs/Search Test Model.json"),
"rU") as f:
archesfile = JSONDeserializer().deserialize(f)
ResourceGraphImporter(archesfile["graph"])
cls.search_model_graphid = "d291a445-fa5f-11e6-afa8-14109fd34195"
cls.search_model_cultural_period_nodeid = "7a182580-fa60-11e6-96d1-14109fd34195"
cls.search_model_creation_date_nodeid = "1c1d05f5-fa60-11e6-887f-14109fd34195"
cls.search_model_destruction_date_nodeid = "e771b8a1-65fe-11e7-9163-14109fd34195"
cls.search_model_name_nodeid = "2fe14de3-fa61-11e6-897b-14109fd34195"
cls.search_model_sensitive_info_nodeid = "57446fae-65ff-11e7-b63a-14109fd34195"
cls.search_model_geom_nodeid = "3ebc6785-fa61-11e6-8c85-14109fd34195"
cls.user = User.objects.create_user(
"unpriviliged_user", "*****@*****.**", "test")
cls.user.groups.add(Group.objects.get(name="Guest"))
nodegroup = models.NodeGroup.objects.get(
pk=cls.search_model_destruction_date_nodeid)
assign_perm("no_access_to_nodegroup", cls.user, nodegroup)
# Add a concept that defines a min and max date
concept = {
"id":
"00000000-0000-0000-0000-000000000001",
"legacyoid":
"ARCHES",
"nodetype":
"ConceptScheme",
"values": [],
"subconcepts": [{
"values": [
{
"value": "Mock concept",
"language": "en-US",
"category": "label",
"type": "prefLabel",
"id": "",
"conceptid": ""
},
{
"value": "1950",
"language": "en-US",
"category": "note",
"type": "min_year",
"id": "",
"conceptid": ""
},
{
"value": "1980",
"language": "en-US",
"category": "note",
"type": "max_year",
"id": "",
"conceptid": ""
},
],
"relationshiptype":
"hasTopConcept",
"nodetype":
"Concept",
"id":
"",
"legacyoid":
"",
"subconcepts": [],
"parentconcepts": [],
"relatedconcepts": [],
}],
}
post_data = JSONSerializer().serialize(concept)
content_type = "application/x-www-form-urlencoded"
response = cls.client.post(
reverse(
"concept",
kwargs={"conceptid": "00000000-0000-0000-0000-000000000001"}),
post_data, content_type)
response_json = json.loads(response.content)
valueid = response_json["subconcepts"][0]["values"][0]["id"]
cls.conceptid = response_json["subconcepts"][0]["id"]
# add resource instance with only a cultural period defined
cls.cultural_period_resource = Resource(
graph_id=cls.search_model_graphid)
tile = Tile(data={cls.search_model_cultural_period_nodeid: [valueid]},
nodegroup_id=cls.search_model_cultural_period_nodeid)
cls.cultural_period_resource.tiles.append(tile)
cls.cultural_period_resource.save()
# add resource instance with a creation and destruction date defined
cls.date_resource = Resource(graph_id=cls.search_model_graphid)
tile = Tile(data={cls.search_model_creation_date_nodeid: "1941-01-01"},
nodegroup_id=cls.search_model_creation_date_nodeid)
cls.date_resource.tiles.append(tile)
tile = Tile(
data={cls.search_model_destruction_date_nodeid: "1948-01-01"},
nodegroup_id=cls.search_model_destruction_date_nodeid)
cls.date_resource.tiles.append(tile)
tile = Tile(data={cls.search_model_name_nodeid: "testing 123"},
nodegroup_id=cls.search_model_name_nodeid)
cls.date_resource.tiles.append(tile)
cls.date_resource.save()
# add resource instance with a creation date and a cultural period defined
cls.date_and_cultural_period_resource = Resource(
graph_id=cls.search_model_graphid)
tile = Tile(data={cls.search_model_creation_date_nodeid: "1942-01-01"},
nodegroup_id=cls.search_model_creation_date_nodeid)
cls.date_and_cultural_period_resource.tiles.append(tile)
tile = Tile(data={cls.search_model_cultural_period_nodeid: [valueid]},
nodegroup_id=cls.search_model_cultural_period_nodeid)
cls.date_and_cultural_period_resource.tiles.append(tile)
cls.date_and_cultural_period_resource.save()
# add resource instance with with no dates or periods defined
cls.name_resource = Resource(graph_id=cls.search_model_graphid)
tile = Tile(data={cls.search_model_name_nodeid: "some test name"},
nodegroup_id=cls.search_model_name_nodeid)
cls.name_resource.tiles.append(tile)
geom = {
"type":
"FeatureCollection",
"features": [{
"geometry": {
"type": "Point",
"coordinates": [0, 0]
},
"type": "Feature",
"properties": {}
}],
}
tile = Tile(data={cls.search_model_geom_nodeid: geom},
nodegroup_id=cls.search_model_geom_nodeid)
cls.name_resource.tiles.append(tile)
cls.name_resource.save()
# add delay to allow for indexes to be updated
time.sleep(1)
