DaoHtmlIterator.java

Go to the documentation of this file.

/*
 * Turró i Cutiller Foundation. License notice.
 * Copyright (C) 2013 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.jpa.iterator;
 
import java.io.IOException;
import java.io.Writer;
import java.lang.reflect.ParameterizedType;
import java.util.Collection;
import java.util.HashMap;
import java.util.Map;
import java.util.logging.Level;
import java.util.logging.Logger;
import org.turro.string.ObjectString;
import org.turro.string.Strings;
import org.turro.action.content.IContentIterator;
import org.turro.assistant.ParticipationInfo;
import org.turro.collections.KeyValueMap;
import org.turro.elephant.context.ElephantContext;
import org.turro.elephant.context.IConstructor;
import org.turro.elephant.web.ElContext;
import org.turro.html.HTMLHelper;
import org.turro.jpa.Dao;
import org.turro.jpa.entity.EntityWebUrls;
import org.turro.jpa.search.DaoHtmlSearch;
import org.turro.marker.ElephantMarker;
import org.turro.marker.MarkerHelper;
import org.turro.participation.ParticipationReason;
import org.turro.path.Path;
import org.turro.skills.tags.SkillCloud;
import org.turro.tags.TagCloud;
import org.turro.tags.TagSet;
import org.turro.tags.Tags;
import org.turro.visual.EmptyVisualElements;
import org.turro.visual.VisualElements;
 
public abstract class DaoHtmlIterator<E, ID> extends DaoIterator<E, ID> implements IContentIterator {
 
  protected HTMLHelper html;
  protected IConstructor constructor;
  protected ElephantMarker marker;
  protected DaoHtmlSearch searchEngine;
  protected DaoHtmlTree navigationTree;
  
  private String summaryTemplate, fullTemplate;
  private boolean restricted;
  private boolean allowInterest, allowComments, allowVotes, allowForum,
          allowDescriptions, allowAttachments, allowFiles, allowPolls;
  private boolean allowRanking = true, allowMatching = true, allowSorting = true;
  private String rankingInstance, matchingInstance;
  private boolean doMatching;
  private boolean navigatorTop = true, navigatorBottom = true, 
          searchOption = true, forceSummary = false;
  private int page, currentIndex, currentSize;
  private ID item;
  private E entity;
  private final Class<ID> idClass; 
  private Writer writer;
  private final Map<String, Object> markerAttributes;
 
  
  public DaoHtmlIterator(Dao dao, ElephantMarker marker) {
    this(dao, marker, null);
  }
 
  public DaoHtmlIterator(Dao dao, ElephantMarker marker, Writer writer) {
    super(dao);
    this.marker = marker;
    this.constructor = marker.getConstructor();
    this.writer = writer;
    this.idClass = (Class<ID>) ((ParameterizedType) getClass()
            .getGenericSuperclass()).getActualTypeArguments()[1];
    markerAttributes = new HashMap<>();
  }
 
  public void setSummaryTemplate(String summaryTemplate) {
    this.summaryTemplate = summaryTemplate;
  }
 
  public String getSummaryTemplate() {
    return Strings.isBlank(summaryTemplate) ? "summary" : summaryTemplate;
  }
  
  public void setFullTemplate(String fullTemplate) {
    this.fullTemplate = fullTemplate;
  }
 
  public String getFullTemplate() {
    return Strings.isBlank(fullTemplate) ? "full" : fullTemplate;
  }
 
  public boolean isRestricted() {
    return restricted;
  }
 
  public void setRestricted(boolean restricted) {
    this.restricted = restricted;
  }
 
  public boolean isAllowInterest() {
    return allowInterest;
  }
 
  public void setAllowInterest(boolean allowInterest) {
    this.allowInterest = allowInterest;
  }
 
  public boolean isAllowComments() {
    return allowComments;
  }
 
  public void setAllowComments(boolean allowComments) {
    this.allowComments = allowComments;
  }
 
  public boolean isAllowVotes() {
    return allowVotes;
  }
 
  public void setAllowVotes(boolean allowVotes) {
    this.allowVotes = allowVotes;
  }
 
  public boolean isAllowForum() {
    return allowForum;
  }
 
  public void setAllowForum(boolean allowForum) {
    this.allowForum = allowForum;
  }
 
  public boolean isAllowDescriptions() {
    return allowDescriptions;
  }
 
  public void setAllowDescriptions(boolean allowDescriptions) {
    this.allowDescriptions = allowDescriptions;
  }
 
  public boolean isAllowAttachments() {
    return allowAttachments;
  }
 
  public void setAllowAttachments(boolean allowAttachments) {
    this.allowAttachments = allowAttachments;
  }
 
  public boolean isAllowFiles() {
    return allowFiles;
  }
 
  public void setAllowFiles(boolean allowFiles) {
    this.allowFiles = allowFiles;
  }
 
  public boolean isAllowPolls() {
    return allowPolls;
  }
 
  public void setAllowPolls(boolean allowPolls) {
    this.allowPolls = allowPolls;
  }
 
  public boolean isAllowRanking() {
    return allowRanking;
  }
 
  public void setAllowRanking(boolean allowRanking) {
    this.allowRanking = allowRanking;
  }
 
  public boolean isAllowMatching() {
    return allowMatching;
  }
 
  public void setAllowMatching(boolean allowMatching) {
    this.allowMatching = allowMatching;
  }
 
  public boolean isDoMatching() {
    return doMatching;
  }
 
  public void setDoMatching(boolean doMatching) {
    this.doMatching = doMatching;
  }
 
  public String getRankingInstance() {
    return rankingInstance;
  }
 
  public void setRankingInstance(String rankingInstance) {
    this.rankingInstance = rankingInstance;
  }
 
  public String getMatchingInstance() {
    return matchingInstance;
  }
 
  public void setMatchingInstance(String matchingInstance) {
    this.matchingInstance = matchingInstance;
  }
 
  public boolean isAllowSorting() {
    return allowSorting;
  }
 
  public void setAllowSorting(boolean allowSorting) {
    this.allowSorting = allowSorting;
  }
  
  public boolean isNavigatorTop() {
    return navigatorTop;
  }
 
  public void setNavigatorTop(boolean navigatorTop) {
    this.navigatorTop = navigatorTop;
  }
 
  public boolean isNavigatorBottom() {
    return navigatorBottom;
  }
 
  public void setNavigatorBottom(boolean navigatorBottom) {
    this.navigatorBottom = navigatorBottom;
  }
 
  public DaoHtmlTree getNavigationTree() {
    return navigationTree;
  }
 
  public void setNavigationTree(DaoHtmlTree navigationTree) {
    this.navigationTree = navigationTree;
  }
 
  public DaoHtmlSearch getSearchEngine() {
    return searchEngine;
  }
 
  public void setSearchEngine(DaoHtmlSearch searchEngine) {
    this.searchEngine = searchEngine;
    if(searchEngine != null) searchEngine.setIterator(this);
  }
 
  public boolean isSearchOption() {
    return searchOption && !constructor.isHeadless();
  }
 
  public void setSearchOption(boolean searchOption) {
    this.searchOption = searchOption;
  }
 
  public boolean isForceSummary() {
    return forceSummary;
  }
 
  public void setForceSummary(boolean forceSummary) {
    this.forceSummary = forceSummary;
  }
 
  public boolean wantItem() {
    return getIdentifier() != null;
  }
  
  public boolean isItem() {
    return entity != null;
  }
  
  public boolean checkEntity(ID value) {
    return entity(value) != null;
  }
 
  @Override
  public Object addAttribute(String key, Object value) {
    return markerAttributes.put(key, value);
  }
  
  @Override
  public Writer getWriter() {
    try {
      return writer != null ? writer : constructor.getOut();
    } catch (IOException ex) {
      Logger.getLogger(DaoHtmlIterator.class.getName()).log(Level.SEVERE, ElephantContext.logMsg(null), ex);
    }
    return null;
  }
  
  @Override
  public void load() {
    if(PRELOAD_TMPL.equals(summaryTemplate)) {
      preload();
    } else {
      if(!constructor.isHeadless()) {
        TagCloud.toggleTags(constructor, entityRoot());
        SkillCloud.toggleSkills(constructor, entityRoot(), true);
        SkillCloud.toggleSkills(constructor, entityRoot(), false);
      }
      item = getIdentifier();
      if(item != null) {
        entity = entity(item);
      }
    }
  }
  
  public void forceItem(ID item) {
    this.item = item;
    if(item != null) {
      entity = entity(item);
    }
  }
  
  public String getTitle() {
    return entity != null ? title(entity) : null;
  }
  
  public Collection<String> getMetas() {
    return entity != null ? metas(entity) : null;
  }
  
  @Override
  public void render() {
    if(PRELOAD_TMPL.equals(summaryTemplate)) return;
    initClauses();
    marker.putAll(markerAttributes);
    marker.put("iterator", this);
    marker.put("navigatorTop", navigatorTop);
    marker.put("navigatorBottom", navigatorBottom);
    marker.put("searchOption", searchOption);
    page = constructor.isHeadless() ? 0 : (Integer) ObjectString.parseString(constructor.getParameter("page"), Integer.class, true);
    if(entity != null) {
      if(isValid(entity)) {
        html = new HTMLHelper(constructor, writer);
        DaoNavigator navigator = new DaoNavigator(this);
        marker.put("navigator", navigator);
        marker.put("empty", false);
        marker.put("divider", false);
        marker.put("header", true);
        marker.put("footer", true);
        marker.put("single", true);
        if(canShow(entity)) {
          renderItem(marker, entity, page);
        } else {
          renderForbidden(marker, page);
        }
        html.endAllTags();
        markAsSeen(entity);
      }
    } else {
      current(page);
      if(items == null) {
        return;
      }
      html = new HTMLHelper(constructor, writer);
      DaoNavigator navigator = new DaoNavigator(this);
      marker.put("navigator", navigator);
      currentIndex = 0; 
      currentSize = items.size();
      if(currentSize == 0) {
        marker.put("empty", true);
        marker.put("divider", false);
        marker.put("header", true);
        marker.put("footer", true);
        marker.put("single", false);
        renderSummary(marker, null, current());
      } else {
        marker.put("empty", false);
        marker.put("single", false);
        int countValids = 0;
        for(E e : items) {
          if(isValid(e)) {
            countValids++;
            marker.put("divider", !isFirst());
            marker.put("header", isFirst());
            marker.put("footer", isLast());
            renderSummary(marker, e, page);
          }
          currentIndex++;
        }
        if(countValids == 0) {
          marker.put("empty", true);
          marker.put("divider", false);
          marker.put("header", true);
          marker.put("footer", true);
          marker.put("single", false);
          renderSummary(marker, null, current());
        }
      }
    }
  }
 
  public boolean isFirst() {
    return currentIndex == 0;
  }
  
  public boolean isLast() {
    return currentIndex == currentSize - 1;
  }
  
  /* Engines */
  
  public String renderSearchEngine() {
    return searchEngine != null ? searchEngine.render(constructor) : "";
  }
  
  public String renderTree() {
    return navigationTree != null ? navigationTree.parse() : "";
  }
  
  public String renderTreeSelection() {
    return navigationTree != null ? navigationTree.parseSelected() : "";
  }
  
  public TagSet getCloudTags() {
    return TagCloud.getTags(constructor, entityRoot());
  }
  
  public TagSet getEntityTags(Object entity) {
    return Tags.getTags(entity);
  }
  
  public boolean isSeen(Object entity) {
    return new ParticipationInfo(entity, ParticipationReason.REASON_SEEN).isChecked();
  }
  
  /* End engines */
 
  /* Visuals */
 
  public VisualElements getVisuals() {
    if(_visuals == null) {
      _visuals = loadVisuals();
    }
    return _visuals;
  }
  
  private VisualElements _visuals;
  
  protected VisualElements loadVisuals() {
    return new EmptyVisualElements();
  }
  
  /* End visuals */
  
  @Override
  public boolean isEmpty() {
    return getTotalCount() < 1;
  }
  
  protected abstract String entityRoot();
  protected abstract E entity(ID value);
  protected abstract void renderSummary(ElephantMarker marker, E e, int page);
  protected abstract void renderItem(ElephantMarker marker, E e, int page);
  protected abstract String title(E e);
  protected abstract Collection<String> metas(E e);
  
  protected void renderForbidden(ElephantMarker marker, int page) {
  }
          
  protected ID getIDFromURL(String root) {
    if(constructor != null && !constructor.isHeadless()) {
      String url = ElContext.extractPath(constructor.getRequest().getServletPath()),
             contextPath = constructor.getCurrentContext().getPath();
      if(!EntityWebUrls.sameURL(url, contextPath)) {
        String entityPath = EntityWebUrls.getEntityPath(root, url.substring(contextPath.length()));
        if(!Strings.isBlank(entityPath)) {
          Path path = new Path(entityPath);
          if(path.getSize() == 2) {
            return parseId(path.getNode(1));
          }
        }
      }
    }
    return null;
  }
  
  protected ID getIdentifier() {
    if(constructor.isHeadless() || forceSummary) {
      return null;
    }
    KeyValueMap kvm = MarkerHelper.getObfuscatedParameters();
    if(kvm != null && !kvm.isEmpty() && kvm.containsKey("item")) {
      return parseId(kvm.get("item"));
    }
    return parseId(constructor.getParameter("item"));
  }
  
  protected void preload() {}
  //protected void onRenderItem(E e) {}
 
  protected boolean isValid(E e) {
    return e != null;
  }
 
  protected boolean canShow(E e) {
    return true;
  }
 
  protected ID parseId(String value) {
    return (ID) ObjectString.parseString(value, idClass, false);
  }
  
  protected String stringId(ID value) {
    return String.valueOf(value);
  }
  
  /* Seen */
  
  private void markAsSeen(E entity) {
    new ParticipationInfo(entity, ParticipationReason.REASON_SEEN).check();
  }
 
}