public ActionResult Crear([Bind(Include = "TipoTecnicaID,Nombre,Descripcion,Status,Temp")] TipoTecnica tipoTecnica)
        {
            //validar el nombre
            var tt = db.TipoTecnicas.Select(a => new { a.Nombre, a.TipoTecnicaID }).FirstOrDefault(a => a.Nombre == tipoTecnica.Nombre);

            if (tt != null)
            {
                ModelState.AddModelError("Nombre", "Nombre ya existe.");
            }


            if (ModelState.IsValid)
            {
                tipoTecnica.TipoTecnicaID = Guid.NewGuid();
                db.TipoTecnicas.Add(tipoTecnica);
                db.SaveChanges();

                AlertaSuccess(string.Format("Tipo de Técnica: <b>{0}</b> creada.", tipoTecnica.Nombre), true);

                string url = Url.Action("Lista", "TipoTecnica");
                return(Json(new { success = true, url = url }));
            }

            return(PartialView("_Crear", tipoTecnica));
        }
        public ActionResult Crear([Bind(Include = "TipoMovimientoID,Nombre,Status")] TipoMovimiento tipoMovimiento)
        {
            //validar el nombre
            var tmov = db.TipoMovimientos.Select(a => new { a.Nombre, a.TipoMovimientoID }).FirstOrDefault(a => a.Nombre == tipoMovimiento.Nombre);

            if (tmov != null)
            {
                ModelState.AddModelError("Nombre", "Nombre ya existe.");
            }


            if (ModelState.IsValid)
            {
                tipoMovimiento.TipoMovimientoID = Guid.NewGuid();
                db.TipoMovimientos.Add(tipoMovimiento);
                db.SaveChanges();

                AlertaSuccess(string.Format("Tipo de Movimiento: <b>{0}</b> creado.", tipoMovimiento.Nombre), true);

                string url = Url.Action("Lista", "TipoMovimiento");
                return(Json(new { success = true, url = url }));
            }

            return(PartialView("_Crear", tipoMovimiento));
        }
        public ActionResult Crear([Bind(Include = "AutorID,Nombre,Apellido,LugarNacimiento,AnoNacimiento,LugarMuerte,AnoMuerte,Observaciones,Status,Temp")] Autor autor, bool EsRegistroObra)
        {
            //validar el nombre
            var aut = db.Autores.Select(a => new { a.Nombre, a.Apellido, a.AutorID }).FirstOrDefault(a => a.Nombre == autor.Nombre && a.Apellido == autor.Apellido);

            if (aut != null)
            {
                ModelState.AddModelError("Nombre", "Nombre ya existe.");
            }

            if (ModelState.IsValid)
            {
                autor.AutorID = Guid.NewGuid();
                db.Autores.Add(autor);
                db.SaveChanges();

                AlertaSuccess(string.Format("Autor: <b>{0} {1}</b> creado.", autor.Nombre, autor.Apellido), true);

                if (EsRegistroObra)
                {
                    return(Json(new { success = true, nombre = autor.Nombre + " " + autor.Apellido, autorID = autor.AutorID }));
                }
                else
                {
                    string url = Url.Action("Lista", "Autor");
                    return(Json(new { success = true, url = url }));
                }
            }

            ViewBag.EsRegistroObra = EsRegistroObra;

            return(PartialView("_Crear", autor));
        }
Beispiel #4
0
        public ActionResult Crear([Bind(Include = "UsuarioID,UserName,Password,Nombre,Apellido,Correo,Status,ConfirmPassword")] Usuario usuario)
        {
            if (usuario.Password != usuario.ConfirmPassword)
            {
                ModelState.AddModelError("ConfirmPassword", "La Contraseña no coincide");
            }

            if (ModelState.IsValid)
            {
                //volver a revalidar, ya que hay error de validacion en el cliente
                if (db.Usuarios.Where(a => a.UserName == usuario.UserName).Count() > 0)
                {
                    ModelState.AddModelError("UserName", "Ya existe un registro con este nombre. Intenta con otro.");
                    return(PartialView("_Crear", usuario));
                }
                usuario.UsuarioID = Guid.NewGuid();
                usuario.Status    = true;

                usuario.Password = EncriptaPass(usuario.Password);

                db.Usuarios.Add(usuario);
                db.SaveChanges();

                AlertaSuccess(string.Format("Usuario: <b>{0}</b> se creo con exitó.", usuario.UserName), true);
                string url = Url.Action("Lista", "Usuario");
                return(Json(new { success = true, url = url, modelo = "Usuario" }));
            }

            ViewBag.PassDefault = "Record_2015";

            return(PartialView("_Crear", usuario));
        }
        public ActionResult Crear([Bind(Include = "ListaValorID,Valor,Status,Temp,TipoAtributoID")] ListaValor listaValor, bool EsRegistroObra)
        {
            var lv = db.ListaValores.Select(a => new { a.ListaValorID, a.Valor, a.TipoAtributoID }).FirstOrDefault(a => a.Valor == listaValor.Valor && a.TipoAtributoID == listaValor.TipoAtributoID);

            if (lv != null)
            {
                ModelState.AddModelError("Valor", "Ya existe, intenta de nuevo.");
            }

            if (ModelState.IsValid)
            {
                listaValor.ListaValorID = Guid.NewGuid();
                db.ListaValores.Add(listaValor);
                db.SaveChanges();

                var tipoatt = db.TipoAtributos.Find(listaValor.TipoAtributoID);

                AlertaSuccess(string.Format("{0}: <b>{1}</b> creado.", tipoatt.Nombre, listaValor.Valor), true);


                if (EsRegistroObra)
                {
                    return(Json(new { success = true, valor = listaValor.Valor, tipoAtributoID = listaValor.TipoAtributoID, listaValorID = listaValor.ListaValorID }));
                }
                else
                {
                    string url = Url.Action("Lista", "ListaValor", new { id = listaValor.TipoAtributoID });
                    return(Json(new { success = true, url = url }));
                }
            }

            ViewBag.EsRegistroObra = EsRegistroObra;

            return(PartialView("_Crear", listaValor));
        }
