PollControl.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.polls;
 
import java.util.Collection;
import java.util.Date;
import java.util.logging.Level;
import java.util.logging.Logger;
import org.apache.commons.mail.EmailException;
import org.turro.action.IEntityHolder;
import org.turro.assistant.Assistant;
import org.turro.assistant.AssistantSet;
import org.turro.auth.Authentication;
import org.turro.command.Command;
import org.turro.command.Context;
import org.turro.elephant.context.Application;
import org.turro.elephant.context.ElephantContext;
import org.turro.elephant.context.IConstructor;
import org.turro.elephant.entities.db.Poll;
import org.turro.elephant.util.Messages;
import org.turro.entities.Entities;
import org.turro.i18n.I_;
import org.turro.mail.message.MailMessageTemplate;
import org.turro.mail.pool.MailMessagePool;
import org.turro.mail.provider.MailProviders;
import org.turro.marker.ElephantMarker;
import org.turro.plugin.contacts.ContactList;
import org.turro.plugin.contacts.IContact;
import org.turro.mail.recipients.IMailRecipients;
import org.turro.zkoss.input.DateboxShort;
import org.turro.zkoss.input.GenericBandbox;
import org.turro.zkoss.input.GenericCombobox;
import org.turro.zkoss.input.GenericListbox;
import org.turro.zkoss.input.KnowsID;
import org.turro.zkoss.input.Percentbox;
import org.turro.zkoss.text.WikiEditor;
import org.zkoss.zk.ui.Executions;
import org.zkoss.zk.ui.HtmlBasedComponent;
import org.zkoss.zk.ui.IdSpace;
import org.zkoss.zk.ui.event.Event;
import org.zkoss.zk.ui.event.Events;
import org.zkoss.zk.ui.event.InputEvent;
import org.zkoss.zk.ui.ext.AfterCompose;
import org.zkoss.zk.ui.select.Selectors;
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.Datebox;
import org.zkoss.zul.Hlayout;
import org.zkoss.zul.Intbox;
import org.zkoss.zul.Label;
import org.zkoss.zul.Listbox;
import org.zkoss.zul.Longbox;
import org.zkoss.zul.Panel;
import org.zkoss.zul.Space;
import org.zkoss.zul.Textbox;
import org.zkoss.zul.Timebox;
 
public class PollControl extends Panel implements IdSpace, AfterCompose {
 
  private Poll poll;
  
  @Wire("#polls")
  private PollListbox polls;
  
  @Wire("#title")
  private Textbox title;
  
  @Wire("#location")
  private Textbox location;
  
  @Wire("#deadline")
  private Datebox deadline;
  
  @Wire("#maxPerOption")
  private Intbox maxPerOption;
  
  @Wire("#maxVotedOptions")
  private Intbox maxVotedOptions;
 
  @Wire("#optionType")
  private OptionDataListbox optionType;
  
  @Wire("#maxmin")
  private Hlayout maxmin;
  
  @Wire("#showParticipants")
  private Checkbox showParticipants;
  
  @Wire("#showVotes")
  private Checkbox showVotes;
 
  @Wire("#allowInsertions")
  private Checkbox allowInsertions;
 
  @Wire("#allowNegatives")
  private Checkbox allowNegatives;
 
  @Wire("#pollWiki")
  private WikiEditor pollWiki;
  
  @Wire("#optionGrid")
  private PollOptionGrid optionGrid;
  
  @Wire("#votesGrid")
  private PollVotesGrid votesGrid;
  
  @Wire("#attachments")
  private IEntityHolder attachments;
 
  @Wire("#files")
  private IEntityHolder files;
 
  @Listen("onSelect = #polls")
  public void onSelectPoll() {
    setPoll(polls.getObjectValue());
  }
  
  @Listen("onChange = #title")
  public void onTitleChange(InputEvent event) {
    if(poll != null) poll.setTitle(event.getValue());
  }
 
  @Listen("onChange = #location")
  public void onLocationChange(InputEvent event) {
    if(poll != null) poll.setLocation(event.getValue());
  }
 
