MetadataExtracter, ContentWorker, MetadataEmbedder, org.springframework.beans.factory.BeanNameAware, org.springframework.beans.factory.Aware, org.springframework.context.ApplicationContextAware

2.1

Jesper Steen Møller, Derek Hulley

getDefaultMapping(), extractRaw(ContentReader), setMapping(Map)

Default constructor. If this is called, then isSupported(String) should be implemented. This is useful when the list of supported mimetypes is not known when the instance is constructed. Alternatively, once the set becomes known, call setSupportedMimetypes(Collection).

Constructor that can be used when the list of supported mimetypes is known up front.

Constructor that can be used when the list of supported extract and embed mimetypes is known up front.

Set the registry to register with. If this is not set, then the default initialization will not auto-register the extracter for general use. It can still be used directly.

Set the mimetypes that are supported by the extracter.

Set the mimetypes that are supported for embedding.

Determines if the extracter works against the given mimetype.

Determines if the extracter works against the given mimetype.

Set the policy to use when existing values are encountered. Depending on how the extractor is called, this may not be relevant, i.e an empty map of existing properties may be passed in by the client code, which may follow its own overwrite strategy.

Set whether the extractor should discard metadata that fails to convert to the target type defined in the data dictionary model. This is true by default i.e. if the data extracted is not compatible with the target model then the extraction will fail. If this is false then any extracted data that fails to convert will be discarded.

Set the date formats, over and above the ISO8601 format, that will be supported for string to date conversions. The supported syntax is described by the SimpleDateFormat Javadocs.

Set if the property mappings augment or override the mapping generically provided by the extracter implementation. The default is false, i.e. any mapping set completely replaces the default mappings.

Note that even when set to true an individual property mapping entry replaces the entry provided by the extracter implementation.

The Alfresco global properties.

The metadata extracter config.

Whether or not to enable the pass through of simple strings to cm:taggable tags

Set if the embed property mappings augment or override the mapping generically provided by the extracter implementation. The default is false, i.e. any mapping set completely replaces the default mappings.

Note that even when set to true an individual property mapping entry replaces the entry provided by the extracter implementation.

Sets the map of source mimetypes to metadata extracter limits.

Gets the ExecutorService to be used for timeout-aware extraction.

If no ExecutorService has been defined a default of Executors.newCachedThreadPool() is used during init().

Sets the ExecutorService to be used for timeout-aware extraction.

Set the mapping from document metadata to system metadata. It is possible to direct an extracted document property to several system properties. The conversion between the document property types and the system property types will be done by the default converter.

Set the embed mapping from document metadata to system metadata. It is possible to direct an model properties to several content file metadata keys. The conversion between the model property types and the content file metadata keys types will be done by the default converter.

Set the properties that contain the mapping from document metadata to system metadata. This is an alternative to the setMapping(Map) method. Any mappings already present will be cleared out. The property mapping is of the form:

 # Namespaces prefixes
 namespace.prefix.cm=http://www.alfresco.org/model/content/1.0
 namespace.prefix.my=http://www....com/alfresco/1.0
 
 # Mapping
 editor=cm:author, my:editor
 title=cm:title
 user1=cm:summary
 user2=cm:description
 

The mapping can therefore be from a single document property onto several system properties.

Set the properties that contain the embed mapping from model properties to content file metadata. This is an alternative to the setEmbedMapping(Map) method. Any mappings already present will be cleared out. The property mapping is of the form:

 # Namespaces prefixes
 namespace.prefix.cm=http://www.alfresco.org/model/content/1.0
 namespace.prefix.my=http://www....com/alfresco/1.0

 # Mapping
 cm\:author=editor
 cm\:title=title
 cm\:summary=user1
 cm\:description=description,user2
 

The embed mapping can therefore be from a model property onto several content file metadata properties.

Helper method for derived classes to obtain the mappings that will be applied to raw values. This should be called after initialization in order to guarantee the complete map is given.

