SocialGroups.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.security;
 
import java.util.ArrayList;
import java.util.Collection;
import java.util.HashSet;
import java.util.List;
import java.util.Set;
import java.util.stream.Collectors;
import org.turro.auth.Authentication;
import org.turro.contacts.Contact;
import org.turro.contacts.ContactType;
import org.turro.contacts.Syndication;
import org.turro.jpa.Dao;
import org.turro.plugin.contacts.IContact;
import org.turro.sql.SqlClause;
import org.turro.tags.Tags;
 
public class SocialGroups extends SecurityGroups {
 
  public static Collection<SecurityGroup> allowedSocialGroups() {
    return SocialGroups.allowedSocialGroups(Authentication.getIContact());
  }
  
  public static Collection<SecurityGroup> allowedSocialGroups(IContact contact) {
    SocialGroups instance = instance();
    if(contact.isAdmin()) {
      return instance.socialGroups.values();
    } else {
      Set<SecurityGroup> socials = new HashSet<>();
      contact.getSyndications().forEach(syndication -> {
        socials.addAll(instance.socialGroups.get(syndication).getAllowed().stream()
                .map(asg -> instance.socialGroups.get(asg.getId())).collect(Collectors.toList()));
      });
      return socials;
    }
  }
  
  public static void syndicate(List<Contact> contacts, Set<String> socialGroupIds, Dao dao) {
    SocialGroups socials = instance();
    contacts.forEach(contact -> {
      socials.synchronizeSocials(contact, socials.flatSocialGroups(contact, socialGroupIds));
      if(dao != null) {
        dao.saveObject(contact);
      }
    });
  }
  
  public static void unsyndicate(List<Contact> contacts, Set<String> socialGroupIds, Dao dao) {
    SocialGroups socials = instance();
    contacts.forEach(contact -> {
      socials.removeSocials(contact, socials.flatSocialGroups(null, socialGroupIds));
      if(dao != null) {
        dao.saveObject(contact);
      }
    });
  }
  
  public static void absoluteSyndicate(List<Contact> contacts, Set<String> socialGroupIds, Dao dao) {
    SocialGroups socials = instance();
    contacts.forEach(contact -> {
      socials.synchronizeSocials(contact, socials.flatSocialGroups(null, socialGroupIds));
      if(dao != null) {
        dao.saveObject(contact);
      }
    });
  }
  
  public static void resyndicate(List<Contact> contacts, Dao dao) {
    SocialGroups socials = instance();
    Set<String> socialGroupIds = new HashSet<>();
    contacts.forEach(contact -> {
      socials.synchronizeSocials(contact, socials.flatSocialGroups(contact, socialGroupIds));
      if(dao != null) {
        dao.saveObject(contact);
      }
    });
  }
  
  /* Inheritance */
  
  public static void checkInheritance(List<Contact> contacts, Dao dao) {
    SocialGroups socials = instance();
    contacts.forEach(contact -> {
      socials.checkInheritance(contact, dao);
    });
  }
  
  /* Utils */
  
  public void removeSocials(Contact contact, Set<String> socialGroupIds) {
    contact.getSyndications().removeIf(syndication -> socialGroupIds.contains(syndication.getName()));
  }
 
  public void synchronizeSocials(Contact contact, Set<String> socialGroupIds) {
    contact.getSyndications().removeIf(syndication -> !socialGroupIds.contains(syndication.getName()));
    Set<String> syndicationNames = contact.getSyndications().stream()
            .map(syndication -> syndication.getName()).collect(Collectors.toSet());
    socialGroupIds.stream().filter(social -> !syndicationNames.contains(social)).forEach(social -> {
      Syndication syndication = new Syndication();
      syndication.setContact(contact);
      syndication.setName(social);
      contact.getSyndications().add(syndication);
    });
  }
 
  @Deprecated
  public void synchronizeTags(Contact contact, Set<String> tags) {
    Set<String> currentTags = Tags.getTags(contact).stream()
            .map(tag -> tag.getTagName()).collect(Collectors.toSet());
    currentTags.stream().filter(tag -> !tags.contains(tag) && possibleTag(tag)).forEach(tag -> {
      Tags.removeTag(contact, tag);
    });
    tags.stream().filter(tag -> !currentTags.contains(tag)).forEach(tag -> {
      Tags.addTag(contact, tag);
    });
  }
 
  public Set<String> flatSocialGroups(Contact contact, Set<String> socials) {
    Set<String> flatSocials = new HashSet<>();
    if(contact != null) {
      flatSocials.addAll(contact.getSyndications().stream()
              .map(syndication -> syndication.getName()).collect(Collectors.toSet()));
    }
    socials.forEach(social -> {
      recurseSocialGroups(flatSocials, socialGroups.get(social));
    });
    return flatSocials;
  }
 
  public Set<String> flatRoles(Set<Syndication> syndications) {
    Set<String> flatRoles = new HashSet<>();
    syndications.forEach(syndication -> {
      SecurityGroup sg = socialGroups.get(syndication.getName());
      if(sg != null) {
        flatRoles.addAll(sg.getRoles());
      }
    });
    return flatRoles;
  }
 
  @Deprecated
  public Set<String> flatTags(Set<Syndication> syndications) {
    Set<String> flatTags = new HashSet<>();
    syndications.forEach(syndication -> {
      SecurityGroup sg = socialGroups.get(syndication.getName());
      if(sg != null) {
        flatTags.addAll(sg.getTags());
      }
    });
    return flatTags;
  }
 
  public void checkInheritance(Contact contact, Dao dao) {
    if(ContactType.juridicals().contains(contact.getType())) {
      contact.getWorkerSet().getWorkers().forEach(staff -> {
        checkCompanyInheritance(staff, dao);
      });
    } else {
      checkCompanyInheritance(contact, dao);
    }
  }
 
  public Contact checkCompanyInheritance(Contact contact, Dao dao) {
    final Contact current = dao.find(Contact.class, contact.getId());
    if(current != null) {
      List<String> inheritance = getInheritedFrom(current);
      // Delete dynamically assigned
      SqlClause.delete("Syndication")
              .where().notIn("name", inheritance)
              .and().equal("dynamic", true)
              .and().equal("contact", current)
              .dao(dao)
              .execute();
      // Dynamize existing
      SqlClause.update("Syndication")
              .set("dynamic", true)
              .where().in("name", inheritance)
              .and().equal("contact", current)
              .dao(dao)
              .execute();
      // Add missing
      List<String> currentNames = SqlClause.select("s.name").from("Syndication s")
              .where().equal("contact", current)
              .dao(dao)
              .resultList(String.class);
      inheritance.stream().filter(name -> !currentNames.contains(name))
              .forEach(name -> {
                Syndication syndication = new Syndication();
                syndication.setContact(current);
                syndication.setName(name);
                syndication.setDynamic(true);
                dao.saveObject(syndication);
              });
      return dao.find(Contact.class, current.getId());
    } else {
      return contact;
    }
    
  }
 
  public List<String> getInheritedFrom(Contact contact) {
    List<String> inheritance = new ArrayList<>();
    if(contact != null) {
      contact.getBusinessSet().getBusinessList().forEach(business -> {
        inheritance.addAll(business.getSyndications().stream()
              .filter(syndication -> syndication.getSocialGroup().isInherits())
              .map(syndication -> syndication.getName())
              .toList());
      });
    }
    return inheritance;
  }
  /* Factory */
  
  public static SocialGroups instance() {
    return new SocialGroups();
  }  
 
}