Beispiel #6
0
        public ActionResult Lista(Guid?id)
        {
            if (id == null)
            {
                return(new HttpStatusCodeResult(HttpStatusCode.BadRequest));
            }

            var tipoPieza = db.TipoPiezas.Find(id);

            if (tipoPieza == null)
            {
                return(HttpNotFound());
            }

            tipoPieza.Atributos = tipoPieza.Atributos.OrderBy(a => a.Orden).ToList();

            var listaTM = db.TipoMostarlos.Where(a => a.Status).OrderBy(a => a.Nombre).ToList();

            foreach (var att in tipoPieza.Atributos)
            {
                //buscar si att esta en listaTM
                foreach (var tm in listaTM)
                {
                    var x = tm.MostrarAtributos.Where(a => a.AtributoID == att.AtributoID).FirstOrDefault();

                    if (x == null)
                    {
                        x = new MostrarAtributo()
                        {
                            TipoMostrarID = tm.TipoMostrarID,
                            AtributoID    = att.AtributoID,
                            Status        = false,
                            Orden         = att.Orden
                        };


                        db.MostrarAtributos.Add(x);
                        db.SaveChanges();
                    }
                }

                att.MostrarAtributos = att.MostrarAtributos.Where(a => a.TipoMostrar.Status).OrderBy(a => a.TipoMostrar.Nombre).ToList();
            }

            ViewBag.totalRegistros = tipoPieza.Atributos.Count;
            ViewBag.id             = tipoPieza.TipoPiezaID;
            ViewBag.nombre         = tipoPieza.Nombre;
            ViewBag.listaTM        = db.TipoMostarlos.Where(a => a.Status).Select(a => a.Nombre).OrderBy(a => a).ToList();


            return(PartialView("_Lista", tipoPieza.Atributos));
        }
Beispiel #7
0
        public ActionResult Crear(ImagenPieza imagenPieza, HttpPostedFileBase FileImagen)
        {
            var FileImageForm = FileImagen;



            if (ModelState.IsValid)
            {
                //guardar la imagen en carpeta
                string extension = Path.GetExtension(FileImageForm.FileName);
                imagenPieza.ImagenPiezaID = Guid.NewGuid();

                imagenPieza.NombreImagen = Guid.NewGuid().ToString() + extension;

                imagenPieza.RutaParcial = "/Content/img/pieza/";



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

                FileImageForm.SaveAs(rutaGuardar_Original);

                FileImageForm.InputStream.Dispose();
                FileImageForm.InputStream.Close();
                GC.Collect();

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


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

                AlertaSuccess(string.Format("Se guardo imagen <b>{0}</b>", imagenPieza.Titulo), true);


                string url = Url.Action("Carrusel", "ImagenPieza", new { id = imagenPieza.PiezaID, status = false, tipo = "thumb" });
                return(Json(new { success = true, url = url, modelo = "ImagenPieza", lista = "lista", idPieza = imagenPieza.PiezaID }));
            }

            return(PartialView("_Crear", imagenPieza));
        }
        public ActionResult Create([Bind(Include = "ImagenPiezaID,Orden,Titulo,Descripcion,EsPrincipal,RutaParcial,NombreImagen,Status,PiezaID")] ImagenPieza imagenPieza)
        {
            if (ModelState.IsValid)
            {
                imagenPieza.ImagenPiezaID = Guid.NewGuid();
                db.ImagenPiezas.Add(imagenPieza);
                db.SaveChanges();
                return(RedirectToAction("Index"));
            }

            ViewBag.PiezaID = new SelectList(db.Piezas, "PiezaID", "SubFolio", imagenPieza.PiezaID);
            return(View(imagenPieza));
        }
