1import logging 

2import os 

3import uuid as uuidlib 

4from datetime import date 

5 

6from actstream import action 

7from django.conf import settings 

8from django.contrib import messages 

9from django.contrib.auth.decorators import login_required 

10from django.contrib.contenttypes.models import ContentType 

11from django.core.exceptions import ( 

12 ImproperlyConfigured, 

13 PermissionDenied, 

14 ValidationError, 

15) 

16from django.forms.models import inlineformset_factory 

17from django.http import FileResponse, Http404, HttpResponse 

18from django.shortcuts import get_object_or_404, redirect, render 

19from django.utils.translation import gettext as _ 

20from django_q.tasks import fetch 

21from django.utils.safestring import mark_safe 

22from guardian.shortcuts import get_objects_for_user, get_users_with_perms 

23 

24from discuss_data.core.decorators import dd_tou_accepted 

25from discuss_data.core.errors import MetaDataError 

26from discuss_data.core.helpers import check_perms, check_perms_403 

27from discuss_data.core.models import KeywordTagged, LanguageTagged 

28from discuss_data.core.views import ( 

29 handler403, 

30 response403, 

31) 

32from discuss_data.core.helpers import get_help_texts 

33from discuss_data.ddcomments.models import Notification 

34from discuss_data.dddatasets.forms import ( 

35 DataFileUploadForm, 

36 DataSetCopyrightForm, 

37 DataSetPrivacyRightsForm, 

38 DataSetCreatorFormSetHelper, 

39 DataSetEditForm, 

40 DataSetForm, 

41 DataSetImageForm, 

42 DataSetIndividualLicenseForm, 

43 DataSetPublicationForm, 

44 DataSetPublishAccept, 

45 DataSubmissionAgreementAcceptForm, 

46 DataSubmissionAgreementForm, 

47) 

48from discuss_data.dddatasets.models import ( 

49 AnalysisMethodsTagged, 

50 Category, 

51 CollectionMethodsTagged, 

52 DataFile, 

53 DataSet, 

54 DataSetCreator, 

55 DataSetManagementObject, 

56 DataSetPublication, 

57 DataSubmissionAgreement, 

58 DisciplinesTagged, 

59 License, 

60) 

61from discuss_data.dddatasets.utils import ( 

62 dataset_comments, 

63 dataset_edit_comment, 

64 get_dataset_fields_from_form, 

65 get_man_page, 

66) 

67from discuss_data.ddpublications.forms import PublicationForm 

68from discuss_data.ddpublications.models import Publication 

69from discuss_data.ddusers.forms import DariahTermsOfUse 

70from discuss_data.ddusers.models import Country, User 

71from discuss_data.ddusers.views import user_notifications, user_search 

72from discuss_data.dhrep.publisher import Publisher, PublisherError 

73from discuss_data.dhrep.token import TokenHelper 

74from discuss_data.pages.models import LicensePage 

75 

76logger = logging.getLogger(__name__) 

77 

78 

79""" prep views 

80 TODO: split up further 

81""" 

82 

83 

84@login_required 

85@dd_tou_accepted 

86def listing(request): 

87 context = dict() 

88 user = request.user 

89 context["user"] = user 

90 dsmo_admin = set( 

91 get_objects_for_user(user, "admin_dsmo", DataSetManagementObject).exclude( 

92 owner=user 

93 ) 

94 ) 

95 dsmo_edit = set( 

96 get_objects_for_user(user, "edit_dsmo", DataSetManagementObject).exclude( 

97 owner=user 

98 ) 

99 ) 

100 dsmo_view = set( 

101 get_objects_for_user(user, "view_dsmo", DataSetManagementObject).exclude( 

102 owner=user 

103 ) 

104 ) 

105 

106 context["dsmo_own"] = DataSetManagementObject.objects.filter(owner=user) 

107 context["dsmo_admin"] = dsmo_admin 

108 context["dsmo_edit"] = dsmo_edit.difference(dsmo_admin) 

109 context["dsmo_view"] = dsmo_view.difference(dsmo_edit) 

110 

111 # logger.debug(objects_own) 

112 # logger.debug(objects_view) 

113 context["manpage"] = get_man_page("dataset-list") # ddataset-edit-description") 

114 context["object_type"] = "dataset management object" 

115 context["edit_url"] = "dataset_edit" 

116 context["add_url"] = "dataset_add" 

117 context["delete_url"] = "ic_ds_remove" 

118 

119 return render(request, "dddatasets/prep/listing.html", context) 

120 

121 

122@login_required 

123@dd_tou_accepted 

124def add(request): 

125 if request.method == "POST": 

126 ds = DataSet() 

127 form = DataSetEditForm(request.POST, request.FILES, instance=ds) 

128 if form.is_valid(): 

129 ds = form.save(commit=False) 

130 ds.owner = request.user 

131 try: 

132 ds.save() 

133 except LicensePage.DoesNotExist as e: 

134 messages.error(request, e) 

135 logger.error(e) 

136 raise Http404(e) from e 

137 form.save_m2m() 

138 main_category_slug = form.cleaned_data.get("main_category") 

139 main_category = Category.objects.get(slug=main_category_slug) 

140 ds.dataset_management_object.main_category = main_category 

141 ds.dataset_management_object.save() 

142 return redirect("dddatasets:prep_edit", ds_uuid=ds.uuid) 

143 else: 

144 messages.warning(request, form.errors.as_data()) 

145 else: 

146 form = DataSetEditForm() 

147 

148 return render( 

149 request, 

150 "dddatasets/prep/dataset_add.html", 

151 { 

152 "manpage": get_man_page("data-upload"), 

153 "user": request.user, 

154 "form": form, 

155 "categories_all": Category.objects.all().order_by("name"), 

156 "btn_text": _("Add Dataset"), 

157 }, 

158 ) 

159 

160 

161@login_required 

162@dd_tou_accepted 

163def remove(request): 

164 """ 

165 Function to delete a dataset which uses ic-delete-from and 

166 the DELETE http-method (POST, but translated by django-intercooler-helpers) 

167 and form data to send the uuid 

168 """ 

169 # redirect if no intercooler request 

170 if not request.is_intercooler(): 

171 return redirect("dddatasets:prep_listing") 

172 if request.method == "DELETE": 

173 ds_uuid = request.DELETE["objectid"] 

174 ds = get_object_or_404(DataSet, uuid=ds_uuid) 

175 if ds.owner != request.user: 

176 raise PermissionDenied() 

177 

178 if ds.is_frozen(): 

179 messages.error( 

180 request, 

181 _( 

182 "Deletion of published datasets or currently reviewed datasets is not possible" 

183 ), 

184 ) 

185 return edit_versions(request, ds.uuid) 

186 

187 dsmo = ds.dataset_management_object 

188 ds.delete() 

189 

190 topversion = dsmo.get_top_version_dataset() 

191 return redirect("dddatasets:prep_edit_versions", ds_uuid=topversion.uuid) 

192 else: 

193 # redirect Requests other than DELETE 

194 return redirect("dddatasets:prep_listing") 

195 

196 

197@login_required 

198@dd_tou_accepted 

199def refresh_header(request, ds_uuid): 

200 ds = get_object_or_404(DataSet, uuid=ds_uuid) 

201 if not check_perms("edit_dsmo", request.user, ds.dataset_management_object): 

202 return response403("Access denied") 

203 return render(request, "dddatasets/prep/_dataset_refresh_header.html", {"ds": ds},) 

204 

205 

206@login_required 

207@dd_tou_accepted 

208def edit(request, ds_uuid): 

209 """ 

210 Prep area tab to edit dataset description 

211 TODO: can probably be merged with edit_detail 

212 """ 

213 ds = get_object_or_404(DataSet, uuid=ds_uuid) 

214 

215 if ds.is_frozen(): 

216 if ds.pub_request_pending() and request.user in ds.get_curators(): 

217 pass 

218 else: 

219 return redirect("dddatasets:prep_edit_versions", ds_uuid=ds.uuid,) 

220 else: 

221 if not check_perms("edit_dsmo", request.user, ds.dataset_management_object): 

222 return response403("Access denied") 

223 

224 context = dict() 

225 context["help_texts"] = get_help_texts("edit-dataset-description-add-tags") 

226 context["ds"] = ds 

227 

228 return render(request, "dddatasets/prep/edit.html", context) 

229 

230 

231@login_required 

232@dd_tou_accepted 

233def edit_image(request, ds_uuid): 

234 ds = get_object_or_404(DataSet, uuid=ds_uuid) 

235 if ds.is_frozen(): 

236 if ds.pub_request_pending() and request.user in ds.get_curators(): 

