コード例 #1
0
 public ActionResult Edit([Bind(Include = "id_academia,nombre,ubicacion,activo,eliminado,id_usuario_crecion,id_usuario_modificacion,id_usuario_eliminacion,fecha_creacion,fecha_modificacion,fecha_eliminacion")] Academia academia)
 {
     if (ModelState.IsValid)
     {
         using (DbContextTransaction tran = db.Database.BeginTransaction())
         {
             try
             {
                 Academia academiaEdit = db.Academia.SingleOrDefault(a => a.activo && a.id_academia == academia.id_academia);
                 if (academiaEdit == null)
                 {
                     return(HttpNotFound());
                 }
                 academiaEdit.nombre    = ConversionMayusculas(academia.nombre);
                 academiaEdit.ubicacion = ConversionMayusculas(academia.ubicacion);
                 UsuarioTO usuario = Cache.DiccionarioUsuariosLogueados[User.Identity.Name];
                 academiaEdit.fecha_modificacion      = DateTime.Now;
                 academiaEdit.id_usuario_modificacion = usuario.usuario.id_usuario;
                 db.Entry(academiaEdit).State         = EntityState.Modified;
                 db.SaveChanges();
                 tran.Commit();
                 return(RedirectToAction("Index"));
             }
             catch
             {
                 tran.Rollback();
             }
         }
     }
     return(View(academia));
 }
コード例 #2
0
 public ActionResult Edit([Bind(Include = "id_instructor,primer_nombre,segundo_nombre,primer_apellido,segundo_apellido,fecha_creacion,fecha_modificacion,fecha_eliminacion,id_usuario_creacion,id_usuario_modificacion,id_usuario_eliminacion,activo,eliminado")] Instructor instructor)
 {
     if (ModelState.IsValid)
     {
         using (DbContextTransaction tran = db.Database.BeginTransaction())
         {
             try
             {
                 Instructor edit_instructor = db.Instructor.Find(instructor.id_instructor);
                 edit_instructor.primer_nombre           = instructor.primer_nombre;
                 edit_instructor.segundo_nombre          = instructor.segundo_nombre;
                 edit_instructor.primer_apellido         = instructor.primer_apellido;
                 edit_instructor.segundo_apellido        = instructor.segundo_apellido;
                 edit_instructor.fecha_modificacion      = DateTime.Now;
                 edit_instructor.id_usuario_modificacion = Cache.DiccionarioUsuariosLogueados[User.Identity.Name].usuario.id_usuario;
                 db.Entry(edit_instructor).State         = EntityState.Modified;
                 db.SaveChanges();
                 tran.Commit();
                 return(RedirectToAction("Index"));
             }
             catch
             {
                 tran.Rollback();
             }
         }
     }
     return(View(instructor));
 }
コード例 #3
0
 public ActionResult Edit(Empresa empresa)
 {
     if (ModelState.IsValid)
     {
         Empresa empresaEdit = db.Empresa.SingleOrDefault(e => e.id_empresa == empresa.id_empresa && !e.eliminado);
         if (empresaEdit == null)
         {
             return(HttpNotFound());
         }
         empresaEdit.id_usuario_modificacion = Cache.DiccionarioUsuariosLogueados[User.Identity.Name].usuario.id_usuario;
         empresaEdit.fecha_modificacion      = DateTime.Now;
         empresaEdit.centro_trabajo          = !String.IsNullOrEmpty(empresa.centro_trabajo) ? empresa.centro_trabajo.ToUpper() : "";
         empresaEdit.contacto          = !String.IsNullOrEmpty(empresa.centro_trabajo) ? empresa.centro_trabajo.ToUpper() : "";
         empresaEdit.direccion         = !String.IsNullOrEmpty(empresa.direccion) ? empresa.direccion.ToUpper() : "";
         empresaEdit.nombre            = !String.IsNullOrEmpty(empresa.nombre) ? empresa.nombre.ToUpper() : "";
         empresaEdit.nombre_comercial  = !String.IsNullOrEmpty(empresa.nombre_comercial) ? empresa.nombre_comercial.ToUpper() : "";
         empresaEdit.correo            = empresa.correo;
         empresaEdit.encabezado_boleta = empresa.encabezado_boleta;
         empresaEdit.fax             = empresa.fax;
         empresaEdit.id_municipio    = empresa.id_municipio;
         empresaEdit.id_pais         = empresa.id_pais;
         empresaEdit.nit             = empresa.nit;
         empresaEdit.numero_patronal = empresa.numero_patronal;
         empresaEdit.prestaciones    = empresa.prestaciones;
         empresaEdit.telefono        = empresa.telefono;
         empresaEdit.zona            = empresa.zona;
         db.Entry(empresaEdit).State = EntityState.Modified;
         db.SaveChanges();
         return(RedirectToAction("Index"));
     }
     ViewBag.pais       = new SelectList(db.Paises.Where(e => !e.eliminado), "id_pais", "nombre", empresa.id_pais);
     ViewBag.municipios = new SelectList(db.Municipios.Where(m => !m.eliminado), "id_municipio", "nombre", empresa.id_municipio);
     return(View(empresa));
 }
