ServletUtils.java

Go to the documentation of this file.

package cedar.jetweb.servlet;

import javax.servlet.http.HttpServletRequest;

import java.io.PrintWriter;
import java.io.File;

import java.util.Vector;
import java.util.Collection;
import java.util.HashMap;
import java.util.Map;
import java.util.Map.Entry;
import java.util.Iterator;
import java.util.List;
import java.util.Set;
import java.util.Arrays;
import java.util.Scanner;

import cedar.jetweb.*;

import cedar.jetweb.model.*;
import cedar.jetweb.model.plots.*;
import cedar.jetweb.model.fit.Fit;
import cedar.jetweb.model.paper.Paper;
import cedar.jetweb.model.paper.PaperBank;

import cedar.jetweb.html.*;

import cedar.jetweb.job.*;

import cedar.jetweb.batch.SubmitScriptHandler;

import cedar.jetweb.xml.JetWebPlotReader;
import cedar.jetweb.xml.JetWebPlotReaderFactory;
import cedar.jetweb.hist.JetWebHist;

import cedar.jetweb.generator.Generator;

import com.oreilly.servlet.multipart.*;

public abstract class ServletUtils {

    private static boolean initCuts_ = true;
    private static HashMap<String, String> allowedCuts_ = 
    new HashMap<String, String>();

    public static ResultSearchPattern makePattern(HttpServletRequest request)
    throws JetWebException {

    ResultSearchPattern pattern;

    if(request.getParameterValues("MOREDATA")!=null ||
       request.getParameterValues("SIMILARDATA")!=null ||
       request.getParameterValues("FINDDATA")!=null 
       ){

        // Build a result search pattern from the model Id.
        String[] tmp = request.getParameterValues("MODELID");
        try {
        int modelId = Integer.parseInt(tmp[0]);
        pattern = new Model(modelId);

        } catch (NumberFormatException e) {
        System.out.println(e);
        pattern = new ResultSearchPattern();
        }       
        
        getCuts(request, pattern.getGenerator());

        return pattern;
    }

    pattern = new ResultSearchPattern();
    
    String[] tmp = request.getParameterValues("DESCRIPTION");
    if(tmp!=null&&tmp.length!=0){
        pattern.setDescription(tmp[0]);
    }
    // Generator
    tmp = request.getParameterValues("GENERATOR");
    try {
        for (int i=0; i<tmp.length;i++){
        // generator properies should be of the format name-version
        //int id = Integer.parseInt(tmp[i]);
        String name = tmp[i].substring(0,tmp[i].indexOf("-")); 
        String version = tmp[i].substring(tmp[i].indexOf("-")+1);
        //System.out.println("adding "+name+" "+version);
        pattern.getGeneratorList().add(Generator.Maker(name,version));
        }
        
    } catch (NullPointerException e){}



    try {
        Vector<String> pdfs = new Vector<String>();
        pdfs.addAll(Arrays.asList(request.getParameterValues("PHOTONPDF")));
        pdfs.addAll(Arrays.asList(request.getParameterValues("PROTONPDF")));

        for(String pdfStr: pdfs){

        PDF pdf = new PDF(pdfStr);
        if(pdf.isPhoton()) pattern.getPhotonPDFList().add(pdf);
        if(pdf.isProton()) pattern.getProtonPDFList().add(pdf);
        }

    } catch (NullPointerException e){}
    
    getGeneratorParameters(request,pattern.getGenerator());
    return pattern;
    }



