public bool Ativar(EmissaoCFO cfo)
        {
            try
            {
                if (!_validar.Ativar(cfo))
                {
                    return(false);
                }

                GerenciadorTransacao.ObterIDAtual();

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

                    _da.Ativar(cfo, bancoDeDados);

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

                    Validacao.Add(Mensagem.EmissaoCFO.AtivadoSucesso(cfo.Numero));

                    bancoDeDados.Commit();
                }
            }
            catch (Exception exc)
            {
                Validacao.AddErro(exc);
            }

            return(Validacao.EhValido);
        }
示例#2
0
        public bool Cancelar(EmissaoCFO entidade)
        {
            GerenciadorTransacao.ObterIDAtual();

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

                EmissaoCFO entidadeBanco = _da.ObterPorNumero(Convert.ToInt64(entidade.Numero), entidade.Serie, true, false, bancoDeDados);

                if (!String.IsNullOrWhiteSpace(entidadeBanco.Numero))
                {
                    string numtemp = entidadeBanco.Numero;
                    if (numtemp.Count() > 8)
                    {
                        entidadeBanco.Numero = numtemp.Substring(0, 8);
                        entidadeBanco.Serie  = numtemp[9].ToString();
                    }

                    _da.Cancelar(entidadeBanco, bancoDeDados);
                }

                bancoDeDados.Commit();
            }

            return(Validacao.EhValido);
        }
示例#3
0
        public ActionResult AtivarConfirm(int id)
        {
            EmissaoCFO cfo = _bus.Obter(id, simplificado: true);

            cfo.DataAtivacao.Data = DateTime.Today;

            return(PartialView("AtivarPartial", cfo));
        }
示例#4
0
        public ActionResult Ativar(EmissaoCFO entidade)
        {
            _bus.Ativar(entidade);

            string UrlRedirecionar = Url.Action("Index", "CFO") + "?Msg=" + Validacao.QueryParam() + "&acaoGerarPdfId=" + entidade.Id.ToString();

            return(Json(new { EhValido = Validacao.EhValido, Msg = Validacao.Erros, @UrlRedirecionar = UrlRedirecionar, @Id = entidade.Id }, JsonRequestBehavior.AllowGet));
        }
示例#5
0
        public ActionResult Editar(EmissaoCFO entidade)
        {
            _bus.Salvar(entidade);

            string UrlRedirecionar = Url.Action("Index", "CFO") + "?Msg=" + Validacao.QueryParam() + "&acaoId=" + entidade.Id.ToString();

            return(Json(new { @EhValido = Validacao.EhValido, @Msg = Validacao.Erros, @UrlRedirecionar = UrlRedirecionar }, JsonRequestBehavior.AllowGet));
        }
示例#6
0
        public ListarVM(List <QuantPaginacao> quantPaginacao, List <Lista> situacoes)
        {
            Paginacao  = new Paginacao();
            Resultados = new List <EmissaoCFO>();
            Filtros    = new EmissaoCFO();

            SituacaoLista = ViewModelHelper.CriarSelectList(situacoes, true, true);
            Paginacao.ListaQuantPaginacao = ViewModelHelper.CriarSelectList(quantPaginacao, false, false);
        }
示例#7
0
        public bool Editar(EmissaoCFO entidade)
        {
            if (entidade.SituacaoId != (int)eDocumentoFitossanitarioSituacao.EmElaboracao)
            {
                Validacao.Add(Mensagem.EmissaoCFO.EditarSituacaoInvalida);
            }

            return(Validacao.EhValido);
        }
示例#8
0
        public ActionResult Editar(EmissaoCFO entidade)
        {
            entidade.PossuiLaudoLaboratorial           = false;
            entidade.PossuiTratamentoFinsQuarentenario = false;
            _bus.Salvar(entidade);

            string UrlRedirecionar = Url.Action("Index", "CFO") + "?Msg=" + Validacao.QueryParam() + "&acaoId=" + entidade.Id.ToString();

            return(Json(new { @EhValido = Validacao.EhValido, @Msg = Validacao.Erros, @UrlRedirecionar = UrlRedirecionar }, JsonRequestBehavior.AllowGet));
        }
