コード例 #1
0
        //MEDIDAS - MARCO
        public ActionResult ImportarMedida_Marcos()
        {
            /*
                "Sin marco ó base"
                "Museográficas",
                "Marco"
            */

            RecordFCSContext dbx = new RecordFCSContext();
            ViewBag.NombreTabla = "MEDIDA MARCO";

            string nombreMedida = "Marco";
            Int64 tipoMed = db.TipoMedidas.Where(a => a.Nombre == nombreMedida).Select(a => a.TipoMedidaID).FirstOrDefault();

            ViewBag.error = "";
            if (tipoMed != 0)
            {
                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;

                    List<AnonimoMedida> listaAnt = new List<AnonimoMedida>();
                    con1.Open();
                    string tabla = "m_pieza_MedidasMarcos";
                    string textSql1 = string.Format("SELECT * FROM [{0}]", tabla);
                    SqlCommand sql1 = new SqlCommand(textSql1, con1);
                    SqlDataReader leer1 = sql1.ExecuteReader();

                    while (leer1.Read())
                    {
                        string id_pieza = leer1["id_pieza"].ToString();
                        string UMPeso_Clave = leer1["UMPeso_Clave"].ToString();
                        double? alto = Convert.ToDouble(leer1["alto"].ToString());
                        string UMLongitud_Clave = leer1["UMLongitud_Clave"].ToString();
                        double? ancho = Convert.ToDouble(leer1["ancho"].ToString());
                        double? profundo = Convert.ToDouble(leer1["profundo"].ToString());
                        double? diametro = Convert.ToDouble(leer1["diametro"].ToString());
                        double? diametro2 = Convert.ToDouble(leer1["diametro2"].ToString());
                        double? peso = Convert.ToDouble(leer1["peso"].ToString());
                        string cve_tipo_medida = leer1["cve_tipo_medida"].ToString();
                        string otr_med = leer1["otr_med"].ToString();

                        if (alto == 0.0) alto = null;
                        if (ancho == 0.0) ancho = null;
                        if (profundo == 0.0) profundo = null;
                        if (diametro == 0.0) diametro = null;
                        if (diametro2 == 0.0) diametro2 = null;
                        if (peso == 0.0) peso = null;

                        //ingreso la validacion del campo clave
                        AnonimoMedida am = new AnonimoMedida()
                        {
                            id_pieza = id_pieza,
                            UMPeso_Clave = UMPeso_Clave,
                            alto = alto,
                            UMLongitud_Clave = UMLongitud_Clave,
                            ancho = ancho,
                            profundo = profundo,
                            diametro = diametro,
                            diametro2 = diametro2,
                            peso = peso,
                            cve_tipo_medida = cve_tipo_medida

                        };

                        if (string.IsNullOrWhiteSpace(otr_med)) otr_med = null;
                        else am.otr_med = otr_med;

                        listaAnt.Add(am);

                    }

                    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)
                        {
                            var anonimaMed = listaAnt.Where(a => a.id_pieza == pieza.AntID).ToList();

                            if (anonimaMed.Count > 0)
                            {
                                foreach (var anMed in anonimaMed)
                                {
                                    Medida med = new Medida()
                                    {
                                        Ancho = anMed.ancho,
                                        Diametro = anMed.diametro,
                                        Largo = anMed.alto,
                                        Peso = anMed.peso,
                                        PiezaID = pieza.PiezaID,
                                        Profundidad = anMed.profundo,
                                        Status = true,
                                        TipoMedidaID = tipoMed,
                                        Otra = anMed.otr_med
                                    };

                                    switch (anMed.UMLongitud_Clave)
                                    {
                                        case "21001":
                                            med.UMLongitud = UMLongitud.cm;
                                            break;
                                        case "21002":
                                            med.UMLongitud = UMLongitud.mm;
                                            break;
                                        case "21003":
                                            med.UMLongitud = UMLongitud.pulgadas;
                                            break;
                                        case "21004":
                                            med.UMLongitud = UMLongitud.m;
                                            break;
                                    }

                                    switch (anMed.UMPeso_Clave)
                                    {
                                        case "22002":
                                            med.UMMasa = UMMasa.kg;
                                            break;
                                        case "22003":
                                            med.UMMasa = UMMasa.gr;
                                            break;
                                    }

                                    dbx.Medidas.Add(med);
                                }
                            }

                        }

                        dbx.SaveChanges();

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

                        inicio = fin;
                        fin = fin + total;
                    }

                }
                catch (Exception)
                {

                    throw;
                }
            }

            return PartialView("_ImportarPieza_Descriptivo");
        }
コード例 #2
0
        //IMPORTAR PIEZA - TITULO ORIGINAL
        public ActionResult ImportarPieza_TituloOriginal()
        {
            RecordFCSContext dbx = new RecordFCSContext();
            ViewBag.NombreTabla = "PIEZA TITULO ORIGINAL";
            var tipoAttID = dbx.TipoAtributos.Where(a => a.AntNombre == "titulo_ori").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 = 100;

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

                List<AnonimoPiezaTabla> listaAnt = new List<AnonimoPiezaTabla>();
                con1.Open();
                string campo0 = "id_pieza";
                string campo1 = "titulo_ori";
                string tabla = "m_pieza_descriptivo";
                string textSql1 = string.Format("SELECT [{0}], [{1}] FROM [{2}]", campo0, campo1, tabla);
                SqlCommand sql1 = new SqlCommand(textSql1, con1);
                SqlDataReader leer1 = sql1.ExecuteReader();

                while (leer1.Read())
                {
                    string id = leer1[campo0].ToString();
                    string clave = leer1[campo1].ToString();
                    //ingreso la validacion del campo clave

                    if (clave == "0" || clave == "" || clave == " " || clave == "-" || clave == " -" || clave == "." || clave == " ." || clave == "Pendiente por definir")
                    {

                    }
                    else
                    {
                        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
                        var anonimaPiezaTabla = listaAnt.Where(a => a.id_pieza == pieza.AntID).ToList();

                        if (anonimaPiezaTabla.Count > 0)
                        {
                            foreach (var apt in anonimaPiezaTabla)
                            {
                                //buscar el Atributo en TipoPieza
                                Int64 attID = dbx.Atributos.Where(a => a.TipoAtributoID == tipoAttID && a.TipoPiezaID == pieza.TipoPiezaID).Select(a => a.AtributoID).FirstOrDefault();

                                if (attID == 0)
                                {
                                    //crear el Atributo para ese TipoPieza
                                    Atributo att = new Atributo()
                                    {
                                        TipoAtributoID = tipoAttID,
                                        TipoPiezaID = pieza.TipoPiezaID,
                                        Status = true,
                                        EnFichaBasica = true,
                                        Orden = 1,
                                        Requerido = true
                                    };
                                    dbx.Atributos.Add(att);
                                    dbx.SaveChanges();
                                    attID = att.AtributoID;
                                }

                                //crear AtributoPieza

                                AtributoPieza attPieza = new AtributoPieza()
                                {
                                    PiezaID = pieza.PiezaID,
                                    AtributoID = attID,
                                    Valor = apt.Clave
                                };

                                dbx.AtributoPiezas.Add(attPieza);
                            }
                        }

                    }

                    dbx.SaveChanges();

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

                    inicio = fin;
                    fin = fin + total;
                }

            }
            catch (Exception)
            {

                throw;
            }
            return PartialView("_ImportarPieza_Descriptivo");
        }