Normally, the list of properties that can be extracted from a document is fixed and well-known - in that case, just extract everything. But Some implementations may have an extra, indeterminate set of values available for extraction. If the extraction of these runtime parameters is expensive, then the keys provided by the return value can be used to extract values from the documents. The metadata extraction becomes fully configuration-driven, i.e. declaring further mappings will result in more values being extracted from the documents.

Most extractors will not be using this method. For an example of its use, see the OpenDocument extractor, which uses the mapping to select specific user properties from a document.

Helper method for derived classes to obtain the embed mappings. This should be called after initialization in order to guarantee the complete map is given.

Normally, the list of properties that can be embedded in a document is fixed and well-known.. But some implementations may have an extra, indeterminate set of values available for embedding. If the embedding of these runtime parameters is expensive, then the keys provided by the return value can be used to embed values in the documents. The metadata embedding becomes fully configuration-driven, i.e. declaring further mappings will result in more values being embedded in the documents.

A utility method to read mapping properties from a resource file and convert to the map form.

A utility method to convert global properties to the Map form for the given propertyComponent.

Mappings can be specified using the same method defined for normal mapping properties files but with a prefix of metadata.extracter, the extracter bean name, and the extract component. For example: metadata.extracter.TikaAuto.extract.namespace.prefix.my=http://DummyMappingMetadataExtracter metadata.extracter.TikaAuto.extract.namespace.prefix.cm=http://www.alfresco.org/model/content/1.0 metadata.extracter.TikaAuto.extract.dc\:description=cm:description, my:customDescription

A utility method to convert mapping properties to the Map form.

A utility method to read embed mapping properties from a resource file and convert to the map form.

A utility method to convert global mapping properties to the Map form.

Different from readGlobalExtractMappingProperties in that keys are the Alfresco QNames and values are file metadata properties.

Mappings can be specified using the same method defined for normal embed mapping properties files but with a prefix of metadata.extracter, the extracter bean name, and the embed component. For example: metadata.extracter.TikaAuto.embed.namespace.prefix.cm=http://www.alfresco.org/model/content/1.0 metadata.extracter.TikaAuto.embed.cm\:description=description

A utility method to convert mapping properties to the Map form.

Different from readMappingProperties in that keys are the Alfresco QNames and values are file metadata properties.

Registers this instance of the extracter with the registry. This will call the init() method and then register if the registry is available.

Provides a hook point for implementations to perform initialization. The base implementation must be invoked or the extracter will fail during extraction. The default mappings will be requested during initialization.

Checks if the mimetype is supported.

Checks if embedding for the mimetype is supported.

Extracts the metadata values from the content provided by the reader and source mimetype to the supplied map. The internal mapping and overwrite policy between document metadata and system metadata will be used.

The extraction viability can be determined by an up front call to MetadataExtracter.isSupported(String).

The source mimetype must be available on the ContentAccessor.getMimetype() method of the reader.

Extracts the metadata values from the content provided by the reader and source mimetype to the supplied map.

The extraction viability can be determined by an up front call to MetadataExtracter.isSupported(String).

The source mimetype must be available on the ContentAccessor.getMimetype() method of the reader.

Extracts the metadata from the content provided by the reader and source mimetype to the supplied map. The mapping from document metadata to system metadata is explicitly provided. The overwrite policy is also explictly set.

The extraction viability can be determined by an up front call to MetadataExtracter.isSupported(String).

The source mimetype must be available on the ContentAccessor.getMimetype() method of the reader.

Embeds the given properties into the file specified by the given content writer. *

The embedding viability can be determined by an up front call to MetadataEmbedder.isEmbeddingSupported(String).

The source mimetype must be available on the ContentAccessor.getMimetype() method of the writer.

Filters the system properties that are going to be applied. Gives the metadata extracter an opportunity to remove properties that may not be appropriate in a given context.

Convert a date String to a Date object

