using System;
using System.Collections.Generic;
using System.ComponentModel;
using System.Data;
using System.Drawing;
using System.Linq;
using System.Text;
using System.Windows.Forms;
using LLNet.GUI;
using LLNet.Utils;
using System.Threading;
using GenesisCnx = LLNet.Tienda.wsGenesis;
using System.Xml;
using CrystalDecisions.Shared;
using CrystalDecisions.CrystalReports.Engine;

namespace LLNet.Tienda.MainForms.Forms.OtrosServ.Marchamos
{
    public partial class FrmMarchamos : Form
    {

        #region Variables
        private string _id, _monto, nombrecliente, descripcion, No_prove, referencia, empresa, moneda, creado_el, _multi ;
        public bool  facturar;
        private string _SkuAlterno; // CODIGO DEL SERVICIO
        private string varUSRG, varPWDG, varURLE;

        #endregion
        
        #region Propiedades
      
        /// <summary>CODIGO DEL SERVICIO</summary>
        public string SkuAlterno
        {
            get
            {
                return _SkuAlterno;
            }
        }

        /// <summary>ID</summary>
        public string Id
        {
            get
            {
                return _id;
            }
        }

        /// <summary>MONTO</summary>
        public string Monto
        {
            get
            {
                return _monto;
            }
        }

        /// <summary> Es pagado por medio del proveedor Multicreditos</summary>
        public string Multi
        {
            get
            {
                return _multi;
            }
        }

        #endregion

        public FrmMarchamos()
        {
            InitializeComponent();
            //
            pnMarchamosAR.Visible = false;
            pnMarchamosPend.Visible = true;
            //
            LlenarComprobantes();
            LlenarParametros();
            facturar = false;
            ckMulti.Checked = false;
        }

        #region LlenarParametros
        /// <summary>Obtiene los Parámetros Generales Necesarios</summary>
        private void LlenarParametros()
        {
            Utils.QueryParams qp = new LLNet.Utils.QueryParams();
            //CONSULTA LOS PARÁMETROS DE LA BD
            DataSet dsB = GUI.CApp.bll.getDataSet("PDV", "C_PAM", qp);

            //SKU_ALTERNO
            object[] datos = new object[1];
            datos = dsB.Tables[0].Rows[0].ItemArray;
                                    
            _SkuAlterno = datos[0].ToString();
            //
            qp = new LLNet.Utils.QueryParams();
            //CONSULTA LOS PARÁMETROS DE LA BD
            dsB = GUI.CApp.bll.getDataSet("PDV", "C_PGEN", qp);

            datos = new object[2];
            datos = dsB.Tables[0].Rows[0].ItemArray;

            varUSRG = datos[0].ToString();
            varPWDG = datos[1].ToString();
            varURLE = datos[2].ToString();
        }
        #endregion

        #region LlenarComprobantes
        /// <summary>Obtiene los parámetros necesarios de cada tienda </summary>
        private void LlenarComprobantes()
        {
            Utils.QueryParams qp = new LLNet.Utils.QueryParams();
            qp.AddReplaceParam("pUsuario", GUI.CApp.usuario);// pUsuario
            //CONSULTA LOS PARÁMETROS DE LA BD
            DataSet dsE = GUI.CApp.bll.getDataSet("PDV", "AM_RECIBOS", qp);           

            if (dsE.Tables.Count > 0)
            {
                gCtrlMarchms.DataSource = dsE.Tables[0];
            }
            else
            {
                gCtrlMarchms.DataSource = null;
                gCtrlMarchms.Refresh();
            }           
        }
        #endregion

        #region mAnulacionRecibo
        /// <summary>
        /// Anula un recibo de pago de marchamo
        /// </summary>
        private void mAnulacionRecibo()
        {
            string vID = Convert.ToString(gvMarchamos.GetRowCellValue(gvMarchamos.FocusedRowHandle,
                    gvMarchamos.Columns[1]));
            string vDocumento = Convert.ToString(gvMarchamos.GetRowCellValue(gvMarchamos.FocusedRowHandle,
                gvMarchamos.Columns[0]));
            bool vExito = false;

            vExito = mAnularTransBNCR(vDocumento, Convert.ToString(gvMarchamos.GetRowCellValue(gvMarchamos.FocusedRowHandle,
                gvMarchamos.Columns[10])));

            if (vExito)
            {
                #region //Elimina pagos con CrediCuotas
                Utils.QueryParams qpCC = new LLNet.Utils.QueryParams();
                qpCC.AddReplaceParam("pFactura", vDocumento);
                string pCCE = GUI.CApp.bll.GetSingleValue("WMS_F_REFACCE", qpCC, "PDV").ToString();
                bool AnCCE = false; //Anular CREDICUOTAS correcto
                if (pCCE != "")
                {//si pago con CREDICUOTAS
                    try
                    {
                        AnCCE = Anular_TransCrediCuotsEk(Convert.ToString(gvMarchamos.GetRowCellValue(gvMarchamos.FocusedRowHandle,
                        gvMarchamos.Columns[10])));
                    }
                    catch (Exception ex)
                    {
                        CApp.ShowMessage(ex.Message, "CrediCuotas Ekono", true);
                        RegBDERRORCREDEK("", "", "", "", pCCE, ex.Message, "ANULACION");
                    }
                }
                else
                {//no pago con CREDICUOTAS
                    AnCCE = true;
                }
                #endregion

                if (AnCCE)
                {
                    QueryParams vParametros = new QueryParams();
                    vParametros.AddReplaceParam("pDOCUMENTO", vDocumento);
                    vParametros.AddReplaceParam("pID", vID);

                    if (GUI.CApp.Sup != null && GUI.CApp.Sup != String.Empty)
                    {
                        vParametros.AddReplaceParam("pUSUARIO", GUI.CApp.Sup);
                    }
                    else
                    {
                        vParametros.AddReplaceParam("pUSUARIO", GUI.CApp.usuario);
                    }

                    GUI.CApp.bll.ExecuteSql("AM_P_ANUL_RECIBO", vParametros, "PDV");
                    //
                    imprimirDocumentoDOS(Convert.ToInt64(vDocumento), "", 5026, "", "");
                    //
                    CApp.ShowMessage("Recibo anulado con éxito", "Marchamos", true);
                    //
                    mRecibosCancelados();
                }
            }
        }
        #endregion

