Contract.java

Go to the documentation of this file.

/*
 * Turró i Cutiller Foundation. License notice.
 * Copyright (C) 2011 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.financials.entity;
 
import java.util.*;
import javax.persistence.*;
import org.turro.string.Strings;
import org.turro.action.Contacts;
import org.turro.elephant.calendar.Periodicity;
import org.turro.elephant.db.IdUtils;
import org.turro.elephant.db.WhereClause;
import org.turro.financials.db.FinancialsPU;
import org.turro.jpa.Dao;
import org.turro.jpa.entity.IDaoEntity;
import org.turro.plugin.contacts.ContactList;
import org.turro.plugin.contacts.IContact;
import org.turro.reflection.MappingSet;
import org.turro.util.PhraseBuilder;
 
@Entity
public class Contract implements java.io.Serializable, IDaoEntity {
  
  @Id
  @Column(name="IDENTIFIER")
  private long id;
 
  private String globalId;
 
  private String contractor;
 
  private String name;
 
  private boolean stock, cash, active, useContractorCode;
 
  private OperatingModifier operatingModifier = OperatingModifier.OPMOD_NORMAL;
 
  private String grouping;
  
  private double fee;
  
  private Periodicity periodicity = Periodicity.PUNCTUAL;
  
  @ManyToOne
  private Department department;
 
  @ManyToOne
  private Service service;
 
  @Column(name="START_DATE")
  @Temporal(value = TemporalType.TIMESTAMP)
  private Date startDate;
 
  @Column(name="END_DATE")
  @Temporal(value = TemporalType.TIMESTAMP)
  private Date endDate;
 
  @Lob
  @Column(length=4096)
  private String notes;
 
  private Currency currency;
  
  private boolean equivalenceSurcharge;
 
  @ManyToOne(fetch=FetchType.LAZY)
  private ContractDefinition contractDefinition;
 
  @OneToMany(fetch = FetchType.EAGER)
  private Set<ContractPreference> contractPreferences = new HashSet<ContractPreference>();
 
  @OneToMany(mappedBy = "contract", fetch = FetchType.LAZY, cascade = CascadeType.ALL, orphanRemoval=true)
  private Set<RelatedContractStore> relatedContractStores = new HashSet<RelatedContractStore>();
 
  @OneToMany(mappedBy = "contract", fetch = FetchType.EAGER, cascade = CascadeType.ALL, orphanRemoval=true)
  @OrderBy(value="name")
  private Set<ContractParticipant> participants = new HashSet<ContractParticipant>();
 
  @OneToMany(mappedBy = "contract", fetch = FetchType.EAGER, cascade = CascadeType.ALL, orphanRemoval=true)
  private Set<ContractFlow> contractFlows = new HashSet<ContractFlow>();
 
  @OneToMany(mappedBy = "contract", fetch = FetchType.EAGER, cascade = CascadeType.ALL, orphanRemoval=true)
  private Set<Tax> taxes = new HashSet<Tax>();
  
  @OneToMany(mappedBy = "contract", fetch = FetchType.EAGER, cascade = CascadeType.ALL, orphanRemoval=true)
  private Set<Contracted> contracted = new HashSet<Contracted>();
  
  @OneToOne(cascade = CascadeType.ALL)
  private ContractHandshake contractHandshake;
 
  public boolean isActive() {
    return active;
  }
 
  public void setActive(boolean active) {
    this.active = active;
  }
 
  public boolean isCash() {
    return cash;
  }
 
  public void setCash(boolean cash) {
    this.cash = cash;
  }
 
  public ContractDefinition getContractDefinition() {
    Dao dao = new FinancialsPU();
    if(id > 0 && dao.isNotLoaded(contractDefinition)) {
      contractDefinition = dao.lazyLoader(Contract.class, this, "contractDefinition").contractDefinition;
    }
    return contractDefinition;
  }
 
  public void setContractDefinition(ContractDefinition contractDefinition) {
    this.contractDefinition = contractDefinition;
  }
 
  public Set<ContractFlow> getContractFlows() {
    return contractFlows;
  }
 
  public void setContractFlows(Set<ContractFlow> contractFlows) {
    this.contractFlows = contractFlows;
  }
 
  public Set<ContractPreference> getContractPreferences() {
    return contractPreferences;
  }
 
  public void setContractPreferences(Set<ContractPreference> contractPreferences) {
    this.contractPreferences = contractPreferences;
  }
 
  public String getContractor() {
    return contractor;
  }
 
  public void setContractor(String contractor) {
    this.contractor = contractor;
  }
 
  public Currency getCurrency() {
    if(currency == null) {
      currency = Currency.getInstance("EUR");
    }
    return currency;
  }
 
  public void setCurrency(Currency currency) {
    this.currency = currency;
  }
 
  public Department getDepartment() {
    return department;
  }
 
  public void setDepartment(Department department) {
    this.department = department;
  }
 
  public Date getEndDate() {
    return endDate;
  }
 
  public void setEndDate(Date endDate) {
    this.endDate = endDate;
  }
 
  public boolean isEquivalenceSurcharge() {
    return equivalenceSurcharge;
  }
 
  public void setEquivalenceSurcharge(boolean equivalenceSurcharge) {
    this.equivalenceSurcharge = equivalenceSurcharge;
  }
 
  public String getGlobalId() {
    return globalId;
  }
 
  public void setGlobalId(String globalId) {
    this.globalId = globalId;
  }
 
  public long getId() {
    return id;
  }
 
  public void setId(long id) {
    this.id = id;
  }
 
  public String getName() {
    return name;
  }
 
  public void setName(String name) {
    this.name = name;
  }
 
  public String getNotes() {
    return notes;
  }
 
  public void setNotes(String notes) {
    this.notes = notes;
  }
 
  public OperatingModifier getOperatingModifier() {
    return operatingModifier;
  }
 
  public void setOperatingModifier(OperatingModifier operatingModifier) {
    this.operatingModifier = operatingModifier;
  }
 
  public String getGrouping() {
    return grouping;
  }
 
  public void setGrouping(String grouping) {
    this.grouping = grouping;
  }
 
  public double getFee() {
    return fee;
  }
 
  public void setFee(double fee) {
    this.fee = fee;
  }
 
  public Periodicity getPeriodicity() {
    return periodicity;
  }
 
  public void setPeriodicity(Periodicity periodicity) {
    this.periodicity = periodicity;
  }
 
  public Set<ContractParticipant> getParticipants() {
    return participants;
  }
 
  public void setParticipants(Set<ContractParticipant> participants) {
    this.participants = participants;
  }
 
  public Set<RelatedContractStore> getRelatedContractStores() {
    Dao dao = new FinancialsPU();
    if(id > 0 && dao.isNotLoaded(relatedContractStores)) {
      relatedContractStores = dao.lazyLoader(Contract.class, this, "relatedContractStores").relatedContractStores;
    }
    return relatedContractStores;
  }
 
  public void setRelatedContractStores(Set<RelatedContractStore> relatedContractStores) {
    this.relatedContractStores = relatedContractStores;
  }
 
  public Service getService() {
    return service;
  }
 
  public void setService(Service service) {
    this.service = service;
  }
 
  public Date getStartDate() {
    return startDate;
  }
 
  public void setStartDate(Date startDate) {
    this.startDate = startDate;
  }
 
  public boolean isStock() {
    return stock;
  }
 
  public void setStock(boolean stock) {
    this.stock = stock;
  }
 
  public Set<Tax> getTaxes() {
    return taxes;
  }
 
  public void setTaxes(Set<Tax> taxes) {
    this.taxes = taxes;
  }
 
  public Set<Contracted> getContracted() {
    return contracted;
  }
 
  public void setContracted(Set<Contracted> contracted) {
    this.contracted = contracted;
  }
 
  public boolean isUseContractorCode() {
    return useContractorCode;
  }
 
  public void setUseContractorCode(boolean useContractorCode) {
    this.useContractorCode = useContractorCode;
  }
 
  public ContractHandshake getContractHandshake() {
    return contractHandshake;
  }
 
  public void setContractHandshake(ContractHandshake contractHandshake) {
    this.contractHandshake = contractHandshake;
  }
 
  /* IDaoEntity */
  
  @Override
  public Object entityId() {
    return id;
  }
 
  @Override
  public boolean isEmpty() {
    return Strings.isBlank(contractor) || getContractDefinition() == null;
  }
 
  @Override
  public void prepareSave() {
    if(!stock) {
      department = null;
      service = null;
    }
    IDaoEntity.super.prepareSave();
    name = Strings.truncateAndWarn(getFullDescription(), 255);
    if(operatingModifier == null) {
      operatingModifier = OperatingModifier.OPMOD_NORMAL;
    }
    if(id == 0) {
      id = IdUtils.getNewLongIdFromLong(new FinancialsPU(), "Contract", "id");
    }
  }
 
  @Override
  public Collection<Collection> collections() {
    return List.of(
            getParticipants(), 
            getRelatedContractStores(),
            getContractFlows(),
            getTaxes(),
            getContracted());
  }
 
  /* Helpers */
 
  public IContact getIContractor() {
    if(!Strings.isBlank(contractor)) {
      return Contacts.getContactById(contractor);
    }
    return null;
  }
 
  public String getPartialDescription() {
    StringBuilder sb = new StringBuilder();
    if(!Strings.isBlank(globalId)) {
      sb.append(globalId);
    }
    return sb.length() > 0 ? sb.toString() : getFullDescription();
  }
 
  public String getFullDescription() {
    StringBuilder sb = new StringBuilder();
    if(department != null) {
      sb.append(department.getFullName());
      service = null;
    } else if(service != null) {
      sb.append(service.getFullName());
      department = null;
    } else {
      IContact ic = getIContractor();
      if(ic != null) {
        sb.append(ic.getName());
      }
    }
    if(getContractDefinition() != null) {
      PhraseBuilder pb = new PhraseBuilder();
      pb.addWord(contractDefinition.getName());
      pb.addPendingSeparator(": ");
      for(ContractPreference cp : getContractPreferences()) {
        pb.addWord(cp.getName());
        pb.addPendingSeparator(",");
      }
      if(!pb.isBlank()) {
        pb.enclose("()");
        sb.append(" " + pb.toString());
      }
    }
    if(!OperatingModifier.OPMOD_NORMAL.equals(getOperatingModifier())) {
      sb.append(" [" + getOperatingModifier().toString().substring(6, 12) + "]");
    }
    if(globalId != null) {
      sb.append(" " + globalId);
    }
    return sb.toString();
  }
 
  public Collection<ContractFlow> getFlowFor(Document document) {
    ArrayList<ContractFlow> flows = new ArrayList<>();
    if(document != null && document.getDocumentDefinition() != null) {
      for(ContractFlow cf : contractFlows) {
        if(cf.getDocumentDefinition().getId() == document.getDocumentDefinition().getId()) {
          flows.add(cf);
        }
      }
    }
    return flows;
  }
  
  public List<Document> getDocuments() {
    WhereClause wc = new WhereClause();
    wc.addClause("select d from Document d");
    wc.addClause("where d.contract = :contract");
    wc.addNamedValue("contract", this);
    Dao dao = new FinancialsPU();
    return dao.getResultList(Document.class, wc);
  }
 
  public static void checkNames() {
    Dao dao = new FinancialsPU();
    List<Contract> list = dao.getResultList(
            "select contract from Contract as contract");
    for(Contract c : list) {
      c.prepareSave();
      dao.saveObject(c);
    }
  }
 
  /* Participants helper */
  
  private transient ContactList _participants, _docParticipants;
  
  public Collection<IContact> getIParticipants() {
    if(_participants == null) {
      _participants = new ContactList();
      for(ContractParticipant cp : getParticipants()) {
        _participants.add(Contacts.getContactById(cp.getIdContact()));
      }
      _participants.add(getIContractor());
    }
    return _participants;
  }
  
  public Collection<IContact> getIParticipantsEmail() {
    if(_docParticipants == null) {
      _docParticipants = new ContactList();
      for(ContractParticipant cp : getParticipants()) {
        if(cp.getInterventionType().isSendDocuments()) {
          _docParticipants.add(Contacts.getContactById(cp.getIdContact()));
        }
      }
      _docParticipants.add(getIContractor());
    }
    return _docParticipants;
  }
  
  /* Usual */
  
  public String getUsualPath(DocumentDefinition documentDefinition) {
    if(documentDefinition != null) {
      return "dc-" +
              getId() + "-" +
              documentDefinition.getId() + "-";
    }
    return "";
  }
 
  /* XML Serializer */
  
  public MappingSet getSerializerMappings() {
    MappingSet set = new MappingSet();
    set.addMapping(Contract.class, 1, 
            new String[] { "id", "globalId", "contractor", "name" }, 
            new String[] { "stock", "cash", "active", "useContractorCode", "operatingModifier", 
              "startDate", "endDate", "notes", "department", "service", "contractDefinition",
              "contractPreferences", "relatedContractStores", "participants", "currency", 
              "taxes", "equivalenceSurcharge", "contractFlows", "contractHandshake",
              "grouping", "fee", "periodicity", "contracted" });
    set.addMapping(Department.class, 2,
            new String[] { "id", "name" }, 
            null);
    set.addMapping(Service.class, 2,
            new String[] { "id", "name" }, 
            null);
    set.addMapping(ContractDefinition.class, 2,
            new String[] { "id", "name" }, 
            null);
    set.addMapping(ContractPreference.class, 2,
            new String[] { "id", "name" }, 
            null);
    set.addMapping(RelatedContractStore.class, 2,
            new String[] { "allowed" }, 
            new String[] { "documentDefinition", "store" });
    set.addMapping(DocumentDefinition.class, 3,
            new String[] { "id", "name" }, 
            null);
    set.addMapping(Contract.class, 3,
            new String[] { "id", "name" }, 
            null);
    set.addMapping(ContractParticipant.class, 2,
            new String[] { "name", "interventionType" }, 
            null);
    set.addMapping(Currency.class, 2,
            new String[] { "currencyCode" }, 
            null);
    set.addMapping(Tax.class, 2,
            new String[] { "taxType", "tax", "equivalenceSurcharge" }, 
            null);
    set.addMapping(ContractFlow.class, 2,
            new String[] { "description" }, 
            new String[] { "documentDefinition", "contractExpiries" });
    set.addMapping(ContractExpiry.class, 3,
            new String[] { "concept",  "daysToAdd", "dayOfWeek", "percentValue", "amountValue" }, 
            new String[] { "documentDefinition", "lineType", "daysOfMonth", "excludedMonths" });
    set.addMapping(DocumentDefinition.class, 4,
            new String[] { "id", "name" }, 
            null);
    set.addMapping(LineType.class, 4,
            new String[] { "name" }, 
            null);
    set.addMapping(Integer.class, 4,
            new String[] { "this" }, 
            null);
    set.addMapping(ContractHandshake.class, 2,
            new String[] { "remoteId", "remoteName", "remoteServer" }, 
            null);
    set.addMapping(Contracted.class, 2,
            new String[] { "concept", "price", "quantity" }, 
            new String[] { "product" });
    set.addMapping(Product.class, 3,
            new String[] { "id", "productCode" }, 
            new String[] { "description" });
    return set;
  }
 
}