Adds a value to the map, conserving null values. Values are converted to null if:

• it is an empty string value after trimming
• it is an empty collection
• it is an empty array

String values are trimmed before being put into the map. Otherwise, it is up to the extracter to ensure that the value is a Serializable. It is not appropriate to implicitly convert values in order to make them Serializable - the best conversion method will depend on the value's specific meaning.

Helper method to fetch a clean map into which raw values can be dumped.

This method provides a best guess of where to store the values extracted from the documents. The list of properties mapped by default need not include all properties extracted from the document; just the obvious set of mappings need be supplied. Implementations must either provide the default mapping properties in the expected location or override the method to provide the default mapping.

The default implementation looks for the default mapping file in the location given by the class name and .properties. If the extracter's class is x.y.z.MyExtracter then the default properties will be picked up at classpath:/alfresco/metadata/MyExtracter.properties. The previous location of classpath:/x/y/z/MyExtracter.properties is still supported but may be removed in a future release. Inner classes are supported, but the '$' in the class name is replaced with '-', so default properties for x.y.z.MyStuff$MyExtracter will be located using classpath:/alfresco/metadata/MyStuff-MyExtracter.properties.

The default mapping implementation should include thorough Javadocs so that the system administrators can accurately determine how to best enhance or override the default mapping.

If the default mapping is declared in a properties file other than the one named after the class, then the readMappingProperties(String) method can be used to quickly generate the return value:

      {
          return readMappingProperties(DEFAULT_MAPPING);
      }
 

The map can also be created in code either statically or during the call.

This method provides a best guess of what model properties should be embedded in content. The list of properties mapped by default need not include all properties to be embedded in the document; just the obvious set of mappings need be supplied. Implementations must either provide the default mapping properties in the expected location or override the method to provide the default mapping.

The default implementation looks for the default mapping file in the location given by the class name and .embed.properties. If the extracter's class is x.y.z.MyExtracter then the default properties will be picked up at classpath:/x/y/z/MyExtracter.embed.properties. Inner classes are supported, but the '$' in the class name is replaced with '-', so default properties for x.y.z.MyStuff$MyExtracter will be located using x.y.z.MyStuff-MyExtracter.embed.properties.

The default mapping implementation should include thorough Javadocs so that the system administrators can accurately determine how to best enhance or override the default mapping.

If the default mapping is declared in a properties file other than the one named after the class, then the readEmbedMappingProperties(String) method can be used to quickly generate the return value:

      protected Map<> getDefaultMapping()
      {
          return readEmbedMappingProperties(DEFAULT_MAPPING);
      }
 

The map can also be created in code either statically or during the call.

If no embed mapping properties file is found a reverse of the extract mapping in getDefaultMapping() will be assumed with the first QName in each value used as the key for this mapping and a last win approach for duplicates.

Gets the metadata extracter limits for the given mimetype.

A specific match for the given mimetype is tried first and if none is found a wildcard of "*" is tried, if still not found defaults value will be used

Override to provide the raw extracted metadata values. An extracter should extract as many of the available properties as is realistically possible. Even if the default mapping doesn't handle all properties, it is possible for each instance of the extracter to be configured differently and more or less of the properties may be used in different installations.

Raw values must not be trimmed or removed for any reason. Null values and empty strings are

• Null: Removed
• Empty String: Passed to the OverwritePolicy
• Non Serializable: Converted to String or fails if that is not possible

Properties extracted and their meanings and types should be thoroughly described in the class-level javadocs of the extracter implementation, for example:

 editor: - the document editor        -->  cm:author
 title:  - the document title         -->  cm:title
 user1:  - the document summary
 user2:  - the document description   -->  cm:description
 user3:  -
 user4:  -
 

Override to embed metadata values. An extracter should embed as many of the available properties as is realistically possible. Even if the default mapping doesn't handle all properties, it is possible for each instance of the extracter to be configured differently and more or less of the properties may be used in different installations.