public String deleteSelected() {
   NovoLog novoLog = new NovoLog();
   Dao dao = new Dao();
   novoLog.startList();
   if (selectedCnaeConvencao != null) {
     dao.openTransaction();
     for (int i = 0; i < selectedCnaeConvencao.size(); i++) {
       if (!dao.delete(selectedCnaeConvencao.get(i))) {
         dao.rollback();
         GenericaMensagem.warn("Erro", "Ao excluir registro!");
         novoLog.cancelList();
         return null;
       }
       novoLog.delete(
           "ID: "
               + selectedCnaeConvencao.get(i).getId()
               + " - Cnae: ("
               + selectedCnaeConvencao.get(i).getCnae().getId()
               + ") "
               + selectedCnaeConvencao.get(i).getCnae().getCnae()
               + " - "
               + selectedCnaeConvencao.get(i).getCnae().getNumero()
               + " - Descrição: "
               + selectedCnaeConvencao.get(i).getConvencao().getDescricao());
     }
     novoLog.saveList();
     dao.commit();
     listCnaes.clear();
     listCnaesConvencao.clear();
     GenericaMensagem.info("Sucesso", "Registro(s) removido(s)");
     selectedCnae = null;
     selectedCnaeConvencao = null;
   }
   return null;
 }
  public void adicionar() {
    if (!validaAdicionar()) {
      return;
    }

    Dao dao = new Dao();

    dao.openTransaction();

    declaracaoGrupo = new DeclaracaoGrupo();
    declaracaoGrupo.setDeclaracaoTipo(
        (DeclaracaoTipo)
            dao.find(
                new DeclaracaoTipo(),
                Integer.valueOf(listaDeclaracaoTipo.get(indexDeclaracaoTipo).getDescription())));
    declaracaoGrupo.setSubGrupoConvenio(
        (SubGrupoConvenio)
            dao.find(
                new SubGrupoConvenio(),
                Integer.valueOf(listaSubGrupo.get(indexSubGrupo).getDescription())));

    if (!dao.save(declaracaoGrupo)) {
      dao.rollback();
      GenericaMensagem.error("Atenção", "Erro ao Adicionar Grupo Declaração!");
      return;
    }

    dao.commit();

    declaracaoGrupo = new DeclaracaoGrupo();
    loadListaDeclaracaoGrupo();

    GenericaMensagem.info("Sucesso", "Grupo Declaração adicionada!");
  }
  public String replicar() {
    MensagemConvencaoDB db = new MensagemConvencaoDBToplink();
    List<MensagemConvencao> listam = new ArrayList();

    listam = db.pesquisaTodosAno(this.getListaRefReplica().get(idReplica).getLabel());

    Dao dao = new Dao();
    if (!listam.isEmpty()) {
      dao.openTransaction();
    }
    DataHoje dh = new DataHoje();
    boolean comita = false;
    for (int i = 0; i < listam.size(); i++) {
      MensagemConvencao mc = new MensagemConvencao();
      mc =
          db.verificaMensagem(
              listam.get(i).getConvencao().getId(),
              listam.get(i).getServicos().getId(),
              listam.get(i).getTipoServico().getId(),
              listam.get(i).getGrupoCidade().getId(),
              listam.get(i).getReferencia().substring(0, 3) + replicaPara);
      if (mc != null && mc.getId() != -1) {
        continue;
      }

      MensagemConvencao men =
          new MensagemConvencao(
              -1,
              listam.get(i).getGrupoCidade(),
              listam.get(i).getConvencao(),
              listam.get(i).getServicos(),
              listam.get(i).getTipoServico(),
              listam.get(i).getMensagemContribuinte(),
              listam.get(i).getMensagemCompensacao(),
              listam.get(i).getReferencia().substring(0, 3) + replicaPara,
              DataHoje.converte(dh.incrementarAnos(1, listam.get(i).getVencimento())));

      if (dao.save(men)) {
        comita = true;
      } else {
      }
    }
    if (comita) {
      dao.commit();
      msgConfirma = "Registro replicado com Sucesso!";
      GenericaMensagem.info("Sucesso", msgConfirma);
    } else {
      dao.rollback();
      msgConfirma = "Nenhuma mensagem para Replicar!";
      GenericaMensagem.warn("Erro", msgConfirma);
    }
    return "";
  }
  public void excluir() {
    Dao dao = new Dao();

    dao.openTransaction();

    if (!dao.delete(declaracaoGrupo)) {
      dao.rollback();
      GenericaMensagem.error("Atenção", "Não foi possível excluir Declaração Grupo!");
      return;
    }

    dao.commit();
    loadListaDeclaracaoGrupo();
    GenericaMensagem.info("Sucesso", "Declaração Grupo excluída!");
  }
  public void meusLogs(Integer rotina_id) {
    try {
      HttpServletRequest paginaRequerida =
          (HttpServletRequest) FacesContext.getCurrentInstance().getExternalContext().getRequest();
      String pagina =
          ((ChamadaPaginaBean) GenericaSessao.getObject("chamadaPaginaBean"))
              .converteURL(paginaRequerida.getRequestURI());
      // PesquisaLogBean pesquisaLogBean = new PesquisaLogBean();
      RotinaDao rotinaDao = new RotinaDao();
      Rotina r = rotinaDao.pesquisaRotinaPorPagina(pagina);
      if (r == null) {
        r = rotinaDao.pesquisaRotinaPorAcao(pagina);
      }
      getListLogs().clear();
      Integer[] integer = new Integer[] {0};
      if (getListRotinas().isEmpty()) {
        GenericaMensagem.info("Sistema", "Nenhum Log encontrado");
      }
      if (r != null) {
        for (int i = 0; i < listSelectItem[0].size(); i++) {
          if (Integer.parseInt(listSelectItem[0].get(i).getDescription()) == rotina_id) {
            integer[0] = i;
            break;
          }
        }
      }
      if (integer[0] == 0) {
        setBlockRotina(false);
        GenericaMensagem.info("Sistema", "Nenhum Log encontrado para esta rotina!");
      } else {
        setBlockRotina(true);
      }
      // GenericaSessao.put("pesquisaLogBean", pesquisaLogBean);
      filtro[1] = true;
      filtro[2] = true;
      setUsuario((Usuario) GenericaSessao.getObject("sessaoUsuario"));
      setBlockUsuario(true);
      setIndex(integer);
      setFiltro(filtro);
      // pesquisaLogBean.setIndex(integer);
      getListRotinas();
      getListLogs();
      getFiltroEvento();
    } catch (Exception e) {

    }
  }
 public String excluir() {
   if (mensagemConvencao.getId() != -1) {
     NovoLog novoLog = new NovoLog();
     Dao dao = new Dao();
     mensagemConvencao = (MensagemConvencao) dao.find(mensagemConvencao);
     dao.openTransaction();
     if (dao.delete(mensagemConvencao)) {
       novoLog.delete(
           " - Referência: "
               + mensagemConvencao.getReferencia()
               + " - Vencimento: "
               + mensagemConvencao.getVencimento()
               + " - Serviço: ("
               + mensagemConvencao.getServicos().getId()
               + ") "
               + " - Tipo Serviço: ("
               + mensagemConvencao.getTipoServico().getId()
               + ") "
               + mensagemConvencao.getTipoServico().getDescricao()
               + " - Convenção: ("
               + mensagemConvencao.getConvencao().getId()
               + ") "
               + mensagemConvencao.getConvencao().getDescricao()
               + " - Grupo Cidade: ("
               + mensagemConvencao.getGrupoCidade().getId()
               + ") "
               + mensagemConvencao.getGrupoCidade().getDescricao()
               + " - Mensagem Compensação: "
               + mensagemConvencao.getMensagemCompensacao()
               + " - Mensagem Contribuinte: "
               + mensagemConvencao.getMensagemContribuinte());
       dao.commit();
       msgConfirma = "Mensagem Excluida com Sucesso!";
       GenericaMensagem.info("Sucesso", msgConfirma);
     } else {
       dao.rollback();
       msgConfirma = "Mensagem não pode ser Excluida!";
       GenericaMensagem.warn("Erro", msgConfirma);
     }
   } else {
     GenericaMensagem.warn("Erro", "Pesquise uma mensagem para ser Excluída!");
   }
   return null;
 }
 public Boolean validaAdicionar() {
   DeclaracaoGrupoDao dao = new DeclaracaoGrupoDao();
   if (dao.existeDeclaracaoGrupo(
       Integer.valueOf(listaDeclaracaoTipo.get(indexDeclaracaoTipo).getDescription()),
       Integer.valueOf(listaSubGrupo.get(indexSubGrupo).getDescription()))) {
     GenericaMensagem.warn("Atenção", "Tipo e Sub Grupo já adicionados!");
     return false;
   }
   return true;
 }
  public void loadList() {
    lista.clear();
    listaMovimentoBoleto.clear();

    if (descricaoPesquisa.isEmpty()) {
      GenericaMensagem.warn("Atenção", "Digite uma pesquisa!");
      return;
    }

    // listaMovimentoBoleto = new PesquisaBoletosSocialDao().listaMovimentoBoleto(tipoPesquisa,
    // descricaoPesquisa);
    List<Object> result =
        new PesquisaBoletosSocialDao().listaMovimentoBoleto(tipoPesquisa, descricaoPesquisa);

    for (Object linha : result) {
      listaMovimentoBoleto.add(
          new LinhaBoleto(
              (Integer) ((List) linha).get(0), // id_titular
              (String) ((List) linha).get(1), // nome_titular
              (Integer) ((List) linha).get(2), // id_beneficiario
              (String) ((List) linha).get(3), // nome_beneficiario
              (Integer) ((List) linha).get(4), // id_servico
              (String) ((List) linha).get(5), // nome_servico
              ((Double) ((List) linha).get(6)).floatValue(), // valor
              DataHoje.converteData((Date) ((List) linha).get(7)), // vencimento
              (String) ((List) linha).get(8), // boleto atual
              (String) ((List) linha).get(9), // boleto anterior
              DataHoje.converteData((Date) ((List) linha).get(10)), // quitacao
              (Integer) ((List) linha).get(11), // id_movimento (atual)
              (Integer) ((List) linha).get(12), // id_boleto (anterior)
              (ContaCobranca)
                  new Dao()
                      .find(
                          new ContaCobranca(),
                          (Integer) ((List) linha).get(13)) // id_conta_cobranca
              ));
    }

    if (listaMovimentoBoleto.isEmpty()) {
      GenericaMensagem.warn("Atenção", "Nenhum Boleto encontrado!");
    }
  }
