def add_result_from_survey(request, db_name, id, lon, lat, altim, ts, description, text, form, style, isdirty):
feature_definitions = json.loads(form)
table_name = feature_definitions['sectionname']
fields = get_fields_from_definition(feature_definitions['forms'])
survey = Survey.objects.filter(name=db_name).first()
section = SurveySection.objects.filter(name=table_name,survey_id=survey.id).first()
if survey and section:
sql=''
sql_fields='wkb_geometry,modified_by'
sql_values="ST_GeomFromEWKT('SRID="+str(section.srs)+";MULTIPOINT(("+str(lon)+" "+str(lat)+"))'),'" + request.user.username + "'"
for field in fields:
sql_fields = sql_fields + ',' + field['name']
value = field['value']
if field['type'] == 'character_varying':
value = "'" + field['value'] + "'"
sql_values = sql_values + ',' + value
sql = '(' + sql_fields + ') VALUES (' + sql_values +')'
params = json.loads(survey.datastore.connection_params)
host = params['host']
port = params['port']
dbname = params['database']
user = params['user']
passwd = params['passwd']
schema = params.get('schema', 'public')
i = Introspect(database=dbname, host=host, port=port, user=user, password=passwd)
i.insert_sql(schema, table_name, sql)
def get_geometry_field(layer):
if layer.type == 'v_PostGIS':
params = json.loads(layer.datastore.connection_params)
host = params['host']
port = params['port']
dbname = params['database']
user = params['user']
passwd = params['passwd']
schema = params.get('schema', 'public')
i = Introspect(database=dbname,
host=host,
port=port,
user=user,
password=passwd)
layer_name_split = layer.name.split(':')
layer_name = layer.name
if layer_name_split.__len__() > 1:
layer_name = layer_name_split[1]
if layer_name:
geom_fields = i.get_geometry_columns_info(layer_name, schema)
i.close()
if geom_fields.__len__() > 0:
return {
'field_name': geom_fields[0][2],
'field_type': geom_fields[0][5],
}
return ''
def post(self, request, *args, **kwargs):
form = PostgisLayerUploadForm(request.POST, request.FILES, user=request.user)
if form.is_valid():
try:
if mapservice.exportShpToPostgis(form.cleaned_data):
request.session.message = _('Export process done successfully')
return redirect("/gvsigonline/filemanager/?path=" + request.POST.get('directory_path'))
except rest_geoserver.RequestError as e:
message = e.server_message
request.session['message'] = str(message)
if e.status_code == -1:
name = form.data['name']
datastore_id = form.data['datastore']
datastore = Datastore.objects.get(id=datastore_id)
params = json.loads(datastore.connection_params)
host = params['host']
port = params['port']
dbname = params['database']
user = params['user']
passwd = params['passwd']
schema = params.get('schema', 'public')
i = Introspect(database=dbname, host=host, port=port, user=user, password=passwd)
i.delete_table(schema, name)
return redirect("/gvsigonline/filemanager/export_to_database/?path=" + request.POST.get('file_path'))
except Exception as exc:
request.session['message'] = _('Server error')
return redirect("/gvsigonline/filemanager/export_to_database/?path=" + request.POST.get('file_path'))
else:
request.session['message'] = _('You must fill in all fields')
return redirect("/gvsigonline/filemanager/export_to_database/?path=" + request.POST.get('file_path'))
def set_database_config(self, provider):
params = json.loads(provider.params)
datastore_id = params["datastore_id"]
provider.dbtable = params['resource']
provider.dbfield = params['text_field']
datastore = Datastore.objects.get(id=datastore_id)
datastore_params = json.loads(datastore.connection_params)
dbhost = datastore_params['host']
dbport = datastore_params['port']
dbname = datastore_params['database']
dbuser = datastore_params['user']
dbpassword = datastore_params['passwd']
provider.dbtable = params['resource']
provider.dbfield = params['text_field']
provider.dbfieldId = params['id_field']
provider.dbfieldGeom = params['geom_field']
provider.dbschema = datastore.name
provider.fieldsWithGeom = (provider.dbfield + ', ' +
provider.dbfieldId + ', ' +
'st_transform(ST_PointOnSurface(' +
provider.dbfieldGeom + '), 4326) AS P,' +
'st_asgeojson(st_transform(' +
provider.dbfieldGeom + ', 4326)) as G ')
provider.fields = (provider.dbfield + ', ' + provider.dbfieldId)
i = Introspect(database=dbname,
host=dbhost,
port=dbport,
user=dbuser,
password=dbpassword)
field_info = i.get_geometry_column_info(provider.dbtable,
provider.dbfieldGeom,
provider.dbschema)
try:
provider.srs = field_info[0][4]
provider.connection = psycopg2.connect("host=" + dbhost +
" port=" + dbport +
" dbname=" + dbname +
" user="******" password="******"Connect ... "
except StandardError, e:
print "Failed to connect!", e
return False
def check_schema_exists(schema):
dbhost = settings.GVSIGOL_USERS_CARTODB['dbhost']
dbport = settings.GVSIGOL_USERS_CARTODB['dbport']
dbname = settings.GVSIGOL_USERS_CARTODB['dbname']
dbuser = settings.GVSIGOL_USERS_CARTODB['dbuser']
dbpassword = settings.GVSIGOL_USERS_CARTODB['dbpassword']
i = Introspect(database=dbname,
host=dbhost,
port=dbport,
user=dbuser,
password=dbpassword)
exists = i.schema_exists(schema)
i.close()
return exists
def isValidCartociudadDB(datastore):
params = json.loads(datastore.connection_params)
host = params['host']
port = params['port']
dbname = params['database']
user = params['user']
passwd = params['passwd']
schema = params.get('schema', 'public')
i = Introspect(database=dbname,
host=host,
port=port,
user=user,
password=passwd)
resources = i.get_tables(schema)
i.close()
resources_needed = []
#if not geocoding_setting.CARTOCIUDAD_DB_CODIGO_POSTAL in resources:
# resources_needed.append(geocoding_setting.CARTOCIUDAD_DB_CODIGO_POSTAL)
if not resources or not geocoding_setting.CARTOCIUDAD_DB_TRAMO_VIAL in resources:
resources_needed.append(geocoding_setting.CARTOCIUDAD_DB_TRAMO_VIAL)
if not resources or not geocoding_setting.CARTOCIUDAD_DB_PORTAL_PK in resources:
resources_needed.append(geocoding_setting.CARTOCIUDAD_DB_PORTAL_PK)
#if not geocoding_setting.CARTOCIUDAD_DB_MANZANA in resources:
# resources_needed.append(geocoding_setting.CARTOCIUDAD_DB_MANZANA)
#if not geocoding_setting.CARTOCIUDAD_DB_LINEA_AUXILIAR in resources:
# resources_needed.append(geocoding_setting.CARTOCIUDAD_DB_LINEA_AUXILIAR)
if not resources or not geocoding_setting.CARTOCIUDAD_DB_MUNICIPIO_VIAL in resources:
resources_needed.append(
geocoding_setting.CARTOCIUDAD_DB_MUNICIPIO_VIAL)
if not resources or not geocoding_setting.CARTOCIUDAD_DB_MUNICIPIO in resources:
resources_needed.append(geocoding_setting.CARTOCIUDAD_DB_MUNICIPIO)
if not resources or not geocoding_setting.CARTOCIUDAD_DB_PROVINCIA in resources:
resources_needed.append(geocoding_setting.CARTOCIUDAD_DB_PROVINCIA)
#if not geocoding_setting.CARTOCIUDAD_DB_TOPONIMO in resources:
# resources_needed.append(geocoding_setting.CARTOCIUDAD_DB_TOPONIMO)
return resources_needed
def get_db_connect_from_layer(layer_id):
layer = Layer.objects.get(id=int(layer_id))
datastore = Datastore.objects.get(id=layer.datastore_id)
params = json.loads(datastore.connection_params)
host = params['host']
port = params['port']
dbname = params['database']
user = params['user']
passwd = params['passwd']
i = Introspect(database=dbname,
host=host,
port=port,
user=user,
password=passwd)
return i, layer.name, params['schema']
def get_db_connect_from_datastore(datastore):
if not isinstance(datastore, Datastore):
datastore = Datastore.objects.get(id=int(datastore))
params = json.loads(datastore.connection_params)
host = params['host']
port = params['port']
dbname = params['database']
user = params['user']
passwd = params['passwd']
i = Introspect(database=dbname,
host=host,
port=port,
user=user,
password=passwd)
return i, params
def clone_layer(target_datastore,
layer,
layer_group,
copy_data=True,
permissions=CLONE_PERMISSION_CLONE):
if layer.type == 'v_PostGIS': # operation not defined for the rest of types
# create the table
dbhost = settings.GVSIGOL_USERS_CARTODB['dbhost']
dbport = settings.GVSIGOL_USERS_CARTODB['dbport']
dbname = settings.GVSIGOL_USERS_CARTODB['dbname']
dbuser = settings.GVSIGOL_USERS_CARTODB['dbuser']
dbpassword = settings.GVSIGOL_USERS_CARTODB['dbpassword']
i = Introspect(database=dbname,
host=dbhost,
port=dbport,
user=dbuser,
password=dbpassword)
table_name = layer.source_name if layer.source_name else layer.name
new_table_name = i.clone_table(layer.datastore.name,
table_name,
target_datastore.name,
table_name,
copy_data=copy_data)
i.close()
from gvsigol_services import views
server = geographic_servers.get_instance().get_server_by_id(
target_datastore.workspace.server.id)
layerConf = ast.literal_eval(layer.conf) if layer.conf else {}
extraParams = {
"max_features": layerConf.get('featuretype', {}).get('', 0)
}
# add layer to Geoserver
views.do_add_layer(server, target_datastore, new_table_name,
layer.title, layer.queryable, extraParams)
new_name = new_table_name
if Layer.objects.filter(name=new_name,
datastore=target_datastore).exists():
base_name = target_datastore.workspace.name + "_" + layer.name
new_name = base_name
i = 1
salt = ''
while Layer.objects.filter(name=layer.name,
datastore=target_datastore).exists():
new_name = base_name + '_' + str(i) + salt
i = i + 1
if (i % 1000) == 0:
salt = '_' + get_random_string(3)
# clone layer
old_id = layer.pk
layer.pk = None
layer.name = new_name
layer.datastore = target_datastore
if layer_group is not None:
layer.layer_group = layer_group
layer.save()
new_layer_instance = Layer.objects.get(id=layer.pk)
old_instance = Layer.objects.get(id=old_id)
if permissions != CLONE_PERMISSION_SKIP:
admin_group = UserGroup.objects.get(name__exact='admin')
read_groups = [admin_group]
write_groups = [admin_group]
for lrg in LayerReadGroup.objects.filter(layer=old_instance):
lrg.pk = None
lrg.layer = new_layer_instance
lrg.save()
read_groups.append(lrg.group)
for lwg in LayerWriteGroup.objects.filter(layer=old_instance):
lwg.pk = None
lwg.layer = new_layer_instance
lwg.save()
write_groups.append(lwg.group)
server.setLayerDataRules(layer, read_groups, write_groups)
set_time_enabled(server, new_layer_instance)
for enum in LayerFieldEnumeration.objects.filter(layer=old_instance):
enum.pk = None
enum.layer = new_layer_instance
enum.save()
from gvsigol_symbology.services import clone_layer_styles
clone_layer_styles(server, old_instance, new_layer_instance)
for lyr_res in LayerResource.objects.filter(layer=old_instance):
lyr_res.pk = None
lyr_res.layer = new_layer_instance
lyr_res.save()
"""
TODO:
- models from plugins (for instance metadata, charts, etc)
"""
server.updateThumbnail(new_layer_instance, 'create')
core_utils.toc_add_layer(new_layer_instance)
server.createOrUpdateGeoserverLayerGroup(
new_layer_instance.layer_group)
return new_layer_instance
return layer