submitKS.java

package eu.fbk.knowledgestore.populator.naf;

import java.io.File;
import java.io.IOException;
import java.io.Writer;
import java.util.Hashtable;
import java.util.Iterator;
import java.util.LinkedList;
import java.util.List;
import java.util.Map;
import org.openrdf.model.URI;
import org.openrdf.model.impl.URIImpl;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

import eu.fbk.knowledgestore.OperationException;
import eu.fbk.knowledgestore.Session;
import eu.fbk.knowledgestore.data.ParseException;
import eu.fbk.knowledgestore.data.Record;
import eu.fbk.knowledgestore.data.Representation;
import eu.fbk.knowledgestore.vocabulary.KS;

public class submitKS {
    private static Logger logger = LoggerFactory.getLogger(submitKS.class);

    public static Integer init(Hashtable<String, KSPresentation> batchList, boolean store_partical_info, Session session) throws IOException{
	    
	List<Record> resources=null;
	List<Record> mentions=null;
	try {
		checkResourceFoundInKS(session,batchList);
	    // Clear all resources stored in the KS
	    // session.delete(KS.RESOURCE).exec();

	    // Store resource records, in a single operation
	    resources = submitResources(batchList, session);
	    //store mentions records, in a single operation
	    mentions = submitMentions(batchList, session);
        //upload news file
        uploadNews(batchList, session);
        // upload naf file
        uploadNaf(batchList, session);

        LinkedList<KSPresentation> submittedFiles = getAllSubmittedFiles(batchList);
        for (KSPresentation ksF : submittedFiles) {
            if (nafPopulator.out != null) {
                    nafPopulator.out.append("NAF: " + ksF.getNaf_file_path())
                            .append(ksF.getStats().getStats()).append("\n");
                    nafPopulator.out.flush();
            }
            nafPopulator.updatestats(ksF.getStats());
        }
    
	    return 1;
	} catch (ParseException e) {
	    //e.printStackTrace();
	    //rollback
        logger.error(e.getMessage(), e);
	    rollback(session,resources,mentions);
	    //inout.append(e.getMessage());
	    return 0;
	} catch (IllegalStateException e) {
	    //rollback
        logger.error(e.getMessage(), e);
	    rollback(session,resources,mentions);
	    return 0;
	} catch (OperationException e) {
	    //rollback
	    logger.error(e.getMessage(), e);
	    rollback(session,resources,mentions);
            
	    return 0;
	} catch (IOException e) {
	    //rollback
        logger.error(e.getMessage(), e);
	    rollback(session,resources,mentions);
	    return 0;
	}
		
    }
    
    private static boolean doSubmitToKS(KSPresentation tmp){
        //Default 1=discard the new, 2=ignore repopulate, 3=delete repopulate
    	if(nafPopulator.KSresourceReplacement==1&&!tmp.isFoundInKS())
    		return true;
    	if(nafPopulator.KSresourceReplacement==2)
    		return true;
    	if(nafPopulator.KSresourceReplacement==3){
    		if(tmp.isFoundInKS()){
    			//TODO do the deletion of the previous ks resources then return true;
    		}
    		return true;
    	}
    		
    	return false;
    }
	
    private static void checkResourceFoundInKS(
			Session session, Hashtable<String, KSPresentation> batchList) {
    	if(nafPopulator.KSresourceReplacement!=2){
    	for (KSPresentation tmp : batchList.values()) {
    	    try {
                Record record = session.retrieve(KS.RESOURCE).ids(tmp.getNaf().getID())
                        .properties(KS.STORED_AS).exec().getUnique();
                boolean correctlyPopulated = record != null && !record.isNull(KS.STORED_AS);
//    			long cc = session.count(KS.RESOURCE).ids(tmp.getNewsResource().getID()).exec();//TODO
    			if(correctlyPopulated)
    				tmp.setFoundInKS(true);
    			else
    				tmp.setFoundInKS(false);
    			
    		} catch (IllegalStateException e) {
    			tmp.setFoundInKS(false);
    		    logger.error(e.getMessage(), e);
    		} catch (OperationException e) {
    			tmp.setFoundInKS(false);
    		    logger.error(e.getMessage(), e);
    		}
    	  }
    	}
	}

	private static void rollback(Session session, List<Record> resources, List<Record> mentions){
	List<URI> idsIT;
	
	try {
	    // delete the resources by id
	    idsIT = new LinkedList<URI>();
	    for(Record rID : resources){
		idsIT.add(rID.getID());
	    }
	    session.delete(KS.RESOURCE).ids(idsIT).exec();

	    // delete the mentions by id
	    idsIT.clear();
	    for(Record rID : mentions){
		idsIT.add(rID.getID());
	    }
	    session.delete(KS.MENTION).ids(idsIT).exec();

        } catch (ParseException e) {
            logger.error("Error rollback: "+e.getMessage());
        } catch (IllegalStateException e) {
            logger.error("Error rollback: "+e.getMessage());
        } catch (OperationException e) {
            logger.error("Error rollback: "+e.getMessage());
        }
    }

