public List <BE.TipoArbitro> Leer()
        {
            var ls = new List <BE.TipoArbitro>();

            BE.TipoArbitro beTipoArbitro = new BE.TipoArbitro();

            var dt = _accesoBaseDeDatos.Seleccionar(new BE.TipoArbitro(), false);

            foreach (DataRow row in dt.Rows)
            {
                var aTipoArbitro = new BE.TipoArbitro
                {
                    Id          = Convert.ToInt32(row["Id"]),
                    Descripcion = row["Descripcion"].ToString().Trim(),
                    Deporte     = new BE.Deporte()
                    {
                        Id = Convert.ToInt32(row["IdDeporte"])
                    },
                };

                ls.Add(aTipoArbitro);
            }

            return(ls);
        }
        public BE.TipoArbitro ObtenerTipoArbitroPorId(int idTipoArbitro)
        {
            var dtTipoArbitro = _accesoBaseDeDatos.Seleccionar(new BE.TipoArbitro()
            {
                Id = idTipoArbitro
            }, true);

            if (dtTipoArbitro.Rows.Count == 0)
            {
                return(null);
            }

            var row          = dtTipoArbitro.Rows[0];
            var aTipoArbitro = new BE.TipoArbitro
            {
                Id          = Convert.ToInt32(row["Id"]),
                Descripcion = row["Descripcion"].ToString().Trim(),
                Deporte     = new BE.Deporte()
                {
                    Id = Convert.ToInt32(row["IdDeporte"])
                },
            };

            return(aTipoArbitro);
        }
        public BE.TipoArbitro ObtnerTipoArbitroPorIdReducido(int idTipoArbitro)
        {
            BE.TipoArbitro beTipoArbitro = _dalManagerTipoArbitro.ObtenerTipoArbitroPorId(idTipoArbitro);

            // beTipoArbitro.Deporte = _bllDeporte.ObtnerDeportePorId(beTipoArbitro.Deporte.Id);

            return(beTipoArbitro);
        }
        /// <summary>
        /// Agrega un nuevo TipoArbitro al sistema.
        /// </summary>
        /// <param name="pTipoArbitro">TipoArbitro a agregar.</param>
        /// <returns></returns>
        public Resultado Agregar(BE.TipoArbitro pTipoArbitro)
        {
            var resultado = _dalManagerTipoArbitro.Insertar(pTipoArbitro);

            if (resultado == ResultadoBd.OK)
            {
                return(new Resultado(false, "Ok"));
            }

            return(new Resultado(false, "No se dio de alta el TipoArbitro."));
        }
        /// <summary>
        /// Quita un TipoArbitro.
        /// </summary>
        /// <param name="pTipoArbitro">TipoArbitro a quitar.</param>
        /// <returns></returns>
        public Resultado Quitar(BE.TipoArbitro pTipoArbitro)
        {
            ResultadoBd resultado = _dalManagerTipoArbitro.Borrar(pTipoArbitro);

            if (resultado == ResultadoBd.OK)
            {
                return(new Resultado(false, "Ok"));
            }


            return(new Resultado(false, "No se pudo borrar el TipoArbitro."));
        }
        /// <summary>
        /// Edita un TipoArbitro.
        /// </summary>
        /// <param name="pTipoArbitro">TipoArbitro a editar.</param>
        /// <returns></returns>
        public Resultado Editar(BE.TipoArbitro pTipoArbitro)
        {
            ResultadoBd resultado = _dalManagerTipoArbitro.Actualizar(pTipoArbitro);

            if (resultado == ResultadoBd.OK)
            {
                return(new Resultado(false, "Ok"));
            }


            return(new Resultado(false, "No se pudo editar el TipoArbitro."));
        }
