Beispiel #1
0
        public bool Ativar(PTV ptv)
        {
            try
            {
                PTV PTVBanco = Obter(ptv.Id, false);
                ptv.Numero   = PTVBanco.Numero;
                ptv.Produtos = PTVBanco.Produtos;

                if (PTVBanco.NumeroTipo == (int)eDocumentoFitossanitarioTipoNumero.Digital && PTVBanco.Situacao == (int)ePTVSituacao.EmElaboracao)
                {
                    string numero = VerificarNumeroPTV(string.Empty, ptv.NumeroTipo.GetValueOrDefault());
                    if (!string.IsNullOrEmpty(numero))
                    {
                        ptv.Numero = Convert.ToInt64(numero);
                    }

                    if (!Validacao.EhValido)
                    {
                        return(Validacao.EhValido);
                    }
                }

                if (Validacao.EhValido && _validar.Ativar(ptv.DataAtivacao, PTVBanco))
                {
                    GerenciadorTransacao.ObterIDAtual();

                    using (BancoDeDados bancoDeDados = BancoDeDados.ObterInstancia())
                    {
                        bancoDeDados.IniciarTransacao();

                        _da.Ativar(ptv, bancoDeDados);

                        bancoDeDados.Commit();

                        Validacao.Add(Mensagem.PTV.AtivadoSucesso(ptv.Numero.ToString()));
                    }
                }
            }
            catch (Exception ex)
            {
                Validacao.AddErro(ex);
            }

            return(Validacao.EhValido);
        }
Beispiel #2
0
        internal bool PTVCancelar(PTV ptv)
        {
            if (!FuncionarioHabilitadoValido())
            {
                return(false);
            }

            PTV ptvBanco = _da.Obter(ptv.Id, true);

            ValidacoesGenericasBus.DataMensagem(ptv.DataCancelamento, "DataCancelamento", "cancelamento");

            if (ptvBanco.Situacao != (int)ePTVSituacao.Valido)
            {
                Validacao.Add(Mensagem.PTV.CancelarSituacaoInvalida);
            }

            return(Validacao.EhValido);
        }
Beispiel #3
0
        internal bool Excluir(int id)
        {
            if (!FuncionarioHabilitadoValido())
            {
                return(false);
            }

            PTV ptvBanco = _da.Obter(id, true);

            DateTime dtBanco = (DateTime)ptvBanco.DataEmissao.Data;

            if (ptvBanco.Situacao != (int)ePTVSituacao.EmElaboracao)
            {
                Validacao.Add(Mensagem.PTV.NaoPodeEditarPTV);
            }

            return(Validacao.EhValido);
        }
        public bool ValidarAcessoComunicadorPTV(int idPTV)
        {
            if (!_da.PossuiAcessoComunicadorPTV(idPTV, Executor.Current.Id))
            {
                Validacao.Add(Mensagem.PTV.AcessoNaoPermitido);
                return(false);
            }

            PTV eptv = _da.Obter(idPTV, true);

            if (eptv.Situacao != (int)eSolicitarPTVSituacao.Bloqueado)
            {
                Validacao.Add(Mensagem.PTV.ComunicadorPTVSituacaoInvalida);
                return(false);
            }

            return(true);
        }
Beispiel #5
0
        public ActionResult GerarPdfCredenciado(int id)
        {
            try
            {
                Tecnomapas.EtramiteX.Credenciado.Model.RelatorioIndividual.ModuloHabilitacaoEmissaoPTV.Pdf.PdfEmissaoPTV pdf = new Tecnomapas.EtramiteX.Credenciado.Model.RelatorioIndividual.ModuloHabilitacaoEmissaoPTV.Pdf.PdfEmissaoPTV();
                Tecnomapas.EtramiteX.Credenciado.Model.ModuloPTV.Business.PTVBus PTVBus = new Tecnomapas.EtramiteX.Credenciado.Model.ModuloPTV.Business.PTVBus();
                PTV PTV = PTVBus.Obter(id, simplificado: true);

                int    situacaoId    = PTV.Situacao;
                string situacaoTexto = PTV.SituacaoTexto;
                return(ViewModelHelper.GerarArquivoPdf(pdf.Gerar(id, situacaoId, situacaoTexto), "EPTV"));
            }
            catch (Exception exc)
            {
                Validacao.AddErro(exc);
                return(RedirectToAction("Index", "PTV", Validacao.QueryParamSerializer()));
            }
        }
Beispiel #6
0
        public PTV Obter(int id, bool simplificado = false)
        {
            try
            {
                PTV ptv = new PTV();

                ptv = _da.Obter(id, simplificado);
                ptv.NotaFiscalDeCaixas = ObterNotasFiscalDeCaixas(id);
                ptv.NFCaixa.notaFiscalCaixaApresentacao = (ptv.NotaFiscalDeCaixas.Count() > 0) ? 0 : 1;

                return(ptv);
            }
            catch (Exception ex)
            {
                Validacao.AddErro(ex);
            }

            return(null);
        }
Beispiel #7
0
        /// <summary>
        ///	Buscar Empreendimento
        /// </summary>
        /// <param name="empreendimentoID"></param>
        /// <returns>Retorna o ID e a Descrição do Empreendimento</returns>
        public List <ListaValor> ObterResponsaveisEmpreendimento(int empreendimentoID, List <PTVProduto> produtos)
        {
            try
            {
                int produtorOrigem = 0;
                if (produtos != null && produtos.Count > 0)
                {
                    PTVProduto primeiroItem = produtos.FirstOrDefault(x => x.OrigemTipo == (int)eDocumentoFitossanitarioTipo.CFO || x.OrigemTipo == (int)eDocumentoFitossanitarioTipo.PTV);

                    if (primeiroItem != null)
                    {
                        switch ((eDocumentoFitossanitarioTipo)primeiroItem.OrigemTipo)
                        {
                        case eDocumentoFitossanitarioTipo.CFO:
                            EmissaoCFOBus emissaoCFOBus = new EmissaoCFOBus();
                            EmissaoCFO    cfo           = emissaoCFOBus.Obter(primeiroItem.Origem, true);
                            produtorOrigem = cfo.ProdutorId;
                            break;

                        case eDocumentoFitossanitarioTipo.PTV:
                            PTV ptv = Obter(primeiroItem.Origem, true);
                            produtorOrigem = ptv.ResponsavelEmpreendimento;
                            break;
                        }
                    }
                }

                List <ListaValor> lista = _da.ObterResponsaveisEmpreendimento(empreendimentoID);
                if (produtorOrigem > 0)
                {
                    return(lista.Where(x => x.Id == produtorOrigem).ToList());
                }

                return(lista);
            }
            catch (Exception ex)
            {
                Validacao.AddErro(ex);
            }

            return(new List <ListaValor>());
        }
        public ActionResult GerarPdf(int id)
        {
            try
            {
                if (HttpContext.User != null && HttpContext.User.Identity.IsAuthenticated)
                {
                    PdfEmissaoPTV pdf = new PdfEmissaoPTV();
                    PTV           PTV = _busPTV.Obter(id, simplificado: true);

                    return(ViewModelHelper.GerarArquivoPdf(pdf.Gerar(id, PTV.Tid, PTV.Situacao, PTV.SituacaoTexto), "PTV", dataHoraControleAcesso: true));
                }

                Validacao.Add(Mensagem.Funcionario.SemPermissao);
                return(Redirect(FormsAuthentication.LoginUrl));
            }
            catch (Exception exc)
            {
                Validacao.AddErro(exc);
                return(RedirectToAction("Index", "PTV", Validacao.QueryParamSerializer()));
            }
        }