    public static PlotSelection makePlotSelection(HttpServletRequest request) {

    PlotSelection selection = new PlotSelection();

    String[] sumplots = request.getParameterValues("SUMPLOT");
    String[] fitplots = request.getParameterValues("FITPLOT");

    try {

        if (sumplots!=null){
        for (int i=0; i<sumplots.length;i++){
            DataPlot plot = PaperBank.getPlot(Integer.parseInt(sumplots[i]));
            selection.getSumPlots().add(plot);
        }
        }
        if (fitplots!=null){
        for (int i=0; i<fitplots.length;i++){
            DataPlot plot = PaperBank.getPlot(Integer.parseInt(fitplots[i]));
            selection.getFitPlots().add(plot);
        }
        }
    } catch (Exception e){
        e.printStackTrace(System.out);
    }

    return selection;
        
    }
    public static void performResultSearch(ResultSearchPattern pattern,
                       PrintWriter out,
                       String servletPath,
                       PlotSelection selection,
                       HttpServletRequest request){

    try {
        String sort = request.getParameter("SORT");
        if (sort==null) {
        sort = HTMLUtils.DATE;
        }
        int nMatches = 0;
        
        if (request.getParameter("GETFITS")!=null) {
        List<Fit> list = Fit.getFits(pattern,selection,sort);
        nMatches = list.size();
        if (list.size()!=0) {
            HTMLUtils.displayList(out,servletPath,false,list);
            return;
        }
        } else {
        List<Model> list = Model.getModels(pattern,sort);
        if (list.size()!=0) {
            HTMLUtils.displayList(out,servletPath,false,list);
            return;
        }
        }
        
        StringBuffer message = new StringBuffer("<p>Insufficient data currently exist in the database matching the parameters you specified.</p> <p>Submit the form below to request generation of this data.</p>");
        if (request.getParameter("GETFITS")!=null){
        message.append("<div class='actionbuttons'>");
        message.append("<p>There may be models in the databse matching these parameters, but without the full dataset available. You can find these by searching for models rather than fits using the button below.</p>");
        message.append(HTMLUtils.writeSubmitButton("GETMODELS",
                               "Search for models matching the criteria specified",
                               "Get Models"));
        message.append("</div>");
        }
        HTMLUtils.writeJobRequestForm(message.toString(),pattern,selection,out,servletPath);
        

    } catch (JetWebException e){
        HTMLErrorWriter.write(out,e);
    }
    }
    
    public static void updateConfig(HttpServletRequest request){

    String[] tmp;

    tmp = request.getParameterValues("RUNSUBDIR");
    if (tmp!=null){
        if (tmp.length>0){
        if (tmp[0]!=""){
            if (!tmp[0].startsWith("/") && tmp[0]!="") {tmp[0] = "/"+tmp[0];}
            JetWebConfig.jobOutDirName = tmp[0];
        }
        }
    }

    tmp = request.getParameterValues("BATCHFAC");
    if (tmp.length>0) {
        try {
        SubmitScriptHandler.BATCHFACILITY = Integer.parseInt(tmp[0]);
        } catch (NumberFormatException e) {
        System.out.println("Invalid batch facility: "+tmp[0]+" : should be an integer");
        }
    }

    tmp = request.getParameterValues("PLOTS");
    if (tmp!=null){
        if (tmp.length>0){
        JetWebConfig.writePlots=true;
        } else {
        JetWebConfig.writePlots=false;
        }
    } else {
        JetWebConfig.writePlots=false;
    }
    }

    public static void editFit(HttpServletRequest request, PrintWriter out, 
                   String servletPath) 
    throws JetWebException{

    int fitId   = Integer.parseInt(request.getParameter("FITID"));
    
    if (request.getParameter("FITACTION").equals("REDO")){
        
        System.out.println("Redoing Fit "+fitId);
        Fit fit = new Fit(fitId);
        fit.update(true);
        HTMLFitWriter op = new HTMLFitWriter(out,servletPath);
        op.setVerbose(true);
        op.display(fit);
        op.close();
    }
    /*      
    } else if (request.getParameter("FITACTION").equals("ZERO")){
        
        // Zero the chi2 etc for the fit, and the data for all the
        // predicted and fitted plots.  Remove the index file.
        // Then move the input log and aida files into the run/edit
        // directory.  Optionally, then regenerate the fit
        // immediately.
        
        // Force an update of the fit.
        // (turn off plots first)
        boolean temp = JetWebConfig.writePlots;
        JetWebConfig.writePlots=false;
        Fit fit = new Fit(fitId);
        JetWebConfig.writePlots=temp;
        
        Model model = fit.getModel();
        MCProcessType proc = new MCProcessType();

        // Zero the data associated with this fit.
        if (request.getParameter("REMOVEEE")!=null) {
        proc.setParticle1(Collision.ELECTRON);
        proc.setParticle2(Collision.POSITRON);
        model.zero(proc);
        }
        
        if (request.getParameter("REMOVEEP")!=null) {
        proc.setParticle1(Collision.ELECTRON);
        proc.setParticle2(Collision.PROTON);
        model.zero(proc);
        }
        
        if (request.getParameter("REMOVEPP")!=null) {
        proc.setParticle1(Collision.PROTON);
        proc.setParticle2(Collision.ANTIPROTON);
        model.zero(proc);
        }

        // Zero all the fitted stuff.
        fit.zero();
        
        HTMLWriter op = new HTMLWriter(out,servletPath);
        op.forwardTo(JetWebConfig.getHTMLRoot()
             +"/"+JetWebConfig.plotCacheDirName
             +"/"+fitId+"/index.html");
        
    } else if (request.getParameter("FITACTION").equals("REMOVE")){
        
        Fit.delete(fitId);
        HTMLUtils.writeControlScreen("Remove Fit "+fitId,null,null,out,
                   servletPath);
        
    }
    */
    }



