C# DataFieldCollection.Clear方法代码示例

        private void IncludeDiariaQuantidade()
        {
            try
            {
                DataFieldCollection lFields = new DataFieldCollection();
                OperationResult lReturn = new OperationResult();

                DataTable lTable = (DataTable)Session["ModalidadeQuantidadealteracao"];

                for (int i = 0; i < lTable.Rows.Count; i++)
                {
                    lFields.Add(DIARIAQUANTIDADEQD._DIAQT_ID, hdfDiaqtIdAlteracao.Value);
                    lFields.Add(DIARIAQUANTIDADEQD._DIA_ID, hdfDiaIdAlteracao.Value);
                    lFields.Add(DIARIAQUANTIDADEQD._DIAQT_ADICIONAL, lTable.Rows[i][DIARIAQUANTIDADEQD._DIAQT_ADICIONAL.Name].ToString());
                    lFields.Add(DIARIAQUANTIDADEQD._DIAQT_DATADEINICIO, lTable.Rows[i][DIARIAQUANTIDADEQD._DIAQT_DATADEINICIO.Name].ToString());
                    lFields.Add(DIARIAQUANTIDADEQD._DIAQT_DATADETERMINO, lTable.Rows[i][DIARIAQUANTIDADEQD._DIAQT_DATADETERMINO.Name].ToString());
                    lFields.Add(DIARIAQUANTIDADEQD._DIAQT_DIARIATOTAL, lTable.Rows[i][DIARIAQUANTIDADEQD._DIAQT_DIARIATOTAL.Name].ToString());
                    lFields.Add(DIARIAQUANTIDADEQD._DIAQT_LOCALDEDESTINO, lTable.Rows[i][DIARIAQUANTIDADEQD._DIAQT_LOCALDEDESTINO.Name].ToString());
                    lFields.Add(DIARIAQUANTIDADEQD._DIAQT_LOCALDEPARTIDA, lTable.Rows[i][DIARIAQUANTIDADEQD._DIAQT_LOCALDEPARTIDA.Name].ToString());
                    lFields.Add(DIARIAQUANTIDADEQD._DIAQT_SUBTOTAL, lTable.Rows[i][DIARIAQUANTIDADEQD._DIAQT_SUBTOTAL.Name].ToString());
                    lFields.Add(DIARIAQUANTIDADEQD._DIAQT_VALORTOTAL, lTable.Rows[i][DIARIAQUANTIDADEQD._DIAQT_VALORTOTAL.Name].ToString());
                    lFields.Add(DIARIAQUANTIDADEQD._DIAQT_VALORUNITARIO, lTable.Rows[i][DIARIAQUANTIDADEQD._DIAQT_VALORUNITARIO.Name].ToString());
                    lFields.Add(DIARIAQUANTIDADEQD._TVD_ID, lTable.Rows[i][DIARIAQUANTIDADEQD._TVD_ID.Name].ToString());
                    lFields.Add(DIARIAQUANTIDADEQD._DIAQT_REGDATE, DateTime.Now);
                    lFields.Add(DIARIAQUANTIDADEQD._DIAQT_REGUSER, Session["_SessionUser"].ToString());
                    lFields.Add(DIARIAQUANTIDADEQD._DIAQT_STATUS, "A");

                    lReturn = DIARIAQUANTIDADETo.Update(lFields, LocalInstance.ConnectionInfo);

                    if (!lReturn.IsValid)
                    {
                        Exception err = new Exception(lReturn.OperationException.Message.ToString());
                        throw err;
                    }
                    lFields.Clear();
                    lReturn = null;
                }
                lTable = null;
            }
            catch (WebManagerException e)
            {
                e.TratarExcecao(true);
            }
            catch (Exception err)
            {
                (new UnknownException(err)).TratarExcecao(true);
            }
        }

        private void SuprimentoPortariaInclude()
        {
            decimal lPORT = 0;
            try
            {
                DataFieldCollection lFields = new DataFieldCollection();
                OperationResult lReturn = new OperationResult();

                lPORT = PortariaInclude();

                if (lPORT > 0)
                {

                    lFields.Add(SUPRIMENTOFUNDOQD._SUPFUN_ID, hidKey_id.Value);
                    lFields.Add(PORTARIAQD._PORT_ID, lPORT);
                    lFields.Add(SUPRIMENTOFUNDOQD._SUPFUN_REGDATE, DateTime.Now);
                    lFields.Add(SUPRIMENTOFUNDOQD._SUPFUN_REGUSER, "USER");
                    lFields.Add(SUPRIMENTOFUNDOQD._SUPFUN_STATUS, "A");

                    lReturn = SUPRIMENTOFUNDOTo.Update(lFields, LocalInstance.ConnectionInfo);

                    if (!lReturn.IsValid)
                    {
                        Exception err = new Exception(lReturn.OperationException.Message.ToString());
                        throw err;
                    }
                    lFields.Clear();
                }

                clearPortaria();

                Session["PropostoDefensor"] = null;
                Session["PropostoServidor"] = null;
                string path = (string)Session["_URLAnterior"];
                Session["_URLAnterior"] = null;
                if (path.Length > 0) Response.Redirect(path);

            }
            catch (WebManagerException e)
            {
                e.TratarExcecao(false);
            }
            catch (Exception err)
            {
                (new UnknownException(err)).TratarExcecao(false);
            }
        }

        private void InterfaceInclude()
        {
            decimal lsupfun_id = 0, lPestacao = 0;

            try
            {
                DataFieldCollection lFields = new DataFieldCollection();
                OperationResult lReturn = new OperationResult();

                #region INSERT DOCUMENTO
                decimal lDOC_ID = DocumentoInclude();
                #endregion

                #region INSERT PRESTACAO
                lPestacao = PrestacaoInclude(lDOC_ID);
                #endregion

                if (lPestacao > 0) //1 if
                {
                    #region INSERT SUPRIMENTOFUNDO

                    if (dvSolicitante.Visible)
                        lFields.Add(SUPRIMENTOFUNDOQD._PESF_PROPONENTE, decimal.Parse(lblID.Text));
                    else
                        lFields.Add(SUPRIMENTOFUNDOQD._PESF_PROPONENTE, decimal.Parse(hidPESF_ID.Value));

                    lFields.Add(SUPRIMENTOFUNDOQD._PESF_PROPOSTO, decimal.Parse(hidPESF_ID2.Value));
                    lFields.Add(SUPRIMENTOFUNDOQD._DOC_ID, lDOC_ID);
                    lFields.Add(SUPRIMENTOFUNDOQD._PRES_ID, lPestacao);
                    lFields.Add(SUPRIMENTOFUNDOQD._SUPFUN_PRAZODIAS1, txtPRES_ID.Text);
                    //lFields.Add(SUPRIMENTOFUNDOQD._PESF_ID, );
                    lFields.Add(SUPRIMENTOFUNDOQD._SUPFUN_MATERIALCONSUMO, txtVALORES1_ID.Text);
                    lFields.Add(SUPRIMENTOFUNDOQD._SUPFUN_PASSAGEMLOCOMOCAO, txtVALORES2_ID.Text);
                    lFields.Add(SUPRIMENTOFUNDOQD._SUPFUN_SERVPESSOAFISICA, txtVALORES3_ID.Text);
                    lFields.Add(SUPRIMENTOFUNDOQD._SUPFUN_SERVPESSOAJURIDICA, txtVALORES4_ID.Text);

                    if (hidPendencia.Value.Length > 0)
                        lFields.Add(SUPRIMENTOFUNDOQD._SUPFUN_PENDENCIAPROPOSTO, hidPendencia.Value);

                    lFields.Add(SUPRIMENTOFUNDOQD._SUPFUN_JUSTIFICATIVA, txtSUPFUN_JUSTIFICATIVA.Text);
                    lFields.Add(SUPRIMENTOFUNDOQD._SUPFUN_PRAZOINICIO, txtSUPFUN_PRAZOINICIO.Text);
                    lFields.Add(SUPRIMENTOFUNDOQD._SUPFUN_PRAZOFIM, txtSUPFUN_PRAZOFIM.Text);
                    lFields.Add(SUPRIMENTOFUNDOQD._SUPFUN_DATASOLICITACAO, DateTime.Now); //25/09/2012 Ricardo Almeida
                    lFields.Add(SUPRIMENTOFUNDOQD._SUPFUN_REGDATE, DateTime.Now);
                    lFields.Add(SUPRIMENTOFUNDOQD._SUPFUN_REGUSER, "USER");
                    lFields.Add(SUPRIMENTOFUNDOQD._SUPFUN_STATUS, "A");

                    lReturn = SUPRIMENTOFUNDOTo.Insert(lFields, LocalInstance.ConnectionInfo);
                    #endregion

                    if (!lReturn.IsValid)
                    {
                        Exception err = new Exception(lReturn.OperationException.Message.ToString());
                        throw err;
                    }
                    else
                    {
                        lsupfun_id = lReturn.SequenceControl;

                        lFields.Clear();
                        lReturn = null;

                        #region modalidades escolhidas
                        foreach (ListItem li in chkMODALIDADE.Items)
                        {
                            if (li.Selected)
                            {
                                lFields.Add(MODALIDADEXSUPRIMENTOFUNDOQD._MODA_ID, li.Value);
                                lFields.Add(MODALIDADEXSUPRIMENTOFUNDOQD._SUPFUN_ID, lsupfun_id);
                                lFields.Add(MODALIDADEXSUPRIMENTOFUNDOQD._MODAFUNDO_REGDATE, DateTime.Now);
                                lFields.Add(MODALIDADEXSUPRIMENTOFUNDOQD._MODAFUNDO_REGUSER, "USER");
                                lFields.Add(MODALIDADEXSUPRIMENTOFUNDOQD._MODAFUNDO_STATUS, "A");

                                lReturn = MODALIDADEXSUPRIMENTOFUNDODo.Insert(lFields, LocalInstance.ConnectionInfo);

                                if (!lReturn.IsValid)
                                {
                                    Exception err = new Exception(lReturn.OperationException.Message.ToString());
                                    throw err;
                                }
                            }
                            lFields.Clear();
                        }
                        #endregion

                        #region destinações escolhidas
                        foreach (ListItem li in chkDESTINACAO.Items)
                        {
                            if (li.Selected)
                            {
                                lFields.Add(DESTINACAOXSUPRIMENTOFUNDOQD._DEST_ID, li.Value);
                                lFields.Add(DESTINACAOXSUPRIMENTOFUNDOQD._SUPFUN_ID, lsupfun_id);
                                lFields.Add(DESTINACAOXSUPRIMENTOFUNDOQD._DESTFUNDO_REGDATE, DateTime.Now);
                                lFields.Add(DESTINACAOXSUPRIMENTOFUNDOQD._DESTFUNDO_REGUSER, "USER");
                                lFields.Add(DESTINACAOXSUPRIMENTOFUNDOQD._DESTFUNDO_STATUS, "A");

                                lReturn = DESTINACAOXSUPRIMENTOFUNDODo.Insert(lFields, LocalInstance.ConnectionInfo);

                                if (!lReturn.IsValid)
                                {
//.........这里部分代码省略.........

        //salva a diaria
        private void InterfaceInclude()
        {
            decimal ldia_id = 0, lPestacao = 0;

            try
            {
                DataFieldCollection lFields = new DataFieldCollection();
                OperationResult lReturn = new OperationResult();

                #region INSERT DOCUMENTO
                decimal lDOC_ID = DocumentoInclude();
                #endregion

                #region INSERT PRESTACAO
                lPestacao = PrestacaoInclude(lDOC_ID);
                #endregion

                if (lPestacao > 0)
                { //1 if
                    //INSERT DEFDOCUMENTOMOVIMENTO - CATEGORIA = SUPRIMENTOFUNDO

                    #region INSERT DIARIA

                    lFields.Add(DIARIAQD._TPDIA_ID, decimal.Parse(ddlTPDIA_ID.SelectedValue));
                    lFields.Add(DIARIAQD._DOC_ID, lDOC_ID);
                    lFields.Add(DIARIAQD._PRES_ID, lPestacao);

                    if (lblID.Text.Length > 0)
                        lFields.Add(DIARIAQD._PESF_PROPONENTE, decimal.Parse(lblID.Text));
                    else
                        lFields.Add(DIARIAQD._PESF_PROPONENTE, decimal.Parse(hidPESF_ID.Value));

                    lFields.Add(DIARIAQD._DIA_SESIM, ddlSIMNAO.SelectedValue.Equals("0") ? "S" : "N");
                    //lFields.Add(DIARIAQD._DIA_OBJETIVO, txtDIA_OBJETIVO.Text);
                    //lFields.Add(DIARIAQD._DIA_JUSTIFICATIVA, txtDIA_JUSTIFICATIVA.Text);
                    //25/09/2012 Ricardo Almeida
                    //Inclusão do campo data de solicitaçãos
                    lFields.Add(DIARIAQD._DIA_DATASOLICITACAO, DateTime.Now);
                    lFields.Add(DIARIAQD._DIA_REGDATE, DateTime.Now);
                    lFields.Add(DIARIAQD._DIA_REGUSER, Session["_SessionUser"].ToString());
                    lFields.Add(DIARIAQD._DIA_STATUS, "A");

                    lReturn = DIARIATo.Insert(lFields, LocalInstance.ConnectionInfo);
                    #endregion

                    if (!lReturn.IsValid)
                    {
                        Exception err = new Exception(lReturn.OperationException.Message.ToString());
                        throw err;
                    }
                    else
                    {
                        ldia_id = lReturn.SequenceControl;
                        InsertProposto(ldia_id);

                        lFields.Clear();
                        lReturn = null;

                        // insere o tipo de diaria
                        if (ddlSIMNAO.SelectedValue.Equals("0"))
                        {
                            #region trequisito passagem
                            foreach (ListItem li in chkDIA_SESIM.Items)
                            {
                                if (li.Selected)
                                {
                                    lFields.Add(DIARIAXTIPODESLOCAMENTOQD._DESLOC_ID, li.Value);
                                    lFields.Add(DIARIAXTIPODESLOCAMENTOQD._DIA_ID, ldia_id);
                                    lFields.Add(DIARIAXTIPODESLOCAMENTOQD._DIATIPO_REGDATE, DateTime.Now);
                                    lFields.Add(DIARIAXTIPODESLOCAMENTOQD._DIATIPO_REGUSER, Session["_SessionUser"].ToString());
                                    lFields.Add(DIARIAXTIPODESLOCAMENTOQD._DIATIPO_STATUS, "A");

                                    lReturn = DIARIAXTIPODESLOCAMENTODo.Insert(lFields, LocalInstance.ConnectionInfo);

                                    if (!lReturn.IsValid)
                                    {
                                        Exception err = new Exception(lReturn.OperationException.Message.ToString());
                                        throw err;
                                    }
                                }
                                lFields.Clear();

                            }
                            #endregion
                        }
                        else
                        {
                            #region trequisito passagme
                            foreach (ListItem li in chkDIA_SENAO.Items)
                            {
                                if (li.Selected)
                                {
                                    lFields.Add(DIARIAXTIPODESLOCAMENTOQD._DESLOC_ID, li.Value);
                                    lFields.Add(DIARIAXTIPODESLOCAMENTOQD._DIA_ID, ldia_id);
                                    lFields.Add(DIARIAXTIPODESLOCAMENTOQD._DIATIPO_REGDATE, DateTime.Now);
                                    lFields.Add(DIARIAXTIPODESLOCAMENTOQD._DIATIPO_REGUSER, Session["_SessionUser"].ToString());
                                    lFields.Add(DIARIAXTIPODESLOCAMENTOQD._DIATIPO_STATUS, "A");

                                    lReturn = DIARIAXTIPODESLOCAMENTODo.Insert(lFields, LocalInstance.ConnectionInfo);
//.........这里部分代码省略.........

        private void DiariaPortariaInclude()
        {
            DataTable lTableDiaria = (DataTable)Session["lTableDiaria"];
            decimal lPORT = 0;
            try
            {
                DataFieldCollection lFields = new DataFieldCollection();
                OperationResult lReturn = new OperationResult();

                lPORT = PortariaInclude();

                if (lPORT > 0)
                {
                    for (int i = 0; i < lTableDiaria.Rows.Count; i++)
                    {
                        lFields.Add(DIARIAXPORTARIAQD._DIA_ID, lTableDiaria.Rows[i][DIARIAQD._DIA_ID.Name].ToString());
                        lFields.Add(DIARIAXPORTARIAQD._PORT_ID, lPORT);
                        lFields.Add(DIARIAXPORTARIAQD._DIAPORT_REGDATE, DateTime.Now);
                        lFields.Add(DIARIAXPORTARIAQD._DIAPORT_REGUSER, "USER");
                        lFields.Add(DIARIAXPORTARIAQD._DIAPORT_STATUS, "A");

                        lReturn = DIARIAXPORTARIATo.Insert(lFields, LocalInstance.ConnectionInfo);

                        if (!lReturn.IsValid)
                        {
                            Exception err = new Exception(lReturn.OperationException.Message.ToString());
                            throw err;
                        }
                        lFields.Clear();
                    }
                }

                decimal lDiariaPortaria = lReturn.SequenceControl;

                if (lDiariaPortaria > 0)
                {
                    clearPortaria();

                    //if (Session["ValorServidor"] != null) Session["ValorServidor"] = null;
                    //else if (Session["ValorDefensor"] != null) Session["valorDefensor"] = null;

                    //if (Session["ValorServidor"] == null && Session["ValorDefensor"] != null)
                    //{
                    //    MessageBox1.wuc_ShowMessage("Há mais uma portaria.", 1);
                    //    GeraTextoPortaria();
                    //}
                    //else if (Session["ValorServidor"] == null && Session["ValorDefensor"] == null)
                    //{
                    Session["PropostoDefensor"] = null;
                    Session["PropostoServidor"] = null;
                    string path = (string)Session["_URLAnterior"];
                    Session["_URLAnterior"] = null;
                    if (path.Length > 0) Response.Redirect(path);
                    //}
                }
            }
            catch (WebManagerException e)
            {
                e.TratarExcecao(true);
            }
            catch (Exception err)
            {
                (new UnknownException(err)).TratarExcecao(true);
            }
            lTableDiaria = null;
        }

        protected void InterfaceIncludeCompraMaterial()
        {
            int lOrd = 1;
            DataTable lTableMateriais = CreateTableRelatorio();

            try
            {
                DataTable lMaterial = (DataTable)ViewState["ITEM"];

                DataFieldCollection lFields = new DataFieldCollection();
                OperationResult lReturn = new OperationResult();

                for (int i = 0; i < lMaterial.Rows.Count; i++)
                {
                    lFields.Add(COMPRAMATERIALQD._COMPMAT_QTD, lMaterial.Rows[i]["QTDCOMPRADA"].ToString());
                    lFields.Add(COMPRAMATERIALQD._COMPMAT_VALOR, lMaterial.Rows[i]["VALORUNI"].ToString());
                    lFields.Add(COMPRAMATERIALQD._MATERIALDETALHAMENTO_ID, lMaterial.Rows[i][MATERIALDETALHAMENTOQD._MATERIALDETALHAMENTO_ID.Name].ToString());
                    lFields.Add(COMPRAMATERIALQD._PESF_ID, hidPESF_ID.Value);
                    lFields.Add(COMPRAMATERIALQD._COMPMAT_REGDATE, DateTime.Now);
                    lFields.Add(COMPRAMATERIALQD._COMPMAT_REGUSER, "USER");
                    lFields.Add(COMPRAMATERIALQD._COMPMAT_STATUS, "A");

                    lReturn = COMPRAMATERIALTo.Insert(lFields, LocalInstance.ConnectionInfo);

                    if (!lReturn.IsValid)
                    {
                        Exception err = new Exception(lReturn.OperationException.Message.ToString());
                        throw err;
                    }

                    else
                    {
                        DataRow linha = lTableMateriais.NewRow();
                        linha["ORD"] = lOrd;
                        linha["MATERIAL"] = lMaterial.Rows[i][MATERIALDETALHAMENTOQD._MATERIALDETALHAMENTO_DESCRICAO.Name].ToString();
                        linha["PEDITEM_QTD"] = long.Parse(lMaterial.Rows[i]["QTDCOMPRADA"].ToString()).ToString();

                        lTableMateriais.Rows.Add(linha);
                        lOrd++;
                        InterfaceIncludeEstoque(lReturn.SequenceControl, decimal.Parse(lMaterial.Rows[i]["QTDCOMPRADA"].ToString()),
                                                decimal.Parse(lMaterial.Rows[i][MATERIALQD._MATERIAL_ID.Name].ToString()));
                    }

                    lFields.Clear();
                }

                lMaterial = (DataTable)ViewState["ITEM2"];
                lFields.Clear();
                for (int i = 0; i < lMaterial.Rows.Count; i++)
                {
                    lFields.Add(COMPRAMATERIALQD._COMPMAT_QTD, lMaterial.Rows[i]["QTDCOMPRADA"].ToString());
                    lFields.Add(COMPRAMATERIALQD._COMPMAT_VALOR, lMaterial.Rows[i]["VALORUNI"].ToString());
                    lFields.Add(COMPRAMATERIALQD._MATFORN_ID, lMaterial.Rows[i][MATDETXFORNECEDORQD._MATFORN_ID.Name].ToString());
                    lFields.Add(COMPRAMATERIALQD._PESF_ID, hidPESF_ID.Value);
                    lFields.Add(COMPRAMATERIALQD._COMPMAT_REGDATE, DateTime.Now);
                    lFields.Add(COMPRAMATERIALQD._COMPMAT_REGUSER, "USER");
                    lFields.Add(COMPRAMATERIALQD._COMPMAT_STATUS, "A");

                    lReturn = COMPRAMATERIALTo.Insert(lFields, LocalInstance.ConnectionInfo);

                    if (!lReturn.IsValid)
                    {
                        Exception err = new Exception(lReturn.OperationException.Message.ToString());
                        throw err;
                    }
                    else
                    {
                        DataRow linha = lTableMateriais.NewRow();
                        linha["ORD"] = lOrd;
                        linha["MATERIAL"] = lMaterial.Rows[i][MATDETXFORNECEDORQD._MATFORN_DESC.Name].ToString();
                        linha["PEDITEM_QTD"] = long.Parse(lMaterial.Rows[i]["QTDCOMPRADA"].ToString()).ToString();

                        lTableMateriais.Rows.Add(linha);
                        lOrd++;

                        InterfaceIncludeEstoque(lReturn.SequenceControl, decimal.Parse(lMaterial.Rows[i]["QTDCOMPRADA"].ToString()),
                                                decimal.Parse(lMaterial.Rows[i][MATERIALQD._MATERIAL_ID.Name].ToString()));
                    }

                    lFields.Clear();
                }
            }
            catch (WebManagerException er)
            {
                er.TratarExcecao(true);
            }
            catch (Exception err)
            {
                (new UnknownException(err)).TratarExcecao(true);
            }

            Session["WRK_PARAMETER_REGUSER"] = txtPES_ID.Text;
            Session["WRK_TABLE"] = lTableMateriais;
        }

        private void InterfaceIncludeNotaFiscal(decimal notaid)
        {
            try
            {
                DataTable lTable = (DataTable)ViewState["WRK_TABLE"];

                DataFieldCollection lFields = new DataFieldCollection();
                OperationResult lReturn = new OperationResult();

                CreateTableReceitaDespesa();
                DataTable lTableReceitaDespesa = (DataTable)ViewState["WRK_TABLE_RD"];

                for (int i = 0; i < lTable.Rows.Count; i++)
                {
                    lFields.Add(NotaFiscalQD._NOTFIS_NUMERO, lTable.Rows[i][NotaFiscalQD._NOTFIS_NUMERO.Name].ToString());
                    lFields.Add(NotaFiscalQD._NOTFIS_VALOR, lTable.Rows[i][NotaFiscalQD._NOTFIS_VALOR.Name].ToString());
                    lFields.Add(NotaFiscalQD._NOTFIS_TIPO, lTable.Rows[i][NotaFiscalQD._NOTFIS_TIPO.Name].DBToDecimal());

                    decimal fig_id = InterfaceIncludeFigura((byte[])lTable.Rows[i]["FIGURA"]);

                    if (fig_id == 0)
                    {
                        lFields.Clear();
                        continue;
                    }
                    lFields.Add(NotaFiscalQD._FIG_ID, fig_id);
                    lFields.Add(NotaFiscalQD._PRESNOT_ID, notaid);
                    lFields.Add(NotaFiscalQD._NOTFIS_REGDATE, DateTime.Now);
                    lFields.Add(NotaFiscalQD._NOTFIS_REGUSER, "USER");
                    lFields.Add(NotaFiscalQD._NOTFIS_STATUS, "A");

                    lReturn = NotaFiscalTo.Insert(lFields, LocalInstance.ConnectionInfo);

                    if (!lReturn.IsValid)
                    {
                        Exception err = new Exception(lReturn.OperationException.Message.ToString());
                        throw err;
                    }

                    lFields.Clear();

                    #region Tabela Relatorio
                    DataRow lRow = lTableReceitaDespesa.NewRow();

                    int lord = i + 2;
                    lRow["ORD"] = lord.ToString();
                    lRow[NotaFiscalQD._NOTFIS_DESCRICAO.Name] = lTable.Rows[i][NotaFiscalQD._NOTFIS_DESCRICAO.Name].ToString();
                    lRow[NotaFiscalQD._NOTFIS_NUMERO.Name] = lTable.Rows[i][NotaFiscalQD._NOTFIS_NUMERO.Name].ToString();

                    //if (lTable.Rows[i][NotaFiscalQD._NOTFIS_TIPO.Name].DBToDecimal() == (decimal)TipoNotaFiscal.NotaFiscal)
                    //    lRow["DEBITO"] = lTable.Rows[i][NotaFiscalQD._NOTFIS_VALOR.Name].DBToDecimal();
                    //else
                    lRow["CREDITO"] = lTable.Rows[i][NotaFiscalQD._NOTFIS_VALOR.Name].DBToDecimal();

                    lTableReceitaDespesa.Rows.Add(lRow);

                    #endregion
                }

                Session["WRK_PARAMETER_REGUSER"] = hidPES_NOME.Value;
                Session["WRK_PARAMETER_PORTARIA"] = hidPORT_NUMERO.Value;
                Session["WRK_TABLE"] = lTableReceitaDespesa;
            }
            catch (WebManagerException e)
            {
                e.TratarExcecao(true);
            }
            catch (Exception err)
            {
                (new UnknownException(err)).TratarExcecao(true);
            }
        }

    private void HomologarPeca()
    {
        DataFieldCollection lFields = new DataFieldCollection();
        OperationResult lReturn = new OperationResult();

        try
        {
            lFields.Clear();
            lFields.Add(PECASXNAAPQD._PECN_ID,      hfPeca.Value);
            lFields.Add(PECASXNAAPQD._TPMN_ID,      ddlTipoMateria.SelectedValue);
            lFields.Add(PECASXNAAPQD._TPEN_ID,      ddlTipoPeca.SelectedValue);
            lFields.Add(PECASXNAAPQD._PECN_TAGS,    limparNome(txtTags.Text.ToUpper()));
            lFields.Add(PECASXNAAPQD._PECN_EMENTA,  limparNome(txtEmenta.Text.ToUpper()));
            lFields.Add(PECASXNAAPQD._PECN_TEXTO,   ftbPeticao.Text);
            lFields.Add(PECASXNAAPQD._PECN_REGDATE, DateTime.Now);
            lFields.Add(PECASXNAAPQD._PECN_STATUS,  "A");
            lFields.Add(PECASXNAAPQD._PECN_USUARIO, hfUsuario.Value);

            lReturn = PECASXNAAPDo.Update(lFields, LocalInstance.ConnectionInfo, "LOW");

            if (!lReturn.IsValid)
            {
                Exception err = new Exception(lReturn.OperationException.Message.ToString());
                MessageBox1.wuc_ShowMessage(err.ToString(), 3);
            }
            else
            {
                MessageBox1.wuc_ShowMessage("Peça Homologada com Sucesso", 1);
                LimpaCampos();
                panHomolog.Visible = false;
                panConsulta.Visible = true;
                CarregaDadosGrid("");
            }
        }
        catch (Exception err)
        {
            MessageBox1.wuc_ShowMessage(err.ToString(), 3);
        }
    }

        private void InterfaceInclude()
        {
            try
            {
                string lPESF_ID = Session["_SessionPESF_ID"].ToString();
                string lDIAPRO_ID = DIARIA_PROPOSTOTo.GetDIARIA_PROPOSTO(LocalInstance.ConnectionInfo, lPESF_ID,
                                                                         Session["_DIA_ID"].ToString());

                if (lDIAPRO_ID.Length > 0)
                {
                    DataFieldCollection lFields = new DataFieldCollection();
                    OperationResult lReturn = new OperationResult();

                    lFields.Add(RELATORIOVIAGEMQD._DIAPRO_ID,           lDIAPRO_ID);
                    lFields.Add(RELATORIOVIAGEMQD._DIAQT_ID,            Session["_DIAQT_ID"].ToString());
                    lFields.Add(RELATORIOVIAGEMQD._RELVIA_ATIVIDADES,   txtRELVIA_ATIVIDADES.Text);
                    lFields.Add(RELATORIOVIAGEMQD._RELVIA_REGDATE,      DateTime.Now);
                    lFields.Add(RELATORIOVIAGEMQD._RELVIA_REGUSER,      Session["_SessionUser"].ToString());
                    lFields.Add(RELATORIOVIAGEMQD._RELVIA_STATUS,       "A");

                    lReturn = RELATORIOVIAGEMTo.Insert(lFields, LocalInstance.ConnectionInfo);

                    if (!lReturn.IsValid)
                    {
                        Exception err = new Exception(lReturn.OperationException.Message.ToString());
                        throw err;
                    }
                    decimal lRELVIA_ID = lReturn.SequenceControl;
                    decimal lFIG_ID = 0;
                    byte[] documento = new byte[0];

                    DataTable lTable = (DataTable)ViewState["_anexoRelatorio"];
                    if (ViewState["_anexoRelatorio"] != null)
                    {
                        for (int i = 0; i < lTable.Rows.Count; i++)
                        {
                            documento = (byte[])lTable.Rows[i][FIGURASQD._FIG_IMAGEN.Name];

                            lFields.Clear();
                            lFields.Add(FIGURASQD._FIG_NOME,    lTable.Rows[i][FIGURASQD._FIG_NOME.Name].ToString());
                            lFields.Add(FIGURASQD._FIG_FORMATO, lTable.Rows[i][FIGURASQD._FIG_FORMATO.Name].ToString());
                            lFields.Add(FIGURASQD._FIG_IMAGEN,  documento);
                            lFields.Add(FIGURASQD._FIG_TAMANHO, documento);
                            lFields.Add(FIGURASQD._FIG_REGDATE, DateTime.Now);
                            lFields.Add(FIGURASQD._FIG_REGUSER, Session["_SessionUser"].ToString());
                            lFields.Add(FIGURASQD._FIG_STATUS, "A");

                            lReturn = FIGURASTo.Insert(lFields, LocalInstance.ConnectionInfo);

                            if (!lReturn.IsValid)
                            {
                                Exception err = new Exception(lReturn.OperationException.Message.ToString());
                                throw err;
                            }

                            lFIG_ID = lReturn.SequenceControl;

                            lFields.Clear();
                            lFields.Add(RelatorioViagemxFigurasQD._RELVIA_ID, lRELVIA_ID);
                            lFields.Add(RelatorioViagemxFigurasQD._FIG_ID, lFIG_ID);
                            lFields.Add(RelatorioViagemxFigurasQD._RELVIAFIG_REGDATE, DateTime.Now);
                            lFields.Add(RelatorioViagemxFigurasQD._RELVIAFIG_REGUSER, Session["_SessionUser"].ToString());
                            lFields.Add(RelatorioViagemxFigurasQD._RELVIAFIG_STATUS, "A");

                            lReturn = RelatorioViagemxFigurasTo.Insert(lFields, LocalInstance.ConnectionInfo);
                        }
                    }

                    if (!lReturn.IsValid)
                    {
                        Exception err = new Exception(lReturn.OperationException.Message.ToString());
                        throw err;
                    }
                    else
                    {
                        MessageBox1.wuc_ShowMessage("Registro salvo com sucesso.", "PRESTACAOCONTA.aspx", 1);
                        Session["_DIA_ID"] = null;
                    }
                }
            }
            catch (WebManagerException e)
            {
                e.TratarExcecao(true);
            }
            catch (Exception err)
            {
                (new UnknownException(err)).TratarExcecao(true);
            }
        }

        private void InterfaceIncludeMaterials(decimal lIDPedido)
        {
            int lOrd = 1;
            DataTable lTableMateriais = CreateTableRelatorio();

            try
            {
                DataTable lCarrinho = (DataTable)ViewState["GRID_CARRINHO"];
                DataFieldCollection lFields = new DataFieldCollection();
                OperationResult lReturn = new OperationResult();

                foreach (DataRow lLinha in lCarrinho.Rows)
                {
                    lFields.Add(PEDIDOMATERIALQD._PEDIDO_ID, lIDPedido);
                    lFields.Add(PEDIDOMATERIALQD._MATERIAL_ID, decimal.Parse(lLinha["MATERIAL_ID"].ToString()));
                    lFields.Add(PEDIDOMATERIALQD._PEDMAT_QUANTIDADE, decimal.Parse(lLinha["MATERIAL_QTD"].ToString()));
                    lFields.Add(PEDIDOMATERIALQD._PEDMAT_REGDATE, DateTime.Now);
                    lFields.Add(PEDIDOMATERIALQD._PEDMAT_REGUSER, "USER");
                    lFields.Add(PEDIDOMATERIALQD._PEDMAT_STATUS, "A");

                    lReturn = PEDIDOMATERIALTo.Insert(lFields, LocalInstance.ConnectionInfo);

                    if (!lReturn.IsValid)
                    {
                        Exception err = new Exception(lReturn.OperationException.Message.ToString());
                        throw err;
                    }
                    else
                    {
                        DataRow linhaRelatorio = lTableMateriais.NewRow();
                        linhaRelatorio["ORD"] = lOrd;
                        linhaRelatorio["MATERIAL"] = lLinha[MATERIALQD._MATERIAL_NOME.Name].ToString();
                        linhaRelatorio["PEDITEM_QTD"] = lLinha["MATERIAL_QTD"].ToString();
                        linhaRelatorio["CODIGO"] = lLinha[MATERIALQD._MATERIAL_CODIGO.Name].ToString();

                        lTableMateriais.Rows.Add(linhaRelatorio);
                        lOrd++;
                    }

                    lFields.Clear();
                }

                // MessageBox1.wuc_ShowMessage("Pedido realizado com sucesso.", 1);
            }
            catch (WebManagerException e)
            {
                e.TratarExcecao(true);
            }
            catch (Exception err)
            {
                (new UnknownException(err)).TratarExcecao(true);
            }

            if (txtNomeSolicitante.Text.Length > 0)
                Session["WRK_PARAMETER_REGUSER"] = txtNomeSolicitante.Text + "             " + txtSETOR_PROPONENTE.Text + "    " + txtFUNC_PROPONENTE.Text;
            else
                Session["WRK_PARAMETER_REGUSER"] = txtPES_ID.Text + "       " + txtSETOR_PROPONENTE.Text + "       " + txtFUNC_PROPONENTE.Text;

            Session["WRK_TABLE"] = lTableMateriais;
            Session["WRK_PARAMETER_OBS"] = txtOBS.Text;
        }

    private void ExcluirPeca()
    {
        DataFieldCollection lFields = new DataFieldCollection();
        OperationResult lReturn = new OperationResult();

        try
        {
            lFields.Clear();
            lFields.Add(PECASXNAAPQD._PECN_ID,      hfPeca.Value);
            lFields.Add(PECASXNAAPQD._PECN_REGDATE, DateTime.Now);
            lFields.Add(PECASXNAAPQD._PECN_STATUS,  "I");
            lFields.Add(PECASXNAAPQD._PECN_USUARIO, hfUsuario.Value);

            lReturn = PECASXNAAPDo.Update(lFields, LocalInstance.ConnectionInfo, "LOW");

            if (!lReturn.IsValid)
            {
                Exception err = new Exception(lReturn.OperationException.Message.ToString());
                MessageBox1.wuc_ShowMessage(err.ToString(), 3);
            }
            else
            {
                MessageBox1.wuc_ShowMessage("Peça Exlcuída com Sucesso", 1);
                LimpaCampos();
                panHomolog.Visible = false;
                panConsulta.Visible = true;
                CarregaDadosGrid("");
            }
        }
        catch (Exception err)
        {
            MessageBox1.wuc_ShowMessage(err.ToString(), 3);
        }
    }

        private void InterfaceIncludeMaterials(decimal pPEDCOMP_ID)
        {
            int lOrd = 1;
            DataTable lTableMateriais = CreateTableRelatorio();

            try
            {
                DataFieldCollection lFields = new DataFieldCollection();
                OperationResult lReturn = new OperationResult();

                DataTable lTable = (DataTable)ViewState["WRK_CARRINHO"];

                #region Tabela MaterialDetalhamento

                for (int i = 0; i < lTable.Rows.Count; i++)
                {
                    lFields.Add(PEDIDOCOMPRAITEMQD._PEDCOMP_ID, pPEDCOMP_ID);
                    lFields.Add(PEDIDOCOMPRAITEMQD._MATERIALDETALHAMENTO_ID,
                                lTable.Rows[i][MATERIALDETALHAMENTOQD._MATERIALDETALHAMENTO_ID.Name].ToString());
                    lFields.Add(PEDIDOCOMPRAITEMQD._PEDITEM_QTD, lTable.Rows[i]["QUANTIDADE"].ToString());
                    lFields.Add(PEDIDOCOMPRAITEMQD._PEDITEM_REGDATE, DateTime.Now);
                    lFields.Add(PEDIDOCOMPRAITEMQD._PEDITEM_REGUSER, "USER");
                    lFields.Add(PEDIDOCOMPRAITEMQD._PEDITEM_STATUS, "A");

                    lReturn = PEDIDOCOMPRAITEMTo.Insert(lFields, LocalInstance.ConnectionInfo);

                    if (!lReturn.IsValid)
                    {
                        Exception err = new Exception(lReturn.OperationException.Message.ToString());
                        throw err;
                    }
                    else
                    {
                        DataRow linha = lTableMateriais.NewRow();
                        linha["ORD"] = lOrd;
                        linha["MATERIAL"] =
                            lTable.Rows[i][MATERIALDETALHAMENTOQD._MATERIALDETALHAMENTO_DESCRICAO.Name].ToString();
                        linha["PEDITEM_QTD"] = lTable.Rows[i]["QUANTIDADE"].ToString();

                        lTableMateriais.Rows.Add(linha);
                        lOrd++;
                    }

                    lFields.Clear();
                }

                #endregion

                lFields.Clear();

                #region Tabela MaterialDetalhamento

                lTable = (DataTable)ViewState["WRK_CARRINHO2"];

                for (int i = 0; i < lTable.Rows.Count; i++)
                {
                    lFields.Add(PEDIDOCOMPRAITEMQD._PEDCOMP_ID, pPEDCOMP_ID);
                    lFields.Add(PEDIDOCOMPRAITEMQD._MATFORN_ID,
                                lTable.Rows[i][MATDETXFORNECEDORQD._MATFORN_ID.Name].ToString());
                    lFields.Add(PEDIDOCOMPRAITEMQD._PEDITEM_QTD, lTable.Rows[i]["QUANTIDADE"].ToString());
                    lFields.Add(PEDIDOCOMPRAITEMQD._PEDITEM_REGDATE, DateTime.Now);
                    lFields.Add(PEDIDOCOMPRAITEMQD._PEDITEM_REGUSER, "USER");
                    lFields.Add(PEDIDOCOMPRAITEMQD._PEDITEM_STATUS, "A");

                    lReturn = PEDIDOCOMPRAITEMTo.Insert(lFields, LocalInstance.ConnectionInfo);

                    if (!lReturn.IsValid)
                    {
                        Exception err = new Exception(lReturn.OperationException.Message.ToString());
                        throw err;
                    }
                    else
                    {
                        DataRow linha = lTableMateriais.NewRow();
                        linha["ORD"] = lOrd;
                        linha["MATERIAL"] = lTable.Rows[i][MATDETXFORNECEDORQD._MATFORN_DESC.Name].ToString();
                        linha["PEDITEM_QTD"] = lTable.Rows[i]["QUANTIDADE"].ToString();

                        lTableMateriais.Rows.Add(linha);
                        lOrd++;
                    }

                    lFields.Clear();
                }

                #endregion
            }
            catch (WebManagerException e)
            {
                e.TratarExcecao(true);
            }
            catch (Exception err)
            {
                (new UnknownException(err)).TratarExcecao(true);
            }
            Session["WRK_PARAMETER_REGUSER"] = txtPES_ID.Text;
            Session["WRK_TABLE"] = lTableMateriais;
        }

    private void CadastroPeca()
    {
        DataFieldCollection lFields = new DataFieldCollection();
        OperationResult lReturn = new OperationResult();

        try
        {
            lFields.Clear();
            lFields.Add(TIPOPECAXNAAPQD._TPEN_DESCRICAO,    limparNome(txtPeca.Text));
            lFields.Add(TIPOPECAXNAAPQD._TPEN_REGDATE,      DateTime.Now);
            lFields.Add(TIPOPECAXNAAPQD._TPEN_STATUS,       "A");
            lFields.Add(TIPOPECAXNAAPQD._TPEN_USUARIO,      hfUsuario.Value);

            lReturn = TIPOPECAXNAAPDo.Insert(lFields, LocalInstance.ConnectionInfo);

            if (!lReturn.IsValid)
            {
                Exception err = new Exception(lReturn.OperationException.Message.ToString());
                MessageBox1.wuc_ShowMessage(err.ToString(), 3);
            }
            else
            {
                MessageBox1.wuc_ShowMessage("Tipo de Peça Cadastrada com Sucesso", 1);
                LimpaCampos();
                panCadastro.Visible = false;
                panConsulta.Visible = true;
                CarregaDadosGrid();
            }
        }
        catch (Exception err)
        {
            MessageBox1.wuc_ShowMessage(err.ToString(), 3);
        }
    }

    private void ModificarMateria(string pCondicao)
    {
        DataFieldCollection lFields = new DataFieldCollection();
        OperationResult lReturn = new OperationResult();

        try
        {
            lFields.Clear();
            lFields.Add(TIPOMATERIAXNAAPQD._TPMN_ID,        hfPeca.Value);
            if(pCondicao == "A")
                lFields.Add(TIPOMATERIAXNAAPQD._TPMN_DESCRICAO, limparNome(txtMateria.Text));
            lFields.Add(TIPOMATERIAXNAAPQD._TPMN_REGDATE,   DateTime.Now);
            lFields.Add(TIPOMATERIAXNAAPQD._TPMN_STATUS,    pCondicao);
            lFields.Add(TIPOMATERIAXNAAPQD._TPMN_USUARIO,   hfUsuario.Value);

            lReturn = TIPOMATERIAXNAAPDo.Update(lFields, LocalInstance.ConnectionInfo);

            if (!lReturn.IsValid)
            {
                Exception err = new Exception(lReturn.OperationException.Message.ToString());
                MessageBox1.wuc_ShowMessage(err.ToString(), 3);
            }
            else
            {
                MessageBox1.wuc_ShowMessage("Operação efetuada com Sucesso", 1);
                LimpaCampos();
                panCadastro.Visible = false;
                panConsulta.Visible = true;
                CarregaDadosGrid();
            }
        }
        catch (Exception err)
        {
            MessageBox1.wuc_ShowMessage(err.ToString(), 3);
        }
    }

        private void InterfaceInclude()
        {
            try
            {
                string lPESF_ID = Session["_SessionPESF_ID"].ToString();

                    DataFieldCollection lFields = new DataFieldCollection();
                    OperationResult lReturn = new OperationResult();

                    decimal lCGDR_ID = 0;
                    byte[] documento = new byte[0];

                    DataTable lTable = (DataTable)ViewState["_anexoRelatorio"];
                    if (ViewState["_anexoRelatorio"] != null)
                    {
                        for (int i = 0; i < lTable.Rows.Count; i++)
                        {
                            documento = (byte[])lTable.Rows[i][CORREGEDORIAIMGQD._CGDR_IMG.Name];

                            lFields.Clear();
                            lFields.Add(CORREGEDORIAIMGQD._CGDR_TIPO, lTable.Rows[i][CORREGEDORIAIMGQD._CGDR_TIPO.Name].ToString());
                            lFields.Add(CORREGEDORIAIMGQD._CGDR_NOME, lTable.Rows[i][CORREGEDORIAIMGQD._CGDR_NOME.Name].ToString());
                            lFields.Add(CORREGEDORIAIMGQD._CGDR_SIT, 0); //0-Enviado
                            lFields.Add(CORREGEDORIAIMGQD._CGDR_IMG, documento);
                            lFields.Add(CORREGEDORIAIMGQD._PESF_ID, lPESF_ID);
                            //lFields.Add(CORREGEDORIAIMGQD._CGDR_DESCRICAO, lTable.Rows[i][CORREGEDORIAIMGQD._CGDR_DESCRICAO.Name].ToString());
                            //lFields.Add(CORREGEDORIAIMGQD._CGDR_MES, DdlMes.SelectedValue);
                            lFields.Add(CORREGEDORIAIMGQD._CGDR_REGDATE, DateTime.Now);

                            lReturn = CORREGEDORIAIMGTo.Insert(lFields, LocalInstance.ConnectionInfo);

                            if (!lReturn.IsValid)
                            {
                                Exception err = new Exception(lReturn.OperationException.Message.ToString());
                                throw err;
                            }

                            lCGDR_ID = lReturn.SequenceControl;
                        }
                    }

                    if (!lReturn.IsValid)
                    {
                        Exception err = new Exception(lReturn.OperationException.Message.ToString());
                        throw err;
                    }
                    else
                    {
                        MessageBox1.wuc_ShowMessage("Registro salvo com sucesso.", 1);
                        Clear();
                    }
            }
            catch (WebManagerException e)
            {
                e.TratarExcecao(true);
            }
            catch (Exception err)
            {
                (new UnknownException(err)).TratarExcecao(true);
            }
        }