示例#9
0
        public ActionResult Visualizar(int id)
        {
            EmissaoCFO entidade = _bus.ObterHistorico(id);

            CFOVM vm = new CFOVM(entidade, _bus.ObterProdutoresLista(entidade.CredenciadoId), ListaCredenciadoBus.Estados, ListaCredenciadoBus.Municipios(entidade.EstadoId), _bus.ObterEmpreendimentosListaEtramiteX(entidade.ProdutorId),
                                 new List <Lista>(), ListaCredenciadoBus.CFOProdutoEspecificacao, ListaCredenciadoBus.DocFitossanitarioSituacao, new List <Lista>(), ListaCredenciadoBus.Municipios(entidade.EstadoEmissaoId));

            vm.IsVisualizar = true;
            return(View(vm));
        }
示例#10
0
        internal bool Excluir(int id)
        {
            EmissaoCFO cfo = _da.Obter(id, true);

            if (cfo.SituacaoId != (int)eDocumentoFitossanitarioSituacao.EmElaboracao)
            {
                Validacao.Add(Mensagem.EmissaoCFO.ExcluirSituacaoInvalida);
            }

            return(Validacao.EhValido);
        }
示例#11
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:
                PTVBus ptvBus = new PTVBus();
                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;

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

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

            //	if ((saldoOutrosDoc + quantidadeAdicionada + (prod.ExibeQtdKg ? prod.Quantidade / 1000 : prod.Quantidade)) > saldo)
            //	{
            //		Validacao.Add(Mensagem.PTV.SomaQuantidadeInvalida);
            //	}
            //}

            return(saldo);
        }
示例#12
0
        public ActionResult GerarPdf(int id)
        {
            try
            {
                EmissaoCFO cfo = _bus.Obter(id, simplificado: true);

                PdfCFO pdf = new PdfCFO();
                return(ViewModelHelper.GerarArquivoPdf(pdf.Gerar(id, cfo.CredenciadoId), "CFO"));
            }
            catch (Exception exc)
            {
                Validacao.AddErro(exc);
                return(RedirectToAction("Index", "CFO", Validacao.QueryParamSerializer()));
            }
        }
示例#13
0
        public bool Cancelar(EmissaoCFO entidade)
        {
            GerenciadorTransacao.ObterIDAtual();

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

                EmissaoCFO entidadeBanco = _da.ObterPorNumero(Convert.ToInt64(entidade.Numero), true, false, bancoDeDados);
                _da.Cancelar(entidadeBanco, bancoDeDados);

                bancoDeDados.Commit();
            }

            return(Validacao.EhValido);
        }
示例#14
0
        public ActionResult Criar()
        {
            if (!_validar.VerificarCredenciadoHabilitado())
            {
                return(RedirectToAction("Index", "CFO", Validacao.QueryParamSerializer()));
            }

            EmissaoCFO cfo = new EmissaoCFO();

            cfo.SituacaoId            = (int)eDocumentoFitossanitarioSituacao.EmElaboracao;
            cfo.DataEmissao.DataTexto = DateTime.Today.ToShortDateString();
            cfo.EstadoEmissaoId       = ViewModelHelper.EstadoDefaultId();

            CFOVM vm = new CFOVM(cfo, _bus.ObterProdutoresLista(), ListaCredenciadoBus.Estados, new List <Municipio>(), new List <Lista>(),
                                 new List <Lista>(), ListaCredenciadoBus.CFOProdutoEspecificacao, ListaCredenciadoBus.DocFitossanitarioSituacao, new List <Lista>(), ListaCredenciadoBus.Municipios(cfo.EstadoEmissaoId));

            return(View(vm));
        }
示例#15
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>());
        }
示例#16
0
        public EmissaoCFO ObterHistorico(int id, bool simplificado = false)
        {
            try
            {
                EmissaoCFO dataSource = _da.Obter(id, simplificado);

                if (dataSource.SituacaoId != (int)eDocumentoFitossanitarioSituacao.EmElaboracao)
                {
                    dataSource.Produtos = _da.ObterHistorico(id, dataSource.Tid);
                }

                return(dataSource);
            }
            catch (Exception exc)
            {
                Validacao.AddErro(exc);
            }

            return(null);
        }
