def setUp(self): ''' define some helper variables here ''' self.portal = self.layer['portal'] self.request = self.layer['request'].clone() alsoProvides(self.request, IPloneintranetAttachmentsLayer) # Docconv: will generate previews for this self.pdf = api.content.create( container=self.portal, type='File', id='test-file', file=NamedBlobFile(data=resource_string( 'ploneintranet.attachments.tests', 'plone.pdf').decode('latin1', 'utf8'), filename=u'plone.pdf'), ) # This will be skipped by docconv: no need for preview generation self.image = api.content.create( container=self.portal, type='Image', id='test-image', image=dummy_image(), ) # We also need a file that contains an image :) # This will be also skipped by docconv self.fileimage = api.content.create( container=self.portal, type='File', id='test-image-file', file=dummy_image(), ) # We finally try with an empty file # This will be also skipped by docconv self.empty = api.content.create( container=self.portal, type='File', id='test-empty', )
def test_get_file(self): # pragma: no cover self.portal.invokeFactory('File', id='file1') self.portal.file1.title = 'File' self.portal.file1.description = u'A file' pdf_file = os.path.join(os.path.dirname(__file__), u'file.pdf') self.portal.file1.file = NamedBlobFile(data=open(pdf_file, 'r').read(), contentType='application/pdf', filename=u'file.pdf') intids = getUtility(IIntIds) file_id = intids.getId(self.portal.file1) self.portal.file1.file = RelationValue(file_id) transaction.commit() response = self.api_session.get(self.portal.file1.absolute_url()) self.assertEqual(response.status_code, 200) self.assertEqual( response.headers.get('Content-Type'), 'application/json', 'When sending a GET request with Content-Type: application/json ' + 'the server should respond with sending back application/json.') self.assertEqual(response.json()['@id'], self.portal.file1.absolute_url())
def movetoPublic(self): path = '/'.join(self.context.getPhysicalPath()) all_brains = api.content.find(portal_type='genweb.organs.file', path=path) results = [] for brain in all_brains: obj = brain.getObject() # Show initial values if getattr(obj, 'visiblefile', False): initial_visible = obj.visiblefile.filename else: initial_visible = 'Empty' if getattr(obj, 'hiddenfile', False): initial_hidden = obj.hiddenfile.filename else: initial_hidden = 'Empty' final_visible = 'Not modified' final_hidden = 'Not modified' if obj.hiddenfile and not obj.visiblefile: initial_visible = 'Empty' initial_hidden = obj.hiddenfile.filename # Move private to public obj.visiblefile = NamedBlobFile( data=obj.hiddenfile.data, contentType=obj.hiddenfile.contentType, filename=obj.hiddenfile.filename) transaction.commit() del obj.hiddenfile final_visible = obj.visiblefile.filename final_hidden = 'Empty (Deleted)' element = { 'original-visiblefile': initial_visible, 'original-hiddenfile': initial_hidden, 'path': obj.absolute_url(), 'final-visiblefile': final_visible, 'final-hiddenfile': final_hidden, } results.append(element) return json.dumps(results, indent=2, sort_keys=True)
def test_getobjsize_file(self): from plone.namedfile.file import NamedBlobFile filename = os.path.join(os.path.dirname(__file__), u'image.jpg') with open(filename, 'rb') as f: file_data = f.read() test_file = NamedBlobFile( data=file_data, filename=filename) primary_field_info = IPrimaryFieldInfo(self.file) primary_field_info.field.set(self.file, test_file) self.file.reindexObject() brains = self.catalog.searchResults(dict( path='/plone/folder/file', )) self.assertEqual( '5.0 KB', brains[0].getObjSize, )
def _addDashboardPODTemplateExportOrganizations(self): """Add the export organizations DashboardPODTemplate in the contacts directory.""" logger.info( "Adding 'Export CSV DashboardPODTemplate' to 'contacts' directory..." ) pod_template_id = 'export-organizations' contacts = self.portal.contacts if pod_template_id in contacts.objectIds(): self._already_migrated() return profile_path = self.ps._getImportContext( self.profile_name)._profile_path odt_path = profile_path + '/../testing/templates/organizations-export.ods' odt_file = open(odt_path, 'rb') odt_binary = odt_file.read() odt_file.close() data = { 'title': 'Export CSV', 'pod_formats': ['ods', 'xls'], 'dashboard_collections': contacts.get('orgs-searches').all_orgs.UID(), 'odt_file': NamedBlobFile( data=odt_binary, contentType='application/vnd.oasis.opendocument.text', # pt.odt_file could be relative (../../other_profile/templates/sample.odt) filename=u'export-organizations.ods'), 'use_objects': True, } podTemplate = api.content.create(id=pod_template_id, type='DashboardPODTemplate', container=contacts, **data) podTemplate.reindexObject() logger.info('Done.')
def testCloneNamedFileBlobsOnCloneModifiers(self): file_fti = DexterityFTI('BlobFile', model_source=""" <model xmlns="http://namespaces.plone.org/supermodel/schema"> <schema> <field name="file" type="plone.namedfile.field.NamedBlobFile"> <title>File</title> <required>True</required> </field> </schema> </model> """) self.portal.portal_types._setObject('BlobFile', file_fti) file1 = createContentInContainer(self.portal, 'BlobFile') file1.file = NamedBlobFile('dummy test data', filename=u'test.txt') modifier = CloneNamedFileBlobs('modifier', 'Modifier') pers_id, pers_load, empty1, empty2 = modifier.getOnCloneModifiers( file1) self.assertTrue(pers_id(file1.file._blob)) self.assertTrue(pers_load(file1.file._blob) is None) self.assertTrue(empty1 == []) self.assertTrue(empty2 == [])
def fixattrs(self, item, obj): for key in item.keys(): if not key.startswith(self.datafield_prefix): continue value = base64.b64decode(item[key]['data']) fieldname = key[len(self.datafield_prefix):] if IBaseObject.providedBy(obj): field = obj.getField(fieldname) if field is None: continue old_value = field.get(obj).data if value != old_value: field.set(obj, value) obj.setFilename(item[key]['filename']) obj.setContentType(item[key]['content_type']) else: # dexterity filename = item[key]['filename'] if fieldname == 'file': wrapped_data = NamedBlobFile(data=value, filename=filename) elif fieldname == 'image': wrapped_data = NamedBlobImage(data=value, filename=filename) setattr(obj, fieldname, wrapped_data)
def printCSV(self, rows, type_info): lines = [] if type_info == 'actividad': HEADER_CSV.extend(['community', 'activity', 'comments', 'documents', 'links', 'media']) elif type_info == 'chats': HEADER_CSV.extend(['chat', 'number of messages']) lines.append(HEADER_CSV) [lines.append(row) for row in rows['rows']] portal = getDestinationFolder(type_info) filename = "%s.csv" % time.strftime("%02d-%02m-%Y") output = StringIO.StringIO() a = csv.writer(output, delimiter=',') a.writerows(lines) data = output.getvalue() tb = transaction.begin() file = NamedBlobFile(data=data, filename=u'{}'.format(filename), contentType='application/csv') obj = createContentInContainer(portal, 'AppFile', id='{}'.format(filename), title='{}'.format(filename), file=file, checkConstraints=False) obj.reindexObject() tb.commit() self.response.setBody('%s' % tb.status, lock=True)
def setUp(self): self.app = self.layer['app'] self.portal = self.layer['portal'] self.testfolder = api.content.create( type='Folder', title=u"Testfolder", container=self.portal) ff = open(os.path.join(os.path.dirname(__file__), TEST_FILENAME), 'r') self.filedata = ff.read() ff.close() self.testfile = api.content.create( type='File', id='test-file', title=u"Test File", file=NamedBlobFile(data=self.filedata, filename=TEST_FILENAME), container=self.testfolder) self.testdoc = api.content.create( type='Document', id='test-doc', title=u"Test Doc", text=u"This is a test doc with no preview generated (yet)", container=self.testfolder)
def test_dexterity_file_get(self): self.portal.invokeFactory('File', id='file') self.portal.file.title = 'My File' self.portal.file.description = u'This is a file' pdf_file = os.path.join(os.path.dirname(__file__), u'file.pdf') fd = open(pdf_file, 'rb') self.portal.file.file = NamedBlobFile(data=fd.read(), contentType='application/pdf', filename=u'file.pdf') fd.close() intids = getUtility(IIntIds) file_id = intids.getId(self.portal.file) self.portal.file.file = RelationValue(file_id) import transaction transaction.commit() response = requests.get(self.portal.file.absolute_url(), headers={'Accept': 'application/json'}, auth=(SITE_OWNER_NAME, SITE_OWNER_PASSWORD)) self.assertEqual(200, response.status_code) self.assertEqual(u'file', response.json().get('id')) self.assertEqual(u'GET', response.json().get('method'))
def revert_to_version(self, version_id, create_version=True, force=False): """Reverts the adapted document to a specific version. We only revert the file field, since we do not wan't to version the metadata on the document. If `create_version` is set to `True`, a new version is created after reverting. """ if not force and not self.is_revert_allowed(): # Avoid plone.protect unnecessarily jumping in self.request.response.setHeader('content-type', 'text/plain') raise Unauthorized() version = self.versioner.retrieve_version(version_id) old_obj = version.object if old_obj.file: # Create a new NamedBlobFile instance instead of using # a reference in order to avoid the version being reverted # to being overwritten later old_file_copy = NamedBlobFile(old_obj.file.data, filename=old_obj.file.filename, contentType=old_obj.file.contentType) self.context.file = old_file_copy else: self.context.file = None if create_version: # let's create a version msg = _(u'Reverted file to version ${version_id}.', mapping=dict(version_id=version_id)) comment = translate(msg, context=self.request) self.versioner.create_version(comment) # event notify( ObjectRevertedToVersion(self.context, version_id, create_version))
def test_dexterity_item_event(self): provideHandler( factory=self.mock_event.mock_handler, adapts=[ IItemZippedEvent, ], ) note = create( Builder("event_note").having( blob=NamedBlobFile(data='NoteNoteNote', filename=u'note.txt'))) # Force the generator to fire, the events live there list( getMultiAdapter((note, self.request), interface=IZipRepresentation).get_files()) self.assertEquals(1, len(self.mock_event.event_history)) self.assertIsInstance(self.mock_event.event_history[0], ItemZippedEvent) self.assertEquals('event_note', self.mock_event.event_history[0].object.id)
def sample_file(self): file_value = NamedBlobFile( data=TestDocumentDefaults.SAMPLE_FILE, contentType='text/plain', filename=u'b\xe4rengraben.txt') return file_value
def test_accepts_normal_files(self): file = NamedBlobFile('bla bla', filename=u'test.txt') validator = UploadValidator(*self.validator_arguments()) validator.validate(file)
def test_upload_file(self): document = create(Builder("document")) field = IDocumentSchema['file'] file = NamedBlobFile('bla bla', filename=u'test.txt') field.set(document, file) self.assertTrue(field.get(document).data == 'bla bla')
def folderupload(self, files, title='', description=''): if not self.doc.isDocument(): return self.doc.setfile(self.doc, files[0]) docfolderId = self.doc.getId() dbfolderId = self.doc.getParentDatabase().id #TODO come configurare diverse cartelle per applicazione o plomino db (da fare sulle singole app)? target = self.context.portal_url.getPortalObject()[ATTACHMENT_FOLDER] with adopt_roles('Manager'): if not dbfolderId in target.keys(): target.invokeFactory("Folder", id=dbfolderId, title=dbfolderId) target = target[dbfolderId] if not docfolderId in target.keys(): target.invokeFactory("Folder", id=docfolderId, title=docfolderId) docFolder = target[docfolderId] for username, roles in self.doc.get_local_roles(): docFolder.manage_setLocalRoles(username, roles) if not isinstance(files, list): files = [files] #se non campo multiplo vuoto la cartella #TODO tenere allineati i files nella cartella con i nomi sul campo di plomino current_files = self.doc.getItem(self.element) cleaned_files = {} if self.multiple: for fName in current_files: if fName in docFolder.keys(): cleaned_files[fName] = current_files[fName] self.doc.setItem(self.element, cleaned_files) #se upload singolo cancello tutti i file presenti collegati al campo else: try: docFolder.manage_delObjects(current_files.keys()) except Exception as error: pass self.doc.removeItem(self.element) namechooser = INameChooser(docFolder) loaded = [] for item in files: if item.filename: content_type = item.headers.get('Content-Type') filename = safe_unicode(item.filename) data = item.read() id_name = '' title = title and title[0] or filename # Get a unique id here id_name = namechooser.chooseName(title, docFolder) # Portal types allowed : File and Image # Since Plone 4.x both types use Blob if content_type in IMAGE_MIMETYPES: portal_type = 'Image' wrapped_data = NamedBlobImage(data=data, filename=filename) else: portal_type = 'File' wrapped_data = NamedBlobFile(data=data, filename=filename) # Create content docFolder.invokeFactory(portal_type, id=id_name, title=title, description=description[0]) newfile = docFolder[id_name] # Set data if portal_type == 'File': if IATFile.providedBy(newfile): newfile.setFile(data, filename=filename) else: newfile.file = wrapped_data elif portal_type == 'Image': if IATImage.providedBy(newfile): newfile.setImage(data, filename=filename) else: newfile.image = wrapped_data # Finalize content creation, reindex it newfile.reindexObject() notify(ObjectModifiedEvent(newfile)) loaded.append(newfile) if loaded: return loaded return False
def with_asset_file(self, filename): self.document.file = NamedBlobFile( assets.load(filename), filename=unicode(filename))
def setup_content_data(self): path = os.path.dirname(__file__) mp3_audio = open(os.path.join(path, 'files', 'file.mp3')).read() ogg_audio = open(os.path.join(path, 'files', 'file.ogg')).read() self.mp3 = NamedBlobFile(mp3_audio, 'audio/mp3', u'file.mp3') self.ogg = NamedBlobFile(ogg_audio, 'audio/ogg', u'file.ogg')
def sample_msg(self): message_value = NamedBlobFile(data=TestMailDefaults.SAMPLE_MAIL, contentType='message/rfc822', filename=u'msg.eml') return message_value
def addPodTemplate(self, container, pt, source): '''Adds a POD template from p_pt (a PodTemplateDescriptor instance).''' cfg = None if container.portal_type == 'MeetingConfig': cfg = container dest_folder = getattr(container, TOOL_FOLDER_POD_TEMPLATES) else: # contacts DashboardPODTemplate dest_folder = container # The template must be retrieved on disk from a profile or use another pod_template odt_file = None pod_template_to_use = None if pt.odt_file: # pt.odt_file may be a full path or a relative path filePath = pt.odt_file.startswith( '/') and pt.odt_file or '%s/templates/%s' % (source, pt.odt_file) data = self.find_binary(filePath) odt_file = NamedBlobFile( data=data, contentType='application/vnd.oasis.opendocument.text', # pt.odt_file could be relative (../../other_profile/templates/sample.odt) filename=safe_unicode(pt.odt_file.split('/')[-1]), ) elif pt.pod_template_to_use['cfg_id']: pod_template_to_use_cfg = self.tool.get( pt.pod_template_to_use['cfg_id']) if not pod_template_to_use_cfg: logger.warning( 'Cfg with id {0} not found when adding Pod template {1}, template was not added' .format(pt.pod_template_to_use['cfg_id'], pt.pod_template_to_use['template_id'])) return pod_template = pod_template_to_use_cfg.podtemplates.get( pt.pod_template_to_use['template_id']) if not pod_template: logger.warning( 'Pod template with id {0} not found in cfg with id {1}, template was not added' .format(pt.pod_template_to_use['template_id'], pt.pod_template_to_use['cfg_id'])) return pod_template_to_use = pod_template.UID() else: raise PloneMeetingError( 'A PodTemplateDescriptor must have a defined odt_file or pod_template_to_use!' ) data = pt.getData(odt_file=odt_file, pod_template_to_use=pod_template_to_use) if data['is_style']: podType = 'StyleTemplate' else: podType = pt.dashboard and 'DashboardPODTemplate' or 'ConfigurablePODTemplate' # turn the pod_portal_types from MeetingItem to MeetingItemShortname adapted_pod_portal_types = [] for pod_portal_type in data['pod_portal_types']: if pod_portal_type.startswith('Meeting'): pod_portal_type = pod_portal_type + cfg.shortName adapted_pod_portal_types.append(pod_portal_type) data['pod_portal_types'] = adapted_pod_portal_types if podType == 'DashboardPODTemplate': # parameter use_objects is excluded by default as only relevant for DashboardPODTemplates data['use_objects'] = pt.use_objects # manage dashboard_collections from dashboard_collection_ids # we have ids and we need UIDs res = [] if cfg: collections_container = cfg.searches else: # contacts collections_container = container for coll_id in pt.dashboard_collections_ids: for folder in collections_container.objectValues( 'ATFolder'): if coll_id in folder.objectIds(): collection = getattr(folder, coll_id) break res.append(collection.UID()) data['dashboard_collections'] = res for sub_template in data['merge_templates']: sub_template['template'] = dest_folder.get( sub_template['template']).UID() # associate style template with pod template if necessary if not data['is_style'] and data['style_template']: # we have a list of style templates styles_uids = [] for style_template in data['style_template']: style_template_obj = dest_folder.get(style_template) if style_template_obj.id in data['style_template']: styles_uids.append(style_template_obj.UID()) data['style_template'] = styles_uids podTemplate = api.content.create(type=podType, container=dest_folder, **data) validate_fields(podTemplate, raise_on_errors=True) return podTemplate
def getDefaultForFieldType(self, field): # default string default_value = self.placeholder # Field Class field_klass = field.__class__.__name__ # Handle different value_type attributes of the field. value_type = getattr(field, 'value_type', None) if value_type: # If we're a data grid field if isinstance(value_type, DictRow): kwargs = {} s = getattr(value_type, 'schema', None) if s: for (_name, _field) in getAllSchemaFieldsAndDescriptions(s): if not isinstance(field, Method): kwargs[_name] = self.getDefaultForFieldType(_field) return [ kwargs, ] elif isinstance(value_type, (schema.TextLine, )): pass elif isinstance(value_type, (schema.Choice, )): vocabulary_name = getattr(value_type, 'vocabularyName', None) vocabulary = getattr(value_type, 'vocabulary', None) if vocabulary_name: vocabulary_factory = getUtility(IVocabularyFactory, vocabulary_name) vocabulary = vocabulary_factory(self.context) if vocabulary: if isinstance(vocabulary, SimpleVocabulary): try: default_value = vocabulary.by_value.keys()[0] except: pass else: pass # Return nothing for methods if field_klass in [ 'Method', ]: return None # Define dummy fields rich_text = RichTextValue(raw='<p>%s</p>' % self.placeholder, mimeType=u'text/html', outputMimeType='text/x-html-safe') named_blob_file = NamedBlobFile(filename=u'sample.pdf', contentType='application/pdf') named_blob_file.data = self.placeholder.encode('utf-8') named_blob_image = NamedBlobImage(filename=u'sample.png', contentType='image/png') named_blob_image.data = self.placeholder.encode('utf-8') # Simple field defaults defaults = { 'Int': 10, 'Text': "\n".join(3 * [self.placeholder]), 'List': [ default_value, ], 'Tuple': (default_value, ), 'TextLine': default_value, 'Bool': True, 'Datetime': datetime.now(), 'RichText': rich_text, 'NamedBlobFile': named_blob_file, 'NamedBlobImage': named_blob_image, 'Choice': default_value, } # If a default, return that. Otherwise, return the placeholder. return defaults.get(field_klass, self.placeholder)
def process(context): video = context.file if not video or video.filename == aws.FILENAME: return try: opened = openBlob(video._blob) bfilepath = opened.name opened.close() except IOError: logger.warn('error opening blob file') return # by default, assume all non-mp4 videos need to be converted # but in reality, all videos need converting, even mp4. # md5 is only what makes this possible convert_it = video.contentType.split('/')[-1] != 'mp4' if md5 is not None: old_hash = getattr(context, '_file_hash', None) current_hash = md5(bfilepath) if old_hash is None or old_hash != current_hash: convert_it = True if context.image and not convert_it: # already an mp4 and already has a screen grab return tmpdir = mkdtemp() tmpfilepath = os.path.join(tmpdir, video.filename) copyfile(bfilepath, tmpfilepath) if convert_it: output_filepath = os.path.join(tmpdir, 'output.mp4') try: avconv.convert(tmpfilepath, output_filepath) except: pass if os.path.exists( output_filepath) and os.path.getsize(output_filepath) > 0: if md5 is not None: try: context._file_hash = md5(output_filepath) except: pass context._p_jar.sync() fi = open(output_filepath) namedblob = NamedBlobFile(fi, filename=switchFileExt( video.filename, 'mp4')) context.file = namedblob fi.close() if not context.image: # try and grab one from video output_filepath = os.path.join(tmpdir, u'screengrab.png') try: avconv.grab_frame(tmpfilepath, output_filepath) if os.path.exists(output_filepath): fi = open(output_filepath) context.image = NamedBlobImage(fi, filename=u'screengrab.png') fi.close() except: logger.warn('error getting thumbnail from video') rmtree(tmpdir)
def install_demo(context): """ """ if context.readDataFile('collectivedocumentgenerator_demo_marker.txt') is None: return portal = api.portal.get() if not hasattr(portal, 'podtemplates'): templates_folder = api.content.create( type='Folder', title=_(u'POD Templates'), id='podtemplates', container=portal, exclude_from_nav=True ) templates_folder.setTitle('POD Templates') templates_folder.reindexObject() pod_folder = getattr(portal, 'podtemplates') constrain_types = IConstrainTypes(pod_folder) constrain_types.setConstrainTypesMode(1) constrain_types.setLocallyAllowedTypes(POD_TEMPLATE_TYPES.keys()) constrain_types.setImmediatelyAddableTypes(POD_TEMPLATE_TYPES.keys()) # Create some test content style_template_id = 'test_style_template' if not hasattr(pod_folder, style_template_id): api.content.create( type='StyleTemplate', id=style_template_id, title='Styles', odt_file=NamedBlobFile( data=context.readDataFile('templates/styles.odt'), contentType='application/vnd.oasis.opendocument.text', filename=u'styles.odt', ), container=pod_folder, exclude_from_nav=True ) style_template = getattr(pod_folder, style_template_id) style_template_id = 'test_style_template_2' if not hasattr(pod_folder, style_template_id): api.content.create( type='StyleTemplate', id=style_template_id, title=_(u'Styles n°2'), odt_file=NamedBlobFile( data=context.readDataFile('templates/styles_2.odt'), contentType='application/vnd.oasis.opendocument.text', filename=u'styles_2.odt', ), container=pod_folder, exclude_from_nav=True ) sub_template_id = 'sub_template' if not hasattr(pod_folder, sub_template_id): api.content.create( type='SubTemplate', id=sub_template_id, title=_(u'Header'), odt_file=NamedBlobFile( data=context.readDataFile('templates/sub_template.odt'), contentType='application/vnd.oasis.opendocument.text', filename=u'sub_template.odt', ), container=pod_folder, exclude_from_nav=True, style_template=[style_template.UID()], ) sub_template = getattr(pod_folder, sub_template_id) if not hasattr(pod_folder, 'loop_template'): api.content.create( type='MailingLoopTemplate', id='loop_template', title=_(u'Mailing loop template'), odt_file=NamedBlobFile( data=context.readDataFile('templates/mailing.odt'), contentType='application/vnd.oasis.opendocument.text', filename=u'mailing.odt', ), container=pod_folder, exclude_from_nav=True, style_template=[style_template.UID()], ) loop_template = getattr(pod_folder, 'loop_template') if not hasattr(pod_folder, 'test_template'): api.content.create( type='PODTemplate', id='test_template', title=_(u'General template'), odt_file=NamedBlobFile( data=context.readDataFile('templates/modele_general.odt'), contentType='application/vnd.oasis.opendocument.text', filename=u'modele_general.odt', ), container=pod_folder, exclude_from_nav=True, ) if not hasattr(pod_folder, 'test_template_multiple'): api.content.create( type='ConfigurablePODTemplate', id='test_template_multiple', title=_(u'Multiple format template'), odt_file=NamedBlobFile( data=context.readDataFile('templates/modele_general.odt'), contentType='application/vnd.oasis.opendocument.text', filename=u'modele_general.odt', ), container=pod_folder, exclude_from_nav=True, pod_formats=['odt', 'pdf', 'doc', 'docx'], pod_portal_types=['Document'], style_template=[style_template.UID()], merge_templates=[ { 'template': sub_template.UID(), 'pod_context_name': 'header', 'do_rendering': True, } ], ) if not hasattr(pod_folder, 'test_template_bis'): api.content.create( type='ConfigurablePODTemplate', id='test_template_bis', title=_(u'Collection template'), odt_file=NamedBlobFile( data=context.readDataFile(safe_unicode('templates/modèle_collection.odt')), contentType='application/vnd.oasis.opendocument.text', filename=u'modèle_collection.odt', ), container=pod_folder, exclude_from_nav=True, pod_formats=['odt', 'pdf', ], pod_portal_types=['Collection', 'Folder'], style_template=[style_template.UID()], merge_templates=[ { 'template': sub_template.UID(), 'pod_context_name': 'header', 'do_rendering': False, } ], context_variables=[ { 'name': 'details', 'value': '1', } ], ) if not hasattr(pod_folder, 'test_ods_template'): api.content.create( type='ConfigurablePODTemplate', id='test_ods_template', title=_(u'Spreadsheet template'), odt_file=NamedBlobFile( data=context.readDataFile('templates/modele_general.ods'), contentType='application/vnd.oasis.opendocument.spreadsheet', filename=u'modele_general.ods', ), container=pod_folder, exclude_from_nav=True, pod_formats=['ods', 'xls', ], pod_portal_types=['Document'], style_template=[style_template.UID()], ) if not hasattr(pod_folder, 'test_template_possibly_mailed'): api.content.create( type='ConfigurablePODTemplate', id='test_template_possibly_mailed', title=_(u'Possibly mailed template'), odt_file=NamedBlobFile( data=context.readDataFile('templates/possibly_mailed_model.odt'), contentType='application/vnd.oasis.opendocument.text', filename=u'possibly_mailed_model.odt', ), container=pod_folder, exclude_from_nav=True, pod_formats=['odt'], pod_portal_types=['Folder'], mailing_loop_template=loop_template.UID(), context_variables=[ { 'name': 'details', 'value': '1', } ], ) if not hasattr(pod_folder, 'test_template_reusable'): api.content.create( type='ConfigurablePODTemplate', id='test_template_reusable', title=_(u'Reusable template'), odt_file=NamedBlobFile( data=context.readDataFile('templates/modele_general.odt'), contentType='application/vnd.oasis.opendocument.text', filename=u'modele_general.odt', ), is_reusable=True, container=pod_folder, pod_formats=['odt'], pod_portal_types=['Folder'], exclude_from_nav=True ) reusable_template = getattr(pod_folder, 'test_template_reusable') if not hasattr(pod_folder, 'test_template_reuse'): api.content.create( type='ConfigurablePODTemplate', id='test_template_reuse', title=_(u'Reuse Test Template'), container=pod_folder, exclude_from_nav=True, pod_formats=['odt', 'pdf', 'doc', 'docx'], pod_portal_types=['Document'], pod_template_to_use=reusable_template.UID() )
def dummy_file(): from plone.namedfile.file import NamedBlobFile path = os.path.join(os.path.dirname(__file__), FILENAME) return NamedBlobFile(data=open(path, 'r').read(), filename=FILENAME)
def __iter__(self): for item in self.previous: if item['_type'] == 'tdf.templateuploadcenter.tuprelease' or \ item['_type'] == 'tdf.extensionuploadcenter.euprelease' or \ item['_type'] == 'PSCRelease': release = self.context.unrestrictedTraverse( str(item['_path']).lstrip('/'), None) if not release: yield item # Get the files below it from the item's original_path catalog_query = { 'path': { 'query': '' }, 'portal_type': [ 'PSCFile', ] } catalog_query['path'][ 'query'] = self.remote_root + item['_original_path'] catalog_query = ' '.join(str(catalog_query).split()) catalog_query = base64.b64encode(catalog_query) self.payload = {'catalog_query': catalog_query} # Make request resp = requests.get( '{}{}/get_catalog_results'.format(self.remote_url, self.catalog_path), params=self.payload, auth=(self.remote_username, self.remote_password)) file_list = resp.json() # Get the files index = 0 for rfile in file_list: resp = requests.get(self.remote_url + rfile, auth=item['_auth_info']) if resp.ok: data = resp.content filename = rfile.split('/')[-1] thefile = NamedBlobFile( data=data, filename=filename, contentType=mimetypes.guess_type(filename)[0] or '') if index < len(AVAILABLE_FIELDS): setattr(release, AVAILABLE_FIELDS[index], thefile) else: migration_error.error( 'The release {} has exceeded the number of allowed files. The file {} has been discarded.' .format(aq_parent(release).id, filename)) index = index + 1 else: migration_error.error( 'There was a problem trying to retrieve the file.') yield item
def set_field_value(self, uid, field, value, field_type): """Set field value with a specific type XXX: Only dexterity fields are supported """ pc = getToolByName(self, 'portal_catalog') results = pc.unrestrictedSearchResults(UID=uid) obj = results[0]._unrestrictedGetObject() if field_type == 'float': value = float(value) if field_type == 'int': value = int(value) if field_type == 'list': value = eval(value) if field_type.startswith('datetime'): # field_type must begin with 'datetime' # followed by optional format 'datetime%Y%m%d%H%M' # without format: %Y%m%d%H%M is used field_type = field_type[8:] fmt = field_type and field_type or '%Y%m%d%H%M' value = datetime.strptime(value, fmt) if field_type.startswith('date'): # field_type must begin with 'date' # followed by optional format 'date%Y%m%d' # without format: %Y%m%d is used field_type = field_type[4:] fmt = field_type and field_type or '%Y%m%d' value = datetime.strptime(value, fmt).date() if field_type == 'reference' and HAS_DEXTERITY_RELATIONS: results_referenced = pc.unrestrictedSearchResults(UID=value) referenced_obj = results_referenced[0]._unrestrictedGetObject() intids = getUtility(IIntIds) referenced_obj_intid = intids.getId(referenced_obj) value = RelationValue(referenced_obj_intid) if field_type == 'references' and HAS_DEXTERITY_RELATIONS: values = eval(value) intids = getUtility(IIntIds) value = [] for uid in values: results_referenced = pc.unrestrictedSearchResults(UID=uid) referenced_obj = results_referenced[ 0]._unrestrictedGetObject() referenced_obj_intid = intids.getId(referenced_obj) value.append(RelationValue(referenced_obj_intid)) if field_type == 'text/html': value = RichTextValue(value, 'text/html', 'text/html') obj.text = value if field_type == 'file': pdf_file = os.path.join(os.path.dirname(__file__), 'content', u'file.pdf') value = NamedBlobFile(data=open(pdf_file, 'r').read(), contentType='application/pdf', filename=u'file.pdf') if field_type == 'image': image_file = os.path.join(os.path.dirname(__file__), u'image.jpg') value = NamedBlobImage(data=open(image_file, 'r').read(), contentType='image/jpg', filename=u'image.jpg') setattr(obj, field, value) obj.reindexObject() notify(ObjectModifiedEvent(obj))
def create_content(self, *args, **kwargs): """Create content and return its UID""" disableCSRFProtection() # XXX: Because kwargs are only supported with robotframework >= 2.8.3, # we must parse them here to support robotframework < 2.8.3. for arg in [x for x in args if '=' in x]: name, value = arg.split('=', 1) kwargs[name] = value assert 'type' in kwargs, u"Keyword arguments must include 'type'." portal_type = kwargs.get('type') portal = getSite() if 'container' in kwargs: pc = getToolByName(portal, 'portal_catalog') uid_or_path = kwargs.pop('container') uid_results =\ pc.unrestrictedSearchResults(UID=uid_or_path) path_results = \ pc.unrestrictedSearchResults( path={'query': uid_or_path.rstrip('/'), 'depth': 0}) container =\ (uid_results or path_results)[0]._unrestrictedGetObject() else: container = portal # if we create 'file' and 'image' kwargs entries, they should not be # used to create the content but be set afterwards create_kwargs = {} create_kwargs.update(kwargs) if HAS_DEXTERITY: if portal_type in ('File', ) and 'file' not in kwargs: pdf_file = os.path.join(os.path.dirname(__file__), 'content', u'file.pdf') value = NamedBlobFile(data=open(pdf_file, 'r').read(), contentType='application/pdf', filename=u'file.pdf') kwargs['file'] = value if portal_type in ('Image', 'News Item') and 'image' not in kwargs: prefill_image_types(portal, kwargs) id_ = kwargs.pop('id', None) type_ = kwargs.pop('type') content = None if HAS_DEXTERITY: # The title attribute for Dexterity types needs to be unicode if 'title' in kwargs and isinstance(kwargs['title'], str): kwargs['title'] = kwargs['title'].decode('utf-8') from plone.dexterity.interfaces import IDexterityFTI from plone.dexterity.utils import createContentInContainer try: getUtility(IDexterityFTI, name=type_) content = createContentInContainer(container, type_, **create_kwargs) if id_ is not None and content.id != id_: container.manage_renameObject(content.id, id_) except ComponentLookupError: pass if HAS_DEXTERITY and content: # For dexterity-types, we need a second pass to fill all fields # using their widgets to get e.g. RichText-values created # correctly. fti = getUtility(IDexterityFTI, name=type_) schema = fti.lookupSchema() fields = {} for name in schema: fields[name] = schema[name] for schema in getAdditionalSchemata(portal_type=type_): for name in schema: fields[name] = schema[name] for name, field in fields.items(): widget = queryMultiAdapter((field, getRequest()), IFieldWidget) if widget and name in kwargs: if not IFromUnicode.providedBy(field): value = kwargs[name] elif isinstance(kwargs[name], unicode): value = kwargs[name] else: value = unicode(str(kwargs[name]), 'utf-8', errors='ignore') converter = IDataConverter(widget) dm = queryMultiAdapter((content, field), IDataManager) if dm: dm.set(converter.toFieldValue(value)) if content is None: if id_ is None: normalizer = queryUtility(IURLNormalizer) id_ = normalizer.normalize(kwargs['title']) # It must be Archetypes based content: content = container[container.invokeFactory(type_, id_, **kwargs)] content.processForm() return IUUID(content)
def process_local_images(data, obj, base_image_path): get_file_type = magic.Magic(mime=True) image_fieldnames_added = [] if data.get("set_dummy_image", False) and isinstance( data.get("set_dummy_image"), list): new_file = BytesIO() generate_image().save(new_file, "png") new_file = new_file if type(new_file) == str else new_file.getvalue() for image_field in data["set_dummy_image"]: setattr( obj, image_field, NamedBlobImage(data=new_file, contentType="image/png"), ) image_fieldnames_added + data["set_dummy_image"] elif data.get("set_dummy_image", False) and isinstance( data.get("set_dummy_image"), bool): # Legacy behavior, set_dummy_image is a boolean obj.image = NamedBlobImage(data=generate_image().tobytes(), contentType="image/png") image_fieldnames_added.append("image") if data.get("set_dummy_file", False) and isinstance( data.get("set_dummy_file"), list): new_file = BytesIO() generate_image().save(new_file, "png") new_file = new_file if type(new_file) == str else new_file.getvalue() for image_field in data["set_dummy_file"]: setattr( obj, image_field, NamedBlobFile(data=new_file, contentType="image/png"), ) elif data.get("set_dummy_file", False) and isinstance( data.get("set_dummy_file"), bool): # Legacy behavior, set_dummy_file is a boolean obj.file = NamedBlobFile(data=generate_image().tobytes(), contentType="image/png") if data.get("set_local_image", False) and isinstance( data.get("set_local_image"), dict): for image_data in data["set_local_image"].items(): new_file = open(os.path.join(base_image_path, image_data[1]), "rb") # Get the correct content-type content_type = get_file_type.from_buffer(new_file.read()) new_file.seek(0) setattr( obj, image_data[0], NamedBlobImage( data=new_file.read(), filename=image_data[1], contentType=content_type, ), ) image_fieldnames_added.append(image_data[0]) elif data.get("set_local_image", False) and isinstance( data.get("set_local_image"), str): new_file = open( os.path.join(base_image_path, data.get("set_local_image")), "rb") # Get the correct content-type content_type = get_file_type.from_buffer(new_file.read()) new_file.seek(0) obj.image = NamedBlobImage( data=new_file.read(), filename=data.get("set_local_image"), contentType=content_type, ) image_fieldnames_added.append("image") if data.get("set_local_file", False) and isinstance( data.get("set_local_file"), dict): for image_data in data["set_local_file"].items(): new_file = open(os.path.join(base_image_path, image_data[1]), "rb") # Get the correct content-type content_type = get_file_type.from_buffer(new_file.read()) new_file.seek(0) setattr( obj, image_data[0], NamedBlobFile( data=new_file.read(), filename=image_data[1], contentType=content_type, ), ) elif data.get("set_local_file", False) and isinstance( data.get("set_local_file"), str): new_file = open( os.path.join(base_image_path, data.get("set_local_file")), "rb") # Get the correct content-type content_type = get_file_type.from_buffer(new_file.read()) new_file.seek(0) obj.file = NamedBlobFile( data=new_file.read(), filename=data.get("set_local_file"), contentType=content_type, ) return image_fieldnames_added
def create_object(self, folder, type_, info): filename = info['name'] name = filename.decode("utf8") chooser = INameChooser(folder) chooser_name = name.lower().replace('aq_', '') newid = chooser.chooseName(chooser_name, folder.aq_parent) # strip metadata from file if (type_ in ('Image', 'File', 'Video', 'Audio') and exiftool is not None and 'tmp_file' in info): is_pdf = ('application/pdf' in guess_type(info['tmp_file'])) if is_pdf and gs_pdf is not None: try: gs_pdf(info['tmp_file']) except Exception: logger.warn('Could not strip additional metadata with gs {}'.format(info['tmp_file'])) # noqa try: exiftool(info['tmp_file']) except Exception: logger.warn('Could not strip metadata from file: %s' % info['tmp_file']) if is_pdf and qpdf is not None: try: qpdf(info['tmp_file']) except Exception: logger.warn('Could not strip additional metadata with qpdf {}'.format(info['tmp_file'])) # noqa fi = open(info['tmp_file'], 'r') try: # Try to determine which kind of NamedBlob we need # This will suffice for standard p.a.contenttypes File/Image # and any other custom type that would have 'File' or 'Image' in # its type name filename = ploneutils.safe_unicode(filename) create_opts = dict( type=type_, id=newid, container=folder) if 'Image' in type_: image = NamedBlobImage(data=fi, filename=filename) try: image.focal_point = [ float(self.request.form.get('focalX')), float(self.request.form.get('focalY')) ] except Exception: pass create_opts['image'] = image else: create_opts['file'] = NamedBlobFile(data=fi, filename=filename) for field in get_upload_fields(): if not field.get('name'): continue name = field['name'] if not self.request.form.get(name): continue if name in ('tags', 'subject'): # tags needs to be converted create_opts['subject'] = self.request.form.get(name).split(';') else: create_opts[name] = self.request.form.get(name, '') return api.content.create(**create_opts) finally: fi.close()
def create_im_mails(tc, start=1, end=100, senders=[], transitions=[], by_days=200): """Create a number of im""" print('Creating {} incoming mails'.format(end - start + 1)) import imio.dms.mail as imiodmsmail filespath = "%s/batchimport/toprocess/incoming-mail" % imiodmsmail.__path__[ 0] files = [ unicode(name) for name in os.listdir(filespath) if os.path.splitext(name)[1][1:] in ('pdf', 'doc', 'jpg') ] files_cycle = cycle(files) intids = getUtility(IIntIds) isenders = [intids.getId(ct) for ct in senders] senders_cycle = cycle(isenders) services = get_registry_organizations() selected_orgs = [ org for i, org in enumerate(services) if i in (0, 1, 2, 4, 5, 6) ] orgas_cycle = cycle(selected_orgs) ifld = tc.layer['portal']['incoming-mail'] setattr(ifld, 'folder_period', u'day') with api.env.adopt_user(username='******'): days = 0 for i in range(start, end + 1): if i % by_days == 0: days += 1 mid = 'im{}'.format(i) if mid not in ifld: scan_date = datetime.datetime.now() - datetime.timedelta( days=days) params = { 'title': 'Courrier %d' % i, 'mail_type': 'courrier', 'internal_reference_no': 'E{:04d}'.format(i), 'reception_date': scan_date, # 'sender': [RelationValue(senders_cycle.next())], 'treating_groups': orgas_cycle.next(), 'recipient_groups': [services[3]], # Direction générale, communication 'description': 'Ceci est la description du courrier %d' % i, } t_st = datetime.datetime.now() mail = sub_create(ifld, 'dmsincomingmail', scan_date, mid, **params) if i == start or i % 1000 == 0: print("Creation time at {}: '{}'".format( i, datetime.datetime.now() - t_st)) filename = files_cycle.next() with open("%s/%s" % (filespath, filename), 'rb') as fo: file_object = NamedBlobFile(fo.read(), filename=filename) createContentInContainer(mail, 'dmsmainfile', title='', file=file_object, scan_id='0509999{:08d}'.format(i), scan_date=scan_date) do_transitions(mail, transitions)