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);
            }
        }
Ejemplo n.º 2
0
        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);
            }
        }
Ejemplo n.º 3
0
        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);
            }
        }
Ejemplo n.º 4
0
        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);
            }
        }
Ejemplo n.º 5
0
        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);
            }
        }
Ejemplo n.º 6
0
        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);
            }
        }
Ejemplo n.º 8
0
                                                 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);
            }
        }
Ejemplo n.º 10
0
        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);
            }
        }
Ejemplo n.º 11
0
        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);
            }
        }
Ejemplo n.º 12
0
        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);
            }
        }
Ejemplo n.º 13
0
        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);
            }
        }
Ejemplo n.º 14
0
        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);
            }
        }
Ejemplo n.º 15
0
        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);
            }
        }
Ejemplo n.º 16
0
        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);
            }
        }
Ejemplo n.º 17
0
        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);
            }
        }
Ejemplo n.º 18
0
        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);
            }
        }