public ActionResult CambiarStatus(Int64? id, bool Estado)
{
if (id == null)
{
return new HttpStatusCodeResult(HttpStatusCode.BadRequest);
}
Pieza pieza = new Pieza()
{
PiezaID = Convert.ToInt64(id),
Status = Estado
};
if (Estado)
{
ViewBag.PagName = "Activar";
ViewBag.Estado = ViewBag.PagName;
}
else
{
ViewBag.PagName = "Desactivar";
ViewBag.Estado = ViewBag.PagName;
}
return PartialView("_CambiarStatus", pieza);
}
//IMPORTAR PIEZA DESCRIPTIVO
public ActionResult ImportarPieza_Descriptivo()
{
/*
*
* AutorPieza Autor_Clave
* generico titulo
* generico_L EscArtistica_Clave
* generico_L FormaAdquisicion_Clave
* generico_L Procedencia_Clave
* generico_L FiliacionEstilistica_Clave
* generico_L CasaComercial_Clave
* generico_L EdoConservacion_Clave
* generico descripcion
* generico grafica
* generico otros_materiales
* generico catalogo
* generico numero_catalogo
* generico palabra_clave
* generico palabra_clave
* generico numero_registro
* generico titulo_ori
* generico Procedencia
*
*
*
*
*
* ------------ IMPLEMENTAR INDEPENDIENTES --------------
* * ???????? cve_marco
*
* ImagenPieza m_pieza_foto
*
* ColeccionGibranPieza ClassColeccion_Clave
* TecnicaMarco MTecnicaMarco_Clave
* Médidas m_pieza_dimensiones
*
* * CatalogoPieza m_cats
* ExposicionPieza m_guion_det
* TecnicaPieza MatriculaTecnica_Clave
* MatriculaPieza Matricula_Clave
*/
// Inicia el contador:
Stopwatch tiempo = Stopwatch.StartNew();
var tAtt_Autor = db.TipoAtributos.SingleOrDefault(a => a.AntNombre == "Autor_Clave").TipoAtributoID;
//TipoAtributo tAtt_Autor = db.TipoAtributos.SingleOrDefault(a => a.AntNombre == "Autor_Clave");
//TipoAtributo tAtt_Catalogo = db.TipoAtributos.Single(a => a.AntNombre == "Autor_Clave");
//TipoAtributo tAtt_Exposicion = db.TipoAtributos.Single(a => a.AntNombre == "Autor_Clave");
//TipoAtributo tAtt_Tecnica = db.TipoAtributos.Single(a => a.AntNombre == "Autor_Clave");
//TipoAtributo tAtt_Matricula = db.TipoAtributos.Single(a => a.AntNombre == "Autor_Clave");
//
ViewBag.NombreTabla = "CATALOGO DE OBRAS - REGISTRO BASICO";
ViewBag.error = "";
try
{
// mandar mensaje de conexcion
ViewBag.mensaje = "Conexión establecida";
//definir el sql
var total = 500;
var inicio = 2520; //colocar AntID no el ObraID
var fin = inicio + total;
var limite = 103475;
while (fin <= limite)
{
con1.Open();
string textSql = string.Format("SELECT * FROM [m_pieza_descriptivo] WHERE [id_pieza] > {0} AND [id_pieza] <= {1}", inicio, fin);
SqlCommand sql = new SqlCommand(textSql, con1);
SqlDataReader leer = sql.ExecuteReader();
while (leer.Read())
{
//Buscar que la Obra Exista
string idPiezaText = leer["id_pieza"].ToString();
Obra obra = null;
var xObra = db.Obras.Where(a => a.AntID == idPiezaText).Select(a => new { a.ObraID, a.AntID, a.Clave });
if (xObra.Count() > 0)
{
obra = new Obra()
{
ObraID = xObra.FirstOrDefault().ObraID,
AntID = xObra.FirstOrDefault().AntID,
Clave = xObra.FirstOrDefault().Clave
};
}
if (obra != null)
{
//traer la PiezaMaestra
string claveText = obra.Clave + "-A";
Pieza piezaMaestra = null;
var xPiezaMaestra = db.Piezas.Where(a => a.Clave == claveText && a.ObraID == obra.ObraID).Select(a => new { a.ObraID, a.PiezaID, a.Clave, a.TipoPiezaID });
if (xPiezaMaestra.Count() > 0)
{
piezaMaestra = new Pieza()
{
ObraID = xPiezaMaestra.FirstOrDefault().ObraID,
PiezaID = xPiezaMaestra.FirstOrDefault().PiezaID,
TipoPiezaID = xPiezaMaestra.FirstOrDefault().TipoPiezaID,
Clave = xPiezaMaestra.FirstOrDefault().Clave
};
}
if (piezaMaestra != null)
{
// AUTOR_PIEZA ------------------------------------------------------------------------------------------------
// Autor_Clave ------------------------------------------------------------------------------------------------
string autorIDText = leer["Autor_Clave"].ToString();
Autor autor = null;
var xAutor = db.Autores.Where(a => a.AntID == autorIDText).Select(a => new { a.AutorID });
if (xAutor.Count() > 0)
{
autor = new Autor()
{
AutorID = xAutor.FirstOrDefault().AutorID
};
}
//si autor == null o "0" no hacer nada
if (autor != null)
{
//Buscar que exista Atributo con TipoPieza y TipoAtributo
Atributo att = null;
var xAtt = db.Atributos.Where(a => a.TipoAtributoID == tAtt_Autor && a.TipoPiezaID == piezaMaestra.TipoPiezaID).Select(a => new { a.AtributoID });
if (xAtt.Count() > 0)
{
att = new Atributo()
{
AtributoID = xAtt.FirstOrDefault().AtributoID
};
}
else
{
//no existe entonces crearlo
att.TipoPiezaID = piezaMaestra.TipoPiezaID;
att.TipoAtributoID = tAtt_Autor;
att.NombreAlterno = null;
att.Orden = 100;
att.Status = true;
att.Requerido = true;
att.EnFichaBasica = true;
db.Atributos.Add(att);
db.SaveChanges();
}
//comenzar creacion del AtributoPieza con valores null
AtributoPieza attPiezaGenAutor = new AtributoPieza()
{
PiezaID = piezaMaestra.PiezaID,
AtributoID = att.AtributoID,
};
db.AtributoPiezas.Add(attPiezaGenAutor);
AutorPieza autorPieza = new AutorPieza()
{
PiezaID = piezaMaestra.PiezaID,
AutorID = autor.AutorID,
Status = true
};
db.AutorPiezas.Add(autorPieza);
}
// GENERICOS --------------------------------------------------------------------------------------------------
List<string> campos = new List<string>()
{
"titulo",
"EscArtistica_Clave",
"FormaAdquisicion_Clave",
"Procedencia_Clave",
"FiliacionEstilistica_Clave",
"CasaComercial_Clave",
"EdoConservacion_Clave",
"descripcion",
"otros_materiales",
"catalogo",
"numero_catalogo",
"numero_registro",
"titulo_ori",
"Procedencia"
};
foreach (var campoAnt in campos)
{
//buscar el tipo de atributo
TipoAtributo tipoAttGen = null;
var xTipoAttGen = db.TipoAtributos.Where(a => a.AntNombre == campoAnt).Select(a => new { a.EsLista, a.TipoAtributoID });
if (xTipoAttGen.Count() > 0)
{
tipoAttGen = new TipoAtributo()
{
EsLista = xTipoAttGen.FirstOrDefault().EsLista,
TipoAtributoID = xTipoAttGen.FirstOrDefault().TipoAtributoID
};
}
if (tipoAttGen != null)
{
//Extraer el valor a buscar o guardar de la base vieja
string valorCampo = leer[campoAnt].ToString();
//Validar el valor del campo
bool todoOk = true;
if (tipoAttGen.EsLista)
{
if (valorCampo == "0")
{
todoOk = false;
}
}
else
{
if (valorCampo == "0" || valorCampo == "" || valorCampo == " " || valorCampo == "-" || valorCampo == " -" || valorCampo == "Pendiente por definir")
{
todoOk = false;
}
}
//paso la validacion
if (todoOk)
{
//Buscar que el Atributo Exista con TipoPieza y TipoAtributo
Atributo attGen = null;
var xAttGen = db.Atributos.Where(a => a.TipoAtributoID == tipoAttGen.TipoAtributoID && a.TipoPiezaID == piezaMaestra.TipoPiezaID).Select(a => new { a.AtributoID });
if (xAttGen.Count() > 0)
{
attGen = new Atributo()
{
AtributoID = xAttGen.FirstOrDefault().AtributoID
};
}
else
{
//si no existe entonces crearlo
attGen = new Atributo()
{
TipoPiezaID = piezaMaestra.TipoPiezaID,
TipoAtributoID = tipoAttGen.TipoAtributoID,
Orden = 100,
Status = true,
Requerido = false,
EnFichaBasica = false
};
db.Atributos.Add(attGen);
db.SaveChanges();
}
//comenzar creacion del AtributoPieza con el valor extraido y validado
AtributoPieza attPiezaGen = new AtributoPieza()
{
PiezaID = piezaMaestra.PiezaID,
AtributoID = attGen.AtributoID,
};
if (tipoAttGen.EsLista)
{
//buscar el valor en ListaValor en el tipo de atributo
ListaValor listaValorGen = null;
var xListaValorGen = db.ListaValores.Where(a => a.AntID == valorCampo && a.TipoAtributoID == tipoAttGen.TipoAtributoID).Select(a => new { a.ListaValorID });
if (xListaValorGen.Count() > 0)
{
listaValorGen = new ListaValor()
{
ListaValorID = xListaValorGen.FirstOrDefault().ListaValorID
};
}
if (listaValorGen != null)
{
attPiezaGen.ListaValorID = listaValorGen.ListaValorID;
db.AtributoPiezas.Add(attPiezaGen);
db.SaveChanges();
}
}
else
{
attPiezaGen.Valor = valorCampo;
db.AtributoPiezas.Add(attPiezaGen);
db.SaveChanges();
}
}
}
else
{
ViewBag.error = "error";
ViewBag.mensaje = "No existe la Tipo de Atributo, intenta resolver el problema antes de continuar";
}
}
// ------------------------------------------------------------------------------------------------------------
// ------------------------------------------------------------------------------------------------------------
db.SaveChanges();
}
else
{
ViewBag.error = "error";
ViewBag.mensaje = "No existe la PiezaMaestra, intenta resolver el problema antes de continuar";
}
}
else
{
ViewBag.error = "error";
ViewBag.mensaje = "No existe la Obra, intenta resolver el problema antes de continuar";
}
}
inicio = fin;
fin = fin + total;
con1.Close();
}
// Para el contador e imprime el resultado:
ViewBag.TiempoTotal = tiempo.Elapsed.TotalSeconds.ToString();
var lista = db.Piezas.ToList();
ViewBag.TotalRegistros = lista.Count;
return PartialView("_ImportarPieza_Descriptivo", lista);
}
catch (Exception)
{
ViewBag.error = "error";
ViewBag.mensaje = "Conexión fallida";
}
ViewBag.TiempoTotal = tiempo.Elapsed.TotalSeconds.ToString();
return PartialView("_ImportarPieza_Descriptivo");
}
//---------------------------------------------------------------------
// 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();
}
//---------------------------------------------------------------------------
public ActionResult ImportarObras_Obra()
{
// Inicia el contador:
Stopwatch tiempo = Stopwatch.StartNew();
ViewBag.NombreTabla = "CATALOGO DE OBRAS - REGISTRO BASICO";
ViewBag.error = "";
try
{
//abrir conexion
// mandar mensaje de conexcion
ViewBag.mensaje = "Conexión establecida";
//List<Obra> lista = new List<Obra>();
//definir el sql
var total = 1000;
var inicio = 99331; //ultimo registro en la base vieja
var fin = inicio + total;
var limite = 105475;
while (fin <= limite)
{
con1.Open();
string textSql = string.Format("SELECT * FROM [m_pieza] WHERE [id_pieza] > {0} AND [id_pieza] <= {1}", inicio, fin);
//string textSql = string.Format("SELECT * FROM [m_pieza]");
SqlCommand sql = new SqlCommand(textSql, con1);
//ejecutar el sql
SqlDataReader leer = sql.ExecuteReader();
//realizar el foreach
while (leer.Read())
{
//registros a traer y donde guardarlos
/*
* OK ---------- O B R A ------------------------------
* id_pieza = obra.Clave, obra.AntID
* TipoAdquisicion_Clave = obra.TipoAdquisicionID
* Ubicacion_Clave = obra.UbicacionID
* Propietario_Clave = obra.PropietarioID
* TipoObjeto_Clave = obra.TipoObraID
* fecha_registro_ORI = obra.FechaRegistro
* estatus = obra.Status
* -------------------------------------------------
* --------- P I E Z A M A E S T R A -------------
* Matricula_Clave = pieza.MatriculaPieza
* MatriculaTecnica_Clave = pieza.TecnicaPieza
* UbicacionActual = pieza.UbicacionID
* fecha_registro = pieza.FechaRegistro
*
* ClassColeccion_Clave = pieza.ColeccionGibranPieza
*
* --------- N O S E U S A N ------------------
* ---pieza_treg
* ---tmp
* ---usu_id_cap
* ---baja
* ---cInventario
* ---cInvestigacion
* ---cve_usuario
* ---otr_ubic
* ---fecha_ingreso
*
*
*/
// crear un registro de OBRA--------------------------
Obra obra = new Obra();
obra.Clave = leer["id_pieza"].ToString();
string tipoObraText = leer["TipoObjeto_Clave"].ToString();
var xTipoObras = db.TipoObras.Where(a => a.AntID == tipoObraText).Select(a => a.TipoObraID);
if (xTipoObras.Count() > 0)
obra.TipoObraID = xTipoObras.FirstOrDefault();
else
obra.TipoObraID = db.TipoObras.Single(a => a.Nombre == "S/D").TipoObraID;
string tipoAdqquisicionText = leer["TipoAdquisicion_Clave"].ToString();
var xTipoAdquisicion = db.TipoAdquisiciones.Where(a => a.AntID == tipoAdqquisicionText).Select(a => a.TipoAdquisicionID);
if (xTipoAdquisicion.Count() > 0)
obra.TipoAdquisicionID = xTipoAdquisicion.FirstOrDefault();
string propietarioText = leer["Propietario_Clave"].ToString();
var xPropietario = db.Propietarios.Where(a => a.AntID == propietarioText).Select(a => a.PropietarioID);
if (xPropietario.Count() > 0)
obra.PropietarioID = xPropietario.FirstOrDefault();
else
obra.PropietarioID = db.Propietarios.Single(a => a.AntID == "24006").PropietarioID;
string ubicacionText = leer["Ubicacion_Clave"].ToString();
var xUbicacion = db.Ubicaciones.Where(a => a.AntID == ubicacionText).Select(a => a.UbicacionID);
if (xUbicacion.Count() > 0)
obra.UbicacionID = xPropietario.FirstOrDefault();
else
obra.UbicacionID = db.Ubicaciones.Single(a => a.AntID == "4036").UbicacionID;
//cortar la fecha MM/dd/yyy y colocarla como dd/MM/yyy
//DateTime fecha=DateTime.ParseExact(leer["fecha_registro_ORI"].ToString(), "MM/dd/yyyy", CultureInfo.InvariantCulture);
obra.FechaRegistro = DateTime.Now;
obra.Status = Status.Activo;
obra.AntID = leer["id_pieza"].ToString();
//extraer m_pieza_coleccion
//obra.ColeccionID = ;
con2.Open();
//definir el sql
string textSql_int = string.Format("SELECT TOP 1 * FROM [m_pieza_coleccion] WHERE [id_pieza] = {0}", obra.AntID);
SqlCommand sql_int = new SqlCommand(textSql_int, con2);
//ejecutar el sql
SqlDataReader leer_int = sql_int.ExecuteReader();
//realizar el foreach
leer_int.Read();
var coleccionText = leer_int["Coleccion_Clave"].ToString();
if (coleccionText != "0" || coleccionText != "")
{
//realizar la buscqueda en coleccion con el antID
var xColeccion = db.Colecciones.Where(a => a.AntID == coleccionText).Select(a => a.ColeccionID);
if (xColeccion.Count() > 0)
obra.ColeccionID = xColeccion.FirstOrDefault();
}
con2.Close();
db.Obras.Add(obra);
db.SaveChanges();
//creo su pieza con la Maestra v.1
/*
* UbicacionActual = pieza.UbicacionID
* fecha_registro = pieza.FechaRegistro
*/
//var tipoPieza = obra.TipoObra.TipoPiezas.FirstOrDefault();
var tipoPieza = db.TipoObras.Find(obra.TipoObraID).TipoPiezas.FirstOrDefault();
Pieza piezaMaestra = new Pieza()
{
ObraID = obra.ObraID,
Clave = obra.Clave + "-" + tipoPieza.Clave,
TipoPiezaID = tipoPieza.TipoPiezaID,
FechaRegistro = obra.FechaRegistro,
Status = true
};
string ubicacionActual = leer["UbicacionActual"].ToString();
var xUbicacion2 = db.Ubicaciones.Where(a => a.AntID == ubicacionActual).Select(a => a.UbicacionID);
if (xUbicacion2.Count() > 0)
piezaMaestra.UbicacionID = xUbicacion2.FirstOrDefault();
else
piezaMaestra.UbicacionID = obra.UbicacionID;
db.Piezas.Add(piezaMaestra);
db.SaveChanges();
//lista.Add(obra);
//agregarle los atributos de las piezas
}
inicio = fin;
fin = fin + total;
con1.Close();
}
ViewBag.TiempoTotal = tiempo.Elapsed.TotalSeconds.ToString();
var lista = db.Obras.ToList();
ViewBag.TotalRegistros = lista.Count;
// Para el contador e imprime el resultado:
return PartialView("_ImportarObras_Obra", lista);
}
catch (Exception)
{
ViewBag.error = "error";
ViewBag.mensaje = "Conexión fallida";
}
ViewBag.TiempoTotal = tiempo.Elapsed.TotalSeconds.ToString();
return PartialView("_ImportarObras_Obra");
}
public ActionResult Registro(Int64 TipoObraID, Int64 TipoPiezaID, string Folio)
{
db.Dispose();
db = new RecordFCSContext();
////Validar el Folio
//while (db.Obras.Where(a => a.Clave == Folio).Count() > 0)
//{
// string[] nuevaClave = Folio.Split('-');
// int numero = Convert.ToInt32(nuevaClave[1]);
// numero++;
// Folio = nuevaClave[0] + '-' + numero.ToString().PadLeft(4, '0');
//}
var obra = new Obra()
{
Clave = Folio,
TipoObraID = TipoObraID,
FechaRegistro = DateTime.Now,
Status = Status.PreRegistro,
};
//lista de atributos
var listaAtributos = db.Atributos.Where(a => a.TipoPiezaID == TipoPiezaID).ToList();
// filtrar los atributos que son solo de la OBRA
foreach (var item in listaAtributos)
{
string campo = "req_list_" + item.TipoAtributoID;
string id_text = Request.Form[campo];
Int64 id = Convert.ToInt64(id_text);
switch (item.TipoAtributo.DatoCS)
{
case "TipoAdquisicionID":
var tipoAdq = db.TipoAdquisiciones.Where(a => a.TipoAdquisicionID == id).Select(a => new { a.TipoAdquisicionID, a.Nombre}).FirstOrDefault();
if (tipoAdq != null)
{
obra.TipoAdquisicionID = id;
}
break;
case "PropietarioID":
var propietario = db.Propietarios.Where(a => a.PropietarioID == id).Select(a => new { a.PropietarioID, a.Nombre}).FirstOrDefault();
if (propietario != null)
{
obra.PropietarioID = id;
}
break;
case "ColeccionID":
var coleccion = db.Colecciones.Where(a => a.ColeccionID == id).Select(a => new { a.ColeccionID, a.Nombre}).FirstOrDefault();
if (coleccion != null)
{
obra.ColeccionID = id;
}
break;
case "UbicacionID":
var ubicacion = db.Ubicaciones.Where(a => a.UbicacionID == id).Select(a => new { a.UbicacionID, a.Nombre}).FirstOrDefault();
if (ubicacion != null)
{
obra.UbicacionID = id;
}
break;
}
}
//validar la clave al final
//ultimo registro + 1
var ultimo = db.Obras.Select(a => new { a.ObraID, a.TipoObraID, a.Status, a.Clave}).ToList().LastOrDefault();
if (ultimo != null)
{
var folio = Convert.ToInt32(ultimo.Clave) + 1;
obra.Clave = folio.ToString();
}
db.Obras.Add(obra);
db.SaveChanges();
// crear la pieza
var tipoPieza = db.TipoPiezas.Where(a => a.TipoPiezaID == TipoPiezaID).Select(a => new {a.TipoPiezaID, a.TipoObraID, a.Clave }).FirstOrDefault();
var pieza = new Pieza()
{
ObraID = obra.ObraID,
Clave = obra.Clave + "-" + tipoPieza.Clave, // Rdddaaaa-0000-A
TipoPiezaID = TipoPiezaID,
UbicacionID = obra.UbicacionID,
FechaRegistro = obra.FechaRegistro,
Status = true
};
db.Piezas.Add(pieza);
db.SaveChanges();
//llenar los atributoPieza y si son requeridos extraer el valor
foreach (var item in listaAtributos)
{
var atributoPieza = new AtributoPieza()
{
PiezaID = pieza.PiezaID,
AtributoID = item.AtributoID
};
//si son NombreID == "Generico" guardar en AtributoPieza
if (item.TipoAtributo.NombreID == "Generico")
{
//y si es Requerido extraer el valor del form
if (item.Requerido)
{
//si es lista lo guarda en ValorListaID y si no en Valor
if (item.TipoAtributo.EsLista)
{
string campo = "req_list_" + item.TipoAtributoID;
Int64? id = Convert.ToInt64(Request.Form[campo]);
var listaValor = db.ListaValores.Where(a => a.ListaValorID == id).Select(a => new {a.ListaValorID, a.TipoAtributoID}).FirstOrDefault();
if (listaValor != null)
{
atributoPieza.ListaValorID = id;
}
}
else
{
string campo = "req_" + item.TipoAtributoID;
string valor = Request.Form[campo];
if (!String.IsNullOrEmpty(valor) || !String.IsNullOrWhiteSpace(valor))
{
atributoPieza.Valor = valor;
}
}
}
}
else if (item.TipoAtributo.DatoHTML == "Catalogo")
{
//Si no es generico pero si es DatoHTML = "Catalogo"
// y si es Requerido entonces guardar el valor en la TABLAPieza
if (item.Requerido)
{
string campo = "req_list_" + item.TipoAtributoID;
int? id = Convert.ToInt32(Request.Form[campo]);
switch (item.TipoAtributo.DatoCS)
{
case "TecnicaPieza":
var tecnica = db.Tecnicas.Where(a => a.TecnicaID == id).Select(a => new { a.TecnicaID, a.Descripcion}).FirstOrDefault();
if (tecnica != null)
{
TecnicaPieza tecPieza = new TecnicaPieza()
{
PiezaID = pieza.PiezaID,
TecnicaID = tecnica.TecnicaID,
Status = true
};
db.TecnicaPiezas.Add(tecPieza);
//db.SaveChanges();
}
break;
case "AutorPieza":
var autor = db.Autores.Where(a => a.AutorID == id).Select(a => new { a.AutorID, a.Nombre}).FirstOrDefault();
if (autor != null)
{
AutorPieza autorPieza = new AutorPieza()
{
PiezaID = pieza.PiezaID,
AutorID = autor.AutorID,
Status = true
};
db.AutorPiezas.Add(autorPieza);
//db.SaveChanges();
}
break;
case "ImagenPieza":
//PEndiente por implementar
HttpPostedFileBase FileImagen = Request.Files["FileName"];
var extension = Path.GetExtension(FileImagen.FileName);
var imagenPieza = new ImagenPieza()
{
PiezaID = pieza.PiezaID,
Status = true,
Orden = 1,
Titulo = Request.Form["imagen_" + "Titulo"],
Descripcion = Request.Form["imagen_" + "Descripcion"],
};
imagenPieza.ImgNombre = Guid.NewGuid().ToString() + extension;
var rutaOriginal = Server.MapPath("~" + imagenPieza.Ruta);
var rutaThumbnail = Server.MapPath("~" + imagenPieza.RutaThumb);
FileImagen.SaveAs(rutaOriginal);
//GUARDAR THUMBNAIL
var thumb = new Thumbnail()
{
OrigenSrc = rutaOriginal,
DestinoSrc = rutaThumbnail,
LimiteAnchoAlto = 300
};
thumb.GuardarThumbnail();
//guardar en db
db.ImagenPiezas.Add(imagenPieza);
//db.SaveChanges();
break;
case "Medida":
//Pendiente por implementar
var tipoMedida = db.TipoMedidas.Where(a => a.TipoMedidaID == id).Select(a => new { a.TipoMedidaID, a.Nombre}).FirstOrDefault();
if (tipoMedida != null)
{
Medida medida = new Medida()
{
PiezaID = pieza.PiezaID,
TipoMedidaID = tipoMedida.TipoMedidaID,
Status = true
};
var xlargo = Request.Form["med_" + "Largo"].ToString();
var xancho = Request.Form["med_" + "Ancho"].ToString();
var xprofundidad =Request.Form["med_" + "Profundidad"].ToString();
var xdiametro = Request.Form["med_" + "Diametro"].ToString();
var xdiametro2 = Request.Form["med_" + "Diametro2"].ToString();
var xUMLongitud = Request.Form["med_" + "UMLongitud"].ToString();
if (xlargo != "0" && xlargo != "")
medida.Largo = Convert.ToDouble(xlargo);
if (xancho != "0" && xancho != "")
medida.Ancho = Convert.ToDouble(xancho);
if (xprofundidad != "0" && xprofundidad != "")
medida.Profundidad = Convert.ToDouble(xprofundidad);
if (xdiametro != "0" && xdiametro != "")
medida.Diametro = Convert.ToDouble(xdiametro);
if (xdiametro2 != "0" && xdiametro2 != "")
medida.Diametro2 = Convert.ToDouble(xdiametro2);
switch (xUMLongitud)
{
case "cm":
medida.UMLongitud = UMLongitud.cm;
break;
case "km":
medida.UMLongitud = UMLongitud.km;
break;
case "m":
medida.UMLongitud = UMLongitud.m;
break;
case "mm":
medida.UMLongitud = UMLongitud.mm;
break;
case "pulgadas":
medida.UMLongitud = UMLongitud.pulgadas;
break;
}
db.Medidas.Add(medida);
//db.SaveChanges();
}
break;
case "CatalogoPieza":
var catalogo = db.Catalogos.Where(a => a.CatalogoID == id).Select(a => new { a.CatalogoID, a.Nombre}).FirstOrDefault();
if (catalogo != null)
{
CatalogoPieza catPieza = new CatalogoPieza()
{
PiezaID = pieza.PiezaID,
CatalogoID = catalogo.CatalogoID,
Status = true
};
db.CatalogoPiezas.Add(catPieza);
//db.SaveChanges();
}
break;
case "ExposicionPieza":
var exposicion = db.Exposiciones.Where(a => a.ExposicionID == id).Select(a => new {a.ExposicionID, a.Nombre }).FirstOrDefault();
if (exposicion != null)
{
ExposicionPieza expoPieza = new ExposicionPieza()
{
PiezaID = pieza.PiezaID,
ExposicionID = exposicion.ExposicionID,
Status = true
};
db.ExposicionPiezas.Add(expoPieza);
//db.SaveChanges();
}
break;
case "MatriculaPieza":
var matricula = db.Matriculas.Where(a => a.MatriculaID == id).Select(a => new { a.MatriculaID, a.Descripcion}).FirstOrDefault();
if (matricula != null)
{
MatriculaPieza matPieza = new MatriculaPieza()
{
PiezaID = pieza.PiezaID,
MatriculaID = matricula.MatriculaID,
Status = true
};
db.MatriculaPiezas.Add(matPieza);
//db.SaveChanges();
}
break;
case "TecnicaMarcoPieza":
var tenicaMarco = db.TecnicaMarcos.Where(a => a.TecnicaMarcoID == id).Select(a => new { a.TecnicaMarcoID, a.Descripcion}).FirstOrDefault();
if (tenicaMarco != null)
{
TecnicaMarcoPieza tecMarcoPieza = new TecnicaMarcoPieza()
{
PiezaID = pieza.PiezaID,
TecnicaMarcoID = tenicaMarco.TecnicaMarcoID,
Status = true
};
db.TecnicaMarcoPiezas.Add(tecMarcoPieza);
//db.SaveChanges();
}
break;
}
}
}
db.AtributoPiezas.Add(atributoPieza);
}
db.SaveChanges();
//redireccionar si se tiene el permiso para ver ficha completa
if (User.IsInRole("ObraFichComplet"))
{
return RedirectToAction("Detalles", "Obra", new { id = obra.ObraID });
}
else
{
AlertaSuccess(string.Format("Se registro la obra: {0}, pero no tiene los permisos para visualizarla.", obra.Clave),true);
return RedirectToAction("Registro", "Obra");
}
}
public ActionResult Registrar(Guid? TipoObraID, int? LetraFolioID, Guid? TipoPiezaID)
{
var Formulario = Request.Form;
if (TipoObraID == null || LetraFolioID == null || TipoPiezaID == null)
return new HttpStatusCodeResult(HttpStatusCode.BadRequest);
var letra = db.LetraFolios.Find(LetraFolioID);
var tipoObra = db.TipoObras.Find(TipoObraID);
var tipoPieza = tipoObra.TipoPiezas.FirstOrDefault(a => a.TipoPiezaID == TipoPiezaID);
if (tipoObra == null || letra == null || tipoPieza == null)
return HttpNotFound();
var obra = new Obra()
{
FechaRegistro = DateTime.Now,
TipoObraID = tipoObra.TipoObraID,
LetraFolioID = letra.LetraFolioID,
Status = false,
NumeroFolio = 1
};
obra.ObraID = Guid.NewGuid();
//Crear pieza
Pieza pieza = new Pieza()
{
PiezaID = Guid.NewGuid(),
FechaRegistro = obra.FechaRegistro,
ObraID = obra.ObraID,
Status = false,
PiezaPadreID = null, // null = Principal o Maestra
TipoPiezaID = tipoPieza.TipoPiezaID,
SubFolio = tipoPieza.Prefijo
};
//lista de atributos de registro
var listaAttRegistro = tipoPieza.Atributos.Where(a => a.Status && a.MostrarAtributos.Any(b => b.TipoMostrar.Nombre == "Registro" && b.Status) && a.TipoAtributo.Status).OrderBy(a => a.Orden).ToList();
List<AtributoPieza> listaAdd_AttGen = new List<AtributoPieza>();
List<AutorPieza> listaAdd_AttAutor = new List<AutorPieza>();
List<ImagenPieza> listaAdd_AttImg = new List<ImagenPieza>();
List<TecnicaPieza> listaAdd_AttTec = new List<TecnicaPieza>();
List<MedidaPieza> listaAdd_AttMed = new List<MedidaPieza>();
Ubicacion ubicacionAdd = null;
List<string> listaKey;
/*
* Extraer los registros del formulario dependiendo el tipo de Atributo
*
* IMAGEN
* SIMPLE
* id_####################_File (File)
* id_####################_Titulo (Input)
* id_####################_Descripcion (Input)
*
*
*/
foreach (var att in listaAttRegistro)
{
var tipoAtt = att.TipoAtributo;
if (tipoAtt.EsGenerico)
{
/*
* GENERICO
* LISTA
* SIMPLE
* id_#################### (Select)
* MULTI
* id_####################_#################### (Input)
*/
if (tipoAtt.EsLista)
{
if (tipoAtt.EsMultipleValor)
listaKey = Formulario.AllKeys.Where(k => k.StartsWith("id_" + att.AtributoID + "_")).ToList();
else
listaKey = Formulario.AllKeys.Where(k => k.StartsWith("id_" + att.AtributoID)).ToList();
//buscar en form todas las llaves que correspondan al id_xxxxxxxxxxxxxx_xxxxxxxxxxxxxx
foreach (string key in listaKey)
{
var addOk = true;
string valor = Formulario[key];
addOk = String.IsNullOrWhiteSpace(valor) ? false : true;
//validar el valorID, buscar el valor
Guid valorID = addOk ? new Guid(valor) : new Guid(new Byte[16]);
addOk = !addOk ? addOk : listaAdd_AttGen.Where(a => a.AtributoID == att.AtributoID && a.ListaValorID == valorID).FirstOrDefault() == null ? true : false;
addOk = !addOk ? addOk : db.ListaValores.Where(a => a.TipoAtributoID == tipoAtt.TipoAtributoID && a.Status && a.ListaValorID == valorID).FirstOrDefault() == null ? false : true;
if (addOk)
listaAdd_AttGen.Add(new AtributoPieza()
{
AtributoPiezaID = Guid.NewGuid(),
AtributoID = att.AtributoID,
PiezaID = pieza.PiezaID,
Status = true,
ListaValorID = valorID
});
}
}
else
{
/*
* GENERICO
* CAMPO
* SIMPLE
* id_#################### (Input)
* MULTI
* id_####################_##### (Input)
*/
if (tipoAtt.EsMultipleValor)
listaKey = Formulario.AllKeys.Where(k => k.StartsWith("id_" + att.AtributoID + "_")).ToList();
else
listaKey = Formulario.AllKeys.Where(k => k.StartsWith("id_" + att.AtributoID)).ToList();
//buscar en form todas las llaves que correspondan al id_xxxxxxxxxxxxxx
foreach (string key in listaKey)
{
var addOk = true;
string valor = Formulario[key];
//validar el campo, quitar espacios en blanco, bla bla bla
valor = valor.Trim(); // quitar espacios en inicio y fin
valor = Regex.Replace(valor, @"\s+", " "); //quitar espacios de sobra
addOk = String.IsNullOrWhiteSpace(valor) ? false : true;
addOk = !addOk ? addOk : listaAdd_AttGen.Where(a => a.AtributoID == att.AtributoID && a.Valor == valor).FirstOrDefault() == null ? true : false;
if (addOk)
listaAdd_AttGen.Add(new AtributoPieza()
{
AtributoPiezaID = Guid.NewGuid(),
AtributoID = att.AtributoID,
PiezaID = pieza.PiezaID,
Status = true,
Valor = valor
});
}
}
}
else
{
switch (tipoAtt.TablaSQL)
{
case "Autor":
/*
* AUTOR
* MULTIPLE
* id_####################_#################### (Input)
* id_####################_####################_prefijo (Input)
*/
//filtrar id_#######
listaKey = Formulario.AllKeys.Where(k => k.StartsWith("id_" + att.AtributoID + "_")).ToList();
///filtrar: ignorar los _prefijo
listaKey = listaKey.Where(k => !k.EndsWith("_prefijo")).ToList();
//buscar en form todas las llaves que correspondan al id_xxxxxxxxxxxxxx_xxxxxxxxxxxxxx
foreach (string key in listaKey)
{
var addOk = true;
string text_autorID = Formulario[key];
string text_prefijo = Formulario[key + "_prefijo"];
addOk = String.IsNullOrWhiteSpace(text_autorID) ? false : true;
//validar el valorID, buscar el valor
Guid autorID = addOk ? new Guid(text_autorID) : new Guid(new Byte[16]);
addOk = !addOk ? addOk : listaAdd_AttAutor.Where(a => a.AutorID == autorID).FirstOrDefault() == null ? true : false;
addOk = !addOk ? addOk : db.Autores.Where(a => a.Status && a.AutorID == autorID).FirstOrDefault() == null ? false : true;
if (addOk)
{
var autorPieza = new AutorPieza()
{
AutorID = autorID,
PiezaID = pieza.PiezaID,
esPrincipal = false,
Prefijo = text_prefijo,
Status = true
};
//validar si es principal
if (autorPieza.Prefijo.ToLower() == "principal")
autorPieza.esPrincipal = listaAdd_AttAutor.Where(a => a.esPrincipal).Count() == 0 ? true : false;
listaAdd_AttAutor.Add(autorPieza);
}
}
break;
case "Ubicacion":
/*
* UBICACION
* SIMPLE
* id_#################### (select)
*/
listaKey = Formulario.AllKeys.Where(k => k.StartsWith("id_" + att.AtributoID)).ToList();
//buscar en form todas las llaves que correspondan al id_xxxxxxxxxxxxxx_xxxxxxxxxxxxxx
foreach (string key in listaKey)
{
var addOk = true;
string texto_ubicacionID = Formulario[key];
addOk = String.IsNullOrWhiteSpace(texto_ubicacionID) ? false : true;
//validar el valorID, buscar el valor
Guid ubicacionID = addOk ? new Guid(texto_ubicacionID) : new Guid(new Byte[16]);
addOk = !addOk ? addOk : ubicacionAdd == null ? true : false;
addOk = !addOk ? addOk : db.Ubicaciones.Where(a => a.Status && a.UbicacionID == ubicacionID).FirstOrDefault() == null ? false : true;
if (addOk)
pieza.UbicacionID = ubicacionID;
}
break;
case "TipoTecnica":
/*
* TECNICA
* SIMPLE
* id_#################### (Select)
*/
listaKey = Formulario.AllKeys.Where(k => k.StartsWith("id_" + att.AtributoID)).ToList();
//buscar en form todas las llaves que correspondan al id_xxxxxxxxxxxxxx_xxxxxxxxxxxxxx
foreach (string key in listaKey)
{
var addOk = true;
string texto_TecnicaID = Formulario[key];
addOk = String.IsNullOrWhiteSpace(texto_TecnicaID) ? false : true;
//validar el valorID, buscar el valor
Guid tecnicaID = addOk ? new Guid(texto_TecnicaID) : new Guid(new Byte[16]);
addOk = !addOk ? addOk : listaAdd_AttTec.Where(a => a.TecnicaID == tecnicaID).FirstOrDefault() == null ? true : false;
addOk = !addOk ? addOk : db.Tecnicas.Where(a => a.TecnicaID == tecnicaID && a.Status).FirstOrDefault() == null ? false : true;
if (addOk)
{
var tecnica = db.Tecnicas.Where(a => a.TecnicaID == tecnicaID && a.Status).FirstOrDefault();
listaAdd_AttTec.Add(new TecnicaPieza()
{
PiezaID = pieza.PiezaID,
Status = true,
TecnicaID = tecnica.TecnicaID,
TipoTecnicaID = tecnica.TipoTecnicaID
});
}
}
break;
case "TipoMedida":
/*
* TIPO MEDIDA
* SIMPLE
* id_#################### (Select)(TipoMedida)
* id_####################_UML (Select)
* id_####################_Altura (input)
* id_####################_Anchura (input)
* id_####################_Profundidad (input)
* id_####################_Diametro (input)
* id_####################_Diametro2 (input)
*/
listaKey = Formulario.AllKeys.Where(k => k == "TipoMedidaID").ToList();
//buscar en form todas las llaves que correspondan al id_xxxxxxxxxxxxxx_xxxxxxxxxxxxxx
foreach (string key in listaKey)
{
var addOk = true;
string texto_TipoMedidaID = Formulario[key];
addOk = String.IsNullOrWhiteSpace(texto_TipoMedidaID) ? false : true;
//validar el valorID, buscar el valor
Guid tipoMedidaID = addOk ? new Guid(texto_TipoMedidaID) : new Guid(new Byte[16]);
addOk = !addOk ? addOk : listaAdd_AttMed.Where(a => a.TipoMedidaID == tipoMedidaID).FirstOrDefault() == null ? true : false;
addOk = !addOk ? addOk : db.TipoMedidas.Where(a => a.TipoMedidaID == tipoMedidaID && a.Status).FirstOrDefault() == null ? false : true;
if (addOk)
{
var medidaPieza = new MedidaPieza()
{
PiezaID = pieza.PiezaID,
Status = true,
TipoMedidaID = tipoMedidaID
};
string text_UML = String.IsNullOrWhiteSpace(Formulario["id_" + att.AtributoID + "_UML"]) ? "cm" : Formulario["id_" + att.AtributoID + "_UML"];
string text_Altura = String.IsNullOrWhiteSpace(Formulario["id_" + att.AtributoID + "_Altura"]) ? "0" : Formulario["id_" + att.AtributoID + "_Altura"];
string text_Anchura = String.IsNullOrWhiteSpace(Formulario["id_" + att.AtributoID + "_Anchura"]) ? "0" : Formulario["id_" + att.AtributoID + "_Anchura"];
string text_Profundidad = String.IsNullOrWhiteSpace(Formulario["id_" + att.AtributoID + "_Profundidad"]) ? "0" : Formulario["id_" + att.AtributoID + "_Profundidad"];
string text_Diametro = String.IsNullOrWhiteSpace(Formulario["id_" + att.AtributoID + "_Diametro"]) ? "0" : Formulario["id_" + att.AtributoID + "_Diametro"];
string text_Diametro2 = String.IsNullOrWhiteSpace(Formulario["id_" + att.AtributoID + "_Diametro2"]) ? "0" : Formulario["id_" + att.AtributoID + "_Diametro2"];
if (text_Altura == "0") medidaPieza.Altura = Convert.ToDouble("text_Altura");
if (text_Anchura == "0") medidaPieza.Anchura = Convert.ToDouble("text_Anchura");
if (text_Altura == "0") medidaPieza.Profundidad = Convert.ToDouble("text_Profundidad");
if (text_Altura == "0") medidaPieza.Diametro = Convert.ToDouble("text_Diametro");
if (text_Altura == "0") medidaPieza.Diametro2 = Convert.ToDouble("text_Diametro2");
switch (text_UML)
{
case "pulgada": medidaPieza.UMLongitud = UMLongitud.pulgada; break;
case "dc": medidaPieza.UMLongitud = UMLongitud.dc; break;
case "m": medidaPieza.UMLongitud = UMLongitud.m; break;
case "dam": medidaPieza.UMLongitud = UMLongitud.dam; break;
case "mm": medidaPieza.UMLongitud = UMLongitud.mm; break;
case "hm": medidaPieza.UMLongitud = UMLongitud.hm; break;
case "km": medidaPieza.UMLongitud = UMLongitud.km; break;
default: medidaPieza.UMLongitud = UMLongitud.cm; break;
}
listaAdd_AttMed.Add(medidaPieza);
}
}
break;
case "ImagenPieza":
listaKey = Request.Files.AllKeys.Where(k => k == "id_" + att.AtributoID + "_File").ToList();
//buscar en form todas las llaves que correspondan al id_xxxxxxxxxxxxxx_xxxxxxxxxxxxxx
foreach (string key in listaKey)
{
HttpPostedFileBase FileImagen = Request.Files[key];
string texto_Titulo = Formulario["id_" + att.AtributoID + "_Titulo"];
string texto_Descripcion = Formulario["id_" + att.AtributoID + "_Descripcion"];
string extension = Path.GetExtension(FileImagen.FileName);
var imgGuid = Guid.NewGuid();
ImagenPieza imagenPieza = new ImagenPieza()
{
PiezaID = pieza.PiezaID,
ImagenPiezaID = imgGuid,
Titulo = texto_Titulo,
Descripcion = texto_Descripcion,
EsPrincipal = true,
Orden = 1,
Status = true,
RutaParcial = "/Content/img/pieza/",
NombreImagen = imgGuid.ToString() + extension,
};
var rutaGuardar_Original = Server.MapPath(imagenPieza.Ruta);
FileImagen.SaveAs(rutaGuardar_Original);
//Generar la mini
Thumbnail mini = new Thumbnail()
{
OrigenSrc = rutaGuardar_Original,
DestinoSrc = Server.MapPath(imagenPieza.RutaMini),
LimiteAnchoAlto = 250
};
mini.GuardarThumbnail();
//add a la lista de imagenes
listaAdd_AttImg.Add(imagenPieza);
}
break;
default:
AlertaDanger(String.Format("No se pudo guardar el campo, {0}.", att.NombreAlterno));
break;
}
}
}
if (ModelState.IsValid)
{
//validar el numero de folio
obra.NumeroFolio = DarFolioValido(obra.LetraFolioID, obra.NumeroFolio);
//Guardar la obra
db.Obras.Add(obra);
db.SaveChanges();
//Guardar la pieza
db.Piezas.Add(pieza);
db.SaveChanges();
//Guardar sus atributos
db.AtributoPiezas.AddRange(listaAdd_AttGen);
db.AutorPiezas.AddRange(listaAdd_AttAutor);
db.ImagenPiezas.AddRange(listaAdd_AttImg);
db.TecnicaPiezas.AddRange(listaAdd_AttTec);
db.MedidaPiezas.AddRange(listaAdd_AttMed);
db.SaveChanges();
return RedirectToAction("Detalles", "Obra", new { id = obra.ObraID});
}
return Json(new { success = false });
}
public ActionResult 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();
}
public ActionResult Crear(Int64? obraID)
{
if (obraID == null)
{
return new HttpStatusCodeResult(HttpStatusCode.BadRequest);
}
Obra obra = db.Obras.Find(obraID);
if (obra == null)
{
return HttpNotFound();
}
//Llenar Datos de Pieza
Pieza pieza = new Pieza()
{
ObraID = obra.ObraID,
Status = true
};
//lista de otras piezas qe se pueden agregar a la obra
//no mostrar las maestras
//una obra solo puede contener una pieza maestra
ViewBag.TipoPiezaID = new SelectList(db.TipoPiezas.Where(a => a.TipoObraID == obra.TipoObraID && a.EsMaestra == false).OrderBy(a => a.Nombre), "TipoPiezaID", "Nombre");
return PartialView("_Crear", pieza);
}