def get(self, request, *args, **kwargs):
user, profile = user_and_profile(request)
dataset_id = request.GET.get('id', None)
publish = request.GET.get('publish', None)
if dataset_id and publish.lower() == 'toggle':
dataset = get_object_or_404_extended(
Dataset, user, include={'id': dataset_id})
dataset.published = not dataset.published
current_user = (user == dataset.editor) and user or None
dataset.save(current_user=current_user)
message = (
'Le jeu de données <strong>{0}</strong> '
'est maintenant en accès <strong>{1}</strong>.'
).format(dataset.title, dataset.published and 'public' or 'privé')
status = 200
return render(request, 'idgo_admin/response.html',
context={'message': message}, status=status)
def post(self, request, *args, **kwargs):
user, profile = user_and_profile(request)
if not profile.crige_membership:
raise Http404
context = self.get_context(request, user)
footprint = request.POST.get('footprint') or None
footprint = footprint and json.loads(footprint)
layer_name = request.POST.get('layer')
resource_name = request.POST.get('resource')
dataset_name = request.POST.get('dataset')
dst_crs = request.POST.get('crs')
format_vector = request.POST.get('format-vector') or None
if format_vector:
dst_format_vector = ExtractorSupportedFormat.objects.get(
name=format_vector, type='vector').details
format_raster = request.POST.get('format-raster') or None
if format_raster:
dst_format_raster = ExtractorSupportedFormat.objects.get(
name=format_raster, type='raster').details
data_extractions = []
additional_files = []
if layer_name or resource_name:
if layer_name:
model = 'Layer'
foreign_field = 'name'
foreign_value = layer_name
layer = get_object_or_404(Layer, name=layer_name)
resource = layer.resource
if resource_name:
model = 'Resource'
foreign_field = 'ckan_id'
foreign_value = resource_name
resource = get_object_or_404(Resource, ckan_id=resource_name)
layer = resource.get_layers()[0] # Car relation 1-1
if layer.type == 'raster':
data_extraction = {
**{
'source': layer.filename,
},
**dst_format_raster
}
elif layer.type == 'vector':
data_extraction = {
**{
'layer':
layer.name,
'source':
'PG:host=postgis-master user=datagis dbname=datagis',
},
**dst_format_vector
}
data_extraction['dst_srs'] = dst_crs or 'EPSG:2154'
if resource.geo_restriction:
footprint_restriction = \
json.loads(user.profile.organisation.jurisdiction.geom.geojson)
if footprint:
try:
data_extraction['footprint'] = intersect(
json.dumps(footprint),
json.dumps(footprint_restriction))
except Exception as e:
msg = "La zone d'extraction génère une erreur"
messages.error(request, msg)
return render_with_info_profile(request,
self.template,
context=context)
else:
data_extraction['footprint'] = footprint_restriction
data_extraction['footprint_srs'] = 'EPSG:4326'
elif footprint:
data_extraction['footprint'] = footprint
data_extraction['footprint_srs'] = 'EPSG:4326'
data_extractions.append(data_extraction)
# Pas d'`additional_files` dans le cas présent.
elif dataset_name:
model = 'Dataset'
foreign_field = 'slug'
foreign_value = dataset_name
dataset = get_object_or_404(Dataset, slug=dataset_name)
for resource in dataset.get_resources():
for layer in resource.get_layers():
if layer.type == 'raster':
data_extraction = {
**{
'source': layer.filename,
},
**dst_format_raster
}
elif layer.type == 'vector':
data_extraction = {
**{
'layer':
layer.name,
'source':
'PG:host=postgis-master user=datagis dbname=datagis',
},
**dst_format_vector
}
data_extraction['dst_srs'] = dst_crs or 'EPSG:2154'
if resource.geo_restriction:
footprint_restriction = \
json.loads(user.profile.organisation.jurisdiction.geom.geojson)
if footprint:
data_extraction['footprint'] = intersect(
json.dumps(footprint),
json.dumps(footprint_restriction))
else:
data_extraction[
'footprint'] = footprint_restriction
data_extraction['footprint_srs'] = 'EPSG:4326'
elif footprint:
data_extraction['footprint'] = footprint
data_extraction['footprint_srs'] = 'EPSG:4326'
data_extractions.append(data_extraction)
if resource.data_type == 'annexe':
additional_files.append({
'file_name':
resource.filename,
'dir_name':
'Documentation associée',
'file_location':
CkanHandler.get_resource(str(
resource.ckan_id)).get('url')
})
query = {
'user_id':
user.username,
'user_email_address':
user.email,
'user_name':
user.last_name,
'user_first_name':
user.first_name,
'user_company':
user.profile.organisation and user.profile.organisation.legal_name
or '',
'user_address':
user.profile.organisation
and user.profile.organisation.full_address or '',
'data_extractions':
data_extractions,
'additional_files':
additional_files
}
r = requests.post(EXTRACTOR_URL, json=query)
if r.status_code == 201:
details = r.json()
AsyncExtractorTask.objects.create(
details=details,
foreign_field=foreign_field,
foreign_value=foreign_value,
model=model,
query=query,
submission_datetime=details.get('submission_datetime'),
uuid=UUID(details.get('task_id')),
user=user)
messages.success(request, (
"L'extraction a été ajoutée à la liste de tâche. "
"Vous allez recevoir un e-mail une fois l'extraction réalisée."
))
domain = Site.objects.get(name='extractor').domain
url = 'http{secure}://{domain}{path}'.format(
secure=request.is_secure and 's' or '',
domain=domain,
path=reverse('idgo_admin:extractor_dashboard'))
return HttpResponseRedirect(url)
else:
if r.status_code == 400:
details = r.json().get('detail')
msg = '{}: {}'.format(details.get('title', 'Error'),
' '.join(details.get('list', 'Error')))
else:
msg = "L'extracteur n'est pas disponible pour le moment."
messages.error(request, msg)
return render_with_info_profile(request,
self.template,
context=context)
def extractor_task(request, *args, **kwargs):
user, profile = user_and_profile(request)
instance = get_object_or_404(AsyncExtractorTask,
uuid=request.GET.get('id'))
query = instance.query or instance.details.get['query']
extract_params = {}
format_raster, format_vector = None, None
for data_extraction in query['data_extractions']:
for format in ExtractorSupportedFormat.objects.all():
if format.details.get('dst_format') == data_extraction.get(
'dst_format'):
if format.type == 'raster':
format_raster = format
if format.type == 'vector':
format_vector = format
extract_params = data_extraction
auth_name, auth_code = extract_params.get('dst_srs').split(':')
crs = SupportedCrs.objects.get(auth_name=auth_name, auth_code=auth_code)
if instance.model == 'Dataset':
dataset = instance.target_object
bounds = dataset.bbox.extent
layers = [layer for layer in dataset.get_layers()]
elif instance.model == 'Resource':
resource = instance.target_object
bounds = resource.bbox.extent
layers = [layer for layer in resource.get_layers()]
elif instance.model == 'Layer':
layer = instance.target_object
bounds = layer.bbox.extent
layers = [instance.target_object]
data = {
'bounds':
bounds,
'crs':
crs.description,
'footprint':
extract_params.get('footprint'),
'format_raster':
format_raster and format_raster.description or '-',
'format_vector':
format_vector and format_vector.description or '-',
'layer': [l.name for l in layers],
'start':
instance.start_datetime,
'stop':
instance.stop_datetime,
'target':
'{} : {}'.format(instance.target_object._meta.verbose_name,
instance.target_object.__str__()),
'target_value':
instance.foreign_value,
'target_field':
instance.foreign_field,
'target_model':
instance.model.lower(),
'submission':
instance.details.get('submission_datetime'),
'user':
instance.user.get_full_name()
}
if instance.success is False:
data['error'] = instance.details.get('exception',
'Une erreur est survenu.')
return JsonResponse(data=data)
def get(self, request):
user, profile = user_and_profile(request)
context = {'terms': Gdpr.objects.latest('issue_date')}
return render_with_info_profile(request,
'idgo_admin/gdpr.html',
context=context)
def post(self, request):
user, profile = user_and_profile(request)
GdprUser.objects.create(user=user,
gdpr=Gdpr.objects.latest('issue_date'))
return mama_redirect('idgo_admin:list_my_datasets')
def post(self, request, id, *args, **kwargs):
user, profile = user_and_profile(request)
dataset = get_object_or_404(Dataset, id=id)
delete = 'delete' in request.POST
save = 'save' in request.POST
save_and_continue = 'continue' in request.POST
if delete and dataset.geonet_id:
try:
geonet.delete_record(dataset.geonet_id)
dataset.geonet_id = None
dataset.save(current_user=None)
except Exception:
messages.error(
request,
"La fiche de metadonnées a été supprimée avec succès.")
else:
messages.success(
request,
"La fiche de metadonnées a été supprimée avec succès.")
# finally:
return HttpResponseRedirect(
reverse('idgo_admin:dataset_mdedit', kwargs={'id': id}))
if save or save_and_continue:
data = dict(request.POST)
dataset.title = data['dataTitle'][0] or dataset.title
dataset.description = data['dataAbstract'][0] or None
date_creation = data['dataDateCreation'][0] or None
if date_creation:
dataset.date_creation = datetime.strptime(
date_creation, "%Y-%m-%d").date()
date_modification = data['dataDateRevision'][0] or None
if date_modification:
dataset.date_modification = datetime.strptime(
date_modification, "%Y-%m-%d").date()
date_publication = data['dataDatePublication'][0] or None
if date_publication:
dataset.date_publication = datetime.strptime(
date_publication, "%Y-%m-%d").date()
dataset.update_frequency = {
'notPlanned': 'never', # [011]
'asNeeded': 'asneeded', # [009]
'irregular': 'intermittently', # [010]
'continual': 'continuously', # [001]
'daily': 'daily', # [002]
'weekly': 'weekly', # [003]
'fortnightly': 'fortnightly', # [004]
'monthly': 'monthly', # [005]
'quarterly': 'quaterly', # [006]
'semiannual': 'biannually', # [007]
'annual': 'annually' # [008]
}.get(data['dataMaintenanceFrequency'][0], 'unknown') # [012]
keywords = [
k.strip() for l in [s.split(',') for s in data['keyword']]
for k in l if k
]
if keywords:
dataset.keywords.clear()
for k in keywords:
dataset.keywords.add(k)
root = ET.fromstring(request.POST.get('xml'))
ns = {
'gmd': 'http://www.isotc211.org/2005/gmd',
'gco': 'http://www.isotc211.org/2005/gco'
}
geonet_id = root.find('gmd:fileIdentifier/gco:CharacterString',
ns).text
record = ET.tostring(root,
encoding='utf-8',
method='xml',
short_empty_elements=True)
error = False
if not geonet.get_record(geonet_id):
try:
geonet.create_record(geonet_id, record)
except Exception:
error = True
messages.error(
request,
"La création de la fiche de métadonnées a échoué.")
else:
# Toujours publier la fiche
geonet.publish(geonet_id)
dataset.geonet_id = geonet_id
messages.success(
request,
"La fiche de metadonnées a été créée avec succès.")
else:
try:
geonet.update_record(geonet_id, record)
except Exception:
error = True
messages.error(
request,
"La mise à jour de la fiche de métadonnées a échoué.")
else:
messages.success(
request,
"La fiche de metadonnées a été mise à jour avec succès."
)
if not error:
dataset.save(current_user=user, synchronize=True)
if save_and_continue:
reverse_to = reverse('idgo_admin:dataset_mdedit',
kwargs={'id': id})
else:
reverse_to = reverse('idgo_admin:list_my_datasets')
return HttpResponseRedirect(reverse_to)
def post(self, request, id, *args, **kwargs):
user, profile = user_and_profile(request)
is_admin = profile.is_admin
is_referent = LiaisonsReferents.objects.filter(
profile=profile, organisation__id=id,
validated_on__isnull=False) and True or False
if not (is_referent or is_admin):
raise Http404()
organisation = get_object_or_404(Organisation, id=id)
context = {'organisation': organisation}
url = request.POST.get('url')
try:
with transaction.atomic():
instance, created = \
RemoteCsw.objects.get_or_create(
organisation=organisation, url=url)
except CswBaseError as e:
form = RemoteCswForm(request.POST)
form.add_error('url', e.__str__())
except ValidationError as e:
form = RemoteCswForm(request.POST)
form.add_error(e.code, e.message)
else:
context['datasets'] = Dataset.harvested_csw.filter(
organisation=organisation)
context['instance'] = instance
form = RemoteCswForm(request.POST, instance=instance)
context['form'] = form
if not form.is_valid():
messages.error(request, form._errors.__str__())
return HttpResponseRedirect(
reverse('idgo_admin:edit_remote_csw_link',
kwargs={'id': organisation.id}))
for k, v in form.cleaned_data.items():
setattr(instance, k, v)
try:
with transaction.atomic():
instance.save(harvest=not created)
except ValidationError as e:
error = True
messages.error(request, e.__str__())
except CswBaseError as e:
error = True
form.add_error('__all__', e.__str__())
messages.error(request, e.__str__())
except CriticalError as e:
error = True
form.add_error('__all__', e.__str__())
messages.error(request, e.__str__())
else:
error = False
context['datasets'] = \
Dataset.harvested_csw.filter(organisation=organisation)
context['form'] = RemoteCswForm(instance=instance)
if created:
msg = "Veuillez indiquez une requête <strong>GetRecord</strong> avant moissonnage du service."
else:
msg = 'Les informations de moissonnage ont été mises à jour.'
messages.success(request, msg)
if 'continue' in request.POST or error:
return render_with_info_profile(request,
self.template,
context=context)
return HttpResponseRedirect(
reverse('idgo_admin:update_organisation',
kwargs={'id': organisation.id}))
def post(self, request, dataset_id=None, *args, **kwargs):
# Vider systèmatiquement les messages
storage = messages.get_messages(request)
storage.used = True
user, profile = user_and_profile(request)
dataset = get_object_or_404_extended(Dataset,
user,
include={'id': dataset_id})
resource = None
id = request.POST.get('id', request.GET.get('id'))
if id:
include = {'id': id, 'dataset': dataset}
resource = get_object_or_404_extended(Resource,
user,
include=include)
form = Form(request.POST,
request.FILES,
instance=resource,
dataset=dataset,
user=user)
context = self.get_context(form, user, dataset, resource)
ajax = 'ajax' in request.POST
save_and_continue = 'continue' in request.POST
if not form.is_valid():
if ajax:
error = dict([(k, [str(m) for m in v])
for k, v in form.errors.items()])
msg = 'Veuillez corriger le formulaire.'
if '__all__' in error:
error['__all__'].prepend(msg)
else:
error['__all__'] = [msg]
return JsonResponse(json.dumps({'error': error}), safe=False)
return render_with_info_profile(request, self.template, context)
data = form.cleaned_data
kvp = {
'dataset':
dataset,
'title':
data['title'],
'description':
data['description'],
'lang':
data['lang'],
'data_type':
data['data_type'],
'format_type':
data['format_type'],
'last_update':
data['last_update'],
'restricted_level':
data['restricted_level'],
'up_file':
data['up_file'],
'dl_url':
data['dl_url'],
'synchronisation':
data['synchronisation'],
'sync_frequency':
data['sync_frequency'],
'referenced_url':
data['referenced_url'],
'ftp_file':
data['ftp_file']
and os.path.join(FTP_DIR, user.username, data['ftp_file']) or None,
'crs':
data['crs'],
'encoding':
data.get('encoding') or None,
'extractable':
data['extractable'],
'ogc_services':
data['ogc_services'],
'geo_restriction':
data['geo_restriction'],
}
profiles_allowed = None
organisations_allowed = None
if data['restricted_level'] == 'only_allowed_users':
profiles_allowed = data['profiles_allowed']
elif data['restricted_level'] == 'same_organization':
organisations_allowed = [form._dataset.organisation]
elif data['restricted_level'] == 'any_organization':
organisations_allowed = data['organisations_allowed']
memory_up_file = request.FILES.get('up_file')
file_extras = memory_up_file and {
'mimetype': memory_up_file.content_type,
'resource_type': memory_up_file.name,
'size': memory_up_file.size
} or None
try:
with transaction.atomic():
save_opts = {
'current_user': user,
'file_extras': file_extras,
'synchronize': True
}
if not id:
resource = Resource.default.create(save_opts=save_opts,
**kvp)
else:
resource = Resource.objects.get(pk=id)
for k, v in kvp.items():
setattr(resource, k, v)
if organisations_allowed:
resource.organisations_allowed = organisations_allowed
if profiles_allowed:
resource.profiles_allowed = profiles_allowed
save_opts['synchronize'] = True
save_opts['file_extras'] = None # IMPORTANT
resource.save(**save_opts)
except ValidationError as e:
if e.code == 'crs':
form.add_error(e.code, '')
form.add_error('__all__', e.message)
elif e.code == 'encoding':
form.add_error(e.code, '')
form.add_error('__all__', e.message)
else:
form.add_error(e.code, e.message)
messages.error(request, ' '.join(e))
error = dict([(k, [str(m) for m in v])
for k, v in form.errors.items()])
except CkanBaseError as e:
error = {'__all__': [e.__str__()]}
form.add_error('__all__', e.__str__())
messages.error(request, e.__str__())
else:
if id:
send_resource_update_mail(user, resource)
else:
send_resource_creation_mail(user, resource)
dataset_href = reverse(self.namespace,
kwargs={'dataset_id': dataset_id})
messages.success(
request,
('La ressource a été {0} avec succès. Souhaitez-vous '
'<a href="{1}">ajouter une nouvelle ressource</a> ? ou bien '
'<a href="{2}/dataset/{3}/resource/{4}" target="_blank">'
'voir la ressource dans CKAN</a> ?').format(
id and 'mise à jour' or 'créée', dataset_href, CKAN_URL,
dataset.slug, resource.ckan_id))
if ajax:
response = HttpResponse(status=201) # Ugly hack
if save_and_continue:
href = '{0}?id={1}'.format(dataset_href, resource.id)
else:
href = '{0}?id={1}#resources/{2}'.format(
reverse('idgo_admin:dataset'), dataset_id, resource.id)
response['Content-Location'] = href
return response
else:
if save_and_continue:
url = '{0}?id={1}'.format(dataset_href, resource.id)
return HttpResponseRedirect(url)
# else:
url = '{0}?id={1}#resources/{2}'.format(
reverse('idgo_admin:dataset'), dataset_id, resource.id)
return HttpResponseRedirect(url)
if ajax:
form._errors = None
return JsonResponse(json.dumps({'error': error}), safe=False)
return render_with_info_profile(request, self.template, context)
def get(self, request, id, *args, **kwargs):
user, profile = user_and_profile(request)
get_object_or_404(Dataset, id=id)
return render(request, self.template)
def post(self, request, id, *args, **kwargs):
user, profile = user_and_profile(request)
is_admin = profile.is_admin
is_referent = LiaisonsReferents.objects.filter(
profile=profile, organisation__id=id,
validated_on__isnull=False) and True or False
if not (is_referent or is_admin):
raise Http404()
organisation = get_object_or_404(Organisation, id=id)
context = {'organisation': organisation}
url = request.POST.get('url')
try:
with transaction.atomic():
instance, created = \
RemoteDcat.objects.get_or_create(
organisation=organisation, url=url)
except DcatBaseError as e:
form = RemoteDcatForm(request.POST)
form.add_error('url', e.__str__())
except ValidationError as e:
form = RemoteDcatForm(request.POST)
form.add_error(e.code, e.message)
else:
context['datasets'] = Dataset.harvested_dcat.filter(
organisation=organisation)
context['instance'] = instance
form = RemoteDcatForm(request.POST, instance=instance)
try:
# with transaction.atomic():
# self.map_categories(instance, request.POST, form)
# self.map_licences(instance, request.POST, form)
pass
except ValidationError as e:
error = True
messages.error(request, e.__str__())
except DcatBaseError as e:
error = True
form.add_error('__all__', e.__str__())
messages.error(request, e.__str__())
else:
# Une fois le mapping effectué, on sauvegarde l'instance
context['form'] = form
if not form.is_valid():
return render_with_info_profile(request,
self.template,
context=context)
for k, v in form.cleaned_data.items():
setattr(instance, k, v)
try:
with transaction.atomic():
instance.save(harvest=not created)
except ValidationError as e:
error = True
messages.error(request, e.__str__())
except DcatBaseError as e:
error = True
form.add_error('__all__', e.__str__())
messages.error(request, e.__str__())
except CriticalError as e:
error = True
form.add_error('__all__', e.__str__())
messages.error(request, e.__str__())
else:
error = False
context['datasets'] = \
Dataset.harvested_dcat.filter(organisation=organisation)
context['form'] = RemoteDcatForm(instance=instance)
if created:
msg = "Veuillez configurer les informations ci-dessous et poursuivre le moissonnage du catalogue."
else:
msg = "Les informations de moissonnage ont été mises à jour."
messages.success(request, msg)
if 'continue' in request.POST or error:
return HttpResponseRedirect(
reverse('idgo_admin:edit_remote_dcat_link',
kwargs={'id': organisation.id}))
return HttpResponseRedirect(
reverse('idgo_admin:update_organisation',
kwargs={'id': organisation.id}))
def post(self, request, code):
user, profile = user_and_profile(request)
if code not in ('for', 'new'):
if not profile.is_crige_admin:
raise Http404()
fake = None
jurisdiction = get_object_or_404(Jurisdiction, code=code)
else:
if code == 'new' and not profile.is_crige_admin:
raise Http404()
fake = (code == 'for')
new = (code == 'new')
jurisdiction = None
code = None
basemaps = BaseMaps.objects.all()
communes = serialize(
'geojson',
Commune.objects.all().transform(srid=4326),
geometry_field='geom')
organisation_pk = request.GET.get('organisation')
if organisation_pk:
organisation = get_object_or_404(Organisation, pk=organisation_pk)
else:
organisation = None
if 'reuse' in request.POST:
jurisdiction_pk = request.POST.get('jurisdiction')
try:
instance = Jurisdiction.objects.get(pk=jurisdiction_pk)
except Jurisdiction.DoesNotExist:
pass
else:
# E-mail envoyé aux administrateurs
send_mail_asking_for_jurisdiction_attachment(user, instance, organisation)
# E-mail envoyé à l'utilisateur
send_jurisdiction_attachment_mail(user, instance, organisation)
messages.success(request, (
'Votre demande de rattachement au territoire '
'de compétence « {name} » a été envoyée aux administrateurs.'
).format(name=instance.name))
return HttpResponseRedirect(
reverse('idgo_admin:show_organisation', kwargs={'id': organisation.id}))
# else:
form = Form(request.POST, instance=jurisdiction, include={'user': user})
if 'save' in request.POST:
form.fields['name'].required = True
form.fields['code'].required = True
context = {
'basemaps': basemaps,
'communes': communes,
'fake': fake,
'new': new,
'form': form,
'instance': jurisdiction,
'organisation': organisation,
}
if not form.is_valid():
return render_with_info_profile(request, self.template, context=context)
prefill = form.cleaned_data.get('prefill', False)
context['prefill'] = prefill
if prefill and 'save' not in request.POST:
del context['form']
jurisdiction = form.cleaned_data['jurisdiction']
if jurisdiction:
initial = {
'jurisdiction': jurisdiction,
'prefill': prefill,
'communes': [
item.commune for item in
JurisdictionCommune.objects.filter(jurisdiction=jurisdiction)
],
}
context['form'] = Form(initial=initial, include={'user': user})
return render_with_info_profile(request, self.template, context=context)
else:
context['form'] = Form(include={'user': user})
return render_with_info_profile(request, self.template, context=context)
if not ('save' in request.POST or 'continue' in request.POST):
return render_with_info_profile(request, self.template, context=context)
try:
with transaction.atomic():
if not code:
properties = dict(
(item, form.cleaned_data[item]) for item in form.Meta.property_fields)
try:
jurisdiction = Jurisdiction.objects.create(**properties)
except IntegrityError:
if prefill:
jurisdiction = Jurisdiction.objects.get(**properties)
else:
for item in form.Meta.property_fields:
setattr(jurisdiction, item, form.cleaned_data[item])
jurisdiction.save(old=code)
JurisdictionCommune.objects \
.filter(jurisdiction=jurisdiction) \
.exclude(commune__in=form.cleaned_data['communes']) \
.delete()
for commune in form.cleaned_data['communes']:
kvp = {'jurisdiction': jurisdiction, 'commune': commune}
try:
JurisdictionCommune.objects.get(**kvp)
except JurisdictionCommune.DoesNotExist:
kvp['created_by'] = profile
JurisdictionCommune.objects.create(**kvp)
jurisdiction.set_geom()
# Ugly time:
if fake:
url = '{}?organisation={}'.format(
request.build_absolute_uri(reverse(
'idgo_admin:jurisdiction_editor', kwargs={'code': 'new'})),
organisation.pk)
# E-mail envoyé aux administrateurs
send_mail_asking_for_jurisdiction_creation(user, jurisdiction, organisation, url)
# E-mail envoyé à l'utilisateur
send_jurisdiction_creation_mail(user, jurisdiction, organisation)
raise FakeError('Force atomic to roll back.')
except ValidationError as e:
messages.error(request, ' '.join(e))
except FakeError:
# S'il s'agit d'une simple demande on revient
# toujours sur la liste des organisations
messages.success(request, (
'Votre demande de création de territoire '
'de compétence a été envoyée aux administrateurs.'))
return HttpResponseRedirect(
reverse('idgo_admin:show_organisation', kwargs={'id': organisation.id}))
else:
messages.success(request, (
'Le territoire de compétence a été '
'{} avec succès.').format(code and 'mis à jour' or 'créé'))
if 'save' in request.POST:
to = '{}#{}'.format(
reverse('idgo_admin:jurisdictions'), jurisdiction.code)
else: # continue
to = reverse(
'idgo_admin:jurisdiction_editor',
kwargs={'code': jurisdiction.code})
return HttpResponseRedirect(to)
def get(self, request, dataset_id=None, *args, **kwargs):
user, profile = user_and_profile(request)
dataset = get_object_or_404_extended(Dataset, user, include={'id': dataset_id})
context = {
'dataset': dataset,
}
return render_with_info_profile(request, 'resource/new.html', context)
# @method_decorator(decorators, name='dispatch')
# class ResourceManager(View):
# template = 'resource/resource.html'
#
# def get_context(self, form, user, dataset, resource=None):
# return {
# 'target': datasets_target(dataset, user),
# 'dataset': dataset,
# 'resource': resource,
# 'form': form,
# }
#
# def resource_router(self, dataset_id, app, instance_id=None, action='create'):
# from django.apps import apps
# from django.urls.exceptions import NoReverseMatch
# if apps.is_installed(app):
# url_pattern = "{0}:resource-{0}-{1}".format(app, action)
# kvp = {'dataset_id': dataset_id}
# if action == 'update':
# kvp['pk'] = instance_id
# return reverse(url_pattern, kwargs=kvp)
# else:
# raise NoReverseMatch
#
# @ExceptionsHandler(actions={ProfileHttp404: on_profile_http404})
# def get(self, request, dataset_id=None, *args, **kwargs):
#
# user, profile = user_and_profile(request)
#
# dataset = get_object_or_404_extended(
# Dataset, user, include={'id': dataset_id})
# # redirect to resource children app:
# app = request.POST.get('app', request.GET.get('app'))
# if app:
# return redirect(self.resource_router(dataset_id, app, action='create'))
# # Redirect to layer
# # _resource = request.GET.get('resource')
# # _layer = request.GET.get('layer')
# # if _resource and _layer:
# # return redirect(
# # reverse('idgo_admin:layer_editor', kwargs={
# # 'dataset_id': dataset.id,
# # 'resource_id': _resource,
# # 'layer_id': _layer}))
# #
# # resource = None
# # id = request.GET.get('id')
# # if id:
# # include = {'id': id, 'dataset_id': dataset.id}
# # resource = get_object_or_404_extended(Resource, user, include=include)
#
# # form = Form(instance=resource)
# context = self.get_context(None, user, dataset, resource=resource)
# return render_with_info_profile(request, self.template, context)
#
# @ExceptionsHandler(ignore=[Http404], actions={ProfileHttp404: on_profile_http404})
# @transaction.atomic
# def post(self, request, dataset_id=None, *args, **kwargs):
# user, profile = user_and_profile(request)
# dataset = get_object_or_404_extended(
# Dataset, user, include={'id': dataset_id})
# form = Form(request.POST, request.FILES)
# if form.is_valid():
#
# try:
# resource = form.save()
# except Exception:
# logger.excption('ResourceManager:post')
# else:
# app = request.POST.get('app')
# return redirect(self.resource_router(dataset_id, app, action='create'))
#
# context = self.get_context(form, user, dataset, resource)
# return render_with_info_profile(request, self.template, context)
# @login_required(login_url=settings.LOGIN_URL)
# @csrf_exempt
# def resource(request, dataset_id=None, *args, **kwargs):
# user, profile = user_and_profile(request)
#
# id = request.GET.get('id', request.GET.get('ckan_id'))
# if not id:
# raise Http404()
#
# kvp = {}
# try:
# id = int(id)
# except ValueError:
# kvp['ckan_id'] = id
# else:
# kvp['id'] = id
# finally:
# resource = get_object_or_404(Resource, **kvp)
#
# # TODO:
# # return redirect(reverse('idgo_admin:resource_editor', kwargs={
# # 'dataset_id': resource.dataset.id, 'resource_id': resource.id}))
# return redirect(
# '{}?id={}'.format(
# reverse(
# 'resource:resource', kwargs={'dataset_id': resource.dataset.id}),
# resource.id))
def post(self, request, id, *args, **kwargs):
user, profile = user_and_profile(request)
instance = get_object_or_404(Organisation, id=id, is_active=True)
if not request.is_ajax():
if 'delete' in request.POST and instance.geonet_id:
try:
geonet.delete_record(instance.geonet_id)
instance.geonet_id = None
instance.save()
except Exception as e:
messages.error(
request,
"La fiche de metadonnées a été supprimée avec succès.")
else:
messages.success(
request,
"La fiche de metadonnées a été supprimée avec succès.")
return HttpResponseRedirect(
reverse(self.namespace, kwargs={'id': instance.id}))
root = ET.fromstring(request.body)
ns = {
'gmd': 'http://www.isotc211.org/2005/gmd',
'gco': 'http://www.isotc211.org/2005/gco'
}
id = root.find('gmd:fileIdentifier/gco:CharacterString', ns).text
record = ET.tostring(root,
encoding='utf-8',
method='xml',
short_empty_elements=True)
if not geonet.is_record_exists(id):
try:
geonet.create_record(id, record)
except Exception:
messages.error(
request,
'La création de la fiche de métadonnées a échoué.')
else:
geonet.publish(id) # Toujours publier la fiche
instance.geonet_id = id
instance.save()
messages.success(
request,
'La fiche de metadonnées a été créée avec succès.')
else:
try:
geonet.update_record(id, record)
except Exception:
messages.error(
request,
'La mise à jour de la fiche de métadonnées a échoué.')
else:
messages.success(
request,
'La fiche de metadonnées a été créée avec succès.')
return HttpResponse()
def get(self, request, id, *args, **kwargs):
user, profile = user_and_profile(request)
instance = get_object_or_404(Organisation, id=id, is_active=True)
config = {
'app_name': 'mdEdit',
'app_title': 'mdEdit',
'app_version': '0.14.9',
'app_copyrights': '(c) CIGAL 2016',
'languages': {
'locales': ['fr']
},
'defaultLanguage': 'fr',
'server_url_md': GEONETWORK_URL,
'views': {
'list': [{
'path':
reverse('idgo_admin:service_mdedit_tpl_edit',
kwargs={'id': instance.id}),
'values': {
'fr': 'Edition'
},
'locales': {
'fr': join_url('views/edit/tpl-edit_fr.json')
}
}, {
'path':
join_url('tpl-view.html', path=MDEDIT_HTML_PATH),
'values': {
'fr': 'Vue'
},
'locales': {
'fr': join_url('views/view/tpl-view_fr.json')
}
}]
},
'models': {
'list': [{
'path': join_url(MDEDIT_SERVICE_MODEL),
'value': 'Modèle de fiche vierge'
}]
},
'locales': MDEDIT_LOCALES,
'locales_path': join_url('locales/'),
'geographicextents_list': join_url('list_geographicextents.json'),
'referencesystems_list': join_url('list_referencesystems.json'),
'static_root': join_url('libs/mdedit/', path=STATIC_URL),
'modal_template': {
'help': join_url('modal-help.html', path=MDEDIT_HTML_PATH)
}
}
context = {
'organisation': instance,
'doc_url': READTHEDOC_URL_INSPIRE,
'config': config
}
record = instance.geonet_id and geonet.get_record(
str(instance.geonet_id)) or None
if record:
xml = record.xml.decode(encoding='utf-8')
context['record_xml'] = re.sub('\n', '',
xml).replace("'",
"\\'") # C'est moche
else:
context['record_obj'] = prefill_service_model(instance)
return render_with_info_profile(request,
self.template,
context=context)
def list_my_datasets(request, *args, **kwargs):
user, profile = user_and_profile(request)
context = handle_context(
Dataset.default.filter(editor=user), request.GET, target='mine')
return render_with_info_profile(
request, 'idgo_admin/dataset/datasets.html', status=200, context=context)
def get(self, request, id, *args, **kwargs):
user, profile = user_and_profile(request)
get_object_or_404(Organisation, id=id, is_active=True)
return render(request, self.template)
def post(self, request, id, *args, **kwargs):
user, profile = user_and_profile(request)
if not LiaisonsContributeurs.objects.filter(
profile=profile, validated_on__isnull=False).exists():
raise Http404()
if id != 'new':
instance = get_object_or_404_extended(Dataset, user, include={'id': id})
else:
instance = None
id = None
include = {
'user': user,
'id': id,
'identification': id and True or False,
}
form = Form(request.POST, request.FILES, instance=instance, include=include)
context = self.get_context(form, user, instance)
if not form.is_valid():
errors = form._errors.get('__all__', [])
errors and messages.error(request, ' '.join(errors))
return render_with_info_profile(
request, 'idgo_admin/dataset/dataset.html', context)
data = form.cleaned_data
kvp = {
'broadcaster_name': data['broadcaster_name'],
'broadcaster_email': data['broadcaster_email'],
'slug': data['slug'],
'date_creation': data['date_creation'],
'date_modification': data['date_modification'],
'date_publication': data['date_publication'],
'description': data['description'],
'geocover': data['geocover'],
'granularity': data['granularity'],
'license': data['license'],
'title': data['title'],
'organisation': data['organisation'],
'owner_email': data['owner_email'],
'owner_name': data['owner_name'],
'update_frequency': data['update_frequency'],
'published': data['published'],
'support': data['support'],
'thumbnail': data['thumbnail'],
}
try:
with transaction.atomic():
if id:
instance = Dataset.objects.get(pk=id)
for k, v in kvp.items():
setattr(instance, k, v)
else:
kvp['editor'] = user
save_opts = {'current_user': user, 'synchronize': False}
instance = Dataset.default.create(save_opts=save_opts, **kvp)
instance.categories.set(data.get('categories', []), clear=True)
keywords = data.get('keywords')
if keywords:
instance.keywords.clear()
for k in keywords:
instance.keywords.add(k)
instance.data_type.set(data.get('data_type', []), clear=True)
instance.save(current_user=user, synchronize=True)
except ValidationError as e:
messages.error(request, ' '.join(e))
except CkanBaseError as e:
form.add_error('__all__', e.__str__())
messages.error(request, e.__str__())
else:
if id:
send_dataset_update_mail(user, instance)
else:
send_dataset_creation_mail(user, instance)
if id:
messages.success(request, 'Le jeu de données a été mis à jour avec succès.')
else:
messages.success(request, (
'Le jeu de données a été créé avec succès. Souhaitez-vous '
'<a href="{0}">créer un nouveau jeu de données</a> ? ou '
'<a href="{1}">ajouter une ressource</a> ? ou bien '
'<a href="{2}/dataset/{3}" target="_blank">voir le jeu '
'de données dans CKAN</a> ?').format(
reverse('idgo_admin:dataset_editor', kwargs={'id': 'new'}),
reverse('idgo_admin:resource', kwargs={'dataset_id': instance.id}),
CKAN_URL, instance.slug))
if 'continue' in request.POST:
return HttpResponseRedirect(
reverse('idgo_admin:dataset_editor', kwargs={'id': instance.id}))
target = instance.editor == profile.user and 'my' or 'all'
url = reverse('idgo_admin:list_{target}_datasets'.format(target=target))
return HttpResponseRedirect('{url}#{hash}'.format(url=url, hash=instance.slug))
return render_with_info_profile(request, 'idgo_admin/dataset/dataset.html', context)
def post(self, request, code):
user, profile = user_and_profile(request)
if code not in ('for', 'new'):
if not profile.is_crige_admin:
raise Http404
fake = None
jurisdiction = get_object_or_404(Jurisdiction, code=code)
else:
if code == 'new' and not profile.is_crige_admin:
raise Http404
fake = (code == 'for')
jurisdiction = None
code = None
organisation_pk = request.GET.get('organisation')
if organisation_pk:
organisation = get_object_or_404(Organisation, pk=organisation_pk)
else:
organisation = None
form = Form(request.POST, instance=jurisdiction, include={'user': user})
basemaps = BaseMaps.objects.all()
communes = serialize(
'geojson', Commune.objects.all().transform(srid=4326),
geometry_field='geom')
context = {
'basemaps': basemaps,
'communes': communes,
'fake': fake,
'form': form,
'instance': jurisdiction,
'organisation': organisation}
if not form.is_valid():
return render_with_info_profile(request, self.template, context=context)
try:
with transaction.atomic():
if not code:
jurisdiction = Jurisdiction.objects.create(**dict(
(item, form.cleaned_data[item])
for item in form.Meta.property_fields))
else:
for item in form.Meta.property_fields:
setattr(jurisdiction, item, form.cleaned_data[item])
jurisdiction.save(old=code)
JurisdictionCommune.objects \
.filter(jurisdiction=jurisdiction) \
.exclude(commune__in=form.cleaned_data['communes']) \
.delete()
for commune in form.cleaned_data['communes']:
kvp = {'jurisdiction': jurisdiction, 'commune': commune}
try:
JurisdictionCommune.objects.get(**kvp)
except JurisdictionCommune.DoesNotExist:
kvp['created_by'] = profile
JurisdictionCommune.objects.create(**kvp)
jurisdiction.set_geom()
# Ugly time:
if fake:
url = '{}?organisation={}'.format(
request.build_absolute_uri(reverse(
'idgo_admin:jurisdiction_editor', kwargs={'code': 'new'})),
organisation.pk)
# E-mail envoyé aux administrateurs
send_mail_asking_for_jurisdiction_creation(user, jurisdiction, organisation, url)
# E-mail envoyé à l'utilisateur
send_jurisdiction_creation_mail(user, jurisdiction, organisation)
raise FakeError('Force atomic to roll back.')
except ValidationError as e:
messages.error(request, ' '.join(e))
except FakeError as e:
messages.success(request, (
'Votre demande de création de territoire '
'de compétence a été envoyée aux administrateurs.'))
else:
messages.success(request, (
'Le territoire de compétence a été '
'{} avec succès.').format(code and 'mis à jour' or 'créé'))
if 'save' in request.POST:
to = '{}#{}'.format(
reverse('idgo_admin:jurisdictions'), jurisdiction.code)
else:
to = reverse(
'idgo_admin:jurisdiction_editor',
kwargs={'code': jurisdiction.code})
if fake:
# S'il s'agit d'une simple demande on revient
# toujours sur la liste des organisations
to = reverse('idgo_admin:all_organisations')
return HttpResponseRedirect(to)
