Esempio n. 1
0
        /// <summary>
        /// Carga las mesas que estan en estado ocupado de la mesa que va a editar
        /// </summary>
        private void CargarMesasViejas()
        {
            foreach (int Elemento in MesasEditar)
            {
                string InformacionDelError = string.Empty;

                ClsMesas Mesas             = new ClsMesas();
                Mesa     CargarMesasViejas = Mesas.LeerPorNumero(Elemento, ClsMesas.ETipoDeListado.PorID, ref InformacionDelError);

                if (CargarMesasViejas != null)
                {
                    int NumeroDeFila = dgvCrearMesa.Rows.Add();

                    dgvCrearMesa.Rows[NumeroDeFila].Cells[(int)ENumColDGVMesa.ID_Mesa].Value     = CargarMesasViejas.ID_Mesa;
                    dgvCrearMesa.Rows[NumeroDeFila].Cells[(int)ENumColDGVMesa.Numero].Value      = CargarMesasViejas.Numero;
                    dgvCrearMesa.Rows[NumeroDeFila].Cells[(int)ENumColDGVMesa.Capacidad].Value   = CargarMesasViejas.Capacidad;
                    dgvCrearMesa.Rows[NumeroDeFila].Cells[(int)ENumColDGVMesa.Seleccionar].Value = true;

                    ClsColores.MarcarFilaDGV(dgvCrearMesa, NumeroDeFila, true);

                    lblResultadoCapacidadTotal.Text = Convert.ToString(Convert.ToInt32(lblResultadoCapacidadTotal.Text) + CargarMesasViejas.Capacidad);
                }
                else if (InformacionDelError == string.Empty)
                {
                    MessageBox.Show("Ocurrio un fallo al cargar el filtro de estados", "Aviso", MessageBoxButtons.OK, MessageBoxIcon.Warning);
                }
                else
                {
                    MessageBox.Show($"{InformacionDelError}", "Aviso", MessageBoxButtons.OK, MessageBoxIcon.Warning);
                }
            }

            dgvCrearMesa.Sort(dgvCrearMesa.Columns[(int)ENumColDGVMesa.Numero], ListSortDirection.Ascending);
        }
        private bool BuscarUsuariosAtendiendoMesa(int _Indice)
        {
            string InformacionDelError = string.Empty;

            ClsMesas    Mesas = new ClsMesas();
            List <Mesa> BuscarUsuariosConMesaAsignada = Mesas.LeerListado(ClsMesas.ETipoDeListado.MesasOcupadas, ref InformacionDelError);;

            if (BuscarUsuariosConMesaAsignada != null)
            {
                foreach (Mesa Elemento in BuscarUsuariosConMesaAsignada)
                {
                    if (Elemento.ID_Usuario == (int)dgvDatosUsuarios.Rows[_Indice].Cells[(int)ENumColDGVUsuarios.ID_Usuario].Value)
                    {
                        return(true);
                    }
                }
            }
            else if (InformacionDelError == string.Empty)
            {
                MessageBox.Show("Fallo al buscar si usuarios que esten atendiendo mesas", "Aviso", MessageBoxButtons.OK, MessageBoxIcon.Warning);
                return(true);
            }
            else
            {
                MessageBox.Show($"{InformacionDelError}", "Aviso", MessageBoxButtons.OK, MessageBoxIcon.Warning);
                return(true);
            }

            return(false);
        }
        private void BtnAplicarNuevaCapacidad_Click(object sender, EventArgs e)
        {
            // TODO - Cambiar la capacidad de una mesa
            string InformacionDelError = string.Empty;

            ClsMesas Mesas = new ClsMesas();
            Mesa     EditarCapacidadMesa = new Mesa();

            EditarCapacidadMesa = Mesas.LeerPorNumero((int)nudNumeroDeMesaEditar.Value, ClsMesas.ETipoDeListado.PorNumeroDeMesa, ref InformacionDelError);

            if (EditarCapacidadMesa != null)
            {
                if (EditarCapacidadMesa.Capacidad != (int)nudNuevaCapacidad.Value)
                {
                    EditarCapacidadMesa.Capacidad = (int)nudNuevaCapacidad.Value;

                    if (Mesas.Actualizar(EditarCapacidadMesa, ref InformacionDelError) != 0)
                    {
                        FrmPrincipal.ObtenerInstancia().S_tslResultadoOperacion = "Capacidad de la mesa actualizada";
                    }
                    else if (InformacionDelError == string.Empty)
                    {
                        FrmPrincipal.ObtenerInstancia().MensajeAdvertencia("Fallo al actualizar la capacidad de la mesa");
                    }
                    else
                    {
                        FrmPrincipal.ObtenerInstancia().MensajeAdvertencia("Fallo al actualizar la capacidad de la mesa");
                        MessageBox.Show($"{InformacionDelError}", "Aviso", MessageBoxButtons.OK, MessageBoxIcon.Warning);
                    }
                }
                else
                {
                    FrmPrincipal.ObtenerInstancia().S_tslResultadoOperacion = "Seleccione una nueva capacidad";
                }
            }
            else if (InformacionDelError == string.Empty)
            {
                FrmPrincipal.ObtenerInstancia().MensajeAdvertencia("Fallo al buscar la mesa a editar");
            }
            else
            {
                FrmPrincipal.ObtenerInstancia().MensajeAdvertencia("Fallo al buscar la mesa a editar");
                MessageBox.Show($"{InformacionDelError}", "Aviso", MessageBoxButtons.OK, MessageBoxIcon.Warning);
            }
        }
        /// <summary>
        /// Busca las mesas pertenecientes a la planta alta, que estan en estado activo.
        /// </summary>
        /// <returns>Cantidad de mesas que esten activas.</returns>
        private int ListarMesasActivasPA()
        {
            string InformacionDelError = string.Empty;

            ClsMesas Mesas = new ClsMesas();

            List <Mesa> ListarMesasPA = Mesas.LeerListado(ClsMesas.ETipoDeListado.MesasActivasPA, ref InformacionDelError);

            if (ListarMesasPA != null)
            {
                return(ListarMesasPA.Count);
            }
            else if (InformacionDelError != string.Empty)
            {
                FrmPrincipal.ObtenerInstancia().MensajeAdvertencia("Error al intentar calcular las mesas de la PA");
                MessageBox.Show($"{InformacionDelError}", "Aviso", MessageBoxButtons.OK, MessageBoxIcon.Warning);
            }

            return(-1);
        }
