def publish_content(db_object, versioned, is_major_update=True):
"""
Publish a given content.
.. note::
create a manifest.json without the introduction and conclusion if not needed. Also remove the 'text' field
of extracts.
:param db_object: Database representation of the content
:type db_object: PublishableContent
:param versioned: version of the content to publish
:type versioned: VersionedContent
:param is_major_update: if set to `True`, will update the publication date
:type is_major_update: bool
:raise FailureDuringPublication: if something goes wrong
:return: the published representation
:rtype: zds.tutorialv2.models.database.PublishedContent
"""
from zds.tutorialv2.models.database import PublishedContent
if is_major_update:
versioned.pubdate = datetime.now()
# First write the files in a temporary directory: if anything goes wrong,
# the last published version is not impacted !
tmp_path = os.path.join(settings.ZDS_APP['content']['repo_public_path'],
versioned.slug + '__building')
if os.path.exists(tmp_path):
shutil.rmtree(tmp_path) # erase previous attempt, if any
# render HTML:
altered_version = copy.deepcopy(versioned)
publish_container(db_object, tmp_path, altered_version)
altered_version.dump_json(os.path.join(tmp_path, 'manifest.json'))
# make room for 'extra contents'
extra_contents_path = os.path.join(
tmp_path, settings.ZDS_APP['content']['extra_contents_dirname'])
os.makedirs(extra_contents_path)
base_name = os.path.join(extra_contents_path, versioned.slug)
# 1. markdown file (base for the others) :
# If we come from a command line, we need to activate i18n, to have the date in the french language.
cur_language = translation.get_language()
versioned.pubdate = datetime.now()
try:
translation.activate(settings.LANGUAGE_CODE)
parsed = render_to_string('tutorialv2/export/content.md',
{'content': versioned})
finally:
translation.activate(cur_language)
parsed_with_local_images = retrieve_and_update_images_links(
parsed, directory=extra_contents_path)
md_file_path = base_name + '.md'
md_file = codecs.open(md_file_path, 'w', encoding='utf-8')
try:
md_file.write(parsed_with_local_images)
except (UnicodeError, UnicodeEncodeError):
raise FailureDuringPublication(
_('Une erreur est survenue durant la génération du fichier markdown '
'à télécharger, vérifiez le code markdown'))
finally:
md_file.close()
pandoc_debug_str = ''
if settings.PANDOC_LOG_STATE:
pandoc_debug_str = ' 2>&1 | tee -a ' + settings.PANDOC_LOG
if settings.ZDS_APP['content'][
'extra_content_generation_policy'] == 'SYNC':
# ok, now we can really publish the thing !
generate_exernal_content(base_name, extra_contents_path, md_file_path,
pandoc_debug_str)
elif settings.ZDS_APP['content'][
'extra_content_generation_policy'] == 'WATCHDOG':
PublicatorRegistery.get('watchdog').publish(md_file_path,
base_name,
silently_pass=False)
is_update = False
if db_object.public_version:
public_version = db_object.public_version
is_update = True
# the content have been published in the past, so clean old files !
old_path = public_version.get_prod_path()
shutil.rmtree(old_path)
# if the slug change, instead of using the same object, a new one will be created
if versioned.slug != public_version.content_public_slug:
public_version.must_redirect = True # set redirection
publication_date = public_version.publication_date
public_version.save()
db_object.public_version = PublishedContent()
public_version = db_object.public_version
# if content have already been published, keep publication date !
public_version.publication_date = publication_date
else:
public_version = PublishedContent()
# make the new public version
public_version.content_public_slug = versioned.slug
public_version.content_type = versioned.type
public_version.content_pk = db_object.pk
public_version.content = db_object
public_version.must_reindex = True
public_version.save()
public_version.char_count = public_version.get_char_count(md_file_path)
for author in db_object.authors.all():
public_version.authors.add(author)
public_version.save()
# move the stuffs into the good position
if settings.ZDS_APP['content'][
'extra_content_generation_policy'] != 'WATCHDOG':
shutil.move(tmp_path, public_version.get_prod_path())
else: # if we use watchdog, we use copy to get md and zip file in prod but everything else will be handled by
# watchdog
shutil.copytree(tmp_path, public_version.get_prod_path())
# save public version
if is_major_update or not is_update:
public_version.publication_date = datetime.now()
elif is_update:
public_version.update_date = datetime.now()
public_version.sha_public = versioned.current_version
public_version.save()
try:
make_zip_file(public_version)
except OSError:
pass
return public_version
def publish_content(db_object, versioned, is_major_update=True):
"""
Publish a given content.
.. note::
create a manifest.json without the introduction and conclusion if not needed. Also remove the 'text' field
of extracts.
:param db_object: Database representation of the content
:type db_object: zds.tutorialv2.models.database.PublishableContent
:param versioned: version of the content to publish
:type versioned: zds.tutorialv2.models.versioned.VersionedContent
:param is_major_update: if set to `True`, will update the publication date
:type is_major_update: bool
:raise FailureDuringPublication: if something goes wrong
:return: the published representation
:rtype: zds.tutorialv2.models.database.PublishedContent
"""
from zds.tutorialv2.models.database import PublishedContent
if is_major_update:
versioned.pubdate = datetime.now()
# First write the files to a temporary directory: if anything goes wrong,
# the last published version is not impacted !
tmp_path = path.join(settings.ZDS_APP["content"]["repo_public_path"], versioned.slug + "__building")
if path.exists(tmp_path):
shutil.rmtree(tmp_path) # remove previous attempt, if any
# render HTML:
altered_version = copy.deepcopy(versioned)
publish_container(db_object, tmp_path, altered_version)
altered_version.dump_json(path.join(tmp_path, "manifest.json"))
# make room for 'extra contents'
build_extra_contents_path = path.join(tmp_path, settings.ZDS_APP["content"]["extra_contents_dirname"])
makedirs(build_extra_contents_path)
base_name = path.join(build_extra_contents_path, versioned.slug)
# 1. markdown file (base for the others) :
# If we come from a command line, we need to activate i18n, to have the date in the french language.
cur_language = translation.get_language()
altered_version.pubdate = datetime.now()
md_file_path = base_name + ".md"
with contextlib.suppress(OSError):
Path(Path(md_file_path).parent, "images").mkdir()
is_update = False
if db_object.public_version:
is_update, public_version = update_existing_publication(db_object, versioned)
else:
public_version = PublishedContent()
# make the new public version
public_version.content_public_slug = versioned.slug
public_version.content_type = versioned.type
public_version.content_pk = db_object.pk
public_version.content = db_object
public_version.must_reindex = True
public_version.save()
with contextlib.suppress(FileExistsError):
makedirs(public_version.get_extra_contents_directory())
PublicatorRegistry.get("md").publish(md_file_path, base_name, versioned=versioned, cur_language=cur_language)
public_version.char_count = public_version.get_char_count(md_file_path)
if is_major_update or not is_update:
public_version.publication_date = datetime.now()
elif is_update:
public_version.update_date = datetime.now()
public_version.sha_public = versioned.current_version
public_version.save()
with contextlib.suppress(OSError):
make_zip_file(public_version)
public_version.save(update_fields=["char_count", "publication_date", "update_date", "sha_public"])
public_version.authors.clear()
for author in db_object.authors.all():
public_version.authors.add(author)
# this puts the manifest.json and base json file on the prod path.
shutil.rmtree(public_version.get_prod_path(), ignore_errors=True)
shutil.copytree(tmp_path, public_version.get_prod_path())
if settings.ZDS_APP["content"]["extra_content_generation_policy"] == "SYNC":
# ok, now we can really publish the thing!
generate_external_content(base_name, build_extra_contents_path, md_file_path)
elif settings.ZDS_APP["content"]["extra_content_generation_policy"] == "WATCHDOG":
PublicatorRegistry.get("watchdog").publish(md_file_path, base_name, silently_pass=False)
db_object.sha_public = versioned.current_version
return public_version
def publish_content(db_object, versioned, is_major_update=True):
"""
Publish a given content.
.. note::
create a manifest.json without the introduction and conclusion if not needed. Also remove the 'text' field
of extracts.
:param db_object: Database representation of the content
:type db_object: zds.tutorialv2.models.database.PublishableContent
:param versioned: version of the content to publish
:type versioned: zds.tutorialv2.models.versioned.VersionedContent
:param is_major_update: if set to `True`, will update the publication date
:type is_major_update: bool
:raise FailureDuringPublication: if something goes wrong
:return: the published representation
:rtype: zds.tutorialv2.models.database.PublishedContent
"""
from zds.tutorialv2.models.database import PublishedContent
if is_major_update:
versioned.pubdate = datetime.now()
# First write the files to a temporary directory: if anything goes wrong,
# the last published version is not impacted !
tmp_path = path.join(settings.ZDS_APP['content']['repo_public_path'], versioned.slug + '__building')
if path.exists(tmp_path):
shutil.rmtree(tmp_path) # remove previous attempt, if any
# render HTML:
altered_version = copy.deepcopy(versioned)
publish_container(db_object, tmp_path, altered_version)
altered_version.dump_json(path.join(tmp_path, 'manifest.json'))
# make room for 'extra contents'
build_extra_contents_path = path.join(tmp_path, settings.ZDS_APP['content']['extra_contents_dirname'])
makedirs(build_extra_contents_path)
base_name = path.join(build_extra_contents_path, versioned.slug)
# 1. markdown file (base for the others) :
# If we come from a command line, we need to activate i18n, to have the date in the french language.
cur_language = translation.get_language()
altered_version.pubdate = datetime.now()
md_file_path = base_name + '.md'
with contextlib.suppress(OSError):
Path(Path(md_file_path).parent, 'images').mkdir()
is_update = False
if db_object.public_version:
is_update, public_version = update_existing_publication(db_object, versioned)
else:
public_version = PublishedContent()
# make the new public version
public_version.content_public_slug = versioned.slug
public_version.content_type = versioned.type
public_version.content_pk = db_object.pk
public_version.content = db_object
public_version.must_reindex = True
public_version.save()
with contextlib.suppress(FileExistsError):
makedirs(public_version.get_extra_contents_directory())
PublicatorRegistry.get('md').publish(md_file_path, base_name, versioned=versioned, cur_language=cur_language)
public_version.char_count = public_version.get_char_count(md_file_path)
if is_major_update or not is_update:
public_version.publication_date = datetime.now()
elif is_update:
public_version.update_date = datetime.now()
public_version.sha_public = versioned.current_version
public_version.save()
with contextlib.suppress(OSError):
make_zip_file(public_version)
public_version.save(
update_fields=['char_count', 'publication_date', 'update_date', 'sha_public'])
public_version.authors.clear()
for author in db_object.authors.all():
public_version.authors.add(author)
# this puts the manifest.json and base json file on the prod path.
shutil.rmtree(public_version.get_prod_path(), ignore_errors=True)
shutil.copytree(tmp_path, public_version.get_prod_path())
if settings.ZDS_APP['content']['extra_content_generation_policy'] == 'SYNC':
# ok, now we can really publish the thing!
generate_external_content(base_name, build_extra_contents_path, md_file_path)
elif settings.ZDS_APP['content']['extra_content_generation_policy'] == 'WATCHDOG':
PublicatorRegistry.get('watchdog').publish(md_file_path, base_name, silently_pass=False)
db_object.sha_public = versioned.current_version
return public_version