Example #1
0
        public async Task <IActionResult> EditSriDetalle(SriDetalle sriDetalle)
        {
            Response response = new Response();

            try
            {
                if (sriDetalle.FraccionBasica >= sriDetalle.ExcesoHasta)
                {
                    ModelState.AddModelError("FraccionBasica", "La Fracción básica no puede ser mayor que Exceso hasta");
                    ModelState.AddModelError("ExcesoHasta", "El Exceso hasta no puede se menor que la Fracción básica");
                    return(View(sriDetalle));
                }
                if (ObtenerSriNomina().IdSri > 0)
                {
                    sriDetalle.IdSri = ObtenerSriNomina().IdSri;
                    response         = await apiServicio.EditarAsync <Response>(sriDetalle, new Uri(WebApp.BaseAddress),
                                                                                "api/SriNomina/EditarSriDetalle");

                    if (response.IsSuccess)
                    {
                        return(this.Redireccionar($"{Mensaje.Informacion}|{Mensaje.Satisfactorio}", "IndexSriDetalle"));
                    }
                    this.TempData["Mensaje"] = $"{Mensaje.Informacion}|{response.Message}";
                    await CargarComboxConceptoConjunto();

                    return(View(sriDetalle));
                }
                return(this.Redireccionar($"{Mensaje.Error}|{Mensaje.ErrorCargarDatos}"));
            }
            catch (Exception)
            {
                return(this.Redireccionar($"{Mensaje.Error}|{Mensaje.ErrorCargarDatos}"));
            }
        }
        public async Task <IActionResult> Reliquidacion(int id)
        {
            try
            {
                var sol = new SolicitudViatico()
                {
                    IdSolicitudViatico = id,
                    Estado             = 4
                };
                var sol1 = new SolicitudViaticoViewModel()
                {
                    SolicitudViatico = sol
                };

                var respuestaEmpleado = await apiServicio.EditarAsync <Response>(sol1, new Uri(WebApp.BaseAddress),
                                                                                 "api/SolicitudViaticos/ActualizarEstadoSolicitudViatico");

                if (respuestaEmpleado.IsSuccess)
                {
                    return(RedirectToAction("ListadoEmpleadosSolicitudViaticos"));
                }

                return(BadRequest());
            }
            catch (Exception ex)
            {
                return(BadRequest());
            }
        }
        public async Task <IActionResult> Detalle(FichaCandidatoViewModel fichaCandidato)
        {
            if (!ModelState.IsValid)
            {
                InicializarMensaje(Mensaje.CorregirFormulario);
                return(View(fichaCandidato));
            }

            try
            {
                var response = await apiServicio.EditarAsync <Response>(fichaCandidato, new Uri(WebApp.BaseAddress), "api/Candidatos/EditarCandidato");

                if (response.IsSuccess)
                {
                    return(RedirectToAction("Detalle", new { mensaje = Mensaje.GuardadoSatisfactorio, idCandidato = HttpContext.Session.GetInt32(Constantes.idCandidatoSession) }));
                }
                // await CargarCombosEmpleado(datosBasicosEmpleado);
                ViewData["Error"] = Mensaje.ExisteEmpleado;
                return(View(fichaCandidato));
            }
            catch (Exception ex)
            {
                throw;
            }
        }
