/// <summary>
/// Actualiza una entidad de tipo UnidadOrganizacionalEmpresas
/// </summary>
/// <param name="valOriginal">valor trackeado en entity framework</param>
/// <param name="valNuevo">valor nuevo, normalmente el que se recibe desde web api</param>
/// <returns></returns>
public async Task Update(UnidadOrganizacionalEmpresas valOriginal, UnidadOrganizacionalEmpresas valNuevo)
{
try
{
_db.Entry(valOriginal).CurrentValues.SetValues(valNuevo); //actualizamos los valores de la entidad
await _db.SaveChangesAsync();
}
catch (Exception e)
{
throw new Exception(e.Message, e);
}
}
public async Task Update(GrupoColegiadoPartInt model)
{
try
{
var _model = await _db.GrupoColegiadoPartInt.FirstOrDefaultAsync(e => e.GrupoColegiadoPartIntId == model.GrupoColegiadoPartIntId);
if (_model != null)
{
_db.Entry(_model).CurrentValues.SetValues(model);
await _db.SaveChangesAsync();
//if (model.IntegrantesN.Length >= 0)
//{
// await ActualizaIntegranteGC(model);
//}
//if (model.integrantesAntDel.Length >= 0)
//{
// await EliminaIntegranteGC(model);
//}
}
}
catch (Exception e)
{
throw new Exception(e.Message, e);
}
}
public async Task Update(Aliado model)
{
try
{
var _model = await _db.Aliado.FirstOrDefaultAsync(e => e.AliadoId == model.AliadoId);
if (_model != null)
{
_db.Entry(_model).CurrentValues.SetValues(model);
await _db.SaveChangesAsync();
if (model.listaContactos != null)
{
var listaContactosViejos = await _db.ContactorPorAliados.Where(e => e.aliadoId == model.AliadoId).ToListAsync();
foreach (var contacto in listaContactosViejos)
{
var x = await _db.ContactorPorAliados.FirstOrDefaultAsync(e => e.id == contacto.id);
if (x != null)
{
_db.ContactorPorAliados.Remove(x);
await _db.SaveChangesAsync();
}
}
ContactosPorAliados nuevoContacto = new ContactosPorAliados();
foreach (var c in model.listaContactos)
{
nuevoContacto.aliadoId = model.AliadoId;
nuevoContacto.ContactoId = c.ContactoId;
nuevoContacto.fechaRegistro = DateTime.Now;
_db.ContactorPorAliados.Add(nuevoContacto);
await _db.SaveChangesAsync();
}
}
}
}
catch (Exception e)
{
throw new Exception(e.Message, e);
}
}
public async Task UpdateLecciones(Convocatoria model)
{
try
{
var _model = await _db.Convocatoria.FirstOrDefaultAsync(e => e.ConvocatoriaId == model.ConvocatoriaId);
var _modelM = await _db.Convocatoria.FirstOrDefaultAsync(e => e.ConvocatoriaId == model.ConvocatoriaId);
if (_model != null)
{
_modelM.LeccionesAprendidas = model.LeccionesAprendidas;
_db.Entry(_model).CurrentValues.SetValues(_modelM);
await _db.SaveChangesAsync();
}
}
catch (Exception e)
{
throw new Exception(e.Message, e);
}
}
public async Task Update(EstudiosMercado Obj)// UpdateSolicitud
{
try
{
var result = await _ctx.EstudiosMercado.FirstOrDefaultAsync(e => e.EstudiosMercadoId == Obj.EstudiosMercadoId);
if (result != null)
{
_ctx.Entry(result).CurrentValues.SetValues(Obj);
await _ctx.SaveChangesAsync();
var listaArchivosViejos = await _ctx.AdjuntosEstudiosMercado.Where(e => e.EstudiosMercadoId == Obj.EstudiosMercadoId).ToListAsync();
if (listaArchivosViejos.Count() > 0)
{
var adjuntos = listaArchivosViejos.Select(x => x.AdjuntoId).ToList();
_ctx.AdjuntosEstudiosMercado.RemoveRange(listaArchivosViejos);
await _ctx.SaveChangesAsync();
foreach (var c in adjuntos)
{
await new AdjuntoRepository().Delete(c);
}
}
AdjuntoRepository adjuntorepo = new AdjuntoRepository();
if (Obj.listaAdjuntos != null)
{
foreach (var c in Obj.listaAdjuntos)
{
await adjuntorepo.Create(c);
AdjuntosEstudiosMercado nuevoAdjunto = new AdjuntosEstudiosMercado();
nuevoAdjunto.EstudiosMercadoId = Obj.EstudiosMercadoId;
nuevoAdjunto.AdjuntoId = c.AdjuntoId;
_ctx.AdjuntosEstudiosMercado.Add(nuevoAdjunto);
await _ctx.SaveChangesAsync();
}
}
}
}
catch (Exception e)
{
throw new Exception(e.Message, e);
}
}
public async Task update(Eventos evento)
{
try
{
var _evento = await _db.Eventos
.FirstOrDefaultAsync(t => t.EventoId == evento.EventoId);
if (_evento != null)
{
_db.Entry(_evento).CurrentValues.SetValues(evento);
await _db.SaveChangesAsync();
//Dispose();
}
else
{
//Dispose();
}
}
catch (Exception e)
{
throw new Exception(e.Message, e);
}
}
public async Task update(Especialista especialista)
{
try
{
var _especialista = await _db.Especialistas
.FirstOrDefaultAsync(t => t.EspecialistaId == especialista.EspecialistaId);
if (_especialista != null)
{
_db.Entry(_especialista).CurrentValues.SetValues(especialista);
await _db.SaveChangesAsync();
//Dispose();
}
else
{
//Dispose();
}
}
catch (Exception e)
{
throw new Exception(e.Message, e);
}
}
public async Task update(ClaveEmpresas cveEmpresa)
{
try
{
var _evento = await _db.ClaveEmpresas
.FirstOrDefaultAsync(t => t.ClaveEmpresasId == cveEmpresa.ClaveEmpresasId);
if (_evento != null)
{
_db.Entry(_evento).CurrentValues.SetValues(cveEmpresa);
await _db.SaveChangesAsync();
//Dispose();
}
else
{
//Dispose();
}
}
catch (Exception e)
{
throw new Exception(e.Message, e);
}
}
public async Task Update(Competidor model)
{
try
{
var _model = await _dbComp.Competidor.FirstOrDefaultAsync(e => e.CompetidorId == model.CompetidorId);
if (_model != null)
{
_dbComp.Entry(_model).CurrentValues.SetValues(model);
await _dbComp.SaveChangesAsync();
//Se eliminan los adjuntos anteriores del registro, esto evita tener multiples listas de adjuntos (nuevos, viejos) por cada adjunto que agregue/elimine el usuario
var fksAdjuntos = await _dbComp.AdjuntoPorCompetidor.Where(e => e.CompetidorId == model.CompetidorId).ToListAsync();
if (fksAdjuntos.Count() > 0)
{
var listaAdjuntos = fksAdjuntos.Select(x => x.AdjuntoId).ToList();
_dbComp.AdjuntoPorCompetidor.RemoveRange(fksAdjuntos);
await _dbComp.SaveChangesAsync();
await new AdjuntoRepository().DeleteByCollectionIds(listaAdjuntos);
}
//Se registran los adjuntos de nuevo
if (model.AdjuntoPorCompetidor.Count > 0)
{
foreach (var item in model.AdjuntoPorCompetidor)
{
Adjunto obj = new Adjunto();
obj.RutaCompleta = item.Adjunto.RutaCompleta;
obj.nombre = item.Adjunto.nombre;
obj.ModuloId = "CR";
var entities = _dbGEN.dbSetAdjuntos.Add(obj);
await _dbGEN.SaveChangesAsync();
await insertaAdjuntosCompetidor(item.Autor, obj.AdjuntoId, item.tipo, model.CompetidorId);//string autor, long IdAdjunto, string tipo, int idcompetidor
}
// await insertaAdjunto(model);
}
}
}
catch (Exception e)
{
throw new Exception(e.Message, e);
}
}
//public async Task<ProyectoPorConvocatoria> ValidaExist(ProyectoPorConvocatoria model)
//{
// try
// {
// var _model = await _db.ProyectoPorConvocatoria.FirstOrDefaultAsync(e => e.ConvocatoriaId == model.ConvocatoriaId && e.ProyectoId == model.ProyectoId);
// if (_model != null)
// {
// return _model;
// }
// else {
// return null;
// }
// }
// catch (Exception e)
// {
// throw new Exception(e.Message, e);
// }
//}
public async Task Update(ProyectoPorConvocatoria model)
{
try
{
var _model = await _db.ProyectoPorConvocatoria.FirstOrDefaultAsync(e => e.ProyectoPorConvocatoriaId == model.ProyectoPorConvocatoriaId);
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(HistorialUnidadesOrganizacionalesEmpresas model)
{
try
{
var entity = await _db.HistorialUnidadesOrganizacionalesEmpresas.Where(x => x.historialId == model.historialId).FirstOrDefaultAsync();
if (entity != null)
{
_db.Entry(entity).CurrentValues.SetValues(model);
await _db.SaveChangesAsync();
}
}
catch (Exception e)
{
throw new Exception(e.Message, e);
}
}
public async Task Update(TematicaPorFondoPrograma model)
{
try
{
var _model = await _db.TematicaPorFondoPrograma.FirstOrDefaultAsync(e => e.TematicaPorFondoProgramaId == model.TematicaPorFondoProgramaId);
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(LineaDesarrolloTecnologico model)
{
try
{
var _model = await _db.LineaDesarrolloTecnologico.FirstOrDefaultAsync(e => e.LineaDesarrolloTecnologicoId == model.LineaDesarrolloTecnologicoId);
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(IntegranteGrupoColegiadoExterno model)
{
try
{
var _model = await _db.IntegranteGrupoColegiadoExterno.FirstOrDefaultAsync(e => e.IntegranteGrupoColegiadoExternoId == model.IntegranteGrupoColegiadoExternoId);
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(PersonaPartInt model)
{
try
{
var _model = await _db.PersonaPartInt.FirstOrDefaultAsync(e => e.PersonaPartIntId == model.PersonaPartIntId);
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(AreaInvestigacion model)
{
try
{
var _model = await _db.AreaInvestigacion.FirstOrDefaultAsync(e => e.AreaInvestigacionId == model.AreaInvestigacionId);
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(ServicioPorProveedor model)
{
try
{
var _model = await _db.ServicioPorProveedor.FirstOrDefaultAsync(e => e.ServicioPorProveedorId == model.ServicioPorProveedorId);
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(TipoConvenio model)
{
try
{
var _model = await _db.TipoConvenio.FirstOrDefaultAsync(e => e.ConvenioId == model.ConvenioId);
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(ContactoPuestoHistorico contactoPuesto)
{
try
{
var _contactoPuesto = await _db.ContactoPuestoHistorico
.FirstOrDefaultAsync(c => c.ContactoPuestoHistoricoId == contactoPuesto.ContactoPuestoHistoricoId);
if (_contactoPuesto != null)
{
_db.Entry(_contactoPuesto).CurrentValues.SetValues(contactoPuesto);
await _db.SaveChangesAsync();
}
}
catch (Exception e)
{
throw new Exception(e.Message, e);
}
}
public async Task Update(ContactoPerfil contactoPerfil)
{
try
{
var _contactoPerfil = await _db.ContactoPerfil
.FirstOrDefaultAsync
(c => c.ContactoPerfilId == contactoPerfil.ContactoPerfilId);
if (_contactoPerfil != null)
{
_db.Entry(_contactoPerfil).CurrentValues.SetValues(contactoPerfil);
await _db.SaveChangesAsync();
}
}
catch (Exception e)
{
throw new Exception(e.Message, e);
}
}
public async Task Update(FondoPrograma model)
{
try
{
var _model = await _db.FondoPrograma.FirstOrDefaultAsync(e => e.FondoProgramaId == model.FondoProgramaId);
if (_model != null)
{
//if (model.sitiosWebAntDel.Length > 0)
//{
// //Elimina los sitios web que tenia dados de alta y elimino al actualizar
// await EliminaSitioWebFondoPrograma(model);
//}
//if (model.sitiosWebNuevos.Length > 0)
//{
// await InsertaSitioWebFondoProgramaUpdate(model);
//}
if (model.areasNuevos.Length > 0)
{
await InsertaAreTematicaFondoUpdate(model);
}
if (model.areasAntDel.Length > 0)
{
await EliminaAreasFondo(model);
}
_db.Entry(_model).CurrentValues.SetValues(model);
await _db.SaveChangesAsync();
}
}
catch (Exception e)
{
throw new Exception(e.Message, e);
}
}
public async Task update(SeguimientoOportunidad seguimientoON)
{
try
{
var _seguimiento = await _db.SeguimientoOportunidad
.FirstOrDefaultAsync(t => t.SeguimientoOportunidadId == seguimientoON.SeguimientoOportunidadId);
if (_seguimiento != null)
{
_db.Entry(_seguimiento).CurrentValues.SetValues(seguimientoON);
await _db.SaveChangesAsync();
//Dispose();
}
else
{
//Dispose();
}
}
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 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);
}
}