ContactsVM.java

Go to the documentation of this file.

/*
 * Turró i Cutiller Foundation. License notice.
 * Copyright (C) 2021 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.contacts.model;
 
import java.util.Collection;
import java.util.Collections;
import java.util.EnumSet;
import java.util.HashSet;
import java.util.List;
import java.util.Set;
import java.util.stream.Collectors;
import org.turro.action.Plugins;
import org.turro.command.Context;
import org.turro.contacts.Contact;
import org.turro.contacts.ContactType;
import org.turro.contacts.content.DirectoryType;
import org.turro.contacts.db.ContactsPU;
import org.turro.contacts.form.ContactWrapper;
import org.turro.contacts.relation.FuzzyRelationTypes;
import org.turro.contacts.social.SocialGroupListbox;
import org.turro.contacts.social.SocialGroupValue;
import org.turro.contacts.util.ContactList;
import org.turro.contacts.zul.contact.ContactTypeListbox;
import org.turro.contacts.zul.menu.ContactMenu;
import org.turro.elephant.context.Application;
import org.turro.elephant.db.WhereClause;
import org.turro.elephant.util.Components;
import org.turro.elephant.zkoss.ModalWindow;
import org.turro.entities.IElephantEntity;
import org.turro.i18n.I_;
import org.turro.jpa.Dao;
import org.turro.menu.ElephantMenu;
import org.turro.plugin.IPlugin;
import org.turro.security.SecItem;
import org.turro.security.Secs;
import org.turro.security.SecurityGroups;
import org.turro.security.SocialGroups;
import org.turro.skills.tags.SkillItem;
import org.turro.skills.tags.SkillTags;
import org.turro.tags.TagItem;
import org.turro.tags.Tags;
import org.turro.zkoss.dialog.DialogField;
import org.turro.zkoss.dialog.Dialogs;
import org.turro.zul.frame.Framework;
import org.zkoss.bind.BindUtils;
import org.zkoss.bind.annotation.BindingParam;
import org.zkoss.bind.annotation.Command;
import org.zkoss.bind.annotation.NotifyChange;
import org.zkoss.zk.ui.Component;
import org.zkoss.zul.Button;
import org.zkoss.zul.ListModel;
import org.zkoss.zul.ListModelSet;
import org.zkoss.zul.Row;
 
public class ContactsVM {
  
  private final boolean allContacts;
  private final ModelSearch search;
  
  private Set<DirectoryType> typeSet;
  private Set<SecItem> secSet;
  private Set<TagItem> tagSet;
  private Set<SkillItem> skillSet;
  private String searchValue;
  private boolean doNotLoad;
  private ContactItem selected;
  private ContactModel model;
 
  public ContactsVM() {
    this.search = new ModelSearch();
    this.typeSet = new HashSet<>(EnumSet.allOf(DirectoryType.class));
    this.secSet = new HashSet<>();
    this.tagSet = new HashSet<>();
    this.skillSet = new HashSet<>();
    this.allContacts = Application.getApplication().isInRole("contact:all");
    
    // Migration
    Secs.removeSyndication(getDao(), "directory");
    Tags.removeTags("contact", List.of("directory"));
    Tags.removeTags("contact", List.of("student"));
    Tags.removeTags("contact", SecurityGroups.getAll().stream()
            .map(sg -> sg.getTags()).flatMap(Set::stream).collect(Collectors.toList()));
  }
 
  @NotifyChange("model")
  @Command
  public void sec(@BindingParam("selected") Set<SecItem> selected ) {
    secSet = new HashSet<>(selected);
  }
  
  @NotifyChange("model")
  @Command
  public void tag(@BindingParam("selected") Set<TagItem> selected ) {
    tagSet = new HashSet<>(selected);
  }
  
  @NotifyChange("model")
  @Command
  public void skill(@BindingParam("selected") Set<SkillItem> selected ) {
    skillSet = new HashSet<>(selected);
  }
  
  @Command
  public void edit(@BindingParam("item") ContactItem item) {
    ContactMenu.showContact(item.getContact().getId());
  }
  
  @Command
  public void organigram(@BindingParam("item") ContactItem item) {
    ContactMenu.showOrganigram(item.getContact());
  }
  
  @Command
  public void vcard(@BindingParam("item") ContactItem item) {
    ElephantMenu.showEntityModal(item.getContact().getId(), "contactId", "/contact/vcard.zul", null);
  }
  
  @Command
  public void qrcode(@BindingParam("item") ContactItem item) {
    ElephantMenu.showEntityModal(item.getContact().getId(), "contactId", "/contact/qrcode.zul", null);
  }
  
  @Command
  public void participations(@BindingParam("item") ContactItem item) {
    ContactMenu.showParticipations(ContactsPU.getObjectPath(item.getContact()));
  }
  
  @Command
  public void subscriptions(@BindingParam("item") ContactItem item) {
    ContactMenu.showSubscriptions(item.getContact());
  }
  
  @Command
  public void delete(@BindingParam("item") ContactItem item, @BindingParam("ctrl") Component ctrl) {
    ElephantMenu.showEntityModal(item.getContact().getId(), "contactId", "/contact/delContact.zul", new org.turro.command.Command() {
      @Override
      public Object execute(Context context) {
        ModalWindow mw = (ModalWindow) context.get("win");
        if(mw.getResult() == 1) {
          new ContactWrapper(item.getContact()).delete();
          Row row = Components.from(ctrl).parent(Row.class);
          if(row != null) row.detach();
        }
        return true;
      }
    });
  }
  
  @NotifyChange("model")
  @Command
  public void select(@BindingParam("item") IElephantEntity item) {
    selected = new ContactItem(getDao(), item.getStringId(), true);
  }
  
  @Command
  public void add() {
    ContactMenu.showContact((String) null);
  }
  
  @NotifyChange("model")
  @Command
  public void selectall() {
    if(model != null) {
      model.selectAll();
      doNotLoad = true;
    }
  }
  
  @NotifyChange("model")
  @Command
  public void deselectall() {
    if(model != null) {
      model.deselectAll();
      doNotLoad = true;
    }
  }
  
  @NotifyChange("model")
  @Command
  public void togglesel() {
    if(model != null) {
      model.toggleSelection();
      doNotLoad = true;
    }
  }
  
  @Command
  public void export() {
    Button export = (Button) Plugins.loadImplementation(IPlugin.class, "vcard");
    if(export != null) {
      ((IPlugin) export).setData("export", contactsFromModel());
    }
  }
  
  @Command
  public void copy() {
    Framework.getClipboard().put("bbf_clip_contact", contactsFromModel());
  }
  
  @Command
  public void copyrel() {
    Framework.getClipboard().put("bbf_clip_contact", relationsFromModel());
  }
  
  @Command
  public void addtosc() {
    if(model != null && !model.getSelected().isEmpty()) {
      Dialogs.title(I_.get("Add to social group"))
             .width("400px")
             .height("500px")
             .addField(DialogField.field("Social group").onEditor(() -> {
                    SocialGroupListbox sglb = new SocialGroupListbox();
                    sglb.setMultiple(true);
                    sglb.setCheckmark(true);
                    sglb.setRows(11);
                    sglb.loadSocialGroups(true);
                    return sglb;
             }))
             .onOk((dialogs) -> {
               Collection<SocialGroupValue> sgs = dialogs.<SocialGroupListbox>getEditor("Social group").getObjectValues();
               if(!sgs.isEmpty()) {
                 List<Contact> selection = model.getSelected().stream().map(ci -> ci.getContact()).collect(Collectors.toList());
                 SocialGroups.syndicate(
                         selection, 
                         sgs.stream().map(sgv -> sgv.getKey()).collect(Collectors.toSet()),
                         getDao());
                 SocialGroups.checkInheritance(selection, getDao());
                 BindUtils.postNotifyChange(null, null, ContactsVM.this, "model");
               }
             })
             .emptyCancel()
             .show();
    }
  }
  
  @Command
  public void delfromsc() {
    if(model != null && !model.getSelected().isEmpty()) {
      Dialogs.title(I_.get("Remove from social group"))
             .width("400px")
             .height("500px")
             .addField(DialogField.field("Social group").onEditor(() -> {
                    SocialGroupListbox sglb = new SocialGroupListbox();
                    sglb.setMultiple(true);
                    sglb.setCheckmark(true);
                    sglb.setRows(11);
                    sglb.loadSocialGroups(true);
                    return sglb;
             }))
             .onOk((dialogs) -> {
               Collection<SocialGroupValue> sgs = dialogs.<SocialGroupListbox>getEditor("Social group").getObjectValues();
               if(!sgs.isEmpty()) {
                 List<Contact> selection = model.getSelected().stream().map(ci -> ci.getContact()).collect(Collectors.toList());
                 SocialGroups.unsyndicate(
                         selection, 
                         sgs.stream().map(sgv -> sgv.getKey()).collect(Collectors.toSet()),
                         getDao());
                 SocialGroups.checkInheritance(selection, getDao());
                 BindUtils.postNotifyChange(null, null, ContactsVM.this, "model");
               }
             })
             .emptyCancel()
             .show();
    }
  }
  
  @Command
  public void resyndicate() {
    if(model != null && !model.getSelected().isEmpty()) {
      List<Contact> selection = model.getSelected().stream().map(ci -> ci.getContact()).collect(Collectors.toList());
      SocialGroups.resyndicate(
              selection,
              getDao());
      SocialGroups.checkInheritance(selection, getDao());
      BindUtils.postNotifyChange(null, null, ContactsVM.this, "model");
    }
  }
 
  @Command
  public void settype() {
    if(model != null && !model.getSelected().isEmpty()) {
      Dialogs.title(I_.get("Set type"))
             .width("400px")
             .height("300px")
             .addField(DialogField.field("Type").onEditor(() -> {
               ContactTypeListbox ctl = new ContactTypeListbox();
               ctl.setSelectFirst(false);
               ctl.setCheckmark(true);
               ctl.setRows(4);
               return ctl;
             }))
             .onOk((dialogs) -> {
               ContactType type = dialogs.<ContactTypeListbox>getEditor("Type").getObjectValue();
               if(type != null) {
                 List<Contact> contacts = model.getSelected().stream().map(ci -> ci.getContact())
                          .collect(Collectors.toList());
                 contacts.forEach(contact -> contact.setType(type));
                 getDao().saveCollection(contacts);
                 BindUtils.postNotifyChange(null, null, ContactsVM.this, "model");
               }
             })
             .emptyCancel()
             .show();
    }
  }
  
  @Command
  public void activate() {
    if(model != null && !model.getSelected().isEmpty()) {
      List<Contact> contacts = model.getSelected().stream().map(ci -> ci.getContact())
               .collect(Collectors.toList());
      contacts.forEach(contact -> contact.setDeactivated(false));
      getDao().saveCollection(contacts);
      BindUtils.postNotifyChange(null, null, ContactsVM.this, "model");
    }
  }
  
  @Command
  public void deactivate() {
    if(model != null && !model.getSelected().isEmpty()) {
      List<Contact> contacts = model.getSelected().stream().map(ci -> ci.getContact())
               .collect(Collectors.toList());
      contacts.forEach(contact -> contact.setDeactivated(true));
      getDao().saveCollection(contacts);
      BindUtils.postNotifyChange(null, null, ContactsVM.this, "model");
    }
  }
  
  @NotifyChange("model")
  @Command("update")
  public void update() {}
  
  public Set<DirectoryType> getTypeSet() {
    return typeSet;
  }
 
  public void setTypeSet(Set<DirectoryType> typeSet) {
    this.typeSet = typeSet;
  }
 
  public String getSearchValue() {
    return searchValue;
  }
 
  public void setSearchValue(String searchValue) {
    this.searchValue = searchValue;
  }
 
  public boolean isUseConnector() {
    return search.isUseConnector();
  }
 
  public void setUseConnector(boolean useConnector) {
    search.setUseConnector(useConnector);
  }
 
  public boolean isUseAddress() {
    return search.isUseAddress();
  }
 
  public void setUseAddress(boolean useAddress) {
    search.setUseAddress(useAddress);
  }
 
  public boolean isUseComment() {
    return search.isUseComment();
  }
 
  public void setUseComment(boolean useComment) {
    search.setUseComment(useComment);
  }
 
  public ContactModel getModel() {
    if(doNotLoad) {
      doNotLoad = false;
      return model;
    }
    model = null;
    if(selected != null) {
      model = new ContactModel(getDao(), selected);
      selected = null;
    } else {
      if(typeSet.isEmpty()) return new ContactModel(getDao(), Collections.EMPTY_LIST);
      WhereClause wc = new WhereClause();
      wc.addClause("select distinct contact.id from Contact contact");
      wc.addClause("left outer join contact.businessRelations relation");
      wc.addClause("left outer join contact.connectors connector");
      wc.addClause("left outer join contact.addresses address");
      wc.addClause("left outer join contact.syndications syndication");
      wc.addClause("left outer join contact.comments comment");
      search.apply("where", searchValue, wc, secSet.isEmpty() && tagSet.isEmpty() && skillSet.isEmpty());
      if(!typeSet.equals(EnumSet.allOf(DirectoryType.class))) {
        wc.addClause("and (");
        String sep = "";
        if(typeSet.contains(DirectoryType.DIRECTORY_COMPANIES)) {
          wc.addClause(sep + "contact.type = :typeb");
          wc.addNamedValue("typeb", ContactType.CONTACT_COMPANY);
          sep = "or ";
        }
        if(typeSet.contains(DirectoryType.DIRECTORY_CENTERS)) {
          wc.addClause(sep + "contact.type = :typec");
          wc.addNamedValue("typec", ContactType.CONTACT_LEARNINGCENTER);
          sep = "or ";
        }
        if(typeSet.contains(DirectoryType.DIRECTORY_PROFESSIONALS)) {
          FuzzyRelationTypes.isProfessional(wc, sep, "relation");
          sep = "or ";
        }
        if(typeSet.contains(DirectoryType.DIRECTORY_EDUCATORS)) {
          FuzzyRelationTypes.isEducator(wc, sep, "relation");
          sep = "or ";
        }
        if(typeSet.contains(DirectoryType.DIRECTORY_STUDENTS)) {
          FuzzyRelationTypes.isStudent(wc, sep, "relation");
          sep = "or ";
        }
        if(typeSet.contains(DirectoryType.DIRECTORY_SINGLETONS)) {
          FuzzyRelationTypes.isSingleton(wc, sep, "contact", "relation");
          sep = "or ";
        }
        wc.addClause(")");
      }
      if(secSet != null && !secSet.isEmpty()) {
        List<String> ids = Secs.getIdentifiers(getDao(), secSet);
        if(ids == null || ids.isEmpty()) {
          wc.addClause("and 1=2");
        } else {
          wc.addIn("and", "contact.id", ids);
        }
      }
      if(tagSet != null && !tagSet.isEmpty()) {
        List<String> ids = Tags.getIdentifiers("contact", tagSet);
        if(ids == null || ids.isEmpty()) {
          wc.addClause("and 1=2");
        } else {
          wc.addIn("and", "contact.id", ids);
        }
      }
      if(skillSet != null && !skillSet.isEmpty()) {
        List<String> ids = SkillTags.getIdentifiers("contact", skillSet);
        if(ids == null || ids.isEmpty()) {
          wc.addClause("and 1=2");
        } else {
          wc.addIn("and", "contact.id", ids);
        }
      }
      if(!allContacts) {
        wc.addIn("and", "syndication.name", 
                SocialGroups.allowedSocialGroups().stream().map(sg -> sg.getId()).collect(Collectors.toList()));
      }
      wc.addClause("order by contact.name");
      model = new ContactModel(getDao(), getDao().getResultList(wc));
    }
    return model;
  }
  
  public ListModel getTypeModel() {
    return new ListModelSet(DirectoryType.values());
  }
  
  private List contactsFromModel() {
    ContactList list = new ContactList();
    if(model != null) {
      for(ContactItem mi : model.getSelected()) {
        list.add(mi.getContact());
      }
    }
    return list;
  }
  
  private List relationsFromModel() {
    ContactList list = new ContactList();
    if(model != null) {
      for(ContactItem mi : model.getSelected()) {
        list.addAll(mi.getContact().getCoworkers(mi.getContact()));
      }
    }
    return list;
  }
  
  /* Dao */
  
  private Dao _dao;
  
  private Dao getDao() {
    if(_dao == null) {
      _dao = new ContactsPU();
    }
    return _dao;
  }
 
}