def validate(self, errors=None):
for nodeid, value in self.data.items():
datatype_factory = DataTypeFactory()
node = models.Node.objects.get(nodeid=nodeid)
datatype = datatype_factory.get_instance(node.datatype)
error = datatype.validate(value, node=node)
for error_instance in error:
if error_instance["type"] == "ERROR":
raise TileValidationError(
_("{0}".format(error_instance["message"])))
if errors is not None:
errors += error
return errors
def datatype_post_save_actions(self, request=None):
userid = None
if request is not None:
userid = str(request.user.id)
if hasattr(request.user, "userprofile") is not True:
models.UserProfile.objects.create(user=request.user)
tile_data = self.get_tile_data(userid)
for nodeid, value in list(tile_data.items()):
datatype_factory = DataTypeFactory()
node = models.Node.objects.get(nodeid=nodeid)
datatype = datatype_factory.get_instance(node.datatype)
if request is not None:
datatype.handle_request(self, request, node)
def import_business_data(self,
file_format=None,
business_data=None,
mapping=None,
overwrite='append',
bulk=False,
create_concepts=False,
create_collections=False):
reader = None
start = time()
cursor = connection.cursor()
try:
if file_format == None:
file_format = self.file_format
if business_data == None:
business_data = self.business_data
if mapping == None:
mapping = self.mapping
if file_format == 'json':
reader = ArchesFileReader()
reader.import_business_data(business_data, mapping)
elif file_format == 'csv' or file_format == 'shp' or file_format == 'zip':
if mapping != None:
reader = CsvReader()
reader.import_business_data(
business_data=business_data,
mapping=mapping,
overwrite=overwrite,
bulk=bulk,
create_concepts=create_concepts,
create_collections=create_collections)
else:
print '*' * 80
print 'ERROR: No mapping file detected. Please indicate one with the \'-c\' paramater or place one in the same directory as your business data.'
print '*' * 80
sys.exit()
elapsed = (time() - start)
print 'Time to import_business_data = {0}'.format(
datetime.timedelta(seconds=elapsed))
reader.report_errors()
finally:
datatype_factory = DataTypeFactory()
datatypes = DDataType.objects.all()
for datatype in datatypes:
datatype_instance = datatype_factory.get_instance(
datatype.datatype)
datatype_instance.after_update_all()
def import_business_data(self, file_format=None, business_data=None, mapping=None,
overwrite='append', bulk=False, create_concepts=False,
create_collections=False, use_multiprocessing=False):
reader = None
start = time()
cursor = connection.cursor()
try:
if file_format == None:
file_format = self.file_format
if business_data == None:
business_data = self.business_data
if mapping == None:
mapping = self.mapping
if file_format == 'json':
reader = ArchesFileReader()
reader.import_business_data(business_data, mapping)
elif file_format == 'jsonl':
with open(self.file[0], 'rU') as openf:
lines = openf.readlines()
if use_multiprocessing is True:
pool = Pool(cpu_count())
pool.map(import_one_resource, lines)
connections.close_all()
reader = ArchesFileReader()
else:
reader = ArchesFileReader()
for line in lines:
archesresource = JSONDeserializer().deserialize(line)
reader.import_business_data({"resources": [archesresource]})
elif file_format == 'csv' or file_format == 'shp' or file_format == 'zip':
if mapping != None:
reader = CsvReader()
reader.import_business_data(business_data=business_data, mapping=mapping, overwrite=overwrite, bulk=bulk, create_concepts=create_concepts, create_collections=create_collections)
else:
print('*'*80)
print('ERROR: No mapping file detected. Please indicate one with the \'-c\' paramater or place one in the same directory as your business data.')
print('*'*80)
sys.exit()
elapsed = (time() - start)
print('Time to import_business_data = {0}'.format(datetime.timedelta(seconds=elapsed)))
reader.report_errors()
finally:
datatype_factory = DataTypeFactory()
datatypes = DDataType.objects.all()
for datatype in datatypes:
datatype_instance = datatype_factory.get_instance(datatype.datatype)
datatype_instance.after_update_all()
def bulk_save(resources):
"""
Saves and indexes a list of resources
Arguments:
resources -- a list of resource models
"""
se = SearchEngineFactory().create()
datatype_factory = DataTypeFactory()
node_datatypes = {
str(nodeid): datatype
for nodeid, datatype in models.Node.objects.values_list(
'nodeid', 'datatype')
}
tiles = []
documents = []
term_list = []
for resource in resources:
resource.tiles = resource.get_flattened_tiles()
tiles.extend(resource.tiles)
# need to save the models first before getting the documents for index
Resource.objects.bulk_create(resources)
TileModel.objects.bulk_create(tiles)
for resource in resources:
resource.save_edit(edit_type='create')
document, terms = resource.get_documents_to_index(
fetchTiles=False,
datatype_factory=datatype_factory,
node_datatypes=node_datatypes)
document['root_ontology_class'] = resource.get_root_ontology()
documents.append(
se.create_bulk_item(index='resources',
id=document['resourceinstanceid'],
data=document))
for term in terms:
term_list.append(
se.create_bulk_item(index='terms',
id=term['_id'],
data=term['_source']))
for tile in tiles:
tile.save_edit(edit_type='tile create', new_value=tile.data)
# bulk index the resources, tiles and terms
se.bulk_index(documents)
se.bulk_index(term_list)
def get_provisional_edit(self, doc, tile, sync_user_id, db):
if doc["provisionaledits"] != "":
if sync_user_id in doc["provisionaledits"]:
user_edit = doc["provisionaledits"][sync_user_id]
for nodeid, value in iter(list(user_edit["value"].items())):
datatype_factory = DataTypeFactory()
node = models.Node.objects.get(nodeid=nodeid)
datatype = datatype_factory.get_instance(node.datatype)
newvalue = datatype.process_mobile_data(tile, node, db, doc, value)
if newvalue is not None:
user_edit["value"][nodeid] = newvalue
return user_edit["value"]
else:
return None
def get(self, request, resourceid=None, include_display_values=True):
datatype_factory = DataTypeFactory()
nodeid = request.GET.get("nodeid", None)
search_term = request.GET.get("term", None)
permitted_tiles = []
perm = "read_nodegroup"
tiles = models.TileModel.objects.filter(resourceinstance_id=resourceid)
if nodeid is not None:
node = models.Node.objects.get(pk=nodeid)
tiles = tiles.filter(nodegroup=node.nodegroup)
for tile in tiles:
if request.user.has_perm(perm, tile.nodegroup):
tile = Tile.objects.get(pk=tile.tileid)
tile.filter_by_perm(request.user, perm)
tile_dict = model_to_dict(tile)
if include_display_values:
tile_dict["display_values"] = []
for node in models.Node.objects.filter(
nodegroup=tile.nodegroup):
if str(node.nodeid) in tile.data:
datatype = datatype_factory.get_instance(
node.datatype)
display_value = datatype.get_display_value(
tile, node)
if display_value is not None:
if search_term is not None and search_term in display_value:
tile_dict["display_values"].append({
"value":
display_value,
"label":
node.name,
"nodeid":
node.nodeid
})
elif search_term is None:
tile_dict["display_values"].append({
"value":
display_value,
"label":
node.name,
"nodeid":
node.nodeid
})
if search_term is None:
permitted_tiles.append(tile_dict)
elif len(tile_dict["display_values"]) > 0:
permitted_tiles.append(tile_dict)
return JSONResponse({"tiles": permitted_tiles})
def index(self):
"""
Indexes all the nessesary items values of a resource to support search
"""
if unicode(self.graph_id) != unicode(settings.SYSTEM_SETTINGS_RESOURCE_MODEL_ID):
se = SearchEngineFactory().create()
datatype_factory = DataTypeFactory()
node_datatypes = {str(nodeid): datatype for nodeid, datatype in models.Node.objects.values_list('nodeid', 'datatype')}
document, terms = self.get_documents_to_index(datatype_factory=datatype_factory, node_datatypes=node_datatypes)
document['root_ontology_class'] = self.get_root_ontology()
se.index_data('resource', self.graph_id, JSONSerializer().serializeToPython(document), id=self.pk)
for term in terms:
se.index_data('strings', 'term', term['_source'], id=term['_id'])
def __init__(self, search_request=None):
if search_request is None:
raise Exception("Need to pass in a search request")
search_request.GET = search_request.GET.copy()
search_request.GET["tiles"] = True
search_request.GET["export"] = True
self.compact = search_request.GET.get("compact", True)
self.precision = int(search_request.GET.get("precision", 5))
self.search_request = search_request
self.datatype_factory = DataTypeFactory()
self.node_lookup = {}
self.output = {}
self.set_precision = GeoUtils().set_precision
def index(self):
"""
Indexes all the nessesary items values of a resource to support search
"""
if str(self.graph_id) != str(settings.SYSTEM_SETTINGS_RESOURCE_MODEL_ID):
se = SearchEngineFactory().create()
datatype_factory = DataTypeFactory()
node_datatypes = {str(nodeid): datatype for nodeid, datatype in models.Node.objects.values_list("nodeid", "datatype")}
document, terms = self.get_documents_to_index(datatype_factory=datatype_factory, node_datatypes=node_datatypes)
document["root_ontology_class"] = self.get_root_ontology()
doc = JSONSerializer().serializeToPython(document)
se.index_data(index="resources", body=doc, id=self.pk)
for term in terms:
se.index_data("terms", body=term["_source"], id=term["_id"])
def __init__(self, **kwargs):
super(CsvWriter, self).__init__(**kwargs)
self.datatype_factory = DataTypeFactory()
self.node_datatypes = {
str(nodeid): datatype
for nodeid, datatype in Node.objects.values_list(
'nodeid', 'datatype').filter(~Q(datatype='semantic'),
graph__isresource=True)
}
self.single_file = kwargs.pop('single_file', False)
self.resource_export_configs = self.read_export_configs(
kwargs.pop('configs', None))
if len(self.resource_export_configs) == 0:
raise MissingConfigException()
def validate(self,
value,
row_number=None,
source="",
node=None,
nodeid=None):
errors = []
# iterate list of values and use the concept validation on each one
if value is not None:
validate_concept = DataTypeFactory().get_instance("concept")
for v in value:
val = v.strip()
errors += validate_concept.validate(val, row_number)
return errors
def get_context_data(self, **kwargs):
datatype_factory = DataTypeFactory()
context = super(BaseManagerView, self).get_context_data(**kwargs)
context[
'system_settings_graphid'] = settings.SYSTEM_SETTINGS_RESOURCE_MODEL_ID
context['graph_models'] = models.GraphModel.objects.all().exclude(
graphid=settings.SYSTEM_SETTINGS_RESOURCE_MODEL_ID)
context['graphs'] = JSONSerializer().serialize(context['graph_models'])
context['createable_resources'] = JSONSerializer().serialize(
get_createable_resource_types(self.request.user))
context['nav'] = {
'icon': 'fa fa-chevron-circle-right',
'title': '',
'help': ('', ''),
'menu': False,
'search': True,
'res_edit': False,
'login': True,
'print': False,
}
geom_datatypes = [
d.pk for d in models.DDataType.objects.filter(isgeometric=True)
]
geom_nodes = models.Node.objects.filter(
graph__isresource=True,
graph__isactive=True,
datatype__in=geom_datatypes).exclude(
graph__graphid=settings.SYSTEM_SETTINGS_RESOURCE_MODEL_ID)
resource_layers = []
resource_sources = []
for node in geom_nodes:
if self.request.user.has_perm('read_nodegroup', node.nodegroup):
datatype = datatype_factory.get_instance(node.datatype)
map_source = datatype.get_map_source(node)
if map_source is not None:
resource_sources.append(map_source)
map_layer = datatype.get_map_layer(node)
if map_layer is not None:
resource_layers.append(map_layer)
context['app_name'] = settings.APP_NAME
context['geom_nodes'] = geom_nodes
context['resource_map_layers'] = resource_layers
context['resource_map_sources'] = resource_sources
context['iiif_manifests'] = models.IIIFManifest.objects.all()
return context
def bulk_save(resources):
"""
Saves and indexes a list of resources
Arguments:
resources -- a list of resource models
"""
se = SearchEngineFactory().create()
datatype_factory = DataTypeFactory()
node_datatypes = {str(nodeid): datatype for nodeid, datatype in models.Node.objects.values_list("nodeid", "datatype")}
tiles = []
documents = []
term_list = []
for resource in resources:
resource.tiles = resource.get_flattened_tiles()
tiles.extend(resource.tiles)
# need to save the models first before getting the documents for index
start = time()
Resource.objects.bulk_create(resources)
TileModel.objects.bulk_create(tiles)
print(f"Time to bulk create tiles and resources: {datetime.timedelta(seconds=time() - start)}")
start = time()
for resource in resources:
resource.save_edit(edit_type="create")
resources[0].tiles[0].save_edit(note=f"Bulk created: {len(tiles)} for {len(resources)} resources.", edit_type="bulk_create")
print("Time to save resource edits: %s" % datetime.timedelta(seconds=time() - start))
for resource in resources:
start = time()
document, terms = resource.get_documents_to_index(
fetchTiles=False, datatype_factory=datatype_factory, node_datatypes=node_datatypes
)
documents.append(se.create_bulk_item(index="resources", id=document["resourceinstanceid"], data=document))
for term in terms:
term_list.append(se.create_bulk_item(index="terms", id=term["_id"], data=term["_source"]))
se.bulk_index(documents)
se.bulk_index(term_list)
def check_for_missing_nodes(self, request):
missing_nodes = []
for nodeid, value in self.data.iteritems():
datatype_factory = DataTypeFactory()
node = models.Node.objects.get(nodeid=nodeid)
datatype = datatype_factory.get_instance(node.datatype)
datatype.clean(self, nodeid)
if request is not None:
datatype.handle_request(self, request, node)
if self.data[nodeid] == None and node.isrequired == True:
missing_nodes.append(node.name)
if missing_nodes != []:
message = _(
'This card requires values for the following:')
raise ValidationError(message,
(', ').join(missing_nodes))
def validate(self, errors=None):
for nodeid, value in self.data.iteritems():
datatype_factory = DataTypeFactory()
node = models.Node.objects.get(nodeid=nodeid)
datatype = datatype_factory.get_instance(node.datatype)
error = datatype.validate(value)
for error_instance in error:
if error_instance['type'] == 'ERROR':
print(
str(error_instance) + " rejected tile with pk: " +
str(self.pk))
raise TileValidationError(
_("Your tile: {0} ".format(error_instance["message"])))
if errors != None:
errors += error
return errors
def __init__(self, search_request=None):
if search_request is None:
raise Exception("Need to pass in a search request")
search_request.GET = search_request.GET.copy()
search_request.GET["tiles"] = True
search_request.GET["export"] = True
self.format = search_request.GET.get("format", "tilecsv")
self.compact = search_request.GET.get("compact", True)
self.precision = int(search_request.GET.get("precision", 5))
if self.format == "shp" and self.compact is not True:
raise Exception("Results must be compact to export to shapefile")
self.search_request = search_request
self.datatype_factory = DataTypeFactory()
self.node_lookup = {}
self.output = {}
self.set_precision = GeoUtils().set_precision
def from_tile(cls, tile, node_tile_reference, datatype_factory=None, compact=False, hide_empty_nodes=False, as_json=True):
"""
Generates a label-based graph from a given tile
"""
if not datatype_factory:
datatype_factory = DataTypeFactory()
graph = cls._build_graph(
node=models.Node.objects.get(pk=tile.nodegroup_id),
tile=tile,
parent_tree=None,
tile_reference=node_tile_reference,
datatype_factory=datatype_factory,
)
return graph.as_json(include_empty_nodes=bool(not hide_empty_nodes)) if as_json else graph
def get_context_data(self, **kwargs):
datatype_factory = DataTypeFactory()
context = super(BaseManagerView, self).get_context_data(**kwargs)
context['graph_models'] = models.GraphModel.objects.all()
context['graphs'] = JSONSerializer().serialize(context['graph_models'])
if 'Resource Editor' in self.request.user.user_groups:
context['resource_instances'] = Resource.objects.all().order_by(
'-createdtime')[:100]
else:
context['resource_instances'] = []
context['nav'] = {
'icon': 'fa fa-chevron-circle-right',
'title': '',
'help': ('', ''),
'menu': False,
'search': True,
'res_edit': False,
'edit_history': True,
'login': True,
'print': False,
}
geom_datatypes = [
d.pk for d in models.DDataType.objects.filter(isgeometric=True)
]
geom_nodes = models.Node.objects.filter(graph__isresource=True,
graph__isactive=True,
datatype__in=geom_datatypes)
resource_layers = []
resource_sources = []
for node in geom_nodes:
# TODO: check user node level permissions here, if user does not
# have read permissions on this node, then do not create map layer
# or source
datatype = datatype_factory.get_instance(node.datatype)
map_source = datatype.get_map_source(node)
if map_source is not None:
resource_sources.append(map_source)
map_layer = datatype.get_map_layer(node)
if map_layer is not None:
resource_layers.append(map_layer)
context['geom_nodes'] = geom_nodes
context['resource_map_layers'] = resource_layers
context['resource_map_sources'] = resource_sources
context['iiif_manifests'] = models.IIIFManifest.objects.all()
return context
def get(self, request):
datatype_factory = DataTypeFactory()
datatypes = models.DDataType.objects.all()
widgets = models.Widget.objects.all()
map_layers = models.MapLayer.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_sources=map_sources,
datatypes_json=JSONSerializer().serialize(datatypes),
main_script='views/map-layer-manager',
)
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:
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)
card = Card.objects.get(nodegroup_id=node.nodegroup_id)
permissions[str(node.pk)] = {
"users": card.users,
"groups": card.groups,
}
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'] = (_('Map Layer Manager'),
'help/map-manager-help.htm')
return render(request, 'views/map-layer-manager.htm', context)
def get_tileserver_config(layer_id):
database = settings.DATABASES['default']
datatype_factory = DataTypeFactory()
try:
node = models.Node.objects.get(pk=layer_id)
# TODO: check user node permissions here, if user
# does not have read access to this node, fire an exception
datatype = datatype_factory.get_instance(node.datatype)
layer_config = datatype.get_layer_config(node)
except Exception:
layer_model = models.TileserverLayer.objects.get(name=layer_id)
layer_config = layer_model.config
config_dict = {"cache": settings.TILE_CACHE_CONFIG, "layers": {}}
config_dict["layers"][str(layer_id)] = layer_config
return config_dict
def post(self, request):
datatype_factory = DataTypeFactory()
tileid = request.POST.get("tileid")
nodeid = request.POST.get("nodeid")
data = request.POST.get("data")
resourceid = request.POST.get("resourceinstanceid", None)
try:
node = models.Node.objects.get(nodeid=nodeid)
datatype = datatype_factory.get_instance(node.datatype)
except Exception as e:
return JSONResponse(e)
data = datatype.process_api_data(data)
new_tile = tile_model.update_node_value(nodeid,
data,
tileid,
resourceinstanceid=resourceid)
response = JSONResponse(new_tile)
return response
def save(self, *args, **kwargs):
request = kwargs.pop('request', None)
index = kwargs.pop('index', True)
self.__preSave(request)
if self.data != {}:
for nodeid, value in self.data.iteritems():
datatype_factory = DataTypeFactory()
datatype = datatype_factory.get_instance(
models.Node.objects.get(nodeid=nodeid).datatype)
datatype.convert_value(self, nodeid)
super(Tile, self).save(*args, **kwargs)
if index:
self.index()
for tiles in self.tiles.itervalues():
for tile in tiles:
tile.resourceinstance = self.resourceinstance
tile.parenttile = self
tile.save(*args, request=request, index=index, **kwargs)
def check_for_missing_nodes(self, request):
missing_nodes = []
for nodeid, value in self.data.iteritems():
datatype_factory = DataTypeFactory()
node = models.Node.objects.get(nodeid=nodeid)
datatype = datatype_factory.get_instance(node.datatype)
datatype.clean(self, nodeid)
if request is not None:
if self.data[nodeid] is None and node.isrequired is True:
if len(node.cardxnodexwidget_set.all()) > 0:
missing_nodes.append(
node.cardxnodexwidget_set.all()[0].label)
else:
missing_nodes.append(node.name)
if missing_nodes != []:
message = _('This card requires values for the following: ')
message += (', ').join(missing_nodes)
raise TileValidationError(message)
def from_resource(cls, resource, datatype_factory=None, node_cache=None, compact=False, hide_empty_nodes=False, as_json=True):
"""
Generates a label-based graph from a given resource
"""
if not datatype_factory:
datatype_factory = DataTypeFactory()
if node_cache is None: # need explicit None comparison
node_cache = {}
if not resource.tiles:
resource.load_tiles()
node_ids_to_tiles_reference = cls.generate_node_ids_to_tiles_reference(resource=resource)
root_label_based_node = LabelBasedNode(name=None, node_id=None, tile_id=None, value=None)
for tile in resource.tiles:
label_based_graph = LabelBasedGraph.from_tile(
tile=tile,
node_ids_to_tiles_reference=node_ids_to_tiles_reference,
datatype_factory=datatype_factory,
node_cache=node_cache,
compact=compact,
hide_empty_nodes=hide_empty_nodes,
as_json=False,
)
if label_based_graph:
root_label_based_node.child_nodes.append(label_based_graph)
if as_json:
root_label_based_node_json = root_label_based_node.as_json(compact=compact, include_empty_nodes=bool(not hide_empty_nodes))
_dummy_resource_name, resource_graph = root_label_based_node_json.popitem()
# removes unneccesary ( None ) top-node values
for key in [NODE_ID_KEY, TILE_ID_KEY, VALUE_KEY]:
if key in resource_graph:
resource_graph.pop(key)
return resource_graph
else: # pragma: no cover
return root_label_based_node
def index_resources_by_type(resource_types, clear_index=True, batch_size=settings.BULK_IMPORT_BATCH_SIZE):
"""
Indexes all resources of a given type(s)
Arguments:
resource_types -- array of graph ids that represent resource types
Keyword Arguments:
clear_index -- set to True to remove all the resources of the types passed in from the index before the reindexing operation
batch_size -- the number of records to index as a group, the larger the number to more memory required
"""
se = SearchEngineFactory().create()
datatype_factory = DataTypeFactory()
node_datatypes = {str(nodeid): datatype for nodeid, datatype in models.Node.objects.values_list('nodeid', 'datatype')}
for resource_type in resource_types:
start = datetime.now()
resources = Resource.objects.filter(graph_id=str(resource_type))
graph_name = models.GraphModel.objects.get(graphid=str(resource_type)).name
print "Indexing resource type '{0}'".format(graph_name)
result_summary = {'database': len(resources), 'indexed': 0}
q = Query(se=se)
term = Term(field='graph_id', term=str(resource_type))
q.add_query(term)
if clear_index:
q.delete(index='resources', refresh=True)
with se.BulkIndexer(batch_size=batch_size, refresh=True) as doc_indexer:
with se.BulkIndexer(batch_size=batch_size, refresh=True) as term_indexer:
for resource in resources:
document, terms = resource.get_documents_to_index(fetchTiles=True, datatype_factory=datatype_factory, node_datatypes=node_datatypes)
doc_indexer.add(index='resources', id=document['resourceinstanceid'], data=document)
for term in terms:
term_indexer.add(index='terms', id=term['_id'], data=term['_source'])
result_summary['indexed'] = se.count(index='resources', body=q.dsl)
status = 'Passed' if result_summary['database'] == result_summary['indexed'] else 'Failed'
print "Status: {0}, Resource Type: {1}, In Database: {2}, Indexed: {3}, Took: {4} seconds".format(status, graph_name, result_summary['database'], result_summary['indexed'], (datetime.now()-start).seconds)
return status
def get(self, request, resourceid=None):
if Resource.objects.filter(pk=resourceid).exists():
try:
active_cons_node_list = {
"Geospatial Location": "8d41e4d6-a250-11e9-accd-00224800b26d",
"Name": "8d41e4ab-a250-11e9-87d1-00224800b26d",
"Consultation Type": "8d41e4dd-a250-11e9-9032-00224800b26d",
"Proposal": "8d41e4bd-a250-11e9-89e8-00224800b26d",
"Casework Officer": "8d41e4d4-a250-11e9-a3ff-00224800b26d",
"Target Date": "8d41e4cb-a250-11e9-9cf2-00224800b26d",
"Consultation Log Date": "8d41e4cf-a250-11e9-a86d-00224800b26d",
"Completion Date": "8d41e4cd-a250-11e9-a25b-00224800b26d",
"Development Type": "8d41e4cc-a250-11e9-87b3-00224800b26d",
"Application Type": "8d41e4d5-a250-11e9-b968-00224800b26d",
"Application Area": "8d41e4de-a250-11e9-973b-00224800b26d",
"Casework Officer": "8d41e4d4-a250-11e9-a3ff-00224800b26d",
"Planning Officer": "8d41e4d7-a250-11e9-83c2-00224800b26d",
"Owner": "8d41e4e1-a250-11e9-8d14-00224800b26d",
"Applicant": "8d41e4ce-a250-11e9-b83c-00224800b26d",
"Agent": "8d41e4d9-a250-11e9-82dc-00224800b26d",
}
resource = Resource.objects.get(pk=resourceid)
se = SearchEngineFactory().create()
document = se.search(index='resources', id=resourceid, doc_type='_doc')
datatype_factory = DataTypeFactory()
additional_data = {}
if document['_source']['graph_id'] == '8d41e49e-a250-11e9-9eab-00224800b26d':
tiles = build_resource_dict([resource], active_cons_node_list, datatype_factory)
additional_data = tiles[0]
ret = {
'graphid': document['_source']['graph_id'],
'graph_name': resource.graph.name,
'displaydescription': document['_source']['displaydescription'],
'map_popup': document['_source']['map_popup'],
'displayname': document['_source']['displayname'],
'geometries': document['_source']['geometries']
}
ret.update(additional_data)
return JSONResponse(ret)
except Exception as e:
logger.exception(_('Failed to fetch resource instance descriptors'))
return HttpResponseNotFound()
def get(self, request):
# data = JSONDeserializer().deserialize(request.body)
datatype_factory = DataTypeFactory()
template_id = request.GET.get('template_id')
resourceinstance_id = request.GET.get('resourceinstance_id', None)
self.resource = Resource.objects.get(resourceinstanceid=resourceinstance_id)
self.resource.load_tiles()
consultation_instance_id = None
consultation = None
for tile in self.resource.tiles: # self.resource is of communication model
if 'a5901911-6d1e-11e9-8674-dca90488358a' in tile.data.keys(): # related-consultation nodegroup
consultation_instance_id = tile.data['a5901911-6d1e-11e9-8674-dca90488358a'][0]
template_name = self.get_template_path(template_id)
template_path = os.path.join(settings.APP_ROOT, 'docx', template_name)
self.doc = Document(template_path)
new_file_name = None
new_file_path = None
if consultation_instance_id is not None:
consultation = Resource.objects.get(resourceinstanceid=consultation_instance_id)
consultation.load_tiles()
if template_name == 'GLAAS Planning Letter A - No Progression - template.docx':
self.edit_letter_A(consultation, datatype_factory)
elif template_name == 'GLAAS Planning Letter B2 - Predetermination - template.docx':
self.edit_letter_B2(consultation, datatype_factory)
new_file_name = 'edited_'+template_name
new_file_path = os.path.join(settings.APP_ROOT, 'uploadedfiles/docx', new_file_name)
self.doc.save(new_file_path)
# with open(new_file_path, "rb") as docx_file:
# result = mammoth.convert_to_html(docx_file)
# html = result.value # The generated HTML
# with open(html_path, 'wb') as html_file:
# html_file.write(html)
# html_file.close()
if resourceinstance_id is not None:
return JSONResponse({'resource': self.resource, 'template': new_file_path, 'download': 'http://localhost:8000/files/uploadedfiles/docx/'+new_file_name })
return HttpResponseNotFound()
def index(self):
"""
Indexes all the nessesary items values of a resource to support search
"""
if str(self.graph_id) != str(settings.SYSTEM_SETTINGS_RESOURCE_MODEL_ID):
datatype_factory = DataTypeFactory()
node_datatypes = {str(nodeid): datatype for nodeid, datatype in models.Node.objects.values_list("nodeid", "datatype")}
document, terms = self.get_documents_to_index(datatype_factory=datatype_factory, node_datatypes=node_datatypes)
document["root_ontology_class"] = self.get_root_ontology()
doc = JSONSerializer().serializeToPython(document)
se.index_data(index=RESOURCES_INDEX, body=doc, id=self.pk)
for term in terms:
se.index_data("terms", body=term["_source"], id=term["_id"])
for index in settings.ELASTICSEARCH_CUSTOM_INDEXES:
es_index = import_class_from_string(index["module"])(index["name"])
doc, doc_id = es_index.get_documents_to_index(self, document["tiles"])
es_index.index_document(document=doc, id=doc_id)
def __init__(self):
self.tiles = {}
self.errors = {}
self.resources = []
self.use_ids = False
self.datatype_factory = DataTypeFactory()
self.resource_model_root_classes = set()
self.non_unique_classes = set()
self.graph_id_lookup = {}
for graph in models.GraphModel.objects.filter(isresource=True):
node = models.Node.objects.get(graph_id=graph.pk, istopnode=True)
self.graph_id_lookup[node.ontologyclass] = graph.pk
if node.ontologyclass in self.resource_model_root_classes:
#make a note of non-unique root classes
self.non_unique_classes.add(node.ontologyclass)
else:
self.resource_model_root_classes.add(node.ontologyclass)
self.resource_model_root_classes = self.resource_model_root_classes - self.non_unique_classes
self.ontologyproperties = models.Edge.objects.values_list(
'ontologyproperty', flat=True).distinct()
