def write_properties(cur, sb, lang, filename):
cur.execute(
"SELECT properties.propertyid, properties.propertyname, properties.propertydisplay "
"FROM ontology.properties;")
rows = cur.fetchall()
sb.writelines(
["Arches.createNamespace('Arches.i18n.DomainData.Properties');\n"])
a = None
data = []
for row in rows:
a = Property()
a.propertyid = row[0]
a.propertyname = row[1]
a.displayvalue = row[2]
data.append(a)
ret = "Arches.i18n.DomainData.Properties=" + JSONSerializer().serialize(
data, ensure_ascii=False) + ";\n"
sb.writelines(ret)
utils.WriteToFile(filename, sb.getvalue(), 'a')
sb.truncate(0)
def Logout(request):
GR = GenericResponse()
logout(request)
GR.status_code = 0
GR.success = True
GR.message = "Logout successful"
return HttpResponse(JSONSerializer().serialize(GR))
def search_terms(request):
se = SearchEngineFactory().create()
searchString = request.GET['q']
return HttpResponse(JSONSerializer().serialize(se.search(
searchString.lower(),
index='term',
type='value',
search_field='term',
use_fuzzy=True),
ensure_ascii=False))
def Search(request):
se = SearchEngineFactory().create()
searchString = request.GET['q']
search_results = _normalize_spatial_results_to_wkt(
se.search(searchString.lower(),
index='entity',
type='',
search_field='strings',
use_phrase=True))
return HttpResponse(JSONSerializer().serialize(search_results,
ensure_ascii=False))
def Concept(request, ids):
full_graph = request.GET.get('full_graph', 'true') == 'true'
exclude_subconcepts = request.GET.get('exclude_subconcepts',
'false') == 'true'
exclude_parentconcepts = request.GET.get('exclude_parentconcepts',
'false') == 'true'
exclude_notes = request.GET.get('exclude_notes', 'false') == 'true'
exclude_labels = request.GET.get('exclude_labels', 'false') == 'true'
exclude_metadata = request.GET.get('exclude_metadata', 'false') == 'true'
emulate_elastic_search = request.GET.get('emulate_elastic_search',
'true') == 'true'
fromdb = request.GET.get('fromdb', 'false') == 'true'
ret = []
if request.method == 'GET':
if fromdb:
for id in ids.split(','):
if ".E" in id:
entitytype = archesmodels.EntityTypes.objects.get(pk=id)
concept = entitytype.conceptid
else:
concept = archesmodels.Concepts.objects.get(conceptid=id)
concept_graph = concept.toObject(
full_graph=full_graph,
exclude_subconcepts=exclude_subconcepts,
exclude_parentconcepts=exclude_parentconcepts,
exclude_notes=exclude_notes,
exclude_labels=exclude_labels,
exclude_metadata=exclude_metadata)
if emulate_elastic_search:
ret.append({'_type': id, '_source': concept_graph})
else:
ret.append(concept_graph)
if emulate_elastic_search:
ret = {'hits': {'hits': ret}}
else:
se = SearchEngineFactory().create()
ret = se.search('',
index='concept',
type=ids,
search_field='value',
use_wildcard=True)
return HttpResponse(JSONSerializer().serialize(ret,
ensure_ascii=True,
indent=4))
def GetUser(request):
GR = GenericResponse()
if request.user.is_authenticated():
GR.returnObj = request.user
GR.status_code = 0
GR.success = True
GR.message = ""
else:
GR.status_code = 1
GR.message = "User not authenticated"
return HttpResponse(JSONSerializer().serialize(GR))
def EntityTypes(request, entitytypeid):
entityschema = []
if entitytypeid == '':
return HttpResponse(JSONSerializer().serialize({},
ensure_ascii=True,
indent=4))
else:
if request.GET.get('f') is None:
return render_to_response('graph.htm', {},
context_instance=RequestContext(request))
else:
entityschema = {
entitytypeid: Entity.get_mapping_schema(entitytypeid)
}
if request.GET.get('f') == 'json':
return HttpResponse(JSONSerializer().serialize(
entityschema, ensure_ascii=True, indent=4),
content_type='application/json')
if request.GET.get('f') == 'd3':
d3Schema = d3Obj()
d3Schema.name = entitytypeid
for assestAttr in entityschema[entitytypeid]:
d3ObjAssestAttr = d3Obj()
d3ObjAssestAttr.name = assestAttr
for step in entityschema[entitytypeid][assestAttr][
'steps']:
d3ObjStep = d3Obj()
d3ObjStep.name = step['entitytypedomain'] + ' ' + step[
'propertyid'] + ' ' + step['entitytyperange']
d3ObjAssestAttr.children.append(d3ObjStep)
d3Schema.children.append(d3ObjAssestAttr)
return HttpResponse(JSONSerializer().serialize(
d3Schema, ensure_ascii=True, indent=4))
def index_concepts_by_entitytypeid(self, entitytypeid):
entitytype = archesmodels.EntityTypes.objects.get(pk=entitytypeid)
concept_graph = entitytype.conceptid.toObject(
full_graph=True, exclude_parentconcepts=True, exclude_notes=True)
if len(concept_graph.subconcepts) > 0:
data = JSONSerializer().serializeToPython(concept_graph,
ensure_ascii=True,
indent=4)
self.index(data,
'concept',
entitytypeid,
'id',
processdoc=None,
getid=None,
bulk=False)
def MapLayers(request, entitytypeid):
data = []
bbox = request.GET['bbox']
limit = request.GET.get('limit', 10000)
try:
se = SearchEngineFactory().create()
data = se.search('',
index="maplayers",
type=entitytypeid,
end_offset=limit)
except:
pass
return HttpResponse(JSONSerializer().serialize(data,
ensure_ascii=True,
indent=4))
def _normalize_spatial_results_to_wkt(search_results):
for search_result in search_results['hits']['hits']:
if settings.ENTITY_TYPE_FOR_MAP_DISPLAY in search_result['_source']:
wkts = []
for geom in search_result['_source'][
settings.ENTITY_TYPE_FOR_MAP_DISPLAY]:
wkts.append(
GEOSGeometry(JSONSerializer().serialize(
geom, ensure_ascii=False)).wkt)
search_result['_source'][
settings.ENTITY_TYPE_FOR_MAP_DISPLAY] = wkts
wkts = []
for geom in search_result['_source']['geometries']:
wkts.append(GEOSGeometry(geom).wkt)
search_result['_source']['geometries'] = wkts
return search_results
def write_app_config(cur, sb, filename):
cur.execute("SELECT name, defaultvalue, datatype "
"FROM app_metadata.app_config "
"WHERE isprivate = False;")
rows = cur.fetchall()
sb.writelines(["Ext.namespace('Arches.config.App');\n"])
sb.writelines(["Arches.config.App = {\n"])
data = []
currententitytypeid = ''
for row in rows:
if row[2] == 'text':
data.append("\t" + row[0] + ": '" + row[1] + "'")
else:
data.append("\t" + row[0] + ": " + row[1] + "")
# find primary name information
entitytypes = archesmodels.EntityTypes.objects.filter(
pk=settings.PRIMARY_DISPLAY_NAME_LOOKUPS['entity_type'])
if len(entitytypes) == 1:
concept = entitytypes[0].conceptid
concept_graph = concept.toObject(full_graph=True)
def findLabel(concept, labelToFind):
for label in concept.labels:
if label.value == labelToFind:
return label
if (len(concept.subconcepts) > 0):
for subconcept in concept.subconcepts:
return findLabel(subconcept, labelToFind)
concept_label = findLabel(
concept_graph,
settings.PRIMARY_DISPLAY_NAME_LOOKUPS['lookup_value'])
data.append("\tprimaryNameInfo:%s" % (JSONSerializer().serialize(
concept_label, ensure_ascii=False, indent=8)))
data.append("\tarches_version:'%s'" % version.__VERSION__)
sb.writelines(",\n".join(data) + "\n};")
utils.WriteToFile(filename, sb.getvalue(), 'w')
sb.truncate(0)
def write_information_themes(cur, sb, lang, filename):
cur.execute("""
SELECT a.informationthemeid,
app_metadata.get_i18n_value(a.name_i18n_key, '""" + lang +
"""', '') as name,
a.displayclass,
a.entitytypeid,
d.formid,
d.sortorder
FROM app_metadata.information_themes a
LEFT JOIN app_metadata.information_themes_x_forms d ON a.informationthemeid = d.informationthemeid
order by informationthemeid;
""")
rows = cur.fetchall()
sb.writelines([
"Arches.createNamespace('Arches.i18n.DomainData.InformationThemes');\n"
])
a = None
data = []
currententitytypeid = ''
for row in rows:
if currententitytypeid != row[0] and currententitytypeid != '':
data.append(a)
if currententitytypeid != row[0]:
currententitytypeid = row[0]
a = InformationTheme()
a.id = row[0]
a.name = row[1]
a.displayclass = row[2]
a.entitytypeid = row[3]
if currententitytypeid == row[0]:
a.forms.append({'formid': row[4], 'sortorder': row[5]})
if a != None:
data.append(a)
ret = "Arches.i18n.DomainData.InformationThemes=" + JSONSerializer(
).serialize(data, ensure_ascii=False) + ";\n"
sb.writelines(ret)
utils.WriteToFile(filename, sb.getvalue(), 'a')
sb.truncate(0)
def write_localized_displays(cur, sb, lang, filename):
cur.execute("SELECT labelid, label "
"FROM concepts.labels "
"WHERE languageid = '" + lang + "';")
rows = cur.fetchall()
a = None
data = {}
for row in rows:
data[row[0]] = row[1]
ret = "Arches.i18n.DomainData.ConceptSchemaLabels=" + JSONSerializer(
).serialize(data, ensure_ascii=True) + ";\n"
sb.writelines(ret)
utils.WriteToFile(filename, sb.getvalue(), 'a')
sb.truncate(0)
def Login(request):
username = request.POST['username']
password = request.POST['password']
user = authenticate(username=username, password=password)
GR = GenericResponse()
GR.returnObj = user
if user is not None:
if user.is_active:
login(request, user)
GR.success = True
GR.status_code = 0
else:
# Return a 'disabled account' error message
GR.message = 'account disabled'
# don't send the password even if it is hashed
user.password = ''
else:
# Return an 'invalid login' error message.
GR.message = 'invalid login'
return HttpResponse(JSONSerializer().serialize(GR))
def write_forms(cur, sb, lang, filename):
cur.execute("SELECT formid, app_metadata.get_i18n_value(name_i18n_key, '" +
lang + "', widgetname) as name, widgetname "
"FROM app_metadata.forms;")
rows = cur.fetchall()
sb.writelines(
["Arches.createNamespace('Arches.i18n.DomainData.Forms');\n"])
data = []
for row in rows:
a = Form()
a.id = row[0]
a.name = row[1]
a.widgetname = row[2]
data.append(a)
ret = "Arches.i18n.DomainData.Forms=" + JSONSerializer().serialize(
data, ensure_ascii=False) + ";\n"
sb.writelines(ret)
utils.WriteToFile(filename, sb.getvalue(), 'a')
sb.truncate(0)
def Entities(request, entityid):
entity = []
if request.method == 'GET':
if entityid == '':
pass
else:
showlabels = request.GET.get('labeled', False) == 'true'
entity = Entity().get(entityid, showlabels=showlabels)
else:
if not request.user.is_authenticated():
raise Exception(
'User must be logged in to insert, update, or delete entities')
if request.method == 'POST':
data = JSONDeserializer().deserialize(request.body)
if not isinstance(data, list):
data = [data]
for each_entity in data:
entity = Entity(each_entity)
if entity.entityid != '':
entity.delete_index()
entity.save(username=request.user.username)
entity.index()
elif request.method == 'DELETE':
data = JSONDeserializer().deserialize(request.body)
if not isinstance(data, list):
data = [data]
for each_entity in data:
entity = Entity(each_entity)
entity.delete_index()
try:
entity.delete(delete_root=entity.get_rank() == 0)
except:
print "failed but going to pretend it worked"
return HttpResponse(JSONSerializer().serialize(entity,
ensure_ascii=True,
indent=4))
def EntityPOST(request):
obj = JSONDeserializer().deserialize(request.body)
return HttpResponse(JSONSerializer().serialize(obj, ensure_ascii=False))
def index(self):
"""
Gets a SearchResult object for a given asset entity
Used for populating the search index with searchable entity information
"""
if self.get_rank() == 0:
se = SearchEngineFactory().create()
search_result = {}
search_result['entityid'] = self.entityid
search_result['entitytypeid'] = self.entitytypeid
search_result['strings'] = []
search_result['geometries'] = []
search_result['concepts'] = []
term_entities = []
names = []
for name in self.get_primary_display_name():
names.append(name.value)
primary_display_name = ' '.join(names)
search_result['primaryname'] = primary_display_name
for enititytype in settings.SEARCHABLE_ENTITY_TYPES:
for entity in self.find_entities_by_type_id(enititytype):
search_result['strings'].append(entity.value)
term_entities.append(entity)
for geom_entity in self.find_entities_by_type_id(
settings.ENTITY_TYPE_FOR_MAP_DISPLAY):
search_result['geometries'].append(
fromstr(geom_entity.value).json)
mapfeature = MapFeature()
mapfeature.geomentityid = geom_entity.entityid
mapfeature.entityid = self.entityid
mapfeature.entitytypeid = self.entitytypeid
mapfeature.primaryname = primary_display_name
mapfeature.geometry = geom_entity.value
data = JSONSerializer().serializeToPython(mapfeature,
ensure_ascii=True,
indent=4)
se.index_data('maplayers',
self.entitytypeid,
data,
idfield='geomentityid')
def to_int(s):
try:
return int(s)
except ValueError:
return ''
def inspect_node(entity):
if entity.entitytypeid in settings.ADV_SEARCHABLE_ENTITY_TYPES or entity.entitytypeid in settings.SEARCHABLE_ENTITY_TYPES:
if entity.entitytypeid not in search_result:
search_result[entity.entitytypeid] = []
if entity.entitytypeid in settings.ENTITY_TYPE_FOR_MAP_DISPLAY:
search_result[entity.entitytypeid].append(
JSONDeserializer().deserialize(
fromstr(entity.value).json))
else:
search_result[entity.entitytypeid].append(entity.value)
self.traverse(inspect_node)
for entitytype, value in search_result.iteritems():
if entitytype in settings.ADV_SEARCHABLE_ENTITY_TYPES or entitytype in settings.SEARCHABLE_ENTITY_TYPES:
if entitytype in settings.ENTITY_TYPE_FOR_MAP_DISPLAY:
se.create_mapping('entity', self.entitytypeid,
entitytype, 'geo_shape')
else:
try:
uuid.UUID(value[0])
# SET FIELDS WITH UUIDS TO BE "NOT ANALYZED" IN ELASTIC SEARCH
se.create_mapping('entity', self.entitytypeid,
entitytype, 'string',
'not_analyzed')
except (ValueError):
pass
search_result[entitytype] = list(
set(search_result[entitytype]))
data = JSONSerializer().serializeToPython(search_result,
ensure_ascii=True,
indent=4)
se.index_data('entity',
self.entitytypeid,
data,
idfield=None,
id=self.entityid)
se.create_mapping('term', 'value', 'entityids', 'string',
'not_analyzed')
se.index_terms(term_entities)
return search_result
def write_entity_types(cur, sb, lang, filename):
cur.execute("""
SELECT
a.entitytypeid,
lbl.value AS entitytypename,
(SELECT n.value
FROM concepts.values n
WHERE n.conceptid = a.conceptid AND n.languageid = lbl.languageid
AND valuetype = 'scopeNote'
LIMIT 1) AS description,
lbl.languageid,
(SELECT r.widgetname
FROM app_metadata.reports r
LEFT JOIN app_metadata.entity_type_x_reports bb ON a.entitytypeid = bb.entitytypeid
LEFT JOIN app_metadata.reports cc ON r.reportid = cc.reportid
WHERE bb.entitytypeid = a.entitytypeid
LIMIT 1) AS reportwidget,
a.icon,
a.isresource,
a.conceptid,
a.groupid,
(SELECT value
FROM app_metadata.i18n
WHERE languageid = '""" + lang + """'
AND key = rg.name_i18n_key) AS groupname,
rg.displayclass AS groupdisplayclass
FROM data.entity_types a
LEFT JOIN concepts.concepts dv ON a.conceptid = dv.conceptid
LEFT JOIN concepts.values lbl ON dv.conceptid = lbl.conceptid
LEFT JOIN app_metadata.resource_groups rg on a.groupid = rg.groupid
WHERE 1=1
and lbl.valuetype = 'prefLabel'
order by entitytypeid;
""")
rows = cur.fetchall()
sb.writelines(
["Arches.createNamespace('Arches.i18n.DomainData.EntityTypes');\n"])
a = None
data = []
currententitytypeid = ''
for row in rows:
if currententitytypeid != row[0] and currententitytypeid != '':
data.append(a)
if currententitytypeid != row[0]:
currententitytypeid = row[0]
a = EntityType()
a.entitytypeid = row[0]
a.entitytypename = row[1]
a.description = row[2]
a.reportwidget = row[4]
a.icon = row[5]
a.isresource = row[6]
a.groupname = row[9]
a.groupdisplayclass = row[10]
if a != None:
data.append(a)
ret = "Arches.i18n.DomainData.EntityTypes=" + JSONSerializer().serialize(
data, ensure_ascii=False) + ";\n"
sb.writelines(ret)
utils.WriteToFile(filename, sb.getvalue(), 'a')
sb.truncate(0)
def write_map_layers(cur, sb, lang, filename):
""" Writes out all the layers in the maplayers table to the localized text files (en-us.js for example).
If there is more then 1 language defined for the app then all layers will be
written to every localized file regardless of whether the name of the of the MapLayer
has been locaized or not.
This is to make sure that all the layers are available in all languages regardless of
the status of the localization effort.
"""
basemaps = []
layergroups = []
sb.writelines(["Arches.createNamespace('Arches.i18n.MapLayers');\n"])
# first get the list of all layer ids
cur.execute(
"SELECT id FROM app_metadata.maplayers ORDER BY layergroup_i18n_key")
layerids = cur.fetchall()
for layerid in layerids:
# try and get the localized layer info
cur.execute(
"""SELECT id, active, on_map as \"onMap\", selectable,
basemap, app_metadata.get_i18n_value(name_i18n_key, %s, '') as name, icon, symbology, thumbnail,
app_metadata.get_i18n_value(description_i18n_key, %s, '') as description,
app_metadata.get_i18n_value(layergroup_i18n_key, %s, '') as layergroup, layer, sortorder
FROM app_metadata.maplayers
WHERE maplayers.id = %s """, [lang, lang, lang, layerid])
rows = dictfetchall(cur)
# if the layer name hasn't been localized fall back to the default language
if len(rows) == 0:
cur.execute(
"SELECT id, active, on_map as \"onMap\", selectable, "
"basemap, app_metadata.get_i18n_value(name_i18n_key, %s, '') as name, icon, symbology, thumbnail, "
"app_metadata.get_i18n_value(description_i18n_key, %s, '') as description, "
"app_metadata.get_i18n_value(layergroup_i18n_key, %s, '') as layergroup, layer, sortorder "
"FROM app_metadata.maplayers "
"WHERE maplayers.id = %s ", [lang, lang, lang, layerid])
rows = dictfetchall(cur)
# write out basemaps first
for row in rows:
if row['basemap'] == True:
basemaps.append(row)
# write out all other layers next
for row in rows:
if row['basemap'] == False:
if has_name(layergroups, row['layergroup']):
get_layergroup_by_name(
layergroups, row['layergroup']).layers.append(row)
else:
layergroups.append(LayerGroup(row['layergroup']))
get_layergroup_by_name(
layergroups, row['layergroup']).layers.append(row)
ret = "Arches.i18n.MapLayers.basemaps=" + JSONSerializer().serialize(
basemaps, ensure_ascii=False) + ";\n"
sb.writelines(ret)
utils.WriteToFile(filename, sb.getvalue(), 'a')
sb.truncate(0)
ret = "Arches.i18n.MapLayers.layerGroups=" + JSONSerializer().serialize(
layergroups, ensure_ascii=False) + ";\n"
sb.writelines(ret)
utils.WriteToFile(filename, sb.getvalue(), 'a')
sb.truncate(0)