示例#17
0
        internal bool Ativar(EmissaoCFO entidade)
        {
            EmissaoCFO entidadeBanco = _da.Obter(entidade.Id);

            ValidacoesGenericasBus.DataMensagem(entidade.DataAtivacao, "DataAtivacao", "ativação");

            if (entidadeBanco.TipoNumero == (int)eDocumentoFitossanitarioTipoNumero.Digital && entidade.DataAtivacao.DataTexto != DateTime.Today.ToShortDateString())
            {
                Validacao.Add(Mensagem.Padrao.DataIgualAtual("DataAtivacao", "ativação"));
            }

            if (entidadeBanco.SituacaoId != (int)eDocumentoFitossanitarioSituacao.EmElaboracao)
            {
                Validacao.Add(Mensagem.EmissaoCFO.AtivarSituacaoInvalida);
            }

            Salvar(entidadeBanco);

            return(Validacao.EhValido);
        }
示例#18
0
        public Resultados <EmissaoCFO> Filtrar(EmissaoCFO filtrosListar, Paginacao paginacao)
        {
            try
            {
                Filtro <EmissaoCFO>     filtro     = new Filtro <EmissaoCFO>(filtrosListar, paginacao);
                Resultados <EmissaoCFO> resultados = _da.Filtrar(filtro);

                if (resultados.Quantidade < 1)
                {
                    Validacao.Add(Mensagem.Padrao.NaoEncontrouRegistros);
                }

                return(resultados);
            }
            catch (Exception exc)
            {
                Validacao.AddErro(exc);
            }

            return(null);
        }
示例#19
0
        public CFOVM(EmissaoCFO cfo, List <Lista> lstProdutores, List <Estado> lstEstados, List <Municipio> lstMunicipios, List <Lista> lstEmpreendimentos,
                     List <Lista> lstPragas, List <Lista> lstCFOProdutosEspecificacoes, List <Lista> lstSituacoes, List <Lista> lstUnidadesProducao, List <Municipio> lstMunicipiosEmissao)
        {
            CFO = cfo ?? new EmissaoCFO();

            if (CFO.Id <= 0)
            {
                if (lstProdutores != null && lstProdutores.Count == 1)
                {
                    CFO.ProdutorId = Convert.ToInt32(lstProdutores.First().Id);
                }

                if (lstEmpreendimentos != null && lstEmpreendimentos.Count == 1)
                {
                    CFO.EmpreendimentoId = Convert.ToInt32(lstEmpreendimentos.First().Id);
                }
            }

            Produtores                = ViewModelHelper.CriarSelectList(lstProdutores, false, true, CFO.ProdutorId.ToString());
            Empreendimentos           = ViewModelHelper.CriarSelectList(lstEmpreendimentos, false, true, cfo.EmpreendimentoId.ToString());
            Situacoes                 = ViewModelHelper.CriarSelectList(lstSituacoes, false, true, cfo.SituacaoId.ToString());
            UnidadesProducao          = ViewModelHelper.CriarSelectList(lstUnidadesProducao);
            CFOProdutosEspecificacoes = lstCFOProdutosEspecificacoes;
            Pragas            = ViewModelHelper.CriarSelectList(lstPragas);
            Estados           = ViewModelHelper.CriarSelectList(lstEstados);
            Municipios        = ViewModelHelper.CriarSelectList(lstMunicipios);
            EstadosEmissao    = ViewModelHelper.CriarSelectList(lstEstados, selecionado: CFO.EstadoEmissaoId.ToString());
            MunicipiosEmissao = ViewModelHelper.CriarSelectList(lstMunicipiosEmissao, selecionado: CFO.MunicipioEmissaoId.ToString());

            if (CFO.EstadoId > 0)
            {
                Estados.Single(x => x.Value == CFO.EstadoId.ToString()).Selected = true;
            }

            if (CFO.MunicipioId > 0)
            {
                Municipios.Single(x => x.Value == CFO.MunicipioId.ToString()).Selected = true;
            }
        }
示例#20
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);
        }
