public async Task <ResultDto <User> > Update(User user)
{
ResultDto <User> result;
var userExist = _dbContext.Repository <User>().Where(x => x.UserId == user.UserId).SingleOrDefault();
if (userExist == null)
{
result = new ResultDto <User>
{
Data = user,
StatusCode = HttpStatusCode.NotFound,
ErrorMessage = "User doesn't exist"
};
return(result);
}
_dbContext.Update(user);
_dbContext.Commit();
result = new ResultDto <User>
{
Data = user,
StatusCode = HttpStatusCode.OK
};
return(result);
}
public async Task <Customer> ReadAsync(string id)
{
var customer = await _customerRepository.ReadAsync(id);
_dbContext.Commit();
return(customer);
}
public IEnumerable <Market> GetAll()
{
var result = _context.Market.GetAll();
_context.Commit();
return(result);
}
public async Task AddCustomerAsync(Customer customer)
{
string query = @"INSERT INTO Customers
(CustomerId, Firstname, Lastname, Email, Password, Address, City, PostalCode, Telephone)
VALUES(@CustomerId ,@Firstname, @Lastname, @Email, @Password, @Address, @City, @PostalCode, @Telephone)";
await _connection.ExecuteAsync(query, param : customer, transaction : _transaction, commandType : CommandType.Text);
_dbContext.Commit();
}
public dynamic DeleteAggregate()
{
int id = this.Request.Form["id"];
_dbContext.BeginTransaction();
_deleteProjectRequestAggregateCommand.Execute(id);
_dbContext.Commit();
return(HttpStatusCode.OK);
}
public long Add(TEntity obj)
{
using (var trans = _uow.BeginTransaction())
{
_uow.GetEntity <TEntity>().Add(obj);
trans.Commit();
_uow.Commit();
return(obj.Id);
}
}
public IEnumerable <Product> GetAll()
{
var result = _context.Product.GetAll();
_context.Commit();
return(result);
}
public void Transaction()
{
IDbContext dbContext = null;
try
{
dbContext = DbContextFactory.GetDbContext();
dbContext.Open(true);
dbContext.From <Student>().Insert(new Student()
{
Name = "stduent1"
});
//throw new Exception("rollback");
dbContext.From <School>().Insert(new School()
{
Name = "school1"
});
dbContext.Commit();
}
catch (Exception)
{
dbContext?.Rollback();
throw;
}
finally
{
dbContext?.Close();
}
}
public void SaveEventsFor <TAggregate>(Guid?aggregateId, int eventsLoaded, ArrayList newEvents)
{
var aggregate = this.Aggregates.Find(aggregateId.Value);
if (aggregate == null)
{
aggregate = new CqrsModels.Aggregate
{
Id = aggregateId.Value,
AggregateType = typeof(TAggregate).AssemblyQualifiedName,
CommitDateTime = DateTime.UtcNow
};
Aggregates.Add(aggregate);
}
for (int i = 0; i < newEvents.Count; i++)
{
var e = newEvents[i];
eventsLoaded = eventsLoaded + i;
Events.Add(new CqrsModels.Event
{
Id = Guid.NewGuid(),
AggregateId = aggregate.Id,
SequenceNumber = eventsLoaded,
Type = e.GetType().AssemblyQualifiedName,
Body = SerializeEvent(e),
CommitDateTime = aggregate.CommitDateTime
});
}
_context.Commit();
}
public void ActualizarCuentaBanco(CuentaBanco cuentaBanco)
{
using (IDbContext dbContext = localContainer.Resolve <IDbContext>())
{
try
{
Empresa empresa = dbContext.EmpresaRepository.Find(cuentaBanco.IdEmpresa);
if (empresa == null)
{
throw new BusinessException("Empresa no registrada en el sistema. Por favor, pongase en contacto con su proveedor del servicio.");
}
dbContext.NotificarModificacion(cuentaBanco);
dbContext.Commit();
}
catch (BusinessException ex)
{
dbContext.RollBack();
throw ex;
}
catch (Exception ex)
{
dbContext.RollBack();
log.Error("Error al actualizar la cuenta bancaría: ", ex);
throw new Exception("Se produjo un error actualizando la cuenta bancaria. Por favor consulte con su proveedor..");
}
}
}
public dynamic Save()
{
SaveLogFileViewModel model = this.Bind <SaveLogFileViewModel>();
// make sure the processing directory exists
_dirWrap.CreateDirectory(_appSettings.LogFileProcessingDirectory);
foreach (HttpFile f in Request.Files)
{
// save the file to disk
string filePath = Path.Combine(_appSettings.LogFileProcessingDirectory, f.Name);
using (var fileStream = File.Create(filePath))
{
f.Value.Seek(0, SeekOrigin.Begin);
f.Value.CopyTo(fileStream);
}
// create the log file record - this will kick off the job to actually process the file
try
{
_dbContext.BeginTransaction();
_createLogFileCommand.Execute(model.ProjectId, filePath);
_dbContext.Commit();
}
catch (Exception ex)
{
_dbContext.Rollback();
return(this.Response.AsJson <string>(ex.Message, HttpStatusCode.BadRequest));
}
}
return(HttpStatusCode.OK);
}
public async Task <ReportCore> GetAsync(string id)
{
var product = await _reportCoreRepository.GetAsync(id);
_dbContext.Commit();
return(product);
}
public void SaveChanges()
{
if (!_dbContext.IsTransactionStarted)
{
throw new InvalidOperationException("Transaction have already been commited or disposed.");
}
_dbContext.Commit();
}
public BusinessResult Add(T entity)
{
BusinessResult result = new BusinessResult();
var id = _repositoryBase.Add(entity);
_dbContext.Commit();
if (id > 0)
{
result.Code = 1; result.Data = entity; result.Type = "success";
}
else
{
result.Code = 2; result.Message = "Veri eklenemedi."; result.Type = "warning";
}
return(result);
}
public async Task AddOrderAsync(Order order)
{
string query = @"INSERT INTO Orders (DateCreated, OrderState, CustomerId)
VALUES (@DateCreated, @OrderState, @CustomerId)";
await _connection.ExecuteAsync(query, param : order, transaction : _transaction, commandType : CommandType.Text);
_dbContext.Commit();
}
public void AnularTraslado(int intIdTraslado, int intIdUsuario, string strMotivoAnulacion)
{
using (IDbContext dbContext = localContainer.Resolve <IDbContext>())
{
try
{
Traslado traslado = dbContext.TrasladoRepository.Include("DetalleTraslado").FirstOrDefault(x => x.IdTraslado == intIdTraslado);
if (traslado == null)
{
throw new Exception("El registro de traslado por anular no existe.");
}
if (traslado.Nulo)
{
throw new Exception("El registro de traslado ya ha sido anulado.");
}
Empresa empresa = dbContext.EmpresaRepository.Find(traslado.IdEmpresa);
if (empresa == null)
{
throw new BusinessException("Empresa no registrada en el sistema. Por favor, pongase en contacto con su proveedor del servicio.");
}
SucursalPorEmpresa sucursal = dbContext.SucursalPorEmpresaRepository.FirstOrDefault(x => x.IdEmpresa == traslado.IdEmpresa && x.IdSucursal == traslado.IdSucursalOrigen);
if (sucursal == null)
{
throw new BusinessException("Sucursal no registrada en el sistema. Por favor, pongase en contacto con su proveedor del servicio.");
}
if (sucursal.CierreEnEjecucion)
{
throw new BusinessException("Se está ejecutando el cierre en este momento. No es posible registrar la transacción.");
}
traslado.Nulo = true;
traslado.IdAnuladoPor = intIdUsuario;
traslado.MotivoAnulacion = strMotivoAnulacion;
dbContext.NotificarModificacion(traslado);
if (traslado.IdAsiento > 0)
{
IContabilidadService servicioContabilidad = new ContabilidadService();
servicioContabilidad.ReversarAsientoContable(dbContext, traslado.IdAsiento);
}
dbContext.Commit();
}
catch (BusinessException ex)
{
dbContext.RollBack();
throw ex;
}
catch (Exception ex)
{
dbContext.RollBack();
log.Error("Error al anular el registro de traslado: ", ex);
throw new Exception("Se produjo un error anulando el traslado. Por favor consulte con su proveedor.");
}
}
}
protected override void PostProceed(IInvocation invocation)
{
var method = invocation.MethodInvocationTarget;
if (method?.GetCustomAttribute <TransactionalAttribute>() != null)
{
//_logger.LogInformation($"{invocation.Method.Name}事务拦截后");
_dbContext.Commit();
}
stopwatch.Stop();
_logger.LogInformation($"{method}执行时间为：{stopwatch.ElapsedMilliseconds}毫秒");
}
public void ExecuteResetProcessedLogFileJob(int logFileId)
{
using (IDbContext dbContext = _dbContextFactory.GetDbContext())
{
ISetLogFileUnprocessedCommand cmd = new SetLogFileUnprocessedCommand(dbContext
, new JobRegistrationService()
);
dbContext.BeginTransaction();
cmd.Execute(logFileId);
dbContext.Commit();
}
}
/// <summary>
/// The can open form to write for subject.
/// </summary>
/// <param name="formId">
/// The form id.
/// </param>
/// <param name="subjectId">
/// The subject id.
/// </param>
/// <param name="appUserId">
/// The app user id.
/// </param>
/// <returns>
/// The <see cref="bool"/> .
/// </returns>
public bool CanOpenFormToWriteForSubject(int formId, int subjectId, int appUserId)
{
var lockedForm = _context.FormInProcesses.FirstOrDefault(f => f.FormId == formId && f.SubjectId == subjectId);
if (lockedForm == null)
{
lockedForm = new FormInProcess {
AppUserId = 0, FormId = formId, SubjectId = subjectId, IsLocked = false, MaxLockTimeMin = 0
};
_context.Commit();
}
if (lockedForm.IsLocked)
{
if ((DateTime.UtcNow - lockedForm.OpenendOn).Minutes > lockedForm.MaxLockTimeMin || lockedForm.AppUserId == appUserId)
{
UnlockFormFromReadOnly(formId, subjectId, appUserId);
_context.Commit();
}
}
return(lockedForm.IsLocked);
}
public void Delete()
{
_dbContext.BeginTransaction();
long id = _dbContext.Insert <Employee>(new Employee {
EmpName = "test"
});
_dbContext.Delete <Employee>(id);
_dbContext.Commit();
var employee = _dbContext.QueryWhere <Employee>($"Id={id}");
Assert.NotNull(employee);
Assert.Equal(0, employee?.Count());
}
public string AgregarTraslado(Traslado traslado)
{
using (IDbContext dbContext = localContainer.Resolve <IDbContext>())
{
try
{
Empresa empresa = dbContext.EmpresaRepository.Find(traslado.IdEmpresa);
if (empresa == null)
{
throw new BusinessException("Empresa no registrada en el sistema. Por favor, pongase en contacto con su proveedor del servicio.");
}
SucursalPorEmpresa sucursal = dbContext.SucursalPorEmpresaRepository.FirstOrDefault(x => x.IdEmpresa == traslado.IdEmpresa && x.IdSucursal == traslado.IdSucursalOrigen);
if (sucursal == null)
{
throw new BusinessException("Sucursal no registrada en el sistema. Por favor, pongase en contacto con su proveedor del servicio.");
}
if (sucursal.CierreEnEjecucion)
{
throw new BusinessException("Se está ejecutando el cierre en este momento. No es posible registrar la transacción.");
}
traslado.IdAsiento = 0;
foreach (var detalle in traslado.DetalleTraslado)
{
var existencias = dbContext.ExistenciaPorSucursalRepository.AsNoTracking().Where(x => x.IdEmpresa == empresa.IdEmpresa && x.IdSucursal == traslado.IdSucursalOrigen && x.IdProducto == detalle.IdProducto).FirstOrDefault();
if (existencias == null)
{
throw new BusinessException("El producto " + detalle.IdProducto + " no posee registro de existencias en la sucursal origen del traslado.");
}
if (detalle.Cantidad > existencias.Cantidad)
{
throw new BusinessException("La cantidad indicada para el produco " + detalle.IdProducto + " supera las existencias en la sucursal origen del traslado.");
}
}
dbContext.TrasladoRepository.Add(traslado);
dbContext.Commit();
}
catch (BusinessException ex)
{
dbContext.RollBack();
throw ex;
}
catch (Exception ex)
{
dbContext.RollBack();
log.Error("Error al agregar el registro de devolución: ", ex);
throw new Exception("Se produjo un error agregando la información de la devolución. Por favor consulte con su proveedor.");
}
}
return(traslado.IdTraslado.ToString());
}
public void DbTransaction(Action <IDbContext> action)
{
try
{
_dbContext.BeginTransaction();
action?.Invoke(_dbContext);
_dbContext.Commit();
}
catch (Exception ex)
{
_dbContext.Rollback();
_logger.LogError(ex.Message);
}
}
/// <summary>
/// 追加对象
/// </summary>
/// <typeparam name="TEntity">参数类型</typeparam>
/// <param name="entity">追加对象</param>
public void Insert <TEntity>(TEntity entity, bool isCommit = false) where TEntity : class
{
if (entity == null)
{
return;
}
_context.Set <TEntity>().Add(entity);
_context.Commit();
}
public string AgregarMovimientoBanco(MovimientoBanco movimiento)
{
using (IDbContext dbContext = localContainer.Resolve <IDbContext>())
{
try
{
CuentaBanco cuenta = dbContext.CuentaBancoRepository.Find(movimiento.IdCuenta);
if (cuenta == null)
{
throw new Exception("La cuenta bancaria asignada al movimiento no existe.");
}
Empresa empresa = dbContext.EmpresaRepository.Find(cuenta.IdEmpresa);
if (empresa == null)
{
throw new BusinessException("Empresa no registrada en el sistema. Por favor, pongase en contacto con su proveedor del servicio.");
}
TipoMovimientoBanco tipo = dbContext.TipoMovimientoBancoRepository.Find(movimiento.IdTipo);
if (tipo == null)
{
throw new Exception("El tipo de movimiento no existe.");
}
movimiento.SaldoAnterior = cuenta.Saldo;
if (tipo.DebeHaber == StaticTipoDebitoCredito.Debito)
{
cuenta.Saldo -= movimiento.Monto;
}
else
{
cuenta.Saldo += movimiento.Monto;
}
dbContext.MovimientoBancoRepository.Add(movimiento);
dbContext.NotificarModificacion(cuenta);
dbContext.Commit();
return(movimiento.IdMov.ToString());
}
catch (BusinessException ex)
{
dbContext.RollBack();
throw ex;
}
catch (Exception ex)
{
dbContext.RollBack();
log.Error("Error al agregar el movimiento bancario: ", ex);
throw new Exception("Se produjo un error agregando el movimiento bancario. Por favor consulte con su proveedor..");
}
}
}
/// <summary>
/// Registers a background job that runs through all the requests for a specific log file, and recalculates the aggregates
/// for those requests using the project aggregates set by the user.
/// </summary>
/// <param name="logFileId"></param>
public void ExecuteAggregateRequestJob(int logFileId)
{
using (IDbContext dbContext = _dbContextFactory.GetDbContext())
{
IResetRequestAggregatesCommand cmd = new ResetRequestAggregatesCommand(dbContext
, new LogFileRepository(dbContext)
, new RequestRepository(dbContext)
, new ProjectRequestAggregateRepository(dbContext)
, new RequestAggregationService()
);
dbContext.BeginTransaction();
cmd.Execute(logFileId);
dbContext.Commit();
}
}
/// <summary>
/// Job registered once a file has been uploaded, to process the contents of the log file.
/// </summary>
/// <param name="logFileId"></param>
/// <param name="filePath"></param>
public void ExecuteProcessLogFileJob(int logFileId, string filePath)
{
using (IDbContext dbContext = _dbContextFactory.GetDbContext())
{
IProcessLogFileCommand cmd = new ProcessLogFileCommand(dbContext
, new LogFileRepository(dbContext)
, new CreateRequestBatchCommand(dbContext, new RequestValidator())
, new JobRegistrationService()
, new FileWrap()
);
dbContext.BeginTransaction();
cmd.Execute(logFileId, filePath);
dbContext.Commit();
}
}
public dynamic ProjectSave()
{
ProjectFormViewModel model = this.Bind <ProjectFormViewModel>();
ProjectModel project = Mapper.Map <ProjectFormViewModel, ProjectModel>(model);
ValidationResult validationResult = _projectValidator.Validate(project);
if (validationResult.Success)
{
_dbContext.BeginTransaction();
project = _createProjectCommand.Execute(project);
_dbContext.Commit();
}
SaveResultModel result = new SaveResultModel(project.Id.ToString(), validationResult.Success, validationResult.Messages.ToArray());
return(this.Response.AsJson(result));
}
public void AnularMovimientoBanco(int intIdMovimiento, int intIdUsuario, string strMotivoAnulacion)
{
using (IDbContext dbContext = localContainer.Resolve <IDbContext>())
{
try
{
MovimientoBanco movimiento = dbContext.MovimientoBancoRepository.Find(intIdMovimiento);
if (movimiento == null)
{
throw new Exception("El movimiento por eliminar no existe.");
}
CuentaBanco cuenta = dbContext.CuentaBancoRepository.Find(movimiento.IdCuenta);
if (cuenta == null)
{
throw new Exception("La cuenta bancaria asignada al movimiento no existe.");
}
Empresa empresa = dbContext.EmpresaRepository.Find(cuenta.IdEmpresa);
if (empresa == null)
{
throw new BusinessException("Empresa no registrada en el sistema. Por favor, pongase en contacto con su proveedor del servicio.");
}
movimiento.Nulo = true;
movimiento.IdAnuladoPor = intIdUsuario;
movimiento.MotivoAnulacion = strMotivoAnulacion;
dbContext.NotificarModificacion(movimiento);
cuenta.Saldo -= movimiento.Monto;
dbContext.NotificarModificacion(cuenta);
dbContext.Commit();
}
catch (BusinessException ex)
{
dbContext.RollBack();
throw ex;
}
catch (Exception ex)
{
dbContext.RollBack();
log.Error("Error al anular el movimiento bancario: ", ex);
throw new Exception("Se produjo un error anulando el movimiento bancario. Por favor consulte con su proveedor..");
}
}
}
/// <summary>
/// 事务
/// </summary>
/// <param name="sample">The sample.</param>
/// <param name="sample2">The sample2.</param>
/// <returns></returns>
public bool CreateWithTransaction(EFSample sample, EFSample sample2)
{
bool result = true;
using (IDbContext dbcontext = _contextFactory.Create())
{
try
{
dbcontext.BeginTransaction();//开启事务
dbcontext.Create(sample);
dbcontext.Create(sample2);
dbcontext.Commit();
}
catch (Exception)
{
dbcontext.Rollback();
result = false;
}
}
return(result);
}
public async Task test()
{
Agent entity2 = new Agent();
entity2.Id = entity2.CreateId();
entity2.Name = "111";
entity2.ContactNumber = "111";
entity2.Key = "111";
entity2.Secret = "111";
entity2.Remarks = "111";
await _agentRep.InsertAsync(entity2);
context.BeginTransaction();
Agent entity = new Agent();
entity.Id = entity.CreateId();
entity.Name = "111";
entity.ContactNumber = "111";
entity.Key = "111";
entity.Secret = "111";
entity.Remarks = "111";
int r = await _agentRep.InsertAsync(entity);
context.Commit();
Agent entity3 = new Agent();
entity3.Id = entity3.CreateId();
entity3.Name = "111";
entity3.ContactNumber = "111";
entity3.Key = "111";
entity3.Secret = "111";
entity3.Remarks = "111";
await _agentRep.InsertAsync(entity3);
}