  @Listen("onChange = #deadline")
  public void onDeadlineChange() {
    if(poll != null) poll.setDeadline(deadline.getValue());
  }
 
  @Listen("onChange = #maxPerOption")
  public void onMaxPerOptionChange(InputEvent event) {
    if(poll != null) poll.setMaxPerOption(Integer.valueOf(event.getValue()));
  }
 
  @Listen("onChange = #maxVotedOptions")
  public void onMaxVotedOptionsChange(InputEvent event) {
    if(poll != null) poll.setMaxVotedOptions(Integer.valueOf(event.getValue()));
  }
 
  @Listen("onSelect = #optionType")
  public void onTypeSelect() {
    if(poll != null) {
      poll.setOptionClass(optionType.getObjectValue().getType());
      createMaxmin(null, null);
    }
  }
 
  @Listen("onCheck = #showParticipants")
  public void onCheckParticipants() {
    if(poll != null) poll.setShowParticipants(showParticipants.isChecked());
  }
  
  @Listen("onCheck = #showVotes")
  public void onCheckVotes() {
    if(poll != null) poll.setShowVotes(showVotes.isChecked());
  }
 
  @Listen("onCheck = #allowInsertions")
  public void onCheckInsertions() {
    if(poll != null) poll.setAllowInsertions(allowInsertions.isChecked());
  }
 
  @Listen("onCheck = #allowNegatives")
  public void onCheckNegatives() {
    if(poll != null) poll.setAllowNegatives(allowNegatives.isChecked());
  }
  
  @Listen("onChange = #pollWiki")
  public void onWikiChange(InputEvent event) {
    if(poll != null) poll.setWiki(event.getValue());
  }
  
  @Listen("onClick = #createPoll")
  public void onCreatePoll() {
    Poll poll = new Poll();
    poll.setEntityPath(entityPath);
    poll.setOptionClass(OptionDataType.OPTION_STRING.getType());
    setPoll(poll);
  }
 
  @Listen("onClick = #savePoll")
  public void onSave() {
    if(poll != null) {
      poll = PollsUtil.savePoll(poll, optionGrid.getValues());
      polls.updateCollection(PollsUtil.getPolls(entityPath));
      polls.setObjectValue(poll);
      setPoll(polls.getObjectValue());
    }
  }
 
  @Listen("onClick = #deletePoll")
  public void onDelete() {
    if(poll != null) {
      Messages.confirmDeletion().add(poll.getTitle()).show(() -> {
        PollsUtil.removePoll(poll);
        polls.updateCollection(PollsUtil.getPolls(entityPath));
        setPoll(polls.getObjectValue());
      });
    }
  }
 
  @Listen("onClick = #sendTest")
  public void onSendTest() {
    ContactList contacts = new ContactList();
    contacts.add(Authentication.getIContact());
    IMailRecipients.selectRecipients(contacts, new Command() {
      @Override
      public Object execute(Context context) {
        IMailRecipients mr = (IMailRecipients) context.get("component");
        Collection<IContact> emails = mr.getRecipients();
        if(emails != null) {
          AssistantSet as = new AssistantSet();
          as.addContacts(emails);
          doSend(as);
        }
        return null;
      }
    });  
  }
  
  @Listen("onClick = #send")
  public void onSend() {
    doSend(poll.getParticipants());
  }
  
  public void setPoll(Poll poll) {
    this.poll = poll;
    updateControls();
  }
  
