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

1import json 

2from typing import Any 

3 

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 

14 

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 

51 

52 

53class SubmissionCreateView(LoginRequiredMixin, CreateView): 

54 """ 

55 View for creating a new submission with a preprint id. 

56 """ 

57 

58 model = Submission 

59 form_class = SubmissionCreateForm 

60 template_name = "mesh/forms/form_full_page.html" 

61 restricted_roles = [Author] 

62 

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 

68 

69 def get_success_url(self) -> str: 

70 """ 

71 Redirects to the SubmissionAuthor view to add authors to the 

72 newly created submission. 

73 """ 

74 

75 return reverse( 

76 "mesh:submission_edit_article_metadata", kwargs={"submission_pk": self.submission.pk} 

77 ) 

78 

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()) 

85 

86 def get_context_data(self, *args, **kwargs): 

87 context = super().get_context_data(*args, **kwargs) 

88 context["page_title"] = _("New submission") 

89 

90 # context["data-get-url"] = reverse("mesh:submission_create_vuejs") 

91 

92 # Stepper 

93 step_id = "preprint" 

94 stepper = get_submission_stepper(None) 

95 stepper.set_active_step(step_id) 

96 context["stepper"] = stepper 

97 

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() 

101 

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 

108 

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 

114 

115 

116class SubmissionPreprintUpdateView(LoginRequiredMixin, MeshObjectMixin, UpdateView): 

117 """ 

118 View for updating a submission with a new preprint id. 

119 """ 

120 

121 model = Submission 

122 form_class = SubmissionCreateForm 

123 template_name = "mesh/forms/form_full_page.html" 

124 restricted_roles = [Author] 

125 

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 

131 

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 

138 

139 def get_success_url(self) -> str: 

140 """ 

141 Redirects to the SubmissionAuthor view to add authors to the 

142 newly created submission. 

143 """ 

144 

145 return reverse( 

146 "mesh:submission_edit_article_metadata", kwargs={"submission_pk": self.object.pk} 

147 ) 

148 

149 def form_valid(self, form): 

150 preprint_id = form.cleaned_data["preprint_id"] 

151 

152 if preprint_id != "": 

153 article_data = fetch_article(preprint_id) 

154 

155 title = article_data.title_html 

156 self.submission.name = title 

157 

158 if len(article_data.abstracts) > 0: 

159 abstract = article_data.abstracts[0]["value_tex"] 

160 self.submission.abstract = abstract 

161 

162 self.submission._user = self.request.user 

163 self.submission.save() 

164 

165 current_version = self.submission.get_current_version() 

166 current_version._user = self.request.user 

167 current_version.save() 

168 

169 self.submission.authors.all().delete() 

170 

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() 

180 

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 ) 

188 

189 return HttpResponseRedirect(self.get_success_url()) 

190 

191 def get_context_data(self, *args, **kwargs): 

192 context = super().get_context_data(*args, **kwargs) 

193 context["page_title"] = _("Update submission preprint id") 

194 

195 # context["data-get-url"] = reverse("mesh:submission_create_vuejs") 

196 

197 # Stepper 

198 step_id = "preprint" 

199 stepper = get_submission_stepper(self.submission) 

200 stepper.set_active_step(step_id) 

201 context["stepper"] = stepper 

202 

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() 

206 

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 

213 

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 

219 

220 

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"] 

228 

229 self.submission = None 

230 self.version = None 

231 self.submission_main_file = None 

232 

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 

238 

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 

244 

245 def obj_to_dict(obj): 

246 return obj.__dict__ 

247 

248 data["article"]["colid"] = colid 

249 dump = json.dumps(data, default=obj_to_dict) 

250 return HttpResponse(dump, content_type="application/json") 

251 

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" 

261 

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() 

268 

269 submission_main_file = SubmissionMainFile( 

270 attached_to=self.submission.get_current_version(), file=self.request.FILES["pdf"] 

271 ) 

272 submission_main_file.save() 

273 

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) 

281 

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) 

295 

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) 

301 

302 def post(self, request, *args, **kwargs): 

303 body_unicode = request.POST.get("data", "") 

304 data = json.loads(body_unicode) 

305 

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}) 

313 

314 data["colid"] = app_settings.COLID 

315 

316 article_data = self.convert_data_from_vuejs3(data) 

317 title = article_data.title_html 

318 

319 abstract = article_data.abstracts[0]["value_html"] 