示例#21
0
        public ActionResult Editar(int id)
        {
            if (!_validar.VerificarCredenciadoHabilitado())
            {
                return(RedirectToAction("Index", "CFO", Validacao.QueryParamSerializer()));
            }

            EmissaoCFO cfo = _bus.Obter(id);

            if (!_validar.Editar(cfo))
            {
                return(RedirectToAction("Index", "CFO", Validacao.QueryParamSerializer()));
            }

            List <int> culturas = new List <int>();

            cfo.Produtos.Select(x => x.CulturaId).ToList().ForEach(cultura =>
            {
                culturas.Add(cultura);
            });

            CFOVM vm = new CFOVM(cfo, _bus.ObterProdutoresLista(), ListaCredenciadoBus.Estados, ListaCredenciadoBus.Municipios(cfo.EstadoId), _bus.ObterEmpreendimentosLista(cfo.ProdutorId), _bus.ObterPragasLista(cfo.Produtos),
                                 ListaCredenciadoBus.CFOProdutoEspecificacao, ListaCredenciadoBus.DocFitossanitarioSituacao, _bus.ObterUnidadesProducaoLista(cfo.EmpreendimentoId, cfo.ProdutorId), ListaCredenciadoBus.Municipios(cfo.EstadoEmissaoId));

            CulturaInternoBus culturaBus            = new CulturaInternoBus();
            List <Cultivar>   cultivares            = culturaBus.ObterCultivares(cfo.Produtos.Select(x => x.CulturaId).ToList(), cfo.Produtos.Select(x => x.LoteId).ToList()) ?? new List <Cultivar>();
            List <string>     declaracoesAdicionais = cultivares
                                                      .Where(x => cfo.Produtos.Select(y => y.CultivarId).ToList().Any(y => y == x.Id))
                                                      .SelectMany(x => x.LsCultivarConfiguracao.Where(y => cfo.Produtos.Count(z => z.CultivarId == y.Cultivar && y.TipoProducaoId == (int)ValidacoesGenericasBus.ObterTipoProducao(z.UnidadeMedidaId)) > 0))
                                                      .Where(x => cfo.Pragas.Any(y => y.Id == x.PragaId))
                                                      .Select(x => x.DeclaracaoAdicionalTextoHtml)
                                                      .Distinct().ToList();

            vm.CFO.DeclaracaoAdicionalHtml = String.Join(" ", declaracoesAdicionais);

            return(View(vm));
        }
示例#22
0
        public Resultados <EmissaoCFO> Filtrar(EmissaoCFO filtrosListar, Paginacao paginacao)
        {
            try
            {
                Filtro <EmissaoCFO>     filtro     = new Filtro <EmissaoCFO>(filtrosListar, paginacao);
                Resultados <EmissaoCFO> resultados = _da.Filtrar(filtro);

                if (resultados.Quantidade < 1)
                {
                    Validacao.Add(Mensagem.Padrao.NaoEncontrouRegistros);
                }
                else
                {
                    for (int i = 0; i < resultados.Itens.Count; i++)
                    {
                        if (resultados.Itens[i].SituacaoId != (int)eDocumentoFitossanitarioSituacao.EmElaboracao)
                        {
                            var listaProdutos = _da.ObterHistorico(resultados.Itens[i].Id, resultados.Itens[i].Tid);

                            if (listaProdutos.Count > 0)
                            {
                                resultados.Itens[i].CulturaCultivar = listaProdutos.First().CulturaTexto + "/" + listaProdutos.First().CultivarTexto;
                            }
                        }
                    }
                }

                return(resultados);
            }
            catch (Exception exc)
            {
                Validacao.AddErro(exc);
            }

            return(null);
        }
