Ejemplo n.º 1
0
        public IActionResult Index(int id)
        {
            var usuarioMuro = _dbContext.UsuarioMuro.SingleOrDefault(um =>
                                                                     um.IdDuenno == Int32.Parse(((ClaimsIdentity)User.Identity).FindFirst(ClaimTypes.NameIdentifier).Value) &&
                                                                     um.IdMuro == id);

            if (usuarioMuro == null)
            {
                throw new ExcepcionMuroAgil("No está autorizado para ver el detalle del muro seleccionado.");
            }

            Muro muro = _dbContext.Muro.Where(m => m.Id == id).FirstOrDefault();

            var listaEtapas = _dbContext.Etapa.Where(e => e.IdMuro == muro.Id).OrderBy(e => e.Posicion).ToList();

            foreach (var etapa in listaEtapas)
            {
                var listaTareas = _dbContext.Tarea.Where(t => t.IdEtapa == etapa.Id).OrderBy(t => t.Posicion).ToList();
                etapa.Tarea = listaTareas;
            }
            muro.Etapa = listaEtapas;

            usuarioMuro.IdMuroNavigation = muro;

            return(View("Index", usuarioMuro));
        }
Ejemplo n.º 2
0
        public async Task <ActionResult <Muro> > DeleteMuro(int id)
        {
            // Se valida que el usuario es el dueño del muro a eliminar...
            UsuarioMuro usuarioMuro = await _context.UsuarioMuro
                                      .SingleOrDefaultAsync(um =>
                                                            um.IdMuro == id &&
                                                            um.IdDuenno == Conectado.ID(this) &&
                                                            um.Permiso == 1
                                                            );

            if (usuarioMuro == null)
            {
                ModelState.AddModelError(
                    nameof(id),
                    "El muro ingresado no existe o no eres dueño de éste.");
                return(ValidationProblem());
            }

            // Se elimina el muro seleccionado...
            Muro muro = await _context.Muro.SingleOrDefaultAsync(m => m.Id == id);

            if (muro != null)
            {
                _context.Muro.Remove(muro);
                await _context.SaveChangesAsync();
            }

            return(Ok());
        }
Ejemplo n.º 3
0
        private void btnMuro_Click(object sender, EventArgs e)
        {
            Muro muro = new Muro();

            Aldea aldea = Aldea.GetInstancia();

            MessageBox.Show("Ha creado un edificio defensivo 'Muro'");
        }
Ejemplo n.º 4
0
    //en caso de no poder moverse, comprueba que es unmuro y en su caso, el muro pierde durabilidad
    protected override void NoPuedeMover(GameObject go)
    {
        Muro muro = go.GetComponent <Muro>();

        if (muro != null)
        {
            muro.DañoMuro(dañoMuro);
            anim.SetTrigger("playerAttack");
        }
    }
Ejemplo n.º 5
0
        public void Login()
        {
            IniciaSesion login = new IniciaSesion(_driver);

            login.IngresarCorreoElectronico("");
            login.IngresarPassword("");
            login.IniciarSesion();
            var muro = new Muro(_driver);

            Assert.Equal("Benjamin Camacho", muro.GetNombre());
        }
Ejemplo n.º 6
0
 void RevisaMuros(Vector2 puntoInicio, List <BoxCollider2D> grupo, Vector2 dirAvanzaMuro, int ejeMov, int signoEje, System.Func <BoxCollider2D, float> fBoundMin, System.Func <BoxCollider2D, float> fBoundMax)
 {
     if (grupo.Count == 0)
     {
         muros.Add(new Muro(puntoInicio, puntoInicio + dirAvanzaMuro * BoxCol.size[ejeMov], transform.worldToLocalMatrix, true));
     }
     else
     {
         grupo.Sort((a, b) => signoEje * fBoundMin(a).CompareTo(fBoundMin(b)));
         // var pri = grupo[0];
         // if (fBoundMin(pri) * signoEje <= puntoInicio[ejeMov] * signoEje) puntoInicio[ejeMov] = fBoundMax(pri);
         foreach (var col in grupo)
         {
             if (puntoInicio[ejeMov] * signoEje < fBoundMin(col) * signoEje)
             {
                 float off     = fBoundMin(col) * signoEje - puntoInicio[ejeMov] * signoEje;
                 var   niuMuro = new Muro(puntoInicio, puntoInicio + dirAvanzaMuro * off, transform.worldToLocalMatrix);
                 niuMuro.discriminable = off < Physics2D.defaultContactOffset * 2f;
                 muros.Add(niuMuro);
                 puntoInicio[ejeMov] = fBoundMax(col);
             }
             else
             {//significa que el punto de inicio esta "adentro" del collider, y lo tengo que mover hasta afuera de este al menos
                 var niuPos = fBoundMax(col);
                 //pero nos tenemos que asegurar de no volver hacia atras
                 if (puntoInicio[ejeMov] * signoEje < niuPos * signoEje)
                 {
                     puntoInicio[ejeMov] = niuPos;
                 }
             }
         }
         if (puntoInicio[ejeMov] * signoEje < fBoundMax(BoxCol) * signoEje)
         {//por ahi nos quedamos sin colliders, pero aun nos falta poner muro del otro lado
             float off = fBoundMax(BoxCol) * signoEje - puntoInicio[ejeMov] * signoEje;
             muros.Add(new Muro(puntoInicio, puntoInicio + dirAvanzaMuro * off, transform.worldToLocalMatrix));
             puntoInicio[ejeMov] += off;
         }
     }
 }
