Laboratoire ICAR » Plateforme TXM

package org.txm.concordance.rcp.editors;

import java.util.ArrayList;

import java.util.List;

import org.eclipse.core.runtime.CoreException;

import org.eclipse.core.runtime.IConfigurationElement;

import org.eclipse.core.runtime.IProgressMonitor;

import org.eclipse.core.runtime.IStatus;

import org.eclipse.core.runtime.Platform;

import org.eclipse.core.runtime.Status;

import org.eclipse.jface.action.Action;

import org.eclipse.jface.action.IMenuListener;

import org.eclipse.jface.action.IMenuManager;

import org.eclipse.swt.widgets.TableItem;

import org.eclipse.ui.IEditorInput;

import org.eclipse.ui.IEditorSite;

import org.eclipse.ui.IWorkbenchPartSite;

import org.eclipse.ui.PartInitException;

import org.txm.concordance.core.functions.Concordance;

import org.txm.concordance.rcp.handlers.DeleteLines;

import org.txm.concordance.rcp.messages.ConcordanceUIMessages;

import org.txm.concordance.rcp.widgets.ComplexSortSelector;

import org.txm.core.preferences.TXMPreferences;

import org.txm.core.results.Parameter;

import org.txm.core.results.TXMResult;

import org.txm.rcp.IImageKeys;

import org.txm.rcp.JobsTimer;

import org.txm.rcp.StatusLine;

import org.txm.rcp.editors.TXMBrowser;

import org.txm.rcp.editors.TXMEditor;

import org.txm.rcp.editors.TableKeyListener;

import org.txm.rcp.editors.listeners.ComputeKeyListener;

import org.txm.rcp.editors.listeners.ComputeSelectionListener;

import org.txm.rcp.messages.TXMUIMessages;

import org.txm.rcp.preferences.RCPPreferences;

import org.txm.rcp.swt.GLComposite;

import org.txm.rcp.swt.widget.AssistedQueryWidget;

import org.txm.rcp.swt.widget.NavigationWidget;

import org.txm.rcp.swt.widget.PropertiesSelector;

import org.txm.rcp.utils.JobHandler;

import org.txm.rcp.views.QueriesView;

import org.txm.searchengine.cqp.CQPSearchEngine;

import org.txm.searchengine.cqp.ReferencePattern;

import org.txm.searchengine.cqp.corpus.Corpus;

import org.txm.searchengine.cqp.corpus.Property;

import org.txm.searchengine.cqp.corpus.WordProperty;

import org.txm.utils.logger.Log;

		data3.right = new FormAttachment(100);

		viewer.getTable().setLayoutData(data3);

		createContextMenu();

	}

	/**

	println " stop if a XML source is malformed: "+stopIfMalformed

}

// Apply XSL

if (MONITOR != null && MONITOR.isCanceled()) { return MONITOR.done(); }

//get metadata values from CSV

Metadatas metadatas; // text metadata

if (allmetadatasfile.exists()) {

	println "Trying to read metadata from: "+allmetadatasfile

	println " stop if a XML source is malformed: "+stopIfMalformed

}

// Apply XSL

if (MONITOR != null && MONITOR.isCanceled()) { return MONITOR.done(); }

	println " stop if a XML source is malformed: "+stopIfMalformed

}

// Apply Factiva2XMLTXM

println "Factiva -> xml/w"

String paginationElement = "pb";

boolean normalizeMetadata = true;

if (txmDir.listFiles() == null) {

	println "No file to process"

txmDir.deleteDir();

txmDir.mkdirs();

// Apply XSL

if (MONITOR != null && MONITOR.isCanceled()) { return MONITOR.done(); }

		Collections.sort(filelist);

		// get the headers

		Metadatas metadatas; // text metadata

		println "Trying to read metadata from: "+csvfile

//get metadata values from CSV

Metadatas metadatas; // text metadata

println "Trying to read metadatas values from: "+allmetadatasfile

if (allmetadatasfile.exists()) {

	File copy = new File(binDir, "metadata.csv")

import java.io.BufferedWriter;

import java.io.File;

import java.io.FileOutputStream;

import java.io.IOException;

import java.io.OutputStreamWriter;

import javax.xml.xpath.XPathExpressionException;

import javax.xml.xpath.XPathFactory;

import org.txm.importer.AddAttributeInXml;

import org.txm.importer.PersonalNamespaceContext;

import org.txm.utils.AsciiUtils;

import org.txm.utils.CsvReader;

import org.txm.utils.Pair;

 * The Class Metadatas.

 */

