public async Task <FlowResult <PagedList <FlowType> > > GetPagedTypesByEntityAsync(Type entityType,
PageOptions pageOptions)
{
try
{
Logger.LogInfo("try to get paged list of types.");
var typeSet = StateManager.GetFlowSet <FlowType>();
var stateSet = StateManager.GetFlowSet <FlowState>();
var query = from type in typeSet.GetAll()
let states = stateSet.GetAll().Where(x => x.TypeId == type.Id)
where type.EntityType.Equals(entityType.FullName)
select new FlowType()
{
CreatedAt = type.CreatedAt,
Deleted = type.Deleted,
EntityPayloadType = type.EntityPayloadType,
EntityType = type.EntityType,
Id = type.Id,
ModifiedAt = type.ModifiedAt,
Name = type.Name,
States = states.ToList()
};
var pagedList = await typeSet.ToPagedListAsync(query, pageOptions);
var result = new FlowResult <PagedList <FlowType> >();
result.SetResult(pagedList);
Logger.LogInfo($"paged list of types with count '{pagedList.Count}' fetched.");
return(result);
}
catch (Exception ex)
{
Logger.LogError(ex.Message);
return(FlowResult <PagedList <FlowType> > .Failed(new FlowError(ex.Message)));
}
}
public async Task <FlowResult <IEnumerable <FlowType> > > GetTypesAsync()
{
try
{
Logger.LogInfo("try to get list of types.");
var typeSet = StateManager.GetFlowSet <FlowType>();
var stateSet = StateManager.GetFlowSet <FlowState>();
var query = from type in typeSet.GetAll()
let states = stateSet.GetAll().Where(x => x.TypeId == type.Id)
select new FlowType()
{
CreatedAt = type.CreatedAt,
Deleted = type.Deleted,
EntityPayloadType = type.EntityPayloadType,
EntityType = type.EntityType,
Id = type.Id,
ModifiedAt = type.ModifiedAt,
Name = type.Name,
States = states.ToList()
};
var types = await typeSet.ToListAsync(query);
var result = new FlowResult <IEnumerable <FlowType> >();
result.SetResult(types);
Logger.LogInfo($"list of types with count '{types.Count()}' fetched.");
return(result);
}
catch (Exception ex)
{
Logger.LogError(ex.Message);
return(FlowResult <IEnumerable <FlowType> > .Failed(new FlowError(ex.Message)));
}
}
public async Task <FlowResult <FlowState> > GetStateAsync(
Expression <Func <FlowState, bool> > expression)
{
try
{
Logger.LogInfo("try to get a state of flow by expression.");
var stateSet = StateManager.GetFlowSet <FlowState>();
var state = await stateSet.FirstOrDefaultAsync(expression);
if (state == null)
{
Logger.LogWarning("state not exist.");
return(FlowResult <FlowState> .Failed(
new FlowError(FlowErrors.ItemNotFound, args : nameof(FlowState))));
}
var result = new FlowResult <FlowState>();
result.SetResult(state);
Logger.LogInfo($"state with id '{state.Id}' fetched.");
return(result);
}
catch (Exception ex)
{
Logger.LogError(ex.Message);
return(FlowResult <FlowState> .Failed(new FlowError(ex.Message)));
}
}
public async Task <FlowResult <FlowInstance> > GetInstanceAsync(
Expression <Func <FlowInstance, bool> > expression)
{
try
{
Logger.LogInfo("try to get an instance of flow by expression.");
var instanceSet = StateManager.GetFlowSet <FlowInstance>();
var instance = await instanceSet.FirstOrDefaultAsync(expression);
if (instance == null)
{
Logger.LogWarning("instance not exist.");
return(FlowResult <FlowInstance> .Failed(
new FlowError(FlowErrors.ItemNotFound, args : nameof(FlowInstance))));
}
var result = new FlowResult <FlowInstance>();
if (instance.Active == false)
{
Logger.LogWarning("instance is inactive");
result.Warns.Add(new FlowWarn(FlowWarns.InstanceInactive));
}
result.SetResult(instance);
Logger.LogInfo($"instance with id '{instance.Id}' fetched.");
return(result);
}
catch (Exception ex)
{
Logger.LogError(ex.Message);
return(FlowResult <FlowInstance> .Failed(new FlowError(ex.Message)));
}
}
public async Task <FlowResult <FlowType> > GetTypeAsync(
Expression <Func <FlowType, bool> > expression)
{
try
{
Logger.LogInfo("try to get a type of flow by expression.");
var typeSet = StateManager.GetFlowSet <FlowType>();
var stateSet = StateManager.GetFlowSet <FlowState>();
var query = from type in typeSet.GetAll()
let states = stateSet.GetAll().Where(x => x.TypeId == type.Id)
select new FlowType()
{
CreatedAt = type.CreatedAt,
Deleted = type.Deleted,
EntityPayloadType = type.EntityPayloadType,
EntityType = type.EntityType,
Id = type.Id,
ModifiedAt = type.ModifiedAt,
Name = type.Name,
States = states.ToList()
};
query = query.Where(expression);
var flowType = await typeSet.FirstOrDefaultAsync(query);
if (flowType == null)
{
Logger.LogWarning("type not exist.");
return(FlowResult <FlowType> .Failed(
new FlowError(FlowErrors.ItemNotFound, args : nameof(FlowType))));
}
var result = new FlowResult <FlowType>();
result.SetResult(flowType);
Logger.LogInfo($"type with id '{flowType.Id}' fetched.");
return(result);
}
catch (Exception ex)
{
Logger.LogError(ex.Message);
return(FlowResult <FlowType> .Failed(new FlowError(ex.Message)));
}
}
public async Task <FlowResult <FlowType> > GetTypeByIdAsync(Guid id)
{
try
{
Logger.LogInfo("try to get a type of flow by id.");
var typeSet = StateManager.GetFlowSet <FlowType>();
var stateSet = StateManager.GetFlowSet <FlowState>();
var query = from type in typeSet.GetAll()
join state in stateSet.GetAll() on type.Id equals state.TypeId into states
where type.Id.Equals(id)
select new FlowType()
{
CreatedAt = type.CreatedAt,
Deleted = type.Deleted,
EntityPayloadType = type.EntityPayloadType,
EntityType = type.EntityType,
Id = type.Id,
ModifiedAt = type.ModifiedAt,
Name = type.Name,
States = states.ToList()
};
var flowType = await typeSet.FirstOrDefaultAsync(query);
if (flowType == null)
{
Logger.LogWarning("type not exist.");
return(FlowResult <FlowType> .Failed(
new FlowError(FlowErrors.ItemNotFound, args : nameof(FlowType))));
}
var result = new FlowResult <FlowType>();
result.SetResult(flowType);
Logger.LogInfo($"type with id '{flowType.Id}' fetched.");
return(result);
}
catch (Exception ex)
{
Logger.LogError(ex.Message);
return(FlowResult <FlowType> .Failed(new FlowError(ex.Message)));
}
}
public async Task <FlowResult <IEnumerable <FlowState> > > GetStatesByTypeIdAsync(Guid flowTypeId)
{
try
{
Logger.LogInfo($"try to get states of a flow type by id '{flowTypeId}'.");
var stateSet = StateManager.GetFlowSet <FlowState>();
var query = stateSet.GetAll()
.Where(x => x.TypeId == flowTypeId);
var states = await stateSet.ToListAsync(query);
var result = new FlowResult <IEnumerable <FlowState> >();
result.SetResult(states);
Logger.LogInfo($"list of flow states of flow type with id '{flowTypeId}' has been fetched.");
return(result);
}
catch (Exception ex)
{
Logger.LogError(ex.Message);
return(FlowResult <IEnumerable <FlowState> > .Failed(new FlowError(ex.Message)));
}
}
