AgreementsUtil.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.agreements;
 
import java.util.ArrayList;
import java.util.Collection;
import java.util.Date;
import java.util.List;
import java.util.stream.Collectors;
import org.turro.string.Strings;
import org.turro.action.Contacts;
import org.turro.elephant.db.ElephantPU;
import org.turro.elephant.db.WhereClause;
import org.turro.elephant.entities.db.Agreement;
import org.turro.elephant.entities.db.AgreementSignature;
import org.turro.jpa.Dao;
import org.turro.plugin.contacts.IContact;
 
public class AgreementsUtil {
 
  public static List<Agreement> getAgreements() {
    WhereClause wc = new WhereClause();
    wc.addClause("select a from Agreement a");
    return new ElephantPU().getResultList(wc);
  }
  
  public static boolean deleteAgreement(Agreement agreement) {
    if(agreement != null && agreement.getSignatures().isEmpty()) {
      new ElephantPU().deleteObject(agreement);
      return true;
    }
    return false;
  }
 
  public static List<AgreementSignature> notSigned(IContact contact) {
    return new AgreementsUtil(contact).getNotSigned();
  } 
  
  private final IContact contact;
  
  private List<AgreementSignature> signatures;
 
  public AgreementsUtil(IContact contact) {
    this.contact = contact;
  }
 
  public AgreementsUtil(String idContact) {
    this.contact = Contacts.getContactById(idContact);
  }
 
  public IContact getContact() {
    return contact;
  }
 
  public boolean isValid() {
    return Contacts.isValid(contact); 
  }
  
  public boolean canNotify() {
    return getSignatures(null).stream().noneMatch((as) -> (as.getAgreement().isRequiredToNotify() && !as.doesAgree()));
  }
 
  public boolean canAccess() {
    return getSignatures(null).stream().noneMatch((as) -> (as.getAgreement().isRequiredToAccess() && !as.doesAgree()));
  }
 
  public boolean canAct(String action) {
    return getSignatures(action).stream().noneMatch((as) -> (as.getAgreement().isRequiredToAction() && action.equals(as.getAgreement().getAction()) && !as.doesAgree()));
  }
 
  public boolean declinedNotifications() {
    return getSignatures(null).stream().anyMatch((as) -> (as.getAgreement().isRequiredToNotify() && as.isSigned() && !as.isAgreed()));
  }
 
  public boolean declinedAccessing() {
    return getSignatures(null).stream().anyMatch((as) -> (as.getAgreement().isRequiredToAccess() && as.isSigned() && !as.isAgreed()));
  }
 
  public boolean declinedActing(String action) {
    return getSignatures(action).stream().anyMatch((as) -> (as.getAgreement().isRequiredToAction() && action.equals(as.getAgreement().getAction()) && as.isSigned() && !as.isAgreed()));
  }
 
  public List<AgreementSignature> getPeremptories() {
    return getSignatures(null).stream().filter((s) -> s.getAgreement().isPeremptory()).collect(Collectors.toList());
  }
  
  public List<AgreementSignature> getSignatures(String action) {
    if(signatures == null) {
      signatures = new ArrayList<>();
      if(Contacts.isValid(contact)) {
        signatures.addAll(getAgreementSignatures());
        notCreated(action).stream().map((a) -> {
          AgreementSignature as = new AgreementSignature();
          as.setIdContact(contact.getId());
          as.setAgreement(a);
          as.setAgreed(false);
          as.setSentCount(0);
          as.setSignedDate(null);
          return getDao().saveObject(as);
        }).forEachOrdered((as) -> {
          signatures.add(as);
        });
      }
    }
    return signatures;
  }
 
  public List<AgreementSignature> getNotSigned() {
    return getSignatures(null).stream().filter((s) -> !s.isSigned()).collect(Collectors.toList());
  }
  
  public List<AgreementSignature> getSigned() {
    return getSignatures(null).stream().filter((s) -> s.isSigned()).collect(Collectors.toList());
  }
  
  public void sign(Agreement agreement, boolean agreed) {
    if(agreement != null) {
      WhereClause wc = new WhereClause();
      wc.addClause("select asig from AgreementSignature asig");
      wc.addClause("where asig.agreement = :agreement");
      wc.addNamedValue("agreement", agreement);
      wc.addClause("and asig.idContact = :contact");
      wc.addNamedValue("contact", contact.getId());
      AgreementSignature as = (AgreementSignature) getDao().getSingleResultOrNull(wc);
      if(as == null) {
        as = new AgreementSignature();
        as.setIdContact(contact.getId());
        as.setAgreement(agreement);
        as.setSentCount(0);
      }
      if(!as.doesAgree()) {
        as.setAgreed(agreed);
        as.setSignedDate(new Date());
        getDao().saveObject(as);
      }
    }
  }
  
  public void sign(Long agreementId, boolean agreed) {
    sign(getDao().find(Agreement.class, agreementId), agreed);
  }
  
  public void markAsSent(AgreementSignature as) {
    if(as.getId() != null) {
      WhereClause wc = new WhereClause();
      wc.addClause("update AgreementSignature");
      wc.addClause("set sentCount = sentCount + 1");
      wc.addClause("where agreement = :agreement");
      wc.addNamedValue("agreement", as.getAgreement());
      wc.addClause("and idContact = :contact");
      wc.addNamedValue("contact", as.getIdContact());
      getDao().executeUpdate(wc);
    } else {
      as.setSentCount(1);
      getDao().saveObject(as);
    }
  }
 
  private List<Agreement> notCreated(String action) {
    WhereClause wc = new WhereClause();
    wc.addClause("select a from Agreement a");
    wc.addClause("where not exists (");
    wc.addClause("  select asig from AgreementSignature asig");
    wc.addClause("  where asig.agreement = a");
    wc.addClause("  and asig.idContact = :contact");
    wc.addNamedValue("contact", contact.getId());
    wc.addClause(")");
    // Only empty actions or requested action
    wc.addClause("and (a.action is null or trim(a.action) = '' or a.action = :action)");
    wc.addNamedValue("action", action);
    
    return (List<Agreement>) getDao().getResultList(wc).stream().filter((a) -> 
            fit((Agreement) a)).collect(Collectors.toList());
  }
  
  private boolean fit(Agreement agreement) {
    String appliesString = agreement.getAppliesTo();
    if(Strings.isBlank(appliesString) || "*".equals(appliesString)) {
      return true;
    }
    String[] applies = appliesString.split(",");
    for(String syndication : applies) {
      if(contact.getSyndications().contains(syndication)) {
        return true;
      }
    }
    return false;
  }
 
  private Collection<AgreementSignature> getAgreementSignatures() {
    WhereClause wc = new WhereClause();
    wc.addClause("select asig from AgreementSignature asig");
    wc.addClause("where asig.idContact = :contact");
    wc.addNamedValue("contact", contact.getId());
    return getDao().getResultList(wc);
  }
 
  /* Dao */
  
  private Dao _dao;
 
  private Dao getDao() {
    if (_dao == null) {
      _dao = new ElephantPU();
    }
    return _dao;
  }
 
}