Java Examples for org.springframework.web.bind.annotation.RequestParam

@RequestMapping
public ResponseEntity<ApiError> handleErrorPage(@RequestParam("errorCode") final String errorCode, final WebRequest request) {
    final HttpStatus httpStatus = HttpStatus.valueOf((Integer) request.getAttribute(RequestDispatcher.ERROR_STATUS_CODE, RequestAttributes.SCOPE_REQUEST));
    final ApiError apiError = apiErrorCreator.createApiError(request, errorCode, httpStatus.getReasonPhrase());
    return new ResponseEntity<>(apiError, httpStatus);
}

//limit:10
//offset:5
@RequestMapping("/userActionList")
@ResponseBody
public PageResult pauseJobExecution(@RequestParam(value = "limit", required = true) int limit, @RequestParam(value = "offset", required = true) int offset, @RequestParam(value = "search", required = false) String search) {
    if (search != null)
        search = search.trim();
    PageResult pageResult = new PageResult();
    pageResult.setRows(userActionRecordService.selectUserActionRecordList(limit, offset, search));
    pageResult.setTotal(userActionRecordService.selectUserActionRecordCount(search));
    return pageResult;
}

@RequestMapping(method = RequestMethod.GET)
public ModelAndView handleRequestInternal(@RequestParam(value = "globalPrdCategoryNum", required = true) String globalPrdCategoryNum) {
    ModelAndView modelAndView = new ModelAndView("viewProductCategoryDetails");
    List<ProductCategoryTypeDto> typeDto = adminServiceFacade.retrieveProductCategoryTypes();
    ProductCategoryDetailsDto detailsDto = adminServiceFacade.retrieveProductCateogry(globalPrdCategoryNum);
    modelAndView.addObject("typeDto", typeDto);
    modelAndView.addObject("detailsDto", detailsDto);
    modelAndView.addObject("breadcrumbs", new AdminBreadcrumbBuilder().withLink("viewProductCategoryDetails", "viewProductCategoryDetails.ftl").build());
    modelAndView.addObject("globalPrdCategoryNum", globalPrdCategoryNum);
    return modelAndView;
}

@RequestMapping(method = RequestMethod.GET)
public ModelAndView handleRequestInternal(@RequestParam(value = "globalPrdCategoryNum", required = true) String globalPrdCategoryNum) {
    ModelAndView modelAndView = new ModelAndView("viewProductCategoryDetails");
    List<ProductCategoryTypeDto> typeDto = adminServiceFacade.retrieveProductCategoryTypes();
    ProductCategoryDetailsDto detailsDto = adminServiceFacade.retrieveProductCateogry(globalPrdCategoryNum);
    modelAndView.addObject("typeDto", typeDto);
    modelAndView.addObject("detailsDto", detailsDto);
    modelAndView.addObject("breadcrumbs", new AdminBreadcrumbBuilder().withLink("viewProductCategoryDetails", "viewProductCategoryDetails.ftl").build());
    modelAndView.addObject("globalPrdCategoryNum", globalPrdCategoryNum);
    return modelAndView;
}

public void controller(PageModel model, @RequestParam(value = "stopAskingToConfigure", required = false) Boolean stopAskingToConfigure) {
    AtlasService service = Context.getService(AtlasService.class);
    if (stopAskingToConfigure != null && stopAskingToConfigure) {
        service.setStopAskingToConfigure(true);
    }
    AtlasData data = service.getAtlasData();
    model.addAttribute("data", data);
    model.addAttribute("stopAskingToConfigure", service.getStopAskingToConfigure());
}

@ResponseBody
@RequestMapping
protected Long orderWarn(HttpServletRequest request, @RequestParam("lastTime") long lastTime) {
    AdminUser adminUser = securityVerifier.getPersistentAdminUser();
    FulfillmentLocation fulfillmentLocation = ((MyAdminUser) adminUser).getFulfillmentLocation();
    Long count = myOrderService.countOrderByTime(new Date(lastTime), fulfillmentLocation);
    // Date(lastTime),fulfillmentLocation);
    return count;
}

@RequestMapping(method = RequestMethod.GET, value = "tags", params = "tagName")
List<TagResource> searchTags(@RequestParam("tagName") Optional<String> tagNameOpt) {
    return tagNameOpt.map( tagName -> {
        if (tagName.length() > 1) {
            return tagService.findLikeTagName(tagName).stream().map( tag -> beanMapper.map(tag, TagResource.class)).collect(Collectors.toList());
        } else {
            return Collections.<TagResource>emptyList();
        }
    }).orElseGet(this::getTags);
}

/**
	 * 注册用户
	 */
@RequestMapping(method = RequestMethod.POST)
public String register(User user, @RequestParam("departmentId") Integer departmentId, Model model) {
    List<Group> groupList = Lists.newArrayList();
    // 注册用户默认给予 2:apply 申请人 的��角色.
    groupList.add(comm.accountService.getGroup(AccountConstant.DefaultGroups.apply.toInteger()));
    user.setGroupList(groupList);
    // 给予 2:apply 申请人 的用户类型
    user.setType(AccountConstant.UserTypes.apply.toInteger());
    user.setDepartment(comm.accountService.getDepartment(departmentId));
    comm.accountService.registerUser(user);
    // 登录系统
    UsernamePasswordToken token = new UsernamePasswordToken();
    token.setPassword(user.getPlainPassword().toCharArray());
    token.setUsername(user.getLoginName());
    SecurityUtils.getSubject().login(token);
    return "redirect:/";
}

@RequestMapping(value = "/comentarios.htm", method = RequestMethod.GET)
@ModelAttribute(COMENTARIO)
public Comentario verPost(@RequestParam(value = "idPost", required = false) Long id, Model model) {
    Comentario comentario = new Comentario();
    if (id != null) {
        List<Comentario> comentarios = comentarioService.listarTodosLosComentariosPorPost(id);
        Post post = postService.obtenerPost(id);
        comentario.setIdPost(post.getId());
        model.addAttribute(COMENTARIOS, comentarios);
        model.addAttribute(POST, post);
    }
    return comentario;
}

@RequestMapping(value = "/movie", method = RequestMethod.GET)
public Map<String, Double> getSimilarMovies(@RequestParam(value = "movie1", required = true) String movieOne, @RequestParam(value = "movie2", required = true) String movieTwo, HttpServletRequest request, HttpServletResponse response) {
    System.out.println(movieOne + movieTwo);
    EmbeddedNeo4j e = new EmbeddedNeo4j();
    e.startUp();
    Map m = e.getUsersFromDb(movieOne, movieTwo);
    e.shutDown();
    return m;
//		List<String> l = new LinkedList<String>();
//		l.add(movieOne);
//		l.add(movieTwo);
//		return l;
}

@RequestMapping(method = RequestMethod.GET, value = "/audit/messages")
@ResponseBody
public List<AuditMessageItem> getAuditMessages(@RequestParam(value = "previousAuditMessageIndex", defaultValue = "0") long previousIndex) throws IOException {
    List<AuditMessage> messages = auditor.messagesSince(previousIndex);
    return with(messages).convert(new Converter<AuditMessage, AuditMessageItem>() {

        @Override
        public AuditMessageItem convert(AuditMessage auditMessage) {
            return AuditMessageItem.from(auditMessage);
        }
    });
}

@RequestMapping(value = "/html2pdf", method = RequestMethod.GET)
protected void processRequest(@RequestParam("url") String url, HttpServletRequest request, HttpServletResponse response) throws Exception {
    try {
        IOUtils.copy(generationPdfDzOrder(url, request.getSession().getServletContext().getRealPath("/")), response.getOutputStream());
        TimeUnit.SECONDS.sleep(2);
    } catch (Exception e) {
        System.out.print(e.toString());
    } finally {
        response.getOutputStream().close();
    }
}

@RequestMapping(value = "/rest-api/programs-with-products", method = GET, headers = ACCEPT_JSON)
public ResponseEntity<RestResponse> getProgramWithProductsByFacility(@RequestParam String facilityCode) {
    try {
        List<ProgramWithProducts> programsWithProducts = programService.getAllProgramsWithProductsByFacilityCode(facilityCode);
        return response("programsWithProducts", programsWithProducts);
    } catch (DataException e) {
        return error(e.getOpenLmisMessage(), BAD_REQUEST);
    }
}

public void main(@RequestParam("test") String input) throws Exception {
    Document doc = XmlUtils.loadDoc("/testcode/xpath/data.xml");
    String query = "//groups/group[@id='" + input + "']/writeAccess/text()";
    XPathAPI api1 = getXPathAPI();
    api1.evaluate(null, null, query, null);
    api1.selectNodeList(null, null, query, null);
    JDKXPathAPI api2 = getJDKXPathAPI();
    api2.evaluate(null, null, query, null);
    api2.selectNodeList(null, null, query, null);
    XalanXPathAPI api3 = getXalanXPathAPI();
    api3.evaluate(null, null, query, null);
    api3.selectNodeList(null, null, query, null);
}

@RequestMapping(method = RequestMethod.GET, params = { "username", "password" }, value = "create")
public User create(@RequestParam(required = true, value = "username") final String usernaem, @RequestParam(required = true, value = "password") final String password) {
    final User user = new User();
    user.setEmail(String.format("%s@gmail.com", UUID.randomUUID()));
    user.getAccount().setUsername(usernaem);
    user.getAccount().setPassword(encoder.encode(password));
    user.getAccount().addAuthorities("ROLE_ADMIN");
    user.setFirstName("Dave");
    user.setLastName("Tester");
    return repository.save(user);
}

