public void RollbackTransaction() { lock (lockObject) { dbTransaction?.Rollback(); dbTransaction?.Dispose(); dbTransaction = null; } }
public void CommitTransaction() { try { _transaction?.Commit(); } catch { _transaction?.Rollback(); throw; } }
public void Commit() { try { _context.SaveChanges(); _transaction?.Commit(); } catch { _transaction?.Rollback(); CleanUpTransaction(); throw; } }
/// <summary> /// Save change into database. /// </summary> /// <returns></returns> public override int Commit() { int result; try { //result = GetListRepository().Sum(repositoryBase => repositoryBase.Commit()); result = DataContext.SaveChanges(); _transaction?.Commit(); _transaction?.Dispose(); _transaction = null; IList <IRepositoryBase> listRepositoryBases = GetAllRepository(); foreach (IRepositoryBase repositoryBase in listRepositoryBases) { repositoryBase.HasTransaction = true; } } catch (System.Exception) { _transaction?.Rollback(); _transaction?.Dispose(); _transaction = null; IList <IRepositoryBase> listRepositoryBases = GetAllRepository(); foreach (IRepositoryBase repositoryBase in listRepositoryBases) { repositoryBase.HasTransaction = true; } throw; } return(result); }
public void Rollback() { //todo надо ли это? Context.Rollback(); _transaction?.Rollback(); }
public void RollbackTransaction() { if (!_transactionClosed) { _transaction?.Rollback(); _transactionClosed = true; } }
public virtual void CleanUp() { if (RollBack) { _transaction?.Rollback(); } else { _transaction?.Commit(); } }
public void Commit() { try { _context.SaveChanges(); _transaction?.Commit(); } catch (Exception e) { _transaction?.Rollback(); throw e; } }
public void RollbackTransaction() { try { _currentTransaction?.Rollback(); } finally { if (_currentTransaction != null) { _currentTransaction.Dispose(); _currentTransaction = null; } } }
public void RollbackTransaction() { try { DbContextTransaction?.Rollback(); } finally { if (DbContextTransaction != null) { DbContextTransaction.Dispose(); DbContextTransaction = null; } } }
public void Excute <T>(string sql, SqlParameter[] parameters) where T : class { DbContextTransaction trans = null; try { trans = this.Context.Database.BeginTransaction(); this.Context.Database.ExecuteSqlCommand(sql, parameters); trans.Commit(); } catch (Exception ex) { trans?.Rollback(); throw ex; } }
private PackageVersion GetorAddPackageVersionEntity(Package package, Entity.Package packageEntity) { var packageVersionEntity = GetPackageVersionEntity(package, packageEntity); // This version of the package was already processed, don't process again if (packageVersionEntity != null) { Logger.LogDebug($"{package.Id}.{package.Version} package version already exists. Ignoring."); return(packageVersionEntity); } DbContextTransaction transaction = null; try { transaction = dbContext.Database.BeginTransaction(); // Get package contents from repository var tempVersion = new Version(package.Version); packageVersionEntity = new PackageVersion { Version = package.Version, MajorVersion = Math.Max(0, tempVersion.Major), MinorVersion = Math.Max(0, tempVersion.Minor), BuildVersion = Math.Max(0, tempVersion.Build), RevisionVersion = Math.Max(0, tempVersion.Revision) }; packageEntity.PackageVersions.Add(packageVersionEntity); dbContext.SaveChanges(); Logger.LogInformation($"{package.Id}.{package.Version} package version added to database."); PopulatePackageAssembliesFromPackageContent(package, packageEntity, packageVersionEntity); transaction.Commit(); return(packageVersionEntity); } catch { Logger.LogError("Exception thrown. Rolling back changes."); transaction?.Rollback(); throw; } }
public void Excute <T>(string sql, SqlParameter[] parameters) where T : class { DbContextTransaction transaction = null; try { transaction = Context.Database.BeginTransaction(); Context.Database.ExecuteSqlCommand(sql, parameters); transaction.Commit(); } catch (Exception) { transaction?.Rollback(); throw; } finally { transaction?.Dispose(); } }
public async Task CommitAsync(Exception exception = null) { try { if (_dbTransaction != null && exception != null) { _dbTransaction.Rollback(); Debug.WriteLine($" Rollback with Skip Transaction {_dbContext.Identifier}"); return; } await _dbContext.SaveChangesAsync().ConfigureAwait(false); Debug.WriteLine($" Commit Transaction {_dbContext.Identifier}"); _dbTransaction?.Commit(); } catch (Exception) { if (_dbTransaction?.UnderlyingTransaction.Connection != null) { _dbTransaction?.Rollback(); Debug.WriteLine($" Rollback Transaction {_dbContext.Identifier}"); } throw; } finally { if (_dbTransaction != null) { _dbTransaction.Dispose(); _dbTransaction = null; Debug.WriteLine($" Dispose Transaction {_dbContext.Identifier}"); } } }
public void RollBack() { _trans?.Rollback(); }
public void Rollback() { _transaction?.Rollback(); CleanUpTransaction(); }
public ActionResult Index(InicioMesModel modelo) { string bodegas = Request["listar_bodegas"]; ViewBag.bodegas = bodegas; ViewBag.bodccs_cod = context.bodega_concesionario.OrderBy(x => x.bodccs_nombre).ToList(); if (ModelState.IsValid) { using (DbContextTransaction dbTran = context.Database.BeginTransaction()) { try { if (!string.IsNullOrEmpty(bodegas)) { string[] bodegasId = bodegas.Split(','); List <int> listaBodegas = new List <int>(); foreach (string item in bodegasId) { listaBodegas.Add(Convert.ToInt32(item)); } foreach (int j in listaBodegas) { mesactualbodega bodega = context.mesactualbodega.FirstOrDefault(x => x.idbodega == j); if (bodega == null) { mesactualbodega mesactualbodega = new mesactualbodega { idbodega = j, mesacual = modelo.mes, anoactual = modelo.anio, fec_creacion = DateTime.Now, userid_creacion = Convert.ToInt32(Session["user_usuarioid"]) }; context.mesactualbodega.Add(mesactualbodega); context.SaveChanges(); } else { int idb = bodega.id; mesactualbodega mab = context.mesactualbodega.Find(idb); mab.mesacual = modelo.mes; mab.anoactual = modelo.anio; context.Entry(mab).State = EntityState.Modified; context.SaveChanges(); } } int mesAnterior = modelo.mes; int anioAnterior = modelo.anio; mesAnterior = mesAnterior == 1 ? 12 : mesAnterior - 1; anioAnterior = mesAnterior == 12 ? anioAnterior - 1 : anioAnterior; #region referencias inven List <referencias_inven> buscarReferencia_Inven = context.referencias_inven.Where(x => listaBodegas.Contains(x.bodega) && x.ano == anioAnterior && x.mes == mesAnterior) .ToList(); foreach (referencias_inven referencia_inven in buscarReferencia_Inven) { referencias_inven inven = new referencias_inven(); referencias_inven existe = context.referencias_inven.FirstOrDefault(x => x.ano == modelo.anio && x.mes == modelo.mes && x.bodega == referencia_inven.bodega && x.codigo == referencia_inven.codigo); if (existe == null) { inven.bodega = referencia_inven.bodega; inven.ano = (short)modelo.anio; inven.mes = (short)modelo.mes; inven.can_ini = referencia_inven.can_ini + referencia_inven.can_ent - referencia_inven.can_sal; inven.cos_ini = referencia_inven.cos_ini + referencia_inven.cos_ent - referencia_inven.cos_sal; inven.codigo = referencia_inven.codigo; inven.modulo = referencia_inven.modulo; inven.costo_prom = referencia_inven.costo_prom; context.referencias_inven.Add(inven); context.SaveChanges(); } else { existe.can_ini = referencia_inven.can_ini + referencia_inven.can_ent - referencia_inven.can_sal; existe.cos_ini = referencia_inven.cos_ini + referencia_inven.cos_ent - referencia_inven.cos_sal; existe.costo_prom = referencia_inven.costo_prom; context.Entry(existe).State = EntityState.Modified; context.SaveChanges(); } } #endregion #region cuentas valores List <cuentas_valores> buscarCuentasValores = context.cuentas_valores .Where(x => x.ano == anioAnterior && x.mes == mesAnterior).ToList(); foreach (cuentas_valores cuentaValor in buscarCuentasValores) { cuentas_valores cv = new cuentas_valores(); cuentas_valores existe = context.cuentas_valores.FirstOrDefault(x => x.ano == modelo.anio && x.mes == modelo.mes && x.centro == cuentaValor.centro && x.cuenta == cuentaValor.cuenta && x.nit == cuentaValor.nit); if (existe != null) { existe.saldo_ini += cuentaValor.saldo_ini + cuentaValor.debito - cuentaValor.credito; existe.saldo_ininiff += cuentaValor.saldo_ininiff + cuentaValor.debitoniff - cuentaValor.creditoniff; context.Entry(existe).State = EntityState.Modified; context.SaveChanges(); } else { cv.ano = (short)modelo.anio; cv.mes = (short)modelo.mes; cv.cuenta = cuentaValor.cuenta; cv.centro = cuentaValor.centro; cv.nit = cuentaValor.nit; cv.saldo_ini += cuentaValor.saldo_ini + cuentaValor.debito - cuentaValor.credito; cv.saldo_ininiff += cuentaValor.saldo_ininiff + cuentaValor.debitoniff - cuentaValor.creditoniff; context.cuentas_valores.Add(cv); context.SaveChanges(); } /*context.cuentas_valores.Add(new cuentas_valores() * { * ano = (short)modelo.anio, * mes = (short)modelo.mes, * cuenta = cuentaValor.cuenta, * centro = cuentaValor.centro, * nit = cuentaValor.nit, * saldo_ini = (cuentaValor.saldo_ini) + (cuentaValor.debito) - (cuentaValor.credito), * saldo_ininiff = (cuentaValor.saldo_ininiff) + (cuentaValor.debitoniff) - (cuentaValor.creditoniff) * });*/ } #endregion if (buscarReferencia_Inven.Count > 0 || buscarCuentasValores.Count > 0) { TempData["mensaje"] = "El inicio de mes se ha realizado exitosamente."; ViewBag.bodegas = ""; dbTran.Commit(); return(RedirectToAction("Index")); } TempData["mensaje_error"] = "No se han actualizado los registros porque no se encontraron datos para la(s) bodegas seleccionadas en el mes seleccionado"; } } catch (DbEntityValidationException) { dbTran.Rollback(); throw; } } } return(View(modelo)); }
public void Rollback() { DbContextTransaction.Rollback(); }
public void RollbackTran() { _transaction.Rollback(); _transaction.Dispose(); }
public void Rollback() { _transaction?.Rollback(); }
/// <summary> /// Rolls back the transaction that contains all pending actions on the Repository. /// </summary> public void RollbackTransaction() { _dbContextTransaction?.Rollback(); _dbContextTransaction?.Dispose(); _dbContextTransaction = null; }
public void Rollback() { _dbContextTransaction?.Rollback(); }
public void Rollback() { _transaction?.Rollback(); _transaction?.Dispose(); _transaction = null; }
public ActionResult Create(Project model, List <int> emp, HttpPostedFileBase file) { var list = RoleController.Instance.GetUserRoles(PortalSettings.PortalId, "", "Manager"); ViewBag.Users = new SelectList(list, "UserID", "FullName", model.ManagerID); var listEmployee = RoleController.Instance.GetUserRoles(PortalSettings.PortalId, "", "Employee"); ViewBag.Employees = new SelectList(listEmployee, "UserID", "FullName", emp); if (Request.HttpMethod == "GET") { model.StartDate = model.ExpectEndDate = DateTime.Now; ModelState.Clear(); } else { model.StartDate = DateTime.ParseExact(model.StartDateTemp, "dd/MM/yyyy", null); model.ExpectEndDate = DateTime.ParseExact(model.ExpectEndDateTemp, "dd/MM/yyyy", null); if (ModelState.IsValid) { if (uow.ProjectRepo.Existed(model.ProjectName)) { ModelState.AddModelError("", "Project is existed"); return(View(model)); } // else { //save person for project using (DbContextTransaction dbTran = uow._context.Database.BeginTransaction()) { try { model.ProcessStatus = "KH"; uow.ProjectRepo.Insert(model); uow.Save(); if (emp != null) { foreach (var item in emp) { uow.ProjectPersonRepo.Insert(new ProjectPerson { ProjectId = model.ID, UserId = item }); } uow.Save(); } if (file.ContentLength > 0) { uow.DocumentRepo.Insert(new Documents { ProjectId = model.ID, Name = Path.GetFileNameWithoutExtension(file.FileName), Path = UploadService.Upload(file), Extension = Path.GetExtension(file.FileName), PostDate = DateTime.Now }); uow.Save(); } dbTran.Commit(); return(RedirectToDefaultRoute()); } catch (Exception ex) { ModelState.AddModelError("", ex.Message); dbTran.Rollback(); } finally{ uow.Close(); } } } } } return(View(model)); }
public void Rollback() { _objTran?.Rollback(); _objTran?.Dispose(); }
//guardar carga masiva public string saveFile(CargaMasivaCreateDto model) { var rpta = ""; try { using (var ctx = new PresupuestoContext()) { using (DbContextTransaction transaction = ctx.Database.BeginTransaction()) { try { foreach (var d in model.detalle) { var detalle = new SPDetallePresupuesto { Id = model.Id, presupuestoId = model.presupuestoId, referencia = d.referencia, cantidad = d.cantidad, total_referencia = d.total_referencia, fincaId = d.fincaId, subloteId = d.subloteId, unidad_by_p_cs = d.unidad_by_p_cs, costo_by_p_cs = d.costo_by_p_cs }; ctx.Configuration.AutoDetectChangesEnabled = false; ctx.SPDetallePresupuesto.Add(detalle); ctx.SaveChanges(); var detalleId = detalle.Id; if (model.codigoTipo == "P_MO") { //obtener dimensiones por actividad SPDimension _dimension = new SPDimension(); var dimensiones = _dimension.GetDimensionesbyActividad(detalle.referencia); if (dimensiones.Count > 0) { //eliminamos los existentes para sustituirlos var costosdim = ctx.SPCostoByDimension.Where(x => x.detalle_presupuesdoId == detalleId).ToList(); ctx.SPCostoByDimension.RemoveRange(costosdim); ctx.SaveChanges(); foreach (var ca in dimensiones) { var costo_actividad = new SPCostoByDimension { dimensionId = ca.dimensionId, detalle_presupuesdoId = detalleId, costo = Convert.ToDouble(detalle.total_referencia) * (ca.factor / 100) }; //costo_actividad.costo = Math.Round(Convert.ToDecimal(costo_actividad.costo), 2); ctx.Configuration.AutoDetectChangesEnabled = false; ctx.SPCostoByDimension.Add(costo_actividad); ctx.SaveChanges(); } } } } transaction.Commit(); rpta = "Carga de datos realizada correctamente"; } catch (Exception e) { transaction.Rollback(); throw e; } } } } catch (Exception e) { throw e; } return(rpta); }
//guardar o actualizar lotes public string Save(CreateDetalleManoObraDto model) { var rpta = ""; try { using (var ctx = new PresupuestoContext()) { using (DbContextTransaction transaction = ctx.Database.BeginTransaction()) { try { if (model.referencia == null) { model.referencia = model.referencia_producto; } var d_manoObra = new SPDetallePresupuesto { Id = model.Id, presupuestoId = model.presupuestoId, fincaId = model.fincaId, subloteId = model.loteId, referencia = model.referencia, total_referencia = model.total_referencia, cantidad = model.cantidad, unidad_by_p_cs = model.unidad_by_p_cs, costo_by_p_cs = model.costo_by_p_cs, estado = "I" }; if (d_manoObra.Id > 0) { ctx.Entry(d_manoObra).State = EntityState.Modified; } else { ctx.Entry(d_manoObra).State = EntityState.Added; } ctx.SaveChanges(); ctx.Database.ExecuteSqlCommand("UPDATE SPDetallePresupuesto SET estado = 'I' WHERE presupuestoId IN (@p0) and fincaId IN (@p1)", d_manoObra.presupuestoId, d_manoObra.fincaId); var detalleId = d_manoObra.Id; //obtener dimensiones por actividad SPDimension _dimension = new SPDimension(); var dimensiones = _dimension.GetDimensionesbyActividad(d_manoObra.referencia); if (dimensiones.Count > 0) { //eliminamos los existentes para sustituirlos var costosdim = ctx.SPCostoByDimension.Where(x => x.detalle_presupuesdoId == detalleId).ToList(); ctx.SPCostoByDimension.RemoveRange(costosdim); ctx.SaveChanges(); foreach (var ca in dimensiones) { var costo_actividad = new SPCostoByDimension { dimensionId = ca.dimensionId, detalle_presupuesdoId = detalleId, costo = Convert.ToDouble(d_manoObra.total_referencia) * (ca.factor / 100) }; //costo_actividad.costo = Math.Round(Convert.ToDecimal(costo_actividad.costo), 2); ctx.SPCostoByDimension.Add(costo_actividad); ctx.SaveChanges(); } } transaction.Commit(); rpta = "accion se agrego presupuesto correctamente"; } catch (Exception e) { transaction.Rollback(); throw e; } } } } catch { } return(rpta); }
public void RollbackTransactionContext() { mTransactionContext.Rollback(); }
public int SaveInDbTransaction(IsolationLevel isolationLevel = IsolationLevel.ReadCommitted) { DbContextTransaction transaction = null; try { transaction = _context.Database.BeginTransaction(IsolationLevel.ReadCommitted); using (transaction) { #region Handling auditing var modifiedEntries = _context.ChangeTracker.Entries() .Where(x => x.Entity is IAuditableEntity && (x.State == EntityState.Added || x.State == EntityState.Modified)); foreach (var entry in modifiedEntries) { var entity = entry.Entity as IAuditableEntity; if (entity != null) { var identityName = Thread.CurrentPrincipal.Identity.Name; var now = DateTime.UtcNow; if (entry.State == EntityState.Added) { entity.CreatedBy = identityName; entity.Created = now; } else { _context.Entry(entity).Property(x => x.CreatedBy).IsModified = false; _context.Entry(entity).Property(x => x.Created).IsModified = false; } entity.ModifiedBy = identityName; entity.Modified = now; } } #endregion var affectedRows = _context.SaveChanges(); transaction.Commit(); return(affectedRows); } } catch (DbEntityValidationException dbEx) { foreach (var validationError in dbEx.EntityValidationErrors.SelectMany( validationErrors => validationErrors.ValidationErrors)) { ErrorMessage += $"Property: {validationError.PropertyName} Error: {validationError.ErrorMessage}" + Environment.NewLine; } transaction?.Rollback(); throw new Exception(ErrorMessage, dbEx); } catch (Exception exception) { ErrorMessage = exception.Message; transaction?.Rollback(); throw new Exception(ErrorMessage, exception); } }
public virtual void CleanUp() { transaction?.Rollback(); }