HandshakeItem.java

Go to the documentation of this file.

/*
 * Turró i Cutiller Foundation. License notice.
 * Copyright (C) 2015 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.handshake;
 
import java.io.File;
import java.util.Set;
import org.turro.string.Strings;
import org.turro.command.Command;
import org.turro.command.Context;
import org.turro.elephant.context.ElephantContext;
import org.turro.elephant.util.DateFormats;
import org.turro.elephant.util.Images;
import org.turro.financials.contract.ContractCombobox;
import org.turro.financials.db.FinancialsPU;
import org.turro.financials.entity.Contract;
import org.turro.financials.entity.ContractHandshake;
import org.turro.financials.entity.Document;
import org.turro.financials.entity.DocumentDefinition;
import org.turro.financials.entity.DocumentLine;
import org.turro.financials.entity.DocumentRelation;
import org.turro.financials.entity.Product;
import org.turro.financials.entity.ProductByContractor;
import org.turro.financials.menu.FinancialsMenu;
import org.turro.financials.model.contract.ContractUsualSet;
import org.turro.financials.product.ProductCombobox;
import org.turro.http.ElephantResponse;
import org.turro.i18n.I_;
import org.turro.jpa.Dao;
import org.turro.zkoss.dialog.InputDialog;
import org.turro.zkoss.dialog.InputField;
import org.turro.zul.frame.Framework;
import org.zkoss.zk.ui.HtmlBasedComponent;
 
public class HandshakeItem {
  
  private final File file;
  private final Object handshake;
 
  public HandshakeItem(File file, Object handshake) {
    this.file = file;
    this.handshake = handshake;
  }
 
  public File getFile() {
    return file;
  }
  
  public String getFrom() {
    if(handshake instanceof HandshakeContract) {
      HandshakeContract hc = (HandshakeContract) handshake;
      return hc.petitioner;
    } else if(handshake instanceof HandshakeDocument) {
      HandshakeDocument hd = (HandshakeDocument) handshake;
      HandshakeContract hc = hd.contract;
      return hc.petitioner;
    } else if(handshake instanceof HandshakeProduct) {
      HandshakeProduct hp = (HandshakeProduct) handshake;
      return hp.petitioner;
    }
    return null;
  }
  
  public String getDescription() {
    if(handshake instanceof HandshakeContract) {
      HandshakeContract hc = (HandshakeContract) handshake;
      return hc.remoteName;
    } else if(handshake instanceof HandshakeDocument) {
      HandshakeDocument hd = (HandshakeDocument) handshake;
      return hd.documentName + " " + hd.documentNumber + ", " + DateFormats.format(hd.documentDate, true);
    } else if(handshake instanceof HandshakeProduct) {
      HandshakeProduct hp = (HandshakeProduct) handshake;
      return hp.description;
    }
    return null;
  }
  
  public HandshakeItemStatus getStatus() {
    if(handshake instanceof HandshakeContract) {
      HandshakeContract hc = (HandshakeContract) handshake;
      Contract contract = HandshakeContract.getContractFromHandshake(hc);
      if(contract != null) {
        return HandshakeItemStatus.HSITEM_EXISTS;
      } else {
        return HandshakeItemStatus.HSITEM_NEW;
      }
    } else if(handshake instanceof HandshakeDocument) {
      HandshakeDocument hd = (HandshakeDocument) handshake;
      Contract contract = HandshakeContract.getContractFromHandshake(hd.contract);
      if(contract != null) {
        Document document = HandshakeDocument.getDocumentFromHandshake(contract, hd);
        if(document != null) {
          return HandshakeItemStatus.HSITEM_EXISTS;
        } else {
          return HandshakeItemStatus.HSITEM_NEW;
        }
      }
    } else if(handshake instanceof HandshakeProduct) {
      HandshakeProduct hp = (HandshakeProduct) handshake;
      Product product = HandshakeProduct.getProductFromHandshake(hp);
      if(product != null) {
        return HandshakeItemStatus.HSITEM_EXISTS;
      } else {
        return HandshakeItemStatus.HSITEM_NEW;
      }
    }
    return null;
  }
  
  public String getConnectImage() {
    if(handshake instanceof HandshakeContract) {
      return Images.getImage("contract");
    } else if(handshake instanceof HandshakeDocument) {
      // no connection to document
    } else if(handshake instanceof HandshakeProduct) {
      return Images.getImage("product");
    }
    return null;
  }
  
  public String getCreateImage() {
    if(handshake instanceof HandshakeContract) {
      // no new contract
    } else if(handshake instanceof HandshakeDocument) {
      return Images.getImage("document_new");
    } else if(handshake instanceof HandshakeProduct) {
      return Images.getImage("product_new");
    }
    return null;
  }
  
  public boolean deleteFile() {
    return file.delete();
  }
 
  public void connect(Command command) {
    if(handshake instanceof HandshakeContract) {
      HandshakeContract hc = (HandshakeContract) handshake;
      connectContract(hc, command);
    } else if(handshake instanceof HandshakeDocument) {
      // no connection to document
    } else if(handshake instanceof HandshakeProduct) {
      HandshakeProduct hp = (HandshakeProduct) handshake;
      connectProduct(hp, command);
    }
  }
 
  private void connectContract(final HandshakeContract hc, final Command command) {
    InputDialog.getInput(
            Framework.getCurrent().getPage(),
            I_.get("Connect to..."),
            new InputField[] {
              new InputField("Contract", null, null, 0) {
                @Override
                protected HtmlBasedComponent createEditor() {
                  ContractCombobox ccb = new ContractCombobox();
                  ccb.setOnlyActive(true);
                  ccb.setDocumentDefinition(DocumentDefinition.getHandshakeReceiver());
                  return ccb;
                }
              }
            }, new Command() {
      @Override
      public Object execute(Context context) {
        InputField[] fields = (InputField[]) context.get("fields");
        if (fields.length > 0) {
          for (InputField f : fields) {
            if ("Contract".equals(f.getLabel())) {
              Contract contract = (Contract) f.getValue();
              ContractHandshake ch = new ContractHandshake();
              ch.setContract(contract);
              ch.setRemoteId(hc.remoteId);
              ch.setRemoteName(hc.remoteName);
              ch.setRemoteServer(hc.remoteServer);
              contract.setContractHandshake(ch);
              ElephantResponse er = HandshakeUtil.sendAcceptance(contract, ElephantContext.getServerUrl("http"), hc.remoteId);
              if(ElephantResponse.isCorrect(er)) {
                new FinancialsPU().saveObject(contract);
                if(command != null) command.execute(context);
              }
            }
          }
        }
        return null;
      }
    });
  }
 
  private void connectProduct(final HandshakeProduct hp, final Command command) {
    InputDialog.getInput(
            Framework.getCurrent().getPage(),
            I_.get("Connect to..."),
            new InputField[] {
              new InputField("Product", null, null, 0) {
                @Override
                protected HtmlBasedComponent createEditor() {
                  return new ProductCombobox();
                }
              }
            }, new Command() {
      @Override
      public Object execute(Context context) {
        InputField[] fields = (InputField[]) context.get("fields");
        if (fields.length > 0) {
          for (InputField f : fields) {
            if ("Product".equals(f.getLabel())) {
              Product product = (Product) f.getValue();
              ProductByContractor pbc = new ProductByContractor();
              pbc.setContract(hp.contract);
              pbc.setProduct(product);
              pbc.setContractorCode(hp.code);
              pbc.setDescription(hp.description);
              pbc.setPrice(hp.price);
              pbc.setTax(hp.tax);
              new FinancialsPU().saveObject(pbc);
              if(command != null) command.execute(context);
            }
          }
        }
        return null;
      }
    });
  }
 
  public boolean create() {
    if(handshake instanceof HandshakeContract) {
      // no new contract
    } else if(handshake instanceof HandshakeDocument) {
      if(createDocument((HandshakeDocument) handshake)) return true;      
    } else if(handshake instanceof HandshakeProduct) {
      HandshakeProduct hp = (HandshakeProduct) handshake;
      if(createProduct(hp)) return true;
    }
    return false;
  }
 
  private boolean createDocument(HandshakeDocument hsdoc) {
    Dao dao = new FinancialsPU();
    Document document = processDocument(dao, hsdoc);
    if(document != null && !document.isEmpty()) {
      FinancialsMenu.showDocument(document);
      return true;
    }
    return false;
  }
  
  private Document processDocument(Dao dao, HandshakeDocument hsdoc) {
    Contract contract = HandshakeContract.getContractFromHandshake(hsdoc.contract);
    Document document = new Document();
    document.setContract(contract);
    document.setDocumentDefinition(dao.find(DocumentDefinition.class, (Long) hsdoc.definitionId));
    document.setDocumentNumber(hsdoc.documentNumber);
    document.setDocumentDate(hsdoc.documentDate);
    document.setReceiptDate(document.getDocumentDate());
    Set<Contract> usualStores = new ContractUsualSet(document.getStores(), true, document.getUsualPath() + "st:");
    Contract store = usualStores.iterator().next();
    if(store == null) {
      store = document.getDefaultStore();
    }
    int count = 1;
    for(HandshakeDocLine hsdl : hsdoc.lines) {
      DocumentLine dl = new DocumentLine();
      dl.setDocument(document);
      dl.setLineOrder(count++);
      dl.setConcept(hsdl.concept);
      dl.setDiscountMoney(hsdl.discountMoney);
      dl.setDiscountPerCent(hsdl.discountPerCent);
      dl.setEquivalenceSurcharge(hsdl.equivalenceSurcharge);
      dl.setPrice(hsdl.price);
      if(hsdl.product != null) setDocumentLineProduct(dl, hsdl.product);
      dl.setQuantity(hsdl.quantity);
      dl.setRetention(hsdl.retention);
      dl.setTax(hsdl.tax);
      dl.setLineType(document.getDefaultLineType());
      dl.setStore(store);
      document.getDocumentLines().add(dl);
    }
    for(HandshakeDocument hsd : hsdoc.expiries) {
      Document d = processDocument(dao, hsd);
      if(!d.isEmpty()) {
        DocumentRelation dr = new DocumentRelation();
        dr.setAncestor(document);
        dr.setDescendant(d);
        document.getDescendants().add(dr);
      }
    }
    return document;
  }
 
  private void setDocumentLineProduct(DocumentLine dl, HandshakeProduct product) {
    product.contract = dl.getDocument().getContract();
    ProductByContractor pbc = HandshakeProduct.getProductByContractorFromHandshake(product);
    if(pbc != null) {
      dl.setProductByContractor(pbc);
      dl.setProduct(pbc.getProduct());
    } else if(!Strings.isBlank(product.description)) {
      if(Strings.isBlank(dl.getConcept())) {
        dl.setConcept(product.description);
      } else {
        dl.setConcept(product.description + "\n" + dl.getConcept());
      }
    }
  }
 
  private boolean createProduct(HandshakeProduct hp) {
    Dao dao = new FinancialsPU();
    Product product = new Product();
    product.setDescription(hp.description);
    product.setPrice(hp.price);
    product.setTax(hp.tax);
    ProductByContractor pbc = new ProductByContractor();
    pbc.setContract(hp.contract);
    pbc.setProduct(product);
    pbc.setContractorCode(hp.code);
    pbc.setDescription(hp.description);
    pbc.setPrice(hp.price);
    pbc.setTax(hp.tax);
    product.getProductByContractors().add(pbc);
    product.prepareSave();
    dao.saveObject(product);
    return true;
  }
 
}