public ActionResult Crear(Int64? id)
        {
            if (id == null)
            {
                return new HttpStatusCodeResult(HttpStatusCode.BadRequest);
            }
            Pieza pieza = db.Piezas.Find(id);
            if (pieza == null)
            {
                return HttpNotFound();
            }
            var autorPieza = new AutorPieza()
            {
                PiezaID = pieza.PiezaID,
                Status = true
            };

            return PartialView("_Crear", autorPieza);
        }
        //IMPORTAR PIEZA DESCRIPTIVO ALTERNATIVO
        public ActionResult ImportarPieza_Descriptivo_alternativo()
        {
            var tipoAtt_Autor = db.TipoAtributos.Where(a => a.AntNombre == "Autor_Clave").AsEnumerable().Select(a => new { a.TipoAtributoID, a.AntNombre, a.EsLista }).FirstOrDefault();
            var tipoAttGen_titulo = db.TipoAtributos.Where(a => a.AntNombre == "titulo").AsEnumerable().Select(a => new { a.TipoAtributoID, a.AntNombre, a.EsLista }).FirstOrDefault();
            var tipoAttGen_EscArt = db.TipoAtributos.Where(a => a.AntNombre == "EscArtistica_Clave").AsEnumerable().Select(a => new { a.TipoAtributoID, a.AntNombre, a.EsLista }).FirstOrDefault();
            var tipoAttGen_FormAdq = db.TipoAtributos.Where(a => a.AntNombre == "FormaAdquisicion_Clave").AsEnumerable().Select(a => new { a.TipoAtributoID, a.AntNombre, a.EsLista }).FirstOrDefault();
            var tipoAttGen_ProcedenList = db.TipoAtributos.Where(a => a.AntNombre == "Procedencia_Clave").AsEnumerable().Select(a => new { a.TipoAtributoID, a.AntNombre, a.EsLista }).FirstOrDefault();
            var tipoAttGen_FiliEst = db.TipoAtributos.Where(a => a.AntNombre == "FiliacionEstilistica_Clave").AsEnumerable().Select(a => new { a.TipoAtributoID, a.AntNombre, a.EsLista }).FirstOrDefault();
            var tipoAttGen_CasaComer = db.TipoAtributos.Where(a => a.AntNombre == "CasaComercial_Clave").AsEnumerable().Select(a => new { a.TipoAtributoID, a.AntNombre, a.EsLista }).FirstOrDefault();
            var tipoAttGen_EdoConserv = db.TipoAtributos.Where(a => a.AntNombre == "EdoConservacion_Clave").AsEnumerable().Select(a => new { a.TipoAtributoID, a.AntNombre, a.EsLista }).FirstOrDefault();
            var tipoAttGen_descripcion = db.TipoAtributos.Where(a => a.AntNombre == "descripcion").AsEnumerable().Select(a => new { a.TipoAtributoID, a.AntNombre, a.EsLista }).FirstOrDefault();
            var tipoAttGen_otros_mat = db.TipoAtributos.Where(a => a.AntNombre == "otros_materiales").AsEnumerable().Select(a => new { a.TipoAtributoID, a.AntNombre, a.EsLista }).FirstOrDefault();
            var tipoAttGen_catalogo = db.TipoAtributos.Where(a => a.AntNombre == "catalogo").AsEnumerable().Select(a => new { a.TipoAtributoID, a.AntNombre, a.EsLista }).FirstOrDefault();
            var tipoAttGen_num_cat = db.TipoAtributos.Where(a => a.AntNombre == "numero_catalogo").AsEnumerable().Select(a => new { a.TipoAtributoID, a.AntNombre, a.EsLista }).FirstOrDefault();
            var tipoAttGen_num_reg = db.TipoAtributos.Where(a => a.AntNombre == "numero_registro").AsEnumerable().Select(a => new { a.TipoAtributoID, a.AntNombre, a.EsLista }).FirstOrDefault();
            var tipoAttGen_titu_ori = db.TipoAtributos.Where(a => a.AntNombre == "titulo_ori").AsEnumerable().Select(a => new { a.TipoAtributoID, a.AntNombre, a.EsLista }).FirstOrDefault();
            var tipoAttGen_Proceden = db.TipoAtributos.Where(a => a.AntNombre == "Procedencia").AsEnumerable().Select(a => new { a.TipoAtributoID, a.AntNombre, a.EsLista }).FirstOrDefault();

            List<string> camposLista = new List<string>()
            {
                "Autor_Clave",
                "titulo",
                "EscArtistica_Clave",
                "FormaAdquisicion_Clave",
                "Procedencia_Clave",
                "FiliacionEstilistica_Clave",
                "CasaComercial_Clave",
                "EdoConservacion_Clave",
                "descripcion",
                "otros_materiales",
                "catalogo",
                "numero_catalogo",
                "numero_registro",
                "titulo_ori",
                "Procedencia"
            };

            ViewBag.NombreTabla = "CATALOGO DE OBRAS - PIEZA DESCRIPTIVO ALTERNATIVO";

            ViewBag.error = "";

            try
            {
                // mandar mensaje de conexion
                ViewBag.mensaje = "Conexión establecida";
                //definir el sql
                Int64 actual = 2528; //colocar el OBRAID
                Int64 limite = 70000;

                while (actual <= limite)
                {
                    //todo sera sobre la obra y pieza default
                    var obra = db.Obras.Find(actual);

                    if (obra != null)
                    {
                        var piezaMaestra = obra.Piezas.FirstOrDefault();
                        if (piezaMaestra != null)
                        {
                            string AnteriorID = obra.AntID;
                            con1.Open();
                            string textSql1 = string.Format("SELECT TOP 1 * FROM [m_pieza_descriptivo] WHERE [id_pieza] = {0}", AnteriorID);
                            SqlCommand sql1 = new SqlCommand(textSql1, con1);
                            SqlDataReader leer1 = sql1.ExecuteReader();

                            if (leer1.FieldCount > 0)
                            {
                                leer1.Read();
                                foreach (var campoText in camposLista)
                                {
                                    TipoAtributo tipoAtributo = null;
                                    switch (campoText)
                                    {
                                        case "Autor_Clave": tipoAtributo = new TipoAtributo() { TipoAtributoID = tipoAtt_Autor.TipoAtributoID, EsLista = tipoAtt_Autor.EsLista, AntNombre = tipoAtt_Autor.AntNombre }; break;
                                        case "titulo": tipoAtributo = new TipoAtributo() { TipoAtributoID = tipoAttGen_titulo.TipoAtributoID, EsLista = tipoAttGen_titulo.EsLista, AntNombre = tipoAttGen_titulo.AntNombre }; break;
                                        case "EscArtistica_Clave": tipoAtributo = new TipoAtributo() { TipoAtributoID = tipoAttGen_EscArt.TipoAtributoID, EsLista = tipoAttGen_EscArt.EsLista, AntNombre = tipoAttGen_EscArt.AntNombre }; break;
                                        case "FormaAdquisicion_Clave": tipoAtributo = new TipoAtributo() { TipoAtributoID = tipoAttGen_FormAdq.TipoAtributoID, EsLista = tipoAttGen_FormAdq.EsLista, AntNombre = tipoAttGen_FormAdq.AntNombre }; break;
                                        case "Procedencia_Clave": tipoAtributo = new TipoAtributo() { TipoAtributoID = tipoAttGen_ProcedenList.TipoAtributoID, EsLista = tipoAttGen_ProcedenList.EsLista, AntNombre = tipoAttGen_ProcedenList.AntNombre }; break;
                                        case "FiliacionEstilistica_Clave": tipoAtributo = new TipoAtributo() { TipoAtributoID = tipoAttGen_FiliEst.TipoAtributoID, EsLista = tipoAttGen_FiliEst.EsLista, AntNombre = tipoAttGen_FiliEst.AntNombre }; break;
                                        case "CasaComercial_Clave": tipoAtributo = new TipoAtributo() { TipoAtributoID = tipoAttGen_CasaComer.TipoAtributoID, EsLista = tipoAttGen_CasaComer.EsLista, AntNombre = tipoAttGen_CasaComer.AntNombre }; break;
                                        case "EdoConservacion_Clave": tipoAtributo = new TipoAtributo() { TipoAtributoID = tipoAttGen_EdoConserv.TipoAtributoID, EsLista = tipoAttGen_EdoConserv.EsLista, AntNombre = tipoAttGen_EdoConserv.AntNombre }; break;
                                        case "descripcion": tipoAtributo = new TipoAtributo() { TipoAtributoID = tipoAttGen_descripcion.TipoAtributoID, EsLista = tipoAttGen_descripcion.EsLista, AntNombre = tipoAttGen_descripcion.AntNombre }; break;
                                        case "otros_materiales": tipoAtributo = new TipoAtributo() { TipoAtributoID = tipoAttGen_otros_mat.TipoAtributoID, EsLista = tipoAttGen_otros_mat.EsLista, AntNombre = tipoAttGen_otros_mat.AntNombre }; break;
                                        case "catalogo": tipoAtributo = new TipoAtributo() { TipoAtributoID = tipoAttGen_catalogo.TipoAtributoID, EsLista = tipoAttGen_catalogo.EsLista, AntNombre = tipoAttGen_catalogo.AntNombre }; break;
                                        case "numero_catalogo": tipoAtributo = new TipoAtributo() { TipoAtributoID = tipoAttGen_num_cat.TipoAtributoID, EsLista = tipoAttGen_num_cat.EsLista, AntNombre = tipoAttGen_num_cat.AntNombre }; break;
                                        case "numero_registro": tipoAtributo = new TipoAtributo() { TipoAtributoID = tipoAttGen_num_reg.TipoAtributoID, EsLista = tipoAttGen_num_reg.EsLista, AntNombre = tipoAttGen_num_reg.AntNombre }; break;
                                        case "titulo_ori": tipoAtributo = new TipoAtributo() { TipoAtributoID = tipoAttGen_titu_ori.TipoAtributoID, EsLista = tipoAttGen_titu_ori.EsLista, AntNombre = tipoAttGen_titu_ori.AntNombre }; break;
                                        case "Procedencia": tipoAtributo = new TipoAtributo() { TipoAtributoID = tipoAttGen_Proceden.TipoAtributoID, EsLista = tipoAttGen_Proceden.EsLista, AntNombre = tipoAttGen_Proceden.AntNombre }; break;
                                        default:
                                            ViewBag.mensajeError = "No existe la Obra";
                                            break;
                                    };

                                    if (tipoAtributo != null)
                                    {
                                        //Extraer el valor del query leer1
                                        string valorCampoExtra = leer1[campoText].ToString();
                                        //validar el valor del campo
                                        bool todoOK = true;

                                        if (tipoAtributo.EsLista)
                                        {
                                            if (valorCampoExtra == "0")
                                                todoOK = false;
                                        }
                                        else
                                        {
                                            if (valorCampoExtra == "0" || valorCampoExtra == "" || valorCampoExtra == " " || valorCampoExtra == "-" || valorCampoExtra == " -" || valorCampoExtra == "." || valorCampoExtra == " ." || valorCampoExtra == "Pendiente por definir")
                                                todoOK = false;
                                        };

                                        if (todoOK)
                                        {
                                            //Buscar que el ATRIBUTO Exista en TipoPieza con TipoPieza y TipoAtributo
                                            Int64 atributoID = db.Atributos.Where(a => a.TipoAtributoID == tipoAtributo.TipoAtributoID && a.TipoPiezaID == piezaMaestra.TipoPiezaID).Select(a => a.AtributoID).FirstOrDefault();

                                            if (atributoID == 0)
                                            {
                                                //si ATRIBUTO no existe entonces crearlo, primero crear
                                                //en TIPOOBRA el TipoAtributo

                                                //TIPOPIEZA * ATRIBUTOS
                                                Atributo atributo = new Atributo()
                                                {
                                                    TipoPiezaID = piezaMaestra.TipoPiezaID,
                                                    TipoAtributoID = tipoAtributo.TipoAtributoID,
                                                    NombreAlterno = null,
                                                    Orden = 98,
                                                    Status = true,
                                                    Requerido = false,
                                                    EnFichaBasica = false

                                                };

                                                db.Atributos.Add(atributo);
                                                db.SaveChanges();

                                                atributoID = atributo.AtributoID;
                                            }//fin creacion de atributo null

                                            //comenzar creacion del AtributoPieza con el valor extraido y validado
                                            //se podria generar la validacion de si ya existe, actualizarlo
                                            bool crear = false;
                                            AtributoPieza attPieza = db.AtributoPiezas.Find(piezaMaestra.PiezaID, atributoID);
                                            if (attPieza == null)
                                            {
                                                //crear el AtributoPieza
                                                crear = true;
                                                attPieza = new AtributoPieza()
                                                {
                                                    PiezaID = piezaMaestra.PiezaID,
                                                    AtributoID = atributoID,
                                                };
                                            }

                                            if (campoText == "Autor_Clave")
                                            {
                                                //generar codigo para el registro de AutorPieza
                                                //verificar si ya existe y si no actualizarlo
                                                //buscar el autor

                                                Int64 AutorID = db.Autores.Where(a => a.AntID == valorCampoExtra).Select(a => a.AutorID).FirstOrDefault();

                                                if (crear)
                                                {
                                                    AutorPieza autorPieza = new AutorPieza()
                                                    {
                                                        PiezaID = piezaMaestra.PiezaID,
                                                        AutorID = AutorID,
                                                        Status = true
                                                    };

                                                    db.AutorPiezas.Add(autorPieza);

                                                }
                                            }
                                            else
                                            {
                                                if (tipoAtributo.EsLista)
                                                {
                                                    //buscar el valor en ListaValor en el tipo de Atributo
                                                    Int64 listaValorID = db.ListaValores.Where(a => a.AntID == valorCampoExtra && a.TipoAtributoID == tipoAtributo.TipoAtributoID).Select(a => a.ListaValorID).FirstOrDefault();
                                                    if (listaValorID != 0)
                                                        attPieza.ListaValorID = listaValorID;
                                                }
                                                else
                                                {
                                                    attPieza.Valor = valorCampoExtra;
                                                }

                                                if (crear)
                                                    db.AtributoPiezas.Add(attPieza);
                                                else
                                                    db.Entry(attPieza).State = EntityState.Modified;
                                            }
                                        }//fin del todo ok

                                    }//fin del tipoAtributo null
                                    else
                                    {
                                        ViewBag.mensajeError = "No existe id_pieza en la consulta";
                                    }

                                }//fin del foreach de listaCampos

                                db.SaveChanges();

                            }//fin foreach camposLista
                        }
                        else
                        {
                            ViewBag.mensajeError = "No existe la Pieza";
                        }
                    }
                    else
                    {
                        ViewBag.mensajeError = "No existe la Obra";
                    }

                    actual++;
                    con1.Close();

                }//fin while
            }
            catch (Exception)
            {
                ViewBag.error = "error";
                ViewBag.mensaje = "Conexión fallida";
            }

            return PartialView("_ImportarPieza_Descriptivo");
        }
        //IMPORTAR PIEZA DESCRIPTIVO
        public ActionResult ImportarPieza_Descriptivo()
        {
            /*
             *
             * AutorPieza       Autor_Clave
             * generico         titulo
             * generico_L       EscArtistica_Clave
             * generico_L       FormaAdquisicion_Clave
             * generico_L       Procedencia_Clave
             * generico_L       FiliacionEstilistica_Clave
             * generico_L       CasaComercial_Clave
             * generico_L       EdoConservacion_Clave
             * generico         descripcion
             * generico         grafica
             * generico         otros_materiales
             * generico         catalogo
             * generico         numero_catalogo
             * generico         palabra_clave
             * generico         palabra_clave
             * generico         numero_registro
             * generico         titulo_ori
             * generico         Procedencia
             *
             *
             *
             *
             *
             * ------------ IMPLEMENTAR INDEPENDIENTES --------------
             * * ????????         cve_marco
             *
             * ImagenPieza  	    m_pieza_foto
             *
             * ColeccionGibranPieza     ClassColeccion_Clave
             * TecnicaMarco             MTecnicaMarco_Clave
             * Médidas	                m_pieza_dimensiones
             *
             *              * CatalogoPieza	    m_cats
             * ExposicionPieza	    m_guion_det
             * TecnicaPieza         MatriculaTecnica_Clave
             * MatriculaPieza       Matricula_Clave

             */

            // Inicia el contador:
            Stopwatch tiempo = Stopwatch.StartNew();

            var tAtt_Autor = db.TipoAtributos.SingleOrDefault(a => a.AntNombre == "Autor_Clave").TipoAtributoID;
            //TipoAtributo tAtt_Autor = db.TipoAtributos.SingleOrDefault(a => a.AntNombre == "Autor_Clave");

            //TipoAtributo tAtt_Catalogo = db.TipoAtributos.Single(a => a.AntNombre == "Autor_Clave");
            //TipoAtributo tAtt_Exposicion = db.TipoAtributos.Single(a => a.AntNombre == "Autor_Clave");
            //TipoAtributo tAtt_Tecnica = db.TipoAtributos.Single(a => a.AntNombre == "Autor_Clave");
            //TipoAtributo tAtt_Matricula = db.TipoAtributos.Single(a => a.AntNombre == "Autor_Clave");

            //
            ViewBag.NombreTabla = "CATALOGO DE OBRAS - REGISTRO BASICO";

            ViewBag.error = "";

            try
            {
                // mandar mensaje de conexcion
                ViewBag.mensaje = "Conexión establecida";
                //definir el sql
                var total = 500;
                var inicio = 2520; //colocar AntID no el ObraID
                var fin = inicio + total;

                var limite = 103475;

                while (fin <= limite)
                {
                    con1.Open();
                    string textSql = string.Format("SELECT * FROM [m_pieza_descriptivo] WHERE [id_pieza] > {0} AND [id_pieza] <= {1}", inicio, fin);

                    SqlCommand sql = new SqlCommand(textSql, con1);
                    SqlDataReader leer = sql.ExecuteReader();

                    while (leer.Read())
                    {
                        //Buscar que la Obra Exista
                        string idPiezaText = leer["id_pieza"].ToString();
                        Obra obra = null;
                        var xObra = db.Obras.Where(a => a.AntID == idPiezaText).Select(a => new { a.ObraID, a.AntID, a.Clave });

                        if (xObra.Count() > 0)
                        {
                            obra = new Obra()
                            {
                                ObraID = xObra.FirstOrDefault().ObraID,
                                AntID = xObra.FirstOrDefault().AntID,
                                Clave = xObra.FirstOrDefault().Clave
                            };
                        }

                        if (obra != null)
                        {
                            //traer la PiezaMaestra
                            string claveText = obra.Clave + "-A";
                            Pieza piezaMaestra = null;
                            var xPiezaMaestra = db.Piezas.Where(a => a.Clave == claveText && a.ObraID == obra.ObraID).Select(a => new { a.ObraID, a.PiezaID, a.Clave, a.TipoPiezaID });
                            if (xPiezaMaestra.Count() > 0)
                            {
                                piezaMaestra = new Pieza()
                                {
                                    ObraID = xPiezaMaestra.FirstOrDefault().ObraID,
                                    PiezaID = xPiezaMaestra.FirstOrDefault().PiezaID,
                                    TipoPiezaID = xPiezaMaestra.FirstOrDefault().TipoPiezaID,
                                    Clave = xPiezaMaestra.FirstOrDefault().Clave
                                };
                            }

                            if (piezaMaestra != null)
                            {
                                // AUTOR_PIEZA ------------------------------------------------------------------------------------------------
                                // Autor_Clave ------------------------------------------------------------------------------------------------
                                string autorIDText = leer["Autor_Clave"].ToString();
                                Autor autor = null;
                                var xAutor = db.Autores.Where(a => a.AntID == autorIDText).Select(a => new { a.AutorID });
                                if (xAutor.Count() > 0)
                                {
                                    autor = new Autor()
                                    {
                                        AutorID = xAutor.FirstOrDefault().AutorID
                                    };
                                }

                                //si autor == null o "0" no hacer nada
                                if (autor != null)
                                {
                                    //Buscar que exista Atributo con TipoPieza y TipoAtributo
                                    Atributo att = null;
                                    var xAtt = db.Atributos.Where(a => a.TipoAtributoID == tAtt_Autor && a.TipoPiezaID == piezaMaestra.TipoPiezaID).Select(a => new { a.AtributoID });
                                    if (xAtt.Count() > 0)
                                    {
                                        att = new Atributo()
                                        {
                                            AtributoID = xAtt.FirstOrDefault().AtributoID
                                        };
                                    }
                                    else
                                    {
                                        //no existe entonces crearlo

                                        att.TipoPiezaID = piezaMaestra.TipoPiezaID;
                                        att.TipoAtributoID = tAtt_Autor;
                                        att.NombreAlterno = null;
                                        att.Orden = 100;
                                        att.Status = true;
                                        att.Requerido = true;
                                        att.EnFichaBasica = true;

                                        db.Atributos.Add(att);
                                        db.SaveChanges();

                                    }

                                    //comenzar creacion del AtributoPieza con valores null
                                    AtributoPieza attPiezaGenAutor = new AtributoPieza()
                                    {
                                        PiezaID = piezaMaestra.PiezaID,
                                        AtributoID = att.AtributoID,
                                    };
                                    db.AtributoPiezas.Add(attPiezaGenAutor);

                                    AutorPieza autorPieza = new AutorPieza()
                                    {
                                        PiezaID = piezaMaestra.PiezaID,
                                        AutorID = autor.AutorID,
                                        Status = true
                                    };
                                    db.AutorPiezas.Add(autorPieza);
                                }

                                // GENERICOS --------------------------------------------------------------------------------------------------
                                List<string> campos = new List<string>()
                                {
                                    "titulo",
                                    "EscArtistica_Clave",
                                    "FormaAdquisicion_Clave",
                                    "Procedencia_Clave",
                                    "FiliacionEstilistica_Clave",
                                    "CasaComercial_Clave",
                                    "EdoConservacion_Clave",
                                    "descripcion",
                                    "otros_materiales",
                                    "catalogo",
                                    "numero_catalogo",
                                    "numero_registro",
                                    "titulo_ori",
                                    "Procedencia"
                                };

                                foreach (var campoAnt in campos)
                                {
                                    //buscar el tipo de atributo
                                    TipoAtributo tipoAttGen = null;
                                    var xTipoAttGen = db.TipoAtributos.Where(a => a.AntNombre == campoAnt).Select(a => new { a.EsLista, a.TipoAtributoID });
                                    if (xTipoAttGen.Count() > 0)
                                    {
                                        tipoAttGen = new TipoAtributo()
                                        {
                                            EsLista = xTipoAttGen.FirstOrDefault().EsLista,
                                            TipoAtributoID = xTipoAttGen.FirstOrDefault().TipoAtributoID
                                        };
                                    }

                                    if (tipoAttGen != null)
                                    {
                                        //Extraer el valor a buscar o guardar de la base vieja
                                        string valorCampo = leer[campoAnt].ToString();
                                        //Validar el valor del campo
                                        bool todoOk = true;
                                        if (tipoAttGen.EsLista)
                                        {
                                            if (valorCampo == "0")
                                            {
                                                todoOk = false;
                                            }
                                        }
                                        else
                                        {
                                            if (valorCampo == "0" || valorCampo == "" || valorCampo == " " || valorCampo == "-" || valorCampo == " -" || valorCampo == "Pendiente por definir")
                                            {
                                                todoOk = false;
                                            }
                                        }

                                        //paso la validacion
                                        if (todoOk)
                                        {
                                            //Buscar que el Atributo Exista con TipoPieza y TipoAtributo
                                            Atributo attGen = null;
                                            var xAttGen = db.Atributos.Where(a => a.TipoAtributoID == tipoAttGen.TipoAtributoID && a.TipoPiezaID == piezaMaestra.TipoPiezaID).Select(a => new { a.AtributoID });
                                            if (xAttGen.Count() > 0)
                                            {
                                                attGen = new Atributo()
                                                {
                                                    AtributoID = xAttGen.FirstOrDefault().AtributoID
                                                };
                                            }
                                            else
                                            {
                                                //si no existe entonces crearlo
                                                attGen = new Atributo()
                                                {
                                                    TipoPiezaID = piezaMaestra.TipoPiezaID,
                                                    TipoAtributoID = tipoAttGen.TipoAtributoID,
                                                    Orden = 100,
                                                    Status = true,
                                                    Requerido = false,
                                                    EnFichaBasica = false
                                                };

                                                db.Atributos.Add(attGen);
                                                db.SaveChanges();
                                            }

                                            //comenzar creacion del AtributoPieza con el valor extraido y validado
                                            AtributoPieza attPiezaGen = new AtributoPieza()
                                            {
                                                PiezaID = piezaMaestra.PiezaID,
                                                AtributoID = attGen.AtributoID,
                                            };

                                            if (tipoAttGen.EsLista)
                                            {
                                                //buscar el valor en ListaValor en el tipo de atributo
                                                ListaValor listaValorGen = null;
                                                var xListaValorGen = db.ListaValores.Where(a => a.AntID == valorCampo && a.TipoAtributoID == tipoAttGen.TipoAtributoID).Select(a => new { a.ListaValorID });
                                                if (xListaValorGen.Count() > 0)
                                                {
                                                    listaValorGen = new ListaValor()
                                                    {
                                                        ListaValorID = xListaValorGen.FirstOrDefault().ListaValorID
                                                    };

                                                }

                                                if (listaValorGen != null)
                                                {
                                                    attPiezaGen.ListaValorID = listaValorGen.ListaValorID;
                                                    db.AtributoPiezas.Add(attPiezaGen);
                                                    db.SaveChanges();
                                                }
                                            }
                                            else
                                            {
                                                attPiezaGen.Valor = valorCampo;
                                                db.AtributoPiezas.Add(attPiezaGen);
                                                db.SaveChanges();
                                            }
                                        }

                                    }
                                    else
                                    {

                                        ViewBag.error = "error";
                                        ViewBag.mensaje = "No existe la Tipo de Atributo, intenta resolver el problema antes de continuar";
                                    }
                                }
                                // ------------------------------------------------------------------------------------------------------------
                                // ------------------------------------------------------------------------------------------------------------
                                db.SaveChanges();
                            }
                            else
                            {
                                ViewBag.error = "error";
                                ViewBag.mensaje = "No existe la PiezaMaestra, intenta resolver el problema antes de continuar";
                            }
                        }
                        else
                        {
                            ViewBag.error = "error";
                            ViewBag.mensaje = "No existe la Obra, intenta resolver el problema antes de continuar";
                        }

                    }

                    inicio = fin;
                    fin = fin + total;
                    con1.Close();
                }

                // Para el contador e imprime el resultado:
                ViewBag.TiempoTotal = tiempo.Elapsed.TotalSeconds.ToString();

                var lista = db.Piezas.ToList();
                ViewBag.TotalRegistros = lista.Count;

                return PartialView("_ImportarPieza_Descriptivo", lista);
            }
            catch (Exception)
            {
                ViewBag.error = "error";
                ViewBag.mensaje = "Conexión fallida";
            }

            ViewBag.TiempoTotal = tiempo.Elapsed.TotalSeconds.ToString();
            return PartialView("_ImportarPieza_Descriptivo");
        }
        //IMPORTAR PIEZA - AUTOR
        public ActionResult ImportarPieza_Autor()
        {
            RecordFCSContext dbx = new RecordFCSContext();
            ViewBag.NombreTabla = "PIEZA AUTOR";
            var tipoAtt_AutorID = dbx.TipoAtributos.Where(a => a.AntNombre == "Autor_Clave").Select(a => a.TipoAtributoID).FirstOrDefault();

            ViewBag.error = "";

            try
            {
                // mandar mensaje de conexion
                ViewBag.mensaje = "Conexión establecida";
                //definir el sql
                Int64 limite = 100000;
                Int64 total = 500;

                Int64 inicio = 0; //colocar el PIEZAID del cual comenzar se comienza desde actual+1
                Int64 fin = inicio + total;

                var listaAutores = dbx.Autores.Select(a => new { a.AutorID, a.AntID }).ToList();
                List<AnonimoPiezaTabla> listaAnt = new List<AnonimoPiezaTabla>();

                con1.Open();
                string textSql1 = string.Format("SELECT [id_pieza], [Autor_Clave] FROM [m_pieza_descriptivo]");
                SqlCommand sql1 = new SqlCommand(textSql1, con1);
                SqlDataReader leer1 = sql1.ExecuteReader();

                while (leer1.Read())
                {
                    string id = leer1["id_pieza"].ToString();
                    string clave = leer1["Autor_Clave"].ToString();
                    listaAnt.Add(new AnonimoPiezaTabla()
                    {
                        id_pieza = id,
                        Clave = clave
                    });

                }
                con1.Close();

                while (fin <= limite)
                {
                    //tener la lista de pieza
                    var listPiezas = dbx.Piezas.Where(a => a.ObraID > inicio && a.ObraID <= fin).Select(a => new { a.ObraID, a.PiezaID, a.TipoPiezaID, a.Obra.AntID }).ToList();

                    foreach (var pieza in listPiezas)
                    {
                        //registrar una Pieza Autor
                        var anoPiezaAutor = listaAnt.FirstOrDefault(a => a.id_pieza == pieza.AntID);
                        //buscar al Autor
                        var autor = listaAutores.FirstOrDefault(a => a.AntID == anoPiezaAutor.Clave);

                        AutorPieza autorPieza = new AutorPieza()
                        {
                            PiezaID = pieza.PiezaID,
                            AutorID = autor.AutorID,
                            Status = true
                        };

                        dbx.AutorPiezas.Add(autorPieza);

                    }
                    dbx.SaveChanges();

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

                    inicio = fin;
                    fin = fin + total;
                }

            }
            catch (Exception)
            {

                throw;
            }
            return PartialView("_ImportarPieza_Descriptivo");
        }
