public void TwoFullyAndEquallyDefinedWorkStepInstancesShouldEqual()
{
var ws1 = WorkStep.New("/path").UpdateOrdinal(1).UpdateType(WorkStepType.Normal).UpdateWorkItemClass("class").UpdateTitle("title").UpdateWipLimit(2);
var ws2 = WorkStep.New("/path").UpdateOrdinal(1).UpdateType(WorkStepType.Normal).UpdateWorkItemClass("class").UpdateTitle("title").UpdateWipLimit(2);
AssertAreEqual(ws1, ws2);
}
public void ShouldEqualHaveSameHashCodeAndToStringIfPathMatch()
{
var ws1 = WorkStep.New("/path");
var ws2 = WorkStep.New("/path");
AssertAreEqual(ws1, ws2);
}
public void ShouldUpdateTitle()
{
var workStep = WorkStep.New("/analysis");
Assert.AreEqual(null, workStep.Title);
Assert.AreEqual("title", workStep.UpdateTitle("title").Title);
}
public void ShouldUpdateType()
{
var workStep = WorkStep.New("/analysis");
Assert.AreEqual(WorkStepType.Normal, workStep.Type);
Assert.AreEqual(WorkStepType.Begin, workStep.UpdateType(WorkStepType.Begin).Type);
}
public void ShouldUpdateOrdinal()
{
var workStep = WorkStep.New("/analysis");
Assert.AreEqual(null, workStep.Ordinal);
Assert.AreEqual(1, workStep.UpdateOrdinal(1).Ordinal);
}
public void ShouldNotEqualNotHaveSameHashCodeOrToStringIfPathVary()
{
var ws1 = WorkStep.New("/path1");
var ws2 = WorkStep.New("/path2");
AssertAreNotEqual(ws1, ws2);
}
/// <summary>
/// Setzt den Letzten WorkStep zurück.
/// Aufruf über Button
/// </summary>
public void UndoLast()
{
foreach (Task t in currentWorkStep.tasks)
{
if (t.TaskDone)
{
currentWorkStep.ActivateWorkStep();
return;
}
}
int targetIdx = 0;
while (workSteps[targetIdx] != currentWorkStep)
{
targetIdx++;
}
targetIdx--;
currentWorkStep = workSteps[0];
foreach (WorkStep ws in workSteps)
{
ws.InitWorkStep();
}
ActivateNextWorkStep();
while (targetIdx > 0 && currentWorkStep != workSteps[targetIdx])
{
SkipWorkStep();
ActivateNextWorkStep();
}
}
public void ShouldUpdateWorkItemIfTimeStampIsSetAndEqualToLastTimeStamp()
{
var mocks = new MockRepository();
var createTime = DateTime.Now;
_workflow.MockTime(mocks, createTime);
using (mocks.Playback())
{
_workStepRepository.Add(WorkStep.New("/analysis").UpdateOrdinal(1).UpdateType(WorkStepType.Begin).UpdateWorkItemClass("cr"));
_workflow.CreateWorkItem(WorkItem.New("cr1", "/analysis"));
}
var updateTime = createTime.AddMilliseconds(1);
_workflow.MockTime(mocks, updateTime);
using (mocks.Playback())
{
_workflow.UpdateWorkItem(WorkItem.New("cr1", "/analysis").UpdateTimestamp(createTime));
}
var workItem = _workflow.GetWorkItem("cr1");
Assert.AreEqual(updateTime, workItem.Timestamp);
}
public object Deserialize(WorkStep step)
{
if (step.Type != OperationConstants.CHANGE_TEXT)
{
//TODO throw exception
return(null);
}
var desc = new ChangeTextDescription();
desc.Content = step.Params["content"];
desc.Units = step.Params["units"];
int count;
if (!int.TryParse(step.Params["variables._count"], out count))
{
//TODO throw Exception
return(null);
}
for (int i = 0; i < count; i++)
{
var kvp = new KeyValuePair <string, string>(step.Params["variables." + i + ".code"], step.Params["variables." + i + ".name"]);
desc.Variables.Add(kvp);
}
return(desc);
}
public object Deserialize(WorkStep step)
{
if (step.Type != OperationConstants.PIVOT)
{
//TODO throw exception
return(null);
}
var desc = new List <PivotDescription>();
int count;
if (!int.TryParse(step.Params["_count"], out count))
{
//TODO throw Exception
return(null);
}
for (int i = 0; i < count; i++)
{
var d = new PivotDescription();
d.VariableName = step.Params[i + ".name"];
d.VariablePlacement = (PlacementType)Enum.Parse(typeof(PlacementType), step.Params[i + ".placement"], true);
desc.Add(d);
}
return(desc.ToArray());
}
private void RenderTransientListItem(HtmlTextWriter writer, WorkStep transientStep, WorkItem expandedWorkItem)
{
writer.AddAttribute(HtmlTextWriterAttribute.Class, "transient");
writer.RenderBeginTag(HtmlTextWriterTag.Li);
writer.RenderBeginTag(HtmlTextWriterTag.Ol);
writer.AddAttribute(HtmlTextWriterAttribute.Id, GenerateWorkStepId(transientStep));
writer.AddAttribute(HtmlTextWriterAttribute.Class, GetLeafStepClasses(transientStep).Join(' '));
writer.RenderBeginTag(HtmlTextWriterTag.Li);
writer.RenderBeginTag(HtmlTextWriterTag.Ol);
RenderWorkItem(writer, expandedWorkItem);
writer.RenderEndTag(); //ol
writer.RenderEndTag(); //li
var childSteps = _workflowRepository.GetChildWorkSteps(transientStep.Path);
RenderWorkStepListItems(writer, childSteps);
writer.RenderEndTag(); //ol
writer.RenderEndTag(); //li
}
private void DGVAddRow(WorkStep keyname, string[] aydata)
{
BeginInvoke((Action)(() =>
{
DGVMenus[keyname].AddGridrow(aydata);
}));
}
public WorkStep Serialize(object obj)
{
if (!(obj is ChangeValueOrderDescription))
{
//TODO throw exception
return(null);
}
var desc = obj as ChangeValueOrderDescription;
var step = new WorkStep()
{
Id = Guid.NewGuid().ToString()
};
step.Type = OperationConstants.CHANGE_VALUE_ORDER;
step.Params.Add("variableCode", desc.VariableCode);
step.Params.Add("indexies._count", desc.ModifiedVariableValueWeight.Length.ToString());
for (int i = 0; i < desc.ModifiedVariableValueWeight.Length; i++)
{
step.Params.Add("indexies." + i, desc.ModifiedVariableValueWeight[i].ToString());
}
return(step);
}
public static WorkStep CreateWorkStep(this IWriteableWorkStepRepository repository, string path, int wipLimit)
{
var step = WorkStep.New(path).UpdateWipLimit(wipLimit);
repository.CreateWorkStep(step);
return(step);
}
public static WorkStep CreateWorkStep(this IWriteableWorkStepRepository repository, string path, WorkStepType type)
{
var step = WorkStep.New(path).UpdateType(type);
repository.CreateWorkStep(step);
return(step);
}
public WorkStep GetWorkStep(string parentPath)
{
var workStep = WorkStep.New(WorkflowPath.CombinePath(parentPath, Step));
if (Ordinal.HasValue)
{
workStep = workStep.UpdateOrdinal(Ordinal.Value);
}
if (Type.HasValue)
{
workStep = workStep.UpdateType(Type.Value);
}
if (WorkItemClass != null)
{
workStep = workStep.UpdateWorkItemClass(WorkItemClass);
}
if (Title != null)
{
workStep = workStep.UpdateTitle(Title);
}
return(workStep);
}
public WorkStep Serialize(object obj)
{
if (!(obj is CalculatePerPartDescription))
{
//TODO throw exception
return(null);
}
var desc = obj as CalculatePerPartDescription;
var step = new WorkStep()
{
Id = Guid.NewGuid().ToString()
};
step.Type = OperationConstants.PER_PART;
step.Params.Add("calculationVariant", desc.CalculationVariant.ToString());
step.Params.Add("operationType", desc.OperationType.ToString());
step.Params.Add("valueName", desc.ValueName);
step.Params.Add("keepValue", desc.KeepValue.ToString());
desc.ValueSelection.Serialize(step, "selection.");
return(step);
}
/// <summary>
/// </summary>
/// <param name="wstep"/>
/// <param name="handled"/>
/// <param name="prevReturnValue"/>
/// <returns/>
public IEnumerable <AoEquipment> GET_LOADABLE_EQPS0(WorkStep wstep, ref bool handled, IEnumerable <AoEquipment> prevReturnValue)
{
try
{
List <AoEquipment> equipList = new List <AoEquipment>();
if (wstep.Steps.Count == 0)
{
return(equipList);
}
List <string> list = SimulationHelper.GetLoadableList(wstep.Steps[0] as MicronBEAssyBEStep);
foreach (string eqp in list)
{
AoEquipment aeqp = AoFactory.Current.GetEquipment(eqp);
if (aeqp == null)
{
continue;
}
equipList.Add(aeqp);
}
return(equipList);
}
catch (Exception e)
{
WriteHelper.WriteErrorHistory(ErrorLevel.FATAL, string.Format("ErrorMessage : {0} MethodName : {1}", e.Message, System.Reflection.MethodInfo.GetCurrentMethod().Name));
return(default(IEnumerable <AoEquipment>));
}
}
public WorkStep Serialize(object obj)
{
if (!(obj is PivotDescription[]))
{
//TODO throw exception
return(null);
}
var desc = obj as PivotDescription[];
var step = new WorkStep();
step.Id = Guid.NewGuid().ToString();
step.Type = OperationConstants.PIVOT;
step.Params.Add("_count", desc.Length.ToString());
for (int i = 0; i < desc.Length; i++)
{
step.Params.Add(i + ".name", desc[i].VariableName);
step.Params.Add(i + ".placement", desc[i].VariablePlacement.ToString());
}
return(step);
}
private static WorkStep GenerateWorkStep(string path, IEnumerable <Attribute> attributes)
{
var step = WorkStep.New(path);
foreach (var attribute in attributes)
{
switch (attribute.Name)
{
case "Type":
step = step.UpdateType((WorkStepType)Enum.Parse(typeof(WorkStepType), attribute.Value));
break;
case "Ordinal":
step = step.UpdateOrdinal(XmlConvert.ToInt32(attribute.Value));
break;
case "WorkItemClass":
step = step.UpdateWorkItemClass(attribute.Value);
break;
case "Title":
step = step.UpdateTitle(attribute.Value);
break;
}
}
return(step);
}
private void SendUpdateRequest(WorkStep workStep)
{
var putAttributeRequest = new PutAttributesRequest {
DomainName = _domain, ItemName = workStep.Path
};
putAttributeRequest.Attribute.Add(new ReplaceableAttribute {
Name = "Type", Value = workStep.Type.ToString(), Replace = true
});
putAttributeRequest.Attribute.Add(new ReplaceableAttribute {
Name = "Ordinal", Value = workStep.Ordinal.ToString(), Replace = true
});
putAttributeRequest.Attribute.Add(new ReplaceableAttribute {
Name = "WorkItemClass", Value = workStep.WorkItemClass, Replace = true
});
if (!string.IsNullOrEmpty(workStep.Title))
{
putAttributeRequest.Attribute.Add(new ReplaceableAttribute {
Name = "Title", Value = workStep.Title, Replace = true
});
}
_client.PutAttributes(putAttributeRequest);
}
public WorkStep Serialize(object obj)
{
if (!(obj is ChangeTextCodePresentationDescription))
{
//TODO throw exception
return(null);
}
var desc = obj as ChangeTextCodePresentationDescription;
var step = new WorkStep();
step.Id = Guid.NewGuid().ToString();
step.Type = OperationConstants.CHANGE_TEXT_CODE_PRESENTATION;
step.Params.Add("variables._count", desc.PresentationDictionary.Count.ToString());
int i = 0;
foreach (KeyValuePair <String, HeaderPresentationType> kvp in desc.PresentationDictionary)
{
step.Params.Add("variables." + i + ".code", kvp.Key);
step.Params.Add("variables." + i + ".presentationType", kvp.Value.ToString());
i++;
}
return(step);
}
public object Deserialize(WorkStep step)
{
if (step.Type != OperationConstants.CHANGE_TEXT_CODE_PRESENTATION)
{
//TODO throw exception
return(null);
}
var desc = new ChangeTextCodePresentationDescription();
int count;
if (!int.TryParse(step.Params["variables._count"], out count))
{
//TODO throw Exception
return(null);
}
for (int i = 0; i < count; i++)
{
string code = step.Params["variables." + i + ".code"];
HeaderPresentationType presType = (HeaderPresentationType)Enum.Parse(typeof(HeaderPresentationType), step.Params["variables." + i + ".presentationType"], true);
desc.PresentationDictionary.Add(code, presType);
}
return(desc);
}
public void ShouldCreateWorkStepWithSameWorkItemClassAsPrecedingSibilingIfMissingWorkItemClassAndNoParent()
{
_creator.CreateWorkStep(WorkStep.New("/analysis").UpdateWorkItemClass("class1"));
_creator.CreateWorkStep(WorkStep.New("/development"));
Assert.AreEqual("class1", _workStepRepository.GetWorkStep("/development").WorkItemClass);
}
public void ShouldCreateChildrenOfParallelStepWithDifferentWorkItemClass()
{
_creator.CreateWorkStep(
WorkStep.New("/feedback").UpdateType(WorkStepType.Parallel).UpdateWorkItemClass("cr"));
_creator.CreateWorkStep(WorkStep.New("/feedback/review").UpdateWorkItemClass("cr-review"));
_creator.CreateWorkStep(WorkStep.New("/feedback/test").UpdateWorkItemClass("cr-test"));
}
public void ShouldAppendWhenCreatingWorkStepWithoutOrdinal()
{
_creator.CreateWorkStep(WorkStep.New("/analysis").UpdateWorkItemClass("cr"));
_creator.CreateWorkStep(WorkStep.New("/analysis/inprocess"));
_creator.CreateWorkStep(WorkStep.New("/analysis/done"));
Assert.AreEqual(1, _workStepRepository.GetWorkStep("/analysis/done").Ordinal);
}
public void ShouldThrowExceptionIfSiblingHasSameOrdinalWhenCreatingWorkStep()
{
_creator.CreateWorkStep(WorkStep.New("/analysis").UpdateWorkItemClass("cr").UpdateOrdinal(1));
AssertUtils.AssertThrows <InvalidOperationException>(
() => _creator.CreateWorkStep(WorkStep.New("/development").UpdateOrdinal(1))
);
}
public static WorkStep CreateWorkStep(this IWriteableWorkStepRepository repository, string path)
{
var step = WorkStep.New(path);
repository.CreateWorkStep(step);
return(step);
}
public void CreateWorkStep(WorkStep workStep)
{
var entry = WorkStepLogEntry.CreateEntry(workStep);
_workflow.CreateWorkStep(workStep);
_log.AddLogEntry(entry);
}
public WorkStep Serialize(object obj)
{
if (!(obj is ChangeTextDescription))
{
//TODO throw exception
return(null);
}
var desc = obj as ChangeTextDescription;
var step = new WorkStep();
step.Id = Guid.NewGuid().ToString();
step.Type = OperationConstants.CHANGE_TEXT;
step.Params.Add("content", desc.Content);
step.Params.Add("units", desc.Units);
step.Params.Add("variables._count", desc.Variables.Count.ToString());
for (int i = 0; i < desc.Variables.Count; i++)
{
step.Params.Add("variables." + i + ".code", desc.Variables[i].Key);
step.Params.Add("variables." + i + ".name", desc.Variables[i].Value);
}
return(step);
}
public WorkItemTransition(WorkItem workItem, WorkStep workStep)
{
WorkItem = workItem;
WorkStep = workStep;
}
private bool CanAcceptWip(WorkStep workStep, string workItemId)
{
return _wipLimit.CanAcceptWorkItem(WorkItem.New(workItemId, workStep.Path));
}
public void LogCreateWorkStep(WorkStep workStep)
{
_writer.WriteLine("{0},{1},{2}", "CREATE STEP", DateTime.Now, workStep.Path);
_writer.Flush();
}
private static void AssertAreNotEqual(WorkStep ws1, WorkStep ws2)
{
Assert.IsFalse(ws1.Equals(ws2));
Assert.AreNotEqual(ws1.GetHashCode(), ws2.GetHashCode());
Assert.AreNotEqual(ws1.ToString(), ws2.ToString());
}
public WipLimitViolationException(WorkItem workItem, WorkStep toWorkStep)
: base(string.Format("WIP limit violated. Cannot move work item '{0}' to work step '{1}'",
workItem.Id, toWorkStep.Path))
{
}
public static WorkStepLogEntry CreateEntry(WorkStep workStep)
{
return new WorkStepLogEntry {WorkStep = workStep};
}
private void AssertBelowWipLimitAndCreateWorkItem(WorkStep workStep, params string[] ids)
{
foreach (var id in ids)
{
Assert.IsTrue(CanAcceptWip(workStep, id));
_workItemRepository.CreateWorkItem(workStep, id);
}
}
