public async Task Update(PersonalProyecto model)
{
try
{
string origen = ConfigurationManager.AppSettings["OrigenDatos"];
model.Origen = origen;
var _model = await _db.dbSetPersonalProyectos.FirstOrDefaultAsync(e => e.PersonalProyectoId == model.PersonalProyectoId);
if (_model != null)
{
_db.Entry(_model).CurrentValues.SetValues(model);
await _db.SaveChangesAsync();
if (model.EstadoFlujoId == 3 && model.Participacion.Equals("Jefe de Proyecto"))
{
Proyecto proyecto = await _db.dbSetProyectoGEN.FirstOrDefaultAsync(e => e.ProyectoId == model.ProyectoId);
Personas persona = await _db.dbSetPersonas.FirstOrDefaultAsync(e => e.ClavePersona == model.ClavePersona);
if (proyecto != null)
{
proyecto.NumjefeProyecto = model.ClavePersona;
proyecto.NombreJefeProyecto = persona.NombreCompleto;
_db.Entry(proyecto).CurrentValues.SetValues(proyecto);
await _db.SaveChangesAsync();
}
}
}
}
catch (Exception e)
{
throw new Exception(e.Message, e);
}
}
public async Task UpdateStadoOrCreate(LikesLinked model)
{
try
{
var _model = await _db.bdSetLikesLinked.FirstOrDefaultAsync(
e => e.Aprobador.Equals(model.Aprobador) && e.Empleado.Equals(model.Empleado) &&
e.IdExteno.Equals(model.IdExteno) && e.Tipo == 1);
if (_model != null)
{
model.Id = _model.Id;
_db.Entry(_model).CurrentValues.SetValues(model);
await _db.SaveChangesAsync();
}
else
{
await this.Create(model);
}
}
catch (Exception e)
{
throw new Exception(e.Message, e);
}
}
public async Task Update(Roles model)
{
try
{
var resultados = await _db.Database.SqlQuery <String>("SELECT Descripcion FROM GEN.cat_Roles where Descripcion collate Latin1_General_CI_AI = '" + model.Descripcion + "'").CountAsync();
if (resultados > 0)
{
throw new Exception("El rol que desea modificar ya existe");
}
else
{
var _model = await _db.dbSetRoles.FirstOrDefaultAsync(e => e.RolId == model.RolId);
if (_model != null)
{
_db.Entry(_model).CurrentValues.SetValues(model);
await _db.SaveChangesAsync();
}
}
}
catch (Exception e)
{
throw new Exception(e.Message, e);
}
}
public async Task AsignarIniciativa(Iniciativas iniciativa)
{
try
{
var _iniciativaEmpresa = await _ctx.dbSetIniciativa
.FirstOrDefaultAsync(c => c.FolioId == iniciativa.FolioId);
if (_iniciativaEmpresa != null)
{
_ctx.Entry(_iniciativaEmpresa).CurrentValues.SetValues(iniciativa);
await _ctx.SaveChangesAsync();
}
}
catch (Exception e)
{
throw new Exception(e.Message, e);
}
}
public async Task AsignarPropuesta(Propuestas propuestas)
{
try
{
var _propuestaEmpresa = await _ctx.dbSetPropuesta
.FirstOrDefaultAsync(c => c.PropuestaId == propuestas.PropuestaId);
if (_propuestaEmpresa != null)
{
_ctx.Entry(_propuestaEmpresa).CurrentValues.SetValues(propuestas);
await _ctx.SaveChangesAsync();
}
}
catch (Exception e)
{
throw new Exception(e.Message, e);
}
}
public async Task AsignarProyecto(Proyecto proyecto)
{
try
{
var _proyectoEmpresa = await _dbGen.dbSetProyectoGEN
.FirstOrDefaultAsync(c => c.ProyectoId == proyecto.ProyectoId);
if (_proyectoEmpresa != null)
{
_dbGen.Entry(_proyectoEmpresa).CurrentValues.SetValues(proyecto);
await _dbGen.SaveChangesAsync();
}
}
catch (Exception e)
{
throw new Exception(e.Message, e);
}
}
public async Task Update(MovimientoCategoria model)
{
try
{
var _model = await _db.bdSetMovimientoCategoria.FirstOrDefaultAsync(e => e.Id == model.Id);
if (_model != null)
{
_db.Entry(_model).CurrentValues.SetValues(model);
await _db.SaveChangesAsync();
}
}
catch (Exception e)
{
throw new Exception(e.Message, e);
}
}
public async Task Update(Plaza model)
{
try
{
var _model = await _db.dbSetPlaza.FirstOrDefaultAsync(e => e.PlazaId == model.PlazaId);
if (_model != null)
{
_db.Entry(_model).CurrentValues.SetValues(model);
await _db.SaveChangesAsync();
}
}
catch (Exception e)
{
throw new Exception(e.Message, e);
}
}
//public async Task Create(CorreoTemplate model)
//{
// try
// {
// dbGEN.bdSetCorreoTemplate.Add(model);
// await dbGEN.SaveChangesAsync();
// }
// catch (Exception e)
// {
// throw new Exception(e.Message, e);
// }
//}
public async Task Update(CorreoTemplate model)
{
try
{
var _model = await dbGEN.bdSetCorreoTemplate.FirstOrDefaultAsync(e => e.Id == model.Id);
if (_model != null)
{
dbGEN.Entry(_model).CurrentValues.SetValues(model);
await dbGEN.SaveChangesAsync();
}
}
catch (Exception e)
{
throw new Exception(e.Message, e);
}
}
public async Task Update(UnidadOrganizacional model)
{
try
{
var _model = await _db.dbSetUnidadOrganizacional.FirstOrDefaultAsync(e => e.ClaveUnidad == model.ClaveUnidad);
if (_model != null)
{
_db.Entry(_model).CurrentValues.SetValues(model);
await _db.SaveChangesAsync();
}
}
catch (Exception e)
{
throw new Exception(e.Message, e);
}
}
public async Task Update(AccesoModulos model)
{
try
{
var _model = await _db.bdSetAccesoModulos.FirstOrDefaultAsync(e => e.id == model.id);
if (_model != null)
{
_db.Entry(_model).CurrentValues.SetValues(model);
await _db.SaveChangesAsync();
}
}
catch (Exception e)
{
throw new Exception(e.Message, e);
}
}
public async Task Update(TipoUnidad model)
{
try
{
var _model = await _db.dbSetTipoUnidad.FirstOrDefaultAsync(e => e.TipoUnidadID == model.TipoUnidadID);
if (_model != null)
{
_db.Entry(_model).CurrentValues.SetValues(model);
await _db.SaveChangesAsync();
}
}
catch (Exception e)
{
throw new Exception(e.Message, e);
}
}
public async Task Update(OCSuscripciones model)
{
try
{
var _model = await _db.dbSetOCSuscripciones.FirstOrDefaultAsync(
e =>
e.ClaveEmpleado == model.ClaveEmpleado &&
e.OcsId == model.OcsId);
if (_model != null)
{
_db.Entry(_model).CurrentValues.SetValues(model);
await _db.SaveChangesAsync();
}
}
catch (Exception e)
{
throw new Exception(e.Message, e);
}
}
public async Task <int> Desactivar(RecuperaPassword recup)
{
try
{
var rp = await _db.RecuperaPassword
.Where(e => e.RecuperaPasswordId == recup.RecuperaPasswordId)
.FirstOrDefaultAsync();
if (rp != null)
{
recup.Activo = 0;
_db.Entry(rp).CurrentValues.SetValues(recup);
await _db.SaveChangesAsync();
}
return(rp.RecuperaPasswordId);
}
catch (Exception e)
{
throw new Exception(e.Message, e);
}
}
public async Task UpdateContacto(Contacto contacto)
{
try
{
var _model = await _db.Contacto
.Include(x => x.Adjunto)
.FirstOrDefaultAsync(e => e.ContactoId == contacto.ContactoId);
if (_model != null)
{
var empresaAnterior = _model.EmpresaId;
var unidadAnterior = _model.ClaveUnidad;
var puesto = _model.Puesto;
//Actualizacion de adjuntos
if (contacto.Adjunto != null)
{
if (_model.Adjunto != null && _model.Adjunto.AdjuntoId > 0)
{
contacto.Adjunto.AdjuntoId = _model.Adjunto.AdjuntoId;
}
if (contacto.Adjunto.AdjuntoId < 1)//nuevo adjunto
{
try
{
_dbGen.dbSetAdjuntos.Add(contacto.Adjunto);
await _dbGen.SaveChangesAsync();
contacto.AdjuntoId = contacto.Adjunto.AdjuntoId;
}
catch (Exception e)
{
throw new Exception(e.Message, e);
}
}
else
{ //actualizar adjunto
var anteriorAdjunto = await _dbGen.dbSetAdjuntos.FirstOrDefaultAsync(e => e.AdjuntoId == contacto.Adjunto.AdjuntoId);
if (anteriorAdjunto != null)
{
_dbGen.Entry(anteriorAdjunto).CurrentValues.SetValues(contacto.Adjunto);
await _dbGen.SaveChangesAsync();
}
}
}
//En caso de que haya un cambio de puesto en el contacto ....
if (empresaAnterior != contacto.EmpresaId || unidadAnterior != contacto.ClaveUnidad || puesto != contacto.Puesto)
{
//Actualiza el ultimo puesto del contacto
await new ContactoPuestoHistoricoRepository().ActualizaUltimoPuestoContacto(Convert.ToInt32(_model.ContactoId), _model.EmpresaId);
//Crea un nuevo puesto en su historial
//ContactoPuestoHistorico nuevoPuesto = new ContactoPuestoHistorico();
//nuevoPuesto.ContactoId = Convert.ToInt32(_model.ContactoId);
//nuevoPuesto.EmpresaId = contacto.EmpresaId;
//nuevoPuesto.Puesto = contacto.Puesto;
//nuevoPuesto.FechaInicio = DateTime.Today;
//nuevoPuesto.ClaveUnidad = contacto.ClaveUnidad;
await new ContactoPuestoHistoricoRepository().ModificaPuestoContacto(Convert.ToInt32(_model.ContactoId), contacto.EmpresaId, contacto.ClaveUnidad, contacto.Puesto, "agregar");
//await new ContactoPuestoHistoricoRepository().Create(nuevoPuesto);
}
_db.Entry(_model).CurrentValues.SetValues(contacto);
await _db.SaveChangesAsync();
}
}
catch (Exception e)
{
throw new Exception(e.Message, e);
}
}
public async Task Update(BecarioExterno model)
{
try
{
var _model = await _db.BecarioExterno
.FirstOrDefaultAsync(e => e.BecarioExternoId == model.BecarioExternoId);
if (model.EstadoFlujoId == 1 && _model.EstadoFlujoId == 3)
{
await new NuevoOCRepository().DeleteId("BecarioExterno", _model.BecarioExternoId + "");
}
if (_model != null)
{
foreach (var adjuntoBecarioExterno in model.AdjuntoBecarioExterno)
{
if (adjuntoBecarioExterno.Adjunto != null)
{
try
{
if (adjuntoBecarioExterno.Adjunto.AdjuntoId < 1) //NUEVO ADJUNTO
{
_dbGen.dbSetAdjuntos.Add(adjuntoBecarioExterno.Adjunto);
await _dbGen.SaveChangesAsync(); //guardar el adjunto
adjuntoBecarioExterno.AdjuntoId = adjuntoBecarioExterno.Adjunto.AdjuntoId;
adjuntoBecarioExterno.BecarioExternoId = model.BecarioExternoId;
//guardar nuevo adjuntoBecarioExterno
_db.AdjuntoBecarioExterno.Add(adjuntoBecarioExterno);
await _db.SaveChangesAsync(); //guardar el adjunto
_dbGen = new GEN_Context();
}
else //adjunto existente: actualizar el adjunto
{
if (adjuntoBecarioExterno.Adjunto.nombre.Equals("eliminar"))
{
var _adjuntoBe = await _db.AdjuntoBecarioExterno.FirstOrDefaultAsync(e => e.AdjuntoId == adjuntoBecarioExterno.Adjunto.AdjuntoId);
if (_adjuntoBe != null)
{
_db.AdjuntoBecarioExterno.Remove(_adjuntoBe);
await _db.SaveChangesAsync();
}
}
else
{
var _modelAdjunto = await _dbGen.dbSetAdjuntos.FirstOrDefaultAsync(e => e.AdjuntoId == adjuntoBecarioExterno.Adjunto.AdjuntoId);
_dbGen.Entry(_modelAdjunto).CurrentValues.SetValues(adjuntoBecarioExterno.Adjunto);
await _dbGen.SaveChangesAsync();
}
//if (model.EstadoFlujoId == 3)
//{
// await new NuevoOCRepository().Create(
// new NuevoOC("CH",
// "IBE",
// model.Titulo,
// "indexMT.html#/InformeBecariooDetails/" + model.BecarioExternoId
// ));
//}
}
}
catch (Exception e)
{
throw new Exception(e.Message, e);
}
}
}
_db.Entry(_model).CurrentValues.SetValues(model);
await _db.SaveChangesAsync();
PersonasRepository prep = new PersonasRepository();
Personas p = await prep.GetByClave(model.Asesor_ClavePersona);
p.ultimaActualizacion = DateTime.Now;
await prep.Update(p);
}
}
catch (Exception e)
{
throw new Exception(e.Message, e);
}
}
public async Task UpdateEmpresa(Empresa empresa)
{
try
{
var _model = await _db.Empresa
.Include(x => x.Adjunto)
.FirstOrDefaultAsync(e => e.EmpresaId == empresa.EmpresaId);
if (_model != null)
{
string viejoNombre = _model.NombreEmpresa;
var contactoId = _model.ContactoId;
if (empresa.Adjunto != null)
{
if (_model.Adjunto != null && _model.Adjunto.AdjuntoId > 0)
{
empresa.Adjunto.AdjuntoId = _model.Adjunto.AdjuntoId;
}
if (empresa.Adjunto.AdjuntoId < 1)//nuevo adjunto
{
try
{
_dbGen.dbSetAdjuntos.Add(empresa.Adjunto);
await _dbGen.SaveChangesAsync();
empresa.AdjuntoId = empresa.Adjunto.AdjuntoId;
}
catch (Exception e)
{
throw new Exception(e.Message, e);
}
}
else
{ //actualizar adjunto
var anteriorAdjunto = await _dbGen.dbSetAdjuntos.FirstOrDefaultAsync(e => e.AdjuntoId == empresa.Adjunto.AdjuntoId);
if (anteriorAdjunto != null)
{
_dbGen.Entry(anteriorAdjunto).CurrentValues.SetValues(empresa.Adjunto);
await _dbGen.SaveChangesAsync();
}
}
}
_db.Entry(_model).CurrentValues.SetValues(empresa);
await _db.SaveChangesAsync();
if (!viejoNombre.Equals(_model.NombreEmpresa)) //Actualizamos la miga de pan de sus unidades organizacionales asociadas
{
var unidadesOrganizacionales = await _db.UnidadOrganizacionalEmpresas.Where(x => x.EmpresaId == empresa.EmpresaId && x.padre == null).AsNoTracking().ToListAsync();
if (unidadesOrganizacionales.Count > 0)
{
foreach (var unidad in unidadesOrganizacionales)
{
new UnidadOrganizacionalEmpresasRepository().ActualizaMigasDePanRamas(unidad.ClaveUnidad.Trim(), _model.NombreEmpresa, unidad.CampoAgrupador);
}
}
}
if (contactoId != empresa.ContactoId) //En caso de que se agreguen o se eliminen contactos como titulares
{
await ActualizaPuestosContactos(contactoId, empresa);
}
}
else
{
throw new ApplicationException("Ya existe un registro con ese nombre.");
}
}
catch (Exception e)
{
throw new Exception(e.Message, e);
}
}
public async Task Update(CursosPersonal model)
{
try
{
var _model = await _db.dbSetCursosPersonal
.FirstOrDefaultAsync(e => e.CursosPersonalId == model.CursosPersonalId);
if (_model != null)
{
foreach (var adjuntoCursosPersonal in model.AdjuntoCursosPersonal)
{
if (adjuntoCursosPersonal.Adjunto != null)
{
try
{
if (adjuntoCursosPersonal.Adjunto.AdjuntoId < 1) //NUEVO ADJUNTO
{
_dbGen.dbSetAdjuntos.Add(adjuntoCursosPersonal.Adjunto);
await _dbGen.SaveChangesAsync(); //guardar el adjunto
adjuntoCursosPersonal.AdjuntoId = adjuntoCursosPersonal.Adjunto.AdjuntoId;
adjuntoCursosPersonal.CursosPersonalId = model.CursosPersonalId;
//guardar nuevo adjuntoCursosPersonal
_db.dbSetAdjuntoCursosPersonal.Add(adjuntoCursosPersonal);
await _db.SaveChangesAsync(); //guardar el adjunto
}
else //adjunto existente: actualizar el adjunto
{
var _modelAdjunto = await _dbGen.dbSetAdjuntos.FirstOrDefaultAsync(e => e.AdjuntoId == adjuntoCursosPersonal.Adjunto.AdjuntoId);
_dbGen.Entry(_modelAdjunto).CurrentValues.SetValues(adjuntoCursosPersonal.Adjunto);
await _dbGen.SaveChangesAsync();
}
}
catch (Exception e)
{
throw new Exception(e.Message, e);
}
}
}
foreach (var autoresCursosPersonal in model.AutoresCursosPersonal)
{
try
{
if (autoresCursosPersonal.AutoresCursosPersonalId < 1) //NUEVO Autor
{
autoresCursosPersonal.Autor_ClavePersona = autoresCursosPersonal.Autor_ClavePersona;
autoresCursosPersonal.Autor_Nombre = autoresCursosPersonal.Autor_Nombre;
autoresCursosPersonal.CursosPersonalId = model.CursosPersonalId;
autoresCursosPersonal.AutoresCursosPersonalId = autoresCursosPersonal.AutoresCursosPersonalId;
//guardar nuevo adjuntoCursosPersonal
_db.dbSetAutoresCursosPersonal.Add(autoresCursosPersonal);
await _db.SaveChangesAsync(); //guardar el adjunto
}
else //adjunto existente: actualizar el adjunto
{
var _modelAutores = await _db.dbSetAutoresCursosPersonal.FirstOrDefaultAsync(e => e.AutoresCursosPersonalId == autoresCursosPersonal.AutoresCursosPersonalId);
_db.Entry(_modelAutores).CurrentValues.SetValues(autoresCursosPersonal);
await _db.SaveChangesAsync();
}
}
catch (Exception e)
{
throw new Exception(e.Message, e);
}
}
_db.Entry(_model).CurrentValues.SetValues(model);
await _db.SaveChangesAsync();
}
}
catch (Exception e)
{
throw new Exception(e.Message, e);
}
}