Hide keyboard shortcuts

Hot-keys on this page

r m x p   toggle line displays

j k   next/prev highlighted chunk

0   (zero) top of page

1   (one) first highlighted chunk

1import logging 

2 

3from actstream import action 

4from actstream.actions import follow, unfollow 

5from actstream.models import Action, followers, following, user_stream 

6from django.contrib import messages 

7from django.contrib.auth.decorators import login_required 

8from django.contrib.contenttypes.models import ContentType 

9from django.core.paginator import Paginator 

10from django.http import ( 

11 Http404, 

12 HttpResponse, 

13 HttpResponseRedirect, 

14) 

15from django.shortcuts import get_object_or_404, redirect, render 

16from django.utils.translation import gettext as _ 

17from django.views.generic import TemplateView 

18from django.views.generic.list import ListView 

19 

20from discuss_data.core.decorators import dd_tou_accepted, dd_profile_accessible 

21from discuss_data.core.models import KeywordTagged 

22from discuss_data.core.views import core_search_view 

23from discuss_data.core.helpers import index_search, get_oep_parameters 

24 

25from discuss_data.ddcomments.forms import NotificationForm 

26from discuss_data.ddcomments.models import Notification 

27from discuss_data.dddatasets.forms import DataListForm, DataSetToListForm 

28from discuss_data.dddatasets.models import DataList, DataSet 

29from discuss_data.dddatasets.utils import get_man_page 

30from discuss_data.ddpublications.forms import PublicationForm 

31from discuss_data.ddpublications.models import Publication 

32from discuss_data.ddusers.forms import ( 

33 AffiliationForm, 

34 ProjectForm, 

35 UserForm, 

36 UserImageForm, 

37) 

38from discuss_data.ddusers.models import Affiliation, Country, Project, User 

39 

40logger = logging.getLogger(__name__) 

41 

42 

43class UsersListView(ListView): 

44 """a class based implementation of `ddusers.views.user_list` (deprecated)""" 

45 

46 model = User 

47 context_object_name = "users" 

48 paginate_by = 25 

49 template_name = "ddusers/_search_results.html" 

50 

51 def get_queryset(self): 

52 filtered = ( 

53 self.model.objects.exclude(profile_accessibility="HID") 

54 .exclude(is_active=False) 

55 .exclude(first_name="") 

56 .exclude(last_name="") 

57 ) 

58 

59 if self.request.user.is_authenticated: 

60 return filtered 

61 

62 return filtered.exclude(profile_accessibility="NET") 

63 

64 

65class UserDetailsView(TemplateView): 

66 """show user details""" 

67 

68 template_name = "ddusers/detail.html" 

69 

70 def get_context_data(self, **kwargs): 

71 context = super().get_context_data(**kwargs) 

72 user = get_object_or_404(User, uuid=context["us_uuid"]) 

73 

74 initial = { 

75 "recipient_uuid": user.uuid, 

76 "parent_uuid": None, 

77 } 

78 additional_context = { 

79 "profile_accessibility": user.profile_accessibility, 

80 "form": NotificationForm(initial=initial), 

81 "add_url": "ddusers:notification", 

82 "object": user, 

83 "ictarget": "#ds-content", 

84 "btn_text": _("Send message"), 

85 "user": user, 

86 } 

87 return {**context, **additional_context} 

88 

89 def get(self, request, *args, **kwargs): 

90 context = self.get_context_data(**kwargs) 

91 if (context["user"].profile_accessibility == "PUB") or ( 

92 context["user"].profile_accessibility == "NET" 

93 and request.user.is_authenticated 

94 ): 

95 return render(request, "ddusers/detail.html", context) 

96 

97 messages.error(request, "The user has chosen not to share his profile details.") 

98 return HttpResponseRedirect("/users/search/") # better: redirect to last page 

99 

100 

101def user_search(query): 

102 """ 

103 Search view to lookup User objects on prep collaboration page 

104 """ 

105 return index_search("user_index", query) 

106 

107 

108def search(request): 

109 """ 

110 Main search view for users, used as the listing view for the people page 

111 """ 

112 return core_search_view(request, "user_index", 10) 

113 

114 

115def first_steps(request): 

116 page = get_man_page(slug="first-steps-overview") 

117 if request.method == "POST": 

118 request.user.show_first_steps = False 

119 request.user.save() 

120 return HttpResponse() 

121 

122 return render( 

123 request, 

124 "ddusers/_first_steps.html", 

125 {"page": page}, 

126 ) 

127 

128 

129def accept_tou(request): 

130 page = get_man_page(slug="terms-and-conditions") 

131 if request.method == "POST": 

132 if not request.user.accepted_dd_tou: 

133 request.user.accepted_dd_tou = True 

134 request.user.save() 