コード例 #4
0
 public ActionResult Edit(string nombre, int id_curso, int id_academia)
 {
     if (ModelState.IsValid)
     {
         using (DbContextTransaction tran = db.Database.BeginTransaction())
         {
             try
             {
                 UsuarioTO usuario = Cache.DiccionarioUsuariosLogueados[User.Identity.Name];
                 Curso     curso   = db.Curso.Find(id_curso);
                 curso.fecha_modificacion      = DateTime.Now;
                 curso.nombre                  = nombre;
                 curso.id_usuario_modificacion = usuario.usuario.id_usuario;
                 db.Entry(curso).State         = EntityState.Modified;
                 db.SaveChanges();
                 tran.Commit();
             }
             catch
             {
                 tran.Rollback();
                 ModelState.AddModelError("", "Error. Cambios no realizados.");
             }
         }
     }
     return(RedirectToAction("Index", new { id_academia = id_academia }));
 }
コード例 #5
0
        public ActionResult FinalizarEstadoFuerza(int id_estado_fuerza)
        {
            Estado_Fuerza estadofuerza = db.Estado_Fuerza.SingleOrDefault(e => e.id_estado_fuerza == id_estado_fuerza && e.activo && !e.eliminado);

            if (estadofuerza == null)
            {
                return(HttpNotFound());
            }
            estadofuerza.activo                  = false;
            estadofuerza.fecha_finalizacion      = estadofuerza.fecha_modificacion = DateTime.Now;
            estadofuerza.id_usuario_finalizacion = estadofuerza.id_usuario_modificacion = Cache.DiccionarioUsuariosLogueados[User.Identity.Name].usuario.id_usuario;
            //using (DbContextTransaction tran = db.Database.BeginTransaction())
            {
                try
                {
                    db.Entry(estadofuerza).State = EntityState.Modified;
                    db.SaveChanges();
                    db.Finalizar_Dia(estadofuerza.id_estado_fuerza);
                    //tran.Commit();
                    return(RedirectToAction("EstadoFuerza"));
                }
                catch
                {
                    //tran.Rollback();
                    ContextMessage msg = new ContextMessage(ContextMessage.Error, "Error durante la conexión con el servidor. Cambios no efectuados.");
                    msg.ReturnUrl = Url.Action("EstadoFuerza");
                    TempData[User.Identity.Name] = msg;
                    return(RedirectToAction("Mensaje"));
                }
            }
        }
