Subversion Repositories Integrator Subversion

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

import java.util.List;

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.VerificadorUtil;
import br.com.ec.core.validador.Validador;
import br.com.ec.domain.model.Avaliacao;
import br.com.ec.domain.model.AvaliacaoProduto;
import br.com.ec.domain.model.Produto;
import br.com.ec.domain.service.AvaliacaoProdutoService;
import br.com.ec.domain.service.AvaliacaoService;
import br.com.ec.domain.service.PendenciaService;
import br.com.ec.domain.service.ProdutoService;
import br.com.ec.domain.service.UsuarioService;
import br.com.ec.repository.AvaliacaoRepository;

@Service
public class AvaliacaoServiceImpl extends AbstractService<Avaliacao> implements AvaliacaoService {
       
        private AvaliacaoRepository avaliacaoRepository;
       
        private PendenciaService pendenciaService;
        private UsuarioService usuarioService;
        private ProdutoService produtoService;
        private AvaliacaoProdutoService avaliacaoProdutoService;

        @Autowired
        public AvaliacaoServiceImpl(Validador validador, AvaliacaoRepository avaliacaoRepository, PendenciaService pendenciaService,
                        UsuarioService usuarioService, ProdutoService produtoService, AvaliacaoProdutoService avaliacaoProdutoService) {
                super(validador);
                this.avaliacaoRepository = avaliacaoRepository;
                this.pendenciaService = pendenciaService;
                this.usuarioService = usuarioService;
                this.produtoService = produtoService;
                this.avaliacaoProdutoService = avaliacaoProdutoService;
        }

        @Override
        protected GenericRepository<Avaliacao> getRepository() {
                return avaliacaoRepository;
        }
       
        @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 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;
        }
        */
}