    public static void changePaper(HttpServletRequest request,PrintWriter out){

    System.out.println("Changing paper!");

    try {
        int paperId= Integer.parseInt(request.getParameter("PAPERID"));     
        Paper paper = new Paper(paperId);

        paper.setTitle(request.getParameter("TITLE").trim());
        paper.setIRN(Integer.parseInt(request.getParameter("IRN").trim()));
        paper.setReference(request.getParameter("REFERENCE").trim());
        paper.setCollaboration(request.getParameter("COLLABORATION").trim());
        paper.setContact(request.getParameter("CONTACT").trim());
        paper.setCodeAuthor(request.getParameter("CODEAUTHOR").trim());
        paper.setAccelerator(request.getParameter("ACCELERATOR").trim());
        paper.setDirName(request.getParameter("DIRECTORY").trim());

        boolean existed = !paper.store();

    } catch (NumberFormatException e){
        e.printStackTrace(System.out);
    } catch (JetWebException jwe){
        HTMLErrorWriter.write(out,jwe);

    }
    }

    public static void modifyPlots(HashMap<String,String> parameters, 
                   Paper paper) throws JetWebException {
    
    System.out.println("Modifying plots");
    if (paper.getPlots()==null) {
        return;
    }

    //Iterator<DataPlot> plotlist = paper.getPlots().iterator(); 
    //while (plotlist.hasNext()){
    for (DataPlot dPlot : paper.getPlots()){

        RealPlot plot = (RealPlot)dPlot;        
        
        int num = plot.getNumber();
        
        String title = parameters.get("TITLE"+num);
        if (title != null){
        
        plot.setTitle(title);
        plot.setXLabel(parameters.get("XLABEL"+num));
        plot.setYLabel(parameters.get("YLABEL"+num));
    
        String cutValueString = parameters.get("CUTVALUE"+num);

        String cutName = parameters.get("CUTNAME"+num);
        if(cutValueString!=null && 
           cutName!=null &&
           cutValueString.length()!=0){
            Double cutValue = Double.parseDouble(cutValueString);
            Cut cut = new Cut(cutName, cutValue);
            plot.getCutCollection().addCut(cut);
            }
        try {
            double scaleFactor 
            = Double.parseDouble(parameters.get("SCALE"+num));
            plot.setScale(scaleFactor);
            
            boolean tf = 
            (Boolean.valueOf(parameters.get("DEFSUM"+num))).booleanValue();
            plot.setDefaultSum(tf);
            
            tf = (Boolean.valueOf(parameters.get("ISSHAPE"+num))).booleanValue();;
            plot.setShape(tf);
            
            tf = (Boolean.valueOf(parameters.get("ISLOG"+num))).booleanValue();;
            plot.setLogarithmic(tf);
            
            plot.setCollisionId(Integer.parseInt(parameters.get("COLL"+num)));
            
            //Collision collision = new Collision(plot.getCollisionId());
            Iterator<PlotSwitch> switches = plot.getSwitches();
            while (switches.hasNext()){
            PlotSwitch ps = (PlotSwitch)switches.next();
            decodeSwitch(parameters,ps,String.valueOf(ps.getId()));
            if (!MCProcessType.checkCollision(plot.getCollisionId(),ps.getMCProcessTypeId())){
                plot.deleteSwitch(ps);
            }
            }
            
            // Decode the new switch, if there is one.
            PlotSwitch newps = new PlotSwitch();
            decodeSwitch(parameters,newps,num+"-new");
            newps.setPlotId(plot.getId());
            if (MCProcessType.checkCollision(plot.getCollisionId(),newps.getMCProcessTypeId())){
            plot.addSwitch(newps); 
            }

        } catch (Exception e) {
            System.out.println(e);
            throw new JetWebException(e,"Error parsing plot parameters");
        }

        String path = JetWebConfig.rootDirectory+"/"+JetWebConfig.plotCacheDirName
            +"/"+paper.getDirName();

        // Reread the XML for plots which have new files upload.
        if ( parameters.get("UPDATED"+num)!=null ){

            try {
            System.out.println("Paper Directory is:"+paper.getDirName());
            String xmlFile = path+"/plot"+plot.getNumber()+"."+JetWebConfig.graphicsType;
            System.out.println("Trying to read "+xmlFile);
            JetWebPlotReader reader = JetWebPlotReaderFactory.getNewPlotReader(xmlFile);
            reader.fillPlot(plot);
            //plot.setDataPoints(reader.getDataPoints());

            } catch (Exception e){
            throw new 
                JetWebException(e, "Corrupt XML file: plot not updated."+
                        "Paper: "+paper.getId()+": plot "+plot.getNumber());
            }
        }

        try {
            plot.store();
            System.out.println("Stored plot");
        } catch (JetWebException jwdb){
            throw new JetWebException(jwdb,"Error modifying plots");
        }

        JetWebHist.writeGraphics(plot,path);
        }
    }
    }
    public static void addPlot(HashMap<String,String> parameters, Paper paper,String inKey) throws JetWebException {
        

    System.out.println("Adding plot to paper "+paper.getId());

    String key = "-" + inKey;

    int newPlotId = paper.getNPlots();
    //RealPlot plot = new RealPlot(newPlotId,paper.getId());        

    String title = parameters.get("TITLE"+key);
    String hzsteerPlotId = parameters.get("HZSTEERPLOTID");
    String hzsteerPlotName = parameters.get("HZSTEERPLOT");
    String mcPlotId = parameters.get("HZMCPLOTID");

    RealPlot plot;

    Integer mcid = -1;

    if(hzsteerPlotId!=null &&
       !hzsteerPlotId.equals("")){

        Integer hpid;
        try{
        hpid = Integer.parseInt(hzsteerPlotId);
        if(mcPlotId!=null || !mcPlotId.equals("")){
            mcid = Integer.parseInt(mcPlotId);
        }else{
            mcid = -hpid;
            System.out.println
            ("Warning: plot id for MC plot not specified - " + 
             "assuming the negative of the data plot id");
        }
        }catch(NumberFormatException err){
        throw new JetWebException(err);
        }

        System.out.println("Using plot id " + hpid +
                   " for paper "+paper.getId());

        plot = new RealPlot(hpid, paper.getId());
    }else{
        System.out.println("Using plot id " + newPlotId +
                   " for paper "+paper.getId());
        plot = new RealPlot(newPlotId,paper.getId());
    }
    if (title != null){

        plot.setTitle(title);
        plot.setXLabel(parameters.get("XLABEL"+key));
        plot.setYLabel(parameters.get("YLABEL"+key));
        PlotSwitch pSwitch = new PlotSwitch();
        try {
        double scaleFactor 
            = Double.parseDouble(parameters.get("SCALE"+key));
        plot.setScale(scaleFactor);
        
        boolean tf = 
            (Boolean.valueOf(parameters.get("DEFSUM"+key))).booleanValue();
        plot.setDefaultSum(tf);
        
        tf = (Boolean.valueOf(parameters.get("ISSHAPE"+key))).booleanValue();;
        plot.setShape(tf);
        
        tf = (Boolean.valueOf(parameters.get("ISLOG"+key))).booleanValue();;
        plot.setLogarithmic(tf);
        
        //int procId = Integer.parseInt(parameters.get("DEFPROC"+key));
        //plot.setMCProcessType(new MCProcessType(procId));
            // Should be done via swtich.
        
        } catch (Exception e) {
        throw new JetWebException(e,"Error parsing plot parameters");
        }

        String path = JetWebConfig.rootDirectory+"/"+JetWebConfig.plotCacheDirName
        +"/"+paper.getDirName();

        try {
        System.out.println("Paper Directory is:"+paper.getDirName());
        File xmlFile = new File(path+"/plot-"+key+".xml");
        String xmlFileString = path + "/plot" + 
            plot.getNumber()+"."+JetWebConfig.graphicsType;

        System.out.println(parameters);
        System.out.println("hzsteerPlotId = "+hzsteerPlotId);
        System.out.println("hzsteerPlotName = "+hzsteerPlotName);

        if (!xmlFile.exists()) {

            if(hzsteerPlotId!=null &&
               !hzsteerPlotId.equals("") &&
               hzsteerPlotName!=null && 
               !hzsteerPlotName.equals("")){
            xmlFile = new File(hzsteerPlotName);
            xmlFileString = hzsteerPlotName.
                substring(0, hzsteerPlotName.lastIndexOf("/"));
            xmlFileString = xmlFileString + 
                "/plot" + hzsteerPlotId + ".aida";
            }else{

            System.out.println("Cannot find plot file " +
                       xmlFile.getPath());

            throw new JetWebException
                (xmlFile.getPath(),"File does not exist");
            }
        }

        File standardXML = new File(xmlFileString);
        xmlFile.renameTo(standardXML); 

        
        //      plot.readPointsFromXML();
        System.out.println("Trying to read "+xmlFileString);
        JetWebPlotReader reader = 
            JetWebPlotReaderFactory.getNewPlotReader(xmlFileString);
        //JetWebPlotReader reader = 
        //  JetWebPlotReaderFactory.getNewPlotReader(hzsteerPlotName);
        reader.setDirectory(paper.getDirName());
        reader.fillPlot(plot);
        plot.setNumber(mcid);
        String colIdString = parameters.get("COLL"+key);
        System.out.println("colIdString = "+colIdString);
        if(colIdString!=null && !colIdString.equals("")){
            int colId = Integer.parseInt(colIdString);
            System.out.println("Setting plot collision id to "+colId);
            plot.setCollisionId(colId);
        }
        //plot.setDataPoints(reader.getDataPoints());
        } catch (Exception e){
        throw new 
            JetWebException(e, "Corrupt XML file: plot not updated."+
                    "Paper: "+paper.getId()+": plot "+plot.getNumber());
        }

        try {
        plot.store();
        pSwitch.setPlotId(plot.getId());
        System.out.println("PROCNEW"+key);
        String procnew = parameters.get("PROCNEW"+key);
        Integer pid = 0;
        if(procnew!=null){
            pid = Integer.parseInt(procnew);
        
            
            pSwitch.setMCProcessTypeId(pid);
            pSwitch.store();
            plot.addSwitch(pSwitch);
        }
        System.out.println("back from plot.store()");
        } catch (JetWebException jwdb){
        throw new JetWebException(jwdb,"Error adding plot");
        }

        JetWebHist.writeGraphics(plot,path);
    }
    return;
    }