  private void updateControls() {
    if(poll != null) {
      title.setValue(poll.getTitle());
      title.setPlaceholder(I_.get("Title"));
      title.setReadonly(false);
      location.setValue(poll.getLocation());
      location.setReadonly(false);
      deadline.setValue(poll.getDeadline());
      deadline.setReadonly(false);
      maxPerOption.setValue(poll.getMaxPerOption());
      maxPerOption.setReadonly(false);
      maxVotedOptions.setValue(poll.getMaxVotedOptions());
      maxVotedOptions.setReadonly(false);
      optionType.setObjectValue(OptionDataType.getOptionType(poll.getOptionClass()));
      optionType.setDisabled(false);
      createMaxmin(poll.getOptionStart(), poll.getOptionEnd());
      showParticipants.setChecked(poll.isShowParticipants());
      showVotes.setChecked(poll.isShowVotes());
      allowInsertions.setChecked(poll.isAllowInsertions());
      allowNegatives.setChecked(poll.isAllowNegatives());
      pollWiki.setImageFolder("/_internal/files/poll/" + poll.getId());
      pollWiki.setFileFolder("/_internal/files/poll/" + poll.getId());
      pollWiki.setValue(poll.getWiki());
      pollWiki.setReadOnlyRepository(false);
      if(poll.getId() != null && poll.getId() > 0) {
        optionGrid.setAllowInsertions(true);
        optionGrid.setAllowDeletions(true);
        optionGrid.setReadOnly(false);
        optionGrid.setPoll(poll);
        votesGrid.setPoll(poll);
      } else {
        optionGrid.setAllowInsertions(false);
        optionGrid.setAllowDeletions(false);
        optionGrid.setReadOnly(true);
        optionGrid.setPoll(null);
        votesGrid.setPoll(null);
      }
      attachments.setEntity(poll);
      attachments.refreshControls();
      files.setEntity(poll);
      files.refreshControls();
    } else {
      title.setValue(null);
      title.setPlaceholder(null);
      title.setReadonly(true);
      location.setValue(null);
      location.setReadonly(true);
      deadline.setValue(null);
      deadline.setReadonly(true);
      maxPerOption.setValue(0);
      maxPerOption.setReadonly(true);
      maxVotedOptions.setValue(0);
      maxVotedOptions.setReadonly(true);
      optionType.setObjectValue(OptionDataType.OPTION_STRING);
      optionType.setDisabled(true);
      pollWiki.setImageFolder("/_internal/files/poll/empty");
      pollWiki.setFileFolder("/_internal/files/poll/empty");
      pollWiki.setValue(null);
      pollWiki.setReadOnlyRepository(true);
      showParticipants.setChecked(false);
      showVotes.setChecked(false);
      allowInsertions.setChecked(false);
      allowNegatives.setChecked(false);
      optionGrid.setAllowInsertions(false);
      optionGrid.setAllowDeletions(false);
      optionGrid.setReadOnly(true);
      optionGrid.setPoll(null);
      votesGrid.setPoll(null);
      attachments.setEntity(null);
      attachments.refreshControls();
      files.setEntity(null);
      files.refreshControls();
    }
  }
 
  /* Controls */
  
  public PollControl() {
    Executions.createComponents("/WEB-INF/_zul/bs/comps/poll/pollControl.zul", this, null);
    Selectors.wireComponents(this, this, false);
    Selectors.wireEventListeners(this, this);
  }
 
  protected String entityPath;
  protected Object entity;
 
  public String getEntityPath() {
    return entityPath;
  }
 
  public void setEntityPath(String entityPath) {
    this.entityPath = entityPath;
  }
 
  public Object getEntity() {
    return entity;
  }
 
  public void setEntity(Object entity) {
    this.entity = entity;
    if(entity != null) {
      entityPath = Entities.getController(entity).getPath();
    }
  }
 
  @Override
  public void afterCompose() {
    polls.updateCollection(PollsUtil.getPolls(entityPath));
    setPoll(polls.getObjectValue());
  }
 
  /* Mail */
  
  protected void doSend(AssistantSet participants) {
    IConstructor constructor = Application.getApplication().getConstructor();
    MailMessagePool pool = MailProviders.instance().getGeneric(constructor);
    if(pool != null) {
      for(Assistant assistant : participants) {
        try {
          MailMessageTemplate mmt = MailMessageTemplate.of(pool.getProvider());
          mmt.setSubject(I_.get("Poll") + ": " + poll.getTitle() + " - " + ElephantContext.getSiteName());
          mmt.addTo(assistant.email, assistant.name);
          ElephantMarker em = new ElephantMarker(constructor, true);
          em.put("poll", poll);
          em.put("contact", assistant.contact);
          em.put("email", assistant.email);
          em.put("notifier", this);
          em.put("iee", Entities.getController(entity));
          em.put("template", PollIterator.getOptionTemplate(poll));
          mmt.setRoot("/poll");
          mmt.setMessage(em, "poll", assistant.contact);
          pool.addToPool(mmt);
          pool.sendPool();
        } catch (EmailException ex) {
          Logger.getLogger(PollControl.class.getName()).log(Level.SEVERE, ElephantContext.logMsg(null), ex);
        }
      }
    }
  }
  