コード例 #3
0
        //---------------------------------------------------------------------
        //AGREGAR ATRIBUTOS A TIPOOBRAS
        public ActionResult ModificarTiposObrasAtt()
        {
            RecordFCSContext dbx = new RecordFCSContext();
            var listaTipoAtt = db.TipoAtributos.OrderBy(a => a.BuscadorOrden).Select(a => new { a.TipoAtributoID, a.EsLista, a.BuscadorOrden, a.AntNombre }).ToList();
            var listaTipoPiezas = db.TipoPiezas.Select(a => new { a.TipoPiezaID, a.TipoObraID, a.Nombre, a.EsMaestra, a.Clave, a.AntID }).ToList();

            foreach (var tipoPieza in listaTipoPiezas)
            {
                foreach (var tipoAtt in listaTipoAtt)
                {
                    bool esNuevo = false;
                    bool guardar = false;
                    var att = dbx.Atributos.SingleOrDefault(a => a.TipoAtributoID == tipoAtt.TipoAtributoID && a.TipoPiezaID == tipoPieza.TipoPiezaID);

                    if (att == null)
                    {
                        esNuevo = true;
                        att = new Atributo()
                        {
                            TipoAtributoID = tipoAtt.TipoAtributoID,
                            TipoPiezaID = tipoPieza.TipoPiezaID
                        };
                    }

                    att.Orden = Convert.ToInt32(tipoAtt.BuscadorOrden);

                    switch (tipoAtt.AntNombre)
                    {
                        case "m_pieza_foto":
                            att.Requerido = false;
                            att.EnFichaBasica = true;
                            att.Orden = Convert.ToInt32(tipoAtt.BuscadorOrden);
                            att.Status = true;
                            guardar = true;
                            break;
                        case "clave2":
                            att.Requerido = false;
                            att.Orden = Convert.ToInt32(tipoAtt.BuscadorOrden);
                            att.Status = true;

                            if (tipoPieza.EsMaestra)
                            {
                                att.EnFichaBasica = false;
                            }
                            else
                            {
                                att.EnFichaBasica = true;
                            }

                            guardar = true;
                            break;
                        case "TipoPieza_Clave":
                            att.Requerido = false;
                            att.Orden = Convert.ToInt32(tipoAtt.BuscadorOrden);
                            att.Status = true;

                            if (tipoPieza.EsMaestra)
                            {
                                att.EnFichaBasica = false;
                            }
                            else
                            {
                                att.EnFichaBasica = true;
                            }

                            guardar = true;
                            break;
                        case "fecha_registro":
                            if (!tipoPieza.EsMaestra)
                            {
                                att.Requerido = false;
                                att.EnFichaBasica = false;
                                att.Orden = Convert.ToInt32(tipoAtt.BuscadorOrden);
                                att.Status = true;
                                guardar = true;
                            }
                            break;
                        case "estatus_pieza":
                            if (!tipoPieza.EsMaestra)
                            {
                                att.Requerido = false;
                                att.EnFichaBasica = false;
                                att.Orden = Convert.ToInt32(tipoAtt.BuscadorOrden);
                                att.Status = true;
                                guardar = true;
                            }
                            break;

                        case "titulo":
                            att.Requerido = true;
                            att.EnFichaBasica = true;
                            att.Orden = Convert.ToInt32(tipoAtt.BuscadorOrden);
                            att.Status = true;
                            guardar = true;
                            break;

                        case "m_pieza_dimensiones":
                            att.Requerido = false;
                            att.EnFichaBasica = true;
                            att.Orden = Convert.ToInt32(tipoAtt.BuscadorOrden);
                            att.Status = true;
                            guardar = true;
                            break;
                        case "descripcion":
                            att.Requerido = true;
                            att.EnFichaBasica = true;
                            att.Orden = Convert.ToInt32(tipoAtt.BuscadorOrden);
                            att.Status = true;
                            guardar = true;
                            break;
                        case "m_guion_det":
                            att.Requerido = false;
                            att.EnFichaBasica = false;
                            att.Orden = Convert.ToInt32(tipoAtt.BuscadorOrden);
                            att.Status = true;
                            guardar = true;
                            break;

                        case "EdoConservacion_Clave":
                            att.Requerido = false;
                            att.EnFichaBasica = false;
                            att.Orden = Convert.ToInt32(tipoAtt.BuscadorOrden);
                            att.Status = true;
                            guardar = true;
                            break;

                        case "Ubicacion_Clave (OBRA)":
                            att.Requerido = false;
                            att.EnFichaBasica = false;
                            att.Orden = Convert.ToInt32(tipoAtt.BuscadorOrden);
                            att.Status = true;
                            guardar = true;
                            break;

                        case "observaciones":
                            att.Requerido = false;
                            att.EnFichaBasica = false;
                            att.Orden = Convert.ToInt32(tipoAtt.BuscadorOrden);
                            att.Status = true;
                            guardar = true;
                            break;

                        case "estatus":
                            if (tipoPieza.EsMaestra)
                            {
                                att.Requerido = false;
                                att.EnFichaBasica = false;
                                att.Orden = Convert.ToInt32(tipoAtt.BuscadorOrden);
                                att.Status = true;
                                guardar = true;
                            }
                            else
                            {
                                att.Requerido = false;
                                att.EnFichaBasica = false;
                                att.Orden = Convert.ToInt32(tipoAtt.BuscadorOrden);
                                att.Status = false;
                                guardar = true;
                            }
                            break;

                        case "TipoObjeto_Clave":
                        case "clave1":
                        case "m_pieza_coleccion":
                        case "Autor_Clave":
                        case "FechaEjecucion_Clave":
                        case "m_cats":
                        case "MatriculaTecnica_Clave":
                        case "fecha_registro_ORI":
                        case "catTipoAdquisicion":
                        case "FormaAdquisicion_Clave":
                        case "Propietario_Clave":

                            if (tipoPieza.EsMaestra)
                            {
                                att.Requerido = false;
                                att.EnFichaBasica = false;
                                att.Orden = Convert.ToInt32(tipoAtt.BuscadorOrden);
                                att.Status = true;
                                guardar = true;
                            }

                            break;

                        default:
                            if (!esNuevo)
                            {
                                att.Requerido = false;
                                att.EnFichaBasica = false;
                                att.Orden = Convert.ToInt32(tipoAtt.BuscadorOrden);
                                att.Status = true;
                                guardar = true;
                            }
                            break;

                    }

                    if (guardar)
                    {
                        if (esNuevo)
                        {
                            //save
                            dbx.Atributos.Add(att);
                        }
                        else
                        {
                            //update
                            dbx.Entry(att).State = EntityState.Modified;
                        }
                    }

                }
                dbx.SaveChanges();
                dbx.Dispose();
                dbx = new RecordFCSContext();
            }
              return View();
        }
コード例 #4
0
        //-----------------------------------------------------------------
        //IMAGENES QUEDA PENDIENTE
        //IMPORTAR PIEZA - IMAGENES
        public ActionResult ImportarPieza_Imagenes()
        {
            RecordFCSContext dbx = new RecordFCSContext();
            ViewBag.NombreTabla = "PIEZA IMAGENES";

            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;

                List<AnonimoImagenPiezaTabla> listaAnt = new List<AnonimoImagenPiezaTabla>();
                con1.Open();
                string campo0 = "id_pieza";
                string campo1 = "Consec";
                string campo2 = "nombre";
                string campo3 = "ruta_imagen";

                string tabla = "m_pieza_foto";
                string textSql1 = string.Format("SELECT [{0}], [{1}],[{2}], [{3}] FROM [{4}] ORDER BY [{5}]", campo0, campo1, campo2, campo3, tabla, campo0);
                SqlCommand sql1 = new SqlCommand(textSql1, con1);
                SqlDataReader leer1 = sql1.ExecuteReader();

                while (leer1.Read())
                {
                    string id_pieza = leer1[campo0].ToString();
                    string consec = leer1[campo1].ToString();
                    string nombre = leer1[campo2].ToString();
                    string ruta_imagen = leer1[campo3].ToString();

                    //ingreso la validacion del campo clave

                    listaAnt.Add(new AnonimoImagenPiezaTabla()
                    {
                        id_pieza = id_pieza,
                        Consec = consec,
                        nombre = nombre,
                        ruta_imagen = ruta_imagen
                    });

                }

                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)
                    {
                        var anonimaImagen = listaAnt.Where(a => a.id_pieza == pieza.AntID).ToList();

                        if (anonimaImagen.Count > 0)
                        {
                            foreach (var anImg in anonimaImagen)
                            {
                                ImagenPieza imgPieza = new ImagenPieza()
                                {
                                    PiezaID = pieza.PiezaID,
                                    Orden = Convert.ToInt32(anImg.Consec),
                                    Titulo = anImg.nombre,
                                    ImgNombre = anImg.ruta_imagen,
                                    Status = true,
                                };

                                dbx.ImagenPiezas.Add(imgPieza);
                            }
                        }

                    }

                    dbx.SaveChanges();

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

                    inicio = fin;
                    fin = fin + total;
                }

            }
            catch (Exception)
            {

                throw;
            }
            return PartialView("_ImportarPieza_Descriptivo");
        }
コード例 #5
0
        //IMPORTAR PIEZA - TECNICA MARCO
        public ActionResult ImportarPieza_TecnicaMarco()
        {
            RecordFCSContext dbx = new RecordFCSContext();
            ViewBag.NombreTabla = "PIEZA TECNICA MARCO";
            var tipoAtt_MatriculaID = dbx.TipoAtributos.Where(a => a.AntNombre == "MTecnicaMarco_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 listaTecnicaMarcos = dbx.TecnicaMarcos.Select(a => new { a.TecnicaMarcoID, a.AntID }).ToList();
                List<AnonimoPiezaTabla> listaAnt = new List<AnonimoPiezaTabla>();

                con1.Open();
                string campo0 = "id_pieza";
                string campo1 = "MTecnicaMarco_Clave";
                string tabla = "m_pieza_obra_comun";
                string textSql1 = string.Format("SELECT [{0}], [{1}] FROM [{2}]", campo0, campo1, tabla);
                SqlCommand sql1 = new SqlCommand(textSql1, con1);
                SqlDataReader leer1 = sql1.ExecuteReader();

                while (leer1.Read())
                {
                    string id = leer1[campo0].ToString();
                    string clave = leer1[campo1].ToString();
                    if (clave != "0")
                    {
                        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 anonimaPiezaTabla = listaAnt.Where(a => a.id_pieza == pieza.AntID).ToList();

                        if (anonimaPiezaTabla.Count > 0)
                        {
                            foreach (var apt in anonimaPiezaTabla)
                            {
                                //buscar al Autor
                                var tecnica = listaTecnicaMarcos.FirstOrDefault(a => a.AntID == apt.Clave);

                                TecnicaMarcoPieza tecMarcoPieza = new TecnicaMarcoPieza()
                                {
                                    PiezaID = pieza.PiezaID,
                                    TecnicaMarcoID = tecnica.TecnicaMarcoID,
                                    Status = true
                                };

                                dbx.TecnicaMarcoPiezas.Add(tecMarcoPieza);

                            }
                        }

                    }

                    dbx.SaveChanges();

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

                    inicio = fin;
                    fin = fin + total;
                }

            }
            catch (Exception)
            {

                throw;
            }
            return PartialView("_ImportarPieza_Descriptivo");
        }
コード例 #6
0
        //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");
        }