Esempio n. 9
0
 public void delete(Correcao co) {
   correcao = co;
   DaoInterface di = new Dao();
   NovoLog novoLog = new NovoLog();
   if (di.delete(correcao, true)) {
     novoLog.delete(
         "ID: "
             + correcao.getId()
             + " - Índice: ("
             + correcao.getIndice().getId()
             + ") "
             + " - Serviços: ("
             + correcao.getServicos().getId()
             + ") "
             + correcao.getServicos().getDescricao()
             + " - Período: "
             + correcao.getReferenciaInicial()
             + " - "
             + correcao.getReferenciaFinal()
             + " - Juros Diário: "
             + correcao.getJurosDiarios()
             + " - Juros 1º Mês: "
             + correcao.getJurosPriMes()
             + " - Juros >= 2º Mês: "
             + correcao.getJurosApartir2Mes()
             + " - Multa por Funcionário: "
             + correcao.getMultaPorFuncionario()
             + " - Multa 1º Mês: "
             + correcao.getMultaPriMes()
             + " - Multa >= 2º Mês: "
             + correcao.getMultaApartir2Mes());
     GenericaMensagem.info("Sucesso", "Correção Excluida");
   } else {
     GenericaMensagem.warn("Erro", "Erro ao excluir Correção!");
   }
   correcao = new Correcao();
   listIndices.clear();
   listServicos.clear();
   listaCorrecao.clear();
 }
 public void adddeleteSelected() {
   if (selectedCnae != null) {
     NovoLog novoLog = new NovoLog();
     novoLog.startList();
     int iConvencao = Integer.parseInt(getListConvencao().get(idConvencao).getDescription());
     Dao dao = new Dao();
     Convencao convencao = (Convencao) dao.find(new Convencao(), iConvencao);
     dao.openTransaction();
     for (int i = 0; i < selectedCnae.size(); i++) {
       CnaeConvencao cnaeConvencao = new CnaeConvencao(-1, (Cnae) selectedCnae.get(i), convencao);
       if (dao.save(cnaeConvencao)) {
         novoLog.save(
             "ID: "
                 + cnaeConvencao.getId()
                 + " - Cnae: ("
                 + cnaeConvencao.getCnae().getId()
                 + ") "
                 + cnaeConvencao.getCnae().getCnae()
                 + " - "
                 + cnaeConvencao.getCnae().getNumero()
                 + " - Descrição: "
                 + cnaeConvencao.getConvencao().getDescricao());
         GenericaMensagem.info("Sucesso", "Registro adicionado");
       } else {
         novoLog.cancelList();
         dao.rollback();
         GenericaMensagem.warn("Erro", "Ao adicionar registro");
         return;
       }
     }
     novoLog.saveList();
     dao.commit();
     listCnaes.clear();
     listCnaesConvencao.clear();
     selectedCnae = null;
     selectedCnaeConvencao = null;
   }
 }
  public void voltarBoletos() {
    if (listaMovimentoBoleto.isEmpty()) {
      GenericaMensagem.warn("Atenção", "Lista de Movimentos vazia!");
      return;
    }

    for (LinhaBoleto lb : listaMovimentoBoleto) {
      if (!lb.getQuitacao().isEmpty()) {
        GenericaMensagem.warn("Atenção", "Existem Movimentos Baixados!");
        return;
      }
    }

    Dao dao = new Dao();

    // PEGA O PRIMEIRO BOLETO POIS SERÃO TODOS IGUAIS E NÃO TEM NECESSIDADE DE COLOCAR NO LOPPING
    Boleto b = (Boleto) dao.find(new Boleto(), listaMovimentoBoleto.get(0).getId_boleto());

    dao.openTransaction();
    for (LinhaBoleto lb : listaMovimentoBoleto) {
      Movimento m = (Movimento) dao.find(new Movimento(), lb.getId_movimento());

      m.setDocumento(b.getBoletoComposto());
      m.setNrCtrBoleto(b.getNrCtrBoleto());

      if (!dao.update(m)) {
        GenericaMensagem.error("Erro", "Não foi possível atualizar Boleto!");
        dao.rollback();
        return;
      }
    }

    dao.commit();
    GenericaMensagem.info("Sucesso", "Movimentos atualizados!");
    loadList();
  }
  public List<SelectItem> getListaTipoServico() {
    if (listaTipoServico.isEmpty()) {
      TipoServicoDB db = new TipoServicoDBToplink();
      List<TipoServico> select = db.pesquisaTodosPeloContaCobranca();

      if (select.isEmpty()) {
        GenericaMensagem.error("Atenção", "Serviço Conta Cobrança não encontrado!");
        return listaTipoServico;
      }

      for (int i = 0; i < select.size(); i++) {
        listaTipoServico.add(
            new SelectItem(
                i, select.get(i).getDescricao(), Integer.toString(select.get(i).getId())));
      }
    }
    return listaTipoServico;
  }
