AgreementComposer.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.List;
import java.util.logging.Level;
import java.util.logging.Logger;
import org.apache.commons.mail.EmailException;
import org.turro.action.MailSenders;
import org.turro.command.Command;
import org.turro.elephant.context.Application;
import org.turro.elephant.context.ElephantContext;
import org.turro.elephant.context.IConstructor;
import org.turro.elephant.db.ElephantPU;
import org.turro.elephant.entities.db.Agreement;
import org.turro.elephant.entities.db.AgreementSignature;
import org.turro.elephant.util.Messages;
import org.turro.i18n.I_;
import org.turro.jpa.Dao;
import org.turro.plugin.contacts.IContact;
import org.turro.zkoss.dialog.SelectionDialog;
import org.turro.zkoss.text.WikiEditor;
import org.zkoss.zk.ui.Component;
import org.zkoss.zk.ui.select.SelectorComposer;
import org.zkoss.zk.ui.select.annotation.Listen;
import org.zkoss.zk.ui.select.annotation.Wire;
import org.zkoss.zul.Checkbox;
import org.zkoss.zul.Label;
import org.zkoss.zul.Textbox;
 
public class AgreementComposer extends SelectorComposer<Component> {
 
  private Agreement agreement;
 
  @Wire("#agreeCombo")
  private AgreementCombobox agreeCombo;
 
  @Wire("#agreed")
  private Label agreed;
 
  @Wire("#declined")
  private Label declined;
 
  @Wire("#notsigned")
  private Label notsigned;
 
  @Wire("#title")
  private Textbox title;
 
  @Wire("#toNotify")
  private Checkbox toNotify;
 
  @Wire("#toAccess")
  private Checkbox toAccess;
 
  @Wire("#toAction")
  private Checkbox toAction;
 
  @Wire("#peremptory")
  private Checkbox peremptory;
 
  @Wire("#action")
  private Textbox action;
 
  @Wire("#agreeWiki")
  private WikiEditor agreeWiki;
 
  @Listen("onClick = #signatures")
  public final void onSignatures() {
    if (agreement != null) {
      SelectionDialog.showComponent(getPage(), I_.get("Signatures"),
              new SignaturesListbox(agreement), "900px", "500px", (Command) null);
    }
  }
 
  @Listen("onClick = #reminders")
  public final void onReminders() {
    Messages.confirmProcess().show(() -> {
      try {
        sendNotSigned();
      } catch (Exception ex) {
        Logger.getLogger(AgreementComposer.class.getName()).log(Level.SEVERE, ElephantContext.logMsg(null), ex);
      }
    });
  }
 
  @Listen("onClick = #save")
  public final void onSave() {
    getDao().saveObject(agreement);
  }
 
  @Listen("onClick = #delete")
  public final void onDelete() {
    if (AgreementsUtil.deleteAgreement(agreement)) {
      agreement = null;
      updateControls();
    }
  }
 
  @Listen("onChange = #title")
  public final void onChange() {
    checkAgreement().setTitle(title.getValue());
    updateControls();
  }
 
  @Listen("onChange = #action")
  public final void onAction() {
    checkAgreement().setAction(action.getValue());
    updateControls();
  }
 
  @Listen("onChange = #agreeWiki")
  public final void onWiki() {
    checkAgreement().setWiki(agreeWiki.getValue());
    checkAgreement().setText(agreeWiki.getHtml());
    updateControls();
  }
 
  @Listen("onSelect = #agreeCombo")
  public final void onSelect() {
    agreement = agreeCombo.getObjectValue();
    if (agreement != null) {
      List<AgreementSignature> signatures = agreement.getSignatures();
      agreed.setValue("" + signatures.stream().filter((as) -> (as.isSigned() && as.isAgreed())).count());
      declined.setValue("" + signatures.stream().filter((as) -> (as.isSigned() && !as.isAgreed())).count());
      notsigned.setValue("" + signatures.stream().filter((as) -> (!as.isSigned())).count());
    } else {
      agreed.setValue("");
      declined.setValue("");
      notsigned.setValue("");
    }
    updateControls();
  }
 
  @Listen("onCheck = #toNotify; onCheck = #toAccess; onCheck = #toAction; onCheck = #peremptory")
  public final void onCheck() {
    checkAgreement().setRequiredToNotify(toNotify.isChecked());
    checkAgreement().setRequiredToAccess(toAccess.isChecked());
    checkAgreement().setRequiredToAction(toAction.isChecked());
    checkAgreement().setPeremptory(peremptory.isChecked());
    updateControls();
  }
 
  private void updateControls() {
    if (agreement != null) {
      title.setReadonly(false);
      title.setValue(agreement.getTitle());
      toNotify.setDisabled(false);
      toNotify.setChecked(agreement.isRequiredToNotify());
      toAccess.setDisabled(false);
      toAccess.setChecked(agreement.isRequiredToAccess());
      toAction.setDisabled(false);
      toAction.setChecked(agreement.isRequiredToAction());
      peremptory.setDisabled(false);
      peremptory.setChecked(agreement.isPeremptory());
      action.setReadonly(!agreement.isRequiredToAction());
      action.setValue(agreement.getAction());
      agreeWiki.setReadonly(false);
      agreeWiki.setValue(agreement.getWiki());
    } else {
      title.setReadonly(true);
      title.setValue(null);
      toNotify.setDisabled(true);
      toNotify.setChecked(false);
      toAccess.setDisabled(true);
      toAccess.setChecked(false);
      toAction.setDisabled(true);
      toAction.setChecked(false);
      peremptory.setDisabled(true);
      peremptory.setChecked(false);
      action.setReadonly(true);
      action.setValue(null);
      agreeWiki.setReadonly(true);
      agreeWiki.setValue(null);
    }
  }
 
  private Agreement checkAgreement() {
    if (agreement == null) {
      agreement = new Agreement();
      agreement.setAppliesTo("*");
    }
    return agreement;
  }
 
  private void sendNotSigned() throws EmailException, Exception {
    IConstructor constructor = Application.getApplication().getConstructor();
    for (AgreementSignature as : agreement.getSignatures()) {
      if (!as.isSigned()) {
        IContact contact = as.getContact();
        if (contact.isWebUser()) {
          MailSenders.getPool()
                  .setRoot("/agreements")
                  .addContact(contact)
                  .put("signature", as)
                  .put("acceptUrl", AgreementAction.createURL(constructor, as, contact, true))
                  .put("declineUrl", AgreementAction.createURL(constructor, as, contact, false))
                  .sendTemplate("requiredSignature", as.getAgreement().getTitle() + " : " + ElephantContext.getSiteName());
        }
      }
    }
  }
 
  /* Dao */
  private Dao _dao;
 
  private Dao getDao() {
    if (_dao == null) {
      _dao = new ElephantPU();
    }
    return _dao;
  }
 
}