コード例 #6
0
 public ActionResult Edit([Bind(Include = "id_razon_social,id_cliente,razon_social,nombre_comercial,nit,direccion_fisica,municipio_direccion_fisica,direccion_fiscal,municipio_direccion_fiscal,direccion_facturacion,municipio_direccion_facturacion,activo,eliminado,id_usuario_creacion,id_usuario_modificacion,id_usuario_eliminacion,fecha_creacion,fecha_modificacion,fecha_eliminacion")] Razones_Sociales razones_Sociales)
 {
     if (ModelState.IsValid)
     {
         Razones_Sociales razones_sociales_edit = db.Razones_Sociales.Find(razones_Sociales.id_razon_social);
         UsuarioTO        usuarioTO             = Cache.DiccionarioUsuariosLogueados[User.Identity.Name];
         razones_sociales_edit.razon_social     = razones_Sociales.razon_social;
         razones_sociales_edit.nombre_comercial = razones_Sociales.nombre_comercial;
         razones_sociales_edit.nit = razones_Sociales.nit;
         razones_sociales_edit.direccion_fisica        = razones_Sociales.direccion_fisica;
         razones_sociales_edit.direccion_fiscal        = razones_Sociales.direccion_fiscal;
         razones_sociales_edit.direccion_facturacion   = razones_Sociales.direccion_facturacion;
         razones_sociales_edit.id_usuario_modificacion = usuarioTO.usuario.id_usuario;
         razones_sociales_edit.fecha_modificacion      = DateTime.Now;
         razones_sociales_edit.eliminado       = false;
         razones_sociales_edit.activo          = true;
         db.Entry(razones_sociales_edit).State = EntityState.Modified;
         db.SaveChanges();
         return(RedirectToAction("Index"));
     }
     ViewBag.id_cliente = new SelectList(db.Clientes.Where(x => x.eliminado == false), "id_cliente", "nombre", razones_Sociales.id_cliente);
     ViewBag.municipio_direccion_facturacion = new SelectList(db.Municipios.Where(x => x.eliminado == false), "id_municipio", "nombre", razones_Sociales.municipio_direccion_facturacion);
     ViewBag.municipio_direccion_fiscal      = new SelectList(db.Municipios.Where(x => x.eliminado == false), "id_municipio", "nombre", razones_Sociales.municipio_direccion_fiscal);
     ViewBag.municipio_direccion_fisica      = new SelectList(db.Municipios.Where(x => x.eliminado == false), "id_municipio", "nombre", razones_Sociales.municipio_direccion_fisica);
     return(View(razones_Sociales));
 }
コード例 #7
0
 public ActionResult Edit(Tipo_Puesto tipo_puesto)
 {
     using (DbContextTransaction tran = db.Database.BeginTransaction())
     {
         try
         {
             Tipo_Puesto editTipo_puesto = db.Tipo_Puesto.SingleOrDefault(t => t.id_tipo_puesto == tipo_puesto.id_tipo_puesto && t.activo);
             if (editTipo_puesto == null)
             {
                 return(HttpNotFound());
             }
             //editTipo_puesto.id_empresa = tipo_puesto.id_empresa;
             editTipo_puesto.nombre = tipo_puesto.nombre;
             editTipo_puesto.genera_estado_fuerza    = tipo_puesto.genera_estado_fuerza;
             editTipo_puesto.salario_maximo          = Convert.ToDecimal(Request["salario_maximo"], CultureInfo.InvariantCulture);
             editTipo_puesto.salario_minimo          = Convert.ToDecimal(Request["salario_minimo"], CultureInfo.InvariantCulture);
             editTipo_puesto.fecha_modificacion      = DateTime.Now;
             editTipo_puesto.id_usuario_modificacion = Cache.DiccionarioUsuariosLogueados[User.Identity.Name].usuario.id_usuario;
             db.Entry(editTipo_puesto).State         = EntityState.Modified;
             db.SaveChanges();
             tran.Commit();
             return(RedirectToAction("Index"));
         }
         catch
         {
             tran.Rollback();
             ContextMessage msg = new ContextMessage(ContextMessage.Error, "No se pudo modificar correctamente el Tipo de Puesto");
             msg.ReturnUrl = Url.Action("Edit");
             TempData[User.Identity.Name] = msg;
             return(RedirectToAction("Mensaje", "Home"));
         }
     }
 }
コード例 #8
0
 public JsonResult EditarGestionDestalle(int id_gestion_cobro_detalle, int id_tipo_gestion_proyectada, DateTime fecha_proyectada,
                                         int?id_tipo_gestion_realizada, DateTime?fecha_gestion_realizada, int?id_tipo_respuesta_gestion, string comentario, bool realizada)
 {
     try
     {
         Gestion_Cobro_Detalle gcd = db.Gestion_Cobro_Detalle.SingleOrDefault(g => g.activo && g.id_gestion_cobro_detalle == id_gestion_cobro_detalle);
         if (gcd == null)
         {
             return(Json(new { result = 1 }, JsonRequestBehavior.AllowGet));
         }
         gcd.fecha_proyectada = fecha_proyectada;
         gcd.id_cat_tipo_gestion_proyectada = id_tipo_gestion_proyectada;
         gcd.id_cat_tipo_gestion_realizada  = id_tipo_gestion_realizada;
         gcd.fecha_realizado = fecha_gestion_realizada;
         gcd.id_cat_tipo_respuesta_gestion = id_tipo_respuesta_gestion;
         gcd.comentario = comentario;
         gcd.id_usuario_modificacion = Cache.DiccionarioUsuariosLogueados[User.Identity.Name].usuario.id_usuario;
         gcd.fecha_modificacion      = DateTime.Now;
         gcd.realizada       = realizada;
         db.Entry(gcd).State = EntityState.Modified;
         db.SaveChanges();
         return(Json(new { result = 2 }, JsonRequestBehavior.AllowGet));
     }
     catch
     {
         return(Json(new { result = 1 }, JsonRequestBehavior.AllowGet));
     }
 }