237 pass 

238 else: 

239 return redirect("dddatasets:prep_edit_versions", ds_uuid=ds.uuid,) 

240 else: 

241 if not check_perms("edit_dsmo", request.user, ds.dataset_management_object): 

242 return response403("Access denied") 

243 err = None 

244 

245 if request.method == "POST": 

246 if not check_perms("edit_dsmo", request.user, ds.dataset_management_object): 

247 return response403("Access denied") 

248 form = DataSetImageForm(request.POST, request.FILES) 

249 if form.is_valid(): 

250 if form.cleaned_data["image"]: 

251 ds.image = form.cleaned_data["image"] 

252 ds.save() 

253 action.send(request.user, verb="edited image of", target=ds, public=False) 

254 return HttpResponse("upload successful") 

255 else: 

256 err = form.errors.as_data() 

257 

258 response = render( 

259 request, "dddatasets/prep/_dataset_image.html", {"ds": ds, "err": err}, 

260 ) 

261 return response 

262 

263 

264@login_required 

265@dd_tou_accepted 

266def edit_detail(request, ds_uuid): 

267 """ 

268 Prep area tab to edit dataset description 

269 """ 

270 updated = False 

271 target = "Dataset description" 

272 ds = get_object_or_404(DataSet, uuid=ds_uuid) 

273 

274 ds_uuid = ds.uuid 

275 categories_all = Category.objects.all().order_by("name") 

276 

277 if ds.is_frozen(): 

278 if ds.pub_request_pending() and request.user in ds.get_curators(): 

279 pass 

280 else: 

281 return redirect("dddatasets:prep_edit_versions", ds_uuid=ds.uuid,) 

282 else: 

283 if not check_perms("edit_dsmo", request.user, ds.dataset_management_object): 

284 return response403("Access denied") 

285 

286 if request.method == "POST": 

287 if not check_perms("edit_dsmo", request.user, ds.dataset_management_object): 

288 return response403("Access denied") 

289 

290 form = DataSetEditForm(request.POST, request.FILES, instance=ds) 

291 if form.is_valid(): 

292 ds = form.save(commit=False) 

293 ds.uuid = ds_uuid 

294 ds.save() 

295 form.save_m2m() 

296 main_category_slug = form.cleaned_data.get("main_category") 

297 categories = form.cleaned_data.get("categories") 

298 main_category = Category.objects.get(slug=main_category_slug) 

299 ds.dataset_management_object.main_category = main_category 

300 ds.dataset_management_object.categories.set(categories) 

301 ds.dataset_management_object.save() 

302 ds.save() 

303 

304 err = None 

305 updated = True 

306 # send an action 

307 action.send( 

308 request.user, verb="edited description of", target=ds, public=False 

309 ) 

310 else: 

311 err = form.errors.as_data() 

312 

313 else: 

314 # user = request.user 

315 err = None 

316 form = DataSetEditForm(instance=ds) 

317 

318 return render( 

319 request, 

320 "core/_edit_form.html", 

321 { 

322 "ds": ds, 

323 "form": form, 

324 "user": request.user, 

325 "updated": updated, 

326 "err": err, 

327 "target": target, 

328 "categories_all": categories_all, 

329 "btn_text": _("Save Description"), 

330 }, 

331 ) 

332 

333 

334@login_required 

335@dd_tou_accepted 

336def country_tags_list(request, ds_uuid): 

337 ds = get_object_or_404(DataSet, uuid=ds_uuid) 

338 if ds.is_frozen(): 

339 if ds.pub_request_pending() and request.user in ds.get_curators(): 

340 pass 

341 else: 

342 return redirect("dddatasets:prep_edit_versions", ds_uuid=ds.uuid,) 

343 else: 

344 if not check_perms("edit_dsmo", request.user, ds.dataset_management_object): 

345 return response403("Access denied") 

346 

347 all_countries = Country.objects.filter(public=True) 

348 countries = list() 

349 for ac in all_countries: 

350 if ac in ds.get_countries(): 

351 countries.append((ac, True)) 

352 else: 

353 countries.append((ac, False)) 

354 

355 return render( 

356 request, 

357 "dddatasets/prep/_dataset_country_tags_list.html", 

358 {"ds": ds, "countries": countries}, 

359 ) 

360 

361 

362@login_required 

363@dd_tou_accepted 

364def object_tags_list(request, object_type): 

365 if object_type == "language": 

366 qs = LanguageTagged.objects.all() 

367 if object_type == "keyword": 

368 qs = KeywordTagged.objects.all() 

369 if object_type == "disciplines": 

370 qs = DisciplinesTagged.objects.all() 

371 if object_type == "methods_of_data_collection": 

372 qs = CollectionMethodsTagged.objects.all() 

373 if object_type == "methods_of_data_analysis": 

374 qs = AnalysisMethodsTagged.objects.all() 

375 query = None 

376 

377 if query: 

378 return qs.filter(name__istartswith=query) 

379 else: 

380 return render(request, "dddatasets/prep/_object_tags_list.html", {"qs": qs}) 

381 

382 

383@login_required 

384@dd_tou_accepted 

385def country_tags_edit(request, ds_uuid): 

386 # redirect if no intercooler request 

387 if not request.is_intercooler(): 

388 return redirect("dddatasets:prep_edit", ds_uuid) 

389 ds = get_object_or_404(DataSet, uuid=ds_uuid) 

390 if not check_perms("edit_dsmo", request.user, ds.dataset_management_object): 

391 return response403("Access denied") 

392 

393 if request.method == "POST": 

394 slug = request.POST.get("country") 

395 country = Country.objects.get(slug=slug) 

396 if country in ds.get_countries(): 

397 ds.countries.remove(country) 

398 else: 

399 ds.countries.add(country) 

400 ds.save() 

401 

402 return country_tags_list(request, ds_uuid) 

403 

404 

405@login_required 

406@dd_tou_accepted 

407def tag_add(request, ds_uuid, object_type): 

408 # redirect if no intercooler request 

409 if not request.is_intercooler(): 

410 return redirect("dddatasets:prep_edit", ds_uuid) 

411 ds = get_object_or_404(DataSet, uuid=ds_uuid) 

412 

413 if ds.is_frozen(): 

414 if ds.pub_request_pending() and request.user in ds.get_curators(): 

415 pass 

416 else: 

417 return redirect("dddatasets:prep_edit_versions", ds_uuid=ds.uuid,) 

418 else: 

419 if not check_perms("edit_dsmo", request.user, ds.dataset_management_object): 

420 return response403("Access denied") 

421 

422 if request.method == "POST": 

423 if check_perms("edit_dsmo", request.user, ds.dataset_management_object): 

424 tag = request.POST.get("%s-tag" % (object_type,), "").title() 

425 if len(tag) > 0: 

426 if object_type == "language": 

427 ds.languages_of_data.add(tag) 

428 elif object_type == "keyword": 

429 ds.keywords.add(tag) 

430 elif object_type == "disciplines": 

431 ds.disciplines.add(tag) 

432 elif object_type == "methods_of_data_collection": 

433 ds.methods_of_data_collection.add(tag) 

434 elif object_type == "methods_of_data_analysis": 

435 ds.methods_of_data_analysis.add(tag) 

436 

437 if object_type == "language": 

438 tags = ds.get_language_tags() 

439 elif object_type == "keyword": 

440 tags = ds.get_keyword_tags() 

441 elif object_type == "disciplines": 

442 tags = ds.get_disciplines_tags() 

443 elif object_type == "methods_of_data_collection": 

444 tags = ds.get_methods_of_data_collection_tags() 

445 elif object_type == "methods_of_data_analysis": 

446 tags = ds.get_methods_of_data_analysis_tags() 

447 else: 

448 tags = None 

449 

450 return render( 

451 request, 

452 "dddatasets/prep/_tag_add_control.html", 

453 {"user": request.user, "ds": ds, "tags": tags, "object": object_type}, 

454 ) 

455 

456 

457@login_required 

458@dd_tou_accepted 

459def tag_remove(request, ds_uuid, object_type): 

460 # redirect if no intercooler request 

461 if not request.is_intercooler(): 

462 return redirect("dddatasets:prep_edit", ds_uuid) 

463 ds = get_object_or_404(DataSet, uuid=ds_uuid) 

464 

465 if request.method == "POST": 

466 tag_pk = request.POST.get("%s-tag-remove" % (object_type,), "") 

467 if len(tag_pk) > 0: 

468 if object_type == "language": 

469 tag = LanguageTagged.objects.get(id=tag_pk) 

470 if check_perms("edit_dsmo", request.user, ds.dataset_management_object): 

471 ds.languages_of_data.remove(tag) 

