def handle_pust_request(request, dataset_name=None):
# name -> slug
# published -> private
user = request.user
dataset = None
if dataset_name:
for instance in handler_get_request(request):
if instance.slug == dataset_name:
dataset = instance
break
if not instance:
raise Http404()
# TODO: Vérifier les droits
data = getattr(request, request.method).dict()
organisation_slug = data.get('organisation')
if organisation_slug:
try:
organisation = Organisation.objects.get(slug=organisation_slug)
except Organisation.DoesNotExist as e:
raise GenericException(details=e.__str__())
elif dataset:
organisation = dataset.organisation
else:
organisation = None
license_slug = data.get('license')
if data.get('license'):
try:
license = License.objects.get(slug=license_slug)
except License.DoesNotExist as e:
raise GenericException(details=e.__str__())
elif dataset:
license = dataset.license
else:
license = None
data_form = {
'title': data.get('title', dataset and dataset.title),
'slug': data.get('name', slugify(data.get('title'))),
'description': data.get('description'),
# 'thumbnail' -> request.FILES
'keywords': data.get('keywords'),
'categories': data.get('categories'),
'date_creation': data.get('date_creation'),
'date_modification': data.get('date_modification'),
'date_publication': data.get('date_publication'),
'update_frequency': data.get('update_frequency'),
# 'geocover'
'granularity': data.get('granularity', 'indefinie'),
'organisation': organisation.pk,
'license': license.pk,
'support': data.get('support', True),
'data_type': data.get('type'),
'owner_name': data.get('owner_name'),
'owner_email': data.get('owner_email'),
'broadcaster_name': data.get('broadcaster_name'),
'broadcaster_email': data.get('broadcaster_email'),
'published': not data.get('private', False),
}
pk = dataset and dataset.pk or None
include = {'user': user, 'id': pk, 'identification': pk and True or False}
form = Form(data_form, request.FILES, instance=dataset, include=include)
if not form.is_valid():
raise GenericException(details=form._errors)
data = form.cleaned_data
kvp = {
'title': data['title'],
'slug': data['slug'],
'description': data['description'],
'thumbnail': data['thumbnail'],
# keywords
# categories
'date_creation': data['date_creation'],
'date_modification': data['date_modification'],
'date_publication': data['date_publication'],
'update_frequency': data['update_frequency'],
'geocover': data['geocover'],
'granularity': data['granularity'],
'organisation': data['organisation'],
'license': data['license'],
'support': data['support'],
# data_type
'owner_email': data['owner_email'],
'owner_name': data['owner_name'],
'broadcaster_name': data['broadcaster_name'],
'broadcaster_email': data['broadcaster_email'],
'published': data['published'],
}
try:
with transaction.atomic():
if dataset:
for k, v in kvp.items():
setattr(dataset, k, v)
else:
kvp['editor'] = user
save_opts = {'current_user': user, 'synchronize': False}
dataset = Dataset.default.create(save_opts=save_opts, **kvp)
dataset.categories.set(data.get('categories', []), clear=True)
keywords = data.get('keywords')
if keywords:
dataset.keywords.clear()
for k in keywords:
dataset.keywords.add(k)
dataset.data_type.set(data.get('data_type', []), clear=True)
dataset.save(current_user=user, synchronize=True)
except ValidationError as e:
form.add_error('__all__', e.__str__())
except CkanBaseError as e:
form.add_error('__all__', e.__str__())
else:
if dataset_name:
send_dataset_update_mail(user, dataset)
else:
send_dataset_creation_mail(user, dataset)
return dataset
raise GenericException(details=form.__str__())
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 handle_pust_request(request, dataset_name=None):
# name -> slug
# type -> data_type
# categories/category -> categories
# private -> published
user = request.user
dataset = None
if dataset_name:
for instance in handler_get_request(request):
if instance.slug == dataset_name:
dataset = instance
break
if not instance:
raise Http404()
query_data = getattr(request, request.method) # QueryDict
# Forcer l'éditeur (attention privilège d'admin)
editor = None
if user.profile.is_admin:
editor = query_data.pop('editor', None)
if editor:
try:
editor = User.objects.get(username=editor[-1])
except User.DoesNotExist as e:
raise GenericException(details={'editor': e.__str__()})
# slug/name
slug = query_data.pop('name', dataset and [dataset.slug])
if slug:
query_data.__setitem__('slug', slug[-1])
# `title` est obligatoire
title = query_data.pop('title', dataset and [dataset.title])
if title:
query_data.__setitem__('title', title[-1])
# `organisation`
organisation_slug = query_data.pop('organisation', None)
if organisation_slug:
try:
organisation = Organisation.objects.get(slug=organisation_slug[-1])
except Organisation.DoesNotExist as e:
raise GenericException(details=e.__str__())
elif dataset:
organisation = dataset.organisation
else:
organisation = None
if organisation:
query_data.__setitem__('organisation', organisation.pk)
# `licence`
license_slug = query_data.pop('license', None)
if license_slug:
try:
license = License.objects.get(slug=license_slug[-1])
except License.DoesNotExist as e:
raise GenericException(details=e.__str__())
elif dataset:
license = dataset.license
else:
license = None
if license:
query_data.__setitem__('license', license.pk)
# `categories`
category_slugs = query_data.pop('categories',
query_data.pop('category', None))
if category_slugs:
try:
categories = Category.objects.filter(slug__in=category_slugs)
except Category.DoesNotExist as e:
raise GenericException(details=e.__str__())
elif dataset:
categories = dataset.categories.all()
else:
categories = None
if categories:
query_data.setlist('categories',
[instance.pk for instance in categories])
# `data_type`
data_type_slugs = query_data.pop(
'types', query_data.pop('type', query_data.pop('data_type', None)))
if data_type_slugs:
try:
data_type = DataType.objects.filter(slug__in=data_type_slugs)
except DataType.DoesNotExist as e:
raise GenericException(details=e.__str__())
elif dataset:
data_type = dataset.data_type.all()
else:
data_type = None
if data_type:
query_data.setlist('data_type',
[instance.pk for instance in data_type])
# `keywords`
keyword_tags = query_data.pop('keywords', query_data.pop('keyword', None))
if keyword_tags:
query_data.__setitem__('keywords', ','.join(keyword_tags))
# `published` or `private`
published = query_data.pop('published', None)
private = query_data.pop('private', None)
if (published and published[-1].lower() in ('on', 'true',)) or \
(private and private[-1].lower() in ('off', 'false',)):
query_data.__setitem__('published', True)
elif (published and published[-1].lower() in ('off', 'false',)) or \
(private and private[-1].lower() in ('on', 'true',)):
query_data.__setitem__('published', False)
pk = dataset and dataset.pk or None
include = {
'user': editor or user,
'id': pk,
'identification': pk and True or False
}
# TODO: Extent
extent = query_data.pop('extent', None)
form = Form(query_data, request.FILES, instance=dataset, include=include)
if not form.is_valid():
raise GenericException(details=form._errors)
data = form.cleaned_data
kvp = {
'title': data['title'],
'slug': data['slug'],
'description': data['description'],
'thumbnail': data['thumbnail'],
# keywords
# categories
'date_creation': data['date_creation'],
'date_modification': data['date_modification'],
'date_publication': data['date_publication'],
'update_frequency': data['update_frequency'],
'geocover': data['geocover'],
'granularity': data['granularity'],
'organisation': data['organisation'],
'license': data['license'],
'support': data['support'],
# data_type
'owner_email': data['owner_email'],
'owner_name': data['owner_name'],
'broadcaster_name': data['broadcaster_name'],
'broadcaster_email': data['broadcaster_email'],
'published': data['published'],
}
try:
with transaction.atomic():
if dataset:
for k, v in kvp.items():
setattr(dataset, k, v)
else:
kvp['editor'] = editor or user
save_opts = {'current_user': user, 'synchronize': False}
dataset = Dataset.default.create(save_opts=save_opts, **kvp)
# categories
categories = Category.objects.filter(pk__in=data.get('categories'))
dataset.categories.set(categories, clear=True)
# data_type
data_type = DataType.objects.filter(pk__in=data.get('data_type'))
dataset.data_type.set(data_type, clear=True)
# keywords
keywords = data.get('keywords')
if keywords:
dataset.keywords.clear()
for k in keywords:
dataset.keywords.add(k)
dataset.save(current_user=user, synchronize=True)
except ValidationError as e:
form.add_error('__all__', e.__str__())
except CkanBaseError as e:
form.add_error('__all__', e.__str__())
else:
if dataset_name:
send_dataset_update_mail(user, dataset)
else:
send_dataset_creation_mail(user, dataset)
return dataset
raise GenericException(details=form.__str__())