135 next_url = request.POST.get("nexturl") 

136 messages.success(request, _("Terms of use accepted, redirecting")) 

137 

138 if next_url: 

139 return HttpResponseRedirect(next_url) 

140 else: 

141 return HttpResponseRedirect("/dashboard") 

142 else: 

143 next_url = request.GET.get("next") 

144 return render( 

145 request, 

146 "ddusers/accept_tou.html", 

147 {"page": page, "next_url": next_url}, 

148 ) 

149 

150 

151@login_required 

152@dd_tou_accepted 

153def format_act_feed(request, feed, object_list=None): 

154 action_list = list() 

155 

156 for act in feed: 

157 try: 

158 if act.target.class_name() == "User": 

159 action_list.append(act) 

160 if act.target.class_name() == "DataSet" and act.target.published: 

161 action_list.append(act) 

162 if act.target.class_name() == "DataList": 

163 action_list.append(act) 

164 if act.target.class_name() == "Comment": 

165 action_list.append(act) 

166 if ( 

167 act.target.class_name() == "DataSetManagementObject" 

168 and act.target.published 

169 ): 

170 action_list.append(act) 

171 except AttributeError as e: 

172 logger.error("act {}, target {}, error {}".format(act, act.target, e)) 

173 paginator = Paginator(action_list, 5) 

174 page = request.GET.get("page") 

175 feed_actions = paginator.get_page(page) 

176 paginator_range = range(1, paginator.num_pages + 1) 

177 return feed_actions, paginator_range, paginator.num_pages + 1 

178 

179 

180@login_required 

181@dd_tou_accepted 

182def datasets_act_feed(request): 

183 if request.user.is_authenticated: 

184 feed_actions, paginator_range, paginator_last_page = format_act_feed( 

185 request, request.user.get_datasets_actions() 

186 ) 

187 feed_type = "datasets-act-feed" 

188 

189 return render( 

190 request, 

191 "ddusers/dashboard.html", 

192 { 

193 "feed_actions": feed_actions, 

194 "paginator_range": paginator_range, 

195 "paginator_last_page": paginator_last_page, 

196 "feed_type": feed_type, 

197 }, 

198 ) 

199 

200 

201@login_required 

202@dd_tou_accepted 

203def following_act_feed(request): 

204 if request.user.is_authenticated: 

205 feed_actions, paginator_range, paginator_last_page = format_act_feed( 

206 request, request.user.get_following_actions() 

207 ) 

208 feed_type = "following-act-feed" 

209 

210 return render( 

211 request, 

212 "ddusers/dashboard.html", 

213 { 

214 "feed_actions": feed_actions, 

215 "paginator_range": paginator_range, 

216 "paginator_last_page": paginator_last_page, 

217 "feed_type": feed_type, 

218 }, 

219 ) 

220 

221 

222@login_required 

223@dd_tou_accepted 

224def notification_act_feed(request): 

225 """ 

226 Deprecated, to be replaced by user_notifications() 

227 """ 

228 # list of ids of datasets where user has admin rights 

229 user_admin_datasets = list( 

230 request.user.get_published_admin_datasets().values_list("id", flat=True) 

231 ) 

232 

233 # queries for actions with notification as action object and one of the users datasets as target 

234 actions_ar = Action.objects.access_requests_received(user_admin_datasets) 

235 

236 notification_content_type = ContentType.objects.get( 

237 app_label="ddcomments", model="comment" 

238 ) 

239 actions_notifications = Action.objects.any_everything(request.user).filter( 

240 action_object_content_type=notification_content_type.id, 

241 ) 

242 

243 actions = actions_ar | actions_notifications 

244 feed_actions, paginator_range, paginator_last_page = format_act_feed( 

245 request, actions 

246 ) 

247 feed_type = "notification-act-feed" 

248 

249 return render( 

250 request, 

251 "ddusers/dashboard.html", 

252 { 

253 "feed_actions": feed_actions, 

254 "paginator_range": paginator_range, 

255 "paginator_last_page": paginator_last_page, 

256 "feed_type": feed_type, 

257 }, 

258 ) 

259 

260 

261@login_required 

262@dd_tou_accepted 

263def user_notifications(request): 

264 user_notifications_to = Notification.objects.root_nodes().filter( 

265 recipient=request.user 

266 ) 

267 user_notifications_from = Notification.objects.root_nodes().filter( 

268 owner=request.user 

269 ) 

270 

271 user_admin_datasets = list( 

272 request.user.get_published_admin_datasets().values_list("id", flat=True) 

273 ) 

274 

275 dataset_content_type = ContentType.objects.get( 

276 app_label="dddatasets", model="dataset" 

277 ) 

278 datasets_notifications = Notification.objects.root_nodes().filter( 

279 content_type=dataset_content_type.id, object_id__in=user_admin_datasets 

280 ) 