@RequestMapping(method = RequestMethod.GET)
public void getstyle(HttpServletRequest request, HttpServletResponse response, @RequestParam(value = "QUERYID") String queryId, @RequestParam(value = "STYLEID") String styleId) throws Exception {
    SimpleFeatureSource results = (SimpleFeatureSource) getCache().getResults(queryId).getFeatureSource();
    Style style = getCache().getStyle(styleId).getGtStyle(results.getFeatures());
    if (style == null) {
        throw new IllegalArgumentException("There is no style cached with id: " + styleId);
    }
    response.setContentType("application/xml");
    PrintWriter writer = response.getWriter();
    try {
        SLDTransformer styleTransform = new SLDTransformer();
        styleTransform.setEncoding(Charset.forName("UTF-8"));
        styleTransform.setIndentation(4);
        String xml = styleTransform.transform(style);
        writer.write(xml);
    } finally {
        writer.close();
    }
}

@RequestMapping(method = RequestMethod.GET)
public String list(@RequestParam(value = "searchName", required = false) String searchName, @RequestParam(value = "pageSize", required = false) Integer pageSize, @RequestParam(value = "currentPage", required = false) Integer currentPage, Model model, HttpServletRequest request) {
    HospitalCoreService hcs = Context.getService(HospitalCoreService.class);
    SimpleDateFormat sdf = new SimpleDateFormat("dd/MM/yyyy");
    String dateStr = sdf.format(new Date());
    model.addAttribute("currentDate", dateStr);
    return "/module/hospitalcore/downloadasCSV/downloadCsv";
}

@RequestMapping(value = "/functions", method = RequestMethod.GET, produces = MediaType.APPLICATION_JSON_VALUE)
@ResponseBody
public synchronized List<String> getRFunctions(@RequestParam(required = false) final String startsWith) throws RException {
    if (rFunctions == null) {
        rFunctions = loadRFunctions();
    }
    if (startsWith == null) {
        return rFunctions;
    } else {
        List<String> result = new ArrayList<String>();
        for (String funct : rFunctions) {
            if (funct.startsWith(startsWith)) {
                result.add(funct);
            }
        }
        return result;
    }
}

@RequestMapping
public String entry(HttpServletRequest httpRequest, @RequestParam("app") String app) {
    AppConfiguration appConfig = getAppConfigByApp(app);
    if (appConfig == null) {
        httpRequest.setAttribute(ERROR, "App is not configured");
        return "diagram";
    }
    try {
        DataFlowsObject dfObj = DataFlowsUtls.getDataFlow(appConfig.getMachine(), appConfig.getPort());
        dfObj.setNodes(dfObj.getNodes());
        httpRequest.setAttribute(DATA, JsonUtil.toJson(dfObj));
    } catch (Exception e) {
        httpRequest.setAttribute(ERROR, "Connect failed, please check whether you have set machine or pool, port correctly");
    }
    return "diagram";
}

/**
	 * 组织�选。
	 * 
	 * @param id
	 * @param excludeChildrenId
	 * @param request
	 * @param modelMap
	 * @return
	 */
@RequestMapping("f7_org_tree.do")
public String f7OrgTree(Integer id, @RequestParam(defaultValue = "true") Boolean allowRoot, Integer excludeChildrenId, HttpServletRequest request, org.springframework.ui.Model modelMap) {
    List<Org> list = service.findList();
    Org bean = null, excludeChildrenBean = null;
    if (id != null) {
        bean = service.get(id);
    }
    if (excludeChildrenId != null) {
        excludeChildrenBean = service.get(excludeChildrenId);
    }
    modelMap.addAttribute("id", id);
    modelMap.addAttribute("allowRoot", allowRoot);
    modelMap.addAttribute("excludeChildrenId", excludeChildrenId);
    modelMap.addAttribute("bean", bean);
    modelMap.addAttribute("excludeChildrenBean", excludeChildrenBean);
    modelMap.addAttribute("list", list);
    return "core/org/f7_org_tree";
}

@RequestMapping("tree-list")
public String list(@RequestParam(value = "partyStructTypeId", required = false) Long partyStructTypeId, Model model) {
    String tenantId = tenantHolder.getTenantId();
    List<PartyStructType> partyStructTypes = partyStructTypeManager.findBy("tenantId", tenantId);
    List<PartyEntity> partyEntities = partyService.getTopPartyEntities(partyStructTypeId);
    model.addAttribute("partyStructTypes", partyStructTypes);
    model.addAttribute("partyEntities", partyEntities);
    return "party/tree-list";
}

@RequestMapping(value = "/cmmsMachineParts/workerCosts.xls", method = RequestMethod.GET)
public ModelAndView generatePlannedEventsReport(@RequestParam("sourceCost") final Long sourceCost, @RequestParam("dateFrom") String dateFromString, @RequestParam("dateTo") String dateToString) {
    try {
        HashMap<String, Object> filtersMap = new HashMap<>();
        Date dateFrom = df.parse(dateFromString);
        Date dateTo = df.parse(dateToString);
        filtersMap.put(SourceCostReportFilterFields.FROM_DATE, dateFrom);
        filtersMap.put(SourceCostReportFilterFields.TO_DATE, dateTo);
        filtersMap.put(SourceCostReportFilterFields.SOURCE_COST, sourceCost);
        return new ModelAndView("workerCostsXlsView", "filtersMap", filtersMap);
    } catch (ParseException ex) {
        throw new RuntimeException(ex);
    }
}

@RequestMapping(method = RequestMethod.GET)
public String getNavigation(Model model, @RequestParam String searchUrl, @RequestParam String active, @RequestParam(required = false) String searchString) {
    NavigationResource navResource = new NavigationResource(active, searchString != null ? searchString : "");
    navResource.add(linkTo(moviesBaseUrl).path(NavPathFragment.MOVIES).withRel(NavRelation.MOVIES));
    navResource.add(linkTo(shopBaseUrl).withRel(NavRelation.SHOP));
    navResource.add(linkTo(actorsBaseUrl).path(NavPathFragment.ACTORS).withRel(NavRelation.ACTORS));
    navResource.add(linkTo(moviesBaseUrl).path(NavPathFragment.LOGOUT).withRel(NavRelation.LOGOUT));
    navResource.add(linkTo(searchUrl).withRel(NavRelation.SEARCH));
    model.addAttribute("navResource", navResource);
    return "navigation/navigation";
}

@RequestMapping(method = RequestMethod.GET)
@ResponseBody
public Object jqueryValidationEngineValidate(HttpServletRequest request, @RequestParam(value = "fieldId", required = false) String fieldId, @RequestParam(value = "fieldValue", required = false) String fieldValue) {
    ValidateResponse response = ValidateResponse.newInstance();
    if (JCaptcha.hasCaptcha(request, fieldValue) == false) {
        response.validateFail(fieldId, "验��错误");
    } else {
        response.validateSuccess(fieldId, "验��正确");
    }
    return response.result();
}

@RequestMapping(value = "/module/CDAGenerator/detailPagecdatypes", method = RequestMethod.GET)
public void manage(@RequestParam(required = false, value = "templateid") String id, ModelMap model) {
    List<BaseCdaTypeHandler> singleCdaType = null;
    CDAGeneratorService cdaser = (CDAGeneratorService) Context.getService(CDAGeneratorService.class);
    singleCdaType = cdaser.getAllCdaTypeChildHandlers();
    for (int i = 0; i < singleCdaType.size(); i++) {
        BaseCdaTypeHandler b = singleCdaType.get(i);
        if (b.templateid.equals(id)) {
            model.addAttribute("detailcda", b);
        }
    }
}

@ResponseBody
@RequestMapping(method = RequestMethod.GET)
public SimpleObject get(@RequestParam(value = "privileges") String privileges) {
    SimpleObject results = new SimpleObject();
    if (StringUtils.isNotEmpty(privileges)) {
        try {
            results.put("hasPrivileges", Context.hasPrivilege(privileges));
        } catch (Exception ex) {
            LOG.error("Error checking privileges. ", ex);
        }
    }
    return results;
}

/**
	 * Retrieves either an existing or new report to edit
	 */
@RequestMapping("/module/reporting/reports/reportEditor")
public void editReport(ModelMap model, @RequestParam(required = false, value = "uuid") String uuid, @RequestParam(required = false, value = "type") Class<? extends ReportDefinition> type) {
    ReportDefinitionService rs = Context.getService(ReportDefinitionService.class);
    ReportDefinition r = rs.getDefinition(uuid, type);
    model.addAttribute("report", r);
    if (StringUtils.isNotEmpty(uuid)) {
        List<ReportDesign> designs = Context.getService(ReportService.class).getReportDesigns(r, null, false);
        model.addAttribute("designs", designs);
    }
}

@SuppressWarnings("deprecation")
@RequestMapping(method = RequestMethod.GET)
protected ModelAndView handleRequestInternal(@RequestParam("s_year") Integer s_year, @RequestParam("s_month") Integer s_month, @RequestParam("s_day") Integer s_day, @RequestParam("e_year") Integer e_year, @RequestParam("e_month") Integer e_month, @RequestParam("e_day") Integer e_day, @RequestParam("branch") Integer branch, @RequestParam("type") Integer type, @RequestParam("assignment") Integer assignment) throws Exception {
    Date start = new Date();
    Date end = new Date();
    start.setYear(s_year);
    start.setMonth(s_month);
    start.setDate(s_day);
    end.setYear(e_year);
    end.setMonth(e_month);
    end.setDate(e_day);
    List<BaseModel> hours = statDAO.getHourReportByUserByPeriodByAssignmentByTypeByBranch(assignment, branch, type, start, end);
    return new ModelAndView("userassignmentreporttoxlsview", "Hours", hours);
}

