public async Task Create(SoftwarePersonal model)
 {
     try
     {
         _db.dbSetSoftwarePersonal.Add(model);
         await _db.SaveChangesAsync();
     }
     catch (Exception e)
     {
         throw new Exception(e.Message, e);
     }
 }
        public async Task UpdateEstado(SoftwarePersonal TD)
        {
            try
            {
                var result = await _db.dbSetSoftwarePersonal.FirstOrDefaultAsync(e => e.SoftwarePersonalId == TD.SoftwarePersonalId);

                if (result != null)
                {
                    result.EstadoFlujoId = TD.EstadoFlujoId;

                    await _db.SaveChangesAsync();
                }
            }
            catch (Exception e)
            {
                throw new Exception(e.Message, e);
            }
        }
        public async Task Update(SoftwarePersonal model)
        {
            try
            {
                model.TipoAccesoCat = null;
                model.TipoSoftware  = null;
                var _model = await _db.dbSetSoftwarePersonal.Where(x => x.SoftwarePersonalId == model.SoftwarePersonalId).FirstOrDefaultAsync();

                try
                {
                    if (model.ManualUsuario == null)
                    {
                        if (_model.ManualUsuario != null)
                        {
                            var id = _model.ManualUsuario;
                            _model.ManualUsuario = null;
                            await _db.SaveChangesAsync();

                            await new AdjuntoRepository().Delete(id);
                        }
                        var idManuUsuario = await CreateAdjuntoSwMT(model.AdjuntoManualUsuario);

                        model.ManualUsuario = idManuUsuario;
                    }
                    else
                    {
                        _db.dbSetAdjuntoOfMT.Attach(model.AdjuntoManualUsuario);
                        _db.Entry(model.AdjuntoManualUsuario).State = EntityState.Modified;
                        await _db.SaveChangesAsync();
                    }
                }
                catch (Exception ex) {
                    _db = new MT_Context();
                }
                try
                {
                    if (model.ManualTecnico == null)
                    {
                        if (_model.ManualTecnico != null)
                        {
                            var id = _model.ManualTecnico;
                            _model.ManualTecnico = null;
                            await _db.SaveChangesAsync();

                            await new AdjuntoRepository().Delete(id);
                        }
                        var idManuTecnico = await CreateAdjuntoSwMT(model.AdjuntoManualTecnico);

                        model.ManualTecnico = idManuTecnico;
                    }
                    else
                    {
                        _db.dbSetAdjuntoOfMT.Attach(model.AdjuntoManualTecnico);
                        _db.Entry(model.AdjuntoManualTecnico).State = EntityState.Modified;
                        await _db.SaveChangesAsync();
                    }
                }
                catch (Exception ex) { _db = new MT_Context(); }
                try
                {
                    if (model.CodigoFuente == null)
                    {
                        if (_model.CodigoFuente != null)
                        {
                            var id = _model.CodigoFuente;
                            _model.CodigoFuente = null;
                            await _db.SaveChangesAsync();

                            await new AdjuntoRepository().Delete(id);
                        }
                        var idcodFuente = await CreateAdjuntoSwMT(model.AdjuntoCodigoFuente);

                        model.CodigoFuente = idcodFuente;
                    }
                    else
                    {
                        _db.dbSetAdjuntoOfMT.Attach(model.AdjuntoCodigoFuente);
                        _db.Entry(model.AdjuntoCodigoFuente).State = EntityState.Modified;
                        await _db.SaveChangesAsync();
                    }
                }
                catch (Exception ex) { _db = new MT_Context(); }

                foreach (var a in model.Autores)
                {
                    if (a.AutorSoftwareId < 1)
                    {
                        try
                        {
                            a.SoftwarePersonalId = model.SoftwarePersonalId;
                            _db.dbSetAutorSoftware.Add(a);
                            await _db.SaveChangesAsync();
                        }
                        catch (Exception ex1)
                        {
                            _db = new MT_Context();
                        }
                    }
                }


                if (model != null)
                {
                    _db.dbSetSoftwarePersonal.Attach(_model);
                    _db.Entry(model).State = EntityState.Detached;
                    _db.Entry(_model).CurrentValues.SetValues(model);

                    //_db.Entry(_model).State = EntityState.Detached;
                    //_db.dbSetSoftwarePersonal.Attach(model);
                    //_db.Entry(model).State = EntityState.Modified;

                    await _db.SaveChangesAsync();
                }
            }
            catch (Exception e)
            {
                throw new Exception(e.Message, e);
            }
        }