Ejemplo n.º 7
0
        public async Task <IActionResult> PutMuro(EntMuroIdEtapaId entradaMuro)
        {
            //Se valida que el usuario es el dueño del muro a modificar...
            UsuarioMuro usuarioMuro = await _context.UsuarioMuro.SingleOrDefaultAsync(um =>
                                                                                      um.IdDuenno == Conectado.ID(this) &&
                                                                                      um.IdMuro == entradaMuro.Id &&
                                                                                      um.Permiso == 1);

            if (usuarioMuro == null)
            {
                ModelState.AddModelError(
                    nameof(entradaMuro.Id),
                    "El muro ingresado no existe o no eres dueño de éste.");
                return(ValidationProblem());
            }

            Muro muro = await _context.Muro.SingleOrDefaultAsync(m => m.Id == entradaMuro.Id);

            if (muro == null)
            {
                ModelState.AddModelError(
                    nameof(entradaMuro.Id),
                    "El muro ingresado no existe o no eres dueño de éste.");
                return(ValidationProblem());
            }

            muro.Nombre = entradaMuro.Nombre;
            muro.FechaUltimaModificacion = DateTime.Now;

            // Se modifican las etapas existentes, y se marcan las etapas a eliminar...
            List <Etapa> etapasEliminadas = new List <Etapa>();
            List <Etapa> etapas           = await _context.Etapa
                                            .Where(e => e.IdMuro == muro.Id)
                                            .OrderBy(e => e.Posicion)
                                            .ToListAsync();

            foreach (Etapa etapa in etapas)
            {
                bool clienteLoElimino = true;
                foreach (EntEtapaId etapaCliente in entradaMuro.Etapas)
                {
                    if (etapa.Id == etapaCliente.Id)
                    {
                        etapa.Nombre     = etapaCliente.Nombre;
                        etapa.Posicion   = etapaCliente.Posicion;
                        clienteLoElimino = false;
                        break;
                    }
                }

                if (clienteLoElimino)
                {
                    etapasEliminadas.Add(etapa);
                }
            }

            // Se agregan las etapas nuevas al muro...
            foreach (EntEtapaId etapaCliente in entradaMuro.Etapas)
            {
                if (etapaCliente.Id == 0)
                {
                    Etapa etapa = new Etapa()
                    {
                        IdMuro   = muro.Id,
                        Nombre   = etapaCliente.Nombre,
                        Posicion = etapaCliente.Posicion
                    };

                    await _context.Etapa.AddAsync(etapa);
                }
            }

            await _context.SaveChangesAsync();

            // Se cambian las tareas de etapas eliminadas, a las etapas que corresponden...
            if (entradaMuro.Accion != 3)
            {
                Etapa etapaDestino = null;
                if (entradaMuro.Accion == 1)
                {
                    etapas = await _context.Etapa
                             .Where(e => e.IdMuro == muro.Id)
                             .OrderBy(e => e.Posicion)
                             .ToListAsync();
                }
                else
                {
                    etapas = await _context.Etapa
                             .Where(e => e.IdMuro == muro.Id)
                             .OrderByDescending(e => e.Posicion)
                             .ToListAsync();
                }

                foreach (Etapa etapa in etapas)
                {
                    bool seraEliminada = false;
                    foreach (Etapa etapaEliminada in etapasEliminadas)
                    {
                        if (etapa.Id == etapaEliminada.Id)
                        {
                            seraEliminada = true;
                            break;
                        }
                    }

                    if (!seraEliminada)
                    {
                        etapaDestino = etapa;
                        break;
                    }
                }

                if (etapaDestino != null)
                {
                    Tarea ultTarea = await _context.Tarea
                                     .Where(t => t.IdEtapa == etapaDestino.Id)
                                     .OrderByDescending(t => t.Posicion)
                                     .FirstOrDefaultAsync();

                    List <Tarea> tareasMover = new List <Tarea>();
                    foreach (Etapa etapaEliminada in etapasEliminadas)
                    {
                        tareasMover.AddRange(await _context.Tarea
                                             .Where(t => t.IdEtapa == etapaEliminada.Id)
                                             .OrderBy(t => t.Posicion)
                                             .ToListAsync());
                    }

                    short pos = 0;
                    if (ultTarea != null)
                    {
                        pos = ultTarea.Posicion;
                    }

                    foreach (Tarea tareaMover in tareasMover)
                    {
                        pos++;
                        tareaMover.IdEtapa  = etapaDestino.Id;
                        tareaMover.Posicion = pos;
                    }

                    await _context.SaveChangesAsync();
                }
            }

            _context.Etapa.RemoveRange(etapasEliminadas);
            await _context.SaveChangesAsync();

            return(Ok());
        }