Esempio n. 5
0
        /// <summary>
        /// Lista las mesas que se estan por reservas al crear/editar una reserva.
        /// </summary>
        private void CargarDGVMesasPreReservadas()
        {
            int[,] ArrayMesas = new int[12, 2];
            int CapacidadTotal = 0;

            string InformacionDelError = string.Empty;

            ClsMesas Mesas = new ClsMesas();
            Mesa     BuscarMesasCargadas = new Mesa();

            foreach (int Numero in ListaDeMesasReserva)
            {
                BuscarMesasCargadas = Mesas.LeerPorNumero(Numero, ClsMesas.ETipoDeListado.PorID, ref InformacionDelError);

                if (BuscarMesasCargadas != null)
                {
                    int NumeroDeFila = dgvMesasReservadas.Rows.Add();

                    dgvMesasReservadas.Rows[NumeroDeFila].Cells[(int)ENumColDGVMesas.ID_Mesa].Value   = BuscarMesasCargadas.ID_Mesa;
                    dgvMesasReservadas.Rows[NumeroDeFila].Cells[(int)ENumColDGVMesas.Numero].Value    = BuscarMesasCargadas.Numero;
                    dgvMesasReservadas.Rows[NumeroDeFila].Cells[(int)ENumColDGVMesas.Capacidad].Value = BuscarMesasCargadas.Capacidad;

                    CapacidadTotal += BuscarMesasCargadas.Capacidad;
                }
                else if (InformacionDelError == string.Empty)
                {
                    MessageBox.Show("Fallo al comprobar si trabaja con planta alta", "Aviso", MessageBoxButtons.OK, MessageBoxIcon.Warning);
                    Close();
                }
                else
                {
                    MessageBox.Show($"{InformacionDelError}", "Aviso", MessageBoxButtons.OK, MessageBoxIcon.Warning);
                    Close();
                }
            }

            dgvMesasReservadas.Sort(dgvMesasReservadas.Columns[(int)ENumColDGVMesas.Numero], ListSortDirection.Ascending);

            lblResultadoCapacidadTotal.Text = Convert.ToString(CapacidadTotal);
        }
        /// <summary>Carga el DGV.</summary>
        private void CargarDGVListarMesas(ClsMesas.ETipoDeListado _TipoDeListado)
        {
            dgvListarMesas.Rows.Clear();

            string InformacionDelError = string.Empty;

            ClsMesas Mesas = new ClsMesas();

            List <Mesa> ListarMesas = Mesas.LeerListado(_TipoDeListado, ref InformacionDelError);

            if (ListarMesas != null)
            {
                int CapacidadTotal = 0;

                foreach (Mesa Elemento in ListarMesas)
                {
                    int NumeroDeFila = dgvListarMesas.Rows.Add();

                    dgvListarMesas.Rows[NumeroDeFila].Cells[(int)ENumColDGVMesa.ID_Mesa].Value   = Elemento.ID_Mesa;
                    dgvListarMesas.Rows[NumeroDeFila].Cells[(int)ENumColDGVMesa.Numero].Value    = Elemento.Numero;
                    dgvListarMesas.Rows[NumeroDeFila].Cells[(int)ENumColDGVMesa.Capacidad].Value = Elemento.Capacidad;

                    CapacidadTotal += Elemento.Capacidad;
                }
                dgvListarMesas.Sort(dgvListarMesas.Columns[(int)ENumColDGVMesa.Numero], ListSortDirection.Ascending);

                lblResultadoCapacidadTotal.Text = Convert.ToString(CapacidadTotal);
            }
            else if (InformacionDelError == string.Empty)
            {
                MessageBox.Show("Fallo al comprobar si trabaja con planta alta", "Aviso", MessageBoxButtons.OK, MessageBoxIcon.Warning);
            }
            else
            {
                MessageBox.Show($"{InformacionDelError}", "Aviso", MessageBoxButtons.OK, MessageBoxIcon.Warning);
            }
        }
        private void CargarDGVMesasDisponibles(ClsMesasXReservas.EMesasDisponibles _TipoDeFiltro)
        {
            dgvSeleccionarMesaReserva.Rows.Clear();

            lblResultadoCapacidadTotal.Text = "0";

            string InformacionDelError = string.Empty;

            ClsMesasXReservas   MesasXReservas       = new ClsMesasXReservas();
            List <MesaXReserva> ListaMesasReservadas = MesasXReservas.LeerListado(_TipoDeFiltro, ref InformacionDelError, FechaParaReservar.Date);

            ClsMesas    Mesas            = new ClsMesas();
            List <Mesa> MesasDisponibles = null;

            // Trae la lista por planta
            if (_TipoDeFiltro == ClsMesasXReservas.EMesasDisponibles.MesasDisponiblesPB)
            {
                MesasDisponibles = Mesas.LeerListado(ClsMesas.ETipoDeListado.MesasActivasPB, ref InformacionDelError);
            }
            else
            {
                MesasDisponibles = Mesas.LeerListado(ClsMesas.ETipoDeListado.MesasActivasPA, ref InformacionDelError);
            }

            if (MesasDisponibles != null && ListaMesasReservadas != null)
            {
                // Recorro todas las mesas activas
                foreach (Mesa Elemento in MesasDisponibles)
                {
                    bool MesaNoReservada = true;

                    // Elimino de la lista las mesas que encuentre en la lista de las reservadas
                    foreach (MesaXReserva ElementoSecundario in ListaMesasReservadas)
                    {
                        if (Elemento.ID_Mesa == ElementoSecundario.ID_Mesa && ElementoSecundario.ID_Reserva != ID_Reserva)
                        {
                            MesaNoReservada = false;
                        }
                    }

                    if (MesaNoReservada)
                    {
                        bool MarcarMesaReservada = false;
                        int  NumeroDeFila        = dgvSeleccionarMesaReserva.Rows.Add();

                        dgvSeleccionarMesaReserva.Rows[NumeroDeFila].Cells[(int)ENumColDGVMesa.ID_Mesa].Value   = Elemento.ID_Mesa;
                        dgvSeleccionarMesaReserva.Rows[NumeroDeFila].Cells[(int)ENumColDGVMesa.Numero].Value    = Elemento.Numero;
                        dgvSeleccionarMesaReserva.Rows[NumeroDeFila].Cells[(int)ENumColDGVMesa.Capacidad].Value = Elemento.Capacidad;

                        // Marca las mesas ya reservadas al editar una reserva
                        foreach (MesaXReserva ElementoSecundario in ListaMesasReservadas)
                        {
                            if (Elemento.ID_Mesa == ElementoSecundario.ID_Mesa)
                            {
                                MarcarMesaReservada             = true;
                                lblResultadoCapacidadTotal.Text = Convert.ToString(Convert.ToInt32(lblResultadoCapacidadTotal.Text) + Elemento.Capacidad);
                            }
                        }

                        dgvSeleccionarMesaReserva.Rows[NumeroDeFila].Cells[(int)ENumColDGVMesa.Seleccionar].Value = MarcarMesaReservada;

                        if (MarcarMesaReservada)
                        {
                            ClsColores.MarcarFilaDGV(dgvSeleccionarMesaReserva, NumeroDeFila, true);
                        }
                        else
                        {
                            ClsColores.MarcarFilaDGV(dgvSeleccionarMesaReserva, NumeroDeFila, false);
                        }
                    }
                }

                UltimaFilaSeleccionada = -1;

                dgvSeleccionarMesaReserva.Sort(dgvSeleccionarMesaReserva.Columns[(int)ENumColDGVMesa.Numero], ListSortDirection.Ascending);
            }
            else if (InformacionDelError == string.Empty)
            {
                MessageBox.Show($"Ocurrio un fallo al cargar las mesas reservadas", "Aviso", MessageBoxButtons.OK, MessageBoxIcon.Warning);
            }
            else
            {
                MessageBox.Show($"{InformacionDelError}", "Aviso", MessageBoxButtons.OK, MessageBoxIcon.Warning);
            }
        }
        private void BtnEliminar_Click(object sender, EventArgs e)
        {
            if (nudCantidadMesasAEliminar.Value > 0)
            {
                string InformacionDelError = string.Empty;

                ClsMesas Mesas = new ClsMesas();

                List <Mesa> MesasActivas;

                MesasActivas = Mesas.LeerListado(ClsMesas.ETipoDeListado.MesasOcupadas, ref InformacionDelError);

                if (MesasActivas != null)
                {
                    if (MesasActivas.Count == 0)
                    {
                        MesasActivas = null;

                        if (rbnPlantaBaja.Checked)
                        {
                            MesasActivas = Mesas.LeerListado(ClsMesas.ETipoDeListado.MesasActivasPB, ref InformacionDelError);
                        }
                        else
                        {
                            MesasActivas = Mesas.LeerListado(ClsMesas.ETipoDeListado.MesasActivasPA, ref InformacionDelError);
                        }

                        if (MesasActivas != null)
                        {
                            MesasActivas.Reverse();

                            int Contador = 0;

                            foreach (Mesa Elemento in MesasActivas)
                            {
                                Elemento.ID_EstadoMesa = (int)ClsEstadosMesas.EEstadosMesas.Inactivo;

                                if (Mesas.Actualizar(Elemento, ref InformacionDelError) != 0)
                                {
                                    FrmPrincipal.ObtenerInstancia().S_tslResultadoOperacion = "Mesa/s eliminada/s";
                                }
                                else if (InformacionDelError == string.Empty)
                                {
                                    FrmPrincipal.ObtenerInstancia().MensajeAdvertencia("Error al intentar eliminar la mesa");
                                    MessageBox.Show("Error al intentar eliminar la mesa", "Aviso", MessageBoxButtons.OK, MessageBoxIcon.Warning);
                                }
                                else
                                {
                                    FrmPrincipal.ObtenerInstancia().MensajeAdvertencia("Error al intentar eliminar la mesa");
                                    MessageBox.Show($"{InformacionDelError}", "Aviso", MessageBoxButtons.OK, MessageBoxIcon.Warning);
                                }

                                Contador++;

                                if (Contador == nudCantidadMesasAEliminar.Value)
                                {
                                    break;
                                }
                            }

                            // Actualizo los NUD con los nuevos valores
                            ActualizarControles();

                            FrmPrincipal.ObtenerInstancia().S_tslResultadoOperacion = "Mesa/s eliminada/s";
                        }
                        else if (InformacionDelError == string.Empty)
                        {
                            FrmPrincipal.ObtenerInstancia().MensajeAdvertencia("Error al intentar eliminar la mesa");
                        }
                        else
                        {
                            FrmPrincipal.ObtenerInstancia().MensajeAdvertencia("Error al intentar eliminar la mesa");
                            MessageBox.Show($"{InformacionDelError}", "Aviso", MessageBoxButtons.OK, MessageBoxIcon.Warning);
                        }
                    }
                    else
                    {
                        using (FrmInformacion FormInformacion = new FrmInformacion($"No puede eliminar mesas, el sistema se detectó que hay en uso actualmente para pedidos. Finalize " +
                                                                                   $"los mismo e intente nuevamente.", ClsColores.Blanco, 250, 300))
                        {
                            FormInformacion.ShowDialog();
                        }
                    }
                }
                else if (InformacionDelError != string.Empty)
                {
                    FrmPrincipal.ObtenerInstancia().MensajeAdvertencia("Error al intentar eliminar la mesa");
                    MessageBox.Show($"{InformacionDelError}", "Aviso", MessageBoxButtons.OK, MessageBoxIcon.Warning);
                }
            }
        }
        private void BtnCrearMesa_Click(object sender, EventArgs e)
        {
            CargarConfiguracion();

            int MesasPlantaBaja = Convert.ToInt32(lblCantidadMesasPB.Text);

            // Entrar si la mesa que se va a crear es menor a 99 o la mesa que va a crear sera de la PA
            if (MesasPlantaBaja < 99 || rbnPlantaAlta.Checked)
            {
                string InformacionDelError = string.Empty;

                ClsMesas Mesas = new ClsMesas();
                Mesa     BuscarMesaInactiva = new Mesa();

                if (rbnPlantaBaja.Checked)
                {
                    BuscarMesaInactiva = Mesas.LeerPorNumero(-1, ClsMesas.ETipoDeListado.PrimerMesaInactivaPB, ref InformacionDelError);
                }
                else
                {
                    BuscarMesaInactiva = Mesas.LeerPorNumero(-1, ClsMesas.ETipoDeListado.PrimerMesaInactivaPA, ref InformacionDelError);
                }

                if (BuscarMesaInactiva != null) //encontro una mesa ya creada para actualizarle el estado y la capacidad
                {
                    BuscarMesaInactiva.ID_EstadoMesa = (int)ClsEstadosMesas.EEstadosMesas.Activo_Disponible;
                    BuscarMesaInactiva.Capacidad     = (int)nudCapacidadNuevaMesa.Value;

                    if (Mesas.Actualizar(BuscarMesaInactiva, ref InformacionDelError) != 0)
                    {
                        ActualizarControles();
                        FrmPrincipal.ObtenerInstancia().S_tslResultadoOperacion = "Mesa creada correctamente";
                    }
                    else if (InformacionDelError != string.Empty)
                    {
                        FrmPrincipal.ObtenerInstancia().MensajeAdvertencia("Fallo al crear la mesa");
                        MessageBox.Show($"{InformacionDelError}", "Aviso", MessageBoxButtons.OK, MessageBoxIcon.Warning);
                    }
                }
                else if (InformacionDelError == string.Empty) // No se encontro una mesa inactiva ni se genero una excepcion
                {                                             // crear la mesa
                    BuscarMesaInactiva = new Mesa();

                    BuscarMesaInactiva.Numero        = Convert.ToInt32(lblNumeroNuevaMesa.Text);
                    BuscarMesaInactiva.ID_EstadoMesa = (int)ClsEstadosMesas.EEstadosMesas.Activo_Disponible;
                    BuscarMesaInactiva.Capacidad     = (int)nudCapacidadNuevaMesa.Value;
                    BuscarMesaInactiva.ID_Usuario    = 1;

                    if (Mesas.Crear(BuscarMesaInactiva, ref InformacionDelError) != 0)
                    {
                        ActualizarControles();
                        FrmPrincipal.ObtenerInstancia().S_tslResultadoOperacion = "Mesa creada correctamente";
                    }
                    else if (InformacionDelError == string.Empty)
                    {
                        FrmPrincipal.ObtenerInstancia().MensajeAdvertencia("Fallo al crear la mesa");
                    }
                    else
                    {
                        FrmPrincipal.ObtenerInstancia().MensajeAdvertencia("Fallo al crear la mesa");
                        MessageBox.Show($"{InformacionDelError}", "Aviso", MessageBoxButtons.OK, MessageBoxIcon.Warning);
                    }
                }
                else
                {
                    FrmPrincipal.ObtenerInstancia().MensajeAdvertencia("Fallo al crear la mesa");
                    MessageBox.Show($"{InformacionDelError}", "Aviso", MessageBoxButtons.OK, MessageBoxIcon.Warning);
                }
            }
            else
            {
                FrmPrincipal.ObtenerInstancia().S_tslResultadoOperacion = "Alcanzo el limite de mesas en la PB";
            }
        }