        #region mAnularTransBNCR
        /// <summary>
        /// Anula un voucher del BNCR virtual
        /// </summary>
        private bool mAnularTransBNCR(string pDocumento, string pDocumento_Padre)
        {
            string supervisor = "";
            bool vExito = false;

            if (GUI.CApp.Sup != null && GUI.CApp.Sup != "")
            {
                supervisor = GUI.CApp.Sup;
            }
            else
            {
                supervisor = GUI.CApp.usuario;
            }

            Utils.QueryParams qp = new LLNet.Utils.QueryParams();
            qp.AddReplaceParam("DOCUMENTO", pDocumento);
            DataSet ds_datos = GUI.CApp.bll.getDataSet("PDV", "DatosTransRec", qp);

            if (ds_datos.Tables.Count > 0 && ds_datos.Tables[0].Rows.Count > 0)
            {
                bool proceder = true;//Se pone en false, si una transacción no se puedo anular
                foreach (DataRow fila in ds_datos.Tables[0].Rows)
                {
                    if (proceder)
                    {
                        string NumAutoriz = fila.ItemArray[1].ToString();//Número de autorización
                        string NumTarj = fila.ItemArray[2].ToString();//Número de tarjeta enmascarado
                        string NumRef = fila.ItemArray[3].ToString();//Número de referencia de la transacción
                        string MontoTrans = fila.ItemArray[4].ToString();//Monto transacción

                        if (MontoTrans == "")
                            MontoTrans = "0";

                        QueryParams qparams = new QueryParams();
                        qparams.AddReplaceParam("TARJETA", NumTarj);
                        qparams.AddReplaceParam("AUTORIZACION", NumAutoriz);
                        qparams.AddReplaceParam("REFERENCIA", NumRef);
                        object caja = GUI.CApp.bll.GetSingleValue("ExisteVenta", qparams, "PDV");
                        //Verifica si la venta con esos datos existe
                        if (caja == null)
                        {
                            proceder = false;
                            CApp.ShowMessage("No existe una transacción con esos datos", "Anulación de Documentos", true);
                        }
                        else
                        {
                            if (decimal.Parse(caja.ToString()) == 0)
                            {
                                proceder = false;
                                CApp.ShowMessage("No existe una transacción con esos datos", "Anulación de Documentos", true);
                            }
                            else if (decimal.Parse(caja.ToString()) != Program.Caja)
                            {
                                proceder = false;
                                CApp.ShowMessage("Debe hacer la anulación en la misma caja que se hizo la transacción", "Anulación de Documentos", true);
                            }
                            else
                            {
                                object anulada = GUI.CApp.bll.GetSingleValue("ExisteAnulacion", qparams, "PDV");
                                //
                                if (anulada == null)
                                {
                                    proceder = false;
                                    CApp.ShowMessage("La transacción ya fue anulada o los datos son erróneos", "Anulación de Documentos", true);
                                }
                                else
                                {
                                    if (int.Parse(anulada.ToString()) == 1)
                                    {
                                        proceder = false;
                                        CApp.ShowMessage("La transacción ya fue anulada", "Anulación de Documentos", true);
                                    }
                                    else
                                    {
                                        //Verifica si los datos de la transacción, corresponden al BNCR o BCR
                                        if (fila.ItemArray[5].ToString() == "2")//BNCR
                                        {
                                            #region BNCR
                                            qparams = new QueryParams();
                                            qparams.AddReplaceParam("TARJETA", NumTarj);
                                            qparams.AddReplaceParam("AUTORIZACION", NumAutoriz);
                                            qparams.AddReplaceParam("REFERENCIA", NumRef);
                                            qparams.AddReplaceParam("EMISOR", "2");
                                            object cerrada = GUI.CApp.bll.GetSingleValue("TransCerrada", qparams, "PDV");

                                            if (cerrada == null)
                                            {
                                                proceder = false;
                                                CApp.ShowMessage("No se pueden cargar los datos", "Anulación de Documentos", true);
                                            }
                                            else
                                            {
                                                if (int.Parse(cerrada.ToString()) != 0)
                                                {
                                                    proceder = false;
                                                    CApp.ShowMessage("La transacción ya fue cerrada", "Anulación de Documentos", true);
                                                }
                                                else
                                                {
                                                    vExito = RealizarTransaccion(supervisor, NumAutoriz, NumTarj, NumRef, MontoTrans, pDocumento_Padre);
                                                }
                                            }
                                            #endregion
                                        }
                                    }
                                }
                            }
                        }
                    }
                }//
            }
            else
            {
                vExito = true;
            }

            return vExito;
        }
        #endregion