Ejemplo n.º 8
0
        public async Task <ActionResult <SalMuroConEtapas> > PostMuros(EntMuroEtapa entradaMuro)
        {
            // Se crea el nuevo muro...
            Muro muro = new Muro()
            {
                Nombre                  = entradaMuro.Nombre,
                FechaCreacion           = DateTime.Now,
                FechaUltimaModificacion = DateTime.Now
            };
            await _context.Muro.AddAsync(muro);

            await _context.SaveChangesAsync();

            // Se crea la relación usuario/muro...
            UsuarioMuro usuarioMuro = new UsuarioMuro()
            {
                IdDuenno = Conectado.ID(this),
                IdMuro   = muro.Id,
                Permiso  = 1
            };
            await _context.UsuarioMuro.AddAsync(usuarioMuro);

            // Se crean las etapas del muro...
            List <Etapa> etapasCreadas = new List <Etapa>();

            foreach (EntEtapaBase entEtapa in entradaMuro.Etapas)
            {
                Etapa etapa = new Etapa()
                {
                    IdMuro   = muro.Id,
                    Nombre   = entEtapa.Nombre,
                    Posicion = entEtapa.Posicion
                };

                await _context.Etapa.AddAsync(etapa);

                etapasCreadas.Add(etapa);
            }

            await _context.SaveChangesAsync();

            SalMuroConEtapas salida = new SalMuroConEtapas()
            {
                IdMuro                  = muro.Id,
                NombreMuro              = muro.Nombre,
                FechaCreacion           = muro.FechaCreacion.ToString("yyyyMMddHHmmss"),
                FechaUltimaModificacion = muro.FechaUltimaModificacion.ToString("yyyyMMddHHmmss"),
                Permiso                 = usuarioMuro.Permiso
            };

            foreach (Etapa etapaCreada in etapasCreadas)
            {
                SalEtapaBase salidaEtapa = new SalEtapaBase()
                {
                    Id       = etapaCreada.Id,
                    Nombre   = etapaCreada.Nombre,
                    Posicion = etapaCreada.Posicion
                };
                salida.Etapas.Add(salidaEtapa);
            }

            return(salida);
        }
