MailInline.java

Go to the documentation of this file.

/*
 * Turró i Cutiller Foundation. License notice.
 * Copyright (C) 2022 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.mail.message;
 
import com.steadystate.css.parser.CSSOMParser;
import java.io.File;
import java.io.FilenameFilter;
import java.io.IOException;
import java.io.StringReader;
import java.util.HashMap;
import java.util.LinkedHashMap;
import java.util.Map;
import java.util.StringTokenizer;
import org.turro.string.Strings;
import org.jsoup.Jsoup;
import org.jsoup.nodes.Document;
import org.jsoup.nodes.Element;
import org.jsoup.select.Elements;
import org.turro.elephant.context.ElephantContext;
import org.turro.elephant.impl.util.FileUtil;
import org.turro.html.HTMLEntities;
import org.turro.log.WebLoggers;
import org.w3c.css.sac.InputSource;
import org.w3c.dom.css.CSSRule;
import org.w3c.dom.css.CSSRuleList;
import org.w3c.dom.css.CSSStyleDeclaration;
import org.w3c.dom.css.CSSStyleRule;
import org.w3c.dom.css.CSSStyleSheet;
 
public class MailInline {
 
  public static final String MAIL_CSS = "/WEB-INF/elephant/templates-mail/css";
 
  public String inline(String html) {
    if(Strings.isBlank(html)) {
      return html;
    }
//    try {
//      html = inlineStyles(html);
//    } catch (IOException ex) {
//      Logger.getLogger(MailFormat.class.getName()).log(Level.SEVERE, ElephantContext.logMsg(null), ex);
//    }
    File rootCSS = new File(ElephantContext.getRealPath(MAIL_CSS));
    if (rootCSS.exists()) {
      for (File css : rootCSS.listFiles(new FilenameFilter() {
        @Override
        public boolean accept(File dir, String name) {
          return name.endsWith(".css");
        }
      })) {
        try {
          html = inlineCSS(css, html);
        } catch (IOException ex) {
          WebLoggers.info(this).exception(ex).log();
        }
      }
    }
    return HTMLEntities.escape(html);
  }
 
  private String inlineCSS(File css, String html) throws IOException {
    CSSOMParser parser = new CSSOMParser();
    CSSStyleSheet stylesheet = parser.parseStyleSheet(new InputSource(new StringReader(FileUtil.getContent(css))), null, null);
 
    final Document doc = Jsoup.parse(html);
    final CSSRuleList rules = stylesheet.getCssRules();
    final Map<Element, Map<String, String>> elementStyles = new HashMap<>();
 
    for (int i = 0; i < rules.getLength(); i++) {
      final CSSRule rule = rules.item(i);
      if (rule instanceof CSSStyleRule) {
        final CSSStyleRule styleRule = (CSSStyleRule) rule;
        final String selector = styleRule.getSelectorText();
 
        if (!selector.contains(":")) {
          final Elements selectedElements = doc.select(selector);
          for (final Element selected : selectedElements) {
            if (!elementStyles.containsKey(selected)) {
              elementStyles.put(selected, new LinkedHashMap<String, String>());
            }
 
            final CSSStyleDeclaration styleDeclaration = styleRule.getStyle();
 
            for (int j = 0; j < styleDeclaration.getLength(); j++) {
              final String propertyName = styleDeclaration.item(j);
              final String propertyValue = styleDeclaration.getPropertyValue(propertyName);
              final Map<String, String> elementStyle = elementStyles.get(selected);
              elementStyle.put(propertyName, convert(propertyValue));
            }
 
          }
        }
      }
    }
 
    for (final Map.Entry<Element, Map<String, String>> elementEntry : elementStyles.entrySet()) {
      final Element element = elementEntry.getKey();
      final StringBuilder builder = new StringBuilder();
      for (final Map.Entry<String, String> styleEntry : elementEntry.getValue().entrySet()) {
        builder.append(styleEntry.getKey()).append(":").append(styleEntry.getValue()).append(";");
      }
      builder.append(element.attr("style"));
      element.attr("style", builder.toString());
      //element.removeAttr("class");
    }
    
    return doc.html();
  }
 
  public String inlineStyles(String html) throws IOException {
    final Document doc = Jsoup.parse(html);
    String style = "style";
    Elements els = doc.select(style);
    for (Element e : els) {
      String styleRules = e.getAllElements().get(0).data().replaceAll("\n", "").trim(), delims
              = "{}";
      StringTokenizer st = new StringTokenizer(styleRules, delims);
      while (st.countTokens() > 1) {
        String selector = st.nextToken(), properties = st.nextToken();
        if (selector.indexOf(":") > 0) {
          selector = selector.substring(0, selector.indexOf(":"));
        }
        if (Strings.isBlank(selector)) {
          continue;
        }
        Elements selectedElements = doc.select(selector);
        for (Element selElem : selectedElements) {
          String oldProperties = selElem.attr(style);
          selElem.attr(
                  style,
                  oldProperties.length() > 0 ? concatenateProperties(oldProperties,
                  properties) : properties);
        }
      }
      e.remove();
    }
    
    return doc.html();
  }
 
  private static String concatenateProperties(String oldProp, String newProp) {
    oldProp = oldProp.trim();
    if (!newProp.endsWith(";")) {
      newProp += ";";
    }
    return newProp + oldProp;
  }
 
  private String convert(String propertyValue) {
    if(propertyValue.startsWith("rgb")) {
      String colors[] = propertyValue.substring(4, propertyValue.length() - 1).split("\\s*,\\s*");
      propertyValue = String.format("#%02x%02x%02x", 
              Integer.parseInt(colors[0]), Integer.parseInt(colors[1]), Integer.parseInt(colors[2]));  
    }
    return propertyValue; //.replaceAll("\\&quot\\;", "'");
  }
  
}