Esempio n. 10
0
        private void CargarDGVCrearMesas(ClsMesas.ETipoDeListado _TipoDeListado)
        {
            dgvCrearMesa.Rows.Clear();
            lblResultadoCapacidadTotal.Text = "0";

            string InformacionDelError = string.Empty;

            ClsMesas    Mesas = new ClsMesas();
            List <Mesa> CargarMesasDisponibles = Mesas.LeerListado(_TipoDeListado, ref InformacionDelError);

            if (CargarMesasDisponibles != null)
            {
                bool MesasOcupadasCargadas = false;

                foreach (Mesa Elemento in CargarMesasDisponibles)
                {
                    int NumeroDeFila = dgvCrearMesa.Rows.Add();

                    dgvCrearMesa.Rows[NumeroDeFila].Cells[(int)ENumColDGVMesa.ID_Mesa].Value     = Elemento.ID_Mesa;
                    dgvCrearMesa.Rows[NumeroDeFila].Cells[(int)ENumColDGVMesa.Numero].Value      = Elemento.Numero;
                    dgvCrearMesa.Rows[NumeroDeFila].Cells[(int)ENumColDGVMesa.Capacidad].Value   = Elemento.Capacidad;
                    dgvCrearMesa.Rows[NumeroDeFila].Cells[(int)ENumColDGVMesa.Seleccionar].Value = false;

                    if (MesasEditar.Count > 0 && !MesasOcupadasCargadas)
                    {
                        if (ClsMesas.ETipoDeListado.MesasDisponiblesPB == _TipoDeListado && PlantaBaja)
                        {
                            CargarMesasViejas();
                        }
                        else if (ClsMesas.ETipoDeListado.MesasDisponiblesPA == _TipoDeListado && !PlantaBaja)
                        {
                            CargarMesasViejas();
                        }
                        MesasOcupadasCargadas = true;
                    }
                }

                if (CargarMesasDisponibles.Count == 0)
                {
                    if (MesasEditar.Count > 0 && !MesasOcupadasCargadas)
                    {
                        if (ClsMesas.ETipoDeListado.MesasDisponiblesPB == _TipoDeListado && PlantaBaja)
                        {
                            CargarMesasViejas();
                        }
                        else if (ClsMesas.ETipoDeListado.MesasDisponiblesPA == _TipoDeListado && !PlantaBaja)
                        {
                            CargarMesasViejas();
                        }
                    }
                }
            }
            else if (InformacionDelError == string.Empty)
            {
                MessageBox.Show("Ocurrio un fallo al cargar el filtro de estados", "Aviso", MessageBoxButtons.OK, MessageBoxIcon.Warning);
            }
            else
            {
                MessageBox.Show($"{InformacionDelError}", "Aviso", MessageBoxButtons.OK, MessageBoxIcon.Warning);
            }

            dgvCrearMesa.Sort(dgvCrearMesa.Columns[(int)ENumColDGVMesa.Numero], ListSortDirection.Ascending);
        }