Example #4
0
        private async Task <entidades.Utils.Response> EliminarToken(Adscpassw adscpassw)
        {
            entidades.Utils.Response response = new entidades.Utils.Response();
            try
            {
                if (!string.IsNullOrEmpty(adscpassw.AdpsLogin))
                {
                    response = await apiServicio.EditarAsync <entidades.Utils.Response>(adscpassw, new Uri(WebApp.BaseAddressSeguridad), "api/Adscpassws/EliminarToken");

                    if (response.IsSuccess)
                    {
                        await GuardarLogService.SaveLogEntry(new LogEntryTranfer { ApplicationName = Convert.ToString(Aplicacion.WebAppRM), EntityID = string.Format("{0} : {1}", "Sistema", adscpassw.AdpsLogin), LogCategoryParametre = Convert.ToString(LogCategoryParameter.Edit), LogLevelShortName = Convert.ToString(LogLevelParameter.ADV), Message = "Se ha actualizado un estado civil", UserName = "******" });

                        return(response);
                    }
                }
                return(null);
            }
            catch (Exception)
            {
                await GuardarLogService.SaveLogEntry(new LogEntryTranfer { ApplicationName = Convert.ToString(Aplicacion.WebAppRM), Message = "Editando un estado civil", LogCategoryParametre = Convert.ToString(LogCategoryParameter.Edit), LogLevelShortName = Convert.ToString(LogLevelParameter.ERR), UserName = "******" });

                return(null);
            }
        }
        public async Task <IActionResult> Create(SolicitudPlanificacionVacacionesViewModel modelo)
        {
            try {
                var response = await apiServicio.EditarAsync <Response>(
                    modelo,
                    new Uri(WebApp.BaseAddress),
                    "api/SolicitudPlanificacionVacaciones/InsertarSolicitudPlanificacionVacaciones"
                    );

                if (response.IsSuccess)
                {
                    return(this.Redireccionar(
                               "SolicitarPlanificacionVacaciones",
                               "Index",
                               $"{Mensaje.Success}|{response.Message}"
                               ));
                }

                this.TempData["MensajeTimer"] = $"{Mensaje.Error}|{response.Message}|{"10000"}";

                return(View(modelo));
            }
            catch (Exception ex)
            {
                return(BadRequest());
            }
        }
Example #6
0
        public async Task <IActionResult> AprobacionSolicitudViatico(ViewModelsSolicitudViaticos viewModelsSolicitudViaticos)
        {
            try
            {
                var VerificarPresupuesto = await apiServicio.ObtenerElementoAsync1 <Response>(viewModelsSolicitudViaticos, new Uri(WebApp.BaseAddress),
                                                                                              "api/Presupuesto/ObtenerPresupuesto");

                if (VerificarPresupuesto.IsSuccess)
                {
                    var sol = new SolicitudViatico()
                    {
                        IdSolicitudViatico = viewModelsSolicitudViaticos.IdSolicitudViatico,
                        Estado             = 3
                    };

                    var respuestaEmpleado = await apiServicio.EditarAsync <Response>(sol, new Uri(WebApp.BaseAddress),
                                                                                     "api/SolicitudViaticos/ActualizarEstadoSolicitudViatico");

                    if (respuestaEmpleado.IsSuccess)
                    {
                        return(RedirectToAction("DetalleSolicitudViaticos", new { id = viewModelsSolicitudViaticos.IdEmpleado }));
                    }
                }
                return(this.RedireccionarMensajeTime("SolicitudViaticosTH", "AprobacionSolicitudViatico", new { id = viewModelsSolicitudViaticos.IdSolicitudViatico }, $"{Mensaje.Error}|{VerificarPresupuesto.Message}|{"25000"}"));
            }
            catch (Exception ex)
            {
                return(BadRequest());
            }
        }
Example #7
0
        public async Task <IActionResult> AprobacionSolicitudViatico(int id, int idEmpleado)
        {
            try
            {
                var sol = new SolicitudViatico()
                {
                    IdSolicitudViatico = id,
                    Estado             = 3
                };

                var respuestaEmpleado = await apiServicio.EditarAsync <Response>(sol, new Uri(WebApp.BaseAddress),
                                                                                 "api/SolicitudViaticos/ActualizarEstadoSolicitudViatico");

                if (respuestaEmpleado.IsSuccess)
                {
                    return(RedirectToAction("DetalleSolicitudViaticos", new { id = idEmpleado }));
                }

                return(BadRequest());
            }
            catch (Exception ex)
            {
                return(BadRequest());
            }
        }
        public async Task <IActionResult> EditConceptoConjunto(ConceptoConjuntoNomina ConceptoConjuntoNomina)
        {
            if (!ModelState.IsValid)
            {
                return(View(ConceptoConjuntoNomina));
            }
            Response response = new Response();

            try
            {
                if (ObtenerConceptoNomina().IdConcepto > 0)
                {
                    ConceptoConjuntoNomina.IdConcepto = ObtenerConceptoNomina().IdConcepto;
                    response = await apiServicio.EditarAsync <Response>(ConceptoConjuntoNomina, new Uri(WebApp.BaseAddress),
                                                                        "api/ConceptoConjuntoNomina/EditarConceptoConjuntoNomina");

                    if (response.IsSuccess)
                    {
                        return(this.Redireccionar($"{Mensaje.Informacion}|{Mensaje.Satisfactorio}", "IndexConceptoConjunto"));
                    }
                    this.TempData["Mensaje"] = $"{Mensaje.Error}|{response.Message}";
                    await CargarComboxConceptoConjunto();

                    return(View(ConceptoConjuntoNomina));
                }
                return(this.Redireccionar($"{Mensaje.Error}|{Mensaje.ErrorCargarDatos}"));
            }
            catch (Exception)
            {
                return(this.Redireccionar($"{Mensaje.Error}|{Mensaje.ErrorCargarDatos}"));
            }
        }