472 tags = ds.get_language_tags() 

473 if object_type == "keyword": 

474 tag = KeywordTagged.objects.get(id=tag_pk) 

475 if check_perms("edit_dsmo", request.user, ds.dataset_management_object): 

476 ds.keywords.remove(tag) 

477 tags = ds.get_keyword_tags() 

478 if object_type == "disciplines": 

479 tag = DisciplinesTagged.objects.get(id=tag_pk) 

480 if check_perms("edit_dsmo", request.user, ds.dataset_management_object): 

481 ds.disciplines.remove(tag) 

482 tags = ds.get_disciplines_tags() 

483 if object_type == "methods_of_data_collection": 

484 tag = CollectionMethodsTagged.objects.get(id=tag_pk) 

485 if check_perms("edit_dsmo", request.user, ds.dataset_management_object): 

486 ds.methods_of_data_collection.remove(tag) 

487 tags = ds.get_methods_of_data_collection_tags() 

488 if object_type == "methods_of_data_analysis": 

489 tag = AnalysisMethodsTagged.objects.get(id=tag_pk) 

490 if check_perms("edit_dsmo", request.user, ds.dataset_management_object): 

491 ds.methods_of_data_analysis.remove(tag) 

492 tags = ds.get_methods_of_data_analysis_tags() 

493 

494 return render( 

495 request, 

496 "dddatasets/prep/_tag_add_control.html", 

497 {"user": request.user, "ds": ds, "tags": tags, "object": object_type}, 

498 ) 

499 

500 

501@login_required 

502@dd_tou_accepted 

503def edit_metadata(request, ds_uuid): 

504 """ 

505 Prep area tab to edit metadata 

506 """ 

507 updated = False 

508 target = "Dataset Metadata" 

509 manpage = get_man_page("edit-dataset-metadata") 

510 ds = get_object_or_404(DataSet, uuid=ds_uuid) 

511 

512 if ds.is_frozen(): 

513 if ds.pub_request_pending() and request.user in ds.get_curators(): 

514 pass 

515 else: 

516 return redirect("dddatasets:prep_edit_versions", ds_uuid=ds.uuid,) 

517 else: 

518 if not check_perms("edit_dsmo", request.user, ds.dataset_management_object): 

519 return handler403(request) 

520 

521 ds_creators = DataSetCreator.objects.filter(dataset=ds) 

522 next_url = request.session.get(str(ds_uuid) + "wp") 

523 

524 if ds_creators.count() == 0: 

525 extra = 1 

526 else: 

527 extra = 0 

528 

529 DataSetCreatorFormSet = inlineformset_factory( 

530 DataSet, 

531 DataSetCreator, 

532 fields=["name", "creator_type", "url", "first_name"], 

533 extra=extra, 

534 can_delete=True, 

535 ) 

536 

537 if request.method == "POST": 

538 if not check_perms("edit_dsmo", request.user, ds.dataset_management_object): 

539 return HttpResponse(_("Access denied")) 

540 

541 formset = DataSetCreatorFormSet(request.POST, queryset=ds_creators, instance=ds) 

542 helper = DataSetCreatorFormSetHelper() 

543 form = DataSetForm(request.POST, instance=ds) 

544 dsmo = ds.dataset_management_object 

545 version = ds.version 

546 if form.is_valid(): 

547 ds = form.save(commit=False) 

548 ds.dataset_management_object = dsmo 

549 ds.version = version 

550 ds.save() 

551 form.save_m2m() 

552 err = None 

553 updated = True 

554 

555 if formset.is_valid(): 

556 formset.save() 

557 else: 

558 err = formset.errors 

559 action.send( 

560 request.user, verb="edited metadata of", target=ds, public=False 

561 ) 

562 if next_url: 

563 return redirect(next_url) 

564 

565 else: 

566 err = form.errors.as_data() 

567 

568 else: 

569 err = None 

570 formset = DataSetCreatorFormSet(queryset=ds_creators, instance=ds) 

571 helper = DataSetCreatorFormSetHelper() 

572 form = DataSetForm(instance=ds) 

573 

574 help_texts = get_help_texts( 

575 "edit-metadata" 

576 ) # needed to populate creators help in form 

577 

578 return render( 

579 request, 

580 "dddatasets/prep/dataset_edit_metadata.html", 

581 { 

582 "ds": ds, 

583 "formset": formset, 

584 "helper": helper, 

585 "form": form, 

586 "user": request.user, 

587 "updated": updated, 

588 "err": err, 

589 "target": target, 

590 "manpage": manpage, 

591 "help_texts": help_texts, 

592 "next_url": next_url, 

593 }, 

594 ) 

595 

596 

597@login_required 

598@dd_tou_accepted 

599def edit_collaboration(request, ds_uuid): 

600 """ 

601 Prep area tab to edit collaborators 

602 """ 

603 ds = get_object_or_404(DataSet, uuid=ds_uuid) 

604 dsmo = ds.dataset_management_object 

605 manpage = get_man_page("edit-collaboration") 

606 

607 # check_perms_403('admin_dataset', request.user, dsmo) 

608 if check_perms("admin_dsmo", request.user, dsmo): 

609 logger.debug("users with perms: %s", get_users_with_perms(dsmo)) 

610 access = True 

611 else: 

612 access = False 

613 

614 if ds.is_frozen() and request.user not in ds.get_curators(): 

615 return redirect("dddatasets:prep_edit_versions", ds_uuid=ds.uuid,) 

616 

617 user_perms = dsmo.get_dsmo_users_with_perms() 

618 

619 control_args = { 

620 "user_all": dsmo.get_dsmo_users(), 

621 "user_admin": user_perms["admin"], 

622 "user_edit": user_perms["edit"], 

623 "user_view": user_perms["view"], 

624 "groups": dsmo.groups.all(), 

625 "div_id": "dataset-users", 

626 "input_id": "dataset-user", 

627 "url_object_search": "ddusers:user_search", 

628 "text": "Dataset Users", 

629 } 

630 

631 return render( 

632 request, 

633 "dddatasets/prep/dataset_edit_collaboration.html", 

634 {"ds": ds, "manpage": manpage, "control_args": control_args, "access": access}, 

635 ) 

636 

637 

638@login_required 

639@dd_tou_accepted 

640def edit_access_user_search(request, ds_uuid): 

641 # redirect if no intercooler request 

642 if not request.is_intercooler(): 

643 return redirect("dddatasets:prep_edit_publish_access", ds_uuid) 

644 ds = get_object_or_404(DataSet, uuid=ds_uuid) 

645 if not check_perms("edit_dsmo", request.user, ds.dataset_management_object): 

646 return HttpResponse(_("Access denied")) 

647 

648 term = request.GET.get("q") 

649 qs = user_search(term) 

650 

651 search_type = "pubaccess_search" 

652 

653 return render( 

654 request, 

655 "ddusers/_search_results.html", 

656 {"object_list": qs, "ds": ds, "search_type": search_type}, 

657 ) 

658 

659 

660@login_required 

661@dd_tou_accepted 

662def edit_access_user(request, ds_uuid): 

663 ds = get_object_or_404(DataSet, uuid=ds_uuid) 

664 if not check_perms("admin_dsmo", request.user, ds.dataset_management_object): 

665 return HttpResponse(_("Access denied")) 

666 # check_perms_403("admin_dataset", request.user, dsmo) 

667 

668 if request.method == "POST": 

669 userid = request.POST["userid"] 

670 user = User.objects.get(uuid=userid) 

671 perm_code = request.POST["perm"] 

672 feed = request.POST.get("requestsrc") 

673 

674 if perm_code == "clr": 

675 logger.debug("clearing perms for %s", user) 

676 ds.clear_user_permissions(user) 

677 ds.save() 

678 

679 action.send( 

680 request.user, 

681 verb="revoked access", 

682 action_object=ds, 

683 target=user, 

684 public=False, 

685 ) 

686 

687 notification = Notification() 

688 notification.text = "access revoked" 

689 notification.owner = request.user 

690 notification.recipient = user 

691 notification.notification_type = Notification.ACCESS_REQUEST 

692 notification.content_type = ContentType.objects.get_for_model(ds) 

693 notification.object_id = ds.id 

694 notification.save() 

695 

696 elif perm_code == "acc": 

697 access_request = ds.get_access_request(user) 

698 logger.debug("assigning perms for %s", user) 

699 ds.assign_user_permissions(user, "ra_view_dataset") 

700 ds.save() 

701 action.send( 

702 request.user, 

703 verb="granted access", 

704 action_object=ds, 

705 target=user, 

706 public=False, 

707 ) 

708 

709 notification = Notification() 