Ejemplo n.º 9
0
        public async Task <ActionResult <SalMuroConTareas> > ModificarTareas(EntMuroSoloId entradaMuro)
        {
            // Se valida que el usuario tenga permisos de edición en el muro...
            UsuarioMuro usuarioMuro = await _context.UsuarioMuro
                                      .Include(um => um.IdMuroNavigation)
                                      .SingleOrDefaultAsync(um =>
                                                            um.IdMuro == entradaMuro.Id &&
                                                            um.IdDuenno == Conectado.ID(this) &&
                                                            (um.Permiso == 1 ||
                                                             um.Permiso == 2)
                                                            );

            if (usuarioMuro == null)
            {
                ModelState.AddModelError(
                    nameof(entradaMuro.Id),
                    "El muro ingresado no existe o no tienes permisos sobre éste.");
                return(ValidationProblem());
            }

            // Se valida que todas las etapas sean parte del muro a editar...
            foreach (EntEtapaSoloId entradaEtapa in entradaMuro.Etapas)
            {
                Etapa etapa = await _context.Etapa
                              .SingleOrDefaultAsync(e =>
                                                    e.Id == entradaEtapa.Id &&
                                                    e.IdMuro == entradaMuro.Id
                                                    );

                if (etapa == null)
                {
                    ModelState.AddModelError(
                        nameof(entradaEtapa.Id),
                        "Una de las etapas ingresadas no pertenece al muro...");
                    return(ValidationProblem());
                }
            }

            // Se eliminan las tareas que no son recibidas desde el cliente...
            List <Tarea> tareasExistentes = await _context.Tarea
                                            .Include(t => t.IdEtapaNavigation)
                                            .Where(t => t.IdEtapaNavigation.IdMuro == entradaMuro.Id)
                                            .ToListAsync();

            foreach (Tarea tareaExistente in tareasExistentes)
            {
                bool existeTarea = false;

                foreach (EntEtapaSoloId entradaEtapa in entradaMuro.Etapas)
                {
                    foreach (EntTareaBase entradaTarea in entradaEtapa.Tareas)
                    {
                        if (tareaExistente.Id == entradaTarea.Id)
                        {
                            existeTarea = true;
                            break;
                        }
                    }
                    if (existeTarea)
                    {
                        break;
                    }
                    ;
                }

                if (!existeTarea)
                {
                    _context.Tarea.Remove(tareaExistente);
                }
            }

            // Se agregan o modifican el resto de tareas...
            foreach (EntEtapaSoloId entradaEtapa in entradaMuro.Etapas)
            {
                foreach (EntTareaBase entradaTarea in entradaEtapa.Tareas)
                {
                    Tarea tareaOriginal = await _context.Tarea
                                          .Include(t => t.IdEtapaNavigation)
                                          .SingleOrDefaultAsync(t =>
                                                                t.Id == entradaTarea.Id &&
                                                                t.IdEtapaNavigation.IdMuro == entradaMuro.Id
                                                                );

                    if (tareaOriginal == null)
                    {
                        // Se agregan las tareas que no existen en la base de datos...
                        Tarea nuevaTarea = new Tarea()
                        {
                            Titulo      = entradaTarea.Titulo,
                            Descripcion = entradaTarea.Descripcion,
                            IdEtapa     = entradaEtapa.Id,
                            Posicion    = entradaTarea.Posicion,
                            Familia     = entradaTarea.Familia,
                            Red         = entradaTarea.Red,
                            Green       = entradaTarea.Green,
                            Blue        = entradaTarea.Blue
                        };
                        _context.Tarea.Add(nuevaTarea);
                    }
                    else
                    {
                        tareaOriginal.Titulo      = entradaTarea.Titulo;
                        tareaOriginal.Descripcion = entradaTarea.Descripcion;
                        tareaOriginal.IdEtapa     = entradaEtapa.Id;
                        tareaOriginal.Posicion    = entradaTarea.Posicion;
                        tareaOriginal.Familia     = entradaTarea.Familia;
                        tareaOriginal.Red         = entradaTarea.Red;
                        tareaOriginal.Green       = entradaTarea.Green;
                        tareaOriginal.Blue        = entradaTarea.Blue;
                        _context.Tarea.Update(tareaOriginal);
                    }
                }
            }

            // Se modifica la fecha de última actualización...
            Muro muro = await _context.Muro.SingleOrDefaultAsync(m => m.Id == entradaMuro.Id);

            muro.FechaUltimaModificacion = DateTime.Now;
            await _context.SaveChangesAsync();

            return(await ObtenerTareas(entradaMuro.Id));
        }