281 

282 notifications = ( 

283 user_notifications_to | user_notifications_from | datasets_notifications 

284 ) 

285 

286 feed_type = "notifications" 

287 

288 paginator = Paginator(notifications.order_by("-date_added"), 5) 

289 page = request.GET.get("page") 

290 feed_actions = paginator.get_page(page) 

291 paginator_range = range(1, paginator.num_pages + 1) 

292 paginator_last_page = paginator.num_pages + 1 

293 

294 form = NotificationForm() 

295 

296 return render( 

297 request, 

298 "ddusers/dashboard.html", 

299 { 

300 "feed_actions": feed_actions, 

301 "paginator_range": paginator_range, 

302 "paginator_last_page": paginator_last_page, 

303 "feed_type": feed_type, 

304 "form": form, 

305 "add_url": "ddusers:notification", 

306 "btn_text": "Reply", 

307 }, 

308 ) 

309 

310 

311@login_required 

312@dd_tou_accepted 

313def user_curation(request): 

314 dataset_content_type = ContentType.objects.get( 

315 app_label="dddatasets", model="dataset" 

316 ) 

317 user_curated_datasets = list( 

318 request.user.get_curated_datasets().values_list("id", flat=True) 

319 ) 

320 

321 datasets_notifications_curators = Notification.objects.root_nodes().filter( 

322 content_type=dataset_content_type.id, object_id__in=user_curated_datasets 

323 ) 

324 

325 notifications = datasets_notifications_curators 

326 feed_type = "curation" 

327 

328 paginator = Paginator(notifications.order_by("-date_added"), 5) 

329 page = request.GET.get("page") 

330 feed_actions = paginator.get_page(page) 

331 paginator_range = range(1, paginator.num_pages + 1) 

332 paginator_last_page = paginator.num_pages + 1 

333 

334 form = NotificationForm() 

335 

336 return render( 

337 request, 

338 "ddusers/dashboard.html", 

339 { 

340 "feed_actions": feed_actions, 

341 "paginator_range": paginator_range, 

342 "paginator_last_page": paginator_last_page, 

343 "feed_type": feed_type, 

344 "form": form, 

345 "add_url": "ddusers:notification", 

346 "btn_text": "Reply", 

347 }, 

348 ) 

349 

350 

351@login_required 

352@dd_tou_accepted 

353def user_act_feed(request): 

354 feed_actions, paginator_range, paginator_last_page = format_act_feed( 

355 request, request.user.get_user_actions() 

356 ) 

357 

358 feed_type = "user-act-feed" 

359 return render( 

360 request, 

361 "ddusers/dashboard.html", 

362 { 

363 "feed_actions": feed_actions, 

364 "paginator_range": paginator_range, 

365 "paginator_last_page": paginator_last_page, 

366 "feed_type": feed_type, 

367 }, 

368 ) 

369 

370 

371@login_required 

372@dd_tou_accepted 

373def following_users(request): 

374 feed_type = "following-users" 

375 object_list = following(request.user, User) 

376 

377 return render( 

378 request, 

379 "ddusers/dashboard.html", 

380 { 

381 "object_list": object_list, 

382 # "paginator_range": paginator_range, 

383 # "paginator_last_page": paginator_last_page, 

384 "feed_type": feed_type, 

385 }, 

386 ) 

387 

388 

389@login_required 

390@dd_tou_accepted 

391def followers_users(request): 

392 feed_type = "followers" 

393 object_list = followers(request.user) 

394 

395 return render( 

396 request, 

397 "ddusers/dashboard.html", 

398 { 

399 "object_list": object_list, 

400 # "paginator_range": paginator_range, 

401 # "paginator_last_page": paginator_last_page, 

402 "feed_type": feed_type, 

403 }, 

404 ) 

405 

406 

407@login_required 

408@dd_tou_accepted 

409def list_following_datasets(request): 

410 object_list = following(request.user, DataSet) 

411 pagetitle = _("Followed Datasets") 

412 follow_type = "datasets" 

413 

414 return render( 

415 request, 

416 "ddusers/list_follow.html", 

417 { 

418 "object_list": object_list, 

419 "object_type": follow_type + "_followed", 

420 "pagetitle": pagetitle, 

421 }, 

422 ) 

423 

424 

425@login_required 

426@dd_tou_accepted 

427def list_following_datalists(request): 

428 object_list = following(request.user, DataList) 

429 pagetitle = _("Followed Data Lists") 

430 follow_type = "datalists" 

431 

432 return render( 

433 request, 

434 "ddusers/list_follow.html", 

435 { 

436 "object_list": object_list, 

437 "object_type": follow_type + "_followed", 

438 "pagetitle": pagetitle, 

439 }, 

440 ) 