コード例 #7
0
        //---------------------------------------------------------------------
        // OTRAS PIEZAS DE LA OBRA
        public ActionResult ImportarOtrasPiezas()
        {
            RecordFCSContext dbx = new RecordFCSContext();
            ViewBag.NombreTabla = "IMPORTAR OTRAS PIEZAS";

            //buscar los TipoAtributoID

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

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

            var tipoAtt_TecnicaID = dbx.TipoAtributos.Where(a => a.AntNombre == "MatriculaTecnica_Clave").Select(a => a.TipoAtributoID).FirstOrDefault();
            var tipoAtt_Titulo = dbx.TipoAtributos.Where(a => a.AntNombre == "titulo").Select(a => a.TipoAtributoID).FirstOrDefault();
            var tipoAtt_Descripcion = dbx.TipoAtributos.Where(a => a.AntNombre == "descripcion").Select(a => a.TipoAtributoID).FirstOrDefault();
            var tipoAtt_Foto = dbx.TipoAtributos.Where(a => a.AntNombre == "m_pieza_foto").Select(a => a.TipoAtributoID).FirstOrDefault();

            var listaTecnicas = dbx.Tecnicas.Select(a => new { a.TecnicaID, a.AntID }).ToList();

            List<AnonimoOtraPieza> listaAnt = new List<AnonimoOtraPieza>();
            con1.Open();
            string tabla = "m_otras_piezas";
            string textSql1 = string.Format("SELECT * FROM [{0}] ORDER BY [id_pieza], [Sub_pieza] , [nSubIndex]", tabla);
            SqlCommand sql1 = new SqlCommand(textSql1, con1);
            SqlDataReader leer1 = sql1.ExecuteReader();

            while (leer1.Read())
            {
                string id_pieza = leer1["id_pieza"].ToString();
                int Sub_pieza = Convert.ToInt32(leer1["Sub_pieza"].ToString());
                int Consec = Convert.ToInt32(leer1["Consec"].ToString());
                string MatriculaTecnica_Clave = leer1["MatriculaTecnica_Clave"].ToString();
                string TipoPieza_Clave = leer1["TipoPieza_Clave"].ToString();
                string TipoPieza_Descripcion = leer1["TipoPieza_Descripcion"].ToString();
                string Ubicacion_Clave = leer1["Ubicacion_Clave"].ToString();
                string ruta_imagen = leer1["ruta_imagen"].ToString();
                int nSubIndex = Convert.ToInt32(leer1["nSubIndex"].ToString());
                double? Alto = Convert.ToDouble(leer1["Alto"].ToString());
                double? Ancho = Convert.ToDouble(leer1["Ancho"].ToString());
                double? Fondo = Convert.ToDouble(leer1["Fondo"].ToString());
                double? Diametro = Convert.ToDouble(leer1["Diametro"].ToString());
                double? Diametro2 = Convert.ToDouble(leer1["Diametro2"].ToString());
                string Descripcion = leer1["Descripcion"].ToString();
                string UbicacionActual = leer1["UbicacionActual"].ToString();
                int Jerarquia_Clave = Convert.ToInt32(leer1["Jerarquia_Clave"].ToString());

                if (Alto == 0.0) Alto = null;
                if (Ancho == 0.0) Ancho = null;
                if (Fondo == 0.0) Fondo = null;
                if (Diametro == 0.0) Diametro = null;
                if (Diametro2 == 0.0) Diametro2 = null;

                listaAnt.Add(new AnonimoOtraPieza()
                {
                    id_pieza = id_pieza,
                    Sub_pieza = Sub_pieza,
                    Consec = Consec,
                    MatriculaTecnica_Clave = MatriculaTecnica_Clave,
                    TipoPieza_Clave = TipoPieza_Clave,
                    TipoPieza_Descripcion = TipoPieza_Descripcion,
                    Ubicacion_Clave = Ubicacion_Clave,
                    ruta_imagen = ruta_imagen,
                    nSubIndex = nSubIndex,
                    Alto = Alto,
                    Ancho = Ancho,
                    Fondo = Fondo,
                    Diametro = Diametro,
                    Diametro2 = Diametro2,
                    Descripcion = Descripcion,
                    UbicacionActual = UbicacionActual,
                    Jerarquia_Clave = Jerarquia_Clave
                });
            }
            con1.Close();

            string[] letras =
                {
                    "A", "B", "C", "D", "E", "F", "G", "H", "I", "J", "K", "L", "M", "N", "O", "P", "Q", "R", "S", "T", "U", "V", "W", "X", "Y", "Z",

                    "AA", "AB", "AC", "AD", "AE", "AF", "AG", "AH", "AI", "AJ", "AK", "AL", "AM", "AN", "AO", "AP", "AQ", "AR", "AS", "AT", "AU", "AV", "AW", "AX", "AY", "AZ",
                    "BA", "BB", "BC", "BD", "BE", "BF", "BG", "BH", "BI", "BJ", "BK", "BL", "BM", "BN", "BO", "BP", "BQ", "BR", "BS", "BT", "BU", "BV", "BW", "BX", "BY", "BZ",
                    "CA", "CB", "CC", "CD", "CE", "CF", "CG", "CH", "CI", "CJ", "CK", "CL", "CM", "CN", "CO", "CP", "CQ", "CR", "CS", "CT", "CU", "CV", "CW", "CX", "CY", "CZ",
                    "DA", "DB", "DC", "DD", "DE", "DF", "DG", "DH", "DI", "DJ", "DK", "DL", "DM", "DN", "DO", "DP", "DQ", "DR", "DS", "DT", "DU", "DV", "DW", "DX", "DY", "DZ",
                    "EA", "EB", "EC", "ED", "EE", "EF", "EG", "EH", "EI", "EJ", "EK", "EL", "EM", "EN", "EO", "EP", "EQ", "ER", "ES", "ET", "EU", "EV", "EW", "EX", "EY", "EZ",
                    "FA", "FB", "FC", "FD", "FE", "FF", "FG", "FH", "FI", "FJ", "FK", "FL", "FM", "FN", "FO", "FP", "FQ", "FR", "FS", "FT", "FU", "FV", "FW", "FX", "FY", "FZ",
                    "GA", "GB", "GC", "GD", "GE", "GF", "GG", "GH", "GI", "GJ", "GK", "GL", "GM", "GN", "GO", "GP", "GQ", "GR", "GS", "GT", "GU", "GV", "GW", "GX", "GY", "GZ",
                    "HA", "HB", "HC", "HD", "HE", "HF", "HG", "HH", "HI", "HJ", "HK", "HL", "HM", "HN", "HO", "HP", "HQ", "HR", "HS", "HT", "HU", "HV", "HW", "HX", "HY", "HZ",
                    "IA", "IB", "IC", "ID", "IE", "IF", "IG", "IH", "II", "IJ", "IK", "IL", "IM", "IN", "IO", "IP", "IQ", "IR", "IS", "IT", "IU", "IV", "IW", "IX", "IY", "IZ",
                    "JA", "JB", "JC", "JD", "JE", "JF", "JG", "JH", "JI", "JJ", "JK", "JL", "JM", "JN", "JO", "JP", "JQ", "JR", "JS", "JT", "JU", "JV", "JW", "JX", "JY", "JZ",
                    "KA", "KB", "KC", "KD", "KE", "KF", "KG", "KH", "KI", "KJ", "KK", "KL", "KM", "KN", "KO", "KP", "KQ", "KR", "KS", "KT", "KU", "KV", "KW", "KX", "KY", "KZ",
                    "LA", "LB", "LC", "LD", "LE", "LF", "LG", "LH", "LI", "LJ", "LK", "LL", "LM", "LN", "LO", "LP", "LQ", "LR", "LS", "LT", "LU", "LV", "LW", "LX", "LY", "LZ",
                    "MA", "MB", "MC", "MD", "ME", "MF", "MG", "MH", "MI", "MJ", "MK", "ML", "MM", "MN", "MO", "MP", "MQ", "MR", "MS", "MT", "MU", "MV", "MW", "MX", "MY", "MZ",
                    "NA", "NB", "NC", "ND", "NE", "NF", "NG", "NH", "NI", "NJ", "NK", "NL", "NM", "NN", "NO", "NP", "NQ", "NR", "NS", "NT", "NU", "NV", "NW", "NX", "NY", "NZ",
                    "OA", "OB", "OC", "OD", "OE", "OF", "OG", "OH", "OI", "OJ", "OK", "OL", "OM", "ON", "OO", "OP", "OQ", "OR", "OS", "OT", "OU", "OV", "OW", "OX", "OY", "OZ",
                    "PA", "PB", "PC", "PD", "PE", "PF", "PG", "PH", "PI", "PJ", "PK", "PL", "PM", "PN", "PO", "PP", "PQ", "PR", "PS", "PT", "PU", "PV", "PW", "PX", "PY", "PZ",
                    "QA", "QB", "QC", "QD", "QE", "QF", "QG", "QH", "QI", "QJ", "QK", "QL", "QM", "QN", "QO", "QP", "QQ", "QR", "QS", "QT", "QU", "QV", "QW", "QX", "QY", "QZ",
                    "RA", "RB", "RC", "RD", "RE", "RF", "RG", "RH", "RI", "RJ", "RK", "RL", "RM", "RN", "RO", "RP", "RQ", "RR", "RS", "RT", "RU", "RV", "RW", "RX", "RY", "RZ",
                    "SA", "SB", "SC", "SD", "SE", "SF", "SG", "SH", "SI", "SJ", "SK", "SL", "SM", "SN", "SO", "SP", "SQ", "SR", "SS", "ST", "SU", "SV", "SW", "SX", "SY", "SZ",
                    "TA", "TB", "TC", "TD", "TE", "TF", "TG", "TH", "TI", "TJ", "TK", "TL", "TM", "TN", "TO", "TP", "TQ", "TR", "TS", "TT", "TU", "TV", "TW", "TX", "TY", "TZ",
                    "UA", "UB", "UC", "UD", "UE", "UF", "UG", "UH", "UI", "UJ", "UK", "UL", "UM", "UN", "UO", "UP", "UQ", "UR", "US", "UT", "UU", "UV", "UW", "UX", "UY", "UZ",
                    "VA", "VB", "VC", "VD", "VE", "VF", "VG", "VH", "VI", "VJ", "VK", "VL", "VM", "VN", "VO", "VP", "VQ", "VR", "VS", "VT", "VU", "VV", "VW", "VX", "VY", "VZ",
                    "WA", "WB", "WC", "WD", "WE", "WF", "WG", "WH", "WI", "WJ", "WK", "WL", "WM", "WN", "WO", "WP", "WQ", "WR", "WS", "WT", "WU", "WV", "WW", "WX", "WY", "WZ",
                    "XA", "XB", "XC", "XD", "XE", "XF", "XG", "XH", "XI", "XJ", "XK", "XL", "XM", "XN", "XO", "XP", "XQ", "XR", "XS", "XT", "XU", "XV", "XW", "XX", "XY", "XZ",
                    "YA", "YB", "YC", "YD", "YE", "YF", "YG", "YH", "YI", "YJ", "YK", "YL", "YM", "YN", "YO", "YP", "YQ", "YR", "YS", "YT", "YU", "YV", "YW", "YX", "YY", "YZ",
                    "ZA", "ZB", "ZC", "ZD", "ZE", "ZF", "ZG", "ZH", "ZI", "ZJ", "ZK", "ZL", "ZM", "ZN", "ZO", "ZP", "ZQ", "ZR", "ZS", "ZT", "ZU", "ZV", "ZW", "ZX", "ZY", "ZZ",

                    "AAA", "AAB", "AAC", "AAD", "AAE", "AAF", "AAG", "AAH", "AAI", "AAJ", "AAK", "AAL", "AAM", "AAN", "AAO", "AAP", "AAQ", "AAR", "AAS", "AAT", "AAU", "AAV", "AAW", "AAX", "AAY", "AAZ",
                    "BAA", "BAB", "BAC", "BAD", "BAE", "BAF", "BAG", "BAH", "BAI", "BAJ", "BAK", "BAL", "BAM", "BAN", "BAO", "BAP", "BAQ", "BAR", "BAS", "BAT", "BAU", "BAV", "BAW", "BAX", "BAY", "BAZ",
                    "CAA", "CAB", "CAC", "CAD", "CAE", "CAF", "CAG", "CAH", "CAI", "CAJ", "CAK", "CAL", "CAM", "CAN", "CAO", "CAP", "CAQ", "CAR", "CAS", "CAT", "CAU", "CAV", "CAW", "CAX", "CAY", "CAZ",
                    "DAA", "DAB", "DAC", "DAD", "DAE", "DAF", "DAG", "DAH", "DAI", "DAJ", "DAK", "DAL", "DAM", "DAN", "DAO", "DAP", "DAQ", "DAR", "DAS", "DAT", "DAU", "DAV", "DAW", "DAX", "DAY", "DAZ",
                    "EAA", "EAB", "EAC", "EAD", "EAE", "EAF", "EAG", "EAH", "EAI", "EAJ", "EAK", "EAL", "EAM", "EAN", "EAO", "EAP", "EAQ", "EAR", "EAS", "EAT", "EAU", "EAV", "EAW", "EAX", "EAY", "EAZ",
                    "FAA", "FAB", "FAC", "FAD", "FAE", "FAF", "F*G", "FAH", "FAI", "FAJ", "FAK", "FAL", "FAM", "FAN", "FAO", "FAP", "FAQ", "FAR", "FAS", "FAT", "FAU", "FAV", "FAW", "FAX", "FAY", "FAZ",
                    "GAA", "GAB", "GAC", "GAD", "GAE", "GAF", "GAG", "GAH", "GAI", "GAJ", "GAK", "GAL", "GAM", "GAN", "GAO", "GAP", "GAQ", "GAR", "GAS", "GAT", "GAU", "GAV", "GAW", "GAX", "GAY", "GAZ",
                    "HAA", "HAB", "HAC", "HAD", "HAE", "HAF", "HAG", "HAH", "HAI", "HAJ", "HAK", "HAL", "HAM", "HAN", "HAO", "HAP", "HAQ", "HAR", "HAS", "HAT", "HAU", "HAV", "HAW", "HAX", "HAY", "HAZ",
                    "IAA", "IAB", "IAC", "IAD", "IAE", "IAF", "IAG", "IAH", "IAI", "IAJ", "IAK", "IAL", "IAM", "IAN", "IAO", "IAP", "IAQ", "IAR", "IAS", "IAT", "IAU", "IAV", "IAW", "IAX", "IAY", "IAZ",
                    "JAA", "JAB", "JAC", "JAD", "JAE", "JAF", "JAG", "JAH", "JAI", "JAJ", "JAK", "JAL", "JAM", "JAN", "JAO", "JAP", "JAQ", "JAR", "JAS", "JAT", "JAU", "JAV", "JAW", "JAX", "JAY", "JAZ",
                    "KAA", "KAB", "KAC", "KAD", "KAE", "KAF", "KAG", "KAH", "KAI", "KAJ", "KAK", "KAL", "KAM", "KAN", "KAO", "KAP", "KAQ", "KAR", "KAS", "KAT", "KAU", "KAV", "KAW", "KAX", "KAY", "KAZ",
                    "LAA", "LAB", "LAC", "LAD", "LAE", "LAF", "LAG", "LAH", "LAI", "LAJ", "LAK", "LAL", "LAM", "LAN", "LAO", "LAP", "LAQ", "LAR", "LAS", "LAT", "LAU", "LAV", "LAW", "LAX", "LAY", "LAZ",
                    "MAA", "MAB", "MAC", "MAD", "MAE", "MAF", "MAG", "MAH", "MAI", "MAJ", "MAK", "MAL", "MAM", "MAN", "MAO", "MAP", "MAQ", "MAR", "MAS", "MAT", "MAU", "MAV", "MAW", "MAX", "MAY", "MAZ",
                    "NAA", "NAB", "NAC", "NAD", "NAE", "NAF", "NAG", "NAH", "NAI", "NAJ", "NAK", "NAL", "NAM", "NAN", "NAO", "NAP", "NAQ", "NAR", "NAS", "NAT", "NAU", "NAV", "NAW", "NAX", "NAY", "NAZ",
                    "OAA", "OAB", "OAC", "OAD", "OAE", "OAF", "OAG", "OAH", "OAI", "OAJ", "OAK", "OAL", "OAM", "OAN", "OAO", "OAP", "OAQ", "OAR", "OAS", "OAT", "OAU", "OAV", "OAW", "OAX", "OAY", "OAZ",
                    "PAA", "PAB", "PAC", "PAD", "PAE", "PAF", "PAG", "PAH", "PAI", "PAJ", "PAK", "PAL", "PAM", "PAN", "PAO", "PAP", "PAQ", "PAR", "PAS", "PAT", "PAU", "PAV", "PAW", "PAX", "PAY", "PAZ",
                    "QAA", "QAB", "QAC", "QAD", "QAE", "QAF", "QAG", "QAH", "QAI", "QAJ", "QAK", "QAL", "QAM", "QAN", "QAO", "QAP", "QAQ", "QAR", "QAS", "QAT", "QAU", "QAV", "QAW", "QAX", "QAY", "QAZ",
                    "RAA", "RAB", "RAC", "RAD", "RAE", "RAF", "RAG", "RAH", "RAI", "RAJ", "RAK", "RAL", "RAM", "RAN", "RAO", "RAP", "RAQ", "RAR", "RAS", "RAT", "RAU", "RAV", "RAW", "RAX", "RAY", "RAZ",
                    "SAA", "SAB", "SAC", "SAD", "SAE", "SAF", "SAG", "SAH", "SAI", "SAJ", "SAK", "SAL", "SAM", "SAN", "SAO", "SAP", "SAQ", "SAR", "SAS", "SAT", "SAU", "SAV", "SAW", "SAX", "SAY", "SAZ",
                    "TAA", "TAB", "TAC", "TAD", "TAE", "TAF", "TAG", "TAH", "TAI", "TAJ", "TAK", "TAL", "TAM", "TAN", "TAO", "TAP", "TAQ", "TAR", "TAS", "TAT", "TAU", "TAV", "TAW", "TAX", "TAY", "TAZ",
                    "UAA", "UAB", "UAC", "UAD", "UAE", "UAF", "UAG", "UAH", "UAI", "UAJ", "UAK", "UAL", "UAM", "UAN", "UAO", "UAP", "UAQ", "UAR", "UAS", "UAT", "UAU", "UAV", "UAW", "UAX", "UAY", "UAZ",
                    "VAA", "VAB", "VAC", "VAD", "VAE", "VAF", "VAG", "VAH", "VAI", "VAJ", "VAK", "VAL", "VAM", "VAN", "VAO", "VAP", "VAQ", "VAR", "VAS", "VAT", "VAU", "VAV", "VAW", "VAX", "VAY", "VAZ",
                    "WAA", "WAB", "WAC", "WAD", "WAE", "WAF", "WAG", "WAH", "WAI", "WAJ", "WAK", "WAL", "WAM", "WAN", "WAO", "WAP", "WAQ", "WAR", "WAS", "WAT", "WAU", "WAV", "WAW", "WAX", "WAY", "WAZ",
                    "XAA", "XAB", "XAC", "XAD", "XAE", "XAF", "XAG", "XAH", "XAI", "XAJ", "XAK", "XAL", "XAM", "XAN", "XAO", "XAP", "XAQ", "XAR", "XAS", "XAT", "XAU", "XAV", "XAW", "XAX", "XAY", "XAZ",
                    "YAA", "YAB", "YAC", "YAD", "YAE", "YAF", "YAG", "YAH", "YAI", "YAJ", "YAK", "YAL", "YAM", "YAN", "YAO", "YAP", "YAQ", "YAR", "YAS", "YAT", "YAU", "YAV", "YAW", "YAX", "YAY", "YAZ",
                    "ZAA", "ZAB", "ZAC", "ZAD", "ZAE", "ZAF", "ZAG", "ZAH", "ZAI", "ZAJ", "ZAK", "ZAL", "ZAM", "ZAN", "ZAO", "ZAP", "ZAQ", "ZAR", "ZAS", "ZAT", "ZAU", "ZAV", "ZAW", "ZAX", "ZAY", "ZAZ",

                    "ABA", "ABB", "ABC", "ABD", "ABE", "ABF", "ABG", "ABH", "ABI", "ABJ", "ABK", "ABL", "ABM", "ABN", "ABO", "ABP", "ABQ", "ABR", "ABS", "ABT", "ABU", "ABV", "ABW", "ABX", "ABY", "ABZ",
                    "BBA", "BBB", "BBC", "BBD", "BBE", "BBF", "BBG", "BBH", "BBI", "BBJ", "BBK", "BBL", "BBM", "BBN", "BBO", "BBP", "BBQ", "BBR", "BBS", "BBT", "BBU", "BBV", "BBW", "BBX", "BBY", "BBZ",
                    "CBA", "CBB", "CBC", "CBD", "CBE", "CBF", "CBG", "CBH", "CBI", "CBJ", "CBK", "CBL", "CBM", "CBN", "CBO", "CBP", "CBQ", "CBR", "CBS", "CBT", "CBU", "CBV", "CBW", "CBX", "CBY", "CBZ",
                    "DBA", "DBB", "DBC", "DBD", "DBE", "DBF", "DBG", "DBH", "DBI", "DBJ", "DBK", "DBL", "DBM", "DBN", "DBO", "DBP", "DBQ", "DBR", "DBS", "DBT", "DBU", "DBV", "DBW", "DBX", "DBY", "DBZ",
                    "EBA", "EBB", "EBC", "EBD", "EBE", "EBF", "EBG", "EBH", "EBI", "EBJ", "EBK", "EBL", "EBM", "EBN", "EBO", "EBP", "EBQ", "EBR", "EBS", "EBT", "EBU", "EBV", "EBW", "EBX", "EBY", "EBZ",
                    "FBA", "FBB", "FBC", "FBD", "FBE", "FBF", "FBG", "FBH", "FBI", "FBJ", "FBK", "FBL", "FBM", "FBN", "FBO", "FBP", "FBQ", "FBR", "FBS", "FBT", "FBU", "FBV", "FBW", "FBX", "FBY", "FBZ",
                    "GBA", "GBB", "GBC", "GBD", "GBE", "GBF", "GBG", "GBH", "GBI", "GBJ", "GBK", "GBL", "GBM", "GBN", "GBO", "GBP", "GBQ", "GBR", "GBS", "GBT", "GBU", "GBV", "GBW", "GBX", "GBY", "GBZ",
                    "HBA", "HBB", "HBC", "HBD", "HBE", "HBF", "HBG", "HBH", "HBI", "HBJ", "HBK", "HBL", "HBM", "HBN", "HBO", "HBP", "HBQ", "HBR", "HBS", "HBT", "HBU", "HBV", "HBW", "HBX", "HBY", "HBZ",
                    "IBA", "IBB", "IBC", "IBD", "IBE", "IBF", "IBG", "IBH", "IBI", "IBJ", "IBK", "IBL", "IBM", "IBN", "IBO", "IBP", "IBQ", "IBR", "IBS", "IBT", "IBU", "IBV", "IBW", "IBX", "IBY", "IBZ",
                    "JBA", "JBB", "JBC", "JBD", "JBE", "JBF", "JBG", "JBH", "JBI", "JBJ", "JBK", "JBL", "JBM", "JBN", "JBO", "JBP", "JBQ", "JBR", "JBS", "JBT", "JBU", "JBV", "JBW", "JBX", "JBY", "JBZ",
                    "KBA", "KBB", "KBC", "KBD", "KBE", "KBF", "KBG", "KBH", "KBI", "KBJ", "KBK", "KBL", "KBM", "KBN", "KBO", "KBP", "KBQ", "KBR", "KBS", "KBT", "KBU", "KBV", "KBW", "KBX", "KBY", "KBZ",
                    "LBA", "LBB", "LBC", "LBD", "LBE", "LBF", "LBG", "LBH", "LBI", "LBJ", "LBK", "LBL", "LBM", "LBN", "LBO", "LBP", "LBQ", "LBR", "LBS", "LBT", "LBU", "LBV", "LBW", "LBX", "LBY", "LBZ",
                    "MBA", "MBB", "MBC", "MBD", "MBE", "MBF", "MBG", "MBH", "MBI", "MBJ", "MBK", "MBL", "MBM", "MBN", "MBO", "MBP", "MBQ", "MBR", "MBS", "MBT", "MBU", "MBV", "MBW", "MBX", "MBY", "MBZ",
                    "NBA", "NBB", "NBC", "NBD", "NBE", "NBF", "NBG", "NBH", "NBI", "NBJ", "NBK", "NBL", "NBM", "NBN", "NBO", "NBP", "NBQ", "NBR", "NBS", "NBT", "NBU", "NBV", "NBW", "NBX", "NBY", "NBZ",
                    "OBA", "OBB", "OBC", "OBD", "OBE", "OBF", "OBG", "OBH", "OBI", "OBJ", "OBK", "OBL", "OBM", "OBN", "OBO", "OBP", "OBQ", "OBR", "OBS", "OBT", "OBU", "OBV", "OBW", "OBX", "OBY", "OBZ",
                    "PBA", "PBB", "PBC", "PBD", "PBE", "PBF", "PBG", "PBH", "PBI", "PBJ", "PBK", "PBL", "PBM", "PBN", "PBO", "PBP", "PBQ", "PBR", "PBS", "PBT", "PBU", "PBV", "PBW", "PBX", "PBY", "PBZ",
                    "QBA", "QBB", "QBC", "QBD", "QBE", "QBF", "QBG", "QBH", "QBI", "QBJ", "QBK", "QBL", "QBM", "QBN", "QBO", "QBP", "QBQ", "QBR", "QBS", "QBT", "QBU", "QBV", "QBW", "QBX", "QBY", "QBZ",
                    "RBA", "RBB", "RBC", "RBD", "RBE", "RBF", "RBG", "RBH", "RBI", "RBJ", "RBK", "RBL", "RBM", "RBN", "RBO", "RBP", "RBQ", "RBR", "RBS", "RBT", "RBU", "RBV", "RBW", "RBX", "RBY", "RBZ",
                    "SBA", "SBB", "SBC", "SBD", "SBE", "SBF", "SBG", "SBH", "SBI", "SBJ", "SBK", "SBL", "SBM", "SBN", "SBO", "SBP", "SBQ", "SBR", "SBS", "SBT", "SBU", "SBV", "SBW", "SBX", "SBY", "SBZ",
                    "TBA", "TBB", "TBC", "TBD", "TBE", "TBF", "TBG", "TBH", "TBI", "TBJ", "TBK", "TBL", "TBM", "TBN", "TBO", "TBP", "TBQ", "TBR", "TBS", "TBT", "TBU", "TBV", "TBW", "TBX", "TBY", "TBZ",
                    "UBA", "UBB", "UBC", "UBD", "UBE", "UBF", "UBG", "UBH", "UBI", "UBJ", "UBK", "UBL", "UBM", "UBN", "UBO", "UBP", "UBQ", "UBR", "UBS", "UBT", "UBU", "UBV", "UBW", "UBX", "UBY", "UBZ",
                    "VBA", "VBB", "VBC", "VBD", "VBE", "VBF", "VBG", "VBH", "VBI", "VBJ", "VBK", "VBL", "VBM", "VBN", "VBO", "VBP", "VBQ", "VBR", "VBS", "VBT", "VBU", "VBV", "VBW", "VBX", "VBY", "VBZ",
                    "WBA", "WBB", "WBC", "WBD", "WBE", "WBF", "WBG", "WBH", "WBI", "WBJ", "WBK", "WBL", "WBM", "WBN", "WBO", "WBP", "WBQ", "WBR", "WBS", "WBT", "WBU", "WBV", "WBW", "WBX", "WBY", "WBZ",
                    "XBA", "XBB", "XBC", "XBD", "XBE", "XBF", "XBG", "XBH", "XBI", "XBJ", "XBK", "XBL", "XBM", "XBN", "XBO", "XBP", "XBQ", "XBR", "XBS", "XBT", "XBU", "XBV", "XBW", "XBX", "XBY", "XBZ",
                    "YBA", "YBB", "YBC", "YBD", "YBE", "YBF", "YBG", "YBH", "YBI", "YBJ", "YBK", "YBL", "YBM", "YBN", "YBO", "YBP", "YBQ", "YBR", "YBS", "YBT", "YBU", "YBV", "YBW", "YBX", "YBY", "YBZ",
                    "ZBA", "ZBB", "ZBC", "ZBD", "ZBE", "ZBF", "ZBG", "ZBH", "ZBI", "ZBJ", "ZBK", "ZBL", "ZBM", "ZBN", "ZBO", "ZBP", "ZBQ", "ZBR", "ZBS", "ZBT", "ZBU", "ZBV", "ZBW", "ZBX", "ZBY", "ZBZ",

                    "ACA", "ACB", "ACC", "ACD", "ACE", "ACF", "ACG", "ACH", "ACI", "ACJ", "ACK", "ACL", "ACM", "ACN", "ACO", "ACP", "ACQ", "ACR", "ACS", "ACT", "ACU", "ACV", "ACW", "ACX", "ACY", "ACZ",
                    "BCA", "BCB", "BCC", "BCD", "BCE", "BCF", "BCG", "BCH", "BCI", "BCJ", "BCK", "BCL", "BCM", "BCN", "BCO", "BCP", "BCQ", "BCR", "BCS", "BCT", "BCU", "BCV", "BCW", "BCX", "BCY", "BCZ",
                    "CCA", "CCB", "CCC", "CCD", "CCE", "CCF", "CCG", "CCH", "CCI", "CCJ", "CCK", "CCL", "CCM", "CCN", "CCO", "CCP", "CCQ", "CCR", "CCS", "CCT", "CCU", "CCV", "CCW", "CCX", "CCY", "CCZ",
                    "DCA", "DCB", "DCC", "DCD", "DCE", "DCF", "DCG", "DCH", "DCI", "DCJ", "DCK", "DCL", "DCM", "DCN", "DCO", "DCP", "DCQ", "DCR", "DCS", "DCT", "DCU", "DCV", "DCW", "DCX", "DCY", "DCZ",
                    "ECA", "ECB", "ECC", "ECD", "ECE", "ECF", "ECG", "ECH", "ECI", "ECJ", "ECK", "ECL", "ECM", "ECN", "ECO", "ECP", "ECQ", "ECR", "ECS", "ECT", "ECU", "ECV", "ECW", "ECX", "ECY", "ECZ",
                    "FCA", "FCB", "FCC", "FCD", "FCE", "FCF", "FCG", "FCH", "FCI", "FCJ", "FCK", "FCL", "FCM", "FCN", "FCO", "FCP", "FCQ", "FCR", "FCS", "FCT", "FCU", "FCV", "FCW", "FCX", "FCY", "FCZ",
                    "GCA", "GCB", "GCC", "GCD", "GCE", "GCF", "GCG", "GCH", "GCI", "GCJ", "GCK", "GCL", "GCM", "GCN", "GCO", "GCP", "GCQ", "GCR", "GCS", "GCT", "GCU", "GCV", "GCW", "GCX", "GCY", "GCZ",
                    "HCA", "HCB", "HCC", "HCD", "HCE", "HCF", "HCG", "HCH", "HCI", "HCJ", "HCK", "HCL", "HCM", "HCN", "HCO", "HCP", "HCQ", "HCR", "HCS", "HCT", "HCU", "HCV", "HCW", "HCX", "HCY", "HCZ",
                    "ICA", "ICB", "ICC", "ICD", "ICE", "ICF", "ICG", "ICH", "ICI", "ICJ", "ICK", "ICL", "ICM", "ICN", "ICO", "ICP", "ICQ", "ICR", "ICS", "ICT", "ICU", "ICV", "ICW", "ICX", "ICY", "ICZ",
                    "JCA", "JCB", "JCC", "JCD", "JCE", "JCF", "JCG", "JCH", "JCI", "JCJ", "JCK", "JCL", "JCM", "JCN", "JCO", "JCP", "JCQ", "JCR", "JCS", "JCT", "JCU", "JCV", "JCW", "JCX", "JCY", "JCZ",
                    "KCA", "KCB", "KCC", "KCD", "KCE", "KCF", "KCG", "KCH", "KCI", "KCJ", "KCK", "KCL", "KCM", "KCN", "KCO", "KCP", "KCQ", "KCR", "KCS", "KCT", "KCU", "KCV", "KCW", "KCX", "KCY", "KCZ",
                    "LCA", "LCB", "LCC", "LCD", "LCE", "LCF", "LCG", "LCH", "LCI", "LCJ", "LCK", "LCL", "LCM", "LCN", "LCO", "LCP", "LCQ", "LCR", "LCS", "LCT", "LCU", "LCV", "LCW", "LCX", "LCY", "LCZ",
                    "MCA", "MCB", "MCC", "MCD", "MCE", "MCF", "MCG", "MCH", "MCI", "MCJ", "MCK", "MCL", "MCM", "MCN", "MCO", "MCP", "MCQ", "MCR", "MCS", "MCT", "MCU", "MCV", "MCW", "MCX", "MCY", "MCZ",
                    "NCA", "NCB", "NCC", "NCD", "NCE", "NCF", "NCG", "NCH", "NCI", "NCJ", "NCK", "NCL", "NCM", "NCN", "NCO", "NCP", "NCQ", "NCR", "NCS", "NCT", "NCU", "NCV", "NCW", "NCX", "NCY", "NCZ",
                    "OCA", "OCB", "OCC", "OCD", "OCE", "OCF", "OCG", "OCH", "OCI", "OCJ", "OCK", "OCL", "OCM", "OCN", "OCO", "OCP", "OCQ", "OCR", "OCS", "OCT", "OCU", "OCV", "OCW", "OCX", "OCY", "OCZ",
                    "PCA", "PCB", "PCC", "PCD", "PCE", "PCF", "PCG", "PCH", "PCI", "PCJ", "PCK", "PCL", "PCM", "PCN", "PCO", "PCP", "PCQ", "PCR", "PCS", "PCT", "PCU", "PCV", "PCW", "PCX", "PCY", "PCZ",
                    "QCA", "QCB", "QCC", "QCD", "QCE", "QCF", "QCG", "QCH", "QCI", "QCJ", "QCK", "QCL", "QCM", "QCN", "QCO", "QCP", "QCQ", "QCR", "QCS", "QCT", "QCU", "QCV", "QCW", "QCX", "QCY", "QCZ",
                    "RCA", "RCB", "RCC", "RCD", "RCE", "RCF", "RCG", "RCH", "RCI", "RCJ", "RCK", "RCL", "RCM", "RCN", "RCO", "RCP", "RCQ", "RCR", "RCS", "RCT", "RCU", "RCV", "RCW", "RCX", "RCY", "RCZ",
                    "SCA", "SCB", "SCC", "SCD", "SCE", "SCF", "SCG", "SCH", "SCI", "SCJ", "SCK", "SCL", "SCM", "SCN", "SCO", "SCP", "SCQ", "SCR", "SCS", "SCT", "SCU", "SCV", "SCW", "SCX", "SCY", "SCZ",
                    "TCA", "TCB", "TCC", "TCD", "TCE", "TCF", "TCG", "TCH", "TCI", "TCJ", "TCK", "TCL", "TCM", "TCN", "TCO", "TCP", "TCQ", "TCR", "TCS", "TCT", "TCU", "TCV", "TCW", "TCX", "TCY", "TCZ",
                    "UCA", "UCB", "UCC", "UCD", "UCE", "UCF", "UCG", "UCH", "UCI", "UCJ", "UCK", "UCL", "UCM", "UCN", "UCO", "UCP", "UCQ", "UCR", "UCS", "UCT", "UCU", "UCV", "UCW", "UCX", "UCY", "UCZ",
                    "VCA", "VCB", "VCC", "VCD", "VCE", "VCF", "VCG", "VCH", "VCI", "VCJ", "VCK", "VCL", "VCM", "VCN", "VCO", "VCP", "VCQ", "VCR", "VCS", "VCT", "VCU", "VCV", "VCW", "VCX", "VCY", "VCZ",
                    "WCA", "WCB", "WCC", "WCD", "WCE", "WCF", "WCG", "WCH", "WCI", "WCJ", "WCK", "WCL", "WCM", "WCN", "WCO", "WCP", "WCQ", "WCR", "WCS", "WCT", "WCU", "WCV", "WCW", "WCX", "WCY", "WCZ",
                    "XCA", "XCB", "XCC", "XCD", "XCE", "XCF", "XCG", "XCH", "XCI", "XCJ", "XCK", "XCL", "XCM", "XCN", "XCO", "XCP", "XCQ", "XCR", "XCS", "XCT", "XCU", "XCV", "XCW", "XCX", "XCY", "XCZ",
                    "YCA", "YCB", "YCC", "YCD", "YCE", "YCF", "YCG", "YCH", "YCI", "YCJ", "YCK", "YCL", "YCM", "YCN", "YCO", "YCP", "YCQ", "YCR", "YCS", "YCT", "YCU", "YCV", "YCW", "YCX", "YCY", "YCZ",
                    "ZCA", "ZCB", "ZCC", "ZCD", "ZCE", "ZCF", "ZCG", "ZCH", "ZCI", "ZCJ", "ZCK", "ZCL", "ZCM", "ZCN", "ZCO", "ZCP", "ZCQ", "ZCR", "ZCS", "ZCT", "ZCU", "ZCV", "ZCW", "ZCX", "ZCY", "ZCZ",

                    "ADA", "ADB", "ADC", "ADD", "ADE", "ADF", "ADG", "ADH", "ADI", "ADJ", "ADK", "ADL", "ADM", "ADN", "ADO", "ADP", "ADQ", "ADR", "ADS", "ADT", "ADU", "ADV", "ADW", "ADX", "ADY", "ADZ",
                    "BDA", "BDB", "BDC", "BDD", "BDE", "BDF", "BDG", "BDH", "BDI", "BDJ", "BDK", "BDL", "BDM", "BDN", "BDO", "BDP", "BDQ", "BDR", "BDS", "BDT", "BDU", "BDV", "BDW", "BDX", "BDY", "BDZ",
                    "CDA", "CDB", "CDC", "CDD", "CDE", "CDF", "CDG", "CDH", "CDI", "CDJ", "CDK", "CDL", "CDM", "CDN", "CDO", "CDP", "CDQ", "CDR", "CDS", "CDT", "CDU", "CDV", "CDW", "CDX", "CDY", "CDZ",
                    "DDA", "DDB", "DDC", "DDD", "DDE", "DDF", "DDG", "DDH", "DDI", "DDJ", "DDK", "DDL", "DDM", "DDN", "DDO", "DDP", "DDQ", "DDR", "DDS", "DDT", "DDU", "DDV", "DDW", "DDX", "DDY", "DDZ",
                    "EDA", "EDB", "EDC", "EDD", "EDE", "EDF", "EDG", "EDH", "EDI", "EDJ", "EDK", "EDL", "EDM", "EDN", "EDO", "EDP", "EDQ", "EDR", "EDS", "EDT", "EDU", "EDV", "EDW", "EDX", "EDY", "EDZ",
                    "FDA", "FDB", "FDC", "FDD", "FDE", "FDF", "FDG", "FDH", "FDI", "FDJ", "FDK", "FDL", "FDM", "FDN", "FDO", "FDP", "FDQ", "FDR", "FDS", "FDT", "FDU", "FDV", "FDW", "FDX", "FDY", "FDZ",
                    "GDA", "GDB", "GDC", "GDD", "GDE", "GDF", "GDG", "GDH", "GDI", "GDJ", "GDK", "GDL", "GDM", "GDN", "GDO", "GDP", "GDQ", "GDR", "GDS", "GDT", "GDU", "GDV", "GDW", "GDX", "GDY", "GDZ",
                    "HDA", "HDB", "HDC", "HDD", "HDE", "HDF", "HDG", "HDH", "HDI", "HDJ", "HDK", "HDL", "HDM", "HDN", "HDO", "HDP", "HDQ", "HDR", "HDS", "HDT", "HDU", "HDV", "HDW", "HDX", "HDY", "HDZ",
                    "IDA", "IDB", "IDC", "IDD", "IDE", "IDF", "IDG", "IDH", "IDI", "IDJ", "IDK", "IDL", "IDM", "IDN", "IDO", "IDP", "IDQ", "IDR", "IDS", "IDT", "IDU", "IDV", "IDW", "IDX", "IDY", "IDZ",
                    "JDA", "JDB", "JDC", "JDD", "JDE", "JDF", "JDG", "JDH", "JDI", "JDJ", "JDK", "JDL", "JDM", "JDN", "JDO", "JDP", "JDQ", "JDR", "JDS", "JDT", "JDU", "JDV", "JDW", "JDX", "JDY", "JDZ",
                    "KDA", "KDB", "KDC", "KDD", "KDE", "KDF", "KDG", "KDH", "KDI", "KDJ", "KDK", "KDL", "KDM", "KDN", "KDO", "KDP", "KDQ", "KDR", "KDS", "KDT", "KDU", "KDV", "KDW", "KDX", "KDY", "KDZ",
                    "LDA", "LDB", "LDC", "LDD", "LDE", "LDF", "LDG", "LDH", "LDI", "LDJ", "LDK", "LDL", "LDM", "LDN", "LDO", "LDP", "LDQ", "LDR", "LDS", "LDT", "LDU", "LDV", "LDW", "LDX", "LDY", "LDZ",
                    "MDA", "MDB", "MDC", "MDD", "MDE", "MDF", "MDG", "MDH", "MDI", "MDJ", "MDK", "MDL", "MDM", "MDN", "MDO", "MDP", "MDQ", "MDR", "MDS", "MDT", "MDU", "MDV", "MDW", "MDX", "MDY", "MDZ",
                    "NDA", "NDB", "NDC", "NDD", "NDE", "NDF", "NDG", "NDH", "NDI", "NDJ", "NDK", "NDL", "NDM", "NDN", "NDO", "NDP", "NDQ", "NDR", "NDS", "NDT", "NDU", "NDV", "NDW", "NDX", "NDY", "NDZ",
                    "ODA", "ODB", "ODC", "ODD", "ODE", "ODF", "ODG", "ODH", "ODI", "ODJ", "ODK", "ODL", "ODM", "ODN", "ODO", "ODP", "ODQ", "ODR", "ODS", "ODT", "ODU", "ODV", "ODW", "ODX", "ODY", "ODZ",
                    "PDA", "PDB", "PDC", "PDD", "PDE", "PDF", "PDG", "PDH", "PDI", "PDJ", "PDK", "PDL", "PDM", "PDN", "PDO", "PDP", "PDQ", "PDR", "PDS", "PDT", "PDU", "PDV", "PDW", "PDX", "PDY", "PDZ",
                    "QDA", "QDB", "QDC", "QDD", "QDE", "QDF", "QDG", "QDH", "QDI", "QDJ", "QDK", "QDL", "QDM", "QDN", "QDO", "QDP", "QDQ", "QDR", "QDS", "QDT", "QDU", "QDV", "QDW", "QDX", "QDY", "QDZ",
                    "RDA", "RDB", "RDC", "RDD", "RDE", "RDF", "RDG", "RDH", "RDI", "RDJ", "RDK", "RDL", "RDM", "RDN", "RDO", "RDP", "RDQ", "RDR", "RDS", "RDT", "RDU", "RDV", "RDW", "RDX", "RDY", "RDZ",
                    "SDA", "SDB", "SDC", "SDD", "SDE", "SDF", "SDG", "SDH", "SDI", "SDJ", "SDK", "SDL", "SDM", "SDN", "SDO", "SDP", "SDQ", "SDR", "SDS", "SDT", "SDU", "SDV", "SDW", "SDX", "SDY", "SDZ",
                    "TDA", "TDB", "TDC", "TDD", "TDE", "TDF", "TDG", "TDH", "TDI", "TDJ", "TDK", "TDL", "TDM", "TDN", "TDO", "TDP", "TDQ", "TDR", "TDS", "TDT", "TDU", "TDV", "TDW", "TDX", "TDY", "TDZ",
                    "UDA", "UDB", "UDC", "UDD", "UDE", "UDF", "UDG", "UDH", "UDI", "UDJ", "UDK", "UDL", "UDM", "UDN", "UDO", "UDP", "UDQ", "UDR", "UDS", "UDT", "UDU", "UDV", "UDW", "UDX", "UDY", "UDZ",
                    "VDA", "VDB", "VDC", "VDD", "VDE", "VDF", "VDG", "VDH", "VDI", "VDJ", "VDK", "VDL", "VDM", "VDN", "VDO", "VDP", "VDQ", "VDR", "VDS", "VDT", "VDU", "VDV", "VDW", "VDX", "VDY", "VDZ",
                    "WDA", "WDB", "WDC", "WDD", "WDE", "WDF", "WDG", "WDH", "WDI", "WDJ", "WDK", "WDL", "WDM", "WDN", "WDO", "WDP", "WDQ", "WDR", "WDS", "WDT", "WDU", "WDV", "WDW", "WDX", "WDY", "WDZ",
                    "XDA", "XDB", "XDC", "XDD", "XDE", "XDF", "XDG", "XDH", "XDI", "XDJ", "XDK", "XDL", "XDM", "XDN", "XDO", "XDP", "XDQ", "XDR", "XDS", "XDT", "XDU", "XDV", "XDW", "XDX", "XDY", "XDZ",
                    "YDA", "YDB", "YDC", "YDD", "YDE", "YDF", "YDG", "YDH", "YDI", "YDJ", "YDK", "YDL", "YDM", "YDN", "YDO", "YDP", "YDQ", "YDR", "YDS", "YDT", "YDU", "YDV", "YDW", "YDX", "YDY", "YDZ",
                    "ZDA", "ZDB", "ZDC", "ZDD", "ZDE", "ZDF", "ZDG", "ZDH", "ZDI", "ZDJ", "ZDK", "ZDL", "ZDM", "ZDN", "ZDO", "ZDP", "ZDQ", "ZDR", "ZDS", "ZDT", "ZDU", "ZDV", "ZDW", "ZDX", "ZDY", "ZDZ"

                };

            while (fin <= limite)
            {
                //traer la lista de piezas
                var listObras = dbx.Obras.Where(a => a.ObraID > inicio && a.ObraID <= fin).Select(a => new { a.ObraID, a.TipoObraID, a.AntID, a.Clave, a.UbicacionID }).ToList();

                foreach (var obra in listObras)
                {
                    var anonimaOtraPieza = listaAnt.Where(a => a.id_pieza == obra.AntID).ToList();
                    if (anonimaOtraPieza.Count > 0)
                    {
                        foreach (var aop in anonimaOtraPieza)
                        {
                            //buscar tipoPieza
                            var tipoPieza = dbx.TipoPiezas.Where(a => a.TipoObraID == obra.TipoObraID && a.AntID == aop.TipoPieza_Clave).Select(a => new { a.TipoObraID, a.TipoPiezaID, a.Clave, a.AntID }).FirstOrDefault();
                            if (tipoPieza == null)
                            {
                                int orden = dbx.TipoPiezas.Where(a => a.TipoObraID == obra.TipoObraID).Count() + 1;
                                string clave = letras[orden - 1];
                                string nombre = "Pendiente por definir";

                                if (aop.TipoPieza_Clave != "0")
                                {
                                    nombre = aop.TipoPieza_Descripcion;
                                }

                                //crear el TipoPieza con AntID = antID
                                TipoPieza tp = new TipoPieza()
                                {
                                    Nombre = nombre,
                                    Clave = clave,
                                    Orden = orden,
                                    Status = true,
                                    TipoObraID = obra.TipoObraID,
                                    EsMaestra = false,
                                    AntID = aop.TipoPieza_Clave
                                };

                                dbx.TipoPiezas.Add(tp);
                                dbx.SaveChanges();
                                tipoPieza = dbx.TipoPiezas.Where(a => a.TipoObraID == obra.TipoObraID && a.AntID == aop.TipoPieza_Clave).Select(a => new { a.TipoObraID, a.TipoPiezaID, a.Clave, a.AntID }).FirstOrDefault();
                            }

                            //ya tenemos el TipoPieza
                            //buscar si ya existe la Pieza con el TipoPieza si no crearlo
                            string antID = aop.id_pieza + "-" + aop.Sub_pieza;
                            var pieza = dbx.Piezas.Where(a => a.AntID == antID).Select(a => new { a.PiezaID, a.AntID, a.Clave, a.ObraID, a.TipoPiezaID }).FirstOrDefault();
                            if (pieza == null)
                            {
                                var clave = obra.Clave + "-" + tipoPieza.Clave;
                                //CONTAR PIEZAS QUE EXISTEN EN ESTA OBRA CON ESE TIPO DE PIEZA
                                int totalPiezas = dbx.Piezas.Where(a => a.TipoPiezaID == tipoPieza.TipoPiezaID && a.ObraID == obra.ObraID).Count();

                                if (totalPiezas != 0)
                                {
                                    clave = clave + (totalPiezas + 1);
                                }

                                Pieza p = new Pieza()
                                {
                                    ObraID = obra.ObraID,
                                    Clave = clave,
                                    TipoPiezaID = tipoPieza.TipoPiezaID,
                                    UbicacionID = obra.UbicacionID,
                                    FechaRegistro = DateTime.Now,
                                    Status = true,
                                    AntID = antID
                                };

                                dbx.Piezas.Add(p);
                                dbx.SaveChanges();
                                //registrar todo lo que tenga la tabla
                                //TecnicaPieza - MatriculaTecnica_Clave
                                var tecnica = listaTecnicas.FirstOrDefault(a => a.AntID == aop.MatriculaTecnica_Clave);
                                if (tecnica != null)
                                {
                                    TecnicaPieza tecPieza = new TecnicaPieza()
                                    {
                                        PiezaID = p.PiezaID,
                                        TecnicaID = tecnica.TecnicaID,
                                        Status = true
                                    };
                                    dbx.TecnicaPiezas.Add(tecPieza);
                                }

                                //Titulo - TipoPieza_Descripcion
                                if (!string.IsNullOrWhiteSpace(aop.TipoPieza_Descripcion))
                                {
                                    Int64 attID_Titulo = dbx.Atributos.Where(a => a.TipoAtributoID == tipoAtt_Titulo && a.TipoPiezaID == tipoPieza.TipoPiezaID).Select(a => a.AtributoID).FirstOrDefault();
                                    if (attID_Titulo == 0)
                                    {
                                        Atributo attTitulo = new Atributo()
                                        {
                                            TipoAtributoID = tipoAtt_Titulo,
                                            TipoPiezaID = tipoPieza.TipoPiezaID,
                                            Status = true,
                                            EnFichaBasica = true,
                                            Orden = 1,
                                            Requerido = false
                                        };
                                        dbx.Atributos.Add(attTitulo);
                                        dbx.SaveChanges();
                                        attID_Titulo = attTitulo.AtributoID;
                                    }
                                    AtributoPieza attPiezaTitulo = new AtributoPieza()
                                    {
                                        PiezaID = p.PiezaID,
                                        AtributoID = attID_Titulo,
                                        Valor = aop.TipoPieza_Descripcion
                                    };
                                    dbx.AtributoPiezas.Add(attPiezaTitulo);
                                }

                                //Descripcion - Descripcion
                                if (!string.IsNullOrWhiteSpace(aop.Descripcion))
                                {
                                    Int64 attID_Descripcion = dbx.Atributos.Where(a => a.TipoAtributoID == tipoAtt_Descripcion && a.TipoPiezaID == tipoPieza.TipoPiezaID).Select(a => a.AtributoID).FirstOrDefault();
                                    if (attID_Descripcion == 0)
                                    {
                                        Atributo attDescripcion = new Atributo()
                                        {
                                            TipoAtributoID = tipoAtt_Descripcion,
                                            TipoPiezaID = tipoPieza.TipoPiezaID,
                                            Status = true,
                                            EnFichaBasica = true,
                                            Orden = 1,
                                            Requerido = false
                                        };
                                        dbx.Atributos.Add(attDescripcion);
                                        dbx.SaveChanges();
                                        attID_Descripcion = attDescripcion.AtributoID;
                                    }
                                    AtributoPieza attPiezaDescripcion = new AtributoPieza()
                                    {
                                        PiezaID = p.PiezaID,
                                        AtributoID = attID_Descripcion,
                                        Valor = aop.Descripcion
                                    };
                                    dbx.AtributoPiezas.Add(attPiezaDescripcion);
                                }

                                //Medidas - Sin cuadro o marco - Alto, Ancho, Fondo, Diametro,Diametro2
                                string nombreMedida = "Sin marco ó base";
                                Int64 tipoMed = db.TipoMedidas.Where(a => a.Nombre == nombreMedida).Select(a => a.TipoMedidaID).FirstOrDefault();

                                Medida med = new Medida()
                                {
                                    Ancho = aop.Ancho,
                                    Diametro = aop.Diametro,
                                    Largo = aop.Alto,
                                    PiezaID = p.PiezaID,
                                    Profundidad = aop.Fondo,
                                    Status = true,
                                    TipoMedidaID = tipoMed,
                                };

                                dbx.Medidas.Add(med);
                                pieza = dbx.Piezas.Where(a => a.AntID == antID).Select(a => new { a.PiezaID, a.AntID, a.Clave, a.ObraID, a.TipoPiezaID }).FirstOrDefault();
                            }

                            //agregar la foto
                            //ImagenPieza - ruta_imagen
                            if (!string.IsNullOrWhiteSpace(aop.ruta_imagen))
                            {
                                ImagenPieza imgPieza = new ImagenPieza()
                                {
                                    PiezaID = pieza.PiezaID,
                                    Orden = aop.nSubIndex,
                                    Titulo = aop.TipoPieza_Descripcion,
                                    ImgNombre = aop.ruta_imagen,
                                    Status = true,
                                };

                                dbx.ImagenPiezas.Add(imgPieza);
                            }
                        }
                    }
                }

                dbx.SaveChanges();

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

                inicio = fin;
                fin = fin + total;
            }

            //}
            //catch (Exception)
            //{

            //    throw;
            //}

            return View();
        }
