private bool Cancelar(MovimientoTemp mov, bool Executar)
        {
            db = new RecordFCSContext();

            bool bandera = false;

            DateTime Fecha = DateTime.Now;
            mov.FechaUltimaEjecucion = Fecha;

            string Motivo = "Cancelar movimiento.";

            try
            {
                bandera = true;

                //Validar que el movimiento se pueda cancelar, comprobando las piezas en estado SeMovio sean las ultimas en su mov
                #region Validacion 3: En ultimo movimiento

                int totalMovidas = mov.MovimientoTempPiezas.Where(a => a.SeMovio).Count();
                int totalMovidasSonUltimas = 0;

                foreach (var piezaEnMovReal in mov.MovimientoTempPiezas.Where(a => a.SeMovio && a.Pieza.UbicacionID == mov.UbicacionDestinoID).ToList())
                    if ((piezaEnMovReal.Pieza.MovimientoTempPiezas.Where(a => a.Orden > piezaEnMovReal.Orden && !a.EnError).Count() > 0))
                        totalMovidasSonUltimas = 0;
                    else
                        totalMovidasSonUltimas++;

                if (totalMovidas != totalMovidasSonUltimas)
                    throw new Exception("No se pueden cancelar las piezas");

                #endregion

                //Revertir todas las piezas
                foreach (var PiezaIDDel in mov.MovimientoTempPiezas.Select(a => a.PiezaID).ToList())
                {
                    bandera = false;
                    //la pieza en el movimiento
                    var item = db.MovimientoTempPiezas.FirstOrDefault(a => a.PiezaID == PiezaIDDel && a.MovimientoTempID == mov.MovimientoTempID);

                    bool RegresarHistorial = false;

                    //saber si es eliminable y si se puede regresar el estado
                    if (item != null)
                    {
                        if (item.SeMovio)
                        {
                            bool esUltimo = item.Pieza.MovimientoTempPiezas.Where(a => a.Orden > item.Orden && !a.EnError).Count() > 0 ? false : true;
                            bool conPendientes = item.Pieza.MovimientoTempPiezas.Where(a => a.EsPendiente && a.MovimientoTempID != mov.MovimientoTempID && !a.EnError).Count() > 0 ? true : false;

                            if (esUltimo)
                                RegresarHistorial = true;
                        }
                        else
                        {
                            RegresarHistorial = true;
                        }
                    }

                    if (RegresarHistorial)
                    {
                        //Regresar la ubicacion original
                        if (item.SeMovio)
                        {
                            var pieza = db.Piezas.Find(PiezaIDDel);

                            RegresarHistorial = false;

                            if (pieza != null)
                            {
                                if (pieza.UbicacionID == mov.UbicacionDestinoID)
                                {
                                    pieza.UbicacionID = mov.UbicacionOrigenID;

                                    //------ Logica HISTORIAL

                                    #region Generar el historial

                                    //objeto del formulario
                                    var objetoDelUbi = pieza;
                                    //Objeto de la base de datos
                                    var objetoDBDelUbi = db.Piezas.Find(pieza.PiezaID);
                                    //tabla o clase a la que pertenece
                                    var tablaNombreDelUbi = "Pieza";
                                    //llave primaria del objeto
                                    var llavePrimariaDelUbi = objetoDBDelUbi.PiezaID.ToString();

                                    //generar el historial
                                    var historialLogDelUbi = HistorialLogica.EditarEntidad(
                                        objetoDelUbi,
                                        objetoDBDelUbi,
                                        tablaNombreDelUbi,
                                        llavePrimariaDelUbi,
                                        User.UsuarioID,
                                        db,
                                        "Cancelar Movimiento: " + mov.Folio,
                                        mov.FechaUltimaEjecucion
                                        );

                                    #endregion

                                    #region Guardar el historial

                                    if (historialLogDelUbi != null)
                                    {
                                        //Cambiar el estado a la entidad a modificada
                                        db.Entry(objetoDBDelUbi).State = EntityState.Modified;
                                        //Guardamos la entidad modificada
                                        db.SaveChanges();

                                        //Guardar el historial
                                        db.HistorialLogs.Add(historialLogDelUbi);
                                        db.SaveChanges();

                                        RegresarHistorial = true;
                                    }

                                    #endregion

                                    //------

                                }

                            }

                        }

                        if (RegresarHistorial)
                        {

                            item.SeMovio = false;
                            item.EsPendiente = true;
                            item.EnError = true;
                            item.Comentario = "Validar de nuevo [Movimiento Cancelado].";

                            //------ Logica HISTORIAL

                            #region Generar el historial

                            //objeto del formulario
                            var objetoEdit = item;
                            //Objeto de la base de datos
                            var objetoDBEdit = db.MovimientoTempPiezas.Find(item.MovimientoTempID, item.PiezaID);
                            //tabla o clase a la que pertenece
                            var tablaNombreEdit = "MovimientoTempPieza";
                            //llave primaria del objeto
                            var llavePrimariaEdit = objetoDBEdit.MovimientoTempID + "," + objetoDBEdit.PiezaID;

                            //generar el historial
                            var historialLogEdit = HistorialLogica.EditarEntidad(
                                objetoEdit,
                                objetoDBEdit,
                                tablaNombreEdit,
                                llavePrimariaEdit,
                                User.UsuarioID,
                                db,
                                Motivo,
                                Fecha
                                );

                            #endregion

                            #region Guardar el historial

                            if (historialLogEdit != null)
                            {
                                //Cambiar el estado a la entidad a modificada
                                db.Entry(objetoDBEdit).State = EntityState.Modified;
                                //Guardamos la entidad modificada
                                db.SaveChanges();

                                //Guardar el historial
                                db.HistorialLogs.Add(historialLogEdit);
                                db.SaveChanges();

                                bandera = true;
                            }
                            else
                            {
                                bandera = true;
                            }

                            #endregion

                            //------

                        }

                    }

                }

                if (bandera)
                {
                    //Como todas las piezas que tenia se revertieron
                    //Regresar el Estatus

                    mov.EstadoMovimiento = EstadoMovimientoTemp.Cancelado;

                    //------ Logica HISTORIAL

                    #region Generar el historial

                    //objeto del formulario
                    var objeto3 = mov;
                    //Objeto de la base de datos
                    var objetoDB3 = db.MovimientosTemp.Find(mov.MovimientoTempID);
                    //tabla o clase a la que pertenece
                    var tablaNombre3 = "MovimientoTemp";
                    //llave primaria del objeto
                    var llavePrimaria3 = objetoDB3.MovimientoTempID.ToString();

                    //generar el historial
                    var historialLog3 = HistorialLogica.EditarEntidad(
                        objeto3,
                        objetoDB3,
                        tablaNombre3,
                        llavePrimaria3,
                        User.UsuarioID,
                        db,
                        Motivo,
                        Fecha
                        );

                    #endregion

                    #region Guardar el historial

                    if (historialLog3 != null)
                    {
                        //Cambiar el estado a la entidad a modificada
                        db.Entry(objetoDB3).State = EntityState.Modified;
                        //Guardamos la entidad modificada
                        db.SaveChanges();

                        //Guardar el historial
                        db.HistorialLogs.Add(historialLog3);
                        db.SaveChanges();
                    }
                    else
                    {
                        throw new Exception();
                    }
                    #endregion

                    //------

                }
            }
            catch (Exception)
            {
                bandera = false;
            }

            if (bandera)
                AlertaDefault("Se Cancelo el moviento");
            else
                AlertaDefault("No se pudo cancelar el movimiento");

            return bandera;
        }
        public ActionResult Crear(Guid? TipoMovimientoID, bool TieneExposicion)
        {
            db = new RecordFCSContext();

            var tipoMov = db.TipoMovimientos.Find(TipoMovimientoID);

            if (tipoMov == null) return HttpNotFound();

            var mov = new MovimientoTemp()
            {
                TieneExposicion = TieneExposicion,
                TipoMovimientoID = tipoMov.TipoMovimientoID,
                TipoMovimiento = tipoMov,
                EstadoMovimiento = EstadoMovimientoTemp.Procesando,
                EsValido = false
                //Folio = db.MovimientosTemp.Select(a => a.Folio).OrderBy(a => a).SingleOrDefault() + 1

            };

            mov.Folio = db.MovimientosTemp.Select(a => a.Folio).OrderByDescending(a => a).FirstOrDefault() + 1;

            var listaUbicaciones = db.Ubicaciones.Where(a => a.Status).Select(a => new { a.Nombre, a.UbicacionID }).OrderBy(a => a.Nombre);

            ViewBag.UbicacionDestinoID = new SelectList(listaUbicaciones, "UbicacionID", "Nombre");
            ViewBag.UbicacionOrigenID = new SelectList(listaUbicaciones, "UbicacionID", "Nombre");

            return View(mov);
        }
        public ActionResult IndexMovimiento(string id)
        {
            var db = new RecordFCSContext();
            db.Configuration.LazyLoadingEnabled = false;

            string tabla = "MovimientoTemp";

            var lista = db.HistorialLogs.Where(a => a.LlavePrimaria == id && a.TablaNombre == tabla).OrderByDescending(a => a.EventoFecha).ToList();

            return PartialView("_IndexMovimiento", lista);
        }
        public ActionResult CancelarMovimientoConfirmado(Guid MovimientoTempID, bool Executar)
        {
            db = new RecordFCSContext();

            bool bandera = false;

            if (Executar)
            {
                //Buscar el movimiento

                MovimientoTemp mov = db.MovimientosTemp.Find(MovimientoTempID);

                if (mov != null)
                {
                    bandera = Cancelar(mov, Executar);
                }

            }

            var url = Url.Action("Detalles", "MovimientoTemp", new { id = MovimientoTempID });

            return Json(new { success = bandera, url = url });
        }
        public ActionResult Editar(Guid? id, bool EnExpo = false)
        {
            db = new RecordFCSContext();

            if (id == null) return new HttpStatusCodeResult(HttpStatusCode.BadRequest);

            MovimientoTemp mov = db.MovimientosTemp.Find(id);

            if (mov == null) return HttpNotFound();

            if (!mov.TieneExposicion && EnExpo)
                mov.TieneExposicion = EnExpo;

            var listaUbicaciones = db.Ubicaciones.Where(a => a.Status).Select(a => new { a.Nombre, a.UbicacionID }).OrderBy(a => a.Nombre);

            //Ubicacion destino no puede editarse si se encuentra por lo menos una Pieza Procesada
            ViewBag.UbiDestinoEnabled = mov.MovimientoTempPiezas.Where(a => a.SeMovio).Count() == 0 ? true : false;

            ViewBag.FechaSalidaEnabled = (mov.EstadoMovimiento == EstadoMovimientoTemp.Procesando) ? true : false;

            //Solo habilitar el forzar cuando: MovimientoEstado = Procesando, Concluido,Concluido_SinValidar ,
            ViewBag.ForzarMovimientoEnabled =
                (
                mov.EstadoMovimiento == EstadoMovimientoTemp.Concluido ||
                mov.EstadoMovimiento == EstadoMovimientoTemp.Concluido_SinValidar ||
                mov.EstadoMovimiento == EstadoMovimientoTemp.Procesando
                )
                ? true : false;

            ViewBag.UbicacionDestinoID = new SelectList(listaUbicaciones, "UbicacionID", "Nombre", mov.UbicacionDestinoID);

            #region Validar navegacion de movimientos

            // 1 2 3 4 [5] 6 7 8 9 10
            // [1] 2 3 4 5 6 7 8 9 10
            // 1 2 3 4 5 6 7 8 9 9 [10]

            MovimientoTemp movTemp = null;
            movTemp = db.MovimientosTemp.Where(a => a.Folio < mov.Folio).OrderByDescending(a => a.Folio).FirstOrDefault();
            ViewBag.MovAnterior = movTemp == null ? Guid.Empty : movTemp.MovimientoTempID;

            movTemp = db.MovimientosTemp.Where(a => a.Folio > mov.Folio).OrderBy(a => a.Folio).FirstOrDefault();
            ViewBag.MovSiguiente = movTemp == null ? Guid.Empty : movTemp.MovimientoTempID;

            #endregion

            return View(mov);
        }
        public static HistorialLog EliminarEntidad(object objeto, string tablaNombre, string llavePrimaria, Guid usuarioID, RecordFCSContext db, DateTime? EventoFecha = null)
        {
            HistorialLog historialLog;

            EventoFecha = EventoFecha ?? DateTime.Now;

            try
            {
                #region Eliminar entidades

                var entidad = db.Entry(objeto);

                #endregion

                #region Validar las propiedades que sufrieron cambios

                List<HistorialLogDetalle> listaHistorialLogDetalles = new List<HistorialLogDetalle>();

                //tipo de evento: Crear, Editar, Eliminar
                string eventoTipo = "Eliminar";
                //motivo por el cual se realiza la accion
                string motivo = "Eliminación de registro";

                //Crear el HistorialLog
                historialLog = new HistorialLog()
                {
                    HistorialLogID = Guid.NewGuid(),
                    EventoFecha = EventoFecha.Value,
                    EventoTipo = eventoTipo,
                    TablaNombre = tablaNombre,
                    LlavePrimaria = llavePrimaria,
                    Motivo = motivo,
                    UsuarioID = usuarioID,
                    CategoriaTipo = ""
                };

                //Crear la lista de propiedades con cambios
                foreach (var propiedadNombre in entidad.OriginalValues.PropertyNames)
                {
                    var valorOriginal = (entidad.Property(propiedadNombre).OriginalValue ?? "").ToString();

                    //validar que la propiedad que se va a eliminar no sea vacia o nula, asi evitamos basura en la base de datos
                    if (!string.IsNullOrWhiteSpace(valorOriginal))
                    {
                        listaHistorialLogDetalles.Add(new HistorialLogDetalle()
                        {
                            HistorialLogDetalleID = Guid.NewGuid(),
                            HistorialLogID = historialLog.HistorialLogID,
                            ColumnaNombre = propiedadNombre,
                            ValorNuevo = "",
                            ValorOriginal = valorOriginal
                        });
                    }
                }

                #endregion

                #region Validar el historial

                if (listaHistorialLogDetalles.Count > 0)
                    historialLog.HistorialLogDetalles = listaHistorialLogDetalles;
                else
                    historialLog = null;

                #endregion

            }
            catch (Exception)
            {

                historialLog = null;
            }

            return historialLog;
        }
        public ActionResult FichaPrint(Guid? id, int i)
        {
            db = new RecordFCSContext();

            if (id == null)
                return new HttpStatusCodeResult(HttpStatusCode.BadRequest);

            Pieza pieza = db.Piezas.Find(id);

            if (pieza == null)
                return HttpNotFound();

            itemPiezaMini piezaMini = new itemPiezaMini()
            {
                ObraID = pieza.ObraID,
                PiezaID = pieza.PiezaID,
                FolioObra = pieza.Obra.LetraFolio.Nombre + pieza.Obra.NumeroFolio,
                FolioPieza = pieza.ImprimirFolio(),
                NombreObra = pieza.Obra.TipoObra.Nombre,
                NombrePieza = pieza.TipoPieza.Nombre,
                esPrincipal = pieza.TipoPieza.EsPrincipal,
                //esBusqueda = esBusqueda,
                //ListaPiezasHijas = new List<Guid>(),
                Atributos = new List<itemPiezaMiniAtt>(),
                UbicacionOrigenID = pieza.UbicacionID
            };

            //extraer la lista de att de la pieza en guion
            var listaAttMovFicha = pieza.TipoPieza.Atributos.Where(a => a.Status && a.MostrarAtributos.Any(b => b.TipoMostrar.Nombre == "Basicos" && b.Status) && a.TipoAtributo.Status).OrderBy(a => a.Orden).ToList();

            //llenar los attFicha
            foreach (var att in listaAttMovFicha)
            {
                var tipoAtt = att.TipoAtributo;

                var attFicha = new itemPiezaMiniAtt()
                {
                    Nombre = att.NombreAlterno,
                    Orden = att.Orden,
                    PiezaID = piezaMini.PiezaID,
                    AtributoID = att.AtributoID,
                    Valores = new List<itemPiezaMiniAttValor>()
                };

                if (tipoAtt.EsGenerico)
                {
                    var lista_AttPieza = pieza.AtributoPiezas.Where(a => a.Atributo == att).ToList();

                    if (lista_AttPieza.Count > 0)
                    {
                        foreach (var item in lista_AttPieza)
                        {
                            var attValor = new itemPiezaMiniAttValor()
                            {
                                AtributoPiezaID = item.AtributoPiezaID,
                                Orden = attFicha.Valores.Count + 1
                            };

                            if (tipoAtt.EsLista)
                            {
                                attValor.Valor = item.ListaValor.Valor;
                            }
                            else
                            {
                                attValor.Valor = item.Valor;
                            }

                            if (!string.IsNullOrWhiteSpace(attValor.Valor))
                            {
                                attFicha.Valores.Add(attValor);
                            }
                        }
                    }
                }
                else
                {
                    switch (tipoAtt.TablaSQL)
                    {
                        case "Autor":
                            var lista_AttAutor = pieza.AutorPiezas.Where(a => a.Status).OrderByDescending(a => a.esPrincipal).ThenBy(a => a.Prefijo).ThenBy(a => a.Autor.Nombre).ToList();
                            if (lista_AttAutor.Count > 0)
                            {
                                foreach (var item in lista_AttAutor)
                                {
                                    var attValor = new itemPiezaMiniAttValor()
                                    {
                                        AtributoPiezaID = item.AutorID,
                                        Orden = attFicha.Valores.Count + 1
                                    };

                                    var textoNombre = Regex.Replace(string.Format(item.Autor.Seudonimo + " " + item.Autor.Nombre + " " + item.Autor.ApellidoPaterno + " " + item.Autor.ApellidoMaterno).ToString().Trim(), @"\s+", " ");

                                    attValor.Valor = string.IsNullOrWhiteSpace(item.Prefijo) ? "" : item.Prefijo + ": " + textoNombre;

                                    if (!string.IsNullOrWhiteSpace(attValor.Valor))
                                    {
                                        attFicha.Valores.Add(attValor);
                                    }
                                }
                            }
                            break;

                        case "Ubicacion":
                            if (pieza.UbicacionID != null)
                            {
                                var attValor = new itemPiezaMiniAttValor()
                                {
                                    AtributoPiezaID = pieza.UbicacionID,
                                    Orden = 1,
                                    Valor = pieza.Ubicacion.Nombre
                                };

                                if (!string.IsNullOrWhiteSpace(attValor.Valor))
                                {
                                    attFicha.Valores.Add(attValor);
                                }

                            }
                            break;

                        case "TipoTecnica":
                            var lista_Tecnicas = pieza.TecnicaPiezas.Where(a => a.Status).OrderBy(a => a.TipoTecnica.Nombre).ToList();

                            if (lista_Tecnicas.Count > 0)
                            {
                                foreach (var item in lista_Tecnicas)
                                {
                                    var attValor = new itemPiezaMiniAttValor()
                                    {
                                        AtributoPiezaID = item.TecnicaID,
                                        Orden = attFicha.Valores.Count + 1
                                    };

                                    attValor.Valor = item.TipoTecnica.Nombre + ": " + item.Tecnica.Descripcion;

                                    if (!string.IsNullOrWhiteSpace(item.Tecnica.Descripcion))
                                    {
                                        attFicha.Valores.Add(attValor);
                                    }
                                }
                            }
                            break;

                        case "TipoMedida":
                            var lista_Medidas = pieza.MedidaPiezas.Where(a => a.Status).OrderBy(a => a.TipoMedida.Nombre).ToList();
                            if (lista_Medidas.Count > 0)
                            {
                                foreach (var item in lista_Medidas)
                                {
                                    var attValor = new itemPiezaMiniAttValor()
                                    {
                                        AtributoPiezaID = item.TipoMedidaID,
                                        Orden = attFicha.Valores.Count + 1
                                    };

                                    string medidaTexto = "";
                                    bool existe0 = false;
                                    bool existe1 = false;

                                    //1x
                                    existe0 = item.Altura.HasValue ? true : false;
                                    existe1 = item.Anchura.HasValue ? true : false;

                                    medidaTexto += existe0 ? item.Altura.ToString() : "";
                                    medidaTexto += existe0 && existe1 ? "x" : "";
                                    existe0 = existe1;
                                    existe1 = item.Profundidad.HasValue ? true : false;

                                    //2x
                                    medidaTexto += medidaTexto.EndsWith("x") ? "" : medidaTexto.Length > 0 && existe0 ? "x" : "";
                                    medidaTexto += existe0 ? item.Anchura.ToString() : "";
                                    medidaTexto += existe0 && existe1 ? "x" : "";
                                    existe0 = existe1;
                                    existe1 = item.Diametro.HasValue ? true : false;

                                    //3x
                                    medidaTexto += medidaTexto.EndsWith("x") ? "" : medidaTexto.Length > 0 && existe0 ? "x" : "";
                                    medidaTexto += existe0 ? item.Profundidad.ToString() : "";
                                    medidaTexto += existe0 && existe1 ? "x" : "";
                                    existe0 = existe1;
                                    existe1 = item.Diametro2.HasValue ? true : false;

                                    //4Øx
                                    medidaTexto += medidaTexto.EndsWith("x") ? "" : medidaTexto.Length > 0 && existe0 ? "x" : "";
                                    medidaTexto += existe0 ? item.Diametro.ToString() + "Ø" : "";
                                    medidaTexto += existe0 && existe1 ? "x" : "";
                                    existe0 = existe1;
                                    existe1 = item.UMLongitud.HasValue ? true : false;

                                    //cm
                                    medidaTexto += medidaTexto.EndsWith("x") ? "" : medidaTexto.Length > 0 && existe0 ? "x" : "";
                                    medidaTexto += existe0 ? item.Diametro2.ToString() + "Ø" : "";
                                    medidaTexto += existe1 && medidaTexto.Length > 0 ? item.UMLongitud.ToString() + " " : " ";
                                    existe0 = item.Peso.HasValue ? true : false;

                                    //6
                                    medidaTexto += medidaTexto.EndsWith(" ") && existe0 ? item.Peso.ToString() + item.UMMasa : "";
                                    existe0 = item.Otra == null || item.Otra == "" ? false : true;

                                    //otra
                                    medidaTexto += existe0 ? medidaTexto.Length > 0 ? ", " + item.Otra : item.Otra : "";

                                    attValor.Valor = medidaTexto;

                                    if (!string.IsNullOrWhiteSpace(attValor.Valor))
                                    {
                                        attFicha.Valores.Add(attValor);
                                    }
                                }
                            }
                            break;
                        default:
                            break;
                    }
                }

                if (attFicha.Valores.Count > 0)
                {
                    piezaMini.Atributos.Add(attFicha);
                }
            }

            //var imagen = pieza.ImagenPiezas.OrderBy(a => a.Orden).FirstOrDefault(a => a.Status && a.EsPrincipal);
            TipoArchivo tipoArchivo = db.TipoArchivos.FirstOrDefault(a => a.Temp == "imagen_clave");

            //Solo imagen que sea basica y sea la primera
            var imagen = pieza.ArchivosPiezas.Where(a => a.Status && a.TipoArchivoID == tipoArchivo.TipoArchivoID && a.MostrarArchivos.Any(b => b.TipoMostrarArchivo.Nombre == "Basicos" && b.Status)).OrderBy(a => a.Orden).FirstOrDefault();

            if (imagen != null)
            {
                //Comprobar que el archivo exista
                FileInfo infoThumb = new FileInfo(Server.MapPath("~" + imagen.Ruta));

                if (infoThumb.Exists)
                {
                    piezaMini.ImagenID = imagen.ArchivoPiezaID;
                    piezaMini.RutaImagenMini = imagen.RutaThumb;
                }
            }

            //pieza.TipoPieza.TipoPiezasHijas = pieza.TipoPieza.TipoPiezasHijas.Where(a => a.Status).OrderBy(a => a.Orden).ToList();

            //ViewBag.listaAttributosFichaCompleta = listaAttributosFicha;
            string lado = "";

            if (i % 2 == 0)
                lado = "left";
            else
                lado = "right";

            ViewBag.lado = lado;

            return PartialView("_FichaPrint", piezaMini);
        }
        public ActionResult Detalles(Guid? id)
        {
            db = new RecordFCSContext();

            #region Validar que exista el movimiento

            if (id == null) return new HttpStatusCodeResult(HttpStatusCode.BadRequest);
            MovimientoTemp mov = db.MovimientosTemp.Find(id);
            if (mov == null) return HttpNotFound();

            #endregion

            #region Navegacion de movimientos

            // 1 2 3 4 [5] 6 7 8 9 10
            // [1] 2 3 4 5 6 7 8 9 10
            // 1 2 3 4 5 6 7 8 9 9 [10]

            MovimientoTemp movTemp = null;
            movTemp = db.MovimientosTemp.Where(a => a.Folio < mov.Folio).OrderByDescending(a => a.Folio).FirstOrDefault();
            ViewBag.MovAnterior = movTemp == null ? Guid.Empty : movTemp.MovimientoTempID;

            movTemp = db.MovimientosTemp.Where(a => a.Folio > mov.Folio).OrderBy(a => a.Folio).FirstOrDefault();
            ViewBag.MovSiguiente = movTemp == null ? Guid.Empty : movTemp.MovimientoTempID;

            #endregion

            bool BtnCancelarEnabled = false;
            bool BtnRevertirEnabled = false;
            bool BtnEditarEnabled = true;
            bool BtnImprimirEnabled = false;

            //TipoArchivo tipoArchivo = db.TipoArchivos.FirstOrDefault(a => a.Temp == "imagen_clave");

            //Tipo de atributo a mostrar
            var TipoAttTitulo = db.TipoAtributos.FirstOrDefault(a => a.Temp == "titulo");

            //lista de piezas guardadas en el moviento

            var lista = db.MovimientoTempPiezas
                       .Where(a => a.MovimientoTempID == mov.MovimientoTempID)
                       .OrderBy(a => a.Pieza.Obra.LetraFolio.Nombre)
                       .ThenBy(a => a.Pieza.Obra.NumeroFolio)
                       .ThenBy(a => a.Pieza.SubFolio)
                       .Select(a => new Item_MovPieza()
                       {
                           ObraID = a.Pieza.ObraID,
                           FolioObra = a.Pieza.Obra.LetraFolio.Nombre + a.Pieza.Obra.NumeroFolio,
                           FolioPieza = a.FolioPieza,//a.Pieza.Obra.LetraFolio.Nombre + a.Pieza.Obra.NumeroFolio + a.
                           PiezaID = a.PiezaID,
                           UbicacionID = a.Pieza.UbicacionID,
                           EnError = a.EnError,
                           EsPendiente = a.EsPendiente,
                           SeMovio = a.SeMovio,
                           ExisteEnMov = true,
                           Comentario = a.Comentario,
                           EsUltimo = a.Pieza.MovimientoTempPiezas.Where(b => b.Orden > a.Orden && !a.EnError).Count() > 0 ? false : true
                       }).ToList();

            //foreach (var item in lista)
            //{
            //    var p = db.Piezas.AsNoTracking().FirstOrDefault(a => a.PiezaID == item.PiezaID);

            //    item.FolioPieza = p.ImprimirFolio();
            //}

            //lista de Items de tipo movimiento pieza
            //var lista = new List<Item_MovPieza>();

            //Crear la lista
            //foreach (var item in lista)
            //{
            //    db = new RecordFCSContext();
            //    db.Configuration.ValidateOnSaveEnabled = false;
            //    db.Configuration.AutoDetectChangesEnabled = false;

            //    item.FolioPieza = db.Piezas.FirstOrDefault(a => a.PiezaID == item.PiezaID).ImprimirFolio();

            //    //var obj = new Item_MovPieza()
            //    //{
            //    //    ObraID = item.Pieza.ObraID,
            //    //    PiezaID = item.PiezaID,
            //    //    UbicacionID = item.Pieza.UbicacionID,
            //    //    EnError = item.EnError,
            //    //    EsPendiente = item.EsPendiente,
            //    //    SeMovio = item.SeMovio,
            //    //    ExisteEnMov = true,
            //    //    Comentario = item.Comentario,
            //    //};

            //    //obj.FolioObra = item.Pieza.Obra.LetraFolio.Nombre + item.Pieza.Obra.NumeroFolio;
            //    //obj.FolioPieza = item.Pieza.ImprimirFolio();

            //    ////var imagen = item.ArchivosPiezas.Where(b => b.Status && b.TipoArchivoID == tipoArchivo.TipoArchivoID && b.MostrarArchivos.Any(c => c.TipoMostrarArchivoID == tipoMostrarArchivo.TipoMostrarArchivoID && c.Status)).OrderBy(b => b.Orden).FirstOrDefault();
            //    ////obj.Imagen = imagen == null ? "" : imagen.RutaThumb;

            //    //////Extraer el autor
            //    ////try
            //    ////{
            //    ////    var autor = item.Pieza.AutorPiezas.OrderBy(b => b.Orden).FirstOrDefault(b => b.esPrincipal && b.Status);
            //    ////    obj.Autor = autor.Autor.Seudonimo + " " + autor.Autor.Nombre + " " + autor.Autor.ApellidoPaterno + " " + autor.Autor.ApellidoMaterno;
            //    ////}
            //    ////catch (Exception)
            //    ////{
            //    ////    obj.Autor = "Sin autor";
            //    ////}

            //    //////Extraer el titulo
            //    ////try
            //    ////{
            //    ////    var titulo = item.Pieza.AtributoPiezas.FirstOrDefault(b => b.Atributo.TipoAtributoID == TipoAttTitulo.TipoAtributoID);
            //    ////    obj.Titulo = titulo.Valor;
            //    ////}
            //    ////catch (Exception)
            //    ////{
            //    ////    obj.Titulo = "Sin titulo";
            //    ////}

            //    ////obj.TotalPiezas = item.PiezasHijas.Count();

            //    ////Saber si es el ultimo registro (Este no sirve, solo como referencia)
            //    //obj.EsUltimo = item.Pieza.MovimientoTempPiezas.Where(a => a.Orden > item.Orden && !a.EnError).Count() > 0 ? false : true;

            //    //lista.Add(obj);
            //}

            ViewData["ListaPiezasMov_" + id] = lista;

            List<string> InfoEstadoMov = new List<string>();

            #region Crear la informacion del movimiento

            #region Comparar la fecha

            var limiteDias = 2; //limite de dias para validar

            var fechaActual = DateTime.Now; // fecha y hora actuales
            var fechaMov = mov.FechaSalida.Value; // fecha de execucion del movimiento

            var fechaTemp = fechaActual; // fecha temporal con la fehca actual
            var totalDias = (fechaTemp - fechaMov).Days; // extraer los dias faltantes
            fechaTemp = fechaTemp.AddDays(totalDias); //agregar los dias faltantes para ir acercandonos mas a la fecha
            var totalHoras = (fechaTemp - fechaMov).Hours; // extraer las horas faltantes
            fechaTemp = fechaTemp.AddHours(totalHoras); //agregar las horas faltaqntes para acercarn¡nos mas a la fecha
            var totalMinutos = (fechaTemp - fechaMov).Minutes; // extraer los minutos faltantes

            #endregion

            switch (mov.EstadoMovimiento)
            {
                case EstadoMovimientoTemp.Cancelado:
                    BtnRevertirEnabled = true;

                    break;

                case EstadoMovimientoTemp.Concluido:
                    BtnCancelarEnabled = true;

                    break;

                case EstadoMovimientoTemp.Concluido_SinValidar:
                    BtnCancelarEnabled = true;

                    InfoEstadoMov.Add("Movimiento Concluido <b>SIN VALIDACION</b>");

                    var fechaLimite = fechaMov.AddDays(limiteDias); // agregar los dias limites para crear la fecha limite

                    if (fechaActual < fechaLimite)
                    {
                        fechaTemp = fechaActual; // fecha temporal con la fehca actual

                        totalDias = (fechaLimite - fechaActual).Days; // extraer los dias faltantes
                        fechaTemp = fechaTemp.AddDays(totalDias); //agregar los dias faltantes para ir acercandonos mas a la fecha
                        totalHoras = (fechaLimite - fechaActual).Hours; // extraer las horas faltantes
                        fechaTemp = fechaTemp.AddHours(totalHoras); //agregar las horas faltaqntes para acercarn¡nos mas a la fecha
                        totalMinutos = (fechaLimite - fechaActual).Minutes; // extraer los minutos faltantes

                        InfoEstadoMov.Add("En máximo " + limiteDias + " dias se revertira el estado del movimiento a <b>RETORNADO</b>. Validar lo antes posible.");
                        InfoEstadoMov.Add("Tiempo estimado: <b>" + totalDias + " dias, " + totalHoras + " hrs y " + totalMinutos + " mins.</b>");
                    }
                    else
                        InfoEstadoMov.Add("En unos instantes se <b>REVERTIRA</b> el movimiento.");

                    break;

                case EstadoMovimientoTemp.Procesando:
                    BtnCancelarEnabled = true;

                    if (mov.MovimientoTempPiezas.Where(a => (a.SeMovio || a.EsPendiente) && !a.EnError).Count() == 0)
                        InfoEstadoMov.Add("No contiene obras/piezas. No se ejecutara hasta agregar por lo menos una valida.");
                    else
                    {
                        if (mov.EsValido)
                            InfoEstadoMov.Add("Movimiento en Proceso.");
                        else
                            InfoEstadoMov.Add("Movimiento en Proceso <b>SIN VALIDACION</b>. Validar lo antes posible.");

                        InfoEstadoMov.Add("Tiempo estimado: <b>" + totalDias + " dias, " + totalHoras + " hrs y " + totalMinutos + " mins.</b>");
                    }

                    BtnCancelarEnabled = true;
                    break;

                case EstadoMovimientoTemp.Retornado:

                    BtnRevertirEnabled = true;

                    InfoEstadoMov.Add("Movimiento retornado");
                    InfoEstadoMov.Add("Tiempo que retorno: <b>" + totalDias + " dias, " + totalHoras + " hrs y " + totalMinutos + " mins.</b>");

                    break;

                default:
                    InfoEstadoMov.Add("Error");
                    break;
            }

            #endregion

            BtnImprimirEnabled = (mov.MovimientoTempPiezas.Where(a => (a.SeMovio || a.EsPendiente) && !a.EnError).Count() == 0) ? false : true;

            ViewBag.InfoEstadoMov = InfoEstadoMov;

            #region Botones

            //logica de los botones
            ViewBag.BtnCancelarEnabled = BtnCancelarEnabled;
            ViewBag.BtnRevertirEnabled = BtnRevertirEnabled;
            ViewBag.BtnEditarEnabled = BtnEditarEnabled;
            ViewBag.BtnImprimirEnabled = BtnImprimirEnabled;

            #endregion

            return View(mov);
        }
        public ActionResult CancelarMovimiento(Guid? id)
        {
            db = new RecordFCSContext();

            if (id == null) return new HttpStatusCodeResult(HttpStatusCode.BadRequest);

            MovimientoTemp mov = db.MovimientosTemp.Find(id);

            if (mov == null) return HttpNotFound();

            //Validar que el movimiento se pueda cancelar
            //todas las piezas que estan en estado EsMovido se puedan mover

            bool Executar = false;

            int totalMovidas = mov.MovimientoTempPiezas.Where(a => a.SeMovio).Count();
            int totalMovidasSonUltimas = 0;

            List<string> listaPiezasEnError = new List<string>();

            #region Validacion 3: En ultimo movimiento

            foreach (var piezaEnMovReal in mov.MovimientoTempPiezas.Where(a => a.SeMovio && a.Pieza.UbicacionID == mov.UbicacionDestinoID).ToList())
            {
                if ((piezaEnMovReal.Pieza.MovimientoTempPiezas.Where(a => a.Orden > piezaEnMovReal.Orden && !a.EnError).Count() > 0))
                {
                    totalMovidasSonUltimas = 0;
                    listaPiezasEnError.Add(piezaEnMovReal.Pieza.ImprimirFolio());
                }
                else
                {
                    totalMovidasSonUltimas++;
                }

            }

            #endregion

            Executar = totalMovidas == totalMovidasSonUltimas ? true : false;

            ViewBag.Executar = Executar;
            ViewBag.listaPiezasEnError = listaPiezasEnError;

            return PartialView("_Cancelar", mov);
        }
        public bool EjecutarMovimiento(Guid? id, EstadoMovimientoTemp Estado, DateTime? Fecha = null)
        {
            db = new RecordFCSContext();

            bool bandera = false;

            Fecha = Fecha ?? DateTime.Now;
            try
            {
                if (id != null)
                {
                    MovimientoTemp mov = db.MovimientosTemp.Find(id);

                    if (mov != null)
                        if (mov.MovimientoTempPiezas.Where(a => !a.SeMovio && a.EsPendiente && !a.EnError).Count() > 0)
                            EjecutarMovimiento(mov, Estado, Fecha.Value);
                }
            }
            catch (Exception)
            {
                bandera = false;
            }

            return bandera;
        }
        // GET: MovimientoTempPieza/Create
        public async Task<ActionResult> FormCrear(Guid id)
        {

            db = new RecordFCSContext();
            db.Configuration.ValidateOnSaveEnabled = false;
            db.Configuration.AutoDetectChangesEnabled = false;

            #region Inicializar

            //Variable Movimiento ID
            ViewBag.MovID = id;

            //Listas guardadas en variables de sesion
            var listaBuscar = new List<Item_MovPieza>();
            var listaAceptar = new List<Item_MovPieza>();
            var listaError = new List<Item_MovPieza>();

            Session["listaBuscar_" + id] = listaBuscar;
            Session["listaAceptar_" + id] = listaAceptar;
            Session["listaError_" + id] = listaError;

            //atributos para el menu de carga de piezas
            var tipoAttGuion = db.TipoAtributos.FirstOrDefault(a => a.Temp == "guion_clave");
            var listaGuiones = tipoAttGuion.ListaValores.Where(a => a.Status && a.AtributoPiezas.Count > 0).Select(a => new { Nombre = a.Valor + " (" + a.AtributoPiezas.Count + ")", GuionID = a.ListaValorID }).OrderBy(a => a.Nombre);
            ViewBag.GuionID = new SelectList(listaGuiones, "GuionID", "Nombre");

            var listaLetras = db.LetraFolios.Select(a => new { a.LetraFolioID, Nombre = a.Nombre, a.Status }).Where(a => a.Status).OrderBy(a => a.Nombre);
            ViewBag.LetraFolioID = new SelectList(listaLetras, "LetraFolioID", "Nombre", listaLetras.FirstOrDefault().LetraFolioID);

            #endregion

            //Buscar el movimiento
            var mov = db.MovimientosTemp.Find(id);

            ViewBag.EstadoMovimiento = mov.EstadoMovimiento;




            //llenar las listas

            #region Seleccionar Imagenes mostradas en Guion
            //var tipoMostrarArchivo = db.TipoMostrarArchivos.FirstOrDefault(a => a.Nombre == "Guion");

            //if (tipoMostrarArchivo == null)
            //{
            //    tipoMostrarArchivo = new TipoMostrarArchivo()
            //    {
            //        TipoMostrarArchivoID = Guid.NewGuid(),
            //        Nombre = "Guion",
            //        Status = true,
            //        Descripcion = "Ficha de movimientos"
            //    };
            //    db.TipoMostrarArchivos.Add(tipoMostrarArchivo);
            //    db.SaveChanges();
            //}

            //TipoArchivo tipoArchivo = db.TipoArchivos.FirstOrDefault(a => a.Temp == "imagen_clave");

            #endregion

            //Atributo titulo
            var TipoAttTitulo = db.TipoAtributos.FirstOrDefault(a => a.Temp == "titulo");

            //lista de piezas guardadas en el movimiento

            db = new RecordFCSContext();
            db.Configuration.ValidateOnSaveEnabled = false;
            db.Configuration.AutoDetectChangesEnabled = false;


            //var listaOrdenada = db.MovimientoTempPiezas.Where(a=> a.MovimientoTempID == mov.MovimientoTempID).OrderBy(a => a.Pieza.Obra.LetraFolio.Nombre).ThenBy(a => a.Pieza.Obra.NumeroFolio).ThenBy(a => a.Pieza.SubFolio).ToList();

            var lista = db.MovimientoTempPiezas
                        .Where(a => a.MovimientoTempID == mov.MovimientoTempID)
                        .OrderBy(a => a.Pieza.Obra.LetraFolio.Nombre)
                        .ThenBy(a => a.Pieza.Obra.NumeroFolio)
                        .ThenBy(a => a.Pieza.SubFolio)
                        .Select(a => new Item_MovPieza()
                        {
                            ObraID = a.Pieza.ObraID,
                            FolioObra = a.Pieza.Obra.LetraFolio.Nombre + a.Pieza.Obra.NumeroFolio,
                            FolioPieza = a.FolioPieza,
                            PiezaID = a.PiezaID,
                            UbicacionID = a.Pieza.UbicacionID,
                            EnError = a.EnError,
                            EsPendiente = a.EsPendiente,
                            SeMovio = a.SeMovio,
                            ExisteEnMov = true,
                            Comentario = a.Comentario,
                            EsUltimo = a.Pieza.MovimientoTempPiezas.Where(b => b.Orden > a.Orden && !a.EnError).Count() > 0 ? false : true
                        })
                        .ToList();

            ////Extraer los campos que necesitan mas logica
            //foreach (var item in lista)
            //{
            //    item.FolioPieza = db.Piezas.FirstOrDefault(a => a.PiezaID == item.PiezaID).ImprimirFolio();
            //}



            #region No se usa ya

            //foreach (var obj in lista)
            //{





            //    ////var obj = new Item_MovPieza();

            //    ////obj.ObraID = item.Pieza.ObraID;
            //    ////obj.FolioObra = item.Pieza.Obra.LetraFolio.Nombre + item.Pieza.Obra.NumeroFolio;
            //    ////obj.PiezaID = item.PiezaID;
            //    ////obj.FolioPieza = item.Pieza.ImprimirFolio();
            //    ////obj.UbicacionID = item.Pieza.UbicacionID;
            //    //////var imagen = item.ArchivosPiezas.Where(b => b.Status && b.TipoArchivoID == tipoArchivo.TipoArchivoID && b.MostrarArchivos.Any(c => c.TipoMostrarArchivoID == tipoMostrarArchivo.TipoMostrarArchivoID && c.Status)).OrderBy(b => b.Orden).FirstOrDefault();
            //    //////obj.Imagen = imagen == null ? "" : imagen.RutaThumb;
            //    ////var autor = item.Pieza.AutorPiezas.OrderBy(b => b.Orden).FirstOrDefault(b => b.esPrincipal && b.Status);
            //    ////obj.Autor = autor == null ? "Sin autor" : autor.Autor == null ? "Sin autor" : autor.Autor.Seudonimo + " " + autor.Autor.Nombre + " " + autor.Autor.ApellidoPaterno + " " + autor.Autor.ApellidoMaterno; var titulo = item.Pieza.AtributoPiezas.FirstOrDefault(b => b.Atributo.TipoAtributoID == TipoAttTitulo.TipoAtributoID);
            //    ////obj.Titulo = titulo == null ? "Sin titulo" : titulo.Valor;
            //    //////obj.TotalPiezas = item.PiezasHijas.Count();
            //    ////obj.EnError = item.EnError;
            //    ////obj.EsPendiente = item.EsPendiente;
            //    ////obj.SeMovio = item.SeMovio;
            //    ////obj.ExisteEnMov = true;
            //    ////obj.Comentario = item.Comentario;
            //    ////obj.EsUltimo = item.Pieza.MovimientoTempPiezas.Where(a => a.Orden > item.Orden && !a.EnError).Count() > 0 ? false : true;


            //    ////if (!obj.EnError)
            //    ////    listaAceptar.Add(obj);
            //    ////else
            //    ////    listaError.Add(obj);

            //}

            #endregion

            listaError.AddRange(lista.Where(a => a.EnError).ToList());
            listaAceptar.AddRange(lista.Where(a => !a.EnError).ToList());

            //listaBuscar = (List<Item_MovPieza>)Session["listaBuscar_" + id];
            //listaAceptar = (List<Item_MovPieza>)Session["listaAceptar_" + id];
            //listaError = (List<Item_MovPieza>)Session["listaError_" + id];

            return PartialView("_FormCrear");
        }
        private string _ExtraerValorDeTabla(string campoValor)
        {
            string valor = "";

            Guid llave1 = Guid.Empty;
            Guid llave2 = Guid.Empty;
            int llaveInt = 0;

            campoValor = campoValor ?? "";

            try
            {
                var db = new RecordFCSContext();

                try
                {
                    llave1 = new Guid(campoValor);

                }
                catch (Exception)
                {
                    llave1 = Guid.Empty;
                }

                var objetoDB = new { llave1 = Guid.Empty, llave2 = Guid.Empty, llaveInt = 0, Texto = campoValor };
                bool tratarObjeto = true;

                switch (ColumnaNombre)
                {
                    case "AutorID":
                        {
                            objetoDB = db.Autores.Select(a => new
                            {
                                llave1 = a.AutorID,
                                llave2 = Guid.Empty,
                                llaveInt = 0,
                                Texto = a.Seudonimo + " " + a.Nombre + " " + a.ApellidoPaterno + " " + a.ApellidoMaterno
                            })
                            .FirstOrDefault(a => a.llave1 == llave1);
                        }
                        break;

                    case "LetraFolioID":
                        {
                            try
                            {
                                llaveInt = Convert.ToInt32(campoValor);
                            }
                            catch (Exception)
                            {
                                llaveInt = 0;
                            }

                            objetoDB = db.LetraFolios.Select(a => new
                            {
                                llave1 = Guid.Empty,
                                llave2 = Guid.Empty,
                                llaveInt = a.LetraFolioID,
                                Texto = a.Nombre
                            })
                            .FirstOrDefault(a => a.llaveInt == llaveInt);
                        }
                        break;

                    case "ListaValorID":
                        {
                            objetoDB = db.ListaValores.Select(a => new
                            {
                                llave1 = a.ListaValorID,
                                llave2 = Guid.Empty,
                                llaveInt = 0,
                                Texto = a.Valor
                            })
                            .FirstOrDefault(a => a.llave1 == llave1);
                        }
                        break;

                    case "UbicacionID":
                    case "UbicacionOrigenID":
                    case "UbicacionDestinoID":
                        {
                            objetoDB = db.Ubicaciones.Select(a => new
                            {
                                llave1 = a.UbicacionID,
                                llave2 = Guid.Empty,
                                llaveInt = 0,
                                Texto = a.Nombre
                            })
                            .FirstOrDefault(a => a.llave1 == llave1);
                        }
                        break;

                    case "MovimientoTempID":
                        {
                            objetoDB = db.MovimientosTemp.Select(a => new
                            {
                                llave1 = a.MovimientoTempID,
                                llave2 = Guid.Empty,
                                llaveInt = 0,
                                Texto = a.Folio.ToString()
                            })
                            .FirstOrDefault(a => a.llave1 == llave1);
                        }
                        break;

                    case "TecnicaID":
                    case "TecnicaPadreID":
                        {
                            objetoDB = db.Tecnicas.Select(a => new
                            {
                                llave1 = a.TecnicaID,
                                llave2 = Guid.Empty,
                                llaveInt = 0,
                                Texto = a.Descripcion
                            })
                            .FirstOrDefault(a => a.llave1 == llave1);
                        }
                        break;

                    case "TipoTecnicaID":
                        {
                            objetoDB = db.TipoTecnicas.Select(a => new
                            {
                                llave1 = a.TipoTecnicaID,
                                llave2 = Guid.Empty,
                                llaveInt = 0,
                                Texto = a.Nombre
                            })
                            .FirstOrDefault(a => a.llave1 == llave1);
                        }
                        break;

                    case "PiezaID":
                    case "PiezaPadreID":
                        {
                            objetoDB = db.Piezas.Select(a => new
                            {
                                llave1 = a.PiezaID,
                                llave2 = Guid.Empty,
                                llaveInt = 0,
                                Texto = a.Obra.LetraFolio.Nombre + a.Obra.NumeroFolio + a.SubFolio
                            })
                            .FirstOrDefault(a => a.llave1 == llave1);
                        }
                        break;

                    case "TipoArchivoID":
                        {
                            objetoDB = db.TipoArchivos.Select(a => new
                            {
                                llave1 = a.TipoArchivoID,
                                llave2 = Guid.Empty,
                                llaveInt = 0,
                                Texto = a.Nombre
                            })
                            .FirstOrDefault(a => a.llave1 == llave1);
                        }
                        break;

                    case "TipoAtributoID":
                        {
                            objetoDB = db.TipoAtributos.Select(a => new
                            {
                                llave1 = a.TipoAtributoID,
                                llave2 = Guid.Empty,
                                llaveInt = 0,
                                Texto = a.Nombre
                            })
                            .FirstOrDefault(a => a.llave1 == llave1);
                        }
                        break;

                    case "TipoMedidaID":
                        {
                            objetoDB = db.TipoMedidas.Select(a => new
                            {
                                llave1 = a.TipoMedidaID,
                                llave2 = Guid.Empty,
                                llaveInt = 0,
                                Texto = a.Nombre
                            })
                            .FirstOrDefault(a => a.llave1 == llave1);
                        }
                        break;

                    case "TipoMostrarArchivoID":
                        {
                            objetoDB = db.TipoMostrarArchivos.Select(a => new
                            {
                                llave1 = a.TipoMostrarArchivoID,
                                llave2 = Guid.Empty,
                                llaveInt = 0,
                                Texto = a.Nombre
                            })
                            .FirstOrDefault(a => a.llave1 == llave1);
                        }
                        break;

                    case "TipoMostrarID":
                        {
                            objetoDB = db.TipoMostarlos.Select(a => new
                            {
                                llave1 = a.TipoMostrarID,
                                llave2 = Guid.Empty,
                                llaveInt = 0,
                                Texto = a.Nombre
                            })
                            .FirstOrDefault(a => a.llave1 == llave1);
                        }
                        break;

                    case "TipoMovimientoID":
                        {
                            objetoDB = db.TipoMovimientos.Select(a => new
                            {
                                llave1 = a.TipoMovimientoID,
                                llave2 = Guid.Empty,
                                llaveInt = 0,
                                Texto = a.Nombre
                            })
                            .FirstOrDefault(a => a.llave1 == llave1);
                        }
                        break;

                    case "ObraID":
                        {
                            objetoDB = db.Obras.Select(a => new
                            {
                                llave1 = a.ObraID,
                                llave2 = Guid.Empty,
                                llaveInt = 0,
                                Texto = a.LetraFolio.Nombre + a.NumeroFolio
                            })
                            .FirstOrDefault(a => a.llave1 == llave1);
                        }
                        break;

                    case "TipoObraID":
                        {
                            objetoDB = db.TipoObras.Select(a => new
                            {
                                llave1 = a.TipoObraID,
                                llave2 = Guid.Empty,
                                llaveInt = 0,
                                Texto = a.Nombre
                            })
                            .FirstOrDefault(a => a.llave1 == llave1);
                        }
                        break;

                    case "TipoPiezaID":
                    case "TipoPiezaPadreID":
                        {
                            objetoDB = db.TipoPiezas.Select(a => new
                            {
                                llave1 = a.TipoPiezaID,
                                llave2 = Guid.Empty,
                                llaveInt = 0,
                                Texto = a.Nombre
                            })
                            .FirstOrDefault(a => a.llave1 == llave1);

                        }
                        break;

                    case "UsuarioID":
                        {
                            objetoDB = db.Usuarios.Select(a => new
                            {
                                llave1 = a.UsuarioID,
                                llave2 = Guid.Empty,
                                llaveInt = 0,
                                Texto = a.Nombre + " " + a.Apellido
                            })
                            .FirstOrDefault(a => a.llave1 == llave1);
                        }
                        break;

                    //Bool ACTIVO -- INACTIVO
                    case "Status":
                        {
                            valor = campoValor == "True" ? "Activo" : campoValor == "False" ? "Inactivo" : campoValor;
                            tratarObjeto = false;
                        }
                        break;

                    //Bool SI --- NO
                    case "EsPrincipal":
                    case "esPrincipal":
                    case "EsValido":
                    case "TieneExposicion":
                    case "Solicitante_DictamenCondicionEspacio":
                    case "Solicitante_DictamenSeguridad":
                    case "Solicitante_PeticionRecibida":
                    case "Solicitante_FacilityReport":
                    case "Solicitante_RevisionGuion":
                    case "Solicitante_CartaAceptacion":
                    case "Solicitante_ListaAvaluo":
                    case "Solicitante_ContratoComodato":
                    case "Solicitante_TramitesFianza":
                    case "Solicitante_PolizaSeguro":
                    case "Solicitante_CondicionConservacion":
                    case "Solicitante_AvisoSeguridad":
                    case "Solicitante_CartasEntregaRecepcion":
                        {
                            valor = campoValor == "True" ? "Si" : campoValor == "False" ? "No" : campoValor;
                            tratarObjeto = false;
                        }
                        break;

                    case "AtributoID":
                        {
                            objetoDB = db.Atributos.Select(a => new
                            {
                                llave1 = a.AtributoID,
                                llave2 = Guid.Empty,
                                llaveInt = 0,
                                Texto = a.NombreAlterno
                            })
                                                        .FirstOrDefault(a => a.llave1 == llave1);
                        }
                        break;

                    case "ArchivoPiezaID":
                    case "AtributoPiezaID":
                    case "ImagenPiezaID":
                    default:
                        {
                            valor = campoValor;
                            tratarObjeto = false;
                        }
                        break;

                }

                if (tratarObjeto)
                    valor = objetoDB.Texto;
            }
            catch (Exception)
            {
                valor = campoValor;
            }

            return valor;
        }
        public ActionResult DetalleMovimiento(Guid? id)
        {
            // el id es el ID del HistorialLog
            var db = new RecordFCSContext();


            if (id == null) return new HttpStatusCodeResult(HttpStatusCode.BadRequest);
            
            HistorialLog movLog = db.HistorialLogs.Find(id);
            
            if (movLog == null) return HttpNotFound();


            var icono = "";

            switch (movLog.EventoTipo)
            {
                case "Crear":
                    icono = "fa fa-plus";
                    break;

                case "Editar":
                    icono = "fa fa-pencil";
                    break;

                case "Eliminar":
                    icono = "fa fa-trash";
                    break;
                default:
                    icono = "";
                    break;
            }


            ViewBag.icono = icono;

            return PartialView("_DetalleMovimiento", movLog);
        }
        private bool EjecutarMovimiento(MovimientoTemp mov, EstadoMovimientoTemp Estado, DateTime Fecha, string Motivo = null)
        {
            bool bandera = false;

            try
            {
                db = new RecordFCSContext();

                Motivo = Motivo ?? "Ejecución del movimiento.";
                //Revalidar las piezas del movimiento que fueron validas y que no se hayan movido y sean pendientes
                int contadorPMovidas = 0;

                foreach (var PiezaID in mov.MovimientoTempPiezas.Where(a => !a.EnError && !a.SeMovio && a.EsPendiente).Select(a => a.PiezaID).ToList())
                {

                    #region Buscar la pieza con su movimiento

                    //Buscar la pieza y la pieza en el movimiento
                    var pieza = db.Piezas.Find(PiezaID);
                    var piezaEnMovReal = pieza.MovimientoTempPiezas.FirstOrDefault(a => a.MovimientoTempID == mov.MovimientoTempID);

                    #endregion

                    #region Declaracion y asignaciones

                    piezaEnMovReal.EnError = false;
                    piezaEnMovReal.EsPendiente = true;
                    piezaEnMovReal.SeMovio = false;

                    string comentario = "";

                    #endregion

                    #region Validacion 1: Asignada en movimientos

                    #region Buscar donde sea Pendiente y sin errores

                    //lista de movimientos ID
                    //Buscar la pieza en todos los movimientos excepto este, donde sea pendiente y no tenga errrores.

                    List<int> listaMov_ID =
                        db.MovimientoTempPiezas
                        .Where(a =>
                            a.PiezaID == PiezaID &&
                            a.MovimientoTempID != mov.MovimientoTempID &&
                            a.EsPendiente && !a.EnError
                            )
                            .Select(a => a.MovimientoTemp.Folio).ToList();

                    #endregion

                    #region Buscar en Concluido sin validar

                    listaMov_ID.AddRange(
                        db.MovimientoTempPiezas.Where(a => a.PiezaID == PiezaID && a.MovimientoTempID != mov.MovimientoTempID &&
                        a.MovimientoTemp.EstadoMovimiento == EstadoMovimientoTemp.Concluido_SinValidar &&
                        a.SeMovio).Select(a => a.MovimientoTemp.Folio).ToList()
                        );

                    #endregion

                    #region Buscar en Cancelado

                    listaMov_ID.AddRange(
                        db.MovimientoTempPiezas.Where(a => a.PiezaID == PiezaID && a.MovimientoTempID != mov.MovimientoTempID &&
                        a.MovimientoTemp.EstadoMovimiento == EstadoMovimientoTemp.Cancelado &&
                        a.SeMovio).Select(a => a.MovimientoTemp.Folio).ToList()
                        );

                    #endregion

                    #region Buscar en Retornado

                    listaMov_ID.AddRange(
                        db.MovimientoTempPiezas.Where(a => a.PiezaID == PiezaID && a.MovimientoTempID != mov.MovimientoTempID &&
                        a.MovimientoTemp.EstadoMovimiento == EstadoMovimientoTemp.Retornado &&
                        a.SeMovio).Select(a => a.MovimientoTemp.Folio).ToList()
                        );

                    #endregion

                    //Si existe con estas condiciones entonces no es disponible
                    foreach (var Folio in listaMov_ID)
                        comentario += " [" + Folio + "]";

                    //Comprobar que no haya estado en algun movimiento
                    if (!string.IsNullOrWhiteSpace(comentario))
                    {
                        piezaEnMovReal.Comentario = "Asignada en:" + comentario + ". ";
                        piezaEnMovReal.EnError = true;
                    }

                    #endregion

                    #region Validacion 2: Ubicacion

                    //validar que la ubicacion de la pieza sea la misma que este movimiento

                    //puede haber piezas que UbicacionID sea null y en este caso se concidera valida.
                    if (pieza.UbicacionID != null)
                    {
                        //Validar que la ubicacion Origen sea igual a la de la pieza
                        if (mov.UbicacionOrigenID != pieza.UbicacionID)
                        {
                            piezaEnMovReal.Comentario += "No comparte la misma ubicación origen. ";
                            piezaEnMovReal.EnError = true;
                        }
                    }

                    #endregion

                    #region Validacion 3: En ultimo movimiento

                    if (pieza.MovimientoTempPiezas.Where(a => a.Orden > piezaEnMovReal.Orden && !a.EnError).Count() > 0)
                    {
                        piezaEnMovReal.Comentario += "No esta en su último movimiento. ";
                        piezaEnMovReal.EnError = true;
                    }

                    #endregion

                    //Sin errores entoces proceder a realizar el cambio de ubicacion

                    #region Cambio de Ubicacion

                    if (!piezaEnMovReal.EnError)
                    {
                        //Sin errores

                        #region Asignar un orden al movimiento de la pieza

                        if (piezaEnMovReal.Orden == 0)
                        {
                            var ordenActual = pieza.MovimientoTempPiezas.Count > 0 ? pieza.MovimientoTempPiezas.OrderByDescending(a => a.Orden).FirstOrDefault().Orden : 0;
                            piezaEnMovReal.Orden = piezaEnMovReal.EnError ? 0 : ordenActual + 1;
                        }

                        #endregion

                        //Ejecutar el cambio de ubicacion
                        pieza.UbicacionID = mov.UbicacionDestinoID;

                        //------ Logica HISTORIAL

                        #region Generar el historial

                        //objeto del formulario
                        var objeto = pieza;
                        //Objeto de la base de datos
                        var objetoDB = db.Piezas.Find(pieza.PiezaID);
                        //tabla o clase a la que pertenece
                        var tablaNombre = "Pieza";
                        //llave primaria del objeto
                        var llavePrimaria = objetoDB.PiezaID.ToString();

                        //generar el historial
                        var historialLog = HistorialLogica.EditarEntidad(
                            objeto,
                            objetoDB,
                            tablaNombre,
                            llavePrimaria,
                            User.UsuarioID,
                            db,
                            Motivo + "[Forzado]",
                            Fecha
                            );

                        #endregion

                        #region Guardar el historial

                        if (historialLog != null)
                        {
                            //Cambiar el estado a la entidad a modificada
                            db.Entry(objetoDB).State = EntityState.Modified;
                            //Guardamos la entidad modificada
                            db.SaveChanges();

                            //Guardar el historial
                            db.HistorialLogs.Add(historialLog);
                            db.SaveChanges();

                            contadorPMovidas++;

                            piezaEnMovReal.SeMovio = true;
                            piezaEnMovReal.EsPendiente = false;
                            piezaEnMovReal.EnError = false;
                            piezaEnMovReal.Comentario = "";
                        }
                        else
                        {
                            throw new Exception();
                        }
                        #endregion

                        //------

                    }
                    else
                    {
                        //Con errores
                        piezaEnMovReal.Orden = 0;
                    }

                    pieza = null;

                    #endregion

                    #region Asignacion de nuevos valores

                    //buscar el objeto
                    var itemTemp = db.MovimientoTempPiezas.Find(mov.MovimientoTempID, PiezaID);
                    itemTemp.Comentario = piezaEnMovReal.Comentario;
                    itemTemp.EnError = piezaEnMovReal.EnError;
                    itemTemp.EsPendiente = piezaEnMovReal.EsPendiente;
                    itemTemp.Orden = piezaEnMovReal.Orden;
                    itemTemp.SeMovio = piezaEnMovReal.SeMovio;

                    piezaEnMovReal = null;

                    #endregion

                    //------ Logica HISTORIAL

                    #region Generar el historial

                    //objeto del formulario
                    var objeto2 = itemTemp;
                    //Objeto de la base de datos
                    var objetoDB2 = db.MovimientoTempPiezas.Find(mov.MovimientoTempID, PiezaID);
                    //tabla o clase a la que pertenece
                    var tablaNombre2 = "MovimientoTempPieza";
                    //llave primaria del objeto
                    var llavePrimaria2 = objetoDB2.MovimientoTempID + "," + objetoDB2.PiezaID;

                    //generar el historial
                    var historialLog2 = HistorialLogica.EditarEntidad(
                        objeto2,
                        objetoDB2,
                        tablaNombre2,
                        llavePrimaria2,
                        User.UsuarioID,
                        db,
                        Motivo + "[Forzado]",
                        Fecha
                        );

                    #endregion

                    #region Guardar el historial

                    if (historialLog2 != null)
                    {
                        //Cambiar el estado a la entidad a modificada
                        db.Entry(objetoDB2).State = EntityState.Modified;
                        //Guardamos la entidad modificada
                        db.SaveChanges();

                        //Guardar el historial
                        db.HistorialLogs.Add(historialLog2);
                        db.SaveChanges();

                    }
                    else
                    {
                        throw new Exception();
                    }
                    #endregion

                    //------

                }

                //Cambio del estatus
                //Solo si se actualizo la ubicacion de por lo menos 1 pieza

                if (contadorPMovidas > 0)
                {
                    //saber cual sera el estatus Concluido ó Concluido_SinValidar
                    if (mov.EsValido)
                        mov.EstadoMovimiento = EstadoMovimientoTemp.Concluido;
                    else
                        mov.EstadoMovimiento = EstadoMovimientoTemp.Concluido_SinValidar;
                }

                //------ Logica HISTORIAL

                #region Generar el historial

                //objeto del formulario
                var objeto3 = mov;
                //Objeto de la base de datos
                var objetoDB3 = db.MovimientosTemp.Find(mov.MovimientoTempID);
                //tabla o clase a la que pertenece
                var tablaNombre3 = "MovimientoTemp";
                //llave primaria del objeto
                var llavePrimaria3 = objetoDB3.MovimientoTempID.ToString();

                //generar el historial
                var historialLog3 = HistorialLogica.EditarEntidad(
                    objeto3,
                    objetoDB3,
                    tablaNombre3,
                    llavePrimaria3,
                    User.UsuarioID,
                    db,
                    Motivo + "[Forzado]",
                    Fecha
                    );

                #endregion

                #region Guardar el historial

                if (historialLog3 != null)
                {
                    //Cambiar el estado a la entidad a modificada
                    db.Entry(objetoDB3).State = EntityState.Modified;
                    //Guardamos la entidad modificada
                    db.SaveChanges();

                    //Guardar el historial
                    db.HistorialLogs.Add(historialLog3);
                    db.SaveChanges();
                }
                else
                {
                    throw new Exception();
                }
                #endregion

                //------

            }
            catch (Exception)
            {
                bandera = false;
            }

            return bandera;
        }
        // GET: MovimientoTemp/Detalles/5
        //[CustomAuthorize(permiso = "")]
        public ActionResult ImprimirBoletin(Guid? id)
        {
            db = new RecordFCSContext();

            string NombreArchivo = "Boletin_";

            if (id == null) return new HttpStatusCodeResult(HttpStatusCode.BadRequest);
            MovimientoTemp mov = db.MovimientosTemp.Find(id);
            if (mov == null) return HttpNotFound();

            //Movimiento con piezas aceptadas

            switch (mov.EstadoMovimiento)
            {
                //Imprimir todas las piezas
                case EstadoMovimientoTemp.Cancelado:
                case EstadoMovimientoTemp.Retornado:
                    mov.MovimientoTempPiezas = mov.MovimientoTempPiezas;
                    break;
                //Imprimir todas las piezas con estatus verdadero en SeMovio
                case EstadoMovimientoTemp.Concluido:
                case EstadoMovimientoTemp.Concluido_SinValidar:
                    mov.MovimientoTempPiezas = mov.MovimientoTempPiezas.Where(a => a.SeMovio).ToList();
                    break;
                //Imprimir todas las piezas con estatus falso en EnError
                case EstadoMovimientoTemp.Procesando:
                    mov.MovimientoTempPiezas = mov.MovimientoTempPiezas.Where(a => !a.EnError).ToList();
                    break;
                //Imprimir ninguna de las piezas
                default:
                    mov.MovimientoTempPiezas = new List<MovimientoTempPieza>();
                    break;
            }

            //Ordenas si no es 0
            if (mov.MovimientoTempPiezas.Count > 1)
                mov.MovimientoTempPiezas = mov.MovimientoTempPiezas.OrderBy(a => a.Pieza.Obra.LetraFolio.Nombre).ThenBy(a => a.Pieza.Obra.NumeroFolio).ThenBy(a => a.Pieza.SubFolio).ToList();

            TipoArchivo tipoArchivo = db.TipoArchivos.FirstOrDefault(a => a.Temp == "imagen_clave");

            NombreArchivo += mov.Folio;

            //return View("BoletinPDF",mov);
            return new ViewAsPdf("BoletinPDF", mov);
            //return new ActionAsPdf("~/Views/MovimientoTemp/BoletinPDF.cshtml", mov)
            //{
            //    FileName = NombreArchivo + ".pdf",
            //    PageSize = Rotativa.Options.Size.Letter
            //};
        }
        public ActionResult Crear(MovimientoTemp movimientoTemp)
        {
            db = new RecordFCSContext();

            //Validacion
            if (movimientoTemp.FechaSalida == null)
                ModelState.AddModelError("FechaSalida", "Ingrese una fecha.");

            if (movimientoTemp.UbicacionOrigenID == null)
                ModelState.AddModelError("UbicacionOrigenID", "Seleccione la ubicación.");

            if (movimientoTemp.UbicacionDestinoID == null)
                ModelState.AddModelError("UbicacionDestinoID", "Seleccione la ubicación.");

            var fechaCreacion = DateTime.Now;

            movimientoTemp.FechaUltimaEjecucion = fechaCreacion;
            //Validar ultimo Folioº
            try
            {
                if (ModelState.IsValid)
                {
                    //Crear la entidad
                    movimientoTemp.Folio = db.MovimientosTemp.Select(a => a.Folio).OrderByDescending(a => a).FirstOrDefault() + 1;

                    movimientoTemp.EstadoMovimiento = EstadoMovimientoTemp.Procesando;
                    movimientoTemp.UsuarioID = User.UsuarioID;
                    movimientoTemp.MovimientoTempID = Guid.NewGuid();
                    db.MovimientosTemp.Add(movimientoTemp);

                    //------ Logica HISTORIAL

                    #region Generar el historial

                    // Generar el historial
                    var historialLog =
                        HistorialLogica.CrearEntidad(
                        movimientoTemp,
                        movimientoTemp.GetType().Name,
                        movimientoTemp.MovimientoTempID.ToString(),
                        User.UsuarioID,
                        db,
                        fechaCreacion);

                    #endregion

                    #region Guardar el historial

                    //Guardar cambios si todo salio correcto
                    if (historialLog != null)
                    {
                        //Guardar la entidad
                        db.SaveChanges();

                        //Guardar el historial
                        db.HistorialLogs.Add(historialLog);
                        db.SaveChanges();
                    }
                    else
                    {
                        throw new Exception();
                    }

                    #endregion

                    //------

                    //Logica para terminar la instruccion
                    AlertaSuccess("Se registro el movimiento: <b>" + movimientoTemp.Folio + "</b>", true);

                    return Json(new { success = true, url = Url.Action("Detalles", new { id = movimientoTemp.MovimientoTempID }) });
                }
            }
            catch (Exception)
            {
                ModelState.AddModelError("", "Error desconocido.");
            }

            //Regresar la vista
            var tipoMov = db.TipoMovimientos.Find(movimientoTemp.TipoMovimientoID);

            if (tipoMov == null) return HttpNotFound();

            movimientoTemp.TipoMovimiento = tipoMov;
            movimientoTemp.TipoMovimientoID = tipoMov.TipoMovimientoID;
            movimientoTemp.EsValido = false;
            movimientoTemp.EstadoMovimiento = EstadoMovimientoTemp.Procesando;

            movimientoTemp.Folio = db.MovimientosTemp.Select(a => a.Folio).OrderByDescending(a => a).FirstOrDefault() + 1;

            var listaUbicaciones = db.Ubicaciones.Where(a => a.Status).Select(a => new { a.Nombre, a.UbicacionID }).OrderBy(a => a.Nombre);

            ViewBag.UbicacionDestinoID = new SelectList(listaUbicaciones, "UbicacionID", "Nombre", movimientoTemp.UbicacionDestinoID);
            ViewBag.UbicacionOrigenID = new SelectList(listaUbicaciones, "UbicacionID", "Nombre", movimientoTemp.UbicacionOrigenID);

            return View(movimientoTemp);
        }
        public ActionResult Index(MovimientoTemp MovTemp = null)
        {
            db = new RecordFCSContext();

            var listaLetras = db.LetraFolios.Select(a => new { a.LetraFolioID, Nombre = a.Nombre, a.Status }).Where(a => a.Status).OrderBy(a => a.Nombre);
            ViewBag.LetraFolioID = new SelectList(listaLetras, "LetraFolioID", "Nombre", listaLetras.FirstOrDefault().LetraFolioID);

            var listaUbicaciones = db.Ubicaciones.Where(a => a.Status).Select(a => new { a.Nombre, a.UbicacionID }).OrderBy(a => a.Nombre);

            ViewBag.UbicacionDestinoID = new SelectList(listaUbicaciones, "UbicacionID", "Nombre");
            ViewBag.UbicacionOrigenID = new SelectList(listaUbicaciones, "UbicacionID", "Nombre");

            ViewBag.TipoMovimientoID = new SelectList(db.TipoMovimientos.Where(a => a.Status).OrderBy(a => a.Nombre), "TipoMovimientoID", "Nombre", MovTemp.TipoMovimientoID);

            if (MovTemp == null)
            {
                MovTemp = new MovimientoTemp()
                {
                    TieneExposicion = false,
                    EstadoMovimiento = null
                };
            }

            return View(MovTemp);
        }
        public ActionResult BuscarMovimientos(int? FolioMovimiento, string FechaInicial, string FechaFinal, Guid? UbicacionOrigenID, Guid? UbicacionDestinoID, string PalabraFrase, EstadoMovimientoTemp? EstadoMovimiento, int? pagina = null)
        {
            db = new RecordFCSContext();

            int pagTamano = 50;
            int pagIndex = 1;
            pagIndex = pagina.HasValue ? Convert.ToInt32(pagina) : 1;

            IQueryable<MovimientoTemp> listaMovimientos = db.MovimientosTemp;
            IPagedList<MovimientoTemp> listaMovimientosEnPagina;

            if (FolioMovimiento != null && FolioMovimiento > 0)
            {
                //realizar la busqueda exclusiva del folio de movimiento
                listaMovimientos = listaMovimientos.Where(a => a.Folio == FolioMovimiento);
            }
            else
            {
                //if (!string.IsNullOrWhiteSpace(FolioObraPieza))
                //{
                //    //realizar la busqueda exclusica del folio de la obra o pieza
                //    listaMovimientos = listaMovimientos.Where(a => a.MovimientoTempPiezas.Any(b => (b.Pieza.Obra.LetraFolio.Nombre + b.Pieza.Obra.NumeroFolio) == FolioObraPieza || (b.Pieza.Obra.LetraFolio.Nombre + b.Pieza.Obra.NumeroFolio + b.Pieza.SubFolio) == FolioObraPieza));
                //}

                //Buscar por fecha Iniciar
                if (!string.IsNullOrWhiteSpace(FechaInicial))
                {
                    //Fecha menor
                    DateTime Fecha = DateTime.ParseExact(FechaInicial, "dd/MM/yyyy hh:mm tt", CultureInfo.InvariantCulture);
                    listaMovimientos = listaMovimientos.Where(a => DateTime.Compare(a.FechaSalida.Value, Fecha) > 0);
                }

                //Buscar por fecha Final
                if (!string.IsNullOrWhiteSpace(FechaFinal))
                {
                    //Fecha mayor
                    DateTime Fecha = DateTime.ParseExact(FechaFinal, "dd/MM/yyyy hh:mm tt", CultureInfo.InvariantCulture);
                    listaMovimientos = listaMovimientos.Where(a => DateTime.Compare(a.FechaSalida.Value, Fecha) < 0);
                }

                //Buscar por Ubicacion Origen
                if (UbicacionOrigenID != null)
                    listaMovimientos = listaMovimientos.Where(a => a.UbicacionOrigenID == UbicacionOrigenID);

                //Buscar por Ubicacion Destino
                if (UbicacionDestinoID != null)
                    listaMovimientos = listaMovimientos.Where(a => a.UbicacionDestinoID == UbicacionDestinoID);

                //Buscar por Palabra o Frase
                if (!string.IsNullOrEmpty(PalabraFrase))
                    listaMovimientos = listaMovimientos.Where(a => a.Observaciones.Contains(PalabraFrase) ||
                        a.Exposicion_Titulo.Contains(PalabraFrase) ||
                        a.Seguro_Notas.Contains(PalabraFrase) ||
                        a.Transporte_Notas.Contains(PalabraFrase) ||
                        a.Transporte_Recorrido.Contains(PalabraFrase)
                        );

                //Buscar por Estado del movimiento
                if (EstadoMovimiento != null)
                    listaMovimientos = listaMovimientos.Where(a => a.EstadoMovimiento == EstadoMovimiento);
            }

            listaMovimientosEnPagina = listaMovimientos.OrderByDescending(a => a.FechaSalida).Select(x => x).ToList().ToPagedList(pagIndex, pagTamano);

            return PartialView("_Lista", listaMovimientosEnPagina);
        }
        public ActionResult RevertirMovimiento(Guid? id)
        {
            db = new RecordFCSContext();

            if (id == null) return new HttpStatusCodeResult(HttpStatusCode.BadRequest);

            MovimientoTemp mov = db.MovimientosTemp.Find(id);

            if (mov == null) return HttpNotFound();

            //Validar que el movimiento se pueda revertir
            //no debe de contener ninguna pieza en estado SeMovio

            bool Executar = mov.MovimientoTempPiezas.Where(a => a.SeMovio).Count() > 0 ? false : true;

            ViewBag.Executar = Executar;

            return PartialView("_Revertir", mov);
        }
        public ActionResult Editar(MovimientoTemp movimientoTemp, List<Item_MovPieza> ListaPiezas, string Motivo, bool ForzarMovimiento = false)
        {
            db = new RecordFCSContext();

            #region Validaciones previas

            if (movimientoTemp.EstadoMovimiento == EstadoMovimientoTemp.Concluido_SinValidar && movimientoTemp.EsValido)
                movimientoTemp.EstadoMovimiento = EstadoMovimientoTemp.Concluido;

            ////cambiar el estado del movimiento dependiendo la fecha y hora
            //if (movimientoTemp.EstadoMovimiento != EstadoMovimientoTemp.Cancelado)
            //{
            //    if (movimientoTemp.FechaSalida < DateTime.Now)
            //    {
            //        movimientoTemp.EstadoMovimiento = EstadoMovimientoTemp.Concluido;
            //    }
            //    else
            //    {
            //        movimientoTemp.EstadoMovimiento = EstadoMovimientoTemp.Procesando;
            //    }
            //}

            //Separar en listas las piezas

            //lista de piezas existentes en el movimiento
            var listaGuidActual = db.MovimientoTempPiezas.Where(a => a.MovimientoTempID == movimientoTemp.MovimientoTempID).Select(a => a.PiezaID).ToList();
            //lista de piezas que se agregaran al movimiento
            var listaAdd = new List<MovimientoTempPieza>();
            //lista de piezas que se editaran
            var listaEdit = new List<MovimientoTempPieza>();

            ListaPiezas = ListaPiezas == null ? new List<Item_MovPieza>() : ListaPiezas;

            foreach (var item in ListaPiezas)
            {
                var existeEnMov = listaGuidActual.Where(a => a == item.PiezaID).Count() > 0 ? true : false;

                var temp = new MovimientoTempPieza()
                {
                    Comentario = item.Comentario,
                    EnError = item.EnError,
                    EsPendiente = item.EsPendiente,
                    MovimientoTempID = movimientoTemp.MovimientoTempID,
                    PiezaID = item.PiezaID,
                    SeMovio = item.SeMovio,
                    FolioPieza = item.FolioPieza
                };

                temp.Comentario = item.EnError ? item.Comentario : "";

                if (!existeEnMov)
                {
                    // C R E A R
                    temp.EsPendiente = true;
                    temp.SeMovio = false;
                    listaAdd.Add(temp);
                }
                else
                {
                    // E D I T A R
                    listaEdit.Add(temp);

                    //quitarlo de la lista existente
                    listaGuidActual.Remove(item.PiezaID);
                }
            }

            #endregion

            //las piezas que no estuvieron eliminarlas
            //y buscar el movimiento anterior donde fueron validas
            //para regresar el estatus.
            if (ModelState.IsValid)
            {
                var fechaEdicion = DateTime.Now;

                movimientoTemp.FechaUltimaEjecucion = fechaEdicion;

                #region Crear el historial del movimiento

                //------ Logica HISTORIAL

                #region Generar el historial

                //objeto del formulario
                var objeto = movimientoTemp;
                //Objeto de la base de datos
                var objetoDB = db.MovimientosTemp.Find(movimientoTemp.MovimientoTempID);
                //tabla o clase a la que pertenece
                var tablaNombre = objeto.GetType().Name;
                //llave primaria del objeto
                var llavePrimaria = objetoDB.MovimientoTempID.ToString();

                //generar el historial
                var historialLog = HistorialLogica.EditarEntidad(
                    objeto,
                    objetoDB,
                    tablaNombre,
                    llavePrimaria,
                    User.UsuarioID,
                    db,
                    Motivo,
                    fechaEdicion
                    );

                #endregion

                #region Guardar el historial

                if (historialLog != null)
                {
                    //Cambiar el estado a la entidad a modificada
                    db.Entry(objetoDB).State = EntityState.Modified;
                    //Guardamos la entidad modificada
                    db.SaveChanges();

                    //Guardar el historial
                    db.HistorialLogs.Add(historialLog);
                    db.SaveChanges();
                }

                #endregion

                //------

                #endregion

                AlertaSuccess("Se edito el movimiento: <b>" + movimientoTemp.Folio + "</b>", true);

                //Crear el historial de las piezas del movimiento
                //Agregar, Editar y Eliminar las piezas
                //No se cambiara el estatus a las piezas ya que esto se hara automaticamente o mediante permisos especiales

                //Agregar
                #region Lista Agregar

                db = new RecordFCSContext();
                db.Configuration.LazyLoadingEnabled = false;

                foreach (var item in listaAdd)
                {

                    var ordenActual = db.MovimientoTempPiezas.Where(a => a.PiezaID == item.PiezaID).Count() > 0 ? db.MovimientoTempPiezas.Where(a => a.PiezaID == item.PiezaID).OrderByDescending(a => a.Orden).FirstOrDefault().Orden : 0;

                    item.Orden = item.EnError ? 0 : ordenActual + 1;

                    var temp = ListaPiezas.FirstOrDefault(a => a.PiezaID == item.PiezaID);

                    db.MovimientoTempPiezas.Add(item);

                    //------ Logica HISTORIAL

                    #region Generar el historial

                    //generar el historial
                    var historialLogAdd = HistorialLogica.CrearEntidad(
                        item,
                        "MovimientoTempPieza",
                        item.MovimientoTempID + "," + item.PiezaID,
                        User.UsuarioID,
                        db,
                        fechaEdicion
                        );

                    #endregion

                    #region Agrega el historial

                    if (historialLogAdd != null)
                    {
                        //Guardar el historial
                        db.HistorialLogs.Add(historialLogAdd);
                        AlertaSuccess("Se agrego la pieza [<b>" + temp.FolioPieza + "</b>]", true);
                    }
                    else
                    {
                        AlertaSuccess("No se pudo agregar la pieza [<b>" + temp.FolioPieza + "</b>]", true);
                    }
                    #endregion

                    //------

                }

                #region Guardar el historial y la entidad

                //Guardar todo
                db.SaveChanges();

                #endregion

                #endregion

                //Editar
                #region Lista Editar

                db = new RecordFCSContext();
                db.Configuration.LazyLoadingEnabled = false;

                foreach (var item in listaEdit.ToList())
                {

                    //Piezas SeMovio = no se pueden edita

                    //buscar la pieza
                    //var pieza = db.Piezas.Find(item.PiezaID);
                    var piezaMovOriginal = db.MovimientoTempPiezas.FirstOrDefault(a => a.PiezaID == item.PiezaID && a.MovimientoTempID == movimientoTemp.MovimientoTempID);

                    if (piezaMovOriginal.SeMovio)
                    {
                        listaEdit.Remove(item);
                    }
                    else
                    {
                        //saber si la pieza cambio en el campo error
                        //valor original - valor nuevo
                        bool ConCambios = piezaMovOriginal.EnError != item.EnError;

                        if (ConCambios)
                        {
                            //Sufrio cambios
                            if (item.EnError)
                            {
                                //ahora con errores
                                //item.Orden = 0;
                                item.EnError = true;
                                item.EsPendiente = true;
                                item.SeMovio = false;
                            }
                            else
                            {
                                //ahora sin errores
                                if (piezaMovOriginal.Orden == 0)
                                {
                                    //generar un orden
                                    var ordenActual = db.MovimientoTempPiezas.Where(a => a.PiezaID == item.PiezaID).Count() > 0 ? db.MovimientoTempPiezas.Where(a => a.PiezaID == item.PiezaID).OrderByDescending(a => a.Orden).FirstOrDefault().Orden : 0;
                                    item.Orden = item.EnError ? 0 : ordenActual + 1;
                                }

                                item.Comentario = "";
                                item.EnError = false;
                                item.EsPendiente = true;
                                item.SeMovio = false;
                            }
                        }
                        else
                        {
                            item.Comentario = piezaMovOriginal.Comentario;
                            item.EnError = piezaMovOriginal.EnError;
                            item.EsPendiente = piezaMovOriginal.EsPendiente;
                            item.Orden = piezaMovOriginal.Orden;
                            item.SeMovio = piezaMovOriginal.SeMovio;
                        }

                        piezaMovOriginal = null;

                        //buscar el objeto
                        var itemTemp = db.MovimientoTempPiezas.Find(item.MovimientoTempID, item.PiezaID);
                        itemTemp.Comentario = item.Comentario;
                        itemTemp.EnError = item.EnError;
                        itemTemp.EsPendiente = item.EsPendiente;
                        itemTemp.Orden = item.Orden;
                        itemTemp.SeMovio = item.SeMovio;
                        itemTemp.FolioPieza = item.FolioPieza;

                        //------ Logica HISTORIAL

                        #region Generar el historial

                        //objeto del formulario
                        var objetoEdit = itemTemp;
                        //Objeto de la base de datos
                        var objetoDBEdit = db.MovimientoTempPiezas.Find(itemTemp.MovimientoTempID, itemTemp.PiezaID);
                        //tabla o clase a la que pertenece
                        var tablaNombreEdit = "MovimientoTempPieza";
                        //llave primaria del objeto
                        var llavePrimariaEdit = objetoDBEdit.MovimientoTempID + "," + objetoDBEdit.PiezaID;

                        //generar el historial
                        var historialLogEdit = HistorialLogica.EditarEntidad(
                            objetoEdit,
                            objetoDBEdit,
                            tablaNombreEdit,
                            llavePrimariaEdit,
                            User.UsuarioID,
                            db,
                            Motivo,
                            fechaEdicion
                            );

                        #endregion

                        #region Agrega el historial

                        if (historialLogEdit != null)
                        {
                            //Cambiar el estado a la entidad a modificada
                            db.Entry(objetoDBEdit).State = EntityState.Modified;

                            //Guardar el historial
                            db.HistorialLogs.Add(historialLogEdit);
                        }

                        #endregion

                        //------

                    }
                }

                #region Guardar el historial y la entidad

                //Guardar todo
                db.SaveChanges();

                #endregion

                #endregion

                //Eliminar
                #region ListaEliminar

                db = new RecordFCSContext();
                //db.Configuration.LazyLoadingEnabled = false;

                foreach (var PiezaIDDel in listaGuidActual)
                {

                    var item = db.MovimientoTempPiezas.FirstOrDefault(a => a.PiezaID == PiezaIDDel && a.MovimientoTempID == movimientoTemp.MovimientoTempID);

                    bool esEliminable = false;
                    string Folio = "";
                    bool RegresarHistorial = false;

                    //saber si es eliminable y si se puede regresar el estado
                    if (item != null)
                    {
                        bool esUltimo = db.MovimientoTempPiezas.Where(a => a.PiezaID == item.PiezaID && a.Orden > item.Orden && !a.EnError).Count() > 0 ? false : true;
                        bool conPendientes = db.MovimientoTempPiezas.Where(a => a.PiezaID == item.PiezaID && a.EsPendiente && a.MovimientoTempID != movimientoTemp.MovimientoTempID && !a.EnError).Count() > 0 ? true : false;

                        Folio = item.Pieza.ImprimirFolio();

                        if (item.SeMovio)
                        {
                            if (esUltimo)
                            {
                                esEliminable = true;
                                RegresarHistorial = true;
                            }
                        }
                        else
                        {
                            if (item.EsPendiente)
                            {
                                esEliminable = true;
                            }
                        }
                    }

                    //es eliminable
                    if (esEliminable)
                    {
                        db.MovimientoTempPiezas.Remove(item);

                        //------ Logica HISTORIAL

                        #region Generar el historial

                        // Generar el historial
                        var historialLogDel =
                            HistorialLogica.EliminarEntidad(
                            item,
                            "MovimientoTempPieza",
                            item.MovimientoTempID + "," + item.PiezaID,
                            User.UsuarioID,
                            db,
                            fechaEdicion);

                        #endregion

                        #region Guardar el historial

                        //Guardar cambios si todo salio correcto
                        if (historialLogDel != null)
                        {
                            //Guardar el historial
                            db.HistorialLogs.Add(historialLogDel);

                            AlertaDanger("Se elimino la pieza [<b>" + Folio + "</b>]", true);

                        }

                        #endregion

                        //------

                        //Regresar el estado de la pieza
                        if (RegresarHistorial)
                        {
                            item = null;
                            var pieza = db.Piezas.Find(PiezaIDDel);
                            if (pieza != null)
                            {
                                if (pieza.UbicacionID == movimientoTemp.UbicacionDestinoID)
                                {
                                    pieza.UbicacionID = movimientoTemp.UbicacionOrigenID;

                                    //------ Logica HISTORIAL

                                    #region Generar el historial

                                    //objeto del formulario
                                    var objetoDelUbi = pieza;
                                    //Objeto de la base de datos
                                    var objetoDBDelUbi = db.Piezas.Find(pieza.PiezaID);
                                    //tabla o clase a la que pertenece
                                    var tablaNombreDelUbi = "Pieza";
                                    //llave primaria del objeto
                                    var llavePrimariaDelUbi = objetoDBDelUbi.PiezaID.ToString();

                                    //generar el historial
                                    var historialLogDelUbi = HistorialLogica.EditarEntidad(
                                        objetoDelUbi,
                                        objetoDBDelUbi,
                                        tablaNombreDelUbi,
                                        llavePrimariaDelUbi,
                                        User.UsuarioID,
                                        db,
                                        "Retornar Movimiento: " + movimientoTemp.Folio,
                                        fechaEdicion
                                        );

                                    #endregion

                                    #region Guardar el historial

                                    if (historialLogDelUbi != null)
                                    {
                                        //Cambiar el estado a la entidad a modificada
                                        db.Entry(objetoDBDelUbi).State = EntityState.Modified;

                                        //Guardar el historial
                                        db.HistorialLogs.Add(historialLogDelUbi);

                                    }

                                    #endregion

                                    //------

                                }
                            }
                        }
                    }
                }

                #region Guardar el historial

                //Guardar todo
                db.SaveChanges();

                #endregion

                #endregion

                if (ForzarMovimiento)
                {
                    //Logica para forzar el movimiento
                    db = new RecordFCSContext();

                    var mov = db.MovimientosTemp.Find(movimientoTemp.MovimientoTempID);

                    var EstadoActual = mov.EstadoMovimiento.Value;

                    //Solo acepta movimientos que no esten cancelados o que tengan retorno
                    if (mov.MovimientoTempPiezas.Where(a => !a.SeMovio && !a.EnError && a.EsPendiente).Count() > 0)
                    {
                        if (EstadoActual == EstadoMovimientoTemp.Concluido ||
                            EstadoActual == EstadoMovimientoTemp.Concluido_SinValidar ||
                            EstadoActual == EstadoMovimientoTemp.Procesando)
                        {
                            //Sirve para cambiar la ubicacion a las piezas

                            //Elegir el estado al cual pasara
                            //Ignorando la fecha
                            switch (EstadoActual)
                            {
                                case EstadoMovimientoTemp.Concluido_SinValidar:
                                    //Comprobar si el movimiento ya es valido
                                    if (mov.EsValido)
                                        EstadoActual = EstadoMovimientoTemp.Concluido;
                                    break;
                                case EstadoMovimientoTemp.Procesando:
                                    //Comprobar si el movimiento ya es valido
                                    if (mov.EsValido)
                                        EstadoActual = EstadoMovimientoTemp.Concluido;
                                    else
                                        EstadoActual = EstadoMovimientoTemp.Concluido_SinValidar;
                                    break;
                            }

                            mov.EstadoMovimiento = EstadoActual;

                            EjecutarMovimiento(mov, EstadoActual, fechaEdicion);

                        }

                    }

                }

                return Json(new { success = true, url = Url.Action("Detalles", new { id = movimientoTemp.MovimientoTempID }) });
            }

            //Si Error
            #region Logica si ocurre un error

            var listaUbicaciones = db.Ubicaciones.Where(a => a.Status).Select(a => new { a.Nombre, a.UbicacionID }).OrderBy(a => a.Nombre);

            //Ubicacion destino no puede editarse si se encuentra por lo menos una Pieza Procesada
            ViewBag.UbiDestinoEnabled = movimientoTemp.MovimientoTempPiezas.Where(a => a.SeMovio).Count() == 0 ? true : false;

            ViewBag.UbicacionDestinoID = new SelectList(listaUbicaciones, "UbicacionID", "Nombre", movimientoTemp.UbicacionDestinoID);

            #region Validar navegacion de movimientos

            // 1 2 3 4 [5] 6 7 8 9 10
            // [1] 2 3 4 5 6 7 8 9 10
            // 1 2 3 4 5 6 7 8 9 9 [10]

            MovimientoTemp movTemp = null;
            movTemp = db.MovimientosTemp.Where(a => a.Folio < movimientoTemp.Folio).OrderByDescending(a => a.Folio).FirstOrDefault();
            ViewBag.MovAnterior = movTemp == null ? Guid.Empty : movTemp.MovimientoTempID;

            movTemp = db.MovimientosTemp.Where(a => a.Folio > movimientoTemp.Folio).OrderBy(a => a.Folio).FirstOrDefault();
            ViewBag.MovSiguiente = movTemp == null ? Guid.Empty : movTemp.MovimientoTempID;

            #endregion

            #endregion

            return View(movimientoTemp);
        }
        public ActionResult RevertirMovimientoConfirmado(Guid MovimientoTempID, bool Executar)
        {
            db = new RecordFCSContext();

            bool bandera = false;

            if (Executar)
            {
                try
                {
                    //Buscar el movimiento

                    MovimientoTemp mov = db.MovimientosTemp.Find(MovimientoTempID);

                    if (mov != null && Executar)
                    {
                        var Fecha = DateTime.Now;
                        var Motivo = "Revertir movimiento.";
                        //Cambiar el estado del movimiento
                        mov.EstadoMovimiento = EstadoMovimientoTemp.Procesando;
                        mov.FechaUltimaEjecucion = Fecha;

                        //------ Logica HISTORIAL

                        #region Generar el historial

                        //objeto del formulario
                        var objeto3 = mov;
                        //Objeto de la base de datos
                        var objetoDB3 = db.MovimientosTemp.Find(mov.MovimientoTempID);
                        //tabla o clase a la que pertenece
                        var tablaNombre3 = "MovimientoTemp";
                        //llave primaria del objeto
                        var llavePrimaria3 = objetoDB3.MovimientoTempID.ToString();

                        //generar el historial
                        var historialLog3 = HistorialLogica.EditarEntidad(
                            objeto3,
                            objetoDB3,
                            tablaNombre3,
                            llavePrimaria3,
                            User.UsuarioID,
                            db,
                            Motivo,
                            Fecha
                            );

                        #endregion

                        #region Guardar el historial

                        if (historialLog3 != null)
                        {
                            //Cambiar el estado a la entidad a modificada
                            db.Entry(objetoDB3).State = EntityState.Modified;
                            //Guardamos la entidad modificada
                            db.SaveChanges();

                            //Guardar el historial
                            db.HistorialLogs.Add(historialLog3);
                            db.SaveChanges();
                            bandera = true;

                        }
                        else
                        {
                            throw new Exception();
                        }
                        #endregion

                        //------

                    }
                    else
                    {
                        bandera = false;
                    }
                }
                catch (Exception)
                {

                    bandera = false;
                }
            }

            if (bandera)
                AlertaDefault("Se Revertio el moviento a " + EstadoMovimientoTemp.Procesando);
            else
                AlertaDefault("No se pudo revertir el movimiento");

            var url = Url.Action("Detalles", "MovimientoTemp", new { id = MovimientoTempID });

            return Json(new { success = bandera, url = url });
        }
        public static HistorialLog EditarEntidad(object objeto, object objetoDB, string tablaNombre, string llavePrimaria, Guid usuarioID, RecordFCSContext db, string motivo, DateTime? EventoFecha = null)
        {
            HistorialLog historialLog;

            EventoFecha = EventoFecha ?? DateTime.Now;

            try
            {
                #region Crear entidades

                //Entidad extraida de la base de datos
                var entidadDB = db.Entry(objetoDB);

                //Entidad extraida del formulario
                var entidadForm = db.Entry(objeto);

                #endregion

                #region Binding Campos Nuevos con Actuales

                foreach (var propiedadNombre in entidadDB.CurrentValues.PropertyNames)
                    entidadDB.Property(propiedadNombre).CurrentValue = entidadForm.Property(propiedadNombre).CurrentValue;

                #endregion

                #region Historial validar las propiedades que sufrieron cambios

                List<HistorialLogDetalle> listaHistorialLogDetalles = new List<HistorialLogDetalle>();

                //tipo de evento: Crear, Editar, Eliminar
                string eventoTipo = "Editar";

                //Crear el HistorialLog
                historialLog = new HistorialLog()
                {
                    HistorialLogID = Guid.NewGuid(),
                    EventoFecha = EventoFecha.Value,
                    EventoTipo = eventoTipo,
                    TablaNombre = tablaNombre,
                    LlavePrimaria = llavePrimaria,
                    Motivo = motivo,
                    UsuarioID = usuarioID,
                    CategoriaTipo = ""
                };

                //Crear la lista de propiedades con cambios
                foreach (var propiedadNombre in entidadDB.CurrentValues.PropertyNames.Where(p => entidadDB.Property(p).IsModified))
                {
                    string columnaNombre = propiedadNombre;
                    var valorOriginal = (entidadDB.Property(propiedadNombre).OriginalValue ?? "").ToString();
                    var valorNuevo = (entidadDB.Property(propiedadNombre).CurrentValue ?? "").ToString();

                    listaHistorialLogDetalles.Add(new HistorialLogDetalle()
                    {
                        HistorialLogDetalleID = Guid.NewGuid(),
                        HistorialLogID = historialLog.HistorialLogID,
                        ColumnaNombre = columnaNombre,
                        ValorOriginal = valorOriginal,
                        ValorNuevo = valorNuevo
                    });
                }

                #endregion

                #region Validar el historial

                if (listaHistorialLogDetalles.Count > 0)
                    historialLog.HistorialLogDetalles = listaHistorialLogDetalles;
                else
                    historialLog = null;

                #endregion

            }
            catch (Exception)
            {

                historialLog = null;
            }

            return historialLog;
        }
        public ActionResult IniciarMigracion()
        {
            int NumFol = 0; //ultima registrada

            RecordFCSContext dbx = new RecordFCSContext();

            int bloqueGuardar = 500;

            Guid TipoObraID = new Guid("375ead18-18db-4a8e-bfbf-7d55ee08ff80");
            TipoObra tipoObra = dbx.TipoObras.Find(TipoObraID);

            Guid TipoPiezaID = new Guid("c84ed502-20d8-4691-9a17-2d739c2bf4da");
            TipoPieza tipoPieza = tipoObra.TipoPiezas.FirstOrDefault(a => a.TipoPiezaID == TipoPiezaID);

            LetraFolio letra = dbx.LetraFolios.SingleOrDefault(a => a.Nombre == "A");

            if (tipoObra != null && tipoPieza != null && letra != null)
            {

                //Extraer los atributos requeridos.
                var listaAttRegistro = tipoPieza.Atributos.Where(a => a.Status && a.MostrarAtributos.Any(b => b.TipoMostrar.Nombre == "Registro" && b.Status) && a.TipoAtributo.Status).OrderBy(a => a.Orden).ToList();

                //extraer
                con1.Open();
                string textSql1 = string.Format("SELECT * FROM [{0}]", "ArchivoFondo");
                SqlCommand sql1 = new SqlCommand(textSql1, con1);
                SqlDataReader leer1 = sql1.ExecuteReader();

                List<RowArchivo> listaArchivoCEHM = new List<RowArchivo>();

                int i = NumFol;

                while (leer1.Read())
                {
                    i++;
                    var rowArchivo = new RowArchivo()
                    {
                        ArchivoID = Convert.ToInt32(i),
                        Asunto1 = Regex.Replace(leer1["Asunto1"].ToString().Trim(), @"\s+", " "),
                        Asunto2 = Regex.Replace(leer1["Asunto2"].ToString().Trim(), @"\s+", " "),
                        Caja = Regex.Replace(leer1["Caja"].ToString().Trim(), @"\s+", " "),
                        Carpeta = Regex.Replace(leer1["Carpeta"].ToString().Trim(), @"\s+", " "),
                        Clasificacion = Regex.Replace(leer1["Clasificacion"].ToString().Trim(), @"\s+", " "),
                        Documento = Regex.Replace(leer1["Documento"].ToString().Trim(), @"\s+", " "),
                        FICHA_NO = Convert.ToInt32(leer1["FICHA_NO"]),
                        Firmadopor = Regex.Replace(leer1["Firmadopor"].ToString().Trim(), @"\s+", " "),
                        Fojas = Regex.Replace(leer1["Fojas"].ToString().Trim(), @"\s+", " "),
                        Fondo = Regex.Replace(leer1["Fondo"].ToString().Trim(), @"\s+", " "),
                        Legajo = Regex.Replace(leer1["Legajo"].ToString().Trim(), @"\s+", " "),
                        LugaryFecha = Regex.Replace(leer1["LugaryFecha"].ToString().Trim(), @"\s+", " "),
                        NoImag = Convert.ToInt32(leer1["NoImag"].ToString() == "" ? 0 : leer1["NoImag"]),
                        Nombredelfondo = Regex.Replace(leer1["Nombredelfondo"].ToString().Trim(), @"\s+", " "),
                        Tipodedocumento = Regex.Replace(leer1["Tipodedocumento"].ToString().Trim(), @"\s+", " "),
                        URLFicha = Regex.Replace(leer1["URLFicha"].ToString().Trim(), @"\s+", " "),
                        URLImagen = Regex.Replace(leer1["URLImagen"].ToString().Trim(), @"\s+", " "),
                        Tema = Regex.Replace(leer1["Tema"].ToString().Trim(), @"\s+", " "),
                        Dirigidoa = Regex.Replace(leer1["Dirigidoa"].ToString().Trim(), @"\s+", " ")

                    };

                    if (rowArchivo.ArchivoID > 0)
                        listaArchivoCEHM.Add(rowArchivo);

                }
                con1.Close();
                leer1 = null;

                int numeroRow = 0;
                List<AtributoPieza> listaAdd_AttGen = new List<AtributoPieza>();
                List<AutorPieza> listaAdd_AttAutor = new List<AutorPieza>();

                foreach (var row in listaArchivoCEHM)
                {

                    if(numeroRow == bloqueGuardar)
                    {
                        //guardar los atributos
                        dbx.AtributoPiezas.AddRange(listaAdd_AttGen);
                        dbx.AutorPiezas.AddRange(listaAdd_AttAutor);
                        dbx.SaveChanges();

                        dbx.Dispose();
                        dbx = new RecordFCSContext();
                        dbx.Configuration.AutoDetectChangesEnabled = false;

                        numeroRow = 0;
                        listaAdd_AttAutor = new List<AutorPieza>();
                        listaAdd_AttGen = new List<AtributoPieza>();

                    }

                    //tratar los att de la pieza
                    var obra = new Obra()
                    {
                        ObraID = Guid.NewGuid(),
                        FechaRegistro = DateTime.Now,
                        TipoObraID = tipoObra.TipoObraID,
                        LetraFolioID = letra.LetraFolioID,
                        Status = false,
                        NumeroFolio = row.ArchivoID
                    };
                    dbx.Obras.Add(obra);

                    //Crear pieza
                    Pieza pieza = new Pieza()
                    {
                        PiezaID = Guid.NewGuid(),
                        FechaRegistro = obra.FechaRegistro,
                        ObraID = obra.ObraID,
                        Status = false,
                        PiezaPadreID = null, // null = Principal o Maestra
                        TipoPiezaID = tipoPieza.TipoPiezaID,
                        SubFolio = tipoPieza.Prefijo
                    };
                    dbx.Piezas.Add(pieza);

                    foreach (var att in listaAttRegistro)
                    {
                        var tipoAtt = att.TipoAtributo;

                        if (tipoAtt.EsGenerico)
                        {

                            if (tipoAtt.EsLista)
                            {
                                /*
                                 * GENERICO LISTA
                                 * Fondo - Fondo_CEHM - Fondo
                                 * Colección - Coleccion_Clave - Nombredelfondo
                                 * Legajo - Legajo_CEHM - Legajo
                                 * Fecha de ejecución - FechaEjecucion_Clave - Fecha de ejecucion
                                 */
                                var addOK = true;
                                string valorText = "";
                                switch (tipoAtt.Temp)
                                {
                                    case "Fondo_CEHM":
                                        addOK = row.Fondo == null || row.Fondo == "" ? false : true;
                                        valorText = addOK ? row.Fondo : "";
                                        break;
                                    case "Coleccion_Clave":
                                        addOK = row.Nombredelfondo == null || row.Nombredelfondo == "" ? false : true;
                                        valorText = addOK ? row.Nombredelfondo : "";
                                        break;
                                    case "Legajo_CEHM":
                                        addOK = row.Legajo == null || row.Legajo == "" ? false : true;
                                        valorText = addOK ? row.Legajo : "";
                                        break;
                                    case "FechaEjecucion_Clave":
                                        addOK = row.LugaryFecha == null || row.LugaryFecha == "" ? false : true;
                                        valorText = addOK ? row.LugaryFecha : "";
                                        break;
                                    default:
                                        addOK = false;
                                        break;
                                }

                                if (addOK)
                                {
                                    var listaValor = dbx.ListaValores.SingleOrDefault(a => a.TipoAtributoID == tipoAtt.TipoAtributoID && a.Valor == valorText);

                                    if (listaValor == null)
                                    {
                                        listaValor = new ListaValor()
                                        {
                                            ListaValorID = Guid.NewGuid(),
                                            Status = true,
                                            TipoAtributoID = tipoAtt.TipoAtributoID,
                                            Valor = valorText
                                        };
                                        dbx.ListaValores.Add(listaValor);
                                        dbx.SaveChanges();
                                    }

                                    listaAdd_AttGen.Add(new AtributoPieza()
                                    {
                                        AtributoPiezaID = Guid.NewGuid(),
                                        AtributoID = att.AtributoID,
                                        PiezaID = pieza.PiezaID,
                                        Status = true,
                                        ListaValorID = listaValor.ListaValorID
                                    });
                                }

                            }
                            else
                            {
                                if (tipoAtt.EsMultipleValor)
                                {
                                    /*
                                     * GENERICO TEXTO MULTIPLE
                                     * Descripción - descripcion
                                     *
                                     *
                                     * Se forma con : Asunto1, Asunto2, Tema

                                     */

                                    var addOK = true;
                                    string valorText = "";

                                    switch (tipoAtt.Temp)
                                    {
                                        case "descripcion":
                                            // Tema
                                            addOK = true;
                                            valorText = "";
                                            addOK = row.Tema == null || row.Tema == "" ? false : true;

                                            valorText = addOK ? row.Tema : "";

                                            if (addOK)
                                            {
                                                listaAdd_AttGen.Add(new AtributoPieza()
                                                {
                                                    AtributoPiezaID = Guid.NewGuid(),
                                                    AtributoID = att.AtributoID,
                                                    PiezaID = pieza.PiezaID,
                                                    Status = true,
                                                    Valor = valorText
                                                });
                                            }

                                            // Asunto1
                                            addOK = true;
                                            valorText = "";
                                            addOK = row.Asunto1 == null || row.Asunto1 == "" ? false : true;

                                            valorText = addOK ? row.Asunto1 : "";
                                            if (addOK)
                                            {
                                                listaAdd_AttGen.Add(new AtributoPieza()
                                                {
                                                    AtributoPiezaID = Guid.NewGuid(),
                                                    AtributoID = att.AtributoID,
                                                    PiezaID = pieza.PiezaID,
                                                    Status = true,
                                                    Valor = valorText
                                                });
                                            }

                                            // Asunto2
                                            addOK = true;
                                            valorText = "";
                                            addOK = row.Asunto2 == null || row.Asunto2 == "" ? false : true;

                                            valorText = addOK ? row.Asunto2 : "";
                                            if (addOK)
                                            {
                                                listaAdd_AttGen.Add(new AtributoPieza()
                                                {
                                                    AtributoPiezaID = Guid.NewGuid(),
                                                    AtributoID = att.AtributoID,
                                                    PiezaID = pieza.PiezaID,
                                                    Status = true,
                                                    Valor = valorText
                                                });
                                            }

                                            break;
                                        default:
                                            addOK = false;
                                            break;
                                    }

                                }
                                else
                                {
                                    /*
                                     * GENERICOS TEXTO
                                     * No ficha CEHM            - NoFicha_CEHM
                                     * Clasificacion CEHM       - Clasificacion_CEHM
                                     * No de caja o carpeta     - NoCajaOCarpeta_Cehm
                                     * No de documento o fojas  - NoDocFojas_CEHM
                                     * Título descriptivo       - titulo
                                     * Enlace ficha             - UrlFicha_CEHM
                                     * No de imagenes           - NoImagen_CEHM
                                     * Enlace Imagenes          - URLImagen_CEHM
                                     */

                                    var addOK = true;
                                    string valorText = "";

                                    switch (tipoAtt.Temp)
                                    {
                                        case "NoFicha_CEHM":
                                            addOK = row.FICHA_NO == 0 ? false : true;
                                            valorText = addOK ? row.FICHA_NO.ToString() : "0";
                                            break;

                                        case "Clasificacion_CEHM":
                                            addOK = row.Clasificacion == null || row.Clasificacion == "" ? false : true;
                                            valorText = addOK ? row.Clasificacion : "";
                                            break;

                                        case "NoCajaOCarpeta_Cehm":
                                            // se forma con:  caja y carpeta
                                            // queda: Caja: 1 / Carpeta: 1
                                            // queda: Caja: 1
                                            // queda: Carpeta : 1
                                            var cajaOk = false;
                                            addOK = row.Caja == null || row.Caja == "" ? false : true;
                                            valorText += addOK? "" + row.Caja : "";
                                            cajaOk = addOK;
                                            addOK = row.Carpeta == null || row.Carpeta == "" ? false : true;
                                            valorText += cajaOk && addOK? " / " : "";
                                            valorText += addOK ? "" + row.Carpeta : "";
                                            addOK = addOK || cajaOk ? true : false;
                                            break;

                                        case "NoDocFojas_CEHM":
                                            // se forma con Fojas, Documento
                                            var fojaOk = false;
                                            addOK = row.Fojas == null || row.Fojas == "" ? false : true;
                                            valorText += addOK? "" + row.Fojas : "";
                                            fojaOk = addOK;
                                            addOK = row.Documento == null || row.Documento == "" ? false : true;
                                            valorText += fojaOk && addOK? " / " : "";
                                            valorText += addOK ? "" + row.Documento : "";
                                            addOK = addOK || fojaOk ? true : false;
                                            break;

                                        case "titulo":
                                            // Tipodedocumento, Dirigidoa

                                            var tipoDocOk = false;
                                            addOK = row.Tipodedocumento == null || row.Tipodedocumento == "" ? false : true;
                                            valorText += addOK? row.Tipodedocumento : "";
                                            tipoDocOk = addOK;
                                            addOK = row.Dirigidoa == null || row.Dirigidoa == "" ? false : true;
                                            valorText += tipoDocOk && addOK ? " / " : "";
                                            valorText += addOK ? row.Dirigidoa : "";
                                            addOK = addOK || tipoDocOk ? true : false;
                                            break;
                                        case "UrlFicha_CEHM":
                                            addOK = row.URLFicha == null || row.URLFicha == "" ? false : true;
                                            valorText = addOK ? row.URLFicha : "";
                                            break;
                                        case "NoImagen_CEHM":
                                            addOK = row.NoImag == 0 ? false : true;
                                            valorText = addOK ? row.NoImag.ToString() : "0";
                                            addOK = true;
                                            break;
                                        case "URLImagen_CEHM":
                                            addOK = row.URLImagen == null || row.URLImagen == "" ? false : true;
                                            valorText = addOK ? row.URLImagen : "";
                                            break;

                                        default:
                                            addOK = false;
                                            break;
                                    }

                                    if (addOK)
                                    {
                                        listaAdd_AttGen.Add(new AtributoPieza()
                                        {
                                            AtributoPiezaID = Guid.NewGuid(),
                                            AtributoID = att.AtributoID,
                                            PiezaID = pieza.PiezaID,
                                            Status = true,
                                            Valor = valorText
                                        });

                                    }

                                }
                            }

                        }
                        else
                        {
                            /*
                             * AUTOR LISTA MULTIPLE
                             * Firmado por
                             */

                            var addOK = true;
                            string valorText = "";

                            addOK = row.Firmadopor == null || row.Firmadopor == "" ? false : true;
                            valorText = addOK ? row.Firmadopor : "";

                            if (addOK)
                            {
                                var autor = dbx.Autores.SingleOrDefault(a => a.Nombre == valorText);

                                if (autor == null)
                                {
                                    autor = new Autor()
                                    {
                                        AutorID = Guid.NewGuid(),
                                        Status = true,
                                        Nombre = valorText
                                    };
                                    dbx.Autores.Add(autor);
                                    dbx.SaveChanges();
                                }

                                listaAdd_AttAutor.Add(new AutorPieza()
                                    {
                                        AutorID = autor.AutorID,
                                        esPrincipal = true,
                                        PiezaID = pieza.PiezaID,
                                        Status = true,
                                        Prefijo = "Principal"
                                    });

                            }

                        }

                    }

                    numeroRow++;
                }

                    //guardar los atributos
                    dbx.AtributoPiezas.AddRange(listaAdd_AttGen);
                    dbx.AutorPiezas.AddRange(listaAdd_AttAutor);
                    dbx.SaveChanges();

                    dbx.Dispose();
                    dbx = new RecordFCSContext();
                    dbx.Configuration.AutoDetectChangesEnabled = false;

            }

            return View();
        }