示例#23
0
        public bool Salvar(EmissaoCFO cfo)
        {
            try
            {
                if (cfo.TipoNumero == (int)eDocumentoFitossanitarioTipoNumero.Digital)
                {
                    if (cfo.Id <= 0)
                    {
                        if (_validar.VerificarNumeroDigitalDisponivel())
                        {
                            cfo.Numero = ObterNumeroDigital();
                        }
                        else
                        {
                            return(false);
                        }
                    }
                    else
                    {
                        EmissaoCFO entidadeBanco = Obter(cfo.Id, simplificado: true);
                        cfo.Numero = entidadeBanco.Numero;
                    }
                }

                CulturaInternoBus culturaBus = new CulturaInternoBus();
                List <Cultivar>   cultivares = culturaBus.ObterCultivares(cfo.Produtos.Select(x => x.CulturaId).ToList()) ?? new List <Cultivar>();

                var declaracoesAdicionais = cultivares
                                            .Where(x => cfo.Produtos.Any(y => y.CultivarId == x.Id))
                                            .SelectMany(x => x.LsCultivarConfiguracao.Where(y => cfo.Produtos.Count(z => z.CultivarId == y.Cultivar && y.TipoProducaoId == (int)ValidacoesGenericasBus.ObterTipoProducao(z.UnidadeMedidaId)) > 0))
                                            .Where(x => cfo.Pragas.Any(y => y.Id == x.PragaId))
                                            .Select(x => x.DeclaracaoAdicionalTexto)
                                            .Distinct().ToList();

                var declaracoesAdicionaisHtml = cultivares
                                                .Where(x => cfo.Produtos.Any(y => y.CultivarId == x.Id))
                                                .SelectMany(x => x.LsCultivarConfiguracao.Where(y => cfo.Produtos.Count(z => z.CultivarId == y.Cultivar && y.TipoProducaoId == (int)ValidacoesGenericasBus.ObterTipoProducao(z.UnidadeMedidaId)) > 0))
                                                .Where(x => cfo.Pragas.Any(y => y.Id == x.PragaId))
                                                .Select(x => x.DeclaracaoAdicionalTextoHtml)
                                                .Distinct().ToList();

                cfo.DeclaracaoAdicional     = String.Join(" ", declaracoesAdicionais);
                cfo.DeclaracaoAdicionalHtml = String.Join(" ", declaracoesAdicionaisHtml);

                _validar.Salvar(cfo);

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

                GerenciadorTransacao.ObterIDAtual();

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

                    _da.Salvar(cfo, bancoDeDados);

                    _busInterno.SetarNumeroUtilizado(cfo.Numero, cfo.TipoNumero.GetValueOrDefault(), eDocumentoFitossanitarioTipo.CFO);

                    Validacao.Add(Mensagem.EmissaoCFO.Salvar(cfo.Numero));

                    bancoDeDados.Commit();
                }
            }
            catch (Exception e)
            {
                Validacao.AddErro(e);
            }

            return(Validacao.EhValido);
        }
示例#24
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);
        }
示例#25
0
        public ActionResult VerificarCredenciadoHabilitado(EmissaoCFO entidade)
        {
            _validar.ValidarAssociarResponsavelTecnicoHabilitado(entidade);

            return(Json(new { @EhValido = Validacao.EhValido, @Msg = Validacao.Erros }, JsonRequestBehavior.AllowGet));
        }
示例#26
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;
            }
        }