Esempio n. 13
0
  public void print(List vector) {
    printed = false;
    Dao dao = new Dao();
    List<List> list = new ArrayList();
    if (!listaSelecionado.isEmpty() && vector == null) {
      list = listaSelecionado;
    } else if (vector != null) {
      list.add(vector);
    }
    String printLog = "";
    NovoLog novoLog = new NovoLog();
    novoLog.startList();
    if (!list.isEmpty()) {
      dao.openTransaction();
      SocioCarteirinhaDao dbc = new SocioCarteirinhaDao();
      DataHoje dh = new DataHoje();
      SociosDao dbs = new SociosDao();
      for (int i = 0; i < list.size(); i++) {
        Integer nrValidadeMeses = 0;
        Integer titular_id = (Integer) ((List) list.get(i)).get(40);
        Pessoa pessoa = (Pessoa) dao.find(new Pessoa(), (Integer) ((List) list.get(i)).get(0));
        Socios socios = dbs.pesquisaSocioPorPessoa(pessoa.getId());
        ValidadeCartao validadeCartao = new ValidadeCartao();
        SocioCarteirinha carteirinha =
            (SocioCarteirinha)
                dao.find(new SocioCarteirinha(), (Integer) ((List) list.get(i)).get(19));
        if (socios.getId() != -1) {
          validadeCartao =
              new ValidadeCartaoDao()
                  .findByCategoriaParentesco(
                      socios.getMatriculaSocios().getCategoria().getId(),
                      socios.getParentesco().getId());
          if (validadeCartao == null) {
            GenericaMensagem.warn("Validação", "Nenhuma validade de cartão encontrada!");
            dao.rollback();
            return;
          }
          nrValidadeMeses = validadeCartao.getNrValidadeMeses();
        } else {
          nrValidadeMeses = configuracaoSocial.getValidadeMesesCartaoAcademia();
        }
        if (socios.getId() != -1 && socios.getMatriculaSocios().getId() != -1) {
          Date validadeCarteirinha;
          if (validadeCartao.getDtValidadeFixa() == null) {
            validadeCarteirinha =
                DataHoje.converte(dh.incrementarMeses(nrValidadeMeses, DataHoje.data()));
          } else {
            validadeCarteirinha = validadeCartao.getDtValidadeFixa();
          }
          carteirinha.setDtValidadeCarteirinha(validadeCarteirinha);
        } else {
          carteirinha.setDtValidadeCarteirinha(
              DataHoje.converte(dh.incrementarMeses(nrValidadeMeses, DataHoje.data())));
        }
        boolean validacao = false;
        if (pessoa.getSocios().getId() != -1) {
          Fisica f = new FisicaDao().pesquisaFisicaPorPessoa(pessoa.getId());
          if (pessoa.getSocios().getMatriculaSocios().getCategoria().isEmpresaObrigatoria()
              && f.getDtAposentadoria() == null
              && titular_id == pessoa.getId()) {
            PessoaEmpresaDao db = new PessoaEmpresaDao();
            PessoaEmpresa pe = db.pesquisaPessoaEmpresaPorPessoa(pessoa.getId());
            // PessoaEmpresa pe = db.pesquisaPessoaEmpresaPorPessoa(titular_id);
            if (pe.getId() == -1) {
              GenericaMensagem.error(
                  "Atenção", "Empresa Não Vinculada a pessoa " + pessoa.getNome());
              validacao = true;
              listaSelecionado = new ArrayList();
            }
          }
          listaSelecionado.remove(vector);
        }

        if (validacao) {
          dao.rollback();
          return;
        }

        String descricao_historico = "Impressão de Carteirinha";
        if (configuracaoSocial.getAtualizaViaCarteirinha()) {
          carteirinha.setVia(carteirinha.getVia() + 1);
          descricao_historico = "Impressão de " + carteirinha.getVia() + "° via do cartão";
          list.get(i).set(11, carteirinha.getVia());
        }

        carteirinha.setEmissao(DataHoje.data());
        if (!dao.update(carteirinha)) {
          dao.rollback();
          return;
        }

        list.get(i).set(6, carteirinha.getValidadeCarteirinha());
        HistoricoCarteirinha hc = new HistoricoCarteirinha();

        hc.setCarteirinha(carteirinha);
        hc.setDescricao(descricao_historico);

        if (list.get(i).get(17) != null) {
          Movimento m =
              (Movimento)
                  dao.find(new Movimento(), Integer.valueOf(list.get(i).get(17).toString()));
          if (m != null) {
            hc.setMovimento(m);
          }
        }

        if (!dao.save(hc)) {
          dao.rollback();
          return;
        }

        // AutorizaImpressaoCartao ai = dbc.pesquisaAutorizaSemHistorico(pessoa.getId(),
        // modeloc.getId());
        AutorizaImpressaoCartao ai =
            dbc.pesquisaAutorizaSemHistorico(
                pessoa.getId(), carteirinha.getModeloCarteirinha().getId());

        if (ai != null) {
          ai.setHistoricoCarteirinha(hc);
          if (!dao.update(ai)) {
            dao.rollback();
            return;
          }
        }
        printLog =
            "ID"
                + hc.getId()
                + " - Pessoa {ID: "
                + pessoa.getId()
                + " - Nome: "
                + pessoa.getNome()
                + " }"
                + " - Impresso por {ID: "
                + hc.getCarteirinha().getModeloCarteirinha().getId()
                + " - Nome: "
                + hc.getCarteirinha().getModeloCarteirinha().getDescricao()
                + " }";
        novoLog.setTabela("soc_historico_carteirinha");
        novoLog.setCodigo(hc.getId());
      }

      if (ImpressaoParaSocios.imprimirCarteirinha(list)) {
        dao.commit();
        if (status.equals("nao_impressos")) {
          printed = false;
        }
        if (disabledImpressaoExterna) {
          disabledImpressaoExterna = false;
          GenericaSessao.put("status", "hoje");
        }
        listaCarteirinha = new ArrayList();
        listaSelecionado = new ArrayList();
        listaSelecionadoMemoria = new ArrayList();
        novoLog.print(printLog);
        novoLog.saveList();
      } else {
        novoLog.cancelList();
        dao.rollback();
      }
    }
  }
  public synchronized String salvar() {
    MensagemConvencaoDB db = new MensagemConvencaoDBToplink();
    ConvencaoCidadeDB dbc = new ConvencaoCidadeDBToplink();
    DataHoje dataHoje = new DataHoje();
    mensagemConvencao.setVencimento(vencimento);

    if (!mensagemConvencao.getVencimento().equals(vencimento)) {
      msgConfirma = "Este vencimento esta incorreto!";
      GenericaMensagem.warn("Erro", msgConfirma);
      return null;
    }

    if ((mensagemConvencao.getReferencia().length() != 7)
        && (Integer.parseInt(this.getListaTipoServico().get(idTipoServico).getDescription())
            != 4)) {
      msgConfirma = "Referência esta incorreta";
      GenericaMensagem.warn("Erro", msgConfirma);
      return null;
    }

    if (DataHoje.converteData(mensagemConvencao.getDtVencimento()) == null) {
      msgConfirma = "Informe o vencimento";
      GenericaMensagem.warn("Erro", msgConfirma);
      return null;
    }

    try {
      if (mensagemConvencao.getId() == -1) {
        // SE ACORDO FOR FALSO ----------------------------------------------------
        if (mensagemConvencao.getReferencia().length() != 7 && !disAcordo) {
          msgConfirma = "Digite uma referencia!";
          GenericaMensagem.warn("Erro", msgConfirma);
          return null;
        }

        int ano = 0;
        String referencia = "", vencto = "", diaOriginal = "";
        int iservicos = Integer.parseInt(this.getListaServico().get(idServico).getDescription()),
            itiposervico =
                Integer.parseInt(this.getListaTipoServico().get(idTipoServico).getDescription());
        if (gerarAno && !disAcordo) {
          ano = 12;
          referencia = "01/01/" + mensagemConvencao.getReferencia().substring(3);
          diaOriginal = mensagemConvencao.getVencimento().substring(0, 2);
          vencto = diaOriginal + "/01/" + mensagemConvencao.getVencimento().substring(6, 10);
          if (iservicos == 1) {
            vencto = dataHoje.incrementarMesesUltimoDia(1, vencto);
          } else {
            vencto = dataHoje.incrementarMeses(1, vencto);
          }
        } else {
          ano = 1;
          referencia = mensagemConvencao.getReferencia();
          diaOriginal = mensagemConvencao.getVencimento().substring(0, 2);
          vencto = mensagemConvencao.getVencimento();
        }

        switch (processarGrupos) {
            //  SALVAR PARA TODOS OS GRUPOS DESTA CONVENÇÃO
          case 1:
            {
              int conv =
                  Integer.parseInt(this.getListaConvencoes().get(idConvencao).getDescription());
              List<GrupoCidade> listgc = dbc.pesquisarGruposPorConvencao(conv);
              for (int l = 0; l < ano; l++) {
                for (int k = 0; k < listgc.size(); k++) {
                  if (gerarAno && !disAcordo) {
                    msgConfirma =
                        this.insertMensagem(
                            conv,
                            listgc.get(k).getId(),
                            iservicos,
                            itiposervico,
                            referencia.substring(3),
                            vencto);
                  } else {
                    msgConfirma =
                        this.insertMensagem(
                            conv,
                            listgc.get(k).getId(),
                            iservicos,
                            itiposervico,
                            referencia,
                            vencto);
                  }
                }
                referencia = dataHoje.incrementarMeses(1, referencia);
                if (iservicos == 1) {
                  vencto = dataHoje.incrementarMesesUltimoDia(1, vencto);
                } else {
                  vencto = diaOriginal + vencto.substring(2, 10);
                  vencto = dataHoje.incrementarMeses(1, vencto);
                }
              }
              break;
            }
            // SALVAR PARA TODAS AS CONVENÇÕES DESTE GRUPO
          case 2:
            {
              int grupoC =
                  Integer.parseInt(this.getListaGrupoCidade().get(idGrupo).getDescription());
              List<Convencao> listc = dbc.pesquisarConvencaoPorGrupos(grupoC);
              for (int l = 0; l < ano; l++) {
                for (int k = 0; k < listc.size(); k++) {
                  if (gerarAno && !disAcordo) {
                    msgConfirma =
                        this.insertMensagem(
                            listc.get(k).getId(),
                            grupoC,
                            iservicos,
                            itiposervico,
                            referencia.substring(3),
                            vencto);
                  } else {
                    msgConfirma =
                        this.insertMensagem(
                            listc.get(k).getId(),
                            grupoC,
                            iservicos,
                            itiposervico,
                            referencia,
                            vencto);
                  }
                }
                referencia = dataHoje.incrementarMeses(1, referencia);
                if (iservicos == 1) {
                  vencto = dataHoje.incrementarMesesUltimoDia(1, vencto);
                } else {
                  vencto = diaOriginal + vencto.substring(2, 10);
                  vencto = dataHoje.incrementarMeses(1, vencto);
                }
              }
              break;
            }
            // SALVAR PARA TODOS OS GRUPOS E CONVENÇÕES
          case 3:
            {
              List<SelectItem> listc = this.getListaConvencoes();
              for (int l = 0; l < ano; l++) {
                for (int k = 0; k < listc.size(); k++) {
                  List<GrupoCidade> listgc =
                      dbc.pesquisarGruposPorConvencao(
                          Integer.parseInt(listc.get(k).getDescription()));
                  for (int w = 0; w < listgc.size(); w++) {
                    if (gerarAno && !disAcordo) {
                      msgConfirma =
                          this.insertMensagem(
                              Integer.parseInt(listc.get(k).getDescription()),
                              listgc.get(w).getId(),
                              iservicos,
                              itiposervico,
                              referencia.substring(3),
                              vencto);
                    } else {
                      msgConfirma =
                          this.insertMensagem(
                              Integer.parseInt(listc.get(k).getDescription()),
                              listgc.get(w).getId(),
                              iservicos,
                              itiposervico,
                              referencia,
                              vencto);
                    }
                  }
                }
                referencia = dataHoje.incrementarMeses(1, referencia);
                if (iservicos == 1) {
                  vencto = dataHoje.incrementarMesesUltimoDia(1, vencto);
                } else {
                  vencto = diaOriginal + vencto.substring(2, 10);
                  vencto = dataHoje.incrementarMeses(1, vencto);
                }
              }
              break;
            }
            // NENHUMA DESTAS OPÇÕES
          case 4:
            {
              int
                  conv =
                      Integer.parseInt(this.getListaConvencoes().get(idConvencao).getDescription()),
                  grupoC =
                      Integer.parseInt(this.getListaGrupoCidade().get(idGrupo).getDescription());
              for (int l = 0; l < ano; l++) {
                if (gerarAno && !disAcordo) {
                  msgConfirma =
                      this.insertMensagem(
                          conv, grupoC, iservicos, itiposervico, referencia.substring(3), vencto);
                } else {
                  msgConfirma =
                      this.insertMensagem(
                          conv, grupoC, iservicos, itiposervico, referencia, vencto);
                }

                referencia = dataHoje.incrementarMeses(1, referencia);
                if (iservicos == 1) {
                  vencto = dataHoje.incrementarMesesUltimoDia(1, vencto);
                } else {
                  vencto = diaOriginal + vencto.substring(2, 10);
                  vencto = dataHoje.incrementarMeses(1, vencto);
                }
              }
              break;
            }
        }
      } else {
        Dao dao = new Dao();
        MensagemConvencao men = null;
        NovoLog novoLog = new NovoLog();
        if (processarTipoServicos) {
          List<MensagemConvencao> lista =
              db.mesmoTipoServico(
                  Integer.parseInt(this.getListaServico().get(idServico).getDescription()),
                  Integer.parseInt(this.getListaTipoServico().get(idTipoServico).getDescription()),
                  mensagemConvencao.getReferencia().substring(3));
          for (int i = 0; i < lista.size(); i++) {
            lista.get(i).setMensagemCompensacao(mensagemConvencao.getMensagemCompensacao());
            lista.get(i).setMensagemContribuinte(mensagemConvencao.getMensagemContribuinte());
            lista.get(i).setVencimento(vencimento);
            men =
                db.verificaMensagem(
                    lista.get(i).getConvencao().getId(),
                    lista.get(i).getServicos().getId(),
                    lista.get(i).getTipoServico().getId(),
                    lista.get(i).getGrupoCidade().getId(),
                    lista.get(i).getReferencia());
            if ((men == null) || (men.getId() != -1)) {
              MensagemConvencao mcBefore = (MensagemConvencao) dao.find(men);
              String beforeUpdate =
                  " - Referência: "
                      + mcBefore.getReferencia()
                      + " - Vencimento: "
                      + mcBefore.getVencimento()
                      + " - Serviço: ("
                      + mcBefore.getServicos().getId()
                      + ") "
                      + " - Tipo Serviço: ("
                      + mcBefore.getTipoServico().getId()
                      + ") "
                      + mcBefore.getTipoServico().getDescricao()
                      + " - Convenção: ("
                      + mcBefore.getConvencao().getId()
                      + ") "
                      + mcBefore.getConvencao().getDescricao()
                      + " - Grupo Cidade: ("
                      + mcBefore.getGrupoCidade().getId()
                      + ") "
                      + mcBefore.getGrupoCidade().getDescricao()
                      + " - Mensagem Compensação: "
                      + mcBefore.getMensagemCompensacao();
              if (db.update(lista.get(i))) {
                msgConfirma = "Mensagem atualizado com sucesso!";
                novoLog.update(
                    beforeUpdate,
                    " - Referência: "
                        + men.getReferencia()
                        + " - Vencimento: "
                        + men.getVencimento()
                        + " - Serviço: ("
                        + men.getServicos().getId()
                        + ") "
                        + " - Tipo Serviço: ("
                        + men.getTipoServico().getId()
                        + ") "
                        + men.getTipoServico().getDescricao()
                        + " - Convenção: ("
                        + men.getConvencao().getId()
                        + ") "
                        + men.getConvencao().getDescricao()
                        + " - Grupo Cidade: ("
                        + men.getGrupoCidade().getId()
                        + ") "
                        + men.getGrupoCidade().getDescricao()
                        + " - Mensagem Compensação: "
                        + men.getMensagemCompensacao()
                        + " - Mensagem Contribuinte: "
                        + men.getMensagemContribuinte());
                GenericaMensagem.info("Sucesso", msgConfirma);
              } else {
                msgConfirma = "Ocorreu um erro ao atualizar!";
                GenericaMensagem.warn("Erro", msgConfirma);
              }
            }
          }
        } else {
          men =
              db.verificaMensagem(
                  mensagemConvencao.getConvencao().getId(),
                  mensagemConvencao.getServicos().getId(),
                  mensagemConvencao.getTipoServico().getId(),
                  mensagemConvencao.getGrupoCidade().getId(),
                  mensagemConvencao.getReferencia());
          MensagemConvencao mcBefore = (MensagemConvencao) dao.find(mensagemConvencao);
          String beforeUpdate =
              " - Referência: "
                  + mcBefore.getReferencia()
                  + " - Vencimento: "
                  + mcBefore.getVencimento()
                  + " - Serviço: ("
                  + mcBefore.getServicos().getId()
                  + ") "
                  + " - Tipo Serviço: ("
                  + mcBefore.getTipoServico().getId()
                  + ") "
                  + mcBefore.getTipoServico().getDescricao()
                  + " - Convenção: ("
                  + mcBefore.getConvencao().getId()
                  + ") "
                  + mcBefore.getConvencao().getDescricao()
                  + " - Grupo Cidade: ("
                  + mcBefore.getGrupoCidade().getId()
                  + ") "
                  + mcBefore.getGrupoCidade().getDescricao()
                  + " - Mensagem Compensação: "
                  + mcBefore.getMensagemCompensacao();
          if (men == null || (men.getId() == mensagemConvencao.getId())) {
            if (db.update(mensagemConvencao)) {
              novoLog.update(
                  beforeUpdate,
                  " - Referência: "
                      + mensagemConvencao.getReferencia()
                      + " - Vencimento: "
                      + mensagemConvencao.getVencimento()
                      + " - Serviço: ("
                      + mensagemConvencao.getServicos().getId()
                      + ") "
                      + " - Tipo Serviço: ("
                      + mensagemConvencao.getTipoServico().getId()
                      + ") "
                      + mensagemConvencao.getTipoServico().getDescricao()
                      + " - Convenção: ("
                      + mensagemConvencao.getConvencao().getId()
                      + ") "
                      + mensagemConvencao.getConvencao().getDescricao()
                      + " - Grupo Cidade: ("
                      + mensagemConvencao.getGrupoCidade().getId()
                      + ") "
                      + mensagemConvencao.getGrupoCidade().getDescricao()
                      + " - Mensagem Compensação: "
                      + mensagemConvencao.getMensagemCompensacao()
                      + " - Mensagem Contribuinte: "
                      + mensagemConvencao.getMensagemContribuinte());
              msgConfirma = "Mensagem atualizado com sucesso!";
              GenericaMensagem.info("Sucesso", msgConfirma);
            } else {
              msgConfirma = "Ocorreu um erro ao atualizar!";
              GenericaMensagem.warn("Erro", msgConfirma);
            }
          } else {
            msgConfirma = "Mensagem já existe!";
            GenericaMensagem.warn("Erro", msgConfirma);
          }
        }
      }
    } catch (Exception e) {
      msgConfirma = e.getMessage();
      GenericaMensagem.warn("Erro", msgConfirma);
    }
    //        mensagemConvencao = new MensagemConvencao();
    //        idGrupo = 0;
    //        idConvencao = 0;
    //        idServico = 0;
    //        idTipoServico = 0;
    return null;
  }
