DocumentationVM.java

Go to the documentation of this file.

/*
 * Turró i Cutiller Foundation. License notice.
 * Copyright (C) 2022 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.documentation.model;
 
import java.util.ArrayList;
import java.util.Collection;
import java.util.Date;
import java.util.List;
import org.turro.string.Strings;
import org.turro.action.MailSenders;
import org.turro.action.PushSenders;
import org.turro.assistant.AssistantListbox;
import org.turro.attach.db.AttachPU;
import org.turro.attach.entity.EntityDocumentation;
import org.turro.attach.entity.EntityDocumentationStatus;
import org.turro.auth.Authentication;
import org.turro.documentation.DocumentDefinition;
import org.turro.elephant.context.ElephantContext;
import org.turro.elephant.util.Messages;
import org.turro.entities.Entities;
import org.turro.entities.EntityRole;
import org.turro.entities.IElephantEntity;
import org.turro.file.Document;
import org.turro.file.FileWrapper;
import org.turro.file.Folder;
import org.turro.i18n.I_;
import org.turro.jpa.Dao;
import org.turro.log.SystemLogger;
import org.turro.plugin.contacts.IContact;
import org.turro.sql.SqlClause;
import org.turro.upload.Medias;
import org.turro.zkoss.dialog.DialogField;
import org.turro.zkoss.dialog.Dialogs;
import org.zkoss.bind.BindUtils;
import org.zkoss.bind.annotation.BindingParam;
import org.zkoss.bind.annotation.Command;
import org.zkoss.bind.annotation.ExecutionArgParam;
import org.zkoss.bind.annotation.Init;
import org.zkoss.bind.annotation.NotifyChange;
import org.zkoss.util.media.Media;
import org.zkoss.zk.ui.Executions;
import org.zkoss.zul.Datebox;
import org.zkoss.zul.Label;
import org.zkoss.zul.Space;
import org.zkoss.zul.Textbox;
 
public class DocumentationVM {
  
  private IElephantEntity iee;
  private List<String> contactIds;
  private IContact contact;
  private boolean canCreate;
  private List<EntityDocumentation> model;
 
  @Init
  public void init(@ExecutionArgParam("entityPath") String entityPath) {
    if(Strings.isBlank(entityPath)) {
      entityPath = Executions.getCurrent().getParameter("entityPath");
    }
    if(!Strings.isBlank(entityPath)) {
      iee = Entities.getController(entityPath);
    } else {
      iee = Entities.emptyController();
    }
  }
 
  public IElephantEntity getIee() {
    return iee;
  }
    
  public boolean isCanCreate() {
    return canCreate;
  }
 
  @Command("add")
  public void add(@BindingParam("document") EntityDocumentation document) {
    DocumentDefinition dd = document.getDefinition();
    if(dd.isAllowMultiple()) {
      Dialogs.title(I_.get("Add contact"))
             .width("400px")
             .height("150px")
             .addField(DialogField.field("Request to").onEditor(() -> {
               AssistantListbox al = new AssistantListbox();
               al.setWebUsers(true);
               al.setEntityPath(iee.getPath());
               al.setMold("select");
               return al;     
             }))
             .onOk((dialogs) -> {
                IContact require = dialogs.<AssistantListbox>getEditor("Request to").getObjectValue();
                if(require != null && require.isValid()) {
                  document.getAssistantIds().add(require.getId());
                  getDao().saveObject(document);
                  BindUtils.postNotifyChange(null, null, DocumentationVM.this, "model");
                  PushSenders.getPool()
                         .addAdministrators()
                         .addContact(require)
                         .send(I_.get("Documentation"), I_.get("Pending upload documents"), document.getEntity().getEntityUrl());
                  MailSenders.getPool().setRoot("/documentation")
                         .addAdministrators()
                         .addContact(require)
                         .silentSendTemplate(document, "required", I_.get("Pending upload documents"));
                }
             })
             .emptyCancel()
             .show();
    }
  }
 
  @NotifyChange("model")
  @Command("upload")
  public void upload(@BindingParam("document") EntityDocumentation document, @BindingParam("medias") Media medias[]) {
    DocumentDefinition dd = document.getDefinition();
    Folder folder = document.getFolder();
    long count = folder.count();
    int done = 0;
    for(Media media : medias) {
      if(++count > dd.getMax() && !exists(folder, media)) break;
      if(!dd.isUploadControl() || !guessOverrides(folder, media)) {
        Medias.toFolder(media, folder);
        done++;
      } else {
        Messages.error().format(I_.get("Download current %s version first!"), media.getName()).show();
      }     
    }
    if(count > dd.getMin()) {
      document.setStatus(EntityDocumentationStatus.PENDING_VALIDATION);
    }
    document.reviewStatus();
    getDao().saveObject(document);
    if(done > 0) {
      PushSenders.getPool()
             .addAdministrators()
             .addContact(document.getRequester())
             .send(I_.get("Documentation"), I_.get("Pending to validate"), document.getEntity().getEntityUrl());
      MailSenders.getPool().setRoot("/documentation")
             .addAdministrators()
             .addContact(document.getRequester())
             .silentSendTemplate(document, "uploaded", I_.get("Pending to validate"));
    }
  }
  
  @Command("download")
  public void download(@BindingParam("document") Document document) {
    new FileWrapper(document.document()).download();
  }
  
  @Command("deleteDoc")
  public void deleteDoc(@BindingParam("document") Document document) {
    Messages.confirmDeletion().add(document.name()).show(() -> {
      document.delete();
      BindUtils.postNotifyChange(null, null, DocumentationVM.this, "model");
    });
  }
  
  @NotifyChange("model")
  @Command("validate")
  public void validate(@BindingParam("document") EntityDocumentation document) {
    document.setStatus(EntityDocumentationStatus.VALIDATED);
    getDao().saveObject(document);
    PushSenders.getPool()
           .addAdministrators()
           .addContact(document.getContact())
           .addContacts(document.getAssistants())
           .send(I_.get("Documentation"), I_.get("Validated"), document.getEntity().getEntityUrl());
    MailSenders.getPool().setRoot("/documentation")
           .addAdministrators()
           .addContact(document.getContact())
           .addContacts(document.getAssistants())
           .silentSendTemplate(document, "validated", I_.get("Validated"));
  }
  
  @Command("deny")
  public void deny(@BindingParam("document") EntityDocumentation document) {
    Dialogs.title(I_.get("Deny"))
           .width("400px")
           .height("250px")
           .addField(DialogField.field("Reason").scale(2))
           .onOk((dialogs) -> {
             String comment = dialogs.<Textbox>getEditor("Reason").getValue();
             document.setStatus(EntityDocumentationStatus.DENIED);
             document.setComment(comment);
             getDao().saveObject(document);
             BindUtils.postNotifyChange(null, null, DocumentationVM.this, "model");
             PushSenders.getPool()
                    .addAdministrators()
                    .addContact(document.getContact())
                    .addContacts(document.getAssistants())
                    .send(I_.get("Documentation"), I_.get("Denied"), document.getEntity().getEntityUrl());
             MailSenders.getPool().setRoot("/documentation")
                    .addAdministrators()
                    .addContact(document.getContact())
                    .addContacts(document.getAssistants())
                    .silentSendTemplate(document, "denied", I_.get("Denied") + ": " + document.getComment());
           })
           .emptyCancel()
           .show();
  }
  
  @Command("delete")
  public void delete(@BindingParam("document") EntityDocumentation document) {
    Messages.confirmDeletion().add(document.getDocumentation()).show(() -> {
      document.getFolder().remove();
      getDao().deleteObject(document);
      BindUtils.postNotifyChange(null, null, DocumentationVM.this, "model");
    });
  }
  
  @Command("info")
  public void info(@BindingParam("document") DocumentDefinition document) {
    Dialogs.title(I_.get("Information"))
            .width("400px")
            .height("300px")
            .addComponent(new Label(document.getDescription()))
            .addComponent(new Space())
            .addComponent(new DownloadDocuments(I_.get("References"), document.getDocumentsFor(contact)))
            .emptyClose()
            .show();
  }
  
  @Command("create")
  public void create() {
    Dialogs.title(I_.get("Request new documentation"))
           .width("400px")
           .height("500px")
           .addField(DialogField.field("Request to").onEditor(() -> {
             AssistantListbox al = new AssistantListbox();
             al.setWebUsers(true);
             al.setEntityPath(iee.getPath());
             al.setMold("select");
             return al;     
           }))
           .addField(DialogField.field("Deadline").onEditor(() -> {
             Datebox dl = new Datebox();
             dl.setFormat("short");
             return dl;     
           }))
           .addField(DialogField.field("Documentation").onEditor(() -> {
             DocumentationListbox dl = new DocumentationListbox(iee.getRoot());
             dl.setSelectFirst(false);
             dl.setCheckmark(true);
             dl.setMultiple(true);
             return dl;     
           }))
           .onOk((dialogs) -> {
             Collection<DocumentDefinition> dds = dialogs.<DocumentationListbox>getEditor("Documentation").getObjectValues();
             if(!dds.isEmpty()) {
               IContact require = dialogs.<AssistantListbox>getEditor("Request to").getObjectValue();
               if(require != null && require.isValid()) {
                 List<EntityDocumentation> eds = new ArrayList<>();
                 dds.forEach(dd -> {
                   EntityDocumentation ed = new EntityDocumentation();
                   ed.setRequesterId(Authentication.getIContact().getId());
                   ed.setEntityPath(iee.getPath());
                   ed.setContactId(require.getId());
                   ed.setDocumentation(dd.getName());
                   ed.setStatus(EntityDocumentationStatus.PENDING_UPLOAD);
                   ed.setDeadline(dialogs.<Datebox>getEditor("Deadline").getValue());
                   eds.add(ed);
                 });
                 getDao().saveCollection(eds);
                 BindUtils.postNotifyChange(null, null, DocumentationVM.this, "model");
                 EntityDocumentation document = eds.iterator().next();
                 PushSenders.getPool()
                        .addAdministrators()
                        .addContact(require)
                        .send(I_.get("Documentation"), I_.get("Pending upload documents"), document.getEntity().getEntityUrl());
                 MailSenders.getPool().setRoot("/documentation")
                        .addAdministrators()
                        .addContact(require)
                        .silentSendTemplate(document, "required", I_.get("Pending upload documents"));
               }
             }
           })
           .emptyCancel()
           .show();
  }
   
  private String selectedType;
 
  public String getSelectedType() {
    return selectedType;
  }
 
  public void setSelectedType(String selectedType) {
    this.selectedType = selectedType;
    BindUtils.postNotifyChange(null, null, DocumentationVM.this, "model");
  }
  
  public List<String> getDocumentationTypes() {
    List<String> types = new ArrayList<>();
    types.add("");
    types.addAll(model.stream().map(ed -> ed.getDefinition().getName()).distinct().toList());
    return types;
  }
  
  public List<EntityDocumentation> getModel() {
    prepareValues();
    String orderBy = canCreate ? "ed.status, ed.entityPath, ed.documentation" :
            "ed.documentation";
    model = SqlClause.select("ed")
            .from("EntityDocumentation ed")
            .where().any()
            .startIf(!canCreate)
            .and().group()
            .and().in("ed.contactId", contactIds)
            .or().equal("ed.requesterId", contact.getId())
            .or().members("ed.assistantIds", contactIds)
            .endGroup()
            .endIf()
            .startIf(!iee.isEmpty())
            .and().equal("ed.entityPath", iee.getPath())
            .endIf()
            .startIf(iee.isEmpty())
            .and().not().equal("ed.status", EntityDocumentationStatus.VALIDATED)
            .endIf()
            .orderBy(orderBy)
            .dao(getDao())
            .resultList(EntityDocumentation.class);
    List<EntityDocumentation> invalids = new ArrayList<>();
    model.removeIf(ed -> !ed.isValid(invalids));
    if(!invalids.isEmpty()) getDao().deleteCollection(invalids);
    model.forEach(ed -> ed.reviewStatus());
    getDao().saveCollection(model);
    if(!Strings.isBlank(selectedType)) {
      model.removeIf(ed -> !selectedType.equals(ed.getDefinition().getName()));
    }
    return model;
  }
 
  private void prepareValues() {
    if(contact == null) {
      canCreate = false;
      contactIds = null;
      contact = Authentication.getIContact();
      if(!iee.isEmpty()) {
        canCreate = contact.isAdmin() || iee.hasRelatedRole(EntityRole.DOCUMENTATION, contact);
      }
      if(!contact.isAdmin()) {
        contactIds = new ArrayList<>();
        contactIds.add(contact.getId());
        contact.getBusinessList().forEach(b -> contactIds.add(b.getId()));
      }
    }
  }
  
  private boolean exists(Folder folder, Media media) {
    String correctedName = Document.correctName(media.getName());
    Document document = Document.from(folder.path().resolve(correctedName));
    return document.exists();
  }
 
  private boolean guessOverrides(Folder folder, Media media) {
    String correctedName = Document.correctName(media.getName());
    Document document = Document.from(folder.path().resolve(correctedName));
    if(document.exists()) {
      String entityPath = "/file" + ElephantContext.getRelativePath(document.path().toString());
      Date lastDownload = SystemLogger.getInstance().getLastDateOf(entityPath, "downloaded");
      return lastDownload == null || document.modified().after(lastDownload);
    }
    return false;
  }
 
  /* Dao */
  
  private Dao _dao;
  
  private Dao getDao() {
    if(_dao == null) {
      _dao = new AttachPU();
    }
    return _dao;
  }
 
}