Coverage for src / mesh / views / views_submission_edit.py: 47%
502 statements
« prev ^ index » next coverage.py v7.13.1, created at 2026-11-03 15:55 +0000
« prev ^ index » next coverage.py v7.13.1, created at 2026-11-03 15:55 +0000
1import json
2from typing import Any
4from django.contrib import messages
5from django.contrib.auth.mixins import LoginRequiredMixin
6from django.http import HttpRequest, HttpResponse, HttpResponseRedirect, JsonResponse
7from django.urls.base import reverse
8from django.utils.translation import gettext_lazy as _
9from django.views.generic import FormView, TemplateView, View
10from django.views.generic.edit import CreateView, DeleteView, UpdateView
11from ptf.model_data import create_articledata, create_contributor
12from ptf_external.fetch_metadata import fetch_article
13from ptf_external.views import ArticleEditFormWithVueAPIView
15from mesh.app_settings import app_settings
16from mesh.models.crud import create_submission
17from mesh.models.file_helpers import post_delete_model_file
18from mesh.models.orm.review_models import ReviewState
19from mesh.models.orm.submission_models import (
20 Submission,
21 SubmissionAuthor,
22 SubmissionLog,
23 SubmissionMainFile,
24 SubmissionVersion,
25)
26from mesh.models.orm.suggestion_model import Suggestion
27from mesh.models.roles.author import Author
28from mesh.models.roles.journal_manager import JournalManager
29from mesh.views.components.button import Button
30from mesh.views.components.stepper import get_submission_stepper
31from mesh.views.forms.base_forms import (
32 SUBMIT_QUERY_PARAMETER,
33 FormAction,
34 HiddenModelChoiceForm,
35)
36from mesh.views.forms.submission_forms import (
37 SubmissionAuthorForm,
38 SubmissionConfirmForm,
39 SubmissionCreateForm,
40 SubmissionDeleteForm,
41 SubmissionEditArticleMetadataForm,
42 SubmissionInfoForm,
43 SubmissionVersionForm,
44)
45from mesh.views.viewmodel import SubmissionProxy
46from mesh.views.views_base import (
47 MeshObjectMixin,
48 SubmittableModelFormMixin,
49)
50from mesh.views.views_reviewer import add_suggestion, add_suggestion_from_person
53class SubmissionCreateView(LoginRequiredMixin, CreateView):
54 """
55 View for creating a new submission with a preprint id.
56 """
58 model = Submission
59 form_class = SubmissionCreateForm
60 template_name = "mesh/forms/form_full_page.html"
61 restricted_roles = [Author]
63 def setup(self, request, *args, **kwargs):
64 super().setup(request, *args, **kwargs)
65 if not self.request.current_role.can_create_submission():
66 raise PermissionError
67 self.submission = None
69 def get_success_url(self) -> str:
70 """
71 Redirects to the SubmissionAuthor view to add authors to the
72 newly created submission.
73 """
75 return reverse(
76 "mesh:submission_edit_article_metadata", kwargs={"submission_pk": self.submission.pk}
77 )
79 def form_valid(self, form) -> HttpResponse:
80 # raise NotImplementedError("TODO : FIX FORM VALIDATION : split logic")
81 self.submission = create_submission(
82 user=self.request.user, preprint_id=form.cleaned_data["preprint_id"]
83 )
84 return HttpResponseRedirect(self.get_success_url())
86 def get_context_data(self, *args, **kwargs):
87 context = super().get_context_data(*args, **kwargs)
88 context["page_title"] = _("New submission")
90 # context["data-get-url"] = reverse("mesh:submission_create_vuejs")
92 # Stepper
93 step_id = "preprint"
94 stepper = get_submission_stepper(None)
95 stepper.set_active_step(step_id)
96 context["stepper"] = stepper
98 # Form buttons
99 # No Save/Next button in the form, they are put in the stepper
100 context["form"].buttons = [] # = submission_stepper_form_buttons()
102 descriptions = [
103 "You are about to start the submit process.",
104 'Please read our guidelines <a href="">here</a>',
105 "If you have a preprint, you can enter its id below. Leave the field blank otherwise.",
106 ]
107 context["form_description"] = descriptions
109 # # Generate breadcrumb data
110 # breadcrumb = get_base_breadcrumb()
111 # breadcrumb.add_item(title=_("New submission"), url=reverse("mesh:submission_create"))
112 # context["breadcrumb"] = breadcrumb
113 return context
116class SubmissionPreprintUpdateView(LoginRequiredMixin, MeshObjectMixin, UpdateView):
117 """
118 View for updating a submission with a new preprint id.
119 """
121 model = Submission
122 form_class = SubmissionCreateForm
123 template_name = "mesh/forms/form_full_page.html"
124 restricted_roles = [Author]
126 def setup(self, request, *args, **kwargs):
127 super().setup(request, *args, **kwargs)
128 self.submission = self.get_submission()
129 if not self.request.current_role.can_edit_submission(self.submission):
130 raise PermissionError
132 def get_object(self, *args, **kwargs) -> Submission:
133 """
134 Override `get_object` built-in method to avoid an additional look-up when
135 we already have the object loaded.
136 """
137 return self.submission
139 def get_success_url(self) -> str:
140 """
141 Redirects to the SubmissionAuthor view to add authors to the
142 newly created submission.
143 """
145 return reverse(
146 "mesh:submission_edit_article_metadata", kwargs={"submission_pk": self.object.pk}
147 )
149 def form_valid(self, form):
150 preprint_id = form.cleaned_data["preprint_id"]
152 if preprint_id != "":
153 article_data = fetch_article(preprint_id)
155 title = article_data.title_html
156 self.submission.name = title
158 if len(article_data.abstracts) > 0:
159 abstract = article_data.abstracts[0]["value_tex"]
160 self.submission.abstract = abstract
162 self.submission._user = self.request.user
163 self.submission.save()
165 current_version = self.submission.get_current_version()
166 current_version._user = self.request.user
167 current_version.save()
169 self.submission.authors.all().delete()
171 for contrib in article_data.contributors:
172 author = SubmissionAuthor(
173 submission=self.submission,
174 first_name=contrib["first_name"],
175 last_name=contrib["last_name"],
176 email=contrib["email"],
177 corresponding=contrib["corresponding"],
178 )
179 author.save()
181 SubmissionLog.add_message(
182 self.submission,
183 content=_("Update of the submission with a preprint id"),
184 content_en="Update of the submission with a preprint id",
185 user=self.request.user,
186 significant=True,
187 )
189 return HttpResponseRedirect(self.get_success_url())
191 def get_context_data(self, *args, **kwargs):
192 context = super().get_context_data(*args, **kwargs)
193 context["page_title"] = _("Update submission preprint id")
195 # context["data-get-url"] = reverse("mesh:submission_create_vuejs")
197 # Stepper
198 step_id = "preprint"
199 stepper = get_submission_stepper(self.submission)
200 stepper.set_active_step(step_id)
201 context["stepper"] = stepper
203 # Form buttons
204 # No Save/Next button in the form, they are put in the stepper
205 context["form"].buttons = [] # = submission_stepper_form_buttons()
207 descriptions = [
208 "You are about to start the submit process.",
209 'Please read our guidelines <a href="">here</a>',
210 "If you have a preprint, you can enter its id below. Leave the field blank otherwise.",
211 ]
212 context["form_description"] = descriptions
214 # # Generate breadcrumb data
215 # breadcrumb = get_base_breadcrumb()
216 # breadcrumb.add_item(title=_("New submission"), url=reverse("mesh:submission_create"))
217 # context["breadcrumb"] = breadcrumb
218 return context
221class SubmissionEditArticleMetadataVuejsAPIView(
222 LoginRequiredMixin, MeshObjectMixin, ArticleEditFormWithVueAPIView
223):
224 def __init__(self, **kwargs):
225 super().__init__(**kwargs)
226 self.fields_to_update = ["contributors", "abstracts", "titles", "pdf"]
227 self.editorial_tools = ["light_authors", "inline_ckeditor"]
229 self.submission = None
230 self.version = None
231 self.submission_main_file = None
233 def setup(self, request, *args, **kwargs):
234 super().setup(request, *args, **kwargs)
235 self.submission = self.get_submission()
236 if not self.request.current_role.can_edit_submission(self.submission):
237 raise PermissionError
239 def get(self, request, *args, **kwargs):
240 colid = app_settings.COLID
241 data_article = create_articledata()
242 data = self.convert_data_for_vuejs3(data_article, colid=colid)
243 data["editorial_tools"] = self.editorial_tools
245 def obj_to_dict(obj):
246 return obj.__dict__
248 data["article"]["colid"] = colid
249 dump = json.dumps(data, default=obj_to_dict)
250 return HttpResponse(dump, content_type="application/json")
252 def handle_pdf_for_vuejs3(self, data, data_article, method=""):
253 if method == "get":
254 submission_main_file = getattr(
255 self.submission.get_current_version(), "main_file", None
256 )
257 if submission_main_file is not None:
258 data["article"]["pdf_name"] = submission_main_file.file.name
259 else:
260 data["article"]["pdf_name"] = "No file uploaded"
262 elif method == "post" and "pdf" in self.request.FILES:
263 submission_main_file = getattr(
264 self.submission.get_current_version(), "main_file", None
265 )
266 if submission_main_file is not None:
267 submission_main_file.delete()
269 submission_main_file = SubmissionMainFile(
270 attached_to=self.submission.get_current_version(), file=self.request.FILES["pdf"]
271 )
272 submission_main_file.save()
274 def handle_titles_for_vuejs3(self, data, data_article, method=""):
275 if method == "get":
276 data["article"]["titles"] = [
277 {"lang": data_article.lang, "value": self.submission.name}
278 ]
279 else:
280 super().handle_titles_for_vuejs3(data, data_article, method)
282 def handle_contributors_for_vuejs3(self, data, data_article, method=""):
283 if method == "get":
284 contributors = []
285 for author in self.submission.authors.all():
286 contrib = create_contributor()
287 contrib["first_name"] = author.first_name
288 contrib["last_name"] = author.last_name
289 contrib["email"] = author.email
290 contrib["corresponding"] = author.corresponding
291 contributors.append(contrib)
292 data["article"]["contributors"] = contributors
293 else:
294 super().handle_contributors_for_vuejs3(data, data_article, method)
296 def handle_abstracts_for_vuejs3(self, data, data_article, method=""):
297 if method == "get":
298 data["article"]["abstracts"] = [{"lang": "en", "value": self.submission.abstract}]
299 else:
300 super().handle_abstracts_for_vuejs3(data, data_article, method)
302 def post(self, request, *args, **kwargs):
303 body_unicode = request.POST.get("data", "")
304 data = json.loads(body_unicode)
306 if (
307 data["title_html"][0]["value"] == ""
308 or data["abstracts"][0]["value"] == ""
309 or len(data["contributors"]) == 0
310 or ("pdf" not in self.request.FILES and data["pdf"]["pdf_name"] == "No file uploaded")
311 ):
312 return JsonResponse({"status_code": 400})
314 data["colid"] = app_settings.COLID
316 article_data = self.convert_data_from_vuejs3(data)
317 title = article_data.title_html
319 abstract = article_data.abstracts[0]["value_html"]
321 self.submission.name = title
322 self.submission.abstract = abstract
323 self.submission._user = request.user
324 self.submission.save()
326 current_version = self.submission.get_current_version()
327 current_version._user = request.user
328 current_version.save()
330 SubmissionAuthor.objects.filter(submission=self.submission).delete()
332 for contrib in article_data.contributors:
333 author = SubmissionAuthor(
334 submission=self.submission,
335 first_name=contrib["first_name"],
336 last_name=contrib["last_name"],
337 email=contrib["email"],
338 corresponding=contrib["corresponding"],
339 )
340 author.save()
342 data["redirect"] = {
343 "redirect": True,
344 "url": reverse(
345 "mesh:submission_info_update", kwargs={"submission_pk": self.submission.pk}
346 ),
347 }
349 return JsonResponse(data)
352class SubmissionRedirectFromVue(TemplateView):
353 template_name = "mesh/forms/form_full_page_redirect.html"
355 def get_context_data(self, **kwargs):
356 context = super().get_context_data(**kwargs)
357 context["message"] = (
358 "La sauvegarde dans Vuejs puis la redirection sur une autre page fonctionne"
359 )
360 return context
362 def get(self, request, *args, **kwargs):
363 """
364 Override the get method to set the form action to "create".
365 """
367 messages.success(self.request, _("New submission successfully created."))
369 return super().get(request, *args, **kwargs)
372class SubmissionInfoView(LoginRequiredMixin, MeshObjectMixin, UpdateView):
373 """
374 View for updating the submission info.
375 """
377 model = Submission
378 form_class = SubmissionInfoForm
379 template_name = "mesh/forms/submission_info.html"
380 submission: Submission
381 restricted_roles = [Author]
382 message_on_restrict = False
384 def setup(self, request, *args, **kwargs):
385 super().setup(request, *args, **kwargs)
386 self.submission = self.get_submission()
387 if not self.request.current_role.can_edit_submission(self.submission):
388 raise PermissionError
390 def get_success_url(self) -> str:
391 # if FormAction.NEXT.value in self.request.POST:
392 # return reverse_lazy("mesh:submission_authors", kwargs={"pk": self.submission.pk})
394 return reverse("mesh:submission_confirm", kwargs={"submission_pk": self.submission.pk})
396 def get_fail_redirect_uri(self) -> str:
397 """
398 Return to the submission details page if the user cannot update the submission.
399 """
400 return self.get_success_url()
402 def get_object(self, *args, **kwargs) -> Submission:
403 """
404 Override `get_object` built-in method to avoid an additional look-up when
405 we already have the object loaded.
406 """
407 return self.submission
409 def get_context_data(self, *args, **kwargs):
410 context = super().get_context_data(*args, **kwargs)
411 context["page_title"] = _("Edit submission info")
413 if self.submission.is_draft:
414 step_id = "info"
415 stepper = get_submission_stepper(self.submission)
416 stepper.set_active_step(step_id)
417 context["stepper"] = stepper
419 # No Save/Next button in the form, they are put in the stepper
420 context["form"].buttons = [] # = submission_stepper_form_buttons()
422 suggestions = self.submission.suggestions_for_reviewer.all()
423 for suggestion in suggestions:
424 reviewer = (
425 suggestion.suggested_reviewer
426 if suggestion.suggested_reviewer is not None
427 else suggestion.suggested_user
428 )
429 if suggestion.suggest_to_avoid:
430 context["avoid_reviewer"] = reviewer
431 else:
432 context["suggested_reviewer"] = reviewer
434 return context
436 def form_valid(self, form):
437 form.instance._user = self.request.user
439 Suggestion.objects.filter(submission=self.submission).delete()
441 for prefix in ["reviewer", "avoid"]:
442 person_info = {
443 "first_name": form.data.get(f"{prefix}_first_name", ""),
444 "last_name": form.data.get(f"{prefix}_last_name", ""),
445 "email": form.data.get(f"{prefix}_email", ""),
446 }
448 if person_info["email"] != "":
449 add_suggestion_from_person(
450 self.submission, person_info, suggest_to_avoid=prefix == "avoid"
451 )
453 return super().form_valid(form)
456class SubmissionEditArticleMetadataView(LoginRequiredMixin, MeshObjectMixin, UpdateView):
457 """
458 View for updating a submission (only the metadata).
459 Only the GET is used to display the form (with VueJS)
460 The POST is handled by SubmissionEditArticleMetadataVuejsAPIView
461 """
463 model = Submission
464 form_class = SubmissionEditArticleMetadataForm
465 template_name = "mesh/forms/form_full_page.html"
466 submission: Submission
467 restricted_roles = [Author]
468 message_on_restrict = False
470 def setup(self, request, *args, **kwargs):
471 super().setup(request, *args, **kwargs)
472 self.submission = self.get_submission()
473 if not self.request.current_role.can_edit_submission(self.submission):
474 raise PermissionError
476 # def get_fail_redirect_uri(self) -> str:
477 # """
478 # Return to the submission details page if the user cannot update the submission.
479 # Not used with VueJS
480 # """
481 # return self.get_success_url()
483 def get_object(self, *args, **kwargs) -> Submission:
484 """
485 Override `get_object` built-in method to avoid an additional look-up when
486 we already have the object loaded.
487 """
488 return self.submission
490 def get_context_data(self, *args, **kwargs):
491 context = super().get_context_data(*args, **kwargs)
492 context["page_title"] = _("Edit article metadata")
494 # data-get-url is used by VueJS to know the GET url to call
495 context["data_get_url"] = reverse(
496 "mesh:submission_update_vuejs",
497 kwargs={"submission_pk": self.submission.pk},
498 )
500 if self.submission.is_draft:
501 step_id = "metadata"
502 stepper = get_submission_stepper(self.submission)
503 stepper.set_active_step(step_id)
504 context["stepper"] = stepper
506 # No Save/Next button in the form, they are put in the stepper
507 context["form"].buttons = [] # = submission_stepper_form_buttons()
509 # Generate breadcrumb data
510 # breadcrumb = get_submission_breadcrumb(self.submission)
511 # breadcrumb.add_item(
512 # title=_("Edit metadata"),
513 # url=reverse_lazy("mesh:submission_edit_article_metadata", kwargs={"pk": self.submission.pk}),
514 # )
515 # context["breadcrumb"] = breadcrumb
516 return context
518 def get_success_url(self) -> str:
519 if FormAction.NEXT.value in self.request.POST:
520 # No POST with VueJS. We shouldn't reach this clause
521 return reverse("mesh:submission_authors", kwargs={"submission_pk": self.submission.pk})
522 return reverse("mesh:submission_details", kwargs={"submission_pk": self.submission.pk})
524 # def form_valid(self, form: SubmissionUpdateForm) -> HttpResponse:
525 # form.instance._user = self.request.user
526 # if not form.changed_data:
527 # form.instance.do_not_update = True
528 #
529 # response = super().form_valid(form)
530 #
531 # if form.has_changed():
532 # SubmissionLog.add_message(
533 # self.submission,
534 # content=_("Modification of the submission's metadata"),
535 # content_en="Modification of the submission's metadata",
536 # user=self.request.user,
537 # )
538 # return response
541class SubmissionVersionCreateView(
542 LoginRequiredMixin, MeshObjectMixin, SubmittableModelFormMixin, CreateView
543):
544 """
545 View for creating a new submission version.
546 """
548 model = SubmissionVersion
549 form_class = SubmissionVersionForm
550 template_name = "mesh/forms/form_full_page.html"
551 submission: Submission
552 restricted_roles = [Author]
553 save_submission = False
554 add_confirm_message = False
556 def setup(self, request, *args, **kwargs):
557 super().setup(request, *args, **kwargs)
558 self.submission = self.get_submission()
559 if not self.request.current_role.can_create_version(self.submission):
560 raise PermissionError
562 def get_form_kwargs(self):
563 kwargs = super().get_form_kwargs()
564 kwargs["submission"] = self.submission
565 return kwargs
567 def form_valid(self, form):
568 form.instance.submission = self.submission
569 return super().form_valid(form)
571 def get_success_url(self) -> str:
572 if FormAction.NEXT.value in self.request.POST:
573 # No POST with VueJS. We shouldn't reach this clause
574 return self.submit_url()
575 return reverse("mesh:submission_details", kwargs={"submission_pk": self.submission.pk})
577 def submit_url(self) -> str:
578 return reverse("mesh:submission_confirm", kwargs={"submission_pk": self.submission.pk})
580 # def form_pre_save(self, form: SubmissionVersionForm):
581 # Not used with VueJS
582 # form.instance._user = self.request.user
583 # form.instance.submission = self.submission
585 def get_context_data(self, *args, **kwargs):
586 context = super().get_context_data(*args, **kwargs)
587 current_version = self.submission.get_current_version()
588 version = current_version.number + 1 if current_version else 1
589 context["page_title"] = _("Submission files")
590 if not self.submission.is_draft:
591 context["page_title"] += f" - Version {version}"
593 submission_url = reverse(
594 "mesh:submission_details", kwargs={"submission_pk": self.submission.pk}
595 )
596 description = "Please fill the form below to submit your files for the submission "
597 description += f"<a href='{submission_url}'><i>{self.submission.name}</i></a>.<br>"
598 context["form_description"] = [description]
600 if self.submission.is_draft:
601 stepper = get_submission_stepper(self.submission)
602 stepper.set_active_step("version")
603 context["stepper"] = stepper
604 context["form"].buttons = []
606 # # Generate breadcrumb data
607 # breadcrumb = get_submission_breadcrumb(self.submission)
608 # breadcrumb.add_item(
609 # title=_("New version"),
610 # url=reverse_lazy(
611 # "mesh:submission_version_create", kwargs={"submission_pk": self.submission.pk}
612 # ),
613 # )
614 # context["breadcrumb"] = breadcrumb
615 return context
617 # def form_valid(self, form):
618 # result = super().form_valid(form)
619 # return result
622class SubmissionVersionUpdateView(
623 LoginRequiredMixin, MeshObjectMixin, SubmittableModelFormMixin, UpdateView
624):
625 """
626 View for updating a submission version.
628 Submitting a version = submitting the whole submission.
629 This requires extra care about checking that all previous steps have been
630 taken when this is the first version.
631 """
633 model = SubmissionVersion
634 form_class = SubmissionVersionForm
635 template_name = "mesh/forms/form_full_page.html"
637 restricted_roles = [Author]
638 message_on_restrict = False
639 save_submission = False
640 add_confirm_message = False
642 def setup(self, request, *args, **kwargs):
643 super().setup(request, *args, **kwargs)
644 self.version = self.get_version()
645 if not self.request.current_role.can_edit_version(self.submission):
646 raise PermissionError
648 def get_fail_redirect_uri(self) -> str:
649 """
650 Redirects to the submission details page if the user cannot update the version.
651 """
652 return self.get_success_url()
654 def get_object(self, *args, **kwargs) -> SubmissionVersion:
655 """
656 Returns the already fetched version.
657 """
658 return self.version
660 def get_form_kwargs(self) -> dict[str, Any]:
661 kwargs = super().get_form_kwargs()
662 if self.request.GET.get(SUBMIT_QUERY_PARAMETER, None) == "true":
663 kwargs[SUBMIT_QUERY_PARAMETER] = True
664 return kwargs
666 def get_success_url(self) -> str:
667 if FormAction.NEXT.value in self.request.POST:
668 return self.submit_url()
669 return reverse(
670 "mesh:submission_details", kwargs={"submission_pk": self.version.submission.pk}
671 )
673 def submit_url(self) -> str:
674 return reverse(
675 "mesh:submission_confirm", kwargs={"submission_pk": self.version.submission.pk}
676 )
678 def form_pre_save(self, form: SubmissionVersionForm) -> None:
679 form.instance._user = self.request.user
681 def get_context_data(self, *args, **kwargs):
682 context = super().get_context_data(*args, **kwargs)
683 context["page_title"] = _(f"Submission files - Version {self.version.number}")
685 submission_url = reverse(
686 "mesh:submission_details", kwargs={"submission_pk": self.version.submission.pk}
687 )
688 description = "Please fill the form below to submit your files for the submission "
689 description += f"<a href='{submission_url}'><i>{self.version.submission.name}</i></a>.<br>"
690 context["form_description"] = [description]
692 if self.version.submission.is_draft:
693 stepper = get_submission_stepper(self.version.submission)
694 stepper.set_active_step("version")
695 context["stepper"] = stepper
696 context["form"].buttons = []
698 # # Generate breadcrumb data
699 # breadcrumb = get_submission_breadcrumb(self.version.submission)
700 # breadcrumb.add_item(
701 # title=_("Edit version") + f" #{self.version.number}",
702 # url=reverse("mesh:submission_version_update", kwargs={"pk": self.version.pk}),
703 # )
704 # context["breadcrumb"] = breadcrumb
705 return context
707 def post(self, request: HttpRequest, *args, **kwargs) -> HttpResponse:
708 """
709 View for updating the submission or deleting one of the associated files.
710 """
711 deletion_requested, _ = post_delete_model_file(self.version, request, self.role_handler)
713 if deletion_requested:
714 # Update the submission object.
715 self.version = self.get_version()
716 return self.get(request, *args, **kwargs)
718 return super().post(request, *args, **kwargs)
721class SubmissionResumeView(LoginRequiredMixin, MeshObjectMixin, View):
722 """
723 View handling the first submit of a submission. It resumes the submission process
724 at the correct edit view according to the missing data.
726 Handles the submission stepper. It redirects to the correct step according to
727 the submission status.
728 - STEP 1: Preprint id
729 - STEP 2: Article Metadata
730 - STEP 3: Submission Info
731 - STEP 4: Confirmation
732 """
734 submission: Submission
735 restricted_roles = [Author]
737 def setup(self, request, *args, **kwargs):
738 super().setup(request, *args, **kwargs)
739 self.submission = self.get_submission()
740 if not self.request.current_role.can_submit_submission(self.submission):
741 raise PermissionError
743 def get(self, request: HttpRequest, *args, **kwargs) -> HttpResponse:
744 stepper = get_submission_stepper(self.submission)
746 # Redirects to the last active step
747 for i in range(len(stepper.steps)):
748 step = stepper.steps[-(i + 1)]
749 if step.href and step.can_navigate:
750 return HttpResponseRedirect(step.href)
752 return HttpResponseRedirect(reverse("mesh:submission_create"))
755class SubmissionAuthorView(LoginRequiredMixin, MeshObjectMixin, TemplateView):
756 """
757 View to add/remove a submission author from a given submission.
758 """
760 submission: Submission
761 template_name = "mesh/forms/submission_author.html"
762 restricted_roles = [Author]
763 init_form: SubmissionAuthorForm | None = None
764 _FORM_ACTION_CORRESPONDING = "_action_toggle_corresponding"
766 def setup(self, request, *args, **kwargs):
767 super().setup(request, *args, **kwargs)
768 self.submission = self.get_submission()
769 if not self.request.current_role.can_edit_submission(self.submission):
770 raise PermissionError
772 def get_context_data(self, *args, **kwargs):
773 context = super().get_context_data(*args, **kwargs)
775 context["submission"] = self.submission
777 authors_qs = self.submission.authors.all()
778 context["authors"] = [
779 {
780 "author": author,
781 "delete_form": HiddenModelChoiceForm(
782 form_action=FormAction.DELETE.value,
783 initial={"instance": author},
784 _queryset=authors_qs,
785 ),
786 "corresponding_form": HiddenModelChoiceForm(
787 form_action="_action_toggle_corresponding",
788 initial={"instance": author},
789 _queryset=authors_qs,
790 ),
791 "buttons": [
792 Button(
793 id=f"author-corresponding-{author.pk}",
794 title=_("Corresponding"),
795 icon_class=("fa-toggle-on" if author.corresponding else "fa-toggle-off"),
796 form=HiddenModelChoiceForm(
797 initial={"instance": author}, _queryset=authors_qs
798 ),
799 attrs={
800 "href": [
801 reverse(
802 "mesh:submission_authors",
803 kwargs={"submission_pk": self.submission.pk},
804 )
805 ],
806 "type": ["submit"],
807 "class": ["primary" if author.corresponding else "inactive"],
808 "name": [self._FORM_ACTION_CORRESPONDING],
809 "data-tooltip": [
810 _("Click to toggle whether the author is a corresponding contact.")
811 ],
812 },
813 ),
814 Button(
815 id=f"author-delete-{author.pk}",
816 title=_("Remove"),
817 icon_class="fa-trash",
818 form=HiddenModelChoiceForm(
819 initial={"instance": author}, _queryset=authors_qs
820 ),
821 attrs={
822 "href": [
823 reverse(
824 "mesh:submission_authors",
825 kwargs={"submission_pk": self.submission.pk},
826 )
827 ],
828 "type": ["submit"],
829 "class": ["button-error"],
830 "name": [FormAction.DELETE.value],
831 },
832 ),
833 ],
834 }
835 for author in self.submission.authors_censored
836 ]
838 initial = {}
839 if not self.submission.authors_censored:
840 initial.update(
841 {
842 "first_name": self.request.user.first_name,
843 "last_name": self.request.user.last_name,
844 "email": self.request.user.email,
845 "primary": True,
846 }
847 )
849 form = self.init_form or SubmissionAuthorForm(
850 submission=self.submission, initial=initial or None
851 )
853 form.buttons = [
854 Button(
855 id="form_save",
856 title=_("Add author"),
857 icon_class="fa-plus",
858 attrs={"type": ["submit"], "class": ["btn-save-form"]},
859 )
860 ]
862 context["page_title"] = _("Authors")
864 if self.submission.is_draft:
865 step_id = "authors"
866 stepper = get_submission_stepper(self.submission)
867 stepper.set_active_step(step_id)
868 context["stepper"] = stepper
869 # version_step = stepper.get_step("version")
870 # if version_step and version_step.can_navigate and version_step.href:
871 # button = Button(
872 # id="next",
873 # title=_("Next"),
874 # icon_class="fa-right-long",
875 # attrs={"href": [version_step.href], "class": ["as-button"]},
876 # )
877 # context["title_buttons"] = [button]
878 #
879 # form.buttons.append(
880 # Button(
881 # id="form_next",
882 # title=_("Next"),
883 # icon_class="fa-right-long",
884 # attrs={
885 # "href": [version_step.href],
886 # "type": ["submit"],
887 # "class": ["as-button", "btn-save-form"],
888 # },
889 # )
890 # )
892 context["form"] = form
894 # # Generate breadcrumb data
895 # breadcrumb = get_submission_breadcrumb(self.submission)
896 # breadcrumb.add_item(
897 # title=_("Authors"),
898 # url=reverse("mesh:submission_authors", kwargs={"pk": self.submission.pk}),
899 # )
900 # context["breadcrumb"] = breadcrumb
902 return context
904 def post(self, request, *args, **kwargs):
905 if FormAction.DELETE.value in request.POST:
906 return self.remove_author(request)
907 elif self._FORM_ACTION_CORRESPONDING in request.POST:
908 return self.toggle_primary_author(request)
910 return self.add_author(request, *args, **kwargs)
912 def add_author(self, request, *args, **kwargs):
913 """
914 Add an `SubmissionAuthor` to the submission.
915 """
916 response = HttpResponseRedirect(
917 reverse("mesh:submission_authors", kwargs={"submission_pk": self.submission.pk})
918 )
919 form = SubmissionAuthorForm(request.POST, submission=self.submission)
920 if not form.is_valid():
921 self.init_form = form
922 return self.get(request, *args, **kwargs)
924 form.instance._user = self.request.user
925 form.instance.submission = self.submission
926 form.save()
928 SubmissionLog.add_message(
929 self.submission,
930 content=f"Author added: {form.instance.first_name} {form.instance.last_name} ({form.instance.email})",
931 content_en=_("Author added")
932 + f": {form.instance.first_name} {form.instance.last_name} ({form.instance.email})",
933 user=request.user,
934 significant=True,
935 )
936 messages.success(
937 request,
938 _("Author added")
939 + f": {form.instance.first_name} {form.instance.last_name} ({form.instance.email})",
940 )
942 return response
944 def remove_author(self, request: HttpRequest) -> HttpResponse:
945 """
946 Remove a `SubmissionAuthor` from the submission.
947 """
948 response = HttpResponseRedirect(
949 reverse("mesh:submission_authors", kwargs={"submission_pk": self.submission.pk})
950 )
951 form = HiddenModelChoiceForm(request.POST, _queryset=self.submission.authors.all())
952 if not form.is_valid():
953 messages.error(request, _("Something went wrong. Please try again."))
954 return response
956 if len(self.submission.authors_censored) < 2:
957 messages.error(
958 request,
959 _("There must be at least 1 author attached to the submission."),
960 )
961 return response
963 author: SubmissionAuthor = form.cleaned_data["instance"]
964 author_string = str(author)
965 author.delete()
967 SubmissionLog.add_message(
968 self.submission,
969 content=f"Author removed: {author_string}",
970 content_en=_("Author added") + f": {author_string}",
971 user=request.user,
972 significant=True,
973 )
974 messages.success(request, _("The author has been removed."))
975 return response
977 def toggle_primary_author(self, request: HttpRequest) -> HttpResponse:
978 """
979 Toggle the `corresponding` boolean of a `SubmissionAuthor` from the submission.
980 """
981 response = HttpResponseRedirect(
982 reverse("mesh:submission_authors", kwargs={"submission_pk": self.submission.pk})
983 )
984 form = HiddenModelChoiceForm(request.POST, _queryset=self.submission.authors.all())
985 if not form.is_valid():
986 messages.error(request, _("Something went wrong. Please try again."))
987 return response
989 author: SubmissionAuthor = form.cleaned_data["instance"]
990 author.corresponding = not author.corresponding
991 author.save()
992 word = "marked" if author.corresponding else "unmarked"
993 messages.success(
994 request,
995 _(f"Author {author} has been {word} as a corresponding contact."),
996 )
998 return response
1001class SubmissionConfirmView(LoginRequiredMixin, MeshObjectMixin, FormView):
1002 """
1003 View to confirm the submission the current SubmissionVersion.
1005 It's used both when submitting a Submission for the first time and when
1006 submitting a revised SubmissionVersion.
1007 """
1009 template_name = "mesh/submission/version_confirm.html"
1010 submission: Submission
1011 form_class = SubmissionConfirmForm
1013 def setup(self, request, *args, **kwargs):
1014 super().setup(request, *args, **kwargs)
1015 self.submission = self.get_submission()
1016 if not self.request.current_role.can_edit_submission(self.submission):
1017 raise PermissionError
1019 def get_success_url(self):
1020 return reverse("mesh:submission_details", kwargs={"submission_pk": self.submission.pk})
1022 def get(self, request, *args, **kwargs):
1023 if not self.submission.is_submittable():
1024 # TODO : Enhance error message
1025 # We theorically shouldn't even be able to get there with an invalid submission
1026 # But real examples have shown that it can happen
1027 messages.error(
1028 request,
1029 _("There must be at least 1 author attached to the submission."),
1030 )
1031 return super().get(request, *args, **kwargs)
1033 def get_object(self, queryset=None) -> SubmissionVersion:
1034 return self.submission.get_current_version()
1036 def get_context_data(self, *args, **kwargs):
1037 context = super().get_context_data(*args, **kwargs)
1039 context["form"].buttons = [
1040 Button(
1041 id="form_save",
1042 title=_("Submit"),
1043 icon_class="fa-check",
1044 attrs={
1045 "type": ["submit"],
1046 "class": ["btn-save-form", "button-highlight"],
1047 },
1048 )
1049 ]
1051 if self.submission.is_draft:
1052 stepper = get_submission_stepper(self.submission)
1053 stepper.set_active_step("confirm")
1054 context["stepper"] = stepper
1056 context["submission_proxy"] = SubmissionProxy(self.submission, self.request.current_role)
1058 files = []
1059 files.append(
1060 {
1061 "file_wrapper": self.submission.get_current_version().main_file,
1062 "type": "Main",
1063 }
1064 )
1066 for file_wrapper in self.submission.get_current_version().additional_files.all():
1067 files.append({"file_wrapper": file_wrapper, "type": "Additional"})
1068 context["submission_files"] = files
1070 # # Breadcrumb
1071 # breadcrumb = get_submission_breadcrumb(self.submission)
1072 # breadcrumb.add_item(
1073 # title=_("Authors"),
1074 # url=reverse("mesh:submission_confirm", kwargs={"pk": self.submission.pk}),
1075 # )
1076 # context["breadcrumb"] = breadcrumb
1078 return context
1080 def form_valid(self, form: SubmissionConfirmForm) -> HttpResponse:
1081 """
1082 Submit the submission's current version.
1083 """
1084 self.submission.submit(self.request.user)
1086 if self.submission.get_current_version().number == 1:
1087 messages.success(
1088 self.request,
1089 _("Your submission has been successfully saved and confirmed."),
1090 )
1091 else:
1092 messages.success(self.request, _("Your revisions were successfully submitted."))
1094 previous_round_number = self.submission.get_current_version().number - 1
1095 if previous_round_number > 0:
1096 previous_round = self.submission.versions.get(number=previous_round_number)
1097 previous_reviewers = [
1098 review.reviewer
1099 for review in previous_round.reviews.filter(state=ReviewState.SUBMITTED.value)
1100 ]
1101 for previous_reviewer in previous_reviewers:
1102 qs = Suggestion.objects.filter(
1103 submission=self.submission, suggested_user=previous_reviewer
1104 )
1105 if not qs.exists():
1106 add_suggestion(
1107 submission=self.submission,
1108 suggested_user=previous_reviewer,
1109 suggested_reviewer=None,
1110 )
1112 return HttpResponseRedirect(self.get_success_url())
1115class SubmissionDeleteView(LoginRequiredMixin, MeshObjectMixin, DeleteView):
1116 model = Submission
1117 submission: Submission
1118 form_class = SubmissionDeleteForm
1119 template_name = "mesh/forms/submission_delete.html"
1120 restricted_roles = [JournalManager, Author]
1121 message_on_restrict = False
1123 def setup(self, request, *args, **kwargs):
1124 super().setup(request, *args, **kwargs)
1125 self.submission = self.get_submission()
1126 if not self.request.current_role.can_edit_submission(self.submission):
1127 raise PermissionError
1129 def get_object(self, *args, **kwargs) -> Submission:
1130 """
1131 Override `get_object` built-in method to avoid an additional look-up when
1132 we already have the object loaded.
1133 """
1134 return self.submission
1136 def get_success_url(self):
1137 return reverse("mesh:submission_list")
1139 def get_context_data(self, *args, **kwargs):
1140 context = super().get_context_data(*args, **kwargs)
1142 context["submission"] = self.submission
1143 context["form"].buttons = [
1144 Button(
1145 id="form_save",
1146 title=_("Delete"),
1147 icon_class="fa-trash",
1148 attrs={
1149 "type": ["submit"],
1150 "class": ["btn-save-form", "button-highlight"],
1151 },
1152 )
1153 ]
1155 return context