public Resultado ValidarProcessoCompraItem(ProcessoCompraItem oPedItem)
        {
            if (oPedItem.Status > 2)
                m_resultado.Sucesso = true;
            else
                m_resultado.Sucesso = oPedItem.Quantidade == oPedItem.QuantidadeComprada;

            return m_resultado;
        }
        public Resultado AtualizaItemCompra(ProcessoCompraItem pPCItem)
        {
            Resultado resultado = new Resultado();
            try
            {
                DbCommand dbc = this.m_db.GetStoredProcCommand("dbo.SP_PEDINTEM_UPDATE");

                this.m_db.AddInParameter(dbc, "@CODPEDITENS", DbType.Int32, pPCItem.CodItem);
                this.m_db.AddInParameter(dbc, "@QTDCOMPRADA", DbType.Int32, pPCItem.QuantidadeComprada);

                if (pPCItem.NotaFiscal > 0)
                    this.m_db.AddInParameter(dbc, "@NOTAFISCAL", DbType.Int32, pPCItem.NotaFiscal);

                if (pPCItem.DataEmissaoNota > DateTime.MinValue)
                    this.m_db.AddInParameter(dbc, "@DATAEMISSAONF", DbType.DateTime, pPCItem.DataEmissaoNota);

                if (pPCItem.NotaSerie != "")
                    this.m_db.AddInParameter(dbc, "@SERIENF", DbType.String, pPCItem.NotaSerie);
                this.m_db.AddInParameter(dbc, "@STATUS", DbType.Int32, pPCItem.NextStatus);

                if (pPCItem.DataCompra > DateTime.MinValue)
                    this.m_db.AddInParameter(dbc, "@DTCOMPRA", DbType.DateTime, pPCItem.DataCompra);
                if (pPCItem.DataPrevisaoEntrega > DateTime.MinValue)
                    this.m_db.AddInParameter(dbc, "@DTPREVISAO", DbType.DateTime, pPCItem.DataPrevisaoEntrega);
                if (pPCItem.DataEntrega > DateTime.MinValue)
                    this.m_db.AddInParameter(dbc, "@DTENTREGA", DbType.DateTime, pPCItem.DataEntrega);
                this.m_db.AddInParameter(dbc, "@VALOR", DbType.Decimal, pPCItem.ValorUnitario);
                this.m_db.AddInParameter(dbc, "@FORNECEDOR", DbType.Int32, pPCItem.Fornecedor.FornecedorID);

                if (pPCItem.TpDocumentoFiscal > 0)
                    this.m_db.AddInParameter(dbc, "@TPDOCUMENTO", DbType.Int32, pPCItem.TpDocumentoFiscal);

                this.m_db.AddInParameter(dbc, "@DESCMOTIVOCANCELADO", DbType.String, pPCItem.DescMotivoCancelamento);

                resultado.Id = Convert.ToInt32(this.m_db.ExecuteNonQuery(dbc));
                resultado.Sucesso = (resultado.Id > 0);

            }
            catch (Exception ex)
            {
                resultado.Sucesso = false;
                Mensagem mensagem = new Mensagem();
                mensagem.Campo = "PedidoItemValor";
                mensagem.Descricoes.Add(ex.Message);
                resultado.Mensagens.Add(mensagem);
            }

            return resultado;
        }
        public Resultado AtualizaItemCompra(ProcessoCompraItem pPCItem)
        {
            Resultado resultado = new Resultado();
            ProcessoCompraItemValidation Validation = new ProcessoCompraItemValidation(pPCItem);

            resultado = Validation.ValidarProcessoCompraItem();

            if (resultado.Sucesso)
            {
                if (pPCItem.NextStatus != 5 && pPCItem.NextStatus != 6)
                {
                    resultado = new PedItemValidation().ValidarProcessoCompraItem(pPCItem);
                    if (resultado.Sucesso == false)
                    {
                        resultado = new Ped_ItemData().IncluirCompraRestante(pPCItem);
                    }
                }
                resultado = new Ped_ItemData().AtualizaItemCompra(pPCItem);
            }

            return resultado;
        }
        public List<ProcessoCompraItem> ListaItensPCompra(int CodPCompra)
        {
            DbCommand dbCommand = this.m_db.GetStoredProcCommand("dbo.SP_PROCESSOCOMPRAITENS_LISTA");
            this.m_db.AddInParameter(dbCommand, "@CDP", DbType.Int32, CodPCompra);

            List<ProcessoCompraItem> listaCompras = new List<ProcessoCompraItem>();

            using (IDataReader readerlistaCompras = this.m_db.ExecuteReader(dbCommand))
            {
                while (readerlistaCompras.Read())
                {
                    ProcessoCompraItem oPedListaItem = new ProcessoCompraItem();
                    Item oItem = new Item();
                    oItem.Nome = Conversion.preencheCampoString(readerlistaCompras["NOM_ITEM"]);

                    oPedListaItem.Item = oItem;
                    oPedListaItem.CodProcesso = Conversion.preencheCampoInt(readerlistaCompras["COD_PROCESSOCOMPRA"]);
                    oPedListaItem.CodPedido = Conversion.preencheCampoInt(readerlistaCompras["COD_PEDIDO"]);
                    oPedListaItem.CodItem = Conversion.preencheCampoInt(readerlistaCompras["COD_PEDITENS"]);
                    oPedListaItem.NomeProjeto = Conversion.preencheCampoString(readerlistaCompras["NOM_PROJETO"]);
                    oPedListaItem.NomeUsuario = Conversion.preencheCampoString(readerlistaCompras["NOME"]);
                    oPedListaItem.Outros = Conversion.preencheCampoString(readerlistaCompras["DSC_OUTROS"]);
                    oPedListaItem.Quantidade = Conversion.preencheCampoInt(readerlistaCompras["QUANTIDADE"]) < 0 ? 0 : Conversion.preencheCampoInt(readerlistaCompras["QUANTIDADE"]);
                    oPedListaItem.QuantidadeComprada = Conversion.preencheCampoInt(readerlistaCompras["NUM_QTDCOMPRADA"]) < 0 ? 0 : Conversion.preencheCampoInt(readerlistaCompras["NUM_QTDCOMPRADA"]);
                    oPedListaItem.NomeItem = Conversion.preencheCampoString(readerlistaCompras["NOM_ITEM"]);
                    oPedListaItem.Empresa = Conversion.preencheCampoString(readerlistaCompras["NOM_CENTRODECUSTO"]);
                    oPedListaItem.ValorUnitario = Conversion.preencheCampoDecimal(readerlistaCompras["VAL_UNITARIO"]) < 0 ? 0 : Conversion.preencheCampoDecimal(readerlistaCompras["VAL_UNITARIO"]);
                    oPedListaItem.DataCompra = Conversion.preencheCampoDateTime(readerlistaCompras["DAT_PEDIDO_COMPRA"]);
                    oPedListaItem.DataPrevisaoEntrega = Conversion.preencheCampoDateTime(readerlistaCompras["DAT_PEDIDO_PREVISAO"]);
                    oPedListaItem.DataEntrega = Conversion.preencheCampoDateTime(readerlistaCompras["DAT_PEDIDO_ENTREGA"]);
                    oPedListaItem.Status = Conversion.preencheCampoInt(readerlistaCompras["NUM_STATUS_ITEM"]);

                    oPedListaItem.TpDocumentoFiscal = Conversion.preencheCampoInt(readerlistaCompras["TP_DOCUMENTO"]) < 0 ? 0 : Conversion.preencheCampoInt(readerlistaCompras["TP_DOCUMENTO"]);
                    oPedListaItem.NotaSerie = Conversion.preencheCampoString(readerlistaCompras["NUM_SERIE_NOTA"]);
                    oPedListaItem.NotaFiscal = Conversion.preencheCampoInt(readerlistaCompras["NUM_NOTAFISCAL"]) < 0 ? 0 : Conversion.preencheCampoInt(readerlistaCompras["NUM_NOTAFISCAL"]);
                    oPedListaItem.DataEmissaoNota = Conversion.preencheCampoDateTime(readerlistaCompras["DAT_EMISSAO_NOTA"]);

                    Fornecedor oFornecedor = new Fornecedor();
                    oFornecedor.FornecedorID = Conversion.preencheCampoInt(readerlistaCompras["FORNECEDOR_ID"]);
                    oPedListaItem.Fornecedor = oFornecedor;

                    Grupo oGrupo = new Grupo();
                    oGrupo.ID = Conversion.preencheCampoInt(readerlistaCompras["GRUPO_ID"]);
                    oGrupo.Nome = Conversion.preencheCampoString(readerlistaCompras["NOM_GRUPO"]);
                    oPedListaItem.Area = oGrupo;

                    oPedListaItem.NomeArea = Conversion.preencheCampoString(readerlistaCompras["NOM_GRUPO"]);

                    listaCompras.Add(oPedListaItem);
                }
                readerlistaCompras.Dispose();
            }
            return listaCompras;
        }
        public Resultado IncluirCompraRestante(ProcessoCompraItem oPedItem)
        {
            Resultado resultado = new Resultado();

            try
            {
                DbCommand dbCommand = this.m_db.GetStoredProcCommand("dbo.SP_PEDITEM_INSERERESTANTE");
                this.m_db.AddInParameter(dbCommand, "@COD_PEDITENS", DbType.Int32, oPedItem.CodItem);
                this.m_db.AddInParameter(dbCommand, "@QUANTIDADE", DbType.Int32, (oPedItem.Quantidade - oPedItem.QuantidadeComprada));

                resultado.Id = Convert.ToInt32(this.m_db.ExecuteScalar(dbCommand));
                resultado.Sucesso = (resultado.Id > 0);

            }
            catch (Exception ex)
            {
                resultado.Sucesso = false;
                Mensagem mensagem = new Mensagem();
                mensagem.Campo = "PedidoItemRestante";
                mensagem.Descricoes.Add(ex.Message);
                resultado.Mensagens.Add(mensagem);
            }

            return resultado;
        }
        protected void Page_Load(object sender, EventArgs e)
        {
            if (!Page.IsPostBack)
            {
                Resultado resultado = new Resultado();

                ddl_Fornecedor.DataSource = new FornecedorFacade().Listar(ref resultado, new Entities.Fornecedor());
                ddl_Fornecedor.DataValueField = "FornecedorID";
                ddl_Fornecedor.DataTextField = "NomeFantasia";
                ddl_Fornecedor.DataBind();
                ddl_Fornecedor.Items.Insert(0, new ListItem("", "0"));

                ddl_TpDocumento.DataSource = new TipoDocumentoFacade().Listar(ref resultado);
                ddl_TpDocumento.DataBind();
                ddl_TpDocumento.Items.Insert(0, new ListItem("", "0"));

                ddl_Status.DataSource = StatusItem = new Ped_ItemFacade().ListarStatus(ref resultado);
                ddl_Status.DataValueField = "StatusId";
                ddl_Status.DataTextField = "Descricao";
                ddl_Status.DataBind();
                ddl_Status.Items.Insert(0, new ListItem("", "0"));

                if (Context.Handler is ProcessoCompraItens)
                {
                    oPCompraItem = ((ProcessoCompraItens)Context.Handler).oProcessoCompraItem;
                    Key = ((ProcessoCompraItens)Context.Handler).Key;
                    ListaGridPersistida = ((ProcessoCompraItens)Context.Handler).Lista;
                    CDP = ((ProcessoCompraItens)Context.Handler).CDP;
                }

                oPCompraItem = ((List<ProcessoCompraItem>)ListaGridPersistida).Find(delegate(ProcessoCompraItem itm)
                {
                    return itm.CodItem == Key;
                });

                lbl_NumPedido.Text = oPCompraItem.CodPedido.ToString();
                lbl_Projeto.Text = oPCompraItem.NomeProjeto.ToString();
                lbl_NomeUsuario.Text = oPCompraItem.NomeUsuario.ToString();

                lbl_Item.Text = oPCompraItem.Outros.ToString().Trim() == "" ? oPCompraItem.NomeItem.ToString() : oPCompraItem.NomeItem.ToString() + "-" + oPCompraItem.Outros.ToString();
                lbl_Quantidade.Text = oPCompraItem.Quantidade.ToString();

                txt_QtdComprada.Text = oPCompraItem.QuantidadeComprada > 0 ? oPCompraItem.QuantidadeComprada.ToString() : "";
                txt_Valor.Text = oPCompraItem.ValorUnitario > 0 ? oPCompraItem.ValorUnitario.ToString() : "";

                dt_DataCompra.Text = oPCompraItem.DataCompra == DateTime.MinValue ? "" : oPCompraItem.DataCompra.ToShortDateString();
                dt_PrevisaoEntrega.Text = oPCompraItem.DataPrevisaoEntrega == DateTime.MinValue ? "" : oPCompraItem.DataPrevisaoEntrega.ToShortDateString();
                dt_Entrega.Text = oPCompraItem.DataEntrega == DateTime.MinValue ? "" : oPCompraItem.DataEntrega.ToShortDateString();

                ddl_Fornecedor.SelectedValue = oPCompraItem.Fornecedor.FornecedorID > 0 ? oPCompraItem.Fornecedor.FornecedorID.ToString() : "0";
                ddl_TpDocumento.SelectedValue = oPCompraItem.TpDocumentoFiscal > 0 ? oPCompraItem.TpDocumentoFiscal.ToString() : "0";

                ddl_Status.SelectedValue = oPCompraItem.Status.ToString();

                txt_NotaFiscal.Text = oPCompraItem.NotaFiscal > 0 ? oPCompraItem.NotaFiscal.ToString() : "";
                txt_NFSerie.Text = oPCompraItem.NotaSerie.ToString();
                dt_EmissaoNF.Text = oPCompraItem.DataEmissaoNota == DateTime.MinValue ? "" : oPCompraItem.DataEmissaoNota.ToShortDateString();

                //if (oPCompraItem.Status == 3)
                //{
                //    txt_QtdComprada.Enabled = false;
                //    txt_QtdComprada.Enabled = false;
                //    txt_Valor.Enabled = false;
                //    ddl_Fornecedor.Enabled = false;
                //}
            }
        }
        private void salvar()
        {
            HarunaNet.Entities.Fornecedor oFornecedor = new HarunaNet.Entities.Fornecedor();
            ProcessoCompraItem oProcessoCompraItemCopia = new ProcessoCompraItem();

            oProcessoCompraItemCopia = oPCompraItem;
            oFornecedor.FornecedorID = Convert.ToInt32(ddl_Fornecedor.SelectedValue);
            oPCompraItem.Fornecedor = oFornecedor;
            oPCompraItem.NextStatus = Convert.ToInt32(ddl_Status.SelectedValue);

            oPCompraItem.QuantidadeComprada = txt_QtdComprada.Text.ToString() == "" ? 0 : Convert.ToInt32(txt_QtdComprada.Text);
            oPCompraItem.ValorUnitario = txt_Valor.Text.ToString() == "" ? 0 : Convert.ToDecimal(txt_Valor.Text);
            oPCompraItem.DataCompra = dt_DataCompra.Text.Trim() != "" ? Convert.ToDateTime(dt_DataCompra.Text) : DateTime.MinValue;
            oPCompraItem.DataPrevisaoEntrega = dt_PrevisaoEntrega.Text.Trim() != "" ? Convert.ToDateTime(dt_PrevisaoEntrega.Text) : DateTime.MinValue;
            oPCompraItem.DataEntrega = dt_Entrega.Text.Trim() != "" ? Convert.ToDateTime(dt_Entrega.Text) : DateTime.MinValue;

            oPCompraItem.DescMotivoCancelamento = txt_DescMotivoCancelamento.Text.Trim();

            if (txt_NotaFiscal.Text.ToString().Trim() != "")
            {
                oPCompraItem.TpDocumentoFiscal = Convert.ToInt32(ddl_TpDocumento.SelectedValue);
                oPCompraItem.NotaFiscal = Convert.ToInt32(txt_NotaFiscal.Text);
                oPCompraItem.DataEmissaoNota = dt_EmissaoNF.Text.Trim() != "" ? Convert.ToDateTime(dt_EmissaoNF.Text) : DateTime.MinValue;
                oPCompraItem.NotaSerie = txt_NFSerie.Text.ToString();
            }
            Resultado resultado = new Resultado();
            resultado = new Ped_ItemFacade().AtualizaItemCompra(oPCompraItem);

            if (resultado.Sucesso)
            {
                LiparCampos();

                string msg = "Item autalizado com sucesso!";

                string script = Consts.JavaScript.Alert(Consts.Funcoes.Replacer4js(msg), false);
                ScriptManager.RegisterStartupScript(this, this.GetType(), "alerta", script, true);

                Response.Redirect("~/ProcessoCompraItens.aspx?cdp=" + oPCompraItem.CodProcesso);
            }
            else
            {
                lblErroDTEntrega.Visible = false;
                lblErroPrevisaoEntrega.Visible = false;
                lblErroFornecedor.Visible = false;

                for (int msg = 0; msg < resultado.Mensagens.Count; msg++)
                {
                    switch (resultado.Mensagens[msg].Campo)
                    {
                        case "DataCompra":
                            lblErroDataCompra.Text = resultado.Mensagens[msg].Descricoes[0];
                            lblErroDataCompra.Visible = true;
                            break;
                        case "Valor":
                            lblErroValor.Text = resultado.Mensagens[msg].Descricoes[0];
                            lblErroValor.Visible = true;
                            break;
                        case "Fornecedor":
                            lblErroFornecedor.Text = resultado.Mensagens[msg].Descricoes[0];
                            lblErroFornecedor.Visible = true;
                            break;
                        case "QuantidadeComprada":
                            lblErroQtdComprada.Text = resultado.Mensagens[msg].Descricoes[0];
                            lblErroQtdComprada.Visible = true;
                            break;
                        case "PrevisaoEntrega":
                            lblErroPrevisaoEntrega.Text = resultado.Mensagens[msg].Descricoes[0];
                            lblErroPrevisaoEntrega.Visible = true;
                            break;
                        case "DataEntrega":
                            lblErroDTEntrega.Text = resultado.Mensagens[msg].Descricoes[0];
                            lblErroDTEntrega.Visible = true;
                            //ScriptManager.RegisterStartupScript(this, this.GetType(), "ResultadoConfirmação", "alert('Erro ao confirmar a operação! Nenhuma alteração efetuada');", true);
                            break;
                        case "DescMotivoCancelamento":

                            lblErroDTEntrega.Visible = true;
                            ScriptManager.RegisterStartupScript(this, this.GetType(), "ResultadoConfirmação", "alert(' " + resultado.Mensagens[msg].Descricoes[0].ToString() + "');", true);
                            break;
                    }
                }

            }
        }
 public ProcessoCompraItemValidation(ProcessoCompraItem pProcessoCompraItem)
 {
     this.m_ProcessoCompraItem = pProcessoCompraItem;
     this.m_resultado.Sucesso = true;
 }