Beispiel #9
0
        public ActionResult Create([Bind(Include = "PiezaID,TipoMedidaID,Altura,Anchura,Profundidad,Diametro,Diametro2,UMLongitud,Peso,UMMasa,Otra,Status,Temp")] MedidaPieza medidaPieza)
        {
            if (ModelState.IsValid)
            {
                medidaPieza.PiezaID = Guid.NewGuid();
                db.MedidaPiezas.Add(medidaPieza);
                db.SaveChanges();
                return(RedirectToAction("Index"));
            }

            ViewBag.PiezaID      = new SelectList(db.Piezas, "PiezaID", "SubFolio", medidaPieza.PiezaID);
            ViewBag.TipoMedidaID = new SelectList(db.TipoMedidas, "TipoMedidaID", "Nombre", medidaPieza.TipoMedidaID);
            return(View(medidaPieza));
        }
Beispiel #10
0
        public ActionResult Create([Bind(Include = "PiezaID,AutorID,Status")] AutorPieza autorPieza)
        {
            if (ModelState.IsValid)
            {
                autorPieza.PiezaID = Guid.NewGuid();
                db.AutorPiezas.Add(autorPieza);
                db.SaveChanges();
                return(RedirectToAction("Index"));
            }

            ViewBag.AutorID = new SelectList(db.Autores, "AutorID", "Nombre", autorPieza.AutorID);
            ViewBag.PiezaID = new SelectList(db.Piezas, "PiezaID", "SubFolio", autorPieza.PiezaID);
            return(View(autorPieza));
        }
        public ActionResult CambiarStatus([Bind(Include = "UsuarioID,TipoPermisoID,Status")] Permiso permiso)
        {
            var         valPermiso  = db.Permisos.Find(permiso.UsuarioID, permiso.TipoPermisoID);
            TipoPermiso tipoPermiso = db.TipoPermisos.Find(permiso.TipoPermisoID);

            if (valPermiso == null)
            {
                //no existe y hay que insertarlo
                permiso.Status = true;
                db.Permisos.Add(permiso);
                AlertaSuccess(string.Format("Permiso: <b>{0}</b> se ACTIVO.", tipoPermiso.Nombre), true);
            }
            else
            {
                //existe entonces hay que eliminarlo
                db.Permisos.Remove(valPermiso);
                AlertaWarning(string.Format("Permiso: <b>{0}</b> se DESACTIVO.", tipoPermiso.Nombre), true);
            }

            db.SaveChanges();

            string url = Url.Action("Lista", "Permiso", new { id = permiso.UsuarioID });

            return(Json(new { success = true, url = url, modelo = "Permiso" }, JsonRequestBehavior.AllowGet));
        }
