nc.noumea.mairie.appock.services.impl.CatalogueServiceImpl.java Source code

Java tutorial

Introduction

Here is the source code for nc.noumea.mairie.appock.services.impl.CatalogueServiceImpl.java

Source

package nc.noumea.mairie.appock.services.impl;

/*-
 * #%L
 * Logiciel de Gestion des approvisionnements et des stocks des fournitures administratives de la Mairie de Nouma
 * %%
 * Copyright (C) 2017 Mairie de Nouma, Nouvelle-Caldonie
 * %%
 * This program is free software: you can redistribute it and/or modify
 * it under the terms of the GNU 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 General Public License for more details.
 *
 * You should have received a copy of the GNU General Public
 * License along with this program.  If not, see
 * <http://www.gnu.org/licenses/gpl-3.0.html>.
 * #L%
 */

import nc.noumea.mairie.appock.core.services.impl.GenericServiceImpl;
import nc.noumea.mairie.appock.core.utility.AppockUtil;
import nc.noumea.mairie.appock.entity.*;
import nc.noumea.mairie.appock.enums.EtatCatalogue;
import nc.noumea.mairie.appock.enums.TypeCatalogueNode;
import nc.noumea.mairie.appock.repositories.CatalogueRepository;
import nc.noumea.mairie.appock.repositories.MimeTypeRepository;
import nc.noumea.mairie.appock.repositories.PhotoArticleCatalogueRepository;
import nc.noumea.mairie.appock.services.CatalogueService;
import nc.noumea.mairie.appock.services.ConfigService;
import nc.noumea.mairie.appock.services.FavoriService;
import nc.noumea.mairie.appock.services.ImportExcelService;
import nc.noumea.mairie.appock.util.CatalogueTreeNode;
import org.apache.commons.io.FileUtils;
import org.apache.commons.lang.StringUtils;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.context.annotation.Scope;
import org.springframework.context.annotation.ScopedProxyMode;
import org.springframework.data.repository.CrudRepository;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;
import org.zkoss.util.media.Media;

import java.io.File;
import java.io.IOException;
import java.util.List;

@Service("catalogueService")
@Scope(value = "singleton", proxyMode = ScopedProxyMode.TARGET_CLASS)
@Transactional
public class CatalogueServiceImpl extends GenericServiceImpl<Catalogue> implements CatalogueService {

    private static Logger log = LoggerFactory.getLogger(CatalogueServiceImpl.class);

    @Autowired
    CatalogueRepository catalogueRepository;

    @Autowired
    MimeTypeRepository mimeTypeRepository;

    @Autowired
    PhotoArticleCatalogueRepository photoArticleCatalogueRepository;

    @Autowired
    ConfigService configService;

    @Autowired
    FavoriService favoriService;

    @Autowired
    ImportExcelService importExcelService;

    @Override
    public CrudRepository getRepository() {
        return catalogueRepository;
    }

    @Override
    public Catalogue findOne(Long id) {
        Catalogue catalogue = catalogueRepository.findOne(id);
        initLazyListeFamilleSousFamilleEtArticleCatalogue(catalogue);
        return catalogue;
    }

    @Override
    public Catalogue findActif() {
        Catalogue catalogue = catalogueRepository.findFirstByEtatCatalogue(EtatCatalogue.ACTIF);
        if (catalogue == null) {
            return null;

        }
        initLazyListeFamilleSousFamilleEtArticleCatalogue(catalogue);
        return catalogue;
    }

    @Override
    public List<String> importCatalogue(Media media, Catalogue catalogue) throws IOException {
        return importExcelService.importCatalogue(media, catalogue);
    }

    @Override
    public PhotoArticleCatalogue savePhotoArticleCatalogue(byte[] content, String nomFichier) throws IOException {
        PhotoArticleCatalogue photoArticleCatalogue = new PhotoArticleCatalogue();
        photoArticleCatalogue.setNomFichier(nomFichier);
        photoArticleCatalogue.setContenu(content);
        photoArticleCatalogue.setMimeType(mimeTypeRepository.findFirstByLibelle(AppockUtil.getMimeType(content)));

        photoArticleCatalogue = photoArticleCatalogueRepository.save(photoArticleCatalogue);

        creeFichierCoteServeur(photoArticleCatalogue);

        return photoArticleCatalogue;
    }

    private void creeFichierCoteServeur(PhotoArticleCatalogue photoArticleCatalogue) throws IOException {
        if (photoArticleCatalogue.getContenu() == null) {
            return;
        }

        FileUtils.writeByteArrayToFile(getFilePieceJointe(photoArticleCatalogue),
                photoArticleCatalogue.getContenu());
    }