/**
	 * TODO: Check this against AjaxRequestController
	 * @param name
	 * @return
	 */
@RequestMapping("/users-list")
@ResponseBody
public List<JsonKeyValue> getUsersList(@RequestParam("q") String name) {
    List<JsonKeyValue> values = new ArrayList<>();
    List<BaseUser> users = this.userService.findUsersLikeLastName(name, ajaxMaxResult);
    for (BaseUser user : users) {
        JsonKeyValue keyValue = new JsonKeyValue(user.getId(), user.getFullName());
        values.add(keyValue);
    }
    return values;
}

/**
	 * Gives stream ids that have been on recently-updated playlists, one per line (text/plain response type)
	 */
@RequestMapping("/recent-activity")
public void showStreamIdsOnRecentPlaylists(@RequestParam(value = "maxAgeMs", required = false) Long maxAgeMs, HttpServletRequest req, HttpServletResponse resp) throws IOException {
    long tenMinsInMs = (long) (10 * 60 * 1000);
    if (maxAgeMs == null || maxAgeMs > tenMinsInMs)
        maxAgeMs = tenMinsInMs;
    List<MidasPlaylist> playlists = midas.getRecentPlaylists(maxAgeMs);
    Set<String> streamIds = new HashSet<String>();
    StringBuffer sb = new StringBuffer("Returning");
    sb.append(playlists.size()).append(" recently-modified playlists to ");
    sb.append(req.getRemoteAddr());
    boolean first = true;
    for (MidasPlaylist pl : playlists) {
        if (first) {
            sb.append(": ");
            first = false;
        } else
            sb.append(", ");
        sb.append(pl.getTitle()).append("(id ").append(pl.getPlaylistId()).append(")");
        streamIds.addAll(pl.getStreamIds());
    }
    log.info(sb);
    resp.setStatus(HttpServletResponse.SC_OK);
    resp.setContentType("text/plain");
    PrintWriter out = new PrintWriter(resp.getOutputStream());
    for (String sid : streamIds) {
        out.println(sid);
    }
    out.close();
}

@RequestMapping("/rss")
public ModelAndView showRss(@RequestParam String listId, HttpServletRequest request) throws Exception {
    ModelAndView mv = new ModelAndView();
    TodoList todoList = todoListsService.unsecuredFindTodoList(listId);
    if (todoList.isRssAllowed()) {
        mv.addObject("todoList", todoList);
        mv.addObject("link", request.getScheme() + "://" + request.getServerName() + ":" + request.getServerPort() + request.getContextPath() + "/tudu/lists");
        mv.setView(new InternalResourceView("/servlet/rss"));
    } else {
        if (log.isDebugEnabled()) {
            log.debug("Rendering RSS feed for Todo List ID '" + todoList.getListId() + "' is not allowed");
        }
        mv.setViewName("rss_not_allowed");
    }
    return mv;
}

@RequestMapping(value = "/getAsync.mvc")
@ResponseBody
public ResultDto getAsync(@RequestParam(value = "portalWidth", required = false) String width, @RequestParam(value = "targetDiv", required = true) String targetDiv, HttpServletRequest request, HttpServletResponse response, Model model) {
    String threadName = Thread.currentThread().getName();
    ResultDto dto = new ResultDto();
    try {
        dto = asyncService.findBalanceAsync(targetDiv);
    } catch (Exception e) {
        e.printStackTrace();
        dto.setContent(e.getMessage());
        dto.setProcessCode(ResultCode.ERROR);
    }
    return dto;
}

@RequestMapping(value = "/upload", method = RequestMethod.POST)
@ResponseBody
public String handleFileUpload(@RequestParam("name") String name, @RequestParam("file") MultipartFile file) {
    if (!file.isEmpty()) {
        try {
            try (BufferedOutputStream stream = new BufferedOutputStream(new FileOutputStream(new File(name)))) {
                stream.write(file.getBytes());
            }
            return "You successfully uploaded " + name + "!";
        } catch (IOException e) {
            return "You failed to upload " + name + " => " + e.getMessage();
        }
    } else {
        return "You failed to upload " + name + " because the file was empty.";
    }
}

/**
     * Backup a Todo List.
     */
@RequestMapping("/secure/backupTodoList.action")
public ModelAndView backup(@RequestParam String listId, HttpSession session) throws Exception {
    TodoList todoList = todoListsManager.findTodoList(listId);
    Document doc = todoListsManager.backupTodoList(todoList);
    session.setAttribute("todoListDocument", doc);
    ModelAndView mv = new ModelAndView();
    mv.setView(new InternalResourceView("/secure/servlet/tudu_lists_backup.xml"));
    return mv;
}

@RequestMapping(value = "/login", method = RequestMethod.GET)
public ModelAndView login(@RequestParam(value = "error", required = false) String error, @RequestParam(value = "logged-out", required = false) String loggedOut) {
    ModelAndView modelAndView = new ModelAndView();
    if (error != null) {
        modelAndView.addObject("error", true);
    }
    if (loggedOut != null) {
        modelAndView.addObject("loggedOut", true);
    }
    modelAndView.addObject("contextPath", serverProperties.getContextPath());
    modelAndView.setViewName("login");
    return modelAndView;
}

@RequestMapping(method = RequestMethod.POST)
public String placeOrder(@RequestParam String email, @RequestParam int quantity, @RequestParam String productId, Model model) {
    long orderId = orderIdCounter.getAndIncrement();
    Order order = new Order(orderId);
    order.setEmail(email);
    order.setQuantity(quantity);
    order.setProductId(productId);
    MessagingTemplate template = new MessagingTemplate(this.orderChannel);
    template.convertAndSend(order);
    model.addAttribute("orderId", orderId);
    return "order";
}

@RequestMapping(value = "/model/{modelName}", produces = MIME.JS)
public void user(HttpServletRequest request, HttpServletResponse response, @PathVariable("modelName") String modelName, @RequestParam(value = "dto", defaultValue = "false") boolean dto) throws IOException {
    try {
        String clsName;
        if (dto) {
            clsName = ProjectConfig.getProperty("package.dto") + "." + modelName;
        } else {
            clsName = ProjectConfig.getProperty("package.pojo") + "." + modelName;
        }
        Class<?> cls = Class.forName(clsName);
        ModelGenerator.writeModel(request, response, cls, OutputFormat.EXTJS4, true);
    } catch (ClassNotFoundException exception) {
        ModelGenerator.writeModel(request, response, NullModel.class, OutputFormat.EXTJS4, true);
    }
}

@RequestMapping("/rss")
public ModelAndView showRss(@RequestParam String listId, HttpServletRequest request) throws Exception {
    ModelAndView mv = new ModelAndView();
    TodoList todoList = todoListsService.unsecuredFindTodoList(listId);
    if (todoList.isRssAllowed()) {
        mv.addObject("todoList", todoList);
        mv.addObject("link", request.getScheme() + "://" + request.getServerName() + ":" + request.getServerPort() + request.getContextPath() + "/tudu/lists");
        mv.setView(new InternalResourceView("/servlet/rss"));
    } else {
        if (log.isDebugEnabled()) {
            log.debug("Rendering RSS feed for Todo List ID '" + todoList.getListId() + "' is not allowed");
        }
        mv.setViewName("rss_not_allowed");
    }
    return mv;
}

@RequestMapping(value = "logout.mvc", method = RequestMethod.GET)
public ModelAndView logout(@RequestParam(value = "error", required = false) String error, @RequestParam(value = "logout", required = false) String logout) {
    logger.info("Logging user out");
    ModelAndView model = new ModelAndView();
    if (error != null) {
        model.addObject("error", "Invalid username and password!");
    }
    if (logout != null) {
        model.addObject("msg", "You've been logged out successfully.");
    }
    model.setViewName("logout");
    return model;
}

@PostMapping(value = REQUEST_URL + "/redeem")
public ResponseEntity<?> redeemCode(@RequestHeader(value = "X-AUTH-TOKEN") String userToken, @RequestParam String codeString) throws IpatException {
    User recipient = _tokenAuthenticationService.getUserFromToken(userToken);
    if (recipient != null) {
        _codeService.redeemCode(recipient, codeString);
        return new ResponseEntity<>(HttpStatus.OK);
    } else {
        return new ResponseEntity<>(HttpStatus.FORBIDDEN);
    }
}

@PostMapping("editBalloonText/balloonTextId")
public String editBalloonText(Model model, @RequestParam long balloonTextId) {
    try {
        if (balloonTextId > 0) {
            model.addAttribute("addEditBalloonText", new AddEditBalloonTextBean(BalloonsClient.getBalloonText(balloonTextId)));
        } else {
            model.addAttribute("addEditBalloonText", new AddEditBalloonTextBean());
        }
    } catch (BalloonUserTrackingNotFound ignored) {
    }
    return "edit/addEditBalloonText";
}

@RequestMapping(value = "/history/historic-variable-instances", method = RequestMethod.GET, produces = "application/json")
public DataResponse getHistoricActivityInstances(@RequestParam Map<String, String> allRequestParams, HttpServletRequest request) {
    HistoricVariableInstanceQueryRequest query = new HistoricVariableInstanceQueryRequest();
    // Populate query based on request
    if (allRequestParams.get("excludeTaskVariables") != null) {
        query.setExcludeTaskVariables(Boolean.valueOf(allRequestParams.get("excludeTaskVariables")));
    }
    if (allRequestParams.get("taskId") != null) {
        query.setTaskId(allRequestParams.get("taskId"));
    }
    if (allRequestParams.get("executionId") != null) {
        query.setExecutionId(allRequestParams.get("executionId"));
    }
    if (allRequestParams.get("processInstanceId") != null) {
        query.setProcessInstanceId(allRequestParams.get("processInstanceId"));
    }
    if (allRequestParams.get("variableName") != null) {
        query.setVariableName(allRequestParams.get("variableName"));
    }
    if (allRequestParams.get("variableNameLike") != null) {
        query.setVariableNameLike(allRequestParams.get("variableNameLike"));
    }
    return getQueryResponse(query, allRequestParams);
}

