static string createMarkdownTable(string key, DecisionTable table)
{
StringBuilder header = new StringBuilder();
StringBuilder seperator = new StringBuilder();
StringBuilder columns = new StringBuilder();
foreach (var input in table.Inputs)
{
if (header.Length == 0)
{
header.Append("| ");
seperator.Append("|-");
columns.Append("| ");
}
header.Append(input.InputExpression.Text + " |");
seperator.Append("".PadRight(input.InputExpression.Text.Length, '-') + "-|");
columns.Append(getSampleForType(input.InputExpression.TypeRef).PadRight(input.InputExpression.Text.Length, ' ') + " |");
}
foreach (var input in table.Outputs)
{
header.Append("*" + input.Name + " |");
seperator.Append("-".PadRight(input.Name.Length + 1, '-') + "-|");
columns.Append(getSampleForType(input.TypeRef).PadRight(input.Name.Length + 1, ' ') + " |");
}
header.Append(" ! |");
seperator.Append(":-:|");
columns.Append("🔸|");
return($"## dmn:{key}\n" + header.ToString() + "\n" + seperator.ToString() + "\n" + columns + "\n" + "#### last run: never\n");
}
public void test()
{
DecisionTable <Class1> table = new DecisionTable <Class1>();
Decision <Class1> dec = new Decision <Class1>();
var conditions = new List <TestStatement <Class1> >();
//conditions.Add(new TestStatement<Class1>{ SourceProperty = new PropertyInfo(), TestOperand = new})
var results = new List <ActionStatement <Class1> >();
}
public string WriteTableToString <T>(DecisionTable <T> table)
where T : class
{
StringBuilder bld = new StringBuilder();
foreach (var line in table.Decisions)
{
foreach (var condition in line.Conditions)
{
bld.Append(condition.ToString());
}
}
return(bld.ToString());
}
protected internal static DmnModelInstance createDmnModelInstance()
{
DmnModelInstance modelInstance = Dmn.createEmptyModel();
Definitions definitions = modelInstance.newInstance(typeof(Definitions));
definitions.Id = DmnModelConstants.DMN_ELEMENT_DEFINITIONS;
definitions.Name = DmnModelConstants.DMN_ELEMENT_DEFINITIONS;
definitions.Namespace = DmnModelConstants.CAMUNDA_NS;
modelInstance.Definitions = definitions;
Decision decision = modelInstance.newInstance(typeof(Decision));
decision.Id = "Decision-1";
decision.Name = "foo";
decision.CamundaHistoryTimeToLive = 5;
modelInstance.Definitions.addChildElement(decision);
DecisionTable decisionTable = modelInstance.newInstance(typeof(DecisionTable));
decisionTable.Id = DmnModelConstants.DMN_ELEMENT_DECISION_TABLE;
decisionTable.HitPolicy = HitPolicy.FIRST;
decision.addChildElement(decisionTable);
Input input = modelInstance.newInstance(typeof(Input));
input.Id = "Input-1";
input.Label = "Input";
decisionTable.addChildElement(input);
InputExpression inputExpression = modelInstance.newInstance(typeof(InputExpression));
inputExpression.Id = "InputExpression-1";
Text inputExpressionText = modelInstance.newInstance(typeof(Text));
inputExpressionText.TextContent = "input";
inputExpression.Text = inputExpressionText;
inputExpression.TypeRef = "string";
input.InputExpression = inputExpression;
Output output = modelInstance.newInstance(typeof(Output));
output.Name = "output";
output.Label = "Output";
output.TypeRef = "string";
decisionTable.addChildElement(output);
return(modelInstance);
}
public List <Element> GetOptimaElements()
{
if (AlgorithmNotRun)
{
return(null);
}
var list = new List <Element>();
var maxCost = GetMaxValue();
for (int i = Categories.Count - 1; i >= 0; i--)
{
var category = Categories[i];
var max = Table
.Where(e => category.Elements.Contains(e.Key.Value))
.OrderByDescending(e => e.Value);
var max2 = max.FirstOrDefault(e => e.Value <= maxCost);
bool maxChosen = false;
if (!DecisionTable.TryGetValue(max2.Key, out maxChosen))
{
continue;
}
;
if (maxChosen == false)
{
continue;
}
;
list.Add(max2.Key.Value);
var remainingMax = max2.Value - max2.Key.Value.Value;
maxCost = remainingMax;
if (maxCost == 0)
{
break;
}
}
return(list);
}
public void LoadData(DecisionTable data, MethodClass method, LimnorProject project)
{
_prj = project;
_method = method;
_dataTable = new DataTable("Data");
_dataTable.Columns.Add("Condition", typeof(object));
_dataTable.Columns.Add("Actions", typeof(object));
if (data != null)
{
this.ClientSize = data.ControlSize;
for (int i = 0; i < data.ConditionCount; i++)
{
_dataTable.Rows.Add(data[i].Condition, data[i].Actions);
}
}
dataGridView1.DataSource = _dataTable;
dataGridView1.Columns[0].AutoSizeMode = DataGridViewAutoSizeColumnMode.Fill;
dataGridView1.Columns[0].SortMode = DataGridViewColumnSortMode.NotSortable;
dataGridView1.Columns[1].AutoSizeMode = DataGridViewAutoSizeColumnMode.Fill;
dataGridView1.Columns[1].SortMode = DataGridViewColumnSortMode.NotSortable;
}
private void KnapsackAlgorithm()
{
foreach (var cost in Costs)
{
int categoryIndex = 0;
foreach (var category in Categories)
{
foreach (var element in category.Elements)
{
var kvp = new KeyValuePair <decimal, Element>(cost, element);
decimal param1 = 0;
if (categoryIndex != 0)
{
var previous = Categories.ElementAtOrDefault(categoryIndex - 1);
param1 = MaxValueInCategory(previous, cost);
}
decimal param2 = 0;
if (cost - element.Cost >= 0)
{
if (cost - element.Cost > 0 && categoryIndex != 0)
{
var previous = Categories.ElementAtOrDefault(categoryIndex - 1);
param2 = MaxValueInCategory(previous, cost - element.Cost);
}
param2 += element.Value;
}
var max = param1 >= param2 ? param1 : param2;
var chosen = param1 <= param2;
Table.Add(kvp, max);
DecisionTable.Add(kvp, chosen);
}
categoryIndex++;
}
}
}
private void btOK_Click(object sender, EventArgs e)
{
Result = new DecisionTable();
for (int i = 0; i < _dataTable.Rows.Count; i++)
{
Result.Add((MathNodeRoot)(_dataTable.Rows[i][0]), (ActionList)(_dataTable.Rows[i][1] == DBNull.Value ? null : _dataTable.Rows[i][1]));
}
Result.ConditionColumnWidth = dataGridView1.Columns[0].Width;
Result.ActionColumnWidth = dataGridView1.Columns[1].Width;
Result.ControlSize = this.ClientSize;
if (EditFinished != null)
{
EditFinished(this, EventArgs.Empty);
}
else
{
Form f = FindForm();
if (f != null)
{
f.DialogResult = DialogResult.OK;
}
}
}
/// <summary>
/// Validates the <paramref name="sourceTable"/> within the <see cref="DmnModel"/>
/// and creates <see cref="DmnDecisionTable"/>
/// </summary>
/// <param name="sourceTable">Decision source parsed from XML</param>
/// <param name="decisionName">Unique name of decision</param>
/// <param name="requiredInputs">Inputs required by decision</param>
/// <param name="requiredDecisions">Decisions, the decision table depends on</param>
///<exception cref="ArgumentNullException"><paramref name="sourceTable"/>, <paramref name="decisionName"/>, <paramref name="requiredInputs"/> or <paramref name="requiredDecisions"/> is null.</exception>
///<exception cref="ArgumentException"><paramref name="decisionName"/> is empty</exception>
/// <exception cref="DmnParserException">No outputs for decision table</exception>
/// <exception cref="DmnParserException">No inputs for decision table</exception>
/// <exception cref="DmnParserException">Input variable for decision table not found</exception>
/// <exception cref="DmnParserException">No rules for decision table</exception>
/// <exception cref="DmnParserException">Number of rule input entries doesn't match the number of inputs for decision table</exception>
/// <exception cref="DmnParserException">Number of rule output entries doesn't match the number of outputs for decision table</exception>
protected DmnDecisionTable CreateDecisionTable(
DecisionTable sourceTable,
string decisionName,
List <IDmnVariable> requiredInputs,
List <IDmnDecision> requiredDecisions)
{
if (sourceTable == null)
{
throw Logger.Fatal <ArgumentNullException>($"{nameof(sourceTable)} is null");
}
if (decisionName == null)
{
throw Logger.Fatal <ArgumentNullException>($"{nameof(decisionName)} is null");
}
if (string.IsNullOrWhiteSpace(decisionName))
{
throw Logger.Fatal <ArgumentException>($"{nameof(decisionName)} is empty");
}
if (requiredInputs == null)
{
throw Logger.Fatal <ArgumentNullException>($"{nameof(requiredInputs)} is null");
}
if (requiredDecisions == null)
{
throw Logger.Fatal <ArgumentNullException>($"{nameof(requiredDecisions)} is null");
}
//prepare outputs
if (sourceTable.Outputs == null || sourceTable.Outputs.Count < 1)
{
throw Logger.Fatal <DmnParserException>($"No outputs for decision table {decisionName}");
}
var outputs = new List <DmnDecisionTableOutput>();
var outputIdx = 0;
foreach (var sourceOutput in sourceTable.Outputs)
{
//Label, Name, Id
var sourceVariableName =
!string.IsNullOrWhiteSpace(sourceOutput.Label) ? sourceOutput.Label :
!string.IsNullOrWhiteSpace(sourceOutput.Name) ? sourceOutput.Name :
sourceOutput.Id;
var variableName = DmnVariableDefinition.NormalizeVariableName(sourceVariableName);
if (!Variables.TryGetValue(variableName, out var variable))
{
//create variable
variable = new DmnVariableDefinition(variableName);
Variables.Add(variableName, variable);
}
variable.AddValueSetter($"Table Decision {decisionName}");
CheckAndUpdateVariableType(variable, sourceOutput.TypeRef);
var allowedValues = sourceOutput.AllowedOutputValues?.Values;
outputs.Add(new DmnDecisionTableOutput(outputIdx, variable, allowedValues));
outputIdx++;
}
//prepare inputs
if (sourceTable.Inputs == null || sourceTable.Inputs.Count < 1)
{
throw Logger.Fatal <DmnParserException>($"No inputs for decision table {decisionName}");
}
var inputs = new List <DmnDecisionTableInput>();
var inputIdx = 0;
foreach (var sourceInput in sourceTable.Inputs)
{
//Expression or variable by Label, Id
DmnVariableDefinition variable = null;
string expression = null;
if (string.IsNullOrWhiteSpace(sourceInput.InputExpression?.Text))
{
var sourceVariableName = !string.IsNullOrWhiteSpace(sourceInput.Label) ? sourceInput.Label : sourceInput.Id;
var variableName = DmnVariableDefinition.NormalizeVariableName(sourceVariableName);
if (!Variables.TryGetValue(variableName, out variable))
{
throw Logger.Fatal <DmnParserException>(
$"Input variable {sourceVariableName} ({variableName}) for decision table {decisionName} not found");
}
CheckAndUpdateVariableType(variable, sourceInput.InputExpression?.TypeRef);
}
else
{
expression = sourceInput.InputExpression.Text;
}
var allowedValues = sourceInput.AllowedInputValues?.Values;
inputs.Add(new DmnDecisionTableInput(inputIdx, variable, expression, allowedValues));
inputIdx++;
}
//prepare rules
if (sourceTable.Rules == null || sourceTable.Rules.Count < 1)
{
throw Logger.Fatal <DmnParserException>($"No rules for decision table {decisionName}");
}
var rules = new List <DmnDecisionTableRule>();
var ruleIdx = 0;
foreach (var sourceRule in sourceTable.Rules)
{
if (sourceRule.InputEntries == null || sourceRule.InputEntries.Count != inputs.Count)
{
throw Logger.Fatal <DmnParserException>($"Number of input entries doesn't match the number of inputs for decision table {decisionName}. Rule Id:{sourceRule.Id} ");
}
if (sourceRule.OutputEntries == null || sourceRule.OutputEntries.Count != outputs.Count)
{
throw Logger.Fatal <DmnParserException>($"Number of output entries doesn't match the number of outputs for decision table {decisionName}. Rule Id:{sourceRule.Id} ");
}
var ruleInputs = new List <DmnDecisionTableRuleInput>();
var ruleOutputs = new List <DmnDecisionTableRuleOutput>();
var ruleName = string.IsNullOrWhiteSpace(sourceRule.Label) ? sourceRule.Id : sourceRule.Label;
//inputs
var ruleInputIdx = 0;
foreach (var sourceRuleInputEntry in sourceRule.InputEntries)
{
if (!string.IsNullOrWhiteSpace(sourceRuleInputEntry.Text) && sourceRuleInputEntry.Text != "-") //don't create rule inputs with no condition - can be also represented as single dash
{
var ruleInput = new DmnDecisionTableRuleInput(inputs[ruleInputIdx], sourceRuleInputEntry.Text);
ruleInputs.Add(ruleInput);
}
ruleInputIdx++;
}
//outputs
var ruleOutputIdx = 0;
foreach (var sourceRuleOutputEntry in sourceRule.OutputEntries)
{
var ruleOutput = new DmnDecisionTableRuleOutput(outputs[ruleOutputIdx], sourceRuleOutputEntry.Text);
ruleOutputs.Add(ruleOutput);
ruleOutputIdx++;
}
rules.Add(new DmnDecisionTableRule(ruleIdx, ruleName, ruleInputs.ToArray(), ruleOutputs.ToArray(), sourceRule.Description));
ruleIdx++;
}
var decisionTable = new DmnDecisionTable(
decisionName,
sourceTable.HitPolicy, sourceTable.Aggregation,
inputs.ToArray(), outputs.ToArray(), rules.ToArray(),
requiredInputs, requiredDecisions);
return(decisionTable);
}
public void AddDecisionTable <T>(DecisionTable <T> table)
where T : class
{
}
public void LoadData(DecisionTable data, MethodClass method, LimnorProject project, MethodDesignerHolder view)
{
_viewer = view;
this.ClientSize = data.ControlSize;
decisionTableControl1.LoadData(data, method, project);
}
