Exemplo n.º 1
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/"));
        }
Exemplo n.º 2
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));
        }