Actions.java

Go to the documentation of this file.

/*
 * Turró i Cutiller Foundation. License notice.
 * Copyright (C) 2014 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.action;
 
import java.io.IOException;
import java.io.UnsupportedEncodingException;
import java.net.URLDecoder;
import java.net.URLEncoder;
import java.nio.charset.Charset;
import java.nio.charset.StandardCharsets;
import java.util.Date;
import java.util.HashMap;
import java.util.Map;
import java.util.Objects;
import java.util.logging.Level;
import java.util.logging.Logger;
import javax.servlet.http.HttpServletResponse;
import org.amic.util.date.CheckDate;
import org.turro.collections.parser.ParserException;
import org.turro.string.ObjectString;
import org.turro.string.Strings;
import org.turro.annotation.ExternalAction;
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.security.IUser;
import org.turro.log.SystemLogType;
import org.turro.log.SystemLogger;
import org.turro.plugin.contacts.IContact;
import org.turro.reflection.Instances;
import org.turro.sso.SSO;
import org.turro.util.CompareUtil;
 
public class Actions {
  
  private static final Charset charset = StandardCharsets.UTF_8;
  
  private static final String 
          ACTION_PAR = "exacton",
          RIGHTNOW_PAR = "exrino",
          DVALID_PAR = "dvalid",
          AJAX_PAR = "ajax";
  
  public static final String 
          USER_PAR = "user",
          REDIR_PAR = "redir",
          COMMAND_PAR = "command";
  
  public static boolean executeAction(IConstructor constructor) {
    String exacton = constructor.getParameter(ACTION_PAR);
    if(!Strings.isBlank(exacton)) {
      try {
        KeyValueMap kvm = new KeyValueMap(ElephantContext.decrypt(exacton));
        if(prepareActions(constructor, kvm)) {
          executeExternalActions(constructor, kvm);
          return checkEnding(constructor, kvm);
        }
      } catch (IOException | ParserException ex) {
        Logger.getLogger(Actions.class.getName()).log(Level.SEVERE, ElephantContext.logMsg(null), ex);
      }
    }
    return false;
  }
 
  public static String createActionFromElephant(String email, String redir) {
    return createAction(email, Strings.convert(redir, charset(redir), Actions.getCharset().name()));
  }
  
  public static String createAction(String email, String redir) {
    String exacton = createParameter(email, redir);
    if(exacton != null) {
      return ACTION_PAR + "=" + exacton;
    }
    return null;
  }
  
  public static String createAction(Map<String, String> values, int daysValid, boolean ajax) {
    String exacton = createParameter(values, daysValid, ajax);
    if(exacton != null) {
      return ACTION_PAR + "=" + exacton;
    }
    return null;
  }
 
  public static String createAction(Map<String, String> values, boolean ajax) {
    String exacton = createParameter(values, ajax);
    if(exacton != null) {
      return ACTION_PAR + "=" + exacton;
    }
    return null;
  }
 
  public static String createAction(Map<String, String> values) {
    String exacton = createParameter(values);
    if(exacton != null) {
      return ACTION_PAR + "=" + exacton;
    }
    return null;
  }
 
  public static String createParameter(String email, String redir) {
    try {
      HashMap<String, String> values = new HashMap<>();
      values.put(Actions.USER_PAR, email);
      values.put(Actions.REDIR_PAR, URLEncoder.encode(redir, charset.name()));
      return Actions.createParameter(values, 8, false);
    } catch (UnsupportedEncodingException ex) {
      Logger.getLogger(Actions.class.getName()).log(Level.SEVERE, null, ex);
    }
    return null;
  }
  
  public static String createParameter(Map<String, String> values, int daysValid, boolean ajax) {
    values.put(DVALID_PAR, ObjectString.formatObject(new CheckDate().addDays(daysValid).getDate(), ObjectString.COMPRESSED_DATE_PATTERN, false));
    return createParameter(values, ajax);
  }
 
  public static String createParameter(Map<String, String> values, boolean ajax) {
    if(ajax) {
      values.put(AJAX_PAR, "true");
    }
    return createParameter(values);
  }
 
  public static String createParameter(Map<String, String> values) {
    String action = KeyValueMap.format(values);
    if(action != null) {
      try {
        return URLEncoder.encode(ElephantContext.encrypt(action), charset.name());
      } catch (UnsupportedEncodingException ex) {
        Logger.getLogger(Actions.class.getName()).log(Level.SEVERE, ElephantContext.logMsg(null), ex);
      }
    }
    return null;
  }
  
  public static String createParameter(String action) {
    if(action != null) {
      try {
        return URLEncoder.encode(ElephantContext.encrypt(action), charset.name());
      } catch (UnsupportedEncodingException ex) {
        Logger.getLogger(Actions.class.getName()).log(Level.SEVERE, ElephantContext.logMsg(null), ex);
      }
    }
    return null;
  }
  
  public static Charset getCharset() {
    return charset;
  }
 
  public static boolean prepareActions(IConstructor constructor, KeyValueMap values) {
    boolean authenticated = false;
    IUser logged = constructor.getUser();
    String email = values.get(USER_PAR);
    if(!Strings.isBlank(email) && logged != null) {
      authenticated = CompareUtil.compare(email, logged.getProperty(IUser.CONNECTOR_EMAIL)) == 0;
    }
    if(!authenticated && (isReminder(values) || ElephantContext.getLiveLinks())) {
      Date valid = (Date) ObjectString.parseString(values.get(DVALID_PAR), ObjectString.COMPRESSED_DATE_PATTERN, Date.class, false);
      if(valid != null) {
        if(valid.before(new Date())) {
          return false;
        }
      }
      if(!Strings.isBlank(email)) {
        IContact user = Contacts.getEmpty();
        if(!user.impersonateByEmail(email)) {
          return false;
        }
        constructor.setSessionAttribute(IUser.INTERNAL_SIGNIN, Boolean.TRUE);
        constructor.setSessionAttribute(IUser.LOGGED_USER, user);
        constructor.setSessionAttribute(Contacts.LOGGED_ICONTACT, Contacts.getLoggedIContact(Application.getApplication()));
        SystemLogger.getInstance().doLog(SystemLogType.LOG_INFO, "/log/in", "Live Link", values.toString());
        if(SSO.hasSSO()) {
          SSO.getSSO().createAssertion(constructor.getRequest(), constructor.getResponse(),
                  (IContact) constructor.getSessionAttribute(Contacts.LOGGED_ICONTACT));
        }
      }
    }
    return true;
  }
  
  public static boolean checkEnding(IConstructor constructor, KeyValueMap values) throws IOException {
    String redir = values.get(REDIR_PAR);
    if(!Strings.isBlank(redir)) {
      HttpServletResponse response = constructor.getResponse();
      response.setCharacterEncoding(charset.name());
      response.sendRedirect(ElephantContext.getRootWebPath() + 
              encodePars(URLDecoder.decode(redir, charset.name()), charset.name() + addParameters(values)));
      return true;
    }
    String ajax = values.get(AJAX_PAR);
    if("true".equals(ajax)) {
      return true;
    }
    return false;
  }
  
  private static String addParameters(KeyValueMap values) {
    String result = "";
    for(String key : values.keySet()) {
      if(!internalPar(key)) {
        if(Strings.isBlank(result)) {
          result = "?" + key + "=" + values.get(key);
        } else {
          result = "&" + key + "=" + values.get(key);
        }
      }
    }
    return result;
  }
 
  private static boolean internalPar(String par) {
    return USER_PAR.equals(par) ||
           DVALID_PAR.equals(par) ||
           AJAX_PAR.equals(par) ||
           REDIR_PAR.equals(par);
  }
  
  /* External Actions */
  
  public static boolean executeExternalActions(IConstructor constructor, KeyValueMap values) {
    if (Instances.cached().byAnnotation(ExternalAction.class, IAction.class)
            .stream().anyMatch((iAction) -> (iAction.execute(constructor, values)))) {
      return true;
    }
    return false;
  }
 
  public static KeyValueMap getAction(IConstructor constructor) {
    String exacton = constructor.getParameter(ACTION_PAR, false);
    if(!Strings.isBlank(exacton)) {
      try {
        KeyValueMap values = new KeyValueMap(ElephantContext.decrypt(exacton));
        Date valid = (Date) ObjectString.parseString(values.get(DVALID_PAR), ObjectString.COMPRESSED_DATE_PATTERN, Date.class, false);
        if(valid != null) {
          if(valid.before(new Date())) {
            return null;
          }
        } else {
          return null;
        }
        return values;
      } catch (ParserException ex) {
        Logger.getLogger(Actions.class.getName()).log(Level.SEVERE, ElephantContext.logMsg(null), ex);
      }
    }
    return null;
  }
 
  private static boolean isReminder(KeyValueMap values) {
    try {
      String redir = values.get(REDIR_PAR);
      return Strings.isBlank(redir) ? false : Objects.equals("/user/changepass", URLDecoder.decode(redir, charset.name()));
    } catch (UnsupportedEncodingException ex) {
      Logger.getLogger(Actions.class.getName()).log(Level.SEVERE, null, ex);
    }
    return false;
  }
  
  private Actions() {
  }
 
  /* RigthNow Actions */
  
  public static boolean isRightNowAction(IConstructor constructor) {
    return !Strings.isBlank(constructor.getParameter(RIGHTNOW_PAR, true));
  }
  
  public static String createPars(String values, int days) {
    try {
      return createRightNowParameter(new KeyValueMap(values));
    } catch (ParserException ex) {
      Logger.getLogger(Actions.class.getName()).log(Level.SEVERE, ElephantContext.logMsg(null), ex);
    }
    return null;
  }
  
  public static String createPars(Map<String, String> values, int days) {
    values.put(DVALID_PAR, ObjectString.formatObject(new CheckDate().addDays(days).getDate(), ObjectString.COMPRESSED_DATE_PATTERN, false));
    return createParameter(values);
  }
 
  public static Map<String, String>  addEmailAndDays(Map<String, String> values, String email, int days) {
    values.put(DVALID_PAR, ObjectString.formatObject(new CheckDate().addDays(days).getDate(), ObjectString.COMPRESSED_DATE_PATTERN, false));
    values.put(USER_PAR, email);
    return values;
  }
  
  public static String createRightNowAction(String values) {
    try {
      return createRightNowAction(new KeyValueMap(values));
    } catch (ParserException ex) {
      Logger.getLogger(Actions.class.getName()).log(Level.SEVERE, null, ex);
    }
    return null;
  }
  
  public static String createRightNowAction(Map<String, String> values) {
    String exrino = createRightNowParameter(values);
    if(exrino != null) {
      try {
        return RIGHTNOW_PAR + "=" + URLEncoder.encode(exrino, charset.name());
      } catch (UnsupportedEncodingException ex) {
        Logger.getLogger(Actions.class.getName()).log(Level.SEVERE, ElephantContext.logMsg(null), ex);
      }
    }
    return null;
  }
  
  public static String createRightNowParameter(String values) {
    return createPars(values, 1);
  }
  
  public static String createRightNowParameter(Map<String, String> values) {
    return createPars(values, 1);
  }
 
  public static KeyValueMap getRightNowAction(IConstructor constructor) {
    String exrino = constructor.getParameter(RIGHTNOW_PAR, true);
    if(!Strings.isBlank(exrino)) {
      try {
        KeyValueMap values = new KeyValueMap(ElephantContext.decrypt(exrino));
        Date valid = (Date) ObjectString.parseString(values.get(DVALID_PAR), ObjectString.COMPRESSED_DATE_PATTERN, Date.class, false);
        if(valid != null) {
          if(valid.before(new Date())) {
            return null;
          }
        } else {
          return null;
        }
        return values;
      } catch (ParserException ex) {
        Logger.getLogger(Actions.class.getName()).log(Level.SEVERE, null, ex);
      }
    }
    return null;
  }
  
  private static String charset(String value) {
    return Strings.charset(value, new String[] { ElephantContext.getEncoding(), charset.name() });
  }
  
  private static String encodePars(String url, String charset) {
    try {
      int p = url.indexOf("?");
      if(p > 1) {
        KeyValueMap map = new KeyValueMap(url.substring(p + 1), "&", "=");
        url = url.substring(0, p + 1) + map.getEncoded(charset);
      }
      return url;
    } catch (UnsupportedEncodingException | ParserException ex) {
      Logger.getLogger(Actions.class.getName()).log(Level.SEVERE, ElephantContext.logMsg(null), ex);
    }
    return null;
  }
  
}