MarkerHelper.java

Go to the documentation of this file.

/*
 * Turró i Cutiller Foundation. License notice.
 * Copyright (C) 2016 Lluis Turró Cutiller <http://www.turro.org/>
 *
 * This program is free software: you can redistribute it and/or modify
 * it under the terms of the GNU Affero General Public License as published by
 * the Free Software Foundation, either version 3 of the License, or
 * (at your option) any later version.
 *
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU Affero General Public License for more details.
 *
 * You should have received a copy of the GNU Affero General Public License
 * along with this program.  If not, see <http://www.gnu.org/licenses/>.
 */
 
package org.turro.marker;
 
import java.io.File;
import java.io.IOException;
import java.io.PrintWriter;
import java.io.StringWriter;
import java.net.URLDecoder;
import java.net.URLEncoder;
import java.nio.charset.Charset;
import java.nio.charset.StandardCharsets;
import java.util.HashMap;
import java.util.Map;
import java.util.Optional;
import java.util.Set;
import java.util.UUID;
import java.util.logging.Level;
import java.util.logging.Logger;
import javax.servlet.ServletException;
import javax.servlet.http.HttpServletRequest;
import org.turro.collections.parser.ParserException;
import org.turro.string.Strings;
import org.turro.action.Actions;
import org.turro.action.ContentService;
import org.turro.action.EntityInfoContent;
import org.turro.action.EntityInfoType;
import org.turro.action.LinkType;
import org.turro.action.MailSenders;
import org.turro.action.Plugins;
import org.turro.collections.KeyValueMap;
import org.turro.elephant.context.Application;
import org.turro.elephant.context.ElephantContext;
import org.turro.elephant.context.IConstructor;
import org.turro.elephant.direct.DirectContents;
import org.turro.elephant.direct.IDirectContent;
import org.turro.elephant.impl.repository.Repository;
import org.turro.elephant.impl.util.Parser;
import org.turro.elephant.security.IUser;
import org.turro.elephant.user.menu.IUserMenu;
import org.turro.elephant.user.menu.UserMenus;
import org.turro.elephant.web.ElContext;
import org.turro.elephant.web.tags.SessionTags;
import org.turro.elephant.web.tags.TagsServlet;
import org.turro.file.Document;
import org.turro.help.HelpContext;
import org.turro.html.Colors;
import org.turro.html.HtmlContent;
import org.turro.log.WebLoggers;
import org.turro.plugin.contacts.IContact;
import org.turro.reflection.Reflections;
import org.turro.user.activity.ActivityType;
import org.turro.user.activity.UserActivityContent;
import org.turro.user.content.IElephantUserContent;
import org.turro.user.content.UserContents;
 
public class MarkerHelper {
  
  private static final Charset charset = StandardCharsets.UTF_8;
  
  private final IConstructor constructor;
 
  public MarkerHelper(IConstructor constructor) {
    this.constructor = constructor;
  }
  
  public String getQRCodeFromCurrent() {
    return getQRCodeFromUrl(constructor.getRequest().getRequestURL().toString());
  }
 
  public String getQRCodeFromUrl(String url) {
    HashMap map = new HashMap();
    map.put("type", "qrcode");
    map.put("data", url);
    return getContent(new KeyValueMap(map));
  }
 
  public String getImageFromUrl(String url) {
    HashMap map = new HashMap();
    map.put("type", "image");
    map.put("data", url);
    return getContent(new KeyValueMap(map));
  }
 
  public String getContent(String values) {
    return ContentService.createURL(constructor, values);
  }
 
  public String getContent(KeyValueMap values) {
    return ContentService.createURL(constructor, values);
  }
 
  public String getEntryPoint(String entryPoint, String values) {
    return ContentService.createEntryPoint(constructor, entryPoint, values);
  }
 
  public String getEntryPoint(String entryPoint, KeyValueMap values) {
    return ContentService.createEntryPoint(constructor, entryPoint, values);
  }
 
  public Repository getRepository(String path) {
    return new Repository(constructor, path);
  }
  
  public String imageOrEmpty(String image) {
    return imageExists(image) ? image : "/_zul/images/no_img.png";
  }
  
  public String imageOrDefault(String image) {
    return imageExists(image) ? image : "/_zul/images/noimg/noimage.png";
  }
  
  public boolean imageExists(String image) {
    if(Strings.isBlank(image)) return false;
    image = image.contains("?") ? image.substring(0, image.indexOf("?")) : image;
    return new File(ElephantContext.getRealPath(image)).exists();
  }
  
  public IDirectContent getCookies() {
    return DirectContents.getDirectContent("cookie-management");
  }
  
