public async Task <VerifyRecordResult> BeforeDeleteCheckAsync(TravelExpenseAdapterModel paraObject)
{
CleanTrackingHelper.Clean <TravelExpenseDetail>(context);
TravelExpenseDetail item = await context.TravelExpenseDetail
.AsNoTracking()
.FirstOrDefaultAsync(x => x.TravelExpenseId == paraObject.Id);
if (item != null)
{
return(VerifyRecordResultFactory.Build(false, ErrorMessageEnum.該紀錄無法刪除因為有其他資料表在使用中));
}
return(VerifyRecordResultFactory.Build(true));
}
public async Task <VerifyRecordResult> BeforeDeleteCheckAsync(SystemLogAdapterModel paraObject)
{
CleanTrackingHelper.Clean <OrderItem>(context);
var searchItem = await context.SystemLog
.AsNoTracking()
.FirstOrDefaultAsync(x => x.Id == paraObject.Id);
if (searchItem == null)
{
return(VerifyRecordResultFactory.Build(false, ErrorMessageEnum.無法刪除紀錄_要刪除的紀錄已經不存在資料庫上));
}
return(VerifyRecordResultFactory.Build(true));
}
public async Task <VerifyRecordResult> AddAsync(ProductAdapterModel paraObject)
{
Product itemParameter = Mapper.Map <Product>(paraObject);
CleanTrackingHelper.Clean <Product>(context);
await context.Product
.AddAsync(itemParameter);
await context.SaveChangesAsync();
CleanTrackingHelper.Clean <Product>(context);
return(VerifyRecordResultFactory.Build(true));
}
public async Task <VerifyRecordResult> AddAsync(LeaveCategoryAdapterModel paraObject)
{
LeaveCategory itemParameter = Mapper.Map <LeaveCategory>(paraObject);
CleanTrackingHelper.Clean <LeaveCategory>(context);
await context.LeaveCategory
.AddAsync(itemParameter);
await context.SaveChangesAsync();
CleanTrackingHelper.Clean <LeaveCategory>(context);
return(VerifyRecordResultFactory.Build(true));
}
public async Task <VerifyRecordResult> BeforeDeleteCheckAsync(LeaveCategoryAdapterModel paraObject)
{
CleanTrackingHelper.Clean <LeaveForm>(context);
LeaveForm item = await context.LeaveForm
.AsNoTracking()
.FirstOrDefaultAsync(x => x.LeaveCategoryId == paraObject.Id);
if (item != null)
{
return(VerifyRecordResultFactory.Build(false, ErrorMessageEnum.該紀錄無法刪除因為有其他資料表在使用中));
}
return(VerifyRecordResultFactory.Build(true));
}
public async Task <VerifyRecordResult> AddAsync(OrderItemAdapterModel paraObject)
{
OrderItem itemParameter = Mapper.Map <OrderItem>(paraObject);
CleanTrackingHelper.Clean <OrderItem>(context);
await context.OrderItem
.AddAsync(itemParameter);
await context.SaveChangesAsync();
CleanTrackingHelper.Clean <OrderItem>(context);
return(VerifyRecordResultFactory.Build(true));
}
public async Task <VerifyRecordResult> AddAsync(TravelExpenseAdapterModel paraObject)
{
TravelExpense itemParameter = Mapper.Map <TravelExpense>(paraObject);
CleanTrackingHelper.Clean <TravelExpense>(context);
await context.TravelExpense
.AddAsync(itemParameter);
await context.SaveChangesAsync();
CleanTrackingHelper.Clean <TravelExpense>(context);
return(VerifyRecordResultFactory.Build(true));
}
public async Task ChangePassword(MyUserAdapterModel myUserAdapterModel, string newPassword)
{
string encodePassword =
PasswordHelper.GetPasswordSHA(myUserAdapterModel.Salt, newPassword);
myUserAdapterModel.Password = encodePassword;
var myUser = Mapper.Map <MyUser>(myUserAdapterModel);
CleanTrackingHelper.Clean <MyUser>(context);
context.Entry(myUser).State = EntityState.Modified;
await context.SaveChangesAsync();
CleanTrackingHelper.Clean <MyUser>(context);
}
public async Task <VerifyRecordResult> BeforeUpdateCheckAsync(WorkOrderAdapterModel paraObject)
{
CleanTrackingHelper.Clean <WorkOrder>(context);
var searchItem = await context.WorkOrder
.AsNoTracking()
.FirstOrDefaultAsync(x => x.Id == paraObject.Id);
if (searchItem == null)
{
return(VerifyRecordResultFactory.Build(false, ErrorMessageEnum.要更新的紀錄_發生同時存取衝突_已經不存在資料庫上));
}
return(VerifyRecordResultFactory.Build(true));
}
public async Task <MyUserAdapterModel> UserByAccount(string account)
{
CleanTrackingHelper.Clean <MyUser>(context);
MyUser user = new();
MyUserAdapterModel userAdapterModel = new();
user = await context.MyUser
.AsNoTracking()
.FirstOrDefaultAsync(x => x.Account == account);
userAdapterModel = Mapper.Map <MyUserAdapterModel>(user);
CleanTrackingHelper.Clean <MyUser>(context);
return(userAdapterModel);
}
public async Task MailReadedAsync(FlowInboxAdapterModel flowInboxAdapterModel)
{
CleanTrackingHelper.Clean <FlowInbox>(context);
CleanTrackingHelper.Clean <FlowMaster>(context);
CleanTrackingHelper.Clean <MyUser>(context);
flowInboxAdapterModel.IsRead = true;
var flowInbox = Mapper.Map <FlowInbox>(flowInboxAdapterModel);
context.FlowInbox.Update(flowInbox);
await context.SaveChangesAsync();
CleanTrackingHelper.Clean <FlowInbox>(context);
CleanTrackingHelper.Clean <FlowMaster>(context);
CleanTrackingHelper.Clean <MyUser>(context);
}
public async Task DenyAsync(FlowMasterAdapterModel flowMasterAdapterModel,
ApproveOpinionModel approveOpinionModel)
{
CleanTrackingHelper.Clean <FlowMaster>(context);
CleanTrackingHelper.Clean <FlowUser>(context);
CleanTrackingHelper.Clean <FlowHistory>(context);
CleanTrackingHelper.Clean <MyUser>(context);
(var flowUsers, var user) = await GetUsersDataAsync(flowMasterAdapterModel);
if (CheckCurrentActionUser(flowUsers, user, flowMasterAdapterModel) == false)
{
return;
}
RecoveryCompletion(flowUsers, flowMasterAdapterModel.ProcessLevel);
flowMasterAdapterModel.ProcessLevel--;
RecoveryCompletion(flowUsers, flowMasterAdapterModel.ProcessLevel);
CopyUserAutoCompletion(flowUsers, flowMasterAdapterModel.ProcessLevel);
if (flowMasterAdapterModel.ProcessLevel > 0)
{
}
else
{
flowMasterAdapterModel.Status = 0;
}
FindNextActionUser(flowUsers, flowMasterAdapterModel);
await context.BulkUpdateAsync(flowUsers);
await UpdateAsync(flowMasterAdapterModel);
await AddHistoryRecord(user, flowMasterAdapterModel,
$"{approveOpinionModel.Summary}", $"{approveOpinionModel.Comment}", false);
#region 產生收件匣紀錄
await NotifyInboxUsers(flowUsers, flowMasterAdapterModel, flowMasterAdapterModel.ProcessLevel);
#endregion
CleanTrackingHelper.Clean <FlowMaster>(context);
CleanTrackingHelper.Clean <FlowUser>(context);
CleanTrackingHelper.Clean <FlowHistory>(context);
CleanTrackingHelper.Clean <MyUser>(context);
}
async Task OhterDependencyData(ExceptionRecordAdapterModel data)
{
if (data.MyUserId != null)
{
CleanTrackingHelper.Clean <MyUser>(context);
var user = await context.MyUser
.AsNoTracking()
.FirstOrDefaultAsync(x => x.Id == data.MyUserId);
if (user != null)
{
data.MyUserName = user.Name;
}
}
return;
}
public async Task EnableIt(PhaseCategoryAdapterModel paraObject)
{
await Task.Delay(100);
PhaseCategory curritem = await context.PhaseCategory
.AsNoTracking()
.FirstOrDefaultAsync(x => x.Id == paraObject.Id);
CleanTrackingHelper.Clean <PhaseCategory>(context);
curritem.Enable = true;
context.Entry(curritem).State = EntityState.Modified;
await context.SaveChangesAsync();
CleanTrackingHelper.Clean <PhaseCategory>(context);
return;
}
public async Task <VerifyRecordResult> AddAsync(WorkingLogDetailAdapterModel paraObject)
{
WorkingLogDetail itemParameter = Mapper.Map <WorkingLogDetail>(paraObject);
CleanTrackingHelper.Clean <WorkingLogDetail>(context);
await context.WorkingLogDetail
.AddAsync(itemParameter);
await context.SaveChangesAsync();
var id = itemParameter.WorkingLogId;
CleanTrackingHelper.Clean <WorkingLogDetail>(context);
await CountingWorkingHour(id);
return(VerifyRecordResultFactory.Build(true));
}
public async Task DisableIt(CategoryMainAdapterModel paraObject)
{
await Task.Delay(100);
CategoryMain curritem = await context.CategoryMain
.AsNoTracking()
.FirstOrDefaultAsync(x => x.Id == paraObject.Id);
CleanTrackingHelper.Clean <CategoryMain>(context);
curritem.Enable = false;
//context.Entry(curritem).State = EntityState.Modified;
context.Update(curritem);
await context.SaveChangesAsync();
CleanTrackingHelper.Clean <CategoryMain>(context);
return;
}
public async Task <VerifyRecordResult> BeforeUpdateCheckAsync(MyUserAdapterModel paraObject)
{
if (paraObject.Account.ToLower() == MagicHelper.開發者帳號)
{
return(VerifyRecordResultFactory.Build(false, ErrorMessageEnum.開發者帳號不可以被修改));
}
CleanTrackingHelper.Clean <MyUser>(context);
var searchItem = await context.MyUser
.AsNoTracking()
.FirstOrDefaultAsync(x => x.Id == paraObject.Id);
if (searchItem == null)
{
return(VerifyRecordResultFactory.Build(false, ErrorMessageEnum.要更新的紀錄_發生同時存取衝突_已經不存在資料庫上));
}
searchItem = await context.MyUser
.AsNoTracking()
.FirstOrDefaultAsync(x => x.Id == paraObject.Id);
if (searchItem != null)
{
if (searchItem.Account.ToLower() == MagicHelper.開發者帳號)
{
return(VerifyRecordResultFactory.Build(false, ErrorMessageEnum.開發者帳號不可以被修改));
}
}
else
{
return(VerifyRecordResultFactory.Build(false, ErrorMessageEnum.要更新的紀錄_發生同時存取衝突_已經不存在資料庫上));
}
searchItem = await context.MyUser
.AsNoTracking()
.FirstOrDefaultAsync(x => x.Account == paraObject.Account &&
x.Id != paraObject.Id);
if (searchItem != null)
{
return(VerifyRecordResultFactory.Build(false, ErrorMessageEnum.要修改的紀錄已經存在無法修改));
}
return(VerifyRecordResultFactory.Build(true));
}
public async Task <VerifyRecordResult> BeforeAddCheckAsync(MenuDataAdapterModel paraObject)
{
CleanTrackingHelper.Clean <MenuData>(context);
if (paraObject.MenuRoleId == 0)
{
return(VerifyRecordResultFactory.Build(false, ErrorMessageEnum.尚未輸入功能表的角色));
}
var item = await context.MenuData
.AsNoTracking()
.FirstOrDefaultAsync(x => x.MenuRoleId == paraObject.MenuRoleId &&
x.Name == paraObject.Name);
if (item != null)
{
return(VerifyRecordResultFactory.Build(false, ErrorMessageEnum.該功能項目已經存在該功能表的角色));
}
return(VerifyRecordResultFactory.Build(true));
}
public async Task <VerifyRecordResult> BeforeAddCheckAsync(PolicyDetailAdapterModel paraObject)
{
CleanTrackingHelper.Clean <PolicyDetail>(context);
if (paraObject.MyUserId == 0)
{
return(VerifyRecordResultFactory.Build(false, "需要指定一個使用者"));
}
var item = await context.PolicyDetail
.AsNoTracking()
.FirstOrDefaultAsync(x => x.PolicyHeaderId == paraObject.PolicyHeaderId &&
x.MyUserId == paraObject.MyUserId);
if (item != null)
{
return(VerifyRecordResultFactory.Build(false, "同一個簽核政策內，使用者不能重複指定"));
}
return(VerifyRecordResultFactory.Build(true));
}
public async Task <VerifyRecordResult> BeforeAddCheckAsync(OrderItemAdapterModel paraObject)
{
CleanTrackingHelper.Clean <OrderItem>(context);
if (paraObject.ProductId == 0)
{
return(VerifyRecordResultFactory.Build(false, ErrorMessageEnum.尚未輸入該訂單要用到的產品));
}
var item = await context.OrderItem
.AsNoTracking()
.FirstOrDefaultAsync(x => x.OrderMasterId == paraObject.OrderMasterId &&
x.ProductId == paraObject.ProductId);
if (item != null)
{
return(VerifyRecordResultFactory.Build(false, ErrorMessageEnum.該訂單已經存在該產品_不能重複同樣的商品在一訂單內));
}
return(VerifyRecordResultFactory.Build(true));
}
public async Task <VerifyRecordResult> AddAsync(ExceptionRecordAdapterModel paraObject)
{
ExceptionRecord itemParameter = Mapper.Map <ExceptionRecord>(paraObject);
CleanTrackingHelper.Clean <ExceptionRecord>(context);
try
{
await context.ExceptionRecord
.AddAsync(itemParameter);
await context.SaveChangesAsync();
}
catch (Exception ex)
{
Console.WriteLine(ex.Message);
}
CleanTrackingHelper.Clean <ExceptionRecord>(context);
return(VerifyRecordResultFactory.Build(true));
}
public async Task <bool> CheckUserShowActionAsync(FlowMasterAdapterModel flowMasterAdapterModel,
CurrentUser currentUser)
{
CleanTrackingHelper.Clean <FlowMaster>(context);
CleanTrackingHelper.Clean <FlowUser>(context);
CleanTrackingHelper.Clean <FlowHistory>(context);
CleanTrackingHelper.Clean <MyUser>(context);
(var flowUsers, var user) = await GetUsersDataByActionAsync(flowMasterAdapterModel, currentUser);
flowMasterAdapterModel.UserShowAction = CheckCurrentActionUser(flowUsers, user, flowMasterAdapterModel);
CleanTrackingHelper.Clean <FlowMaster>(context);
CleanTrackingHelper.Clean <FlowUser>(context);
CleanTrackingHelper.Clean <FlowHistory>(context);
CleanTrackingHelper.Clean <MyUser>(context);
return(flowMasterAdapterModel.UserShowAction);
}
public async Task <VerifyRecordResult> BeforeUpdateCheckAsync(PhaseMessageAdapterModel paraObject)
{
CleanTrackingHelper.Clean <PhaseMessage>(context);
if (paraObject.PhaseCategoryId == 0)
{
return(VerifyRecordResultFactory.Build(false, "需要指定一個片語分類"));
}
var searchItem = await context.PhaseMessage
.AsNoTracking()
.FirstOrDefaultAsync(x => x.Id == paraObject.Id);
if (searchItem == null)
{
return(VerifyRecordResultFactory.Build(false, ErrorMessageEnum.要更新的紀錄_發生同時存取衝突_已經不存在資料庫上));
}
return(VerifyRecordResultFactory.Build(true));
}
public async Task <VerifyRecordResult> AddAsync(MyUserAdapterModel paraObject)
{
try
{
MyUser itemParameter = Mapper.Map <MyUser>(paraObject);
CleanTrackingHelper.Clean <MyUser>(context);
await context.MyUser
.AddAsync(itemParameter);
await context.SaveChangesAsync();
CleanTrackingHelper.Clean <MyUser>(context);
return(VerifyRecordResultFactory.Build(true));
}
catch (Exception ex)
{
Logger.LogError(ex, "新增記錄發生例外異常");
return(VerifyRecordResultFactory.Build(false, "新增記錄發生例外異常", ex));
}
}
public async Task <bool> DeleteAsync(Order paraObject)
{
Order item = await context.Order
.AsNoTracking()
.FirstOrDefaultAsync(x => x.OrderId == paraObject.OrderId);
if (item == null)
{
return(false);
}
else
{
CleanTrackingHelper.Clean <Order>(context);
context.Entry(paraObject).State = EntityState.Deleted;
await context.SaveChangesAsync();
CleanTrackingHelper.Clean <Order>(context);
return(true);
}
}
public async Task <bool> DeleteAsync(StudentGrade paraObject)
{
StudentGrade item = await context.StudentGrade
.AsNoTracking()
.FirstOrDefaultAsync(x => x.EnrollmentId == paraObject.EnrollmentId);
if (item == null)
{
return(false);
}
else
{
CleanTrackingHelper.Clean <StudentGrade>(context);
context.Entry(item).State = EntityState.Deleted;
await context.SaveChangesAsync();
CleanTrackingHelper.Clean <StudentGrade>(context);
return(true);
}
}
private async Task <List <Product> > 建立產品紀錄Async()
{
CleanTrackingHelper.Clean <Product>(context);
CleanTrackingHelper.Clean <OrderMaster>(context);
CleanTrackingHelper.Clean <OrderItem>(context);
List <Product> products = new List <Product>();
for (int i = 0; i < 10; i++)
{
Product product = new Product()
{
Name = $"Product{i}"
};
products.Add(product);
context.Add(product);
}
await context.SaveChangesAsync();
return(products);
}
public async Task SendAsync(FlowMasterAdapterModel flowMasterAdapterModel,
ApproveOpinionModel approveOpinionModel)
{
CleanTrackingHelper.Clean <FlowMaster>(context);
CleanTrackingHelper.Clean <FlowUser>(context);
CleanTrackingHelper.Clean <FlowHistory>(context);
CleanTrackingHelper.Clean <MyUser>(context);
(var flowUsers, var user) = await GetUsersDataAsync(flowMasterAdapterModel);
if (user.Id != flowMasterAdapterModel.MyUserId)
{
return;
}
var flowUser = flowUsers.FirstOrDefault(x => x.Level == 0);
flowUser.Completion = true;
flowMasterAdapterModel.ProcessLevel = 1;
flowMasterAdapterModel.Status = 1;
CopyUserAutoCompletion(flowUsers, flowMasterAdapterModel.ProcessLevel);
FindNextActionUser(flowUsers, flowMasterAdapterModel);
await context.BulkUpdateAsync(flowUsers);
await UpdateAsync(flowMasterAdapterModel);
await AddHistoryRecord(user, flowMasterAdapterModel,
$"{approveOpinionModel.Summary}", $"{approveOpinionModel.Comment}", true);
#region 產生收件匣紀錄
await NotifyInboxUsers(flowUsers, flowMasterAdapterModel, flowMasterAdapterModel.ProcessLevel);
#endregion
CleanTrackingHelper.Clean <FlowMaster>(context);
CleanTrackingHelper.Clean <FlowUser>(context);
CleanTrackingHelper.Clean <FlowHistory>(context);
CleanTrackingHelper.Clean <MyUser>(context);
}
public async Task BackToSendAsync(FlowMasterAdapterModel flowMasterAdapterModel,
ApproveOpinionModel approveOpinionModel)
{
CleanTrackingHelper.Clean <FlowMaster>(context);
CleanTrackingHelper.Clean <FlowUser>(context);
CleanTrackingHelper.Clean <FlowHistory>(context);
CleanTrackingHelper.Clean <MyUser>(context);
(var flowUsers, var user) = await GetUsersDataAsync(flowMasterAdapterModel);
if (CheckCurrentActionUser(flowUsers, user, flowMasterAdapterModel) == false)
{
return;
}
foreach (var item in flowUsers)
{
item.Completion = false;
}
flowMasterAdapterModel.ProcessLevel = 0;
flowMasterAdapterModel.Status = 0;
FindNextActionUser(flowUsers, flowMasterAdapterModel);
await context.BulkUpdateAsync(flowUsers);
await UpdateAsync(flowMasterAdapterModel);
await AddHistoryRecord(user, flowMasterAdapterModel,
$"{approveOpinionModel.Summary}", $"{approveOpinionModel.Comment}", false);
#region 產生收件匣紀錄
await NotifyInboxUsers(flowUsers, flowMasterAdapterModel, flowMasterAdapterModel.ProcessLevel);
#endregion
CleanTrackingHelper.Clean <FlowMaster>(context);
CleanTrackingHelper.Clean <FlowUser>(context);
CleanTrackingHelper.Clean <FlowHistory>(context);
CleanTrackingHelper.Clean <MyUser>(context);
}
async Task CountingWorkingHour(int WorkingLogId)
{
CleanTrackingHelper.Clean <WorkingLog>(context);
var totalHours = await context.WorkingLogDetail
.AsNoTracking()
.Where(x => x.WorkingLogId == WorkingLogId)
.SumAsync(x => x.Hours);
var item = await context.WorkingLog
.AsNoTracking()
.FirstOrDefaultAsync(x => x.Id == WorkingLogId);
if (item != null)
{
item.TotalHours = totalHours;
context.Update(item);
await context.SaveChangesAsync();
CleanTrackingHelper.Clean <WorkingLog>(context);
}
}
