def test_watchdog(self): PublicatorRegistry.unregister('pdf') PublicatorRegistry.unregister('printable-pdf') PublicatorRegistry.unregister('epub') PublicatorRegistry.unregister('html') with open('path', 'w') as f: f.write('my_content;/path/to/markdown.md') @PublicatorRegistry.register('test', '', '') class TestPublicator(Publicator): def __init__(self, *__): pass PublicatorRegistry.get('test').publish = Mock() event = FileCreatedEvent('path') handler = TutorialIsPublished() handler.prepare_generation = Mock() handler.finish_generation = Mock() handler.on_created(event) self.assertTrue(PublicatorRegistry.get('test').publish.called) handler.finish_generation.assert_called_with('/path/to', 'path') handler.prepare_generation.assert_called_with('/path/to') os.remove('path')
def test_watchdog(self): PublicatorRegistry.unregister('pdf') PublicatorRegistry.unregister('printable-pdf') PublicatorRegistry.unregister('epub') PublicatorRegistry.unregister('html') with open('path', 'w') as f: f.write('my_content;/path/to/markdown.md') @PublicatorRegistry.register('test', '', '') class TestPublicator(Publicator): def __init__(self, *__): pass PublicatorRegistry.get('test').publish = Mock() event = FileCreatedEvent('path') handler = TutorialIsPublished() handler.prepare_generation = Mock() handler.finish_generation = Mock() handler.on_created(event) self.assertTrue(PublicatorRegistry.get('test').publish.called) handler.finish_generation.assert_called_with('/path/to', 'path') handler.prepare_generation.assert_called_with('/path/to') os.remove('path')
def handle(self, *args, **options): try: ids = list(set(options.get('id')[0].replace('id=', '').split(','))) except IndexError: ids = [] if len(ids) > 0: public_contents = PublishedContent.objects.filter( content_pk__in=ids, must_redirect=False).all() else: public_contents = PublishedContent.objects.filter( must_redirect=False).all() num_of_contents = len(public_contents) if num_of_contents == 0: self.stdout.write( _("Aucun contenu n'a été sélectionné, aucun PDF ne sera généré" )) return self.stdout.write( _('Génération de epub pour {} contenu {}').format( num_of_contents, 's' if num_of_contents > 1 else '')) for content in public_contents: with contextlib.suppress(NotAPublicVersion, FailureDuringPublication): self.stdout.write(_('- {}').format( content.content_public_slug), ending='') extra_content_dir = content.get_extra_contents_directory() building_extra_content_path = Path( str(Path(extra_content_dir).parent) + '__building', 'extra_contents', content.content_public_slug) if not building_extra_content_path.exists(): building_extra_content_path.mkdir(parents=True) base_name = os.path.join(str(extra_content_dir), content.content_public_slug) # delete previous one if os.path.exists(base_name + '.epub'): os.remove(base_name + '.epub') PublicatorRegistry.get('epub').publish( base_name + '.md', str(building_extra_content_path)) # check: if os.path.exists(base_name + '.epub'): self.stdout.write(' [OK]') else: self.stdout.write(' [ERREUR]') os.chdir(settings.BASE_DIR)
def post(self, request, *args, **kwargs): try: publishable_content = self.get_object() if not publishable_content.public_version: raise Http404("Not public content") self.ensure_directories(publishable_content) PublicatorRegistry.get("watchdog").publish_from_published_content( publishable_content.public_version) except ValueError: return Response({}, status=status.HTTP_400_BAD_REQUEST, headers={}) else: return Response({}, status=status.HTTP_201_CREATED, headers={})
def handle(self, *__, **options): try: ids = list(set(options.get("id")[0].replace("id=", "").split(","))) except IndexError: ids = [] if len(ids) > 0: public_contents = PublishedContent.objects.filter( content_pk__in=ids, must_redirect=False).all() else: public_contents = PublishedContent.objects.filter( must_redirect=False).all() num_of_contents = len(public_contents) if num_of_contents == 0: self.stdout.write( _("Aucun contenu n'a été sélectionné, aucun markdown ne sera généré" )) return self.stdout.write( _("Génération de epub pour {} contenu {}").format( num_of_contents, "s" if num_of_contents > 1 else "")) for content in public_contents: with contextlib.suppress(NotAPublicVersion, FailureDuringPublication): self.stdout.write(_("- {}").format( content.content_public_slug), ending="") extra_content_dir = content.get_extra_contents_directory() building_extra_content_path = Path( str(Path(extra_content_dir).parent) + "__building", "extra_contents", content.content_public_slug) if not building_extra_content_path.exists(): building_extra_content_path.mkdir(parents=True) base_name = str( Path(str(extra_content_dir), content.content_public_slug)) PublicatorRegistry.get("md").publish( base_name + ".md", str(building_extra_content_path), cur_language=translation.get_language(), versioned=content.content.load_version(public=True), ) # check: if Path(base_name + ".md").exists(): self.stdout.write(" [OK]") else: self.stdout.write(" [ERREUR]")
def handle(self, *args, **options): try: ids = list(set(options.get("id")[0].replace("id=", "").split(","))) except IndexError: ids = [] if len(ids) > 0: public_contents = PublishedContent.objects.filter( content_pk__in=ids, must_redirect=False).all() else: public_contents = PublishedContent.objects.filter( must_redirect=False).all() num_of_contents = len(public_contents) if num_of_contents == 0: self.stdout.write( _("Aucun contenu n'a été sélectionné, aucun PDF ne sera généré" )) return self.stdout.write( _("Génération de PDF pour {} contenu{}").format( num_of_contents, "s" if num_of_contents > 1 else "")) for content in public_contents: with contextlib.suppress(NotAPublicVersion): self.stdout.write(_("- {}").format( content.content_public_slug), ending="") extra_content_dir = content.get_extra_contents_directory() building_extra_content_path = Path( str(Path(extra_content_dir).parent) + "__building", "extra_contents", content.content_public_slug) if not building_extra_content_path.exists(): building_extra_content_path.mkdir(parents=True) base_name = os.path.join(extra_content_dir, content.content_public_slug) # delete previous one if os.path.exists(base_name + ".pdf"): os.remove(base_name + ".pdf") PublicatorRegistry.get("pdf").publish( base_name + ".md", str(building_extra_content_path)) # check: if os.path.exists(base_name + ".pdf"): self.stdout.write(" [OK]") else: self.stdout.write(" [ERREUR]") os.chdir(settings.BASE_DIR)
def run(self): requested_events = PublicationEvent.objects.select_related( "published_object", "published_object__content", "published_object__content__image").filter( state_of_processing="REQUESTED") for publication_event in requested_events.iterator(): content = publication_event.published_object extra_content_dir = content.get_extra_contents_directory() building_extra_content_path = Path( str(Path(extra_content_dir).parent) + "__building", "extra_contents", content.content_public_slug) if not building_extra_content_path.exists(): building_extra_content_path.mkdir(parents=True) base_name = str(building_extra_content_path) md_file_path = base_name + ".md" logger.info("Exporting « %s » as %s", content.title(), publication_event.format_requested) publication_event.state_of_processing = "RUNNING" publication_event.save() publicator = PublicatorRegistry.get( publication_event.format_requested) try: publicator.publish(md_file_path, base_name) except FailureDuringPublication: logger.error("Failed to export « %s » as %s", content.title(), publication_event.format_requested) publication_event.state_of_processing = "FAILURE" else: logger.info("Succeed to export « %s » as %s", content.title(), publication_event.format_requested) publication_event.state_of_processing = "SUCCESS" publication_event.save()
def setUp(self): self.mas = ProfileFactory().user self.overridden_zds_app["member"]["bot_account"] = self.mas.username self.licence = LicenceFactory() self.user_author = ProfileFactory().user self.staff = StaffProfileFactory().user self.tuto = PublishableContentFactory(type="TUTORIAL") self.tuto.authors.add(self.user_author) UserGalleryFactory(gallery=self.tuto.gallery, user=self.user_author, mode="W") self.tuto.licence = self.licence self.tuto.save() self.tuto_draft = self.tuto.load_version() self.part1 = ContainerFactory(parent=self.tuto_draft, db_object=self.tuto) self.chapter1 = ContainerFactory(parent=self.part1, db_object=self.tuto) self.old_registry = {key: value for key, value in PublicatorRegistry.get_all_registered()} class TestPdfPublicator(Publicator): def publish(self, md_file_path, base_name, **kwargs): with Path(base_name + ".pdf").open("w") as f: f.write("bla") shutil.copy2(str(Path(base_name + ".pdf")), str(Path(md_file_path.replace("__building", "")).parent)) PublicatorRegistry.registry["pdf"] = TestPdfPublicator()
def launch_publicators(executor): query_set = PublicationEvent.objects.select_related('published_object', 'published_object__content', 'published_object__content__image') \ .filter(state_of_processing='REQUESTED') for publication_event in query_set.iterator(): logger.info('Export %s -- format=%s', publication_event.published_object.title(), publication_event.format_requested) content = publication_event.published_object publicator = PublicatorRegistry.get( publication_event.format_requested) extra_content_dir = content.get_extra_contents_directory() building_extra_content_path = Path( str(Path(extra_content_dir).parent) + '__building', 'extra_contents', content.content_public_slug) if not building_extra_content_path.exists(): building_extra_content_path.mkdir(parents=True) base_name = str(building_extra_content_path) md_file_path = base_name + '.md' publication_event.state_of_processing = 'RUNNING' publication_event.save() future = executor.submit(publicator.publish, md_file_path, base_name) future.add_done_callback( Command.get_callback_of(publication_event))
def setUp(self): self.mas = ProfileFactory().user self.overridden_zds_app['member']['bot_account'] = self.mas.username self.licence = LicenceFactory() self.user_author = ProfileFactory().user self.staff = StaffProfileFactory().user self.tuto = PublishableContentFactory(type='TUTORIAL') self.tuto.authors.add(self.user_author) UserGalleryFactory(gallery=self.tuto.gallery, user=self.user_author, mode='W') self.tuto.licence = self.licence self.tuto.save() self.tuto_draft = self.tuto.load_version() self.part1 = ContainerFactory(parent=self.tuto_draft, db_object=self.tuto) self.chapter1 = ContainerFactory(parent=self.part1, db_object=self.tuto) self.old_registry = {key: value for key, value in PublicatorRegistry.get_all_registered()} class TestPdfPublicator(Publicator): def publish(self, md_file_path, base_name, **kwargs): with Path(base_name + '.pdf').open('w') as f: f.write('bla') shutil.copy2(str(Path(base_name + '.pdf')), str(Path(md_file_path.replace('__building', '')).parent)) PublicatorRegistry.registry['pdf'] = TestPdfPublicator()
def run(self): requested_events = PublicationEvent.objects.select_related('published_object', 'published_object__content', 'published_object__content__image') \ .filter(state_of_processing='REQUESTED') for publication_event in requested_events.iterator(): content = publication_event.published_object extra_content_dir = content.get_extra_contents_directory() building_extra_content_path = Path( str(Path(extra_content_dir).parent) + '__building', 'extra_contents', content.content_public_slug) if not building_extra_content_path.exists(): building_extra_content_path.mkdir(parents=True) base_name = str(building_extra_content_path) md_file_path = base_name + '.md' logger.info('Exporting « %s » as %s', content.title(), publication_event.format_requested) publication_event.state_of_processing = 'RUNNING' publication_event.save() publicator = PublicatorRegistry.get( publication_event.format_requested) try: publicator.publish(md_file_path, base_name) except FailureDuringPublication: logger.error('Failed to export « %s » as %s', content.title(), publication_event.format_requested) publication_event.state_of_processing = 'FAILURE' else: logger.info('Succeed to export « %s » as %s', content.title(), publication_event.format_requested) publication_event.state_of_processing = 'SUCCESS' publication_event.save()
def handle(self, *args, **options): try: ids = list(set(options.get('id')[0].replace('id=', '').split(','))) except IndexError: ids = [] if len(ids) > 0: public_contents = PublishedContent.objects.filter(content_pk__in=ids, must_redirect=False).all() else: public_contents = PublishedContent.objects.filter(must_redirect=False).all() num_of_contents = len(public_contents) if num_of_contents == 0: self.stdout.write(_("Aucun contenu n'a été sélectionné, aucun PDF ne sera généré")) return self.stdout.write(_('Génération de epub pour {} contenu {}').format( num_of_contents, 's' if num_of_contents > 1 else '')) for content in public_contents: with contextlib.suppress(NotAPublicVersion, FailureDuringPublication): self.stdout.write(_('- {}').format(content.content_public_slug), ending='') extra_content_dir = content.get_extra_contents_directory() building_extra_content_path = Path(str(Path(extra_content_dir).parent) + '__building', 'extra_contents', content.content_public_slug) if not building_extra_content_path.exists(): building_extra_content_path.mkdir(parents=True) base_name = os.path.join(str(extra_content_dir), content.content_public_slug) # delete previous one if os.path.exists(base_name + '.epub'): os.remove(base_name + '.epub') PublicatorRegistry.get('epub').publish(base_name + '.md', str(building_extra_content_path)) # check: if os.path.exists(base_name + '.epub'): self.stdout.write(' [OK]') else: self.stdout.write(' [ERREUR]') os.chdir(settings.BASE_DIR)
def setUp(self): self.licence = LicenceFactory() self.user_author = ProfileFactory().user self.old_registry = { key: value for key, value in PublicatorRegistry.get_all_registered() } self.old_build_pdf_when_published = self.overridden_zds_app["content"][ "build_pdf_when_published"] self.overridden_zds_app["content"]["build_pdf_when_published"] = True
def handle(self, *__, **options): try: ids = list(set(options.get('id')[0].replace('id=', '').split(','))) except IndexError: ids = [] if len(ids) > 0: public_contents = PublishedContent.objects.filter(content_pk__in=ids, must_redirect=False).all() else: public_contents = PublishedContent.objects.filter(must_redirect=False).all() num_of_contents = len(public_contents) if num_of_contents == 0: self.stdout.write(_("Aucun contenu n'a été sélectionné, aucun markdown ne sera généré")) return self.stdout.write(_('Génération de epub pour {} contenu {}').format( num_of_contents, 's' if num_of_contents > 1 else '')) for content in public_contents: with contextlib.suppress(NotAPublicVersion, FailureDuringPublication): self.stdout.write(_('- {}').format(content.content_public_slug), ending='') extra_content_dir = content.get_extra_contents_directory() building_extra_content_path = Path(str(Path(extra_content_dir).parent) + '__building', 'extra_contents', content.content_public_slug) if not building_extra_content_path.exists(): building_extra_content_path.mkdir(parents=True) base_name = str(Path(str(extra_content_dir), content.content_public_slug)) PublicatorRegistry.get('md').publish(base_name + '.md', str(building_extra_content_path), cur_language=translation.get_language(), versioned=content.content.load_version(public=True)) # check: if Path(base_name + '.md').exists(): self.stdout.write(' [OK]') else: self.stdout.write(' [ERREUR]')
def post(self, request, *args, **kwargs): try: publishable_content = self.get_object() if not publishable_content.public_version: raise Http404('Not public content') tmp_dir, _ = self.ensure_directories(publishable_content) versioned = publishable_content.load_version(public=True) base_name = str(Path(tmp_dir, versioned.slug)) md_file_path = str(Path(tmp_dir, versioned.slug + '.md')) PublicatorRegistry.get('md').publish( md_file_path, base_name, versioned=versioned, cur_language=translation.get_language()) PublicatorRegistry.get('watchdog').publish_from_published_content( publishable_content.public_version) except ValueError: return Response({}, status=status.HTTP_400_BAD_REQUEST, headers={}) else: return Response({}, status=status.HTTP_201_CREATED, headers={})
def run(self): requested_events = PublicationEvent.objects.select_related( "published_object", "published_object__content", "published_object__content__image").filter( state_of_processing="REQUESTED") for publication_event in requested_events.iterator(): try: content = publication_event.published_object extra_content_dir = content.get_extra_contents_directory() building_extra_content_path = Path( str(Path(extra_content_dir).parent) + "__building", "extra_contents", content.content_public_slug) if not building_extra_content_path.exists(): building_extra_content_path.mkdir(parents=True) base_name = str(building_extra_content_path) md_file_path = base_name + ".md" logger.info("Exporting « %s » as %s", content.title(), publication_event.format_requested) publication_event.state_of_processing = "RUNNING" publication_event.save() publicator = PublicatorRegistry.get( publication_event.format_requested) publicator.publish(md_file_path, base_name) except: # Update and save the publication state before logging, in case # content.title() would raise an exception (it already used to # happen!). publication_event.state_of_processing = "FAILURE" publication_event.save() logger.exception("Failed to export « %s » as %s", content.title(), publication_event.format_requested) else: publication_event.state_of_processing = "SUCCESS" publication_event.save() logger.info("Succeed to export « %s » as %s", content.title(), publication_event.format_requested)
def test_export_only_ready_to_publish(self): """ Test exported contents contain only ready_to_publish==True parts. """ # We save the current settings for the PDF publicator: previous_pdf_publicator = PublicatorRegistry.get("pdf") previous_build_pdf_when_published = self.overridden_zds_app["content"][ "build_pdf_when_published"] # We need to produce at least the LaTeX file, so we use the real PDF publicator: PublicatorRegistry.registry["pdf"] = ZMarkdownRebberLatexPublicator( ".pdf") self.overridden_zds_app["content"]["build_pdf_when_published"] = True # Medium-size tutorial midsize_tuto = PublishableContentFactory(type="TUTORIAL") midsize_tuto.authors.add(self.user_author) UserGalleryFactory(gallery=midsize_tuto.gallery, user=self.user_author, mode="W") midsize_tuto.licence = self.licence midsize_tuto.save() # populate with 3 chapters (1 extract each), one not being ready for pubication midsize_tuto_draft = midsize_tuto.load_version() chapter1 = ContainerFactory(parent=midsize_tuto_draft, db_object=midsize_tuto, title="Chapter 1 ready") ExtractFactory(container=chapter1, db_object=midsize_tuto) chapter2 = ContainerFactory(parent=midsize_tuto_draft, db_object=midsize_tuto, title="Chapter 2 ready") ExtractFactory(container=chapter2, db_object=midsize_tuto) chapter3 = ContainerFactory(parent=midsize_tuto_draft, db_object=midsize_tuto, title="Chapter 3 not ready") chapter3.ready_to_publish = False ExtractFactory(container=chapter3, db_object=midsize_tuto) # publish it midsize_tuto = PublishableContent.objects.get(pk=midsize_tuto.pk) published = publish_content(midsize_tuto, midsize_tuto_draft) public = midsize_tuto.load_version(sha=published.sha_public, public=published) # test creation of files: self.assertTrue(Path(published.get_prod_path()).is_dir()) self.assertTrue( Path(published.get_prod_path(), "manifest.json").is_file()) self.assertTrue( Path(public.get_prod_path(), public.introduction).is_file()) self.assertTrue( Path(public.get_prod_path(), public.conclusion).is_file()) self.assertEqual(len(public.children), 2) for child in public.children: self.assertTrue(os.path.isfile( child.get_prod_path())) # an HTML file for each chapter self.assertIsNone(child.introduction) self.assertIsNone(child.conclusion) # Test Markdown content: self.assertTrue(published.has_md()) with Path(published.get_extra_contents_directory(), published.content_public_slug + ".md").open("r") as md: content = md.read() self.assertIn(chapter1.title, content) self.assertIn(chapter2.title, content) self.assertNotIn(chapter3.title, content) # TODO: factorize getting the LaTeX file path with what is done in zds.tutorialv2.publication_utils.publish_content() tmp_path = os.path.join( settings.ZDS_APP["content"]["repo_public_path"], published.content_public_slug + "__building") build_extra_contents_path = os.path.join( tmp_path, settings.ZDS_APP["content"]["extra_contents_dirname"]) base_name = os.path.join(build_extra_contents_path, published.content_public_slug) tex_file = base_name + ".tex" # PDF generation may fail, we only test the LaTeX content: with open(tex_file) as tex: content = tex.read() self.assertIn(chapter1.title, content) self.assertIn(chapter2.title, content) self.assertNotIn(chapter3.title, content) # We set back the previous settings: PublicatorRegistry.registry["pdf"] = previous_pdf_publicator self.overridden_zds_app["content"][ "build_pdf_when_published"] = previous_build_pdf_when_published