Example #9
0
        public async Task <IActionResult> Edit(string id, SolicitudVacaciones solicitudVacaciones)
        {
            Response response = new Response();

            try
            {
                if (!string.IsNullOrEmpty(id))
                {
                    solicitudVacaciones.FechaSolicitud = DateTime.Now;
                    response = await apiServicio.EditarAsync(id, solicitudVacaciones, new Uri(WebApp.BaseAddress),
                                                             "api/SolicitudVacaciones");

                    if (response.IsSuccess)
                    {
                        return(RedirectToAction("Index"));
                    }
                    ViewData["Error"] = response.Message;
                    //ViewData["IdBrigadaSSO"] = new Microsoft.AspNetCore.Mvc.Rendering.SelectList(await apiServicio.Listar<BrigadaSSO>(new Uri(WebApp.BaseAddress), "api/BrigadasSSO/ListarBrigadasSSO"), "IdBrigadaSSO", "Nombre");
                    return(View(solicitudVacaciones));
                }
                return(BadRequest());
            }
            catch (Exception ex)
            {
                return(BadRequest());
            }
        }
        public async Task <IActionResult> EditPlanCapacitacion(PlanCapacitacion planCapacitacion)
        {
            var respuesta = new Response();

            try
            {
                respuesta = await apiServicio.EditarAsync <Response>(planCapacitacion, new Uri(WebApp.BaseAddress),
                                                                     "api/MigracionCapacitaciones/EditarPlanCapacitacion");

                if (respuesta.IsSuccess)
                {
                    await cargarCombox();

                    var vista = JsonConvert.DeserializeObject <PlanCapacitacion>(respuesta.Resultado.ToString());
                    return(View(vista));
                }


                return(this.Redireccionar($"{Mensaje.Error}|{respuesta.Message}"));
            }
            catch (Exception)
            {
                return(this.Redireccionar($"{Mensaje.Error}|{respuesta.Message}"));
            }
        }
Example #11
0
        public async Task <IActionResult> EditReliquidacion(string id, ReliquidacionViatico reliquidacion)
        {
            Response response = new Response();

            try
            {
                if (!string.IsNullOrEmpty(id))
                {
                    response = await apiServicio.EditarAsync(id, reliquidacion, new Uri(WebApp.BaseAddress),
                                                             "api/ReliquidacionViaticos");

                    if (response.IsSuccess)
                    {
                        return(RedirectToAction("Informe", new { IdSolicitudViatico = reliquidacion.IdSolicitudViatico, IdItinerarioViatico = reliquidacion.IdItinerarioViatico }));
                    }
                    ViewData["Error"] = response.Message;
                    return(View(reliquidacion));
                }
                return(BadRequest());
            }
            catch (Exception ex)
            {
                return(BadRequest());
            }
        }
Example #12
0
        public async Task <IActionResult> EditFacilitador(string id, PreguntaEvaluacionEvento generalCapacitacion)
        {
            Response response = new Response();

            try
            {
                if (!string.IsNullOrEmpty(id))
                {
                    response = await apiServicio.EditarAsync(id, generalCapacitacion, new Uri(WebApp.BaseAddress),
                                                             "api/PreguntaEvaluacionEvento");

                    if (response.IsSuccess)
                    {
                        return(RedirectToAction("IndexFacilitador"));
                    }

                    return(View(generalCapacitacion));
                }
                return(BadRequest());
            }
            catch (Exception ex)
            {
                return(BadRequest());
            }
        }