@RequestMapping("/config")
public List<ServiceDTO> getConfigService(@RequestParam(value = "appId", defaultValue = "") String appId, @RequestParam(value = "ip", required = false) String clientIp) {
    List<InstanceInfo> instances = discoveryService.getConfigServiceInstances();
    List<ServiceDTO> result = instances.stream().map(new Function<InstanceInfo, ServiceDTO>() {

        @Override
        public ServiceDTO apply(InstanceInfo instance) {
            ServiceDTO service = new ServiceDTO();
            service.setAppName(instance.getAppName());
            service.setInstanceId(instance.getInstanceId());
            service.setHomepageUrl(instance.getHomePageUrl());
            return service;
        }
    }).collect(Collectors.toList());
    return result;
}

@RequestMapping(method = RequestMethod.GET)
public ModelAndView handleRequest(@RequestParam(required = false, value = "q") String query) throws Exception {
    Model model = new ExtendedModelMap();
    try {
        model.addAttribute(Constants.USER_LIST, userManager.search(query));
    } catch (SearchException se) {
        model.addAttribute("searchError", se.getMessage());
        model.addAttribute(userManager.getUsers());
    }
    return new ModelAndView("admin/userList", model.asMap());
}

@RequestMapping("/bannerlocations.do")
public String handleBannerLocations(@RequestParam long[] bannerlocations, Model model) {
    List<BannerLocation> bannerLocationlist = new LinkedList<BannerLocation>();
    for (long blid : bannerlocations) {
        BannerLocation bannerLocation = bannerLocationService.getEntity(blid);
        if (bannerLocation != null && bannerLocation.getBanner() != null) {
            bannerLocationlist.add(bannerLocation);
        }
    }
    model.addAttribute("bannerlocations", bannerLocationlist);
    return "no/dusken/aranea/base/web/bannerlocation/view";
}

@RequestMapping(value = { "/afx/slide", "/afx/slide/**", "/afx/slide/*.*" }, method = { GET, HEAD, OPTIONS, POST }, produces = "*/*", consumes = "*/*")
@ResponseBody
public void onrequest(HttpServletRequest request, HttpServletResponse response, @RequestParam(value = "p", required = false) String p) {
    Payload payload = new Payload(request, response);
    payload.setPattern("/afx/slide/");
    if (Objects.nonNull(p)) {
        if (p.contains("slide.html")) {
            payload.getResponse().setContentType("text/html;charset=UTF-8");
            payload.write(slideConverter.getRendered());
            return;
        }
    }
    commonResource.processPayload(payload);
}

// @Audit
@RequestMapping(value = "/login", method = RequestMethod.GET)
public ModelAndView login(@RequestParam(value = "error", required = false) String error, @RequestParam(value = "logout", required = false) String logout) {
    userService.login("test", "123");
    ModelAndView model = new ModelAndView();
    if (error != null) {
        model.addObject("error", "Invalid username and password!");
    }
    if (logout != null) {
        model.addObject("msg", "You've been logged out successfully.");
    }
    model.setViewName("login");
    return model;
}

@RequestMapping(value = { "/addInterest" }, produces = "text/plain;charset=UTF-8")
@ResponseBody
public String addInterest(@RequestParam(value = "userId", required = true) Long userId, @RequestParam(value = "bookId", required = true) Long bookId, @RequestParam(value = "typeId", required = true) Integer typeId) {
    JsonResult jr = new JsonResult();
    try {
        interestService.addInterest(userId, bookId, InterestType.getTypeById(typeId));
        jr.setIsSuccess(Boolean.TRUE);
        jr.setMessage("�功�");
        jr.setUser_id(userId);
    } catch (Exception e) {
        jr.setIsSuccess(Boolean.FALSE);
        jr.setMessage("异常�");
    }
    return jr.toJson(jr);
}

/**
     * Sample usage: curl "http://localhost:9080/router-non-blocking-lambda?minMs=1000&maxMs=2000"
     *
     * @param minMs
     * @param maxMs
     * @return
     * @throws java.io.IOException
     */
@RequestMapping("/router-non-blocking-lambda")
public DeferredResult<String> nonBlockingRouter(@RequestParam(value = "minMs", required = false, defaultValue = "0") int minMs, @RequestParam(value = "maxMs", required = false, defaultValue = "0") int maxMs) throws IOException {
    LOG.logStartNonBlocking();
    final DeferredResult<String> deferredResult = new DeferredResult<>();
    String url = SP_NON_BLOCKING_URL + "?minMs=" + minMs + "&maxMs=" + maxMs;
    asyncHttpClient.execute(url, ( response) -> {
        // TODO: Handle status codes other than 200...
        int httpStatus = response.getStatusCode();
        if (deferredResult.isSetOrExpired()) {
            LOG.logAlreadyExpiredNonBlocking();
        } else {
            boolean deferredStatus = deferredResult.setResult(response.getResponseBody());
            LOG.logEndNonBlocking(httpStatus, deferredStatus);
        }
        return response;
    }, ( throwable) -> {
        if (deferredResult.isSetOrExpired()) {
            LOG.logExceptionNonBlocking(throwable);
        }
    });
    LOG.logLeaveThreadNonBlocking();
    // Return to let go of the precious thread we are holding on to...
    return deferredResult;
}

/**
     * ��注册传感器
     * 
     * @param username
     * @param usertoken
     * @param serialnum
     * @param sensortype
     * @param session
     * @return
     */
@AuthPass
@ResponseBody
@RequestMapping(value = "/add", method = RequestMethod.POST, produces = "application/json;charset=UTF-8")
public Object getMySensor(@RequestParam(value = "username", required = true) String username, @RequestParam(value = "usertoken", required = true) String usertoken, @RequestParam(value = "serialnum", required = true) String serialnum, @RequestParam(value = "sensortype", required = true) String sensortype, @RequestParam(value = "sensoraddr", required = true) String sensoraddr) {
    StringBuilder regMsg = new StringBuilder("{\"returnmsg\":\"");
    if (serialnum.trim().equals("") || sensortype.trim().equals("")) {
        regMsg.append(SensorDataStatusEnum.PI.getValue());
        regMsg.append("\"}");
        return regMsg.toString();
    }
    SensorEntity se = new SensorEntity();
    se.setSerialNum(serialnum);
    se.setSensorType(sensortype);
    se.setSensorAddr(sensoraddr);
    if (userService.checkAuth(username)) {
        try {
            regMsg.append(sensorService.saveSensorByObject(se).getDisplayName());
        } catch (Exception e) {
            regMsg.append(SensorStatusEnum.SF.getValue());
        }
    } else {
        regMsg.append(UserStatusEnum.AF.getValue());
    }
    regMsg.append("\"}");
    return regMsg.toString();
}

@RequestMapping(value = "/", method = { RequestMethod.POST })
@ResponseBody
public ResponseEntity<? extends Object> verify(HttpServletRequest req, @RequestParam(value = "recaptcha_challenge_field") String challengeKey, @RequestParam(value = "recaptcha_response_field") String answer) {
    MultiValueMap<String, String> request = new LinkedMultiValueMap<String, String>();
    request.set("privatekey", "6Le098kSAAAAAIvst-QpKIxqkUpITQd7aKtLSgMQ");
    request.set("remoteip", req.getRemoteAddr());
    request.set("challenge", challengeKey);
    request.set("response", answer);
    logger.debug("==============" + req.getRemoteAddr());
    logger.debug("==============req = " + request);
    String resultStr = restTemplate.postForObject("http://www.google.com/recaptcha/api/verify", request, String.class);
    String[] results = resultStr.split("\n");
    if ("true".equals(results[0])) {
        return new ResponseEntity<String>(Boolean.TRUE.toString(), HttpStatus.OK);
    } else {
        logger.debug(resultStr);
        return new ResponseEntity<String>(Boolean.FALSE.toString(), HttpStatus.OK);
    }
}

//
@RequestMapping("goodcasescore")
@ResponseBody
public String goodCasescore(@RequestParam("taskid") int taskid, @RequestParam("caseid") int caseid) {
    taskcaseMapper.updateGoodCasescore(taskid, caseid);
    int taskCount = taskcaseMapper.getTaskCount(taskid);
    int taskDoneCount = taskcaseMapper.getTaskDoneCount(taskid);
    if (taskCount == taskDoneCount) {
        int taskGoodResultCount = taskcaseMapper.getTaskGoodResultCount(taskid);
        int taskscore = taskGoodResultCount * 100 / taskCount;
        taskService.updateTaskscore(taskid, taskscore);
        return taskid + "_" + caseid;
    }
    return taskid + "_" + caseid;
}

/**
	 * Simply selects the home view to render by returning its name.
	 * 
	 * @throws IOException
	 */
@RequestMapping(value = "/image", method = RequestMethod.GET)
public void loadImage(@RequestParam("imageName") String imageName, HttpServletResponse response) throws IOException {
    String fullName = basePath + imageName;
    logger.debug("About to load file: " + fullName);
    OutputStream out = response.getOutputStream();
    InputStream in = new FileInputStream(fullName);
    int read;
    byte[] buffer = new byte[ARRAY_SIZE];
    do {
        read = in.read(buffer);
        if (read != -1) {
            out.write(buffer);
        }
    } while (read != -1);
    in.close();
    out.close();
}