        #region mRecibosCancelados
        /// <summary>
        /// Muestra los recibos cancelados, de marchamos, hechos por el cajero, en el día
        /// </summary>
        private void mRecibosCancelados()
        {
            gcMarchamos.DataSource = null;

            QueryParams vParametros = new QueryParams();
            vParametros.AddReplaceParam("pJORNADA", Program.Jornada.ToString());
            //
            // Obtiene los recibos cancelados
            using (DataSet vRecibos = GUI.CApp.bll.getDataSet("PDV", "AM_V_RECIBOS_COBRADOS", vParametros))
            {
                // Verifica que haya datos
                if (vRecibos.Tables.Count > 0 && vRecibos.Tables[0].Rows.Count > 0)
                {
                    gcMarchamos.DataSource = vRecibos.Tables[0];
                }
            }
        }
        #endregion

        #region mReporte
        /// <summary>
        /// Obtiene los datos para el reporte
        /// </summary>
        private void mReporte()
        {
            ReportDocument vReporte = new ReportDocument();
            vReporte.Load(GUI.CApp.ExeDir + "crRepMarchamos.rpt");
            //
            QueryParams vParametros = new QueryParams();
            vParametros.AddReplaceParam("pJORNADA", Program.Jornada.ToString());
            vParametros.AddReplaceParam("pCOD_ESTADO", "C");
            //
            DataSet vDatos = new DataSet();
            vDatos = GUI.CApp.bll.getDataSet("PDV", "AM_V_REPORTE_MARCHAMOS", vParametros);

            if (vDatos.Tables.Count > 0 && vDatos.Tables[0].Rows.Count > 0)
            {
                vReporte.Database.Tables["AM_V_REPORTE_MARCHAMOS"].SetDataSource(vDatos.Tables[0]);
                vReporte.Refresh();
                FrmReporte vForm = new FrmReporte(vReporte);
                vForm.ShowDialog();
            }
            else
            {
                CApp.ShowMessage("No se han realizado recibos", "Marchamos", true);
            }
        }
        #endregion

        #region imprimirDocumentoDOS
        private static void imprimirDocumentoDOS(long documento, string Impresora, long formato, string prefijo, string BatName)
        {
            if (BatName == "")
                BatName = "imprimir.bat";
            string Ruta = Application.StartupPath;
            string factura = String.Empty;
            QueryParams qp = new QueryParams();
            if (Ruta != string.Empty)
            {
                System.Diagnostics.ProcessStartInfo startInfo = new System.Diagnostics.ProcessStartInfo(Ruta + "\\" + BatName);
                startInfo.WindowStyle = System.Diagnostics.ProcessWindowStyle.Hidden;
                string Args = "";

                string varTipoTxt = Helpers.ObjToStr(CApp.GetParam("TTXT"));

                if (varTipoTxt == "U") // SI EL TIPO DE GENERACION DE ARCHIVO ES POR USUARIO O DOCUMENTO
                {
                    if (prefijo != "")
                        Args = prefijo + CApp.usuario + ".txt ";
                    else
                        Args = CApp.usuario + ".txt ";
                }
                else
                {
                    long pDocumento = documento;
                    if (prefijo != "")
                        Args = prefijo + pDocumento + ".txt ";
                    else
                        Args = pDocumento + ".txt ";
                }
                startInfo.Arguments = Args;

                try
                {
                    qp.AddReplaceParam("DOCUMENTO", documento.ToString());
                    object factTmp = GUI.CApp.bll.GetSingleValue("ObtenerFact", qp, "PDV");
                    if (factTmp != null && factTmp.ToString() != "")
                        factura = factTmp.ToString();
                    qp.Clear();

                    qp.AddReplaceParam("DOCUMENTO", documento.ToString());
                    qp.AddReplaceParam("FORMATO", formato.ToString());
                    qp.AddReplaceParam("USUARIO", CApp.usuario.ToString());
                    CApp.bll.ExecuteSql("GENERAR_IMPRESION_POS", qp, "PDV");
                    Thread.Sleep(3000); // SE LE DA TIEMPO A LA BD DE GENERAR EL ARCHIVO DE TEXTO
                    System.Diagnostics.Process.Start(startInfo);
                }
                catch (Exception ex)
                {
                    CApp.ShowMessage(ex.Message + "\rREIMPRIMA LA FACTURA/RECIBO " + factura, "Impresion de Documentos", true);
                }
            }
            else
            {
                throw new Exception("No esta Definido el Parametro UATI");
            }
            //startInfo.UseShellExecute = false; 
        }
        #endregion

        #region RegBDERRORCREDEK
        ///Registrar en BD UN ERROR DE CREDITO EKONO
        private void RegBDERRORCREDEK(string pERR_COD_ESTADO, string pERR_DESC, string pCOD_ESTADO,
            string pDESC_ESTADO, string pREFERENCIA, string pERROR, string pWS)
        {
            /*
              &&pREFERENCIA&&, &&pJORNADA&& ,
                    '&&pCOD_ESTADO&&' , '&&pDESC_ESTADO&&', '&&pERR_COD_EST&&' , 
                    '&&pERR_DESC&&', '&&pWS&&','&&pERROR&&'
             */
            Utils.QueryParams qp = new LLNet.Utils.QueryParams();

            if (pERR_COD_ESTADO == "")
            {
                qp.AddReplaceParam("pERR_COD_EST", DBNull.Value.ToString());
            }
            else
            {
                qp.AddReplaceParam("pERR_COD_EST", pERR_COD_ESTADO);
            }
            if (pERR_DESC == "")
            {
                qp.AddReplaceParam("pERR_DESC", DBNull.Value.ToString());
            }
            else
            {
                qp.AddReplaceParam("pERR_DESC", pERR_DESC);
            }
            if (pCOD_ESTADO == "")
            {
                qp.AddReplaceParam("pCOD_ESTADO", DBNull.Value.ToString());
            }
            else
            {
                qp.AddReplaceParam("pCOD_ESTADO", pCOD_ESTADO);
            }
            if (pDESC_ESTADO == "")
            {
                qp.AddReplaceParam("pDESC_ESTADO", DBNull.Value.ToString());
            }
            else
            {
                qp.AddReplaceParam("pDESC_ESTADO", pDESC_ESTADO);
            }
            if (pERROR == "")
            {
                qp.AddReplaceParam("pERROR", DBNull.Value.ToString());
            }
            else
            {
                qp.AddReplaceParam("pERROR", pERROR);
            }
            if (pWS == "")
            {
                qp.AddReplaceParam("pWS", DBNull.Value.ToString());
            }
            else
            {
                qp.AddReplaceParam("pWS", pWS);
            }
            if (pREFERENCIA == "")
            {
                qp.AddReplaceParam("pREFERENCIA", "0");
            }
            else
            {
                qp.AddReplaceParam("pREFERENCIA", pREFERENCIA);
            }
            //Jornada
            qp.AddReplaceParam("pJORNADA", Program.Jornada.ToString());


            // Llama el procedimiento que almacena los datos dl pago en la BD
            GUI.CApp.bll.ExecuteSql("WMS_P_CREDITOEK_ERROR", qp, "PDV");
        }
        #endregion