710 notification.text = "access granted" 

711 notification.owner = request.user 

712 notification.recipient = user 

713 notification.notification_type = Notification.ACCESS_REQUEST 

714 notification.content_type = ContentType.objects.get_for_model(ds) 

715 notification.object_id = ds.id 

716 if access_request: 

717 notification.parent = access_request.notification 

718 notification.save() 

719 

720 if access_request: 

721 access_request.delete() 

722 

723 else: 

724 logger.error("requested non existing perm_code: %s", perm_code) 

725 if feed: 

726 return user_notifications(request) 

727 else: 

728 return edit_publish_access(request, ds_uuid) 

729 

730 

731@login_required 

732@dd_tou_accepted 

733def edit_collaboration_user_search(request, ds_uuid): 

734 ds = get_object_or_404(DataSet, uuid=ds_uuid) 

735 if not check_perms("edit_dsmo", request.user, ds.dataset_management_object): 

736 return HttpResponse(_("Access denied")) 

737 

738 term = request.GET.get("q") 

739 qs = user_search(term) 

740 search_type = "collaboration_search" 

741 

742 return render( 

743 request, 

744 "ddusers/_search_results.html", 

745 {"object_list": qs, "ds": ds, "search_type": search_type}, 

746 ) 

747 

748 

749@login_required 

750@dd_tou_accepted 

751def edit_collaboration_user(request, ds_uuid): 

752 ds = get_object_or_404(DataSet, uuid=ds_uuid) 

753 dsmo = ds.dataset_management_object 

754 if not check_perms("admin_dsmo", request.user, ds.dataset_management_object): 

755 return HttpResponse(_("Access denied")) 

756 # check_perms_403("admin_dataset", request.user, dsmo) 

757 

758 if request.method == "POST": 

759 userid = request.POST["userid"] 

760 user = User.objects.get(uuid=userid) 

761 perm_code = request.POST["perm"] 

762 

763 if perm_code == "clr": 

764 dsmo.clear_user_permissions(user) 

765 elif perm_code == "v": 

766 dsmo.assign_user_permissions(user, "view") 

767 elif perm_code == "e": 

768 dsmo.assign_user_permissions(user, "edit") 

769 elif perm_code == "a": 

770 dsmo.assign_user_permissions(user, "admin") 

771 else: 

772 logger.error("requested non existing perm_code: %s", perm_code) 

773 

774 return edit_collaboration(request, ds_uuid) 

775 

776 

777@login_required 

778@dd_tou_accepted 

779def comments(request, ds_uuid): 

780 """ 

781 calls dataset_comments for "prep" comments 

782 """ 

783 response = dataset_comments(request, ds_uuid, "prep") 

784 return response 

785 

786 

787@login_required 

788@dd_tou_accepted 

789def edit_comment(request, ds_uuid, co_uuid=None): 

790 """ 

791 calls dataset_edit_comment for a "prep" comment 

792 """ 

793 response = dataset_edit_comment(request, ds_uuid, "prep", co_uuid) 

794 return response 

795 

796 

797@login_required 

798@dd_tou_accepted 

799def edit_comment_reply(request, ds_uuid, co_uuid): 

800 """ 

801 calls dataset_edit_comment_reply for a "prep" comment 

802 """ 

803 response = dataset_edit_comment(request, ds_uuid, "prep", co_uuid, reply=True) 

804 return response 

805 

806 

807@login_required 

808@dd_tou_accepted 

809def edit_datafiles(request, ds_uuid): 

810 """ 

811 List datafiles 

812 """ 

813 ds = get_object_or_404(DataSet, uuid=ds_uuid) 

814 if ds.is_frozen(): 

815 if ds.pub_request_pending() and request.user in ds.get_curators(): 

816 pass 

817 else: 

818 return redirect("dddatasets:prep_edit_versions", ds_uuid=ds.uuid,) 

819 else: 

820 if not check_perms("edit_dsmo", request.user, ds.dataset_management_object): 

821 return handler403(request) 

822 manpage = get_man_page("manage-datafiles") 

823 

824 next_url = request.session.get(str(ds_uuid) + "wp") 

825 

826 return render( 

827 request, 

828 "dddatasets/prep/dataset_edit_datafiles.html", 

829 {"ds": ds, "manpage": manpage, "next_url": next_url}, 

830 ) 

831 

832 

833def handle_uploaded_file(file_obj, df_uuid): 

834 # construct filePath using DATA_ROOT setting and datasets prefix 

835 filePath = settings.DATA_ROOT + os.sep + "datasets" + os.sep + str(df_uuid) 

836 with open(filePath, "ab") as destination: 

837 for chunk in file_obj.chunks(): 

838 destination.write(chunk) 

839 return filePath 

840 

841 

842@login_required 

843@dd_tou_accepted 

844def edit_datafile(request, ds_uuid, df_uuid=None): 

845 """ 

846 Add, edit, remove datafiles 

847 """ 

848 ds = get_object_or_404(DataSet, uuid=ds_uuid) 

849 

850 if ds.is_frozen(): 

851 if ds.pub_request_pending() and request.user in ds.get_curators(): 

852 pass 

853 else: 

854 return redirect("dddatasets:prep_edit_versions", ds_uuid=ds.uuid,) 

855 else: 

856 if not check_perms("edit_dsmo", request.user, ds.dataset_management_object): 

857 return handler403(request) 

858 

859 next_url = request.session.get(str(ds_uuid) + "wp") 

860 

861 # DELETE 

862 if request.method == "DELETE": 

863 if not check_perms("edit_dsmo", request.user, ds.dataset_management_object): 

864 return HttpResponse(_("Access denied")) 

865 

866 df_uuid = request.DELETE["objectid"] 

867 datafile = DataFile.objects.get(uuid=df_uuid) 

868 datafile.delete() 

869 # TODO: needs a full http get to close the modal 

870 return redirect("dddatasets:prep_edit_datafiles", ds_uuid=ds.uuid) 

871 

872 if request.method == "POST": 

873 if not check_perms("edit_dsmo", request.user, ds.dataset_management_object): 

874 return HttpResponse(_("Access denied")) 

875 

876 if df_uuid: 

877 # Edit 

878 try: 

879 datafile = DataFile.objects.get(uuid=df_uuid, dataset=ds) 

880 except DataFile.DoesNotExist: 

881 datafile = DataFile(uuid=df_uuid, dataset=ds) 

882 

883 form = DataFileUploadForm(request.POST, request.FILES, instance=datafile) 

884 if form.is_valid(): 

885 if request.FILES: 

886 orig_name = datafile.file.name 

887 filePath = handle_uploaded_file(datafile.file, df_uuid) 

888 datafile.file = filePath 

889 datafile.name = orig_name 

890 

891 datafile.data_file_type = form.cleaned_data["data_file_type"] 

892 datafile.save() 

893 form_err = None 

894 updated = True 

895 else: 

896 updated = False 

897 return HttpResponse(form.errors.as_text(), status=500,) 

898 else: 

899 # POST should always have an df_uuid 

900 return edit_datafiles(request, ds_uuid) 

901 else: 

902 # Get 

903 if df_uuid: 

904 # Edit 

905 datafile = DataFile.objects.get(uuid=df_uuid, dataset=ds) 

906 form = DataFileUploadForm(instance=datafile) 

907 else: 

908 if not check_perms("edit_dsmo", request.user, ds.dataset_management_object): 

909 return HttpResponse(_("Access denied")) 

910 # generate datafile uuid to add to form 

911 df_uuid = uuidlib.uuid4() 

912 form = DataFileUploadForm() 

913 updated = False 

914 form_err = None 

915 return render( 

916 request, 

917 "dddatasets/prep/_dataset_edit_datafile.html", 

918 { 

919 "target": "datafile", 

920 "ictarget": "ds-content", 

921 "form": form, 

922 "user": request.user, 

923 "form_err": form_err, 

924 "updated": updated, 

925 "ds_uuid": ds_uuid, 

926 "df_uuid": df_uuid, 

927 "next_url": next_url, 

928 }, 

929 ) 

930 

931 

932@login_required 

933@dd_tou_accepted 

934def edit_publication(request, ds_uuid, ds_pub_uuid=None): 

935 """ 

936 Add, edit, remove publications 

937 """ 

938 ds = get_object_or_404(DataSet, uuid=ds_uuid) 

939 check_perms_403("edit_dsmo", request.user, ds.dataset_management_object) 

940 # DELETE, remove DatasetPublication object, not Publication 

941 if request.method == "DELETE": 

942 ds_pub_uuid = request.DELETE["objectid"] 

943 ds_pub = DataSetPublication.objects.get(uuid=ds_pub_uuid) 