Ejemplo n.º 10
0
        public void Grabar(string nombre)
        {
            if (nombre == null || nombre.Trim().Equals(""))
            {
                Response.StatusCode = 500;
                return;
            }

            var muro = new Muro()
            {
                Nombre                  = nombre,
                FechaCreacion           = DateTime.Now,
                FechaUltimaModificacion = DateTime.Now
            };

            _dbContext.Muro.Add(muro);
            _dbContext.SaveChanges();

            var usuarioMuro = new UsuarioMuro()
            {
                IdDuenno = Int32.Parse(((ClaimsIdentity)User.Identity).FindFirst(ClaimTypes.NameIdentifier).Value),
                IdMuro   = muro.Id,
                Permiso  = 1
            };

            _dbContext.UsuarioMuro.Add(usuarioMuro);

            _dbContext.Etapa.Add(new Etapa()
            {
                Nombre   = "HISTORIA",
                IdMuro   = muro.Id,
                Posicion = 1
            });
            _dbContext.Etapa.Add(new Etapa()
            {
                Nombre   = "PENDIENTE",
                IdMuro   = muro.Id,
                Posicion = 2
            });
            _dbContext.Etapa.Add(new Etapa()
            {
                Nombre   = "EN CONSTRUCCIÓN",
                IdMuro   = muro.Id,
                Posicion = 3
            });
            _dbContext.Etapa.Add(new Etapa()
            {
                Nombre   = "COMPLETADO",
                IdMuro   = muro.Id,
                Posicion = 4
            });
            _dbContext.Etapa.Add(new Etapa()
            {
                Nombre   = "PRUEBA",
                IdMuro   = muro.Id,
                Posicion = 5
            });

            _dbContext.SaveChanges();
            Response.StatusCode = 200;
        }
Ejemplo n.º 11
0
        public async Task <ActionResult> ObtenerInfoActualizada(int idMuro)
        {
            UsuarioMuro usuarioMuro = await _dbContext.UsuarioMuro
                                      .SingleOrDefaultAsync(um =>
                                                            um.IdDuenno == Int32.Parse(((ClaimsIdentity)User.Identity).FindFirst(ClaimTypes.NameIdentifier).Value) &&
                                                            um.IdMuro == idMuro);

            if (usuarioMuro == null)
            {
                return(StatusCode(401));
            }

            Muro muro = await _dbContext.Muro
                        .SingleOrDefaultAsync(m =>
                                              m.Id == idMuro);

            JSONMuro jsonMuro = new JSONMuro {
                Id                      = muro.Id,
                Nombre                  = WebUtility.HtmlEncode(muro.Nombre),
                FechaCreacion           = muro.FechaCreacion.ToString("yyyyMMddHHmmss"),
                FechaUltimaModificacion = muro.FechaUltimaModificacion.ToString("yyyyMMddHHmmss"),
                Permiso                 = usuarioMuro.Permiso,
                Etapas                  = new List <JSONEtapa>()
            };

            List <Etapa> listaEtapas = await _dbContext.Etapa
                                       .Where(e => e.IdMuro == muro.Id)
                                       .OrderBy(e => e.Posicion)
                                       .ToListAsync();

            foreach (Etapa etapa in listaEtapas)
            {
                jsonMuro.Etapas.Add(new JSONEtapa {
                    Id       = etapa.Id,
                    Nombre   = WebUtility.HtmlEncode(etapa.Nombre),
                    Posicion = etapa.Posicion,
                    Tareas   = new List <JSONTarea>()
                });

                List <Tarea> listaTareas = await _dbContext.Tarea
                                           .Where(t => t.IdEtapa == etapa.Id)
                                           .OrderBy(t => t.Posicion)
                                           .ToListAsync();

                foreach (Tarea tarea in listaTareas)
                {
                    jsonMuro.Etapas.LastOrDefault().Tareas.Add(new JSONTarea {
                        Id          = tarea.Id,
                        Titulo      = WebUtility.HtmlEncode(tarea.Titulo),
                        Descripcion = WebUtility.HtmlEncode(tarea.Descripcion),
                        Posicion    = tarea.Posicion,
                        Familia     = tarea.Familia,
                        Red         = tarea.Red,
                        Green       = tarea.Green,
                        Blue        = tarea.Blue
                    });
                }
            }

            return(StatusCode(200, Json(jsonMuro)));
        }