        #region Anular_TransCrediCuotsEk
        //Anula una transaccion de pago 
        private bool Anular_TransCrediCuotsEk(string doc)
        {
            bool trans = false;

            Utils.QueryParams qpcx = new LLNet.Utils.QueryParams();
            qpcx.AddReplaceParam("pdoc", doc);
            DataSet dsBC = GUI.CApp.bll.getDataSet("PDV", "WMS_TRANSCREDITOEK", qpcx);
            if (dsBC.Tables.Count > 0)
            {
                if (dsBC.Tables[0].Rows.Count > 0)
                {
                    foreach (DataRow Fila in dsBC.Tables[0].Rows)
                    {
                        object[] datos = new object[6];
                        datos = Fila.ItemArray;

                        if (GUI.CApp.ValidateAccess("AnlrCrEk", "Anula un Pago Credicuotas Ekono"))
                        {

                            //w.ID_TRANS_PROV,CG_F_PARAMETER_VALUE ('BREE') bodega, w.NIT_CLIENTE, w.VALORCOMPRA, w.FECHA_TRANS, referencia


                            //Número de autorización
                            string REFERENCIA = datos[5].ToString();

                            QueryParams qp = new QueryParams();
                            qp.AddReplaceParam("pREFERENCIA", REFERENCIA);
                            string ValFecha = GUI.CApp.bll.GetSingleValue("VALFECCREDITOEK", qp, "PDV").ToString();

                            if (ValFecha == "1")
                            {
                                //Número de autorización
                                string SUCURSAL = datos[1].ToString();
                                //Pin
                                string ID_TRANS_PROV = datos[0].ToString();
                                //Número de referencia de la transacción
                                string VALORCOMPRA = datos[3].ToString();
                                //FECHA TRANSACCION
                                string FECHA_TRANS = datos[4].ToString();
                                //FECHA TRANSACCION
                                string NIT_CLIENTE = datos[2].ToString();

                                string supervisor = "";
                                if (GUI.CApp.Sup != null && GUI.CApp.Sup != "")
                                {
                                    supervisor = GUI.CApp.Sup;
                                }
                                else
                                {
                                    supervisor = GUI.CApp.usuario;
                                }

                                //WEB SERVICE CON SUS MÉTODOS
                                GenesisCnx.Service wsGenesis = new GenesisCnx.Service();
                                wsGenesis.Url = varURLE;
                                XmlNode nod = wsGenesis.AnulaCompra(ID_TRANS_PROV, "F", SUCURSAL, CApp.usuario, Program.Caja.ToString(), 
                                    Program.Jornada.ToString(), NIT_CLIENTE, VALORCOMPRA, FECHA_TRANS, varUSRG, varPWDG);
                                XmlNodeList list = nod.SelectNodes("/datos");
                                foreach (XmlNode DATO in list)
                                {
                                    //  MessageBox.Show(DATO.InnerXml);
                                    if (DATO.HasChildNodes)
                                    {/*
                              <err_cod_estado>05</err_cod_estado><err_descripcion>Datos Incorrectos</err_descripcion>
                              */
                                        XmlNode cod_estado = DATO.SelectSingleNode("cod_estado");
                                        XmlNode desc_estado = DATO.SelectSingleNode("desc_estado");
                                        XmlNode err_cod_est = DATO.SelectSingleNode("err_cod_est");
                                        XmlNode err_desc = DATO.SelectSingleNode("err_desc");
                                        XmlNode id_trans_anulacion = DATO.SelectSingleNode("id_trans_anulacion");
                                        XmlNode tran_jornada = DATO.SelectSingleNode("tran_jornada");
                                        XmlNode tran_cedula = DATO.SelectSingleNode("tran_cedula");
                                        XmlNode tran_nombre = DATO.SelectSingleNode("tran_nombre");
                                        XmlNode tran_monto = DATO.SelectSingleNode("tran_monto");
                                        XmlNode tran_fecha = DATO.SelectSingleNode("tran_fecha");

                                        string codestado = "", descestado = "", errcodest = "", errdesc = "", idtransanulacion = "";

                                        if (cod_estado != null)
                                            codestado = cod_estado.InnerText;
                                        if (desc_estado != null)
                                            descestado = desc_estado.InnerText;
                                        if (err_cod_est != null)
                                            errcodest = err_cod_est.InnerText;
                                        if (err_desc != null)
                                            errdesc = err_desc.InnerText;
                                        if (id_trans_anulacion != null)
                                            idtransanulacion = id_trans_anulacion.InnerText;

                                        if (errcodest == "1")
                                        {//CONSULTA CORRECTA
                                            if (codestado == "1")
                                            {//TRANSACCION CORRECTA
                                                trans = true;

                                                RegBDAnul(REFERENCIA, CApp.usuario.ToString(), ID_TRANS_PROV, idtransanulacion);
                                                //IMPRIME EL COMPROBANTE DE ANULACION
                                                imprimirAVCREDITOEK(REFERENCIA);
                                            }
                                            else
                                            { //ERROR
                                                // this.exito = false;
                                                CApp.ShowMessage(descestado, "Error CrediCuotas", false);
                                                RegBDERRORCREDEK(errcodest, errdesc, codestado, descestado, REFERENCIA, "", "ANULACION");
                                            }
                                        }
                                        else
                                        { //ERROR CONSULTA
                                            //this.exito = false;
                                            CApp.ShowMessage(errdesc, "Error CrediCuotas", false);
                                            RegBDERRORCREDEK(errcodest, errdesc, codestado, descestado, REFERENCIA, "", "ANULACION");
                                        }

                                    }
                                    else
                                    {
                                        //this.exito = false;
                                        CApp.ShowMessage("No se obtiene datos", "Error CrediCuotas", false);
                                        RegBDERRORCREDEK("", "", "", "", REFERENCIA, "No se obtiene datos del XML", "ANULACION");
                                    }
                                }
                            }
                            else
                            {
                                CApp.ShowMessage("No se puede anular un pago CrediCuotas que no sea del día", "Pagos CrediCuotas Ekono", false);
                            }
                        }
                        else
                        {
                            CApp.ShowMessage("No tienes permisos para realizar la anulación", "Pagos CrediCuotas Ekono", false);
                        }
                    }
                }
                else
                    CApp.ShowMessage("No se puede anular un pago CrediCuotas asociado a una factura/recibo", "Pagos CrediCuotas Ekono", false);
            }
            return trans;
        }
        #endregion

