Coverage for src/ptf_tools/views/cms_views.py: 49%
862 statements
« prev ^ index » next coverage.py v7.7.0, created at 2025-04-03 12:11 +0000
1import base64
2import json
3import os
4import re
5import shutil
6from datetime import datetime
8import requests
9from ckeditor_uploader.views import ImageUploadView, browse
10from django.conf import settings
11from django.contrib import messages
12from django.contrib.auth.mixins import UserPassesTestMixin
13from django.core.exceptions import PermissionDenied
14from django.db.models import Q
15from django.forms.models import model_to_dict
16from django.http import (
17 Http404,
18 HttpResponse,
19 HttpResponseBadRequest,
20 HttpResponseRedirect,
21 HttpResponseServerError,
22 JsonResponse,
23)
24from django.shortcuts import get_object_or_404, redirect
25from django.urls import resolve, reverse
26from django.utils import timezone
27from django.utils.safestring import mark_safe
28from django.views.decorators.csrf import csrf_exempt
29from django.views.generic import CreateView, TemplateView, UpdateView, View
30from lxml import etree
31from mersenne_cms.models import (
32 MERSENNE_ID_VIRTUAL_ISSUES,
33 News,
34 Page,
35 get_news_content,
36 get_pages_content,
37 import_news,
38 import_pages,
39)
40from munch import Munch
41from PIL import Image
42from ptf import model_data_converter, model_helpers
43from ptf.cmds import solr_cmds, xml_cmds
44from ptf.cmds.ptf_cmds import base_ptf_cmds
45from ptf.cmds.xml import xml_utils
46from ptf.cmds.xml.ckeditor.ckeditor_parser import CkeditorParser
47from ptf.cmds.xml.jats.builder.issue import get_issue_title_xml
48from ptf.display import resolver
50# from ptf.display import resolver
51from ptf.exceptions import ServerUnderMaintenance
53# from ptf.model_data import ArticleData
54from ptf.model_data import IssueData, create_contributor, create_datastream, create_publisherdata
55from ptf.model_data_converter import jats_from_abstract
57# from ptf.models import ExtLink
58# from ptf.models import ResourceInSpecialIssue
59# from ptf.models import Contribution
60# from ptf.models import Collection
61from ptf.models import (
62 Article,
63 Collection,
64 Container,
65 ContribAddress,
66 ExtLink,
67 GraphicalAbstract,
68 RelatedArticles,
69 RelatedObject,
70)
71from ptf.site_register import SITE_REGISTER
72from ptf.utils import get_names
73from requests import Timeout
75from ptf_tools.forms import GraphicalAbstractForm, NewsForm, PageForm, RelatedForm
76from ptf_tools.utils import is_authorized_editor
78from .base_views import check_lock
81def get_media_base_root(colid):
82 """
83 Base folder where media files are stored in Trammel
84 """
85 if colid in ["CRMECA", "CRBIOL", "CRGEOS", "CRCHIM", "CRMATH", "CRPHYS"]:
86 colid = "CR"
88 return os.path.join(settings.RESOURCES_ROOT, "media", colid)
91def get_media_base_root_in_test(colid):
92 """
93 Base folder where media files are stored in the test website
94 Use the same folder as the Trammel media folder so that no copy is necessary when deploy in test
95 """
96 return get_media_base_root(colid)
99def get_media_base_root_in_prod(colid):
100 """
101 Base folder where media files are stored in the prod website
102 """
103 if colid in ["CRMECA", "CRBIOL", "CRGEOS", "CRCHIM", "CRMATH", "CRPHYS"]:
104 colid = "CR"
106 return os.path.join(settings.MERSENNE_PROD_DATA_FOLDER, "media", colid)
109def get_media_base_url(colid):
110 path = os.path.join(settings.MEDIA_URL, colid)
112 if colid in ["CRMECA", "CRBIOL", "CRGEOS", "CRCHIM", "CRMATH", "CRPHYS"]:
113 prefixes = {
114 "CRMECA": "mecanique",
115 "CRBIOL": "biologies",
116 "CRGEOS": "geoscience",
117 "CRCHIM": "chimie",
118 "CRMATH": "mathematique",
119 "CRPHYS": "physique",
120 }
121 path = f"/{prefixes[colid]}{settings.MEDIA_URL}/CR"
123 return path
126def change_ckeditor_storage(colid):
127 """
128 By default, CKEditor stores all the files under 1 folder (MEDIA_ROOT)
129 We want to store the files under a subfolder of @colid
130 To do that we have to
131 - change the URL calling this view to pass the site_id (info used by the Pages to filter the objects)
132 - modify the storage location
133 """
135 from ckeditor_uploader import utils, views
136 from django.core.files.storage import FileSystemStorage
138 storage = FileSystemStorage(
139 location=get_media_base_root(colid), base_url=get_media_base_url(colid)
140 )
142 utils.storage = storage
143 views.storage = storage
146class EditorRequiredMixin(UserPassesTestMixin):
147 def test_func(self):
148 return is_authorized_editor(self.request.user, self.kwargs.get("colid"))
151class CollectionImageUploadView(EditorRequiredMixin, ImageUploadView):
152 """
153 By default, CKEditor stores all the files under 1 folder (MEDIA_ROOT)
154 We want to store the files under a subfolder of @colid
155 To do that we have to
156 - change the URL calling this view to pass the site_id (info used by the Pages to filter the objects)
157 - modify the storage location
158 """
160 def dispatch(self, request, *args, **kwargs):
161 colid = kwargs["colid"]
163 change_ckeditor_storage(colid)
165 return super().dispatch(request, **kwargs)
168class CollectionBrowseView(EditorRequiredMixin, View):
169 def dispatch(self, request, **kwargs):
170 colid = kwargs["colid"]
172 change_ckeditor_storage(colid)
174 return browse(request)
177file_upload_in_collection = csrf_exempt(CollectionImageUploadView.as_view())
178file_browse_in_collection = csrf_exempt(CollectionBrowseView.as_view())
181def deploy_cms(site, collection):
182 colid = collection.pid
183 base_url = getattr(collection, site)()
185 if base_url is None: 185 ↛ 188line 185 didn't jump to line 188 because the condition on line 185 was always true
186 return JsonResponse({"message": "OK"})
188 if site == "website":
189 from_base_path = get_media_base_root_in_test(colid)
190 to_base_path = get_media_base_root_in_prod(colid)
192 for sub_path in ["uploads", "images"]:
193 from_path = os.path.join(from_base_path, sub_path)
194 to_path = os.path.join(to_base_path, sub_path)
195 if os.path.exists(from_path):
196 try:
197 shutil.copytree(from_path, to_path, dirs_exist_ok=True)
198 except OSError as exception:
199 return HttpResponseServerError(f"Error during copy: {exception}")
201 site_id = model_helpers.get_site_id(colid)
202 if model_helpers.get_site_default_language(site_id):
203 from modeltranslation import fields, manager
205 old_ftor = manager.get_language
206 manager.get_language = monkey_get_language_en
207 fields.get_language = monkey_get_language_en
209 pages = get_pages_content(colid)
210 news = get_news_content(colid)
212 manager.get_language = old_ftor
213 fields.get_language = old_ftor
214 else:
215 pages = get_pages_content(colid)
216 news = get_news_content(colid)
218 data = json.dumps({"pages": json.loads(pages), "news": json.loads(news)})
219 url = getattr(collection, site)() + "/import_cms/"
221 try:
222 response = requests.put(url, data=data, verify=False)
224 if response.status_code == 503:
225 e = ServerUnderMaintenance(
226 "The journal test website is under maintenance. Please try again later."
227 )
228 return HttpResponseServerError(e, status=503)
230 except Timeout as exception:
231 return HttpResponse(exception, status=408)
232 except Exception as exception:
233 return HttpResponseServerError(exception)
235 return JsonResponse({"message": "OK"})
238class HandleCMSMixin(EditorRequiredMixin):
239 """
240 Mixin for classes that need to send request to (test) website to import/export CMS content (pages, news)
241 """
243 # def dispatch(self, request, *args, **kwargs):
244 # self.colid = self.kwargs["colid"]
245 # return super().dispatch(request, *args, **kwargs)
247 def init_data(self, kwargs):
248 self.collection = None
250 self.colid = kwargs.get("colid", None)
251 if self.colid:
252 self.collection = model_helpers.get_collection(self.colid)
253 if not self.collection:
254 raise Http404(f"{self.colid} does not exist")
256 test_server_url = self.collection.test_website()
257 if not test_server_url:
258 raise Http404("The collection has no test site")
260 prod_server_url = self.collection.website()
261 if not prod_server_url:
262 raise Http404("The collection has no prod site")
265class GetCMSFromSiteAPIView(HandleCMSMixin, View):
266 """
267 Get the CMS content from the (test) website and save it on disk.
268 It can be used if needed to restore the Trammel content with RestoreCMSAPIView below
269 """
271 def get(self, request, *args, **kwargs):
272 self.init_data(self.kwargs)
274 site = kwargs.get("site", "test_website")
276 try:
277 url = getattr(self.collection, site)() + "/export_cms/"
278 response = requests.get(url, verify=False)
280 # Just to need to save the json on disk
281 # Media files are already saved in MEDIA_ROOT which is equal to
282 # /mersenne_test_data/@colid/media
283 folder = get_media_base_root(self.colid)
284 os.makedirs(folder, exist_ok=True)
285 filename = os.path.join(folder, f"pages_{self.colid}.json")
286 with open(filename, mode="w", encoding="utf-8") as file:
287 file.write(response.content.decode(encoding="utf-8"))
289 except Timeout as exception:
290 return HttpResponse(exception, status=408)
291 except Exception as exception:
292 return HttpResponseServerError(exception)
294 return JsonResponse({"message": "OK", "status": 200})
297def monkey_get_language_en():
298 return "en"
301class RestoreCMSAPIView(HandleCMSMixin, View):
302 """
303 Restore the Trammel CMS content (of a colid) from disk
304 """
306 def get(self, request, *args, **kwargs):
307 self.init_data(self.kwargs)
309 folder = get_media_base_root(self.colid)
310 filename = os.path.join(folder, f"pages_{self.colid}.json")
311 with open(filename, encoding="utf-8") as f:
312 json_data = json.load(f)
314 pages = json_data.get("pages")
316 site_id = model_helpers.get_site_id(self.colid)
317 if model_helpers.get_site_default_language(site_id):
318 from modeltranslation import fields, manager
320 old_ftor = manager.get_language
321 manager.get_language = monkey_get_language_en
322 fields.get_language = monkey_get_language_en
324 import_pages(pages, self.colid)
326 manager.get_language = old_ftor
327 fields.get_language = old_ftor
328 else:
329 import_pages(pages, self.colid)
331 if "news" in json_data:
332 news = json_data.get("news")
333 import_news(news, self.colid)
335 return JsonResponse({"message": "OK", "status": 200})
338class DeployCMSAPIView(HandleCMSMixin, View):
339 def get(self, request, *args, **kwargs):
340 self.init_data(self.kwargs)
342 if check_lock():
343 msg = "Trammel is under maintenance. Please try again later."
344 messages.error(self.request, msg)
345 return JsonResponse({"messages": msg, "status": 503})
347 site = kwargs.get("site", "test_website")
349 response = deploy_cms(site, self.collection)
351 if response.status_code == 503:
352 messages.error(
353 self.request, "The journal website is under maintenance. Please try again later."
354 )
356 return response
359def get_server_urls(collection, site="test_website"):
360 urls = [""]
361 if hasattr(settings, "MERSENNE_DEV_URL"): 361 ↛ 363line 361 didn't jump to line 363 because the condition on line 361 was never true
362 # set RESOURCES_ROOT and apache config accordingly (for instance with "/mersenne_dev_data")
363 url = getattr(collection, "test_website")().split(".fr")
364 urls = [settings.MERSENNE_DEV_URL + url[1] if len(url) == 2 else ""]
365 elif site == "both": 365 ↛ 366line 365 didn't jump to line 366 because the condition on line 365 was never true
366 urls = [getattr(collection, "test_website")(), getattr(collection, "website")()]
367 elif hasattr(collection, site) and getattr(collection, site)(): 367 ↛ 368line 367 didn't jump to line 368 because the condition on line 367 was never true
368 urls = [getattr(collection, site)()]
369 return urls
372class SuggestDeployView(EditorRequiredMixin, View):
373 def post(self, request, *args, **kwargs):
374 doi = kwargs.get("doi", "")
375 site = kwargs.get("site", "test_website")
376 article = get_object_or_404(Article, doi=doi)
378 obj, created = RelatedArticles.objects.get_or_create(resource=article)
379 form = RelatedForm(request.POST or None, instance=obj)
380 if form.is_valid(): 380 ↛ 397line 380 didn't jump to line 397 because the condition on line 380 was always true
381 data = form.cleaned_data
382 obj.date_modified = timezone.now()
383 form.save()
384 collection = article.my_container.my_collection
385 urls = get_server_urls(collection, site=site)
386 response = requests.models.Response()
387 for url in urls: 387 ↛ 395line 387 didn't jump to line 395 because the loop on line 387 didn't complete
388 url = url + reverse("api-update-suggest", kwargs={"doi": doi})
389 try:
390 response = requests.post(url, data=data, timeout=15)
391 except requests.exceptions.RequestException as e:
392 response.status_code = 503
393 response.reason = e.args[0]
394 break
395 return HttpResponse(status=response.status_code, reason=response.reason)
396 else:
397 return HttpResponseBadRequest()
400def suggest_debug(results, article, message):
401 crop_results = 5
402 if results: 402 ↛ 403line 402 didn't jump to line 403 because the condition on line 402 was never true
403 dois = []
404 results["docs"] = results["docs"][:crop_results]
405 numFound = f'({len(results["docs"])} sur {results["numFound"]} documents)'
406 head = f"Résultats de la recherche automatique {numFound} :\n\n"
407 for item in results["docs"]:
408 doi = item.get("doi")
409 if doi:
410 explain = results["explain"][item["id"]]
411 terms = re.findall(r"([0-9.]+?) = weight\((.+?:.+?) in", explain)
412 terms.sort(key=lambda t: t[0], reverse=True)
413 details = (" + ").join(f"{round(float(s), 1)}:{t}" for s, t in terms)
414 score = f'Score : {round(float(item["score"]), 1)} (= {details})\n'
415 url = ""
416 suggest = Article.objects.filter(doi=doi).first()
417 if suggest and suggest.my_container:
418 collection = suggest.my_container.my_collection
419 base_url = collection.website() or ""
420 url = base_url + "/articles/" + doi
421 dois.append((doi, url, score))
423 tail = f'\n\nScore minimum retenu : {results["params"]["min_score"]}\n\n\n'
424 tail += "Termes principaux utilisés pour la requête "
425 tail = [tail + "(champ:terme recherché | pertinence du terme) :\n"]
426 if results["params"]["mlt.fl"] == "all":
427 tail.append(" * all = body + abstract + title + authors + keywords\n")
428 terms = results["interestingTerms"]
429 terms = [" | ".join((x[0], str(x[1]))) for x in zip(terms[::2], terms[1::2])]
430 tail.extend(reversed(terms))
431 tail.append("\n\nParamètres de la requête :\n")
432 tail.extend([f"{k}: {v} " for k, v in results["params"].items()])
433 return [(head, dois, "\n".join(tail))]
434 else:
435 msg = f'Erreur {message["status"]} {message["err"]} at {message["url"]}'
436 return [(msg, [], "")]
439class SuggestUpdateView(EditorRequiredMixin, TemplateView):
440 template_name = "editorial_tools/suggested.html"
442 def get_context_data(self, **kwargs):
443 doi = kwargs.get("doi", "")
444 article = get_object_or_404(Article, doi=doi)
446 obj, created = RelatedArticles.objects.get_or_create(resource=article)
447 collection = article.my_container.my_collection
448 base_url = collection.website() or ""
449 response = requests.models.Response()
450 try:
451 response = requests.get(base_url + "/mlt/" + doi, timeout=10.0)
452 except requests.exceptions.RequestException as e:
453 response.status_code = 503
454 response.reason = e.args[0]
455 msg = {
456 "url": response.url,
457 "status": response.status_code,
458 "err": response.reason,
459 }
460 results = None
461 if response.status_code == 200: 461 ↛ 462line 461 didn't jump to line 462 because the condition on line 461 was never true
462 results = solr_cmds.auto_suggest_doi(obj, article, response.json())
463 context = super().get_context_data(**kwargs)
464 context["debug"] = suggest_debug(results, article, msg)
465 context["form"] = RelatedForm(instance=obj)
466 context["author"] = "; ".join(get_names(article, "author"))
467 context["citation_base"] = article.get_citation_base().strip(", .")
468 context["article"] = article
469 context["date_modified"] = obj.date_modified
470 context["url"] = base_url + "/articles/" + doi
471 return context
474class EditorialToolsVolumeItemsView(EditorRequiredMixin, TemplateView):
475 template_name = "editorial_tools/volume-items.html"
477 def get_context_data(self, **kwargs):
478 vid = kwargs.get("vid")
479 site_name = settings.SITE_NAME if hasattr(settings, "SITE_NAME") else ""
480 is_cr = len(site_name) == 6 and site_name[0:2] == "cr"
481 issues_articles, collection = model_helpers.get_issues_in_volume(vid, is_cr)
482 context = super().get_context_data(**kwargs)
483 context["issues_articles"] = issues_articles
484 context["collection"] = collection
485 return context
488class EditorialToolsArticleView(EditorRequiredMixin, TemplateView):
489 template_name = "editorial_tools/find-article.html"
491 def get_context_data(self, **kwargs):
492 colid = kwargs.get("colid")
493 doi = kwargs.get("doi")
494 article = get_object_or_404(Article, doi=doi, my_container__my_collection__pid=colid)
496 context = super().get_context_data(**kwargs)
497 context["article"] = article
498 context["citation_base"] = article.get_citation_base().strip(", .")
499 return context
502class GraphicalAbstractUpdateView(EditorRequiredMixin, TemplateView):
503 template_name = "editorial_tools/graphical-abstract.html"
505 def get_context_data(self, **kwargs):
506 doi = kwargs.get("doi", "")
507 article = get_object_or_404(Article, doi=doi)
509 obj, created = GraphicalAbstract.objects.get_or_create(resource=article)
510 context = super().get_context_data(**kwargs)
511 context["author"] = "; ".join(get_names(article, "author"))
512 context["citation_base"] = article.get_citation_base().strip(", .")
513 context["article"] = article
514 context["date_modified"] = obj.date_modified
515 context["form"] = GraphicalAbstractForm(instance=obj)
516 context["graphical_abstract"] = obj.graphical_abstract
517 context["illustration"] = obj.illustration
518 return context
521class GraphicalAbstractDeployView(EditorRequiredMixin, View):
522 def post(self, request, *args, **kwargs):
523 doi = kwargs.get("doi", "")
524 site = kwargs.get("site", "both")
525 article = get_object_or_404(Article, doi=doi)
527 obj, created = GraphicalAbstract.objects.get_or_create(resource=article)
528 form = GraphicalAbstractForm(request.POST, request.FILES or None, instance=obj)
529 if form.is_valid(): 529 ↛ 556line 529 didn't jump to line 556 because the condition on line 529 was always true
530 obj.date_modified = timezone.now()
531 data = {"date_modified": obj.date_modified}
532 form.save()
533 files = {}
534 if obj.graphical_abstract and os.path.exists(obj.graphical_abstract.path): 534 ↛ 535line 534 didn't jump to line 535 because the condition on line 534 was never true
535 with open(obj.graphical_abstract.path, "rb") as fp:
536 files.update({"graphical_abstract": (obj.graphical_abstract.name, fp.read())})
537 if obj.illustration and os.path.exists(obj.illustration.path): 537 ↛ 538line 537 didn't jump to line 538 because the condition on line 537 was never true
538 with open(obj.illustration.path, "rb") as fp:
539 files.update({"illustration": (obj.illustration.name, fp.read())})
540 collection = article.my_container.my_collection
541 urls = get_server_urls(collection, site=site)
542 response = requests.models.Response()
543 for url in urls: 543 ↛ 554line 543 didn't jump to line 554 because the loop on line 543 didn't complete
544 url = url + reverse("api-graphical-abstract", kwargs={"doi": doi})
545 try:
546 if not obj.graphical_abstract and not obj.illustration: 546 ↛ 549line 546 didn't jump to line 549 because the condition on line 546 was always true
547 response = requests.delete(url, data=data, files=files, timeout=15)
548 else:
549 response = requests.post(url, data=data, files=files, timeout=15)
550 except requests.exceptions.RequestException as e:
551 response.status_code = 503
552 response.reason = e.args[0]
553 break
554 return HttpResponse(status=response.status_code, reason=response.reason)
555 else:
556 return HttpResponseBadRequest()
559def parse_content(content):
560 table = re.search(r'(.*?)(<table id="summary".+?</table>)(.*)', content, re.DOTALL)
561 if not table:
562 return {"head": content, "tail": "", "articles": []}
564 articles = []
565 rows = re.findall(r"<tr>.+?</tr>", table.group(2), re.DOTALL)
566 for row in rows:
567 citation = re.search(r'<div href=".*?">(.*?)</div>', row, re.DOTALL)
568 href = re.search(r'href="(.+?)\/?">', row)
569 doi = re.search(r"(10[.].+)", href.group(1)) if href else ""
570 src = re.search(r'<img.+?src="(.+?)"', row)
571 item = {}
572 item["citation"] = citation.group(1) if citation else ""
573 item["doi"] = doi.group(1) if doi else href.group(1) if href else ""
574 item["src"] = src.group(1) if src else ""
575 item["imageName"] = item["src"].split("/")[-1] if item["src"] else ""
576 if item["doi"] or item["src"]:
577 articles.append(item)
578 return {"head": table.group(1), "tail": table.group(3), "articles": articles}
581class VirtualIssueParseView(EditorRequiredMixin, View):
582 def get(self, request, *args, **kwargs):
583 pid = kwargs.get("pid", "")
584 page = get_object_or_404(Page, id=pid)
586 data = {"pid": pid}
587 data["colid"] = kwargs.get("colid", "")
588 journal = model_helpers.get_collection(data["colid"])
589 data["journal_title"] = journal.title_tex.replace(".", "")
590 site_id = model_helpers.get_site_id(data["colid"])
591 data["page"] = model_to_dict(page)
592 pages = Page.objects.filter(site_id=site_id).exclude(id=pid)
593 data["parents"] = [model_to_dict(p, fields=["id", "menu_title"]) for p in pages]
595 content_fr = parse_content(page.content_fr)
596 data["head_fr"] = content_fr["head"]
597 data["tail_fr"] = content_fr["tail"]
599 content_en = parse_content(page.content_en)
600 data["articles"] = content_en["articles"]
601 data["head_en"] = content_en["head"]
602 data["tail_en"] = content_en["tail"]
603 return JsonResponse(data)
606class VirtualIssueUpdateView(EditorRequiredMixin, TemplateView):
607 template_name = "editorial_tools/virtual-issue.html"
609 def get(self, request, *args, **kwargs):
610 pid = kwargs.get("pid", "")
611 get_object_or_404(Page, id=pid)
612 return super().get(request, *args, **kwargs)
615class VirtualIssueCreateView(EditorRequiredMixin, View):
616 def get(self, request, *args, **kwargs):
617 colid = kwargs.get("colid", "")
618 site_id = model_helpers.get_site_id(colid)
619 parent, _ = Page.objects.get_or_create(
620 mersenne_id=MERSENNE_ID_VIRTUAL_ISSUES,
621 parent_page=None,
622 site_id=site_id,
623 )
624 page = Page.objects.create(
625 menu_title_en="New virtual issue",
626 menu_title_fr="Nouvelle collection transverse",
627 parent_page=parent,
628 site_id=site_id,
629 state="draft",
630 )
631 kwargs = {"colid": colid, "pid": page.id}
632 return HttpResponseRedirect(reverse("virtual_issue_update", kwargs=kwargs))
635class SpecialIssuesIndex(EditorRequiredMixin, TemplateView):
636 template_name = "editorial_tools/special-issues-index.html"
638 def get_context_data(self, **kwargs):
639 colid = kwargs.get("colid", "")
641 context = super().get_context_data(**kwargs)
642 context["colid"] = colid
643 collection = Collection.objects.get(pid=colid)
644 context["special_issues"] = Container.objects.filter(
645 Q(ctype="issue_special") | Q(ctype="issue_special_img")
646 ).filter(my_collection=collection)
648 context["journal"] = model_helpers.get_collection(colid, sites=False)
649 return context
652class SpecialIssueEditView(EditorRequiredMixin, TemplateView):
653 template_name = "editorial_tools/special-issue-edit.html"
655 def get_context_data(self, **kwargs):
656 context = super().get_context_data(**kwargs)
657 return context
660class VirtualIssuesIndex(EditorRequiredMixin, TemplateView):
661 template_name = "editorial_tools/virtual-issues-index.html"
663 def get_context_data(self, **kwargs):
664 colid = kwargs.get("colid", "")
665 site_id = model_helpers.get_site_id(colid)
666 vi = get_object_or_404(Page, mersenne_id=MERSENNE_ID_VIRTUAL_ISSUES)
667 pages = Page.objects.filter(site_id=site_id, parent_page=vi)
668 context = super().get_context_data(**kwargs)
669 context["journal"] = model_helpers.get_collection(colid)
670 context["pages"] = pages
671 return context
674def get_citation_fr(doi, citation_en):
675 citation_fr = citation_en
676 article = Article.objects.filter(doi=doi).first()
677 if article and article.trans_title_html:
678 trans_title = article.trans_title_html
679 try:
680 citation_fr = re.sub(
681 r'(<a href="https:\/\/doi\.org.*">)([^<]+)',
682 rf"\1{trans_title}",
683 citation_en,
684 )
685 except re.error:
686 pass
687 return citation_fr
690def summary_build(articles, colid):
691 summary_fr = ""
692 summary_en = ""
693 head = '<table id="summary"><tbody>'
694 tail = "</tbody></table>"
695 style = "max-width:180px;max-height:200px"
696 colid_lo = colid.lower()
697 site_domain = SITE_REGISTER[colid_lo]["site_domain"].split("/")
698 site_domain = "/" + site_domain[-1] if len(site_domain) == 2 else ""
700 for article in articles:
701 image_src = article.get("src", "")
702 image_name = article.get("imageName", "")
703 doi = article.get("doi", "")
704 citation_en = article.get("citation", "")
705 if doi or citation_en:
706 row_fr = f'<div href="{doi}">{get_citation_fr(doi, citation_en)}</div>'
707 row_en = f'<div href="{doi}">{citation_en}</div>'
708 if image_src:
709 date = datetime.now().strftime("%Y/%m/%d/")
710 base_url = get_media_base_url(colid)
711 suffix = os.path.join(base_url, "uploads", date)
712 image_url = os.path.join(site_domain, suffix, image_name)
713 image_header = "^data:image/.+;base64,"
714 if re.match(image_header, image_src):
715 image_src = re.sub(image_header, "", image_src)
716 base64_data = base64.b64decode(image_src)
717 base_root = get_media_base_root(colid)
718 path = os.path.join(base_root, "uploads", date)
719 os.makedirs(path, exist_ok=True)
720 with open(path + image_name, "wb") as fp:
721 fp.write(base64_data)
722 im = f'<img src="{image_url}" style="{style}" />'
723 # TODO mettre la vrai valeur pour le SITE_DOMAIN
724 elif settings.SITE_DOMAIN == "http://127.0.0.1:8002":
725 im = f'<img src="{image_src}" style="{style}" />'
726 else:
727 im = f'<img src="{site_domain}{image_src}" style="{style}" />'
728 summary_fr += f"<tr><td>{im}</td><td>{row_fr}</td></tr>"
729 summary_en += f"<tr><td>{im}</td><td>{row_en}</td></tr>"
730 summary_fr = head + summary_fr + tail
731 summary_en = head + summary_en + tail
732 return {"summary_fr": summary_fr, "summary_en": summary_en}
735# @method_decorator([csrf_exempt], name="dispatch")
736class VirtualIssueDeployView(HandleCMSMixin, View):
737 """
738 called by the Virtual.vue VueJS component, when the virtual issue is saved
739 We get data in JSON and we need to update the corresponding Page.
740 The Page is then immediately posted to the test_website.
741 The "Apply the changes to the production website" button is then used to update the (prod) website
742 => See DeployCMSAPIView
743 """
745 def post(self, request, *args, **kwargs):
746 self.init_data(self.kwargs)
748 pid = kwargs.get("pid")
749 colid = self.colid
750 data = json.loads(request.body)
751 summary = summary_build(data["articles"], colid)
752 page = get_object_or_404(Page, id=pid)
753 page.slug = page.slug_fr = page.slug_en = None
754 page.menu_title_fr = data["title_fr"]
755 page.menu_title_en = data["title_en"]
756 page.content_fr = data["head_fr"] + summary["summary_fr"] + data["tail_fr"]
757 page.content_en = data["head_en"] + summary["summary_en"] + data["tail_en"]
758 page.state = data["page"]["state"]
759 page.menu_order = data["page"]["menu_order"]
760 page.parent_page = Page.objects.filter(id=data["page"]["parent_page"]).first()
761 page.save()
763 response = deploy_cms("test_website", self.collection)
764 if response.status_code == 503:
765 messages.error(
766 self.request, "The journal website is under maintenance. Please try again later."
767 )
769 return response # HttpResponse(status=response.status_code, reason=response.reason)
772class SpecialIssueEditAPIView(HandleCMSMixin, TemplateView):
773 template_name = "editorial_tools/special-issue-edit.html"
775 def get_context_data(self, **kwargs):
776 context = super().get_context_data(**kwargs)
777 return context
779 def set_contrib_addresses(self, contrib, contribution):
780 for address in contrib:
781 contrib_address = ContribAddress(contribution=contribution, address=address)
782 contrib_address.save()
784 def delete(self, pid):
785 special_issue = Container.objects.get(pid=pid)
786 cmd = base_ptf_cmds.addContainerPtfCmd()
787 cmd.set_object_to_be_deleted(special_issue)
788 cmd.undo()
790 def get(self, request, *args, **kwargs):
791 pid = kwargs.get("pid", "")
793 data = {"pid": pid}
794 colid = kwargs.get("colid", "")
795 data["colid"] = colid
796 journal = model_helpers.get_collection(colid, sites=False)
797 name = resolve(request.path_info).url_name
798 if name == "special_issue_delete": 798 ↛ 799line 798 didn't jump to line 799 because the condition on line 798 was never true
799 self.delete(pid)
800 return redirect("special_issues_index", data["colid"])
802 data["journal_title"] = journal.title_tex.replace(".", "")
804 if pid != "create":
805 container = get_object_or_404(Container, pid=pid)
806 # TODO: pass the lang and trans_lang as well
807 # In VueJS (Special.vu)e, titleFr = title_html
808 data["title"] = container.trans_title_html
809 data["doi"] = container.doi
810 data["trans_title"] = container.title_html
811 data["year"] = container.year
812 data["volume"] = container.volume
813 data["articles"] = [
814 {"doi": article.resource_doi, "citation": article.citation}
815 for article in container.resources_in_special_issue.all().order_by("seq")
816 ]
817 if container.ctype == "issue_special_img": 817 ↛ 818line 817 didn't jump to line 818 because the condition on line 817 was never true
818 data["use_resources_icon"] = True
819 else:
820 data["use_resources_icon"] = False
822 contribs = model_data_converter.db_to_contributors(container.contributions)
823 data["contribs"] = contribs
824 abstract_set = container.abstract_set.all()
825 data["head_fr"] = (
826 abstract_set.filter(tag="head_fr").first().value_html
827 if abstract_set.filter(tag="head_fr").exists()
828 else ""
829 )
830 data["head_en"] = (
831 abstract_set.filter(tag="head_en").first().value_html
832 if abstract_set.filter(tag="head_en").exists()
833 else ""
834 )
835 data["tail_fr"] = (
836 abstract_set.filter(tag="tail_fr").first().value_html
837 if abstract_set.filter(tag="tail_fr").exists()
838 else ""
839 )
840 data["tail_en"] = (
841 abstract_set.filter(tag="tail_en").first().value_html
842 if abstract_set.filter(tag="tail_en").exists()
843 else ""
844 )
845 data["editor_bio_en"] = (
846 abstract_set.filter(tag="bio_en").first().value_html
847 if abstract_set.filter(tag="bio_en").exists()
848 else ""
849 )
850 data["editor_bio_fr"] = (
851 abstract_set.filter(tag="bio_fr").first().value_html
852 if abstract_set.filter(tag="bio_fr").exists()
853 else ""
854 )
856 streams = container.datastream_set.all()
857 data["pdf_file_name"] = ""
858 data["edito_file_name"] = ""
859 data["edito_display_name"] = ""
860 for stream in streams: # don't work 860 ↛ 861line 860 didn't jump to line 861 because the loop on line 860 never started
861 if os.path.basename(stream.location).split(".")[0] == data["pid"]:
862 data["pdf_file_name"] = stream.text
863 try:
864 # edito related objects metadata contains both file real name and displayed name in issue summary
865 edito_name_infos = container.relatedobject_set.get(rel="edito").metadata.split(
866 "$$$"
867 )
868 data["edito_file_name"] = edito_name_infos[0]
869 data["edito_display_name"] = edito_name_infos[1]
871 except RelatedObject.DoesNotExist:
872 pass
873 try:
874 container_icon = container.extlink_set.get(rel="icon")
876 data["icon_location"] = container_icon.location
877 except ExtLink.DoesNotExist:
878 data["icon_location"] = ""
879 # try:
880 # special_issue_icon = container.extlink_set.get(rel="icon")
881 # data["special_issue_icon"] = special_issue_icon.location
882 # except ExtLink.DoesNotExist:
883 # data["special_issue_icon"] = None
885 else:
886 data["title"] = ""
887 data["doi"] = None
888 data["trans_title"] = ""
889 data["year"] = ""
890 data["volume"] = ""
891 data["articles"] = []
892 data["contribs"] = []
894 data["head_fr"] = ""
895 data["head_en"] = ""
896 data["tail_fr"] = ""
897 data["tail_en"] = ""
898 data["editor_bio_en"] = ""
899 data["editor_bio_fr"] = ""
900 data["pdf_file_name"] = ""
901 data["edito_file_name"] = ""
902 data["use_resources_icon"] = False
904 return JsonResponse(data)
906 def post(self, request, *args, **kwargs):
907 # le but est de faire un IssueDAta
908 pid = kwargs.get("pid", "")
909 colid = kwargs.get("colid", "")
910 journal = collection = model_helpers.get_collection(colid, sites=False)
911 special_issue = IssueData()
912 year = request.POST["year"]
913 # TODO 1: the values should be the tex values, not the html ones
914 # TODO 2: In VueJS, titleFr = title
915 trans_title_html = request.POST["title"]
916 title_html = request.POST["trans_title"]
917 if pid != "create":
918 # TODO: do not use the pk, but the pid in the URLs
919 container = get_object_or_404(Container, pid=pid)
920 lang = container.lang
921 trans_lang = container.trans_lang
922 xpub = create_publisherdata()
923 xpub.name = container.my_publisher.pid
924 special_issue.provider = container.provider
925 special_issue.number = container.number
926 volume = container.volume
927 special_issue_pid = pid
928 special_issue.date_pre_published = container.date_pre_published
929 special_issue.date_published = container.date_published
930 # used for first special issues created withou a proper doi
931 # can be remove when no doi's less special issue existe
932 if not container.doi: 932 ↛ 933line 932 didn't jump to line 933 because the condition on line 932 was never true
933 special_issue.doi = model_helpers.assign_container_doi(colid)
934 else:
935 special_issue.doi = container.doi
936 else:
937 lang = "en"
938 container = None
939 trans_lang = "fr"
940 xpub = create_publisherdata()
941 special_issue.doi = model_helpers.assign_container_doi(colid)
942 volume = ""
943 issues = collection.content.all().order_by("-year")
944 # if cras_issues.exists():
945 same_year_issues = issues.filter(year=int(year))
946 if same_year_issues.exists(): 946 ↛ 948line 946 didn't jump to line 948 because the condition on line 946 was always true
947 volume = same_year_issues.first().volume
948 elif (
949 issues.exists() and colid != "HOUCHES"
950 ): # because we don't want a volume for houches
951 volume = str(int(issues.first().volume) + 1)
952 else:
953 volume = ""
954 # issues = model_helpers.get_volumes_in_collection(collection, get_special_issues=True)
955 # if issues["sorted_issues"]:
956 # volumes = issues["sorted_issues"][0]["volumes"]
957 # for v in volumes:
958 # if v["fyear"] == int(year):
959 # volume = v["volume"]
960 # break
962 if colid == "HOUCHES": 962 ↛ 963line 962 didn't jump to line 963 because the condition on line 962 was never true
963 xpub.name = "UGA Éditions"
964 else:
965 xpub.name = issues.first().my_publisher.pid
966 # xpub.name = parent_container.my_publisher.pid
967 special_issue.provider = collection.provider
969 special_issues = issues.filter(year=year).filter(
970 Q(ctype="issue_special") | Q(ctype="issue") | Q(ctype="issue_special_img")
971 )
972 if special_issues: 972 ↛ 982line 972 didn't jump to line 982 because the condition on line 972 was always true
973 all_special_issues_numbers = [
974 int(si.number[1:]) for si in special_issues if si.number[1:].isnumeric()
975 ]
976 if len(all_special_issues_numbers) > 0:
977 max_number = max(all_special_issues_numbers)
978 else:
979 max_number = 0
981 else:
982 max_number = 0
983 special_issue.number = f"S{max_number + 1}"
984 special_issue_pid = f"{colid}_{year}__{volume}_{special_issue.number}"
985 if request.POST["use_resources_icon"] == "true": 985 ↛ 986line 985 didn't jump to line 986 because the condition on line 985 was never true
986 special_issue.ctype = "issue_special_img"
987 else:
988 special_issue.ctype = "issue_special"
989 title_xml = get_issue_title_xml(title_html, lang, trans_title_html, trans_lang)
991 existing_issue = model_helpers.get_resource(special_issue_pid)
992 if pid == "create" and existing_issue is not None: 992 ↛ 993line 992 didn't jump to line 993 because the condition on line 992 was never true
993 raise ValueError(f"The special issue with the pid {special_issue_pid} already exists")
995 special_issue.lang = lang
996 special_issue.trans_lang = trans_lang
997 special_issue.year = year
998 special_issue.volume = volume
999 special_issue.title_html = title_html
1000 special_issue.trans_title_html = trans_title_html
1001 special_issue.title_xml = title_xml
1002 special_issue.journal = journal
1004 special_issue.publisher = xpub
1005 special_issue.pid = special_issue_pid
1006 special_issue.last_modified_iso_8601_date_str = datetime.now().strftime(
1007 "%Y-%m-%d %H:%M:%S"
1008 )
1010 articles = []
1011 contribs = []
1012 index = 0
1014 if "nb_articles" in request.POST.keys():
1015 while index < int(request.POST["nb_articles"]):
1016 article = json.loads(request.POST[f"article[{index}]"])
1017 article["citation"] = xml_utils.replace_html_entities(article["citation"])
1018 # article["citation"] = xml_utils.escape(article["citation"])
1019 articles.append(article)
1021 index += 1
1023 special_issue.articles = [Munch(article) for article in articles]
1024 index = 0
1025 # TODO make a function to call to add a contributor
1026 if "nb_contrib" in request.POST.keys():
1027 while index < int(request.POST["nb_contrib"]):
1028 contrib = json.loads(request.POST[f"contrib[{index}]"])
1029 contributor = create_contributor()
1030 contributor["first_name"] = contrib["first_name"]
1031 contributor["last_name"] = contrib["last_name"]
1032 contributor["orcid"] = contrib["orcid"]
1033 contributor["role"] = "editor"
1035 contrib_xml = xml_utils.get_contrib_xml(contrib)
1036 contributor["contrib_xml"] = contrib_xml
1037 contribs.append(Munch(contributor))
1038 index += 1
1039 special_issue.contributors = contribs
1041 # Part of the code that handle forwords and lastwords
1043 xhead_fr, head_fr_xml = self.create_abstract_from_vuejs(
1044 request.POST["head_fr"], "fr", "intro", colid, special_issue_pid
1045 )
1046 xtail_fr, tail_fr_xml = self.create_abstract_from_vuejs(
1047 request.POST["tail_fr"], "fr", "tail", colid, special_issue_pid
1048 )
1049 xhead_en, head_en_xml = self.create_abstract_from_vuejs(
1050 request.POST["head_en"], "en", "intro", colid, special_issue_pid
1051 )
1053 xtail_en, tail_en_xml = self.create_abstract_from_vuejs(
1054 request.POST["tail_en"], "en", "tail", colid, special_issue_pid
1055 )
1057 xeditor_bio_en, editor_bio_en_xml = self.create_abstract_from_vuejs(
1058 request.POST["editor_bio_en"], "en", "bio_en", colid, special_issue_pid
1059 )
1061 xeditor_bio_fr, editor_bio_fr_xml = self.create_abstract_from_vuejs(
1062 request.POST["editor_bio_fr"], "fr", "bio_fr", colid, special_issue_pid
1063 )
1065 abstracts = [
1066 head_fr_xml,
1067 head_en_xml,
1068 tail_fr_xml,
1069 tail_en_xml,
1070 editor_bio_fr_xml,
1071 editor_bio_en_xml,
1072 ]
1073 figures = self.create_related_objects_from_abstract(abstracts, colid, special_issue.pid)
1074 special_issue.related_objects = figures
1075 # TODO can be factorized?
1076 special_issue.abstracts = [
1077 {
1078 "tag": "head_fr",
1079 "lang": "fr",
1080 "value_html": xhead_fr.value_html,
1081 "value_tex": xhead_fr.value_tex,
1082 "value_xml": head_fr_xml,
1083 },
1084 {
1085 "tag": "head_en",
1086 "lang": "en",
1087 "value_html": xhead_en.value_html,
1088 "value_tex": xhead_en.value_tex,
1089 "value_xml": head_en_xml,
1090 },
1091 {
1092 "tag": "tail_fr",
1093 "lang": "fr",
1094 "value_html": xtail_fr.value_html,
1095 "value_tex": xtail_fr.value_tex,
1096 "value_xml": tail_fr_xml,
1097 },
1098 {
1099 "tag": "tail_en",
1100 "lang": "en",
1101 "value_html": xtail_en.value_html,
1102 "value_tex": xtail_en.value_tex,
1103 "value_xml": tail_en_xml,
1104 },
1105 {
1106 "tag": "bio_en",
1107 "lang": "en",
1108 "value_html": xeditor_bio_en.value_html,
1109 "value_tex": xeditor_bio_en.value_tex,
1110 "value_xml": editor_bio_en_xml,
1111 },
1112 {
1113 "tag": "bio_fr",
1114 "lang": "fr",
1115 "value_html": xeditor_bio_fr.value_html,
1116 "value_tex": xeditor_bio_fr.value_tex,
1117 "value_xml": editor_bio_fr_xml,
1118 },
1119 ]
1121 # This part handle pdf files included in special issue. Can be editor of full pdf version
1122 # Both are stored in same directory
1124 pdf_file_path = resolver.get_disk_location(
1125 f"{settings.RESOURCES_ROOT}",
1126 f"{collection.pid}",
1127 "pdf",
1128 special_issue_pid,
1129 article_id=None,
1130 do_create_folder=False,
1131 )
1132 pdf_path = os.path.dirname(pdf_file_path)
1133 if "pdf" in self.request.FILES: 1133 ↛ 1134line 1133 didn't jump to line 1134 because the condition on line 1133 was never true
1134 if os.path.isfile(f"{pdf_path}/{pid}.pdf"):
1135 os.remove(f"{pdf_path}/{pid}.pdf")
1136 if "edito" in self.request.FILES: 1136 ↛ 1137line 1136 didn't jump to line 1137 because the condition on line 1136 was never true
1137 if os.path.isfile(f"{pdf_path}/{pid}_edito.pdf"):
1138 os.remove(f"{pdf_path}/{pid}_edito.pdf")
1140 if request.POST["pdf_name"] != "No file uploaded": 1140 ↛ 1141line 1140 didn't jump to line 1141 because the condition on line 1140 was never true
1141 if "pdf" in self.request.FILES:
1142 pdf_file_name = self.request.FILES["pdf"].name
1143 location = pdf_path + "/" + special_issue_pid + ".pdf"
1144 with open(location, "wb+") as destination:
1145 for chunk in self.request.FILES["pdf"].chunks():
1146 destination.write(chunk)
1148 else:
1149 pdf_file_name = request.POST["pdf_name"]
1150 location = pdf_path + "/" + special_issue_pid + ".pdf"
1152 pdf_stream_data = create_datastream()
1153 pdf_stream_data["location"] = location.replace("/mersenne_test_data/", "")
1154 pdf_stream_data["mimetype"] = "application/pdf"
1155 pdf_stream_data["rel"] = "full-text"
1156 pdf_stream_data["text"] = pdf_file_name
1157 special_issue.streams.append(pdf_stream_data)
1159 if request.POST["edito_name"] != "No file uploaded": 1159 ↛ 1160line 1159 didn't jump to line 1160 because the condition on line 1159 was never true
1160 if "edito" in self.request.FILES:
1161 location = pdf_path + "/" + special_issue_pid + "_edito.pdf"
1162 edito_file_name = self.request.FILES["edito"].name
1163 edito_display_name = request.POST["edito_display_name"]
1164 with open(location, "wb+") as destination:
1165 for chunk in self.request.FILES["edito"].chunks():
1166 destination.write(chunk)
1167 else:
1168 location = pdf_path + "/" + special_issue_pid + "_edito.pdf"
1169 edito_file_name = request.POST["edito_name"]
1170 edito_display_name = request.POST["edito_display_name"]
1172 data = {
1173 "rel": "edito",
1174 "mimetype": "application/pdf",
1175 "location": location,
1176 "base": None,
1177 "metadata": edito_file_name + "$$$" + edito_display_name,
1178 }
1179 special_issue.related_objects.append(data)
1180 # Handle special issue icon. It is stored in same directory that pdf version or edito.
1181 # The icon is linked to special issue as an ExtLink
1182 if "icon" in request.FILES: 1182 ↛ 1183line 1182 didn't jump to line 1183 because the condition on line 1182 was never true
1183 icon_file = request.FILES["icon"]
1184 relative_file_name = resolver.copy_file_obj_to_article_folder(
1185 icon_file,
1186 collection.pid,
1187 special_issue.pid,
1188 special_issue.pid,
1189 )
1190 data = {
1191 "rel": "icon",
1192 "location": relative_file_name,
1193 "base": None,
1194 "seq": 1,
1195 "metadata": "",
1196 }
1197 special_issue.ext_links.append(data)
1198 elif "icon" in request.POST.keys(): 1198 ↛ 1199line 1198 didn't jump to line 1199 because the condition on line 1198 was never true
1199 if request.POST["icon"] != "[object Object]":
1200 icon_file = request.POST["icon"].replace("/icon/", "")
1201 data = {
1202 "rel": "icon",
1203 "location": icon_file,
1204 "base": None,
1205 "seq": 1,
1206 "metadata": "",
1207 }
1208 special_issue.ext_links.append(data)
1210 special_issue = Munch(special_issue.__dict__)
1211 params = {"xissue": special_issue, "use_body": False}
1212 cmd = xml_cmds.addOrUpdateIssueXmlCmd(params)
1213 cmd.do()
1214 # tail_fr_html = xml_utils.replace_html_entities(request.POST["tail_fr"])
1215 # tail_en_html = xml_utils.replace_html_entities(request.POST["tail_en"])
1216 return redirect("special_issue_edit_api", colid, special_issue.pid)
1218 def create_abstract_from_vuejs(self, abstract, lang, position, colid, pid):
1219 abstract_html = xml_utils.replace_html_entities(abstract)
1220 xabstract = CkeditorParser(
1221 html_value=abstract_html, issue_pid=colid, pid=pid, mml_formulas=[]
1222 )
1223 abstract_xml = jats_from_abstract(lang, lang, xabstract, position)
1224 return xabstract, abstract_xml
1226 def create_related_objects_from_abstract(self, abstracts, colid, pid):
1227 figures = []
1228 for abstract in abstracts:
1229 abstract_xml = abstract.encode("utf8")
1231 tree = etree.fromstring(abstract_xml)
1233 pics = tree.xpath("//graphic")
1234 for pic in pics: 1234 ↛ 1235line 1234 didn't jump to line 1235 because the loop on line 1234 never started
1235 pic_location = pic.attrib["specific-use"]
1236 basename = os.path.basename(pic.attrib["href"])
1237 ext = basename.split(".")[-1]
1238 base = get_media_base_root(colid)
1239 data_location = os.path.join(
1240 settings.RESOURCES_ROOT, "media", base, "uploads", pic_location, basename
1241 )
1242 # we use related objects to send pics to journal site. Directory where pic is stored in trammel may differ
1243 # from the directory in journal site. So one need to save the pic in same directory that journal's one
1244 # so related objects can go for the correct one
1245 img = Image.open(data_location)
1246 final_data_location = os.path.join(
1247 settings.RESOURCES_ROOT, colid, pid, "src", "figures"
1248 )
1249 if not os.path.isdir(final_data_location):
1250 os.makedirs(final_data_location)
1251 relative_path = os.path.join(colid, pid, "src", "figures", basename)
1252 final_data_location = f"{final_data_location}/{basename}"
1253 img.save(final_data_location)
1254 if ext == "png":
1255 mimetype = "image/png"
1256 else:
1257 mimetype = "image/jpeg"
1258 data = {
1259 "rel": "html-image",
1260 "mimetype": mimetype,
1261 "location": relative_path,
1262 "base": None,
1263 "metadata": "",
1264 }
1265 if data not in figures:
1266 figures.append(data)
1267 return figures
1270class PageIndexView(EditorRequiredMixin, TemplateView):
1271 template_name = "mersenne_cms/page_index.html"
1273 def get_context_data(self, **kwargs):
1274 colid = kwargs.get("colid", "")
1275 site_id = model_helpers.get_site_id(colid)
1276 vi = Page.objects.filter(site_id=site_id, mersenne_id=MERSENNE_ID_VIRTUAL_ISSUES).first()
1277 if vi: 1277 ↛ 1278line 1277 didn't jump to line 1278 because the condition on line 1277 was never true
1278 pages = Page.objects.filter(site_id=site_id).exclude(parent_page=vi)
1279 else:
1280 pages = Page.objects.filter(site_id=site_id)
1281 context = super().get_context_data(**kwargs)
1282 context["colid"] = colid
1283 context["journal"] = model_helpers.get_collection(colid)
1284 context["pages"] = pages
1285 context["news"] = News.objects.filter(site_id=site_id)
1286 context["fields_lang"] = "fr" if model_helpers.is_site_fr_only(site_id) else "en"
1287 return context
1290class PageBaseView(HandleCMSMixin, View):
1291 template_name = "mersenne_cms/page_form.html"
1292 model = Page
1293 form_class = PageForm
1295 def dispatch(self, request, *args, **kwargs):
1296 self.colid = self.kwargs["colid"]
1297 self.collection = model_helpers.get_collection(self.colid, sites=False)
1298 self.site_id = model_helpers.get_site_id(self.colid)
1300 return super().dispatch(request, *args, **kwargs)
1302 def get_success_url(self):
1303 return reverse("page_index", kwargs={"colid": self.colid})
1305 def get_context_data(self, **kwargs):
1306 context = super().get_context_data(**kwargs)
1307 context["journal"] = self.collection
1308 return context
1310 def update_test_website(self):
1311 response = deploy_cms("test_website", self.collection)
1312 if response.status_code < 300: 1312 ↛ 1315line 1312 didn't jump to line 1315 because the condition on line 1312 was always true
1313 messages.success(self.request, "The test website has been updated")
1314 else:
1315 text = "ERROR: Unable to update the test website<br/>"
1317 if response.status_code == 503:
1318 text += "The test website is under maintenance. Please try again later.<br/>"
1319 else:
1320 text += f"Please contact the centre Mersenne<br/><br/>Status code: {response.status_code}<br/>"
1321 if hasattr(response, "content") and response.content:
1322 text += f"{response.content.decode()}<br/>"
1323 if hasattr(response, "reason") and response.reason:
1324 text += f"Reason: {response.reason}<br/>"
1325 if hasattr(response, "text") and response.text:
1326 text += f"Details: {response.text}<br/>"
1327 messages.error(self.request, mark_safe(text))
1329 def get_form_kwargs(self):
1330 kwargs = super().get_form_kwargs()
1331 kwargs["site_id"] = self.site_id
1332 kwargs["user"] = self.request.user
1333 return kwargs
1335 def form_valid(self, form):
1336 form.save()
1338 self.update_test_website()
1340 return HttpResponseRedirect(self.get_success_url())
1343# @method_decorator([csrf_exempt], name="dispatch")
1344class PageDeleteView(PageBaseView):
1345 def post(self, request, *args, **kwargs):
1346 colid = kwargs.get("colid", "")
1347 pk = kwargs.get("pk")
1348 page = get_object_or_404(Page, id=pk)
1349 if page.mersenne_id:
1350 raise PermissionDenied
1352 page.delete()
1354 self.update_test_website()
1356 if page.parent_page and page.parent_page.mersenne_id == MERSENNE_ID_VIRTUAL_ISSUES:
1357 return HttpResponseRedirect(reverse("virtual_issues_index", kwargs={"colid": colid}))
1358 else:
1359 return HttpResponseRedirect(reverse("page_index", kwargs={"colid": colid}))
1362class PageCreateView(PageBaseView, CreateView):
1363 def get_context_data(self, **kwargs):
1364 context = super().get_context_data(**kwargs)
1365 context["title"] = "Add a menu page"
1366 return context
1369class PageUpdateView(PageBaseView, UpdateView):
1370 def get_context_data(self, **kwargs):
1371 context = super().get_context_data(**kwargs)
1372 context["title"] = "Edit a menu page"
1373 return context
1376class NewsBaseView(PageBaseView):
1377 template_name = "mersenne_cms/news_form.html"
1378 model = News
1379 form_class = NewsForm
1382class NewsDeleteView(NewsBaseView):
1383 def post(self, request, *args, **kwargs):
1384 pk = kwargs.get("pk")
1385 news = get_object_or_404(News, id=pk)
1387 news.delete()
1389 self.update_test_website()
1391 return HttpResponseRedirect(self.get_success_url())
1394class NewsCreateView(NewsBaseView, CreateView):
1395 def get_context_data(self, **kwargs):
1396 context = super().get_context_data(**kwargs)
1397 context["title"] = "Add a News"
1398 return context
1401class NewsUpdateView(NewsBaseView, UpdateView):
1402 def get_context_data(self, **kwargs):
1403 context = super().get_context_data(**kwargs)
1404 context["title"] = "Edit a News"
1405 return context
1408# def page_create_view(request, colid):
1409# context = {}
1410# if not is_authorized_editor(request.user, colid):
1411# raise PermissionDenied
1412# collection = model_helpers.get_collection(colid)
1413# page = Page(site_id=model_helpers.get_site_id(colid))
1414# form = PageForm(request.POST or None, instance=page)
1415# if form.is_valid():
1416# form.save()
1417# response = deploy_cms("test_website", collection)
1418# if response.status_code < 300:
1419# messages.success(request, "Page created successfully.")
1420# else:
1421# text = f"ERROR: page creation failed<br/>Status code: {response.status_code}<br/>"
1422# if hasattr(response, "reason") and response.reason:
1423# text += f"Reason: {response.reason}<br/>"
1424# if hasattr(response, "text") and response.text:
1425# text += f"Details: {response.text}<br/>"
1426# messages.error(request, mark_safe(text))
1427# kwargs = {"colid": colid, "pid": form.instance.id}
1428# return HttpResponseRedirect(reverse("page_update", kwargs=kwargs))
1429#
1430# context["form"] = form
1431# context["title"] = "Add a menu page"
1432# context["journal"] = collection
1433# return render(request, "mersenne_cms/page_form.html", context)
1436# def page_update_view(request, colid, pid):
1437# context = {}
1438# if not is_authorized_editor(request.user, colid):
1439# raise PermissionDenied
1440#
1441# collection = model_helpers.get_collection(colid)
1442# page = get_object_or_404(Page, id=pid)
1443# form = PageForm(request.POST or None, instance=page)
1444# if form.is_valid():
1445# form.save()
1446# response = deploy_cms("test_website", collection)
1447# if response.status_code < 300:
1448# messages.success(request, "Page updated successfully.")
1449# else:
1450# text = f"ERROR: page update failed<br/>Status code: {response.status_code}<br/>"
1451# if hasattr(response, "reason") and response.reason:
1452# text += f"Reason: {response.reason}<br/>"
1453# if hasattr(response, "text") and response.text:
1454# text += f"Details: {response.text}<br/>"
1455# messages.error(request, mark_safe(text))
1456# kwargs = {"colid": colid, "pid": form.instance.id}
1457# return HttpResponseRedirect(reverse("page_update", kwargs=kwargs))
1458#
1459# context["form"] = form
1460# context["pid"] = pid
1461# context["title"] = "Edit a menu page"
1462# context["journal"] = collection
1463# return render(request, "mersenne_cms/page_form.html", context)