DossierInitializer.java

Go to the documentation of this file.

/*
 * Turró i Cutiller Foundation. License notice.
 * Copyright (C) 2020 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.entitites;
 
import java.util.Collection;
import java.util.logging.Level;
import java.util.logging.Logger;
import org.turro.action.IElephantInitializer;
import org.turro.annotation.ElephantInitializer;
import org.turro.attach.search.Attachments;
import org.turro.contacts.ContactManagers;
import org.turro.contacts.IContactManager;
import org.turro.dossier.db.DossierPU;
import org.turro.dossier.dossier.ParticipantSet;
import org.turro.dossier.entity.Category;
import org.turro.dossier.entity.CategoryParticipant;
import org.turro.dossier.entity.Dossier;
import org.turro.dossier.entity.DossierOffer;
import org.turro.dossier.entity.Issue;
import org.turro.dossier.entity.IssueParticipant;
import org.turro.dossier.entity.IssueType;
import org.turro.dossier.entity.Participant;
import org.turro.dossier.search.CategoryResults;
import org.turro.elephant.context.IConstructor;
import org.turro.jpa.Dao;
import org.turro.jpa.DaoUtil;
import org.turro.jpa.query.JpaCriteria;
import org.turro.jpa.query.JpaCriteriaDelete;
import org.turro.jpa.query.JpaQuery;
import org.turro.jpa.query.JpaRoot;
import org.turro.log.WebLoggers;
import org.turro.sql.SqlClause;
 
@ElephantInitializer
public class DossierInitializer implements IElephantInitializer {
 
  @Override
  public void initialize(IConstructor constructor) {
    WebLoggers.info(this).message("CategoryResults started").log();
    CategoryResults.normalizeUniquePaths();
    Dao dao = new DossierPU();
    WebLoggers.info(this).message("killDuplicatesAndOrphans started").log();
    killDuplicatesAndOrphans(dao);
    WebLoggers.info(this).message("killMissingContacts started").log();
    killMissingContacts(dao);
    WebLoggers.info(this).message("migrateOffers started").log();
    migrateOffers(dao);
  }
 
  private void killDuplicatesAndOrphans(Dao dao) {
    killCategoryParticipantDuplicates(dao);
    killDossierParticipantDuplicates(dao);
    killIssueParticipantDuplicates(dao);
  }
 
  private void killCategoryParticipantDuplicates(Dao dao) {
    JpaCriteria jc = new JpaCriteria(dao);
    JpaQuery<Object[]> jqcp = jc.query(Object[].class);
    JpaRoot<CategoryParticipant> participant = jqcp.root(CategoryParticipant.class);
    jqcp.multiselect(participant.get("idContact"), participant.get("category"), jc.count(participant.get("id")))
            .groupBy(participant.get("idContact"), participant.get("category"))
            .having(jc.greaterThan(jc.count(participant.get("id")), 1L));
    dao.getResultList(jqcp).forEach((results) -> {
      Category category = (Category) results[1];
      boolean exists = false;
      for(CategoryParticipant cp : new ParticipantSet<>(category.getParticipants())) {
        if(cp.getIdContact().equals(results[0])) {
          if(exists) {
            JpaCriteriaDelete<CategoryParticipant> juc = jc.createCriteriaDelete(CategoryParticipant.class);
            dao.executeDelete(juc.where(jc.equal(juc.field("id"), cp.getId())));
            Logger.getLogger(DossierInitializer.class.getName()).log(
                    Level.INFO, "CategoryParticipant deleted {0} {1} on {2}",
                    new Object[] { cp.getName(), cp.getRole().name(), cp.getCategory().getDescription() });
          }
          exists = true;
        }
      }
    });
  }
 
  private void killDossierParticipantDuplicates(Dao dao) {
    JpaCriteria jc = new JpaCriteria(dao);
    JpaQuery<Object[]> jqcp = jc.query(Object[].class);
    JpaRoot<Participant> participant = jqcp.root(Participant.class);
    jqcp.multiselect(participant.get("idContact"), participant.get("dossier"), jc.count(participant.get("id")))
            .groupBy(participant.get("idContact"), participant.get("dossier"))
            .having(jc.greaterThan(jc.count(participant.get("id")), 1L));
    dao.getResultList(jqcp).forEach((results) -> {
      Dossier dossier = (Dossier) results[1];
      boolean exists = false;
      for(Participant dp : new ParticipantSet<>(dossier.getParticipants())) {
        if(dp.getIdContact().equals(results[0])) {
          if(exists) {
            JpaCriteriaDelete<Participant> juc = jc.createCriteriaDelete(Participant.class);
            dao.executeDelete(juc.where(jc.equal(juc.field("id"), dp.getId())));
            Logger.getLogger(DossierInitializer.class.getName()).log(
                    Level.INFO, "DossierParticipant deleted {0} {1} on {2}",
                    new Object[] { dp.getName(), dp.getRole().name(), dp.getDossier().getDescription() });
          }
          exists = true;
        }
      }
    });
  }
 
  private void killIssueParticipantDuplicates(Dao dao) {
    JpaCriteria jc = new JpaCriteria(dao);
    JpaQuery<Object[]> jqcp = jc.query(Object[].class);
    JpaRoot<IssueParticipant> participant = jqcp.root(IssueParticipant.class);
    jqcp.multiselect(participant.get("idContact"), participant.get("role"), participant.get("issue"), jc.count(participant.get("id")))
            .groupBy(participant.get("idContact"), participant.get("role"), participant.get("issue"))
            .having(jc.greaterThan(jc.count(participant.get("id")), 1L));
    dao.getResultList(jqcp).forEach((results) -> {
      Issue issue = (Issue) results[2];
      boolean exists = false;
      for(IssueParticipant ip : new ParticipantSet<>(issue.getParticipants())) {
        if(ip.getIdContact().equals(results[0]) && ip.getRole().equals(results[1])) {
          if(exists) {
            JpaCriteriaDelete<IssueParticipant> juc = jc.createCriteriaDelete(IssueParticipant.class);
            dao.executeDelete(juc.where(jc.equal(juc.field("id"), ip.getId())));
            Logger.getLogger(DossierInitializer.class.getName()).log(
                    Level.INFO, "IssueParticipant deleted {0} {1} on {2}",
                    new Object[] { ip.getName(), ip.getRole().name(), ip.getIssue().getDescription() });
          }
          exists = true;
        }
      }
    });
  }
 
  private void killMissingContacts(Dao dao) {
    IContactManager manager = ContactManagers.instance();
    manager.removeMissingFrom(dao, "CategoryParticipant", "idContact");
    manager.removeMissingFrom(dao, "Participant", "idContact");
    manager.removeMissingFrom(dao, "IssueParticipant", "idContact");
  }
 
  private void migrateOffers(Dao dao) {
    if(DaoUtil.isEmpty(dao, "DossierOffer") && 
            !DaoUtil.isEmpty(dao, "Issue", "where type = ?", IssueType.TYPE_PROPOSITION)) {
      SqlClause.select("i").from("Issue i")
              .where().equal("i.type", IssueType.TYPE_PROPOSITION)
              .dao(dao)
              .resultList(Issue.class).forEach(issue -> {
                Collection<IssueParticipant> reporters = issue.getIssueParticipants().getReporters();
                if(!reporters.isEmpty()) {
                  DossierOffer dp = new DossierOffer();
                  dp.setDescription(issue.getDescription());
                  dp.setCreation(issue.getIssueDate());
                  dp.setBidderId(reporters.iterator().next().getIdContact());
                  dp.setDossier(issue.getDossier());
                  if(issue.getStatus().isFinished()) {
                    dp.setAccepted(issue.getResolution().isSolved());
                    dp.setDeclined(!dp.isAccepted());
                  }
                  dp = dao.saveObject(dp);
                  Attachments.from(DossierPU.getObjectPath(issue))
                          .toFolder(dp.getFolder());
                }
              });
    }
  }
 
}