        #region RealizarTransaccion IGF
        /// <summary>
        /// Realiza anulación de pago con tarjeta
        /// </summary>
        private bool RealizarTransaccion(string Supervisor, string NumA, string NumT, string NumR, string Monto, string Documento)
        {
            string TipoTrans = "W";//Tipo transacción
            bool Aprobado = false;//Indica si la transacción fue aprobada o no
            double ResponseAmount = 0;//Disponible de la tarjeta en consulta de saldos
            string nombTarj = "";//Nombre del tarjeta habiente
            string Merchant = "", MerchantNumber = "", TerminalNumber = "";
            bool vExito = false;

            Utils.QueryParams qp = new QueryParams();
            qp.AddReplaceParam("CAJA", Program.Caja.ToString());
            qp.AddReplaceParam("EMISOR", "2");

            //Verifica que la caja tenga en la base de datos, los datos de merchant, merchantnumber, terminalnumber
            if (GUI.CApp.bll.GetSingleValue("HayDatos", qp, "PDV").ToString() != "0")
            {
                //Obtiene el merchant, el merchant number y el terminal number
                DataSet ds_datos = GUI.CApp.bll.getDataSet("PDV", "ObtDatosB", qp);

                if (ds_datos.Tables.Count > 0 && ds_datos.Tables[0].Rows.Count > 0)
                {
                    Merchant = ds_datos.Tables[0].Rows[0].ItemArray[0].ToString();
                    MerchantNumber = ds_datos.Tables[0].Rows[0].ItemArray[1].ToString();
                    TerminalNumber = ds_datos.Tables[0].Rows[0].ItemArray[2].ToString();
                    //
                    //
                    string NumAutoriz = NumA;//Número de autorización
                    string NumTarj = NumT;//Número de tarjeta enmascarado
                    string NumRef = NumR;//Número de referencia de la transacción
                    //
                    #region
                    Utils.QueryParams qparams = new QueryParams();
                    string id_tr_tarj = GUI.CApp.bll.GetSingleValue("Sig_Id_tr_tarj", "PDV").ToString();
                    qparams.AddReplaceParam("ID_TR_TARJ", id_tr_tarj);
                    qparams.AddReplaceParam("DOCUMENTO", Documento);
                    qparams.AddReplaceParam("CAJA", Program.Caja.ToString());
                    qparams.AddReplaceParam("TIPO", "Anulación");
                    if (Supervisor != null && Supervisor != "")
                        qparams.AddReplaceParam("USUARIO", Supervisor);
                    else
                        qparams.AddReplaceParam("USUARIO", GUI.CApp.usuario);
                    qparams.AddReplaceParam("MONTO", Monto);
                    qparams.AddReplaceParam("ESTADO", "Pendiente");
                    qparams.AddReplaceParam("EMISOR", "2");
                    qparams.AddReplaceParam("JORNADA", Program.Jornada.ToString());
                    //
                    GUI.CApp.bll.ExecuteSql("Ini_Log_Tarjetas_Anul", qparams, "PDV");
                    #endregion
                    //
                    //Realiza el proceso de anulación de la transacción
                    BNCRGL.BNCR bn = new BNCRGL.BNCR();
                    bn.GenerarTransaccion(Merchant, MerchantNumber, TerminalNumber, TipoTrans,
                    0, 0, 0, 0, 0, ref NumTarj, ref nombTarj, ref Aprobado, ref NumRef,
                    ref NumAutoriz, ref ResponseAmount);
                    //
                    #region (NO) Aprobado
                    if (Aprobado)
                    {
                        qparams = new QueryParams();
                        //Datos fin del proceso de pago con tarjeta de crédito
                        qparams.AddReplaceParam("ID_TR_TARJ", id_tr_tarj);
                        qparams.AddReplaceParam("TARJETA", NumTarj);
                        qparams.AddReplaceParam("AUTORIZACION", NumAutoriz);
                        qparams.AddReplaceParam("REFERENCIA", NumRef);
                        qparams.AddReplaceParam("ESTADO", "Aprobada");
                        qparams.AddReplaceParam("ERRORES", "");
                        //
                        vExito = true;
                        GUI.CApp.bll.ExecuteSql("Fin_Log_Tarjetas", qparams, "PDV");
                    }
                    else
                    {
                        qparams = new QueryParams();
                        qparams.AddReplaceParam("ID_TR_TARJ", id_tr_tarj);
                        qparams.AddReplaceParam("TARJETA", NumTarj);
                        qparams.AddReplaceParam("AUTORIZACION", NumAutoriz);
                        qparams.AddReplaceParam("REFERENCIA", NumRef);
                        qparams.AddReplaceParam("ESTADO", "Denegada");
                        qparams.AddReplaceParam("ERRORES", "Anulación denegada/cancelada");
                        //
                        GUI.CApp.bll.ExecuteSql("Fin_Log_Tarjetas", qparams, "PDV");

                        CApp.ShowMessage("Transacción denegada", "Anulación de Documentos", true);
                    }
                    #endregion
                }
            }
            else
                CApp.ShowMessage("Para esta caja, no existe el merchant, merchantnumber y terminalnumber", "Cobros y Facturación", true);

            return vExito;
        }
        #endregion