441 

442 

443# TODO: not used anymore 

444# @login_required 

445# @dd_tou_accepted 

446# def list_following(request, follow_type): 

447# if request.user.is_authenticated: 

448# if follow_type == "datasets": 

449# object_list = following(request.user, DataSet) 

450# pagetitle = _("Followed Datasets") 

451# elif follow_type == "users": 

452# object_list = following(request.user, User) 

453# pagetitle = _("Followed Users") 

454# elif follow_type == "data_lists": 

455# object_list = following(request.user, DataList) 

456# pagetitle = _("Followed Data Lists") 

457# else: 

458# return Http404() 

459 

460# return render( 

461# request, 

462# "ddusers/list_follow.html", 

463# { 

464# "object_list": object_list, 

465# "object_type": follow_type + "_followed", 

466# "pagetitle": pagetitle, 

467# }, 

468# ) 

469 

470 

471@login_required 

472@dd_tou_accepted 

473def list_followed(request, follow_type): 

474 if request.user.is_authenticated: 

475 if follow_type == "users": 

476 object_list = followers(request.user) 

477 pagetitle = _("Users who are following you") 

478 else: 

479 object_list = None 

480 pagetitle = None 

481 

482 return render( 

483 request, 

484 "ddusers/list_follow.html", 

485 { 

486 "object_list": object_list, 

487 "object_type": follow_type + "_following", 

488 "pagetitle": pagetitle, 

489 }, 

490 ) 

491 

492 

493@login_required 

494@dd_tou_accepted 

495def user_follow(request, us_uuid): 

496 # redirect if no intercooler request 

497 if not request.is_intercooler(): 

498 return redirect("ddusers:edit") 

499 user = get_object_or_404(User, uuid=us_uuid) 

500 if request.user in followers(user): 

501 unfollow(request.user, user) 

502 else: 

503 follow(request.user, user) 

504 return render( 

505 request, 

506 "ddusers/_follow_button.html", 

507 {"object": user, "follow_url": "ddusers:follow"}, 

508 ) 

509 

510 

511@login_required 

512@dd_tou_accepted 

513def user_follow_status(request): 

514 return render( 

515 request, 

516 "ddusers/_user_sidebar_followers.html", 

517 {}, 

518 ) 

519 

520 

521@login_required 

522@dd_tou_accepted 

523def user_notification(request): 

524 if request.method == "POST": 

525 form = NotificationForm(request.POST) 

526 if form.is_valid(): 

527 notification = form.save(commit=False) 

528 notification.owner = request.user 

529 feed_type = form.cleaned_data.get("feed_type") 

530 parent_uuid = form.cleaned_data.get("parent_uuid") 

531 if parent_uuid: 

532 notification.parent = Notification.objects.get(uuid=parent_uuid) 

533 

534 recipient_uuid = form.cleaned_data.get("recipient_uuid") 

535 user = User.objects.get(uuid=recipient_uuid) 

536 notification.recipient = user 

537 notification.notification_type = Notification.PRIVATE 

538 notification.content_type = ContentType.objects.get_for_model(User) 

539 notification.object_id = user.id 

540 notification.save() 

541 

542 messages.success(request, _("Message sent")) 

543 

544 if feed_type == "notifications": 

545 return user_notifications(request) 

546 elif feed_type == "curation": 

547 return user_curation(request) 

548 else: 

549 return user_notifications(request) 

550 else: 

551 messages.error(request, form.errors.as_data()) 

552 else: 

553 form = NotificationForm() 

554 return render( 

555 request, 

556 "ddcomments/_notification_add.html", 

557 {"form": form, "add_url": "ddusers:notification", "ictarget": "#ds-content"}, 

558 ) 

559 

560 

561@dd_profile_accessible 

562def user_affiliations(request, us_uuid): 

563 user = get_object_or_404(User, uuid=us_uuid) 

564 # if (user.profile_accessibility == "PUB") or (user.profile_accessibility == "NET" and request.user.is_authenticated): 

565 return render(request, "ddusers/affiliations.html", {"user": user}) 

566 

567 # messages.error(request, "The user has chosen not to share his profile details.") 

568 # return HttpResponseRedirect("/users/search/") # better: redirect to last page 

569 

570 

571@login_required 

572@dd_tou_accepted 

573def datalist_follow(request, dl_uuid): 

574 # redirect if no intercooler request 

575 if not request.is_intercooler(): 

576 return redirect("dddatasets:search") 

577 

578 data_list = get_object_or_404(DataList, uuid=dl_uuid) 

579 

580 if request.user in followers(data_list): 

581 unfollow(request.user, data_list) 

582 else: 

583 follow(request.user, data_list) 