Example #13
0
        public async Task <IActionResult> EditGastoPersonal(GastoPersonal gastoPersonal)
        {
            Response response = new Response();

            try
            {
                if (ObtenerGastoPersonal().IdEmpleado > 0)
                {
                    gastoPersonal.IdEmpleado = ObtenerGastoPersonal().IdEmpleado;
                    response = await apiServicio.EditarAsync <Response>(gastoPersonal, new Uri(WebApp.BaseAddress),
                                                                        "api/GastoPersonal/EditarGastoPersonal");

                    if (response.IsSuccess)
                    {
                        return(this.Redireccionar("GastoPersonal", "GastoPersonalIndex", new { id = ObtenerGastoPersonal().IdEmpleado }, $"{Mensaje.Informacion}|{Mensaje.Satisfactorio}"));
                    }
                    this.TempData["Mensaje"] = $"{Mensaje.Error}|{response.Message}";
                    await CargarCombox();

                    return(View(gastoPersonal));
                }
                return(this.Redireccionar($"{Mensaje.Error}|{Mensaje.ErrorCargarDatos}"));
            }
            catch (Exception)
            {
                return(this.Redireccionar($"{Mensaje.Error}|{Mensaje.ErrorCargarDatos}"));
            }
        }
Example #14
0
        public async Task <IActionResult> Edit(string id, Persona persona)
        {
            Response response = new Response();

            try
            {
                if (!string.IsNullOrEmpty(id))
                {
                    response = await apiServicio.EditarAsync(id, persona, new Uri(WebApp.BaseAddress),
                                                             "api/Personas");

                    if (response.IsSuccess)
                    {
                        return(RedirectToAction("Index"));
                    }
                    ViewData["IdGenero"] = new SelectList(await apiServicio.Listar <Genero>(new Uri(WebApp.BaseAddress), "api/Generoes/ListarGeneros"), "IdGenero", "Descripcion");
                    return(View(persona));
                }
                return(BadRequest());
            }
            catch (Exception ex)
            {
                return(BadRequest());
            }
        }
Example #15
0
        public async Task <IActionResult> Edit(TipoConjuntoNomina TipoConjuntoNomina)
        {
            if (!ModelState.IsValid)
            {
                InicializarMensaje(null);
                return(View(TipoConjuntoNomina));
            }
            Response response = new Response();

            try
            {
                if (TipoConjuntoNomina.IdTipoConjunto > 0)
                {
                    response = await apiServicio.EditarAsync <Response>(TipoConjuntoNomina, new Uri(WebApp.BaseAddress),
                                                                        "api/TipoConjuntoNomina/EditarTipoConjuntoNomina");

                    if (response.IsSuccess)
                    {
                        return(this.Redireccionar($"{Mensaje.Informacion}|{Mensaje.Satisfactorio}"));
                    }
                    this.TempData["Mensaje"] = $"{Mensaje.Error}|{response.Message}";
                    return(View(TipoConjuntoNomina));
                }
                return(this.Redireccionar($"{Mensaje.Error}|{Mensaje.ErrorEditar}"));
            }
            catch (Exception)
            {
                return(this.Redireccionar($"{Mensaje.Error}|{Mensaje.ErrorEditar}"));
            }
        }
Example #16
0
        public async Task <IActionResult> Edit(string id, DenominacionCompetencia denominacionCompetencia)
        {
            Response response = new Response();

            try
            {
                if (!string.IsNullOrEmpty(id))
                {
                    response = await apiServicio.EditarAsync(id, denominacionCompetencia, new Uri(WebApp.BaseAddress),
                                                             "api/DenominacionesCompetencias");

                    if (response.IsSuccess)
                    {
                        return(this.RedireccionarMensajeTime(
                                   "DenominacionesCompetencias",
                                   "Index",
                                   $"{Mensaje.Success}|{response.Message}|{"7000"}"
                                   ));
                    }

                    this.TempData["MensajeTimer"] = $"{Mensaje.Aviso}|{response.Message}|{"10000"}";

                    return(View(denominacionCompetencia));
                }
                return(BadRequest());
            }
            catch (Exception ex)
            {
                return(BadRequest());
            }
        }
Example #17
0
        public async Task <IActionResult> AprobarPermisos(SolicitudPermisoViewModel solicitudPermisoViewModel)
        {
            Response response = new Response();

            try
            {
                if (solicitudPermisoViewModel != null)
                {
                    response = await apiServicio.EditarAsync <SolicitudPermisoViewModel>(solicitudPermisoViewModel, new Uri(WebApp.BaseAddress), "api/SolicitudesPermisos/EditarEstadoSolicitudPermiso");


                    if (response.IsSuccess)
                    {
                        return(this.RedireccionarMensajeTime(
                                   "SolicitudesPermisosTTHH",
                                   "IndexTTHH",
                                   $"{Mensaje.Success}|{response.Message}|{"6000"}"
                                   ));
                    }

                    this.TempData["MensajeTimer"] = $"{Mensaje.Error}|{response.Message}|{"12000"}";

                    await CargarCombos();

                    return(View(solicitudPermisoViewModel));
                }
                return(BadRequest());
            }
            catch (Exception ex)
            {
                return(BadRequest());
            }
        }