944 ds_pub.delete() 

945 return redirect("dddatasets:prep_edit_publications", ds_uuid=ds.uuid) 

946 

947 if ds_pub_uuid: 

948 ds_pub = DataSetPublication.objects.get(uuid=ds_pub_uuid) 

949 publication = ds_pub.publication 

950 else: 

951 ds_pub = DataSetPublication() 

952 publication = Publication() 

953 ds_pub.dataset = ds 

954 

955 if request.method == "POST": 

956 if ds_pub_uuid: 

957 # Edit 

958 form = PublicationForm( 

959 request.POST, instance=publication, prefix="publication" 

960 ) 

961 sub_form = DataSetPublicationForm( 

962 request.POST, instance=ds_pub, prefix="ds_pub" 

963 ) 

964 if form.is_valid() and sub_form.is_valid(): 

965 publication = form.save() 

966 ds_pub = sub_form.save() 

967 return edit_publications(request, ds_uuid) 

968 else: 

969 # Add 

970 form = PublicationForm( 

971 request.POST, instance=publication, prefix="publication" 

972 ) 

973 sub_form = DataSetPublicationForm( 

974 request.POST, instance=ds_pub, prefix="ds_pub" 

975 ) 

976 if form.is_valid() and sub_form.is_valid(): 

977 ds_pub = sub_form.save(commit=False) 

978 publication = form.save() 

979 ds_pub.publication = publication 

980 ds_pub.save() 

981 updated = True 

982 form_err = None 

983 return edit_publications(request, ds_uuid) 

984 else: 

985 updated = False 

986 form_err = form.errors.as_data() 

987 else: 

988 # Get 

989 if ds_pub_uuid: 

990 # Edit 

991 form = PublicationForm(instance=publication, prefix="publication") 

992 sub_form = DataSetPublicationForm(instance=ds_pub, prefix="ds_pub") 

993 else: 

994 form = PublicationForm(prefix="publication") 

995 sub_form = DataSetPublicationForm(prefix="ds_pub") 

996 updated = False 

997 form_err = None 

998 return render( 

999 request, 

1000 "core/_edit_form.html", 

1001 { 

1002 "target": "publication", 

1003 "ictarget": "ds-content", 

1004 "form": form, 

1005 "sub_form": sub_form, 

1006 "user": request.user, 

1007 "form_err": form_err, 

1008 "updated": updated, 

1009 "next_url": request.session.get(str(ds_uuid) + "wp"), 

1010 }, 

1011 ) 

1012 

1013 

1014@login_required 

1015@dd_tou_accepted 

1016def edit_publications(request, ds_uuid): 

1017 """Display a list of :class:`discuss_data.dddatasets.Publications` connected to a :class:`discuss_data.dddatasets.DataSet`. 

1018 

1019 **Context** 

1020 

1021 ``ds`` 

1022 An instance of :class:`discuss_data.dddatasets.DataSet`. 

1023 

1024 **Template:** 

1025 

1026 :file:`dddatasets/prep/dataset_edit_publications.html` 

1027 """ 

1028 ds = get_object_or_404(DataSet, uuid=ds_uuid) 

1029 if ds.is_frozen(): 

1030 if ds.pub_request_pending() and request.user in ds.get_curators(): 

1031 pass 

1032 else: 

1033 return redirect("dddatasets:prep_edit_versions", ds_uuid=ds.uuid,) 

1034 else: 

1035 if not check_perms("edit_dsmo", request.user, ds.dataset_management_object): 

1036 return handler403(request) 

1037 

1038 manpage = get_man_page("edit-related-publications") 

1039 control_args = { 

1040 "title": "Publications related to this Data Set", 

1041 "type": "publication", 

1042 "edit_url": "dddatasets:prep_edit_publication", 

1043 "add_url": "dddatasets:prep_edit_publication", 

1044 "list_url": "dddatasets:prep_edit_publications", 

1045 "delete_url": "dddatasets:prep_edit_publication", 

1046 "outer_panel": True, 

1047 "add_text": "Add new publication related to this data set...", 

1048 } 

1049 

1050 return render( 

1051 request, 

1052 "dddatasets/prep/dataset_edit_publications.html", 

1053 { 

1054 "ds": ds, 

1055 "control_args": control_args, 

1056 "manpage": manpage, 

1057 "next_url": request.session.get(str(ds_uuid) + "wp"), 

1058 }, 

1059 ) 

1060 

1061 

1062@login_required 

1063@dd_tou_accepted 

1064def dsa_pdf(request, ds_uuid): 

1065 ds = get_object_or_404(DataSet, uuid=ds_uuid) 

1066 check_perms_403("edit_dsmo", request.user, ds.dataset_management_object) 

1067 # Creating http response 

1068 response = FileResponse(ds.dsa.pdf) 

1069 response["Content-Disposition"] = 'inline; filename="{}"'.format(ds.dsa.pdf.name) 

1070 response["Content-Transfer-Encoding"] = "binary" 

1071 return response 

1072 

1073 

1074@login_required 

1075@dd_tou_accepted 

1076def edit_dsa(request, ds_uuid): 

1077 ds = get_object_or_404(DataSet, uuid=ds_uuid) 

1078 check_perms_403("admin_dsmo", request.user, ds.dataset_management_object) 

1079 

1080 if not ds.dsa: 

1081 ds.dsa = DataSubmissionAgreement() 

1082 

1083 if request.method == "POST": 

1084 form = DataSubmissionAgreementForm(request.POST, instance=ds.dsa) 

1085 if form.is_valid(): 

1086 ds.dsa = form.save() 

1087 ds.save() 

1088 updated = True 

1089 form_err = None 

1090 ds.generate_dsa() 

1091 return edit_versions(request, ds_uuid) 

1092 else: 

1093 updated = False 

1094 form_err = form.errors.as_data() 

1095 else: 

1096 # GET 

1097 form = DataSubmissionAgreementForm(instance=ds.dsa) 

1098 updated = False 

1099 form_err = None 

1100 

1101 return render( 

1102 request, 

1103 "core/_edit_form.html", 

1104 { 

1105 "target": "data submission agreement", 

1106 "ictarget": "ds-content", 

1107 "form": form, 

1108 "user": request.user, 

1109 "form_err": form_err, 

1110 "updated": updated, 

1111 "next_url": request.session.get(str(ds_uuid) + "wp"), 

1112 }, 

1113 ) 

1114 

1115 

1116@login_required 

1117@dd_tou_accepted 

1118def edit_versions(request, ds_uuid): 

1119 ds = get_object_or_404(DataSet, uuid=ds_uuid) 

1120 dsmo = ds.dataset_management_object 

1121 

1122 if ds.pub_request_pending() and request.user not in ds.get_curators(): 

1123 if not check_perms("edit_dsmo", request.user, ds.dataset_management_object): 

1124 return handler403(request) 

1125 

1126 if request.user == dsmo.owner: 

1127 publish_right = True 

1128 else: 

1129 publish_right = False 

1130 

1131 manpage = get_man_page("edit-dataset-versions") 

1132 manpage_dsa = get_man_page("data-submission-agreement") 

1133 

1134 control_args = { 

1135 "publish_right": publish_right, 

1136 "title": "Files", 

1137 "type": "datafile", 

1138 "outer_panel": False, 

1139 "edit_url": "dddatasets:prep_edit", 

1140 "view_url": "dddatasets:detail", 

1141 "add_url": "dddatasets:prep_edit_versions_add", 

1142 "list_url": "dddatasets:prep_edit_versions", 

1143 "delete_url": "dddatasets:prep_remove", 

1144 "object_id": ds.uuid, 

1145 "add_text": "Add new version...", 

1146 "object_type": "version", 

1147 "object_text": "Add version", 

1148 "objects": ds.get_versions(), 

1149 } 

1150 

1151 return render( 

1152 request, 

1153 "dddatasets/prep/dataset_edit_versions.html", 

1154 { 

1155 "ds": ds, 

1156 "control_args": control_args, 

1157 "manpage": manpage, 

1158 "manpage_dsa": manpage_dsa, 

1159 "next_url": request.session.get(str(ds_uuid) + "wp"), 

1160 }, 

1161 ) 

1162 

1163 

1164@login_required 

1165@dd_tou_accepted 

1166def edit_versions_add(request, ds_uuid): 

1167 # TODO: this should be done via POST 

1168 # user = User.objects.get(id=request.user.id) 

1169 ds = get_object_or_404(DataSet, uuid=ds_uuid) 

1170 logger.debug("creating new dataset version, checking permissions") 

1171 if not check_perms("edit_dsmo", request.user, ds.dataset_management_object): 