コード例 #8
0
        public ActionResult Crear([Bind(Include = "AtributoID,TipoPiezaID,TipoAtributoID,NombreAlterno,Orden,Status,EnFichaBasica,Requerido")] Atributo atributo, Int64? id)
        {
            if (ModelState.IsValid)
            {
                var tipoAtt = db.TipoAtributos.SingleOrDefault(a=> a.TipoAtributoID == atributo.TipoAtributoID);

                if (tipoAtt != null)
                {
                    atributo.Orden = Convert.ToInt32(tipoAtt.BuscadorOrden);
                }

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

                //al crear un nuevo atributo hay que agregarlo en todas las obras ya registradas
                atributo.TipoAtributo = db.TipoAtributos.Find(atributo.TipoAtributoID);

                var piezas = db.Piezas.Where(p => p.TipoPiezaID == atributo.TipoPiezaID).ToList();

                int i = 0;
                db.Dispose();
                db = new RecordFCSContext();
                db.Configuration.AutoDetectChangesEnabled = false;

                foreach (var pieza in piezas)
                {
                    AtributoPieza atributoPieza = new AtributoPieza
                    {
                        AtributoID = atributo.AtributoID,
                        PiezaID = pieza.PiezaID
                    };
                    //error tratar si no existe ningun registro
                    ////if (atributo.TipoAtributo.EsLista)
                    ////{
                    ////    atributoPieza.ListaValorID = db.ListaValores.Single(lv => (lv.TipoAtributoID == atributo.TipoAtributo.TipoAtributoID && lv.Valor == "- Sin definir -")).ListaValorID;
                    ////}

                    db.AtributoPiezas.Add(atributoPieza);
                    i++;

                    if (i == 500 )
                    {
                        db.SaveChanges();
                        db.Dispose();
                        db = new RecordFCSContext();
                        db.Configuration.AutoDetectChangesEnabled = false;
                        i = 0;
                    }
                }
                db.SaveChanges();

                AlertaSuccess(string.Format("Atributo: <b>{0}</b> se agrego con exitó.", atributo.TipoAtributo.Nombre), true);
                string url = Url.Action("Lista", "Atributo", new { id = atributo.TipoPiezaID });

                return Json(new { success = true, url = url, modelo = "Atributo" });
            }

            // llenar el select personalizado
            var query = db.TipoAtributos.Where(ta => ta.Status == true);
            var listaTipoAtributos = new List<object>();
            foreach (var ta in query)
            {
                var esLista = ta.EsLista ? "[+]" : "";
                var datoHTML = " -- [" + ta.DatoHTML + "]";
                var descripcion = ta.Descripcion == null ? "" : "[" + ta.Descripcion + "]";
                listaTipoAtributos.Add(new
                {
                    TipoAtributoID = ta.TipoAtributoID,
                    Nombre = ta.Nombre + esLista + datoHTML + descripcion
                });
            }

            ViewBag.TipoAtributoID = new SelectList(listaTipoAtributos, "TipoAtributoID", "Nombre", atributo.TipoAtributoID);

            return PartialView("_Crear", atributo);
        }