320 

321 self.submission.name = title 

322 self.submission.abstract = abstract 

323 self.submission._user = request.user 

324 self.submission.save() 

325 

326 current_version = self.submission.get_current_version() 

327 current_version._user = request.user 

328 current_version.save() 

329 

330 SubmissionAuthor.objects.filter(submission=self.submission).delete() 

331 

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() 

341 

342 data["redirect"] = { 

343 "redirect": True, 

344 "url": reverse( 

345 "mesh:submission_info_update", kwargs={"submission_pk": self.submission.pk} 

346 ), 

347 } 

348 

349 return JsonResponse(data) 

350 

351 

352class SubmissionRedirectFromVue(TemplateView): 

353 template_name = "mesh/forms/form_full_page_redirect.html" 

354 

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 

361 

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

363 """ 

364 Override the get method to set the form action to "create". 

365 """ 

366 

367 messages.success(self.request, _("New submission successfully created.")) 

368 

369 return super().get(request, *args, **kwargs) 

370 

371 

372class SubmissionInfoView(LoginRequiredMixin, MeshObjectMixin, UpdateView): 

373 """ 

374 View for updating the submission info. 

375 """ 

376 

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 

383 

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 

389 

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}) 

393 

394 return reverse("mesh:submission_confirm", kwargs={"submission_pk": self.submission.pk}) 

395 

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() 

401 

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 

408 

409 def get_context_data(self, *args, **kwargs): 

410 context = super().get_context_data(*args, **kwargs) 

411 context["page_title"] = _("Edit submission info") 

412 

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 

418 

419 # No Save/Next button in the form, they are put in the stepper 

420 context["form"].buttons = [] # = submission_stepper_form_buttons() 

421 

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 

433 

434 return context 

435 

436 def form_valid(self, form): 

437 form.instance._user = self.request.user 

438 

439 Suggestion.objects.filter(submission=self.submission).delete() 

440 

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 } 

447 

448 if person_info["email"] != "": 

449 add_suggestion_from_person( 

450 self.submission, person_info, suggest_to_avoid=prefix == "avoid" 

451 ) 

452 

453 return super().form_valid(form) 

454 

455 

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 """ 

462 

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 

469 

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 

475 

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() 

482 

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 

489 

490 def get_context_data(self, *args, **kwargs): 

491 context = super().get_context_data(*args, **kwargs) 

492 context["page_title"] = _("Edit article metadata") 

493 

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 ) 

499 

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 

505 

506 # No Save/Next button in the form, they are put in the stepper 

507 context["form"].buttons = [] # = submission_stepper_form_buttons() 

508 

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 

517 

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}) 

523 

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 

539 

540 

541class SubmissionVersionCreateView( 

542 LoginRequiredMixin, MeshObjectMixin, SubmittableModelFormMixin, CreateView 

543): 

544 """ 

545 View for creating a new submission version. 

546 """ 

547 

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 

555 

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 

561 

562 def get_form_kwargs(self): 

563 kwargs = super().get_form_kwargs() 

564 kwargs["submission"] = self.submission 

565 return kwargs 

566 

567 def form_valid(self, form): 

568 form.instance.submission = self.submission 

569 return super().form_valid(form) 

570 

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}) 

576 

577 def submit_url(self) -> str: 

578 return reverse("mesh:submission_confirm", kwargs={"submission_pk": self.submission.pk}) 

579 

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 

584 

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}" 

592 

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] 

599 

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 = [] 

605 

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 

616 

617 # def form_valid(self, form): 

618 # result = super().form_valid(form) 

619 # return result 

620 

621 

622class SubmissionVersionUpdateView( 

623 LoginRequiredMixin, MeshObjectMixin, SubmittableModelFormMixin, UpdateView 

624): 

625 """ 

626 View for updating a submission version. 

627 

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 """ 

632 

633 model = SubmissionVersion 

634 form_class = SubmissionVersionForm 

635 template_name = "mesh/forms/form_full_page.html" 

636 

637 restricted_roles = [Author] 

638 message_on_restrict = False 

639 save_submission = False 

640 add_confirm_message = False 

641 

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 

647 

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() 

653 

654 def get_object(self, *args, **kwargs) -> SubmissionVersion: 

655 """ 

656 Returns the already fetched version. 