コード例 #9
0
        public ActionResult Crear(DateTime fecha_inicio, DateTime fecha_fin, int cantidad_dias, bool tipo_vacacion, int id_vacacion_contrato, string costo)
        {
            var    vacacion_contrato = db.Vacacion_Contrato.Find(id_vacacion_contrato);
            int    dias_usados       = 0;
            string error             = "";

            if (vacacion_contrato.dias_tomados.HasValue)
            {
                dias_usados = vacacion_contrato.dias_tomados.Value;
            }
            if (vacacion_contrato.dias_total >= (dias_usados + cantidad_dias))
            {
                Vacacion_Detalle vacacion_detalle = new Vacacion_Detalle();
                vacacion_detalle.activo              = true;
                vacacion_detalle.eliminado           = false;
                vacacion_detalle.id_empleado         = vacacion_contrato.id_empleado;
                vacacion_detalle.fecha_creacion      = DateTime.Now;
                vacacion_detalle.id_usuario_creacion = Cache.DiccionarioUsuariosLogueados[User.Identity.Name].usuario.id_usuario;

                vacacion_detalle.fecha_inicio         = fecha_inicio;
                vacacion_detalle.fecha_fin            = fecha_fin;
                vacacion_detalle.cantidad_dias        = cantidad_dias;
                vacacion_detalle.tipo_vacacion        = tipo_vacacion;
                vacacion_detalle.id_vacacion_contrato = id_vacacion_contrato;

                if (tipo_vacacion) //true implica que se pagaron las vacaciones al empleado
                {
                    vacacion_detalle.costo = Convert.ToDecimal(costo, CultureInfo.InvariantCulture);
                }
                if (vacacion_contrato.dias_tomados.HasValue)
                {
                    vacacion_contrato.dias_tomados += cantidad_dias;
                }
                else
                {
                    vacacion_contrato.dias_tomados = cantidad_dias;
                }
                try
                {
                    db.Vacacion_Detalle.Add(vacacion_detalle);
                    db.Entry(vacacion_contrato).State = EntityState.Modified;
                    db.SaveChanges();
                    return(RedirectToAction("Details", new { id = id_vacacion_contrato }));
                }
                catch
                {
                    error = "Error en la conexión con el servidor. Operación no efectuada.";
                }
            }
            else
            {
                error = "La cantidad de días ingresadas supera el límite disponible del empleado.";
            }
            ContextMessage msg = new ContextMessage(ContextMessage.Warning, error);

            msg.ReturnUrl = Url.Action("Details", new { id = id_vacacion_contrato });
            TempData[User.Identity.Name] = msg;
            return(RedirectToAction("Mensaje"));
        }
コード例 #10
0
 public ActionResult Edit([Bind(Include = "id_usuario,email,password_hash,bloqueo_habilitado,usuario,nombre_completo_usuario,usuario_externo")] Usuarios usuarios)
 {
     if (ModelState.IsValid)
     {
         usuarios.password_hash   = CipherUtil.Encrypt(usuarios.password_hash);
         db.Entry(usuarios).State = EntityState.Modified;
         db.SaveChanges();
         return(RedirectToAction("Index"));
     }
     return(View(usuarios));
 }
コード例 #11
0
 public ActionResult Edit([Bind(Include = "id_tipo_cuenta,nombre")] Tipo_Cuenta tipo_Cuenta)
 {
     if (ModelState.IsValid)
     {
         Tipo_Direccion edit_tipo_cuenta = db.Tipo_Direccion.Find(tipo_Cuenta.id_tipo_cuenta);
         edit_tipo_cuenta.nombre                 = tipo_Cuenta.nombre;
         edit_tipo_cuenta.fecha_modificacion     = DateTime.Now;
         edit_tipo_cuenta.id_usuario_eliminacion = Cache.DiccionarioUsuariosLogueados[User.Identity.Name].usuario.id_usuario;
         db.Entry(edit_tipo_cuenta).State        = EntityState.Modified;
         db.SaveChanges();
         return(RedirectToAction("Index"));
     }
     return(View(tipo_Cuenta));
 }