1172 return HttpResponse(_("Access denied")) 

1173 

1174 logger.debug("creating new dataset version") 

1175 dsnv = ds.create_new_version() 

1176 dsnv.uuid = uuidlib.uuid4() 

1177 dsnv.save() 

1178 messages.success(request, "New version added.") 

1179 # send an action 

1180 action.send( 

1181 request.user, 

1182 verb="created new version {} of".format(dsnv.version), 

1183 target=ds, 

1184 public=False, 

1185 ) 

1186 return edit_versions(request, dsnv.uuid) 

1187 

1188 

1189@login_required 

1190@dd_tou_accepted 

1191def edit_overview(request, ds_uuid): 

1192 ds = get_object_or_404(DataSet, uuid=ds_uuid) 

1193 manpage = get_man_page("dataset-overview") 

1194 if not check_perms("admin_dsmo", request.user, ds.dataset_management_object): 

1195 return HttpResponse(_("Access denied")) 

1196 # check_perms_403("admin_dataset", request.user, ds.dataset_management_object) 

1197 

1198 metadata = get_dataset_fields_from_form(ds, DataSetForm(instance=ds)) 

1199 detail = get_dataset_fields_from_form(ds, DataSetEditForm(instance=ds)) 

1200 fullpage = True 

1201 

1202 return render( 

1203 request, 

1204 "dddatasets/prep/dataset_edit_preview.html", 

1205 { 

1206 "ds": ds, 

1207 "manpage": manpage, 

1208 "metadata": metadata, 

1209 "detail": detail, 

1210 "fullpage": fullpage, 

1211 }, 

1212 ) 

1213 

1214 

1215@login_required 

1216@dd_tou_accepted 

1217def edit_publish_start(request, ds_uuid): 

1218 ds = get_object_or_404(DataSet, uuid=ds_uuid) 

1219 manpage = get_man_page("dataset-publish") 

1220 if not check_perms("admin_dsmo", request.user, ds.dataset_management_object): 

1221 return HttpResponse(_("Access denied")) 

1222 # check_perms_403("admin_dataset", request.user, ds.dataset_management_object) 

1223 if ds.is_frozen(): 

1224 return redirect("dddatasets:prep_edit_versions", ds_uuid=ds.uuid,) 

1225 

1226 return render( 

1227 request, 

1228 "dddatasets/prep/_dataset_edit_publish_start.html", 

1229 {"ds": ds, "manpage": manpage}, 

1230 ) 

1231 

1232 

1233@login_required 

1234@dd_tou_accepted 

1235def edit_publish_check(request, ds_uuid): 

1236 ds = get_object_or_404(DataSet, uuid=ds_uuid) 

1237 manpage = get_man_page("dataset-publish-check") 

1238 if not check_perms("admin_dsmo", request.user, ds.dataset_management_object): 

1239 return HttpResponse(_("Access denied")) 

1240 # check_perms_403("admin_dataset", request.user, ds.dataset_management_object) 

1241 if ds.is_frozen(): 

1242 return redirect("dddatasets:prep_edit_versions", ds_uuid=ds.uuid,) 

1243 

1244 request.session[str(ds_uuid) + "wp"] = request.path 

1245 

1246 # validate dataset fields 

1247 errors = list() 

1248 try: 

1249 ds.full_clean() 

1250 except ValidationError as error: 

1251 errors.append(error) 

1252 

1253 # check if creator(s) are attached to dataset 

1254 creators = DataSetCreator.objects.filter(dataset=ds) 

1255 if creators.count() < 1: 

1256 try: 

1257 raise ValidationError({"creators": ["This field cannot be blank."]}) 

1258 except ValidationError as error: 

1259 errors.append(error) 

1260 

1261 return render( 

1262 request, 

1263 "dddatasets/prep/_dataset_edit_publish_check.html", 

1264 {"ds": ds, "manpage": manpage, "errors": errors}, 

1265 ) 

1266 

1267 

1268@login_required 

1269@dd_tou_accepted 

1270def edit_publish_datafiles(request, ds_uuid): 

1271 ds = get_object_or_404(DataSet, uuid=ds_uuid) 

1272 manpage = get_man_page("dataset-publish-datafiles") 

1273 if not check_perms("admin_dsmo", request.user, ds.dataset_management_object): 

1274 return HttpResponse(_("Access denied")) 

1275 # check_perms_403("admin_dataset", request.user, ds.dataset_management_object) 

1276 if ds.is_frozen(): 

1277 return redirect("dddatasets:prep_edit_versions", ds_uuid=ds.uuid,) 

1278 

1279 request.session[str(ds_uuid) + "wp"] = request.path 

1280 

1281 return render( 

1282 request, 

1283 "dddatasets/prep/_dataset_edit_publish_datafiles.html", 

1284 {"ds": ds, "manpage": manpage}, 

1285 ) 

1286 

1287 

1288@login_required 

1289@dd_tou_accepted 

1290def edit_publish_license(request, ds_uuid): 

1291 ds = get_object_or_404(DataSet, uuid=ds_uuid) 

1292 manpage = get_man_page("dataset-publish-license") 

1293 if not check_perms("admin_dsmo", request.user, ds.dataset_management_object): 

1294 return HttpResponse(_("Access denied")) 

1295 # check_perms_403("admin_dataset", request.user, ds.dataset_management_object) 

1296 

1297 request.session[str(ds_uuid) + "wp"] = request.path 

1298 

1299 return render( 

1300 request, 

1301 "dddatasets/prep/_dataset_edit_publish_license.html", 

1302 {"ds": ds, "manpage": manpage}, 

1303 ) 

1304 

1305 

1306@login_required 

1307@dd_tou_accepted 

1308def edit_publish_copyright(request, ds_uuid): 

1309 ds = get_object_or_404(DataSet, uuid=ds_uuid) 

1310 manpage = get_man_page("dataset-publish-copyright") 

1311 if not check_perms("admin_dsmo", request.user, ds.dataset_management_object): 

1312 return HttpResponse(_("Access denied")) 

1313 # check_perms_403("admin_dataset", request.user, ds.dataset_management_object) 

1314 if ds.is_frozen(): 

1315 return redirect("dddatasets:prep_edit_versions", ds_uuid=ds.uuid,) 

1316 

1317 request.session[str(ds_uuid) + "wp"] = request.path 

1318 copyright_declaration_page = get_man_page("dataset-copyright-declaration") 

1319 privacy_rights_declaration_page = get_man_page("privacy-rights-declaration") 

1320 

1321 target = _("Dataset Copyright Declaration") 

1322 err = None 

1323 updated = False 

1324 

1325 if request.method == "POST": 

1326 sub_form_copyright = DataSetCopyrightForm(request.POST, instance=ds) 

1327 sub_form_privacy_rights = DataSetPrivacyRightsForm(request.POST, instance=ds) 

1328 form = DataSubmissionAgreementAcceptForm(request.POST, instance=ds.dsa) 

1329 if ( 

1330 form.is_valid() 

1331 and sub_form_copyright.is_valid() 

1332 and sub_form_privacy_rights.is_valid() 

1333 ): 

1334 form.save() 

1335 sub_form_copyright.save() 

1336 sub_form_privacy_rights.save() 

1337 ds.dsa.dsa_accepted_date = date.today() 

1338 updated = True 

1339 else: 

1340 err = form.errors.as_data() 

1341 err += sub_form_copyright.errors.as_data() 

1342 err += sub_form_privacy_rights.errors.as_data() 

1343 else: 

1344 sub_form_copyright = DataSetCopyrightForm(instance=ds) 

1345 sub_form_privacy_rights = DataSetPrivacyRightsForm(instance=ds) 

1346 form = DataSubmissionAgreementAcceptForm(instance=ds.dsa) 

1347 

1348 return render( 

1349 request, 

1350 "dddatasets/prep/_dataset_edit_publish_copyright.html", 

1351 { 

1352 "ds": ds, 

1353 "manpage": manpage, 

1354 "form": form, 

1355 "sub_form_copyright": sub_form_copyright, 

1356 "sub_form_privacy_rights": sub_form_privacy_rights, 

1357 "target": target, 

1358 "err": err, 

1359 "updated": updated, 

1360 "copyright_declaration_page": copyright_declaration_page, 

1361 "privacy_rights_declaration_page": privacy_rights_declaration_page, 

1362 }, 

1363 ) 

1364 

1365 

1366@login_required 

1367@dd_tou_accepted 

1368def edit_publish_final_fetch(request, ds_uuid, task): 

1369 ds = get_object_or_404(DataSet, uuid=ds_uuid) 