        #region RegBDAnul
        private void RegBDAnul(string pREFERENCIA, string pUSUARIO, string pID_TRANS_PROV, string pID_TRANS_ANUL)
        {      /*
                (&&pREFERENCIA&& , '&&pUSUARIO&&' , '&&pID_TRANS_PROV&&' ,&&pID_TRANS_ANUL&& );
                */
            Utils.QueryParams qp = new LLNet.Utils.QueryParams();

            if (pREFERENCIA == "")
            {
                qp.AddReplaceParam("pREFERENCIA", "0");
            }
            else
            {
                qp.AddReplaceParam("pREFERENCIA", pREFERENCIA);
            }
            if (pUSUARIO == "")
            {
                qp.AddReplaceParam("pUSUARIO", DBNull.Value.ToString().ToString());
            }
            else
            {
                qp.AddReplaceParam("pUSUARIO", pUSUARIO);
            }
            if (pID_TRANS_PROV == "")
            {
                qp.AddReplaceParam("pID_TRANS_PROV", DBNull.Value.ToString().ToString());
            }
            else
            {
                qp.AddReplaceParam("pID_TRANS_PROV", pID_TRANS_PROV);
            }
            if (pID_TRANS_ANUL == "")
            {
                qp.AddReplaceParam("pID_TRANS_ANUL", DBNull.Value.ToString().ToString());
            }
            else
            {
                qp.AddReplaceParam("pID_TRANS_ANUL", pID_TRANS_ANUL);
            }

            // Llama el procedimiento que almacena los datos dl pago en la BD
            GUI.CApp.bll.ExecuteSql("WMS_P_CREDITOEK_IAPAGS", qp, "PDV");
        }
        #endregion

        #region imprimirAVCREDITOEK
        private void imprimirAVCREDITOEK(string id)
        {
            try
            {
                object FormatoTipoImpresion = null;
                QueryParams qparams = new LLNet.Utils.QueryParams();
                qparams = new LLNet.Utils.QueryParams();
                qparams.AddReplaceParam("RV_DOMAIN", "DOCUMENTOS TIENDA' AND RV_LOW_VALUE = 'CAFC");
                Model.General.CgRefCodes dsDocTienda = new LLNet.Model.General.CgRefCodes();
                Utils.Helpers.Merge(GUI.CApp.bll.getTypedDataSet(dsDocTienda.GetType(), dsDocTienda.DOMAINS.TableName, qparams), dsDocTienda);
                string format = Utils.Helpers.Nvl(FormatoTipoImpresion, dsDocTienda.DOMAINS[0].RV_MPCC02).ToString();
                imprimirVoucherCCE(Convert.ToInt64(id), "", Convert.ToInt64(format));
            }
            catch (Exception ex)
            {
                CApp.ShowMessage(ex.Message, "Comprobante de Anulación Pago con CrediCuotas Ekono", false);
            }
        }
        #endregion