Ejemplo n.º 12
0
        public async Task <IActionResult> EditarMuro(EditarMuroViewModel model)
        {
            if (!ModelState.IsValid)
            {
                throw new ExcepcionMuroAgil(ModelState.Values
                                            .SelectMany(v => v.Errors)
                                            .Select(e => e.ErrorMessage)
                                            .First());
            }

            // Se crea el muro, o se modifica si ya existe.
            Muro muro = null;

            if (model.Id == 0)
            {
                muro = new Muro()
                {
                    Nombre                  = model.Nombre,
                    FechaCreacion           = DateTime.Now,
                    FechaUltimaModificacion = DateTime.Now
                };

                await _dbContext.Muro.AddAsync(muro);

                await _dbContext.SaveChangesAsync();

                UsuarioMuro usuarioMuro = new UsuarioMuro()
                {
                    IdDuenno = int.Parse(((ClaimsIdentity)User.Identity).FindFirst(ClaimTypes.NameIdentifier).Value),
                    IdMuro   = muro.Id,
                    Permiso  = 1
                };

                await _dbContext.UsuarioMuro.AddAsync(usuarioMuro);
            }
            else
            {
                UsuarioMuro usuarioMuro = await _dbContext.UsuarioMuro.SingleOrDefaultAsync(um =>
                                                                                            um.IdDuenno == int.Parse(((ClaimsIdentity)User.Identity).FindFirst(ClaimTypes.NameIdentifier).Value) &&
                                                                                            um.IdMuro == model.Id &&
                                                                                            um.Permiso == 1);

                if (usuarioMuro == null)
                {
                    throw new ExcepcionMuroAgil("No está autorizado para modificar el muro seleccionado.");
                }

                muro = await _dbContext.Muro.SingleOrDefaultAsync(m => m.Id == model.Id);

                if (muro == null)
                {
                    throw new ExcepcionMuroAgil("No se encontró el muro que está intentando modificar.");
                }

                muro.Nombre = model.Nombre;
                muro.FechaUltimaModificacion = DateTime.Now;

                await _dbContext.SaveChangesAsync();
            }

            // Se modifican las etapas existentes, y se marcan las etapas a eliminar
            List <Etapa> etapasEliminadas = new List <Etapa>();
            List <Etapa> etapas           = await _dbContext.Etapa
                                            .Where(e => e.IdMuro == muro.Id)
                                            .OrderBy(e => e.Posicion)
                                            .ToListAsync();

            foreach (Etapa etapa in etapas)
            {
                bool clienteLoElimino = true;
                foreach (EditarMuroViewModel.Etapa etapaCliente in model.Etapas)
                {
                    if (etapa.Id == etapaCliente.Id)
                    {
                        etapa.Nombre     = etapaCliente.Nombre;
                        etapa.Posicion   = etapaCliente.Posicion;
                        clienteLoElimino = false;
                        break;
                    }
                }

                if (clienteLoElimino)
                {
                    etapasEliminadas.Add(etapa);
                }
                else
                {
                    //_dbContext.Etapa.Update(etapa);
                }
            }

            // Se agregan las etapas nuevas al muro
            foreach (EditarMuroViewModel.Etapa etapaCliente in model.Etapas)
            {
                if (etapaCliente.Id == 0)
                {
                    Etapa etapa = new Etapa()
                    {
                        IdMuro   = muro.Id,
                        Nombre   = etapaCliente.Nombre,
                        Posicion = etapaCliente.Posicion
                    };

                    await _dbContext.Etapa.AddAsync(etapa);
                }
            }
            await _dbContext.SaveChangesAsync();

            if (model.AccionTareas != 3)
            {
                // Se determina la etapa de destino para las tareas que no se quieren eliminar
                Etapa etapaDestino = null;

                if (model.AccionTareas == 1)
                {
                    etapas = await _dbContext.Etapa
                             .Where(e => e.IdMuro == muro.Id)
                             .OrderBy(e => e.Posicion)
                             .ToListAsync();
                }
                else
                {
                    etapas = await _dbContext.Etapa
                             .Where(e => e.IdMuro == muro.Id)
                             .OrderByDescending(e => e.Posicion)
                             .ToListAsync();
                }

                foreach (Etapa etapa in etapas)
                {
                    bool seraEliminada = false;
                    foreach (Etapa etapaEliminada in etapasEliminadas)
                    {
                        if (etapa.Id == etapaEliminada.Id)
                        {
                            seraEliminada = true;
                            break;
                        }
                    }

                    if (!seraEliminada)
                    {
                        etapaDestino = etapa;
                        break;
                    }
                }

                if (etapaDestino != null)
                {
                    Tarea ultTarea = await _dbContext.Tarea
                                     .Where(t => t.IdEtapa == etapaDestino.Id)
                                     .OrderByDescending(t => t.Posicion)
                                     .FirstOrDefaultAsync();

                    List <Tarea> tareasMover = new List <Tarea>();
                    foreach (Etapa etapaEliminada in etapasEliminadas)
                    {
                        tareasMover.AddRange(await _dbContext.Tarea
                                             .Where(t => t.IdEtapa == etapaEliminada.Id)
                                             .OrderBy(t => t.Posicion)
                                             .ToListAsync());
                    }

                    short pos = 0;
                    if (ultTarea != null)
                    {
                        pos = ultTarea.Posicion;
                    }

                    foreach (Tarea tareaMover in tareasMover)
                    {
                        pos++;
                        tareaMover.IdEtapa  = etapaDestino.Id;
                        tareaMover.Posicion = pos;
                        //_dbContext.Tarea.Update(tareaMover);
                    }
                    await _dbContext.SaveChangesAsync();
                }
            }

            _dbContext.Etapa.RemoveRange(etapasEliminadas);
            await _dbContext.SaveChangesAsync();

            return(Redirect("/UsuarioMuro/"));
        }
