001/**
002 * 
003 */
004package org.dllearner.server;
005
006import org.apache.commons.lang.exception.ExceptionUtils;
007import org.slf4j.Logger;
008import org.slf4j.LoggerFactory;
009
010import javax.servlet.ServletException;
011import javax.servlet.http.HttpServlet;
012import javax.servlet.http.HttpServletRequest;
013import javax.servlet.http.HttpServletRequestWrapper;
014import javax.servlet.http.HttpServletResponse;
015import java.io.BufferedReader;
016import java.io.IOException;
017import java.io.InputStreamReader;
018import java.net.URLDecoder;
019import java.util.*;
020
021/**
022 * @author didier
023 * 
024 */
025public class ConfGeneratorServlet extends HttpServlet {
026    
027    private Logger logger = LoggerFactory.getLogger(ConfGeneratorServlet.class);
028    
029    private String template;
030    
031    public ConfGeneratorServlet() {
032        BufferedReader input = new BufferedReader(new InputStreamReader(ConfGeneratorServlet.class
033                .getClassLoader().getResourceAsStream("config.template")));
034        StringBuilder builder = new StringBuilder();
035        try {
036            while (input.ready()) {
037                builder.append(input.readLine());
038                builder.append("\n");
039            }
040        } catch (IOException e) {
041            logger.error("", ExceptionUtils.getRootCause(e));
042        } finally {
043            try {
044                input.close();
045            } catch (IOException e) {
046                logger.error("", ExceptionUtils.getRootCause(e));
047            }
048        }
049        template = builder.toString();
050    }
051    
052    /*
053     * (non-Javadoc)
054     * 
055     * @see
056     * javax.servlet.http.HttpServlet#doGet(javax.servlet.http.HttpServletRequest
057     * , javax.servlet.http.HttpServletResponse)
058     */
059    @Override
060    protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException,
061            IOException {
062        handle(req, resp);
063    }
064    
065    /*
066     * (non-Javadoc)
067     * 
068     * @see
069     * javax.servlet.http.HttpServlet#doPost(javax.servlet.http.HttpServletRequest
070     * , javax.servlet.http.HttpServletResponse)
071     */
072    @Override
073    protected void doPost(HttpServletRequest req, HttpServletResponse resp)
074            throws ServletException, IOException {
075        handle(req, resp);
076    }
077    
078    /**
079     * @param req
080     * @param resp
081     */
082    private void handle(HttpServletRequest req, HttpServletResponse resp) {
083        String tmp = template;
084        try {
085            String[] pos, neg = null;
086            if (!Rest.isSet("pos", req)) {
087                System.out.println("blub");
088                req.getRequestDispatcher("/WEB-INF/sparqr.html").forward(req, resp);
089                return;
090            } else {
091                pos = URLDecoder.decode(req.getParameter("pos"), "UTF-8").split(",");
092                if (Rest.isSet("neg", req)) {
093                    neg = URLDecoder.decode(req.getParameter("neg"), "UTF-8").split(",");
094                }
095            }
096            StringBuilder posStr = new StringBuilder();
097            StringBuilder negStr = new StringBuilder();
098            StringBuilder instances = new StringBuilder();
099            
100            if (neg != null) {
101                tmp=tmp.replace("<LPTYPE>", "\"posNegStandard\"");
102                for (int i = 0; i < neg.length; i++) {
103                    if (i > 0) {
104                        negStr.append(",\n");
105                        instances.append(",\n");
106                    }
107                        negStr.append("\"");
108                        negStr.append(neg[i].replaceAll("\"|\n|\\s", ""));
109                        negStr.append("\"");
110                        instances.append("\"");
111                        instances.append(neg[i].replaceAll("\"|\n|\\s", ""));
112                        instances.append("\"");
113                }
114            } else {
115                tmp=tmp.replace("<LPTYPE>", "\"posOnlyLP\"");
116                tmp=tmp.replace("lp.negativeExamples = {\n<NEGATIVES>\n} ", "");
117            }
118            
119            for (int i = 0; i < pos.length; i++) {
120                if (i > 0) {
121                    posStr.append(",\n");
122                }
123                if (instances.length() > 0) {
124                    instances.append(",\n");
125                }
126                    posStr.append("\"");
127                    posStr.append(pos[i].replaceAll("\"|\n|\\s", ""));
128                    posStr.append("\"");
129                    instances.append("\"");
130                    instances.append(pos[i].replaceAll("\"|\n|\\s", ""));
131                    instances.append("\"");
132            }
133            tmp=tmp.replace("<INSTANCES>", instances.toString());
134            tmp=tmp.replace("<POSITIVES>", posStr.toString());
135            tmp=tmp.replace("<NEGATIVES>", negStr.toString());
136            Map<String, String[]> additionalParams = new HashMap<>();
137            additionalParams.put("conf", new String[]{tmp});
138            System.out.println(tmp);
139            ModifiableWrappedRequest request = new ModifiableWrappedRequest(req, additionalParams);
140            request.getRequestDispatcher("/rest").forward(request, resp);
141        } catch (ServletException | IOException e) {
142            logger.error("", ExceptionUtils.getRootCause(e));
143            try {
144                resp.sendError(500, ExceptionUtils.getRootCause(e).toString());
145            } catch (IOException e1) {
146                logger.error("", ExceptionUtils.getRootCause(e1));
147            }
148        }
149    }
150    
151    public class ModifiableWrappedRequest extends HttpServletRequestWrapper
152    {
153        private final Map<String, String[]> modifiableParameters;
154        private Map<String, String[]> allParameters = null;
155
156        /**
157         * Create a new request wrapper that will merge additional parameters into
158         * the request object without prematurely reading parameters from the
159         * original request.
160         * 
161         * @param request
162         * @param additionalParams
163         */
164        public ModifiableWrappedRequest(final HttpServletRequest request, 
165                                                        final Map<String, String[]> additionalParams)
166        {
167            super(request);
168            modifiableParameters = new TreeMap<>();
169            modifiableParameters.putAll(additionalParams);
170        }
171
172        @Override
173        public String getParameter(final String name)
174        {
175            String[] strings = getParameterMap().get(name);
176            if (strings != null)
177            {
178                return strings[0];
179            }
180            return super.getParameter(name);
181        }
182
183        @Override
184        public Map<String, String[]> getParameterMap()
185        {
186            if (allParameters == null)
187            {
188                allParameters = new TreeMap<>();
189                allParameters.putAll(super.getParameterMap());
190                allParameters.putAll(modifiableParameters);
191            }
192            //Return an unmodifiable collection because we need to uphold the interface contract.
193            return Collections.unmodifiableMap(allParameters);
194        }
195
196        @Override
197        public Enumeration<String> getParameterNames()
198        {
199            return Collections.enumeration(getParameterMap().keySet());
200        }
201
202        @Override
203        public String[] getParameterValues(final String name)
204        {
205            return getParameterMap().get(name);
206        }
207    }
208
209}