public static void MessageSent(Human ambassador, Guid destination, string msg)
{
Kingdom k = FindKingdom(destination);
HumanTask gettingBackTask = new HumanTask(ambassador)
{
TaskType = ETask.SendingMessage,
Destination = k.UserId.ToString(),
Context = Locale.Get("commands.send.empty_answer", k.Language)
};
gettingBackTask.CalculateTaskTime(ambassador);
ambassador.TasksToDo.AddRange(new[] {
new HumanTask(ambassador)
{
TaskType = ETask.Waiting,
TimeLeft = 3
},
gettingBackTask
});
msg = string.Format(Locale.Get("commands.send.recieved", k.Language), ambassador.GetName(k.Language), k.Name, msg);
UsersManager.Send(destination, new MessageCallback(msg));
}
///
/// <summary>
/// +-----------------+ +-----------------+
/// | Case1 \ | aCaseDefinition |
/// +-------------------+---+ +-----------------+
/// | | |
/// | +-------+ | ==> +-----------------+
/// | | A | | | aCasePlanModel |
/// | +-------+ | +-----------------+
/// | | |
/// +-----------------------+ +-----------------+
/// | A |
/// +-----------------+
///
/// </summary>
//JAVA TO C# CONVERTER TODO TASK: Most Java annotations will not have direct .NET equivalent attributes:
//ORIGINAL LINE: @Test public void testActivityTreeWithOneHumanTask()
public virtual void testActivityTreeWithOneHumanTask()
{
// given
HumanTask humanTask = createElement(casePlanModel, "A", typeof(HumanTask));
PlanItem planItem = createElement(casePlanModel, "PI_A", typeof(PlanItem));
planItem.Definition = humanTask;
// when
IList <CaseDefinitionEntity> caseDefinitions = transform();
// then
assertEquals(1, caseDefinitions.Count);
CaseDefinitionEntity caseDefinition = caseDefinitions[0];
IList <CmmnActivity> activities = caseDefinition.Activities;
CmmnActivity casePlanModelActivity = activities[0];
IList <CmmnActivity> planItemActivities = casePlanModelActivity.Activities;
assertEquals(1, planItemActivities.Count);
CmmnActivity child = planItemActivities[0];
assertEquals(planItem.Id, child.Id);
assertTrue(child.Activities.Count == 0);
}
public void initialize(TasklistWindow tasklist, HumanTask task)
{
this.Tasklist = tasklist;
this.Task = task;
Variables = Tasklist.Camunda.HumanTaskService.LoadVariables(task.Id);
}
//JAVA TO C# CONVERTER TODO TASK: Most Java annotations will not have direct .NET equivalent attributes:
//ORIGINAL LINE: @Before public void setUp()
public virtual void setUp()
{
humanTask = createElement(casePlanModel, "aHumanTask", typeof(HumanTask));
planItem = createElement(casePlanModel, "PI_aHumanTask", typeof(PlanItem));
planItem.Definition = humanTask;
}
public void initialize(TasklistWindow tasklist, HumanTask task)
{
this.Tasklist = tasklist;
this.Task = task;
TaskVariables = Tasklist.Camunda.HumanTaskService.LoadVariables(task.Id);
NewVariables = new Dictionary <string, object>();
NewVariables.Add("approved", false);
}
//JAVA TO C# CONVERTER TODO TASK: Most Java annotations will not have direct .NET equivalent attributes:
//ORIGINAL LINE: @Before public void setUp()
public virtual void setUp()
{
humanTask = createElement(casePlanModel, "aHumanTask", typeof(HumanTask));
planningTable = createElement(casePlanModel, "aPlanningTable", typeof(PlanningTable));
discretionaryItem = createElement(planningTable, "DI_aHumanTask", typeof(DiscretionaryItem));
discretionaryItem.Definition = humanTask;
}
public bool AddTask(HumanTask t)
{
if (IsInDepression || RandomManager.QuanticFloat(1 - KingAccpetance) > 0.5f)
{
return(false);
}
TasksToDo.Add(t);
return(true);
}
protected internal virtual void initializeTaskDefinitionFollowUpDate(CmmnElement element, TaskDefinition taskDefinition, CmmnHandlerContext context)
{
HumanTask definition = getDefinition(element);
string followUpDate = definition.CamundaFollowUpDate;
if (!string.ReferenceEquals(followUpDate, null))
{
ExpressionManager expressionManager = context.ExpressionManager;
Expression followUpDateExpression = expressionManager.createExpression(followUpDate);
taskDefinition.FollowUpDateExpression = followUpDateExpression;
}
}
protected internal virtual void initializeTaskDefinitionCandidateGroups(CmmnElement element, TaskDefinition taskDefinition, CmmnHandlerContext context)
{
HumanTask definition = getDefinition(element);
ExpressionManager expressionManager = context.ExpressionManager;
IList <string> candidateGroups = definition.CamundaCandidateGroupsList;
foreach (string candidateGroup in candidateGroups)
{
Expression candidateGroupExpression = expressionManager.createExpression(candidateGroup);
taskDefinition.addCandidateGroupIdExpression(candidateGroupExpression);
}
}
protected internal virtual void initializeTaskDefinitionPriority(CmmnElement element, TaskDefinition taskDefinition, CmmnHandlerContext context)
{
HumanTask definition = getDefinition(element);
string priority = definition.CamundaPriority;
if (!string.ReferenceEquals(priority, null))
{
ExpressionManager expressionManager = context.ExpressionManager;
Expression priorityExpression = expressionManager.createExpression(priority);
taskDefinition.PriorityExpression = priorityExpression;
}
}
public override CmmnActivity handleElement(CmmnElement element, CmmnHandlerContext context)
{
HumanTask definition = getDefinition(element);
if (!definition.Blocking)
{
// The CMMN 1.0 specification says:
// When a HumanTask is not 'blocking' (isBlocking is 'false'),
// it can be considered a 'manual' Task, i.e., the Case management
// system is not tracking the lifecycle of the HumanTask (instance).
return(null);
}
return(base.handleElement(element, context));
}
///
/// <summary>
/// +-----------------+ +-----------------+
/// | Case1 \ | aCaseDefinition |
/// +-------------------+-----------------+ +-----------------+
/// | | |
/// | +------------------------+ | +-----------------+
/// | / X \ | | aCasePlanModel |
/// | + +-------+ +-------+ + | +-----------------+
/// | | | A | | B | | | ==> |
/// | + +-------+ +-------+ + | +-----------------+
/// | \ / | | X |
/// | +------------------------+ | +-----------------+
/// | | / \
/// +-------------------------------------+ / \
/// +-----------------+ +-----------------+
/// | A | | B |
/// +-----------------+ +-----------------+
/// </summary>
//JAVA TO C# CONVERTER TODO TASK: Most Java annotations will not have direct .NET equivalent attributes:
//ORIGINAL LINE: @Test public void testActivityTreeWithOneStageAndNestedHumanTasks()
public virtual void testActivityTreeWithOneStageAndNestedHumanTasks()
{
// given
Stage stage = createElement(casePlanModel, "X", typeof(Stage));
HumanTask humanTaskA = createElement(casePlanModel, "A", typeof(HumanTask));
HumanTask humanTaskB = createElement(casePlanModel, "B", typeof(HumanTask));
PlanItem planItemX = createElement(casePlanModel, "PI_X", typeof(PlanItem));
PlanItem planItemA = createElement(stage, "PI_A", typeof(PlanItem));
PlanItem planItemB = createElement(stage, "PI_B", typeof(PlanItem));
planItemX.Definition = stage;
planItemA.Definition = humanTaskA;
planItemB.Definition = humanTaskB;
// when
IList <CaseDefinitionEntity> caseDefinitions = transform();
// then
assertEquals(1, caseDefinitions.Count);
CaseDefinitionEntity caseDefinition = caseDefinitions[0];
IList <CmmnActivity> activities = caseDefinition.Activities;
CmmnActivity casePlanModelActivity = activities[0];
IList <CmmnActivity> children = casePlanModelActivity.Activities;
assertEquals(1, children.Count);
CmmnActivity planItemStage = children[0];
assertEquals(planItemX.Id, planItemStage.Id);
children = planItemStage.Activities;
assertEquals(2, children.Count);
CmmnActivity childPlanItem = children[0];
assertEquals(planItemA.Id, childPlanItem.Id);
assertTrue(childPlanItem.Activities.Count == 0);
childPlanItem = children[1];
assertEquals(planItemB.Id, childPlanItem.Id);
assertTrue(childPlanItem.Activities.Count == 0);
}
public ExecutionResult Train(Dictionary <string, object> dict)
{
int count = 1;
if (dict.ContainsKey("count"))
{
count = (int)dict["count"];
}
if (!dict.ContainsKey("skill"))
{
return(new ExecutionResult(false, new MessageCallback(Locale.Get("jobs.no_job", this.Language), ECharacter.Knight)));
}
string sk = (string)dict["skill"];
JobDescription jb = ContentManager.GetJobDescriptionBySkill(sk);
List <IDependency> deps = new List <IDependency>(jb.TrainDepence);
deps.Add(new HumanDependency());
foreach (IDependency dep in deps)
{
Tuple <bool, MessageCallback> res = dep.CheckKingdom(this);
if (!res.Item1)
{
return(new ExecutionResult(false, res.Item2));
}
}
Human h = dict.Get("human") as Human ?? FindBySkill(sk, false);
HumanTask task = new HumanTask(h)
{
Destination = sk,
TaskType = ETask.Training
};
task.CalculateTaskTime(h);
if (!h.AddTask(task))
{
return(new ExecutionResult(false, new MessageCallback(
Locale.Get(string.Format("problems.dont_work", h.GetName(Language)), Language),
ECharacter.Knight
)));
}
else
{
return(new ExecutionResult(new MessageCallback(Locale.Get("answers.yes", this.Language))));
}
}
protected internal virtual void initializeTaskDefinitionName(CmmnElement element, TaskDefinition taskDefinition, CmmnHandlerContext context)
{
string name = getName(element);
if (string.ReferenceEquals(name, null))
{
HumanTask definition = getDefinition(element);
name = definition.Name;
}
if (!string.ReferenceEquals(name, null))
{
ExpressionManager expressionManager = context.ExpressionManager;
Expression nameExpression = expressionManager.createExpression(name);
taskDefinition.NameExpression = nameExpression;
}
}
public ExecutionResult Extract(Dictionary <string, object> dict)
{
if (!dict.ContainsKey("resource"))
{
return(new ExecutionResult(false, new MessageCallback(Locale.Get("resources.no_resource", this.Language), ECharacter.Knight)));
}
ItemDescription r = (ItemDescription)dict["resource"];
foreach (IDependency dep in r.ExtractionDependencies)
{
Tuple <bool, MessageCallback> res = dep.CheckKingdom(this);
if (!res.Item1)
{
return(new ExecutionResult(false, res.Item2));
}
}
Human h = dict.Get("human") as Human ?? FindBySkill(r.Skill);
HumanTask t = new HumanTask(h)
{
Destination = r.Name,
TaskType = ETask.Extracting,
Repeating = true
};
t.CalculateTaskTime(h, r.Difficulty, r.Skill);
foreach (IDependency dep in r.ExtractionDependencies)
{
t.Use(dep.Use(this));
}
if (!h.AddTask(t))
{
return(new ExecutionResult(false, new MessageCallback(
Locale.Get(string.Format("problems.dont_work", h.GetName(Language)), Language),
ECharacter.Knight
)));
}
else
{
return(new ExecutionResult(new MessageCallback(Locale.Get("answers.yes", this.Language))));
}
}
public ExecutionResult Build(Dictionary <string, object> dict)
{
if (!dict.ContainsKey("building"))
{
return(new ExecutionResult(false, new MessageCallback(Locale.Get("buildings.no_building", this.Language), ECharacter.Knight)));
}
BuildingDescription b = (BuildingDescription)dict["building"];
foreach (IDependency dep in b.Dependencies)
{
Tuple <bool, MessageCallback> res = dep.CheckKingdom(this);
if (!res.Item1)
{
return(new ExecutionResult(false, res.Item2));
}
}
Human h = dict.Get("human") as Human ?? FindBySkill("building");
HumanTask t = new HumanTask(h);
t.Destination = b.Name;
t.TaskType = ETask.Building;
foreach (IDependency dep in b.Dependencies)
{
t.Use(dep.Use(this));
}
t.CalculateTaskTime(h);
if (!h.AddTask(t))
{
return(new ExecutionResult(false, new MessageCallback(
Locale.Get(string.Format("problems.dont_work", h.GetName(Language)), Language),
ECharacter.Knight
)));
}
else
{
return(new ExecutionResult(new MessageCallback(Locale.Get("answers.yes", this.Language))));
}
}
public TaskDetails(HumanTask task)
{
InitializeComponent();
cockpiturl = CamundaEngineClient.COCKPIT_URL + "#/process-instance/" + task.processInstanceId + "/runtime";
CockpitUrlText.Text = cockpiturl;
taskDetailsListView.Items.Add(new TaskProperty("Process Instance Id", task.processInstanceId));
taskDetailsListView.Items.Add(new TaskProperty("Process Definition Id", task.processDefinitionId));
taskDetailsListView.Items.Add(new TaskProperty("Task Assignee", task.assignee));
taskDetailsListView.Items.Add(new TaskProperty("Task Creation Date", String.Format("{0:dd/MM/yyyy HH:mm:ss}", task.created)));
taskDetailsListView.Items.Add(new TaskProperty("Task Definition Key", task.taskDefinitionKey));
taskDetailsListView.Items.Add(new TaskProperty("Task Description", task.description));
taskDetailsListView.Items.Add(new TaskProperty("Task Due Date", String.Format("{0:dd/MM/yyyy HH:mm:ss}", task.due)));
taskDetailsListView.Items.Add(new TaskProperty("Task Follow Up Date", String.Format("{0:dd/MM/yyyy HH:mm:ss}", task.followUp)));
taskDetailsListView.Items.Add(new TaskProperty("Task Form Key", task.formKey));
taskDetailsListView.Items.Add(new TaskProperty("Task Id", task.id));
taskDetailsListView.Items.Add(new TaskProperty("Task Name", task.name));
taskDetailsListView.Items.Add(new TaskProperty("Task Owner", task.owner));
taskDetailsListView.Items.Add(new TaskProperty("Task Priority", task.priority));
}
private void ShowSelectedTask()
{
HumanTask task = (HumanTask)taskListView.SelectedItem;
if (taskListView.SelectedIndex == -1 || task == null || task.FormKey == null)
{
HideDetails();
return;
}
try
{
CamundaTaskForm taskFormPage = (CamundaTaskForm)Activator.CreateInstance(Type.GetType(task.FormKey));
taskFormPage.initialize(this, task);
ShowDetails("Task Form", taskFormPage, true);
ShowDetails("Task Details", new TaskDetails(task), false);
}
catch (Exception ex)
{
// Could not load form - maybe no task for .NET tasklist!
HideDetails();
}
}
protected internal virtual void initializeTaskDefinitionAssignee(CmmnElement element, TaskDefinition taskDefinition, CmmnHandlerContext context)
{
HumanTask definition = getDefinition(element);
Role performer = definition.Performer;
string assignee = null;
if (performer != null)
{
assignee = performer.Name;
}
else
{
assignee = definition.CamundaAssignee;
}
if (!string.ReferenceEquals(assignee, null))
{
ExpressionManager expressionManager = context.ExpressionManager;
Expression assigneeExpression = expressionManager.createExpression(assignee);
taskDefinition.AssigneeExpression = assigneeExpression;
}
}
protected internal virtual void initializeTaskListeners(CmmnElement element, CmmnActivity activity, CmmnHandlerContext context, TaskDefinition taskDefinition)
{
HumanTask humanTask = getDefinition(element);
IList <CamundaTaskListener> listeners = queryExtensionElementsByClass(humanTask, typeof(CamundaTaskListener));
foreach (CamundaTaskListener listener in listeners)
{
TaskListener taskListener = initializeTaskListener(element, activity, context, listener);
string eventName = listener.CamundaEvent;
if (!string.ReferenceEquals(eventName, null))
{
taskDefinition.addTaskListener(eventName, taskListener);
}
else
{
taskDefinition.addTaskListener([email protected]_Fields.EVENTNAME_CREATE, taskListener);
taskDefinition.addTaskListener([email protected]_Fields.EVENTNAME_ASSIGNMENT, taskListener);
taskDefinition.addTaskListener([email protected]_Fields.EVENTNAME_COMPLETE, taskListener);
taskDefinition.addTaskListener([email protected]_Fields.EVENTNAME_DELETE, taskListener);
}
}
}
public virtual void transformHumanTask(PlanItem planItem, HumanTask humanTask, CmmnActivity activity)
{
}
///
/// <summary>
/// +-----------------+ +-----------------+
/// | Case1 \ | aCaseDefinition |
/// +-------------------+-------------------+ +-----------------+
/// | | |
/// | +-------+ | +-----------------+
/// | | A1 | | +---------------| aCasePlanModel |---------------+
/// | +-------+ | | +-----------------+ |
/// | | | | |
/// | +------------------------+ | +-----------------+ +-----------------+ +-----------------+
/// | / X1 \ | | A1 | | X1 | | Y |-----------+
/// | + +-------+ +-------+ + | +-----------------+ +-----------------+ +-----------------+ |
/// | | | A2 | | B | | | / \ / \
/// | + +-------+ +-------+ + | / \ / \
/// | \ / | +---------------+ +---------------+ +-----------------+ +-----------------+
/// | +------------------------+ | | A2 | | B | | C | | X2 |
/// | | +---------------+ +---------------+ +-----------------+ +-----------------+
/// | +-----------------------------+ | ==> / \
/// | / Y \ | +---------------+ +---------------+
/// | + +-------+ + | | A1 | | B |
/// | | | C | | | +---------------+ +---------------+
/// | | +-------+ | |
/// | | | |
/// | | +------------------------+ | |
/// | | / X2 \ | |
/// | | + +-------+ +-------+ + | |
/// | | | | A1 | | B | | | |
/// | | + +-------+ +-------+ + | |
/// | | \ / | |
/// | + +------------------------+ + |
/// | \ / |
/// | +-----------------------------+ |
/// | |
/// +---------------------------------------+
///
/// </summary>
//JAVA TO C# CONVERTER TODO TASK: Most Java annotations will not have direct .NET equivalent attributes:
//ORIGINAL LINE: @Test public void testNestedStages()
public virtual void testNestedStages()
{
// given
Stage stageX = createElement(casePlanModel, "X", typeof(Stage));
Stage stageY = createElement(casePlanModel, "Y", typeof(Stage));
HumanTask humanTaskA = createElement(casePlanModel, "A", typeof(HumanTask));
HumanTask humanTaskB = createElement(casePlanModel, "B", typeof(HumanTask));
HumanTask humanTaskC = createElement(casePlanModel, "C", typeof(HumanTask));
PlanItem planItemA1 = createElement(casePlanModel, "PI_A1", typeof(PlanItem));
planItemA1.Definition = humanTaskA;
PlanItem planItemX1 = createElement(casePlanModel, "PI_X1", typeof(PlanItem));
planItemX1.Definition = stageX;
PlanItem planItemA2 = createElement(stageX, "PI_A2", typeof(PlanItem));
planItemA2.Definition = humanTaskA;
PlanItem planItemB = createElement(stageX, "PI_B", typeof(PlanItem));
planItemB.Definition = humanTaskB;
PlanItem planItemY = createElement(casePlanModel, "PI_Y", typeof(PlanItem));
planItemY.Definition = stageY;
PlanItem planItemC = createElement(stageY, "PI_C", typeof(PlanItem));
planItemC.Definition = humanTaskC;
PlanItem planItemX2 = createElement(stageY, "PI_X2", typeof(PlanItem));
planItemX2.Definition = stageX;
// when
IList <CaseDefinitionEntity> caseDefinitions = transform();
// then
assertEquals(1, caseDefinitions.Count);
CaseDefinitionEntity caseDefinition = caseDefinitions[0];
IList <CmmnActivity> activities = caseDefinition.Activities;
CmmnActivity casePlanModelActivity = activities[0];
IList <CmmnActivity> children = casePlanModelActivity.Activities;
assertEquals(3, children.Count);
CmmnActivity childPlanItem = children[0];
assertEquals(planItemA1.Id, childPlanItem.Id);
assertTrue(childPlanItem.Activities.Count == 0);
childPlanItem = children[1];
assertEquals(planItemX1.Id, childPlanItem.Id);
IList <CmmnActivity> childrenOfX1 = childPlanItem.Activities;
assertFalse(childrenOfX1.Count == 0);
assertEquals(2, childrenOfX1.Count);
childPlanItem = childrenOfX1[0];
assertEquals(planItemA2.Id, childPlanItem.Id);
assertTrue(childPlanItem.Activities.Count == 0);
childPlanItem = childrenOfX1[1];
assertEquals(planItemB.Id, childPlanItem.Id);
assertTrue(childPlanItem.Activities.Count == 0);
childPlanItem = children[2];
assertEquals(planItemY.Id, childPlanItem.Id);
IList <CmmnActivity> childrenOfY = childPlanItem.Activities;
assertFalse(childrenOfY.Count == 0);
assertEquals(2, childrenOfY.Count);
childPlanItem = childrenOfY[0];
assertEquals(planItemC.Id, childPlanItem.Id);
assertTrue(childPlanItem.Activities.Count == 0);
childPlanItem = childrenOfY[1];
assertEquals(planItemX2.Id, childPlanItem.Id);
IList <CmmnActivity> childrenOfX2 = childPlanItem.Activities;
assertFalse(childrenOfX2.Count == 0);
assertEquals(2, childrenOfX2.Count);
childPlanItem = childrenOfX2[0];
assertEquals(planItemA2.Id, childPlanItem.Id);
assertTrue(childPlanItem.Activities.Count == 0);
childPlanItem = childrenOfX2[1];
assertEquals(planItemB.Id, childPlanItem.Id);
assertTrue(childPlanItem.Activities.Count == 0);
}
public static void UpdateKingdoms(int deltatime)
{
Dictionary <Human, Guid> humansToAdd = new Dictionary <Human, Guid>();
for (int i = HumansOnJourney.Count - 1; i >= 0; i--)
{
Human h = HumansOnJourney[i];
HumanTask t = h.TasksToDo[0];
t.TimeLeft -= deltatime;
if (t.TimeLeft <= 0)
{
Guid k_id = Guid.Parse(t.Destination);
h.TasksToDo.RemoveAt(0);
humansToAdd.Add(h, k_id);
HumansOnJourney.RemoveAt(i);
Saved.Remove(h.HumanId);
DatabaseManager.HumansOnJourney.DeleteOneAsync(hh => h.HumanId == hh.HumanId);
MessageSent(h, k_id, t.Context as string);
}
}
foreach (Kingdom k in Kingdoms)
{
if (humansToAdd.ContainsValue(k.UserId))
{
foreach (var kv in humansToAdd)
{
if (kv.Value == k.UserId)
{
k.Humans.Add(kv.Key);
}
}
}
MessageCallback[] msgs = k.Update((deltatime / 1000f) / k.GetDayTime());
foreach (MessageCallback msg in msgs)
{
UsersManager.Send(k.UserId, msg);
}
}
TimeToSave -= deltatime / 1000f;
if (TimeToSave < 0)
{
TimeToSave = TIME_TO_SAVE;
foreach (Kingdom k in Kingdoms)
{
SaveKingdom(k);
}
foreach (Human h in HumansOnJourney)
{
if (Saved.Contains(h.HumanId))
{
DatabaseManager.HumansOnJourney.ReplaceOneAsync(hh => h.HumanId == hh.HumanId, h);
}
else
{
Saved.Add(h.HumanId);
DatabaseManager.HumansOnJourney.InsertOneAsync(h);
}
}
}
}
public virtual void transformHumanTask(PlanItem planItem, HumanTask humanTask, CmmnActivity caseActivity)
{
addTaskOrStageHandlers(caseActivity);
}
protected internal virtual void transformPlanItem(PlanItem planItem, CmmnActivity parent)
{
PlanItemDefinition definition = planItem.Definition;
ItemHandler planItemTransformer = null;
if (definition is HumanTask)
{
planItemTransformer = getPlanItemHandler(typeof(HumanTask));
}
else if (definition is ProcessTask)
{
planItemTransformer = getPlanItemHandler(typeof(ProcessTask));
}
else if (definition is CaseTask)
{
planItemTransformer = getPlanItemHandler(typeof(CaseTask));
}
else if (definition is DecisionTask)
{
planItemTransformer = getPlanItemHandler(typeof(DecisionTask));
}
else if (definition is Task)
{
planItemTransformer = getPlanItemHandler(typeof(Task));
}
else if (definition is Stage)
{
planItemTransformer = getPlanItemHandler(typeof(Stage));
}
else if (definition is Milestone)
{
planItemTransformer = getPlanItemHandler(typeof(Milestone));
}
else if (definition is EventListener)
{
planItemTransformer = getPlanItemHandler(typeof(EventListener));
}
if (planItemTransformer != null)
{
CmmnActivity newActivity = planItemTransformer.handleElement(planItem, context);
if (definition is Stage)
{
Stage stage = (Stage)definition;
transformStage(stage, newActivity);
context.Parent = parent;
}
else if (definition is HumanTask)
{
HumanTask humanTask = (HumanTask)definition;
// According to the specification: A HumanTask can only contain
// one planningTable, the XSD allows multiple planningTables!
ICollection <PlanningTable> planningTables = humanTask.PlanningTables;
foreach (PlanningTable planningTable in planningTables)
{
transformPlanningTable(planningTable, parent);
}
}
foreach (CmmnTransformListener transformListener in transformListeners)
{
if (definition is HumanTask)
{
transformListener.transformHumanTask(planItem, (HumanTask)definition, newActivity);
}
else if (definition is ProcessTask)
{
transformListener.transformProcessTask(planItem, (ProcessTask)definition, newActivity);
}
else if (definition is CaseTask)
{
transformListener.transformCaseTask(planItem, (CaseTask)definition, newActivity);
}
else if (definition is DecisionTask)
{
transformListener.transformDecisionTask(planItem, (DecisionTask)definition, newActivity);
}
else if (definition is Task)
{
transformListener.transformTask(planItem, (Task)definition, newActivity);
}
else if (definition is Stage)
{
transformListener.transformStage(planItem, (Stage)definition, newActivity);
}
else if (definition is Milestone)
{
transformListener.transformMilestone(planItem, (Milestone)definition, newActivity);
}
else if (definition is EventListener)
{
transformListener.transformEventListener(planItem, (EventListener)definition, newActivity);
}
}
}
}
public virtual void transformHumanTask(PlanItem planItem, HumanTask humanTask, CmmnActivity activity)
{
modelElementInstances.Add(planItem);
modelElementInstances.Add(humanTask);
cmmnActivities.Add(activity);
}
private MessageCallback[] WorkTasks(Human h, float delta)
{
List <MessageCallback> res = new List <MessageCallback>();
HumanTask t = h.TasksToDo.FirstOrDefault();
while (t != null)
{
if (t.TaskType != ETask.ListeningKing)
{
t.TimeLeft -= delta;
}
int k = h.Worked(delta, t.Difficulty) ? 1 : -1;
var soworkers = new List <Human>();
for (int i = 0; i < t.InUse.Count; ++i)
{
Guid[] owners_ids = t.InUse[i].GetOwners();
for (int j = 0; j < owners_ids.Length; ++j)
{
h.UpdateFriendship(owners_ids[j], k * delta);
}
}
if (t.TimeLeft <= 0)
{
if (t.Skill != null)
{
h.UpgradeSkill(t.Skill, 0.999f);
}
h.TasksToDo.RemoveAt(0);
delta = delta + t.TimeLeft;
if (t.Repeating)
{
t.CalculateTaskTime(h, t.Difficulty, t.Skill);
if (!h.AddTask(t))
{
res.Add(new MessageCallback(
Locale.Get(string.Format("problems.dont_work", h.GetName(Language)), Language),
ECharacter.Knight
));
}
}
switch (t.TaskType)
{
case ETask.Building:
AddBuilding(t.Destination, h.GetSkill("building"));
string bname = ContentManager.GetBuildingName(t.Destination, Language);
string msg = string.Format(Locale.Get("notifications.builded", Language), bname);
res.Add(new MessageCallback(msg, ECharacter.King));
break;
case ETask.Training:
h.UpgradeSkill(t.Destination);
break;
case ETask.Extracting:
case ETask.Creating:
AddResource(t.Destination, 1, h.GetSkill(t.Skill));
break;
}
t = h.TasksToDo.FirstOrDefault();
}
else
{
break;
}
}
return(res.ToArray());
}