Beispiel #9
0
        public PTVVM(PTV ptv, List <Lista> lstSituacoes, List <ListaValor> lsResponsavel, List <Lista> lsOrigem, List <TratamentoFitossanitario> lsFitossanitario,
                     List <LaudoLaboratorial> lstLaboratorio, List <Lista> lstCultura, List <Lista> lsTipoTransporte, List <Municipio> lsLocalEmissao, List <Setor> LsSetor, bool isVisualizar = false, List <ListaValor> lsDiaHoraVistoria = null)
        {
            this.PTV          = ptv ?? new PTV();
            this.IsVisualizar = isVisualizar;

            if (lsResponsavel.Count == 1)
            {
                this.PTV.ResponsavelEmpreendimento = lsResponsavel.First().Id;
            }

            this.Situacoes = ViewModelHelper.CriarSelectList(lstSituacoes, true, true, ptv.Situacao.ToString());

            ResponsavelList = ViewModelHelper.CriarSelectList(lsResponsavel, true, true, ptv.ResponsavelEmpreendimento.ToString());

            OrigemTipoList = ViewModelHelper.CriarSelectList(lsOrigem.OrderBy(x => x.Id).ToList(), true, true);

            LsTratamentoFitossanitario = lsFitossanitario ?? new List <TratamentoFitossanitario>();

            this.LstCultura = ViewModelHelper.CriarSelectList(lstCultura);

            this.LsTipoTransporte = ViewModelHelper.CriarSelectList(lsTipoTransporte, true, true, ptv.TransporteTipo.ToString());

            LsLaudoLaboratorial = lstLaboratorio ?? new List <LaudoLaboratorial>();

            if (LsSetor.Count == 1 && ptv.Id >= 0)
            {
                LsSetor.ForEach(x =>
                {
                    ptv.LocalEmissaoId = x.Id;
                });
            }

            this.lsLocalEmissao = ViewModelHelper.CriarSelectList(lsLocalEmissao, true, true, ptv.LocalEmissaoId.ToString());

            this.lsLocalVistoria = ViewModelHelper.CriarSelectList(LsSetor, true, true, ptv.LocalVistoriaId.ToString());

            this.lsDiaHoraVistoria = ViewModelHelper.CriarSelectList(lsDiaHoraVistoria, true, true, ptv.DataHoraVistoriaId.ToString());
        }
        public ActionResult Criar()
        {
            if (!_validar.FuncionarioHabilitadoValido())
            {
                return(RedirectToAction("Index", Validacao.QueryParamSerializer()));
            }

            List <TratamentoFitossanitario> lsFitossanitario = null;
            EtramiteIdentity  func    = User.Identity as EtramiteIdentity;
            List <ListaValor> LsSetor = _busPTV.ObterLocalEmissao(func.UsuarioId);

            PTV ptv = new PTV();

            ptv.NumeroTipo              = (int)eDocumentoFitossanitarioTipoNumero.Digital;
            ptv.PartidaLacradaOrigem    = (int)ePartidaLacradaOrigem.Nao;
            ptv.Destinatario.PessoaTipo = (int)ePessoaTipo.Fisica;
            ptv.RotaTransitoDefinida    = (int)eRotaTransitoDefinida.Sim;
            ptv.NotaFiscalApresentacao  = (int)eApresentacaoNotaFiscal.Sim;
            ptv.Situacao = (int)ePTVSituacao.EmElaboracao;

            _busPTV.ObterResponsavelTecnico(func.FuncionarioId).ForEach(x => { ptv.ResponsavelTecnicoId = x.Id; ptv.ResponsavelTecnicoNome = x.Texto; });

            PTVVM vm = new PTVVM(
                ptv,
                _busLista.PTVSituacao.Where(x => Convert.ToInt32(x.Id) != (int)eDocumentoFitossanitarioSituacao.Cancelado).ToList(),
                new List <ListaValor>(),
                _busLista.DocumentosFitossanitario.Where(x => x.Id != "7").ToList(),
                lsFitossanitario,
                new List <LaudoLaboratorial>(),
                _busPTV.ObterCultura(),
                _busLista.TipoTransporte,
                _busLista.Municipios(8), LsSetor);

            vm.EstadosUF   = ViewModelHelper.CriarSelectList(_busLista.Estados);
            vm.LstUnidades = ViewModelHelper.CriarSelectList(_busLista.PTVUnidadeMedida);

            return(View("Criar", vm));
        }
        public ActionResult Editar(int id)
        {
            PTV ptv = _busPTV.Obter(id);

            if (!_validar.ValidarSituacao(ptv))
            {
                return(RedirectToAction("Index", "PTV", Validacao.QueryParamSerializer()));
            }

            List <Setor>                    locaisVistorias  = _busPTV.SetoresLocalVistoria();
            List <LaudoLaboratorial>        lstLaboratorio   = _busPTV.ObterLaudoLaboratorial(ptv.Produtos);
            List <TratamentoFitossanitario> lsFitossanitario = _busPTV.TratamentoFitossanitário(ptv.Produtos);

            if (lsFitossanitario != null && lsFitossanitario.Count > 5)
            {
                lsFitossanitario.RemoveAt(5);
                lsFitossanitario.RemoveAt(0);
            }

            PTVVM vm = new PTVVM(
                ptv,
                ListaCredenciadoBus.PTVSolicitacaoSituacao,
                _busPTV.ObterResponsaveisEmpreendimento(ptv.Empreendimento, ptv.Produtos),
                ListaCredenciadoBus.DocumentosFitossanitario,
                lsFitossanitario,
                lstLaboratorio,
                _busPTV.ObterCultura(),
                ListaCredenciadoBus.TipoTransporte,
                ListaCredenciadoBus.Municipios(8),
                locaisVistorias, false, _busPTV.DiasHorasVistoria(ptv.LocalVistoriaId, ptv.DataVistoria.AddDays(-1)));

            DestinatarioPTVBus _destinatarioBus = new DestinatarioPTVBus();

            vm.PTV.Destinatario = _destinatarioBus.Obter(ptv.DestinatarioID);
            vm.LstUnidades      = ViewModelHelper.CriarSelectList(ListaCredenciadoBus.PTVUnidadeMedida);

            return(View("Editar", vm));
        }
        public ActionResult Editar(int id)
        {
            if (!_validar.FuncionarioHabilitadoValido())
            {
                return(RedirectToAction("Index", Validacao.QueryParamSerializer()));
            }

            PTV ptv = _busPTV.Obter(id);

            if (!_validar.ValidarSituacao(ptv))
            {
                return(RedirectToAction("Index", "PTV", Validacao.QueryParamSerializer()));
            }

            List <TratamentoFitossanitario> lsFitossanitario = _busPTV.TratamentoFitossanitário(ptv.Produtos);
            List <LaudoLaboratorial>        lstLaboratorio   = _busPTV.ObterLaudoLaboratorial(ptv.Produtos);

            PTVVM vm = new PTVVM(
                ptv,
                _busLista.PTVSituacao,
                _busPTV.ObterResponsaveisEmpreendimento(ptv.Empreendimento, ptv.Produtos),
                _busLista.DocumentosFitossanitario.Where(x => x.Id != "7").ToList(),
                lsFitossanitario,
                lstLaboratorio,
                _busPTV.ObterCultura(),
                _busLista.TipoTransporte,
                _busLista.Municipios(8),
                new List <ListaValor>());

            vm.EstadosUF    = ViewModelHelper.CriarSelectList(_busLista.Estados, true, true, ptv.SemDocOrigem.ufEndereco.ToString());
            vm.MunicipiosOT = ViewModelHelper.CriarSelectList(_busLista.Municipios(ptv.SemDocOrigem.ufEndereco), true, true, ptv.SemDocOrigem.municipioEndereco.ToString());
            DestinatarioPTVBus _destinatarioBus = new DestinatarioPTVBus();

            vm.PTV.Destinatario = _destinatarioBus.Obter(ptv.DestinatarioID);
            vm.LstUnidades      = ViewModelHelper.CriarSelectList(_busLista.PTVUnidadeMedida);

            return(View("Editar", vm));
        }
Beispiel #13
0
        public PTV ObterPorIDCredenciado(int id, bool simplificado = false)
        {
            try
            {
                PTV ptv = new PTV();

                ptv = _da.ObterPorIDCredenciado(id, simplificado);
                ptv.NotaFiscalDeCaixas = ObterNotasFiscalDeCaixas(ptv.Id);
                ptv.NFCaixa.notaFiscalCaixaApresentacao = (ptv.NotaFiscalDeCaixas.Count() > 0) ? 0 : 1;
                if (ptv.Produtos.Count() > 0)
                {
                    ptv.IsPossuiDocOrigem = (ptv.Produtos[0].OrigemTipo == (int)eDocumentoFitossanitarioTipo.SemDocOrigem) ? 0 : 1;
                }

                return(ptv);
            }
            catch (Exception ex)
            {
                Validacao.AddErro(ex);
            }

            return(null);
        }
Beispiel #14
0
        public decimal ObterSaldoDocOrigem(PTVProduto prod)
        {
            decimal saldo = 0;

            switch ((eDocumentoFitossanitarioTipo)prod.OrigemTipo)
            {
            case eDocumentoFitossanitarioTipo.CFO:
                EmissaoCFOBus emissaoCFOBus = new EmissaoCFOBus();
                EmissaoCFO    cfo           = emissaoCFOBus.Obter(prod.Origem);
                saldo = cfo.Produtos.Where(x => x.CultivarId == prod.Cultivar && x.UnidadeMedidaId == prod.UnidadeMedida).Sum(x => x.Quantidade);
                break;

            case eDocumentoFitossanitarioTipo.CFOC:
                EmissaoCFOCBus emissaoCFOCBus = new EmissaoCFOCBus();
                EmissaoCFOC    cfoc           = emissaoCFOCBus.Obter(prod.Origem);
                saldo = cfoc.Produtos.Where(x => x.CultivarId == prod.Cultivar && x.UnidadeMedidaId == prod.UnidadeMedida).Sum(x => x.Quantidade);
                break;

            case eDocumentoFitossanitarioTipo.PTVOutroEstado:
                PTVOutroBus ptvOutroBus = new PTVOutroBus();
                PTVOutro    ptvOutro    = ptvOutroBus.Obter(prod.Origem);
                saldo = ptvOutro.Produtos.Where(x => x.Cultivar == prod.Cultivar && x.UnidadeMedida == prod.UnidadeMedida).Sum(x => x.Quantidade);
                break;

            case eDocumentoFitossanitarioTipo.PTV:
                PTVInternoBus ptvBus = new PTVInternoBus();
                PTV           ptv    = ptvBus.Obter(prod.Origem);
                saldo = ptv.Produtos.Where(x => x.Cultivar == prod.Cultivar && x.UnidadeMedida == prod.UnidadeMedida).Sum(x => x.Quantidade);
                break;
            }

            decimal saldoOutrosDoc = _da.ObterOrigemQuantidade((eDocumentoFitossanitarioTipo)prod.OrigemTipo, prod.Origem, prod.OrigemNumero, prod.Cultivar, prod.UnidadeMedida, 0);                //o último parâmetro, idPTV, nesse caso não importa, porque o PTV atual não deve ser desconsiderado do cálculo

            saldo = saldo - saldoOutrosDoc;

            return(saldo);
        }
Beispiel #15
0
        public bool ValidarAcessoComunicadorPTV(int idPTV)
        {
            if (!FuncionarioHabilitadoValido())
            {
                return(false);
            }

            Tecnomapas.EtramiteX.Credenciado.Model.ModuloPTV.Business.PTVBus ptvCredenciadoBus = new Tecnomapas.EtramiteX.Credenciado.Model.ModuloPTV.Business.PTVBus();
            PTV eptv = ptvCredenciadoBus.Obter(idPTV, true);

            if (!_da.PossuiAcessoComunicadorPTV(Executor.Current.Id, eptv.LocalVistoriaId))
            {
                Validacao.Add(Mensagem.PTV.AcessoNaoPermitido);
                return(false);
            }

            if (eptv.Situacao != (int)eSolicitarPTVSituacao.Bloqueado)
            {
                Validacao.Add(Mensagem.PTV.ComunicadorPTVSituacaoInvalida);
                return(false);
            }

            return(true);
        }