コード例 #9
0
        //Prueba restructura AUTOR
        public ActionResult Restructura_AtributoPieza(Int64? id)
        {
            string error = "";
            string descripcion = "";

            if (id != null)
            {
                var atributo = db.Atributos.Where(a => a.AtributoID == id).Select(a => new { a.AtributoID, a.TipoAtributoID, a.TipoPiezaID }).FirstOrDefault();
                if (atributo != null)
                {

                    //listar todas las piezas que pertenescan al tipo
                    var listaTotalPiezas = db.Piezas.Where(a => a.TipoPiezaID == atributo.TipoPiezaID).Select(a => new { a.PiezaID, a.ObraID }).ToList();
                    var listaPiezasCompletas = db.AtributoPiezas.Where(a => a.AtributoID == atributo.AtributoID).Select(a => new { a.PiezaID, a.Pieza.ObraID }).ToList();

                    var listaPiezas = listaTotalPiezas.Except(listaPiezasCompletas).ToList();

                    int i = 0;
                    db.Dispose();
                    db = new RecordFCSContext();
                    db.Configuration.AutoDetectChangesEnabled = false;

                    foreach (var pieza in listaPiezas)
                    {

                        //crear el AtributoPieza
                        //exception de PRIMARY KEY DUPLICADA
                        try
                        {
                            i++;
                            db.AtributoPiezas.Add(new AtributoPieza()
                            {
                                AtributoID = atributo.AtributoID,
                                PiezaID = pieza.PiezaID
                            });

                        }
                        catch (SqlException ex)
                        {
                            if (ex.Number == 2627)
                            {
                                //Violation of primary key. Handle Exception
                                descripcion = string.Format("llave duplicada en ObraID = {0}, PiezaID = {1} ", pieza.ObraID, pieza.PiezaID);
                            }
                        }

                        if (i >= 500)
                        {
                            db.SaveChanges();

                            db.Dispose();
                            db = new RecordFCSContext();
                            db.Configuration.AutoDetectChangesEnabled = false;
                            i = 0;
                        }

                    }

                }
                else
                    error = string.Format("Atributo no existe. TO = {0}", id);
            }
            else
                error = "Atributo es NULL";

            db.SaveChanges();

            bool errorx = false;
            string tituloMenu = "";
            string descripcionx = "";
            int totalPiezas = 0;
            int totalPiezasCompletas = 0;
            int totalPiezasInCompletas = 0;
            double porCompleto = 0;
            double porIncompleto = 0;

            //Calcular el total de piezas que existen en TipoObra
            //y cuales estan faltan
            if (id != null)
            {
                var atributo = db.Atributos.FirstOrDefault(a => a.AtributoID == id);
                if (id != null)
                {
                    totalPiezas = db.Piezas.Where(a => a.TipoPiezaID == atributo.TipoPiezaID).Count();
                    totalPiezasCompletas = db.AtributoPiezas.Where(a => a.AtributoID == atributo.AtributoID).Count();

                    totalPiezasInCompletas = totalPiezas - totalPiezasCompletas;

                    tituloMenu = atributo.TipoPieza.Nombre;
                    descripcion = atributo.TipoAtributo.Nombre;

                    //total / completas
                    porCompleto = (totalPiezasCompletas * 100) / totalPiezas;
                    porIncompleto = (totalPiezasInCompletas * 100) / totalPiezas;

                }
                else
                {
                    errorx = true;
                    tituloMenu = "Error de Atributo";
                    descripcion = "No existe el Atributo";
                }
            }
            else
            {
                errorx = true;
                tituloMenu = "Error de Atributo";
                descripcion = "No existe el Atributo";
            }

            ViewBag.atributoID = id;
            ViewBag.totalPiezas = totalPiezas;
            ViewBag.totalPiezasCompletas = totalPiezasCompletas;
            ViewBag.totalPiezasInCompletas = totalPiezasInCompletas;
            ViewBag.error = errorx;
            ViewBag.tituloMenu = tituloMenu;
            ViewBag.descripcion = descripcionx;
            ViewBag.porCompleto = porCompleto + "%";
            ViewBag.porIncompleto = porIncompleto + "%";

            return PartialView("_fin");
        }
コード例 #10
0
        public ActionResult IniciarMigracion()
        {
            RecordFCSContext dbx = new RecordFCSContext();

            int bloqueGuardar = 500;

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

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

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

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

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

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

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

                var i = 0;

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

                    };

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

                }
                con1.Close();
                leer1 = null;

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

                foreach (var row in listaArchivoCEHM)
                {

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

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

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

                    }

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

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

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

                        if (tipoAtt.EsGenerico)
                        {

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

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

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

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

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

                                     */

                                    var addOK = true;
                                    string valorText = "";

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

                                            valorText = addOK ? row.Tema : "";

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

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

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

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

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

                                            break;
                                        default:
                                            addOK = false;
                                            break;
                                    }

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

                                    var addOK = true;
                                    string valorText = "";

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

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

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

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

                                        case "titulo":
                                            // Tipodedocumento, Dirigidoa

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

                                        default:
                                            addOK = false;
                                            break;
                                    }

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

                                    }

                                }
                            }

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

                            var addOK = true;
                            string valorText = "";

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

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

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

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

                            }

                        }

                    }

                    numeroRow++;
                }

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

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

            }

            return View();
        }