public async Task <FlowResult <FlowInstance> > DoAsync(InitFlowModel model) { var taskResult = await InstanceService.CreateFlowInstanceAsync(model); var transitionSet = _stateManager.GetFlowSet <FlowTransition>(); var startTransition = await transitionSet .FirstOrDefaultAsync(x => x.TypeId.Equals(taskResult.Result.TypeId) && x.TransitionType == FlowTransitionTypes.Start); if (startTransition == null) { return(FlowResult <FlowInstance> .Failed(new FlowError(FlowErrors.ItemNotFound, "Start transition"))); } var stepResult = await StepService.CreateFlowStepAsync(new MoveModel() { Comment = null, IdentityId = model.InitializerId, InstanceId = taskResult.Result.Id, Payload = null, TransitionId = startTransition.Id }); return(taskResult.Merge(stepResult)); }
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 IEnumerable<TargetFlow> TargetFlows(string client, string flowCodeOrTargetType, DateTime? beginTime = null, DateTime? endTime = null, bool? started = null, bool? completed = null, FlowResult? result = null, bool loadAllInfo = true) { var query = flowManager.LoadFlows(); query = query.Where(o => o.Flow.ClientId == client && (o.Flow.Code == flowCodeOrTargetType || o.Flow.TargetType == flowCodeOrTargetType)); if(beginTime.HasValue) query = query.Where(o => o.CreateTime >= beginTime.Value); if(endTime.HasValue) query = query.Where(o => o.CreateTime <= endTime.Value); if(started.HasValue) query = query.Where(o => o.HasStarted == started.Value); if(completed.HasValue) query = query.Where(o => o.HasCompleted == completed.Value); if(result.HasValue) query = query.Where(o => o.Result == result.Value); var ids = query.Select(o => o.TargetFlowId).ToArray(); List<TargetFlow> tflows = new List<TargetFlow>(); foreach(var id in ids) { var tflow = flowManager.LoadFlow(id, loadAllInfo); tflows.Add(tflow); } return tflows; }
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))); } }
private async Task <FlowResult> ValidateSourceDestinationAsync(IStateManager stateManager, MoveModel model) { var transitionSet = stateManager.GetFlowSet <FlowTransition>(); var transition = await transitionSet.GetByIdAsync(model.TransitionId); if (transition == null) { return(FlowResult.Failed( new FlowError(FlowErrors.ItemNotFound, args: nameof(FlowTransition)))); } var stateSet = stateManager.GetFlowSet <FlowState>(); if (transition.SourceId.HasValue == true) { var source = await stateSet.GetByIdAsync(transition.SourceId.Value); if (source == null) { return(FlowResult.Failed(new FlowError(FlowErrors.ItemNotFound, args: nameof(source)))); } } var destination = await stateSet.GetByIdAsync(transition.DestinationId); if (destination == null) { return(FlowResult.Failed(new FlowError(FlowErrors.ItemNotFound, args: nameof(destination)))); } return(FlowResult.Success); }
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 FlowResult CallFlow(object flowName, dynamic values, string partner = null, string context = null) { if (!(flowName is string flowNameText)) { throw new ApplicationException($"{nameof(CallFlow)}: {nameof(flowName)} must be a string"); } // Always go to start of called flow var stepId = "1"; chatModel.CurrentState.GetFlowAnswers(flowNameText)["params"] = ConvertToNative(values); chatModel.CurrentState.GetFlowAnswers(flowNameText)["result"] = null; var resultPlaceholder = new FlowResult(); SetProperty("ChildResultPlaceholder", resultPlaceholder); SetChildFlow(flowName, stepId); // TODO: Need to track state, to jump back partner/context if (!String.IsNullOrEmpty(partner) && !String.IsNullOrEmpty(context)) { ChangeContext(partner, context); } return(resultPlaceholder); }
public async Task <FlowResult <FlowState> > CreateFlowStateAsync(InitFlowStateModel model) { var set = StateManager.GetFlowSet <FlowState>(); var typeSet = StateManager.GetFlowSet <FlowType>(); var type = await typeSet.GetByIdAsync(model.TypeId); if (type == null) { return(FlowResult <FlowState> .Failed(new FlowError(FlowErrors.ItemNotFound, nameof(type)))); } var entity = FlowEntity.InitializeType(new FlowState() { Name = model.Name, Title = model.Title, StateType = (byte)model.StateType, TypeId = type.Id, Tag = model.Tag, }); var result = await set.CreateAsync(entity); return(FlowResult <FlowState> .Successful(result)); }
public async Task <FlowResult <FlowInstance> > CreateFlowInstanceAsync(InitFlowModel model) { var set = StateManager.GetFlowSet <FlowInstance>(); var typeSet = StateManager.GetFlowSet <FlowType>(); var type = await typeSet.GetByIdAsync(model.TypeId); if (type == null) { return(FlowResult <FlowInstance> .Failed(new FlowError(FlowErrors.ItemNotFound, nameof(type)))); } var entity = FlowEntity.InitializeType(new FlowInstance() { Title = model.Title, Payload = model.Payload, TypeId = type.Id, InitializerId = model.InitializerId, AccessPhrase = model.AccessPhrase, }); var result = await set.CreateAsync(entity); return(FlowResult <FlowInstance> .Successful(result)); }
public Task <FlowResult> ValidateAsync(IStateManager stateManager, InitFlowModel model) { FlowResult result = new FlowResult(); if (model.Title.StringIsEmpty()) { result.Errors.Add(new FlowError(FlowErrors.ServiceIsRequired, args: nameof(model.Title))); } if (model.InitializerId.StringIsEmpty()) { result.Errors.Add(new FlowError(FlowErrors.ServiceIsRequired, args: nameof(model.InitializerId))); } if (model.AccessPhrase.StringIsEmpty()) { result.Warns.Add(new FlowWarn(FlowErrors.ServiceIsEmpty, args: nameof(model.AccessPhrase))); } if (model.Payload.StringIsEmpty()) { result.Warns.Add(new FlowWarn(FlowMessages.ItemAlreadyexist, args: nameof(model.Payload))); } return(Task.FromResult(result)); }
public async Task <FlowResult> ValidateAsync(IStateManager stateManager, InitFlowTypeModel model) { FlowResult result = new FlowResult(); if (string.IsNullOrWhiteSpace(model.Name)) { result.Errors.Add(new FlowError(FlowErrors.ServiceIsRequired, args: nameof(model.Name))); } if (model.EntityPayloadType == null) { result.Errors.Add(new FlowError(FlowErrors.ServiceIsRequired, args: nameof(model.EntityPayloadType))); } if (model.EntityType == null) { result.Errors.Add(new FlowError(FlowErrors.ServiceIsRequired, args: nameof(model.EntityType))); } if (await DuplicateNameExistAsync(stateManager, model)) { result.Errors.Add(new FlowError(FlowMessages.ItemAlreadyexist, args: "Name")); } return(result); }
public async Task <FlowResult> ValidateAsync(IStateManager stateManager, InitFlowStateModel model) { FlowResult result = new FlowResult(); if (model.Name.StringIsEmpty()) { result.Errors.Add(new FlowError(FlowErrors.ServiceIsRequired, args: nameof(model.Name))); } if (model.Title.StringIsEmpty()) { result.Errors.Add(new FlowError(FlowErrors.ServiceIsRequired, args: nameof(model.Title))); } if (model.Tag.StringIsEmpty()) { result.Warns.Add(new FlowWarn(FlowErrors.ServiceIsEmpty, args: nameof(model.Tag))); } if (model.TypeId.GuidIsEmpty()) { result.Errors.Add(new FlowError(FlowErrors.ServiceIsRequired, args: nameof(model.TypeId))); } if (await TypeNotExistAsync(stateManager, model.TypeId)) { result.Errors.Add(new FlowError(FlowErrors.ItemNotFound, args: "Type")); } return(result); }
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 <FlowTransition> > CreateFlowTransitionAsync(InitFlowTransitionModel model) { var set = StateManager.GetFlowSet <FlowTransition>(); var stateSet = StateManager.GetFlowSet <FlowState>(); var source = await stateSet.GetByIdAsync(model.SourceId); if (source == null) { return(FlowResult <FlowTransition> .Failed(new FlowError(FlowErrors.ItemNotFound, nameof(source)))); } var destination = await stateSet.GetByIdAsync(model.DestinationId); if (destination == null) { return(FlowResult <FlowTransition> .Failed(new FlowError(FlowErrors.ItemNotFound, nameof(destination)))); } var entity = FlowEntity.InitializeType(new FlowTransition() { Name = model.Name, Title = model.Title, SourceId = source.Id, DestinationId = destination.Id, TransitionType = model.TransitionType, TypeId = source.TypeId, }); var result = await set.CreateAsync(entity); return(FlowResult <FlowTransition> .Successful(result)); }
public static new FlowResult <TResult> Warn(params FlowWarn[] warns) { var result = new FlowResult <TResult>(); if (warns != null) { result.Warns.AddRange(warns); } return(result); }
public static new FlowResult <TResult> Failed(params FlowError[] errors) { var result = new FlowResult <TResult>(); if (errors != null) { result.Errors.AddRange(errors); } return(result); }
public new FlowResult <TResult> Merge(FlowResult secondResult) { var result = this; result.Errors.AddRange(secondResult.Errors); result.Warns.AddRange(secondResult.Warns); result.Succeeded = result.Succeeded && secondResult.Succeeded; result.Warned = result.Warned && secondResult.Warned; return(result); }
/// <summary> /// 处理结果 /// </summary> /// <param name="result"></param> protected override void AnalyzeResult(FlowResult result) { base.AnalyzeResult(result); if (allSuccessful == false) { result.ResultType = ResultType.MaybeSuccessful; } if (result.OutputData.Contains("not found")) { result.ResultType = ResultType.MaybeSuccessful; } }
private async Task <FlowResult> ValidatePossibleMoveAsync(IStateManager stateManager, MoveModel model) { var instanceSet = stateManager.GetFlowSet <FlowInstance>(); var instance = await instanceSet.GetByIdAsync(model.InstanceId); if (instance == null) { return(FlowResult.Failed(new FlowError(FlowErrors.ItemNotFound, args: nameof(FlowInstance)))); } var stepSet = stateManager.GetFlowSet <FlowStep>(); var instanceCurrentStep = await stepSet .FirstOrDefaultAsync(x => x.InstanceId.Equals(instance.Id) && x.IsCurrent); var transitionSet = stateManager.GetFlowSet <FlowTransition>(); var transition = await transitionSet.GetByIdAsync(model.TransitionId); if (transition == null) { return(FlowResult.Failed( new FlowError(FlowErrors.ItemNotFound, args: nameof(FlowTransition)))); } var instanceLastTransition = await transitionSet.GetByIdAsync(instanceCurrentStep.TransitionId); if (instanceCurrentStep == null) { return(FlowResult.Failed(new FlowError(FlowErrors.ItemNotFound, args: nameof(FlowTransition)))); } var stateSet = stateManager.GetFlowSet <FlowState>(); var state = await stateSet.GetByIdAsync(instanceLastTransition.DestinationId); if (state == null) { return(FlowResult.Failed(new FlowError(FlowErrors.ItemNotFound, args: nameof(state)))); } var possibleTransitions = await transitionSet.GetAllAsync(x => x.SourceId == state.Id); if (possibleTransitions.Select(x => x.Id).Contains(model.TransitionId) == false) { string sourceParam = transition.SourceId.HasValue ? transition.SourceId.Value.ToString() : FlowErrors.StateNull; string destinationParam = transition.DestinationId.ToString(); return(FlowResult.Failed(new FlowError(FlowErrors.MoveImpossibleTransition, sourceParam, destinationParam))); } return(FlowResult.Success); }
public async Task <FlowResult <FlowType> > CreateFlowTypeAsync(InitFlowTypeModel initModel) { var set = StateManager.GetFlowSet <FlowType>(); var entity = FlowEntity.InitializeType(new FlowType() { EntityType = initModel.EntityType.FullName, EntityPayloadType = initModel.EntityPayloadType.FullName, Name = initModel.Name, }); var resultTask = await set.CreateAsync(entity); return(FlowResult <FlowType> .Successful(resultTask)); }
public static FlowResult <TR> Run <T, TR>(this FlowResult <T> src, Func <T, Result <TR> > func) { return(async(handler) => { var data = await src(handler).ConfigureAwait(false); if (data.IsSuccess) { return await handler.Handle(() => func(data.Value).ToAsync()).ConfigureAwait(false); } return Result.Fail <TR>(data.Error); }); }
public async Task <FlowResult <IEnumerable <FlowTransition> > > GetSourceTransitionsAsync(Guid sourceId) { //Get current instance if (sourceId.GuidIsEmpty()) { throw new ArgumentNullException(nameof(sourceId)); } var stateSet = StateManager.GetFlowSet <FlowState>(); var targetSource = await stateSet .FirstOrDefaultAsync(x => x.Id.Equals(sourceId)); if (targetSource == null) { return(FlowResult <IEnumerable <FlowTransition> > .Failed(new FlowError(FlowErrors.ItemNotFound, args : nameof(FlowState)))); } var transitionSet = StateManager.GetFlowSet <FlowTransition>(); var typeSet = StateManager.GetFlowSet <FlowType>(); var reasonSet = StateManager.GetFlowSet <FlowTransitionReason>(); var query = from transition in transitionSet.GetAll() join type in typeSet.GetAll() on transition.TypeId equals type.Id join source in stateSet.GetAll() on transition.SourceId equals source.Id join destination in stateSet.GetAll() on transition.DestinationId equals destination.Id where transition.SourceId == sourceId select new FlowTransition() { Id = transition.Id, Type = type, CreatedAt = transition.CreatedAt, ModifiedAt = transition.ModifiedAt, Deleted = transition.Deleted, TypeId = transition.TypeId, Name = transition.Name, SourceId = transition.SourceId, DestinationId = transition.DestinationId, Destination = destination, IsAutomatic = transition.IsAutomatic, Source = source, Title = transition.Title, TransitionType = transition.TransitionType }; var transitions = await transitionSet.ToListAsync(query); return(FlowResult <IEnumerable <FlowTransition> > .Successful(transitions)); }
protected void HandleFlowResult <T>(FlowResult <T> flowResult) { if (flowResult != null && flowResult.Warned) { TempData["warning"] = flowResult.Warns; } else if (flowResult != null && flowResult.Succeeded == false) { TempData["error"] = flowResult.Errors; } else if (flowResult != null && flowResult.Succeeded) { TempData["success"] = true; } }
public async Task <FlowResult <FlowStep> > CreateFlowStepAsync(MoveModel model) { var set = StateManager.GetFlowSet <FlowStep>(); var instanceSet = StateManager.GetFlowSet <FlowInstance>(); var transitionSet = StateManager.GetFlowSet <FlowTransition>(); var stateSet = StateManager.GetFlowSet <FlowState>(); var instance = await instanceSet.GetByIdAsync(model.InstanceId); if (instance == null) { return(FlowResult <FlowStep> .Failed(new FlowError(FlowErrors.ItemNotFound, nameof(instance)))); } var transition = await transitionSet.GetByIdAsync(model.TransitionId); if (transition == null) { return(FlowResult <FlowStep> .Failed(new FlowError(FlowErrors.ItemNotFound, nameof(transition)))); } var state = await stateSet.GetByIdAsync(transition.DestinationId); if (state == null) { return(FlowResult <FlowStep> .Failed(new FlowError(FlowErrors.ItemNotFound, nameof(state)))); } var entity = FlowEntity.InitializeType(new FlowStep() { InstanceId = instance.Id, IsCurrent = true, TransitionId = transition.Id, Payload = model.Payload, Comment = model.Comment, CurrentStateName = state.Name, CurrentStateTitle = state.Title, CurrentStateType = state.StateType, }); var result = await set.CreateAsync(entity); return(FlowResult <FlowStep> .Successful(result)); }
public async Task <FlowResult <IEnumerable <FlowTransition> > > GetInstanceTransitionsAsync(Guid instanceId) { //Get current instance if (instanceId.GuidIsEmpty()) { throw new ArgumentNullException(nameof(instanceId)); } var instanceSet = StateManager.GetFlowSet <FlowInstance>(); var targetInstance = await instanceSet.FirstOrDefaultAsync(x => x.Id.Equals(instanceId)); if (targetInstance == null) { return(FlowResult <IEnumerable <FlowTransition> > .Failed(new FlowError(FlowErrors.ItemNotFound, args : nameof(FlowInstance)))); } //Get current instance state var stepSet = StateManager.GetFlowSet <FlowStep>(); var currentStep = await stepSet .FirstOrDefaultAsync(x => x.InstanceId.Equals(targetInstance.Id) && x.IsCurrent); if (currentStep == null) { return(FlowResult <IEnumerable <FlowTransition> > .Failed(new FlowError(FlowErrors.InstanceHasnostep))); } //Get current step transition var transitionSet = StateManager.GetFlowSet <FlowTransition>(); var currentTransition = await transitionSet .FirstOrDefaultAsync(x => x.Id.Equals(currentStep.TransitionId)); //Get current state var stateSet = StateManager.GetFlowSet <FlowState>(); var currentState = await stateSet.FirstOrDefaultAsync(x => x.Id.Equals(currentTransition.DestinationId)); //Get current state transitions var transitions = await transitionSet.GetAllAsync(x => x.SourceId.Equals(currentState.Id)); return(FlowResult <IEnumerable <FlowTransition> > .Successful(transitions)); }
public FlowResultWindow(FlowResult result, string message = null, string advise = null) { InitializeComponent(); SetTitle(result.ResultType); Owner = App.Current.MainWindow; TxtBMessage.Text = message ?? "Have a nice day!"; TxtBOutput.Text = result.OutputData.All.ToString(); if (advise == null) { TxtBAdvise.Visibility = Visibility.Hidden; TxtBAdviseTip.Visibility = Visibility.Hidden; } else { TxtBAdvise.Text = advise; } }
private async Task <FlowResult <TResultModel> > HandleRequestAsync <TModel, TResultModel>( IFlowRequest <TModel, TResultModel> request, TModel model) where TModel : class where TResultModel : class { try { Logger.LogInfo(FlowLogs.RequestStarted, args: model.GetType().Name); if (request == null) { throw new FlowException(FlowErrors.ServiceIsNull, nameof(request)); } var validator = ObjectActivator.GetValidator <TModel>(); var validateResult = await validator.ValidateAsync(StateManager, model); Logger.LogInfo(FlowLogs.RequestHasWarn, args: validateResult.Warns.Count.ToString()); Logger.LogInfo(FlowLogs.RequestHasError, args: validateResult.Errors.Count.ToString()); if (!validateResult.Succeeded) { return(FlowResult <TResultModel> .Failed(validateResult.Errors.ToArray())); } Logger.LogInfo(FlowLogs.RequestOperationStarted, args: model.GetType().Name); var requestResult = await request.DoAsync(model); Logger.LogInfo(FlowLogs.RequestOperationFinished, args: model.GetType().Name); if (validateResult.Warned) { requestResult.Warns.AddRange(validateResult.Warns); } Logger.LogInfo(FlowLogs.RequestFinished, args: model.GetType().Name); return(requestResult); } catch (Exception ex) { Logger.LogError(FlowLogs.ExceptionOccured, ex.Message); return(FlowResult <TResultModel> .Failed(new FlowError(FlowErrors.ErrorOccurred))); } }
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))); } }
private async Task <FlowResult> ValidateInstanceAsync(IStateManager stateManager, MoveModel model) { var instanceSet = stateManager.GetFlowSet <FlowInstance>(); var instance = await instanceSet.GetByIdAsync(model.InstanceId); if (instance == null) { return(FlowResult.Failed( new FlowError(FlowErrors.ItemNotFound, args: nameof(FlowInstance)))); } if (instance.Active == false) { return(FlowResult.Failed(new FlowError(FlowErrors.InstanceIsInactive))); } return(FlowResult.Success); }
public async Task <FlowResult <FlowStep> > DisableCurrentStepAsync(Guid instanceId) { var set = StateManager.GetFlowSet <FlowStep>(); var instanceSet = StateManager.GetFlowSet <FlowInstance>(); var instance = await instanceSet.GetByIdAsync(instanceId); if (instance == null) { return(FlowResult <FlowStep> .Failed(new FlowError(FlowErrors.ItemNotFound, nameof(instance)))); } var currentStep = await set.FirstOrDefaultAsync(x => x.InstanceId.Equals(instanceId) && x.IsCurrent); currentStep.IsCurrent = false; var updateResult = await set.UpdateAsync(currentStep); return(FlowResult <FlowStep> .Successful(updateResult)); }
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 IEnumerable<TargetFlowInfo> GetTargetFlows(string client, string flowCodeOrTargetType, DateTime? beginTime = null, DateTime? endTime = null, bool? started = null, bool? completed = null, FlowResult? result = null) { var query = repoTargetFlow.Query(o => o.Flow.ClientId == client && (o.Flow.Code == flowCodeOrTargetType || o.Flow.TargetType == flowCodeOrTargetType)); if (beginTime.HasValue) query = query.Where(o => o.CreateTime >= beginTime.Value); if (endTime.HasValue) query = query.Where(o => o.CreateTime <= endTime.Value); if (started.HasValue) query = query.Where(o => o.HasStarted == started.Value); if (completed.HasValue) query = query.Where(o => o.HasCompleted == completed.Value); if (result.HasValue) query = query.Where(o => o.Result == result.Value); query = query.OrderByDescending(o => o.CreateTime); var tflows = query.ToArray(); return tflows.Select(o => GetTargetFlow(o)); }
public IEnumerable<TargetFlowInfo> GetTargetFlows(string client, string flowCodeOrTargetType, DateTime? beginTime = null, DateTime? endTime = null, bool? started = null, bool? completed = null, FlowResult? result = null) { return svr.GetTargetFlows(client, flowCodeOrTargetType, beginTime, endTime, started, completed, result); }
public IEnumerable<TargetFlowInfo> GetTargetFlows(string client, string flowCodeOrTargetType, DateTime? beginTime = null, DateTime? endTime = null, bool? started = null, bool? completed = null, FlowResult? result = null) { Assert.IsStringNotNullOrEmpty(client); Assert.IsStringNotNullOrEmpty(flowCodeOrTargetType); IEnumerable<TargetFlowInfo> r = null; var chanel = CreateChannel(); chanel.Call(p => { r = p.GetTargetFlows(client, flowCodeOrTargetType, beginTime, endTime, started, completed, result); }); return r; }