Beispiel #16
0
        internal bool Salvar(PTV ptv)
        {
            if (!ValidarSituacao(ptv))
            {
                return(Validacao.EhValido);
            }

            #region [ Validação de DUA ]

            if (!ValidarUtilizacaoDUA(ptv.Id, ptv.NumeroDua, ptv.CPFCNPJDUA, ptv.TipoPessoa.ToString()))
            {
                return(Validacao.EhValido);
            }

            #endregion

            if (ptv.NumeroTipo != (int)eDocumentoFitossanitarioTipoNumero.Digital && ptv.NumeroTipo != (int)eDocumentoFitossanitarioTipoNumero.Bloco)
            {
                Validacao.Add(Mensagem.PTV.TipoNumeroObrigatorio);
            }
            if (ptv.NumeroTipo == (int)eDocumentoFitossanitarioTipoNumero.Bloco && ptv.Numero <= 0)
            {
                Validacao.Add(Mensagem.PTV.NumeroPTVObrigatorio);
            }

            ValidacoesGenericasBus.DataMensagem(ptv.DataEmissao, "DataEmissao", "emissão");

            if (ptv.Situacao <= 0)
            {
                Validacao.Add(Mensagem.PTV.SituacaoObrigatorio);
            }

            if (ptv.Empreendimento <= 0)
            {
                Validacao.Add(Mensagem.PTV.EmpreendimentoObrigatorio);
            }

            if (_da.EmpreendimentoPossuiEPTVBloqueado(ptv.Id, ptv.Empreendimento))
            {
                Validacao.Add(Mensagem.PTV.EmpreendimentoEPTVBloqueado);
            }

            if (ptv.ResponsavelEmpreendimento <= 0)
            {
                Validacao.Add(Mensagem.PTV.ResponsavelEmpreend_Obrigatorio);
            }

            if (ptv.Produtos.Count <= 0)
            {
                Validacao.Add(Mensagem.PTV.Identificacao_Produto_Obrigatorio);
            }
            else
            {
                ptv.Produtos.ForEach(item =>
                {
                    ValidarProduto(item, ptv.DataEmissao, ptv.Produtos, ptv.Id);
                });
            }

            if (!ptv.PartidaLacradaOrigem.HasValue)
            {
                Validacao.Add(Mensagem.PTV.PartidaLacrada_Obrigatorio);
            }

            if (ptv.PartidaLacradaOrigem == (int)ePartidaLacradaOrigem.Sim && (String.IsNullOrEmpty(ptv.LacreNumero) && String.IsNullOrEmpty(ptv.PoraoNumero) && String.IsNullOrEmpty(ptv.ContainerNumero)))
            {
                Validacao.Add(Mensagem.PTV.Lacre_porao_container_Obrigatorio);
            }

            if (ptv.DestinatarioID <= 0)
            {
                Validacao.Add(Mensagem.PTV.DestinatarioObrigatorio);
            }

            if (!ptv.PossuiLaudoLaboratorial.HasValue)
            {
                Validacao.Add(Mensagem.PTV.PossuiLaudoLab_Obrigatorio);
            }

            if (ptv.TransporteTipo <= 0)
            {
                Validacao.Add(Mensagem.PTV.TipoTransporteObrigatorio);
            }

            if (String.IsNullOrEmpty(ptv.VeiculoIdentificacaoNumero))
            {
                Validacao.Add(Mensagem.PTV.IdentificacaoVeiculoObrigatorio);
            }

            if (!ptv.RotaTransitoDefinida.HasValue)
            {
                Validacao.Add(Mensagem.PTV.RotaTransitoObrigatorio);
            }
            if (ptv.RotaTransitoDefinida == (int)eRotaTransitoDefinida.Sim && String.IsNullOrEmpty(ptv.Itinerario))
            {
                Validacao.Add(Mensagem.PTV.Itinerário_Obrigatorio);
            }

            if (!ptv.NotaFiscalApresentacao.HasValue || ptv.NotaFiscalApresentacao == (int)eApresentacaoNotaFiscal.Nao)
            {
                Validacao.Add(Mensagem.PTV.ApresentaçãoNotaFiscal_Obrigatorio);
            }

            if (ptv.NotaFiscalApresentacao == (int)eApresentacaoNotaFiscal.Sim && String.IsNullOrEmpty(ptv.NotaFiscalNumero))
            {
                Validacao.Add(Mensagem.PTV.NumeroNotaFiscal_Obrigatorio);
            }

            if (ptv.LocalVistoriaId <= 0)
            {
                Validacao.Add(Mensagem.PTV.LocalVistoriaObrigatorio);
            }

            if (ptv.DataHoraVistoriaId <= 0)
            {
                Validacao.Add(Mensagem.PTV.VistoriaCargaObrigatorio);
            }

            if (ptv.Anexos == null || ptv.Anexos.Count <= 0)
            {
                Validacao.Add(Mensagem.PTV.AnexoObrigatorio);
            }
            else
            {
                if (ptv.Anexos.Count > 5)
                {
                    Validacao.Add(Mensagem.PTV.AnexoLimiteMaximo);
                }

                if (ptv.Anexos.Exists(x => x.Arquivo.Extensao != ".pdf" && x.Arquivo.Extensao != ".jpg" && x.Arquivo.Extensao != ".png"))
                {
                    Validacao.Add(Mensagem.PTV.AnexoFormatoErrado);
                }

                //if (ptv.Anexos.Exists(x => x.Arquivo.Buffer.Length > 2097152))/*2mb*/
                //{
                //	Validacao.Add(Mensagem.PTV.AnexoTamanhoErrado);
                //}
            }

            return(Validacao.EhValido);
        }
