Lifting.java

package lifting.old;

import java.io.ByteArrayInputStream;
import java.io.ByteArrayOutputStream;
import java.io.File;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.lang.reflect.Field;
import java.lang.reflect.Method;
import java.util.Iterator;
import java.util.List;
import java.util.Random;

import javax.xml.transform.Result;
import javax.xml.transform.Source;
import javax.xml.transform.TransformerFactory;
import javax.xml.transform.stream.StreamResult;

import org.jdom2.Document;
import org.jdom2.Element;
import org.jdom2.JDOMException;
import org.jdom2.input.SAXBuilder;
import org.jdom2.output.Format;
import org.jdom2.output.XMLOutputter;
import org.jdom2.transform.JDOMSource;

/**
 * This class is used to make sure that an entity (an InputStream), corresponds
 * to the entity which is expected. It can be extended when the client requests
 * on the server. In this case, the resource must be compared to the the
 * arguments of the service. Or when the server responds to the client. In this
 * case, the resource is compared to what the client is expecting, and to what
 * the server is sending.
 * 
 * 
 */
public abstract class Lifting {

	protected Document document;
	protected Element racine;
	protected String outputPath;
	protected Method service;

	public Lifting(InputStream ressource, Method m) {
		this.initializeOutPutPath();
		SAXBuilder sxb = new SAXBuilder();
		try {
			document = sxb.build(ressource);
		} catch (Exception e) {
			e.printStackTrace();
		}

		racine = document.getRootElement();
		service = m;
	}

	private void initializeOutPutPath() {
		Random r = new Random();
		int randHash = r.nextInt() * 100;
		if (randHash < 0)
			randHash = -randHash;
		this.outputPath = getClass().getClassLoader().getResource(".")
				.getPath()
				+ "FAKEDocuments/" + randHash + "ParameterMODIFIED.xml";
	}

	public Document Lift() {
		try {
			System.out.println("Before: ");
			print(racine);
			treeInclusion();
			System.out.println("After: ");
			print(racine);
			SAXBuilder sxb = new SAXBuilder();
			return sxb.build(new File(outputPath));
		} catch (JDOMException | IOException e) {
			e.printStackTrace();
		}
		return null;
	}

	/**
	 * Is specified for the case of a request to the server, or a response to
	 * the client. The element to compare are different in both cases.
	 */
	protected abstract void treeInclusion();

	public void print(Element e) {
		List<Element> l = e.getChildren();
		Iterator<Element> i = l.iterator();
		System.out.println(racine.getName());
		while (i.hasNext()) {
			Element courant = (Element) i.next();
			System.out.print("	" + courant.getName());
			if (courant.getChildren().size() != 0)
				print(courant);
			else {
				if (courant.getValue() != null) {

					System.out.println(": " + courant.getValue());
				}
			}
		}
	}
	//remove fields that doesn't match any of those in the super class
	// and check that mandatory fields are present
	public boolean removeExtraFields(Element e, Class<?> class1) {
		Field[] fields = class1.getDeclaredFields();
		boolean isNotInSuperClass;
		List<Element> l = e.getChildren();
		Iterator<Element> i = l.iterator();
		int mandatoryFields=0;
		while (i.hasNext()) {
			Element courant = i.next();
			isNotInSuperClass = true;
			for (int j = fields.length - 1; j >= 0; j--) {
				if (fields[j].getName().equals(courant.getName())) {
					isNotInSuperClass = false;
					mandatoryFields++;
					break;
				}
			}
			if (isNotInSuperClass) {
				e.removeContent(courant);
			}
		}
		
		if(fields.length==mandatoryFields){

		try {
			enregistrefichier();
		} catch (Exception e1) {
			e1.printStackTrace();

		}
			return true;
		}
		else{
			return false;
		}
	}

	protected void rename(Element e, String name) {
		e.setName(name);
	}

	public void enregistrefichier() throws Exception {
		XMLOutputter sortie = new XMLOutputter(Format.getPrettyFormat());
		File f = new File(outputPath);
		if (!f.exists()) {
			f.getParentFile().mkdirs();
		}
		sortie.output(document, new FileOutputStream(outputPath));
	}

	public static void enregistrefichier(Element document, String outputPath)
			throws Exception {
		XMLOutputter sortie = new XMLOutputter(Format.getPrettyFormat());
		File f = new File(outputPath);
		if (!f.exists()) {
			f.getParentFile().mkdirs();
		}
		sortie.output(document, new FileOutputStream(outputPath));
	}

	public InputStream lifting() {
		ByteArrayOutputStream outputStream = new ByteArrayOutputStream();
		Source xmlSource = new JDOMSource(this.Lift());
		Result outputTarget = new StreamResult(outputStream);
		try {
			TransformerFactory.newInstance().newTransformer()
					.transform(xmlSource, outputTarget);
		} catch (Exception e) {

		}
		return new ByteArrayInputStream(outputStream.toByteArray());
	}

}