DefaultElephantEntity.java

Go to the documentation of this file.

/*
 * Turró i Cutiller Foundation. License notice.
 * Copyright (C) 2017 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.entities;
 
import java.util.Collection;
import java.util.Collections;
import java.util.HashMap;
import java.util.Objects;
import org.turro.string.Strings;
import org.turro.action.IElephantSendable;
import org.turro.action.IEntityCtrl;
import org.turro.action.Interceptors;
import org.turro.action.LinkType;
import org.turro.action.Plugins;
import org.turro.actor.Actors;
import org.turro.auth.Authentication;
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.direct.AbstractDirectContentCtrl;
import org.turro.elephant.security.IUser;
import org.turro.file.Folder;
import org.turro.jpa.Dao;
import org.turro.jpa.entity.EntityWebUrls;
import org.turro.marker.MarkerHelper;
import org.turro.participation.IParticipationCtrl;
import org.turro.participation.ParticipationReason;
import org.turro.path.Path;
import org.turro.plugin.contacts.IContact;
import org.turro.script.Script;
import org.turro.script.Scripting;
import org.turro.security.ConceptPermission;
 
public abstract class DefaultElephantEntity implements IElephantEntity {
 
  protected String entityPath;
  protected Path path;
  protected Object entity;
 
  public DefaultElephantEntity() {
  }
 
  public DefaultElephantEntity(String entityPath) {
    this.entityPath = entityPath;
    this.path = new Path(entityPath);
  }
 
  public DefaultElephantEntity(Object entity) {
    this.entity = entity;
  }
  
  @Override
  public IElephantEntity getController(String entityPath) {
    String root = new Path(entityPath).getRoot();
    if(itsMine(root)) {
      return createInstance(entityPath);
    }
    return null;
  }
 
  @Override
  public IElephantEntity getController(Object entity) {
    if(itsMine(entity)) {
      return createInstance(entity);
    }
    return null;
  }
 
  @Override
  public boolean isEmpty() {
    return getEntity() == null;
  }
 
  @Override
  public String getStringId() {
    getPath();
    return path != null && (path.getSize() > 1) ? path.getNode(1) : EMPTY_ID;
  }
 
  @Override
  public String getNameOrLabel() {
    return Strings.isBlank(getName(), getLabel());
  }
  
  @Override
  public String getRoot() {
    getPath();
    return path != null ? path.getRoot(): null;
  }
 
  @Override
  public String getPath() {
    if(path == null) {
      path = createPath();
    }
    return path != null ? path.getPath() : null;
  }
 
  @Override
  public String getTreeLabel() {
    if(path != null && path.isRoot()) {
      return getLabel();
    } else if(path.getSize() == 2) {
      return getName();
    }
    return null;
  }
 
  @Override
  public Collection getEntitites(String search, int maxResults) {
    return getEntitites(search, maxResults, new KeyValueMap(new HashMap()));
  }
  
  @Override
  public Collection getEntitites(String root, String search, int maxResults) {
    return getEntitites(root, search, maxResults, new KeyValueMap(new HashMap()));
  }
  
  @Override
  public IElephantSendable getSendable() {
    return null;
  }
 
  @Override
  public Collection<Object> getRelatedByRole(EntityRole role, IContact contact) {
    return Collections.EMPTY_LIST;
  }
 
  @Override
  public boolean hasRelatedRole(EntityRole role, IContact contact) {
    return false;
  }
 
  @Override
  public String getLinkRoot() {
    getPath();
    return path != null ? path.getRoot() : null;
  }
 
  @Override
  public String getEntityUrl() {
    return getEntityUrl(LinkType.WEB, null);
  }
  
  @Override
  public String getMemberUrl() {
    return getEntityUrl(LinkType.WEB_INTERNAL, null);
  }
  
  @Override
  public String getAppUrl() {
    IUser user = Application.getUser();
    if(user instanceof IContact) {
      IContact contact = (IContact) user;
      if(contact.isWebapp()) {
        getPath();
        return "/app/frame?" + Interceptors.parameters(getLinkRoot(), path.getNode(1)).encoded();
      } else {
        return getEntityUrl(LinkType.WEB_INTERNAL, null);
      }
    }
    return null;
  }
 
  @Override
  public String getEntityUrl(LinkType type, String contextPath) {
    if(LinkType.INTERNAL.equals(type)) {
      return getAppUrl();
    } else {
      String ewu = EntityWebUrls.getUrlFromEntity(getEntity());
      if(ewu != null) {
        return getReadAllUrl(type, contextPath) + ewu;
      } else {
        return getReadAllUrl(type, contextPath) + "?" + MarkerHelper.setObfuscatedPars("item=" + getStringId());
      }
    }
  }
  
  @Override
  public String getReadAllUrl(LinkType type, String contextPath) {
    if(LinkType.WEB.equals(type)) {
      if(Strings.isBlank(contextPath)) {
        contextPath = ElephantContext.getEntityWebContext("/" + getLinkRoot());
      }
      if(Strings.isBlank(contextPath)) {
        contextPath = getUserContext();
      }
    } else if(LinkType.WEB_INTERNAL.equals(type)) {
      if(Strings.isBlank(contextPath)) {
        contextPath = getUserContext();
      }
      if(Strings.isBlank(contextPath)) {
        contextPath = ElephantContext.getEntityWebContext("/" + getLinkRoot());
      }
    }
    return Strings.isBlank(contextPath, "/");
  }
 
  protected boolean itsMine(String rootPath) {
    return getAllowedRoots().contains(rootPath);
  }
  
  protected abstract Dao createDao();
  protected abstract boolean itsMine(Object entity);
  protected abstract IElephantEntity createInstance(String entityPath);
  protected abstract IElephantEntity createInstance(Object entity);
  protected abstract Path createPath();
  
  /* Helpers */
  
  protected boolean isValidLongEntity() {
    getPath();
    return path.getSize() == 2 && path.getNode(1).matches("[0-9]+");
  }
     
  /* Dao */
  
  private Dao _dao;
  
  protected Dao getDao() {
    if(_dao == null) {
      _dao = createDao();
    }
    return _dao;
  }
 
  /* Controls */
  
  @Override
  public Object getControl(String name, IContact contact) {
    Object control = Controls.getControl(name);
    return configureCtrl(control, contact);
  }
 
  @Override
  public Object getControl(String name, IConstructor constructor, IContact contact) {
    Object control = Controls.getControl(name, constructor);
    return configureCtrl(control, contact);
  }
 
  @Override
  public Object getControl(String name, String entityPath, IContact contact) {
    Object control = Controls.getControl(name, entityPath);
    return configureCtrl(control, contact);
  }
 
  /* Participation */
  
  @Override
  public Object getParticipationControl(IConstructor constructor, ParticipationReason reason) {
    return getParticipationControl(constructor, Authentication.getIContact(), reason);
  }
  
  @Override
  public Object getParticipationControl(IConstructor constructor, IContact contact, ParticipationReason reason) {
    IParticipationCtrl ctrl = Plugins.loadImplementation(IParticipationCtrl.class, "participation-ctrl");
    ctrl = (IParticipationCtrl) configureCtrl(ctrl, contact);
    ((IEntityCtrl) ctrl).setConstructor(constructor);
    ((IEntityCtrl) ctrl).setEntityPath(getPath());
    ctrl.setReason(reason);
    ((IEntityCtrl) ctrl).setTemplate(reason.toString().replaceAll("_", "-").toLowerCase());
    return ctrl;
  }
  
  @Override
  public String parseSpamCtrl(IConstructor constructor) {
    AbstractDirectContentCtrl ctrl = (AbstractDirectContentCtrl) getParticipationControl(constructor, ParticipationReason.REASON_SPAM);
    return ctrl != null ? ctrl.parse(constructor) : "";
  }
  
  @Override
  public String parseFollowCtrl(IConstructor constructor) {
    AbstractDirectContentCtrl ctrl = (AbstractDirectContentCtrl) getParticipationControl(constructor, ParticipationReason.REASON_FOLLOW);
    return ctrl != null ? ctrl.parse(constructor) : "";
  }
  
  /* Children helpers */
  
  @Override
  public EntitySet getAllChildren() {
    EntitySet set = new EntitySet();
    set.add(this);
    set.addAll(getChildren());
    for(IElephantEntity iee : getChildren()) {
      set.addAll(iee.getAllChildren());
    }
    return set;
  }
  
  /* Actors */
  
  @Override
  public Script getActorScript() {
    return Scripting.instance();
  }
 
  @Override
  public boolean isActor(String actor) {
    return Actors.isActorFor(this, actor);
  }
 
  @Override
  public boolean isActor(IContact contact, String actor) {
    return Actors.isActorFor(contact, this, actor);
  }
 
  @Override
  public ConceptPermission getConceptPermission(String name) {
    return null;
  }
 
  /* Deliverables */
 
  @Override
  public Folder getDeliverables() {
    return StandardFolder.internal()
            .real()
            .entityPath(getPath())
            .folder("deliverables")
            .asFolder();
  }  
  
  /* Simple Objects */
 
  @Override
  public Object getObject(Path entityPath) {
    return null;
  }
 
  @Override
  public IElephantEntity getMain(Object entity) {
    return null;
  }
    
  /* equals & hashCode */
  
  @Override
  public int hashCode() {
    int hash = 7;
    hash = 97 * hash + Objects.hashCode(this.path);
    return hash;
  }
 
  @Override
  public boolean equals(Object obj) {
    if (this == obj) {
      return true;
    }
    if (obj == null) {
      return false;
    }
    if (getClass() != obj.getClass()) {
      return false;
    }
    final DefaultElephantEntity other = (DefaultElephantEntity) obj;
    if (!Objects.equals(this.getPath(), other.getPath())) {
      return false;
    }
    return true;
  }
  
}