Example #18
0
        public async Task <IActionResult> Edit(string id, ClaseArticulo claseArticulo)
        {
            try
            {
                if (!string.IsNullOrEmpty(id))
                {
                    var response = await apiServicio.EditarAsync(id, claseArticulo, new Uri(WebApp.BaseAddressRM), "api/ClaseArticulo");

                    if (response.IsSuccess)
                    {
                        await GuardarLogService.SaveLogEntry(new LogEntryTranfer { ApplicationName = Convert.ToString(Aplicacion.WebAppRM), EntityID = string.Format("{0} : {1}", "Clase de Artículo", id), LogCategoryParametre = Convert.ToString(LogCategoryParameter.Edit), LogLevelShortName = Convert.ToString(LogLevelParameter.ADV), Message = "Se ha actualizado un registro clase de artículo", UserName = "******" });

                        return(this.Redireccionar($"{Mensaje.Informacion}|{Mensaje.Satisfactorio}"));
                    }
                    ViewData["Error"]          = response.Message;
                    ViewData["IdTipoArticulo"] = new Microsoft.AspNetCore.Mvc.Rendering.SelectList(await apiServicio.Listar <TipoArticulo>(new Uri(WebApp.BaseAddressRM), "api/TipoArticulo/ListarTipoArticulo"), "IdTipoArticulo", "Nombre");
                    return(View(claseArticulo));
                }
                return(this.Redireccionar($"{Mensaje.Error}|{Mensaje.RegistroNoExiste}"));
            }
            catch (Exception ex)
            {
                await GuardarLogService.SaveLogEntry(new LogEntryTranfer { ApplicationName = Convert.ToString(Aplicacion.WebAppRM), Message = "Editando un clase de artículo", ExceptionTrace = ex.Message, LogCategoryParametre = Convert.ToString(LogCategoryParameter.Edit), LogLevelShortName = Convert.ToString(LogLevelParameter.ERR), UserName = "******" });

                return(this.Redireccionar($"{Mensaje.Error}|{Mensaje.ErrorEditar}"));
            }
        }
        public async Task <IActionResult> Edit(string id, MotivoTransferencia motivoTransferencia)
        {
            try
            {
                if (!string.IsNullOrEmpty(id))
                {
                    var response = await apiServicio.EditarAsync(id, motivoTransferencia, new Uri(WebApp.BaseAddressRM), "api/MotivoTransferencia");

                    if (response.IsSuccess)
                    {
                        await GuardarLogService.SaveLogEntry(new LogEntryTranfer { ApplicationName = Convert.ToString(Aplicacion.WebAppRM), EntityID = string.Format("{0} : {1}", "Sistema", id), LogCategoryParametre = Convert.ToString(LogCategoryParameter.Edit), LogLevelShortName = Convert.ToString(LogLevelParameter.ADV), Message = "Se ha actualizado un registro sistema", UserName = "******" });

                        return(this.Redireccionar($"{Mensaje.Informacion}|{Mensaje.Satisfactorio}"));
                    }
                    ViewData["Error"] = response.Message;
                    return(View(motivoTransferencia));
                }
                return(this.Redireccionar($"{Mensaje.Error}|{Mensaje.RegistroNoExiste}"));
            }
            catch (Exception ex)
            {
                await GuardarLogService.SaveLogEntry(new LogEntryTranfer { ApplicationName = Convert.ToString(Aplicacion.WebAppRM), Message = "Editando un MotivoTransferencia", ExceptionTrace = ex.Message, LogCategoryParametre = Convert.ToString(LogCategoryParameter.Edit), LogLevelShortName = Convert.ToString(LogLevelParameter.ERR), UserName = "******" });

                return(this.Redireccionar($"{Mensaje.Error}|{Mensaje.ErrorEditar}"));
            }
        }
        public async Task <IActionResult> Edit(string id, AccionPersonal accionPersonal)
        {
            Response response = new Response();

            try
            {
                if (!string.IsNullOrEmpty(id))
                {
                    response = await apiServicio.EditarAsync(id, accionPersonal, new Uri(WebApp.BaseAddress),
                                                             "api/AccionesPersonal");

                    if (response.IsSuccess)
                    {
                        return(RedirectToAction("ListarEmpleadosconAccionPersonalPendiente"));
                    }
                    ViewData["Error"] = response.Message;
                    return(View(accionPersonal));
                }
                return(BadRequest());
            }
            catch (Exception ex)
            {
                return(BadRequest());
            }
        }
        public async Task <IActionResult> Edit(TipoDeGastoPersonal TipoDeGastoPersonal)
        {
            if (!ModelState.IsValid)
            {
                return(View(TipoDeGastoPersonal));
            }
            Response response = new Response();

            try
            {
                if (TipoDeGastoPersonal.IdTipoGastoPersonal > 0)
                {
                    response = await apiServicio.EditarAsync <Response>(TipoDeGastoPersonal, new Uri(WebApp.BaseAddress),
                                                                        "api/TipoDeGastoPersonal/EditarTipoDeGastoPersonal");

                    if (response.IsSuccess)
                    {
                        return(this.Redireccionar($"{Mensaje.Informacion}|{Mensaje.Satisfactorio}"));
                    }
                    this.TempData["Mensaje"] = $"{Mensaje.Error}|{response.Message}";
                    return(View(TipoDeGastoPersonal));
                }
                return(this.Redireccionar($"{Mensaje.Error}|{Mensaje.ErrorEditar}"));
            }
            catch (Exception)
            {
                return(this.Redireccionar($"{Mensaje.Error}|{Mensaje.ErrorEditar}"));
            }
        }
