CollectionHtmlIterator.java

Go to the documentation of this file.

/*
 * Turró i Cutiller Foundation. License notice.
 * Copyright (C) 2018 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.collections;
 
import java.io.IOException;
import java.io.Writer;
import java.lang.reflect.ParameterizedType;
import java.util.Collection;
import java.util.HashMap;
import java.util.List;
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.elephant.context.ElephantContext;
import org.turro.elephant.context.IConstructor;
import org.turro.html.HTMLHelper;
import org.turro.marker.ElephantMarker;
import org.turro.marker.MarkerHelper;
 
public abstract class CollectionHtmlIterator<E, ID> extends CollectionIterator<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 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 CollectionHtmlIterator(List collection, ElephantMarker marker) {
    this(collection, marker, null);
  }
  
  public CollectionHtmlIterator(List collection, ElephantMarker marker, Writer writer) {
    super(collection);
    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 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 searhEngine) {
//    this.searchEngine = searhEngine;
//  }
 
  public boolean isSearchOption() {
    return searchOption;
  }
 
  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;
  }
 
  @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(CollectionHtmlIterator.class.getName()).log(Level.SEVERE, ElephantContext.logMsg(null), ex);
    }
    return null;
  }
  
  @Override
  public void load() {
    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() {
    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);
        CollectionNavigator navigator = new CollectionNavigator(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);
        renderItem(marker, entity, page);
        html.endAllTags();
      }
    } else {
      current(page);
      if(items == null) {
        return;
      }
      html = new HTMLHelper(constructor, writer);
      CollectionNavigator navigator = new CollectionNavigator(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);
        for(E e : items) {
          if(isValid(e)) {
            marker.put("divider", !isFirst());
            marker.put("header", isFirst());
            marker.put("footer", isLast());
            renderSummary(marker, e, current());
          }
          currentIndex++;
        }
      }
    }
  }
 
  public boolean isFirst() {
    return currentIndex == 0;
  }
  
  public boolean isLast() {
    return currentIndex == currentSize - 1;
  }
  
  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() : "";
  }
  
  @Override
  public boolean isEmpty() {
    return getTotalCount() < 1;
  }
  
  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 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"));
    //return constructor.isHeadless() ? null : (ID) ObjectString.parseString(constructor.getParameter("item"), idClass, false);
  }
  
  protected void onRenderItem(E e) {}
 
  protected boolean isValid(E e) {
    return e != null;
  }
  
  protected ID parseId(String value) {
    return (ID) ObjectString.parseString(value, idClass, false);
  }
  
  protected String stringId(ID value) {
    return String.valueOf(value);
  }
  
}