コード例 #12
0
 public ActionResult Edit([Bind(Include = "id_banco,nombre")] Banco banco)
 {
     if (ModelState.IsValid)
     {
         Banco editbanco = db.Banco.Find(banco.id_banco);
         editbanco.nombre                  = banco.nombre;
         editbanco.fecha_modificacion      = DateTime.Now;
         editbanco.id_usuario_modificacion = Cache.DiccionarioUsuariosLogueados[User.Identity.Name].usuario.id_usuario;
         db.Entry(editbanco).State         = EntityState.Modified;
         db.SaveChanges();
         return(RedirectToAction("Index"));
     }
     return(View(banco));
 }
コード例 #13
0
 public ActionResult Edit([Bind(Include = "id_estado_civil,nombre")] Estado_Civil estado_Civil)
 {
     if (ModelState.IsValid)
     {
         Estado_Civil editestado_civil = db.Estado_Civil.Find(estado_Civil.id_estado_civil);
         editestado_civil.nombre                  = estado_Civil.nombre;
         editestado_civil.fecha_modificacion      = DateTime.Now;
         editestado_civil.id_usuario_modificacion = Cache.DiccionarioUsuariosLogueados[User.Identity.Name].usuario.id_usuario;
         db.Entry(editestado_civil).State         = EntityState.Modified;
         db.SaveChanges();
         return(RedirectToAction("Index"));
     }
     return(View(estado_Civil));
 }
コード例 #14
0
 public ActionResult Edit([Bind(Include = "id_profesion,nombre")] Profesion profesion)
 {
     if (ModelState.IsValid)
     {
         Profesion editprofesion = db.Profesion.Find(profesion.id_profesion);
         editprofesion.nombre                  = profesion.nombre;
         editprofesion.fecha_modificacion      = DateTime.Now;
         editprofesion.id_usuario_modificacion = Cache.DiccionarioUsuariosLogueados[User.Identity.Name].usuario.id_usuario;
         db.Entry(editprofesion).State         = EntityState.Modified;
         db.SaveChanges();
         return(RedirectToAction("Index"));
     }
     return(View(profesion));
 }
コード例 #15
0
 public ActionResult Edit([Bind(Include = "id_tipo_telefono,nombre")] Tipo_Telefono tipo_Telefono)
 {
     if (ModelState.IsValid)
     {
         Tipo_Telefono edittipo_telefono = db.Tipo_Telefono.Find(tipo_Telefono.id_tipo_telefono);
         edittipo_telefono.fecha_modificacion      = DateTime.Now;
         edittipo_telefono.id_usuario_modificacion = Cache.DiccionarioUsuariosLogueados[User.Identity.Name].usuario.id_usuario;
         edittipo_telefono.nombre          = tipo_Telefono.nombre;
         db.Entry(edittipo_telefono).State = EntityState.Modified;
         db.SaveChanges();
         return(RedirectToAction("Index"));
     }
     return(View(tipo_Telefono));
 }
コード例 #16
0
 public ActionResult Edit([Bind(Include = "id_grado_estudio,nombre")] Grado_Estudio grado_Estudio)
 {
     if (ModelState.IsValid)
     {
         Grado_Estudio edit_grado_estudio = db.Grado_Estudio.Find(grado_Estudio.id_grado_estudio);
         edit_grado_estudio.fecha_modificacion      = DateTime.Now;
         edit_grado_estudio.id_usuario_modificacion = Cache.DiccionarioUsuariosLogueados[User.Identity.Name].usuario.id_usuario;
         edit_grado_estudio.nombre          = grado_Estudio.nombre;
         db.Entry(edit_grado_estudio).State = EntityState.Modified;
         db.SaveChanges();
         return(RedirectToAction("Index"));
     }
     return(View(grado_Estudio));
 }
コード例 #17
0
 public ActionResult Edit(Cat_Tipos_Agente tipo_Agentes)
 {
     if (ModelState.IsValid)
     {
         UsuarioTO        usuarioTO   = Cache.DiccionarioUsuariosLogueados[User.Identity.Name];
         Cat_Tipos_Agente edit_agente = db.Cat_Tipos_Agente.Where(x => x.id_cat_tipo_agente == tipo_Agentes.id_cat_tipo_agente).FirstOrDefault();
         edit_agente.nombre = tipo_Agentes.nombre;
         edit_agente.id_usuario_modificacion = usuarioTO.usuario.id_usuario;
         edit_agente.fecha_modificacion      = DateTime.Now;
         db.Entry(edit_agente).State         = EntityState.Modified;
         db.SaveChanges();
         return(RedirectToAction("Index"));
     }
     return(View(tipo_Agentes));
 }