Example #22
0
        public async Task <IActionResult> Edit(string id, Proveedor proveedor)
        {
            try
            {
                if (!string.IsNullOrEmpty(id))
                {
                    var response = await apiServicio.EditarAsync(id, proveedor, new Uri(WebApp.BaseAddressRM), "api/Proveedor");

                    if (response.IsSuccess)
                    {
                        await GuardarLogService.SaveLogEntry(new LogEntryTranfer { ApplicationName = Convert.ToString(Aplicacion.WebAppRM), EntityID = string.Format("{0} : {1}", "Sistema", id), LogCategoryParametre = Convert.ToString(LogCategoryParameter.Edit), LogLevelShortName = Convert.ToString(LogLevelParameter.ADV), Message = "Se ha actualizado un registro sistema", UserName = "******" });

                        return(this.Redireccionar($"{Mensaje.Informacion}|{Mensaje.Satisfactorio}"));
                    }
                    ViewData["Error"]         = response.Message;
                    ViewData["LineaServicio"] = new SelectList(await apiServicio.Listar <LineaServicio>(new Uri(WebApp.BaseAddressRM), "api/LineaServicio/ListarLineaServicio"), "IdLineaServicio", "Nombre");
                    return(View(proveedor));
                }
                return(this.Redireccionar($"{Mensaje.Error}|{Mensaje.RegistroNoExiste}"));
            }
            catch (Exception ex)
            {
                await GuardarLogService.SaveLogEntry(new LogEntryTranfer { ApplicationName = Convert.ToString(Aplicacion.WebAppRM), Message = "Editando un Proveedor", ExceptionTrace = ex.Message, LogCategoryParametre = Convert.ToString(LogCategoryParameter.Edit), LogLevelShortName = Convert.ToString(LogLevelParameter.ERR), UserName = "******" });

                return(this.Redireccionar($"{Mensaje.Error}|{Mensaje.ErrorEditar}"));
            }
        }