        #region imprimirVoucherCCE
        /// <summary> Imprime el voucher</summary>
        /// <param name="voucher">Id voucher</param>
        /// <param name="Impresora"></param>
        /// <param name="formato">Formato impresión</param>
        private void imprimirVoucherCCE(long voucher, string Impresora, long formato)
        {
            string Ruta = Application.StartupPath;
            Utils.QueryParams qp = new LLNet.Utils.QueryParams();
            if (Ruta != string.Empty)
            {
                System.Diagnostics.ProcessStartInfo startInfo = new System.Diagnostics.ProcessStartInfo(Ruta + "\\" + "imprimir.bat ");
                startInfo.WindowStyle = System.Diagnostics.ProcessWindowStyle.Hidden;

                string Args = "";
                string varTipoTxt = Utils.Helpers.ObjToStr(GUI.CApp.GetParam("TTXT"));

                if (varTipoTxt == "U") // SI EL TIPO DE GENERACION DE ARCHIVO ES POR USUARIO O DOCUMENTO
                {
                    Args = GUI.CApp.usuario + ".txt ";
                }
                else
                {
                    long pDocumento = voucher;
                    Args = pDocumento + ".txt ";
                }

                startInfo.Arguments = Args;
                try
                {
                    qp.AddReplaceParam("ID_TR_TARJ", voucher.ToString());
                    qp.AddReplaceParam("FORMATO", formato.ToString());
                    qp.AddReplaceParam("USUARIO", GUI.CApp.usuario.ToString());
                    GUI.CApp.bll.ExecuteSql("WMS_P_GENERAR_IMPRVO", qp, "PDV");
                    Thread.Sleep(2000);  // se deja un delay para esperar a que la base contruya el archivo
                    System.Diagnostics.Process.Start(startInfo);

                    #region Imprimir copia voucher
                    string valor = Helpers.Nvl(CApp.GetParam("HCV"), "").ToString();
                    if (valor == "1")//Si valor es 1, se imprime la copia del voucher
                    {
                        qp.AddReplaceParam("ID_TR_TARJ", voucher.ToString());
                        qp.AddReplaceParam("FORMATO", formato.ToString());
                        qp.AddReplaceParam("USUARIO", GUI.CApp.usuario.ToString());
                        GUI.CApp.bll.ExecuteSql("WMS_P_GENERAR_IMPRVO", qp, "PDV");
                        Thread.Sleep(2000);  // se deja un delay para esperar a que la base contruya el archivo
                        System.Diagnostics.Process.Start(startInfo);
                    }
                    #endregion
                }
                catch (Exception ex)
                {
                    GUI.CApp.ShowMessage(ex.Message, "Impresion de Documentos", false);
                }
            }
            else
            {
                throw new Exception("No esta Definido el Parametro UATI");
            }
        }
        #endregion

        private void btnCancelar_Click(object sender, EventArgs e)
        {
            facturar = false;
            this.Close();
        }

        #region btnFacturar_Click
        private void btnFacturar_Click(object sender, EventArgs e)
        {
            bool vContinuar = true;

            if (pnRecManual.Visible)
            {
                if (txtIdProv.Text == String.Empty)
                {
                    CApp.ShowMessage("Ingrese el id del proveedor", "Marchamos", true);
                    txtIdProv.Focus();
                    vContinuar = false;
                }
                else if (mtbMonto.Text == String.Empty)
                {
                    CApp.ShowMessage("Ingrese el monto del marchamo", "Marchamos", true);
                    mtbMonto.Focus();
                    vContinuar = false;
                }
                else
                {
                    QueryParams vParametros = new QueryParams();
                    vParametros.AddReplaceParam("pID", txtId.Text);
                    vParametros.AddReplaceParam("pCAJA", Program.Caja.ToString());
                    vParametros.AddReplaceParam("pCAJERO", GUI.CApp.usuario);
                    vParametros.AddReplaceParam("pMONTO", mtbMonto.Text);
                    vParametros.AddReplaceParam("pNO_PROVE", txtIdProv.Text);

                    if (GUI.CApp.Sup != null && GUI.CApp.Sup != String.Empty)
                    {
                        vParametros.AddReplaceParam("pAUTORIZADO_POR", GUI.CApp.Sup);
                    }
                    else
                    {
                        vParametros.AddReplaceParam("pAUTORIZADO_POR", GUI.CApp.usuario);
                    }

                    GUI.CApp.bll.ExecuteSql("AM_P_ING_MANUAL_REC", vParametros, "PDV");

                    _id = txtId.Text;
                    _monto = mtbMonto.Text;
                }
            }
            else
            {
                //SELECT A.ID, A.MONTO, A.NOMBRECLIENTE, A.DESCRIPCION, A.NO_PROVE, A.REFERENCIA, A.EMPRESA, A.MONEDA, A.CREADO_EL FROM EKONO.AM_RECIBO_IN A WHERE TRIM(A.CAJERO) = '&&pUsuario&&' ORDER BY ID DESC  
                foreach (int handle in gridViewMarch.GetSelectedRows())
                {
                    _id = Convert.ToString(gridViewMarch.GetRowCellValue(handle, gridViewMarch.Columns[0]));
                    _monto = Convert.ToString(gridViewMarch.GetRowCellValue(handle, gridViewMarch.Columns[1]));
                    nombrecliente = Convert.ToString(gridViewMarch.GetRowCellValue(handle, gridViewMarch.Columns[2]));
                    descripcion = Convert.ToString(gridViewMarch.GetRowCellValue(handle, gridViewMarch.Columns[3]));
                    No_prove = Convert.ToString(gridViewMarch.GetRowCellValue(handle, gridViewMarch.Columns[4]));
                    referencia = Convert.ToString(gridViewMarch.GetRowCellValue(handle, gridViewMarch.Columns[5]));
                    empresa = Convert.ToString(gridViewMarch.GetRowCellValue(handle, gridViewMarch.Columns[6]));
                    moneda = Convert.ToString(gridViewMarch.GetRowCellValue(handle, gridViewMarch.Columns[7]));
                    creado_el = Convert.ToString(gridViewMarch.GetRowCellValue(handle, gridViewMarch.Columns[8]));
                }
            }

            if (vContinuar)
            {
                facturar = true;
                DialogResult = DialogResult.Cancel;
                this.Close();
            }
        }
        #endregion

