provider/Projects.java

Go to the documentation of this file.

/*
 * Turró i Cutiller Foundation. License notice.
 * Copyright (C) 2023 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.alliance.provider;
 
import org.turro.alliance.content.control.Participations;
import org.turro.alliance.db.AlliancePU;
import org.turro.alliance.db.entities.AxParticipation;
import org.turro.alliance.db.entities.AxProject;
import org.turro.alliance.db.entities.RelationId;
import org.turro.jpa.Dao;
import org.turro.json.Jsons;
import org.turro.server.db.entities.AxAllianceParticipation;
import org.turro.server.db.entities.AxParticipationRequest;
import org.turro.sql.SqlClause;
import org.turro.string.Strings;
import org.turro.util.Cached;
import org.turro.ws.WsMember;
 
public class Projects {
 
  public Jsons project(String projectId) {
    AxProject project = SqlClause.select("p").from("AxProject p")
            .where().equal("id", projectId)
            .dao(dao.get())
            .singleResult(AxProject.class);
    return Jsons.read(project.toJson());
  }  
 
  public Jsons participations(String projectId) {
    Jsons participations = Jsons.array();
    SqlClause.select("p").from("AxParticipation p")
            .where().equal("id", projectId)
            .dao(dao.get())
            .resultList(AxParticipation.class)
            .forEach(p -> {
              participations.addValue(Jsons.read(p.toJson()));
            });
    return participations;
  }  
 
  public Jsons axParticipations(String projectId, String as) {
    Jsons participations = Jsons.array();
    SqlClause.select("p").from("AxAllianceParticipation p")
            .where().equal("id", correctId(projectId))
            .startIf(!Strings.isBlank(as))
            .and().isTrue(Strings.lowerCase(as))
            .endIf()
            .dao(dao.get())
            .resultList(AxAllianceParticipation.class)
            .forEach(p -> {
              participations.addValue(Jsons.read(p.toJson()));
            });
    return participations;
  }  
 
  public Jsons axPendingParticipations() {
    Jsons participations = Jsons.array();
    SqlClause.select("p").from("AxParticipationRequest p")
            .where().equal("mainMemberId", member.getMemberId())
            .dao(dao.get())
            .resultList(AxParticipationRequest.class)
            .forEach(p -> {
              participations.addValue(Jsons.read(p.toJson()));
            });
    return participations;
  }  
 
  public Jsons axAllParticipations(String projectId) {
    Jsons participations = Jsons.array();
    SqlClause.select("p").from("AxParticipationRequest p")
            .where().equal("id", correctId(projectId))
            .dao(dao.get())
            .resultList(AxParticipationRequest.class)
            .forEach(p -> {
              participations.addValue(Jsons.read(p.toJson()));
            });
    SqlClause.select("p").from("AxAllianceParticipation p")
            .where().equal("id", correctId(projectId))
            .dao(dao.get())
            .resultList(AxAllianceParticipation.class)
            .forEach(p -> {
              participations.addValue(Jsons.read(p.toJson()));
            });
    return participations;
  }  
 
  public Jsons axFullParticipations() {
    Jsons participations = Jsons.array();
    SqlClause.select("p").from("AxParticipationRequest p")
            .where().equal("mainMemberId", member.getMemberId())
            .or().equal("relatedMemberId", member.getMemberId())
            .orderBy("p.creation desc")
            .dao(dao.get())
            .resultList(AxParticipationRequest.class)
            .forEach(p -> {
              participations.addValue(Jsons.read(p.toJson()));
            });
    SqlClause.select("p").from("AxAllianceParticipation p")
            .where().equal("mainMemberId", member.getMemberId())
            .or().equal("relatedMemberId", member.getMemberId())
            .orderBy("p.creation desc")
            .dao(dao.get())
            .resultList(AxAllianceParticipation.class)
            .forEach(p -> {
              participations.addValue(Jsons.read(p.toJson()));
            });
    return participations;
  }  
 
  public void axAskParticipate(Jsons request) {
    AxParticipationRequest axp = new AxParticipationRequest();
    RelationId ri = new RelationId();
    ri.setRelatedEntityId(request.getString("contactId"));
    ri.setRelatedMemberId(member.getMemberId());
    axp.setRelation(ri);
    axp.setId(request.getString("axId"));
    switch(request.getString("as")) {
      case "Beneficiary" -> axp.setBeneficiary(true);
      case "Offerer" -> axp.setOfferer(true);
      case "Consortium" -> axp.setConsortium(true);
    }
    axp.setName(request.getString("contactName"));
    axp.setFace(request.getString("contactFace"));
    axp.setCompany(request.getString("companyName"));
    axp.setCompanyFace(request.getString("companyFace"));
    axp.setMemberName(member.getContact().getTradeName());
    Participations.from(axp).add();
  }  
 
  public boolean isParticipant(Jsons request) {
    return !SqlClause.select("p").from("AxAllianceParticipation p")
            .where().equal("id", request.getString("axId"))
            .and().equal("relatedEntityId", request.getString("contactId"))
            .and().equal("relatedMemberId", member.getMemberId())
            .and().isTrue(request.getString("as").toLowerCase())
            .dao(dao.get())
            .resultList(AxAllianceParticipation.class).isEmpty();
  }
  
  public boolean hasRequested(Jsons request) {
    return !SqlClause.select("p").from("AxParticipationRequest p")
            .where().equal("id", request.getString("axId"))
            .and().equal("relatedEntityId", request.getString("contactId"))
            .and().equal("relatedMemberId", member.getMemberId())
            .and().isTrue(request.getString("as").toLowerCase())
            .dao(dao.get())
            .resultList(AxParticipationRequest.class).isEmpty();
  }
  
  public boolean save(Jsons request) {
    AxAllianceParticipation ap = AxAllianceParticipation.fromJson(request.asJsonValue());
    dao.get().saveObject(ap);
    return true;
  }
  
  public void axValidatePending(Jsons axPending) {
    AxParticipationRequest pr = AxParticipationRequest.fromJson(axPending.asJsonValue());
    Participations.from(pr).validate();
    dao.get().deleteObject(pr);
  }
  
  public void axDeleteParticipation(Jsons axRequest) {
    if(axRequest.getBoolean("validated")) {
      AxAllianceParticipation ap = AxAllianceParticipation.fromJson(axRequest.asJsonValue());
      dao.get().deleteObject(ap);
    } else {
      AxParticipationRequest pr = AxParticipationRequest.fromJson(axRequest.asJsonValue());
      dao.get().deleteObject(pr);
    }
  }
  
  /* Utils */
  
  private String correctId(String axId) {
    if(!Strings.isBlank(axId) && !axId.contains("##")) {
      axId += "##" + member.getMemberId();
    }
    return axId;
  }
 
  /* Dao */
  
  private final Cached<Dao> dao = Cached.instance(() -> new AlliancePU());
 
  /* Factory */
  
  public static Projects from(WsMember member) {
    return new Projects(member);
  }
  
  private final WsMember member;
 
  private Projects(WsMember member) {
    this.member = member;
  }  
 
}