    @Override
    public File getFilePieceJointe(PhotoArticleCatalogue photoArticleCatalogue) {
        if (photoArticleCatalogue == null || photoArticleCatalogue.getId() == null) {
            throw new IllegalArgumentException("photoArticle null ou sans id : " + photoArticleCatalogue);
        }
        return new File(configService.getPieceJointeDir() + File.separatorChar + photoArticleCatalogue.getId());
    }

    @Override
    public CatalogueTreeNode getCatalogueTreeRoot(Catalogue catalogue, boolean uniquementFavoris,
            boolean uniquementActif, boolean uniquementNonVide, String recherche) {
        List<ArticleCatalogue> listeArticleCatalogueFavori = favoriService.findAllArticleCatalogueFavori();
        CatalogueTreeNode root = new CatalogueTreeNode(null, "", null, null, null, 0);

        for (Famille famille : catalogue.getListeFamille()) {
            int nombreArticleFamille = 0;
            for (SousFamille sousFamille : famille.getListeSousFamille()) {
                nombreArticleFamille += calculeNombreArticleSousFamille(uniquementFavoris, uniquementActif,
                        listeArticleCatalogueFavori, sousFamille, recherche);
            }
            CatalogueTreeNode rootFamille = new CatalogueTreeNode(root, famille.getLibelle(), famille.getId(),
                    TypeCatalogueNode.FAMILLE, famille, nombreArticleFamille);
            for (SousFamille sousFamille : famille.getListeSousFamille()) {
                int nombreArticleSousFamille = calculeNombreArticleSousFamille(uniquementFavoris, uniquementActif,
                        listeArticleCatalogueFavori, sousFamille, recherche);
                CatalogueTreeNode rootSousFamille = new CatalogueTreeNode(rootFamille, sousFamille.getLibelle(),
                        sousFamille.getId(), TypeCatalogueNode.SOUS_FAMILLE, sousFamille, nombreArticleSousFamille);

                sousFamille.getListeArticleCatalogue().forEach(this::initPhotoSrc);

                if (!uniquementNonVide || (uniquementNonVide && nombreArticleSousFamille != 0)) {
                    rootFamille.appendChild(rootSousFamille);
                }
            }
            if (!uniquementNonVide || (uniquementNonVide && nombreArticleFamille != 0)) {
                root.appendChild(rootFamille);
            }
        }
        return root;
    }

    /**
     * Permet de calculer le nombre d'articles pour une sous-famille (en prenant en compte uniquement les favoris et/ou uniquement les actifs
     *
     * @param uniquementFavori            on souhaite uniquement les favoris ou non
     * @param uniquementActif             on souhaite uniquement les actifs ou non
     * @param listeArticleCatalogueFavori la liste des articles favoris de l'utilisateur
     * @param sousFamille                 la sous famille pour laquelle on souhaite le nombre d'article
     * @param recherche                   texte facultatif de recherche sur une rfrence ou un libell d'article
     * @return le nombre d'article pour une sous famille (en prenant en compte uniquement les favoris et/ou uniquement les actifs
     */
    private int calculeNombreArticleSousFamille(boolean uniquementFavori, boolean uniquementActif,
            List<ArticleCatalogue> listeArticleCatalogueFavori, SousFamille sousFamille, String recherche) {
        return (int) sousFamille.getListeArticleCatalogue().stream().filter(articleCatalogue -> {
            // filtr car critre de recherche non trouv
            if (StringUtils.isNotBlank(recherche) && !articleCatalogue.getLibelle().contains(recherche)
                    && !articleCatalogue.getReference().contains(recherche)) {
                return false;
            }
            if (uniquementFavori && !listeArticleCatalogueFavori.contains(articleCatalogue)) {
                return false; // filtr car pas favori
            }
            if (uniquementActif && !articleCatalogue.isActif()) {
                return false; // filtr car pas actif
            }
            return true; // ok, compt
        }).count();
    }

    @Override
    public void initPhotoSrc(ArticleCatalogue articleCatalogue) {
        if (articleCatalogue.getPhotoArticleCatalogue() != null) {
            File fichierPhotoArticle = this.getFilePieceJointe(articleCatalogue.getPhotoArticleCatalogue());
            try {
                articleCatalogue.setPhotoSrc(AppockUtil.readFileToBase64(fichierPhotoArticle));
            } catch (IOException e) {
                log.error("IOEXception : " + e);
            }
        }
    }

    private void initLazyListeFamilleSousFamilleEtArticleCatalogue(Catalogue catalogue) {
        AppockUtil.chargeCollection(catalogue.getListeFamille());
        for (Famille famille : catalogue.getListeFamille()) {
            AppockUtil.chargeCollection(famille.getListeSousFamille());
            for (SousFamille sousFamille : famille.getListeSousFamille()) {
                AppockUtil.chargeCollection(sousFamille.getListeArticleCatalogue());
            }
        }
    }
}