Beispiel #17
0
        public bool ValidarProduto(PTVProduto item, DateTecno ptvData, List <PTVProduto> lista, int ptvID)
        {
            lista = lista ?? new List <PTVProduto>();

            if (item.OrigemTipo <= 0)
            {
                Validacao.Add(Mensagem.PTV.TipoOrigemObrigatorio);
            }

            if (item.Origem <= 0 && string.IsNullOrEmpty(item.OrigemNumero))
            {
                Validacao.Add(Mensagem.PTV.OrigemObrigatorio);
            }

            var loteBus = new LoteBus();

            if (item.OrigemTipo == (int)eDocumentoFitossanitarioTipo.CFO && loteBus.VerificarSeCfoJaAssociadaALote(item.Origem))
            {
                Validacao.Add(Mensagem.EmissaoCFO.DocumentoOrigemDeveSerDeMesmaUC);
                return(false);
            }

            #region Saldo

            //TODO
            decimal saldo        = 0;
            int     produtorItem = 0;
            switch ((eDocumentoFitossanitarioTipo)item.OrigemTipo)
            {
            case eDocumentoFitossanitarioTipo.CFO:
                EmissaoCFOBus emissaoCFOBus = new EmissaoCFOBus();
                EmissaoCFO    cfo           = emissaoCFOBus.Obter(item.Origem);
                saldo        = cfo.Produtos.Where(x => x.CultivarId == item.Cultivar && x.UnidadeMedidaId == item.UnidadeMedida).Sum(x => x.Quantidade);
                produtorItem = cfo.ProdutorId;

                if (cfo.SituacaoId != (int)eDocumentoFitossanitarioSituacao.Valido)
                {
                    Validacao.Add(Mensagem.PTV.OrigemSituacaoInvalida(item.OrigemTipoTexto));
                }

                DateTime dataVencimentoCFO = cfo.DataEmissao.Data.GetValueOrDefault().AddDays(cfo.ValidadeCertificado);
                if (dataVencimentoCFO < DateTime.Today)
                {
                    Validacao.Add(Mensagem.Lote.OrigemVencida(item.OrigemTipoTexto));
                }

                if (cfo.DataEmissao.Data > ptvData.Data)
                {
                    Validacao.Add(Mensagem.Lote.OrigemDataMaiorLoteData);
                }
                break;

            case eDocumentoFitossanitarioTipo.CFOC:
                EmissaoCFOCBus emissaoCFOCBus = new EmissaoCFOCBus();
                EmissaoCFOC    cfoc           = emissaoCFOCBus.Obter(item.Origem);
                saldo = cfoc.Produtos.Where(x => x.CultivarId == item.Cultivar && x.UnidadeMedidaId == item.UnidadeMedida).Sum(x => x.Quantidade);

                if (cfoc.SituacaoId != (int)eDocumentoFitossanitarioSituacao.Valido)
                {
                    Validacao.Add(Mensagem.PTV.OrigemSituacaoInvalida(item.OrigemTipoTexto));
                }

                DateTime dataVencimentoCFOC = cfoc.DataEmissao.Data.GetValueOrDefault().AddDays(cfoc.ValidadeCertificado);
                if (dataVencimentoCFOC < DateTime.Today)
                {
                    Validacao.Add(Mensagem.Lote.OrigemVencida(item.OrigemTipoTexto));
                }

                if (cfoc.DataEmissao.Data > ptvData.Data)
                {
                    Validacao.Add(Mensagem.Lote.OrigemDataMaiorLoteData);
                }
                break;

            case eDocumentoFitossanitarioTipo.PTVOutroEstado:
                PTVOutroBus ptvOutroBus = new PTVOutroBus();
                PTVOutro    ptvOutro    = ptvOutroBus.Obter(item.Origem);
                saldo = ptvOutro.Produtos.Where(x => x.Cultivar == item.Cultivar && x.UnidadeMedida == item.UnidadeMedida).Sum(x => x.Quantidade);

                if (ptvOutro.Situacao != (int)ePTVOutroSituacao.Valido)
                {
                    Validacao.Add(Mensagem.PTV.OrigemSituacaoInvalida(item.OrigemTipoTexto));
                }

                if (ptvOutro.ValidoAte.Data.GetValueOrDefault() < DateTime.Today)
                {
                    Validacao.Add(Mensagem.Lote.OrigemVencida(item.OrigemTipoTexto));
                }

                if (ptvOutro.DataEmissao.Data > ptvData.Data)
                {
                    Validacao.Add(Mensagem.Lote.OrigemDataMaiorLoteData);
                }
                break;

            case eDocumentoFitossanitarioTipo.PTV:
                PTVInternoBus ptvBus = new PTVInternoBus();
                PTV           ptv    = ptvBus.Obter(item.Origem);
                saldo        = ptv.Produtos.Where(x => x.Cultivar == item.Cultivar && x.UnidadeMedida == item.UnidadeMedida).Sum(x => x.Quantidade);
                produtorItem = ptv.ResponsavelEmpreendimento;
                break;
            }

            #endregion Saldo

            if (lista.Count > 0 && produtorItem > 0)
            {
                int        produtorOrigem = 0;
                PTVProduto primeiroItem   = lista.FirstOrDefault(x => x.OrigemTipo == (int)eDocumentoFitossanitarioTipo.CFO || x.OrigemTipo == (int)eDocumentoFitossanitarioTipo.PTV);

                if (primeiroItem != null)
                {
                    switch ((eDocumentoFitossanitarioTipo)primeiroItem.OrigemTipo)
                    {
                    case eDocumentoFitossanitarioTipo.CFO:
                        EmissaoCFOBus emissaoCFOBus = new EmissaoCFOBus();
                        EmissaoCFO    cfo           = emissaoCFOBus.Obter(primeiroItem.Origem, true);
                        produtorOrigem = cfo.ProdutorId;
                        break;

                    case eDocumentoFitossanitarioTipo.PTV:
                        PTVInternoBus ptvBus = new PTVInternoBus();
                        PTV           ptv    = ptvBus.Obter(primeiroItem.Origem, true);
                        produtorOrigem = ptv.ResponsavelEmpreendimento;
                        break;
                    }

                    if (produtorItem != produtorOrigem)
                    {
                        Validacao.Add(Mensagem.PTV.ProdutorDiferente);
                    }
                }
            }

            if (!Validacao.EhValido)
            {
                return(false);
            }

            if (item.Cultura <= 0)
            {
                Validacao.Add(Mensagem.PTV.CulturaObrigatorio);
            }
            if (item.Cultivar <= 0)
            {
                Validacao.Add(Mensagem.PTV.CultivarObrigatorio);
            }

            if (item.UnidadeMedida <= 0)
            {
                Validacao.Add(Mensagem.PTV.UnidadeMedidaObrigatorio);
            }

            if (item.Quantidade <= 0)
            {
                Validacao.Add(Mensagem.PTV.QuantidadeObrigatorio);
            }

            if (lista.Count(x => !x.Equals(item)) >= 5)
            {
                Validacao.Add(Mensagem.PTV.QauntidadeItensUltrapassado);
            }

            if (Validacao.EhValido && lista.Count > 0)
            {
                if (lista.Count(x => x.Origem == item.Origem && item.Cultivar == x.Cultivar && x.UnidadeMedida == item.UnidadeMedida && !x.Equals(item)) > 0)
                {
                    Validacao.Add(Mensagem.PTV.ITemProdutoJaAdicionado(item.OrigemTipoTexto));
                }

                if (lista.Count(x => x.EmpreendimentoId != item.EmpreendimentoId && x.EmpreendimentoId > 0) > 0)
                {
                    Validacao.Add(Mensagem.PTV.EmpreendimentoOrigemDiferente);
                }
            }

            if (Validacao.EhValido)
            {
                if (_da.EmpreendimentoPossuiEPTVBloqueado(item.EmpreendimentoId))
                {
                    Validacao.Add(Mensagem.PTV.EmpreendimentoEPTVBloqueado);
                }
            }

            if (Validacao.EhValido)
            {
                if (item.OrigemTipo != (int)eDocumentoFitossanitarioTipo.CFCFR && item.OrigemTipo != (int)eDocumentoFitossanitarioTipo.TF)
                {
                    decimal saldoOutrosDoc = _da.ObterOrigemQuantidade((eDocumentoFitossanitarioTipo)item.OrigemTipo, item.Origem, item.OrigemNumero, item.Cultivar, item.UnidadeMedida, ptvData.Data.GetValueOrDefault().Year, ptvID);

                    decimal quantidadeAdicionada = lista.Where(x => x.OrigemTipo == item.OrigemTipo && x.Origem == item.Origem && x.Cultivar == item.Cultivar && x.UnidadeMedida == item.UnidadeMedida && !x.Equals(item)).Sum(x => x.Quantidade);

                    if ((saldoOutrosDoc + quantidadeAdicionada + item.Quantidade) > saldo)
                    {
                        Validacao.Add(Mensagem.PTV.SomaQuantidadeInvalida);
                    }
                }
            }

            return(Validacao.EhValido);
        }
        internal PTV Obter(int id, bool simplificado = false, BancoDeDados banco = null)
        {
            using (BancoDeDados bancoDeDados = BancoDeDados.ObterInstancia())
            {
                PTV PTV = new PTV();

                Comando comando = bancoDeDados.CriarComando(@"select p.id, p.tid, p.tipo_numero, p.numero, p.data_emissao, p.situacao,
				lst.texto situacao_texto, p.empreendimento, p.responsavel_emp, em.denominador, p.partida_lacrada_origem, p.numero_lacre,
				p.numero_porao, p.numero_container, p.destinatario, p.possui_laudo_laboratorial, p.tipo_transporte, 
				p.veiculo_identificacao_numero, p.rota_transito_definida, p.itinerario, p.apresentacao_nota_fiscal,
				p.numero_nota_fiscal, p.valido_ate, p.responsavel_tecnico, f.nome responsavel_tecnico_nome, p.municipio_emissao 
				from {0}tab_ptv p, {0}tab_empreendimento em, lov_ptv_situacao lst, {0}tab_funcionario f
				where em.id = p.empreendimento and lst.id = p.situacao and p.responsavel_tecnico = f.id and p.id = :id"                , Esquema);

                comando.AdicionarParametroEntrada("id", id, DbType.Int32);

                using (IDataReader reader = bancoDeDados.ExecutarReader(comando))
                {
                    if (reader.Read())
                    {
                        PTV.Id                         = id;
                        PTV.Tid                        = reader.GetValue <string>("tid");
                        PTV.Numero                     = reader.GetValue <Int64>("numero");
                        PTV.NumeroTipo                 = reader.GetValue <int>("tipo_numero");
                        PTV.DataEmissao.Data           = reader.GetValue <DateTime>("data_emissao");
                        PTV.Situacao                   = reader.GetValue <int>("situacao");
                        PTV.SituacaoTexto              = reader.GetValue <string>("situacao_texto");
                        PTV.Empreendimento             = reader.GetValue <int>("empreendimento");
                        PTV.ResponsavelEmpreendimento  = reader.GetValue <int>("responsavel_emp");
                        PTV.EmpreendimentoTexto        = reader.GetValue <string>("denominador");
                        PTV.PartidaLacradaOrigem       = reader.GetValue <int>("partida_lacrada_origem");
                        PTV.LacreNumero                = reader.GetValue <string>("numero_lacre");
                        PTV.PoraoNumero                = reader.GetValue <string>("numero_porao");
                        PTV.ContainerNumero            = reader.GetValue <string>("numero_container");
                        PTV.DestinatarioID             = reader.GetValue <int>("destinatario");
                        PTV.PossuiLaudoLaboratorial    = reader.GetValue <int>("possui_laudo_laboratorial");
                        PTV.TransporteTipo             = reader.GetValue <int>("tipo_transporte");
                        PTV.VeiculoIdentificacaoNumero = reader.GetValue <string>("veiculo_identificacao_numero");
                        PTV.RotaTransitoDefinida       = reader.GetValue <int>("rota_transito_definida");
                        PTV.Itinerario                 = reader.GetValue <string>("itinerario");
                        PTV.NotaFiscalApresentacao     = reader.GetValue <int>("apresentacao_nota_fiscal");
                        PTV.NotaFiscalNumero           = reader.GetValue <string>("numero_nota_fiscal");
                        PTV.ValidoAte.Data             = reader.GetValue <DateTime>("valido_ate");
                        PTV.ResponsavelTecnicoId       = reader.GetValue <int>("responsavel_tecnico");
                        PTV.ResponsavelTecnicoNome     = reader.GetValue <string>("responsavel_tecnico_nome");
                        PTV.LocalEmissaoId             = reader.GetValue <int>("municipio_emissao");
                    }

                    reader.Close();
                }

                if (PTV.Id <= 0 || simplificado)
                {
                    return(PTV);
                }

                #region PTV Produto

                comando = bancoDeDados.CriarComando(@"select pr.id,
															 pr.tid,
															 pr.ptv,
															 pr.origem_tipo,
															 pr.origem,
															 case pr.origem_tipo 
															    when 1 then (select t.numero from cre_cfo t where t.id = pr.origem) 
															    when 2 then (select t.numero from cre_cfoc t where t.id = pr.origem) 
															    when 3 then (select t.numero from tab_ptv t where t.id = pr.origem) 
																when 4 then (select t.numero from tab_ptv_outrouf t where t.id = pr.origem) 
															 else pr.numero_origem end as origem_texto,
															 pr.numero_origem,
															 t.texto tipo_origem_texto,
															 pr.cultura,
															 pr.cultivar,
															 c.texto ||'/'||cc.cultivar as cultura_cultivar,
															 pr.quantidade,
															 pr.unidade_medida,
															 u.texto unidade_medida_texto
														from tab_ptv_produto pr, lov_doc_fitossanitarios_tipo t, tab_cultura c, tab_cultura_cultivar cc, lov_crt_uni_prod_uni_medida  u
														where t.id = pr.origem_tipo  
														  and c.id = pr.cultura
														  and cc.id = pr.cultivar
														  and u.id = pr.unidade_medida    
														  and pr.ptv = :ptv"                                                        , Esquema);

                comando.AdicionarParametroEntrada("ptv", PTV.Id, DbType.Int32);

                using (IDataReader reader = bancoDeDados.ExecutarReader(comando))
                {
                    while (reader.Read())
                    {
                        PTV.Produtos.Add(new PTVProduto()
                        {
                            Id                 = reader.GetValue <int>("id"),
                            Tid                = reader.GetValue <string>("tid"),
                            PTV                = reader.GetValue <int>("ptv"),
                            OrigemTipo         = reader.GetValue <int>("origem_tipo"),
                            OrigemTipoTexto    = reader.GetValue <string>("tipo_origem_texto") + '-' + reader.GetValue <string>("origem_texto"),
                            Origem             = reader.GetValue <int>("origem"),                //Origem ID
                            OrigemNumero       = reader.GetValue <string>("numero_origem"),      //PTV outro Estado
                            IsNumeroOrigem     = String.IsNullOrEmpty(reader.GetValue <string>("origem")),
                            Cultura            = reader.GetValue <int>("cultura"),
                            Cultivar           = reader.GetValue <int>("cultivar"),
                            CulturaCultivar    = reader.GetValue <string>("cultura_cultivar"),
                            Quantidade         = reader.GetValue <decimal>("quantidade"),
                            UnidadeMedida      = reader.GetValue <int>("unidade_medida"),
                            UnidadeMedidaTexto = reader.GetValue <string>("unidade_medida_texto")
                        });
                    }

                    reader.Close();
                }
                #endregion

                return(PTV);
            }
        }
Beispiel #19
0
        //Valida um item que está sendo incluído no lote
        public void Lote(LoteItem item, DateTecno loteData, int empreendimentoID, List <LoteItem> lista, int loteID)
        {
            if (empreendimentoID <= 0)
            {
                Validacao.Add(Mensagem.Lote.EmpreendimentoObrigatorio);
                return;
            }

            if (item.OrigemTipo <= 0)
            {
                Validacao.Add(Mensagem.Lote.OrigemObrigatorio);
            }

            if (item.Cultura <= 0)
            {
                Validacao.Add(Mensagem.Lote.CulturaObrigatoria);
            }

            if (item.Cultivar <= 0)
            {
                Validacao.Add(Mensagem.Lote.CultivarObrigatoria);
            }

            if (item.OrigemTipo >= 5 && item.Quantidade <= 0)
            {
                Validacao.Add(Mensagem.Lote.QuantidadeObrigatorio);
            }

            if (lista.Count(x => x.OrigemTipo == item.OrigemTipo && x.OrigemNumero == item.OrigemNumero && x.Serie == item.Serie && !x.Equals(item)) > 0)
            {
                Validacao.Add(Mensagem.Lote.OrigemJaAdicionada(item.OrigemTipoTexto, item.OrigemNumero.ToString()));
            }

            if (lista != null && lista.Count > 0 && !lista.Any(x => x.Cultivar == item.Cultivar))
            {
                Validacao.Add(Mensagem.Lote.CultivarUnico);
            }

            if (lista != null && lista.Count > 0 && lista.Any(x => x.UnidadeMedida != item.UnidadeMedida))
            {
                Validacao.Add(Mensagem.Lote.UnidadeMedidaUnico);
            }

            if (!Validacao.EhValido)
            {
                return;
            }

            int     auxiliar       = 0;
            decimal saldoDocOrigem = 0;
            List <IdentificacaoProduto> produtos = OrigemNumero(item.OrigemNumero, item.OrigemTipo, item.Serie, out auxiliar);

            if (produtos != null)
            {
                switch ((eDocumentoFitossanitarioTipo)item.OrigemTipo)
                {
                case eDocumentoFitossanitarioTipo.CFO:
                    EmissaoCFOBus emissaoCFOBus = new EmissaoCFOBus();
                    EmissaoCFO    cfo           = emissaoCFOBus.Obter(item.Origem);
                    saldoDocOrigem = cfo.Produtos.Where(x => x.CultivarId == item.Cultivar && x.UnidadeMedidaId == item.UnidadeMedida).Sum(x => x.Quantidade);

                    if (cfo.SituacaoId != (int)eDocumentoFitossanitarioSituacao.Valido)
                    {
                        Validacao.Add(Mensagem.Lote.OrigemSituacaoInvalida(item.OrigemTipoTexto));
                    }

                    DateTime dataVencimentoCFO = cfo.DataAtivacao.Data.GetValueOrDefault().AddDays(cfo.ValidadeCertificado);
                    if (dataVencimentoCFO < DateTime.Today)
                    {
                        Validacao.Add(Mensagem.Lote.OrigemVencida(item.OrigemTipoTexto));
                    }

                    if (cfo.DataEmissao.Data > loteData.Data)
                    {
                        Validacao.Add(Mensagem.Lote.OrigemDataMaiorLoteData);
                    }
                    break;

                case eDocumentoFitossanitarioTipo.CFOC:
                    EmissaoCFOCBus emissaoCFOCBus = new EmissaoCFOCBus();
                    EmissaoCFOC    cfoc           = emissaoCFOCBus.Obter(item.Origem);
                    saldoDocOrigem = cfoc.Produtos.Where(x => x.CultivarId == item.Cultivar && x.UnidadeMedidaId == item.UnidadeMedida).Sum(x => x.Quantidade);

                    if (cfoc.SituacaoId != (int)eDocumentoFitossanitarioSituacao.Valido)
                    {
                        Validacao.Add(Mensagem.Lote.OrigemSituacaoInvalida(item.OrigemTipoTexto));
                    }

                    DateTime dataVencimentoCFOC = cfoc.DataAtivacao.Data.GetValueOrDefault().AddDays(cfoc.ValidadeCertificado);
                    if (dataVencimentoCFOC < DateTime.Today)
                    {
                        Validacao.Add(Mensagem.Lote.OrigemVencida(item.OrigemTipoTexto));
                    }

                    if (cfoc.DataEmissao.Data > loteData.Data)
                    {
                        Validacao.Add(Mensagem.Lote.OrigemDataMaiorLoteData);
                    }
                    break;

                case eDocumentoFitossanitarioTipo.PTV:
                    PTVInternoBus ptvInternoBus = new PTVInternoBus();
                    PTV           ptv           = ptvInternoBus.Obter(item.Origem);
                    saldoDocOrigem = ptv.Produtos.Where(x => x.Cultivar == item.Cultivar && x.UnidadeMedida == item.UnidadeMedida).Sum(x => x.Quantidade);

                    if (ptv.Situacao != (int)ePTVOutroSituacao.Valido)
                    {
                        Validacao.Add(Mensagem.Lote.OrigemSituacaoInvalida(item.OrigemTipoTexto));
                    }

                    if (ptv.ValidoAte.Data.GetValueOrDefault() < DateTime.Today)
                    {
                        Validacao.Add(Mensagem.Lote.OrigemVencida(item.OrigemTipoTexto));
                    }

                    if (ptv.DataEmissao.Data > loteData.Data)
                    {
                        Validacao.Add(Mensagem.Lote.OrigemDataMaiorLoteData);
                    }
                    break;

                case eDocumentoFitossanitarioTipo.PTVOutroEstado:
                    PTVOutroBus ptvOutroBus = new PTVOutroBus();
                    PTVOutro    ptvOutro    = ptvOutroBus.Obter(item.Origem);
                    saldoDocOrigem = ptvOutro.Produtos.Where(x => x.Cultivar == item.Cultivar && x.UnidadeMedida == item.UnidadeMedida).Sum(x => x.Quantidade);

                    if (ptvOutro.Situacao != (int)ePTVOutroSituacao.Valido &&
                        ptvOutro.Situacao != (int)ePTVOutroSituacao.Invalido)
                    {
                        Validacao.Add(Mensagem.Lote.OrigemSituacaoInvalida(item.OrigemTipoTexto));
                    }

                    if (ptvOutro.DataEmissao.Data > loteData.Data)
                    {
                        Validacao.Add(Mensagem.Lote.OrigemDataMaiorLoteData);
                    }
                    break;
                }

                string empreendimento = string.Empty;
                if ((eDocumentoFitossanitarioTipo)item.OrigemTipo == eDocumentoFitossanitarioTipo.PTVOutroEstado)
                {
                    empreendimento = _da.PTVOutroEstadoJaAssociado(item.Origem, empreendimentoID);

                    if (!string.IsNullOrEmpty(empreendimento))
                    {
                        Validacao.Add(Mensagem.Lote.OrigemEmpreendimentoUtilizadoOutroUF(item.OrigemTipoTexto, item.OrigemNumero.ToString(), empreendimento));
                    }
                }

                if (item.OrigemTipo == (int)eDocumentoFitossanitarioTipo.CFO ||
                    item.OrigemTipo == (int)eDocumentoFitossanitarioTipo.CFOC ||
                    item.OrigemTipo == (int)eDocumentoFitossanitarioTipo.PTVOutroEstado)
                {
                    if (!_da.UCPossuiCultivar(empreendimentoID, item.Cultivar))
                    {
                        Validacao.Add(Mensagem.Lote.CultivarDesassociadoUC(item.CultivarTexto));
                    }


                    decimal quantidadeAdicionada = lista.Where(x => x.OrigemTipo == item.OrigemTipo && x.Origem == item.Origem && x.Cultivar == item.Cultivar && x.UnidadeMedida == item.UnidadeMedida && !x.Equals(item)).Sum(x => x.Quantidade);



                    decimal saldoOutrosDoc = _da.ObterOrigemQuantidade((eDocumentoFitossanitarioTipo)item.OrigemTipo, item.Origem, item.OrigemNumero, item.Cultivar, item.UnidadeMedida, DateTime.Now.Year, item.Id);


                    if (item.ExibeKg)
                    {
                        item.Quantidade = item.Quantidade / 1000;
                    }

                    if ((saldoOutrosDoc + item.Quantidade) > saldoDocOrigem)
                    {
                        Validacao.Add(Mensagem.PTV.SomaQuantidadeInvalida);
                    }

                    //SALDO DA UC
                    decimal saldoUc = _da.obterSaldoRestanteCultivarUC(empreendimentoID, item.Cultivar, item.Cultura);



                    if (saldoUc <= 0)
                    {
                        Validacao.Add(Mensagem.Lote.CultivarSaldoTodoUtilizado);
                    }


                    if ((quantidadeAdicionada + item.Quantidade) > saldoUc)
                    {
                        Validacao.Add(Mensagem.Lote.CultivarQuantidadeSomaSuperior);
                    }
                }

                item.Quantidade = saldoDocOrigem;
            }
        }
Beispiel #20
0
        internal bool Salvar(PTV ptv)
        {
            if (!ValidarSituacao(ptv))
            {
                return(Validacao.EhValido);
            }

            #region [ Validação de DUA ]

            if (!ValidarUtilizacaoDUA(ptv.Id, ptv.NumeroDua, ptv.CPFCNPJDUA, ptv.TipoPessoa.ToString()))
            {
                return(Validacao.EhValido);
            }

            #endregion

            if (ptv.NumeroTipo != (int)eDocumentoFitossanitarioTipoNumero.Digital && ptv.NumeroTipo != (int)eDocumentoFitossanitarioTipoNumero.Bloco)
            {
                Validacao.Add(Mensagem.PTV.TipoNumeroObrigatorio);
            }
            if (ptv.NumeroTipo == (int)eDocumentoFitossanitarioTipoNumero.Bloco && ptv.Numero <= 0)
            {
                Validacao.Add(Mensagem.PTV.NumeroPTVObrigatorio);
            }

            ValidacoesGenericasBus.DataMensagem(ptv.DataEmissao, "DataEmissao", "emissão");

            if (ptv.Situacao <= 0)
            {
                Validacao.Add(Mensagem.PTV.SituacaoObrigatorio);
            }

            if (ptv.Produtos.Count > 0 && ((!ptv.Produtos[0].SemDoc) &&
                                           (ptv.Produtos[0].OrigemTipo <= (int)eDocumentoFitossanitarioTipo.PTVOutroEstado)))
            {
                if (ptv.Empreendimento <= 0)
                {
                    Validacao.Add(Mensagem.PTV.EmpreendimentoObrigatorio);
                }

                if (ptv.ResponsavelEmpreendimento <= 0)
                {
                    Validacao.Add(Mensagem.PTV.ResponsavelEmpreend_Obrigatorio);
                }
            }

            if (_da.EmpreendimentoPossuiEPTVBloqueado(ptv.Id, ptv.Empreendimento))
            {
                Validacao.Add(Mensagem.PTV.EmpreendimentoEPTVBloqueado);
            }

            if (ptv.Produtos.Count <= 0)
            {
                Validacao.Add(Mensagem.PTV.Identificacao_Produto_Obrigatorio);
            }
            else
            {
                ptv.Produtos.ForEach(item =>
                {
                    ValidarProduto(item, ptv.DataEmissao, ptv.Produtos, ptv.Id);
                });
            }

            if (!ptv.PartidaLacradaOrigem.HasValue)
            {
                Validacao.Add(Mensagem.PTV.PartidaLacrada_Obrigatorio);
            }

            if (ptv.PartidaLacradaOrigem == (int)ePartidaLacradaOrigem.Sim && (String.IsNullOrEmpty(ptv.LacreNumero) && String.IsNullOrEmpty(ptv.PoraoNumero) && String.IsNullOrEmpty(ptv.ContainerNumero)))
            {
                Validacao.Add(Mensagem.PTV.Lacre_porao_container_Obrigatorio);
            }

            if (ptv.DestinatarioID <= 0)
            {
                Validacao.Add(Mensagem.PTV.DestinatarioObrigatorio);
            }

            if (ptv.TransporteTipo <= 0)
            {
                Validacao.Add(Mensagem.PTV.TipoTransporteObrigatorio);
            }

            if (String.IsNullOrEmpty(ptv.VeiculoIdentificacaoNumero))
            {
                Validacao.Add(Mensagem.PTV.IdentificacaoVeiculoObrigatorio);
            }

            if (!ptv.RotaTransitoDefinida.HasValue)
            {
                Validacao.Add(Mensagem.PTV.RotaTransitoObrigatorio);
            }
            if (ptv.RotaTransitoDefinida == (int)eRotaTransitoDefinida.Sim && String.IsNullOrEmpty(ptv.Itinerario))
            {
                Validacao.Add(Mensagem.PTV.Itinerário_Obrigatorio);
            }

            if (!ptv.NotaFiscalApresentacao.HasValue || ptv.NotaFiscalApresentacao == (int)eApresentacaoNotaFiscal.Nao)
            {
                Validacao.Add(Mensagem.PTV.ApresentaçãoNotaFiscal_Obrigatorio);
            }

            if (ptv.NotaFiscalApresentacao == (int)eApresentacaoNotaFiscal.Sim && String.IsNullOrEmpty(ptv.NotaFiscalNumero))
            {
                Validacao.Add(Mensagem.PTV.NumeroNotaFiscal_Obrigatorio);
            }

            if (ptv.LocalVistoriaId <= 0)
            {
                Validacao.Add(Mensagem.PTV.LocalVistoriaObrigatorio);
            }

            if (ptv.DataHoraVistoriaId <= 0)
            {
                Validacao.Add(Mensagem.PTV.VistoriaCargaObrigatorio);
            }

            if (ptv.Anexos == null || ptv.Anexos.Count <= 0)
            {
                Validacao.Add(Mensagem.PTV.AnexoObrigatorio);
            }
            else
            {
                if (ptv.Anexos.Exists(x => x.Arquivo.Extensao != ".pdf" && x.Arquivo.Extensao != ".jpg" && x.Arquivo.Extensao != ".jpeg"))
                {
                    Validacao.Add(Mensagem.PTV.AnexoFormatoErrado);
                }
            }

            if ((ptv.NFCaixa.notaFiscalCaixaApresentacao == 1 /*SIM*/ && ptv.NotaFiscalDeCaixas.Count() <= 0))
            {
                Validacao.Add(Mensagem.PTV.NenhumaNFCaixaAdicionada);
            }

            if (ptv.Produtos.Any(x => x.Cultura == (int)eCultura.Banana) && ptv.NotaFiscalDeCaixas.Count() <= 0)
            {
                Validacao.Add(Mensagem.PTV.NenhumaNFCaixaAdicionadaECulturaBanana);
            }

            return(Validacao.EhValido);
        }
Beispiel #21
0
        public bool Analisar(PTV eptv)
        {
            try
            {
                Tecnomapas.EtramiteX.Credenciado.Model.ModuloPTV.Business.PTVBus ptvCredenciadoBus = new Tecnomapas.EtramiteX.Credenciado.Model.ModuloPTV.Business.PTVBus();
                PTV eptvBanco = ptvCredenciadoBus.Obter(eptv.Id);

                if (!_validar.Analisar(eptv, eptvBanco))
                {
                    return(false);
                }

                GerenciadorTransacao.ObterIDAtual();

                using (BancoDeDados bancoDeDadosInterno = BancoDeDados.ObterInstancia(SchemaUsuarioInterno))
                {
                    bancoDeDadosInterno.IniciarTransacao();

                    using (BancoDeDados bancoDeDadosCredenciado = BancoDeDados.ObterInstancia(SchemaUsuarioCredenciado))
                    {
                        bancoDeDadosCredenciado.IniciarTransacao();

                        _da.AnalizarEPTV(eptv, bancoDeDadosCredenciado);

                        if (eptv.Situacao == (int)eSolicitarPTVSituacao.Aprovado)
                        {
                            eptvBanco.ValidoAte              = eptv.ValidoAte;
                            eptvBanco.ResponsavelTecnicoId   = eptv.ResponsavelTecnicoId;
                            eptvBanco.ResponsavelTecnicoNome = eptv.ResponsavelTecnicoNome;
                            eptvBanco.LocalEmissaoId         = eptv.LocalEmissaoId;
                            eptvBanco.TemAssinatura          = _da.ExisteAssinaturaDigital(eptv.ResponsavelTecnicoId);

                            if (!_validar.Importar(eptvBanco))
                            {
                                return(Validacao.EhValido);
                            }

                            if (eptvBanco.Anexos.Any())
                            {
                                var arquivoBusCred = new ArquivoBus(eExecutorTipo.Credenciado);
                                var arquivoBusInst = new ArquivoBus(eExecutorTipo.Interno);
                                foreach (var anexo in  eptvBanco.Anexos)
                                {
                                    anexo.Arquivo = arquivoBusInst.Salvar(arquivoBusCred.Obter(anexo.Arquivo.Id.Value));
                                }
                            }

                            try
                            {
                                _da.Importar(eptvBanco, bancoDeDadosInterno);
                            }
                            catch (Exception exc)
                            {
                                if (exc.Message.Contains("UK_TAB_PTV_EPTV"))
                                {
                                    Validacao.Add(new Mensagem {
                                        Texto = "O EPTV já foi importado para o institucional.", Tipo = eTipoMensagem.Advertencia
                                    });
                                    return(Validacao.EhValido);
                                }

                                throw exc;
                            }
                        }

                        string textoEmail = string.Empty;
                        switch (eptv.Situacao)
                        {
                        case 3:
                            eptvBanco.SituacaoTexto = "Aprovado";
                            textoEmail = _configSys.Obter <String>(ConfiguracaoSistema.KeyModeloTextoEmailAprovarSolicitacaoPTV);
                            break;

                        case 4:
                            eptvBanco.SituacaoTexto = "Rejeitado";
                            textoEmail = _configSys.Obter <String>(ConfiguracaoSistema.KeyModeloTextoEmailRejeitarSolicitacaoPTV) + eptv.SituacaoMotivo;
                            break;

                        case 5:
                            eptvBanco.SituacaoTexto = "Fiscalização Agendada";
                            textoEmail = _configSys.Obter <String>(ConfiguracaoSistema.KeyModeloTextoEmailAgendarFiscalizacaoSolicitacaoPTV);
                            break;
                        }

                        #region [ Enviar E-mail ]

                        if (eptv.Situacao == (int)eSolicitarPTVSituacao.Bloqueado)
                        {
                            PTVComunicador comunicador = new PTVComunicador();
                            comunicador.Id                  = _da.ObterIDComunicador(eptv.Id);
                            comunicador.PTVId               = eptv.Id;
                            comunicador.PTVNumero           = eptv.Numero;
                            comunicador.liberadoCredenciado = true;

                            var conversa = new PTVConversa();
                            conversa.Texto = eptv.SituacaoMotivo;
                            comunicador.Conversas.Add(conversa);

                            SalvarConversa(comunicador, bancoDeDadosInterno, bancoDeDadosCredenciado);
                        }
                        else
                        {
                            var emailKeys = new Dictionary <string, string>
                            {
                                { "[data situacao]", DateTime.Today.ToShortDateString() },
                                { "[hora situacao]", DateTime.Now.ToShortTimeString() },
                                { "[numero]", eptvBanco.Numero.ToString() },
                                { "[local vistoria]", eptvBanco.LocalVistoriaTexto },
                                { "[hora vistoria]", eptv.DataHoraVistoriaTexto }
                            };

                            foreach (var item in emailKeys)
                            {
                                textoEmail = textoEmail.Replace(item.Key, item.Value);
                            }

                            var email = new Email();
                            email.Assunto = _configSys.Obter <String>(ConfiguracaoSistema.KeyOrgaoSigla);
                            email.Texto   = textoEmail;
                            email.Tipo    = eEmailTipo.AnaliseEPTV;
                            email.Codigo  = eptv.Id;

                            List <String> lstEmail = _da.ObterEmailsCredenciado(eptv.Id, bancoDeDadosCredenciado);

                            if (lstEmail != null && lstEmail.Count > 0)
                            {
                                email.Destinatario = String.Join(", ", lstEmail.ToArray());

                                EmailBus emailBus = new EmailBus();
                                emailBus.Enviar(email, bancoDeDadosInterno);
                            }
                        }

                        #endregion

                        bancoDeDadosInterno.Commit();
                        bancoDeDadosCredenciado.Commit();
                    }
                }
            }
            catch (Exception ex)
            {
                Validacao.AddErro(ex);
            }

            return(Validacao.EhValido);
        }
Beispiel #22
0
        public bool Enviar(int id)
        {
            try
            {
                PTV ptv = Obter(id, true);

                if (!_validar.Enviar(ptv))
                {
                    return(false);
                }

                ptv.Situacao = (int)eSolicitarPTVSituacao.AguardandoAnalise;
                var tentativas   = 0;
                var numeroGerado = false;

                while (tentativas < 5 && !numeroGerado)
                {
                    if (ptv.NumeroTipo == (int)eDocumentoFitossanitarioTipoNumero.Digital && ptv.Numero <= 0)
                    {
                        string numero = VerificarNumeroPTV(string.Empty, ptv.NumeroTipo.GetValueOrDefault());
                        if (!string.IsNullOrEmpty(numero))
                        {
                            ptv.Numero = Convert.ToInt64(numero);
                        }

                        if (!Validacao.EhValido)
                        {
                            return(Validacao.EhValido);
                        }
                    }

                    GerenciadorTransacao.ObterIDAtual();

                    using (BancoDeDados bancoDeDados = BancoDeDados.ObterInstancia(UsuarioCredenciado))
                    {
                        bancoDeDados.IniciarTransacao();

                        numeroGerado = _da.Enviar(ptv, bancoDeDados);

                        bancoDeDados.Commit();
                    }
                    Thread.Sleep(1000);

                    tentativas++;
                }

                if (tentativas == 5)
                {
                    Validacao.Add(Mensagem.PTV.ErroAoGerarNumero);
                }
                else
                {
                    Validacao.Add(Mensagem.PTV.AtivadoSucesso(ptv.Numero.ToString()));
                }
            }
            catch (Exception ex)
            {
                Validacao.AddErro(ex);
            }

            return(Validacao.EhValido);
        }
Beispiel #23
0
        public List <IdentificacaoProduto> OrigemNumero(string numero, int origemTipo, string serieNumeral, out int origemID)
        {
            if (origemTipo == 0)
            {
                Validacao.Add(Mensagem.Lote.OrigemObrigatorio);
            }

            if (string.IsNullOrEmpty(numero) && !IsEditar)
            {
                Validacao.Add(Mensagem.Lote.OrigemNumeroObrigatorio(string.Empty));
            }
            else
            {
                switch ((eDocumentoFitossanitarioTipo)origemTipo)
                {
                case eDocumentoFitossanitarioTipo.CFO:
                    EmissaoCFOBus emissaoCFOBus = new EmissaoCFOBus();
                    EmissaoCFO    CFO           = emissaoCFOBus.ObterPorNumero(Convert.ToInt64(numero), credenciado: false, serieNumero: serieNumeral);

                    if (CFO.Id > 0)
                    {
                        origemID = CFO.Id;
                        return(CFO.Produtos);
                    }

                    Validacao.Add(Mensagem.Lote.OrigemNumeroInexistente(eDocumentoFitossanitarioTipo.CFO.ToString()));
                    break;

                case eDocumentoFitossanitarioTipo.CFOC:
                    EmissaoCFOCBus emissaoCFOCBus = new EmissaoCFOCBus();
                    EmissaoCFOC    CFOC           = emissaoCFOCBus.ObterPorNumero(Convert.ToInt64(numero), credenciado: false, serieNumero: serieNumeral);

                    if (CFOC.Id > 0)
                    {
                        origemID = CFOC.Id;
                        return(CFOC.Produtos);
                    }

                    Validacao.Add(Mensagem.Lote.OrigemNumeroInexistente(eDocumentoFitossanitarioTipo.CFOC.ToString()));
                    break;

                case eDocumentoFitossanitarioTipo.PTVOutroEstado:

                    PTVOutroBus ptvOutroBus = new PTVOutroBus();
                    PTVOutro    ptvOutro    = ptvOutroBus.ObterPorNumero(Convert.ToInt64(numero), credenciado: false);

                    if (ptvOutro.Id > 0)
                    {
                        origemID = ptvOutro.Id;

                        List <IdentificacaoProduto> lista = new List <IdentificacaoProduto>();
                        foreach (var item in ptvOutro.Produtos)
                        {
                            IdentificacaoProduto itemLista = new IdentificacaoProduto();
                            itemLista.CulturaId       = item.Cultura;
                            itemLista.CulturaTexto    = item.CulturaTexto;
                            itemLista.CultivarId      = item.Cultivar;
                            itemLista.CultivarTexto   = item.CultivarTexto;
                            itemLista.UnidadeMedidaId = item.UnidadeMedida;
                            itemLista.Quantidade      = item.Quantidade;
                            lista.Add(itemLista);
                        }

                        return(lista);
                    }

                    Validacao.Add(Mensagem.Lote.OrigemNumeroInexistente("PTV de outro estado"));

                    break;

                case eDocumentoFitossanitarioTipo.PTV:

                    PTVInternoBus ptvBus = new PTVInternoBus();
                    PTV           ptv    = ptvBus.ObterPorNumero(Convert.ToInt64(numero));

                    if (ptv.Id > 0)
                    {
                        origemID = ptv.Id;

                        List <IdentificacaoProduto> lista = new List <IdentificacaoProduto>();
                        foreach (var item in ptv.Produtos)
                        {
                            IdentificacaoProduto itemLista = new IdentificacaoProduto();
                            itemLista.CulturaId       = item.Cultura;
                            itemLista.CulturaTexto    = item.CulturaTexto;
                            itemLista.CultivarId      = item.Cultivar;
                            itemLista.CultivarTexto   = item.CultivarTexto;
                            itemLista.UnidadeMedidaId = item.UnidadeMedida;
                            itemLista.Quantidade      = item.Quantidade;
                            lista.Add(itemLista);
                        }

                        return(lista);
                    }

                    Validacao.Add(Mensagem.Lote.OrigemNumeroInexistente("PTV"));
                    break;
                }
            }

            origemID = 0;
            return(null);
        }
Beispiel #24
0
        public MemoryStream Gerar(int id, int situacao, string situacaoTexto, PTV ptvInstitucional)
        {
            ArquivoDocCaminho = @"~/Content/_pdfAspose/PTV.doc";

            EmissaoPTVRelatorio dataSource = new EmissaoPTVRelatorio();

            var ptvID = _da.ObterPtvID(id);

            //dataSource = _da.Obter(ptvID);
            if (situacao != (int)ePTVSituacao.EmElaboracao)
            {
                dataSource = _da.ObterHistorico(ptvInstitucional.Id, ptvInstitucional.Tid);
            }
            else
            {
                dataSource = _da.Obter(id);
                dataSource.DataAtivacao = "--/--/--";
            }
            situacao = dataSource.Situacao;

            foreach (PTVProdutoRelatorio prod in dataSource.Produtos)
            {
                if (prod.ExibeQtdKg)
                {
                    prod.Quantidade   *= 1000;
                    prod.UnidadeMedida = "KG";
                }
            }

            if (dataSource.AssinaturaDigital.Id.HasValue && dataSource.AssinaturaDigital.Id.Value > 0)
            {
                dataSource.AssinaturaDigital.Conteudo = AsposeImage.RedimensionarImagemPNG(File.ReadAllBytes(dataSource.AssinaturaDigital.Caminho), 4);
            }
            else
            {
                MemoryStream memory = new MemoryStream();

                Bitmap img = new Bitmap(1, 1);

                img.SetPixel(0, 0, System.Drawing.Color.White);

                img.Save(memory, System.Drawing.Imaging.ImageFormat.Gif);

                dataSource.AssinaturaDigital.Conteudo = memory.ToArray();
            }

            QRCodeEncoder qrCodeEncoder = new QRCodeEncoder();

            qrCodeEncoder.QRCodeScale = 2;

            string url = String.Format("{0}/{1}/{2}", UrlPDFPublico, "ptv/GerarPdfInterno", ptvID);

            System.Drawing.Image imageQRCode = qrCodeEncoder.Encode(url);

            MemoryStream msQRCode = new MemoryStream();

            imageQRCode.Save(msQRCode, System.Drawing.Imaging.ImageFormat.Gif);

            dataSource.QRCode.Conteudo = msQRCode.ToArray();

            #region Condicional

            if (dataSource.PartidaLacrada == (int)ePartidaLacradaOrigem.Sim)
            {
                dataSource.IsLacrada    = "X";
                dataSource.IsNaoLacrada = AsposeData.Empty;
            }
            else
            {
                dataSource.IsLacrada    = AsposeData.Empty;
                dataSource.IsNaoLacrada = "X";
            }
            if (dataSource.Rota_transito_definida == (int)eRotaTransitoDefinida.Sim)
            {
                dataSource.IsRota    = "X";
                dataSource.IsNaoRota = AsposeData.Empty;
            }
            else
            {
                dataSource.IsRota    = AsposeData.Empty;
                dataSource.IsNaoRota = "X";
            }
            if (dataSource.ApresentacaoNotaFiscal == (int)eApresentacaoNotaFiscal.Sim)
            {
                dataSource.IsNota    = "X";
                dataSource.IsNaoNota = AsposeData.Empty;
            }
            else
            {
                dataSource.IsNota    = AsposeData.Empty;
                dataSource.IsNaoNota = "X";
            }

            switch (dataSource.TipoTransporte)
            {
            case 1: dataSource.IsRod = "X"; dataSource.IsAer = AsposeData.Empty; dataSource.IsFer = AsposeData.Empty; dataSource.IsHid = AsposeData.Empty; dataSource.IsOut = AsposeData.Empty; break;

            case 2: dataSource.IsRod = AsposeData.Empty; dataSource.IsAer = "X"; dataSource.IsFer = AsposeData.Empty; dataSource.IsHid = AsposeData.Empty; dataSource.IsOut = AsposeData.Empty; break;

            case 3: dataSource.IsRod = AsposeData.Empty; dataSource.IsAer = AsposeData.Empty; dataSource.IsFer = "X"; dataSource.IsHid = AsposeData.Empty; dataSource.IsOut = AsposeData.Empty; break;

            case 4: dataSource.IsRod = AsposeData.Empty; dataSource.IsAer = AsposeData.Empty; dataSource.IsFer = AsposeData.Empty; dataSource.IsHid = "X"; dataSource.IsOut = AsposeData.Empty; break;

            case 5: dataSource.IsRod = AsposeData.Empty; dataSource.IsAer = AsposeData.Empty; dataSource.IsFer = AsposeData.Empty; dataSource.IsHid = AsposeData.Empty; dataSource.IsOut = "X"; break;
            }

            #endregion

            ObterArquivoTemplate();

            ConfigurarCabecarioRodape(0);

            #region Configurar

            ConfiguracaoDefault.ExibirSimplesConferencia = (situacao == (int)ePTVSituacao.EmElaboracao);

            ConfiguracaoDefault.AddLoadAcao((doc, dataSourceCnf) =>
            {
                List <Row> itensRemover = new List <Row>();

                itensRemover.ForEach(x => x.Remove());
            });

            #endregion

            MemoryStream stream = GerarPdf(dataSource);

            #region Adicionar Tarja

            try
            {
                DateTime dataAtual     = DateTime.Now;
                String   mensagemTarja = "Consultado em " + dataAtual.ToShortDateString() + " às " + dataAtual.ToString(@"HH\hmm\min");

                switch ((ePTVSituacao)situacao)
                {
                case ePTVSituacao.Cancelado:
                    using (MemoryStream msTemp = new MemoryStream(stream.ToArray()))
                    {
                        stream.Close();
                        stream.Dispose();
                        stream = PdfMetodosAuxiliares.TarjaLaranja(msTemp, mensagemTarja, situacaoTexto);
                    }
                    break;

                case ePTVSituacao.Invalido:
                    using (MemoryStream msTemp = new MemoryStream(stream.ToArray()))
                    {
                        stream.Close();
                        stream.Dispose();
                        stream = PdfMetodosAuxiliares.TarjaVermelha(msTemp, mensagemTarja, "Inválida");
                    }
                    break;

                default:
                    break;
                }
            }
            catch
            {
                if (stream != null)
                {
                    stream.Close();
                    stream.Dispose();
                }
                throw;
            }

            #endregion

            return(stream);
        }
Beispiel #25
0
        internal bool Salvar(PTV ptv)
        {
            if (!FuncionarioHabilitadoValido())
            {
                return(false);
            }

            if (!ValidarSituacao(ptv))
            {
                return(Validacao.EhValido);
            }

            if (ptv.NumeroTipo != (int)eDocumentoFitossanitarioTipoNumero.Digital && ptv.NumeroTipo != (int)eDocumentoFitossanitarioTipoNumero.Bloco)
            {
                Validacao.Add(Mensagem.PTV.TipoNumeroObrigatorio);
            }
            if (ptv.NumeroTipo == (int)eDocumentoFitossanitarioTipoNumero.Bloco && ptv.Numero <= 0)
            {
                Validacao.Add(Mensagem.PTV.NumeroPTVObrigatorio);
            }

            ValidacoesGenericasBus.DataMensagem(ptv.DataEmissao, "DataEmissao", "emissão");

            if (ptv.Situacao <= 0)
            {
                Validacao.Add(Mensagem.PTV.SituacaoObrigatorio);
            }

            if (ptv.Empreendimento <= 0)
            {
                Validacao.Add(Mensagem.PTV.EmpreendimentoObrigatorio);
            }

            if (ptv.ResponsavelEmpreendimento <= 0)
            {
                Validacao.Add(Mensagem.PTV.ResponsavelEmpreend_Obrigatorio);
            }

            if (ptv.Produtos.Count <= 0)
            {
                Validacao.Add(Mensagem.PTV.Identificacao_Produto_Obrigatorio);
            }
            else
            {
                ptv.Produtos.ForEach(produto =>
                {
                    ValidarProduto(produto, ptv.DataEmissao, ptv.Produtos, ptv.Id);
                });
            }

            if (!ptv.PartidaLacradaOrigem.HasValue)
            {
                Validacao.Add(Mensagem.PTV.PartidaLacrada_Obrigatorio);
            }

            if (ptv.PartidaLacradaOrigem == (int)ePartidaLacradaOrigem.Sim && (String.IsNullOrEmpty(ptv.LacreNumero) && String.IsNullOrEmpty(ptv.PoraoNumero) && String.IsNullOrEmpty(ptv.ContainerNumero)))
            {
                Validacao.Add(Mensagem.PTV.Lacre_porao_container_Obrigatorio);
            }

            if (ptv.DestinatarioID <= 0)
            {
                Validacao.Add(Mensagem.PTV.DestinatarioObrigatorio);
            }

            if (!ptv.PossuiLaudoLaboratorial.HasValue)
            {
                Validacao.Add(Mensagem.PTV.PossuiLaudoLab_Obrigatorio);
            }

            if (ptv.TransporteTipo <= 0)
            {
                Validacao.Add(Mensagem.PTV.TipoTransporteObrigatorio);
            }

            if (String.IsNullOrEmpty(ptv.VeiculoIdentificacaoNumero))
            {
                Validacao.Add(Mensagem.PTV.IdentificacaoVeiculoObrigatorio);
            }

            if (!ptv.RotaTransitoDefinida.HasValue)
            {
                Validacao.Add(Mensagem.PTV.RotaTransitoObrigatorio);
            }
            if (ptv.RotaTransitoDefinida == (int)eRotaTransitoDefinida.Sim && String.IsNullOrEmpty(ptv.Itinerario))
            {
                Validacao.Add(Mensagem.PTV.Itinerário_Obrigatorio);
            }

            if (!ptv.NotaFiscalApresentacao.HasValue || ptv.NotaFiscalApresentacao == (int)eApresentacaoNotaFiscal.Nao)
            {
                Validacao.Add(Mensagem.PTV.ApresentaçãoNotaFiscal_Obrigatorio);
            }

            if (ptv.NotaFiscalApresentacao == (int)eApresentacaoNotaFiscal.Sim && String.IsNullOrEmpty(ptv.NotaFiscalNumero))
            {
                Validacao.Add(Mensagem.PTV.NumeroNotaFiscal_Obrigatorio);
            }

            if (ValidacoesGenericasBus.DataMensagem(ptv.ValidoAte, "DataValidade", "validação", false))
            {
                if (ptv.ValidoAte.Data < ptv.DataEmissao.Data)
                {
                    Validacao.Add(Mensagem.PTV.DataValidadeMenorDataEmissao);
                }
                else
                {
                    DateTime data = (DateTime)ptv.ValidoAte.Data;
                    DateTime dt   = DateTime.Today.AddDays(30).Subtract(TimeSpan.FromSeconds(1));
                    if (data > dt)
                    {
                        Validacao.Add(Mensagem.PTV.DataValidadeInvalida);
                    }
                }
            }

            if (ptv.ResponsavelTecnicoId <= 0)
            {
                Validacao.Add(Mensagem.PTV.ResponsavelTecnicoObrigatorio);
            }

            if (ptv.LocalEmissaoId <= 0)
            {
                Validacao.Add(Mensagem.PTV.LocalDeEmissaoObrigatorio);
            }

            return(Validacao.EhValido);
        }
Beispiel #26
0
        public bool Salvar(PTV ptv)
        {
            try
            {
                if (ptv.Id <= 0)
                {
                    ptv.Situacao = (int)eSolicitarPTVSituacao.Cadastrado;
                }

                if (_validar.Salvar(ptv))
                {
                    #region Arquivos/Diretorio

                    ArquivoBus _busArquivo = new ArquivoBus(eExecutorTipo.Credenciado);

                    if (ptv.Anexos != null && ptv.Anexos.Count > 0)
                    {
                        foreach (Anexo anexo in ptv.Anexos)
                        {
                            if (!String.IsNullOrWhiteSpace(anexo.Arquivo.TemporarioNome) && anexo.Arquivo.Id == 0)
                            {
                                anexo.Arquivo = _busArquivo.Copiar(anexo.Arquivo);
                            }
                        }
                    }

                    #endregion

                    GerenciadorTransacao.ObterIDAtual();

                    using (BancoDeDados bancoDeDados = BancoDeDados.ObterInstancia(UsuarioCredenciado))
                    {
                        bancoDeDados.IniciarTransacao();

                        #region Arquivos/Banco
                        ArquivoDa arquivoDa = new ArquivoDa();

                        if (ptv.Anexos != null && ptv.Anexos.Count > 0)
                        {
                            foreach (Anexo anexo in ptv.Anexos)
                            {
                                if (!String.IsNullOrWhiteSpace(anexo.Arquivo.TemporarioNome) && anexo.Arquivo.Id == 0)
                                {
                                    arquivoDa.Salvar(anexo.Arquivo, User.FuncionarioId, User.Name, User.Login, (int)eExecutorTipo.Credenciado, User.FuncionarioTid, bancoDeDados);
                                }
                            }
                        }
                        #endregion

                        ptv.PossuiLaudoLaboratorial = 0;

                        _da.Salvar(ptv, bancoDeDados);

                        bancoDeDados.Commit();

                        Validacao.Add(Mensagem.PTV.Salvar);
                    }
                }
            }
            catch (Exception ex)
            {
                Validacao.AddErro(ex);
            }

            return(Validacao.EhValido);
        }
Beispiel #27
0
        internal bool Analisar(PTV eptv, PTV eptvBanco)
        {
            if (!FuncionarioHabilitadoValido())
            {
                return(false);
            }

            //situacoes
            if (eptv.Situacao == 0)
            {
                Validacao.Add(new Mensagem {
                    Texto = "Informe o Resultado da analise.", Tipo = eTipoMensagem.Advertencia
                });
                return(false);
            }

            if (_da.EPTVJaFoiImportado(eptv.Id))
            {
                Validacao.Add(new Mensagem {
                    Texto = "O EPTV já foi importado para o institucional.", Tipo = eTipoMensagem.Advertencia
                });
                return(false);
            }


            if (_da.EmpreendimentoPossuiEPTVBloqueado(eptv.Id, eptv.Empreendimento))
            {
                Validacao.Add(Mensagem.PTV.EmpreendimentoEPTVBloqueado);
            }

            if (Validacao.EhValido)
            {
                if (eptv.Situacao == 3 /*Aprovado*/)
                {
                    if (eptv.ValidoAte.IsEmpty)
                    {
                        Validacao.Add(new Mensagem {
                            Campo = "ValidoAte", Texto = "Campo \"Válido até\" não pode ser vazio.", Tipo = eTipoMensagem.Advertencia
                        });
                    }

                    if (!eptv.ValidoAte.IsValido)
                    {
                        Validacao.Add(new Mensagem {
                            Campo = "ValidoAte", Texto = "Campo \"Válido até\" inválido.", Tipo = eTipoMensagem.Advertencia
                        });
                    }

                    if (eptv.LocalEmissaoId == 0)
                    {
                        Validacao.Add(new Mensagem {
                            Campo = "LocalEmissao", Texto = "Campo \"Local da Emissão\" não selecionado.", Tipo = eTipoMensagem.Advertencia
                        });
                    }
                }

                if ((eptv.Situacao == 4 /*Rejeitado*/ || eptv.Situacao == 6 /*Bloqueado*/) && string.IsNullOrWhiteSpace(eptv.SituacaoMotivo))
                {
                    Validacao.Add(new Mensagem {
                        Campo = "SituacaoMotivo", Texto = "Informe o Motivo da Situação.", Tipo = eTipoMensagem.Advertencia
                    });
                }

                if (eptv.Situacao == (int)eSolicitarPTVSituacao.Bloqueado && eptvBanco.Situacao != (int)eSolicitarPTVSituacao.AgendarFiscalizacao)
                {
                    Validacao.Add(new Mensagem {
                        Texto = "Para Bloquear o EPTV ele deve estar na situação \"Fiscalização Agendada\".", Tipo = eTipoMensagem.Advertencia
                    });
                }

                if (eptv.ResponsavelTecnicoId <= 0)
                {
                    Validacao.Add(Mensagem.PTV.ResponsavelTecnicoObrigatorio);
                }
            }

            return(Validacao.EhValido);
        }
Beispiel #28
0
        internal bool Salvar(PTV ptv)
        {
            if (!FuncionarioHabilitadoValido())
            {
                return(false);
            }

            if (!ValidarSituacao(ptv))
            {
                return(Validacao.EhValido);
            }

            if (ptv.NumeroTipo != (int)eDocumentoFitossanitarioTipoNumero.Digital && ptv.NumeroTipo != (int)eDocumentoFitossanitarioTipoNumero.Bloco)
            {
                Validacao.Add(Mensagem.PTV.TipoNumeroObrigatorio);
            }
            if (ptv.NumeroTipo == (int)eDocumentoFitossanitarioTipoNumero.Bloco && ptv.Numero <= 0)
            {
                Validacao.Add(Mensagem.PTV.NumeroPTVObrigatorio);
            }

            ValidacoesGenericasBus.DataMensagem(ptv.DataEmissao, "DataEmissao", "emissão");


            if (ptv.Situacao <= 0)
            {
                Validacao.Add(Mensagem.PTV.SituacaoObrigatorio);
            }


            if (ptv.Produtos.Count > 0 && ((!ptv.Produtos[0].SemDoc) &&
                                           (ptv.Produtos[0].OrigemTipo <= (int)eDocumentoFitossanitarioTipo.PTVOutroEstado)))
            {
                if (ptv.Empreendimento <= 0)
                {
                    Validacao.Add(Mensagem.PTV.EmpreendimentoObrigatorio);
                }

                if (ptv.ResponsavelEmpreendimento <= 0)
                {
                    Validacao.Add(Mensagem.PTV.ResponsavelEmpreend_Obrigatorio);
                }
            }

            if (ptv.Produtos.Count <= 0)
            {
                Validacao.Add(Mensagem.PTV.Identificacao_Produto_Obrigatorio);
            }
            else
            {
                ptv.Produtos.ForEach(produto =>
                {
                    ValidarProduto(produto, ptv.DataEmissao, ptv.Produtos, ptv.Id);
                });
            }

            if (!ptv.PartidaLacradaOrigem.HasValue)
            {
                Validacao.Add(Mensagem.PTV.PartidaLacrada_Obrigatorio);
            }

            if (ptv.PartidaLacradaOrigem == (int)ePartidaLacradaOrigem.Sim && (String.IsNullOrEmpty(ptv.LacreNumero) && String.IsNullOrEmpty(ptv.PoraoNumero) && String.IsNullOrEmpty(ptv.ContainerNumero)))
            {
                Validacao.Add(Mensagem.PTV.Lacre_porao_container_Obrigatorio);
            }

            if (ptv.DestinatarioID <= 0)
            {
                Validacao.Add(Mensagem.PTV.DestinatarioObrigatorio);
            }

            if (ptv.TransporteTipo <= 0)
            {
                Validacao.Add(Mensagem.PTV.TipoTransporteObrigatorio);
            }

            if (String.IsNullOrEmpty(ptv.VeiculoIdentificacaoNumero))
            {
                Validacao.Add(Mensagem.PTV.IdentificacaoVeiculoObrigatorio);
            }

            if (!ptv.RotaTransitoDefinida.HasValue)
            {
                Validacao.Add(Mensagem.PTV.RotaTransitoObrigatorio);
            }
            if (ptv.RotaTransitoDefinida == (int)eRotaTransitoDefinida.Sim && String.IsNullOrEmpty(ptv.Itinerario))
            {
                Validacao.Add(Mensagem.PTV.Itinerário_Obrigatorio);
            }

            if (!ptv.NotaFiscalApresentacao.HasValue || ptv.NotaFiscalApresentacao == (int)eApresentacaoNotaFiscal.Nao)
            {
                Validacao.Add(Mensagem.PTV.ApresentaçãoNotaFiscal_Obrigatorio);
            }

            if (ptv.NotaFiscalApresentacao == (int)eApresentacaoNotaFiscal.Sim && String.IsNullOrEmpty(ptv.NotaFiscalNumero))
            {
                Validacao.Add(Mensagem.PTV.NumeroNotaFiscal_Obrigatorio);
            }

            if (ValidacoesGenericasBus.DataMensagem(ptv.ValidoAte, "DataValidade", "validação", false))
            {
                if (ptv.ValidoAte.Data < ptv.DataEmissao.Data)
                {
                    Validacao.Add(Mensagem.PTV.DataValidadeMenorDataEmissao);
                }
                else
                {
                    DateTime data = (DateTime)ptv.ValidoAte.Data;
                    DateTime dt   = DateTime.Today.AddDays(30).Subtract(TimeSpan.FromSeconds(1));
                    if (data > dt)
                    {
                        Validacao.Add(Mensagem.PTV.DataValidadeInvalida);
                    }
                }
            }

            if (ptv.ResponsavelTecnicoId <= 0)
            {
                Validacao.Add(Mensagem.PTV.ResponsavelTecnicoObrigatorio);
            }

            if (ptv.LocalEmissaoId <= 0)
            {
                Validacao.Add(Mensagem.PTV.LocalDeEmissaoObrigatorio);
            }

            if (ptv.NFCaixa.notaFiscalCaixaApresentacao == 1 && ptv.NotaFiscalDeCaixas.Count() <= 0)
            {
                Validacao.Add(Mensagem.PTV.NenhumaNFCaixaAdicionada);
            }
            else
            {
                foreach (var nf in ptv.NotaFiscalDeCaixas)
                {
                    NotaFiscalCaixa nfDa = _da.VerificarNumeroNFCaixa(nf);

                    if (nfDa.id > 0 && nf.numeroCaixas > nfDa.saldoAtual)
                    {
                        Validacao.Add(Mensagem.PTV.NumeroDeCaixasMaiorQueSaldoAtual);
                    }
                }
            }

            if ((ptv.NFCaixa.notaFiscalCaixaApresentacao == 1 && ptv.NotaFiscalDeCaixas.Count() <= 0))
            {
                Validacao.Add(Mensagem.PTV.NenhumaNFCaixaAdicionada);
            }

            if (ptv.Produtos.Any(x => x.Cultura == (int)eCultura.Banana) && ptv.NotaFiscalDeCaixas.Count() <= 0)
            {
                Validacao.Add(Mensagem.PTV.NenhumaNFCaixaAdicionadaECulturaBanana);
            }

            return(Validacao.EhValido);
        }