public async Task <FindResponse <CaseWorkerTaskAggregate> > Find(FindCaseWorkerTasksParameter parameter, CancellationToken token)
{
using (var lck = await _caseManagementDbContext.Lock())
{
IQueryable <CaseWorkerTaskModel> result = _caseManagementDbContext.CaseWorkers.Include(_ => _.Roles);
if (parameter.Claims != null && parameter.Claims.Any())
{
var roles = await GetRoles(parameter.Claims, token);
var roleIds = roles.Where(_ => _.RoleId != null).Select(_ => _.RoleId.Value);
result = result.Where(_ => _.Roles.Any(r => roleIds.Contains(r.Id)));
}
if (MAPPING_ACTIVATIONENAME_TO_PROPERTYNAME.ContainsKey(parameter.OrderBy))
{
result = result.InvokeOrderBy(MAPPING_ACTIVATIONENAME_TO_PROPERTYNAME[parameter.OrderBy], parameter.Order);
}
int totalLength = result.Count();
result = result.Skip(parameter.StartIndex).Take(parameter.Count);
var content = await result.ToListAsync(token);
return(new FindResponse <CaseWorkerTaskAggregate>
{
StartIndex = parameter.StartIndex,
Count = parameter.Count,
TotalLength = totalLength,
Content = content.Select(_ => _.ToDomain()).ToList()
});
}
}
public async Task Update(CasePlanInstanceAggregate workflowInstance, CancellationToken token)
{
using (var lck = await _dbContext.Lock())
{
var record = await _dbContext.CasePlanInstances
.Include(_ => _.Roles).ThenInclude(_ => _.Claims)
.Include(_ => _.Files)
.Include(_ => _.WorkerTasks)
.Include(_ => _.Children).ThenInclude(_ => _.Children)
.FirstOrDefaultAsync(_ => _.Id == workflowInstance.AggregateId, token);
if (record == null)
{
return;
}
_dbContext.Roles.RemoveRange(record.Roles);
_dbContext.CasePlanInstanceWorkerTaskLst.RemoveRange(record.WorkerTasks);
_dbContext.CasePlanElementInstanceLst.RemoveRange(record.Children);
_dbContext.CasePlanInstanceFileItemLst.RemoveRange(record.Files);
record.CaseState = (int?)workflowInstance.State;
record.Version = workflowInstance.Version;
record.Name = workflowInstance.Name;
record.ExecutionContext = workflowInstance.ExecutionContext == null ? null : JsonConvert.SerializeObject(workflowInstance.ExecutionContext);
record.Roles = workflowInstance.Roles.Select(_ => _.ToModel(workflowInstance.AggregateId)).ToList();
record.Files = workflowInstance.Files.Select(_ => _.ToModel(workflowInstance.AggregateId)).ToList();
record.WorkerTasks = workflowInstance.WorkerTasks.Select(_ => _.ToModel(workflowInstance.AggregateId)).ToList();
record.Children = workflowInstance.Children == null ? new List <CasePlanElementInstanceModel>() : workflowInstance.Children.Select(_ => _.ToModel(workflowInstance.AggregateId)).ToList();
record.UpdateDateTime = workflowInstance.UpdateDateTime;
}
}
public async Task <FindResponse <CasePlanInstanceAggregate> > Find(FindCasePlanInstancesParameter parameter, CancellationToken token)
{
using (var lck = await _dbContext.Lock())
{
IQueryable <CasePlanInstanceModel> result = _dbContext.CasePlanInstances
.Include(_ => _.Roles).ThenInclude(_ => _.Claims)
.Include(_ => _.Files)
.Include(_ => _.WorkerTasks)
.Include(_ => _.Children).ThenInclude(_ => _.Children);
if (!string.IsNullOrWhiteSpace(parameter.CasePlanId))
{
result = result.Where(r => r.CasePlanId == parameter.CasePlanId);
}
if (MAPPING_WORKFLOWINSTANCE_TO_PROPERTYNAME.ContainsKey(parameter.OrderBy))
{
result = result.InvokeOrderBy(MAPPING_WORKFLOWINSTANCE_TO_PROPERTYNAME[parameter.OrderBy], parameter.Order);
}
int totalLength = result.Count();
result = result.Skip(parameter.StartIndex).Take(parameter.Count);
var content = await result.ToListAsync();
return(new FindResponse <CasePlanInstanceAggregate>
{
StartIndex = parameter.StartIndex,
Count = parameter.Count,
TotalLength = totalLength,
Content = content.Select(_ => _.ToDomain()).ToList()
});
}
}
public async Task <int> Count(CancellationToken token)
{
using (var lck = await _caseManagementDbContext.Lock())
{
var result = await _caseManagementDbContext.CaseFiles.CountAsync(token);
return(result);
}
}
public async Task <Subscription> Get(string casePlanInstanceId, string casePlanElementInstanceId, string evtName, CancellationToken token)
{
using (await _dbContext.Lock())
{
var result = await _dbContext.SubscriptionLst.FirstOrDefaultAsync(_ => _.CasePlanInstanceId == casePlanInstanceId && _.CasePlanElementInstanceId == casePlanElementInstanceId && _.EventName == evtName, token);
return(result == null ? null : result.ToDomain());
}
}
public async Task Queue(QueueMessage message, CancellationToken token)
{
using (var lck = await _dbContext.Lock())
{
_dbContext.QueueMessageLst.Add(new Models.QueueMessageModel
{
CreateDateTime = message.CreationDateTime,
SerializedContent = message.SerializedContent,
QueueName = message.QueueName
});
await _dbContext.SaveChangesAsync(token);
}
}
public async Task <FindResponse <CasePlanAggregate> > Find(FindCasePlansParameter parameter, CancellationToken token)
{
using (var lck = await _dbContext.Lock())
{
IQueryable <CasePlanModel> result = _dbContext.CasePlans
.Include(cp => cp.Roles).ThenInclude(cp => cp.Claims)
.Include(cp => cp.Files);
if (MAPPING_WORKFLOWDEFINITION_TO_PROPERTYNAME.ContainsKey(parameter.OrderBy))
{
result = result.InvokeOrderBy(MAPPING_WORKFLOWDEFINITION_TO_PROPERTYNAME[parameter.OrderBy], parameter.Order);
}
if (!string.IsNullOrWhiteSpace(parameter.CaseFileId))
{
result = result.Where(r => r.CaseFileId == parameter.CaseFileId);
}
if (!string.IsNullOrWhiteSpace(parameter.Text))
{
result = result.Where(r => r.Name.IndexOf(parameter.Text, StringComparison.InvariantCultureIgnoreCase) >= 0);
}
if (!string.IsNullOrWhiteSpace(parameter.CaseOwner))
{
result = result.Where(r => r.CaseOwner == parameter.CaseOwner);
}
if (!string.IsNullOrWhiteSpace(parameter.CasePlanId))
{
result = result.Where(r => r.CasePlanId == parameter.CasePlanId);
}
int totalLength = result.Count();
result = result.Skip(parameter.StartIndex).Take(parameter.Count);
var content = await result.ToListAsync(token);
if (parameter.TakeLatest)
{
content = content.OrderByDescending(r => r.Version).GroupBy(r => r.CasePlanId).Select(r => r.First()).ToList();
}
return(new FindResponse <CasePlanAggregate>
{
StartIndex = parameter.StartIndex,
Count = parameter.Count,
TotalLength = totalLength,
Content = content.Select(_ => _.ToDomain()).ToList()
});
}
}
public async Task Delete(CaseFileAggregate caseFile, CancellationToken token)
{
using (var lck = await _caseManagementDbContext.Lock())
{
var record = await _caseManagementDbContext.CaseFiles.FirstOrDefaultAsync(_ => _.Id == caseFile.AggregateId, token);
if (record == null)
{
return;
}
_caseManagementDbContext.CaseFiles.Remove(record);
}
}
public async Task Delete(CasePlanAggregate workflowDefinition, CancellationToken token)
{
using (var lck = await _dbContext.Lock())
{
var result = await _dbContext.CasePlans.FirstOrDefaultAsync(_ => _.Id == workflowDefinition.AggregateId, token);
if (result == null)
{
return;
}
_dbContext.CasePlans.Remove(result);
}
}
public async Task Delete(CaseWorkerTaskAggregate caseWorkerTask, CancellationToken token)
{
using (var lck = await _caseManagementDbContext.Lock())
{
var record = await _caseManagementDbContext.CaseWorkers.Include(_ => _.Roles)
.FirstOrDefaultAsync(_ => _.Id == caseWorkerTask.AggregateId, token);
if (record == null)
{
return;
}
_caseManagementDbContext.Roles.RemoveRange(record.Roles);
_caseManagementDbContext.CaseWorkers.Remove(record);
}
}
public async Task <FindResponse <CaseWorkerTaskAggregate> > Find(FindCaseWorkerTasksParameter parameter, CancellationToken token)
{
using (var lck = await _caseManagementDbContext.Lock())
{
IQueryable <CaseWorkerTaskModel> result = _caseManagementDbContext.CaseWorkers;
if (MAPPING_ACTIVATIONENAME_TO_PROPERTYNAME.ContainsKey(parameter.OrderBy))
{
result = result.InvokeOrderBy(MAPPING_ACTIVATIONENAME_TO_PROPERTYNAME[parameter.OrderBy], parameter.Order);
}
int totalLength = result.Count();
result = result.Skip(parameter.StartIndex).Take(parameter.Count);
var content = await result.ToListAsync(token);
return(new FindResponse <CaseWorkerTaskAggregate>
{
StartIndex = parameter.StartIndex,
Count = parameter.Count,
TotalLength = totalLength,
Content = content.Select(_ => _.ToDomain()).ToList()
});
}
}