/**
	 * Simply selects the home view to render by returning its name.
	 * 
	 * @throws IOException
	 */
@RequestMapping(value = "/image", method = RequestMethod.GET)
public void loadImage(@RequestParam("imageName") String imageName, HttpServletResponse response) throws IOException {
    String fullName = basePath + imageName;
    logger.debug("About to load file: " + fullName);
    OutputStream out = response.getOutputStream();
    InputStream in = new FileInputStream(fullName);
    int read;
    byte[] buffer = new byte[ARRAY_SIZE];
    do {
        read = in.read(buffer);
        if (read != -1) {
            out.write(buffer);
        }
    } while (read != -1);
    in.close();
    out.close();
}

@RequestMapping(value = "editlabel/{pid}", method = RequestMethod.POST)
@ResponseBody
public Object saveLabel(@PathVariable("pid") String pid, @RequestParam("label") String label) throws IngestException {
    if (label != null && label.trim().length() > 0) {
        try {
            PremisEventLogger logger = new PremisEventLogger(pid);
            PID pidObject = new PID(pid);
            this.client.modifyObject(pidObject, label, null, null, null);
            Element event = logger.logEvent(PremisEventLogger.Type.MIGRATION, "Object renamed to " + label, pidObject);
            PremisEventLogger.addDetailedOutcome(event, "success", "Object renamed successfully", null);
            this.client.writePremisEventsToFedoraObject(logger, pidObject);
        } catch (FedoraException e) {
            throw new IngestException("Could not update label for " + pid, e);
        }
    } else {
        Map<String, String> response = new HashMap<>();
        response.put("message", "error");
        return response;
    }
    Map<String, String> response = new HashMap<>();
    response.put("message", "success");
    return response;
}

/**
     * Resolve principal attributes map.
     *
     * @param uid      the uid
     * @param request  the request
     * @param response the response
     * @return the map
     * @throws Exception the exception
     */
@PostMapping(value = "/resolveattrs")
@ResponseBody
public Map<String, Object> resolvePrincipalAttributes(@RequestParam final String uid, final HttpServletRequest request, final HttpServletResponse response) throws Exception {
    ensureEndpointAccessIsAuthorized(request, response);
    final Principal p = personDirectoryPrincipalResolver.resolve(new BasicIdentifiableCredential(uid));
    final Map<String, Object> map = new LinkedHashMap<>();
    map.put("uid", p.getId());
    map.put("attributes", p.getAttributes());
    return map;
}

@RequestMapping(value = "/setup", method = RequestMethod.POST)
public String setupExecute(@RequestParam("host") String host, @RequestParam("thriftPort") int thriftPort, @RequestParam("jmxPort") int jmxPort, @RequestParam(value = "framedTransport", required = false, defaultValue = "false") boolean framedTransport, ModelMap model) throws Exception {
    properties.setProperty(CassandraProperties.HOST, host);
    properties.setProperty(CassandraProperties.JMX_PORT, String.valueOf(jmxPort));
    properties.setProperty(CassandraProperties.THRIFT_PORT, String.valueOf(thriftPort));
    properties.setProperty(CassandraProperties.FRAMED_TRANSPORT, Boolean.toString(framedTransport));
    properties.saveProperties();
    model.clear();
    return "redirect:/";
}

@RequestMapping("/password/change")
@Transactional(value = "transactionManager", rollbackFor = Throwable.class)
public void changePasswordAction(@RequestParam(value = "old_password") String old_password, @RequestParam(value = "new_password") String new_password) {
    Admin admin = adminDAO.get(getAdminId());
    if (!StringUtils.equals(PasswordUtil.encodePassword(old_password, Constants.DEFAULT_ADMIN_PASSWORD_SALT), admin.getPassword())) {
        returnJson(false, "200", "原密��正确!");
        return;
    }
    admin.setPassword(PasswordUtil.encodePassword(new_password, Constants.DEFAULT_ADMIN_PASSWORD_SALT));
    admin.setUpdated(new Date());
    adminDAO.update(admin);
    returnJson(true, "200", "密�修改�功!");
}

