ProjectGrantFilter.java

Go to the documentation of this file.

/*
 * Turró i Cutiller Foundation. License notice.
 * Copyright (C) 2024 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.alliance.client;
 
import java.time.Instant;
import java.util.Date;
import java.util.List;
import java.util.Set;
import java.util.TreeSet;
import org.turro.alliance.db.entities.AxProjectGrant;
import org.turro.string.Strings;
import org.turro.time.Time;
import org.zkoss.bind.BindUtils;
import org.zkoss.zul.Checkbox;
 
public class ProjectGrantFilter {
 
  private transient ProjectGrantVM vm;
  
  private String search, template;
  
  private final Set<String> sources = new TreeSet<>();
  private final Set<String> tags = new TreeSet<>();
  
  private Boolean minimis, 
          subvention, loan, inKind,
          collaboration,
          micro, small, medium, big, otherOrgs,
          hiring, idi, investment, startUp, formation,
          active, endOfBudget, recurrent;
 
  public ProjectGrantFilter(ProjectGrantVM vm) {
    this.vm = vm;
  }
 
  public void setVm(ProjectGrantVM vm) {
    this.vm = vm;
  }
 
  public String getTemplate() {
    return Strings.isBlank(template, "items");
  }
 
  public void setTemplate(String template) {
    this.template = template;
    BindUtils.postNotifyChange(vm, "grants");
  }
 
  public String getSearch() {
    return search;
  }
 
  public void setSearch(String search) {
    this.search = search;
    BindUtils.postNotifyChange(vm, "grants");
  }
 
  public Checkbox.State getMinimis() {
    return getTristate(minimis);
  }
 
  public void setMinimis(Checkbox.State minimis) {
    this.minimis = setTristate(minimis);
    BindUtils.postNotifyChange(vm, "grants");
  }
 
  public Checkbox.State getSubvention() {
    return getTristate(subvention);
  }
 
  public void setSubvention(Checkbox.State subvention) {
    this.subvention = setTristate(subvention);
    BindUtils.postNotifyChange(vm, "grants");
  }
 
  public Checkbox.State getLoan() {
    return getTristate(loan);
  }
 
  public void setLoan(Checkbox.State loan) {
    this.loan = setTristate(loan);
    BindUtils.postNotifyChange(vm, "grants");
  }
 
  public Checkbox.State getInKind() {
    return getTristate(inKind);
  }
 
  public void setInKind(Checkbox.State inKind) {
    this.inKind = setTristate(inKind);
    BindUtils.postNotifyChange(vm, "grants");
  }
 
  public Checkbox.State getCollaboration() {
    return getTristate(collaboration);
  }
 
  public void setCollaboration(Checkbox.State collaboration) {
    this.collaboration = setTristate(collaboration);
    BindUtils.postNotifyChange(vm, "grants");
  }
 
  public Checkbox.State getMicro() {
    return getTristate(micro);
  }
 
  public void setMicro(Checkbox.State micro) {
    this.micro = setTristate(micro);
    BindUtils.postNotifyChange(vm, "grants");
  }
 
  public Checkbox.State getSmall() {
    return getTristate(small);
  }
 
  public void setSmall(Checkbox.State small) {
    this.small = setTristate(small);
    BindUtils.postNotifyChange(vm, "grants");
  }
 
  public Checkbox.State getMedium() {
    return getTristate(medium);
  }
 
  public void setMedium(Checkbox.State medium) {
    this.medium = setTristate(medium);
    BindUtils.postNotifyChange(vm, "grants");
  }
 
  public Checkbox.State getBig() {
    return getTristate(big);
  }
 
  public void setBig(Checkbox.State big) {
    this.big = setTristate(big);
    BindUtils.postNotifyChange(vm, "grants");
  }
 
  public Checkbox.State getOtherOrgs() {
    return getTristate(otherOrgs);
  }
 
  public void setOtherOrgs(Checkbox.State otherOrgs) {
    this.otherOrgs = setTristate(otherOrgs);
    BindUtils.postNotifyChange(vm, "grants");
  }
 
  public Checkbox.State getHiring() {
    return getTristate(hiring);
  }
 
  public void setHiring(Checkbox.State hiring) {
    this.hiring = setTristate(hiring);
    BindUtils.postNotifyChange(vm, "grants");
  }
 
  public Checkbox.State getIdi() {
    return getTristate(idi);
  }
 
  public void setIdi(Checkbox.State idi) {
    this.idi = setTristate(idi);
    BindUtils.postNotifyChange(vm, "grants");
  }
 
  public Checkbox.State getInvestment() {
    return getTristate(investment);
  }
 
  public void setInvestment(Checkbox.State investment) {
    this.investment = setTristate(investment);
    BindUtils.postNotifyChange(vm, "grants");
  }
 
  public Checkbox.State getStartUp() {
    return getTristate(startUp);
  }
 
  public void setStartUp(Checkbox.State startUp) {
    this.startUp = setTristate(startUp);
    BindUtils.postNotifyChange(vm, "grants");
  }
 
  public Checkbox.State getFormation() {
    return getTristate(formation);
  }
 
  public void setFormation(Checkbox.State formation) {
    this.formation = setTristate(formation);
    BindUtils.postNotifyChange(vm, "grants");
  }
 
  public Checkbox.State getActive() {
    return getTristate(active);
  }
 
  public void setActive(Checkbox.State active) {
    this.active = setTristate(active);
    BindUtils.postNotifyChange(vm, "grants");
  }
 
  public Checkbox.State getEndOfBudget() {
    return getTristate(endOfBudget);
  }
 
  public void setEndOfBudget(Checkbox.State endOfBudget) {
    this.endOfBudget = setTristate(endOfBudget);
    BindUtils.postNotifyChange(vm, "grants");
  }
 
  public Checkbox.State getRecurrent() {
    return getTristate(recurrent);
  }
 
  public void setRecurrent(Checkbox.State recurrent) {
    this.recurrent = setTristate(recurrent);
    BindUtils.postNotifyChange(vm, "grants");
  }
 
  public Set<String> getSources() {
    return sources;
  }
  
  public void addSource(String value) {
    sources.add(value);
  }
  
  public void removeSource(String value) {
    sources.remove(value);
  }
  
  public boolean containsSource(String value) {
    return sources.contains(value);
  }
  
  public void clearSources() {
    sources.clear();
  }
  
  public Set<String> getTags() {
    return tags;
  }
  
  public void addTag(String value) {
    tags.add(value);
  }
  
  public void removeTag(String value) {
    tags.remove(value);
  }
  
  public boolean containsTag(String value) {
    return tags.contains(value);
  }
  
  public void clearTags() {
    tags.clear();
  }
  
  public void clear() {
    search = null;
    minimis = null;
    subvention = null;
    loan = null;
    inKind = null;
    collaboration = null;
    micro = null;
    small = null;
    medium = null;
    big = null;
    otherOrgs = null;
    hiring = null;
    idi = null;
    investment = null;
    startUp = null;
    formation = null;
    endOfBudget = null;
    recurrent = null;
    active = null;
    clearSources();
    clearTags();
  }
  
  public List<AxProjectGrant> process(List<AxProjectGrant> grants, List<TagItem> itags) {
    return grants.stream()
            .filter(g -> fits(g, itags))
            .toList();
  }
 
  private boolean fits(AxProjectGrant projectGrant, List<TagItem> itags) {
    return (Strings.isBlank(search) || Strings.findsIgnoreCase(projectGrant.getTitle(), search)) &&
           (minimis == null || (minimis.equals(projectGrant.isMinimis()))) &&
           (subvention == null || subvention.equals(projectGrant.isSubvention())) &&
           (loan == null || loan.equals(projectGrant.isLoan())) &&
           (inKind == null || inKind.equals(projectGrant.isInKind())) &&
           (collaboration == null || collaboration.equals(projectGrant.isCollaboration())) &&
           (micro == null || micro.equals(projectGrant.isMicro())) &&
           (small == null || small.equals(projectGrant.isSmall())) &&
           (medium == null || medium.equals(projectGrant.isMedium())) &&
           (big == null || big.equals(projectGrant.isBig())) &&
           (otherOrgs == null || otherOrgs.equals(projectGrant.isOtherOrgs())) &&
           (hiring == null || hiring.equals(projectGrant.isHiring())) &&
           (idi == null || idi.equals(projectGrant.isIdi())) &&
           (investment == null || investment.equals(projectGrant.isInvestment())) &&
           (startUp == null || startUp.equals(projectGrant.isStartUp())) &&
           (formation == null || formation.equals(projectGrant.isFormation())) &&
           (endOfBudget == null || endOfBudget.equals(projectGrant.isEndOfBudget())) &&
           (recurrent == null || recurrent.equals(projectGrant.isRecurrent())) &&
           (active == null || active.equals(isActive(projectGrant.getEndDate()))) &&
           (sources.isEmpty() || sources.contains(projectGrant.getSource())) &&
           (tags.isEmpty() || itags.stream()
                   .filter(t -> t.id().equals(projectGrant.getId()))
                   .anyMatch(t -> tags.contains(t.tag())));
            
  }
  
  private boolean isActive(Date value) {
    return value == null || Time.from(value).isAfter(Instant.now());    
  }
 
  private Checkbox.State getTristate(Boolean value) {
    return value == null ? Checkbox.State.INDETERMINATE :
           (value ? Checkbox.State.CHECKED : Checkbox.State.UNCHECKED);
  }
 
  private Boolean setTristate(Checkbox.State value) {
    return switch(value) {
      case CHECKED -> true;
      case UNCHECKED -> false;
      default -> null;
    };
  }
 
  public record TagItem(String tag, String id) {};
  
}