// POST: api/BasesDatos
private async Task <MaterialInduccion> InsertarMaterialInduccion(MaterialInduccion MaterialInduccion)
{
db.MaterialInduccion.Add(MaterialInduccion);
await db.SaveChangesAsync();
return(MaterialInduccion);
}
public async Task <IActionResult> PutAccionPersonal([FromRoute] int id, [FromBody] AccionPersonal accionPersonal)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
if (id != accionPersonal.IdAccionPersonal)
{
return(BadRequest());
}
_context.Entry(accionPersonal).State = EntityState.Modified;
try
{
await _context.SaveChangesAsync();
}
catch (DbUpdateConcurrencyException)
{
if (!AccionPersonalExists(id))
{
return(NotFound());
}
else
{
throw;
}
}
return(NoContent());
}
public async Task <Response> ActualizarEstadoReliquidacion([FromBody] SolicitudViatico solicitudViatico)
{
var informeViaticoActualizar = await db.SolicitudViatico.Where(x => x.IdSolicitudViatico == solicitudViatico.IdSolicitudViatico).FirstOrDefaultAsync();
if (informeViaticoActualizar != null)
{
try
{
informeViaticoActualizar.Estado = 5;
db.SolicitudViatico.Update(informeViaticoActualizar);
await db.SaveChangesAsync();
return(new Response
{
IsSuccess = true,
Message = Mensaje.Satisfactorio,
});
}
catch (Exception ex)
{
return(new Response
{
IsSuccess = false,
Message = Mensaje.Error,
});
}
}
return(new Response
{
IsSuccess = false,
Message = Mensaje.RegistroNoEncontrado,
});
}
// POST: api/BasesDatos
private async Task <DocumentoInformacionInstitucional> InsertarDocumentoInformacionInstitucional(DocumentoInformacionInstitucional DocumentoInformacionInstitucional)
{
db.DocumentoInformacionInstitucional.Add(DocumentoInformacionInstitucional);
await db.SaveChangesAsync();
return(DocumentoInformacionInstitucional);
}
public async Task <IActionResult> PutDependencia([FromRoute] int id, [FromBody] Dependencia dependencia)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
if (id != dependencia.IdDependencia)
{
return(BadRequest());
}
db.Entry(dependencia).State = EntityState.Modified;
try
{
await db.SaveChangesAsync();
}
catch (DbUpdateConcurrencyException)
{
throw;
}
return(NoContent());
}
public async Task <Response> InsertarCandidato([FromBody] ViewModelSeleccionPersonal viewModelSeleccionPersonal)
{
try
{
var respuesta = Existe(viewModelSeleccionPersonal);
if (!respuesta.IsSuccess)
{
using (var transaction = await db.Database.BeginTransactionAsync())
{
var candidato = new Candidato
{
Identificacion = viewModelSeleccionPersonal.identificacion,
Nombre = viewModelSeleccionPersonal.nombres.ToString().ToUpper(),
Apellido = viewModelSeleccionPersonal.Apellidos.ToString().ToUpper()
};
await db.Candidato.AddAsync(candidato);
//await db.SaveChangesAsync();
var candidatoConcurso = new CandidatoConcurso
{
IdCandidato = candidato.IdCandidato,
IdPartidasFase = viewModelSeleccionPersonal.IdPartidaFase
};
await db.CandidatoConcurso.AddAsync(candidatoConcurso);
await db.SaveChangesAsync();
transaction.Commit();
viewModelSeleccionPersonal.IdCandidato = candidato.IdCandidato;
viewModelSeleccionPersonal.IdCandidatoConcurso = candidatoConcurso.IdCandidatoConcurso;
return(new Response
{
IsSuccess = true,
Resultado = viewModelSeleccionPersonal,
Message = Mensaje.GuardadoSatisfactorio
});
}
}
return(new Response
{
IsSuccess = false,
Message = Mensaje.ExisteRegistro,
});
}
catch (Exception ex)
{
return(new Response
{
IsSuccess = false,
Message = Mensaje.Error,
});
}
}
public async Task <IActionResult> PutIndiceOcupacional([FromRoute] int id, [FromBody] IndiceOcupacional indiceOcupacional)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
if (id != indiceOcupacional.IdIndiceOcupacional)
{
return(BadRequest());
}
db.Entry(indiceOcupacional).State = EntityState.Modified;
try
{
await db.SaveChangesAsync();
}
catch (DbUpdateConcurrencyException)
{
if (!IndiceOcupacionalExists(id))
{
return(NotFound());
}
else
{
throw;
}
}
return(NoContent());
}
public async Task <Response> PostTrayectoriaLaboral([FromBody] CandidatoTrayectoriaLaboral candidatoTrayectoriaLaboral)
{
try
{
var respuesta = ExisteTrayectoria(candidatoTrayectoriaLaboral);
if (!respuesta.IsSuccess)
{
db.CandidatoTrayectoriaLaboral.Add(candidatoTrayectoriaLaboral);
await db.SaveChangesAsync();
return(new Response
{
IsSuccess = true,
Message = Mensaje.Satisfactorio
});
}
return(new Response
{
IsSuccess = false,
Message = Mensaje.ExisteRegistro,
});
}
catch (Exception ex)
{
return(new Response
{
IsSuccess = false,
Message = Mensaje.Error,
});
}
}
public async Task <IActionResult> PutEjemplo([FromRoute] int id, [FromBody] Ejemplo ejemplo)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
if (id != ejemplo.Id)
{
return(BadRequest());
}
db.Entry(ejemplo).State = EntityState.Modified;
try
{
await db.SaveChangesAsync();
}
catch (DbUpdateConcurrencyException)
{
if (!EjemploExists(id))
{
return(NotFound());
}
else
{
throw;
}
}
return(NoContent());
}
public async Task <Response> PutTrayectoriaLaboral([FromRoute] int id, [FromBody] TrayectoriaLaboral trayectoriaLaboral)
{
try
{
if (!ModelState.IsValid)
{
return(new Response
{
IsSuccess = false,
Message = Mensaje.ModeloInvalido
});
}
var existe = Existe(trayectoriaLaboral);
var TrayectoriaLaboralActualizar = (TrayectoriaLaboral)existe.Resultado;
if (existe.IsSuccess && TrayectoriaLaboralActualizar.IdTrayectoriaLaboral != id)
{
return(new Response
{
IsSuccess = false,
Message = Mensaje.ExisteRegistro,
});
}
var TrayectoriaLaboral = await db.TrayectoriaLaboral.Where(x => x.IdTrayectoriaLaboral == trayectoriaLaboral.IdTrayectoriaLaboral).FirstOrDefaultAsync();
TrayectoriaLaboral.IdPersona = trayectoriaLaboral.IdPersona;
TrayectoriaLaboral.FechaInicio = trayectoriaLaboral.FechaInicio;
TrayectoriaLaboral.FechaFin = trayectoriaLaboral.FechaFin;
TrayectoriaLaboral.Empresa = trayectoriaLaboral.Empresa.ToString().ToUpper();
TrayectoriaLaboral.PuestoTrabajo = trayectoriaLaboral.PuestoTrabajo.ToString().ToUpper();
TrayectoriaLaboral.DescripcionFunciones = trayectoriaLaboral.DescripcionFunciones != null?
trayectoriaLaboral.DescripcionFunciones.ToString().ToUpper() : null;
TrayectoriaLaboral.AreaAsignada = trayectoriaLaboral.AreaAsignada.ToString().ToUpper();
TrayectoriaLaboral.FormaIngreso = trayectoriaLaboral.FormaIngreso.ToString().ToUpper();
TrayectoriaLaboral.MotivoSalida = (trayectoriaLaboral.MotivoSalida != null)?trayectoriaLaboral.MotivoSalida.ToString().ToUpper():null;
TrayectoriaLaboral.TipoInstitucion = trayectoriaLaboral.TipoInstitucion.ToString().ToUpper();
await db.SaveChangesAsync();
return(new Response
{
IsSuccess = true,
Message = Mensaje.Satisfactorio,
});
}
catch (Exception ex)
{
return(new Response
{
IsSuccess = true,
Message = Mensaje.Excepcion,
});
}
}
public async Task <Response> PutPersonaDiscapacidad([FromRoute] int id, [FromBody] PersonaDiscapacidad personaDiscapacidad)
{
try
{
if (!ModelState.IsValid)
{
return(new Response
{
IsSuccess = false,
Message = Mensaje.ModeloInvalido
});
}
var existe = Existe(personaDiscapacidad);
var PersonaDiscapacidadActualizar = (PersonaDiscapacidad)existe.Resultado;
if (existe.IsSuccess)
{
return(new Response
{
IsSuccess = false,
Message = Mensaje.ExisteRegistro,
});
}
var PersonaDiscapacidadAct = await db.PersonaDiscapacidad.Where(x => x.IdPersonaDiscapacidad == personaDiscapacidad.IdPersonaDiscapacidad).FirstOrDefaultAsync();
PersonaDiscapacidadAct.IdTipoDiscapacidad = personaDiscapacidad.IdTipoDiscapacidad;
PersonaDiscapacidadAct.IdPersona = personaDiscapacidad.IdPersona;
PersonaDiscapacidadAct.NumeroCarnet = personaDiscapacidad.NumeroCarnet;
PersonaDiscapacidadAct.Porciento = personaDiscapacidad.Porciento;
await db.SaveChangesAsync();
return(new Response
{
IsSuccess = true,
Message = Mensaje.Satisfactorio,
});
}
catch (Exception ex)
{
await GuardarLogService.SaveLogEntry(new LogEntryTranfer
{
ApplicationName = Convert.ToString(Aplicacion.SwTH),
ExceptionTrace = ex.Message,
Message = Mensaje.Excepcion,
LogCategoryParametre = Convert.ToString(LogCategoryParameter.Critical),
LogLevelShortName = Convert.ToString(LogLevelParameter.ERR),
UserName = "",
});
return(new Response
{
IsSuccess = true,
Message = Mensaje.Excepcion,
});
}
}
private async Task Actualizar(Rubro Rubro)
{
var rubro = db.Rubro.Find(Rubro.IdRubro);
rubro.Nombre = Rubro.Nombre;
rubro.TasaPorcentualMaxima = Rubro.TasaPorcentualMaxima;
db.Rubro.Update(rubro);
await db.SaveChangesAsync();
}
private async Task Actualizar(Relevancia Relevancia)
{
var relevancia = db.Relevancia.Find(Relevancia.IdRelevancia);
relevancia.Nombre = Relevancia.Nombre;
relevancia.ComportamientoObservable = Relevancia.ComportamientoObservable;
db.Relevancia.Update(relevancia);
await db.SaveChangesAsync();
}
private async Task Actualizar(ManualPuesto ManualPuesto)
{
var manualpuesto = db.ManualPuesto.Find(ManualPuesto.IdManualPuesto);
manualpuesto.Nombre = ManualPuesto.Nombre;
manualpuesto.Descripcion = ManualPuesto.Descripcion;
db.ManualPuesto.Update(manualpuesto);
await db.SaveChangesAsync();
}
private async Task Actualizar(TipoConcurso TipoConcurso)
{
var tipoconcurso = db.TipoConcurso.Find(TipoConcurso.IdTipoConcurso);
tipoconcurso.Nombre = TipoConcurso.Nombre;
tipoconcurso.Descripcion = TipoConcurso.Descripcion;
db.TipoConcurso.Update(tipoconcurso);
await db.SaveChangesAsync();
}
private async Task Actualizar(PaquetesInformaticos PaquetesInformaticos)
{
var paqueteinformatico = db.PaquetesInformaticos.Find(PaquetesInformaticos.IdPaquetesInformaticos);
paqueteinformatico.Nombre = PaquetesInformaticos.Nombre;
paqueteinformatico.Descripcion = PaquetesInformaticos.Descripcion;
db.PaquetesInformaticos.Update(paqueteinformatico);
await db.SaveChangesAsync();
}
private async Task Actualizar(InstitucionFinanciera InstitucionFinanciera)
{
var institucionfinanciera = db.InstitucionFinanciera.Find(InstitucionFinanciera.IdInstitucionFinanciera);
institucionfinanciera.Nombre = InstitucionFinanciera.Nombre;
institucionfinanciera.SPI = InstitucionFinanciera.SPI;
db.InstitucionFinanciera.Update(institucionfinanciera);
await db.SaveChangesAsync();
}
private async Task Actualizar(EscalaGrados escalaGrados)
{
var escalaevatotal = db.EscalaGrados.Find(escalaGrados.IdEscalaGrados);
escalaevatotal.IdGrupoOcupacional = escalaGrados.IdGrupoOcupacional;
escalaevatotal.Grado = escalaGrados.Grado;
escalaevatotal.Remuneracion = escalaGrados.Remuneracion;
db.EscalaGrados.Update(escalaevatotal);
await db.SaveChangesAsync();
}
private async Task Actualizar(ConfiguracionViatico configuracionViatico)
{
var escalaevatotal = db.ConfiguracionViatico.Find(configuracionViatico.IdConfiguracionViatico);
escalaevatotal.IdDependencia = configuracionViatico.IdDependencia;
escalaevatotal.ValorEntregadoPorDia = configuracionViatico.ValorEntregadoPorDia;
escalaevatotal.PorCientoAJustificar = configuracionViatico.PorCientoAJustificar;
db.ConfiguracionViatico.Update(escalaevatotal);
await db.SaveChangesAsync();
}
private async Task Actualizar(EvaluacionInducion evaluacionInducion)
{
var escalaevatotal = db.EvaluacionInducion.Find(evaluacionInducion.IdEvaluacionInduccion);
escalaevatotal.MinimoAprobar = evaluacionInducion.MinimoAprobar;
escalaevatotal.MaximoPuntos = evaluacionInducion.MaximoPuntos;
escalaevatotal.Nombre = evaluacionInducion.Nombre;
db.EvaluacionInducion.Update(escalaevatotal);
await db.SaveChangesAsync();
}
private async Task Actualizar(DenominacionCompetencia DenominacionCompetencia)
{
var capacitacionac = db.DenominacionCompetencia.Find(DenominacionCompetencia.IdDenominacionCompetencia);
capacitacionac.CompetenciaTecnica = DenominacionCompetencia.CompetenciaTecnica;
capacitacionac.Definicion = DenominacionCompetencia.Definicion;
capacitacionac.Nombre = DenominacionCompetencia.Nombre;
db.DenominacionCompetencia.Update(capacitacionac);
await db.SaveChangesAsync();
}
public async Task <Response> PutDatosBancarios([FromRoute] int id, [FromBody] DatosBancarios datosBancarios)
{
try
{
if (!ModelState.IsValid)
{
return(new Response
{
IsSuccess = false,
Message = Mensaje.ModeloInvalido
});
}
var existe = Existe(datosBancarios);
var DatosBancariosActualizar = (DatosBancarios)existe.Resultado;
if (existe.IsSuccess)
{
return(new Response
{
IsSuccess = false,
Message = Mensaje.ExisteRegistro,
});
}
var datosBancariosActualizar = await db.DatosBancarios.Where(x => x.IdDatosBancarios == datosBancarios.IdDatosBancarios).FirstOrDefaultAsync();
datosBancariosActualizar.IdInstitucionFinanciera = datosBancarios.IdInstitucionFinanciera;
datosBancariosActualizar.NumeroCuenta = datosBancarios.NumeroCuenta;
datosBancariosActualizar.Ahorros = datosBancarios.Ahorros;
await db.SaveChangesAsync();
return(new Response
{
IsSuccess = true,
Message = Mensaje.Satisfactorio,
});
}
catch (Exception ex)
{
await GuardarLogService.SaveLogEntry(new LogEntryTranfer
{
ApplicationName = Convert.ToString(Aplicacion.SwTH),
ExceptionTrace = ex.Message,
Message = Mensaje.Excepcion,
LogCategoryParametre = Convert.ToString(LogCategoryParameter.Critical),
LogLevelShortName = Convert.ToString(LogLevelParameter.ERR),
UserName = "",
});
return(new Response
{
IsSuccess = true,
Message = Mensaje.Excepcion,
});
}
}
private async Task Actualizar(EscalaEvaluacionTotal escalaEvaluacionTotal)
{
var escalaevatotal = db.EscalaEvaluacionTotal.Find(escalaEvaluacionTotal.IdEscalaEvaluacionTotal);
escalaevatotal.Name = escalaEvaluacionTotal.Name;
escalaevatotal.Descripcion = escalaEvaluacionTotal.Descripcion;
escalaevatotal.PorcientoDesde = escalaEvaluacionTotal.PorcientoDesde;
escalaevatotal.PorcientoHasta = escalaEvaluacionTotal.PorcientoHasta;
db.EscalaEvaluacionTotal.Update(escalaevatotal);
await db.SaveChangesAsync();
}
private async Task Actualizar(ImpuestoRentaParametros ImpuestoRentaParametros)
{
var impuestorentaparametros = db.ImpuestoRentaParametros.Find(ImpuestoRentaParametros.IdImpuestoRentaParametros);
impuestorentaparametros.ExcesoHasta = ImpuestoRentaParametros.ExcesoHasta;
impuestorentaparametros.FraccionBasica = ImpuestoRentaParametros.FraccionBasica;
impuestorentaparametros.ImpuestoFraccionBasica = ImpuestoRentaParametros.ImpuestoFraccionBasica;
impuestorentaparametros.PorcentajeImpuestoFraccionExcedente = ImpuestoRentaParametros.PorcentajeImpuestoFraccionExcedente;
db.ImpuestoRentaParametros.Update(impuestorentaparametros);
await db.SaveChangesAsync();
}
public async Task <Response> EliminarIndiceOcupacionalComportamiemtoObservable([FromBody] IndiceOcupacionalComportamientoObservable indiceOcupacionalComportamientoObservable)
{
try
{
if (!ModelState.IsValid)
{
return(new Response
{
IsSuccess = false,
Message = Mensaje.ModeloInvalido,
});
}
var respuesta = await db.IndiceOcupacionalComportamientoObservable.SingleOrDefaultAsync(m => m.IdComportamientoObservable == indiceOcupacionalComportamientoObservable.IdComportamientoObservable &&
m.IdIndiceOcupacional == indiceOcupacionalComportamientoObservable.IdIndiceOcupacional);
if (respuesta == null)
{
return(new Response
{
IsSuccess = false,
Message = Mensaje.RegistroNoEncontrado,
});
}
db.IndiceOcupacionalComportamientoObservable.Remove(respuesta);
await db.SaveChangesAsync();
return(new Response
{
IsSuccess = true,
Message = Mensaje.Satisfactorio,
});
}
catch (Exception ex)
{
await GuardarLogService.SaveLogEntry(new LogEntryTranfer
{
ApplicationName = Convert.ToString(Aplicacion.SwTH),
ExceptionTrace = ex.Message,
Message = Mensaje.Excepcion,
LogCategoryParametre = Convert.ToString(LogCategoryParameter.Critical),
LogLevelShortName = Convert.ToString(LogLevelParameter.ERR),
UserName = "",
});
return(new Response
{
IsSuccess = false,
Message = Mensaje.Error,
});
}
}
public async Task <Response> InsertarActividadesGestionCambio([FromBody] ActividadesGestionCambioViewModel actividadesGestionCambioViewModel)
{
try {
if (!ModelState.IsValid)
{
return(new Response
{
IsSuccess = false,
Message = Mensaje.ModeloInvalido,
});
}
var modelo = new ActividadesGestionCambio {
IdDependencia = actividadesGestionCambioViewModel.IdDependencia,
IdEmpleado = actividadesGestionCambioViewModel.IdEmpleado,
Avance = actividadesGestionCambioViewModel.Avance,
EstadoActividadesGestionCambio = actividadesGestionCambioViewModel.ValorEstado,
Tarea = actividadesGestionCambioViewModel.Tarea,
FechaInicio = actividadesGestionCambioViewModel.FechaInicio,
FechaFin = actividadesGestionCambioViewModel.FechaFin,
Observaciones = (String.IsNullOrEmpty(actividadesGestionCambioViewModel.Observaciones)) ? "" : actividadesGestionCambioViewModel.Observaciones
};
if (Existe(modelo).Result.IsSuccess)
{
return(new Response {
IsSuccess = false,
Message = Mensaje.ExisteRegistro
});
}
db.ActividadesGestionCambio.Add(modelo);
await db.SaveChangesAsync();
return(new Response
{
IsSuccess = true,
Message = Mensaje.GuardadoSatisfactorio
});
}
catch (Exception ex)
{
return(new Response {
IsSuccess = false,
Message = Mensaje.Excepcion
});
}
}
public async Task <Response> PostRolPuesto([FromBody] RolPuesto rolPuesto)
{
try
{
if (!ModelState.IsValid)
{
return(new Response
{
IsSuccess = false,
Message = Mensaje.ModeloInvalido
});
}
var respuesta = Existe(rolPuesto);
if (!respuesta.IsSuccess)
{
db.RolPuesto.Add(rolPuesto);
await db.SaveChangesAsync();
return(new Response
{
IsSuccess = true,
Message = Mensaje.Satisfactorio
});
}
return(new Response
{
IsSuccess = false,
Message = Mensaje.ExisteRegistro
});
}
catch (Exception ex)
{
await GuardarLogService.SaveLogEntry(new LogEntryTranfer
{
ApplicationName = Convert.ToString(Aplicacion.SwTH),
ExceptionTrace = ex.Message,
Message = Mensaje.Excepcion,
LogCategoryParametre = Convert.ToString(LogCategoryParameter.Critical),
LogLevelShortName = Convert.ToString(LogLevelParameter.ERR),
UserName = "",
});
return(new Response
{
IsSuccess = false,
Message = Mensaje.Error,
});
}
}
public async Task <Response> InsertarVacacionesrelacionesLaborales([FromBody] VacacionRelacionLaboral vacacionRelacionLaboral)
{
try
{
if (!ModelState.IsValid)
{
return(new Response
{
IsSuccess = false,
Message = Mensaje.ModeloInvalido
});
}
var existe = await Existe(vacacionRelacionLaboral);
if (existe.IsSuccess == true)
{
return(new Response
{
IsSuccess = false,
Message = Mensaje.ExisteVacacionRelacionLaboral
});
}
if (existe.IsSuccess == false && Convert.ToInt32(existe.Resultado) == 0)
{
db.VacacionRelacionLaboral.Add(vacacionRelacionLaboral);
await db.SaveChangesAsync();
return(new Response {
IsSuccess = true,
Message = Mensaje.GuardadoSatisfactorio
});
}
else
{
return(existe);
}
}
catch (Exception ex)
{
return(new Response {
IsSuccess = false,
Message = Mensaje.Excepcion
});
}
}
public async Task <Response> PutPersonaEnfermedad([FromRoute] int id, [FromBody] PersonaEnfermedad PersonaEnfermedad)
{
try
{
if (!ModelState.IsValid)
{
return(new Response
{
IsSuccess = false,
Message = Mensaje.ModeloInvalido
});
}
var existe = Existe(PersonaEnfermedad);
var PersonaEnfermedadActualizar = (PersonaEnfermedad)existe.Resultado;
if (
existe.IsSuccess &&
PersonaEnfermedadActualizar.IdPersonaEnfermedad != PersonaEnfermedad.IdPersonaEnfermedad
)
{
return(new Response
{
IsSuccess = false,
Message = Mensaje.ExisteRegistro,
});
}
var PersonaEnfermedadAct = await db.PersonaEnfermedad.Where(x => x.IdPersonaEnfermedad == PersonaEnfermedad.IdPersonaEnfermedad).FirstOrDefaultAsync();
PersonaEnfermedadAct.IdTipoEnfermedad = PersonaEnfermedad.IdTipoEnfermedad;
PersonaEnfermedadAct.IdPersona = PersonaEnfermedad.IdPersona;
PersonaEnfermedadAct.InstitucionEmite = PersonaEnfermedad.InstitucionEmite.ToString().ToUpper();
await db.SaveChangesAsync();
return(new Response
{
IsSuccess = true,
Message = Mensaje.GuardadoSatisfactorio,
});
}
catch (Exception ex)
{
return(new Response
{
IsSuccess = true,
Message = Mensaje.Excepcion,
});
}
}
public async Task <Response> EditarPeriodoNomina([FromBody] PeriodoNomina PeriodoNomina)
{
try
{
if (await Existe(PeriodoNomina))
{
return(new Response
{
IsSuccess = false,
Message = Mensaje.ExisteRegistro,
});
}
var PeriodoNominaActualizar = await db.PeriodoNomina.Where(x => x.IdPeriodo == PeriodoNomina.IdPeriodo).FirstOrDefaultAsync();
if (PeriodoNominaActualizar == null)
{
return(new Response
{
IsSuccess = false,
});
}
PeriodoNominaActualizar.Estado = PeriodoNomina.Estado;
PeriodoNominaActualizar.Mes = PeriodoNomina.Mes;
PeriodoNominaActualizar.Ano = PeriodoNomina.Ano;
PeriodoNominaActualizar.FechaInicio = PeriodoNomina.FechaInicio;
PeriodoNominaActualizar.FechaFin = PeriodoNomina.FechaFin;
PeriodoNominaActualizar.Descripcion = PeriodoNomina.Descripcion;
PeriodoNominaActualizar.Abierto = PeriodoNomina.Abierto;
db.PeriodoNomina.Update(PeriodoNominaActualizar);
await db.SaveChangesAsync();
return(new Response
{
IsSuccess = true,
Resultado = PeriodoNominaActualizar
});
}
catch (Exception)
{
return(new Response
{
IsSuccess = false,
Message = Mensaje.Excepcion
});
}
}
