public async Task <bool> StoreNewReservation(ReservationDataModel model)
{
var reservationModel = _mapper.Map <ReservationInfo>(model);
//var counter = _context.ReservationInfos.Count()
reservationModel.BookingReferenceId = "";
using (Microsoft.EntityFrameworkCore.Storage.IDbContextTransaction transaction = _context.Database.BeginTransaction())
{
await _context.ReservationInfos.AddAsync(reservationModel);
await _context.SaveChangesAsync();
foreach (var item in model.OptionalServicesList)
{
await _context.AdditionalServiceTakens.AddAsync(new AdditionalServicesTaken()
{
NoOfTimes = item.NoOfTimes,
ReservationInfoId = reservationModel.Id,
Created = DateTime.Now,
AdditionalServiceRateId = item.AdditionlServiceRateId
});
}
if (model.OptionalServicesList.Count() > 0)
{
await _context.SaveChangesAsync();
}
transaction.Commit();
}
if (reservationModel.Id > 0)
{
return(true);
}
return(false);
}
public async Task <int> SaveTaskPriortyAsync(TaskPriorityModel model)
{
TaskEntity taskEntity = await _taskRep.FirstOrDefaultWithDeletedAsync(m => m.Id == model.Id);
using (Microsoft.EntityFrameworkCore.Storage.IDbContextTransaction trs = await _uow.BeginTransactionAsync())
{
if (taskEntity != null)
{
//güncelleme
Mapper.Map(model, taskEntity);
taskEntity.TaskPriority = model.TaskPriority;
taskEntity.IsDeleted = false;
await _taskRep.UpdateAsync(taskEntity);
await _uow.SaveChangesAsync();
trs.Commit();
}
else
{
throw new NotFoundException("Task", model.Id);
}
}
return(taskEntity.Id);
}
public virtual async Task <List <TEntity> > DeleteManyAsync(Expression <Func <TEntity, bool> > where, CancellationToken cancellationToken = default)
{
using (Microsoft.EntityFrameworkCore.Storage.IDbContextTransaction transaction = context.Database.BeginTransaction())
{
try
{
IEnumerable <TEntity> objects = entities.Where(where).AsEnumerable();
foreach (TEntity entity in objects)
{
await DeleteAsync(entity, false, cancellationToken);
}
await context.SaveChangesAsync(cancellationToken);
transaction.Commit();
return(objects.ToList());
}
catch (DbUpdateConcurrencyException)
{
transaction.Rollback();
throw;
}
catch (Exception e)
{
transaction.Rollback();
throw new DbUpdateException("There is an error when commit transaction.", e);
}
}
}
public async Task <int> SaveTaskAsync(TaskModel model)
{
TaskEntity taskEntity = await _taskRep.FirstOrDefaultWithDeletedAsync(m => m.Id == model.Id);
using (Microsoft.EntityFrameworkCore.Storage.IDbContextTransaction trs = await _uow.BeginTransactionAsync())
{
if (taskEntity == null)
{
//yeni kayit
taskEntity = Mapper.Map <TaskModel, TaskEntity>(model);
await _taskRep.AddAsync(taskEntity);
await _uow.SaveChangesAsync();
trs.Commit();
}
else
{
//güncelleme
Mapper.Map(model, taskEntity);
taskEntity.IsDeleted = false;
await _taskRep.UpdateAsync(taskEntity);
await _uow.SaveChangesAsync();
trs.Commit();
}
}
return(taskEntity.Id);
}
public async Task <int> UpdateClient(UpdateClientRequest request)
{
Microsoft.EntityFrameworkCore.Storage.IDbContextTransaction transaction = _db.Database.BeginTransaction();
ClientEntity client = await _db.Client.FindAsync(request.Id);
if (client == null)
{
throw new ClientNotFoundException(request.Id);
}
await _db.Client.Where(a => a.Id == request.Id).UpdateAsync(c => new ClientEntity
{
FirstName = request.FirstName,
LastName = request.LastName,
SexId = (byte)request.Sex,
PersonalNumber = request.PersonalNumber,
BirthDate = request.BirthDate,
BirthCity = request.City,
PhotoUrl = request.PhotoAddress,
});
if (request.PhoneNumbers.Any())
{
await _db.ClientPhoneNumber.Where(c => c.ClientId == client.Id && !request.PhoneNumbers.Select(p => (byte)p.Type).Contains(c.TypeId)).DeleteAsync();
}
await _db.BulkMergeAsync(request.PhoneNumbers.Select(x => new ClientPhoneNumberEntity {
ClientId = request.Id, TypeId = (byte)x.Type, Phone = x.Phone
}), o => o.ColumnPrimaryKeyExpression = c => new { c.ClientId, c.TypeId });
await transaction.CommitAsync();
return(client.Id);
}
public async Task <IActionResult> OnPostAsync(Guid?id)
{
if (id == null)
{
return(NotFound());
}
Project = await db.Project.FindAsync(id);
if (Project != null)
{
using (Microsoft.EntityFrameworkCore.Storage.IDbContextTransaction transaction = db.Database.BeginTransaction())
{
try
{
db.ProjectFeature.RemoveRange(db.ProjectFeature.Where(w => w.ProjectId == Project.Id));
db.Project.Remove(Project);
await db.SaveChangesAsync();
transaction.Commit();
}
catch (Exception)
{
transaction.Rollback();
throw;
}
}
}
return(RedirectToPage("./Index"));
}
public async Task <int> AddPostAccessLog(int postId, int userId = 0)
{
var affected = 0;
//transaction = dbContext.Database.BeginTransaction();
dbContext.PostAccessLogs.Add(new PostAccessLog
{
PostId = postId,
CreatedAt = DateTimeOffset.UtcNow,
IpAddress = GetRemoteIpAddress(),
UserAgent = GetUserAgent(),
UserId = userId > 0 ? userId : (int?)null
});
try
{
affected = await dbContext.SaveChangesAsync();
}
catch (Exception ex)
{
logger.LogError(ex, ex.Message);
if (transaction != null)
{
transaction.Rollback();
transaction.Dispose();
}
transaction = null;
}
return(affected);
}
public async Task <int> RegisterClient(RegisterClientRequest request)
{
Microsoft.EntityFrameworkCore.Storage.IDbContextTransaction transaction = _db.Database.BeginTransaction();
ClientEntity client = new ClientEntity
{
FirstName = request.FirstName,
LastName = request.LastName,
SexId = (byte)request.Sex,
PersonalNumber = request.PersonalNumber,
BirthDate = request.BirthDate,
BirthCity = request.City,
//PhotoUrl = request.PhotoAddress,
StatusId = 1
};
await _db.Client.SingleInsertAsync(client);
await _db.ClientPhoneNumber.BulkInsertAsync(request.PhoneNumbers.Select(x => new ClientPhoneNumberEntity {
ClientId = client.Id, TypeId = (byte)x.Type, Phone = x.Phone
}));
//await _db.ClientRelation.BulkInsertAsync(request.RelatedClients.Select(x => new ClientRelation { ClientId = client.Id, TypeId = (byte)x.Type, RelativeId = x.Id }));
await transaction.CommitAsync();
return(client.Id);
}
public CommonResponse <CategoryVM> SaveNewData(CategoryVM data, TableTransactionVM transaction)
{
CommonResponse <CategoryVM> result;
using Microsoft.EntityFrameworkCore.Storage.IDbContextTransaction dbTransaction = DbContext.Database.BeginTransaction();
try
{
string transactionId = TransactionRepository.InitializeTransaction(transaction);
result = CategoryRepository.SaveData(data, transactionId);
dbTransaction.Commit();
}
catch (Exception e)
{
dbTransaction.Rollback();
Logger.LogError("Error Saving Category Data by IP Address {0} : {1}\nInner Ex : {2}",
transaction?.IpAddress ?? "",
e.Message ?? "",
e.InnerException?.Message ?? ""
);
result = new CommonResponse <CategoryVM>
{
Status = false,
Code = "E-003",
Message = "Save Data Failed! Please Contact an Web Administrator!",
Data = new CategoryVM[] { data },
};
}
return(result);
}
public async Task <int> CommitAsync()
{
int result = 0;
using (Microsoft.EntityFrameworkCore.Storage.IDbContextTransaction transaction = _dbContext.Database.BeginTransaction())
{
try
{
result = await _dbContext.SaveChangesAsync();
transaction.Commit();
}
catch (DbUpdateConcurrencyException)
{
transaction.Rollback();
throw;
}
catch (Exception e)
{
transaction.Rollback();
throw new DbUpdateException("There is an error when commit transaction.", e);
}
}
return(result);
}
/// <summary>
/// Saves all pending changes
/// </summary>
/// <returns>The number of objects in an Added, Modified, or Deleted state</returns>
public int Commit()
{
// Save changes with the default options
int result = 0;
using (Microsoft.EntityFrameworkCore.Storage.IDbContextTransaction transaction = _dbContext.Database.BeginTransaction())
{
try
{
result = _dbContext.SaveChanges();
transaction.Commit();
}
catch (DbUpdateConcurrencyException)
{
transaction.Rollback();
throw;
}
catch (Exception e)
{
transaction.Rollback();
throw new DbUpdateException("There is an error when commit transaction.", e);
}
}
return(result);
}
public async Task <int> SaveAddressAsync(AddressModel model)
{
AddressEntity addressEntity = await _addressRep.FirstOrDefaultAsync(m => m.Id == model.Id);
using (Microsoft.EntityFrameworkCore.Storage.IDbContextTransaction trs = await _uow.BeginTransactionAsync())
{
if (addressEntity == null)
{
//yeni kayit
addressEntity = Mapper.Map <AddressModel, AddressEntity>(model);
await _addressRep.AddAsync(addressEntity);
await _uow.SaveChangesAsync();
}
else
{
//güncelleme
Mapper.Map(model, addressEntity);
await _addressRep.UpdateAsync(addressEntity);
await _uow.SaveChangesAsync();
}
trs.Commit();
}
return(addressEntity.Id);
}
public virtual int ExecuteSqlCommand(string sql, bool doNotEnsureTransaction = false, int?timeout = null, params object[] parameters)
{
//set specific command timeout
int?previousTimeout = Database.GetCommandTimeout();
Database.SetCommandTimeout(timeout);
int result = 0;
if (!doNotEnsureTransaction)
{
//use with transaction
using (Microsoft.EntityFrameworkCore.Storage.IDbContextTransaction transaction = Database.BeginTransaction())
{
result = Database.ExecuteSqlRaw(sql, parameters: parameters);
transaction.Commit();
}
}
else
{
result = Database.ExecuteSqlRaw(sql, parameters: parameters);
}
//return previous timeout back
Database.SetCommandTimeout(previousTimeout);
return(result);
}
public FuncResult Bind(List <SysUserDataCondition> model, string currentUserId)
{
//检查是否重复绑定
foreach (SysUserDataCondition obj in model)
{
SysUserDataCondition entity = _context.SysUserDataCondition.
FirstOrDefault(e => ((!string.IsNullOrWhiteSpace(obj.UserGroupId) && e.UserGroupId == obj.UserGroupId) || (e.UserId == obj.UserId)) &&
e.ConditionId == obj.ConditionId && e.ConditionValue == obj.ConditionValue &&
e.ControllerId == obj.ControllerId);
if (entity != null)
{
return(new FuncResult()
{
IsSuccess = false, Message = $"[{obj.ConditionValue}] 已经绑定请勿重复操作!"
});
}
entity = new SysUserDataCondition()
{
Id = Guid.NewGuid().ToString("N"),
UserId = obj.UserId,
UserGroupId = obj.UserGroupId,
ConditionName = obj.ConditionName,
ConditionId = obj.ConditionId,
ConditionValue = obj.ConditionValue,
ControllerId = obj.ControllerId,
SortValue = obj.SortValue,
CreatedBy = currentUserId,
CreationDate = DateTime.Now,
LastUpdatedBy = currentUserId,
LastUpdateDate = DateTime.Now
};
_context.SysUserDataCondition.Add(entity);
}
using (Microsoft.EntityFrameworkCore.Storage.IDbContextTransaction trans = _context.Database.BeginTransaction())
{
try
{
_context.SaveChanges();
trans.Commit();
}
catch (Exception ex)
{
LogService.WriteError(ex);
trans.Rollback();
return(new FuncResult()
{
IsSuccess = false, Message = "添加数据时发生了预料之外的错误,请稍后重试"
});
}
}
return(new FuncResult()
{
IsSuccess = true
});
}
/// <summary>
/// Executes the given SQL against the database
/// </summary>
/// <param name="sql">The SQL to execute</param>
/// <param name="doNotEnsureTransaction">true - the transaction creation is not ensured; false - the transaction creation is ensured.</param>
/// <param name="timeout">The timeout to use for command. Note that the command timeout is distinct from the connection timeout, which is commonly set on the database connection string</param>
/// <param name="parameters">Parameters to use with the SQL</param>
/// <returns>The number of rows affected</returns>
public virtual int ExecuteSqlCommand(RawSqlString sql, bool doNotEnsureTransaction = false, int?timeout = null, params object[] parameters)
{
using (Microsoft.EntityFrameworkCore.Storage.IDbContextTransaction transaction = Database.BeginTransaction()) {
int result = Database.ExecuteSqlCommand(sql, parameters);
transaction.Commit();
return(result);
}
}
public async Task <FuncResult> Add(DataConditionModel model, string currentUserId)
{
if (_context.SysDataCondition.FirstOrDefault(e => e.TableName.ToUpper() == model.TableName.ToUpper()) != null)
{
return(new FuncResult()
{
IsSuccess = false, Message = "数据维度表名不能重复"
});
}
SysDataCondition entity = new SysDataCondition
{
SysDataConditionId = Guid.NewGuid().ToString("N"),
ConditionName = model.ConditionName,
ParentId = model.ParentId,
SortValue = model.SortValue,
ConditionDesc = model.ConditionDesc,
ConditionValue = model.ConditionValue,
TableName = model.TableName,
ParentColumn = model.ParentColumn,
ConditionValueDesc = model.ConditionValueDesc,
ChildColumn = model.ChildColumn,
MasterSlaveFlag = model.MasterSlaveFlag == true?1:0,
CreationDate = DateTime.Now,
CreatedBy = currentUserId,
LastUpdateDate = DateTime.Now,
LastUpdatedBy = currentUserId
};
await _context.SysDataCondition.AddAsync(entity);
using (Microsoft.EntityFrameworkCore.Storage.IDbContextTransaction trans = _context.Database.BeginTransaction())
{
try
{
await _context.SaveChangesAsync();
trans.Commit();
return(new FuncResult()
{
IsSuccess = true, Content = entity, Message = "添加成功"
});
}
catch (Exception ex)
{
trans.Rollback();
return(new FuncResult()
{
IsSuccess = false, Content = ex.Message, Message = "添加失败"
});
}
}
}
public async Task <FuncResult> Add(SysModelInfo model, string currentUserId)
{
//模块名称不能重复
if (_context.SysModelInfo.FirstOrDefault(e => e.ModelName == model.ModelName) != null)
{
return(new FuncResult()
{
IsSuccess = false, Message = "模块名不能重复!"
});
}
if (string.IsNullOrWhiteSpace(model.ModelGroupId))
{
return(new FuncResult()
{
IsSuccess = false, Message = "所属模块组不能为空"
});
}
model.ModelId = Guid.NewGuid().ToString();
model.LastUpdatedBy = currentUserId;
model.LastUpdateDate = DateTime.Now;
model.CreatedBy = currentUserId;
model.CreationDate = DateTime.Now;
model.DeleteFlag = 0;
await _context.SysModelInfo.AddAsync(model);
using (Microsoft.EntityFrameworkCore.Storage.IDbContextTransaction trans = _context.Database.BeginTransaction())
{
try
{
await _context.SaveChangesAsync();
trans.Commit();
}
catch (Exception ex)
{
trans.Rollback();
return(new FuncResult()
{
IsSuccess = false, Message = ex.Message
});
}
}
return(new FuncResult()
{
IsSuccess = true, Content = model, Message = "添加成功"
});
}
public void Create(Microsoft.EntityFrameworkCore.Storage.IDbContextTransaction dbt, Guid key)
{
try
{
_dbContext.TransactionLog2.Add(new TransactionLog2 {
Key = key
});
_dbContext.SaveChanges();
_dbContext.Database.CommitTransaction(); // If not, nothing occurs
}
catch (Exception)
{
throw;
}
}
public async Task <FuncResult> Add(SysUserInfoModel model, int currentUserId)
{
SysUserInfo entity = new SysUserInfo
{
User_Account = model.UserAccount,
User_Name = model.UserName,
User_Password = model.UserPassword,
User_Org_Id = model.UserOrgId,
User_Group_Names = model.UserGroupNames,
User_Email = model.UserEmail,
User_Is_Ldap = model.UserIsLdap,
User_Mobile_No = model.UserMobileNo,
User_Ower = model.UserOwer,
Language_Code = model.LanguageCode,
User_Is_Lock = model.UserIsLock,
Eff_Start_Date = model.EffStartDate,
Eff_End_Date = model.EffEndDate,
Creation_Date = DateTime.Now,
Created_By = currentUserId
};
await _context.SysUserInfos.AddAsync(entity);
using (Microsoft.EntityFrameworkCore.Storage.IDbContextTransaction trans = _context.Database.BeginTransaction())
{
try
{
await _context.SaveChangesAsync();
trans.Commit();
}
catch (Exception ex)
{
trans.Rollback();
return(new FuncResult()
{
IsSuccess = false, Content = ex.Message
});
}
}
return(new FuncResult()
{
IsSuccess = true, Content = entity, Message = "添加成功"
});
}
public async Task <FuncResult> Add(SysModelGroupModel model, int currentUserId)
{
var entity = new SysModelGroup()
{
Model_Group_Code = model.ModelGroupCode,
Model_Group_Name = model.ModelGroupName,
Parent_Id = model.ParentId,
Sort_Flag = model.SortFlag,
Enable_Flag = model.EnableFlag,
Image_Url = model.ImageUrl,
Group_Belong = model.GroupBelong,
Biz_Sys_Code = model.BizSysCode,
Last_Updated_By = currentUserId,
Last_Update_Date = DateTime.Now,
Created_By = currentUserId,
Creation_Date = DateTime.Now
};
await _context.SysModelGroups.AddAsync(entity);
using (Microsoft.EntityFrameworkCore.Storage.IDbContextTransaction trans = _context.Database.BeginTransaction())
{
try
{
await _context.SaveChangesAsync();
trans.Commit();
}
catch (Exception ex)
{
trans.Rollback();
return(new FuncResult()
{
IsSuccess = false, Content = ex.Message
});
}
}
return(new FuncResult()
{
IsSuccess = true, Content = entity, Message = "添加成功"
});
}
public async Task <bool> Transaction(Action action)
{
bool isCommitted = default;
Microsoft.EntityFrameworkCore.Storage.IDbContextTransaction transaction = null;
try
{
transaction = AppDbContext.Database.BeginTransaction();
action.Invoke();
SetAudit();
await transaction.CommitAsync();
}
catch (Exception exception)
{
await transaction.RollbackAsync();
Logger.WriteLog(logType: CommonEnum.LogLevelEnum.Error, MethodBase.GetCurrentMethod(), exception: exception);
}
return(isCommitted);
}
public void PlaceOrder(Models.Order order)
{
Entities.StoreOrder o = new Entities.StoreOrder();
if (order.Location.LocationID != null)
{
o.LocationId = (int)order.Location.LocationID;
}
if (order.Customer.CustomerID != null)
{
o.CustomerId = (int)order.Customer.CustomerID;
}
o.CheckedOut = DateTime.Now;
ctx.StoreOrders.Add(o);
foreach (Models.Item i in order.Items)
{
Entities.OrderItem oi = new Entities.OrderItem();
if (i.Product.ProductID != null)
{
oi.ProductId = (int)i.Product.ProductID;
}
oi.Quantity = i.Quantity;
o.OrderItems.Add(oi);
}
ctx.SaveChanges();
try {
transaction.Commit();
using var log = new LoggerConfiguration()
.WriteTo.File("log.txt", rollingInterval: RollingInterval.Day, shared: true)
.CreateLogger();
log.Information("TRANSACTION: Committed");
transaction.Dispose();
transaction = ctx.Database.BeginTransaction();
} catch (Exception e) {
Console.WriteLine(e.StackTrace);
using var log = new LoggerConfiguration()
.WriteTo.File("log.txt", rollingInterval: RollingInterval.Day, shared: true)
.CreateLogger();
log.Information("TRANSACTION: Rolled back due to database throwing exception");
transaction.Rollback();
}
}
public async Task <FuncResult> Delete(string[] ids, int currentuserId)
{
var entitys = _context.SysModules.Where(e => ids.Contains(e.Id));
if (entitys.Count() != ids.Length)
{
return(new FuncResult()
{
IsSuccess = false, Message = "参数错误"
});
}
foreach (var obj in entitys)
{
obj.Delete_By = currentuserId;
obj.Delete_Flag = true;
obj.Delete_Time = DateTime.Now;
_context.SysModules.Update(obj);
}
using (Microsoft.EntityFrameworkCore.Storage.IDbContextTransaction trans = _context.Database.BeginTransaction())
{
try
{
await _context.SaveChangesAsync();
trans.Commit();
}
catch (Exception ex)
{
trans.Rollback();
LogService.WriteError(ex);
return(new FuncResult()
{
IsSuccess = false, Message = "删除时发生了意料之外的错误"
});
}
}
return(new FuncResult()
{
IsSuccess = true, Message = $"已成功删除{ids.Length}条记录"
});
}
public async Task <IActionResult> OnPostAsync()
{
if (!ModelState.IsValid)
{
ViewData["ClientId"] = new SelectList(db.Client, "Id", "Code");
return(Page());
}
using (Microsoft.EntityFrameworkCore.Storage.IDbContextTransaction transaction = db.Database.BeginTransaction())
{
try
{
var projectFeatureResult = await new ProjectService().UploadProjectFeaturesAsync(UploadFeatureFile, Project.Id);
// Perform a second check to catch ProcessFormFile method
// violations.
if (!projectFeatureResult.ModelState.IsValid)
{
ViewData["ClientId"] = new SelectList(db.Client, "Id", "Code");
return(Page());
}
db.ProjectFeature.AddRange(projectFeatureResult.ProjectFeatures);
db.Project.Add(Project);
await db.SaveChangesAsync();
transaction.Commit();
return(RedirectToPage("./Index"));
}
catch (Exception)
{
transaction.Rollback();
throw;
}
}
}
public async Task <FuncResult> Delete(string[] ids, string currentUserId)
{
IQueryable <ApdFctTAx> entitys = _context.ApdFctTAx.Where(e => ids.Contains(e.RECORD_ID));
if (entitys.Count() != ids.Length)
{
return(new FuncResult()
{
IsSuccess = false, Message = "参数错误"
});
}
foreach (ApdFctTAx obj in entitys)
{
//删除
_context.ApdFctTAx.Remove(obj);
}
using (Microsoft.EntityFrameworkCore.Storage.IDbContextTransaction trans = _context.Database.BeginTransaction())
{
try
{
await _context.SaveChangesAsync();
trans.Commit();
}
catch (Exception ex)
{
trans.Rollback();
LogService.WriteError(ex);
return(new FuncResult()
{
IsSuccess = false, Message = "删除时发生了意料之外的错误"
});
}
}
return(new FuncResult()
{
IsSuccess = true, Message = $"已成功删除{ids.Length}条记录"
});
}
public async Task <IActionResult> OnPostAsync()
{
if (!ModelState.IsValid)
{
return(Page());
}
Project.ModifiedDate = DateTime.UtcNow;
Project.ModifiedBy = User.Identity.Name;
db.Attach(Project).State = EntityState.Modified;
using (Microsoft.EntityFrameworkCore.Storage.IDbContextTransaction transaction = db.Database.BeginTransaction())
{
try
{
await db.SaveChangesAsync();
transaction.Commit();
return(RedirectToPage("./Index"));
}
catch (DbUpdateConcurrencyException)
{
transaction.Rollback();
if (!ProjectExists(Project.Id))
{
return(NotFound());
}
else
{
throw;
}
}
}
}
public async Task <FuncResult> Add(SysModuleModel model, int currentUserId)
{
//模块名称不能重复
if (_context.SysModules.FirstOrDefault(e => e.ModuleName == model.ModuleName) != null)
{
return(new FuncResult()
{
IsSuccess = false, Message = "模块名不能重复!"
});
}
int level = 1;
if (!string.IsNullOrWhiteSpace(model.ParentId))
{
var parent_entity = _context.SysModules.FirstOrDefault(e => e.Id == model.ParentId);
if (parent_entity == null)
{
return(new FuncResult()
{
IsSuccess = false, Message = "父级ID错误"
});
}
level = parent_entity.Level + 1;
}
var entity = new SysModule()
{
ModuleName = model.ModuleName,
Level = level,
ParentId = model.ParentId,
Last_Updated_By = currentUserId,
Last_Update_Date = DateTime.Now,
Created_By = currentUserId,
Creation_Date = DateTime.Now
};
await _context.SysModules.AddAsync(entity);
using (Microsoft.EntityFrameworkCore.Storage.IDbContextTransaction trans = _context.Database.BeginTransaction())
{
try
{
await _context.SaveChangesAsync();
trans.Commit();
}
catch (Exception ex)
{
trans.Rollback();
return(new FuncResult()
{
IsSuccess = false, Content = ex.Message
});
}
}
return(new FuncResult()
{
IsSuccess = true, Content = entity, Message = "添加成功"
});
}
private void saveDBBtn_Click(object sender, EventArgs e)//+
{
try
{
using (profileContext db = new profileContext())
{
using (Microsoft.EntityFrameworkCore.Storage.IDbContextTransaction tr = db.Database.BeginTransaction())
{
try
{
try
{
DataManipulationService.SaveProfileToDB(db, tr, Document);
tr.Commit();
}
catch (Exception ex)
{
tr.Rollback();
MessageBox.Show(ex.Message);
return;
}
DataManipulationService.SaveResultToDB(db, tr, Document);
}
catch (Exception ex)
{
MainProfile mainProfile = db.MainProfile.SingleOrDefault(p => p.Name == Document.DocumentName);
if (mainProfile != null)
{
db.MainProfile.Remove(mainProfile);
db.SaveChanges();
}
MessageBox.Show(ex.Message);
return;
}
}
}
}
catch (Exception ex)
{
MessageBox.Show(ex.Message);
}
}
/// <summary>
/// Persists all updates to the data source and resets change tracking in the object context.
/// </summary>
/// <returns>The number of objects in an System.Data.Entity.EntityState.Added, System.Data.Entity.EntityState.Modified, or System.Data.Entity.EntityState.Deleted state when System.Data.Objects.ObjectContext.SaveChanges() was called.</returns>
public override int SaveChanges()
{
var cancel = false;
OnBeforeSaveChanges(ref cancel);
if (cancel)
{
return(0);
}
var markedTime = System.DateTime.Now;
//Get the added list
var addedList = this.ChangeTracker.Entries().Where(x => x.State == EntityState.Added);
//Process added list
foreach (var item in addedList)
{
var entity = item.Entity as IAuditable;
if (entity != null)
{
var audit = entity as IAuditableSet;
if (entity.IsModifyAuditImplemented && entity.ModifiedBy != this.ContextStartup.Modifier)
{
if (audit != null)
{
audit.CreatedBy = this.ContextStartup.Modifier;
}
if (audit != null)
{
audit.ModifiedBy = this.ContextStartup.Modifier;
}
}
audit.CreatedDate = markedTime;
audit.ModifiedDate = markedTime;
}
}
this.OnBeforeSaveAddedEntity(new EventArguments.EntityListEventArgs {
List = addedList
});
//Process modified list
var modifiedList = this.ChangeTracker.Entries().Where(x => x.State == EntityState.Modified);
foreach (var item in modifiedList)
{
var entity = item.Entity as IAuditable;
if (entity != null)
{
var audit = entity as IAuditableSet;
if (entity.IsModifyAuditImplemented && entity.ModifiedBy != this.ContextStartup.Modifier)
{
if (audit != null)
{
audit.ModifiedBy = this.ContextStartup.Modifier;
}
}
audit.ModifiedDate = markedTime;
}
}
this.OnBeforeSaveModifiedEntity(new EventArguments.EntityListEventArgs {
List = modifiedList
});
var retval = 0;
Microsoft.EntityFrameworkCore.Storage.IDbContextTransaction customTrans = null;
try
{
_paramList.Clear();
if (base.Database.CurrentTransaction == null)
{
customTrans = base.Database.BeginTransaction();
}
retval += base.SaveChanges();
if (customTrans != null)
{
customTrans.Commit();
}
}
catch
{
throw;
}
finally
{
if (customTrans != null)
{
customTrans.Dispose();
}
}
this.OnAfterSaveAddedEntity(new EventArguments.EntityListEventArgs {
List = addedList
});
this.OnAfterSaveModifiedEntity(new EventArguments.EntityListEventArgs {
List = modifiedList
});
OnAfterSaveChanges();
return(retval);
}
public Task <OrderPenjualan> UpdateOrder(int id, OrderPenjualan order)
{
Microsoft.EntityFrameworkCore.Storage.IDbContextTransaction trans = dbContext.Database.BeginTransaction();
try
{
// dbContext.ChangeTracker.Clear();
ValidateCreateOrder(order);
var lastOrder = dbContext.OrderPenjualan.Where(x => x.Id == id)
.Include(x => x.Gudang)
.Include(x => x.Customer)
.Include(x => x.Sales)
.Include(x => x.Items).FirstOrDefault();
if (lastOrder == null)
{
throw new SystemException("Order Not Found !");
}
if (lastOrder.Customer.Id != order.Customer.Id)
{
lastOrder.Customer = order.Customer;
}
if (lastOrder.Sales.Id != order.Sales.Id)
{
lastOrder.Sales = order.Sales;
}
if (lastOrder.Gudang.Id != order.Gudang.Id)
{
lastOrder.Gudang = order.Gudang;
}
lastOrder.DeadLine = order.DeadLine;
foreach (var item in order.Items)
{
if (item.Id <= 0)
{
dbContext.Entry(item.Product).State = EntityState.Detached;
dbContext.Entry(item.Unit).State = EntityState.Detached;
dbContext.OrderPenjualanItem.Add(item);
}
else
{
var olditem = lastOrder.Items.Where(x => x.Id == item.Id).FirstOrDefault();
if (olditem != null)
{
if (olditem.Product != null)
{
dbContext.Entry(olditem.Product).State = EntityState.Unchanged;
}
if (olditem.Unit != null)
{
dbContext.Entry(olditem.Unit).State = EntityState.Unchanged;
}
dbContext.Entry <OrderPenjualanItem>(olditem).CurrentValues.SetValues(item);
}
}
}
dbContext.Entry <OrderPenjualan>(lastOrder).CurrentValues.SetValues(order);
foreach (var item in lastOrder.Items)
{
var existsDb = order.Items.Where(x => x.Id == item.Id).FirstOrDefault();
if (existsDb == null)
{
lastOrder.Items.Remove(item);
}
}
var result = dbContext.SaveChanges();
trans.Commit();
return(Task.FromResult(order));
}
catch (Exception ex)
{
trans.Rollback();
throw new SystemException(ex.Message);
}
}
