FunnelVertices.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.web.funnel.model;
 
import java.util.Collections;
import java.util.ListIterator;
import java.util.Set;
import java.util.TreeSet;
import java.util.stream.Collectors;
import org.turro.elephant.context.IConstructor;
import org.turro.elephant.entities.web.WebGoal;
import org.turro.elephant.entities.web.WebItemType;
import org.turro.elephant.web.actions.WebLink;
import org.turro.elephant.web.tags.SessionTags;
import org.turro.graph.GraphUtil;
import org.turro.web.funnel.SessionGoals;
import org.turro.web.funnel.graph.FunnelGraph;
import org.turro.web.funnel.graph.FunnelVertex;
 
public class FunnelVertices {
 
  public FunnelVertex current() {
    return graph.getVertex(sessionTags.current());
  }
  
  public FunnelVertex previous() {
    return graph.getVertex(sessionTags.previous());
  }
  
  public Set<FunnelVertex> targets() {
    if(useTags) {
      return current().getTargets();
    } else {
      return graph.getTargets();
    }
  }
  
  public FunnelVertex currentTarget() {
    return currentOf(WebItemType.TARGET);
  }
  
  public Set<FunnelVertex> solutions() {
    if(useTags) {
      return current().getSolutions();
    } else {
      return graph.getSolutions();
    }
  }
  
  public FunnelVertex currentSolution() {
    return currentOf(WebItemType.SOLUTION);
  }
  
  public Set<FunnelVertex> services() {
    if(useTags) {
      return current().getServices();
    } else {
      return graph.getServices();
    }
  }
  
  public FunnelVertex currentService() {
    return currentOf(WebItemType.SERVICE);
  }
  
  public Set<FunnelVertex> nexts() {
    FunnelVertex vertex = current();
    if(vertex != null) {
      return current().getNexts();
    }
    return null;
  }
  
  public Set<WebGoal> goals() {
    FunnelVertex vertex = current();
    if(vertex != null) {
      return current().getItem().getGoals();
    }
    return null;
  }
    
  public Set<WebLink> externals() {
    FunnelVertex vertex = current();
    if(vertex != null) {
      return current().getItem().getExternalLinks();
    }
    return null;
  }
    
  public FunnelVertex getVertex(String webTag) {
    return graph.getVertex(webTag);
  }
          
  public WebGoal getGoal(String goalAction) {
    return graph.getGoal(goalAction);
  }
  
  public Set<FunnelVertex> siblings() {
    final FunnelVertex vertex = current();
    return switch(vertex.getActingType()) {
      case TARGET -> targets().stream()
              .filter(v -> !v.equals(vertex))
              .collect(Collectors.toCollection(TreeSet::new));
      case SOLUTION -> currentTarget().getSolutions().stream()
              .filter(v -> !v.equals(vertex))
              .collect(Collectors.toCollection(TreeSet::new));
      case SERVICE -> currentSolution().getServices().stream()
              .filter(v -> !v.equals(vertex))
              .collect(Collectors.toCollection(TreeSet::new));
      default -> Collections.EMPTY_SET;
    };
  }
          
  /* Behaviour */
  
  public FunnelVertices bySelection(boolean value) {
    useTags = value;
    return this;
  }
  
  /* Utils */
  
  private FunnelVertex currentOf(WebItemType type) {
    ListIterator<String> iterator = sessionTags.tags().listIterator(sessionTags.tags().size() - 1);
    while(iterator.hasPrevious()) {
      String webTag = iterator.previous();
      FunnelVertex vertex = graph.getVertex(webTag);
      if(vertex != null && type.equals(vertex.getItem().getType())) return vertex;
    }
    return null;
  }
  
  /* Factory */
  
  public static FunnelVertices load(IConstructor constructor) {
    return new FunnelVertices(constructor);
  }
 
  private final SessionTags sessionTags;
  private final SessionGoals sessionGoals;
  private final FunnelGraph graph;
  
  private boolean useTags;
  
  private FunnelVertices(IConstructor constructor) {
    sessionTags = SessionTags.get(constructor);
    sessionGoals = SessionGoals.get(constructor);
    graph = FunnelGraph.load();
    if(!sessionGoals.goals().isEmpty()) {
      GraphUtil.removeIfNoneOfSelfOrSuccessors(graph, v -> !Collections.disjoint(sessionGoals.goals(), v.getGoalActions()));
    }
  }
  
}