public class Metadatas extends LinkedHashMap<String , TextInjection> {

	/** Load metadatas from a xml file $lt;metadatas> $lt;meta key="key1"> $lt;entry name="attr1" value="value1"/> $lt;entry name="attr1" value="value1"/> $lt;meta/> $lt;/metadatas>. */

	File xmlfile;

	/** The metadatas. */

	ArrayList<Metadata> metadatas = new ArrayList<Metadata>();

	/** The headers list. */

	ArrayList<String> headersList = new ArrayList<String>();

	/** The isinialize. */

	boolean isinialize = false;

	/**

	 * Checks if is initialized.

	 *

	{

		return isinialize;

	}

	/** The ns context. */

	NamespaceContext nsContext = new PersonalNamespaceContext();

	/**

	 * Instantiates a new metadatas.

	 *

		if(!initialize())

			System.out.println("Error: failed to load metadata from the file "+xmlfile);

	}

	/**

	 *

	 * @param encoding the encoding

	 * @param separator the separator

	 * @param nbheaderline the nbheaderline

	 */

	{

		//println "create xml file version of "+csvfile+" : "+xmlfile

		try {

			}

		} catch (Exception e) {

			// TODO Auto-generated catch block

			org.txm.utils.logger.Log.printStackTrace(e);

			Log.severe(e.toString());

		}

	}

	public File getXMLFile() {

		return xmlfile;

	}

	/** The sattr. */

	String sattr = "";

	/**

	 * Initialize.

	 *

			sattr +="+"+m.id;

			headersList.add(m.id);

		}

		// List<Node> Lmetadatas = doc.texts.text;

		// get metadata nodes

		NodeList textsNodes = doc.getElementsByTagName("texts");

			TextInjection inj = new TextInjection(e);

			this.put(inj.id, inj);

		}

		isinialize = true;

		return true;

	}

	public HashMap<String, String> getTextMetadata(File f)

	{

		HashMap<String, String> data = new HashMap<String, String>();

		String txtname = f.getName();

		int idx = txtname.lastIndexOf(".");

		if(idx > 0) txtname = txtname.substring(0, idx);

		TextInjection injection = this.get(txtname);

		if (injection == null) {

			System.out.println("Could not find injection for text "+txtname);

		for (Entry e : injection) {

			data.put(e.getId(), e.getValue());

		}

		return data;

	}

	/**

	 * Convert csv to xml.

	 *

			System.out.println("Error: CSV file does not exists");

			return false;

		}

		XMLOutputFactory factory = XMLOutputFactory.newInstance();

		FileOutputStream output = new FileOutputStream(xmlFile);

		XMLStreamWriter writer = factory.createXMLStreamWriter(output, "UTF-8");//create a new file

		CsvReader reader = new CsvReader(csvfile.getAbsolutePath(), separator.charAt(0), Charset.forName(encoding));

		if (txtseparator != null && txtseparator.length() > 0)

			reader.setTextQualifier(txtseparator.charAt(0));

		reader.readHeaders();

		String[] headers = reader.getHeaders();

		if (headers.length == 0)

		{

			System.out.println("Error: No header in the metadata file "+csvfile);

			return false;

		}

		if(!headers[0].equals("id"))

		{

			System.out.println("Error: The first column name in the header line of the metadata file '$csvfile' must be 'id' and found '"+headers[0]+"'");

			return false;

		}

		//check for double columns

		HashSet<String> testhash = new HashSet<String>();

		HashSet<String> doubles = new HashSet<String>();

			System.out.println("Error: the metadata file '$csvfile' contains duplicated column names: "+doubles);

			return false;

		}

		String[] longnames = new String[headers.length];

		String[] types = new String[headers.length];

		if (nbheaderline > 1)//get longnames

			for (int i = 0 ; i < headers.length ; i++) {

				longnames[i] = headers[i];

			}

		if (nbheaderline > 2)//got types

		{

			reader.readRecord();

				types[i] = "String";

			}

		}

		writer.writeStartDocument("UTF-8", "1.0");

		writer.writeStartElement("enrichissement");

		writer.writeStartElement("metadatas");

		//println "headers : "+Arrays.toString(headers)

		for (int i = 1 ; i < headers.length ; i++) {

			if (headers[i].length() == 0) {

			writer.writeAttribute("selection", "true");

			writer.writeAttribute("partition", "true");

			writer.writeAttribute("display", "true");

			writer.writeEndElement();

			//}	

		}

		writer.writeEndElement();//close metadatas

		writer.writeStartElement("texts");

		while (reader.readRecord())	{

			writer.writeStartElement("text");

			for(int i = 0 ; i < headers.length ; i++)

				} else if(headers[i].equals("xpath")) {

					writer.writeAttribute("xpath", reader.get(headers[i]));

				}

			for(int i = 0 ; i < headers.length ; i++)

				if(!headers[i].equals("id") && !headers[i].equals("xpath"))

				{

						writer.writeAttribute("value", "N/A");

					else

						writer.writeAttribute("value", value);

				}

			writer.writeEndElement();

		}

		writer.writeEndElement();//close texts

		writer.writeEndElement();//close metadatas

		reader.close();

		writer.close();

		output.close();

		output = null;

		writer = null;

		return true;

	}

	/**

	 * Keep only metadatas.

	 *

				i--;

			}

		}

		for(TextInjection inj : this.values())

		{

			for(int i = 0 ; i < inj.size() ; i++)

			}

		}

	}

	/**

	 * Inject metadatas in xml txm.

	 *

	{

		return injectMetadatasInXml(infile, outfile,"text", "tei");

	}

	/**

	 * Inject metadatas in xml.

	 *

	{

		return injectMetadatasInXml(infile, outfile,tag, null);

	}

	/**

	 * Inject metadatas in xml.

	 *

		String key = infile.getName();

		if(key.lastIndexOf(".") > 0)

			key = key.substring(0, key.lastIndexOf("."));

		ArrayList<org.txm.metadatas.Entry> metas = get(key);

		if (metas == null) {

			System.out.println("\nError: can't find metadata for text of id="+key);

			System.out.println("Maybe the metadata file doesn't have the right format (comma separated values are needed)");

			return false;

		}

		AddAttributeInXml builder = new AddAttributeInXml(infile, tag, metas);

		builder.onlyOneElement();

		return builder.process(outfile);

	}

	/**

	 * Save.

	 *

		try {

			// Création de la source DOM

			Source source = new DOMSource(doc);

			// Création du fichier de sortie

			Writer writer = new BufferedWriter(new OutputStreamWriter(new FileOutputStream(outfile), "UTF-8")); 

			Result resultat = new StreamResult(writer);

			// Configuration du transformer

			TransformerFactory fabrique = new net.sf.saxon.TransformerFactoryImpl();

			Transformer transformer = fabrique.newTransformer();

			transformer.setOutputProperty(OutputKeys.INDENT, "yes");

			transformer.setOutputProperty(OutputKeys.METHOD, "xml");

			transformer.setOutputProperty(OutputKeys.ENCODING, "UTF-8");

			// Transformation

			transformer.transform(source, resultat);

			writer.close();

			return false;

		}

	}

	/**

	 * Insert.

	 *

		//println ("insert $pairs into $xpath")

		XPathFactory factory = XPathFactory.newInstance();

		XPath XpathObj = factory.newXPath();

		XpathObj.setNamespaceContext(nsContext);

		XPathExpression expr = XpathObj.compile(xpath);

		NodeList nodes = (NodeList) expr.evaluate(doc, XPathConstants.NODESET);

		int count = 0;

		for(int i = 0 ; i < nodes.getLength() ; i++) {

			}

			count++;

		}

		factory = null;

		XpathObj = null;

		expr = null;

			return false;

		}

	}

	/**

	 * Gets the property names.

	 *

	{

		return headersList;

	}

	/**

	 * Gets the sattributes.

	 *

			sattr += "+"+attr;

		return sattr;

	}

	/* (non-Javadoc)

	 * @see java.util.AbstractMap#toString()

	 */

	@Override

		StringBuffer str = new StringBuffer();

		str.append("Metadata: \n");

			str.append(" "+data.toString()+"\n");

		str.append("Injections: \n");

			str.append(" "+injection.toString()+"\n");

		}

		return str.toString();

	}

	/**

	 * The main method.

	 *

	 * @param args the arguments

	 */

		String userhome = System.getProperty("user.home");

		File xmlfile = new File(userhome, "/xml/metadata.xml");

		File csvfile = new File(userhome, "/xml/metadata.csv");

			System.out.println(m.toString());

		}

	}

	public ArrayList<Metadata> getMetadatas() {

		return metadatas;

	}	

	public ArrayList<String> getHeadersList(){

		return this.headersList;

	}

Manifest-Version: 1.0

Export-Package: .,

 EDU.oswego.cs.dl.util.concurrent,

 EDU.oswego.cs.dl.util.concurrent.misc,