Beispiel #12
0
        public ActionResult Create([Bind(Include = "PiezaID,SubFolio,FechaRegistro,Status,ObraID,TipoPiezaID,UbicacionID,PiezaPadreID,Temp")] Pieza pieza)
        {
            if (ModelState.IsValid)
            {
                pieza.PiezaID = Guid.NewGuid();
                db.Piezas.Add(pieza);
                db.SaveChanges();
                return(RedirectToAction("Index"));
            }

            ViewBag.ObraID       = new SelectList(db.Obras, "ObraID", "Temp", pieza.ObraID);
            ViewBag.PiezaPadreID = new SelectList(db.Piezas, "PiezaID", "SubFolio", pieza.PiezaPadreID);
            ViewBag.TipoPiezaID  = new SelectList(db.TipoPiezas, "TipoPiezaID", "Nombre", pieza.TipoPiezaID);
            ViewBag.UbicacionID  = new SelectList(db.Ubicaciones, "UbicacionID", "Nombre", pieza.UbicacionID);
            return(View(pieza));
        }
        public ActionResult Crear([Bind(Include = "TipoMostrarID,Nombre,Status")] TipoMostrar tipoMostrar)
        {
            if (ModelState.IsValid)
            {
                tipoMostrar.TipoMostrarID = Guid.NewGuid();
                db.TipoMostarlos.Add(tipoMostrar);
                db.SaveChanges();

                AlertaSuccess(string.Format("Tipo de Mostrar: <b>{0}</b> creado.", tipoMostrar.Nombre), true);

                string url = Url.Action("Lista", "TipoMostrar");
                return(Json(new { success = true, url = url }));
            }

            return(PartialView("_Crear", tipoMostrar));
        }
        public ActionResult Crear(TipoAtributo tipoAtt)
        {
            //revalidar campo unico

            if (ModelState.IsValid)
            {
                tipoAtt.TipoAtributoID = Guid.NewGuid();
                db.TipoAtributos.Add(tipoAtt);
                db.SaveChanges();

                AlertaSuccess(string.Format("Tipo de Atributo: <b>{0}</b> creado.", tipoAtt.Nombre), true);

                string url = Url.Action("Lista", "TipoAtributo");
                return(Json(new { success = true, url = url }));
            }

            return(PartialView("_Crear", tipoAtt));
        }
        public ActionResult Crear([Bind(Include = "TecnicaID,ClaveSigla,ClaveTexto,MatriculaSigla,Descripcion,Status,TipoTecnicaID,TecnicaPadreID,Temp1,Temp2")] Tecnica tecnica, bool EsRegistroObra = false)
        {
            var tec = db.Tecnicas.Select(a => new { a.Descripcion, a.TipoTecnicaID, a.TecnicaID, a.TecnicaPadreID }).FirstOrDefault(a => a.Descripcion == tecnica.Descripcion && a.TipoTecnicaID == tecnica.TipoTecnicaID && a.TecnicaPadreID == tecnica.TecnicaPadreID);

            if (tec != null)
            {
                ModelState.AddModelError("Descripcion", "Ya existe, intenta de nuevo.");
            }



            if (ModelState.IsValid)
            {
                tecnica.TecnicaID = Guid.NewGuid();
                db.Tecnicas.Add(tecnica);
                db.SaveChanges();

                AlertaSuccess(string.Format("Técnica: <b>{0}</b> creada.", tecnica.Descripcion), true);

                if (EsRegistroObra)
                {
                    return(Json(new { success = true, descripcion = tecnica.Descripcion, tecnicaID = tecnica.TecnicaID, tipoTecnicaID = tecnica.TipoTecnicaID }));
                }
                else
                {
                    string url = Url.Action("Lista", "Tecnica", new { id = tecnica.TipoTecnicaID });
                    return(Json(new { success = true, url = url }));
                }
            }

            var ttecnica = db.TipoTecnicas.Find(tecnica.TipoTecnicaID);

            var lista = ttecnica.Tecnicas.Where(a => a.Status && !String.IsNullOrWhiteSpace(a.ClaveSigla) && !String.IsNullOrWhiteSpace(a.ClaveTexto) && !String.IsNullOrWhiteSpace(a.MatriculaSigla)).Select(a => new { a.TecnicaID, Nombre = a.ClaveTexto + " " + a.Descripcion });

            ViewBag.total = lista.Count();

            ViewBag.TecnicaPadreID = new SelectList(lista, "TecnicaID", "Nombre", tecnica.TecnicaPadreID);

            ViewBag.EsRegistroObra = EsRegistroObra;


            return(PartialView("_Crear", tecnica));
        }
        public ActionResult Crear([Bind(Include = "TipoPiezaID,Nombre,Descripcion,Prefijo,Orden,EsPrincipal,Status,TipoObraID,TipoPiezaPadreID,Temp")] TipoPieza tipoPieza)
        {
            var tp = db.TipoPiezas.Select(a => new { a.TipoObraID, a.TipoPiezaPadreID, a.TipoPiezaID, a.Nombre }).FirstOrDefault(a => a.Nombre == tipoPieza.Nombre && a.TipoObraID == tipoPieza.TipoObraID && a.TipoPiezaPadreID == tipoPieza.TipoPiezaPadreID);

            if (tp != null)
            {
                if (tp.TipoPiezaID != tipoPieza.TipoPiezaID)
                {
                    ModelState.AddModelError("Nombre", "Nombre ya existe.");
                }
            }


            if (ModelState.IsValid)
            {
                tipoPieza.TipoPiezaID = Guid.NewGuid();
                db.TipoPiezas.Add(tipoPieza);
                db.SaveChanges();

                AlertaSuccess(string.Format("Tipo de Pieza: <b>{0}</b> creada.", tipoPieza.Nombre), true);

                //principal true enviar tipoobraid



                string url = "";

                if (tipoPieza.TipoPiezaPadreID == null)
                {
                    url = Url.Action("Lista", "TipoPieza", new { id = tipoPieza.TipoObraID, esRoot = true });
                }
                else
                {
                    url = Url.Action("Lista", "TipoPieza", new { id = tipoPieza.TipoPiezaPadreID });
                }


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

            return(PartialView("_Crear", tipoPieza));
        }
        public ActionResult Editar([Bind(Include = "TipoMostrarID,AtributoID,Orden,InicioHTML,FinHTML,Status")] MostrarAtributo mostrarAtributo)
        {
            if (ModelState.IsValid)
            {
                db.Entry(mostrarAtributo).State = EntityState.Modified;
                db.SaveChanges();

                var TipoPiezaID = db.Atributos.FirstOrDefault(a => a.AtributoID == mostrarAtributo.AtributoID).TipoPiezaID;
                var Nombre      = db.TipoMostarlos.FirstOrDefault(a => a.TipoMostrarID == mostrarAtributo.TipoMostrarID).Nombre;


                AlertaInfo(string.Format("Mostrar en: <b>{0}</b> editado.", Nombre), true);

                string url = Url.Action("Lista", "Atributo", new { id = TipoPiezaID });

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

            return(PartialView("_Editar", mostrarAtributo));
        }
        public ActionResult Crear([Bind(Include = "TipoObraID,Nombre,Descripcion,Status,Temp")] TipoObra tipoObra)
        {
            //revalidar el nombre
            if (db.TipoObras.FirstOrDefault(a => a.Nombre == tipoObra.Nombre) != null)
            {
                ModelState.AddModelError("Nombre", "Nombre ya existe.");
            }

            if (ModelState.IsValid)
            {
                tipoObra.TipoObraID = Guid.NewGuid();
                db.TipoObras.Add(tipoObra);
                db.SaveChanges();

                AlertaSuccess(string.Format("Tipo de Obra: <b>{0}</b> creada.", tipoObra.Nombre), true);

                //Crear la pieza Maestra

                TipoPieza tipoPieza = new TipoPieza()
                {
                    TipoPiezaID = Guid.NewGuid(),
                    TipoObraID  = tipoObra.TipoObraID,
                    Nombre      = "Principal",
                    Prefijo     = "A",
                    Orden       = 1,
                    Descripcion = "Pieza principal de la Obra",
                    EsPrincipal = true,
                    Status      = true
                };

                db.TipoPiezas.Add(tipoPieza);
                db.SaveChanges();

                AlertaSuccess(string.Format("Tipo de Pieza : <b>{0}</b> creada.", tipoPieza.Nombre), true);

                string url = Url.Action("Lista", "TipoObra");
                return(Json(new { success = true, url = url }));
            }

            return(PartialView("_Crear", tipoObra));
        }
Beispiel #19
0
        public ActionResult Crear([Bind(Include = "TipoPermisoID,Clave,Nombre,Descripcion,Status")] TipoPermiso tipoPermiso)
        {
            if (ModelState.IsValid)
            {
                //revalidar la clave
                if (db.TipoPermisos.Where(a => a.Clave == tipoPermiso.Clave).Count() > 0)
                {
                    ModelState.AddModelError("Clave", "Ya existe un registro con esta clave. Intenta con otro.");
                    return(PartialView("_Crear", tipoPermiso));
                }
                tipoPermiso.TipoPermisoID = Guid.NewGuid();
                db.TipoPermisos.Add(tipoPermiso);
                db.SaveChanges();

                AlertaSuccess(string.Format("Tipo de Permiso: <b>{0}, {1}</b> se creo con exitó.", tipoPermiso.Clave, tipoPermiso.Nombre), true);
                string url = Url.Action("Lista", "TipoPermiso");
                return(Json(new { success = true, url = url }));
            }

            return(PartialView("_Crear", tipoPermiso));
        }
        public ActionResult Crear([Bind(Include = "PiezaID,AutorID,Status")] AutorPieza autorPieza, Guid AtributoID)
        {
            string renderID = "autor_" + autorPieza.PiezaID + "_";

            string texto   = "";
            bool   guardar = false;

            string valor = Request.Form["id_" + AtributoID].ToString();

            autorPieza.AutorID = new Guid(valor);

            //no existe el ListaValorID entonces actualizar el AtributoPiezaID con el ListaValorID
            if (db.AutorPiezas.Where(a => a.PiezaID == autorPieza.PiezaID && a.AutorID == autorPieza.AutorID).Count() == 0)
            {
                guardar = true;

                var autor = db.Autores.Find(autorPieza.AutorID);

                texto = autor.Nombre + " " + autor.Apellido;

                AlertaSuccess(string.Format("Autor: <b>{0}</b> se agregó.", autor.Nombre + "" + autor.Apellido), true);
                autorPieza.AutorID = autor.AutorID;
            }
            else
            {
                guardar = false;
                //alerta ya existe
            }


            if (guardar)
            {
                db.AutorPiezas.Add(autorPieza);
                db.SaveChanges();
                renderID += autorPieza.AutorID;
            }


            return(Json(new { success = true, renderID = renderID, texto = texto, guardar = guardar }));
        }
Beispiel #21
0
        public ActionResult Crear([Bind(Include = "PiezaID,TipoTecnicaID,Status,TecnicaID")] TecnicaPieza tecnicaPieza, Guid AtributoID)
        {
            string renderID = "tipoTecnica_" + tecnicaPieza.PiezaID + "_";
            string texto    = "";
            bool   guardar  = false;
            string valor    = Request.Form["id_" + AtributoID].ToString();

            tecnicaPieza.TecnicaID = new Guid(valor);

            if (db.TecnicaPiezas.Where(a => a.PiezaID == tecnicaPieza.PiezaID && a.TecnicaID == tecnicaPieza.TecnicaID).Count() == 0)
            {
                guardar = true;

                var tecnica = db.Tecnicas.Find(tecnicaPieza.TecnicaID);

                texto = tecnica.Descripcion;

                AlertaSuccess(string.Format("Técnica: <b>{0}</b> se agregó.", tecnica.Descripcion), true);
                tecnicaPieza.TecnicaID = tecnica.TecnicaID;
            }
            else
            {
                guardar = false;
                //alerta ya existe
            }



            if (guardar)
            {
                db.TecnicaPiezas.Add(tecnicaPieza);
                db.SaveChanges();

                renderID += tecnicaPieza.TecnicaID;
            }

            return(Json(new { success = true, renderID = renderID, texto = texto, guardar = guardar }));
        }
        public ActionResult Crear([Bind(Include = "PiezaID,TipoMedidaID,Altura,Anchura,Profundidad,Diametro,Diametro2,UMLongitud,Peso,UMMasa,Otra,Status,Temp")] MedidaPieza medidaPieza, Guid AtributoID)
        {
            string renderID = "tipoMedida_" + medidaPieza.PiezaID + "_";

            var    tipoMedida = db.TipoMedidas.Find(medidaPieza.TipoMedidaID);
            string texto      = "";

            if (ModelState.IsValid)
            {
                db.MedidaPiezas.Add(medidaPieza);
                db.SaveChanges();

                AlertaSuccess(string.Format("Médida: <b>{0}</b> se agregó.", tipoMedida.Nombre), true);

                return(Json(new { success = true, renderID = renderID, texto = texto, guardar = true }));
            }

            var pieza = db.Piezas.Find(medidaPieza.PiezaID);
            var tipoMedidasExistentes = pieza.MedidaPiezas.Select(a => a.TipoMedidaID);

            ViewBag.TipoMedidaID = new SelectList(db.TipoMedidas.Where(a => a.Status && !tipoMedidasExistentes.Contains(a.TipoMedidaID)).OrderBy(a => a.Nombre).ToList(), "TipoMedidaID", "Nombre", medidaPieza.TipoMedidaID);
            return(PartialView("_Crear", medidaPieza));
        }
        public ActionResult Crear([Bind(Include = "LetraFolioID,Nombre,Descripcion,Status")] LetraFolio letraFolio)
        {
            //validar el nombre
            var lf = db.LetraFolios.Select(a => new { a.Nombre, a.LetraFolioID }).FirstOrDefault(a => a.Nombre == letraFolio.Nombre);

            if (lf != null)
            {
                ModelState.AddModelError("Nombre", "Nombre ya existe.");
            }


            if (ModelState.IsValid)
            {
                db.LetraFolios.Add(letraFolio);
                db.SaveChanges();

                AlertaSuccess(string.Format("Letra de Folio: <b>{0}</b> creada.", letraFolio.Nombre), true);

                string url = Url.Action("Lista", "LetraFolio");
                return(Json(new { success = true, url = url }));
            }

            return(View(letraFolio));
        }
        public ActionResult Crear([Bind(Include = "UbicacionID,Nombre,Descripcion,Status,Temp")] Ubicacion ubicacion, bool EsRegistroObra = false)
        {
            //validar el nombre
            var ubi = db.Ubicaciones.Select(a => new { a.Nombre, a.UbicacionID }).FirstOrDefault(a => a.Nombre == ubicacion.Nombre);

            if (ubi != null)
            {
                ModelState.AddModelError("Nombre", "Nombre ya existe.");
            }


            if (ModelState.IsValid)
            {
                ubicacion.UbicacionID = Guid.NewGuid();
                db.Ubicaciones.Add(ubicacion);
                db.SaveChanges();

                AlertaSuccess(string.Format("Ubicación: <b>{0}</b> creada.", ubicacion.Nombre), true);



                if (EsRegistroObra)
                {
                    return(Json(new { success = true, nombre = ubicacion.Nombre, ubicacionID = ubicacion.UbicacionID }));
                }
                else
                {
                    string url = Url.Action("Lista", "Ubicacion");
                    return(Json(new { success = true, url = url }));
                }
            }

            ViewBag.EsRegistroObra = EsRegistroObra;

            return(PartialView("_Crear", ubicacion));
        }
        public ActionResult IniciarMigracion()
        {
            int NumFol = 0; //ultima registrada

            RecordFCSContext dbx = new RecordFCSContext();

            int bloqueGuardar = 500;


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

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

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


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

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

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

                int i = NumFol;

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


                    if (rowArchivo.ArchivoID > 0)
                    {
                        listaArchivoCEHM.Add(rowArchivo);
                    }
                }
                con1.Close();
                leer1 = null;

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


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

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

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

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


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


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

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

                                case "Coleccion_Clave":
                                    addOK     = row.Nombredelfondo == null || row.Nombredelfondo == "" ? false : true;
                                    valorText = addOK ? row.Nombredelfondo : "";
                                    break;

                                case "Legajo_CEHM":
                                    addOK     = row.Legajo == null || row.Legajo == "" ? false : true;
                                    valorText = addOK ? row.Legajo : "";
                                    break;

                                case "FechaEjecucion_Clave":
                                    addOK     = row.LugaryFecha == null || row.LugaryFecha == "" ? false : true;
                                    valorText = addOK ? row.LugaryFecha : "";
                                    break;

                                default:
                                    addOK = false;
                                    break;
                                }


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

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

                                    listaAdd_AttGen.Add(new AtributoPieza()
                                    {
                                        AtributoPiezaID = Guid.NewGuid(),
                                        AtributoID      = att.AtributoID,
                                        PiezaID         = pieza.PiezaID,
                                        Status          = true,
                                        ListaValorID    = listaValor.ListaValorID
                                    });
                                }
                            }
                            else
                            {
                                if (tipoAtt.EsMultipleValor)
                                {
                                    /*
                                     * GENERICO TEXTO MULTIPLE
                                     * Descripción - descripcion
                                     *
                                     *
                                     * Se forma con : Asunto1, Asunto2, Tema
                                     *
                                     */

                                    var    addOK     = true;
                                    string valorText = "";

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

                                        valorText = addOK ? row.Tema : "";

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

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

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


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

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

                                        break;

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

                                    var    addOK     = true;
                                    string valorText = "";

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

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

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

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

                                    case "titulo":
                                        // Tipodedocumento, Dirigidoa

                                        var tipoDocOk = false;
                                        addOK      = row.Tipodedocumento == null || row.Tipodedocumento == "" ? false : true;
                                        valorText += addOK? row.Tipodedocumento : "";
                                        tipoDocOk  = addOK;
                                        addOK      = row.Dirigidoa == null || row.Dirigidoa == "" ? false : true;
                                        valorText += tipoDocOk && addOK ? " / " : "";
                                        valorText += addOK ? row.Dirigidoa : "";
                                        addOK      = addOK || tipoDocOk ? true : false;
                                        break;

                                    case "UrlFicha_CEHM":
                                        addOK     = row.URLFicha == null || row.URLFicha == "" ? false : true;
                                        valorText = addOK ? row.URLFicha : "";
                                        break;

                                    case "NoImagen_CEHM":
                                        addOK     = row.NoImag == 0 ? false : true;
                                        valorText = addOK ? row.NoImag.ToString() : "0";
                                        addOK     = true;
                                        break;

                                    case "URLImagen_CEHM":
                                        addOK     = row.URLImagen == null || row.URLImagen == "" ? false : true;
                                        valorText = addOK ? row.URLImagen : "";
                                        break;

                                    default:
                                        addOK = false;
                                        break;
                                    }

                                    if (addOK)
                                    {
                                        listaAdd_AttGen.Add(new AtributoPieza()
                                        {
                                            AtributoPiezaID = Guid.NewGuid(),
                                            AtributoID      = att.AtributoID,
                                            PiezaID         = pieza.PiezaID,
                                            Status          = true,
                                            Valor           = valorText
                                        });
                                    }
                                }
                            }
                        }
                        else
                        {
                            /*
                             * AUTOR LISTA MULTIPLE
                             * Firmado por
                             */


                            var    addOK     = true;
                            string valorText = "";

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


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

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


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



                    numeroRow++;
                }

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

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



            return(View());
        }
