Subversion Repositories Integrator Subversion

package br.com.ec.domain.service.impl;

import java.io.ByteArrayInputStream;

import java.io.ByteArrayOutputStream;

import java.io.FileNotFoundException;

import java.io.IOException;

import java.io.InputStream;

import java.util.ArrayList;

import java.util.Iterator;

import java.util.List;

import javax.faces.context.FacesContext;

import org.apache.poi.hssf.usermodel.HSSFSheet;

import org.apache.poi.hssf.usermodel.HSSFWorkbook;

import org.apache.poi.ss.usermodel.Cell;

import org.apache.poi.ss.usermodel.Row;

import org.primefaces.model.DefaultStreamedContent;

import org.primefaces.model.StreamedContent;

import org.springframework.beans.factory.annotation.Autowired;

import org.springframework.stereotype.Service;

import br.com.ec.core.exception.NegocioException;

import br.com.ec.core.generic.AbstractService;

import br.com.ec.core.generic.GenericRepository;

import br.com.ec.core.util.ArquivoUtil;

import br.com.ec.core.util.StringUtil;

import br.com.ec.core.util.VerificadorUtil;

import br.com.ec.core.validador.Validador;

import br.com.ec.domain.dto.AvaliacaoDTO;

import br.com.ec.domain.dto.AvaliacaoFuncionarioDTO;

import br.com.ec.domain.dto.AvaliacaoLojaDTO;

import br.com.ec.domain.dto.AvaliacaoLojaFuncionarioDTO;

import br.com.ec.domain.dto.FolhaPagamentoFuncionarioDTO;

import br.com.ec.domain.dto.FuncionarioDTO;

import br.com.ec.domain.dto.LojaDTO;

import br.com.ec.domain.dto.VigenciaDTO;

import br.com.ec.domain.model.Avaliacao;

import br.com.ec.domain.model.AvaliacaoFuncionario;

import br.com.ec.domain.model.AvaliacaoFuncionarioId;

import br.com.ec.domain.model.AvaliacaoLoja;

import br.com.ec.domain.model.AvaliacaoProduto;

import br.com.ec.domain.model.Funcionario;

import br.com.ec.domain.model.Loja;

import br.com.ec.domain.model.Produto;

import br.com.ec.domain.model.Vigencia;

import br.com.ec.domain.model.tipos.TipoComissionamento;

import br.com.ec.domain.service.AvaliacaoFuncionarioService;

import br.com.ec.domain.service.AvaliacaoLojaService;

import br.com.ec.domain.service.AvaliacaoProdutoService;

import br.com.ec.domain.service.AvaliacaoService;

import br.com.ec.domain.service.FuncionarioService;

import br.com.ec.domain.service.LojaService;

import br.com.ec.domain.service.ProdutoService;

import br.com.ec.repository.AvaliacaoRepository;

@Service

public class AvaliacaoServiceImpl extends AbstractService<Avaliacao> implements AvaliacaoService {

        private AvaliacaoRepository avaliacaoRepository;

        private ProdutoService produtoService;

        private AvaliacaoProdutoService avaliacaoProdutoService;

        private AvaliacaoLojaService avaliacaoLojaService;

        private AvaliacaoFuncionarioService avaliacaoFuncionarioService;

        private FuncionarioService funcionarioService;

        private LojaService lojaService;

        @Autowired

        public AvaliacaoServiceImpl(Validador validador, AvaliacaoRepository avaliacaoRepository,

                        ProdutoService produtoService, AvaliacaoProdutoService avaliacaoProdutoService,

                        AvaliacaoLojaService avaliacaoLojaService, AvaliacaoFuncionarioService avaliacaoFuncionarioService,

                        FuncionarioService funcionarioService, LojaService lojaService) {

                super(validador);

                this.avaliacaoRepository = avaliacaoRepository;

                this.produtoService = produtoService;

                this.avaliacaoProdutoService = avaliacaoProdutoService;

                this.avaliacaoLojaService = avaliacaoLojaService;

                this.avaliacaoFuncionarioService = avaliacaoFuncionarioService;

                this.funcionarioService = funcionarioService;

                this.lojaService = lojaService;

        }

        @Override

        protected GenericRepository<Avaliacao> getRepository() {

                return avaliacaoRepository;

        }