    public static void generatorDefaults(HttpServletRequest request){

    System.out.println("called generatorDefaults");
    
    try{

    MultipartParser mp = 
        new MultipartParser(request, 10*1024*1024); // 10MB
    
    Part part;
    while ((part = mp.readNextPart()) != null) {

        String name = part.getName();

        if (part.isFile()) {
    
        String destDirName = 
            "/home/jmonk/Cedar/Java/tomcat50-jwsdp/mouse/";
        
        File destDir = new File(destDirName);
        
        FilePart filePart = (FilePart) part;
        
        filePart.writeTo(destDir);
        
        }
    }
    }catch (Throwable e){
        System.out.println(e.getMessage());
    }
    return;
    }


    private static void decodeSwitch(HashMap<String,String> parameters, 
                     PlotSwitch ps, 
                     String label){
    
    String proca = parameters.get("PROC"+label);
    if (proca != null && !proca.trim().equals("undefined")) {

        ps.setMCProcessTypeId(Integer.parseInt(proca));

        try {
        String name = parameters.get("PARMNAME"+label);
        if (!name.trim().equals("undefined") 
            && !name.trim().equalsIgnoreCase("undefined/any")
            && !name.trim().equalsIgnoreCase("null")){
            ps.setParameterName(name);
        } else {
            ps.setParameterName(null);
        }
        
        try {
            ps.setParameterValueHigh(Double.parseDouble(parameters.get("PARMVALH"
                                           +label)));
        } catch (Exception e){
            // do nothing
        }
        try {
            ps.setParameterValueLow(Double.parseDouble(parameters.get("PARMVALL"
                                          +label)));
        } catch (Exception e){
            // Do nothing.
        }
        } catch (Exception e){
        // Do nothing
        }
        


        try {
        String name = parameters.get("GEN"+label);
        if (!name.trim().equalsIgnoreCase("undefined") 
            && !name.trim().equalsIgnoreCase("undefined/any")
            && !name.trim().equalsIgnoreCase("null")){
            ps.setGeneratorName(name);
            //System.out.println("Name: "+name);
        } else {
            ps.setGeneratorName(null);
        }
        } catch (Exception e){
        // Do nothing.
        }
        
        
        try {
        ps.setGeneratorVersion(Double.parseDouble(parameters.get("VAL"+label)));
        } catch (Exception e){
        // Do nothing.
        }
        

    }

    }