657 """ 

658 return self.version 

659 

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 

665 

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 ) 

672 

673 def submit_url(self) -> str: 

674 return reverse( 

675 "mesh:submission_confirm", kwargs={"submission_pk": self.version.submission.pk} 

676 ) 

677 

678 def form_pre_save(self, form: SubmissionVersionForm) -> None: 

679 form.instance._user = self.request.user 

680 

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}") 

684 

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] 

691 

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 = [] 

697 

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 

706 

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) 

712 

713 if deletion_requested: 

714 # Update the submission object. 

715 self.version = self.get_version() 

716 return self.get(request, *args, **kwargs) 

717 

718 return super().post(request, *args, **kwargs) 

719 

720 

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. 

725 

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 """ 

733 

734 submission: Submission 

735 restricted_roles = [Author] 

736 

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 

742 

743 def get(self, request: HttpRequest, *args, **kwargs) -> HttpResponse: 

744 stepper = get_submission_stepper(self.submission) 

745 

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) 

751 

752 return HttpResponseRedirect(reverse("mesh:submission_create")) 

753 

754 

755class SubmissionAuthorView(LoginRequiredMixin, MeshObjectMixin, TemplateView): 

756 """ 

757 View to add/remove a submission author from a given submission. 

758 """ 

759 

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" 

765 

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 

771 

772 def get_context_data(self, *args, **kwargs): 

773 context = super().get_context_data(*args, **kwargs) 

774 

775 context["submission"] = self.submission 

776 

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 ] 

837 

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 ) 

848 

849 form = self.init_form or SubmissionAuthorForm( 

850 submission=self.submission, initial=initial or None 

851 ) 

852 

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 ] 

861 

862 context["page_title"] = _("Authors") 

863 

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 # ) 

891 

892 context["form"] = form 

893 

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 

901 

902 return context 

903 

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) 

909 

910 return self.add_author(request, *args, **kwargs) 

911 

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) 

923 

924 form.instance._user = self.request.user 

925 form.instance.submission = self.submission 

926 form.save() 

927 

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 ) 

941 

942 return response 

943 

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 

955 

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 

962 

963 author: SubmissionAuthor = form.cleaned_data["instance"] 

964 author_string = str(author) 

965 author.delete() 

966 

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 

976 

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 

988 

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 ) 

997 

998 return response 

999 

1000 

1001class SubmissionConfirmView(LoginRequiredMixin, MeshObjectMixin, FormView): 

1002 """ 

1003 View to confirm the submission the current SubmissionVersion. 

1004 

1005 It's used both when submitting a Submission for the first time and when 

1006 submitting a revised SubmissionVersion. 

1007 """ 

1008 

1009 template_name = "mesh/submission/version_confirm.html" 

1010 submission: Submission 

1011 form_class = SubmissionConfirmForm 

1012 

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 

1018 

1019 def get_success_url(self): 

1020 return reverse("mesh:submission_details", kwargs={"submission_pk": self.submission.pk}) 

1021 

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) 

1032 

1033 def get_object(self, queryset=None) -> SubmissionVersion: 

1034 return self.submission.get_current_version() 

1035 

1036 def get_context_data(self, *args, **kwargs): 

1037 context = super().get_context_data(*args, **kwargs) 

1038 

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 ] 

1050 

1051 if self.submission.is_draft: 

1052 stepper = get_submission_stepper(self.submission) 

1053 stepper.set_active_step("confirm") 

1054 context["stepper"] = stepper 

1055 

1056 context["submission_proxy"] = SubmissionProxy(self.submission, self.request.current_role) 

1057 

1058 files = [] 

1059 files.append( 

1060 { 

1061 "file_wrapper": self.submission.get_current_version().main_file, 

1062 "type": "Main", 

1063 } 

1064 ) 

1065 

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 

1069 

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 

1077 

1078 return context 

1079 

1080 def form_valid(self, form: SubmissionConfirmForm) -> HttpResponse: 

1081 """ 

1082 Submit the submission's current version. 

1083 """ 

1084 self.submission.submit(self.request.user) 

1085 

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.")) 

1093 

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 ) 

1111 

1112 return HttpResponseRedirect(self.get_success_url()) 

1113 

1114 

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 

1122 

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 

1128 

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 

1135 

1136 def get_success_url(self): 

1137 return reverse("mesh:submission_list") 

1138 

1139 def get_context_data(self, *args, **kwargs): 

1140 context = super().get_context_data(*args, **kwargs) 

1141 

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 ] 

1154 

1155 return context