        @Override

        public AvaliacaoDTO consultarAvaliacao(Long sequencialVigencia) {

                return avaliacaoRepository.consultarAvaliacao(sequencialVigencia);

        }

        @Override

        public List<AvaliacaoProduto> consultarProdutosPromocaoInterna(Long sequencialAvaliacao) {

                return avaliacaoRepository.consultarProdutosPromocaoInterna(sequencialAvaliacao);

        }

        @Override

        public void excluirProdutoPromocaoInterna(AvaliacaoProduto avaliacaoProduto) {

                avaliacaoRepository.excluirProdutoPromocaoInterna(avaliacaoProduto);

        }

        @Override

        public void cadastrarProdutoPromocaoInterna(Avaliacao avaliacao, String codigoProduto) {

                Produto produto = produtoService.consultarProdutoPorCodigo(codigoProduto);

                if (VerificadorUtil.estaNulo(produto)) {

                        throw new NegocioException("Produto não identificado");

                }

                AvaliacaoProduto avaliacaoProduto = new AvaliacaoProduto();

                avaliacaoProduto.setProduto(produto);

                avaliacaoProduto.setAvaliacao(avaliacaoRepository.consultarPorId(avaliacao));

                avaliacaoProdutoService.cadastrar(avaliacaoProduto);

        }

        @Override

        public AvaliacaoDTO consultarAvaliacaoCompleta(Long sequencialAvaliacao) {

                List<AvaliacaoLojaFuncionarioDTO> avaliacaoLojaFuncionarioDTOs = new ArrayList<AvaliacaoLojaFuncionarioDTO>();

                AvaliacaoDTO avaliacaoDetalhada = avaliacaoRepository.consultarAvaliacaoDetalhada(sequencialAvaliacao);

                // CONSULTAR AVALIAÇÕES DAS LOJAS

                List<AvaliacaoLojaDTO> avaliacoesLojas = avaliacaoLojaService.consultarAvaliacaoLojaDaAvaliacao(avaliacaoDetalhada.getSequencial());

                // CONSULTAR AVALIAÇÕES DOS FUNCIONÁRIOS

                for (AvaliacaoLojaDTO avaliacaoLojaDTO : avaliacoesLojas) {

                        AvaliacaoLojaFuncionarioDTO avaliacaoLojaFuncionarioDTO = new AvaliacaoLojaFuncionarioDTO();

                        avaliacaoLojaFuncionarioDTO.setLoja(avaliacaoLojaDTO);

                        avaliacaoLojaFuncionarioDTO.setObservacao(avaliacaoLojaDTO.getObservacao());

                        avaliacaoLojaFuncionarioDTO.setValorMetaMensal(avaliacaoLojaDTO.getValorMetaMensal());

                        avaliacaoLojaFuncionarioDTO.setValorMargemContribuicao(avaliacaoLojaDTO.getValorMargemContribuicao());

                        List<AvaliacaoFuncionarioDTO> avaliacaoFuncionarioDTOs = avaliacaoFuncionarioService.consultarAvaliacoesFuncionarioDaLoja(avaliacaoLojaDTO.getAvaliacaoDTO().getSequencial(), avaliacaoLojaDTO.getLojaDTO().getSequencial());

                        // CONSULTAR DADOS COMPLETOS (FUNCIONARIO E USUARIO)

                        for (AvaliacaoFuncionarioDTO avaliacaoFuncionarioDTO : avaliacaoFuncionarioDTOs) {

                                FuncionarioDTO funcionarioDTOConsultado = funcionarioService.consultar(avaliacaoFuncionarioDTO.getSequencialDoFuncionario());

                                avaliacaoFuncionarioDTO.setFuncionarioDTO(funcionarioDTOConsultado);

                        }

                        avaliacaoLojaFuncionarioDTO.setFuncionarios(avaliacaoFuncionarioDTOs);

                        avaliacaoLojaFuncionarioDTOs.add(avaliacaoLojaFuncionarioDTO);

                }

                avaliacaoDetalhada.setAvaliacoesLojas(avaliacaoLojaFuncionarioDTOs);

                return avaliacaoDetalhada;

        }

        @Override