    public static Vector<MCProcessType> makeMCProcessList(HttpServletRequest request) 
    throws JetWebException {
    
    Vector<MCProcessType> processList = new Vector<MCProcessType>();

    String[] procList = request.getParameterValues("SELECTEDPROCESSID");

    if (procList!=null){
        try { 
        for (int i=0; i<procList.length;i++){   
            
            MCProcessType proc 
            = new MCProcessType(Integer.parseInt(procList[i]));

            if(proc.isValid()){// html page shouldn't even offer
                           // the possibility to generate a 
                           // non-valid proc, no harm in checking!

            /* no - just generate the main processes as single runs.
            Vector<Integer> compatProcIds = 
                proc.getCompatibleProcesses();

            for(Integer id: compatProcIds){
                
                MCProcessType componentProc = 
                new MCProcessType(id);


                if (!processList.contains(componentProc)){
                processList.add(componentProc);
                }
            */
            if (!processList.contains(proc)){
                processList.add(proc);
            }
            }
        }
        } catch (NumberFormatException e){
        throw new JetWebException(e,"Failed to build list of processTypes");
        }       
    }

    return processList;

    }

    public static void getGeneratorParameters(HttpServletRequest request, 
                          Generator gen) 
    throws JetWebException {

    if (gen==null) return;
    
    // We already know the generator, so lets loop over the
    // generator parameters and look for appropriate settings
    Set<Map.Entry<String,Integer>> intParameters;
    Set<Map.Entry<String,Double>>  realParameters;
    Set<Map.Entry<String,HashMap<Integer,Integer>>> intArrays;
    Set<Map.Entry<String,HashMap<Integer,Double>>> realArrays;

    String[] tmp;

    // Set the integer parameters.
    Set<String> names = gen.getIntNames(); 
    for (String pname : names){
        tmp = request.getParameterValues(pname);
        if (tmp!=null && !tmp[0].trim().equals("")) {
        gen.setParameter(pname,Integer.parseInt(tmp[0].trim()));
        }
    } 

    // Now the real parameters.
    names = gen.getRealNames(); 
    for (String pname : names){
        tmp = request.getParameterValues(pname);
        if (tmp!=null && !tmp[0].trim().equals("")) {
        gen.setParameter(pname,Double.parseDouble(tmp[0].trim()));
        }
    } 
    
    // Now the integer arrays.
    intArrays = gen.getIntParameterArrays().entrySet(); 
    names = gen.getIntArrayNames();
    String pname;
    for (String aname : names){

        for (int i=gen.getMinIndex(aname); i<gen.getMaxIndex(aname);i++){
        pname = aname+"-"+i;
        tmp = request.getParameterValues(pname);
        if (tmp!=null && !tmp[0].trim().equals("")) {
            gen.setIntElement(aname,i,Integer.parseInt(tmp[0].trim()));
        }
        }
    }

    // Now the real arrays.
    realArrays = gen.getRealParameterArrays().entrySet(); 
    names = gen.getRealArrayNames();
    for (String aname : names){

        for (int i=gen.getMinIndex(aname); i<gen.getMaxIndex(aname);i++){
        pname = aname+"-"+i;
        tmp = request.getParameterValues(pname);
        if (tmp!=null && !tmp[0].trim().equals("")) {
            gen.setRealElement(aname,i,Double.parseDouble(tmp[0].trim()));
        }
        }
    }
    
    getCuts(request, gen);
    return;
    }