Esempio n. 15
0
 public final void loadList() {
   if (!printed) {
     if (status.isEmpty()) {
       status = "hoje";
     }
     if ((filter.equals("nascimento")
             || filter.equals("nome")
             || filter.equals("codigo")
             || filter.equals("cpf")
             || filter.equals("empresa")
             || filter.equals("cnpj"))
         && query.isEmpty()) {
       GenericaMensagem.warn(
           "Validação", "Específicar um valor válido para o filtro selecionado!");
       return;
     }
     printed = true;
     // listaSelecionado = new ArrayList();
     String inPessoasImprimir = "";
     if (GenericaSessao.exists("inPessoasImprimir")) {
       inPessoasImprimir = GenericaSessao.getString("inPessoasImprimir", true);
     }
     listaCarteirinha = new ArrayList();
     listaCarteirinha =
         new SocioCarteirinhaDao()
             .find(
                 status,
                 filter,
                 query,
                 indexOrdem,
                 getFilialInteger(),
                 idOperador,
                 typeDate,
                 startDate,
                 finishDate,
                 inPessoasImprimir);
     if (!inPessoasImprimir.isEmpty()) {
       if (!listaCarteirinha.isEmpty()) {
         listaSelecionado = new ArrayList();
         for (int i = 0; i < listaCarteirinha.size(); i++) {
           listaSelecionado.add(listaCarteirinha.get(i));
         }
         disabledImpressaoExterna = true;
         inPessoasImprimir = "";
       } else {
         listaCarteirinha =
             new SocioCarteirinhaDao()
                 .find(
                     "nao_impressos",
                     filter,
                     query,
                     indexOrdem,
                     getFilialInteger(),
                     idOperador,
                     typeDate,
                     startDate,
                     finishDate,
                     "");
       }
     }
   }
 }