        public void importarAvaliacaoAnterior(VigenciaDTO vigencia, VigenciaDTO vigenciaSelecionadaParaImportar) {

                Avaliacao avaliacaoNova = new Avaliacao();

                avaliacaoNova.setVigencia(new Vigencia(vigencia.getSequencial()));

                this.cadastrar(avaliacaoNova);

                AvaliacaoDTO avaliacaoAnterior = this.consultarAvaliacao(vigenciaSelecionadaParaImportar.getSequencial());

                avaliacaoAnterior = this.consultarAvaliacaoCompleta(avaliacaoAnterior.getSequencial());

                List<AvaliacaoLoja> lojasParticipantesNovas = new ArrayList<AvaliacaoLoja>();

                List<AvaliacaoFuncionario> participantesNovos = new ArrayList<AvaliacaoFuncionario>();

                for (AvaliacaoLojaFuncionarioDTO avaliacaoLojaFuncionarioDTO : avaliacaoAnterior.getAvaliacoesLojas()) {

                        AvaliacaoLoja avaliacaoLojaNovo = new AvaliacaoLoja();

                        avaliacaoLojaNovo.setAvaliacao(avaliacaoNova);

                        avaliacaoLojaNovo.setLoja(new Loja(avaliacaoLojaFuncionarioDTO.getLoja().getLojaDTO().getSequencial()));

                        avaliacaoLojaNovo.setValorMetaMensal(avaliacaoLojaFuncionarioDTO.getValorMetaMensal());

                        avaliacaoLojaNovo.setValorMargemContribuicao(avaliacaoLojaFuncionarioDTO.getValorMargemContribuicao());

                        lojasParticipantesNovas.add(avaliacaoLojaNovo);

                        for (AvaliacaoFuncionarioDTO avaliacaoFuncionarioDTO : avaliacaoLojaFuncionarioDTO.getFuncionarios()) {

                                AvaliacaoFuncionario avaliacaoFuncionarioNovo = new AvaliacaoFuncionario();

                                avaliacaoFuncionarioNovo.setAvaliacao(avaliacaoNova);

                                avaliacaoFuncionarioNovo.setFuncionario(new Funcionario(avaliacaoFuncionarioDTO.getSequencialDoFuncionario()));

                                avaliacaoFuncionarioNovo.setLoja(new Loja(avaliacaoFuncionarioDTO.getSequencialDaLoja()));

                                avaliacaoFuncionarioNovo.setValorMetaMensal(avaliacaoFuncionarioDTO.getValorMetaMensal());

                                participantesNovos.add(avaliacaoFuncionarioNovo);

                        }

                }

                avaliacaoNova.getParticipantes().addAll(participantesNovos);

                avaliacaoNova.getLojasParticipantes().addAll(lojasParticipantesNovas);

                this.alterar(avaliacaoNova);

        }

        @Override

        public void adicionarLojaNaAvaliacao(AvaliacaoDTO avaliacao, LojaDTO lojaParticipante) {

                // VERIFICAR SE LOJA JÁ CONTA NA AVALIAÇÃO

                for (AvaliacaoLojaFuncionarioDTO avaliacaoLojaFuncionarioDTO : avaliacao.getAvaliacoesLojas()) {

                        if (avaliacaoLojaFuncionarioDTO.getLoja().getLojaDTO().getSequencial().equals(lojaParticipante.getSequencial())) {

                                throw new NegocioException("LOJA JÁ PRESENTE NA AVALIAÇÃO");

                        }

                }

                AvaliacaoLoja avaliacaoLoja = new AvaliacaoLoja();

                avaliacaoLoja.setAvaliacao(consultarPorId(new Avaliacao(avaliacao.getSequencial())));

                avaliacaoLoja.setLoja(lojaService.consultarPorId(new Loja(lojaParticipante.getSequencial())));

                avaliacaoLojaService.cadastrar(avaliacaoLoja);

        }

        @Override

        public void removerLojaDaAvaliacao(AvaliacaoDTO avaliacao, LojaDTO lojaParticipante) {

                AvaliacaoLoja avaliacaoLoja = new AvaliacaoLoja();

                avaliacaoLoja.setAvaliacao(consultarPorId(new Avaliacao(avaliacao.getSequencial())));

                avaliacaoLoja.setLoja(lojaService.consultarPorId(new Loja(lojaParticipante.getSequencial())));

                avaliacaoLoja = avaliacaoLojaService.consultarPorId(avaliacaoLoja);

                avaliacaoLojaService.excluir(avaliacaoLoja);

        }