    private static void getCuts(HttpServletRequest request, Generator gen){
    
    initCuts();

    for(Map.Entry entry: allowedCuts_.entrySet()){

        String HTMLName = (String)entry.getKey();
        String CutName = (String) entry.getValue();
        //String[] tmp = request.getParameterValues("GENPTMIN");
        String[] tmp = request.getParameterValues(HTMLName);
        if(tmp!=null && tmp.length==1){
        Cut cut = new Cut(CutName, Double.parseDouble(tmp[0]));
        gen.addCut(cut);
        }else{
        System.out.println("Using " +
                   CutName + 
                   " from generator defaults");
        }
    }
    return;
    }

    private static void initCuts(){
    if(initCuts_){
        initCuts_ = false;
        allowedCuts_.put("GENPTMIN", "PTMin");
    }
    return;
    }

    public static void deletePlots(HashMap<String,String> parameters, 
                   Paper paper) throws JetWebException {
    
    Vector<DataPlot> togo = new Vector<DataPlot>();
    Collection<? extends DataPlot> plotList = paper.getPlots();

    for (DataPlot plot : plotList){
        
        int num = plot.getNumber();
        
        String deleteMe = parameters.get("DELETEPLOT"+num);
        if (deleteMe != null){
        
        System.out.println("Requested deletion of plot "
                   +plot.getNumber()+", id "+plot.getId()
                   +", paper "+paper.getId());
        RealPlot rplot = (RealPlot)plot;
        rplot.delete();
        togo.add(plot);
        }
    }
    plotList.removeAll(togo);
    }

