LastActivities.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.activity;
 
import java.io.File;
import java.util.Date;
import java.util.Optional;
import java.util.Set;
import org.amic.util.date.CheckDate;
import org.turro.string.ObjectString;
import org.turro.string.Strings;
import org.turro.elephant.impl.util.Serializer;
import org.turro.lock.Initializer;
import org.turro.plugin.contacts.IContact;
import org.turro.reflection.Instances;
 
public class LastActivities {
  
  /* Task util */
  
  public static void generateUserContent(Date date) {
    Date from = new CheckDate().addWeeks(LastActivities.LAST_ACTIVITY_WEEKS).getDate();
    Date now = new Date();
    if(!existsActivitySession(now, from, null)) {
      tryInstance(now, from);
    }
  }
  
  /* User contacts helpers */
  
  public static EntityActivitySet getLastActivity(IContact contact) {
    if(INIT.isBussy()) return new EntityActivitySet();
    Date from = new CheckDate().addWeeks(LastActivities.LAST_ACTIVITY_WEEKS).getDate();
    Date now = new Date();
    return deserializeLastActivitySession(now, from, contact);
  }
  
  /* Last activity session */
  
  public static ContactActivityMap getLastActivitySession(Date from, String entityPath, String type) { 
    cleanOldSessions();
    if(Strings.isBlank(entityPath) && Strings.isBlank(type)) {
      Date now = new Date();
      String fileName = "/activity/" + ObjectString.formatObject(now, ObjectString.URL_DATE_PATTERN, true) + 
              "-" + ObjectString.formatObject(from, ObjectString.URL_DATE_PATTERN, true) + ".ser";
      File ser = Serializer.getFile(fileName);
      if(ser.exists()) {
        return (ContactActivityMap) Serializer.deserialize(ser);
      } else {
        ContactActivityMap current = getContactLastActivites(from, entityPath, type);
        Serializer.serialize(ser, current);
        return current;
      }
    } else {
      return getContactLastActivites(from, entityPath, type);
    }
  }
  
  /* Helper */
  
  public static Object getMainEntity(Object entity) {
    for(ILastActivity iLast : Instances.cached().byAnnotation(LastActivity.class, ILastActivity.class)) {
      Object main = iLast.getMainEntity(entity);
      if(main != null) {
        return main;
      }
    }
    return null;
  }
 
  /* Last activities */
  
  private static ContactActivityMap getContactLastActivites(Date from, String entityPath, String type) {
    return getContactLastActivites(getLastActivites(from, entityPath, type));
  }
 
  private static ContactActivityMap getContactLastActivites(Set<IEntityLastActivity> activities) {
    ContactActivityMap map = new ContactActivityMap();
    activities.forEach((activity) -> {
      activity.getParticipants().forEach((assistant) -> {
        map.putActivity(assistant.getContact(), activity);
      });
    });
    return map;
  }
 
  private static Set<IEntityLastActivity> getLastActivites(Date from, String entityPath, String type) {
    EntityActivitySet activities = new EntityActivitySet();
    Instances.cached().byAnnotation(LastActivity.class, ILastActivity.class).forEach((iLast) -> {
      activities.addAll(iLast.getActivities(from, entityPath, type));
    });
    return activities;
  }
 
  private static void cleanOldSessions() {
    Date now = new CheckDate().addDays(-1).getDate();
    File[] files = Serializer.getFiles("/activity");
    if(files != null) {
      for(File file : files) {
        Date fileDate = (Date) ObjectString.parseString(file.getName().substring(0, 8), 
                ObjectString.URL_DATE_PATTERN, Date.class, false);
        if(fileDate == null || fileDate.before(now)) {
          file.delete();
        }
      }
    }
  }
 
  /* Last activity user content */
  
  public static final int LAST_ACTIVITY_WEEKS = -4;
  
  private static final Initializer<Boolean> INIT = new Initializer<>();
 
  private static Boolean tryInstance(Date now, Date from) {
    return INIT.tryInstance(
            () -> existsActivitySession(now, from, null),
            () -> serializeLastActivitySession(now, from));
  }
  
  private static Boolean serializeLastActivitySession(Date now, Date from) { 
    cleanOldSessions();
    getContactLastActivites(from, null, null).entrySet().forEach(e -> {
      String fileName = "/activity/" + filePrefix(now, from) + e.getKey() + ".ser";
      File ser = Serializer.getFile(fileName);
      Serializer.serialize(ser, e.getValue());
    });
    return Boolean.TRUE;
  }
  
  private static EntityActivitySet deserializeLastActivitySession(Date now, Date from, IContact contact) { 
    String fileName = "/activity/" + filePrefix(now, from) + contact.getId() + ".ser";
    File ser = Serializer.getFile(fileName);
    if(ser.exists()) {
      return Optional.ofNullable((EntityActivitySet) Serializer.deserialize(ser)).orElse(new EntityActivitySet());
    } else {
      return new EntityActivitySet();
    }
  }
  
  private LastActivities() {
  }
  
  /* File utils */
  
  private static boolean existsActivitySession(Date now, Date from, String key) { 
    String filePrefix = filePrefix(now, from);
    if(key == null) {
      for(File file : Serializer.getFiles("/activity")) {
        if(file.getName().startsWith(filePrefix)) return true;
      }
      return false;
    } else {
      return Serializer.getFile("/activity/" + filePrefix + key + ".ser").exists();
    }
  }
  
  private static String filePrefix(Date now, Date from) {
    return ObjectString.formatObject(now, ObjectString.URL_DATE_PATTERN, true) + 
            "-" + ObjectString.formatObject(from, ObjectString.URL_DATE_PATTERN, true) + 
            "-";
  }
  
}