Example #23
0
        public async Task <IActionResult> Edit(string id, Login login)
        {
            Response response = new Response();

            try
            {
                if (!string.IsNullOrEmpty(id))
                {
                    response = await apiServicios.EditarAsync(id, login, new Uri(WebApp.BaseAddress),
                                                              "api/Logins");

                    if (response.IsSuccess)
                    {
                        return(RedirectToAction("Index"));
                    }
                    ViewBag["IdPersona"] = new SelectList(await apiServicios.Listar <Persona>(new Uri(WebApp.BaseAddress), "api/Personas/ListarPersonas"), "IdPersona", "Nombres");
                    ViewData["IdPerfil"] = new SelectList(await apiServicios.Listar <Perfil>(new Uri(WebApp.BaseAddress), "api/Perfils/ListarPerfil"), "IdPerfil", "Descripcion");
                    return(View(login));
                }
                return(BadRequest());
            }
            catch (Exception ex)
            {
                return(BadRequest());
            }
        }
        public async Task <IActionResult> Edit(string id, ComportamientoObservable comportamientoObservable)
        {
            Response response = new Response();

            try
            {
                if (!string.IsNullOrEmpty(id))
                {
                    response = await apiServicio.EditarAsync(id, comportamientoObservable, new Uri(WebApp.BaseAddress),
                                                             "api/ComportamientosObservables");

                    if (response.IsSuccess)
                    {
                        return(this.RedireccionarMensajeTime(
                                   "ComportamientosObservables",
                                   "Index",
                                   $"{Mensaje.Success}|{response.Message}|{"7000"}"
                                   ));
                    }

                    this.TempData["MensajeTimer"] = $"{Mensaje.Error}|{response.Message}|{"10000"}";

                    ViewData["IdNivel"] = new Microsoft.AspNetCore.Mvc.Rendering.SelectList(await apiServicio.Listar <Nivel>(new Uri(WebApp.BaseAddress), "api/Niveles/ListarNiveles"), "IdNivel", "Nombre");
                    ViewData["IdDenominacionCompetencia"] = new Microsoft.AspNetCore.Mvc.Rendering.SelectList(await apiServicio.Listar <DenominacionCompetencia>(new Uri(WebApp.BaseAddress), "api/DenominacionesCompetencias/ListarDenominacionesCompetencias"), "IdDenominacionCompetencia", "Nombre");
                    return(View(comportamientoObservable));
                }
                return(BadRequest());
            }
            catch (Exception ex)
            {
                return(BadRequest());
            }
        }
        public async Task <IActionResult> Edit(ViewModelPartidaFase partidasFaseViewModel)
        {
            try
            {
                var partidasFase = new PartidasFase
                {
                    IdPartidasFase = partidasFaseViewModel.IdPartidaFase,
                    Vacantes       = partidasFaseViewModel.VacantesCreadas
                };

                var response = await apiServicio.EditarAsync <Response>(
                    partidasFase,
                    new Uri(WebApp.BaseAddress),
                    "api/HabilitarConcurso/Editar"
                    );

                if (response.IsSuccess)
                {
                    return(this.RedireccionarMensajeTime(
                               "HabilitarConcursoContrato",
                               "Index",
                               $"{Mensaje.Success}|{response.Message}|{"7000"}"
                               ));
                }

                this.TempData["MensajeTimer"] = $"{Mensaje.Error}|{response.Resultado}|{"7000"}";

                return(View(partidasFaseViewModel));
            }
            catch (Exception ex)
            {
                return(BadRequest());
            }
        }
        public async Task <IActionResult> Edit(string id, CatalogoCuenta catalogoCuenta)
        {
            try
            {
                if (!string.IsNullOrEmpty(id))
                {
                    var response = await apiServicio.EditarAsync(id, catalogoCuenta, new Uri(WebApp.BaseAddressRM), "api/CatalogoCuenta");

                    if (response.IsSuccess)
                    {
                        await GuardarLogService.SaveLogEntry(new LogEntryTranfer { ApplicationName = Convert.ToString(Aplicacion.WebAppRM), EntityID = string.Format("{0} : {1}", "Catálogo de Cuenta", id), LogCategoryParametre = Convert.ToString(LogCategoryParameter.Edit), LogLevelShortName = Convert.ToString(LogLevelParameter.ADV), Message = "Se ha actualizado un registro catálogo de cuenta", UserName = "******" });

                        return(this.Redireccionar($"{Mensaje.Informacion}|{Mensaje.Satisfactorio}"));
                    }
                    ViewData["Error"] = response.Message;
                    var listaCatalogosCuenta = await apiServicio.Listar <CatalogoCuenta>(new Uri(WebApp.BaseAddressRM), "api/CatalogoCuenta/ListarCatalogosCuenta");

                    ViewData["IdCatalogoCuentaHijoVisible"] = listaCatalogosCuenta.Count > 1;
                    listaCatalogosCuenta.Insert(0, new CatalogoCuenta {
                        IdCatalogoCuentaHijo = 0, Codigo = "<< Sin selección >>"
                    });
                    ViewData["IdCatalogoCuentaHijo"] = new Microsoft.AspNetCore.Mvc.Rendering.SelectList(listaCatalogosCuenta, "IdCatalogoCuenta", "Codigo");
                    return(View(catalogoCuenta));
                }
                return(this.Redireccionar($"{Mensaje.Error}|{Mensaje.RegistroNoExiste}"));
            }
            catch (Exception ex)
            {
                await GuardarLogService.SaveLogEntry(new LogEntryTranfer { ApplicationName = Convert.ToString(Aplicacion.WebAppRM), Message = "Editando un catálogo de cuenta", ExceptionTrace = ex.Message, LogCategoryParametre = Convert.ToString(LogCategoryParameter.Edit), LogLevelShortName = Convert.ToString(LogLevelParameter.ERR), UserName = "******" });

                return(this.Redireccionar($"{Mensaje.Error}|{Mensaje.ErrorEditar}"));
            }
        }