Esempio n. 16
0
  // MÉTODO EM DESUSO APAGAR DEPOIS DE 30/04/2016
  public void reImprimirCarteirinha() {
    Dao dao = new Dao();

    if (!listaSelecionado.isEmpty()) {
      CategoriaDao dbCat = new CategoriaDao();
      DataHoje dh = new DataHoje();
      SociosDao dbs = new SociosDao();

      dao.openTransaction();

      for (int i = 0; i < listaSelecionado.size(); i++) {
        Pessoa pessoa =
            (Pessoa) dao.find(new Pessoa(), (Integer) ((List) listaSelecionado.get(i)).get(0));
        Socios socios = dbs.pesquisaSocioPorPessoa(pessoa.getId());
        SocioCarteirinha carteirinha =
            (SocioCarteirinha)
                dao.find(
                    new SocioCarteirinha(), (Integer) ((List) listaSelecionado.get(i)).get(19));
        ValidadeCartao validadeCartao =
            new ValidadeCartaoDao()
                .findByCategoriaParentesco(
                    socios.getMatriculaSocios().getCategoria().getId(),
                    socios.getParentesco().getId());
        if (validadeCartao == null) {
          GenericaMensagem.warn("Validação", "Nenhuma validade de cartão encontrada!");
          dao.rollback();
          return;
        }
        if (socios.getId() != -1 && socios.getMatriculaSocios().getId() != -1) {
          GrupoCategoria gpCat =
              dbCat.pesquisaGrupoPorCategoria(
                  Integer.valueOf(socios.getMatriculaSocios().getCategoria().getId()));
          Date validadeCarteirinha;
          if (validadeCartao.getDtValidadeFixa() == null) {
            validadeCarteirinha =
                DataHoje.converte(
                    dh.incrementarMeses(validadeCartao.getNrValidadeMeses(), DataHoje.data()));
          } else {
            validadeCarteirinha = validadeCartao.getDtValidadeFixa();
          }
          carteirinha.setDtValidadeCarteirinha(validadeCarteirinha);
        } else {
          carteirinha.setDtValidadeCarteirinha(null);
        }

        carteirinha.setVia(carteirinha.getVia() + 1);
        listaSelecionado.get(i).set(6, carteirinha.getValidadeCarteirinha());

        if (carteirinha.getDtEmissao() == null) {
          carteirinha.setEmissao(DataHoje.data());

          if (!dao.update(carteirinha)) {
            dao.rollback();
            GenericaMensagem.warn("Erro", "AO ATUALIZAR CARTEIRINHA!");
            return;
          }

          HistoricoCarteirinha hc = new HistoricoCarteirinha();

          hc.setCarteirinha(carteirinha);
          hc.setDescricao("Primeira ReImpressão de Carteirinha 2º Via");

          if (listaSelecionado.get(i).get(17) != null) {
            Movimento m =
                (Movimento)
                    dao.find(
                        new Movimento(),
                        Integer.valueOf(listaSelecionado.get(i).get(17).toString()));
            if (m != null) {
              hc.setMovimento(m);
            }
          }

          if (!dao.save(hc)) {
            dao.rollback();
            return;
          }
        } else {
          HistoricoCarteirinha hc = new HistoricoCarteirinha();

          carteirinha.setVia(carteirinha.getVia() + 1);

          if (!dao.update(carteirinha)) {
            dao.rollback();
            GenericaMensagem.warn("Erro", "AO ATUALIZAR CARTEIRINHA!");
            return;
          }

          hc.setCarteirinha(carteirinha);
          hc.setDescricao("ReImpressão de Carteirinha 2º Via");

          if (listaSelecionado.get(i).get(17) != null) {
            Movimento m =
                (Movimento)
                    dao.find(
                        new Movimento(),
                        Integer.valueOf(listaSelecionado.get(i).get(17).toString()));
            if (m != null) {
              hc.setMovimento(m);
            }
          }

          if (!dao.save(hc)) {
            dao.rollback();
            GenericaMensagem.warn("Erro", "AO ATUALIZAR HISTÓRICO DA CARTEIRINHA!");
            return;
          }
        }
      }

      if (ImpressaoParaSocios.imprimirCarteirinha(listaSelecionado)) {
        dao.commit();
      } else {
        dao.rollback();
        GenericaMensagem.warn("Erro", "AO ATUALIZAR CARTEIRINHA!");
      }
    }
  }