1370 if not check_perms("admin_dsmo", request.user, ds.dataset_management_object): 

1371 return HttpResponse(_("Access denied")) 

1372 # check_perms_403("admin_dataset", request.user, ds.dataset_management_object) 

1373 

1374 # check if ds is published NOT frozen 

1375 if ds.published: 

1376 return redirect("dddatasets:prep_edit_versions", ds_uuid=ds.uuid,) 

1377 

1378 request.session[str(ds_uuid) + "wp"] = request.path 

1379 

1380 collectionCreated = fetch(task).success 

1381 

1382 response = render( 

1383 request, 

1384 "dddatasets/prep/_dataset_edit_publish_final_fetch.html", 

1385 {"isFetched": collectionCreated, "ds_uuid": str(ds_uuid)}, 

1386 ) 

1387 if collectionCreated: 

1388 messages.success(request, "Collection created successfully.") 

1389 response["X-IC-CancelPolling"] = "true" 

1390 return response 

1391 

1392 

1393@login_required 

1394@dd_tou_accepted 

1395def edit_publish_final_upload(request, ds_uuid): 

1396 ds = get_object_or_404(DataSet, uuid=ds_uuid) 

1397 if not check_perms("admin_dsmo", request.user, ds.dataset_management_object): 

1398 return HttpResponse(_("Access denied")) 

1399 # check_perms_403("admin_dataset", request.user, ds.dataset_management_object) 

1400 

1401 request.session[str(ds_uuid) + "wp"] = request.path 

1402 # check if ds is published NOT frozen 

1403 if ds.published: 

1404 return redirect("dddatasets:prep_edit_versions", ds_uuid=ds.uuid,) 

1405 

1406 th = TokenHelper() 

1407 t = th.get_token_from_session(request) 

1408 publisher = Publisher(t, ds) 

1409 # get collection from session 

1410 collection = request.session.get("collection", None) 

1411 status = publisher.upload_status(collection) 

1412 logger.debug("UPLOAD_STATUS: %s", status) 

1413 upload_complete = True 

1414 task_exists = True 

1415 for file in status.keys(): 

1416 if not status[file]: 

1417 upload_complete = False 

1418 

1419 files = collection.get("files") 

1420 for file in files: 

1421 task_exists = collection["files"][file].get("task_id", False) 

1422 

1423 if not upload_complete and not task_exists: 

1424 tasks = publisher.upload(collection) 

1425 # put task id into collection 

1426 for file in files: 

1427 task_id = tasks[files[file]["df_uuid"]] 

1428 collection["files"][file]["task_id"] = task_id 

1429 # save collection in session 

1430 request.session["collection"] = collection 

1431 

1432 response = render( 

1433 request, 

1434 "dddatasets/prep/_dataset_edit_publish_final_upload.html", 

1435 {"status": status, "upload_complete": upload_complete, "ds_uuid": str(ds_uuid)}, 

1436 ) 

1437 if upload_complete: 

1438 response["X-IC-CancelPolling"] = "true" 

1439 return response 

1440 

1441 

1442@login_required 

1443@dd_tou_accepted 

1444def edit_publish_final_pubdd(request, ds_uuid): 

1445 ds = get_object_or_404(DataSet, uuid=ds_uuid) 

1446 if not check_perms("admin_dsmo", request.user, ds.dataset_management_object): 

1447 return HttpResponse(_("Access denied")) 

1448 # check_perms_403("admin_dataset", request.user, ds.dataset_management_object) 

1449 

1450 # check if ds is published NOT frozen 

1451 if ds.published: 

1452 return redirect("dddatasets:prep_edit_versions", ds_uuid=ds.uuid,) 

1453 

1454 # publish dataset in discuss data (non-dariah) 

1455 try: 

1456 ds.publish(request.user) 

1457 except ImproperlyConfigured: 

1458 messages.error( 

1459 request, 

1460 "This instance of Discuss Data is not properly configured to register DataCite DOIs.", 

1461 ) 

1462 except MetaDataError: 

1463 messages.error(request, "Missing or malformed metadata.") 

1464 # TODO: remove success message from template; messages are supposed to be delivered by messages interface only!!! 

1465 return render( 

1466 request, "dddatasets/prep/_dataset_edit_publish_final_pubdd.html", {"ds": ds}, 

1467 ) 

1468 

1469 

1470@login_required 

1471@dd_tou_accepted 

1472def edit_publish_final_publish(request, ds_uuid): 

1473 ds = get_object_or_404(DataSet, uuid=ds_uuid) 

1474 if not check_perms("admin_dsmo", request.user, ds.dataset_management_object): 

1475 logger.debug("[DHREP PUBLISHER] access denied") 

1476 return HttpResponse(_("Access denied")) 

1477 # check_perms_403("admin_dataset", request.user, ds.dataset_management_object) 

1478 # check if ds is published NOT frozen 

1479 if ds.published: 

1480 return redirect("dddatasets:prep_edit_versions", ds_uuid=ds.uuid,) 

1481 

1482 th = TokenHelper() 

1483 t = th.get_token_from_session(request) 

1484 publisher = Publisher(t, ds) 

1485 # get collection from session 

1486 collection = request.session.get("collection", {}) 

1487 logger.debug("[DHREP PUBLISHER] collection: %s", str(collection)) 

1488 status = publisher.publish_status(collection) 

1489 logger.debug("[DHREP PUBLISHER] status: %s", status) 

1490 

1491 # an API implementation flaw makes the "processStatus" entry missing sometimes; i suppose this is in the state of QUEUING 

1492 try: 

1493 process_status = status["publishStatus"]["processStatus"] 

1494 except KeyError as e: 

1495 logger.error(e) 

1496 process_status = "QUEUED" 

1497 

1498 progress = status["publishStatus"]["progress"] 

1499 

1500 # create response here to cancel polling on success and failed 

1501 response = render( 

1502 request, 

1503 "dddatasets/prep/_dataset_edit_publish_final_publish.html", 

1504 { 

1505 "ds_uuid": str(ds_uuid), 

1506 "status": process_status, 

1507 "progress": progress, 

1508 "ds": ds, 

1509 }, 

1510 ) 

1511 

1512 # problem: it may take more than 5 seconds for a publishjob to begin to run after being triggered 

1513 if process_status == "NOT_QUEUED": 

1514 try: 

1515 resp = publisher.publish(collection) 

1516 except PublisherError as e: 

1517 logger.error(e) 

1518 else: 

1519 logger.debug(resp.text) 

1520 elif process_status == "FINISHED": 

1521 response["X-IC-CancelPolling"] = "true" 

1522 # the status dictionary contains the DOIs after the process has been finished; 

1523 request.session.pop("collection") 

1524 publisher.update_dataset(collection, status) 

1525 # also, make DD publication when finished 

1526 logger.debug("[DHREP PUBLISHER] finished, starting ds.publish: %s", status) 

1527 ds.publish(request.user) 

1528 messages.success( 

1529 request, 

1530 _( 

1531 "Success! The dataset has been published to Discuss Data and the Dariah Repository." 

1532 ), 

1533 ) 

1534 

1535 if process_status == "FAILED": 

1536 response["X-IC-CancelPolling"] = "true" 

1537 logger.error("[DHREP PUBLISHER] FAILED: %s", status) 

1538 messages.error( 

1539 request, _("An Error occured. The dataset has not been published.") 

1540 ) 

1541 return response 

1542 

1543 

1544@login_required 

1545@dd_tou_accepted 

1546def edit_publish_final(request, ds_uuid): 

1547 # TODO: check for valid ds_uuid 

1548 ds = get_object_or_404(DataSet, uuid=ds_uuid) 

1549 manpage = get_man_page("dataset-publish-final") 

1550 if not check_perms("admin_dsmo", request.user, ds.dataset_management_object): 

1551 return HttpResponse(_("Access denied")) 

1552 # check_perms_403("admin_dataset", request.user, ds.dataset_management_object) 

1553 # check if ds is published NOT frozen 

1554 if ds.published: 

1555 return redirect("dddatasets:prep_edit_versions", ds_uuid=ds.uuid,) 

1556 

1557 # define context variables 

1558 requestUri = None 

1559 isTokenValid = False 

1560 form = None 

1561 err = None 

1562 updated = False 

1563 target = _("DARIAH Terms of Use Declaration") 

1564 turtle_task = None 

1565 publish_message = None 

1566 # run checks 

1567 check_error, check_list = ds.perform_checks() 

1568 if check_error: 

1569 error_string = _("Errors ocurred, please fix: ") + " ".join(check_list) 

1570 messages.error(request, error_string) 

1571 publish_message = error_string 

1572 else: 

1573 # no token evaluation if not open access 

