BrightSide/contacts/src/main/java/org/turro/contacts/profile/Profile.java

Go to the documentation of this file.

/*
 * Turró i Cutiller Foundation. License notice.
 * Copyright (C) 2021 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.contacts.profile;
 
import java.util.List;
import java.util.Set;
import java.util.function.Predicate;
import java.util.stream.Collectors;
import org.turro.string.Strings;
import org.turro.action.Actions;
import org.turro.action.Contacts;
import org.turro.assistant.ParticipationInfo;
import org.turro.auth.Authentication;
import org.turro.contacts.BusinessRelation;
import org.turro.contacts.Contact;
import org.turro.contacts.ContactService;
import org.turro.contacts.JobBoard;
import org.turro.contacts.db.ContactsPU;
import org.turro.contacts.relation.Business;
import org.turro.contacts.relation.Relations;
import org.turro.elephant.context.Application;
import org.turro.elephant.context.IConstructor;
import org.turro.elephant.entities.db.Skill;
import org.turro.elephant.entities.db.SkillType;
import org.turro.elephant.impl.repository.RepositoryFile;
import org.turro.elephant.impl.util.Files;
import org.turro.elephant.security.IUser;
import org.turro.elephant.util.Images;
import org.turro.entities.Controls;
import org.turro.entities.Entities;
import org.turro.entities.IElephantEntity;
import org.turro.file.util.FileAttach;
import org.turro.participation.ParticipationReason;
import org.turro.plugin.contacts.IContact;
import org.turro.plugin.contacts.IContactRelation;
import org.turro.plugin.contacts.IProfile;
import org.turro.skills.Skills;
 
public class Profile implements IProfile {
 
  public final static String PHONE = "PhoneProfile",
                             WEB = "Web",
                             NETWORK = "NetworkProfile";
  
  private final IContact contact;
  private final Business business;
  private final List<ProfileRelation> companies, learningCenters;
  private final ProfilePolicies policies;
  private final PublishPolicy policy;
  private final List<Skill> knowledge, functional, attitude, sector, specialty;
  
  private boolean edit = false;
 
  public Profile(Contact contact) {
    this(contact, null);
  }
  
  public Profile(Contact contact, boolean edit) {
    this(contact, null);
    this.edit = edit;
  }
  
  public Profile(Contact contact, PublishPolicy policy) {
    this.contact = Contacts.getContact(contact);
    this.policies = new ProfilePolicies(contact);
    this.policy = policy == null ? takeRequiredFromLogged() : policy;
    this.business = contact.getBusinessSet();
    this.companies = loadCompanies();
    this.learningCenters = loadLearningCenters();
    this.knowledge = loadKnowledge();
    this.functional = loadFunctional();
    this.attitude = loadAttitude();
    this.sector = loadSector();
    this.specialty = loadSpecialty();
  }
 
  @Override
  public IContact getContact() {
    return contact;
  }
  
  @Override
  public boolean getHasImage() {
    return Files.exists(contact.getFace());
  }
  
  @Override
  public String getImage() {
    return Images.getImageOrNull(contact.getFace());
  }
  
  @Override
  public String getImageOrDefault() {
    return Images.getImageOrDefault(contact.getFace());
  }
  
  @Override
  public String getEntityPath() {
    return ContactsPU.getObjectPath(contact.getContact());
  }
  
  @Override
  public boolean getHasName() {
    return !Strings.isBlank(getFinalName());
  }
  
  @Override
  public String getName() {
    return contact.getName();
  }
  
  @Override
  public String getTradeName() {
    return contact.getConnector(IUser.CONNECTOR_TRADE);
  }
  
  @Override
  public String getFinalName() {
    return Strings.isBlank(getTradeName(), getName());
  }
  
  @Override
  public boolean getHasEmail() {
    return !Strings.isBlank(getEmail()) && (isBusiness() || policies.getPolicy(null, "email").allows(policy));
  }
  
  @Override
  public String getEmail() {
    return contact.getEmail();
  }
  
  @Override
  public boolean getHasWeb() {
    return !Strings.isBlank(getWeb()) && (isBusiness() || ProfileContext.getWebOnUsers());
  }
  
  @Override
  public String getWeb() {
    return contact.getConnector(WEB);
  }
  
  @Override
  public boolean getHasPhone() {
    return !Strings.isBlank(getPhone()) && (isBusiness() || policies.getPolicy(null, "phone").allows(policy));
  }
  
  @Override
  public String getPhone() {
    return contact.getConnector(PHONE);
  }
  
  @Override
  public boolean getHasNetwork() {
    return !Strings.isBlank(getNetwork());
  }
  
  @Override
  public String getNetwork() {
    return contact.getConnector(NETWORK);
  }
  
  @Override
  public boolean getHasAbout() {
    return !Strings.isBlank(getAbout());
  }
  
  @Override
  public String getAbout() {
    return contact.getCommentValue("#cv");
  }
  
  private RepositoryFile publicDocs;
  
  public boolean getHasDocuments() {
    if(publicDocs == null) {
      IElephantEntity iee = Entities.getController(contact.getContact());
      FileAttach files = (FileAttach) iee.getControl(Controls.CTRL_FILES, iee.getPath(), contact);
      if(files != null) publicDocs = files.getPublishableRepository(Application.getApplication().getConstructor()).getRoot("/public");
    }
    return publicDocs != null && publicDocs.hasContent();
  }
  
  public RepositoryFile getDocuments() {
    return getHasDocuments() ? publicDocs : null;
  }
  
  public boolean getHasServices() {
    return !getServices().isEmpty();
  }
  
  public Set<ContactService> getServices() {
    return ((Contact) contact.getContact()).getServices();
  }
  
  public List<ProfileRelation> getCurrentCompanies() {
    return getCompanies().stream().filter(r -> r.isInRange()).collect(Collectors.toList());
  }
  
  public List<ProfileRelation> getPastCompanies() {
    return getCompanies().stream().filter(r -> !r.isInRange()).collect(Collectors.toList());
  }
  
  public List<ProfileRelation> getCompanies() {
    return isEdit() ? companies : companies.stream().filter(r -> r.isValidated()).collect(Collectors.toList());
  }
  
  public List<ProfileRelation> getCurrentCenters() {
    return getLearningCenters().stream().filter(r -> r.isInRange()).collect(Collectors.toList());
  }
  
  public List<ProfileRelation> getPastCenters() {
    return getLearningCenters().stream().filter(r -> !r.isInRange()).collect(Collectors.toList());
  }
  
  public List<ProfileRelation> getLearningCenters() {
    return isEdit() ? learningCenters : learningCenters.stream().filter(r -> r.isValidated()).collect(Collectors.toList());
  }
  
  public boolean getHasSkills() {
    return isNatural() && 
            (!knowledge.isEmpty() || !functional.isEmpty() || !attitude.isEmpty()) && 
            policies.getPolicy(null, "skills").allows(policy);
  }
  
  public List<Skill> getKnowledge() {
    return knowledge;
  }
 
  public List<Skill> getAttitude() {
    return attitude;
  }
 
  public List<Skill> getFunctional() {
    return functional;
  }
 
  public boolean getHasCSkills() {
    return isJuridical() && (!sector.isEmpty() || !specialty.isEmpty());
  }
 
  public List<Skill> getSector() {
    return sector;
  }
 
  public List<Skill> getSpecialty() {
    return specialty;
  }
  
  public boolean getHasJobBoard() {
    Contact c = (Contact) contact.getContact();
    return c.getJobBoard() != null && isStudent();
  }
  
  public JobBoard getJobBoard() {
    Contact c = (Contact) contact.getContact();
    return c.getJobBoard();
  }
  
  public PublishPolicy getPolicy(Object entity, String element) {
    return policies.getPolicy(entity, element);
  }
  
  @Override
  public boolean isEdit() {
    return edit;
  }
 
  @Override
  public boolean canBeProfessional() {
    return ProfileContext.hasCompanies() && !hasCurrentRelations();
  }
  
  @Override
  public boolean canBeStudent() {
    return ProfileContext.hasCenters() && !hasCurrentRelations();
  }
  
  @Override
  public boolean canFollow() {
    return !Authentication.isLogged(contact);
  }
  
  public String getFollowCtrl(IConstructor constructor) {
    return Entities.getController(contact.getContact()).parseFollowCtrl(constructor);
  }
  
  public boolean canEdit() {
    return isLoggedSelf() || isLogged(w -> w.isResponsible()) ||
           (isJuridical() && isLoggedAdmin());
  }
  
  public String linkEdit() {
    return contact.isUser() ? "/user/profile" : 
            "/user/profile/editc?" + Actions.createRightNowAction("contact=" + contact.getId());
  }
 
  @Override
  public boolean isInNetworking() {
    return contact.getPermissions().isInRole(ProfileContext.getNetworkingRoles());
  }
  
  @Override
  public boolean isInPremiumNetworking() {
    return contact.getPermissions().isInRole(ProfileContext.getPremiumNetworkingRoles());
  }
  
  @Override
  public boolean isWorker() {
    return !getCurrentCompanies().isEmpty();
  }
  
  @Override
  public boolean isStudent() {
    return !getCurrentCenters().isEmpty();
  }
  
  @Override
  public boolean isResponsible() {
    return getCurrentCenters().stream().anyMatch(r -> r.getRelation().isResponsible());
  }
  
  @Override
  public boolean isCompanyHHRR() {
    return getCurrentCompanies().stream().anyMatch(r -> r.getRelation().isHHRR());
  }
  
  @Override
  public boolean isCenterHHRR() {
    return getCurrentCenters().stream().anyMatch(r -> r.getRelation().isHHRR());
  }
  
  @Override
  public boolean isHHRR() {
    return isCompanyHHRR() || isCenterHHRR();
  }
  
  public boolean isNatural() {
    return !isJuridical();
  }
  
  public boolean isJuridical() {
    return contact.isCompany() || contact.isCenter();
  }
  
  @Override
  public boolean isCompany() {
    return contact.isCompany();
  }
  
  @Override
  public boolean isCenter() {
    return contact.isCenter();
  }
  
  @Override
  public boolean isSingleton() {
    return getCurrentCompanies().isEmpty() && getCurrentCenters().isEmpty();
  }
 
  @Override
  public boolean isTranslator() {
    return !Strings.isBlank(contact.getLangTranslator());
  }
  
  public boolean isLoggedSelf() {
    return Authentication.isLogged(contact);
  }
  
  public boolean isLogged(Predicate<BusinessRelation> predicate) {
    return Authentication.hasContact() &&
            ((Contact) contact.getContact()).getWorkerSet()
            .isByCondition((Contact) Authentication.getIContact().getContact(), predicate);
  }
  
  @Override
  public boolean isShowCompletion() {
    return ProfileContext.getShowCompletion();
  }
  
  public ProfileCompletion getCompletion() {
    return new ProfileCompletion(this);
  }
  
  private boolean hasCurrentRelations() {
    return !(getCurrentCompanies().isEmpty() && getCurrentCenters().isEmpty());
  }
  
  private List<ProfileRelation> loadCompanies() {
    return business.stream().filter(r -> r.isWorker())
            .map(r -> new ProfileRelation(r, policies, policy)).collect(Collectors.toList());
  }
 
  private List<ProfileRelation> loadLearningCenters() {
    return business.stream().filter(r -> r.isStudent())
            .map(r -> new ProfileRelation(r, policies, policy)).collect(Collectors.toList());
  }
  
  private List<Skill> loadKnowledge() {
    return Skills.getSkillsFrom(getEntityPath(), SkillType.SKILL_KNOWLEDGE);
  }
 
  private List<Skill> loadAttitude() {
    return Skills.getSkillsFrom(getEntityPath(), SkillType.SKILL_ATTITUDE);
  }
 
  private List<Skill> loadFunctional() {
    return Skills.getSkillsFrom(getEntityPath(), SkillType.SKILL_FUNCTIONAL);
  }
 
  private List<Skill> loadSector() {
    return Skills.getSkillsFrom(getEntityPath(), SkillType.SKILL_SECTOR);
  }
 
  private List<Skill> loadSpecialty() {
    return Skills.getSkillsFrom(getEntityPath(), SkillType.SKILL_SPECIALTY);
  }
 
  private PublishPolicy takeRequiredFromLogged() {
    IContact logged = Authentication.getIContact();
    if(logged == null || !logged.isValid()) {
      return PublishPolicy.PUBLISH_ALL;
    } else if(logged.equals(contact)) {
      return PublishPolicy.PUBLISH_NONE;
    } else if(new ParticipationInfo(contact, logged, ParticipationReason.REASON_FOLLOW).isChecked()) {
      return PublishPolicy.PUBLISH_FOLLOWING;
    } else {
      return PublishPolicy.PUBLISH_USERS;
    }
  }
 
  private boolean isBusiness() {
    return contact.isCompany() || contact.isCenter();
  }
  
  private boolean isLoggedAdmin() {
    IContact logged = Authentication.getIContact();
    return logged != null && logged.isValid() && logged.isAdmin();
  }
 
  @Override
  public IContactRelation getCompanyRelation() {
    return Relations.companies(contact).getCompanyRelation();
  }  
  
}