@RequestMapping(value = "/", method = RequestMethod.POST)
public String indexPOST(@ModelAttribute(value = "FORM") WhoWhenRequestForm form, @RequestParam(value = "redirect", required = true) String redirect, BindingResult result) {
    RequestValidator requestValidator = new RequestValidator();
    requestValidator.validate(form, result);
    if (!result.hasErrors() && form.getFile().getSize() < Long.valueOf(maxFileSize)) {
        FileOutputStream outputStream = null;
        try {
            String requestIdentifier = generateRequestIdentifier();
            //System.out.println("1");
            byte[] fileBytes = form.getFile().getFileItem().get();
            String targetDir = apacheDeploymentPath + requestIdentifier + File.separator;
            String filePath = targetDir + TARGET_DATA_FILE_NAME;
            File targetFile = new File(filePath);
            // System.out.println("2");
            if (!targetFile.exists()) {
                targetFile.getParentFile().mkdirs();
                outputStream = new FileOutputStream(targetFile);
                outputStream.write(fileBytes);
                outputStream.close();
            }
            BackendRequest backendRequest = new BackendRequest(requestIdentifier, FormUtil.toRequestData(form), targetFile);
            backendService.handle(backendRequest);
            return "redirect:" + redirect + backendRequest.getRequestIdentifier() + "/request";
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
    return "redirect:/?error=true";
}

@RequestMapping(method = GET, value = "/{id}/data", produces = MediaType.APPLICATION_JSON_VALUE)
public List<MeasurementDataDto> getData(@PathVariable("id") UUID uuid, @RequestParam(value = "limit", defaultValue = "all") DataLimit limit, @RequestParam(value = "value", defaultValue = "1") int value) {
    LinkedList<MeasurementDataDto> list = new LinkedList<>();
    int count = 10;
    if (limit == DataLimit.last)
        count = 1;
    for (int i = 0; i < count; i++) {
        list.add(new MeasurementDataDto(new java.util.Date().getTime() - i * 1000, generateNewData(uuid)));
    }
    return list;
}

@RequestMapping(method = { RequestMethod.GET, RequestMethod.POST })
public ModelAndView onView(@RequestParam(value = "statusCode", required = true) Integer statusCode) throws Exception {
    Map<String, Object> model = new HashMap<String, Object>();
    model.put(USER_ATTR, getUser());
    EmbeddedEnvelopeStatus signingStatus = EmbeddedEnvelopeStatus.getStatusForCode(statusCode);
    model.put("statusMessageKey", signingStatus.getErrorMessageKey());
    return new ModelAndView("autoAppComplete", "model", model);
}

@RequestMapping(value = "/CodeParser/{code}", method = RequestMethod.GET)
@ResponseBody
public ResponseEntity<?> getStandardVersion(@PathVariable String code, @RequestParam int gcpLength) {
    HttpHeaders responseHeaders = new HttpHeaders();
    responseHeaders.add("Content-Type", "application/json; charset=utf-8");
    AICodeParser codeParser = new AICodeParser();
    JSONObject result = new JSONObject(codeParser.parse(code, gcpLength));
    return new ResponseEntity<>(result.toString(1), responseHeaders, HttpStatus.OK);
}

@RequestMapping("/auth")
public Map<String, String> authorization(@RequestParam String callbackUrl, @RequestParam(required = false) boolean preferRegistration, @RequestParam(required = false) boolean supportLinkedSandbox) {
    // obtain request token (temporal credential)
    final OAuth1Operations oauthOperations = this.evernoteConnectionFactory.getOAuthOperations();
    // no additional param
    final OAuthToken requestToken = oauthOperations.fetchRequestToken(callbackUrl, null);
    // construct authorization url with callback url for client to redirect
    final OAuth1Parameters parameters = new OAuth1Parameters();
    if (preferRegistration) {
        // create account
        parameters.set("preferRegistration", "true");
    }
    if (supportLinkedSandbox) {
        parameters.set("supportLinkedSandbox", "true");
    }
    final String authorizeUrl = oauthOperations.buildAuthorizeUrl(requestToken.getValue(), parameters);
    final Map<String, String> map = new HashMap<String, String>();
    map.put("authorizeUrl", authorizeUrl);
    map.put("requestTokenValue", requestToken.getValue());
    map.put("requestTokenSecret", requestToken.getSecret());
    return map;
}

@ExtDirectMethod(value = ExtDirectMethodType.FORM_POST, group = "itest_upload_service", event = "test", entryClass = String.class, synchronizeOnSession = true)
public ExtDirectFormPostResult uploadTest(@RequestParam("fileUpload") MultipartFile file, @Valid User user, BindingResult result) throws IOException {
    ExtDirectFormPostResult resp = new ExtDirectFormPostResult(result, false);
    if (file != null && !file.isEmpty()) {
        resp.addResultProperty("fileContents", new String(file.getBytes()));
        resp.addResultProperty("fileName", file.getOriginalFilename());
    }
    resp.addResultProperty("name", user.getName());
    resp.addResultProperty("firstName", user.getFirstName());
    resp.addResultProperty("age", user.getAge());
    resp.addResultProperty("e-mail", user.getEmail());
    resp.setSuccess(true);
    return resp;
}

@RequestMapping(value = "/apitop", method = RequestMethod.GET)
public String currentlog(Model model, @RequestParam(value = "topdatarange", required = false, defaultValue = "0") String topdaterange) {
    //render the list of date
    List<String> timelist = new ArrayList<>();
    long timestamp = DateTimeHelper.getCurrentTime();
    long moringTime = DateTimeHelper.getTimesMorning(timestamp);
    for (int interDay = 0; interDay < fieryConfig.getKeepdataday(); interDay++) {
        timelist.add(DateTimeHelper.TimeStamp2Date(String.valueOf(moringTime - (24 * 60 * 60) * interDay), "yyyy-MM-dd"));
    }
    model.addAttribute("datelist", timelist);
    model.addAttribute("datelist_selected", topdaterange);
    //now the date render
    int datetimeshard = Integer.parseInt(topdaterange);
    long shardtime = moringTime - (24 * 60 * 60) * datetimeshard;
    APITopURLStaticURLCollect urllist = apiTopURLStaticShardCollect.getSharder(shardtime, false);
    if (urllist != null) {
        model.addAttribute("urllist", urllist.getCollectList());
    } else {
        model.addAttribute("urllist", new ArrayList<APITopURLStaticData>());
    }
    return "apitop";
}

@RequestMapping(value = "/attachment/{apiKeyId}/{fileName}")
public void getAttachment(@PathVariable("apiKeyId") long apiKeyId, @PathVariable("fileName") String fileName, @RequestParam(value = "s", required = false) Integer maxSideLength, HttpServletResponse response) throws IOException, TrustRelationshipRevokedException {
    ApiKey apiKey = guestService.getApiKey(apiKeyId);
    File file = SmsBackupUpdater.getAttachmentFile(env.targetEnvironmentProps.getString("btdatastore.db.location"), apiKey.getGuestId(), apiKeyId, fileName);
    if (!file.exists()) {
        response.sendError(404);
    }
    if (maxSideLength == null) {
        IOUtils.copy(new FileInputStream(file), response.getOutputStream());
    } else {
        //TODO: make sure we actually have a photo
        byte[] photoData = IOUtils.toByteArray(new FileInputStream(file));
        IOUtils.write(ImageUtils.createJpegThumbnail(photoData, maxSideLength).getBytes(), response.getOutputStream());
    }
}

@ResponseBody
@RequestMapping(value = "/listRecents", produces = MediaType.APPLICATION_JSON_VALUE)
public PageContentVersionsResponse listRecents(@RequestParam(value = "offset", defaultValue = "0", required = false) final int offset, @RequestParam(value = "limit", defaultValue = "10", required = false) final int limit) {
    //
    Pair<Long, List<PageContent>> p = pageContentService.listRecents(offset, limit);
    Long tot = p.getLeft();
    Pagination pagination = new Pagination(tot, offset, limit);
    TeeConsumeFunction<PageContent, PageContentResponse> f = new TeeConsumeFunction<PageContent, PageContentResponse>(new PageContentReadablePredicate(pageAclService), new PageContentToPageContentResponseFunction(), new EmptyPageContentFunction());
    List<PageContentResponse> l2 = Lists.transform(p.getRight(), f);
    //
    return new PageContentVersionsResponse(pagination, l2);
}

@RequestMapping(value = "/send", method = RequestMethod.POST)
@Timed
@ExceptionMetered
public ModelMap send(@RequestParam(value = "pin", required = false) String pin, @RequestParam(value = "number") String number, @RequestParam(value = "text") String text, @RequestParam(value = "callbackUrl", required = false) String callbackUrl, HttpSession session, HttpServletResponse resp) {
    try {
        User user = APIUtil.getUser(service, session, pin);
        if (user == null) {
            APIUtil.invalidCredentials(resp);
            return null;
        }
        String id = service.sendSMS(user.getPin(), number, text, callbackUrl);
        return new ModelMap("id", id);
    } catch (DataAccessException e) {
        APIUtil.internalError(e, resp);
    } catch (IOException e) {
        APIUtil.internalError(e, resp);
    }
    return null;
}

@RequestMapping(method = RequestMethod.GET)
public String get(HttpServletRequest request, @RequestParam(value = "entornId", required = false) Long entornId, Model model) {
    Long entornActualId = entornId;
    if (entornActualId == null) {
        EntornDto entornActual = (EntornDto) SessionHelper.getAttribute(request, SessionHelper.VARIABLE_ENTORN_ACTUAL_V3);
        entornActualId = entornActual.getId();
    }
    model.addAttribute("dominis", adminService.monitorDominiFindByEntorn(entornActualId));
    model.addAttribute("entorns", entornService.findActiusAll());
    model.addAttribute("entornActualId", entornActualId);
    return "v3/monitorDomini";
}

@RequestMapping(value = "/file", method = RequestMethod.POST)
public ModelAndView handleFormUpload(@RequestParam("username") String username, @RequestParam("authenticationId") String authenticationId, @RequestParam("parcelName") String parcelName, @RequestParam("daysToLive") Integer daysToLive, @RequestParam("file") MultipartFile file) throws IOException {
    ModelAndView mav;
    byte[] payload = null;
    if (!file.isEmpty()) {
        payload = file.getBytes();
    }
    mav = new ModelAndView("outputString");
    String[] accessInfo = uploadParcel.uploadParcel(username, authenticationId, parcelName, daysToLive, payload);
    String output = accessInfo[0] + ":" + accessInfo[1];
    mav.addObject("string", output);
    return mav;
}

@RequestMapping(value = "/account-details", method = RequestMethod.POST, consumes = "application/x-www-form-urlencoded")
public ModelAndView accountDetailsView(@RequestParam("issuer") String issuer, @RequestParam("subject") String subject) {
    ModelAndView mav = new ModelAndView("account-details");
    SingleIdentity chosen = identityService.getSingleBySubjectIssuer(subject, issuer);
    if (chosen != null) {
        mav.addObject("account", chosen);
    } else {
        mav = new ModelAndView("redirect:accounts");
    }
    return mav;
}

@GetMapping(value = "/dbs/{dbId}")
public WebAsyncTask<ResponseEntity<Resource>> getReport(@PathVariable Long dbId, @RequestParam(name = "sessionId", required = true) String sessionId, @RequestParam(name = "baseLineSessionId", required = false) String baseLineSessionId) throws IOException {
    // Given up to 10 minutes to generate a report before timeout failure.
    return new WebAsyncTask<>(1000 * 60 * 10, () -> {
        Resource reportResource = dynamicReportingService.generateReportFor(dbId, sessionId, baseLineSessionId);
        return ResponseEntity.ok().header(HttpHeaders.CONTENT_DISPOSITION, "inline; filename=\"" + reportResource.getFilename() + "\"").header(HttpHeaders.CONTENT_TYPE, MediaType.APPLICATION_PDF_VALUE).body(reportResource);
    });
}

@RequestMapping(method = RequestMethod.GET)
@ResponseBody
public Clients getClients(@RequestParam(value = "caching", defaultValue = "false") boolean caching) {
    long startTime = System.currentTimeMillis();
    List<Client> clients;
    if (caching) {
        clients = cachedClientGetter.getBestClients();
    } else {
        clients = clientGetter.getBestClients();
    }
    logger.info("Loading Clients took {} ms", System.currentTimeMillis() - startTime);
    return new Clients(clients);
}

@RequestMapping(value = "/show", method = RequestMethod.GET)
public String getProcessInstance(@RequestParam String id, ModelMap model) {
    long processInstanceId = Long.parseLong(id);
    ProcessInstanceDesc processInstance = runtimeDataService.getProcessInstanceById(processInstanceId);
    Collection<VariableDesc> variables = runtimeDataService.getVariablesCurrentState(processInstanceId);
    model.addAttribute("processInstance", processInstance);
    model.addAttribute("variables", variables);
    return "processInstance";
}

@RequestMapping("/images/xpdl/thumbnail/(*:processDefId)")
public void getXpdlThumbnail(OutputStream out, @RequestParam("processDefId") String processDefId, HttpServletRequest request, HttpServletResponse response) {
    try {
        response.setContentType("image/jpeg");
        processDefId = processDefId.replaceAll(":", "#");
        File file = XpdlImageUtil.getXpdlThumbnail(workflowFacade.getDesignerwebBaseUrl(request), processDefId);
        byte[] bbuf = new byte[65536];
        DataInputStream in = new DataInputStream(new FileInputStream(file));
        int length = 0;
        while ((in != null) && ((length = in.read(bbuf)) != -1)) {
            out.write(bbuf, 0, length);
        }
        in.close();
        out.flush();
        out.close();
    } catch (Exception ex) {
        LogUtil.error(this.getClass().getName(), ex, "Failed to get XPDL thumbnail [processDefId=" + processDefId + "]");
    }
}

/**
     * Populates the Kanban application with a given project name and WorkItemType. This application
     * is then presented on a given server.
     * @param projectName - the name of the project
     * @param workItemTypeName - the type of WorkItem
     * @param response - the HttpServlet for the site
     * @throws IOException
     */
@RequestMapping("download")
public void download(@PathVariable("projectName") String projectName, @RequestParam("workItemTypeName") String workItemTypeName, HttpServletResponse response) throws IOException {
    KanbanProjectConfiguration configuration = kanbanService.getProjectConfiguration(projectName);
    WorkItemType workItemType = configuration.getWorkItemTypes().getByName(workItemTypeName);
    // copies and saves the csv file
    File file = configuration.getDataFile(workItemType);
    response.setContentType("text/csv");
    response.setContentLength((int) file.length());
    response.setHeader("Content-Disposition", "attachment; filename=\"" + file.getName() + "\"");
    IOUtils.copy(new FileInputStream(file), response.getOutputStream());
}

/**
	 * Returns tasklink
	 *  
	 * @param tasklink
	 * @param currentPage
	 * @param taskType
	 * @param keyword
	 * @param orderType
	 * @param request
	 * @return tasklink
	 */
@ModelAttribute(value = "tasklink")
public String model(@RequestParam String tasklink, @RequestParam String currentPage, @RequestParam String taskType, @RequestParam String keyword, @RequestParam String orderType, RenderRequest request) {
    // store parameters in session for returning page from form page	
    request.getPortletSession().setAttribute(ATTR_CURRENT_PAGE, currentPage, PortletSession.APPLICATION_SCOPE);
    request.getPortletSession().setAttribute(ATTR_TASK_TYPE, taskType, PortletSession.APPLICATION_SCOPE);
    request.getPortletSession().setAttribute(ATTR_KEYWORD, keyword, PortletSession.APPLICATION_SCOPE);
    request.getPortletSession().setAttribute(ATTR_ORDER_TYPE, orderType, PortletSession.APPLICATION_SCOPE);
    return tasklink;
}

@RequestMapping("/anagrams/get")
@ResponseBody
public Set<String> getAnagrams(@RequestParam("word") String word) {
    if (word.length() > 15 || word.contains(" ")) {
        return Sets.newHashSet("Думата Ñ‚Ñ€Ñ?бва да е по-къÑ?а от 15 Ñ?имвола и да не Ñ?ъдържа интервали");
    }
    if (StringUtils.isBlank(word)) {
        return Sets.newHashSet("МолÑ? въведете дума");
    }
    Set<String> anagrams = anagramService.getAnagrams(word);
    if (anagrams.isEmpty()) {
        return Sets.newHashSet("(нÑ?ма)");
    }
    return anagrams;
}

/**
	 * Gets the programs API.
	 *
	 * @param token the token
	 * @return the programs API
	 */
@RequestMapping(value = "api/elementList/")
public ResponseEntity<String> getElementsAPI(@RequestParam(value = "token") String token) {
    // Validate Token and retrieve email
    String email = getEmailOfToken(token);
    if (email != null) {
        List<ElementDTO> elementsDTO = elementService.getElementsDTO(elementService.getElementListReservable());
        String elementsJson = new Gson().toJson(elementsDTO);
        return new ResponseEntity<>(elementsJson, HttpStatus.OK);
    }
    return new ResponseEntity<>(null, HttpStatus.FORBIDDEN);
}

@RequestMapping(value = "/pluginList", method = RequestMethod.GET)
@ResponseBody
public String getContent(@Context HttpServletRequest request, @Context HttpServletResponse response, @RequestParam(value = "type", defaultValue = "delimited") String type) {
    String result = "";
    String baseUrl = request.getRequestURL().toString().replace(request.getRequestURI().substring(1), request.getContextPath());
    try {
        /* Comma delimited String */
        //= utils.getContentAsString(',');
        String dirContents = "";
        ArrayList<String> fileList = DirectoryWatcherVJ6.scheduler.getFileNames();
        if (type.equalsIgnoreCase("delimited")) {
            dirContents = IoUtilities.buildUrlDelimitedList(fileList, ',', baseUrl);
        } else {
            dirContents = IoUtilities.buildJsonUrlList(fileList, baseUrl);
        }
        if (!"".equals(dirContents) || dirContents != null) {
            result = dirContents;
        }
    } catch (Exception ioe) {
        ioe.printStackTrace();
    }
    return result;
}

/**
     * 粉�列表
     * @param page
     * @param model
     * @return
     */
@RequestMapping(value = "fans", method = RequestMethod.GET)
public String blogs(@RequestParam(value = "page", defaultValue = "1") Integer page, Model model) {
    String uid = LoginHelper.getUserId();
    model.addAttribute("followers", followerService.getFollowers(uid));
    model.addAttribute("following", followingService.getFollowing(uid));
    model.addAttribute("pages", followerService.getFollowersByPage(uid, page, pageSize));
    return "/manage/fans";
}

//定时任务调用-问政更新
@RequestMapping(value = "/task_XX/movie/crontab/begin")
public String runMovie(@RequestParam(value = "id", defaultValue = "6982558") final String id) {
    logger.info("TASK BEGIN!");
    Thread t = new Thread() {

        public void run() {
            try {
                movieService.getMovie(id);
            } catch (Exception e) {
                logger.info("TASK ERROR: " + e);
            }
        }
    };
    t.start();
    return "OK";
}

@RequestMapping("/scripts/{name}/run")
public void runScript(@PathVariable("name") String scriptName, @RequestParam Map<String, Object> parameters, HttpServletResponse response) throws IOException {
    ScriptResult result = savedScriptRunner.runScript(scriptName, parameters);
    if (result.getOutputFile() != null) {
        File f = new File(result.getOutputFile());
        if (f.exists()) {
            String guessedContentType = URLConnection.guessContentTypeFromName(f.getName());
            if (guessedContentType != null) {
                response.setContentType(guessedContentType);
            }
            FileCopyUtils.copy(new FileInputStream(f), response.getOutputStream());
            f.delete();
        }
    } else if (StringUtils.isNotBlank(result.getOutput())) {
        response.setContentType("text/plain");
        PrintWriter pw = response.getWriter();
        pw.write(result.getOutput());
        pw.flush();
    }
}

@RequestMapping(value = "/order.html")
public String order(HttpServletRequest request, @RequestParam() String choice1, @RequestParam String choice2, @RequestParam String choice3) {
    log.debug("Incoming order " + choice1 + ", " + choice2 + ", " + choice3);
    Order order = service.placeOrder(choice1, choice2, choice3);
    log.debug("Placed order " + order);
    LinkedList<String> orderedItems = new LinkedList<String>();
    for (ShopableItem item : order.getItems()) {
        orderedItems.add(item.getName());
    }
    request.setAttribute("ordereditems", orderedItems);
    request.setAttribute("totalPrice", preparePrice(order));
    return "confirmation";
}

@RequestMapping(value = "/edit/{id}", method = RequestMethod.POST)
@ResponseBody
public String edit(HttpServletRequest request, @PathVariable int id, @RequestParam(value = "data", required = false, defaultValue = "Empty") String data) {
    StringBuffer s = new StringBuffer();
    s.append("<br>");
    s.append("getContentType : ").append(request.getContentType());
    s.append("<br>");
    s.append("id : ").append(id);
    s.append("<br>");
    s.append("getPathInfo : ").append(request.getPathInfo());
    s.append("<br>create data: ");
    s.append(data);
    Cookie[] cookies = request.getCookies();
    for (Cookie cookie : cookies) {
        System.out.println(cookie.getName() + " : " + cookie.getValue());
    }
    return s.toString();
}

@RequestMapping(value = "/fe/electronictaxreceipts/donate", method = RequestMethod.POST)
public ResponseEntity<String> donate(@RequestParam(value = "accessKey") String accessKey, @RequestParam(value = "total") double total) {
    HttpHeaders responseHeaders = super.createBasicHttpHeaderResponse(APPLICATION_JSON);
    Gson gson = new Gson();
    ResultResponse resultResponse;
    try {
        Assert.hasLength(accessKey);
        accessKey = removeNonNumeric(accessKey);
        Assert.isTrue(validateElectronicTaxReceiptAccessKey(accessKey));
        Assert.isTrue(total > 0.0);
        //Save to database
        ElectronicTaxReceipt receipt = new ElectronicTaxReceipt(accessKey, total);
        electronicTaxReceiptDAO.save(receipt);
        resultResponse = new ResultResponse(true);
    } catch (Exception ex) {
        ex.printStackTrace();
        resultResponse = new ResultResponse(false);
    }
    return new ResponseEntity<>(gson.toJson(resultResponse), responseHeaders, HttpStatus.OK);
}

/**
   * Builds the model for the login page---mainly focusing on the error message handling.
   *
   * @param authentication_failed flag for authentication failed
   * @param invalid_session flag for invalid session
   * @param access_denied flag for access denied
   * @param logout flag for successful logout
   * @return the view model
   */
@RequestMapping(value = "/login**", method = RequestMethod.GET)
public ModelAndView login(@RequestParam(value = "authentication_failed", required = false) boolean authentication_failed, @RequestParam(value = "invalid_session", required = false) boolean invalid_session, @RequestParam(value = "access_denied", required = false) boolean access_denied, @RequestParam(value = "logout", required = false) boolean logout) {
    final Authentication authentication = SecurityContextHolder.getContext().getAuthentication();
    if (!authentication.getPrincipal().equals("anonymousUser")) {
        return new ModelAndView("redirect:" + defaultTargetUrl);
    }
    ModelAndView model = new ModelAndView();
    if (authentication_failed) {
        model.addObject("error", "Authentication failed!");
    } else if (invalid_session) {
        model.addObject("error", "You are currently not logged in!");
    } else if (access_denied) {
        model.addObject("error", "You have insufficient permissions to access this page!");
    } else if (logout) {
        model.addObject("msg", "Logout successful!");
    }
    return model;
}

/**
   * Builds the model for the login page---mainly focusing on the error message handling.
   *
   * @param authentication_failed flag for authentication failed
   * @param invalid_session flag for invalid session
   * @param access_denied flag for access denied
   * @param logout flag for successful logout
   * @return the view model
   */
@RequestMapping(value = "/login**", method = RequestMethod.GET)
public ModelAndView login(@RequestParam(value = "authentication_failed", required = false) boolean authentication_failed, @RequestParam(value = "invalid_session", required = false) boolean invalid_session, @RequestParam(value = "access_denied", required = false) boolean access_denied, @RequestParam(value = "logout", required = false) boolean logout) {
    final Authentication authentication = SecurityContextHolder.getContext().getAuthentication();
    if (!authentication.getPrincipal().equals("anonymousUser")) {
        return new ModelAndView("redirect:" + defaultTargetUrl);
    }
    ModelAndView model = new ModelAndView();
    if (authentication_failed) {
        model.addObject("error", "Authentication failed!");
    } else if (invalid_session) {
        model.addObject("error", "You are currently not logged in!");
    } else if (access_denied) {
        model.addObject("error", "You have insufficient permissions to access this page!");
    } else if (logout) {
        model.addObject("msg", "Logout successful!");
    }
    return model;
}

@RequestMapping(value = "/CodeParser/{code}", method = RequestMethod.GET)
@ResponseBody
public ResponseEntity<?> getStandardVersion(@PathVariable String code, @RequestParam int gcpLength) {
    HttpHeaders responseHeaders = new HttpHeaders();
    responseHeaders.add("Content-Type", "application/json; charset=utf-8");
    AICodeParser codeParser = new AICodeParser();
    JSONObject result = new JSONObject(codeParser.parse(code, gcpLength));
    return new ResponseEntity<>(result.toString(1), responseHeaders, HttpStatus.OK);
}

@RequestMapping()
public ModelAndView index(@RequestParam() String stopId) {
    AgencyAndId id = AgencyAndIdLibrary.convertFromString(stopId);
    StopEntry stop = _graphDao.getStopEntryForId(id);
    List<StopTransfer> transfers = _stopTransferService.getTransfersFromStop(stop);
    ModelAndView mv = new ModelAndView("transfers-for-stop.jspx");
    mv.addObject("transfers", transfers);
    return mv;
}

@RequestMapping("/listLdapUsers")
public String listLdapUsers(HttpServletRequest req, @RequestParam(value = "filter", required = false) String filter) {
    // If no filter is provided, just render the page without results table
    if (!StringUtils.isEmpty(filter)) {
        // Retrieve existing users to remove them from LDAP search results.
        @SuppressWarnings("unchecked") Collection<UserAccountBean> existingAccounts = userAccountDao.findAll();
        Set<String> existingUsernames = new HashSet<String>(existingAccounts.size());
        for (UserAccountBean existingAccount : existingAccounts) {
            existingUsernames.add(existingAccount.getName());
        }
        req.setAttribute("memberList", ldapUserService.listNewUsers(filter, existingUsernames));
    }
    return PAGE_LIST_LDAP_USERS;
}

@RequestMapping(method = RequestMethod.GET)
public void paymentModeFragment(@RequestParam("uuid") String uuid, ModelMap model) {
    IPaymentModeService service = Context.getService(IPaymentModeService.class);
    PaymentMode paymentMode = service.getByUuid(uuid);
    ConceptService conceptService = Context.getConceptService();
    Map<Integer, Concept> conceptMap = new HashMap<Integer, Concept>();
    for (PaymentModeAttributeType type : paymentMode.getAttributeTypes()) {
        if (type.getFormat().equals("org.openmrs.Concept") && type.getForeignKey() != null) {
            conceptMap.put(type.getForeignKey(), conceptService.getConcept(type.getForeignKey()));
        }
    }
    model.addAttribute("paymentMode", paymentMode);
    model.addAttribute("conceptMap", conceptMap);
}

@RequestMapping(method = RequestMethod.GET)
public void viewSource(@RequestParam("file") String file, HttpServletRequest request, HttpServletResponse response) throws IOException {
    if (!enabled) {
        throw (new OpenLegacyRuntimeException("View source controller is not enabled"));
    }
    ServletContext servletContext = request.getSession().getServletContext();
    InputStream resource = servletContext.getResourceAsStream(file);
    if (resource == null) {
        throw (new OpenLegacyRuntimeException("Specified resource doesn''t exists"));
    }
    String content = IOUtils.toString(resource);
    content = HtmlUtils.htmlEscape(content);
    response.getWriter().write(MessageFormat.format(htmlOutput, content));
}

@RequestMapping(method = RequestMethod.GET)
public void paymentModeFragment(@RequestParam("uuid") String uuid, ModelMap model) {
    IPaymentModeService service = Context.getService(IPaymentModeService.class);
    PaymentMode paymentMode = service.getByUuid(uuid);
    ConceptService conceptService = Context.getConceptService();
    Map<Integer, Concept> conceptMap = new HashMap<Integer, Concept>();
    for (PaymentModeAttributeType type : paymentMode.getAttributeTypes()) {
        if (type.getFormat().equals("org.openmrs.Concept") && type.getForeignKey() != null) {
            conceptMap.put(type.getForeignKey(), conceptService.getConcept(type.getForeignKey()));
        }
    }
    model.addAttribute("paymentMode", paymentMode);
    model.addAttribute("conceptMap", conceptMap);
}

@RequestMapping(method = RequestMethod.POST)
public String doPost(HttpSession session, @RequestParam String messageUploadDir) {
    AdministrationService as = Context.getAdministrationService();
    GlobalProperty gp = as.getGlobalPropertyObject("sdmxhdintegration.messageUploadDir");
    gp.setPropertyValue(messageUploadDir);
    as.saveGlobalProperty(gp);
    session.setAttribute(WebConstants.OPENMRS_MSG_ATTR, "Configuration saved");
    return "redirect:config.form";
}

/**
	 * Handles and retrieves the login JSP page
	 *
	 * @return the name of the JSP page
	 */
@RequestMapping(value = "/login", method = RequestMethod.GET)
public String getLoginPage(@RequestParam(value = "error", required = false) boolean error, ModelMap model) {
    LOG.debug("------ getLoginPage :Received request to show login page -----");
    if (error == true) {
        // Assign an error message
        model.put("error", "Invalid username or password provided !!!");
    } else {
        model.put("error", "");
    }
    // This will resolve to /WEB-INF/jsp/loginpage.jsp
    return "loginpage";
}

@RequestMapping(value = "/ponte", method = GET)
ModelAndView carregarApp(@RequestParam("appId") String appId) {
    try {
        ResponseEntity<RespostaPonte> entity = restTemplate.postForEntity(url, new RequestPonte().withAppId(appId), RespostaPonte.class);
        return new ModelAndView("ponte/index", "ponte", entity.getBody());
    } catch (Exception e) {
        return new ModelAndView("erroPonte");
    }
}

/**
	 * 添加
	 */
@RequestMapping("/insert.action")
public String create(String userId, @RequestParam("roleId") String[] roleIds) {
    //当userId  和  roleIds 存在是�入
    if (UtilFuns.isNotEmpty(userId) && UtilFuns.isNotEmpty(roleIds)) {
        UserRoles userRole = null;
        for (String roleId : roleIds) {
            userRole = new UserRoles();
            userRole.setUserId(userId);
            userRole.setRoleId(roleId);
            //�入�验�是�存在
            if (this.userRolesService.isValidate(userId, roleId)) {
                this.userRolesService.insert(userRole);
            }
        }
    }
    return "redirect:/sysadmin/user/" + userId + "/touserroles.action";
}

@RequestMapping(method = RequestMethod.GET)
public String displayCacheEntityManager(final HttpServletRequest request, final Model model, @RequestParam(value = "flush", required = false) String flush) throws Exception {
    List<CacheType> caches = cacheService.getCaches();
    List<String> cacheNames = new ArrayList<String>();
    for (CacheType cacheType : caches) {
        cacheNames.add(cacheType.getAlias());
    }
    if ("all".equals(flush)) {
        cacheService.flushCaches(caches);
    }
    model.addAttribute("title", Constants.QALINGO + " Cache Entity Manager");
    model.addAttribute("flushName", flush);
    model.addAttribute("caches", caches);
    model.addAttribute("hostname", getHostname());
    return CommonUrls.ENTITY_CACHE.getVelocityPage();
}

@ResponseBody
@RequestMapping(value = "/auth/workbench/workspace/{projectid}/{workspaceid}/viewtext", method = RequestMethod.GET, produces = "text/plain;charset=UTF-8")
@ElementAccessPolicy(type = CheckedElementType.WORKSPACE, paramIndex = 0, userRole = { RoleNames.ROLE_WORKSPACE_COLLABORATOR_ADMIN, RoleNames.ROLE_QUADRIGA_ADMIN, RoleNames.ROLE_PROJ_COLLABORATOR_ADMIN, RoleNames.ROLE_WORKSPACE_COLLABORATOR_EDITOR })
public ResponseEntity<String> viewTextfile(@RequestParam("txtid") String txtId, HttpServletResponse response, HttpServletRequest request) throws QuadrigaAccessException {
    try {
        String text = tfManager.retrieveTextFileContent(txtId);
        return textHelper.getResponse(text, response);
    } catch (FileStorageException e) {
        logger.error(e.getMessage());
        String respMessage = "Error while retrieving the file content";
        return new ResponseEntity<String>(respMessage, HttpStatus.NOT_FOUND);
    }
}

@RequestMapping(method = { GET, HEAD, POST })
public String search(SearchForm searchForm, @RequestParam(defaultValue = "1") int page, Model model) {
    Pageable pageable = PageableFactory.forSearch(page);
    SearchResults searchResults = searchService.search(searchForm.getQ(), pageable, searchForm.getFilters());
    Page<SearchResult> entries = searchResults.getPage();
    model.addAttribute("totalResultsCount", entries.getTotalElements());
    model.addAttribute("results", entries.getContent());
    model.addAttribute("paginationInfo", new PaginationInfo(entries));
    SearchFacet root = new SpringFacetsBuilder(searchResults.getFacets()).build();
    model.addAttribute("rootFacet", root);
    model.addAttribute("searchForm", searchForm);
    return "search/results";
}