Beispiel #5
0
        public ActionResult Registro(Int64 TipoObraID, Int64 TipoPiezaID, string Folio)
        {
            db.Dispose();
            db = new RecordFCSContext();
            ////Validar el Folio
            //while (db.Obras.Where(a => a.Clave == Folio).Count() > 0)
            //{
            //    string[] nuevaClave = Folio.Split('-');
            //    int numero = Convert.ToInt32(nuevaClave[1]);
            //    numero++;
            //    Folio = nuevaClave[0] + '-' + numero.ToString().PadLeft(4, '0');
            //}

            var obra = new Obra()
            {
                Clave = Folio,
                TipoObraID = TipoObraID,
                FechaRegistro = DateTime.Now,
                Status = Status.PreRegistro,
            };

            //lista de atributos
            var listaAtributos = db.Atributos.Where(a => a.TipoPiezaID == TipoPiezaID).ToList();

            // filtrar los atributos que son solo de la OBRA
            foreach (var item in listaAtributos)
            {
                string campo = "req_list_" + item.TipoAtributoID;
                string id_text = Request.Form[campo];
                Int64 id = Convert.ToInt64(id_text);
                switch (item.TipoAtributo.DatoCS)
                {
                    case "TipoAdquisicionID":
                        var tipoAdq = db.TipoAdquisiciones.Where(a => a.TipoAdquisicionID == id).Select(a => new { a.TipoAdquisicionID, a.Nombre}).FirstOrDefault();
                        if (tipoAdq != null)
                        {
                            obra.TipoAdquisicionID = id;
                        }
                        break;

                    case "PropietarioID":
                        var propietario = db.Propietarios.Where(a => a.PropietarioID == id).Select(a => new { a.PropietarioID, a.Nombre}).FirstOrDefault();
                        if (propietario != null)
                        {
                            obra.PropietarioID = id;
                        }
                        break;

                    case "ColeccionID":
                        var coleccion = db.Colecciones.Where(a => a.ColeccionID == id).Select(a => new { a.ColeccionID, a.Nombre}).FirstOrDefault();
                        if (coleccion != null)
                        {
                            obra.ColeccionID = id;
                        }
                        break;

                    case "UbicacionID":
                        var ubicacion = db.Ubicaciones.Where(a => a.UbicacionID == id).Select(a => new { a.UbicacionID, a.Nombre}).FirstOrDefault();
                        if (ubicacion != null)
                        {
                            obra.UbicacionID = id;
                        }
                        break;
                }
            }

            //validar la clave al final
            //ultimo registro + 1
            var ultimo = db.Obras.Select(a => new { a.ObraID, a.TipoObraID, a.Status, a.Clave}).ToList().LastOrDefault();

            if (ultimo != null)
            {
                var folio = Convert.ToInt32(ultimo.Clave) + 1;
                obra.Clave = folio.ToString();
            }

            db.Obras.Add(obra);
            db.SaveChanges();

            // crear la pieza
            var tipoPieza = db.TipoPiezas.Where(a => a.TipoPiezaID == TipoPiezaID).Select(a => new {a.TipoPiezaID, a.TipoObraID, a.Clave }).FirstOrDefault();

            var pieza = new Pieza()
            {
                ObraID = obra.ObraID,
                Clave = obra.Clave + "-" + tipoPieza.Clave, // Rdddaaaa-0000-A
                TipoPiezaID = TipoPiezaID,
                UbicacionID = obra.UbicacionID,
                FechaRegistro = obra.FechaRegistro,
                Status = true
            };

            db.Piezas.Add(pieza);
            db.SaveChanges();

            //llenar los atributoPieza y si son requeridos extraer el valor
            foreach (var item in listaAtributos)
            {
                var atributoPieza = new AtributoPieza()
                {
                    PiezaID = pieza.PiezaID,
                    AtributoID = item.AtributoID
                };

                //si son NombreID == "Generico" guardar en AtributoPieza
                if (item.TipoAtributo.NombreID == "Generico")
                {
                    //y si es Requerido extraer el valor del form
                    if (item.Requerido)
                    {
                        //si es lista lo guarda en ValorListaID y si no en Valor
                        if (item.TipoAtributo.EsLista)
                        {
                            string campo = "req_list_" + item.TipoAtributoID;
                            Int64? id = Convert.ToInt64(Request.Form[campo]);

                            var listaValor = db.ListaValores.Where(a => a.ListaValorID == id).Select(a => new {a.ListaValorID, a.TipoAtributoID}).FirstOrDefault();

                            if (listaValor != null)
                            {
                                atributoPieza.ListaValorID = id;
                            }
                        }
                        else
                        {
                            string campo = "req_" + item.TipoAtributoID;
                            string valor = Request.Form[campo];

                            if (!String.IsNullOrEmpty(valor) || !String.IsNullOrWhiteSpace(valor))
                            {
                                atributoPieza.Valor = valor;
                            }
                        }
                    }
                }
                else if (item.TipoAtributo.DatoHTML == "Catalogo")
                {
                    //Si no es generico pero si es DatoHTML = "Catalogo"
                    // y si es Requerido entonces guardar el valor en la TABLAPieza
                    if (item.Requerido)
                    {
                        string campo = "req_list_" + item.TipoAtributoID;
                        int? id = Convert.ToInt32(Request.Form[campo]);
                        switch (item.TipoAtributo.DatoCS)
                        {
                            case "TecnicaPieza":
                                var tecnica = db.Tecnicas.Where(a => a.TecnicaID == id).Select(a => new { a.TecnicaID, a.Descripcion}).FirstOrDefault();
                                if (tecnica != null)
                                {
                                    TecnicaPieza tecPieza = new TecnicaPieza()
                                    {
                                        PiezaID = pieza.PiezaID,
                                        TecnicaID = tecnica.TecnicaID,
                                        Status = true
                                    };
                                    db.TecnicaPiezas.Add(tecPieza);
                                    //db.SaveChanges();
                                }
                                break;

                            case "AutorPieza":
                                var autor = db.Autores.Where(a => a.AutorID == id).Select(a => new { a.AutorID, a.Nombre}).FirstOrDefault();
                                if (autor != null)
                                {
                                    AutorPieza autorPieza = new AutorPieza()
                                    {
                                        PiezaID = pieza.PiezaID,
                                        AutorID = autor.AutorID,
                                        Status = true
                                    };
                                    db.AutorPiezas.Add(autorPieza);
                                    //db.SaveChanges();
                                }
                                break;

                            case "ImagenPieza":
                                //PEndiente por implementar
                                HttpPostedFileBase FileImagen = Request.Files["FileName"];

                                var extension = Path.GetExtension(FileImagen.FileName);
                                var imagenPieza = new ImagenPieza()
                                {
                                    PiezaID = pieza.PiezaID,
                                    Status = true,
                                    Orden = 1,
                                    Titulo = Request.Form["imagen_" + "Titulo"],
                                    Descripcion = Request.Form["imagen_" + "Descripcion"],
                                };

                                imagenPieza.ImgNombre = Guid.NewGuid().ToString() + extension;
                                var rutaOriginal = Server.MapPath("~" + imagenPieza.Ruta);
                                var rutaThumbnail = Server.MapPath("~" + imagenPieza.RutaThumb);

                                FileImagen.SaveAs(rutaOriginal);

                                //GUARDAR THUMBNAIL
                                var thumb = new Thumbnail()
                                {
                                    OrigenSrc = rutaOriginal,
                                    DestinoSrc = rutaThumbnail,
                                    LimiteAnchoAlto = 300
                                };

                                thumb.GuardarThumbnail();

                                //guardar en db
                                db.ImagenPiezas.Add(imagenPieza);
                                //db.SaveChanges();

                                break;

                            case "Medida":
                                //Pendiente por implementar
                                var tipoMedida = db.TipoMedidas.Where(a => a.TipoMedidaID == id).Select(a => new { a.TipoMedidaID, a.Nombre}).FirstOrDefault();
                                if (tipoMedida != null)
                                {
                                    Medida medida = new Medida()
                                    {
                                        PiezaID = pieza.PiezaID,
                                        TipoMedidaID = tipoMedida.TipoMedidaID,
                                        Status = true
                                    };
                                    var xlargo = Request.Form["med_" + "Largo"].ToString();
                                    var xancho = Request.Form["med_" + "Ancho"].ToString();
                                    var xprofundidad =Request.Form["med_" + "Profundidad"].ToString();
                                    var xdiametro = Request.Form["med_" + "Diametro"].ToString();
                                    var xdiametro2 = Request.Form["med_" + "Diametro2"].ToString();
                                    var xUMLongitud = Request.Form["med_" + "UMLongitud"].ToString();

                                    if (xlargo != "0" && xlargo != "")
                                        medida.Largo = Convert.ToDouble(xlargo);
                                    if (xancho != "0" && xancho != "")
                                        medida.Ancho = Convert.ToDouble(xancho);
                                    if (xprofundidad != "0" && xprofundidad != "")
                                        medida.Profundidad = Convert.ToDouble(xprofundidad);
                                    if (xdiametro != "0" && xdiametro != "")
                                        medida.Diametro = Convert.ToDouble(xdiametro);
                                    if (xdiametro2 != "0" && xdiametro2 != "")
                                        medida.Diametro2 = Convert.ToDouble(xdiametro2);

                                    switch (xUMLongitud)
                                    {
                                        case "cm":
                                            medida.UMLongitud = UMLongitud.cm;
                                            break;
                                        case "km":
                                            medida.UMLongitud = UMLongitud.km;
                                            break;
                                        case "m":
                                            medida.UMLongitud = UMLongitud.m;
                                            break;
                                        case "mm":
                                            medida.UMLongitud = UMLongitud.mm;
                                            break;
                                        case "pulgadas":
                                            medida.UMLongitud = UMLongitud.pulgadas;
                                            break;
                                    }
                                    db.Medidas.Add(medida);
                                    //db.SaveChanges();

                                }
                                break;

                            case "CatalogoPieza":
                                var catalogo = db.Catalogos.Where(a => a.CatalogoID == id).Select(a => new { a.CatalogoID, a.Nombre}).FirstOrDefault();
                                if (catalogo != null)
                                {
                                    CatalogoPieza catPieza = new CatalogoPieza()
                                    {
                                        PiezaID = pieza.PiezaID,
                                        CatalogoID = catalogo.CatalogoID,
                                        Status = true
                                    };
                                    db.CatalogoPiezas.Add(catPieza);
                                    //db.SaveChanges();
                                }
                                break;

                            case "ExposicionPieza":
                                var exposicion = db.Exposiciones.Where(a => a.ExposicionID == id).Select(a => new {a.ExposicionID, a.Nombre }).FirstOrDefault();
                                if (exposicion != null)
                                {
                                    ExposicionPieza expoPieza = new ExposicionPieza()
                                    {
                                        PiezaID = pieza.PiezaID,
                                        ExposicionID = exposicion.ExposicionID,
                                        Status = true
                                    };
                                    db.ExposicionPiezas.Add(expoPieza);
                                    //db.SaveChanges();
                                }
                                break;

                            case "MatriculaPieza":
                                var matricula = db.Matriculas.Where(a => a.MatriculaID == id).Select(a => new { a.MatriculaID, a.Descripcion}).FirstOrDefault();
                                if (matricula != null)
                                {
                                    MatriculaPieza matPieza = new MatriculaPieza()
                                    {
                                        PiezaID = pieza.PiezaID,
                                        MatriculaID = matricula.MatriculaID,
                                        Status = true
                                    };
                                    db.MatriculaPiezas.Add(matPieza);
                                    //db.SaveChanges();
                                }
                                break;

                            case "TecnicaMarcoPieza":
                                var tenicaMarco = db.TecnicaMarcos.Where(a => a.TecnicaMarcoID == id).Select(a => new { a.TecnicaMarcoID, a.Descripcion}).FirstOrDefault();
                                if (tenicaMarco != null)
                                {
                                    TecnicaMarcoPieza tecMarcoPieza = new TecnicaMarcoPieza()
                                    {
                                        PiezaID = pieza.PiezaID,
                                        TecnicaMarcoID = tenicaMarco.TecnicaMarcoID,
                                        Status = true
                                    };
                                    db.TecnicaMarcoPiezas.Add(tecMarcoPieza);
                                    //db.SaveChanges();
                                }
                                break;
                        }
                    }
                }

                db.AtributoPiezas.Add(atributoPieza);
            }

            db.SaveChanges();

            //redireccionar si se tiene el permiso para ver ficha completa
            if (User.IsInRole("ObraFichComplet"))
            {
                return RedirectToAction("Detalles", "Obra", new { id = obra.ObraID });
            }
            else
            {
                AlertaSuccess(string.Format("Se registro la obra: {0}, pero no tiene los permisos para visualizarla.", obra.Clave),true);
                return RedirectToAction("Registro", "Obra");
            }
        }
        public ActionResult Registrar(Guid? TipoObraID, int? LetraFolioID, Guid? TipoPiezaID)
        {
            var Formulario = Request.Form;

            if (TipoObraID == null || LetraFolioID == null || TipoPiezaID == null)
                return new HttpStatusCodeResult(HttpStatusCode.BadRequest);

            var letra = db.LetraFolios.Find(LetraFolioID);
            var tipoObra = db.TipoObras.Find(TipoObraID);
            var tipoPieza = tipoObra.TipoPiezas.FirstOrDefault(a => a.TipoPiezaID == TipoPiezaID);

            if (tipoObra == null || letra == null || tipoPieza == null)
                return HttpNotFound();

            var obra = new Obra()
            {
                FechaRegistro = DateTime.Now,
                TipoObraID = tipoObra.TipoObraID,
                LetraFolioID = letra.LetraFolioID,
                Status = false,
                NumeroFolio = 1
            };

            obra.ObraID = Guid.NewGuid();

            //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
            };

            //lista de atributos de registro
            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();

            List<AtributoPieza> listaAdd_AttGen = new List<AtributoPieza>();
            List<AutorPieza> listaAdd_AttAutor = new List<AutorPieza>();
            List<ImagenPieza> listaAdd_AttImg = new List<ImagenPieza>();
            List<TecnicaPieza> listaAdd_AttTec = new List<TecnicaPieza>();
            List<MedidaPieza> listaAdd_AttMed = new List<MedidaPieza>();
            Ubicacion ubicacionAdd = null;

            List<string> listaKey;

            /*
             * Extraer los registros del formulario dependiendo el tipo de Atributo
             *
             * IMAGEN
             *      SIMPLE
             *          id_####################_File        (File)
             *          id_####################_Titulo      (Input)
             *          id_####################_Descripcion (Input)
             *

             *

             */

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

                if (tipoAtt.EsGenerico)
                {
                    /*
                     * GENERICO
                     *      LISTA
                     *          SIMPLE
                     *              id_#################### (Select)
                     *          MULTI
                     *              id_####################_#################### (Input)
                     */
                    if (tipoAtt.EsLista)
                    {

                        if (tipoAtt.EsMultipleValor)
                            listaKey = Formulario.AllKeys.Where(k => k.StartsWith("id_" + att.AtributoID + "_")).ToList();
                        else
                            listaKey = Formulario.AllKeys.Where(k => k.StartsWith("id_" + att.AtributoID)).ToList();

                        //buscar en form todas las llaves que correspondan al id_xxxxxxxxxxxxxx_xxxxxxxxxxxxxx
                        foreach (string key in listaKey)
                        {
                            var addOk = true;
                            string valor = Formulario[key];

                            addOk = String.IsNullOrWhiteSpace(valor) ? false : true;

                            //validar el valorID, buscar el valor
                            Guid valorID = addOk ? new Guid(valor) : new Guid(new Byte[16]);

                            addOk = !addOk ? addOk : listaAdd_AttGen.Where(a => a.AtributoID == att.AtributoID && a.ListaValorID == valorID).FirstOrDefault() == null ? true : false;

                            addOk = !addOk ? addOk : db.ListaValores.Where(a => a.TipoAtributoID == tipoAtt.TipoAtributoID && a.Status && a.ListaValorID == valorID).FirstOrDefault() == null ? false : true;

                            if (addOk)
                                listaAdd_AttGen.Add(new AtributoPieza()
                                {
                                    AtributoPiezaID = Guid.NewGuid(),
                                    AtributoID = att.AtributoID,
                                    PiezaID = pieza.PiezaID,
                                    Status = true,
                                    ListaValorID = valorID
                                });
                        }
                    }
                    else
                    {
                        /*
                         * GENERICO
                         *    CAMPO
                         *        SIMPLE
                         *            id_#################### (Input)
                         *        MULTI
                         *            id_####################_##### (Input)
                         */

                        if (tipoAtt.EsMultipleValor)
                            listaKey = Formulario.AllKeys.Where(k => k.StartsWith("id_" + att.AtributoID + "_")).ToList();
                        else
                            listaKey = Formulario.AllKeys.Where(k => k.StartsWith("id_" + att.AtributoID)).ToList();

                        //buscar en form todas las llaves que correspondan al id_xxxxxxxxxxxxxx
                        foreach (string key in listaKey)
                        {
                            var addOk = true;
                            string valor = Formulario[key];

                            //validar el campo, quitar espacios en blanco, bla bla bla
                            valor = valor.Trim(); // quitar espacios en inicio y fin
                            valor = Regex.Replace(valor, @"\s+", " "); //quitar espacios de sobra

                            addOk = String.IsNullOrWhiteSpace(valor) ? false : true;
                            addOk = !addOk ? addOk : listaAdd_AttGen.Where(a => a.AtributoID == att.AtributoID && a.Valor == valor).FirstOrDefault() == null ? true : false;

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

                        }
                    }
                }
                else
                {
                    switch (tipoAtt.TablaSQL)
                    {
                        case "Autor":
                            /*
                                * AUTOR
                                *      MULTIPLE
                                *          id_####################_####################            (Input)
                                *          id_####################_####################_prefijo    (Input)
                            */
                            //filtrar id_#######
                            listaKey = Formulario.AllKeys.Where(k => k.StartsWith("id_" + att.AtributoID + "_")).ToList();

                            ///filtrar: ignorar los _prefijo
                            listaKey = listaKey.Where(k => !k.EndsWith("_prefijo")).ToList();

                            //buscar en form todas las llaves que correspondan al id_xxxxxxxxxxxxxx_xxxxxxxxxxxxxx
                            foreach (string key in listaKey)
                            {
                                var addOk = true;
                                string text_autorID = Formulario[key];
                                string text_prefijo = Formulario[key + "_prefijo"];

                                addOk = String.IsNullOrWhiteSpace(text_autorID) ? false : true;

                                //validar el valorID, buscar el valor
                                Guid autorID = addOk ? new Guid(text_autorID) : new Guid(new Byte[16]);

                                addOk = !addOk ? addOk : listaAdd_AttAutor.Where(a => a.AutorID == autorID).FirstOrDefault() == null ? true : false;

                                addOk = !addOk ? addOk : db.Autores.Where(a => a.Status && a.AutorID == autorID).FirstOrDefault() == null ? false : true;

                                if (addOk)
                                {
                                    var autorPieza = new AutorPieza()
                                    {
                                        AutorID = autorID,
                                        PiezaID = pieza.PiezaID,
                                        esPrincipal = false,
                                        Prefijo = text_prefijo,
                                        Status = true
                                    };

                                    //validar si es principal
                                    if (autorPieza.Prefijo.ToLower() == "principal")
                                        autorPieza.esPrincipal = listaAdd_AttAutor.Where(a => a.esPrincipal).Count() == 0 ? true : false;

                                    listaAdd_AttAutor.Add(autorPieza);
                                }
                            }
                            break;

                        case "Ubicacion":
                            /*
                                * UBICACION
                                *      SIMPLE
                                *          id_####################     (select)
                            */

                            listaKey = Formulario.AllKeys.Where(k => k.StartsWith("id_" + att.AtributoID)).ToList();

                            //buscar en form todas las llaves que correspondan al id_xxxxxxxxxxxxxx_xxxxxxxxxxxxxx
                            foreach (string key in listaKey)
                            {
                                var addOk = true;
                                string texto_ubicacionID = Formulario[key];

                                addOk = String.IsNullOrWhiteSpace(texto_ubicacionID) ? false : true;

                                //validar el valorID, buscar el valor
                                Guid ubicacionID = addOk ? new Guid(texto_ubicacionID) : new Guid(new Byte[16]);

                                addOk = !addOk ? addOk : ubicacionAdd == null ? true : false;

                                addOk = !addOk ? addOk : db.Ubicaciones.Where(a => a.Status && a.UbicacionID == ubicacionID).FirstOrDefault() == null ? false : true;

                                if (addOk)
                                    pieza.UbicacionID = ubicacionID;
                            }
                            break;

                        case "TipoTecnica":
                            /*
                                * TECNICA
                                *      SIMPLE
                                *          id_####################     (Select)
                             */

                            listaKey = Formulario.AllKeys.Where(k => k.StartsWith("id_" + att.AtributoID)).ToList();

                            //buscar en form todas las llaves que correspondan al id_xxxxxxxxxxxxxx_xxxxxxxxxxxxxx
                            foreach (string key in listaKey)
                            {
                                var addOk = true;
                                string texto_TecnicaID = Formulario[key];

                                addOk = String.IsNullOrWhiteSpace(texto_TecnicaID) ? false : true;

                                //validar el valorID, buscar el valor
                                Guid tecnicaID = addOk ? new Guid(texto_TecnicaID) : new Guid(new Byte[16]);

                                addOk = !addOk ? addOk : listaAdd_AttTec.Where(a => a.TecnicaID == tecnicaID).FirstOrDefault() == null ? true : false;

                                addOk = !addOk ? addOk : db.Tecnicas.Where(a => a.TecnicaID == tecnicaID && a.Status).FirstOrDefault() == null ? false : true;

                                if (addOk)
                                {
                                    var tecnica = db.Tecnicas.Where(a => a.TecnicaID == tecnicaID && a.Status).FirstOrDefault();

                                    listaAdd_AttTec.Add(new TecnicaPieza()
                                    {
                                        PiezaID = pieza.PiezaID,
                                        Status = true,
                                        TecnicaID = tecnica.TecnicaID,
                                        TipoTecnicaID = tecnica.TipoTecnicaID
                                    });
                                }
                            }

                            break;

                        case "TipoMedida":
                            /*
                                * TIPO MEDIDA
                                *      SIMPLE
                                *          id_####################                 (Select)(TipoMedida)
                                *          id_####################_UML             (Select)
                                *          id_####################_Altura          (input)
                                *          id_####################_Anchura         (input)
                                *          id_####################_Profundidad     (input)
                                *          id_####################_Diametro        (input)
                                *          id_####################_Diametro2       (input)
                            */

                            listaKey = Formulario.AllKeys.Where(k => k == "TipoMedidaID").ToList();

                            //buscar en form todas las llaves que correspondan al id_xxxxxxxxxxxxxx_xxxxxxxxxxxxxx
                            foreach (string key in listaKey)
                            {
                                var addOk = true;
                                string texto_TipoMedidaID = Formulario[key];

                                addOk = String.IsNullOrWhiteSpace(texto_TipoMedidaID) ? false : true;

                                //validar el valorID, buscar el valor
                                Guid tipoMedidaID = addOk ? new Guid(texto_TipoMedidaID) : new Guid(new Byte[16]);

                                addOk = !addOk ? addOk : listaAdd_AttMed.Where(a => a.TipoMedidaID == tipoMedidaID).FirstOrDefault() == null ? true : false;

                                addOk = !addOk ? addOk : db.TipoMedidas.Where(a => a.TipoMedidaID == tipoMedidaID && a.Status).FirstOrDefault() == null ? false : true;

                                if (addOk)
                                {
                                    var medidaPieza = new MedidaPieza()
                                    {
                                        PiezaID = pieza.PiezaID,
                                        Status = true,
                                        TipoMedidaID = tipoMedidaID
                                    };

                                    string text_UML = String.IsNullOrWhiteSpace(Formulario["id_" + att.AtributoID + "_UML"]) ? "cm" : Formulario["id_" + att.AtributoID + "_UML"];
                                    string text_Altura = String.IsNullOrWhiteSpace(Formulario["id_" + att.AtributoID + "_Altura"]) ? "0" : Formulario["id_" + att.AtributoID + "_Altura"];
                                    string text_Anchura = String.IsNullOrWhiteSpace(Formulario["id_" + att.AtributoID + "_Anchura"]) ? "0" : Formulario["id_" + att.AtributoID + "_Anchura"];
                                    string text_Profundidad = String.IsNullOrWhiteSpace(Formulario["id_" + att.AtributoID + "_Profundidad"]) ? "0" : Formulario["id_" + att.AtributoID + "_Profundidad"];
                                    string text_Diametro = String.IsNullOrWhiteSpace(Formulario["id_" + att.AtributoID + "_Diametro"]) ? "0" : Formulario["id_" + att.AtributoID + "_Diametro"];
                                    string text_Diametro2 = String.IsNullOrWhiteSpace(Formulario["id_" + att.AtributoID + "_Diametro2"]) ? "0" : Formulario["id_" + att.AtributoID + "_Diametro2"];

                                    if (text_Altura == "0") medidaPieza.Altura = Convert.ToDouble("text_Altura");
                                    if (text_Anchura == "0") medidaPieza.Anchura = Convert.ToDouble("text_Anchura");
                                    if (text_Altura == "0") medidaPieza.Profundidad = Convert.ToDouble("text_Profundidad");
                                    if (text_Altura == "0") medidaPieza.Diametro = Convert.ToDouble("text_Diametro");
                                    if (text_Altura == "0") medidaPieza.Diametro2 = Convert.ToDouble("text_Diametro2");

                                    switch (text_UML)
                                    {
                                        case "pulgada": medidaPieza.UMLongitud = UMLongitud.pulgada; break;
                                        case "dc": medidaPieza.UMLongitud = UMLongitud.dc; break;
                                        case "m": medidaPieza.UMLongitud = UMLongitud.m; break;
                                        case "dam": medidaPieza.UMLongitud = UMLongitud.dam; break;
                                        case "mm": medidaPieza.UMLongitud = UMLongitud.mm; break;
                                        case "hm": medidaPieza.UMLongitud = UMLongitud.hm; break;
                                        case "km": medidaPieza.UMLongitud = UMLongitud.km; break;
                                        default: medidaPieza.UMLongitud = UMLongitud.cm; break;

                                    }

                                    listaAdd_AttMed.Add(medidaPieza);
                                }
                            }

                            break;

                        case "ImagenPieza":

                            listaKey = Request.Files.AllKeys.Where(k => k == "id_" + att.AtributoID + "_File").ToList();

                            //buscar en form todas las llaves que correspondan al id_xxxxxxxxxxxxxx_xxxxxxxxxxxxxx
                            foreach (string key in listaKey)
                            {
                                HttpPostedFileBase FileImagen = Request.Files[key];

                                string texto_Titulo = Formulario["id_" + att.AtributoID + "_Titulo"];
                                string texto_Descripcion = Formulario["id_" + att.AtributoID + "_Descripcion"];
                                string extension = Path.GetExtension(FileImagen.FileName);

                                var imgGuid = Guid.NewGuid();

                                ImagenPieza imagenPieza = new ImagenPieza()
                                {
                                    PiezaID = pieza.PiezaID,
                                    ImagenPiezaID = imgGuid,
                                    Titulo = texto_Titulo,
                                    Descripcion = texto_Descripcion,
                                    EsPrincipal = true,
                                    Orden = 1,
                                    Status = true,
                                    RutaParcial = "/Content/img/pieza/",
                                    NombreImagen = imgGuid.ToString() + extension,
                                };

                                var rutaGuardar_Original = Server.MapPath(imagenPieza.Ruta);

                                FileImagen.SaveAs(rutaGuardar_Original);

                                //Generar la mini
                                Thumbnail mini = new Thumbnail()
                                {
                                    OrigenSrc = rutaGuardar_Original,
                                    DestinoSrc = Server.MapPath(imagenPieza.RutaMini),
                                    LimiteAnchoAlto = 250
                                };

                                mini.GuardarThumbnail();

                                //add a la lista de imagenes

                                listaAdd_AttImg.Add(imagenPieza);
                            }

                            break;

                        default:
                            AlertaDanger(String.Format("No se pudo guardar el campo, {0}.", att.NombreAlterno));
                            break;
                    }

                }

            }

            if (ModelState.IsValid)
            {
                //validar el numero de folio
                obra.NumeroFolio = DarFolioValido(obra.LetraFolioID, obra.NumeroFolio);

                //Guardar la obra
                db.Obras.Add(obra);
                db.SaveChanges();

                //Guardar la pieza
                db.Piezas.Add(pieza);
                db.SaveChanges();

                //Guardar sus atributos
                db.AtributoPiezas.AddRange(listaAdd_AttGen);
                db.AutorPiezas.AddRange(listaAdd_AttAutor);
                db.ImagenPiezas.AddRange(listaAdd_AttImg);
                db.TecnicaPiezas.AddRange(listaAdd_AttTec);
                db.MedidaPiezas.AddRange(listaAdd_AttMed);

                db.SaveChanges();

                return RedirectToAction("Detalles", "Obra", new { id = obra.ObraID});

            }

            return Json(new { success = false });
        }
        public ActionResult Crear([Bind(Include = "PiezaID,ObraID,TipoPiezaID,Status")] Pieza pieza, string Folio)
        {
            Obra obra = db.Obras.Find(pieza.ObraID);
            TipoPieza tipoPieza = db.TipoPiezas.Find(pieza.TipoPiezaID);

            pieza.FechaRegistro = DateTime.Now;
            pieza.UbicacionID = obra.UbicacionID;

            if (obra.Status == Status.Activo)
                pieza.Status = true;
            else
                pieza.Status = false;

            //lista de atributos
            var listaAtributos = db.Atributos.Where(a => a.TipoPiezaID == pieza.TipoPiezaID).ToList();

            // filtrar los atributos que son solo de la PIEZA
            foreach (var item in listaAtributos)
            {
                string campo = "req_list_" + item.TipoAtributoID;
                Int64 id = Convert.ToInt64(Request.Form[campo]);

                switch (item.TipoAtributo.DatoCS)
                {
                    case "UbicacionID":
                        var ubicacion = db.Ubicaciones.Find(id);
                        if (ubicacion != null)
                        {
                            pieza.UbicacionID = id;
                        }
                        break;
                }
            }

            //validar la clave al final
            var clave = "";
            var listaClaves = db.Piezas.Where(p => (p.ObraID == pieza.ObraID && p.TipoPiezaID == pieza.TipoPiezaID)).ToList();

            ////GENERAR EN AUTOMATICO LA CLAVE
            if (listaClaves.Count == 0)
                clave = obra.Clave + "-" + tipoPieza.Clave;
            else
            {
                var listaC = new List<Int32>();
                foreach (var item in listaClaves)
                {
                    char x = Convert.ToChar(tipoPieza.Clave);
                    char s = '-';
                    clave = item.Clave.Split(s).Last();
                    clave = clave.Split(x).Last();
                    if (clave != "")
                        listaC.Add(Convert.ToInt32(clave));
                }
                if (listaC.Count == 0)
                    clave = obra.Clave + "-" + tipoPieza.Clave + "2";
                else
                {
                    listaC.Sort();
                    var mayor = listaC.LastOrDefault();
                    mayor = mayor + 1;
                    clave = obra.Clave + "-" + tipoPieza.Clave + mayor;
                }
            }

            pieza.Clave = clave;

            db.Piezas.Add(pieza);
            db.SaveChanges();

            //llenar los atributoPieza y si son requeridos extraer el valor
            foreach (var item in listaAtributos)
            {
                var atributoPieza = new AtributoPieza()
                {
                    PiezaID = pieza.PiezaID,
                    AtributoID = item.AtributoID
                };

                //si son NombreID == "Generico" guardar en AtributoPieza
                if (item.TipoAtributo.NombreID == "Generico")
                {
                    //y si es Requerido extraer el valor del form
                    if (item.Requerido)
                    {
                        //si es lista lo guarda en ValorListaID y si no en Valor
                        if (item.TipoAtributo.EsLista)
                        {
                            string campo = "req_list_" + item.TipoAtributoID;
                            Int64? id = Convert.ToInt64(Request.Form[campo]);
                            var listaValor = db.ListaValores.Find(id);

                            if (listaValor != null)
                            {
                                atributoPieza.ListaValorID = id;
                            }
                        }
                        else
                        {
                            string campo = "req_" + item.TipoAtributoID;
                            string valor = Request.Form[campo];

                            if (!String.IsNullOrEmpty(valor) || !String.IsNullOrWhiteSpace(valor))
                            {
                                atributoPieza.Valor = valor;
                            }
                        }
                    }
                }
                else if (item.TipoAtributo.DatoHTML == "Catalogo")
                {
                    //Si no es generico pero si es DatoHTML = "Catalogo"
                    // y si es Requerido entonces guardar el valor en la TABLAPieza
                    if (item.Requerido)
                    {
                        string campo = "req_list_" + item.TipoAtributoID;
                        int? id = Convert.ToInt32(Request.Form[campo]);
                        switch (item.TipoAtributo.DatoCS)
                        {
                            case "TecnicaPieza":
                                var tecnica = db.Tecnicas.Find(id);
                                if (tecnica != null)
                                {
                                    TecnicaPieza tecPieza = new TecnicaPieza()
                                    {
                                        PiezaID = pieza.PiezaID,
                                        TecnicaID = tecnica.TecnicaID,
                                        Status = true
                                    };
                                    db.TecnicaPiezas.Add(tecPieza);
                                    db.SaveChanges();
                                }
                                break;

                            case "AutorPieza":
                                var autor = db.Autores.Find(id);
                                if (autor != null)
                                {
                                    AutorPieza autorPieza = new AutorPieza()
                                    {
                                        PiezaID = pieza.PiezaID,
                                        AutorID = autor.AutorID,
                                        Status = true
                                    };
                                    db.AutorPiezas.Add(autorPieza);
                                    db.SaveChanges();
                                }
                                break;

                            case "ImagenPieza":
                                //PEndiente por implementar
                                HttpPostedFileBase FileImagen = Request.Files["FileName"];

                                var extension = Path.GetExtension(FileImagen.FileName);
                                var imagenPieza = new ImagenPieza()
                                {
                                    PiezaID = pieza.PiezaID,
                                    Status = true,
                                    Orden = 1,
                                    Titulo = Request.Form["imagen_" + "Titulo"],
                                    Descripcion = Request.Form["imagen_" + "Descripcion"],
                                };

                                imagenPieza.ImgNombre = Guid.NewGuid().ToString() + extension;
                                var rutaOriginal = Server.MapPath("~" + imagenPieza.Ruta);
                                var rutaThumbnail = Server.MapPath("~" + imagenPieza.RutaThumb);

                                FileImagen.SaveAs(rutaOriginal);

                                //GUARDAR THUMBNAIL
                                var thumb = new Thumbnail()
                                {
                                    OrigenSrc = rutaOriginal,
                                    DestinoSrc = rutaThumbnail,
                                    LimiteAnchoAlto = 300
                                };

                                thumb.GuardarThumbnail();

                                //guardar en db
                                db.ImagenPiezas.Add(imagenPieza);
                                db.SaveChanges();

                                break;

                            case "Medida":
                                //Pendiente por implementar
                                var tipoMedida = db.TipoMedidas.Find(id);
                                if (tipoMedida != null)
                                {
                                    Medida medida = new Medida()
                                    {
                                        PiezaID = pieza.PiezaID,
                                        TipoMedidaID = tipoMedida.TipoMedidaID,
                                        Status = true
                                    };
                                    var xlargo = Request.Form["med_" + "Largo"].ToString();
                                    var xancho = Request.Form["med_" + "Ancho"].ToString();
                                    var xprofundidad = Request.Form["med_" + "Profundidad"].ToString();
                                    var xdiametro = Request.Form["med_" + "Diametro"].ToString();
                                    var xdiametro2 = Request.Form["med_" + "Diametro2"].ToString();
                                    var xUMLongitud = Request.Form["med_" + "UMLongitud"].ToString();

                                    if (xlargo != "0" && xlargo != "")
                                        medida.Largo = Convert.ToDouble(xlargo);
                                    if (xancho != "0" && xancho != "")
                                        medida.Ancho = Convert.ToDouble(xancho);
                                    if (xprofundidad != "0" && xprofundidad != "")
                                        medida.Profundidad = Convert.ToDouble(xprofundidad);
                                    if (xdiametro != "0" && xdiametro != "")
                                        medida.Diametro = Convert.ToDouble(xdiametro);
                                    if (xdiametro2 != "0" && xdiametro2 != "")
                                        medida.Diametro2 = Convert.ToDouble(xdiametro2);

                                    switch (xUMLongitud)
                                    {
                                        case "cm":
                                            medida.UMLongitud = UMLongitud.cm;
                                            break;
                                        case "km":
                                            medida.UMLongitud = UMLongitud.km;
                                            break;
                                        case "m":
                                            medida.UMLongitud = UMLongitud.m;
                                            break;
                                        case "mm":
                                            medida.UMLongitud = UMLongitud.mm;
                                            break;
                                        case "pulgadas":
                                            medida.UMLongitud = UMLongitud.pulgadas;
                                            break;
                                    }
                                    db.Medidas.Add(medida);
                                    db.SaveChanges();

                                }
                                break;

                            case "CatalogoPieza":
                                var catalogo = db.Catalogos.Find(id);
                                if (catalogo != null)
                                {
                                    CatalogoPieza catPieza = new CatalogoPieza()
                                    {
                                        PiezaID = pieza.PiezaID,
                                        CatalogoID = catalogo.CatalogoID,
                                        Status = true
                                    };
                                    db.CatalogoPiezas.Add(catPieza);
                                    db.SaveChanges();
                                }
                                break;

                            case "ExposicionPieza":
                                var exposicion = db.Exposiciones.Find(id);
                                if (exposicion != null)
                                {
                                    ExposicionPieza expoPieza = new ExposicionPieza()
                                    {
                                        PiezaID = pieza.PiezaID,
                                        ExposicionID = exposicion.ExposicionID,
                                        Status = true
                                    };
                                    db.ExposicionPiezas.Add(expoPieza);
                                    db.SaveChanges();
                                }
                                break;

                            case "MatriculaPieza":
                                var matricula = db.Matriculas.Find(id);
                                if (matricula != null)
                                {
                                    MatriculaPieza matPieza = new MatriculaPieza()
                                    {
                                        PiezaID = pieza.PiezaID,
                                        MatriculaID = matricula.MatriculaID,
                                        Status = true
                                    };
                                    db.MatriculaPiezas.Add(matPieza);
                                    db.SaveChanges();
                                }
                                break;

                            case "TecnicaMarcoPieza":
                                var tenicaMarco = db.TecnicaMarcos.Find(id);
                                if (tenicaMarco != null)
                                {
                                    TecnicaMarcoPieza tecMarcoPieza = new TecnicaMarcoPieza()
                                    {
                                        PiezaID = pieza.PiezaID,
                                        TecnicaMarcoID = tenicaMarco.TecnicaMarcoID,
                                        Status = true
                                    };
                                    db.TecnicaMarcoPiezas.Add(tecMarcoPieza);
                                    db.SaveChanges();
                                }
                                break;
                        }
                    }
                }

                db.AtributoPiezas.Add(atributoPieza);
                db.SaveChanges();
            }

            return RedirectToAction("Detalles", "Obra", new { id = obra.ObraID });
        }