PublicationCategories.java

Go to the documentation of this file.

/*
 * Turró i Cutiller Foundation. License notice.
 * Copyright (C) 2019 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.publication.util;
 
import java.util.ArrayList;
import java.util.Collection;
import java.util.Collections;
import java.util.Date;
import java.util.List;
import org.turro.string.Strings;
import org.turro.action.Contacts;
import org.turro.action.queue.ConstraintKeys;
import org.turro.elephant.db.WhereClause;
import org.turro.mail.queue.QueueManager;
import org.turro.plugin.contacts.IContact;
import org.turro.publication.db.PublicationPU;
import org.turro.publication.entity.Publication;
import org.turro.publication.entity.PublicationCategory;
import org.turro.publication.entity.PublicationGroup;
import org.turro.sql.SqlClause;
 
public class PublicationCategories {
 
  public static List<Publication> getPublicationsBy(int max, long group, long category,
          String idContact, boolean accepted) {
    return getPublicationsBy(max, group, category, idContact, accepted, null);
  }
 
  public static List<Publication> getPublicationsBy(int max, long group, long category,
          IContact contact, boolean accepted) {
    return getPublicationsBy(max, group, category, contact, accepted, null);
  }
 
  public static List<Publication> getPublicationsBy(int max, long group, long category,
          String idContact, boolean accepted, String extraSql) {
    return getPublicationsBy(max, group, category, Contacts.getContactById(idContact), accepted, extraSql);
  }
  
  public static List<Publication> getPublicationsBy(int max, long group, long category,
          IContact contact, boolean accepted, String extraSql) {
    return SqlClause.select("publication").from("Publication publication")
            .where().equal("accepted", accepted)
            .startIf(group != 0)
            .and().equal("publication.publicationGroup.id", group)
            .endIf()
            .startIf(category != 0)
            .and().equal("publication.publicationCategory.id", category)
            .endIf()
            .startIf(category == 0 || group == 0)
            .and().isTrue("publication.publicationGroup.publishable")
            .endIf()
            .startIf(contact != null && contact.isWebUser())
            .and().equal("publication.idContact", contact.getId())
            .endIf()
            .startIf(!Strings.isBlank(extraSql))
            .append(extraSql)
            .endIf()
            .orderBy("publication.date DESC")
            .dao(new PublicationPU())
            .max(max)
            .resultList(Publication.class)
            .stream()
            .filter(p -> {
              if(category == 0) {
                return p.getPublicationCategory().strongBond(ConstraintKeys.from(contact));
              } else {
                return true;
              }
            })
            .toList();            
//    WhereClause wc = new WhereClause();
//    wc.addClause("select publication from Publication publication");
//    wc.addClause("where publication.accepted = :accepted");
//    wc.addNamedValue("accepted", accepted);
//    if(group != 0) {
//      wc.addClause("and publication.publicationGroup.id = :group");
//      wc.addNamedValue("group", group);
//    } else {
//      wc.addClause("and publication.publicationGroup.publishable = TRUE");
//    }
//    if(category != 0) {
//      wc.addClause("and publication.publicationCategory.id = :category");
//      wc.addNamedValue("category", category);
//    } else {
//      wc.addClause("and publication.publicationCategory.publishable = TRUE");
//      if(contact != null && contact.isWebUser()) {
//        wc.addClause("and (");
//        wc.addClause("publication.publicationCategory.conditionedBy in :syndications");
//        wc.addNamedValue("syndications", contact.getSyndications());
//        wc.addClause("or (publication.publicationCategory.conditionedBy is null or trim(publication.publicationCategory.conditionedBy) = '')");
//        wc.addClause(")");
//      } else {
//        wc.addClause("and (publication.publicationCategory.conditionedBy is null or trim(publication.publicationCategory.conditionedBy) = '')");
//      }
//    }
//    if(contact != null && contact.isWebUser()) {
//      wc.addClause("and publication.idContact = :idContact");
//      wc.addNamedValue("idContact", contact.getId());
//    }
//    if(!Strings.isBlank(extraSql)) {
//      wc.addClause(extraSql);
//    }
//    wc.addClause("order by publication.date DESC");
//
//    return new PublicationPU().getResultList(wc, max);
  }
 
  public static Collection<PublicationCategory> getPublicCategories() {
    return getPublicCategories((IContact) null);
  }
 
  public static Collection<PublicationCategory> getPublicCategories(String idContact) {
    return getPublicCategories(Contacts.getContactById(idContact));
  }
 
  public static Collection<PublicationCategory> getPublicCategories(IContact contact) {
    return SqlClause.select("c").from("PublicationCategory c")
            .where().isTrue("c.publishable")
            .dao(new PublicationPU())
            .resultList(PublicationCategory.class)
            .stream()
            .filter(pc -> {
              if(contact != null && contact.isWebUser()) {
                return pc.strongBond(ConstraintKeys.from(contact));
              }
              return !pc.isRestricted();
            })
            .toList();
  }
  
  public static Collection<PublicationCategory> getSubscribedPrivateCategories(String idContact) {
    return getSubscribedPrivateCategories(Contacts.getContactById(idContact));
  }
  
  public static Collection<PublicationCategory> getSubscribedPrivateCategories(IContact contact) {
    ArrayList<PublicationCategory> list = new ArrayList<>();
    for(PublicationCategory category : getPrivateCategories()) {
      QueueManager qm = new QueueManager();
      if(qm.contactWants(contact, PublicationElephantNotification.convertId(category))) {
        list.add(category);
      }
    }
    return list;
  }
  
  public static Collection<PublicationCategory> getPrivateCategories() {
    return SqlClause.select("c").from("PublicationCategory c")
            .where().isFalse("c.publishable")
            .dao(new PublicationPU())
            .resultList(PublicationCategory.class);
  }
  
  public static Collection<? extends PublicationCategory> getPrivateBloggerCategories(IContact contact) {
    if(contact != null && contact.isWebUser()) {
      WhereClause wc = new WhereClause();
      wc.addClause("select b.publicationCategory from PublicationBlogger b");
      wc.addClause("where b.idContact = :idContact");
      wc.addNamedValue("idContact", contact.getId());
      wc.addClause("and b.publicationCategory.publishable = FALSE");
      return new PublicationPU().getResultList(wc);
    } else {
      return Collections.EMPTY_LIST;
    }
  }
 
  public static List<Publication> getNotSentPublications(long categoryID) {
    WhereClause wc = new WhereClause();
    wc.addClause("select publication from Publication publication");
    wc.addClause("where publication.sent = FALSE");
    wc.addClause("and publication.accepted = TRUE");
    wc.addClause("and (retainTill is null or retainTill <= :now)");
    wc.addNamedValue("now", new Date());
    if(categoryID != 0) {
      wc.addClause("and publication.publicationCategory.id = :category");
      wc.addNamedValue("category", categoryID);
    }
    wc.addClause("order by publication.date DESC");
    
    return new PublicationPU().getResultList(wc);
  }
 
  public static void markAsSentPublications(long categoryID) {
    WhereClause wc = new WhereClause();
    wc.addClause("update Publication publication");
    wc.addClause("set publication.sent = TRUE");
    wc.addClause("where publication.accepted = TRUE");
    wc.addClause("and (publication.retainTill is null or publication.retainTill <= :now)");
    wc.addNamedValue("now", new Date());
    if(categoryID != 0) {
      wc.addClause("and publication.publicationCategory.id = :category");
      wc.addNamedValue("category", categoryID);
    }
    
    new PublicationPU().executeUpdate(wc);
  }
 
  public static List<PublicationCategory> getPublicationCategories() {
    return new PublicationPU().getResultList(
            "select pc from PublicationCategory pc order by name");
  }
 
  public static List<PublicationGroup> getPublicationGroups() {
    return new PublicationPU().getResultList(
            "select pg from PublicationGroup pg order by name");
  }
 
}