Beispiel #26
0
        public ActionResult Registrar(Guid?TipoObraID, int?LetraFolioID, Guid?TipoPiezaID)
        {
            var Formulario = Request.Form;

            int InicioFolio = 1;

            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());
            }


            //buscar el ultimo numero del folio subido


            InicioFolio = db.Obras.Where(a => a.LetraFolioID == letra.LetraFolioID).Select(a => a.NumeroFolio).OrderByDescending(a => a).FirstOrDefault();

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

            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 FileImageForm = Request.Files[key];

                            string texto_Titulo      = Formulario["id_" + att.AtributoID + "_Titulo"];
                            string texto_Descripcion = Formulario["id_" + att.AtributoID + "_Descripcion"];
                            string extension         = Path.GetExtension(FileImageForm.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);

                            FileImageForm.SaveAs(rutaGuardar_Original);


                            FileImageForm.InputStream.Dispose();
                            FileImageForm.InputStream.Close();
                            GC.Collect();

                            //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 IniciarUsuarios()
        {
            conRec1.Open();
            string        textSql1 = string.Format("SELECT * FROM [{0}]", "m_usuario");
            SqlCommand    sql1     = new SqlCommand(textSql1, conRec1);
            SqlDataReader leer1    = sql1.ExecuteReader();

            List <RowUsuario> listaUsuarios = new List <RowUsuario>();

            var i = 0;

            while (leer1.Read())
            {
                i++;
                var rowUsuario = new RowUsuario()
                {
                    a_materno          = Regex.Replace(leer1["a_materno"].ToString().Trim(), @"\s+", " "),
                    a_paterno          = Regex.Replace(leer1["a_paterno"].ToString().Trim(), @"\s+", " "),
                    cmonitoreo         = Regex.Replace(leer1["cmonitoreo"].ToString().Trim(), @"\s+", " "),
                    cve_permiso        = Regex.Replace(leer1["cve_permiso"].ToString().Trim(), @"\s+", " "),
                    cve_usuario        = Regex.Replace(leer1["cve_usuario"].ToString().Trim(), @"\s+", " "),
                    Departamento_Clave = Regex.Replace(leer1["Departamento_Clave"].ToString().Trim(), @"\s+", " "),
                    email        = Regex.Replace(leer1["email"].ToString().Trim(), @"\s+", " "),
                    estatus      = Regex.Replace(leer1["estatus"].ToString().Trim(), @"\s+", " "),
                    login        = Regex.Replace(leer1["login"].ToString().Trim(), @"\s+", " "),
                    nombre       = Regex.Replace(leer1["nombre"].ToString().Trim(), @"\s+", " "),
                    password     = Regex.Replace(leer1["password"].ToString().Trim(), @"\s+", " "),
                    passwordOK   = Regex.Replace(leer1["passwordOK"].ToString().Trim(), @"\s+", " "),
                    permisos     = Regex.Replace(leer1["permisos"].ToString().Trim(), @"\s+", " "),
                    Puesto_Clave = Regex.Replace(leer1["Puesto_Clave"].ToString().Trim(), @"\s+", " ")
                };


                if (rowUsuario.cve_usuario != "0")
                {
                    listaUsuarios.Add(rowUsuario);
                }
            }
            conRec1.Close();
            leer1 = null;

            string pass           = "******";
            string passEncriptado = EncriptaPass(pass);

            foreach (var item in listaUsuarios)
            {
                var usuario = new Usuario();

                usuario.UsuarioID = Guid.NewGuid();


                usuario.Apellido = item.a_paterno + " " + item.a_materno;
                usuario.Apellido = Regex.Replace(usuario.Apellido.ToString().Trim(), @"\s+", " ");



                try
                {
                    var addr = new System.Net.Mail.MailAddress(item.email);
                    usuario.Correo = item.email;
                }
                catch
                {
                }



                usuario.Nombre   = item.nombre;
                usuario.Password = passEncriptado;



                usuario.Status          = item.estatus == "1" ? true : false;
                usuario.UserName        = item.login;
                usuario.ConfirmPassword = usuario.Password;


                db.Usuarios.Add(usuario);
                db.SaveChanges();
            }


            return(View());
        }