コード例 #18
0
 public ActionResult Edit(Estados_Factura estados_Factura)
 {
     if (ModelState.IsValid)
     {
         UsuarioTO       usuarioTO   = Cache.DiccionarioUsuariosLogueados[User.Identity.Name];
         Estados_Factura edit_estado = db.Estados_Factura.Where(x => x.id_estado_factura == estados_Factura.id_estado_factura).FirstOrDefault();
         edit_estado.fecha_modificacion      = DateTime.Now;
         edit_estado.id_usuario_modificacion = usuarioTO.usuario.id_usuario;
         edit_estado.nombre          = estados_Factura.nombre;
         db.Entry(edit_estado).State = EntityState.Modified;
         db.SaveChanges();
         return(RedirectToAction("Index"));
     }
     return(View(estados_Factura));
 }
コード例 #19
0
 public ActionResult Edit(Tipos_Servicios servicios_Adicionales)
 {
     if (ModelState.IsValid)
     {
         UsuarioTO       usuarioTO = Cache.DiccionarioUsuariosLogueados[User.Identity.Name];
         Tipos_Servicios edit_sa   = db.Tipos_Servicios.Where(x => x.id_tipo_servicio == servicios_Adicionales.id_tipo_servicio).ToList().FirstOrDefault();
         edit_sa.nombre                  = servicios_Adicionales.nombre;
         edit_sa.fecha_modificacion      = DateTime.Now;
         edit_sa.id_usuario_modificacion = usuarioTO.usuario.id_usuario;
         db.Entry(edit_sa).State         = EntityState.Modified;
         db.SaveChanges();
         return(RedirectToAction("Index"));
     }
     return(View(servicios_Adicionales));
 }
コード例 #20
0
        public ActionResult Edit(Cat_Tipos_Agente cat_Tipos_Agente)
        {
            if (ModelState.IsValid)
            {
                UsuarioTO usuarioTO            = Cache.DiccionarioUsuariosLogueados[User.Identity.Name];
                var       edit_cat_tipo_agente = db.Cat_Tipos_Agente.Find(cat_Tipos_Agente.id_cat_tipo_agente);
                edit_cat_tipo_agente.id_usuario_modificacion = usuarioTO.usuario.id_usuario;
                edit_cat_tipo_agente.fecha_modificacion      = DateTime.Now;
                edit_cat_tipo_agente.nombre          = cat_Tipos_Agente.nombre.ToUpper();
                db.Entry(edit_cat_tipo_agente).State = EntityState.Modified;
                db.SaveChanges();
                return(RedirectToAction("Index"));
            }

            return(View(cat_Tipos_Agente));
        }
コード例 #21
0
 public ActionResult Edit([Bind(Include = "id_tipo_archivo,nombre")] Tipo_Archivo tipo_Archivo)
 {
     if (ModelState.IsValid)
     {
         //string oldpath = db.Tipo_Archivo.Find(tipo_Archivo.id_tipo_archivo).nombre;
         Tipo_Archivo edit_tipo_archivo = db.Tipo_Archivo.Find(tipo_Archivo.id_tipo_archivo);
         edit_tipo_archivo.nombre                 = tipo_Archivo.nombre;
         edit_tipo_archivo.fecha_modificacion     = DateTime.Now;
         edit_tipo_archivo.id_usuario_eliminacion = Cache.DiccionarioUsuariosLogueados[User.Identity.Name].usuario.id_usuario;
         //Directory.Move(App_GlobalResources.Resources.FilePath + "\\" + oldpath, App_GlobalResources.Resources.FilePath + "\\" + tipo_Archivo.nombre);
         db.Entry(edit_tipo_archivo).State = EntityState.Modified;
         db.SaveChanges();
         return(RedirectToAction("Index"));
     }
     return(View(tipo_Archivo));
 }