Example #27
0
        public async Task <IActionResult> Edit(string id, Usuarios usuarios)
        {
            Response response = new Response();

            try
            {
                if (!string.IsNullOrEmpty(id))
                {
                    response = await apiServicio.EditarAsync(id, usuarios, new Uri(WebApp.BaseAddress),
                                                             "api/Usuarios");

                    if (response.IsSuccess)
                    {
                        return(RedirectToAction("Index"));
                    }
                    ViewData["IdPerfil"] = new SelectList(await apiServicio.Listar <Perfil>(new Uri(WebApp.BaseAddress), "api/Perfils/ListarPerfiles"), "IdPerfil", "Descripcion");
                    return(View(usuarios));
                }
                return(BadRequest());
            }
            catch (Exception ex)
            {
                return(BadRequest());
            }
        }
        public async Task <IActionResult> Edit(string id, Seguro seguro)
        {
            Response response = new Response();

            try
            {
                if (!string.IsNullOrEmpty(id))
                {
                    response = await apiServicios.EditarAsync(id, seguro, new Uri(WebApp.BaseAddress),
                                                              "api/Seguroes");

                    if (response.IsSuccess)
                    {
                        return(RedirectToAction("Index"));
                    }

                    ViewData["IdPoliza"]   = new SelectList(await apiServicios.Listar <Poliza>(new Uri(WebApp.BaseAddress), "api/Polizas/ListarPoliza"), "IdPoliza", "numPoliza");
                    ViewData["IdVehiculo"] = new SelectList(await apiServicios.Listar <Vehiculo>(new Uri(WebApp.BaseAddress), "api/Vehiculoes/ListarVehiculos"), "IdVehiculo", "Placa");
                    return(View(seguro));
                }
                return(BadRequest());
            }
            catch (Exception ex)
            {
                return(BadRequest());
            }
        }
Example #29
0
        public async Task <IActionResult> Edit(string id, Presupuesto presupuesto)
        {
            Response response = new Response();

            try
            {
                if (!string.IsNullOrEmpty(id))
                {
                    response = await apiServicio.EditarAsync(id, presupuesto, new Uri(WebApp.BaseAddress),
                                                             "api/Presupuesto");

                    if (response.IsSuccess)
                    {
                        return(RedirectToAction("Index"));
                    }
                    ViewData["Error"] = response.Message;
                    return(View(presupuesto));
                }
                return(BadRequest());
            }
            catch (Exception ex)
            {
                return(BadRequest());
            }
        }
        public async Task <IActionResult> EditConceptoConjunto(ConceptoConjuntoNomina ConceptoConjuntoNomina)
        {
            if (!ModelState.IsValid)
            {
                InicializarMensaje(null);
                return(View(ConceptoConjuntoNomina));
            }
            Response response = new Response();

            try
            {
                if (ConceptoConjuntoNomina.IdConjunto > 0)
                {
                    response = await apiServicio.EditarAsync <Response>(ConceptoConjuntoNomina, new Uri(WebApp.BaseAddress),
                                                                        "api/ConceptoConjuntoNomina/EditarConceptoConjuntoNomina");

                    if (response.IsSuccess)
                    {
                        return(this.Redireccionar($"{Mensaje.Satisfactorio}|{Mensaje.Satisfactorio}"));
                    }
                    ViewData["Error"] = response.Message;
                    await CargarComboxConceptoConjunto();

                    return(View(ConceptoConjuntoNomina));
                }
                return(this.Redireccionar($"{Mensaje.Error}|{Mensaje.ErrorCargarDatos}"));
            }
            catch (Exception)
            {
                return(this.Redireccionar($"{Mensaje.Error}|{Mensaje.ErrorCargarDatos}"));
            }
        }