示例#27
0
        internal bool Salvar(EmissaoCFO entidade)
        {
            //Valida a habilitacao antes do salvar o credenciado.

            if (!entidade.TipoNumero.HasValue)
            {
                Validacao.Add(Mensagem.EmissaoCFO.TipoNumeroObrigatorio);
            }
            else
            {
                if (entidade.TipoNumero == (int)eDocumentoFitossanitarioTipoNumero.Bloco)
                {
                    if (!ValidarNumeroBloco(entidade.Numero, entidade.Id))
                    {
                        return(false);
                    }

                    ValidacoesGenericasBus.DataMensagem(entidade.DataEmissao, "CFO_DataEmissao", "emissão");
                }

                if (entidade.TipoNumero == (int)eDocumentoFitossanitarioTipoNumero.Digital)
                {
                    //VerificarNumeroDigitalDisponivel foi validado na BUS
                    if (!_da.NumeroCancelado(entidade.Numero))
                    {
                        Validacao.Add(Mensagem.EmissaoCFO.NumeroCancelado);
                        return(false);
                    }
                }
            }

            if (!_da.VerificarProdutorAssociado(entidade.ProdutorId))
            {
                Validacao.Add(Mensagem.EmissaoCFO.ProdutorNaoEstaMaisAssociado);
            }

            if (!_da.VerificarProdutorAssociadoEmpreendimento(entidade.ProdutorId))
            {
                Validacao.Add(Mensagem.EmissaoCFO.ProdutorNaoEstaMaisAssociadoEmpreendimento);
            }

            if (entidade.ProdutorId <= 0)
            {
                Validacao.Add(Mensagem.EmissaoCFO.ProdutorObrigatorio);
            }

            if (entidade.EmpreendimentoId <= 0)
            {
                Validacao.Add(Mensagem.EmissaoCFO.EmpreendimentoObrigatorio);
            }

            if (entidade.Produtos.Count <= 0)
            {
                Validacao.Add(Mensagem.EmissaoCFO.ProdutoObrigatorio);
            }
            else
            {
                if (entidade.Produtos.Count > 5)
                {
                    Validacao.Add(Mensagem.EmissaoCFO.LimiteMaximo);
                }
                else
                {
                    entidade.Produtos.ForEach(produto =>
                    {
                        ResponsavelTecnico responsavel = _da.ObterResponsavelUC(produto.UnidadeProducao);
                        if (!string.IsNullOrEmpty(responsavel.DataValidadeART) && DateTime.Parse(responsavel.DataValidadeART) < DateTime.Today)
                        {
                            Validacao.Add(Mensagem.EmissaoCFO.DataValidadeARTMenorAtual);
                        }

                        ValidarProduto(entidade.Id, entidade.EmpreendimentoId, produto, entidade.Produtos);
                    });
                }
            }

            if (entidade.Pragas.Count <= 0)
            {
                Validacao.Add(Mensagem.EmissaoCFO.PragaAssociadaCulturaObrigatorio);
            }
            else
            {
                entidade.Pragas.ForEach(praga =>
                {
                    ValidarPraga(praga);
                });
            }

            if (!entidade.PossuiLaudoLaboratorial.HasValue)
            {
                Validacao.Add(Mensagem.EmissaoCFO.PossuiLaudoLaboratorialObrigatorio);
            }
            else
            {
                if (entidade.PossuiLaudoLaboratorial.Value)
                {
                    if (string.IsNullOrEmpty(entidade.NomeLaboratorio))
                    {
                        Validacao.Add(Mensagem.EmissaoCFO.NomeLaboratorioObrigatorio);
                    }

                    if (string.IsNullOrEmpty(entidade.NumeroLaudoResultadoAnalise))
                    {
                        Validacao.Add(Mensagem.EmissaoCFO.NumeroLaudoResultadoAnaliseObrigatorio);
                    }

                    if (entidade.EstadoId <= 0)
                    {
                        Validacao.Add(Mensagem.EmissaoCFO.EstadoObrigatorio);
                    }

                    if (entidade.MunicipioId <= 0)
                    {
                        Validacao.Add(Mensagem.EmissaoCFO.MunicipioObrigatorio);
                    }
                }
            }

            if (entidade.ProdutoEspecificacao <= 0)
            {
                Validacao.Add(Mensagem.EmissaoCFO.ProdutoEspecificacaoObrigatorio);
            }

            if (!entidade.PossuiTratamentoFinsQuarentenario.HasValue)
            {
                Validacao.Add(Mensagem.EmissaoCFO.PossuiTratamentoFinsQuarentenarioObrigatorio);
            }
            else
            {
                if (entidade.PossuiTratamentoFinsQuarentenario.Value)
                {
                    entidade.TratamentosFitossanitarios.ForEach(tratamento =>
                    {
                        ValidarTratamento(tratamento);
                    });
                }
            }

            if (entidade.PartidaLacradaOrigem && string.IsNullOrEmpty(entidade.NumeroLacre) && string.IsNullOrEmpty(entidade.NumeroPorao) && string.IsNullOrEmpty(entidade.NumeroContainer))
            {
                Validacao.Add(Mensagem.EmissaoCFO.LacrePoraoConteinerObrigatorio);
            }

            if (entidade.ValidadeCertificado <= 0)
            {
                Validacao.Add(Mensagem.EmissaoCFO.ValidadeCertificadoObrigatorio);
            }
            else if (entidade.ValidadeCertificado > 30)
            {
                Validacao.Add(Mensagem.EmissaoCFO.ValidadeCertificadoMaxima);
            }

            if (entidade.MunicipioEmissaoId <= 0)
            {
                Validacao.Add(Mensagem.EmissaoCFO.MunicipioEmissaoObrigatorio);
            }

            return(Validacao.EhValido);
        }