Ejemplo n.º 13
0
        public async Task <IActionResult> EditarMuro(int id = 0)
        {
            EditarMuroViewModel model = new EditarMuroViewModel();

            if (id != 0)
            {
                var usuarioMuro = await _dbContext.UsuarioMuro.SingleOrDefaultAsync(um =>
                                                                                    um.IdDuenno == Int32.Parse(((ClaimsIdentity)User.Identity).FindFirst(ClaimTypes.NameIdentifier).Value) &&
                                                                                    um.IdMuro == id &&
                                                                                    um.Permiso == 1);

                if (usuarioMuro == null)
                {
                    throw new ExcepcionMuroAgil("No está autorizado para editar el muro seleccionado.");
                }

                Muro muro = await _dbContext.Muro
                            .SingleOrDefaultAsync(m => m.Id == id);

                if (muro == null)
                {
                    throw new ExcepcionMuroAgil("No existe el muro seleccionado.");
                }

                model.Id     = muro.Id;
                model.Nombre = muro.Nombre;

                ICollection <Etapa> etapas = null;
                etapas = await _dbContext.Etapa
                         .Where(e => e.IdMuro == muro.Id)
                         .OrderBy(e => e.Posicion)
                         .ToListAsync();

                model.Etapas = new List <EditarMuroViewModel.Etapa>();
                if (etapas != null)
                {
                    foreach (var etapa in etapas)
                    {
                        EditarMuroViewModel.Etapa viewModelEtapa = new EditarMuroViewModel.Etapa();

                        viewModelEtapa.Id       = etapa.Id;
                        viewModelEtapa.Nombre   = etapa.Nombre;
                        viewModelEtapa.Posicion = etapa.Posicion;

                        model.Etapas.Add(viewModelEtapa);
                    }
                }
            }
            else
            {
                model.Id     = 0;
                model.Nombre = "";

                UsuarioMuro usuarioMuro = await _dbContext.UsuarioMuro
                                          .Include(um => um.IdMuroNavigation)
                                          .Where(um => um.IdDuenno == Int32.Parse(((ClaimsIdentity)User.Identity).FindFirst(ClaimTypes.NameIdentifier).Value) && um.Permiso == 1)
                                          .OrderByDescending(um => um.IdMuroNavigation.FechaCreacion)
                                          .FirstOrDefaultAsync();

                ICollection <Etapa> etapas = null;
                if (usuarioMuro != null)
                {
                    etapas = await _dbContext.Etapa
                             .Where(e => e.IdMuro == usuarioMuro.IdMuro)
                             .OrderBy(e => e.Posicion)
                             .ToListAsync();
                }
                else
                {
                    etapas = new List <Etapa>();
                    etapas.Add(new Etapa()
                    {
                        Nombre   = "Pendiente",
                        Posicion = 1
                    });
                    etapas.Add(new Etapa()
                    {
                        Nombre   = "En Proceso",
                        Posicion = 2
                    });
                    etapas.Add(new Etapa()
                    {
                        Nombre   = "Terminado",
                        Posicion = 3
                    });
                }

                model.Etapas = new List <EditarMuroViewModel.Etapa>();
                if (etapas != null)
                {
                    foreach (var etapa in etapas)
                    {
                        EditarMuroViewModel.Etapa viewModelEtapa = new EditarMuroViewModel.Etapa();

                        viewModelEtapa.Id       = 0;
                        viewModelEtapa.Nombre   = etapa.Nombre;
                        viewModelEtapa.Posicion = etapa.Posicion;

                        model.Etapas.Add(viewModelEtapa);
                    }
                }
            }

            return(View(model));
        }