Exemple #7
0
        public bool PuedeDirigir(BE.Arbitro arbitro, BE.Partido partido, BE.TipoArbitro tipoArbitro)
        {
            BLL.NivelRegla levelRule = new NivelRegla();

            if (this.EquipoDirigido(partido, arbitro))
            {
                return(false);
            }
            if (this.DirigidoLosUltimos15Dias(partido, arbitro))
            {
                return(false);
            }
            if (levelRule.PuedeDirigirPartidoComoTipoArbitro(arbitro, partido, tipoArbitro))
            {
                return(true);
            }
            return(true);
        }
        public BE.TipoArbitro ObtenerTipoArbitroPorPartidoYArbitroId(int idPartido, int idArbitro)
        {
            var ls   = new List <BE.TipoArbitro>();
            var pars = new IDbDataParameter[2];

            pars[0] = _accesoBaseDeDatos.CrearParametro("@IdPartido", idPartido);
            pars[1] = _accesoBaseDeDatos.CrearParametro("@IdArbitro", idArbitro);

            string query = @"   select ta.*
                                from TipoArbitro ta,
		                             PartidoArbitro pa
                                where ta.Id = pa.IdTipoArbitro
                                and   pa.IdPartido = @IdPartido	                            
                                and   pa.IdArbitro = @IdArbitro
	                            "    ;

            var dt = _accesoBaseDeDatos.Seleccionar(query, pars);

            if (dt.Rows.Count == 0)
            {
                return(null);
            }
            var row = dt.Rows[0];
            //   foreach (DataRow row in dt.Rows)
            //   {
            var aTipoArbitro = new BE.TipoArbitro
            {
                Id          = Convert.ToInt32(row["Id"]),
                Descripcion = row["Descripcion"].ToString().Trim(),
                Deporte     = new BE.Deporte()
                {
                    Id = Convert.ToInt32(row["IdDeporte"])
                },
            };

            //ls.Add(aTipoArbitro);
            //}

            return(aTipoArbitro);
        }
        /// <summary>
        /// Assigns the primary Arbitro.
        /// </summary>
        /// <param name="partidos">The Partidoes.</param>
        /// <param name="arbitros">The Arbitros.</param>
        /// <param name="logicalArbitro">The logical Arbitro.</param>
        /// <param name="tipoArbitro"></param>
        public void AsignarArbitros(List <BE.Partido> partidos, List <BE.Arbitro> arbitros, BLL.Arbitro logicalArbitro, BE.TipoArbitro tipoArbitro)
        {
            //BLL.Partido logicalPartido = new BLL.Partido();
            foreach (BE.Partido partido in partidos)
            {
                foreach (BE.Arbitro arbitro in arbitros)
                {
                    Logger.Log.Info("Partido: " + partido.Equipo1.Nombre + " vs. " + partido.Equipo2.Nombre);
                    Logger.Log.Info("Arbitro: " + arbitro.Apellido + " " + arbitro.Nombre);
                    Logger.Log.Info("Tipo de Arbitro: " + tipoArbitro.Descripcion);
                    if (arbitro.Habilitado == true)
                    {
                        if (logicalArbitro.PuedeDirigir(arbitro, partido, tipoArbitro))
                        {
                            Logger.Log.Info("Resultado: Asignado.");
                            Logger.Log.Info("---------------------------------------");

                            //if (tipoArbitro.Descripcion == "Principal")
                            //{
                            //    partido.Principal = arbitro;
                            //}
                            //else
                            //{
                            //    partido.Asistente = arbitro;
                            //}

                            partido.ArbitrosYTipos.Add(arbitro, tipoArbitro);
                            ActualizarUltimosPartidosDirigidos(arbitro, partido);
                            ActualizarUltimosEquiposDirigidos(arbitro, partido);

                            ////Descomentar para que guarde la asignacion.
                            //logicalPartido.AddReferedPartido(Arbitro.IdArbitro, Partido.IdPartido, TipoArbitro.IdTipoArbitro);

                            arbitros.Remove(arbitro);
                            break;
                        }
                    }
                    else
                    {
                        Logger.Log.Info("Resultado: Estado de arbitro no disponible.");
                        Logger.Log.Info("---------------------------------------");
                    }
                }
            }
        }
Exemple #10
0
 public bool PuedeDirigirPartidoComoTipoArbitro(BE.Arbitro arbitro, BE.Partido partido, BE.TipoArbitro tipoDeArbitroAAsignar)
 {
     foreach (BE.NivelRegla aLevelRule in arbitro.Nivel.ReglasDeNivel)
     {
         if (partido.Equipo1.Categoria.Equals(aLevelRule.Categoria))
         {
             if (tipoDeArbitroAAsignar.Equals(aLevelRule.TipoArbitro))
             {
                 return(true);
             }
             else
             {
                 Logger.Log.Info("Resultado: Fallido Razon: Arbitro " + arbitro.Apellido + " no puede ser " + tipoDeArbitroAAsignar.Descripcion + " de este partido.");
                 Logger.Log.Info("Nivel del árbitro: " + arbitro.Nivel.NombreNivel + " - Categoría del partido: " + partido.Equipo1.Categoria.Descripcion);
                 Logger.Log.Info("---------------------------------------");
             }
         }
     }
     return(false);
 }
 /// <summary>
 /// Borra un TipoArbitro.
 /// </summary>
 /// <param name="pTipoArbitro">TipoArbitro.</param>
 /// <returns></returns>
 public ResultadoBd Borrar(BE.TipoArbitro pTipoArbitro)
 {
     return(_accesoBaseDeDatos.Borrar(pTipoArbitro));
 }
 /// <summary>
 /// Actualiza un TipoArbitro.
 /// </summary>
 /// <param name="pTipoArbitro">TipoArbitro.</param>
 /// <returns></returns>
 public ResultadoBd Actualizar(BE.TipoArbitro pTipoArbitro)
 {
     return(_accesoBaseDeDatos.Actualizar(pTipoArbitro));
 }
 /// <summary>
 /// Inserta un TipoArbitro.
 /// </summary>
 /// <param name="pTipoArbitro">TipoArbitro.</param>
 /// <returns></returns>
 public ResultadoBd Insertar(BE.TipoArbitro pTipoArbitro)
 {
     return(_accesoBaseDeDatos.Insertar(pTipoArbitro));
 }