    public static void deletePaper(HttpServletRequest request)
    throws JetWebException {
    
    int paperId= Integer.parseInt(request.getParameter("PAPERID"));     
    Paper paper = new Paper(paperId);
        
    System.out.println("Requested deletion of paper "+paper.getId());
    paper.delete();

    }

    public static MCProcessType buildProc(HttpServletRequest request) throws JetWebException {

    MCProcessType proc = new MCProcessType();
 
    try {
        String[] tmp = request.getParameterValues("PROCESSID");
        Integer id = Integer.parseInt(tmp[0]);
        proc.setId(id);
    } catch (Exception e){
        throw new JetWebException(e,"proc id");
    }

    try {
        String[] tmp = request.getParameterValues("COLLISIONID");
        Collision coll = new Collision(Integer.parseInt(tmp[0]));
        proc.setCollision(coll);
    } catch (Exception e){
        throw new JetWebException(e,"collision");
    }

    try {
        String[] tmp = request.getParameterValues("ISVALID");       
        proc.setIsValid(Boolean.parseBoolean(tmp[0]));
    } catch (Exception e){
        throw new JetWebException(e,"valid");
    }


    try {
        String[] tmp = request.getParameterValues("PROCNAME");
        proc.setMCProcessName(tmp[0]);
    } catch (Exception e){
        throw new JetWebException(e,"process name");
    }

    // Now parse the string of compatible process types
    try {
        String[] tmp = request.getParameterValues("PLIST");
        //System.out.println(tmp[0]);
        Vector<Integer> plist = new Vector<Integer>();

        Scanner sc = new Scanner(tmp[0]).useDelimiter(":");
        while (sc.hasNextInt()){
        plist.add(sc.nextInt());
        }
        sc.close(); 
        proc.setCompatibleProcesses(plist);

    } catch (Exception e){
        throw new JetWebException(e,"compatible proc list");
    }


    return proc;

    }
}

Generated Wed Jan 17 09:14:27 GMT 2007