        @Override

        public void adicionarParticipanteNaAvaliacao(AvaliacaoDTO avaliacao, LojaDTO lojaParticipante, FuncionarioDTO funcionarioParticipante) {

                // VERIFICAR SE PARTICIPANTE JÁ CONTA NA AVALIAÇÃO

                for (AvaliacaoLojaFuncionarioDTO avaliacaoLojaFuncionarioDTO : avaliacao.getAvaliacoesLojas()) {

                        for (AvaliacaoFuncionarioDTO avaliacaoFuncionarioDTO : avaliacaoLojaFuncionarioDTO.getFuncionarios()) {

                                if (avaliacaoFuncionarioDTO.getFuncionarioDTO().getSequencialFuncionario().equals(funcionarioParticipante.getSequencialFuncionario())) {

                                        throw new NegocioException("FUNCIONÁRIO JÁ PRESENTE NA AVALIAÇÃO");

                                }

                        }

                }

                AvaliacaoFuncionario avaliacaoFuncionario = new AvaliacaoFuncionario();

                avaliacaoFuncionario.setAvaliacao(consultarPorId(new Avaliacao(avaliacao.getSequencial())));

                avaliacaoFuncionario.setLoja(lojaService.consultarPorId(new Loja(lojaParticipante.getSequencial())));

                Funcionario funcionario = new Funcionario(funcionarioParticipante.getSequencialFuncionario());

                avaliacaoFuncionario.setFuncionario(funcionarioService.consultarPorId(funcionario));

                avaliacaoFuncionarioService.cadastrar(avaliacaoFuncionario);

        }

        @Override

        public void removerParticipanteDaAvaliacao(AvaliacaoFuncionarioDTO avaliacaoFuncionarioDTO) {

                AvaliacaoFuncionarioId avaliacaoFuncionarioId = new AvaliacaoFuncionarioId();

                avaliacaoFuncionarioId.setSequencialAvaliacao(avaliacaoFuncionarioDTO.getSequencialDaAvaliacao());

                avaliacaoFuncionarioId.setSequencialFuncionario(avaliacaoFuncionarioDTO.getSequencialDoFuncionario());

                avaliacaoFuncionarioService.excluir(avaliacaoFuncionarioId);

        }

        @Override

