def run(self, export_info):
self.messenger.show(_("CD generation started..."))
app_dir = self._unzip_app(export_info.cd_name)
if app_dir is None:
return
self.export_data_assembler.export(export_info, self.data_dict['data'])
self.data_dict['pagecontent'] = self._convert_page_content(
export_info.pagecontent)
if export_info.start_image is not None:
self.data_dict['has_start_image'] = True
else:
self.data_dict['has_start_image'] = False
data_dir = os.path.join(app_dir, 'assets')
for runner in self.runners:
runner.run(data_dir, self.data_dict)
self._write_data_js(data_dir)
self._write_start_image(data_dir, export_info.start_image)
if self._generate_iso_image(export_info.cd_name, app_dir):
self.messenger.show(_("CD successfully generated"))
def _generate_iso_image(self, cd_name, app_dir):
self.messenger.show(_("CD generation: Generating iso image..."))
try:
genisoimage = self.config.genisoimage
except NoSuchConfigValue:
self.messenger.show(
_("CD generation: No iso generating program defined. Aborting."
))
return False
iso_file_name = os.path.join(self.config.cdexportdir,
"%s.iso" % cd_name)
try:
if os.path.exists(iso_file_name):
os.unlink(iso_file_name)
except:
self.messenger.show(
_("CD generation: Can't remove already existing iso image. Aborting."
))
return False
stdio = open(os.devnull, 'wb')
call([
genisoimage, "-J", "-joliet-long", "-r", "-f", "-apple", "-o",
iso_file_name, app_dir
],
stdout=stdio,
stderr=stdio)
return True
def attach_to_window(self, parent_window):
'''
Hook method that the window calls when initializing
its plugins
'''
self.parent_window = parent_window
menubar = parent_window.menubar
if not menubar.hasmenu(_('Export')):
menubar.addmenu(_('Export'), '')
menubar.addmenuitem(_('Export'),
'command',
'',
label=_('Export chronology'),
command=self.start_chrono_export)
menubar.addmenuitem(_('Export'),
'command',
'',
label=_('Create CD definition'),
command=self.create_cd_definition)
menubar.addmenuitem(_('Export'),
'command',
'',
label=_('Edit CD definition'),
command=self.edit_cd_definition)
menubar.addmenuitem(_('Export'),
'command',
'',
label=_('Create CD from definition'),
command=self.presenter.create_cd_from_definition)
def __init__(self, window_manager: guiinjectorkeys.WINDOW_MANAGER_KEY,
presenter: CHRONO_DIALOG_PRESENTER_KEY):
self.quarters = ("%s 1" % _('Quarter'), "%s 2" % _('Quarter'),
"%s 3" % _('Quarter'), "%s 4" % _('Quarter'))
self.current_quarter = 1
self.quarter_select = None
self.year_entry = None
super().__init__(window_manager, presenter)
def __init__(self, parent, presenter, systematic_point_dialog,
deletion_dialog):
super().__init__(parent, presenter, _('Systematic'))
self.current_document = None
self.view = None
self.new_systematic_point = None
self.systematic_point_dialog = systematic_point_dialog
self.deletion_dialog = deletion_dialog
self.add_button(Action(_('New'), self._select_a_new_systematic_point))
self.add_button(
Action(_('Delete'), self._delete_selected_systematic_point))
def check_chrono_export(self):
print("Checking exporting chronology works...", end='')
dialog = self.injector.get(CHRONO_DIALOG_KEY)
self.start_dialog(
self.event_window_menubar.get_callback(_('Export'),
_('Export chronology')))
dialog.current_quarter = 3
dialog.year_entry.set('1960')
self.close_dialog(dialog)
print("OK")
def create_dialog(self):
super().create_dialog()
# Wizard page 1
Label(self.pages[0], text=_("Start creating a CD")).pack(padx=5,
pady=5)
Label(self.pages[0], text=_("Enter a name for the CD:")).pack()
self.name_entry = AlexEntry(self.pages[0])
self.name_entry.pack()
# Wizard page 2
Label(self.pages[1], text=_("Start page as markdown:")).pack(padx=5,
pady=5)
self.start_page_entry = AlexText(self.pages[1])
self.start_page_entry.pack()
# Wizard page 3
Label(self.pages[2], text=_("Impressum as markdown:")).pack(padx=5,
pady=5)
self.imprint_entry = AlexText(self.pages[2])
self.imprint_entry.pack()
# Wizard page 4
Label(self.pages[3], text=_("Please enter a data range:")).pack(padx=5,
pady=5)
self.start_date_entry = AlexDateEntry(self.pages[3])
self.start_date_entry.label = _("Enter start date:")
self.start_date_entry.pack()
self.end_date_entry = AlexDateEntry(self.pages[3])
self.end_date_entry.label = _("Enter end date:")
self.end_date_entry.pack()
# Wizard page 5
Label(self.pages[4], text=_("Please select a signature")).pack(padx=5,
pady=5)
self.signature_button = AlexButton(
self.pages[4],
command=lambda: self.signature_dialog.activate(
self._signature_callback, label=_("Select a signature")))
self.signature_button.pack()
# Wizard page 6
Label(self.pages[5],
text=_("Please select a title image")).pack(padx=5, pady=5)
self.start_image_button = AlexButton(
self.pages[5], command=self._get_start_image_file)
self.start_image_button.pack()
def attach_to_window(self, parent_window):
'''
Interface method for plugins.
This is a hackish implementation to place the command before the
last menu item.
'''
# TODO: Show a wait warning while creating the pdf
self.parent_window = parent_window
parent_window.menubar.addmenuitem(_('Records'),
'command',
before=_('Quit'),
label=(_('Show as pdf')),
command=self.presenter.generate_pdf)
def delete_entry_action(self):
deletion_entry = self.view.working_entry
children = self.systematic_service.get_children(deletion_entry.id)
if len(children) != 0:
self.show_message(
_("Systematic entry with children may not be deleted"))
return
if self.systematic_service.next_sibling_exists(deletion_entry.id):
self.show_message(_("Can't delete entry when sibling exists"))
return
if self.systematic_service.systematic_id_is_in_use(deletion_entry.id):
self.show_message(
_("Entry which is in use by documents may not be deleted"))
return
self.systematic_service.delete(deletion_entry)
self.message_broker.send_message(Message(SYSTEMATIC_CHANGED))
def run(self, data_dir, data_dict):
number_of_documents = len(data_dict['data']['documents'])
counter = 0
dir_name = os.path.join(data_dir, 'multimedia')
os.makedirs(dir_name, exist_ok=True)
for document in data_dict['data']['documents']:
counter += 1
percentage = int(counter * 100.0 / number_of_documents)
self.messenger.show(
_("CD generation: Fetching multimedia files... %d%% done.") %
percentage)
for file_info in document.file_infos:
if file_info.filetype != 'mpg' and file_info.filetype != 'mp4':
continue
try:
target_file_name = os.path.join(dir_name,
file_info.get_file_name())
source_file_name = self.document_manager.get_file_path(
file_info)
Path(target_file_name).symlink_to(source_file_name)
except DocumentFileNotFound:
self.logger.warn("Did not find file %s" %
file_info.get_basename())
except Exception as e:
self.logger.error(
"Error on processing file %s. Message: %s." %
(file_info.get_basename(), e))
def run(self, data_dir, data_dict):
number_of_documents = len(data_dict['data']['documents'])
counter = 0
percentage_old = -1
dir_name = os.path.join(data_dir, 'pdf')
os.makedirs(dir_name, exist_ok=True)
for document in data_dict['data']['documents']:
counter += 1
percentage = int(counter * 100.0 / number_of_documents)
if percentage != percentage_old:
self.messenger.show(
_("CD generation: Fetching pdf files... %d%% done.") %
percentage)
percentage_old = percentage
try:
file_info = self.document_manager.document_file_info_dao.get_by_id(
document.id)
target_file_name = os.path.join(
dir_name, "%s.pdf" % file_info.get_basename())
source_file_name = self.document_manager.get_generated_file_path(
file_info, DOCUMENT_PDF)
if not exists(source_file_name):
self.document_service.get_pdf(document)
Path(target_file_name).symlink_to(source_file_name)
except DocumentFileNotFound:
self.logger.warn("Did not find file %s" % document.id)
except Exception as e:
self.logger.error("Error on processing file %s. Message: %s." %
(document.id, e))
def _start_creation(self):
'''
This gets a parent node for a new systematic point
'''
self.systematic_dialog.activate(
self._get_parent_entry_callback,
label=_("Please select parent entry for new entry"))
def run(self, data_dir, data_dict):
number_of_documents = len(data_dict['data']['documents'])
counter = 0
dir_name = os.path.join(data_dir, 'screen')
os.makedirs(dir_name, exist_ok=True)
for document in data_dict['data']['documents']:
counter += 1
percentage = int(counter * 100.0 / number_of_documents)
self.messenger.show(
_("CD generation: Fetching display files... %d%% done.") %
percentage)
for file_info in document.file_infos:
try:
target_file_name = os.path.join(
dir_name, "%s.png" % file_info.get_basename())
source_file_name = self.document_manager.get_generated_file_path(
file_info, DISPLAY_IMAGE)
Path(target_file_name).symlink_to(source_file_name)
if not exists(source_file_name):
self.document_service.get_display_image(file_info)
except DocumentFileNotFound:
self.logger.warn("Did not find file %s" %
file_info.get_basename())
except Exception as e:
self.logger.error(
"Error on processing file %s. Message: %s." %
(file_info.get_basename(), e))
def run(self, data_dir, data_dict):
number_of_documents = len(data_dict['data']['documents'])
counter = 0
percentage_old = -1
dir_name = os.path.join(data_dir, 'pdf')
os.makedirs(dir_name, exist_ok=True)
for document in data_dict['data']['documents']:
counter += 1
percentage = int(counter * 100.0 / number_of_documents)
if percentage != percentage_old:
self.messenger.show(
_("CD generation: Fetching pdf files... %d%% done.") %
percentage)
percentage_old = percentage
try:
file_name = os.path.join(dir_name,
"%s.pdf" % expand_id(document.id))
file = open(file_name, "wb")
file.write(self.document_service.get_pdf(document))
file.close()
except DocumentFileNotFound:
self.logger.warn("Did not find file %s" % document.id)
except Exception as e:
self.logger.error("Error on processing file %s. Message: %s." %
(document.id, e))
def run(self, data_dir, data_dict):
number_of_documents = len(data_dict['data']['documents'])
counter = 0
dir_name = os.path.join(data_dir, 'screen')
os.makedirs(dir_name, exist_ok=True)
for document in data_dict['data']['documents']:
counter += 1
percentage = int(counter * 100.0 / number_of_documents)
self.messenger.show(
_("CD generation: Fetching display files... %d%% done.") %
percentage)
for file_info in document.file_infos:
try:
file_name = os.path.join(
dir_name, "%s.png" % file_info.get_basename())
file = open(file_name, "wb")
file.write(
self.document_service.get_display_image(file_info))
file.close()
except DocumentFileNotFound:
self.logger.warn("Did not find file %s" %
file_info.get_basename())
except Exception as e:
self.logger.error(
"Error on processing file %s. Message: %s." %
(file_info.get_basename(), e))
def _get_edit_entry_callback(self, edit_entry):
if edit_entry is None:
return
self.working_entry = edit_entry
self.string_edit_dialog.activate(
self._change_description,
label=_("Please change description for %s:") % edit_entry,
initvalue=edit_entry.description)
def _get_start_image_file(self):
self.window.attributes('-topmost', False)
new_start_image = askopenfilename(filetypes=[(_("Image file"),
".jpg")])
self.window.attributes('-topmost', True)
if new_start_image:
self.start_image = new_start_image
def test_delete_node_with_sibling(self):
identifier = SystematicIdentifier("1.1", 2, 2)
self.tree.get_by_id(identifier) # Assert entry exists
self.view.working_entry = self.tree.get_by_id(identifier).entity
self.presenter.delete_entry_action()
self.assertEquals(_("Can't delete entry when sibling exists"),
self.received_messages[0].message)
def create_signature_entry(self):
AlexLabel(self.interior, text=_("Signature:")).grid(row=3,
column=0,
sticky=W)
self.signature_widget = AlexButton(self.interior,
command=self._select_signature)
self.signature_widget.set(self.NO_SYSTEMATIC_POINT_SELECTED)
self.signature_widget.grid(row=3, column=1, sticky=W)
def _create_new_entry(self, entry_id):
if entry_id is None:
return
self.new_child_id = self.potential_child_ids[entry_id]
self.presenter.create_new_entry_action()
self.string_edit_dialog.activate(
self._change_description,
label=_("Please enter a description for %s:" % self.new_child_id))
def _unzip_app(self, cd_name):
self.messenger.show(_("CD generation: Unzipping app..."))
app_dir = os.path.join(self.config.cdexportdir, cd_name)
try:
if os.path.exists(app_dir):
shutil.rmtree(app_dir)
os.makedirs(app_dir, exist_ok=True)
except:
self.messenger.show(
_("CD generation: Can't create new cd directory. Aborting."))
return None
zip_ref = zipfile.ZipFile(get_zip_file(), 'r')
zip_ref.extractall(app_dir)
zip_ref.close()
return app_dir
def test_delete_used_entry(self):
identifier = SystematicIdentifier("2")
self.tree.get_by_id(identifier) # Assert entry exists
self.view.working_entry = self.tree.get_by_id(identifier).entity
self.presenter.delete_entry_action()
self.assertEquals(
_("Entry which is in use by documents may not be deleted"),
self.received_messages[0].message)
def test_delete_node_with_children(self):
identifier = SystematicIdentifier("1.1")
self.tree.get_by_id(identifier) # Assert entry exists
self.view.working_entry = self.tree.get_by_id(identifier).entity
self.presenter.delete_entry_action()
self.assertEquals(
_("Systematic entry with children may not be deleted"),
self.received_messages[0].message)
def _write_data_js(self, data_dir):
self.messenger.show(_("CD generation: Writing data..."))
javascript = "var alexandria = %s" % json.dumps(self.data_dict,
cls=AlexEncoder)
filename = os.path.join(data_dir, 'data.js')
file = open(filename, "w")
file.write(javascript)
file.close()
def edit_cd_definition(self):
self.cdd_file = askopenfilename(filetypes=[(_("CD definition file"),
".cdd")])
if self.cdd_file is None:
return
self.presenter.load_cdd_file()
self.export_info_dialog.activate(self.save_export_info_callback,
export_info=self.export_info)
def create_dialog(self):
super().create_dialog()
AlexButton(self.buttons_frame,
text=_("Create chronology"),
command=self.presenter.ok_action).pack(side=LEFT)
AlexButton(self.buttons_frame,
text=_("Cancel"),
command=self.presenter.cancel_action).pack(side=LEFT)
self.quarter_select = AlexRadioGroup(self.interior,
title=_('Quarter'),
choices=self.quarters)
self.quarter_select.pack()
AlexLabel(self.interior, text=_(_("Year"))).pack(side=LEFT,
padx=10,
pady=10)
self.year_entry = AlexEntry(self.interior)
self.year_entry.pack(side=LEFT, padx=10, pady=10)
def save_export_info_callback(self, export_info):
self.export_info = export_info
if export_info is None:
return
self.cdd_file = asksaveasfilename(defaultextension='.cdd',
filetypes=[(_("CD definition file"),
".cdd")])
if self.cdd_file:
self.presenter.save_cdd_file()
def check_create_cd_definition(self):
print("Checking creation of cd defininition...", end="")
wizard = self.injector.get(EXPORT_INFO_WIZARD_KEY)
window_manager = self.injector.get(WINDOW_MANAGER_KEY)
self.wait()
window_manager.run_in_thread(
self.event_window_menubar.get_callback(_('Export'),
_('Create CD definition')))
#self.start_dialog(self.event_window_menubar.get_callback(_('Export'), _('Create CD definition')))
self.wait()
wizard.name_entry.set("TESTCD")
self.wait()
wizard._next_page()
self.wait()
#wizard._next_page()
#wizard._next_page()
#wizard._next_page()
print("OK")
def run(self, data_dir, data_dict):
self.messenger.show(_("CD generation: Sorting documents..."))
documents = data_dict['data']['documents']
documents.sort(key=lambda document: document._id)
for i in range(0, len(documents)):
if i == 0:
documents[i].previous_id = documents[len(documents) - 1]._id
else:
documents[i].previous_id = documents[i - 1]._id
if i == len(documents) - 1:
documents[i].next_id = documents[0]._id
else:
documents[i].next_id = documents[i + 1]._id
def __init__(self):
self.start_date = None
self.end_date = None
self.signature = None
self.event_filters = []
self.document_filters = []
self.additional_event_ids = []
self.additional_document_ids = []
self.excluded_event_ids = []
self.excluded_document_ids = []
self.threshold_date = None
self.iterations = 1
self.cd_name = "AlexandriaCD"
self.pagecontent = {}
self.start_image = None
self.pagecontent['startpage'] = _("""
No startpage defined
====================
""")
self.pagecontent['imprint'] = _("""
No imprint defined
==================
""")
