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 Create(PersonalProyecto model)
 {
     try
     {
         string origen = ConfigurationManager.AppSettings["OrigenDatos"];
         model.Origen = origen;
         _db.dbSetPersonalProyectos.Add(model);
         await _db.SaveChangesAsync();
     }
     catch (Exception e)
     {
         throw new Exception(e.Message, e);
     }
 }
        public async Task UpdateEstado(PersonalProyecto Obj)
        {
            try
            {
                var result = await _db.dbSetPersonalProyectos.FirstOrDefaultAsync(e => e.PersonalProyectoId == Obj.PersonalProyectoId);

                if (result != null)
                {
                    result.EstadoFlujoId = Obj.EstadoFlujoId;
                    await _db.SaveChangesAsync();
                }
            }
            catch (Exception e)
            {
                throw new Exception(e.Message, e);
            }
        }
                                                              public async Task <IHttpActionResult> UpdateEstado(PersonalProyecto Obj)
                                                              {
                                                                  try { log.Info(new MDCSet(this.ControllerContext.RouteData));
                                                                        await _entityRepo.UpdateEstado(Obj);

                                                                        return(Ok("Registro actualizado correctamente!")); }
                                                                  catch (Exception e) { log.Error(new MDCSet(this.ControllerContext.RouteData), e);

                                                                                        return(InternalServerError(e)); }
                                                              }
                                                              public async Task <IHttpActionResult> Update(PersonalProyecto model)
                                                              {
                                                                  if (!ModelState.IsValid)
                                                                  {
                                                                      return(BadRequest(ModelState));
                                                                  }

                                                                  try { log.Info(new MDCSet(this.ControllerContext.RouteData));
                                                                        if (model.Adjunto != null)
                                                                        {
                                                                            //Elimar archivo
                                                                            if (model.Adjunto.nombre == "eliminar")
                                                                            {
                                                                                int id = Convert.ToInt32(model.AdjuntoId);
                                                                                model.AdjuntoId = null;
                                                                                await _entityRepo.Update(model);

                                                                                await _adjuntoRepo.Delete(id);

                                                                                return(Ok());
                                                                            }
                                                                            ///Agregar archivo al editar
                                                                            if (model.Adjunto.AdjuntoId == 0)
                                                                            {
                                                                                Adjunto key = await _adjuntoRepo.CreateAd(model.Adjunto);

                                                                                model.AdjuntoId         = key.AdjuntoId;
                                                                                model.Adjunto.AdjuntoId = key.AdjuntoId;
                                                                                await _entityRepo.Update(model);

                                                                                return(Ok(key));
                                                                            }
                                                                        }
                                                                        //solución de ALAN replicada
                                                                        if (model.Adjunto != null)
                                                                        {
                                                                            model.AdjuntoId = model.Adjunto.AdjuntoId;
                                                                        }
                                                                        await _entityRepo.Update(model);

                                                                        return(Ok(model)); }
                                                                  catch (Exception e) { log.Error(new MDCSet(this.ControllerContext.RouteData), e);
                                                                                        return(InternalServerError(e)); }
                                                              }
                                                              [Authorize] public async Task <IHttpActionResult> CreateReturn([FromBody] PersonalProyecto model)
                                                              {
                                                                  //if (!ModelState.IsValid)
                                                                  //{
                                                                  //    return BadRequest(ModelState);
                                                                  //}

                                                                  try { log.Info(new MDCSet(this.ControllerContext.RouteData));
                                                                        await _entityRepo.Create(model);

                                                                        return(Ok(model)); }
                                                                  catch (Exception e) { log.Error(new MDCSet(this.ControllerContext.RouteData), e);
                                                                                        return(InternalServerError(e)); }
                                                              }