        public StreamedContent emitirRelatorioImportacaoFolhaPagamento(AvaliacaoDTO avaliacao) {

                ByteArrayOutputStream baos = new ByteArrayOutputStream();

                try {

                        String caminhoArquivo = "/arquivos_padrao/folhadepagamento_contabilidade.xls";

                        InputStream arquivo = FacesContext.getCurrentInstance().getExternalContext().getResourceAsStream(caminhoArquivo);

                        HSSFWorkbook workbook = new HSSFWorkbook(arquivo);

                        HSSFSheet sheet = workbook.getSheetAt(0);

                        Iterator rowIterator = sheet.rowIterator();

                        while (rowIterator.hasNext()) {

                                Row row = (Row) rowIterator.next();

                                if (row.getRowNum() < 11) {

                                        continue;

                                } else {

                                        Iterator cellIterator = row.cellIterator();

                                        Integer codigoFolha = null;

                                        while (cellIterator.hasNext()) {

                                                Boolean atualizar = true;

                                                Cell cell = (Cell) cellIterator.next();

                                                switch (cell.getColumnIndex()) {

                                                        case 1:

                                                                Integer tipoCelula = cell.getCellType();

                                                                if (tipoCelula.equals(Cell.CELL_TYPE_NUMERIC)) {

                                                                        Double codigo = cell.getNumericCellValue();

                                                                        codigoFolha = codigo.intValue();

                                                                } else {

                                                                        atualizar = false;

                                                                }

                                                                break;

                                                        case 3:

                                                                if (atualizar) {

                                                                        for (AvaliacaoLojaFuncionarioDTO avaliacaoLojaDTO : avaliacao.getAvaliacoesLojas()) {

                                                                                for (AvaliacaoFuncionarioDTO avaliacaoFuncionarioDTO : avaliacaoLojaDTO.getFuncionarios()) {

                                                                                        if (VerificadorUtil.estaNulo(avaliacaoFuncionarioDTO.getFuncionarioDTO().getCodigoContabilidade())) {

                                                                                                throw new NegocioException("Participante " + avaliacaoFuncionarioDTO.getFuncionarioDTO().getNomeDaPessoa() + " sem código contábil cadastrado");

                                                                                        }

                                                                                        if (avaliacaoFuncionarioDTO.getFuncionarioDTO().getCodigoContabilidade().equals(codigoFolha)) {

                                                                                                Double valorComissao = avaliacaoFuncionarioDTO.getValorComissao();

                                                                                                if (VerificadorUtil.estaNulo(valorComissao)) {

                                                                                                        throw new NegocioException("Obrigatório informar todas as comissões");

                                                                                                }

                                                                                                String valor = StringUtil.formatarValorComDoisDigitos(valorComissao.toString());

                                                                                                cell.setCellValue(valor.replace(".", ","));

                                                                                                break;

                                                                                        }

                                                                                }

                                                                        }

                                                                }

                                                                break;

                                                }

                                        }

                                }

                        }

                        try {

                        workbook.write(baos);

                        return DefaultStreamedContent.builder()

                                .name("folha_pagamento")

                                .contentType(ArquivoUtil.retornarContentTypeArquivo("xls"))

                                .stream(() -> new java.io.ByteArrayInputStream(baos.toByteArray()))

                                .build();

                } catch (FileNotFoundException e) {

                        e.printStackTrace();

                } catch (IOException e) {

                        e.printStackTrace();

                } finally {

                                baos.close();

                                arquivo.close();

                                workbook.close();

                        }

                } catch (FileNotFoundException e) {

                        e.printStackTrace();

                } catch (NegocioException ne) {

                        throw new NegocioException(ne.getMessage());

                } catch (Exception e) {

                        e.printStackTrace();

                }

                return null;

                /*

                try {

                        List<byte[]> arquivos = new ArrayList<byte[]>();

                        for (FolhaPagamentoFuncionarioDTO funcionarioFolhaPagamento : folhaPagamentoDTO.getFuncionarios()) {

                                arquivos.add(funcionarioFolhaPagamento.getArquivo().getArquivo());

                        }

                        ByteArrayInputStream input = new ByteArrayInputStream(ArquivoUtil.compactarArquivos(arquivos, "recibo"));

                        return DefaultStreamedContent.builder().contentType(ArquivoUtil.retornarContentTypeArquivo("zip")).name("recibos.zip").stream(() -> input).build();

                } catch (IOException e) {

                        e.printStackTrace();

                }

                return null;

                */

        }