示例#28
0
        public bool ValidarAssociarResponsavelTecnicoHabilitado(EmissaoCFO entidade)
        {
            #region Configurar

            List <Cultivar> cultivares = new List <Cultivar>();
            foreach (var item in entidade.Produtos)
            {
                cultivares.Add(new Cultivar()
                {
                    CulturaId = item.CulturaId, Id = item.CultivarId
                });
            }

            if (cultivares.Count <= 0)
            {
                Validacao.Add(Mensagem.EmissaoCFO.ProdutoObrigatorio);
                return(false);
            }

            HabilitarEmissaoCFOCFOCBus habilitarEmissaoCFOCFOCBus = new HabilitarEmissaoCFOCFOCBus();
            HabilitarEmissaoCFOCFOC    habilitacao = new HabilitarEmissaoCFOCFOCBus().ObterPorCredenciado(User.FuncionarioId);
            if (Validacao.EhValido)
            {
                PragaInternoBus pragaBus = new PragaInternoBus();
                habilitacao.Pragas.ForEach(x =>
                {
                    x.Praga.Culturas = pragaBus.ObterCulturas(x.Praga.Id);
                });
            }
            else
            {
                return(false);
            }

            #endregion

            if (habilitacao.Id <= 0)
            {
                Validacao.Add(Mensagem.EmissaoCFO.ResponsavelTecnicoNaoHabilitado);
                return(false);
            }

            if (habilitacao.Situacao == (int)eHabilitacaoCFOCFOCSituacao.Inativo)
            {
                Validacao.Add(Mensagem.EmissaoCFO.ResponsavelTecnicoInativo);
                return(false);
            }

            if (!habilitacao.Pragas.SelectMany(p => p.Praga.Culturas).ToList().Exists(c => cultivares.Exists(x => x.CulturaId == c.Id)))
            {
                Validacao.Add(Mensagem.EmissaoCFO.ResponsavelTecnicoNaoHabilitadoParaCultura);
                return(false);
            }

            if (DateTime.Parse(habilitacao.ValidadeRegistro) < DateTime.Today)
            {
                Validacao.Add(Mensagem.EmissaoCFO.ValidadeRegistroMenorAtual);
                return(false);
            }

            foreach (var item in entidade.Pragas)
            {
                if (!habilitacao.Pragas.Exists(y => y.Praga.Id == item.Id))
                {
                    Validacao.Add(Mensagem.EmissaoCFO.PragaNaoAssociadaHabilitacao(item.NomeCientifico, item.NomeComum));
                    return(false);
                }
            }

            List <string> aux = new List <string>();
            foreach (var habPraga in habilitacao.Pragas)
            {
                foreach (var cultivarItem in habPraga.Praga.Culturas.SelectMany(x => x.LstCultivar))
                {
                    foreach (var item in cultivares)
                    {
                        if (cultivarItem.Id == item.Id && DateTime.Parse(habPraga.DataFinalHabilitacao) < DateTime.Today)
                        {
                            if (!aux.Any(a => a == cultivarItem.Nome))
                            {
                                aux.Add(cultivarItem.Nome);
                            }
                        }
                    }
                }
            }

            if (aux.Count > 0)
            {
                if ((eDocumentoFitossanitarioTipoNumero)entidade.TipoNumero == eDocumentoFitossanitarioTipoNumero.Bloco)
                {
                    Validacao.Add(Mensagem.EmissaoCFO.ResponsavelTecnicoHabilitacaoPragaVencidaBloco(Mensagem.Concatenar(aux)));
                }
                else
                {
                    Validacao.Add(Mensagem.EmissaoCFO.ResponsavelTecnicoHabilitacaoPragaVencidaDigital(Mensagem.Concatenar(aux)));
                }
            }

            return(Validacao.EhValido);
        }
示例#29
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);
        }