        #region FrmMarchamos_KeyDown
        private void FrmMarchamos_KeyDown(object sender, KeyEventArgs e)
        {
            if (e.Modifiers == Keys.Alt)
            {
                switch (e.KeyCode)
                {
                    case Keys.A:
                        btnAnular_Click(null, null);
                        break;
                    case Keys.M:
                        sbtnMarchamo_Click(null, null);
                        break;
                    case Keys.R:
                        sBtnReimpRecNic_Click(null, null);
                        break;
                    case Keys.C:
                        sBtnRepRecNic_Click(null, null);
                        break;
                }
            }
            else
            {
                switch (e.KeyCode)
                {
                    case Keys.F10:
                        btnReciboManual_Click(null, null);
                        break;
                    case Keys.F11:
                        sbtnImprimir_Click(null, null);
                        break;
                    case Keys.F12: // facturar
                        if (pnMarchamosPend.Visible || lblTitulo.Visible)
                        {
                            btnFacturar_Click(null, null);
                        }
                        else if(pnMarchamosAR.Visible)
                        {
                            sbtnAceptar_Click(null, null);
                        }
                        break;
                    case Keys.Escape:
                        btnCancelar_Click(null, null);
                        break;
                }
            }
        }
        #endregion

        #region sBtnReimpRecNic_Click
        private void sBtnReimpRecNic_Click(object sender, EventArgs e)
        {
            try
            {
                pnMarchamosPend.Visible = false;
                pnMarchamosAR.Visible = true;
                pnRecManual.Visible = false;
                //
                btnFacturar.Visible = false;
                sbtnImprimir.Visible = true;
                sbtnAceptar.Visible = false;
                //
                mRecibosCancelados();
            }
            catch (Exception ex)
            {
                CApp.ShowMessage(ex.Message, "Marchamos", true);
            }
        }
        #endregion

        #region sBtnRepRecNic_Click
        private void sBtnRepRecNic_Click(object sender, EventArgs e)
        {
            try
            {
                mReporte();
            }
            catch (Exception ex)
            {
                CApp.ShowMessage(ex.Message, "Marchamos", true);
            }
        }
        #endregion

        #region btnAnular_Click
        private void btnAnular_Click(object sender, EventArgs e)
        {
            try
            {
                if (GUI.CApp.ValidateAccess("ANUL_IMARCHAMOS", "Anulación de Marchamos"))
                {
                    pnMarchamosPend.Visible = false;
                    pnMarchamosAR.Visible = true;
                    pnRecManual.Visible = false;
                    //
                    btnFacturar.Visible = false;
                    sbtnImprimir.Visible = false;
                    sbtnAceptar.Visible = true;
                    //
                    mRecibosCancelados();
                }
            }
            catch (Exception ex)
            {
                CApp.ShowMessage(ex.Message, "Marchamos", true);
            }
        }
        #endregion

        #region sbtnAceptar_Click
        private void sbtnAceptar_Click(object sender, EventArgs e)
        {
            try
            {
                mAnulacionRecibo();
            }
            catch (Exception ex)
            {
                CApp.ShowMessage(ex.Message, "Marchamos", true);
            }
        }
        #endregion

        #region sbtnMarchamo_Click
        private void sbtnMarchamo_Click(object sender, EventArgs e)
        {
            try
            {
                pnMarchamosPend.Visible = true;
                pnMarchamosAR.Visible = false;
                pnRecManual.Visible = false;
                //
                btnFacturar.Visible = true;
                sbtnImprimir.Visible = false;
                sbtnAceptar.Visible = false;
                LlenarComprobantes();
            }
            catch (Exception ex)
            {
                CApp.ShowMessage(ex.Message, "Marchamos", true);
            }
        }
        #endregion

        #region sbtnImprimir_Click
        private void sbtnImprimir_Click(object sender, EventArgs e)
        {
            try
            {
                string vDocumento = Convert.ToString( gvMarchamos.GetRowCellValue(gvMarchamos.FocusedRowHandle, 
                    gvMarchamos.Columns[0]) );

                QueryParams vParametros = new QueryParams();
                vParametros.AddReplaceParam("pDOCUMENTO", vDocumento);
                GUI.CApp.bll.ExecuteSql("AM_P_INDICA_REIMPRESION", vParametros, "PDV");
                //
                imprimirDocumentoDOS(Convert.ToInt64(vDocumento), "", 5025, "", "");
            }
            catch (Exception ex)
            {
                CApp.ShowMessage(ex.Message, "Marchamos", true);
            }
        }
        #endregion

        #region btnReciboManual_Click
        private void btnReciboManual_Click(object sender, EventArgs e)
        {
            try
            {
                if (GUI.CApp.ValidateAccess("ING_MANUAL_MARCHAMO", "Ingreso Manual de Marchamos"))
                {
                    pnMarchamosPend.Visible = false;
                    pnMarchamosAR.Visible = false;
                    pnRecManual.Visible = true;
                    //
                    btnFacturar.Visible = true;
                    sbtnImprimir.Visible = false;
                    sbtnAceptar.Visible = false;
                    //
                    // Obtiene el número de id para el recibo manual
                    Utils.QueryParams vParametro = new LLNet.Utils.QueryParams();
                    vParametro.AddReplaceParam("SECUENCIA", "AM_S_REC_MANUAL");
                    txtId.Text = Helpers.Nvl(CApp.bll.GetSingleValue("SECUENCIA", vParametro, "General"), "").ToString();
                    //
                    txtIdProv.Focus();
                }
            }
            catch (Exception ex)
            {
                CApp.ShowMessage(ex.Message, "Marchamos", true);
            }
        }
        #endregion

        private void ckMulti_CheckedChanged(object sender, EventArgs e)
        {
            if (this.ckMulti.Checked == true)
            {
                _multi = "M";
            } 
            else
            {
                _multi = "N";
            } 
        }
    }
}