  /* Maxmin */
  
  private void createMaxmin(Object min, Object max) {
    if(poll != null) {
      maxmin.getChildren().clear();
      HtmlBasedComponent minEditor = getEditor(poll.getOptionClass(), false, min);
      minEditor.addEventListener(Events.ON_CHANGE, (Event event) -> {
        poll.setOptionStart(getFormattedString(poll.getOptionClass(), getEditorValue(minEditor)));
      });
      maxmin.appendChild(new Label(I_.get("Min value")));
      maxmin.appendChild(minEditor);
      HtmlBasedComponent maxEditor = getEditor(poll.getOptionClass(), false, max);
      maxEditor.addEventListener(Events.ON_CHANGE, (Event event) -> {
        poll.setOptionEnd(getFormattedString(poll.getOptionClass(), getEditorValue(maxEditor)));
      });
      maxmin.appendChild(new Space());
      maxmin.appendChild(new Label(I_.get("Max value")));
      maxmin.appendChild(maxEditor);
    }
  }
  
  /* Editor helpers */
  
  public static HtmlBasedComponent getEditor(String optionClass, boolean readonly, Object value) {
    if(OptionDataType.OPTION_DATETIME.getType().equals(optionClass)) {
      DateboxShort db = new DateboxShort((Date) OptionDataType.OPTION_DATETIME.getValue((String) value));
      db.setWithTime(true);
      db.setReadonly(readonly);
      return db;
    } else if(OptionDataType.OPTION_DATE.getType().equals(optionClass)) {
      DateboxShort db = new DateboxShort((Date) OptionDataType.OPTION_DATE.getValue((String) value));
      db.setWithTime(false);
      db.setReadonly(readonly);
      return db;
    } else if(OptionDataType.OPTION_TIME.getType().equals(optionClass)) {
      Timebox db = new Timebox((Date) OptionDataType.OPTION_TIME.getValue((String) value));
      db.setReadonly(readonly);
      return db;
    } else if(OptionDataType.OPTION_LONG.getType().equals(optionClass)) {
      Longbox db = new Longbox((Long) OptionDataType.OPTION_LONG.getValue((String) value));
      db.setReadonly(readonly);
      return db;
    } else {
      Textbox tb = new Textbox((String) value);
      tb.setReadonly(readonly);
      tb.setMaxlength(255);
      return tb;
    }
  }
  
  public static String getFormattedString(String optionClass, Object value) {
    return OptionDataType.getOptionType(optionClass).getString(value);
  }
  
  public static Object getEditorValue(HtmlBasedComponent hbc) {
    if(hbc instanceof Checkbox) {
      return ((Checkbox) hbc).isChecked();
    } else if(hbc instanceof Percentbox) {
      return ((Percentbox) hbc).getValue();
    } else if(hbc instanceof Longbox) {
      return ((Longbox) hbc).getValue();
    } else if(hbc instanceof Datebox) {
      return ((Datebox) hbc).getValue();
    } else if(hbc instanceof Timebox) {
      return ((Timebox) hbc).getValue();
    } else if(hbc instanceof KnowsID) {
      return ((KnowsID) hbc).getObjectId();
    } else if(hbc instanceof GenericListbox) {
      return ((GenericListbox) hbc).getObjectValue();
    } else if(hbc instanceof GenericCombobox) {
      return ((GenericCombobox) hbc).getObjectValue();
    } else if(hbc instanceof GenericBandbox) {
      return ((GenericBandbox) hbc).getObjectValue();
    } else if(hbc instanceof Listbox) {
      return ((Listbox) hbc).getSelectedItem().getValue();
    } else {
      return ((Textbox) hbc).getValue();
    }
  }
  
}