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