    private static List<Record> submitMentions(Hashtable<String, KSPresentation> batchList, Session session) throws ParseException, IllegalStateException, OperationException {
	final List<Record> records = getAllMentionType(batchList);
	if(records.size()>0)
	session.merge(KS.MENTION).criteria("overwrite *").records(records)
	    .exec();
	// Count and print the number of resources in the KS
	// final long numResources = session.count(KS.MENTION).exec();
	// System.out.println(numResources + " mentions in the KS");
	
	// return the list of submitted mentions
	return records;
    }

    private static List<Record> submitResources(Hashtable<String, KSPresentation> batchList, Session session) throws IllegalStateException, OperationException, IOException {
	final List<Record> records = getAllResourceType(batchList);
	if(records.size()>0)
	session.merge(KS.RESOURCE).criteria("overwrite *").records(records)
	    .exec();
	// Count and print the number of resources in the KS
	// final long numResources = session.count(KS.RESOURCE).exec();
	// System.out.println(numResources + " resources in the KS");
	return records;
    }

    private static Hashtable<URI, String> uploadNaf(Hashtable<String, KSPresentation> batchList, Session session) throws IllegalStateException, OperationException {
	Hashtable<URI, String> FILE_RESOURCES = getAllNafResources(batchList);
	// Store resource files, one at a time
	for (final Map.Entry<URI, String> entry : FILE_RESOURCES.entrySet()) {
	    final URI resourceID = entry.getKey();
	    final File nafFile = new File(entry.getValue());
	    final Representation representation = Representation.create(nafFile, true);
	    try {
		session.upload(resourceID).representation(representation).exec();
	    } finally {
		representation.close();

		// delete the nafFile if it is a temporary file extracted from a zip or tgz archive
		if (nafPopulator.ZInFile || nafPopulator.TInFile) {
		    nafFile.delete();
		}
	    }
	}
	return FILE_RESOURCES;
    }

    private static Hashtable<URI, String> uploadNews(Hashtable<String, KSPresentation> batchList, Session session) throws IllegalStateException, OperationException {
	Hashtable<URI, String> FILE_RESOURCES = getAllResources(batchList);
	// Store resource files, one at a time
	for (final Map.Entry<URI, String> entry : FILE_RESOURCES.entrySet()) {
	    final URI resourceID = entry.getKey();
	    final Representation representation = Representation.create(entry
									.getValue());
	    try {
		session.upload(resourceID).representation(representation)
		    .exec();
	    } finally {
		representation.close();
	    }
	}
	return FILE_RESOURCES;
    }

    private static List<Record> getAllResourceType(Hashtable<String, KSPresentation> batchList) throws IOException {
	List<Record> temp = new LinkedList<Record>();
	for (KSPresentation tmp : batchList.values()) {
		if(doSubmitToKS(tmp)){
	    temp.add(tmp.getNewsResource());
	    temp.add(tmp.getNaf());
	    /*inout.append(tmp.getNewsResource().toString(Data.getNamespaceMap(),
	      true)
	      + "\n");
	      inout.append(tmp.getNaf().toString(Data.getNamespaceMap(), true)
	      + "\n");*/
		}
	}
	return temp;
    }

    private static Hashtable<URI, String> getAllNafResources(Hashtable<String, KSPresentation> batchList) {
	Hashtable<URI, String> temp = new Hashtable<URI, String>();
	for (KSPresentation tmp : batchList.values()) {
		if(doSubmitToKS(tmp)){
	    temp.put(tmp.getNaf().getID(), tmp.getNaf_file_path());
		}
	}
	return temp;
    }

    private static Hashtable<URI, String> getAllResources(Hashtable<String, KSPresentation> batchList) {
	Hashtable<URI, String> temp = new Hashtable<URI, String>();
	for (KSPresentation tmp : batchList.values()) {
		if(doSubmitToKS(tmp)){
	    temp.put(tmp.getNewsResource().getID(), tmp.getNews());
		}
	}
	return temp;
    }

    private static List<Record> getAllMentionType(Hashtable<String, KSPresentation> batchList) {
	List<Record> temp = new LinkedList<Record>();
	for (KSPresentation tmp : batchList.values()) {
		if(doSubmitToKS(tmp)){
	    temp.addAll(tmp.getMentions().values());
		}
	}
	return temp;
    }
    private static LinkedList<KSPresentation> getAllSubmittedFiles(Hashtable<String, KSPresentation> batchList) {
    	LinkedList<KSPresentation> temp = new LinkedList<KSPresentation>();
    	for (KSPresentation tmp : batchList.values()) {
    		if(doSubmitToKS(tmp)){
    	    temp.addLast(tmp);
    		}else{
    			logger.error("submitKS: NAF: "+tmp.getNaf_file_path()+" - File already exists in KS, discarded!");
    		}
    	}
    	return temp;
        }
}