Пример #1
0
        internal void Criar(PTVOutro PTV, BancoDeDados banco)
        {
            using (BancoDeDados bancoDeDados = BancoDeDados.ObterInstancia(banco))
            {
                bancoDeDados.IniciarTransacao();
                Comando comando = null;

                #region Insert

                comando = bancoDeDados.CriarComando(@"
				insert into tab_ptv_outrouf
					(id,
					tid,
					numero,
					data_emissao,
					data_ativacao,
					data_cancelamento,
					situacao,
					interessado,
					interessado_cnpj_cpf,
					interessado_endereco,
					interessado_estado,
					interessado_municipio,
					destinatario,
					valido_ate,
					resp_tecnico,
					resp_tecnico_num_hab,
					estado,
					municipio,
					credenciado,
                    declaracao_adicional,
                    declaracao_adicional_formatado)
				values
					(seq_tab_ptv_outrouf.nextval,
					:tid,
					:numero,
					:data_emissao,
					:data_ativacao,
					:data_cancelamento,
					:situacao,
					:interessado,
					:interessado_cnpj_cpf,
					:interessado_endereco,
					:interessado_estado,
					:interessado_municipio,
					:destinatario,
					:valido_ate,
					:resp_tecnico,
					:resp_tecnico_num_hab,
					:estado,
					:municipio,
					:credenciado,
                    :declaracao_adicional,
                    :declaracao_adicional_formatado) returning id into :id", Esquema);
                #endregion

                comando.AdicionarParametroEntrada("tid", DbType.String, 36, GerenciadorTransacao.ObterIDAtual());
                comando.AdicionarParametroEntrada("numero", PTV.Numero > 0 ? PTV.Numero : (object)DBNull.Value, DbType.Int64);
                comando.AdicionarParametroEntrada("data_emissao", PTV.DataEmissao.Data, DbType.DateTime);
                comando.AdicionarParametroEntrada("data_ativacao", PTV.DataAtivacao.Data, DbType.DateTime);
                comando.AdicionarParametroEntrada("data_cancelamento", PTV.DataCancelamento.Data, DbType.DateTime);
                comando.AdicionarParametroEntrada("situacao", PTV.Situacao, DbType.Int32);
                comando.AdicionarParametroEntrada("interessado", DbType.String, 120, PTV.Interessado);
                comando.AdicionarParametroEntrada("interessado_cnpj_cpf", DbType.String, 20, PTV.InteressadoCnpjCpf);
                comando.AdicionarParametroEntrada("interessado_endereco", DbType.String, 200, PTV.InteressadoEndereco);
                comando.AdicionarParametroEntrada("interessado_estado", PTV.InteressadoEstadoId, DbType.Int32);
                comando.AdicionarParametroEntrada("interessado_municipio", PTV.InteressadoMunicipioId, DbType.Int32);
                comando.AdicionarParametroEntrada("destinatario", PTV.DestinatarioID, DbType.Int32);
                comando.AdicionarParametroEntrada("valido_ate", PTV.ValidoAte.Data, DbType.DateTime);
                comando.AdicionarParametroEntrada("resp_tecnico", DbType.String, 120, PTV.RespTecnico);
                comando.AdicionarParametroEntrada("resp_tecnico_num_hab", DbType.String, 8, PTV.RespTecnicoNumHab);
                comando.AdicionarParametroEntrada("estado", PTV.Estado, DbType.Int32);
                comando.AdicionarParametroEntrada("municipio", PTV.Municipio, DbType.Int32);
                comando.AdicionarParametroEntrada("credenciado", PTV.CredenciadoId, DbType.Int32);
                comando.AdicionarParametroEntrada("declaracao_adicional", PTV.DeclaracaoAdicional, DbType.String);
                comando.AdicionarParametroEntrada("declaracao_adicional_formatado", PTV.DeclaracaoAdicional, DbType.String);

                //ID de retorno
                comando.AdicionarParametroSaida("id", DbType.Int32);

                bancoDeDados.ExecutarScalar(comando);

                PTV.Id = Convert.ToInt32(comando.ObterValorParametro("id"));

                #region Produto PTV
                //
                //
                comando = bancoDeDados.CriarComando(@"
				insert into tab_ptv_outrouf_produto
					(id, tid, ptv, origem_tipo, cultura, cultivar, quantidade, unidade_medida, tipo_producao, numero_origem)
				values 
					(seq_tab_ptv_outrouf_prod.nextval, :tid, :ptv, :origem_tipo, :cultura, :cultivar, :quantidade, :unidade_medida, :tipo_producao, :numero_origem)"                    , Esquema);

                comando.AdicionarParametroEntrada("tid", DbType.String, 36, GerenciadorTransacao.ObterIDAtual());
                comando.AdicionarParametroEntrada("ptv", PTV.Id, DbType.Int32);
                comando.AdicionarParametroEntrada("origem_tipo", DbType.Int32);

                comando.AdicionarParametroEntrada("cultura", DbType.Int32);
                comando.AdicionarParametroEntrada("cultivar", DbType.Int32);
                comando.AdicionarParametroEntrada("quantidade", DbType.Decimal);
                comando.AdicionarParametroEntrada("unidade_medida", DbType.Int32);
                comando.AdicionarParametroEntrada("numero_origem", DbType.String);
                comando.AdicionarParametroEntrada("tipo_producao", DbType.Int32);

                PTV.Produtos.ForEach(item =>
                {
                    comando.SetarValorParametro("origem_tipo", item.OrigemTipo);
                    comando.SetarValorParametro("cultura", item.Cultura);
                    comando.SetarValorParametro("cultivar", item.Cultivar);
                    comando.SetarValorParametro("quantidade", item.Quantidade);
                    comando.SetarValorParametro("unidade_medida", item.UnidadeMedida);
                    comando.SetarValorParametro("numero_origem", item.OrigemNumero);
                    comando.SetarValorParametro("tipo_producao", item.ProducaoTipo);

                    bancoDeDados.ExecutarNonQuery(comando);
                });

                #endregion

                #region Declaracao PTV

                comando = bancoDeDados.CriarComando(@"
				insert into tab_ptv_outrouf_declaracao
					(id, tid, ptv, declaracao_adicional, cultivar, praga)
				values 
					(seq_tab_ptv_outrouf_declaracao.nextval, :tid, :ptv, :declaracao, :cultivar, :praga)"                    , Esquema);

                comando.AdicionarParametroEntrada("tid", DbType.String, 36, GerenciadorTransacao.ObterIDAtual());
                comando.AdicionarParametroEntrada("ptv", PTV.Id, DbType.Int32);
                comando.AdicionarParametroEntrada("declaracao", DbType.Int32);
                comando.AdicionarParametroEntrada("cultivar", DbType.Int32);
                comando.AdicionarParametroEntrada("praga", DbType.Int32);

                PTV.Declaracoes.ForEach(item =>
                {
                    comando.SetarValorParametro("declaracao", item.IdDeclaracao);
                    comando.SetarValorParametro("cultivar", item.IdCultivar);
                    comando.SetarValorParametro("praga", item.IdPraga);

                    bancoDeDados.ExecutarNonQuery(comando);
                });

                #region Arquivos

                if (PTV.Anexos != null && PTV.Anexos.Count > 0)
                {
                    comando = bancoDeDados.CriarComando(@"insert into tab_ptv_outro_arquivo a (id, ptv, arquivo, ordem, descricao, tid) 
					values ({0}seq_ptv_arquivo.nextval, :ptv, :arquivo, :ordem, :descricao, :tid)"                    , EsquemaBanco);

                    comando.AdicionarParametroEntrada("ptv", PTV.Id, DbType.Int32);
                    comando.AdicionarParametroEntrada("arquivo", DbType.Int32);
                    comando.AdicionarParametroEntrada("ordem", DbType.Int32);
                    comando.AdicionarParametroEntrada("descricao", DbType.String, 100);
                    comando.AdicionarParametroEntrada("tid", DbType.String, 36, GerenciadorTransacao.ObterIDAtual());

                    foreach (Anexo item in PTV.Anexos)
                    {
                        comando.SetarValorParametro("arquivo", item.Arquivo.Id);
                        comando.SetarValorParametro("ordem", item.Ordem);
                        comando.SetarValorParametro("descricao", item.Descricao);
                        bancoDeDados.ExecutarNonQuery(comando);
                    }
                }

                #endregion


                #endregion

                Historico.Gerar(PTV.Id, eHistoricoArtefato.emitirptvoutro, eHistoricoAcao.criar, bancoDeDados);

                bancoDeDados.Commit();
            }
        }
Пример #2
0
        internal PTVOutro Obter(int id, bool simplificado = false, BancoDeDados banco = null)
        {
            PTVOutro PTV = new PTVOutro();

            using (BancoDeDados bancoDeDados = BancoDeDados.ObterInstancia())
            {
                Comando comando = bancoDeDados.CriarComando(@"
				select p.tid                   Tid,
						p.id                    Id,
						p.numero                Numero,
						p.data_emissao          DataEmissaoText,
						p.data_ativacao         DataAtivacaoText,
						p.data_cancelamento     DataCancelamentoText,
						p.situacao              Situacao,
						ls.texto                SituacaoTexto,
						p.interessado           Interessado,
						p.interessado_cnpj_cpf  InteressadoCnpjCpf,
						p.interessado_endereco  InteressadoEndereco,
						p.interessado_estado    InteressadoEstadoId,
						lee.texto               InteressadoEstadoTexto,
						p.interessado_municipio InteressadoMunicipioId,
						lme.texto               InteressadoMunicipioTexto,
						p.destinatario          DestinatarioID,
						p.valido_ate            ValidoAteText,
						p.resp_tecnico          RespTecnico,
						p.resp_tecnico_num_hab  RespTecnicoNumHab,
						p.estado                Estado,
						le.texto                EstadoTexto,
						p.municipio             Municipio,
						lm.texto                MunicipioTexto,
						p.credenciado           CredenciadoId,
                        p.declaracao_adicional  DeclaracaoAdicional,
                        p.declaracao_adicional_formatado    DeclaracaoAdicionalHtml
					from tab_ptv_outrouf               p,
						lov_ptv_situacao              ls,
						lov_estado                    le,
						lov_estado                    lee,
						lov_municipio                 lm,
						lov_municipio                 lme
					where ls.id = p.situacao
					and le.id(+) = p.estado
					and lee.id(+) = p.interessado_estado
					and lm.id(+) = p.municipio
					and lme.id(+) = p.interessado_municipio
					and p.id = :id"                    , Esquema);

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

                PTV = bancoDeDados.ObterEntity <PTVOutro>(comando);

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

                #region PTV Produto

                comando = bancoDeDados.CriarComando(@"
				select pr.id						Id,
					pr.tid							Tid,
					pr.ptv							PTV,
					pr.origem_tipo					OrigemTipo,
					pr.numero_origem				OrigemNumero,
					t.texto							OrigemTipoTexto,
					pr.cultura						Cultura,
					c.texto							CulturaTexto,
					pr.cultivar						Cultivar,
					cc.cultivar						CultivarTexto,
					c.texto || '/' || cc.cultivar	CulturaCultivar,
					pr.quantidade					Quantidade,
					pr.unidade_medida				UnidadeMedida,
					u.texto							UnidadeMedidaTexto,
					pr.tipo_producao				ProducaoTipo,
					ltp.texto						ProducaoTipoTexto
				from tab_ptv_outrouf_produto		pr,
					lov_doc_fitossanitarios_tipo	t,
					tab_cultura						c,
					tab_cultura_cultivar			cc,
					lov_crt_uni_prod_uni_medida		u,
					lov_tipo_producao				ltp
				where t.id = pr.origem_tipo
					and c.id = pr.cultura
					and cc.id = pr.cultivar
					and u.id = pr.unidade_medida
					and pr.tipo_producao = ltp.id(+)
					and pr.ptv = :ptv"                    , Esquema);

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

                PTV.Produtos = bancoDeDados.ObterEntityList <PTVOutroProduto>(comando);

                PTV.Pragas = ObterPragasLista2(PTV.Produtos);

                #endregion

                #region PTV Declaracoes


                comando = bancoDeDados.CriarComando(@"
				select d.praga              IdPraga,
                       p.nome_cientifico    NomeCientifico,
                       p.nome_comum         NomeComum,
                       c.Texto              DeclaracaoAdicional,
                       c.id                 IdDeclaracao,
                       d.cultivar           IdCultivar            
				from 
					tab_ptv_outrouf_declaracao	d,
					lov_cultivar_declara_adicional	c,
                    tab_praga p
				where d.declaracao_adicional = c.id
                    and d.praga = p.id
					and d.ptv = :ptv"                    , Esquema);

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

                PTV.Declaracoes = bancoDeDados.ObterEntityList <PTVOutroDeclaracao>(comando);

                #endregion

                #region Arquivos


                string strSQL = @"select count(*)  from 
                                                        tab_ptv_outrouf ptv 
                                                        inner join tab_ptv_arquivo a on ptv.id = a.ptv
                                                        inner join tab_arquivo b on a.arquivo = b.id
                                                        where ptv.id = :ptv order by a.ordem";
                comando = bancoDeDados.CriarComando(strSQL);

                comando.AdicionarParametroEntrada("ptv", PTV.Id, DbType.Int32);
                int Ret = Convert.ToInt32(bancoDeDados.ExecutarScalar(comando));

                if (Ret == 0)
                {
                    strSQL = @"select a.id, a.ordem, a.descricao, b.nome, b.extensao, b.id arquivo_id, b.caminho,
				       a.tid from tab_ptv_outro_arquivo a, tab_arquivo b where a.arquivo = b.id and a.ptv = :ptv order by a.ordem"                ;
                }
                else
                {
                    strSQL = @"select a.id, a.ordem, a.descricao, b.nome, b.extensao, b.id arquivo_id, b.caminho, a.tid  from 
                                                        tab_ptv_outrouf ptv 
                                                        inner join tab_ptv_arquivo a on ptv.id = a.ptv
                                                        inner join tab_arquivo b on a.arquivo = b.id
                                                        where ptv.id = :ptv order by a.ordem";
                }



                comando = bancoDeDados.CriarComando(strSQL);

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

                using (IDataReader reader = bancoDeDados.ExecutarReader(comando))
                {
                    Anexo item;
                    while (reader.Read())
                    {
                        item           = new Anexo();
                        item.Id        = Convert.ToInt32(reader["id"]);
                        item.Ordem     = Convert.ToInt32(reader["ordem"]);
                        item.Descricao = reader["descricao"].ToString();

                        item.Arquivo.Id       = Convert.ToInt32(reader["arquivo_id"]);
                        item.Arquivo.Caminho  = reader["caminho"].ToString();
                        item.Arquivo.Nome     = reader["nome"].ToString();
                        item.Arquivo.Extensao = reader["extensao"].ToString();

                        item.Tid = reader["tid"].ToString();

                        PTV.Anexos.Add(item);
                    }
                    reader.Close();
                }

                #endregion


                return(PTV);
            }
        }
        public ActionResult CancelarConfirm(int id)
        {
            PTVOutro ptv = _bus.Obter(id, true);

            return(PartialView("CancelarPartial", ptv));
        }
        public ActionResult Cancelar(int id)
        {
            PTVOutro ptv = _bus.Obter(id, true);

            return(View("Cancelar", ptv));
        }
Пример #5
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.DataAtivacao.Data.GetValueOrDefault().AddDays(cfo.ValidadeCertificado);
                if (dataVencimentoCFO < DateTime.Today)
                {
                    Validacao.Add(Mensagem.Lote.OrigemVencida(item.OrigemTipoTexto));
                }

                //if (cfo.DataAtivacao.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.DataAtivacao.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 (item.ExibeQtdKg)
                    {
                        item.Quantidade = item.Quantidade / 1000;
                    }

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

            return(Validacao.EhValido);
        }
Пример #6
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;
            }
        }
Пример #7
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);
        }