Changeset 8140


Ignore:
Timestamp:
2004-09-23T14:42:33+12:00 (20 years ago)
Author:
mdewsnip
Message:

One of the last pieces of new metadata code: support for importing metadata when copying files from outside the collection.

Location:
trunk/gli/src/org/greenstone/gatherer/metadata
Files:
5 edited

Legend:

Unmodified
Added
Removed

  • trunk/gli/src/org/greenstone/gatherer/metadata/DocXMLFile.java

    r8134 r8140  
    2424    {
    2525    super(doc_xml_file_path);
    26 
     26    }
     27
     28
     29    public ArrayList getMetadataExtractedFromFile(File file)
     30    {
     31    // Build up a list of metadata extracted from this file
     32    ArrayList metadata_values = new ArrayList();
     33
     34    String file_relative_path = file.getAbsolutePath();
     35    int import_index = file_relative_path.indexOf("import");
     36    if (import_index != -1) {
     37        file_relative_path = file_relative_path.substring(import_index + "import".length() + 1);
     38    }
     39
     40    // Check whether this doc.xml file contains extracted metadata for the specified file
     41    boolean contains_extracted_metadata_for_file = false;
     42    for (int i = 0; i < files_in_doc_xml_file.size(); i++) {
     43        if (file_relative_path.equals(files_in_doc_xml_file.get(i))) {
     44        contains_extracted_metadata_for_file = true;
     45        break;
     46        }
     47    }
     48
     49    // ...it doesn't
     50    if (!contains_extracted_metadata_for_file) {
     51        return metadata_values;
     52    }
     53
     54    // Parse the doc.xml file
     55    System.err.println("Applicable doc.xml file: " + this);
     56    Document document = XMLTools.parseXMLFile(this);
     57    if (document == null) {
     58        System.err.println("Error: Could not parse doc.xml file " + getAbsolutePath());
     59        return metadata_values;
     60    }
     61
     62    MetadataSet extracted_metadata_set = MetadataSetManager.getMetadataSet(MetadataSetManager.EXTRACTED_METADATA_NAMESPACE);
     63
     64    // Read all the Archive elements in the file
     65    NodeList archive_elements_nodelist = document.getElementsByTagName(ARCHIVE_ELEMENT);
     66    for (int i = 0; i < archive_elements_nodelist.getLength(); i++) {
     67        Element current_archive_element = (Element) archive_elements_nodelist.item(i);
     68
     69        // Read the child Section elements of the archive (but not all descendants)
     70        ArrayList child_section_elements = XMLTools.getChildElementsByTagName(current_archive_element, SECTION_ELEMENT);
     71        for (int j = 0; j < child_section_elements.size(); j++) {
     72        Element current_section_element = (Element) child_section_elements.get(j);
     73
     74        // Read the Description elements of this section only (not child sections as well)
     75        ArrayList child_description_elements = XMLTools.getChildElementsByTagName(current_section_element, DESCRIPTION_ELEMENT);
     76        for (int k = 0; k < child_description_elements.size(); k++) {
     77            Element current_description_element = (Element) child_description_elements.get(k);
     78
     79            // Read all the Metadata elements in this description element
     80            NodeList metadata_elements_nodelist = current_description_element.getElementsByTagName(METADATA_ELEMENT);
     81            for (int l = 0; l < metadata_elements_nodelist.getLength(); l++) {
     82            Element current_metadata_element = (Element) metadata_elements_nodelist.item(l);
     83            String metadata_element_name_full = current_metadata_element.getAttribute("name");
     84
     85            // If the metadata has a namespace it isn't extracted metadata, so we're not interested
     86            String metadata_set_namespace = MetadataTools.getMetadataSetNamespace(metadata_element_name_full);
     87            if (!metadata_set_namespace.equals("")) {
     88                continue;
     89            }
     90
     91            // Extracted metadata!
     92            String metadata_element_name = metadata_element_name_full;
     93
     94            // Ignore lower-case metadata elements (gsdlsourcefilename, gsdlassocfile etc.)
     95            //   and those starting with '/' (/srclink)
     96            char first_character = metadata_element_name.charAt(0);
     97            if (Character.isLowerCase(first_character) || first_character == '/') {
     98                continue;
     99            }
     100
     101            MetadataElement metadata_element = extracted_metadata_set.getMetadataElement(metadata_element_name);
     102
     103            // Value trees are not stored for extracted metadata, so create a new value tree node now
     104            String current_metadata_element_value = XMLTools.getElementTextValue(current_metadata_element);
     105            metadata_element.addMetadataValue(current_metadata_element_value);
     106            MetadataValueTreeNode metadata_value_tree_node = metadata_element.getMetadataValueTreeNode(current_metadata_element_value);
     107
     108            // Add the new metadata value to the list
     109            MetadataValue metadata_value = new MetadataValue(metadata_element, metadata_value_tree_node);
     110            metadata_values.add(metadata_value);
     111            }
     112        }
     113        }
     114    }
     115
     116    return metadata_values;
     117    }
     118
     119
     120    public void skimFile()
     121    {
    27122    MetadataSet extracted_metadata_set = MetadataSetManager.getMetadataSet(MetadataSetManager.EXTRACTED_METADATA_NAMESPACE);
    28123
    … …  
    106201    }
    107202    }
    108 
    109 
    110     public ArrayList getMetadataExtractedFromFile(File file)
    111     {
    112     // Build up a list of metadata extracted from this file
    113     ArrayList metadata_values = new ArrayList();
    114 
    115     String file_relative_path = file.getAbsolutePath();
    116     int import_index = file_relative_path.indexOf("import");
    117     if (import_index != -1) {
    118         file_relative_path = file_relative_path.substring(import_index + "import".length() + 1);
    119     }
    120 
    121     // Check whether this doc.xml file contains extracted metadata for the specified file
    122     boolean contains_extracted_metadata_for_file = false;
    123     for (int i = 0; i < files_in_doc_xml_file.size(); i++) {
    124         if (file_relative_path.equals(files_in_doc_xml_file.get(i))) {
    125         contains_extracted_metadata_for_file = true;
    126         break;
    127         }
    128     }
    129 
    130     // ...it doesn't
    131     if (!contains_extracted_metadata_for_file) {
    132         return metadata_values;
    133     }
    134 
    135     // Parse the doc.xml file
    136     System.err.println("Applicable doc.xml file: " + this);
    137     Document document = XMLTools.parseXMLFile(this);
    138     if (document == null) {
    139         System.err.println("Error: Could not parse doc.xml file " + getAbsolutePath());
    140         return metadata_values;
    141     }
    142 
    143     MetadataSet extracted_metadata_set = MetadataSetManager.getMetadataSet(MetadataSetManager.EXTRACTED_METADATA_NAMESPACE);
    144 
    145     // Read all the Archive elements in the file
    146     NodeList archive_elements_nodelist = document.getElementsByTagName(ARCHIVE_ELEMENT);
    147     for (int i = 0; i < archive_elements_nodelist.getLength(); i++) {
    148         Element current_archive_element = (Element) archive_elements_nodelist.item(i);
    149 
    150         // Read the child Section elements of the archive (but not all descendants)
    151         ArrayList child_section_elements = XMLTools.getChildElementsByTagName(current_archive_element, SECTION_ELEMENT);
    152         for (int j = 0; j < child_section_elements.size(); j++) {
    153         Element current_section_element = (Element) child_section_elements.get(j);
    154 
    155         // Read the Description elements of this section only (not child sections as well)
    156         ArrayList child_description_elements = XMLTools.getChildElementsByTagName(current_section_element, DESCRIPTION_ELEMENT);
    157         for (int k = 0; k < child_description_elements.size(); k++) {
    158             Element current_description_element = (Element) child_description_elements.get(k);
    159 
    160             // Read all the Metadata elements in this description element
    161             NodeList metadata_elements_nodelist = current_description_element.getElementsByTagName(METADATA_ELEMENT);
    162             for (int l = 0; l < metadata_elements_nodelist.getLength(); l++) {
    163             Element current_metadata_element = (Element) metadata_elements_nodelist.item(l);
    164             String metadata_element_name_full = current_metadata_element.getAttribute("name");
    165 
    166             // If the metadata has a namespace it isn't extracted metadata, so we're not interested
    167             String metadata_set_namespace = MetadataTools.getMetadataSetNamespace(metadata_element_name_full);
    168             if (!metadata_set_namespace.equals("")) {
    169                 continue;
    170             }
    171 
    172             // Extracted metadata!
    173             String metadata_element_name = metadata_element_name_full;
    174 
    175             // Ignore lower-case metadata elements (gsdlsourcefilename, gsdlassocfile etc.)
    176             //   and those starting with '/' (/srclink)
    177             char first_character = metadata_element_name.charAt(0);
    178             if (Character.isLowerCase(first_character) || first_character == '/') {
    179                 continue;
    180             }
    181 
    182             MetadataElement metadata_element = extracted_metadata_set.getMetadataElement(metadata_element_name);
    183 
    184             // Value trees are not stored for extracted metadata, so create a new value tree node now
    185             String current_metadata_element_value = XMLTools.getElementTextValue(current_metadata_element);
    186             metadata_element.addMetadataValue(current_metadata_element_value);
    187             MetadataValueTreeNode metadata_value_tree_node = metadata_element.getMetadataValueTreeNode(current_metadata_element_value);
    188 
    189             // Add the new metadata value to the list
    190             MetadataValue metadata_value = new MetadataValue(metadata_element, metadata_value_tree_node);
    191             metadata_values.add(metadata_value);
    192             }
    193         }
    194         }
    195     }
    196 
    197     return metadata_values;
    198     }
    199203}

  • trunk/gli/src/org/greenstone/gatherer/metadata/DocXMLFileManager.java

    r8013 r8140  
    5757    {
    5858    DocXMLFile doc_xml_file = new DocXMLFile(doc_xml_file_file.getAbsolutePath());
     59    doc_xml_file.skimFile();
    5960    doc_xml_files.add(doc_xml_file);
    6061    }

  • trunk/gli/src/org/greenstone/gatherer/metadata/MetadataSetManager.java

    r8129 r8140  
    44import java.io.*;
    55import java.util.*;
     6import org.greenstone.gatherer.gui.MetadataImportMappingPrompt;
    67
    78
    … …  
    119120
    120121
     122    static public String mapUnloadedMetadataElement(String metadata_element_name)
     123    {
     124    // Check if we have an import mapping for this metadata element
     125    String target_metadata_element_name_full = ProfileXMLFileManager.getMetadataElementFor(metadata_element_name);
     126    if (target_metadata_element_name_full != null) {
     127        // Yes, so return it
     128        return target_metadata_element_name_full;
     129    }
     130
     131    // If there are no metadata sets loaded then there is nothing to map the element into
     132    if (metadata_sets.size() <= 1) {
     133        return null;
     134    }
     135
     136    // Ask the user how they want to deal with this element
     137    MetadataImportMappingPrompt metadata_import_mapping_prompt = new MetadataImportMappingPrompt(metadata_element_name);
     138    int result = metadata_import_mapping_prompt.getResult();
     139
     140    // !!! Add the element into an existing metadata set
     141    if (result == MetadataImportMappingPrompt.ADD_BUTTON_PRESSED) {
     142        MetadataSet target_metadata_set = metadata_import_mapping_prompt.getSelectedMetadataSet();
     143        System.err.println("Added to " + target_metadata_set);
     144        // target_metadata_element_name_full =
     145    }
     146
     147    // Replace the element with an element in an existing metadata set
     148    if (result == MetadataImportMappingPrompt.REPLACE_BUTTON_PRESSED) {
     149        MetadataElement target_metadata_element = metadata_import_mapping_prompt.getSelectedMetadataElement();
     150        target_metadata_element_name_full = target_metadata_element.getFullName();
     151    }
     152
     153    // Ignore the element
     154    if (result == MetadataImportMappingPrompt.IGNORE_BUTTON_PRESSED) {
     155        target_metadata_element_name_full = "";
     156    }
     157
     158    // Store this import mapping for future elements with the same name
     159    ProfileXMLFileManager.mapElement(metadata_element_name, target_metadata_element_name_full);
     160
     161    return target_metadata_element_name_full;
     162    }
     163
     164
    121165    static public void unloadMetadataSet(MetadataSet metadata_set)
    122166    {

  • trunk/gli/src/org/greenstone/gatherer/metadata/MetadataXMLFile.java

    r8137 r8140  
    44import java.io.*;
    55import java.util.*;
    6 import org.greenstone.gatherer.gui.MetadataImportMappingPrompt;
    76import org.greenstone.gatherer.util.XMLTools;
    87import org.w3c.dom.*;
    … …  
    2322    {
    2423    super(metadata_xml_file_path);
    25 
    26     boolean file_changed = false;
    27 
    28     // Parse the metadata.xml file
    29     System.err.println("Loading metadata.xml file " + metadata_xml_file_path + "...");
    30     Document document = XMLTools.parseXMLFile(this);
    31     if (document == null) {
    32         System.err.println("Error: Could not parse metadata.xml file " + getAbsolutePath());
    33         return;
    34     }
    35 
    36     // Read all the Metadata elements in the file
    37     NodeList metadata_elements_nodelist = document.getElementsByTagName(METADATA_ELEMENT);
    38     for (int i = 0; i < metadata_elements_nodelist.getLength(); i++) {
    39         Element current_metadata_element = (Element) metadata_elements_nodelist.item(i);
    40         String metadata_element_name_full = current_metadata_element.getAttribute("name");
    41 
    42         // If the metadata element is in an unloaded metadata set give the option of mapping it into a loaded set
    43         String metadata_set_namespace = MetadataTools.getMetadataSetNamespace(metadata_element_name_full);
    44         MetadataSet metadata_set = MetadataSetManager.getMetadataSet(metadata_set_namespace);
    45         if (metadata_set == null) {
    46         // Check if we have an import mapping for this metadata element
    47         String target_metadata_element_name_full = ProfileXMLFileManager.getMetadataElementFor(metadata_element_name_full);
    48         if (target_metadata_element_name_full == null && MetadataSetManager.getMetadataSets().size() > 1) {
    49             // No, so ask the user how they want to deal with this element
    50             MetadataImportMappingPrompt metadata_import_mapping_prompt = new MetadataImportMappingPrompt(metadata_element_name_full);
    51             int result = metadata_import_mapping_prompt.getResult();
    52 
    53             // !!! Add the element into an existing metadata set
    54             if (result == MetadataImportMappingPrompt.ADD_BUTTON_PRESSED) {
    55             MetadataSet target_metadata_set = metadata_import_mapping_prompt.getSelectedMetadataSet();
    56             System.err.println("Added to " + target_metadata_set);
    57             // target_metadata_element_name_full =
    58             }
    59 
    60             // Replace the element with an element in an existing metadata set
    61             if (result == MetadataImportMappingPrompt.REPLACE_BUTTON_PRESSED) {
    62             MetadataElement target_metadata_element = metadata_import_mapping_prompt.getSelectedMetadataElement();
    63             target_metadata_element_name_full = target_metadata_element.getFullName();
    64             }
    65 
    66             // Ignore the element
    67             if (result == MetadataImportMappingPrompt.IGNORE_BUTTON_PRESSED) {
    68             target_metadata_element_name_full = "";
    69             }
    70 
    71             // Store this import mapping for future elements with the same name
    72             ProfileXMLFileManager.mapElement(metadata_element_name_full, target_metadata_element_name_full);
    73         }
    74 
    75         // System.err.println(metadata_element_name_full + " -> " + target_metadata_element_name_full);
    76 
    77         // Skip this element if we still don't have a loaded element for it
    78         if (target_metadata_element_name_full == null || target_metadata_element_name_full.equals("")) {
    79             continue;
    80         }
    81 
    82         // Update the metadata.xml file to have the new element name
    83         current_metadata_element.setAttribute("name", target_metadata_element_name_full);
    84         file_changed = true;
    85 
    86         metadata_element_name_full = target_metadata_element_name_full;
    87         metadata_set_namespace = MetadataTools.getMetadataSetNamespace(metadata_element_name_full);
    88         metadata_set = MetadataSetManager.getMetadataSet(metadata_set_namespace);
    89         }
    90 
    91         String metadata_element_name = MetadataTools.getMetadataElementName(metadata_element_name_full);
    92         MetadataElement metadata_element = metadata_set.getMetadataElement(metadata_element_name);
    93 
    94         String current_metadata_element_value = XMLTools.getElementTextValue(current_metadata_element);
    95         metadata_element.addMetadataValue(current_metadata_element_value);
    96     }
    97 
    98     // Rewrite the metadata.xml file if it has changed
    99     if (file_changed) {
    100         XMLTools.writeXMLFile(this, document);
    101     }
    10224    }
    10325
    … …  
    248170        for (int k = 0; k < metadata_elements_nodelist.getLength(); k++) {
    249171        Element current_metadata_element = (Element) metadata_elements_nodelist.item(k);
    250         String current_metadata_element_name_full = current_metadata_element.getAttribute("name");
    251 
    252         String metadata_set_namespace = MetadataTools.getMetadataSetNamespace(current_metadata_element_name_full);
     172        String metadata_element_name_full = current_metadata_element.getAttribute("name");
     173
     174        String metadata_set_namespace = MetadataTools.getMetadataSetNamespace(metadata_element_name_full);
    253175        MetadataSet metadata_set = MetadataSetManager.getMetadataSet(metadata_set_namespace);
    254176
    255         // If the metadata set isn't loaded, we're not interested in the metadata
     177        // If the metadata set isn't loaded give the option of mapping the element into a loaded set
    256178        if (metadata_set == null) {
    257             continue;
    258         }
    259 
    260         String metadata_element_name = MetadataTools.getMetadataElementName(current_metadata_element_name_full);
     179            String target_metadata_element_name_full = MetadataSetManager.mapUnloadedMetadataElement(metadata_element_name_full);
     180            if (target_metadata_element_name_full == null || target_metadata_element_name_full.equals("")) {
     181            // Skip this element if we still don't have a loaded element for it
     182            continue;
     183            }
     184
     185            metadata_element_name_full = target_metadata_element_name_full;
     186            metadata_set_namespace = MetadataTools.getMetadataSetNamespace(metadata_element_name_full);
     187            metadata_set = MetadataSetManager.getMetadataSet(metadata_set_namespace);
     188        }
     189
     190        String metadata_element_name = MetadataTools.getMetadataElementName(metadata_element_name_full);
    261191        MetadataElement metadata_element = metadata_set.getMetadataElement(metadata_element_name);
    262192
    … …  
    267197
    268198        // Square brackets need to be escaped because they are a special character in Greenstone
    269         String current_metadata_element_value = XMLTools.getElementTextValue(current_metadata_element);
    270         current_metadata_element_value = current_metadata_element_value.replaceAll("&#091;", "[");
    271         current_metadata_element_value = current_metadata_element_value.replaceAll("&#093;", "]");
    272 
    273         MetadataValueTreeNode metadata_value_tree_node = metadata_element.getMetadataValueTreeNode(current_metadata_element_value);
    274 
    275         // If there is no metadata value tree node for this value, something bad has happened
     199        String metadata_element_value = XMLTools.getElementTextValue(current_metadata_element);
     200        metadata_element_value = metadata_element_value.replaceAll("&#091;", "[");
     201        metadata_element_value = metadata_element_value.replaceAll("&#093;", "]");
     202
     203        MetadataValueTreeNode metadata_value_tree_node = metadata_element.getMetadataValueTreeNode(metadata_element_value);
     204
     205        // If there is no metadata value tree node for this value, create it
    276206        if (metadata_value_tree_node == null) {
    277             System.err.println("Error: Could not find value tree node for metadata value \"" + current_metadata_element_value + "\"");
    278             continue;
     207            System.err.println("Note: No value tree node for metadata value \"" + metadata_element_value + "\"");
     208            metadata_element.addMetadataValue(metadata_element_value);
     209            metadata_value_tree_node = metadata_element.getMetadataValueTreeNode(metadata_element_value);
    279210        }
    280211
    … …  
    369300    XMLTools.writeXMLFile(this, document);
    370301    }
     302
     303
     304    public void skimFile()
     305    {
     306    boolean file_changed = false;
     307
     308    // Parse the metadata.xml file
     309    System.err.println("Skimming metadata.xml file " + this + "...");
     310    Document document = XMLTools.parseXMLFile(this);
     311    if (document == null) {
     312        System.err.println("Error: Could not parse metadata.xml file " + getAbsolutePath());
     313        return;
     314    }
     315
     316    // Read all the Metadata elements in the file
     317    NodeList metadata_elements_nodelist = document.getElementsByTagName(METADATA_ELEMENT);
     318    for (int i = 0; i < metadata_elements_nodelist.getLength(); i++) {
     319        Element current_metadata_element = (Element) metadata_elements_nodelist.item(i);
     320        String metadata_element_name_full = current_metadata_element.getAttribute("name");
     321
     322        String metadata_set_namespace = MetadataTools.getMetadataSetNamespace(metadata_element_name_full);
     323        MetadataSet metadata_set = MetadataSetManager.getMetadataSet(metadata_set_namespace);
     324
     325        // If the metadata set isn't loaded give the option of mapping the element into a loaded set
     326        if (metadata_set == null) {
     327        String target_metadata_element_name_full = MetadataSetManager.mapUnloadedMetadataElement(metadata_element_name_full);
     328        if (target_metadata_element_name_full == null || target_metadata_element_name_full.equals("")) {
     329            // Skip this element if we still don't have a loaded element for it
     330            continue;
     331        }
     332
     333        // Update the metadata.xml file to have the new element name
     334        current_metadata_element.setAttribute("name", target_metadata_element_name_full);
     335        file_changed = true;
     336
     337        metadata_element_name_full = target_metadata_element_name_full;
     338        metadata_set_namespace = MetadataTools.getMetadataSetNamespace(metadata_element_name_full);
     339        metadata_set = MetadataSetManager.getMetadataSet(metadata_set_namespace);
     340        }
     341
     342        String metadata_element_name = MetadataTools.getMetadataElementName(metadata_element_name_full);
     343        MetadataElement metadata_element = metadata_set.getMetadataElement(metadata_element_name);
     344
     345        String metadata_element_value = XMLTools.getElementTextValue(current_metadata_element);
     346        metadata_element.addMetadataValue(metadata_element_value);
     347    }
     348
     349    // Rewrite the metadata.xml file if it has changed
     350    if (file_changed) {
     351        XMLTools.writeXMLFile(this, document);
     352    }
     353    }
    371354}

  • trunk/gli/src/org/greenstone/gatherer/metadata/MetadataXMLFileManager.java

    r8137 r8140  
    7979        File child_file = directory_files[i];
    8080        if (!child_file.isDirectory() && child_file.getName().equals("metadata.xml")) {
    81             System.err.println("Found: " + child_file);
    82             applicable_metadata_xml_files.add(new MetadataXMLFile(child_file.getAbsolutePath()));
     81            // It is very important that shallower files come before deeper ones
     82            applicable_metadata_xml_files.add(0, new MetadataXMLFile(child_file.getAbsolutePath()));
    8383        }
    8484        }
    … …  
    195195    {
    196196    MetadataXMLFile metadata_xml_file = new MetadataXMLFile(metadata_xml_file_file.getAbsolutePath());
     197    metadata_xml_file.skimFile();
    197198    metadata_xml_files.add(metadata_xml_file);
    198199    return metadata_xml_file;
Note: See TracChangeset for help on using the changeset viewer.