Esempio n. 17
0
 public void save() {
   CorrecaoDao db = new CorrecaoDao();
   Dao dao = new Dao();
   NovoLog novoLog = new NovoLog();
   Servicos servico =
       (Servicos)
           dao.find(
               new Servicos(),
               Integer.parseInt(getListServicos().get(idServicos).getDescription()));
   correcao.setIndice(
       (Indice)
           dao.find(
               new Indice(), Integer.parseInt(getListIndices().get(idIndices).getDescription())));
   correcao.setServicos(servico);
   if (correcao.getId() == -1) {
     if (DataHoje.validaReferencias(
         correcao.getReferenciaInicial(), correcao.getReferenciaFinal())) {
       List dd =
           db.pesquisaRefValida(
               servico, correcao.getReferenciaInicial(), correcao.getReferenciaFinal());
       if (Integer.parseInt(String.valueOf((Long) dd.get(0))) == 0) {
         if (dao.save(correcao, true)) {
           novoLog.save(
               "ID: "
                   + correcao.getId()
                   + " - Índice: ("
                   + correcao.getIndice().getId()
                   + ") "
                   + " - Serviços: ("
                   + correcao.getServicos().getId()
                   + ") "
                   + correcao.getServicos().getDescricao()
                   + " - Período: "
                   + correcao.getReferenciaInicial()
                   + " - "
                   + correcao.getReferenciaFinal()
                   + " - Juros Diário: "
                   + correcao.getJurosDiarios()
                   + " - Juros 1º Mês: "
                   + correcao.getJurosPriMes()
                   + " - Juros >= 2º Mês: "
                   + correcao.getJurosApartir2Mes()
                   + " - Multa por Funcionário: "
                   + correcao.getMultaPorFuncionario()
                   + " - Multa 1º Mês: "
                   + correcao.getMultaPriMes()
                   + " - Multa >= 2º Mês: "
                   + correcao.getMultaApartir2Mes());
           GenericaMensagem.info("Sucesso", "Correção Salva");
           correcao = new Correcao();
           idIndices = 0;
           idServicos = 0;
         } else {
           GenericaMensagem.warn("Erro", "Erro ao Salvar!");
         }
       } else {
         GenericaMensagem.warn("Validação", "Correção já existente!");
       }
     } else {
       GenericaMensagem.warn("Validação", "Referencia Invalida!");
     }
   } else if (DataHoje.validaReferencias(
       correcao.getReferenciaInicial(), correcao.getReferenciaFinal())) {
     Correcao c = (Correcao) dao.find(correcao);
     String beforeUpdate =
         "ID: "
             + c.getId()
             + " - Índice: ("
             + c.getIndice().getId()
             + ") "
             + " - Serviços: ("
             + c.getServicos().getId()
             + ") "
             + c.getServicos().getDescricao()
             + " - Período: "
             + c.getReferenciaInicial()
             + " - "
             + c.getReferenciaFinal()
             + " - Juros Diário: "
             + c.getJurosDiarios()
             + " - Juros 1º Mês: "
             + c.getJurosPriMes()
             + " - Juros >= 2º Mês: "
             + c.getJurosApartir2Mes()
             + " - Multa por Funcionário: "
             + correcao.getMultaPorFuncionario()
             + " - Multa 1º Mês: "
             + c.getMultaPriMes()
             + " - Multa >= 2º Mês: "
             + c.getMultaApartir2Mes();
     if (dao.update(correcao, true)) {
       novoLog.update(
           beforeUpdate,
           "ID: "
               + correcao.getId()
               + " - Índice: ("
               + correcao.getIndice().getId()
               + ") "
               + " - Serviços: ("
               + correcao.getServicos().getId()
               + ") "
               + correcao.getServicos().getDescricao()
               + " - Período: "
               + correcao.getReferenciaInicial()
               + " - "
               + correcao.getReferenciaFinal()
               + " - Juros Diário: "
               + correcao.getJurosDiarios()
               + " - Juros 1º Mês: "
               + correcao.getJurosPriMes()
               + " - Juros >= 2º Mês: "
               + correcao.getJurosApartir2Mes()
               + " - Multa por Funcionário: "
               + correcao.getMultaPorFuncionario()
               + " - Multa 1º Mês: "
               + correcao.getMultaPriMes()
               + " - Multa >= 2º Mês: "
               + correcao.getMultaApartir2Mes());
       GenericaMensagem.info("Sucesso", "Correção Atualizada!");
       correcao = new Correcao();
       idIndices = 0;
       idServicos = 0;
     } else {
       GenericaMensagem.warn("Erro", "Erro ao atualizar!");
     }
   } else {
     GenericaMensagem.warn("Validação", "Referencia Invalida!");
   }
   listaCorrecao.clear();
 }