584 return render( 

585 request, 

586 "ddusers/_follow_button.html", 

587 { 

588 "object": data_list, 

589 "follow_url": "ddusers:datalist_follow", 

590 "follow_text": "Follow this Data List", 

591 }, 

592 ) 

593 

594 

595@dd_profile_accessible 

596def user_data_lists(request, us_uuid): 

597 user = get_object_or_404(User, uuid=us_uuid) 

598 return render(request, "ddusers/data_lists.html", {"user": user}) 

599 

600 

601@login_required 

602@dd_tou_accepted 

603def user_get_data_list(request, us_uuid, dl_uuid): 

604 user = get_object_or_404(User, uuid=us_uuid) 

605 data_list = get_object_or_404(DataList, uuid=dl_uuid, public=True) 

606 

607 return render( 

608 request, "ddusers/get_data_list.html", {"user": user, "data_list": data_list} 

609 ) 

610 

611 

612@dd_profile_accessible 

613def user_projects(request, us_uuid): 

614 user = get_object_or_404(User, uuid=us_uuid) 

615 return render(request, "ddusers/projects.html", {"user": user}) 

616 

617 

618@dd_profile_accessible 

619def user_publications(request, us_uuid): 

620 user = get_object_or_404(User, uuid=us_uuid) 

621 return render(request, "ddusers/publications.html", {"user": user}) 

622 

623 

624@login_required 

625@dd_tou_accepted 

626def dataset_to_list(request): 

627 user = request.user 

628 if request.method == "DELETE": 

629 form = DataSetToListForm(request.DELETE) 

630 if form.is_valid(): 

631 ds_uuid = form.cleaned_data["ds_uuid"] 

632 dl_uuid = form.cleaned_data["dl_uuid"] 

633 form_type = form.cleaned_data["form_type"] 

634 

635 dataset = DataSet.objects.get(uuid=ds_uuid) 

636 datalist = DataList.objects.get(uuid=dl_uuid) 

637 

638 if datalist.owner == user: 

639 datalist.datasets.remove(dataset) 

640 datalist.save() 

641 if form_type == "table": 

642 response = HttpResponse() 

643 response["X-IC-Remove"] = "10ms" 

644 return response 

645 else: 

646 return render( 

647 request, 

648 "ddusers/_datalist_button.html", 

649 { 

650 "datalist": datalist, 

651 "dataset": dataset, 

652 "btn_mode": "delete", 

653 }, 

654 ) 

655 if request.method == "POST": 

656 form = DataSetToListForm(request.POST) 

657 if form.is_valid(): 

658 ds_uuid = form.cleaned_data["ds_uuid"] 

659 dl_uuid = form.cleaned_data["dl_uuid"] 

660 dataset = DataSet.objects.get(uuid=ds_uuid) 

661 datalist = DataList.objects.get(uuid=dl_uuid) 

662 if datalist.owner == user: 

663 datalist.datasets.add(dataset) 

664 datalist.save() 

665 action.send( 

666 request.user, 

667 verb="added dataset", 

668 action_object=dataset, 

669 target=datalist, 

670 public=datalist.public, 

671 ) 

672 return render( 

673 request, 

674 "ddusers/_datalist_button.html", 

675 {"datalist": datalist, "dataset": dataset, "btn_mode": "add"}, 

676 ) 

677 else: 

678 logger.error(form.errors.as_data()) 

679 messages.error(request, _("Dataset not added to list")) 

680 

681 return render( 

682 request, 

683 "ddusers/_datalist_button.html", 

684 {"user": user, "datalist": datalist, "dataset": dataset, "btn_mode": "error"}, 

685 ) 

686 

687 

688@login_required 

689@dd_tou_accepted 

690def user_lists_all(request): 

691 user = request.user 

692 lists = user.get_lists_all() 

693 return render(request, "ddusers/data_lists.html", {"user": user, "lists": lists}) 

694 

695 

696@login_required 

697@dd_tou_accepted 

698def user_edit_lists(request): 

699 user = request.user 

700 edit_url = "ddusers:edit_list" 

701 return render( 

702 request, 

703 "ddusers/_edit_data_lists.html", 

704 { 

705 "user": user, 

706 "objects": user.get_lists_all(), 

707 "edit_url": edit_url, 

708 "add_url": edit_url, 

709 "delete_url": edit_url, 

710 "object_type": "data_list", 

711 "object_text": "Data List", 

712 "ictarget": "#ds-content", 

713 "edit_mode": True, 

714 }, 

715 ) 

716 

717 

718@dd_profile_accessible 

719def user_lists_public(request, us_uuid): 

720 user = get_object_or_404(User, uuid=us_uuid) 

721 lists = user.get_lists_public() 

722 return render(request, "ddusers/data_lists.html", {"user": user, "lists": lists}) 

723 

724 

725@login_required 

726@dd_tou_accepted 