Beispiel #28
0
        public ActionResult Crear([Bind(Include = "AtributoPiezaID,Valor,Status,PiezaID,AtributoID,ListaValorID")] AtributoPieza atributoPieza)
        {
            Guid   renderID = atributoPieza.AtributoPiezaID;
            string texto    = "";
            bool   guardar  = false;



            var att = db.Atributos.Find(atributoPieza.AtributoID);

            if (att == null)
            {
                guardar = false;
                //alerta no existe el atributo
            }
            else
            {
                if (att.TipoAtributo.EsLista)
                {
                    string valor = Request.Form["id_" + atributoPieza.AtributoID].ToString();

                    atributoPieza.ListaValorID = new Guid(valor);

                    //no existe el ListaValorID entonces actualizar el AtributoPiezaID con el ListaValorID
                    if (db.AtributoPiezas.Where(a => a.AtributoID == atributoPieza.AtributoID && a.PiezaID == atributoPieza.PiezaID && a.ListaValorID == atributoPieza.ListaValorID).Count() == 0)
                    {
                        guardar = true;

                        var listaValor = db.ListaValores.FirstOrDefault(a => a.ListaValorID == atributoPieza.ListaValorID);

                        texto = listaValor.Valor;

                        AlertaSuccess(string.Format("{0}: <b>{1}</b> se creó.", att.NombreAlterno, listaValor.Valor), true);
                    }
                    else
                    {
                        guardar = false;
                        //Alerta ya existe
                    }
                }
                else
                {
                    //campo texto
                    //tratar el atributoPieza.Valor , quitar espacios extras
                    atributoPieza.Valor = Regex.Replace(atributoPieza.Valor.Trim(), @"\s+", " ");

                    if (db.AtributoPiezas.Where(a => a.AtributoID == atributoPieza.AtributoID && a.PiezaID == atributoPieza.PiezaID && a.Valor == atributoPieza.Valor).Count() == 0)
                    {
                        guardar = true;
                        texto   = atributoPieza.Valor;

                        AlertaSuccess(string.Format("{0}: <b>{1}</b> se creó.", att.NombreAlterno, texto), true);
                    }
                    else
                    {
                        guardar = false;
                        //alerta ya existe
                    }
                }
            }

            if (guardar)
            {
                atributoPieza.AtributoPiezaID = Guid.NewGuid();

                atributoPieza.AtributoPiezaID = Guid.NewGuid();
                db.AtributoPiezas.Add(atributoPieza);
                db.SaveChanges();

                renderID = atributoPieza.AtributoPiezaID;
            }



            return(Json(new { success = true, renderID = "valor_" + renderID, texto = texto, guardar = guardar }));
        }