  public IDirectContent getTracker() {
    return DirectContents.getDirectContent("img-tk");
  }
  
  public IDirectContent getPushNotification() {
    return DirectContents.getDirectContent("push-notification");
  }
  
  public IDirectContent getMessageQueue() {
    return DirectContents.getDirectContent("message-queue");
  }
  
  public boolean needCookies() {
    HttpServletRequest request = constructor.getRequest();
    return request != null;
  }
  
  public String processMacrosForWeb(String text) {
    if(text.contains("{@")) {
      StringWriter swriter = new StringWriter();
      try(PrintWriter writer = new PrintWriter(swriter)) {
        Parser.processMacros(constructor, writer, text);
        text = swriter.toString();
      } catch (IOException | ServletException ex) {
        Logger.getLogger(MarkerHelper.class.getName()).log(Level.SEVERE, ElephantContext.logMsg(null), ex);
      }
    }
    return MailSenders.processMacros((IContact) constructor.getUser(), text, true);
  }
  
  public Set<IUserMenu> getUserMenu() {
    return UserMenus.getUserMenu(constructor);
  }
  
  /* User Contents */
  
  public Set<IElephantUserContent> getUserContents() {
    return UserContents.getContents(constructor, (IContact) constructor.getUser());
  }
  
  public Set<String> getUserContentTags() {
    return UserContents.getTags(constructor, (IContact) constructor.getUser());
  }
  
  /* Anonymous */
  
  public IDirectContent getAnonymous() {
    return Plugins.loadImplementation(IDirectContent.class, "anonymous-ctrl");
  }
  
  /* Id's */
  
  public String getIdFrom(String value) {
    return Strings.identifier(value);
  }
  
  public String getUniqueId() {
    return UUID.randomUUID().toString();
  }
  
  /* Help */
  
  public String getHelpLink(ElContext context) {
    return context != null ? HelpContext.helpLink(context.getPath()) : null;
  }
  
  /* EntityInfo */
  
  public String getEntityInfoURL(String entityPath) {
    return EntityInfoContent.createURL(EntityInfoType.FULL, LinkType.WEB) + "&path=" + entityPath;
  }
  
  /* User activity */
  
  public String getUserActivityURL(IContact contact) {
    return new UserActivityContent().createURL(contact, ActivityType.values());
  }
  
  /* Plugins */
  
  public <T> T loadImplementation(String className) {
    Class<T> jclass = Reflections.check(className);
    return Plugins.loadImplementation(jclass);
  }
  
  public <T> T loadImplementation(String className, String label) {
    Class<T> jclass = Reflections.check(className);
    return Plugins.loadImplementation(jclass, label);
  }
  
  /* Web tags */
  
  public String webTags() {
    return SessionTags.get(constructor).path();
  }
  
  public String navigateToWebTag(String fromTag, String webTag) {
    return TagsServlet.navigateFromTo(fromTag, webTag);
  }
  
  public String navigateAndSetWebTag(String fromTag, String path) {
    return TagsServlet.navigateAndSet(fromTag, path);
  }
  
  /* Parameters */
  
  public static final String OBFUSCATED_PAR = "el_xpar";
  private KeyValueMap _keyValueMap;
  
  public String obfuscateParameters(String parameters) {
    return setObfuscatedPars(parameters);
  }
 
  public String obfuscateRightNowPars(String parameters) {
    return setObfuscatedRightNowPars(parameters);
  }
  
  public String getObfuscatedParameter(String parameter) {
    try {
      return getMapFromObfuscated().get(parameter);
    } catch (Exception ex) {
      Logger.getLogger(MarkerHelper.class.getName()).log(Level.SEVERE, ElephantContext.logMsg(null), ex);
    }
    return null;
  }
  
  private KeyValueMap getMapFromObfuscated() {
    if(_keyValueMap == null) {
      String obfuscated = constructor.getParameter(OBFUSCATED_PAR, true);
      if(!Strings.isBlank(obfuscated)) {
        try {
          _keyValueMap = new KeyValueMap(ElephantContext.decrypt(URLDecoder.decode(obfuscated, charset)));
        } catch (Exception ex) {
          WebLoggers.info(this).exception(ex).log();
        }
      }
    }
    return _keyValueMap;
  }
  
  /* Trick */
  
  public String getTrick(int seconds) {
    return FormTrick.createTrick(seconds);
  }
  
  /* Helpers */
  
  public static String setObfuscatedParsPOST(String parameters) {
    return OBFUSCATED_PAR + ":\"" + URLEncoder.encode(Actions.createPars(parameters, 30), charset) + "\"";
  }
  
