def generate_document(self, template_id, field_data): """Return URL to the generated document - throw exception if not possible.""" # Check user system is allowed to use template. ts = TemplateServer(TEMPLATE_URL) """ templates = ts.get_templates(self._user_system_id) template_dict = {t[1]: t[2] for t in templates} do_pdf_dict = {t[1]: t[3] for t in templates} try: url = template_dict[template_id] do_pdf = do_pdf_dict[template_id] except KeyError: url = None raise RuntimeError( 'Template {0} not available for client.'.format( template_id) ) """ template = ts.get_template(self._user_system_id, template_id) if template is None: raise RuntimeError( "Template {0} not available for client.".format(template_id)) url = template[0] do_pdf = template[1] # Retrieve template from template server. real_url = TEMPLATE_BASE_URL + url file_base, extension = os.path.splitext(url) file_base = file_base.split('/').pop() tmp_name = '/tmp/{0}{1}'.format(template_id, extension) (fn, headers) = urllib.urlretrieve(real_url, tmp_name) # Finally generate document, store in appropriate place and # return URL. # Get plugin. plugin_mapping = PluginMapping.objects.filter( extension=extension.strip('.').upper())[0] plugin = PluginManager.get_plugin(plugin_mapping.plugin) # Get fields from template system fields = ts.get_template_fields(template_id) # Get output file name unique_url = get_unique_token() output_dir = os.path.join(settings.MEDIA_ROOT, 'files') extension = 'pdf' if do_pdf else plugin_mapping.output_type output_file = '.'.join([unique_url, extension]) output_path = os.path.join(output_dir, output_file) # TODO: Validate that fields in call exist in template, etc. output_url = settings.MEDIA_URL + 'files/' + output_file #raise RuntimeError("Not implemented: {0}".format(output_url)) plugin.generate_document(tmp_name, output_path, field_data, do_pdf) # Calculate SHA1 hash of output file sha1 = hashlib.sha1() with open(output_path, 'rb') as f: sha1.update(f.read()) hash = sha1.hexdigest() return (BROKER_BASE_URL + output_url, hash)
def generate_template_image(self, template_id, resolusion, image_type, file_name): """ Return a URL to the generated preview. """ # Check user system is allowed to use template. ts = TemplateServer(TEMPLATE_URL) templates = ts.get_templates(self._user_system_id) template_dict = {t[1]: t[2] for t in templates} do_pdf_dict = {t[1]: t[3] for t in templates} try: url = template_dict[template_id] do_pdf = do_pdf_dict[template_id] except KeyError: url = None raise RuntimeError( 'Template {0} not available for client.'.format(template_id)) # Retrieve template from template server. real_url = TEMPLATE_BASE_URL + url file_base, extension = os.path.splitext(url) file_base = file_base.split('/').pop() tmp_name = '/tmp/{0}{1}'.format(template_id, extension) (fn, headers) = urllib.urlretrieve(real_url, tmp_name) # Finally generate document, store in appropriate place and # return URL. # Get plugin. plugin_mapping = PluginMapping.objects.filter( extension=extension.strip('.').upper())[0] plugin = PluginManager.get_plugin(plugin_mapping.plugin) # Get fields from template system fields = ts.get_template_fields(template_id) # Get output file name unique_url = get_unique_token() output_dir = os.path.join(settings.MEDIA_ROOT, 'files') extension = ".png" output_file = file_name[:file_name.rfind('.')] + "_" + image_type output_file += extension output_path = os.path.join(output_dir, output_file) # TODO: Validate that fields in call exist in template, etc. output_url = settings.MEDIA_URL + 'files/' + output_file print "generate_template_image IS RUN" plugin.generate_template_image(tmp_name, output_path, resolusion, image_type, fields) # Calculate SHA1 hash of output file sha1 = hashlib.sha1() with open(output_path, 'rb') as f: sha1.update(f.read()) hash = sha1.hexdigest() return (BROKER_BASE_URL + output_url, hash)
def generate_fo_template(self, template_id, fo_file): """ Return a URL to the generated preview. """ # Check user system is allowed to use template. ts = TemplateServer(TEMPLATE_URL) templates = ts.get_templates(self._user_system_id) template_dict = {t[1]: t[2] for t in templates} do_pdf_dict = {t[1]: t[3] for t in templates} print "TEMPLATE_ID: " + template_id print "TEMPLATES: " + str(template_dict) try: url = template_dict[template_id] do_pdf = do_pdf_dict[template_id] except KeyError: url = None raise RuntimeError( 'Template {0} not available for client.'.format(template_id)) # Retrieve template from template server. real_url = TEMPLATE_BASE_URL + url file_base, extension = os.path.splitext(url) file_base = file_base.split('/').pop() tmp_name = '/tmp/{0}{1}'.format(template_id, extension) (fn, headers) = urllib.urlretrieve(real_url, tmp_name) # Get plugin. plugin_mapping = PluginMapping.objects.filter( extension=extension.strip('.').upper())[0] plugin = PluginManager.get_plugin(plugin_mapping.plugin) # Get output file name unique_url = get_unique_token() output_dir = os.path.join(settings.MEDIA_ROOT, 'files') extension = "fo" output_file = '.'.join([unique_url, extension]) output_path = os.path.join(output_dir, output_file) output_url = settings.MEDIA_URL + 'files/' + output_file plugin.generate_xsl_fo_ghost_document(tmp_name, output_path) # Calculate SHA1 hash of output file sha1 = hashlib.sha1() with open(output_path, 'rb') as f: sha1.update(f.read()) hash = sha1.hexdigest() return (BROKER_BASE_URL + output_url, hash)
def save(self, *args, **kwargs): fo_file_path = "" bs = BrokerServer(document_broker_settings.BROKER_URL) set_broker_server(bs) # Before save if self.file != self._old_file: self.version = self.version + 1 """ We check if template contains HTML input fields. """ file_contents = self.file.read() if not "#[HTML]" in file_contents: """ Couldn't make the commit keyword work on the save method. pre_save= super(Template, self).save(commit=False, *args, **kwargs) Except: save() got an unexpected keyword argument 'commit' This is a dirty way to find the next file: """ found = True i = 0 while found: """ We traverse the files with this name and set the fo output file to be the next one in the row. """ wo_ext = str(self.file.name) wo_ext = wo_ext[:str(self.file.name).rfind(".")] ext = str(self.file.name)[str(self.file.name).rfind("."):] if i == 0: file_name = "files/" file_name += wo_ext else: file_name += wo_ext file_name += "_" + str(i) try: the_file = os.path.join( settings.MEDIA_ROOT, file_name + ext ) with open(the_file, 'r') as f: file_name = "files/" found = True except Exception as e: fo_file_path = file_name + ".fo" found = False i += 1 self.precompiled_file = fo_file_path plugin_mappings = bs.get_plugin_mappings() # Actual save super(Template, self).save(*args, **kwargs) # After save - extract field if file changed. if self.file != self._old_file: # Get plugin name from mapping (_, extension) = os.path.splitext(self.file.path) extension = extension.strip('.').upper() db = DocumentBroker(document_broker_settings.BROKER_URL) plugin_mappings = db.get_plugin_mappings() plugin = PluginManager.get_plugin(plugin_mappings[extension]) fields = plugin.extract_document_fields(str(self.file.path)) existing_fields = Field.objects.filter(document=self) for name, content_type in fields: if name not in [f.name for f in existing_fields]: """ We set the default input type to be text. """ input_type = "TEXT" """ We check if the field take HTML input and declare the input type alike. """ if len(name) > 7: if name[:6] == "[HTML]": input_type = "HTML" self.precompiled_file = None Field.objects.create( name=name, type=input_type, content_type="string", document=self)