727def user_edit_data_list(request, dl_uuid=None): 

728 # redirect if no intercooler request 

729 if not request.is_intercooler(): 

730 return redirect("ddusers:edit_lists") 

731 user = request.user 

732 if request.method == "DELETE": # remove 

733 dl_uuid = request.DELETE["objectid"] 

734 data_list = DataList.objects.get(uuid=dl_uuid) 

735 data_list.delete() 

736 return redirect("ddusers:edit_lists") 

737 if request.method == "POST": # Edit + Add 

738 if dl_uuid: # Edit 

739 data_list = DataList.objects.get(uuid=dl_uuid) 

740 form = DataListForm(request.POST, instance=data_list) 

741 verb = "edited description of data list" 

742 else: # Add 

743 data_list = DataList() 

744 form = DataListForm(request.POST) 

745 verb = "created data list" 

746 if form.is_valid(): 

747 data_list = form.save(commit=False) 

748 data_list.owner = user 

749 data_list.save() 

750 updated = True 

751 form_err = None 

752 logger.error("send action {} for {}".format(verb, data_list)) 

753 action.send( 

754 request.user, 

755 verb=verb, 

756 # action_object=datalist, 

757 target=data_list, 

758 public=data_list.public, 

759 ) 

760 return user_edit_lists(request) 

761 else: 

762 updated = False 

763 form_err = form.errors.as_data() 

764 if request.method == "GET": # get 

765 if dl_uuid: 

766 data_list = DataList.objects.get(uuid=dl_uuid) 

767 form = DataListForm(instance=data_list) 

768 else: 

769 form = DataListForm() 

770 updated = False 

771 form_err = None 

772 

773 return render( 

774 request, 

775 "core/_edit_form.html", 

776 { 

777 "target": "Data List", 

778 "ictarget": "ds-content", 

779 "form": form, 

780 "user": user, 

781 "error_msg": form_err, 

782 "updated": updated, 

783 "editmode": True, 

784 }, 

785 ) 

786 

787 

788@dd_profile_accessible 

789def user_datasets(request, us_uuid): 

790 user = get_object_or_404(User, uuid=us_uuid) 

791 return render(request, "ddusers/datasets.html", {"user": user}) 

792 

793 

794@login_required 

795@dd_tou_accepted 

796def user_edit(request): 

797 oep_publications = get_oep_parameters( 

798 "publication", True, "Add new Discuss Data related publication..." 

799 ) 

800 oep_projects = get_oep_parameters( 

801 "project", True, "Add new Discuss Data related project..." 

802 ) 

803 oep_affiliations = get_oep_parameters("affiliation", True, "Add new affiliation...") 

804 updated = False 

805 user = request.user 

806 if request.method == "POST": 

807 form = UserImageForm(request.POST, request.FILES) 

808 if form.is_valid(): 

809 if form.cleaned_data["photo"]: 

810 user.photo = form.cleaned_data["photo"] 

811 user.save() 

812 logger.debug(user.__dict__) 

813 updated = True 

814 else: 

815 logger.debug("not valid") 

816 logger.debug(form.errors.as_data()) 

817 else: 

818 form = UserImageForm(instance=user) 

819 

820 return render( 

821 request, 

822 "ddusers/edit.html", 

823 { 

824 "user_form": form, 

825 "user": user, 

826 "updated": updated, 

827 "oep_affiliations": oep_affiliations, 

828 "oep_projects": oep_projects, 

829 "oep_publications": oep_publications, 

830 "editmode": True, 

831 }, 

832 ) 

833 

834 

835@login_required 

836@dd_tou_accepted 

837def user_edit_profile(request): 

838 # redirect if no intercooler request 

839 if not request.is_intercooler(): 

840 return redirect("ddusers:edit") 

841 user = request.user 

842 updated = False 

843 err = None 

844 if request.method == "POST": 

845 form = UserForm(request.POST, request.FILES, instance=user) 

846 if form.is_valid(): 

847 user = form.save() 

848 updated = True 

849 else: 

850 updated = False 

851 err = form.errors.as_data() 

852 else: 

853 form = UserForm(instance=user) 

854 return render( 

855 request, 

856 "core/_edit_form.html", 

857 { 

858 "form": form, 

859 "user": user, 

860 "updated": updated, 

861 "err": err, 

862 "target": "User Profile", 

863 "editmode": True, 

864 }, 

865 ) 

866 

867 

868@login_required 

869@dd_tou_accepted 

870def user_edit_affiliations(request): 

871 user = request.user 

872 edit_url = "ddusers:edit_affiliation" 

873 template = "ddusers/_edit_user_objects.html" 

874 if request.method == "POST": 

875 template = "ddusers/_edit_user_objects_sort.html" 

876 object_list = request.POST.getlist("object_uuid") 