1574 if ds.data_access == ds.OPEN_ACCESS: 

1575 th = TokenHelper() 

1576 t = th.get_token_from_session(request) 

1577 collection = {} 

1578 

1579 if t: 

1580 if t.check(): 

1581 isTokenValid = True 

1582 

1583 messages.success( 

1584 request, "Token " + t.access_token + " is " + t.info() 

1585 ) 

1586 publisher = Publisher(t, ds) 

1587 # create a job for the dataset and return the collection as a dictionary 

1588 collection = publisher.create_collection() 

1589 # save collection in session 

1590 request.session["collection"] = collection 

1591 else: 

1592 isTokenValid = False 

1593 messages.error( 

1594 request, "Token " + t.access_token + " is " + t.info() 

1595 ) 

1596 request.session.pop("token") 

1597 request.session["ds_uuid"] = str(ds_uuid) 

1598 else: 

1599 isTokenValid = False 

1600 messages.warning(request, "No Token provided.") 

1601 request.session["ds_uuid"] = str(ds_uuid) 

1602 logger.debug(isTokenValid) 

1603 # return render(request, "dhrep/_getToken.html", {"requestUri": th.request_url}) 

1604 # wenn token nicht gültig, ist collection = {} 

1605 turtle_task = collection.get("turtle_task", None) 

1606 requestUri = th.request_url 

1607 publish_message = None 

1608 

1609 if request.method == "POST": 

1610 form = DariahTermsOfUse(request.POST, instance=request.user) 

1611 if form.is_valid(): 

1612 form.save() 

1613 updated = True 

1614 else: 

1615 err = form.errors.as_data() 

1616 else: 

1617 form = DariahTermsOfUse(instance=request.user) 

1618 

1619 return render( 

1620 request, 

1621 "dddatasets/prep/_dataset_edit_publish_final.html", 

1622 { 

1623 "requestUri": requestUri, 

1624 "isTokenValid": isTokenValid, 

1625 "ds": ds, 

1626 "form": form, 

1627 "updated": updated, 

1628 "err": err, 

1629 "target": target, 

1630 "manpage": manpage, 

1631 "publish_message": publish_message, 

1632 "turtle_task": turtle_task, 

1633 }, 

1634 ) 

1635 

1636 

1637@login_required 

1638@dd_tou_accepted 

1639def edit_publish_request(request, ds_uuid): 

1640 ds = get_object_or_404(DataSet, uuid=ds_uuid) 

1641 manpage = get_man_page("dataset-publish-request") 

1642 if not check_perms("admin_dsmo", request.user, ds.dataset_management_object): 

1643 logger.error("access denied") 

1644 return HttpResponse(_("Access denied")) 

1645 # check_perms_403("admin_dataset", request.user, ds.dataset_management_object) 

1646 if ds.is_frozen(): 

1647 return redirect("dddatasets:prep_edit_versions", ds_uuid=ds.uuid,) 

1648 

1649 if request.method == "POST": 

1650 # run checks 

1651 logger.debug("POST publish request") 

1652 check_error, check_list = ds.perform_checks() 

1653 logger.error(check_error) 

1654 if check_error: 

1655 error_string = _("Errors ocurred, please fix: ") + " ".join(check_list) 

1656 publish_message = error_string 

1657 logger.error(error_string) 

1658 messages.error(request, error_string) 

1659 else: 

1660 logger.debug("start request_publication") 

1661 publish_message = ds.request_publication(request.user) 

1662 logger.debug("end request_publication") 

1663 return edit_versions(request, ds_uuid) 

1664 else: 

1665 publish_message = None 

1666 

1667 return render( 

1668 request, 

1669 "dddatasets/prep/_dataset_edit_publish_request.html", 

1670 {"ds": ds, "manpage": manpage, "publish_message": publish_message}, 

1671 ) 

1672 

1673 

1674@login_required 

1675@dd_tou_accepted 

1676def edit_publish_access(request, ds_uuid): 

1677 ds = get_object_or_404(DataSet, uuid=ds_uuid) 

1678 manpage = get_man_page("dataset_publish") 

1679 

1680 search_type = "pubaccess" 

1681 

1682 form = DataSetIndividualLicenseForm(instance=ds.license) 

1683 

1684 publish_right = check_perms( 

1685 "admin_dsmo", request.user, ds.dataset_management_object 

1686 ) 

1687 

1688 return render( 

1689 request, 

1690 "dddatasets/prep/dataset_edit_publish_access.html", 

1691 { 

1692 "ds": ds, 

1693 "publish_right": publish_right, 

1694 "manpage": manpage, 

1695 "search_type": search_type, 

1696 "form": form, 

1697 "next_url": request.session.get(str(ds_uuid) + "wp"), 

1698 }, 

1699 ) 

1700 

1701 

1702@login_required 

1703@dd_tou_accepted 

1704def edit_publish_access_select(request, ds_uuid): 

1705 ds = get_object_or_404(DataSet, uuid=ds_uuid) 

1706 if not check_perms("admin_dsmo", request.user, ds.dataset_management_object): 

1707 return HttpResponse(_("Access denied")) 

1708 # check_perms_403("admin_dataset", request.user, ds.dataset_management_object) 

1709 

1710 if request.method == "POST": 

1711 if not ds.is_frozen(): 

1712 pubaccess = request.POST["pubaccess"] 

1713 ds.data_access = pubaccess 

1714 ds.save() 

1715 return edit_publish_access(request, ds_uuid) 

1716 else: 

1717 return edit_publish_access(request, ds_uuid) 

1718 

1719 

1720@login_required 

1721@dd_tou_accepted 

1722def edit_publish_license_select(request, ds_uuid): 

1723 ds = get_object_or_404(DataSet, uuid=ds_uuid) 

1724 if not check_perms("admin_dsmo", request.user, ds.dataset_management_object): 

1725 return HttpResponse(_("Access denied")) 

1726 # check_perms_403("admin_dataset", request.user, ds.dataset_management_object) 

1727 if ds.is_frozen(): 

1728 return redirect("dddatasets:prep_edit_versions", ds_uuid=ds.uuid,) 

1729 

1730 if request.method == "POST": 

1731 license_name = request.POST["licensename"] 

1732 if license_name == "individual": 

1733 if not ds.license or ds.license.license_type != License.INDIVIDUAL: 

1734 ds.license = License.objects.create() 

1735 ds.license.license_type = License.INDIVIDUAL 

1736 form = DataSetIndividualLicenseForm(request.POST, instance=ds.license) 

1737 if form.is_valid(): 

1738 ds.license = form.save() 

1739 ds.license.save() 

1740 else: 

1741 # if form is invalid: do not save, show error message 

1742 logger.info("Individual License Form INVALID") 

1743 messages.error( 

1744 request, 

1745 _("Error in editing Individual License: {}").format( 

1746 form.errors.as_text() 

1747 ), 

1748 ) 

1749 elif license_name == "nolicense": 

1750 ds.license = None 

1751 else: 

1752 ds.license = License.objects.get(license_name=license_name) 

1753 standard_license = LicensePage.objects.get(name=license_name) 

1754 ds.license.license_type = License.STANDARD 

1755 ds.license.standard_license = standard_license 

1756 ds.license.save() 

1757 ds.save() 

1758 return edit_publish_access(request, ds_uuid) 

1759 

1760 

1761@login_required 

1762@dd_tou_accepted 

1763def curation(request, ds_uuid): 

1764 ds = get_object_or_404(DataSet, uuid=ds_uuid) 

1765 if ds.pub_request_pending() and request.user not in ds.get_curators(): 

1766 raise PermissionDenied 

1767 

1768 manpage = get_man_page("dataset_curation") 

1769 

1770 if request.method == "POST": 

1771 form = DataSetPublishAccept(request.POST) 

1772 if form.is_valid(): 

1773 decision = form.cleaned_data.get("decision") 

1774 message = form.cleaned_data.get("message") 

1775 if decision == "accept": 

1776 ds.accept_publication(request.user, message) 

1777 messages.success(request, _("Dataset publication request accepted")) 

1778 return edit_versions(request, ds_uuid) 

1779 else: 

1780 ds.deny_publication(request.user, message) 

1781 messages.success(request, _("Dataset publication request denied")) 

1782 return edit_versions(request, ds_uuid) 

1783 else: 

1784 messages.warning(request, form.errors.as_data()) 

1785 

1786 else: 

1787 pass 

1788 return render( 

1789 request, 

1790 "dddatasets/prep/dataset_curation.html", 

1791 { 

1792 "ds": ds, 

1793 "manpage": manpage, 

1794 # "form": form, 

1795 }, 

1796 )