public async Task UpdateSolicitud(Idiomas idioma)
{
try
{
var _idioma = await _ctx.Idiomas.FirstOrDefaultAsync(e => e.IdiomasId == idioma.IdiomasId);
if (_idioma != null)
{
_idioma.FechaValidacion = idioma.FechaValidacion;
_idioma.EstadoFlujoId = idioma.EstadoFlujoId;
_idioma.IdiomaId = idioma.IdiomaId;
_idioma.PorcentajeGradoDominio = idioma.PorcentajeGradoDominio;
_idioma.PorcentajeConversacion = idioma.PorcentajeConversacion;
_idioma.PorcentajeEscritura = idioma.PorcentajeEscritura;
_idioma.PorcentajeLectura = idioma.PorcentajeLectura;
_idioma.FechaAcreditacion = idioma.FechaAcreditacion;
_idioma.Puntuacion = idioma.Puntuacion;
_idioma.CertificacionId = idioma.CertificacionId;
await _ctx.SaveChangesAsync();
PersonasRepository prep = new PersonasRepository();
Personas p = await prep.GetByClave(idioma.ClavePersona);
p.ultimaActualizacion = DateTime.Now;
await prep.Update(p);
}
}
catch (Exception e)
{
throw new Exception(e.Message, e);
}
}
public async Task <WrapperSimpleTypesDTO> AsignarImagenBanner(Personas personaParaAsignarImagenBanner)
{
using (SportsGoEntities context = new SportsGoEntities(false))
{
PersonasRepository personaRepo = new PersonasRepository(context);
int?codigoImagenBanner = await personaRepo.BuscarCodigoImagenBanner(personaParaAsignarImagenBanner);
personaParaAsignarImagenBanner.ArchivosBanner.CodigoTipoArchivo = (int)TipoArchivo.Imagen;
if (codigoImagenBanner.HasValue)
{
ArchivosRepository archivoRepo = new ArchivosRepository(context);
personaParaAsignarImagenBanner.ArchivosBanner.Consecutivo = codigoImagenBanner.Value;
archivoRepo.ModificarArchivo(personaParaAsignarImagenBanner.ArchivosBanner);
}
else
{
Personas personaExistente = await personaRepo.AsignarImagenBanner(personaParaAsignarImagenBanner);
}
WrapperSimpleTypesDTO wrapperCrearImagenBanner = new WrapperSimpleTypesDTO();
wrapperCrearImagenBanner.NumeroRegistrosAfectados = await context.SaveChangesAsync();
if (wrapperCrearImagenBanner.NumeroRegistrosAfectados > 0)
{
wrapperCrearImagenBanner.Exitoso = true;
wrapperCrearImagenBanner.ConsecutivoArchivoCreado = Convert.ToInt64(personaParaAsignarImagenBanner.CodigoArchivoImagenBanner);
}
return(wrapperCrearImagenBanner);
}
}
public async Task <TimeLineNotificaciones> VerificarSiPagoEstaAprobadoYTraerNotificacion(HistorialPagosPersonas pagoParaVerificar)
{
using (SportsGoEntities context = new SportsGoEntities(false))
{
PagosRepository pagosRepo = new PagosRepository(context);
int?codigoEstado = await pagosRepo.BuscarEstadoDeUnPago(pagoParaVerificar);
if (!codigoEstado.HasValue)
{
throw new InvalidOperationException("No se pudo encontrar el estado del pago");
}
TimeLineNotificaciones timeLineNotificacion = null;
if (codigoEstado.Value == (int)EstadoDeLosPagos.Aprobado)
{
Notificaciones notificacionDelPago = await pagosRepo.BuscarNotificacionDeUnPago(pagoParaVerificar);
PersonasRepository personaRepo = new PersonasRepository(context);
int codigoIdioma = await personaRepo.BuscarCodigoIdiomaDeLaPersona(notificacionDelPago.CodigoPersonaDestinoAccion.Value);
notificacionDelPago.CodigoIdiomaUsuarioBase = codigoIdioma;
NoticiasRepository noticiasRepo = new NoticiasRepository(context);
timeLineNotificacion = new TimeLineNotificaciones(await noticiasRepo.BuscarNotificacion(notificacionDelPago));
DateTimeHelperNoPortable helper = new DateTimeHelperNoPortable();
timeLineNotificacion.CreacionNotificacion = helper.ConvertDateTimeFromAnotherTimeZone(pagoParaVerificar.ZonaHorariaGMTBase, helper.DifferenceBetweenGMTAndLocalTimeZone, timeLineNotificacion.CreacionNotificacion);
}
return(timeLineNotificacion);
}
}
public async Task Update(BecarioInterno BI)// UpdateSolicitud
{
try
{
var result = await _ctx.BecarioInterno.FirstOrDefaultAsync(e => e.BecarioInternoId == BI.BecarioInternoId);
if (result != null)
{
if (await ValidarDuplicados(BI))
{
throw new ApplicationException("Ya existe un registro con ese nombre. Intente cambiar el tipo de beca o las fecha de inicio o término");
}
if (BI.Adjunto != null)
{
Adjunto key = await new AdjuntoRepository().CreateAd(BI.Adjunto);
BI.AdjuntoId = key.AdjuntoId;
}
_ctx.Entry(result).CurrentValues.SetValues(BI);
await _ctx.SaveChangesAsync();
PersonasRepository prep = new PersonasRepository();
Personas p = await prep.GetByClave(BI.ClavePersona);
p.ultimaActualizacion = DateTime.Now;
await prep.Update(p);
}
}
catch (Exception e)
{
throw new Exception(e.Message, e);
}
}
public async Task <IHttpActionResult> NotificarAsignacionEvalFI(MiembrosNotificar notificacion)
{
try
{
var _miembrosRepository = new MiembrosGERepository();
var _PersonasRepository = new PersonasRepository();
List <MiembrosGI> miembros = notificacion.ListaMiembros;
int id = notificacion.Id;
await _miembrosRepository.NotificarAsignacionEvalFI(miembros, id);
Correo correo = new Correo();
correo.Modulo = "Gestión de la Innovación";
correo.Seccion = "Idea Innovadora";
correo.TipoCorreo = "NotificacionEvaluadoresFI";
var c = miembros.Select(x => x.ClavePersona);
var lista = await _PersonasRepository.GetAllCollectionMAX(new HashSet <string>(c));
var corrs = new HashSet <String>(lista.Select(x => x.Correo));
correo.Descripcion1 = string.Join(", ", corrs.ToArray());
var correoController = new CorreoController();
try {
await correoController.SendNotificacion(correo);
}
catch (Exception err) { }
return(Ok(""));
}
catch (Exception e)
{
log.Error(new MDCSet(this.ControllerContext.RouteData), e);
return(InternalServerError(e));
}
}
public async Task <BecarioInterno> GetById(int id)
{
try
{
var result = await _ctx.BecarioInterno.Where(e => e.BecarioInternoId == id)
.Include(e => e.EstadoFlujo)
.Include(e => e.BecaInterna)
.Include(e => e.Carrera)
.Include(e => e.Institucion)
.Include(e => e.Institucion.Pais)
.Include(e => e.Pais)
.Include(e => e.Adjunto)
.AsNoTracking()
.FirstOrDefaultAsync();
if (result.ClavePersona != null)
{
PersonasRepository personarepo = new PersonasRepository();
var persona = await personarepo.GetByClave(result.ClavePersona);
result.Persona = persona;
}
return(result);
}
catch (Exception e)
{
throw new Exception(e.Message, e);
}
}
public async Task <Object> GetMiembrosByComunidadInactivos(int id)
{
try
{
PersonasRepository persona = new PersonasRepository();
var entities = await _db.DbSetMiembros
.Where(e => e.idCP == id && e.estado == false)
.AsNoTracking()
.ToListAsync();
foreach (var item in entities)
{
item.foto = await persona.ObtenerFotobyclavepersona(item.idPersonas);
}
persona = null;
return(entities);
}
catch (Exception e)
{
throw new Exception(e.Message, e);
}
}
public async Task <Object> GetByComunidad(int id)
{
try
{
var entities = await _db.DbSetMiembros
.Where(e => e.idCP == id && e.estado == true)
.Include(e => e.RolesCP)
.AsNoTracking()
.ToListAsync();
PersonasRepository personas = new PersonasRepository();
foreach (var item in entities)
{
var datosPersona = await personas.GetByClave(item.idPersonas);
item.correo = datosPersona.Correo;
}
return(entities);
}
catch (Exception e)
{
throw new Exception(e.Message, e);
}
}
public async Task <Object> GetById(int id)
{
try
{
var entities = await _db.DbSetMiembros
.Include(e => e.RolesCP)
.Include(e => e.Comunidad)
.AsNoTracking()
.FirstOrDefaultAsync(e => e.MiembroId == id);
PersonasRepository personas = new PersonasRepository();
Object resultado = new Object();
var datosPersona = await personas.GetByClave(entities.idPersonas);
resultado = new { nombre = datosPersona.NombreCompleto
, roles = new { rolId = entities.RolesCP.RolId, nombre = entities.RolesCP.Nombre }
, comunidades = new { nombreComunidad = entities.Comunidad.Descripcion, categoria = entities.Comunidad.CategoriaCP }
, entities.idCP
, entities.idPersonas
, entities.MiembroId
, entities.FechaAlta
, entities.FechaBaja
, entities.Aceptacion
, entities.FechaAceptacion };
return(resultado);
}
catch (Exception e)
{
throw new Exception(e.Message, e);
}
}
public async Task UpdateSolicitud(FormacionAcademica formacionAcademica)
{
try
{
var _fa = await _ctx.FormacionAcademica.FirstOrDefaultAsync(e => e.FormacionAcademicaId == formacionAcademica.FormacionAcademicaId);
if (_fa != null)
{
//_fa.EstadoFlujoId = formacionAcademica.EstadoFlujoId;
//_fa.GradoAcademicoId = formacionAcademica.GradoAcademicoId;
//_fa.CarreraId = formacionAcademica.CarreraId;
//_fa.Especialidad = formacionAcademica.Especialidad;
//_fa.Cedula = formacionAcademica.Cedula;
//_fa.InstitucionID = formacionAcademica.InstitucionID;
//_fa.PaisID = formacionAcademica.PaisID;
//_fa.FechaInicio = formacionAcademica.FechaInicio;
//_fa.FechaTermino = formacionAcademica.FechaTermino;
//_fa.IdArchivo = formacionAcademica.IdArchivo;
//_fa.EstaTitulado = formacionAcademica.EstaTitulado;
//_fa.FechaValidacion = formacionAcademica.FechaValidacion;
_ctx.Entry(_fa).CurrentValues.SetValues(formacionAcademica);
await _ctx.SaveChangesAsync();
PersonasRepository prep = new PersonasRepository();
Personas p = await prep.GetByClave(formacionAcademica.ClavePersona);
p.ultimaActualizacion = DateTime.Now;
await prep.Update(p);
}
}
catch (Exception e)
{
throw new Exception(e.Message, e);
}
}
public async Task UpdateSolicitud(SNI sni)
{
try
{
var _sni = await _ctx.SNI.FirstOrDefaultAsync(e => e.SNIId == sni.SNIId);
if (_sni != null)
{
_sni.fechaValidacion = sni.fechaValidacion;
_sni.EstadoFlujoId = sni.EstadoFlujoId;
_sni.fechaIngreso = sni.fechaIngreso;
_sni.numeroCVU = sni.numeroCVU;
_sni.fechaInicioNombramiento = sni.fechaInicioNombramiento;
_sni.fechaTerminoNombramiento = sni.fechaTerminoNombramiento;
_sni.NivelSNIId = sni.NivelSNIId;
_sni.AreaSNIId = sni.AreaSNIId;
_sni.numeroExpediente = sni.numeroExpediente;
await _ctx.SaveChangesAsync();
PersonasRepository prep = new PersonasRepository();
Personas p = await prep.GetByClave(sni.ClavePersona);
p.ultimaActualizacion = DateTime.Now;
await prep.Update(p);
}
}
catch (Exception e)
{
throw new Exception(e.Message, e);
}
}
public async Task <IHttpActionResult> test()
{
PersonasRepository p = new PersonasRepository();
var r = await p.GetAllMAX();
return(Ok(r));
}
public async Task <SoftwarePersonal> GetByIdDetails(long id)
{
try
{
var entities = await _db.dbSetSoftwarePersonal.AsNoTracking()
.Include(x => x.Proyecto)
.Include(x => x.TipoSoftware)
.Include(x => x.Autores)
.Include(x => x.AdjuntoManualTecnico)
.Include(x => x.AdjuntoManualUsuario)
.Include(x => x.AdjuntoCodigoFuente)
.Include(x => x.TipoAccesoCat)
.Include(x => x.EstadoFlujo)
.Include(x => x.DerechosAutor)
.FirstOrDefaultAsync(e => e.SoftwarePersonalId == id);
PersonasRepository p = new PersonasRepository();
foreach (var x in entities.Autores)
{
var per = await p.GetByClaveWithoutStatus(x.ClaveAutor);
if (per != null)
{
x.NombreCompleto = per.NombreCompleto;
}
}
return(entities);
}
catch (Exception e)
{
throw new Exception(e.Message, e);
}
}
public async Task <string> participantesComunidad(string id, string trimestre)
{
try
{
double indicador = 0;
DateTime fechaInicio;
DateTime fechaTermino;
switch (trimestre)
{
case "1":
fechaInicio = new DateTime(int.Parse(id), 1, 1, 12, 0, 0);
fechaTermino = new DateTime(int.Parse(id), 3, 31, 12, 0, 0);
break;
case "2":
fechaInicio = new DateTime(int.Parse(id), 4, 1, 12, 0, 0);
fechaTermino = new DateTime(int.Parse(id), 6, 30, 12, 0, 0);
break;
case "3":
fechaInicio = new DateTime(int.Parse(id), 7, 1, 12, 0, 0);
fechaTermino = new DateTime(int.Parse(id), 9, 30, 12, 0, 0);
break;
case "4":
fechaInicio = new DateTime(int.Parse(id), 10, 1, 12, 0, 0);
fechaTermino = new DateTime(int.Parse(id), 12, 31, 12, 0, 0);
break;
default:
fechaInicio = new DateTime(int.Parse(id), 1, 1, 12, 0, 0);
fechaTermino = new DateTime(int.Parse(id), 12, 31, 12, 0, 0);
break;
}
var query = "SELECT DISTINCT idPersonas FROM CP.tab_Miembros where FechaAlta > convert(date,'" + fechaInicio.ToShortDateString() + "',103) and FechaAlta < convert(date,'" + fechaTermino.ToShortDateString() + "',103) and estado = 1";
List <string> miembros = await _db.Database.SqlQuery <string>(query).ToListAsync();
PersonasRepository rp = new PersonasRepository();
int personas = await rp.ContabilizaNoEmpleados();
string cant1 = miembros.Count().ToString();
string cant2 = personas.ToString();
double porcentaje = double.Parse(cant1) / double.Parse(cant2);
if (porcentaje > 0)
{
indicador = porcentaje * 100;
}
return(indicador.ToString());
}
catch (Exception e)
{
throw new Exception(e.Message, e);
}
}
public async Task <Object[]> GetAll()
{
try
{
var entities = await _db.DbSetMiembros
.Where(e => e.estado == true)
.Include(e => e.RolesCP)
.Include(e => e.Comunidad)
.AsNoTracking().ToListAsync();
PersonasRepository personas = new PersonasRepository();
Object [] lista = new Object[entities.Count];
foreach (var obj in entities)
{
var datosPersona = await personas.GetByClave(obj.idPersonas);
lista[entities.IndexOf(obj)] = new { nombre = datosPersona.NombreCompleto
, roles = new { rolId = obj.RolesCP.RolId, nombre = obj.RolesCP.Nombre }
, comunidades = new { nombreComunidad = obj.Comunidad.Descripcion, categoria = obj.Comunidad.CategoriaCP }
, obj.idCP
, obj.idPersonas
, obj.MiembroId
, obj.FechaAlta
, obj.FechaBaja
, obj.Aceptacion
, obj.FechaAceptacion };
}
return(lista);
}
catch (Exception e)
{
throw new Exception(e.Message, e);
}
}
public async Task <FondoPrograma> GetPP(int id)
{
try
{
var entities = await _db.FondoPrograma.AsNoTracking()
.Include("PropuestaPorFondo.Propuestas")
.Include("ProyectoPorFondo.Proyecto")
.Include(e => e.Empresa)
.Include(e => e.FuenteFinanciamiento)
.Include(e => e.SitioWebFondoPrograma)
.Include("TematicaPorFondoPrograma.Tematica")
.AsNoTracking().FirstOrDefaultAsync(e => e.FondoProgramaId == id);
UORepository unidad = new UORepository(_dbGEN);
PersonasRepository persona = new PersonasRepository(_dbGEN);
foreach (PropuestaPorFondo objeto in entities.PropuestaPorFondo)
{
objeto.Propuestas.UnidadOrganizacional = await unidad.UnidadActualWithoutStatus(objeto.Propuestas.UnidadOrganizacionalId);
objeto.Propuestas.Personas = await persona.GetById(objeto.Propuestas.ClaveEmpPropuesta);
}
foreach (ProyectoPorFondo objeto in entities.ProyectoPorFondo)
{
objeto.Proyecto.UnidadOrganizacional = await unidad.UnidadActualWithoutStatus(objeto.Proyecto.UnidadOrganizacionalId);
}
return(entities);
}
catch (Exception e)
{
throw new Exception(e.Message, e);
}
}
public async Task <PersonasDTO> BuscarPersona(Personas personaParaBuscar)
{
using (SportsGoEntities context = new SportsGoEntities(false))
{
PersonasRepository personaRepo = new PersonasRepository(context);
PersonasDTO personaBuscada = await personaRepo.BuscarPersona(personaParaBuscar);
if (personaBuscada.CandidatoDeLaPersona != null)
{
if (personaBuscada.CandidatoDeLaPersona.CodigoResponsable.HasValue)
{
CandidatosRepository candidatoRepo = new CandidatosRepository(context);
CandidatosResponsables candidatoReponsable = new CandidatosResponsables
{
Consecutivo = personaBuscada.CandidatoDeLaPersona.CodigoResponsable.Value
};
personaBuscada.CandidatoDeLaPersona.CandidatosResponsables = await candidatoRepo.BuscarSoloCandidatoResponsableDTO(candidatoReponsable);
}
}
return(personaBuscada);
}
}
public async Task <IEnumerable <PersonalProyecto> > GetPersonasPorProyecto(String id)
{
try
{
var entities = await _db.dbSetPersonalProyectos
.Where(x => x.ProyectoId == id && x.EstadoFlujoId == 3)
.Select(x => x).AsNoTracking().ToListAsync();
if (entities != null && entities.Count > 0)
{
PersonasRepository personasRepo = new PersonasRepository();
foreach (var item in entities)
{
String clavePersona = item.ClavePersona;
var persona = await personasRepo.GetByClaveWithoutStatus(clavePersona);
item.persona = persona;
}
}
return(entities);
}
catch (Exception e)
{
throw new Exception(e.Message, e);
}
}
public SolicitudController()
{
_bita = new BitacoraSolicitudesRepository();
_rolpersonaRepo = new RolPersonaRepository();
_SolicitudRepository = new SolicitudRepository();
_PersonasRepository = new PersonasRepository();
}
public async Task <WrapperSimpleTypesDTO> EliminarImagenBanner(Personas personaImagenBannerParaBorrar)
{
using (SportsGoEntities context = new SportsGoEntities(false))
{
Archivos archivoParaEliminar = new Archivos
{
Consecutivo = personaImagenBannerParaBorrar.CodigoArchivoImagenBanner.Value,
};
PersonasRepository personaRepo = new PersonasRepository(context);
Personas personaExistente = await personaRepo.DesasignarImagenBanner(personaImagenBannerParaBorrar);
ArchivosRepository archivoRepo = new ArchivosRepository(context);
archivoRepo.EliminarArchivo(archivoParaEliminar);
WrapperSimpleTypesDTO wrapperEliminarImagenPerfil = new WrapperSimpleTypesDTO();
wrapperEliminarImagenPerfil.NumeroRegistrosAfectados = await context.SaveChangesAsync();
if (wrapperEliminarImagenPerfil.NumeroRegistrosAfectados > 0)
{
wrapperEliminarImagenPerfil.Exitoso = true;
}
return(wrapperEliminarImagenPerfil);
}
}
public IdeaInnovadoraRepository()
{
dbGI = new GI_Context();
//dbGI.Database.Log = Escribe.Write;
autores = new AutoresIdeaRepository();
_adjuntoRepo = new AdjuntoRepository();
_personaRepo = new PersonasRepository();
}
public SendCorreo(CorreoRepository correoRepo, RolPersonaRepository rolpersonaRepo, PersonasRepository personaRepo)
{
_personaRepo = personaRepo;
_rolpersonaRepo = rolpersonaRepo;
_correoRepo = correoRepo;
_db = new GEN_Context();
_ctx = new SIGCOCHContext();
}
public RecetasController()
{
var dbContext = new Context();
this._recetasRepository = new RecetasRepository(dbContext);
this.personasRepository = new PersonasRepository(dbContext);
this.medicosRepository = new MedicosRepository(dbContext);
}
public SolicitudGIController()
{
_solicitudGIRepository = new SolicitudGIRepository();
_PersonasRepository = new PersonasRepository();
_miembrosRepository = new MiembrosGERepository();
correoController = new CorreoController();
_evaluadorRepo = new EvaluadorIdeaRepository();
}
public ConsultasController()
{
var dbContext = new Context();
this.consultasRepository = new ConsultasRepository(dbContext);
this.personasRepository = new PersonasRepository(dbContext);
this.medicosRepository = new MedicosRepository(dbContext);
}
public SendCorreo()
{
_personaRepo = new PersonasRepository();
_rolpersonaRepo = new RolPersonaRepository();
_correoRepo = new CorreoRepository();
_db = new GEN_Context();
_ctx = new SIGCOCHContext();
}
public async Task <Tuple <WrapperSimpleTypesDTO, TimeLineNotificaciones> > ModificarUsuario(Usuarios usuarioParamodificar)
{
using (SportsGoEntities context = new SportsGoEntities(false))
{
AdministracionRepository adminRepo = new AdministracionRepository(context);
Usuarios usuarioExistente = await adminRepo.ModificarUsuario(usuarioParamodificar);
Notificaciones notificacion = null;
if (usuarioExistente.PlanesUsuarios.CodigoPlan != usuarioParamodificar.PlanesUsuarios.CodigoPlanDeseado)
{
PlanesBusiness planBusiness = new PlanesBusiness();
// Cambio el plan para esa persona
await planBusiness.CambiarDePlanUsuario(usuarioParamodificar.PlanesUsuarios);
// Armamos una notificacion para el nuevo plan
NoticiasRepository noticiasRepo = new NoticiasRepository(context);
notificacion = new Notificaciones
{
CodigoTipoNotificacion = (int)TipoNotificacionEnum.PlanAprobado,
CodigoPlanNuevo = usuarioParamodificar.PlanesUsuarios.CodigoPlanDeseado,
CodigoPersonaDestinoAccion = usuarioExistente.Personas.First().Consecutivo,
Creacion = DateTime.Now
};
noticiasRepo.CrearNotificacion(notificacion);
}
WrapperSimpleTypesDTO wrapperModificarUsuario = new WrapperSimpleTypesDTO();
TimeLineNotificaciones timeLineNotificacion = null;
wrapperModificarUsuario.NumeroRegistrosAfectados = await context.SaveChangesAsync();
if (wrapperModificarUsuario.NumeroRegistrosAfectados > 0)
{
wrapperModificarUsuario.Exitoso = true;
if (notificacion != null && notificacion.Consecutivo > 0)
{
NoticiasRepository noticiasRepo = new NoticiasRepository(context);
if (notificacion.CodigoPersonaDestinoAccion.HasValue && notificacion.CodigoPersonaDestinoAccion > 0)
{
PersonasRepository personaRepo = new PersonasRepository(context);
int codigoIdioma = await personaRepo.BuscarCodigoIdiomaDeLaPersona(notificacion.CodigoPersonaDestinoAccion.Value);
notificacion.CodigoIdiomaUsuarioBase = codigoIdioma;
}
timeLineNotificacion = new TimeLineNotificaciones(await noticiasRepo.BuscarNotificacion(notificacion));
}
}
return(Tuple.Create(wrapperModificarUsuario, timeLineNotificacion));
}
}
//retorna verdadero si la ClavePersona coinside con ClavePersona del registro, alguno de los autores o hiperjefes de los autores
public async Task <Boolean> EvidenciaDownload(int idRegistro, String ClavePersona)
{
try
{
var entitie = await dbGI.DbSetPlanNegocioEvolutivo.AsNoTracking()
.Include(x => x.PlanNegocioEvolAutores)
.FirstOrDefaultAsync(e => e.PlanNegocioEvolutivoId == idRegistro);
if (entitie.TipoAcceso == 1)
{ //1: publico
return(true);
}
else
{
if (entitie.ClavePersona.Equals(ClavePersona))
{
return(true);
}
if (entitie != null && entitie.PlanNegocioEvolAutores != null)
{
var autor = entitie.PlanNegocioEvolAutores.FirstOrDefault(x => x.ClavePersona.Equals(ClavePersona));
if (autor != null)
{
return(true);
}
}
else
{
JerarquiaRepository hiper = new JerarquiaRepository();
Jerarquia jer = new Jerarquia(null, ClavePersona, null);
jer.JefeHiperonimo = ClavePersona;
var autores = entitie.PlanNegocioEvolAutores.Select(x => x.ClavePersona).ToList();
PersonasRepository dbPers = new PersonasRepository();
var personas = await dbPers.GetAllCollectionWithoutStatus(autores);
var unidadesClave = personas.Select(x => x.ClaveUnidad).ToList();
if (unidadesClave != null)
{
foreach (var u in unidadesClave)
{
jer.UnidadOrganizacionalId = u;
if (await hiper.isJefeHiperonimoByUnidadOrganizacionalId(jer))
{
return(true);
}
}
}
}
}
return(false);
}
catch (Exception e)
{
throw new Exception(e.Message, e);
}
}
public async Task <WrapperSimpleTypesDTO> AsignarImagenBannerPersona(int codigoPersona, int codigoArchivo, Stream sourceStream)
{
using (SportsGoEntities context = new SportsGoEntities(false))
using (DbContextTransaction transaction = context.Database.BeginTransaction())
{
ArchivosRepository archivoRepo = new ArchivosRepository(context);
Archivos archivoParaCrear = new Archivos
{
CodigoTipoArchivo = (int)TipoArchivo.Imagen,
ArchivoContenido = new byte[] { 0, 1, 2 }
};
archivoRepo.CrearArchivo(archivoParaCrear);
WrapperSimpleTypesDTO wrapper = new WrapperSimpleTypesDTO();
wrapper.NumeroRegistrosAfectados = await context.SaveChangesAsync();
await archivoRepo.ModificarArchivoContenidoStream(archivoParaCrear.Consecutivo, sourceStream);
if (wrapper.NumeroRegistrosAfectados > 0 || archivoParaCrear.Consecutivo > 0)
{
wrapper.Exitoso = true;
wrapper.ConsecutivoCreado = archivoParaCrear.Consecutivo;
wrapper.ConsecutivoArchivoCreado = archivoParaCrear.Consecutivo;
PersonasRepository personaRepo = new PersonasRepository(context);
// Meto el consecutivo del archivo generado por el EF por la creacion
Personas persona = new Personas
{
Consecutivo = codigoPersona,
CodigoArchivoImagenBanner = archivoParaCrear.Consecutivo
};
Personas personaExistente = await personaRepo.AsignarCodigoImagenBanner(persona);
// Elimino el viejo archivo
if (codigoArchivo > 0)
{
Archivos archivoParaBorrar = new Archivos
{
Consecutivo = codigoArchivo
};
archivoRepo.EliminarArchivo(archivoParaBorrar);
}
wrapper.NumeroRegistrosAfectados += await context.SaveChangesAsync();
transaction.Commit();
}
return(wrapper);
}
}
public async Task Update(Ponencia Obj)// UpdateSolicitud
{
try
{
var result = await _ctx.Ponencia.FirstOrDefaultAsync(e => e.PonenciaId == Obj.PonenciaId);
if (Obj.EstadoFlujoId == 1 && result.EstadoFlujoId == 3)
{
await new NuevoOCRepository().DeleteId("PonenciaCH", result.PonenciaId + "");
}
if (result != null)
{
if (Obj.Adjunto != null)
{
//Eliminar archivo
if (Obj.Adjunto.nombre == "eliminar")
{
int id = Convert.ToInt32(Obj.Adjunto.AdjuntoId);
result.AdjuntoId = null;
await _ctx.SaveChangesAsync();
await new AdjuntoRepository().Delete(id);
}
///Agregar archivo al editar
if (Obj.Adjunto.AdjuntoId == 0)
{
if (result.AdjuntoId != null)
{
var id = result.AdjuntoId;
result.AdjuntoId = null;
await _ctx.SaveChangesAsync();
await new AdjuntoRepository().Delete(id);
}
Adjunto key = await new AdjuntoRepository().CreateAd(Obj.Adjunto);
Obj.AdjuntoId = key.AdjuntoId;
}
}
_ctx.Entry(result).CurrentValues.SetValues(Obj);
await _ctx.SaveChangesAsync();
}
PersonasRepository prep = new PersonasRepository();
Personas p = await prep.GetByClave(Obj.ClavePersona);
p.ultimaActualizacion = DateTime.Now;
await prep.Update(p);
}
catch (Exception e)
{
throw new Exception(e.Message, e);
}
}