コード例 #22
0
 public ActionResult Edit([Bind(Include = "id_tipo_permiso_ausencia,descripcion,id_situacion,activo,eliminado,fecha_creacion,fecha_modificacion,fecha_eliminacion,id_usuario_creacion,id_usuario_modificacion,id_usuario_eliminacion")] Tipo_Permiso_Ausencia tipo_Permiso_Ausencia)
 {
     if (ModelState.IsValid)
     {
         Tipo_Permiso_Ausencia edit_tipo_permiso_ausencia = db.Tipo_Permiso_Ausencia.SingleOrDefault(t => t.activo && t.id_tipo_permiso_ausencia == tipo_Permiso_Ausencia.id_tipo_permiso_ausencia);
         edit_tipo_permiso_ausencia.id_situacion            = tipo_Permiso_Ausencia.id_situacion;
         edit_tipo_permiso_ausencia.descripcion             = tipo_Permiso_Ausencia.descripcion;
         edit_tipo_permiso_ausencia.fecha_modificacion      = DateTime.Now;
         edit_tipo_permiso_ausencia.id_usuario_modificacion = Cache.DiccionarioUsuariosLogueados[User.Identity.Name].usuario.id_usuario;
         db.Entry(edit_tipo_permiso_ausencia).State         = EntityState.Modified;
         db.SaveChanges();
         return(RedirectToAction("Index"));
     }
     ViewBag.situacion = new SelectList(db.Situacion, "id_situacion", "nombre", tipo_Permiso_Ausencia.id_situacion);
     return(View(tipo_Permiso_Ausencia));
 }
コード例 #23
0
        public ActionResult Edit(Tickets_Tipo_Movimiento tickets_Tipo_Movimiento)
        {
            if (ModelState.IsValid)
            {
                UsuarioTO usuarioTO = Cache.DiccionarioUsuariosLogueados[User.Identity.Name];
                var       ttm_temp  = db.Tickets_Tipo_Movimiento.Where(x => x.id_ticket_tipo_movimiento == tickets_Tipo_Movimiento.id_ticket_tipo_movimiento).ToList().FirstOrDefault();
                ttm_temp.id_usuario_modificacion = usuarioTO.usuario.id_usuario;
                ttm_temp.nombre             = tickets_Tipo_Movimiento.nombre;
                ttm_temp.fecha_modificacion = DateTime.Now;
                db.Entry(ttm_temp).State    = EntityState.Modified;
                db.SaveChanges();
                return(RedirectToAction("Index"));
            }

            return(View(tickets_Tipo_Movimiento));
        }
コード例 #24
0
 public ActionResult Edit(Razon_Social_Grupos_Factura razon_Social_Grupos_Factura, string descripcion_factura1, string descripcion_factura2)
 {
     if (ModelState.IsValid)
     {
         UsuarioTO usuarioTO = Cache.DiccionarioUsuariosLogueados[User.Identity.Name];
         var       temp_rsgf = db.Razon_Social_Grupos_Factura.Find(razon_Social_Grupos_Factura.id_razon_social_grupo_factura);
         temp_rsgf.nombre = razon_Social_Grupos_Factura.nombre.ToUpper();
         temp_rsgf.descripcion_factura     = descripcion_factura1.ToUpper() + " @Meses " + descripcion_factura2.ToUpper();
         temp_rsgf.fecha_modificacion      = DateTime.Now;
         temp_rsgf.id_usuario_modificacion = usuarioTO.usuario.id_usuario;
         db.Entry(temp_rsgf).State         = EntityState.Modified;
         db.SaveChanges();
         return(RedirectToAction("Details_RS", "Clientes", new { id_Razon_Social = temp_rsgf.id_razon_social }));
     }
     return(View(razon_Social_Grupos_Factura));
 }
コード例 #25
0
        public ActionResult Edit(Cat_Razones_Eliminacion cat_razones_eliminacion)
        {
            UsuarioTO usuarioTO = Cache.DiccionarioUsuariosLogueados[User.Identity.Name];

            if (ModelState.IsValid)
            {
                var razon_eliminacion_edit = db.Cat_Razones_Eliminacion.Find(cat_razones_eliminacion.id_cat_razon_eliminacion);
                razon_eliminacion_edit.nombre = cat_razones_eliminacion.nombre.ToUpper();
                razon_eliminacion_edit.id_usuario_modificacion = usuarioTO.usuario.id_usuario;
                razon_eliminacion_edit.fecha_modificacion      = DateTime.Now;
                db.Entry(razon_eliminacion_edit).State         = EntityState.Modified;
                db.SaveChanges();
                return(RedirectToAction("Index"));
            }
            return(View(cat_razones_eliminacion));
        }