877 for i, elem_uuid in enumerate(object_list, start=0): 

878 aff = Affiliation.objects.get(uuid=elem_uuid) 

879 aff.list_position = i 

880 aff.save() 

881 

882 return render( 

883 request, 

884 template, 

885 { 

886 "user": user, 

887 "objects": user.get_affiliations(), 

888 "edit_url": edit_url, 

889 "add_url": edit_url, 

890 "sort_url": "ddusers:edit_affiliations", 

891 "delete_url": edit_url, 

892 "object_type": "affiliation", 

893 "object_text": "Add new affiliation...", 

894 "ictarget": "#ds-content", 

895 }, 

896 ) 

897 

898 

899@login_required 

900@dd_tou_accepted 

901def user_edit_affiliation(request, af_uuid=None): 

902 # redirect if no intercooler request 

903 if not request.is_intercooler(): 

904 return redirect("ddusers:edit_affiliations") 

905 user = request.user 

906 if request.method == "DELETE": # remove 

907 af_uuid = request.DELETE["objectid"] 

908 affiliation = Affiliation.objects.get(uuid=af_uuid) 

909 affiliation.delete() 

910 return redirect("ddusers:edit_affiliations") 

911 if request.method == "POST": 

912 if af_uuid: # Edit 

913 affiliation = Affiliation.objects.get(uuid=af_uuid) 

914 form = AffiliationForm(request.POST, prefix="aff", instance=affiliation) 

915 else: 

916 affiliation = Affiliation() # Add 

917 form = AffiliationForm(request.POST, prefix="aff") 

918 if form.is_valid(): 

919 affiliation = form.save(commit=False) 

920 affiliation.user = user 

921 affiliation.save() 

922 updated = True 

923 form_err = None 

924 return redirect("ddusers:edit_affiliations") 

925 else: 

926 updated = False 

927 form_err = form.errors.as_data() 

928 

929 if request.method == "GET": # get 

930 if af_uuid: 

931 affiliation = Affiliation.objects.get(uuid=af_uuid) 

932 form = AffiliationForm(prefix="aff", instance=affiliation) 

933 else: 

934 form = AffiliationForm(prefix="aff") 

935 updated = False 

936 form_err = None 

937 return render( 

938 request, 

939 "core/_edit_form.html", 

940 { 

941 "target": "affiliation", 

942 "ictarget": "ds-content", 

943 "form": form, 

944 "user": user, 

945 "error_msg": form_err, 

946 "updated": updated, 

947 "editmode": True, 

948 }, 

949 ) 

950 

951 

952@login_required 

953@dd_tou_accepted 

954def user_edit_projects(request): 

955 user = request.user 

956 edit_url = "ddusers:edit_project" 

957 return render( 

958 request, 

959 "ddusers/_edit_user_objects.html", 

960 { 

961 "user": user, 

962 "objects": user.get_projects(), 

963 "edit_url": edit_url, 

964 "add_url": edit_url, 

965 "delete_url": edit_url, 

966 "object_type": "project", 

967 "object_text": "Add new project...", 

968 "ictarget": "#ds-content", 

969 "editmode": True, 

970 }, 

971 ) 

972 

973 

974@login_required 

975@dd_tou_accepted 

976def user_edit_project(request, pr_uuid=None): 

977 # redirect if no intercooler request 

978 if not request.is_intercooler(): 

979 return redirect("ddusers:edit_projects") 

980 user = request.user 

981 if request.method == "DELETE": # remove 

982 pr_uuid = request.DELETE["objectid"] 

983 project = Project.objects.get(uuid=pr_uuid) 

984 project.delete() 

985 return redirect("ddusers:edit_projects") 

986 if request.method == "POST": # Edit + Add 

987 if pr_uuid: # Edit 

988 project = Project.objects.get(uuid=pr_uuid) 

989 form = ProjectForm(request.POST, instance=project) 

990 else: # Add 

991 project = Project() 

992 form = ProjectForm(request.POST) 

993 if form.is_valid(): 

994 project = form.save(commit=False) 

995 project.user = user 

996 project.save() 

997 updated = True 

998 form_err = None 

999 return user_edit_projects(request) 

1000 else: 

1001 updated = False 

1002 form_err = form.errors.as_data() 

1003 if request.method == "GET": # get 

1004 if pr_uuid: 

1005 project = Project.objects.get(uuid=pr_uuid) 

1006 form = ProjectForm(instance=project) 

1007 else: 

1008 form = ProjectForm() 

1009 updated = False 

1010 form_err = None 

1011 

1012 return render( 

1013 request, 

1014 "core/_edit_form.html", 

1015 { 

1016 "target": "project", 

1017 "ictarget": "ds-content", 

1018 "form": form, 

1019 "user": user, 

1020 "error_msg": form_err, 

1021 "updated": updated, 

1022 "editmode": True, 

1023 }, 

1024 ) 

