public void guardarVehiculo(Entidades.Vehiculo vehiculo)
        {
            SqlConnection conexion = new SqlConnection(cadenaConexion);
            conexion.Open();
            SqlCommand cmd = new SqlCommand("proc_Vehiculo", conexion);
            cmd.CommandType = CommandType.StoredProcedure;
            cmd.Parameters.AddWithValue("@accion", "i");
            cmd.Parameters.AddWithValue("@Vehiculo_Placa", vehiculo.Vehiculo_Placa);
            cmd.Parameters.AddWithValue("@Parame_MarcaV", vehiculo.Parame_MarcaV);
            cmd.Parameters.AddWithValue("@Pardet_MarcaV", vehiculo.Pardet_MarcaV);
            cmd.Parameters.AddWithValue("@Parame_Modelo", vehiculo.Parame_Modelo);
            cmd.Parameters.AddWithValue("@Pardet_Modelo", vehiculo.Pardet_Modelo);
            cmd.Parameters.AddWithValue("@Parame_SubModelo", vehiculo.Parame_SubModelo);
            cmd.Parameters.AddWithValue("@Pardet_SubModelo", vehiculo.Pardet_SubModelo);
            cmd.Parameters.AddWithValue("@Vehiculo_Anio", vehiculo.Vehiculo_Anio);
            cmd.Parameters.AddWithValue("@Vehiculo_NoMotor", vehiculo.Vehiculo_NoMotor);
            cmd.Parameters.AddWithValue("@Vehiculo_Observacion", vehiculo.Vehiculo_Observacion);

            SqlDataAdapter sda = new SqlDataAdapter(cmd);
            try
            {
                cmd.ExecuteNonQuery();
                conexion.Close();
            }
            catch { throw; }
        }

        public override string guardar(Entidades.PlatosCartaPlatos platosCarta)
        {
            string mensaje = "";
            try
            {
                int cont = 0;
                OleDbConnection conexion = Entidades.Conexion.GetInstancia().crearConexion();

                OleDbCommand cmdUpdate = new OleDbCommand("Update CartaPlatoPlatos Set Activo = @activo Where IdCartaPlato = @idCartaPlato and IdPlato = @idPlato", conexion);
                cmdUpdate.Parameters.AddWithValue("@activo", platosCarta.Activo);
                cmdUpdate.Parameters.AddWithValue("@idCartaPlato", platosCarta.IdCartaPlato);
                cmdUpdate.Parameters.AddWithValue("@idProducto", platosCarta.IdPlato);
                cont = cmdUpdate.ExecuteNonQuery();
                mensaje = "Actualizado con exito.";
                if (cont == 0)
                {
                    OleDbCommand cmd = new OleDbCommand("Insert Into CartaPlatoPlatos(IdCartaPlato,IdPlato,Activo) Values(@idCartaPlato,@idPlato,@activo)", conexion);
                    cmd.Parameters.AddWithValue("@idCartaPlato", platosCarta.IdCartaPlato);
                    cmd.Parameters.AddWithValue("@idPlato", platosCarta.IdPlato);
                    cmd.Parameters.AddWithValue("@activo", platosCarta.Activo);
                    cmd.ExecuteNonQuery();
                    mensaje = "Guardado con exito.";
                }
            }
            catch (Exception ex)
            {
                mensaje = "Ocurrio un problema al guardar " + ex.Message;
            }

            return mensaje;
        }

        public string Excluir(Entidades.GrupoTrabalhoUsuario entidade)
        {
            try
            {
                Dados.LimparParametros();
                object objRetorno = null;
                if (entidade != null && entidade.Usuario != null && entidade.Usuario.IdUsuario > 0 &&
                    entidade.GrupoTrabalho != null && entidade.GrupoTrabalho.IdGrupoTrabalho > 0)
                {
                    Dados.AdicionarParametros("@vchAcao", "DELETAR");
                    Dados.AdicionarParametros("@intIdUsuario", entidade.Usuario.IdUsuario);
                    Dados.AdicionarParametros("@intIdGrupoTrabalho", entidade.GrupoTrabalho.IdGrupoTrabalho);

                    objRetorno = Dados.ExecutarManipulacao(CommandType.StoredProcedure, "spGrupoTrabalhoUsuario");
                }

                int intResultado = 0;
                if (objRetorno != null)
                {
                    if (int.TryParse(objRetorno.ToString(), out intResultado))
                        return intResultado.ToString();
                    else
                        throw new Exception(objRetorno.ToString());
                }
                else
                {
                    return "Não foi possível executar";
                }
            }
            catch (Exception ex)
            {
                throw ex;
            }
        }

        public void Abrir(Entidades.Mercadoria.Mercadoria mercadoria, Entidades.Acerto.ControleAcertoMercadorias acerto)
        {
            // Limpa a lista
            lista.Items.Clear();

            // Limpa a hash:
            hashListViewItemRastro = new Dictionary<ListViewItem, RastroItem>();

            // Obtém os dados do BD
            List<RastroItem> rastro =  acerto.ObterRastro(mercadoria);

            // Cria a lista 
            foreach (RastroItem itemRastro in rastro)
            {
                ListViewItem item = new ListViewItem(new String[lista.Columns.Count]);
                
                item.SubItems[colData.Index].Text = itemRastro.Data.ToLongDateString();
                item.SubItems[colDescrição.Index].Text = itemRastro.Descrição;
                item.SubItems[colDocumento.Index].Text = itemRastro.Documento;
                item.SubItems[colQuantidade.Index].Text = itemRastro.Quantidade.ToString();

                hashListViewItemRastro[item] = itemRastro;
                lista.Items.Add(item);
            }

            if (rastro.Count == 1)
                lista.Items[0].Selected = true;
        }

        public static List<Entidades.TipoArregloDisco> Obtener(Entidades.TipoArregloDisco a)
        {
            List<Entidades.TipoArregloDisco> lista = new List<Entidades.TipoArregloDisco>();
            try
            {
                using (ISession session = NHibernateHelper.OpenSession())
                {
                    //Option
                    ICriteria crit = session.CreateCriteria(typeof(Entidades.TipoArregloDisco));
                    if (a.IdTipoArreglo != 0 && a.IdTipoArreglo.ToString() != "")
                        crit.Add(Restrictions.Eq("IdTipoArreglo", a.IdTipoArreglo));
                   if (!string.IsNullOrEmpty(a.Tipo))
                        crit.Add(Restrictions.Like("Tipo", a.Tipo));
                    if (!string.IsNullOrEmpty(a.Descripcion))
                        crit.Add(Restrictions.Like("Descripcion", a.Descripcion));

                    crit.AddOrder(Order.Asc("Tipo"));

                    lista = (List<Entidades.TipoArregloDisco>)crit.List<Entidades.TipoArregloDisco>();
                }
            }
            catch
            {
                return lista;
            }

            return lista;
        }

        public static List<Entidades.ConceptoEstatus> Obtener(Entidades.ConceptoEstatus a)
        {
            List<Entidades.ConceptoEstatus> lista = new List<Entidades.ConceptoEstatus>();
            try
            {
                using (ISession session = NHibernateHelper.OpenSession())
                {
                    //Option
                    ICriteria crit = session.CreateCriteria(typeof(Entidades.ConceptoEstatus));
                    if (a.IdConceptoEstatus != 0 && a.IdConceptoEstatus.ToString() != "")
                        crit.Add(Restrictions.Eq("IdConceptoEstatus", a.IdConceptoEstatus));
                   if (!string.IsNullOrEmpty(a.Concepto))
                        crit.Add(Restrictions.Like("Concepto", a.Concepto));

                    crit.AddOrder(Order.Asc("Concepto"));

                    lista = (List<Entidades.ConceptoEstatus>)crit.List<Entidades.ConceptoEstatus>();
                }
            }
            catch
            {
                return lista;
            }

            return lista;
        }

        public BalãoMercadoriaInconsistente(Entidades.Mercadoria.Mercadoria mercadoria)
        {
            InitializeComponent();

            lblRef.Text = mercadoria.Referência;
            lblPeso.Text = mercadoria.PesoFormatado;
        }

        public int SP_SALVAR_PROGRAMAENGATE(Entidades.ProgramaEngate entidade)
        {
            int Codigo = 0;
            Queue<SqlParameter> qParameters = null;
            Database db = null;
            try
            {
                db = new Database();
                CreateParameters(ref qParameters,
                        new Property() { NomeCampo = "CodigoPrograma", Value = entidade.CodigoPrograma },
                        new Property() { NomeCampo = "Data", Value = entidade.Data },
                        new Property() { NomeCampo = "TipoEngate", Value = entidade.TipoEngate },
                       new Property() { NomeCampo = "UserID", Value = "Teste" }
                       // new Property() { NomeCampo = "UserID", Value = entidade.UserID }
                    );

                Codigo = db.ExecuteNonQuery("SP_SALVAR_PROGRAMAENGATE", ref qParameters);
            }
            catch (Exception ex)
            {
                throw ex;
            }
            finally
            {
                if (qParameters != null)
                    GC.SuppressFinalize(qParameters);
                if (db != null)
                    db.Dispose();
            }
            return Codigo;
        }

        public int SP_SALVAR_PROGRAMA(Entidades.Programa entidade)
        {
            int Codigo = 0;
            Queue<SqlParameter> qParameter = null;
            Database db = null;
            try
            {
                db = new Database();

                CreateParameters(ref qParameter,
                    new References.DAL.Property() { NomeCampo = "Codigo", Value = entidade.Codigo, Direction = ParameterDirection.Output },
                    new References.DAL.Property() { NomeCampo = "NomePrograma", Value = entidade.NomePrograma },
                    new References.DAL.Property() { NomeCampo = "Descricao", Value = entidade.Descricao },
                    new References.DAL.Property() { NomeCampo = "Ativo", Value = entidade.Ativo }
                );

                Codigo = db.ExecuteNonQuery("[dbo].[SP_SALVAR_PROGRAMA]", ref qParameter);
            }
            catch (Exception ex)
            {
                throw ex;
            }
            finally
            {
                if (qParameter != null)
                    GC.SuppressFinalize(qParameter);
                if (db != null)
                    db.Dispose();
            }
            return Codigo;
        }

        public static List<Entidades.MarcaServidor> ObtenerMarcaServidor(Entidades.MarcaServidor ms)
        {
            List<Entidades.MarcaServidor> lista = new List<Entidades.MarcaServidor>();
            try
            {
                using (ISession session = NHibernateHelper.OpenSession())
                {
                    //Option
                    ICriteria crit = session.CreateCriteria(typeof(Entidades.MarcaServidor));
                    if (ms.IdMarca != 0 && ms.IdMarca.ToString() != "")
                        crit.Add(Restrictions.Eq("IdMarcas", ms.IdMarca));
                    if (!string.IsNullOrEmpty(ms.NombreMarca))
                        crit.Add(Restrictions.Like("NombreMarca", ms.NombreMarca));

                    crit.AddOrder(Order.Asc("NombreMarca"));

                    lista = (List<Entidades.MarcaServidor>)crit.List<Entidades.MarcaServidor>();
                }
            }
            catch
            {
                return lista;
            }

            return lista;
        }

 private void Copiar(DataRow Desde, Entidades.ReporteActividad Hasta)
 {
     Hasta.DescrEntidad = Convert.ToString(Desde["DescrEntidad"]);
     Hasta.Evento = Convert.ToString(Desde["Evento"]);
     Hasta.Estado = Convert.ToString(Desde["Estado"]);
     Hasta.Cantidad = Convert.ToInt32(Desde["Cantidad"]);
 }

        public static string editar(Entidades.Pieza pieza)
        {
            string retorno = "";
            try
            {
                var sql =
                    from c in db.Pieza
                    where c.pie_codigo == pieza.Codigo
                    select c;

                foreach (var s in sql)
                {
                    s.pie_baja = pieza.Baja;
                    s.pie_cantidad = pieza.Cantidad;
                    s.pie_codigo = pieza.Codigo;
                    s.pie_costo = Convert.ToDecimal(pieza.Costo);
                    s.pie_modelo = pieza.Modelo;
                    s.pie_tipo = pieza.Tipo;
                    db.SubmitChanges();
                    retorno = "exito";
                }
            }
            catch (Exception e)
            {
                retorno = e.Message;
            }
            return retorno;
        }

        public void AlmacenaPlantilla(Entidades.PlantillaEstadoCuenta plantilla)
        {
            string mensajeError = string.Empty;
            bool resultado = false;

            try
            {
                using (DaoEstadoCuenta daoEstadoCuenta = new DaoEstadoCuenta())
                {
                    daoEstadoCuenta.BaseDatos = "InformacionEstadoCuenta";
                    daoEstadoCuenta.Servidor = "http://Localhost:9090";

                    resultado = daoEstadoCuenta.InsertarEstadoCuenta(plantilla, out mensajeError);
                }
            }
            catch (ExcepcionDatosEstadoCuenta excepcion)
            {
                throw excepcion;
            }
            catch (Exception excepcion)
            {
                StringBuilder mensaje = new StringBuilder();
                mensaje.Append("Se presentó un error no controlado en la clase AlmacenaPlantilla ");
                mensaje.Append(" en el mètodo AlmacenaPlantilla(). Detalle del error: ");
                mensaje.Append(excepcion.Message);

                throw new ExcepcionLogicaEstadoCuenta(mensajeError.ToString(), excepcion);
            }
        }

        public static void Imprimir(Entidades.Álbum.Álbum álbum, ItensImpressão itens)
        {
            using (PrintDocument documento = new PrintDocument())
            {
                documento.DocumentName = "Álbum " + álbum.Nome;

                using (PrintDialog dlg = new PrintDialog())
                {
                    dlg.AllowCurrentPage = false;
                    dlg.AllowSelection = false;
                    dlg.AllowSomePages = true;
                    dlg.UseEXDialog = true;
                    dlg.Document = documento;

                    if (dlg.ShowDialog() == DialogResult.OK)
                    {
                        ControleImpressão ctrl = new ControleImpressão(álbum, itens);

                        ctrl.página = new Página(
                                documento.PrinterSettings.DefaultPageSettings.PrintableArea.Width / 100f,
                                documento.PrinterSettings.DefaultPageSettings.PrintableArea.Height / 100f,
                                4, 5);
            
                        ctrl.daPágina = dlg.PrinterSettings.FromPage;
                        ctrl.atéPágina = dlg.PrinterSettings.ToPage != 0 ?
                            dlg.PrinterSettings.ToPage : int.MaxValue;

                        documento.PrintPage += new PrintPageEventHandler(ctrl.ImprimirPágina);
                        documento.Print();
                    }
                }
            }
        }

        public ClienteDívida(Entidades.Pessoa.Pessoa cliente)
        {
            InitializeComponent();
            this.cliente = cliente;

            Carregar();
        }

        /// <summary>
        /// Agrega un registro de Comprobante en la B.D.
        /// </summary>
        /// <param name="pComprobante">Objeto Comprobantes</param>
        public void Agregar(Entidades.Comprobantes pComprobante)
        {
            DateTime fchNula;
            fchNula = DateTime.ParseExact("19000101", "yyyyMMdd", System.Globalization.CultureInfo.InvariantCulture);

            //Declaro variable con la sentencia SQL
            string strSQL = "INSERT Comprobantes (Id_Transaccion, Id_PtoVenta, Bloqueado, FchBaja) ";
            strSQL += "VALUES (@id_Transaccion, @id_PtoVenta, @bloqueado, @fchBaja)";



            //Crear objeto de la clase SQLConnection
            SqlConnection objConexion = new SqlConnection(Conexion.strConexion);

            //Crear objeto de SQLCommand
            SqlCommand comAlta = new SqlCommand(strSQL, objConexion);

            //Cargo los valores de los parametros
            comAlta.Parameters.AddWithValue("@id_Transaccion", pComprobante.Id_Transaccion);
            comAlta.Parameters.AddWithValue("@id_PtoVenta", pComprobante.Id_PtoVenta);

            if (DateTime.Compare(pComprobante.FchServDesde, fchNula) > 0)
            {
                comAlta.Parameters.AddWithValue("@fchBaja", pComprobante.FchServDesde);
            }
            else
            {
                comAlta.Parameters.AddWithValue("@fchBaja", DBNull.Value);

            }

            try
            {
                //Abro conexion
                objConexion.Open();

                //Ejecuto el comando con NonQuery cuando es transaccional (Insert, update o delete)
                comAlta.ExecuteNonQuery();

            }
            catch (SqlException)
            {
                //Se produjo un error SQL, SqlExcepcion es especifico de sql por eso va arriba de Excepcion
                throw new Exception("Error en la Base de Datos");
            }
            catch (Exception)
            {
                //Pasa la excepción a la capa de lógica
                throw new Exception("No pudo realizar el Alta del Punto de Venta");
            }
            finally
            {
                //Cierro la conexion solo si estaba abierto
                if (objConexion.State == ConnectionState.Open)
                {
                    objConexion.Close();
                }

            }
        }

 public void Modificar(Entidades.Ticket Ticket)
 {
     try
     {
         Entidades.Ticket t = Leer(Ticket.Cuit, Ticket.Service);
         if (t.Cuit == null)
         {
             Crear(Ticket);
         }
         else
         {
             StringBuilder a = new StringBuilder(string.Empty);
             a.Append("update Ticket set ");
             a.Append("Service='" + Ticket.Service + "', ");
             a.Append("UniqueId='" + Ticket.UniqueId + "', ");
             a.Append("GenerationTime='" + Ticket.GenerationTime.ToString("yyyyMMdd HH:mm:ss") + "', ");
             a.Append("ExpirationTime='" + Ticket.ExpirationTime.ToString("yyyyMMdd HH:mm:ss") + "', ");
             a.Append("Sign='" + Ticket.Sign + "', ");
             a.Append("Token='" + Ticket.Token + "' ");
             a.AppendLine("where Cuit='" + Ticket.Cuit + "' and Service = '" + Ticket.Service + "' ");
             Ejecutar(a.ToString(), TipoRetorno.None, Transaccion.Usa, sesion.CnnStr);
         }
     }
     catch (Exception ex)
     {
         Funciones.GrabarLogTexto("Consultar.txt", ex.Message + " " + ex.StackTrace);
         throw new Exception(ex.Message);
     }
 }

        public int Agregar(Entidades.Curso item)
        {
            MySqlConnection oConn = Datos.General.CreateConnection();
            using (oConn)
            {
                oConn.Open();

                MySqlCommand oCmd = new MySqlCommand();
                using (oCmd)
                {
                    oCmd.Connection = oConn;
                    oCmd.CommandType = CommandType.StoredProcedure;
                    oCmd.CommandText = "CursosAgregar";
                    oCmd.Parameters.AddWithValue("@Anio", item.Anio);
                    oCmd.Parameters.AddWithValue("@Aula", item.Aula);
                    oCmd.Parameters.AddWithValue("@Cupo", item.Cupo);
                    oCmd.Parameters.AddWithValue("@Comision", item.comision.IdComision);
                    oCmd.Parameters.AddWithValue("@Materia", item.materia.IdMateria);
                    oCmd.Parameters.AddWithValue("@Abierto", item.Abierto);

                    // Ejecutamos el comando y retornamos el id generado
                    return Convert.ToInt32(oCmd.ExecuteScalar());
                }
            }
        }

        public static string editar(Entidades.Trabajo trabajo)
        {
            string retorno = "";
            try
            {
                var sql =
                    from c in db.Trabajo
                    where c.tra_codigo == trabajo.Codigo
                    select c;

                foreach (var s in sql)
                {
                    s.tra_codigo = trabajo.Codigo;
                    s.tra_costo = trabajo.Costo;
                    s.tra_descripcion = trabajo.Descripcion;
                    s.pie_baja = trabajo.Baja;
                    db.SubmitChanges();
                    retorno = "exito";
                }
            }
            catch (Exception e)
            {
                retorno = e.Message;
            }
            return retorno;
        }

 public static bool Grabar(Entidades.Distrito pdistrito)
 {
     //una regla de negocio es que el nombre de distrito no podra ser un valor nulo o vacio
     if (string.IsNullOrEmpty(pdistrito.nomb_distrito.Trim()))
         throw new Exception("el nombre del distrito no puede ser un valor nulo o vacio");
     return AccesoDato.AdDistrito.Grabar(pdistrito);
 }