コード例 #26
0
        // PUT api/Department/5
        public IHttpActionResult PutDepartment(int id, Department department)
        {
            if (!ModelState.IsValid)
            {
                return(BadRequest(ModelState));
            }

            if (id != department.deptId)
            {
                return(BadRequest());
            }

            db.Entry(department).State = EntityState.Modified;

            try
            {
                db.SaveChanges();
            }
            catch (DbUpdateConcurrencyException)
            {
                if (!DepartmentExists(id))
                {
                    return(NotFound());
                }
                else
                {
                    throw;
                }
            }

            return(StatusCode(HttpStatusCode.NoContent));
        }
コード例 #27
0
        // PUT api/User/5
        public IHttpActionResult PutUser(int id, User user)
        {
            if (!ModelState.IsValid)
            {
                return(BadRequest(ModelState));
            }

            if (id != user.userId)
            {
                return(BadRequest());
            }

            db.Entry(user).State = EntityState.Modified;

            try
            {
                db.SaveChanges();
            }
            catch (DbUpdateConcurrencyException)
            {
                if (!UserExists(id))
                {
                    return(NotFound());
                }
                else
                {
                    throw;
                }
            }

            return(StatusCode(HttpStatusCode.NoContent));
        }
コード例 #28
0
 public ActionResult Edit([Bind(Include = "id_contrato_servicio,id_ubicacion,id_cat_tipo_facturacion,id_cat_estado_servicio_contratado,activo,eliminado,id_usuario_creacion,id_usuario_modificacion,id_usuario_eliminacion,fecha_creacion,fecha_modificacion,fecha_eliminacion")] Contratos_Servicios contratos_Servicios)
 {
     if (ModelState.IsValid)
     {
         db.Entry(contratos_Servicios).State = EntityState.Modified;
         db.SaveChanges();
         return(RedirectToAction("Index"));
     }
     ViewBag.id_ubicacion                      = new SelectList(db.Ubicaciones, "id_ubicacion", "direccion", contratos_Servicios.id_ubicacion);
     ViewBag.id_usuario_creacion               = new SelectList(db.Usuarios, "id_usuario", "email", contratos_Servicios.id_usuario_creacion);
     ViewBag.id_usuario_eliminacion            = new SelectList(db.Usuarios, "id_usuario", "email", contratos_Servicios.id_usuario_eliminacion);
     ViewBag.id_usuario_modificacion           = new SelectList(db.Usuarios, "id_usuario", "email", contratos_Servicios.id_usuario_modificacion);
     ViewBag.id_cat_estado_servicio_contratado = new SelectList(db.Cat_Estados_Servicio_Contratado, "id_cat_estado_servicio_contratado", "nombre", contratos_Servicios.id_cat_estado_servicio_contratado);
     ViewBag.id_cat_tipo_facturacion           = new SelectList(db.Cat_Tipos_Facturacion, "id_cat_tipo_facturacion", "nombre", contratos_Servicios.id_cat_tipo_facturacion);
     return(View(contratos_Servicios));
 }
コード例 #29
0
        // PUT api/Questionnaire/5
        public IHttpActionResult PutQuestionnaire(int id, Questionnaire questionnaire)
        {
            if (!ModelState.IsValid)
            {
                return(BadRequest(ModelState));
            }

            if (id != questionnaire.qsnId)
            {
                return(BadRequest());
            }

            db.Entry(questionnaire).State = EntityState.Modified;

            try
            {
                db.SaveChanges();
            }
            catch (DbUpdateConcurrencyException)
            {
                if (!QuestionnaireExists(id))
                {
                    return(NotFound());
                }
                else
                {
                    throw;
                }
            }

            return(StatusCode(HttpStatusCode.NoContent));
        }
コード例 #30
0
        public ActionResult Edit(Estado_Tipo estado_Tipo)
        {
            UsuarioTO   usuarioTO       = Cache.DiccionarioUsuariosLogueados[User.Identity.Name];
            Estado_Tipo estado_TipoEdit = db.Estado_Tipo.Find(estado_Tipo.id_estado_tipo);

            if (ModelState.IsValid)
            {
                estado_TipoEdit.descripcion             = estado_Tipo.descripcion;
                estado_TipoEdit.id_usuario_modificacion = usuarioTO.usuario.id_usuario;
                estado_TipoEdit.fecha_modificacion      = DateTime.Now;
                db.Entry(estado_Tipo).State             = EntityState.Modified;
                db.SaveChanges();
                return(RedirectToAction("Index"));
            }
            return(View(estado_Tipo));
        }