public double CalculateResult()
{
operationStage = OperationStage.DisplayResult;
switch (operationMode)
{
case OperationMode.Add:
{
Add();
break;
}
case OperationMode.Subtract:
{
Subtract();
break;
}
case OperationMode.Multiply:
{
Multiply();
break;
}
case OperationMode.Divide:
{
Divide();
break;
}
}
ResultOperand.UpdateTextFromValue();
return(ResultOperand.Value);
}
private void SwitchValues()
{
switch (operationStage)
{
case OperationStage.EnterFirstOperand:
{
SecondOperand.Reset();
operationStage = OperationStage.EnterSecondOperand;
break;
}
case OperationStage.EnterSecondOperand:
{
CalculateResult();
MoveResultToFirstOperand();
SecondOperand.Reset();
operationStage = OperationStage.EnterSecondOperand;
break;
}
case OperationStage.DisplayResult:
{
MoveResultToFirstOperand();
SecondOperand.Reset();
operationStage = OperationStage.EnterSecondOperand;
break;
}
}
}
public void Execute(OperationTypeEnum op, OperationStage stage, Entity entity, Schema.Domain.Entity entityMetadata, List <Schema.Domain.Attribute> attributeMetadatas)
{
var plugins = _entityPluginFinder.QueryByEntityId(entityMetadata.EntityId, Enum.GetName(typeof(OperationTypeEnum), op));
if (plugins.NotEmpty())
{
foreach (var pg in plugins)
{
if (pg.StateCode == RecordState.Disabled)
{
continue;
}
var pinstance = GetInstance(pg);
if (pinstance != null)
{
pinstance.Execute(new PluginExecutionContext()
{
MessageName = op
,
Stage = stage
,
Target = entity
,
User = _currentUser
,
EntityMetadata = entityMetadata
,
AttributeMetadatas = attributeMetadatas
});
}
}
}
}
/// <summary>
/// 创建记录时触发的事件
/// </summary>
/// <param name="data"></param>
/// <param name="stage"></param>
/// <param name="entityMetadata"></param>
private void InternalOnCreate(AggregateRoot data, OperationStage stage, AggregateRootMetaData aggRootMetaDatas)
{
//plugin
var entityId = aggRootMetaDatas.MainMetadata.EntityMetadata.EntityId;
Guid? businessObjectId = aggRootMetaDatas.SystemFormId;
PlugInType pluginType = PlugInType.Form;
_pluginExecutor.Execute(entityId, businessObjectId, pluginType, OperationTypeEnum.Update, stage, data, aggRootMetaDatas);
if (stage == OperationStage.PreOperation)
{
//event publishing
_eventPublisher.Publish(new AggRootCreatingEvent(data)
{
AggRootMetaData = aggRootMetaDatas
});
}
else if (stage == OperationStage.PostOperation)
{
//event publishing
_eventPublisher.Publish(new AggRootCreatedEvent(data)
{
AggRootMetaData = aggRootMetaDatas
});
}
OnCreate(data, stage, aggRootMetaDatas);
}
//==============================================
// Misc
//==============================================
#region Misc
private void SetCurrentStage(OperationStage currentStage)
{
if (currentStage != CurrentStage)
{
CurrentStage = currentStage;
MainButton.Content = currentStage.ToString();
}
ToggleMainButton(CurrentStage != OperationStage.Done);
CleanUpdateCheckBox.IsEnabled = CurrentStage == OperationStage.Update;
}
/// <summary>
/// Guards the only one stage bit set.
/// </summary>
/// <param name="stage">The stage.</param>
/// <exception cref="System.InvalidOperationException"></exception>
private void GuardOnlyOneStageBitSet(OperationStage stage)
{
const string err = "The Run operation of the Workflow manager only supports a single Flag when requesting a run operation. Tasks can be configured to support multiple operations";
int intVal = ((int)stage);
bool singleBitIsSet = (intVal != 0 && (intVal & (intVal - 1)) == 0) || intVal == 0;
if (!singleBitIsSet)
{
throw new System.InvalidOperationException(err);
}
}
/// <inheritdoc />
public void Push(OperationStage nextStage)
{
if (nextStage == null)
{
throw new ArgumentNullException("nextStage");
}
collection.Update(
Query <OperationData> .EQ(x => x.Id, id),
Update <OperationData> .Push(x => x.Stages,
new OperationStageData
{
ReceivedMessageType = nextStage.ReceivedMessageType,
WhenReceived = nextStage.WhenReceived
})
);
}
private void PublishEvents(Entity originData, Entity newData, OperationStage stage, Schema.Domain.Entity entityMetadata, List <Schema.Domain.Attribute> attributeMetadatas)
{
if (stage == OperationStage.PreOperation)
{
_eventPublisher.Publish(new EntityUpdatingEvent(originData, newData)
{
EntityMetadata = entityMetadata, AttributeMetadatas = attributeMetadatas
});
}
else if (stage == OperationStage.PostOperation)
{
_eventPublisher.Publish(new EntityUpdatedEvent(originData, newData)
{
EntityMetadata = entityMetadata, AttributeMetadatas = attributeMetadatas
});
}
}
/// <summary>
/// Runs all registered tasks.
/// </summary>
/// <param name="context">The context.</param>
/// <param name="stage">The stage.</param>
/// <returns>Task.</returns>
/// <exception cref="Trident.Workflow.WorkFlowCancelledException">Task {task.GetType()} cancelled the workflow during {stage.ToString()} stage of the {context.Operation.ToString()}</exception>
protected virtual void RunTasksSync(BusinessContext context, OperationStage stage)
{
if (this.Tasks != null)
{
GuardOnlyOneStageBitSet(stage);
var tasksToRun = (stage == OperationStage.All)
? this.Tasks
: this.Tasks.Where(x => x.Stage.HasFlag(stage)).ToList();
//TODO add sync methods IWorkflowTask interface
foreach (var task in tasksToRun)
{
//if (task.ShouldRun(context) && !task.Run(context))
// throw new WorkFlowCancelledException($"Task {task.GetType()} cancelled the workflow during {stage.ToString()} stage of the {context.Operation.ToString()} operation", task.GetType());
}
}
}
/// <summary>
/// 合并记录时触发的事件
/// </summary>
/// <param name="merged"></param>
/// <param name="target"></param>
/// <param name="stage"></param>
/// <param name="entityMetadata"></param>
private void InternalOnMerge(Entity merged, Entity target, OperationStage stage, Schema.Domain.Entity entityMetadata, List <Schema.Domain.Attribute> attributeMetadatas)
{
//plugin
_entityPluginExecutor.Execute(OperationTypeEnum.Merge, stage, target, entityMetadata, attributeMetadatas);
if (stage == OperationStage.PreOperation)
{
_eventPublisher.Publish(new EntityMergingEvent()
{
Merged = merged, Target = target, EntityMetadata = entityMetadata
});
}
else if (stage == OperationStage.PostOperation)
{
_eventPublisher.Publish(new EntityMergedEvent()
{
Merged = merged, Target = target, EntityMetadata = entityMetadata
});
}
OnMerge(merged, target, stage, entityMetadata, attributeMetadatas);
}
/// <summary>
/// 单据转换时触发的事件
/// </summary>
/// <param name="source"></param>
/// <param name="target"></param>
/// <param name="stage"></param>
/// <param name="targetEntityMeta"></param>
private void InternalOnMap(Entity source, Entity target, OperationStage stage, Schema.Domain.Entity targetEntityMeta, List <Schema.Domain.Attribute> targetAttributeMetadatas)
{
//plugin
_entityPluginExecutor.Execute(OperationTypeEnum.Merge, stage, target, targetEntityMeta, targetAttributeMetadatas);
if (stage == OperationStage.PreOperation)
{
_eventPublisher.Publish(new EntityMappingEvent()
{
Source = source, Target = target, EntityMetadata = targetEntityMeta
});
}
else if (stage == OperationStage.PostOperation)
{
_eventPublisher.Publish(new EntityMappedEvent()
{
Source = source, Target = target, EntityMetadata = targetEntityMeta
});
}
OnMap(source, target, stage, targetEntityMeta, targetAttributeMetadatas);
}
/// <summary>
/// 删除记录时触发的事件
/// </summary>
/// <param name="data"></param>
/// <param name="stage"></param>
/// <param name="entityMetadata"></param>
private void InternalOnDelete(Entity data, OperationStage stage, Schema.Domain.Entity entityMetadata, List <Schema.Domain.Attribute> attributeMetadatas)
{
//plugin
_entityPluginExecutor.Execute(OperationTypeEnum.Delete, stage, data, entityMetadata, attributeMetadatas);
if (stage == OperationStage.PreOperation)
{
_eventPublisher.Publish(new EntityDeletingEvent(data)
{
EntityMetadata = entityMetadata, AttributeMetadatas = attributeMetadatas
});
}
else if (stage == OperationStage.PostOperation)
{
_eventPublisher.Publish(new EntityDeletedEvent(data)
{
EntityMetadata = entityMetadata, AttributeMetadatas = attributeMetadatas
});
}
OnDelete(data, stage, entityMetadata, attributeMetadatas);
}
/// <summary>
/// 共享记录时触发的事件
/// </summary>
/// <param name="data"></param>
/// <param name="stage"></param>
/// <param name="entityMetadata"></param>
private void InternalOnShare(Entity data, OperationStage stage, Schema.Domain.Entity entityMetadata, List <Schema.Domain.Attribute> attributeMetadatas)
{
//plugin
_entityPluginExecutor.Execute(OperationTypeEnum.Share, stage, data, entityMetadata, attributeMetadatas);
if (stage == OperationStage.PreOperation)
{
_eventPublisher.Publish(new EntitySharingEvent()
{
Data = data, EntityMetadata = entityMetadata, Principals = null
});
}
else if (stage == OperationStage.PostOperation)
{
_eventPublisher.Publish(new EntitySharedEvent()
{
Data = data, EntityMetadata = entityMetadata, Principals = null
});
}
OnShare(data, stage, entityMetadata, attributeMetadatas);
}
/// <summary>
/// 分派记录时触发的事件
/// </summary>
/// <param name="data"></param>
/// <param name="newOwnerEntity"></param>
/// <param name="stage"></param>
/// <param name="entityMetadata"></param>
private void InternalOnAssign(Entity data, Entity newOwnerEntity, OperationStage stage, Schema.Domain.Entity entityMetadata, List <Schema.Domain.Attribute> attributeMetadatas)
{
//plugin
_entityPluginExecutor.Execute(OperationTypeEnum.Assign, stage, newOwnerEntity, entityMetadata, attributeMetadatas);
if (stage == OperationStage.PreOperation)
{
_eventPublisher.Publish(new EntityAssigningEvent()
{
OriginData = data, Data = newOwnerEntity, EntityMetadata = entityMetadata
});
}
else if (stage == OperationStage.PostOperation)
{
_eventPublisher.Publish(new EntityAssignedEvent()
{
OriginData = data, Data = newOwnerEntity, EntityMetadata = entityMetadata
});
}
OnAssign(data, newOwnerEntity, stage, entityMetadata, attributeMetadatas);
}
public void ModifyOperand(string commandString)
{
if (operationStage == OperationStage.DisplayResult)
{
MoveResultToFirstOperand();
}
switch (commandString)
{
case ".":
{
GetCurrentOperandObject().SetHasAPoint(true);
break;
}
case "%":
{
GetCurrentOperandObject().DivideBy100();
break;
}
case "+/-":
{
GetCurrentOperandObject().Invert();
break;
}
case "C":
{
FirstOperand.Reset();
SecondOperand.Reset();
ResultOperand.Reset();
operationStage = OperationStage.EnterFirstOperand;
break;
}
}
}
/// <summary>
/// 新建记录时执行的方法
/// 运行于事务中
/// </summary>
/// <param name="data"></param>
/// <param name="stage"></param>
/// <param name="entityMetadata"></param>
public virtual void OnCreate(Entity data, OperationStage stage, Schema.Domain.Entity entityMetadata, List <Schema.Domain.Attribute> attributeMetadatas)
{
}
/// <summary>
/// Validates the specified object to validate.
/// </summary>
/// <param name="context">The context.</param>
/// <param name="stage">The stage.</param>
/// <returns>List<WorkFlowResult>.</returns>
public async Task Run(BusinessContext context, OperationStage stage = OperationStage.All)
{
context.GuardIsNotNull(nameof(context));
context.Target.GuardIsNotNull(nameof(context.Target));
await RunTasks(context, stage);
}
public void RunSync(BusinessContext context, OperationStage stage = OperationStage.All)
{
context.GuardIsNotNull(nameof(context));
context.Target.GuardIsNotNull(nameof(context.Target));
RunTasksSync(context, stage);
}
public virtual void OnUpdate(AggregateRoot existsData, AggregateRoot newData, OperationStage stage, AggregateRootMetaData AggRootMetaDatas)
{
}
/// <summary>
/// 更新记录时触发的事件
/// </summary>
/// <param name="originData"></param>
/// <param name="newData"></param>
/// <param name="stage"></param>
/// <param name="entityMetadata"></param>
private void InternalOnUpdate(Entity originData, Entity newData, OperationStage stage, Schema.Domain.Entity entityMetadata, List <Schema.Domain.Attribute> attributeMetadatas)
{
//plugin
_entityPluginExecutor.Execute(OperationTypeEnum.Update, stage, newData, entityMetadata, attributeMetadatas);
OnUpdate(originData, newData, stage, entityMetadata, attributeMetadatas);
}
/// <summary>
/// 更新记录时执行的方法
/// 运行于事务中
/// </summary>
/// <param name="existsData"></param>
/// <param name="newData"></param>
/// <param name="stage"></param>
/// <param name="entityMetadata"></param>
public virtual void OnUpdate(Entity existsData, Entity newData, OperationStage stage, Schema.Domain.Entity entityMetadata, List <Schema.Domain.Attribute> attributeMetadatas)
{
}
/// <summary>
/// 单据转换时执行的方法
/// 运行于事务中
/// </summary>
/// <param name="source"></param>
/// <param name="target"></param>
/// <param name="stage"></param>
/// <param name="entityMetadata"></param>
public virtual void OnMap(Entity source, Entity target, OperationStage stage, Schema.Domain.Entity targetEntityMeta, List <Schema.Domain.Attribute> targetAttributeMetadatas)
{
}
/// <summary>
/// 记录合并时执行的方法
/// 运行于事务中
/// </summary>
/// <param name="merged"></param>
/// <param name="target"></param>
/// <param name="stage"></param>
/// <param name="entityMetadata"></param>
public virtual void OnMerge(Entity merged, Entity target, OperationStage stage, Schema.Domain.Entity entityMetadata, List <Schema.Domain.Attribute> attributeMetadatas)
{
}
public void Push(OperationStage nextStage)
{
stages.Add(nextStage);
}
/// <summary>
/// 分派记录时执行的方法
/// 运行于事务中
/// </summary>
/// <param name="data"></param>
/// <param name="newOwnerEntity"></param>
/// <param name="stage"></param>
/// <param name="entityMetadata"></param>
public virtual void OnAssign(Entity data, Entity newOwnerEntity, OperationStage stage, Schema.Domain.Entity entityMetadata, List <Schema.Domain.Attribute> attributeMetadatas)
{
}
public void Execute(Guid entityId, Guid?businessObjectId, PlugInType typeCode, OperationTypeEnum op, OperationStage stage, TData tData, KMetadata kMetadata)
{
var plugins = _entityPluginFinder.QueryByEntityId(entityId, Enum.GetName(typeof(OperationTypeEnum), op), businessObjectId, typeCode);
if (plugins.NotEmpty())
{
foreach (var pg in plugins)
{
if (pg.StateCode == RecordState.Disabled)
{
continue;
}
var pinstance = GetInstance(pg);
if (pinstance != null)
{
pinstance.Execute(new PluginExecutionContextT <TData, KMetadata>()
{
MessageName = op
,
Stage = stage
,
User = _currentUser
,
Target = tData
,
metadata = kMetadata
});
}
}
}
}
public virtual void OnCreate(AggregateRoot data, OperationStage stage, AggregateRootMetaData aggRootMetaData)
{
}