        /*

        @Override

        public Avaliacao detalhar(Avaliacao avaliacao) {

                return avaliacaoRepository.detalhar(avaliacao);

        }

        @Override

        public Avaliacao consultarAvaliacaoDaVigencia(Vigencia vigencia) {

                return avaliacaoRepository.consultarAvaliacaoDaVigencia(vigencia);

        }

        @Override

        public List<Avaliacao> consultarAvaliacoesDivulgadas() {

                return avaliacaoRepository.consultarAvaliacoesDivulgadas();

        }

        @Override

        public void solicitarReavaliacao(RankingVendedorDTO rankingVendedor, String solicitacao) {

                StringBuilder conteudo = new StringBuilder();

                conteudo.append("SOLICITANTE: " + rankingVendedor.getVendedor().getNomeDaPessoa() + "\n");

                conteudo.append("DATA DA SOLICITAÇÃO: " + DataUtil.retornarDataFormatadaEmFormatoTexto("dd/MM/yyyy 'às' HH:mm", DataUtils.getDataAtual()) + "\n");

                conteudo.append("OBSERVAÇÕES: \n");

                conteudo.append(solicitacao);

                Pendencia pendencia = new Pendencia();

                pendencia.setDescricao("SOLICITAÇÃO DE REAVALIAÇÃO: " + rankingVendedor.getVendedor().getNomeDaPessoa());

                pendencia.setUsuario(usuarioService.consultarUsuarioPorPessoa(rankingVendedor.getVendedor().getPessoa()));

                pendencia.setData(DataUtils.getDataAtual());

                if (VerificadorUtil.estaNulo(rankingVendedor.getVendedor().getLoja())) {

                        pendencia.setLoja(new Loja(ConstantesSEC.SEQUENCIAL_MATRIZ_ESTOQUE_9.longValue()));

                } else {

                        pendencia.setLoja(rankingVendedor.getVendedor().getLoja());

                }

                Perfil perfilRh = new Perfil();

                perfilRh.setCodigo(ConstantesSEC.PERFIL_RECURSOS_HUMANOS_11);

                pendencia.setPerfil(perfilRh);

                pendenciaService.cadastrar(pendencia);

                new GerenciadorEmailImpl()

                        .comEmailsDestino(ConstantesSEC.DESTINATARIOS_EMAIL_SUPERVISAO)

                        .comAssunto("SOLICITAÇÃO DE REAVALIAÇÃO")

                        .comConteudo(conteudo.toString())

                        .enviar();

        }

        @Override

        public byte[] emitirRelatorioImportacaoFolhaPagamento(ServletContext contexto, Avaliacao avaliacao, Long empresa) {

                ByteArrayOutputStream baos = new ByteArrayOutputStream();

                try {

                        String caminhoArquivo = "/arquivos/modelos/Relatório de Importação - Folha de Pagamento Espaço Case.xls";

                        InputStream arquivo = FacesContext.getCurrentInstance().getExternalContext().getResourceAsStream(caminhoArquivo);

                        HSSFWorkbook workbook = new HSSFWorkbook(arquivo);

                        HSSFSheet sheet = workbook.getSheetAt(0);

                        Iterator rowIterator = sheet.rowIterator();

                        while (rowIterator.hasNext()) {

                                Row row = (Row) rowIterator.next();

                                if (row.getRowNum() < 11) {

                                        continue;

                                } else {

                                        Iterator cellIterator = row.cellIterator();

                                        Integer codigoFolha = null;

                                        while (cellIterator.hasNext()) {

                                                Boolean atualizar = true;

                                                Cell cell = (Cell) cellIterator.next();

                                                switch (cell.getColumnIndex()) {

                                                        case 1:

                                                                Integer tipoCelula = cell.getCellType();

                                                                if (tipoCelula.equals(Cell.CELL_TYPE_NUMERIC)) {

                                                                        Double codigo = cell.getNumericCellValue();

                                                                        codigoFolha = codigo.intValue();

                                                                } else {

                                                                        atualizar = false;

                                                                }

                                                                break;

                                                        case 3:

                                                                if (atualizar) {

                                                                        for (AvaliacaoFuncionario avaliacaoFunc : avaliacao.getParticipantes()) {

                                                                                if (VerificadorUtil.estaNulo(avaliacaoFunc.getFuncionario().getCodigoContabilidade())) {

                                                                                        throw new NegocioException("Participante " + avaliacaoFunc.getFuncionario().getNomeDaPessoa() + " sem código contábil cadastrado");

                                                                                }

                                                                                if (avaliacaoFunc.getFuncionario().getTipoComissionamento().equals(TipoComissionamento.parse(empresa).getValor()) &&

                                                                                        avaliacaoFunc.getFuncionario().getCodigoContabilidade().equals(codigoFolha)) {

                                                                                        Double valorComissao = avaliacaoFunc.getValorComissao();

                                                                                        if (VerificadorUtil.estaNulo(valorComissao)) {

                                                                                                throw new NegocioException("Obrigatório informar todas as comissões");

                                                                                        }

                                                                                        String valor = StringUtil.formatarValorComDoisDigitos(valorComissao.toString());

                                                                                        cell.setCellValue(valor.replace(".", ","));

                                                                                        break;

                                                                                }

                                                                        }

                                                                }

                                                                break;

                                                }

                                        }

                                }

                        }

                        try {

                        workbook.write(baos);

                        return baos.toByteArray();

                } catch (FileNotFoundException e) {

                        e.printStackTrace();

                } catch (IOException e) {

                        e.printStackTrace();

                } finally {

                                baos.close();

                                arquivo.close();

                                workbook.close();

                        }

                } catch (FileNotFoundException e) {

                        e.printStackTrace();

                } catch (NegocioException ne) {

                        throw new NegocioException(ne.getMessage());

                } catch (Exception e) {

                        e.printStackTrace();

                }

        return null;

        }

        */

}