1025 

1026 

1027@login_required 

1028@dd_tou_accepted 

1029def user_edit_publications(request): 

1030 user = request.user 

1031 edit_url = "ddusers:edit_publication" 

1032 return render( 

1033 request, 

1034 "ddusers/_edit_user_objects.html", 

1035 { 

1036 "user": user, 

1037 "objects": user.get_publications(), 

1038 "edit_url": edit_url, 

1039 "add_url": edit_url, 

1040 "delete_url": edit_url, 

1041 "object_type": "publication", 

1042 "object_text": "Add new publication...", 

1043 "ictarget": "#ds-content", 

1044 "editmode": True, 

1045 }, 

1046 ) 

1047 

1048 

1049@login_required 

1050@dd_tou_accepted 

1051def user_edit_publication(request, pub_uuid=None): 

1052 # redirect if no intercooler request 

1053 if not request.is_intercooler(): 

1054 return redirect("ddusers:edit_publications") 

1055 user = request.user 

1056 if request.method == "DELETE": # remove 

1057 pub_uuid = request.DELETE["objectid"] 

1058 publication = Publication.objects.get(uuid=pub_uuid) 

1059 publication.delete() 

1060 return redirect("ddusers:edit_publications") 

1061 if request.method == "POST": # Edit/Add 

1062 if pub_uuid: # Edit 

1063 publication = Publication.objects.get(uuid=pub_uuid) 

1064 form = PublicationForm(request.POST, instance=publication) 

1065 else: # Add 

1066 publication = Publication() 

1067 form = PublicationForm(request.POST) 

1068 if form.is_valid(): 

1069 publication = form.save() 

1070 user.publications.add(publication) 

1071 updated = True 

1072 form_err = None 

1073 return user_edit_publications(request) 

1074 else: 

1075 updated = False 

1076 form_err = form.errors.as_data() 

1077 if request.method == "GET": # get 

1078 if pub_uuid: 

1079 publication = Publication.objects.get(uuid=pub_uuid) 

1080 form = PublicationForm(instance=publication) 

1081 else: 

1082 form = PublicationForm() 

1083 updated = False 

1084 form_err = None 

1085 return render( 

1086 request, 

1087 "core/_edit_form.html", 

1088 { 

1089 "target": "publication", 

1090 "ictarget": "ds-content", 

1091 "form": form, 

1092 "user": user, 

1093 "error_msg": form_err, 

1094 "updated": updated, 

1095 "editmode": True, 

1096 }, 

1097 ) 

1098 

1099 

1100@login_required 

1101@dd_tou_accepted 

1102def user_countries(request): 

1103 # redirect if no intercooler request 

1104 if not request.is_intercooler(): 

1105 return redirect("ddusers:edit") 

1106 user = request.user 

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

1108 countries = list() 

1109 # POST: add or remove a country 

1110 if request.method == "POST": 

1111 country_slug = request.POST["countryslug"] 

1112 country = Country.objects.get(slug=country_slug) 

1113 if country in user.get_countries(): 

1114 user.countries.remove(country) 

1115 else: 

1116 user.countries.add(country) 

1117 user.save() 

1118 

1119 # GET & POST: return a list of all countries, with countries attached to user marked 

1120 for ac in all_countries: 

1121 if ac in user.get_countries(): 

1122 countries.append((ac, True)) 

1123 else: 

1124 countries.append((ac, False)) 

1125 return render( 

1126 request, 

1127 "ddusers/_countries.html", 

1128 {"user": user, "countries": countries}, 

1129 ) 

1130 

1131 

1132@login_required 

1133@dd_tou_accepted 

1134def user_tags(request): 

1135 # redirect if no intercooler request 

1136 if not request.is_intercooler(): 

1137 return redirect("ddusers:edit") 

1138 

1139 user = request.user 

1140 if request.method == "DELETE": 

1141 tagid = request.POST.get("tag-keyword") 

1142 tag = KeywordTagged.objects.get(id=tagid) 

1143 user.interests.remove(tag) 

1144 

1145 if request.method == "POST": 

1146 add = request.POST["interest-tag"].title() 

1147 if len(add) > 0: 

1148 user.interests.add(add) 

1149 

1150 control_args = { 

1151 "div_id": "user-interests", 

1152 "input_id": "interest-tag", 

1153 "objects_get": "user.get_interests", 

1154 "url_objects_all": "core:tags", 

1155 "url_object_add": "ddusers:tags", 

1156 "url_object_remove": "ddusers:tags", 

1157 "text": "user interests", 

1158 } 

1159 return render(request, "ddusers/_tags.html", {"user": user, "ca": control_args})