public Object handlePostLike(Request request, Response response) {
String permalink = request.queryParams("permalink");
String commentOrdinalStr = request.queryParams("comment_ordinal");
// look up the post in question
int ordinal = Integer.parseInt(commentOrdinalStr);
// TODO: check return or have checkSession throw
String username = sessionDAO.findUserNameBySessionId(request.cookie("session"));
Document post = blogPostDAO.findByPermalink(permalink);
// if post not found, redirect to post not found error
if (post == null) {
response.redirect("/post_not_found");
} else {
blogPostDAO.likePost(permalink, ordinal);
response.redirect("/post/" + permalink);
}
SimpleHash root = new SimpleHash();
return templateEngine.render(new ModelAndView(root, "entry_template.ftl"));
}
@Override
public void handle(Request request, Response response)
throws UnauthorizedException, ForbiddenException, InternalServerException {
Boolean authenticated, authorized;
String challenge;
try {
authenticated =
getAuth()
.authenticate(
request.requestMethod(), request.uri(), request.headers("Authorization"));
authorized = getAuth().authorize(request.requestMethod());
challenge = getAuth().challenge();
} catch (UnloadableConfigException | InvalidPropertyException | RuntimeException e) {
throw new InternalServerException(e);
}
if (!authenticated) {
response.header("WWW-Authenticate", challenge);
throw new UnauthorizedException();
}
if (!authorized) {
throw new ForbiddenException();
}
}
/**
* Metodo para inicial la sesion del usuario.
*
* @param request
* @param response
* @return
*/
public Object doLogin(Request request, Response response) {
String nickname = request.queryParams("nickname").toLowerCase();
String password = request.queryParams("password");
SessionFactory sessionFactory = HibernateUtil.getSessionFactory();
Session session = sessionFactory.openSession();
User user =
(User)
session
.createCriteria(User.class)
.add(Restrictions.eq("nickname", nickname))
.add(Restrictions.eq("password", password))
.uniqueResult();
UserValidator validator = new UserValidator(request.session());
validator.validateUser(user);
if (null != user) {
request.session(true);
request.session().attribute("user", user);
response.redirect("/orders");
} else {
response.redirect("/");
}
return null;
}
/**
* @param request The request object providing information about the HTTP request
* @param response The response object providing functionality for modifying the response
* @return The content to be set in the response
* @throws Exception implementation can choose to throw exception
*/
public String handlePostNewPost(Request request, Response response) throws Exception {
String title = StringEscapeUtils.escapeHtml4(request.queryParams("subject"));
String post = StringEscapeUtils.escapeHtml4(request.queryParams("body"));
String tags = StringEscapeUtils.escapeHtml4(request.queryParams("tags"));
String username = sessionDAO.findUserNameBySessionId(request.cookie("session"));
if (username == null) {
response.redirect("/login"); // only logged in users can post to blog
return templateEngine.render(new ModelAndView(null, "redirect.ftl"));
} else if (title.equals("") || post.equals("")) {
SimpleHash root = new SimpleHash();
// redisplay page with errors
root.put("errors", "post must contain a title and blog entry.");
root.put("subject", title);
root.put("username", username);
root.put("tags", tags);
root.put("body", post);
return templateEngine.render(new ModelAndView(root, "newpost_template.ftl"));
} else {
// extract tags
List<String> tagsArray = extractTags(tags);
// substitute some <p> for the paragraph breaks
post = post.replaceAll("\\r?\\n", "<p>");
String permalink = blogPostDAO.addPost(title, post, tagsArray, username);
// now redirect to the blog permalink
response.redirect("/post/" + permalink);
return templateEngine.render(new ModelAndView(null, "redirect.ftl"));
}
}
@Override
public Object handle(final Request request, final Response response) throws Exception {
if (!CreateGameDTO.isValidRequestJson(request.body())) {
response.status(400);
return BAD_JSON_MESSAGE;
}
final CommandExecutionResult result =
GamesController.createGame(new CreateGameDTO(request.body()));
if (result.errorOccurred()) {
response.status(result.getStatus());
} else {
response.status(200);
}
// set any new cookies
if (result.hasNewCookies()) {
Map<String, String> cookies = result.getNewCookies();
for (String key : cookies.keySet()) {
Cookie cookie = new Cookie(key, cookies.get(key));
cookie.setPath("/");
response.raw().addCookie(cookie);
}
}
return result.getBody();
}
/**
* @param request The request object providing information about the HTTP request
* @param response The response object providing functionality for modifying the response
* @return The content to be set in the response
* @throws Exception implementation can choose to throw exception
*/
public String handlePostNewComment(Request request, Response response) throws Exception {
String name = StringEscapeUtils.escapeHtml4(request.queryParams("commentName"));
String email = StringEscapeUtils.escapeHtml4(request.queryParams("commentEmail"));
String body = StringEscapeUtils.escapeHtml4(request.queryParams("commentBody"));
String permalink = request.queryParams("permalink");
Document post = blogPostDAO.findByPermalink(permalink);
if (post == null) {
response.redirect("/post_not_found");
return templateEngine.render(new ModelAndView(null, "redirect.ftl"));
}
// check that comment is good
else if (name.equals("") || body.equals("")) {
// bounce this back to the user for correction
SimpleHash comment = new SimpleHash();
comment.put("name", name);
comment.put("email", email);
comment.put("body", body);
SimpleHash root = new SimpleHash();
root.put("comment", comment);
root.put("post", post);
root.put("errors", "Post must contain your name and an actual comment");
return templateEngine.render(new ModelAndView(root, "entry_template.ftl"));
} else {
blogPostDAO.addPostComment(name, email, body, permalink);
response.redirect("/post/" + permalink);
return templateEngine.render(new ModelAndView(null, "redirect.ftl"));
}
}
public synchronized String transferFromBankToPlayer(Request request, Response response) {
lamport.Add();
if (banks.containsKey(request.params(":gameid"))) {
Collection<Account> accounts = banks.get(request.params(":gameid"));
for (Account account : accounts) {
if (account.getPlayer().getId().equals(request.params(":to"))) {
int am = Integer.parseInt(request.params(":amount"));
account.AddAmount(am);
banks.put(request.params(":gameid"), accounts);
String uri = localUri + "transfers/" + UniqueId++;
Transfer trans =
new Transfer(
request.params(":from"), request.params(":to"), am, request.body(), "", uri);
Event event =
new Event(
"bank transfer",
request.body(),
request.body(),
uri,
account.getPlayer().getId());
transfers.add(trans);
BanksService.sendUpdate(trans, request.params(":gameid"));
response.status(201);
return gson.toJson(event);
}
}
response.status(404);
return "Player not found.";
} else {
response.status(404);
return "Game not found.";
}
}
@Override
public Object handle(Request request, Response response) throws Exception {
String firstName = request.queryParams("firstname");
String lastName = request.queryParams("lastname");
Employee employee = new Employee(firstName, lastName);
Long employeeId = storage.addEmployee(employee);
return employeeId;
}
private String upsertUser(Request request, Response response) throws UsersRepositoryException {
try {
return userService.upsertUser(
request.params(USER_NAME), jsonExtractor.parse(request.body()).getPassword(), response);
} catch (JsonExtractException e) {
LOGGER.info("Error while deserializing addUser request", e);
response.status(400);
return Constants.EMPTY_BODY;
} catch (IllegalArgumentException e) {
LOGGER.info("Invalid user path", e);
response.status(400);
return Constants.EMPTY_BODY;
}
}
/**
* @param request The request object providing information about the HTTP request
* @param response The response object providing functionality for modifying the response
* @return The content to be set in the response
* @throws Exception implementation can choose to throw exception
*/
public String handleGetByTag(Request request, Response response) throws Exception {
String username = sessionDAO.findUserNameBySessionId(request.cookie("session"));
SimpleHash root = new SimpleHash();
String tag = StringEscapeUtils.escapeHtml4(request.params(":thetag"));
List<Document> posts = blogPostDAO.findByTagDateDescending(tag);
root.put("myposts", posts);
if (username != null) {
root.put("username", username);
}
return templateEngine.render(new ModelAndView(root, "blog_template.ftl"));
}
public static Map<String, Object> getBaseModel(Request request) {
Map<String, Object> model = new HashMap<>();
model.put("request", request);
model.put("context", request.contextPath());
model.put("date", new DateTool());
return model;
}
public static LayoutContent displayHome(spark.Request request, Configuration cfg) {
String html = "";
Map<String, String> root = Tools.listLayoutMap();
root.replace("msg", DBH.getMsg(request.session().id()));
Template temp;
try {
temp = cfg.getTemplate("user-home.htm");
Writer out = new StringWriter();
temp.process(root, out);
html = out.toString();
} catch (IOException | TemplateException e) {
// TODO Auto-generated catch block
e.printStackTrace();
html = e.getMessage();
}
HashMap<String, String> options = new HashMap<String, String>();
options.put("addBtn", Tools.getAddBtn("/tramites/agregar", "Iniciar Trámite"));
options.put(
"toolBar",
Tools.getToolbarItem("/tramites/agregar", "Iniciar Trámite", "", "btn red darken-3")
+ Tools.getToolbarItem("/tramites", "Trámites", "", "btn green darken-3"));
LayoutContent lc = new LayoutContent(html, options);
return lc;
}
@Override
public Object handle(Request request, Response response) {
JSONObject result;
try {
JSONObject requestJSON = new JSONObject(request.body());
SudokuGame game =
new SudokuGame(convertJSONObjectToStringArray(requestJSON.getJSONArray("data")));
game.solve();
result = convertStringToJSONObject(game.toString());
} catch (CannotProceedException e) {
result = createErrorMessage("cannot solve");
logger.error(e.getMessage());
} catch (Exception e) {
result = createErrorMessage("unknown");
logger.error(e.getMessage());
}
response.type("application/json");
/*try {
Thread.sleep(15000);
} catch (InterruptedException e) {
e.printStackTrace();
}*/
return result;
}
public VuiBeanResponse doLosQueryService(Request request, Response response) {
VuiBeanResponse losResponse = new VuiBeanResponse();
try {
System.out.println("OnePointServlet : doLOSQuery : Enters");
RequestObject req = ObjectTransformer.convert(request.queryString(), RequestObject.class);
String resp = new IntradoService().doLos(req);
ResObject queryResponse = unmarshall(resp);
losResponse = queryResponse.getPayload().getLosResponse();
if (null == losResponse || null == losResponse.getLevelOfService()) {
String message = queryResponse.getPayload().getErrorResponse().getMessage();
System.out.println("Message ---> :" + message);
losResponse = new VuiBeanResponse();
losResponse.setMessage(message);
}
System.out.println("OnePointServlet : doLOSQuery : Exits");
} catch (Exception e) {
e.printStackTrace();
}
return losResponse;
}
/**
* @param request The request object providing information about the HTTP request
* @param response The response object providing functionality for modifying the response
* @return The content to be set in the response
* @throws Exception implementation can choose to throw exception
*/
public String handleGetPermaLinkPost(Request request, Response response) throws Exception {
String permalink = request.params(":permalink");
System.out.println("/post: get " + permalink);
Document post = blogPostDAO.findByPermalink(permalink);
if (post == null) {
response.redirect("/post_not_found");
return templateEngine.render(new ModelAndView(null, "redirect.ftl"));
} else {
// empty comment to hold new comment in form at bottom of blog entry detail page
SimpleHash newComment = new SimpleHash();
newComment.put("name", "");
newComment.put("email", "");
newComment.put("body", "");
SimpleHash root = new SimpleHash();
root.put("post", post);
root.put("comments", newComment);
return templateEngine.render(new ModelAndView(root, "entry_template.ftl"));
}
}
public ModelAndView handle(Request request, Response response) throws Exception {
// On regarde si l'utilisateur a accès
ModelAndView modelAndView = Authentification.checkEnseignant(request, response);
if (modelAndView != null) return modelAndView;
Map<String, Object> attributes = new HashMap<String, Object>();
attributes.put("title", "Inscription au créneau");
attributes.put("connected", (request.session().attribute("email") != null));
attributes.put("labo", (request.session().attribute("labo") != null));
attributes.put("enseignant", (request.session().attribute("enseignant") != null));
Integer idEnseignant = request.session().attribute("enseignant");
if (idEnseignant == null) response.redirect("/enseignant");
return new ModelAndView(attributes, "inscription-creneau.ftl");
}
@Test
public void testGetFeedItems() {
Request request = createRequestMock("logged-in");
Response response = createResponseMock();
GetFeedItemsRoute feedsRoute = new GetFeedItemsRoute("/feeds");
feedsRoute.setFeedItemProvider(createFeedItemProviderMock());
feedsRoute.setFeedUpdater(createFeedUpdaterMock());
feedsRoute.setFeedProvider(createFeedProviderMock());
when(request.params(":categoryId")).thenReturn("1");
when(request.params(":feedId")).thenReturn("2");
String jsonResponse = (String) feedsRoute.handle(request, response);
String expectedJson =
"[{\"feedItemId\":\"3\",\"username\":\"billblake\",\"catId\":\"1\",\"feedId\":\"2\",\"source\":\"source\",\"title\":\"title\",\"description\":\"description\",\"link\":\"link\",\"imageUrl\":null,\"pubDate\":10000000,\"formattedDate\":\"Jul 28\",\"read\":false,\"saved\":false,\"tags\":null}]";
assertEquals(expectedJson, jsonResponse);
}
private String getUriParam(Request req, String prefix) {
String ret = req.pathInfo().substring(prefix.length());
int index = ret.indexOf("?");
if (index != -1) {
ret = ret.substring(0, index);
}
return ret;
}
public static Set<Route> getRoutesForStop(Request req, List<String> feeds) {
if (req.queryParams("stop") != null) {
String stopId = req.queryParams("stop");
System.out.println(stopId);
Set<Route> routes = new HashSet<>();
// loop through feeds
for (String feedId : feeds) {
// loop through patterns, check for route and return pattern stops
FeedSource source = ApiMain.getFeedSource(feedId);
for (Pattern pattern : source.feed.patterns.values()) {
if (pattern.orderedStops.contains(stopId)) {
routes.add(source.feed.routes.get(pattern.route_id));
}
}
}
return routes;
}
return null;
}
public Object create(Request request, Response response) throws Exception {
final Map<String, String[]> project = request.queryMap("project").toMap();
Project p = Project.fromMap(project);
repository.save(p);
response.redirect("/#/index/dashboard");
return null;
}
public VuiBeanResponse doQueryService(Request request, Response response) {
VuiBeanResponse queryDataResponse = new VuiBeanResponse();
System.out.println("doQueryService : Enters");
try {
String stCPN = request.queryParams("CPN");
String stExternalKey = request.queryParams("ExternalKey");
String resp = new IntradoService().queryData(stCPN, stExternalKey);
ResObject queryResponse = unmarshall(resp);
queryDataResponse = queryResponse.getPayload().getQueryResponse();
System.out.println("OnePointServlet : doQueryService : Exits");
} catch (Exception e) {
e.printStackTrace();
}
return queryDataResponse;
}
/**
* Metodo para registrar a un usuario.
*
* @param request
* @param response
* @return
*/
public Object doSignup(Request request, Response response) {
String name = request.queryParams("name");
String lastName = request.queryParams("last_name");
String nickname = request.queryParams("nickname").toLowerCase();
String password = request.queryParams("password");
String confirmPassword = request.queryParams("confirm_password");
UserValidator validator = new UserValidator(request.session());
validator.validateUserName(name);
validator.validateUserLastName(lastName);
validator.validateNickname(nickname);
validator.validatePassword(password, confirmPassword);
if (!validator.error()) {
SessionFactory sessionFactory = HibernateUtil.getSessionFactory();
Session session = sessionFactory.openSession();
Transaction transaction = session.beginTransaction();
User user = new User();
user.setName(name);
user.setLastName(lastName);
user.setNickname(nickname);
user.setPassword(password);
user.setIsAdmin(false);
session.save(user);
transaction.commit();
session.close();
doLogin(request, response);
} else {
response.redirect("/");
}
return null;
}
@Override
public Object handle(Request request, Response response) throws Exception {
try {
String serviceName = request.params(":serviceName");
deleteServiceJob(serviceName, user, password, tenant, dbClient);
response.status(HttpConstants.HTTP_OK);
response.type(HttpConstants.APPLICATION_JSON);
return "Deletion scheduled for service " + serviceName;
} catch (Exception e) {
response.status(HTTP_BAD_REQUEST);
return e.toString();
}
}
/**
* This is where we would normally load up the blog data but this week, we just display a
* placeholder.
*
* @param request The request object providing information about the HTTP request
* @param response The response object providing functionality for modifying the response
* @return The content to be set in the response
* @throws Exception implementation can choose to throw exception
*/
public String handleGetRoot(Request request, Response response) throws Exception {
SimpleHash root = new SimpleHash();
String username = sessionDAO.findUserNameBySessionId(request.cookie("session"));
List<Document> posts = blogPostDAO.findByDateDescending(10);
root.put("myposts", posts);
if (username != null) {
root.put("username", username);
}
return templateEngine.render(new ModelAndView(root, "blog_template.ftl"));
}
public static byte[] getOrigin(Request req, Response res) {
res.header("Content-Type", "application/octet-stream");
ByteArrayOutputStream baos = new ByteArrayOutputStream();
int x = Integer.parseInt(req.params("x"));
int y = Integer.parseInt(req.params("y").replaceFirst("\\.dat$", ""));
StaticSiteRequest.PointRequest pr = staticSiteRequest.getPointRequest(x, y);
StaticComputer computer = new StaticComputer(pr, network, new TaskStatistics());
try {
computer.write(baos);
return baos.toByteArray();
} catch (Exception e) {
throw new RuntimeException(e);
}
}
private String removeUser(Request request, Response response) {
String username = request.params(USER_NAME);
try {
userService.removeUser(username);
response.status(204);
return Constants.EMPTY_BODY;
} catch (UsersRepositoryException e) {
response.status(204);
return "The user " + username + " does not exists";
} catch (IllegalArgumentException e) {
LOGGER.info("Invalid user path", e);
response.status(400);
return Constants.EMPTY_BODY;
}
}
/**
* @param request The request object providing information about the HTTP request
* @param response The response object providing functionality for modifying the response
* @return The content to be set in the response
* @throws Exception implementation can choose to throw exception
*/
public String handleGetNewPost(Request request, Response response) throws Exception {
// get cookie
String username = sessionDAO.findUserNameBySessionId(request.cookie("session"));
if (username == null) {
// looks like a bad request. user is not logged in
response.redirect("/login");
return templateEngine.render(new ModelAndView(null, "redirect.ftl"));
} else {
SimpleHash root = new SimpleHash();
root.put("username", username);
return templateEngine.render(new ModelAndView(root, "newpost_template.ftl"));
}
}
public VuiBeanResponse doInsertOrDel(Request request, Response response, String action) {
VuiBeanResponse updateResponse = new VuiBeanResponse();
try {
System.out.println("OnePointServlet : doInsert : Enters");
RequestObject req = ObjectTransformer.convert(request.queryString(), RequestObject.class);
String resp = new IntradoService().doInsertOrDel(req, action);
ResObject queryResponse = unmarshall(resp);
updateResponse = queryResponse.getPayload().getUpdateResponse();
System.out.println("OnePointServlet : doInsert : Exits");
} catch (Exception e) {
e.printStackTrace();
}
return updateResponse;
}
public synchronized String replaceBanks(Request request, Response response) {
Type collectionType = new TypeToken<HashMap<String, Collection<Account>>>() {}.getType();
HashMap<String, Collection<Account>> json = gson.fromJson(request.body(), collectionType);
banks = json;
return "success";
}
private CallingContext getContext(Request req) {
return ctxs.get(req.session().id());
}