def user_add(request):
ad_suffix = GVSIGOL_LDAP['AD']
if not ad_suffix:
show_pass_form = True
else:
show_pass_form = False
if request.method == 'POST':
form = UserCreateForm(request.POST)
if form.is_valid():
assigned_groups = []
is_staff = False
if 'is_staff' in form.data:
is_staff = True
is_superuser = False
if 'is_superuser' in form.data:
is_superuser = True
is_staff = True
assigned_groups = []
for key in form.data:
if 'group-' in key:
assigned_groups.append(int(key.split('-')[1]))
try:
if form.data['password1'] == form.data['password2']:
user = User(username=form.data['username'].lower(),
first_name=u''.join(
form.data['first_name']).encode('utf-8'),
last_name=u''.join(
form.data['last_name']).encode('utf-8'),
email=form.data['email'].lower(),
is_superuser=is_superuser,
is_staff=is_staff)
user.set_password(form.data['password1'])
user.save()
#admin_group = UserGroup.objects.get(name__exact='admin')
aux = UserGroup.objects.filter(name="admin")
if aux.count() > 1:
print "WARNING: table gvsigol_auth_usergroup inconsistent !!!!!!!!!!!"
admin_group = aux[0]
if user.is_superuser:
core_services.ldap_add_user(user,
form.data['password1'],
True)
core_services.ldap_add_group_member(user, admin_group)
usergroup_user = UserGroupUser(user=user,
user_group=admin_group)
usergroup_user.save()
else:
core_services.ldap_add_user(user,
form.data['password1'],
False)
#core_services.ldap_add_group_member(user, admin_group)
for ag in assigned_groups:
user_group = UserGroup.objects.get(id=ag)
usergroup_user = UserGroupUser(user=user,
user_group=user_group)
usergroup_user.save()
core_services.ldap_add_group_member(user, user_group)
#User backend
if is_superuser or is_staff:
ugroup = UserGroup(
name='ug_' + form.data['username'].lower(),
description=_(u'User group for') + ': ' +
form.data['username'].lower())
ugroup.save()
ugroup_user = UserGroupUser(user=user,
user_group=ugroup)
ugroup_user.save()
core_services.ldap_add_group(ugroup)
core_services.add_data_directory(ugroup)
core_services.ldap_add_group_member(user, ugroup)
url = mapservice_backend.getBaseUrl() + '/'
ws_name = 'ws_' + form.data['username'].lower()
if mapservice_backend.createWorkspace(
ws_name, url + ws_name, '',
url + ws_name + '/wms', url + ws_name + '/wfs',
url + ws_name + '/wcs',
url + 'gwc/service/wms'):
# save it on DB if successfully created
newWs = Workspace(
name=ws_name,
description='',
uri=url + ws_name,
wms_endpoint=url + ws_name + '/wms',
wfs_endpoint=url + ws_name + '/wfs',
wcs_endpoint=url + ws_name + '/wcs',
cache_endpoint=url + 'gwc/service/wms',
created_by=user.username,
is_public=False)
newWs.save()
ds_name = 'ds_' + form.data['username'].lower()
services_utils.create_datastore(
request, user.username, ds_name, newWs)
mapservice_backend.reload_nodes()
auth_utils.sendMail(user, form.data['password1'])
return redirect('user_list')
except Exception as e:
print "ERROR: Problem creating user " + str(e)
errors = []
#errors.append({'message': _("The username already exists")})
groups = auth_utils.get_all_groups()
return render_to_response(
'user_add.html', {
'form': form,
'groups': groups,
'errors': errors,
'show_pass_form': show_pass_form
},
context_instance=RequestContext(request))
else:
groups = auth_utils.get_all_groups()
return render_to_response('user_add.html', {
'form': form,
'groups': groups,
'show_pass_form': show_pass_form
},
context_instance=RequestContext(request))
else:
form = UserCreateForm()
groups = auth_utils.get_all_groups()
return render_to_response('user_add.html', {
'form': form,
'groups': groups,
'show_pass_form': show_pass_form
},
context_instance=RequestContext(request))
def survey_update_project(request, survey_id):
try:
survey = Survey.objects.get(id=survey_id)
sections = SurveySection.objects.filter(
survey=survey).order_by('order')
permissions = SurveyReadGroup.objects.filter(survey=survey)
'''
Create the project
'''
if survey.project_id != None:
project = Project.objects.get(id=survey.project_id)
project.delete()
project = Project(
name=survey.name,
title=survey.title,
description=survey.title,
center_lat=0,
center_lon=0,
zoom=2,
extent=
'-31602124.97422327,-7044436.526761844,31602124.97422327,7044436.526761844',
toc_order={},
toc_mode='toc_hidden',
created_by=request.user.username,
is_public=False)
project.save()
survey.project_id = project.id
survey.save()
lgname = str(project.id) + '_' + str(
survey_id) + '_' + survey.name + '_' + request.user.username
layergroup = LayerGroup(name=lgname,
title=survey.name,
cached=False,
created_by=request.user.username)
layergroup.save()
survey.layer_group_id = layergroup.id
survey.save()
mapservice_backend.reload_nodes()
project_layergroup = ProjectLayerGroup(project=project,
layer_group=layergroup)
project_layergroup.save()
assigned_layergroups = []
prj_lyrgroups = ProjectLayerGroup.objects.filter(project_id=project.id)
for prj_lyrgroup in prj_lyrgroups:
assigned_layergroups.append(prj_lyrgroup.layer_group.id)
toc_structure = core_utils.get_json_toc(assigned_layergroups)
project.toc_order = toc_structure
project.save()
for permission in permissions:
project_usergroup = ProjectUserGroup(
project=project, user_group=permission.user_group)
project_usergroup.save()
'''
Create the layers
'''
if project:
lyorder = 0
for section in sections:
survey_section_update_project_operation(
request, survey, section, lyorder)
lyorder = lyorder + 1
response = {'result': 'OK'}
except Exception as e:
response = {'result': 'Error', 'message': str(e)}
return HttpResponse(json.dumps(response, indent=4),
content_type='application/json')
def survey_section_update_project_operation(request, survey, section, lyorder):
if section.layer_id != None:
layer_delete_operation(request, section.layer_id)
try:
mapservice_backend.deleteTable(survey.datastore, section.name)
mapservice_backend.deleteResource(survey.datastore.workspace,
survey.datastore, section.name)
except:
pass
geom_type = 'Point'
fields = []
field_defs = []
field_definitions = SURVEY_FUNCTIONS
if section.definition:
definitions = json.loads(section.definition)
for definition in definitions:
form_name = definition["formname"]
for item in definition['formitems']:
item_type = item['type']
for db_item in field_definitions:
for key in db_item:
if key == item_type:
db_type = db_item[key]['db_type']
if db_type != None and db_type.__len__() > 0:
aux = {
'id':
str(section.id) + '_' + form_name + '_' +
item['key'],
'name':
form_name + '_' + item['key'],
'type':
db_type
}
fields.append(aux)
field_def = {}
field_def[
'name'] = form_name + '_' + item['key']
for id, language in LANGUAGES:
field_def['title-' + id] = item['title']
field_def['visible'] = True
field_def['editableactive'] = True
field_def['editable'] = True
for control_field in settings.CONTROL_FIELDS:
if field_def['name'] == control_field[
'name']:
field_def['editableactive'] = False
field_def['editable'] = False
field_def['infovisible'] = False
field_defs.append(field_def)
section.name = prepare_string(section.name)
mapservice_backend.createTableFromFields(survey.datastore, section.name,
geom_type, section.srs, fields)
# first create the resource on the backend
try:
mapservice_backend.createResource(survey.datastore.workspace,
survey.datastore, section.name,
section.title)
except:
pass
try:
mapservice_backend.setQueryable(survey.datastore.workspace.name,
survey.datastore.name,
survey.datastore.type, section.name,
True)
except:
pass
layer = Layer(
datastore=survey.datastore,
layer_group=survey.layer_group,
name=section.name,
title=section.title,
abstract=section.title,
type='v_PostGIS',
visible=True,
queryable=True,
cached=False,
single_image=False,
time_enabled=False,
highlight=False,
order=lyorder,
created_by=request.user.username,
)
layer.save()
style_name = survey.datastore.workspace.name + '_' + layer.name + '_default'
mapservice_backend.createDefaultStyle(layer, style_name)
mapservice_backend.setLayerStyle(layer, style_name, True)
layer = mapservice_backend.updateThumbnail(layer, 'create')
layer.save()
section.layer_id = layer.id
section.save()
layer_conf = {'fields': field_defs}
layer.conf = layer_conf
layer.save()
core_utils.toc_add_layer(layer)
mapservice_backend.createOrUpdateGeoserverLayerGroup(survey.layer_group)
mapservice_backend.reload_nodes()
permissionsr = SurveyReadGroup.objects.filter(survey=survey)
permissionsw = SurveyWriteGroup.objects.filter(survey=survey)
groupsr = []
groupsw = []
for permission in permissionsr:
groupsr.append(permission.user_group)
try:
lwr = LayerReadGroup()
lwr.layer = section.layer
lwr.group = permission.user_group
lwr.save()
except:
pass
for permission in permissionsw:
groupsw.append(permission.user_group)
try:
lwg = LayerWriteGroup()
lwg.layer = section.layer
lwg.group = permission.user_group
lwg.save()
except:
pass
mapservice_backend.setLayerDataRules(layer, groupsr, groupsw)
mapservice_backend.reload_nodes()
def upload_library(name, description, file):
library = Library(name=name, description=description)
library.save()
library_path = utils.check_library_path(library)
file_path = utils.__get_uncompressed_file_upload_path(file)
utils.copyrecursively(file_path + "/resources/", library_path)
file_list = os.listdir(file_path)
for file in file_list:
if not os.path.isdir(file_path + "/" + file):
f = open(file_path + "/" + file, 'r')
sld = sld_reader.parse(f)
style_name = remove_accents(sld.NamedLayer[0].Name)
sld.NamedLayer[0].Name = style_name
style_title = sld.NamedLayer[0].UserStyle[0].FeatureTypeStyle[
0].Rule[0].Title
r = sld.NamedLayer[0].UserStyle[0].FeatureTypeStyle[0].Rule[0]
style = Style(name=style_name,
title=style_title,
is_default=True,
type="US")
style.save()
rule = Rule(style=style,
name=style_name,
title=style_title,
abstract='',
filter=str(""),
minscale=-1 if r.MinScaleDenominator is None else
r.MinScaleDenominator,
maxscale=-1 if r.MaxScaleDenominator is None else
r.MaxScaleDenominator,
order=0)
rule.save()
library_rule = LibraryRule(library=library, rule=rule)
library_rule.save()
scount = r.Symbolizer.__len__() - 1
for s in r.Symbolizer:
if s.original_tagname_ == 'PointSymbolizer':
opacity = s.Graphic.Opacity.valueOf_
rotation = s.Graphic.Rotation.valueOf_
size = s.Graphic.Size.valueOf_
if len(s.Graphic.Mark) >= 1:
mark = s.Graphic.Mark[0]
stroke = '#000000'
if mark.Stroke.CssParameter.__len__() > 0:
stroke = mark.Stroke.CssParameter[0].valueOf_
stroke_width = 1
if mark.Stroke.CssParameter.__len__() > 1:
stroke_width = mark.Stroke.CssParameter[1].valueOf_
stroke_opacity = 1
if mark.Stroke.CssParameter.__len__() > 2:
stroke_opacity = mark.Stroke.CssParameter[
2].valueOf_
stroke_dash_array = 'none'
if mark.Stroke.CssParameter.__len__() > 3:
stroke_dash_array = mark.Stroke.CssParameter[
3].valueOf_
symbolizer = MarkSymbolizer(
rule=rule,
order=scount,
opacity=opacity,
size=size,
rotation=rotation,
well_known_name=mark.WellKnownName,
fill=mark.Fill.CssParameter[0].valueOf_,
fill_opacity=mark.Fill.CssParameter[1].valueOf_,
stroke=stroke,
stroke_width=stroke_width,
stroke_opacity=stroke_opacity,
stroke_dash_array=stroke_dash_array)
symbolizer.save()
if len(s.Graphic.ExternalGraphic) >= 1:
external_graphic = s.Graphic.ExternalGraphic[0]
online_resource = external_graphic.OnlineResource.href.split(
'/')
online_resource[-2] = library.name
new_online_resource = settings.MEDIA_URL + online_resource[
-3] + '/' + library.name + '/' + remove_accents(
online_resource[-1])
symbolizer = ExternalGraphicSymbolizer(
rule=rule,
order=scount,
opacity=opacity,
size=size,
rotation=rotation,
online_resource=new_online_resource,
format=external_graphic.Format)
symbolizer.save()
elif s.original_tagname_ == 'LineSymbolizer':
stroke = '#000000'
if s.Stroke:
if s.Stroke.CssParameter.__len__() > 0:
stroke = s.Stroke.CssParameter[0].valueOf_
stroke_width = 1
if s.Stroke.CssParameter.__len__() > 1:
stroke_width = s.Stroke.CssParameter[1].valueOf_
stroke_opacity = 1
if s.Stroke.CssParameter.__len__() > 2:
stroke_opacity = s.Stroke.CssParameter[2].valueOf_
stroke_dash_array = 'none'
if s.Stroke.CssParameter.__len__() > 3:
stroke_dash_array = s.Stroke.CssParameter[
3].valueOf_
symbolizer = LineSymbolizer(
rule=rule,
order=scount,
stroke=stroke,
stroke_width=stroke_width,
stroke_opacity=stroke_opacity,
stroke_dash_array=stroke_dash_array)
symbolizer.save()
elif s.original_tagname_ == 'PolygonSymbolizer':
stroke = '#000000'
if s.Stroke.CssParameter.__len__() > 0:
stroke = s.Stroke.CssParameter[0].valueOf_
stroke_width = 1
if s.Stroke.CssParameter.__len__() > 1:
stroke_width = s.Stroke.CssParameter[1].valueOf_
stroke_opacity = 1
if s.Stroke.CssParameter.__len__() > 2:
stroke_opacity = s.Stroke.CssParameter[2].valueOf_
stroke_dash_array = 'none'
if s.Stroke.CssParameter.__len__() > 3:
stroke_dash_array = s.Stroke.CssParameter[3].valueOf_
symbolizer = PolygonSymbolizer(
rule=rule,
order=scount,
fill=s.Fill.CssParameter[0].valueOf_,
fill_opacity=s.Fill.CssParameter[1].valueOf_,
stroke=stroke,
stroke_width=stroke_width,
stroke_opacity=stroke_opacity,
stroke_dash_array=stroke_dash_array)
symbolizer.save()
scount -= 1
output = StringIO.StringIO()
sld.export(output, 0)
sld_body = output.getvalue()
output.close()
mapservice.createStyle(style.name, sld_body)
mapservice.reload_nodes()
utils.__delete_temporaries(file_path)