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();
}