  public static String setObfuscatedPars(String parameters) {
    return OBFUSCATED_PAR + "=" + URLEncoder.encode(Actions.createPars(parameters, 30), charset);
  }
  
  public static String setObfuscatedPars(KeyValueMap parameters) {
    return OBFUSCATED_PAR + "=" + URLEncoder.encode(Actions.createPars(parameters, 30), charset);
  }
  
  public static String setObfuscatedRightNowPars(String parameters) {
    return OBFUSCATED_PAR + "=" + URLEncoder.encode(Actions.createRightNowParameter(parameters), charset);
  }
  
  public static String setObfuscatedRightNowPars(KeyValueMap parameters) {
    return OBFUSCATED_PAR + "=" + URLEncoder.encode(Actions.createRightNowParameter(parameters), charset);
  }
  
  public static KeyValueMap getObfuscatedParameters() {
    return getObfuscatedFrom(Application.getApplication().getConstructor().getParameter(OBFUSCATED_PAR));
  }
  
  public static KeyValueMap getObfuscatedParameters(HttpServletRequest request) {
    return getObfuscatedFrom(request.getParameter(OBFUSCATED_PAR));
  }
  
  public static KeyValueMap getObfuscatedFrom(String obfuscated) {
    if(!Strings.isBlank(obfuscated)) {
      try {
        return new KeyValueMap(ElephantContext.decrypt(URLDecoder.decode(obfuscated, charset)));
      } catch (Exception ex) {
        WebLoggers.info(MarkerHelper.class).exception(ex).log();
      }
    }
    return null;
  }
  
  public static KeyValueMap getAllParameters() {
    HttpServletRequest request = Application.getApplication().getHttpServletRequest();
    if(request != null) {
      return getAllParameters(request.getParameterMap());
    }
    return new KeyValueMap(new HashMap());
  }
  
  public static KeyValueMap getAllParameters(Map<String, String[]> parameterMap) {
    final Map map = new HashMap();
    if(parameterMap != null) {
      parameterMap.keySet().forEach((key) -> {
        if(OBFUSCATED_PAR.equals(key)) {
          KeyValueMap kvm = MarkerHelper.getObfuscatedFrom(parameterMap.get(key)[0]);
          if(kvm != null) {
            map.putAll(kvm);
          }
        } else {
          map.put(key, parameterMap.get(key)[0]);
        }
      });
    }
    return new KeyValueMap(map);
  }
  
  public static String obsfuscatedPOST(String context, String values) {
    return "$.post(\"" + context + "\", { " + setObfuscatedParsPOST(values) + " })";
  }
  
  /* Direct Content URLs */
  
  public String getSiteAddress() {
    return ElephantContext.getServerUrl("http");
  }
  
  public static String createPOST(String id, String values) {
    return DirectContents.doCreatePOST(id, values);
  }
  
  public static String createPOST(String id, String domId, String values) {
    return DirectContents.doCreatePOST(id, domId, values);
  }
  
  public static String createURL(String id, String values) {
    return DirectContents.doCreateURL(id, values);
  }
  
  public static String createDirectURL(IConstructor constructor, IContact contact, 
          String directContentId, String values, int daysValid, boolean withDomain) {
    String exrino = null;
    try {
      KeyValueMap kvm = new KeyValueMap(values);
      kvm.put(Actions.USER_PAR, contact.getConnector(IUser.CONNECTOR_EMAIL));
      kvm.put(Actions.REDIR_PAR, (withDomain ? ElephantContext.getServerBase("http") : "") + constructor.getCurrentContext().getWebPath());
      exrino = Actions.createAction(kvm, daysValid, false);
    } catch (ParserException ex) {
      Logger.getLogger(MarkerHelper.class.getName()).log(Level.SEVERE, null, ex);
    }
    return (withDomain ? ElephantContext.getServerBase("http") : "") +
            ElephantContext.getRootWebPath() +
            DirectContents.DIRECT_CONTENT_PATH + directContentId +
            "?" + exrino;
  }
 
  /* Truncate */
  
  public String truncate(String text, int max) {
    return Strings.truncate(text, max);
  }
  
  public String truncateHTML(String html, int max) {
    return HtmlContent.truncate(html, max);
  }
  
  public String truncateHTMLtoPlain(String html, int max) {
    return HtmlContent.plain(html, max);
  }
  
  /* Colors */
  
  public Colors.Color color(String color) {
    return Optional.ofNullable(Colors.of(color)).map(c -> c.color()).orElse(null);
  }
  
  /* Download */
  
  public String downloadPath(Document document) {
    return ElephantContext.getRootWebPath() + "/down_" + 
            ElephantContext.removeWebContext(
                    ElephantContext.getRelativePath(document.path().toString()));
  }
  
}