common/securis.git

package net.curisit.securis.services.helpers;

import java.io.File;
import java.io.IOException;
import java.nio.charset.StandardCharsets;
import java.nio.file.Files;
import java.util.Date;
import java.util.HashMap;
import java.util.Map;
import java.util.Set;

import jakarta.enterprise.context.ApplicationScoped;
import jakarta.inject.Inject;
import jakarta.persistence.EntityManager;
import jakarta.persistence.TypedQuery;

import org.apache.commons.io.FileUtils;
import org.apache.logging.log4j.LogManager;
import org.apache.logging.log4j.Logger;

import net.curisit.integrity.exception.CurisRuntimeException;
import net.curisit.securis.beans.LicenseBean;
import net.curisit.securis.db.License;
import net.curisit.securis.db.LicenseHistory;
import net.curisit.securis.db.LicenseStatus;
import net.curisit.securis.db.Pack;
import net.curisit.securis.db.PackMetadata;
import net.curisit.securis.db.User;
import net.curisit.securis.security.BasicSecurityContext;
import net.curisit.securis.services.exception.SeCurisServiceException;
import net.curisit.securis.services.exception.SeCurisServiceException.ErrorCodes;

@ApplicationScoped
public class LicenseHelper {

    @SuppressWarnings("unused")
    private static final Logger LOG = LogManager.getLogger(LicenseHelper.class);
    private static final long MS_PER_DAY = 24L * 3600L * 1000L;

    @Inject
    private UserHelper userHelper;

    /**
     * Cancel the license
     * 
     * @param lic
     * @param em
     */
    public void cancelLicense(License lic, String reason, BasicSecurityContext bsc, EntityManager em) throws SeCurisServiceException {
        lic.setStatus(LicenseStatus.CANCELLED);
        lic.setCancelledById(bsc.getUserPrincipal().getName());
        lic.setModificationTimestamp(new Date());
        em.persist(lic);

        em.persist(createLicenseHistoryAction(lic, userHelper.getUser(bsc, em), LicenseHistory.Actions.CANCEL, "Cancellation reason: " + reason));
    }

    /**
     * Validates that the passed license exists and is still valid
     * 
     * @param licBean
     * @param em
     * @return The License instance in DB
     * @throws SeCurisServiceException
     */
    public License getActiveLicenseFromDB(LicenseBean licBean, EntityManager em) throws SeCurisServiceException {
        License lic = License.findLicenseByCode(licBean.getLicenseCode(), em);
        if (lic == null) {
            throw new SeCurisServiceException(ErrorCodes.LICENSE_DATA_IS_NOT_VALID, "Current license code doesn't exist");
        }
        if (lic.getStatus() != LicenseStatus.ACTIVE && lic.getStatus() != LicenseStatus.PRE_ACTIVE) {
            throw new SeCurisServiceException(ErrorCodes.LICENSE_DATA_IS_NOT_VALID, "Current license in not active");
        }
        return lic;
    }

    public LicenseHistory createLicenseHistoryAction(License lic, User user, String action, String comments) {
        LicenseHistory lh = new LicenseHistory();
        lh.setLicense(lic);
        lh.setUser(user);
        lh.setCreationTimestamp(new Date());
        lh.setAction(action);
        lh.setComments(comments);
        return lh;
    }

    public LicenseHistory createLicenseHistoryAction(License lic, User user, String action) {
        return createLicenseHistoryAction(lic, user, action, null);
    }

    /**
     * Create a license file in a temporary directory
     * 
     * @param lic
     * @param licFileName
     * @return
     * @throws IOException
     */
    public File createTemporaryLicenseFile(License lic, String licFileName) throws IOException {
        File f = Files.createTempDirectory("securis-server").toFile();
        f = new File(f, licFileName);
        FileUtils.writeStringToFile(f, lic.getLicenseData(), StandardCharsets.UTF_8);
        return f;
    }

    public Map<String, Object> extractPackMetadata(Set<PackMetadata> packMetadata) {
        Map<String, Object> metadata = new HashMap<>();
        for (PackMetadata md : packMetadata) {
            metadata.put(md.getKey(), md.getValue());
        }

        return metadata;
    }

    /**
     * If the action is a renew the expiration date is got form pack end valid
     * date, if the action is a pre-activation the expiration date is calculated
     * using the pack default valid period
     * 
     * @param pack
     * @param isPreActivation
     * @return
     */
    public Date getExpirationDateFromPack(Pack pack, boolean isPreActivation) {
        Long validPeriod;
        if (pack.getEndValidDate().before(new Date())) {
            throw new CurisRuntimeException("Pack end valid period is reached, no new licenses can be activated.");
        }
        if (isPreActivation) {
            validPeriod = pack.getPreactivationValidPeriod() * MS_PER_DAY;
        } else {
            if (pack.getRenewValidPeriod() <= 0) {
                return pack.getEndValidDate();
            }
            long renewPeriod = pack.getRenewValidPeriod() * MS_PER_DAY;
            long expirationPeriod = pack.getEndValidDate().getTime() - new Date().getTime();
            validPeriod = renewPeriod < expirationPeriod ? renewPeriod : expirationPeriod;
        }
        Date expirationDate = new Date(new Date().getTime() + validPeriod);
        return expirationDate;
    }

    /**
     * Get the next free code suffis for a given Pack
     * 
     * @param packId
     * @param em
     * @return
     */
    public int getNextCodeSuffix(int packId, EntityManager em) {
        TypedQuery<Integer> query = em.createNamedQuery("last-code-suffix-used-in-pack", Integer.class);
        query.setParameter("packId", packId);
        Integer lastCodeSuffix = query.getSingleResult();
        return lastCodeSuffix == null ? 1 : lastCodeSuffix + 1;
    }

}