WebContext.java

Go to the documentation of this file.

/*
 * Turró i Cutiller Foundation. License notice.
 * Copyright (C) 2021 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.elephant.web.context;
 
import java.io.File;
import java.io.FileReader;
import java.io.FileWriter;
import java.io.IOException;
import java.io.Reader;
import java.io.Writer;
import java.nio.file.Path;
import java.util.Map;
import java.util.Set;
import java.util.TreeMap;
import java.util.TreeSet;
import java.util.logging.Level;
import java.util.logging.Logger;
import org.turro.string.Strings;
import org.turro.configuration.JsonConfiguration;
import org.turro.elephant.context.ElephantContext;
import org.turro.elephant.context.IElement;
import org.turro.i18n.I_;
 
public class WebContext {
 
  private boolean 
          showInNavigators,
          showAlways,
          traversalNavigation,
          noIndex,
          noFollow,
          printContext,
          printVersion,
          controlVersion,
          icon;
  private Set<String> langs = new TreeSet<>();
  private Map<String, String> names = new TreeMap<>();
  private String i18nKey, order, role, redirect, target, image, webTag;
  
  private WebLayout layout = new WebLayout();
  private WebElement element = new WebElement();
  private WebPage page  = new WebPage();
 
  public boolean isShowInNavigators() {
    return showInNavigators;
  }
 
  public void setShowInNavigators(boolean showInNavigators) {
    this.showInNavigators = showInNavigators;
  }
 
  public boolean isShowAlways() {
    return showAlways;
  }
 
  public void setShowAlways(boolean showAlways) {
    this.showAlways = showAlways;
  }
 
  public boolean isTraversalNavigation() {
    return traversalNavigation;
  }
 
  public void setTraversalNavigation(boolean traversalNavigation) {
    this.traversalNavigation = traversalNavigation;
  }
 
  public boolean isNoIndex() {
    return noIndex;
  }
 
  public void setNoIndex(boolean noIndex) {
    this.noIndex = noIndex;
  }
 
  public boolean isNoFollow() {
    return noFollow;
  }
 
  public void setNoFollow(boolean noFollow) {
    this.noFollow = noFollow;
  }
 
  public boolean isPrintContext() {
    return printContext;
  }
 
  public void setPrintContext(boolean printContext) {
    this.printContext = printContext;
  }
 
  public boolean isPrintVersion() {
    return printVersion;
  }
 
  public void setPrintVersion(boolean printVersion) {
    this.printVersion = printVersion;
  }
 
  public boolean isControlVersion() {
    return controlVersion;
  }
 
  public void setControlVersion(boolean controlVersion) {
    this.controlVersion = controlVersion;
  }
 
  public boolean isIcon() {
    return icon;
  }
 
  public void setIcon(boolean icon) {
    this.icon = icon;
  }
 
  public Set<String> getLangs() {
    return langs;
  }
 
  public void setLangs(Set<String> langs) {
    this.langs = langs;
  }
 
  public String getName() {
    if(!Strings.isBlank(i18nKey)) {
      return I_.get(i18nKey);
    }
    if(!getNames().isEmpty()) {
      return getNames().getOrDefault(
              "_" + I_.api().used().getLanguage(),
              getNames().values().iterator().next());
    }
    return null;
  }
  
  public Map<String, String> getNames() {
    return names;
  }
 
  public void setNames(Map<String, String> names) {
    this.names = names;
  }
 
  public String getI18nKey() {
    return i18nKey;
  }
 
  public void setI18nKey(String i18nKey) {
    this.i18nKey = i18nKey;
  }
 
  public String getOrder() {
    return order;
  }
 
  public void setOrder(String order) {
    this.order = order;
  }
 
  public String getRole() {
    return role;
  }
 
  public void setRole(String role) {
    this.role = role;
  }
 
  public String getRedirect() {
    return redirect;
  }
 
  public void setRedirect(String redirect) {
    this.redirect = redirect;
  }
 
  public String getTarget() {
    return target;
  }
 
  public void setTarget(String target) {
    this.target = target;
  }
 
  public String getImage() {
    return image;
  }
 
  public void setImage(String image) {
    this.image = image;
  }
 
  public String getWebTag() {
    return webTag;
  }
 
  public void setWebTag(String webTag) {
    this.webTag = webTag;
  }
 
  public WebLayout getLayout() {
    return layout;
  }
 
  public void setLayout(WebLayout layout) {
    this.layout = layout;
  }
 
  /* Element */
  
  public WebElement getElement() {
    return element;
  }
 
  public void setElement(WebElement element) {
    this.element = element;
  }
  
  public IElement getElementInstance() {
    return getElement().getInstance(this);
  }
  
  /* Page */
 
  public WebPage getPage() {
    return page;
  }
 
  public void setPage(WebPage page) {
    this.page = page;
  }
    
  /* Utils */
  
  public String getLangsStr() {
    return Strings.listToCvs(getLangs());
  }
  
  public void setLangsStr(String langs) {
    this.langs.clear();
    this.langs.addAll(Strings.csvToList(langs));
  }
  
  public boolean isWikiPage() {
    return Strings.isBlank(redirect) && getElement().isEmpty();
  }
  
  private void prepareSaving() {
    getLangs().removeIf(l -> Strings.isBlank(l));
    getNames().entrySet().removeIf(entry -> 
            (Strings.isBlank(entry.getValue()) || Strings.isBlank(entry.getKey())));
    getElement().getAttributes().entrySet().removeIf(entry -> 
            (Strings.isBlank(entry.getValue()) || Strings.isBlank(entry.getKey())));
  }
 
  /* Dynamics */
  
  private transient boolean dynamic;
 
  public boolean isDynamic() {
    return dynamic;
  }
 
  public void setDynamic(boolean dynamic) {
    this.dynamic = dynamic;
  }
  
  /* Factory */
 
  public static final String
          CONTEXT_FOLDER = "_internal",
          CONTEXT_REPOSITORY = "repository",
          CONTEXT_FILE = "context.el";
  
  public static WebContext inheritFrom(WebContext webContext) {
    WebContext wc = new WebContext();
    wc.setShowInNavigators(webContext.isShowInNavigators());
    wc.setPrintContext(webContext.isPrintContext());
    wc.setRole(webContext.getRole());
    wc.setOrder("000");
    wc.setNoIndex(webContext.isNoIndex());
    wc.setNoFollow(webContext.isNoFollow());
    wc.setPrintVersion(webContext.isPrintVersion());
    wc.setControlVersion(webContext.isControlVersion());
    wc.setTraversalNavigation(webContext.isTraversalNavigation());
    return wc;
  }
  
  public static String relativeRepository() {
    return Path.of("/", CONTEXT_FOLDER, CONTEXT_REPOSITORY).toString();
  }
 
  public static Path repository(Path path) {
    return Path.of(path.toString(), relativeRepository());
  }
 
  public static boolean existsConf(Path path) {
    Path real = Path.of(ElephantContext.getRealPath(path.toString()), 
            CONTEXT_FOLDER, CONTEXT_FILE);
    return real.toFile().exists();
  }
  
  public static boolean removeFrom(Path path) {
    Path real = Path.of(ElephantContext.getRealPath(path.toString()), 
            CONTEXT_FOLDER, CONTEXT_FILE);
    return real.toFile().delete();
  }
  
  public static WebContext loadFrom(Path path) {
    Path real = Path.of(ElephantContext.getRealPath(path.toString()), 
            CONTEXT_FOLDER, CONTEXT_FILE);
    try(Reader reader = new FileReader(real.toFile())) {
      return JsonConfiguration.read(reader, WebContext.class);
    } catch (IOException ex) {
      Logger.getLogger(WebContext.class.getName()).log(Level.SEVERE, null, ex);
      return null;
    }
  }
  
  public static void saveTo(Path path, WebContext context) {
    Path real = Path.of(ElephantContext.getRealPath(path.toString()), 
            CONTEXT_FOLDER, CONTEXT_FILE);
    try(Writer writer = new FileWriter(real.toFile())) {
      context.prepareSaving();
      JsonConfiguration.write(writer, context);
    } catch (IOException ex) {
      Logger.getLogger(WebContext.class.getName()).log(Level.SEVERE, null, ex);
    }
  }
  
  public static boolean createFolders(Path relativePath) {
    File folder = Path.of(ElephantContext.getRealPath("/"), relativePath.toString()).toFile();
    if(!folder.exists()) {
      folder.mkdir();
      folder.toPath().resolve(CONTEXT_FOLDER).resolve(CONTEXT_REPOSITORY).toFile().mkdirs();
      return true;
    } else {
      return false;
    }
  }
 
}