ExtensionAPI-Samples/tutorial_microflows/CalculationsMicroflowCreator.cs at main · mendix/ExtensionAPI-Samples · GitHub

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
using Mendix.StudioPro.ExtensionsAPI.Model;
using Mendix.StudioPro.ExtensionsAPI.Model.DataTypes;
using Mendix.StudioPro.ExtensionsAPI.Model.Microflows;
using Mendix.StudioPro.ExtensionsAPI.Model.Projects;
using Mendix.StudioPro.ExtensionsAPI.Services;
using System.ComponentModel.Composition;

namespace MicroflowTutorial;

[Export(typeof(CalculationsMicroflowCreator))]
[method: ImportingConstructor]
class CalculationsMicroflowCreator(IMicroflowService microflowService, IMicroflowExpressionService microflowExpressionService)
{
    public void CreateMicroflows(IModel currentApp)
    {
        var module = currentApp.Root.GetModules().Single(m => m.Name == "MyFirstModule");

        using var transaction = currentApp.StartTransaction("Create microflows");

        CreateMicroflowsInFolder(currentApp, module);

        transaction.Commit();
    }

    void CreateMicroflowsInFolder(IModel currentApp, IFolderBase folder)
    {
        string multiplicationResult = "multiplicationResult";
        string additionResult = "additionResult";

        string returnValueExpression = $"(${multiplicationResult} - round(${additionResult}) > 0)";

        var callingMicroflow = microflowService.CreateMicroflow(currentApp, folder, "Microflow",
            new MicroflowReturnValue(DataType.Boolean, microflowExpressionService.CreateFromString(returnValueExpression)));

        CreateMultiplicationMicroflow(currentApp, folder, callingMicroflow, multiplicationResult);
        CreateAdditionMicroflow(currentApp, folder, callingMicroflow, additionResult);
    }

    void CreateMultiplicationMicroflow(IModel currentApp, IFolderBase folder, IMicroflow callingMicroflow, string outputVariableName)
    {
        var multiplication1Param = "multiplication1";
        var multiplication2Param = "multiplication2";

        var returnExpression = microflowExpressionService.CreateFromString($"${multiplication1Param} * ${multiplication2Param}");
        var returnValue = new MicroflowReturnValue(DataType.Integer, returnExpression);

        var multiplicationMicroflow = microflowService.CreateMicroflow(currentApp, folder, "MultiplicationMicroflow",
           returnValue,
           (multiplication1Param, DataType.Integer),
           (multiplication2Param, DataType.Integer));

        CreateMicroflowCallActivity(currentApp, callingMicroflow, multiplicationMicroflow,
           outputVariableName,
           (multiplication1Param, "10"),
           (multiplication2Param, "100"));
    }

    void CreateAdditionMicroflow(IModel currentApp, IFolderBase folder, IMicroflow callingMicroflow, string outputVariableName)
    {
        var addition1Param = "addition1";
        var addition2Param = "addition2";

        var returnExpression = microflowExpressionService.CreateFromString($"${addition1Param} + ${addition2Param}");
        var returnValue = new MicroflowReturnValue(DataType.Decimal, returnExpression);

        var additionMicroflow = microflowService.CreateMicroflow(currentApp, folder, "AdditionMicroflow",
            returnValue,
            (addition1Param, DataType.Decimal),
            (addition2Param, DataType.Decimal));

        CreateMicroflowCallActivity(currentApp, callingMicroflow, additionMicroflow,
           outputVariableName,
           (addition1Param, "1.2"),
           (addition2Param, "2.2"));
    }

    void CreateMicroflowCallActivity(IModel currentApp,
    IMicroflow microflowThatCalls,
    IMicroflow calledMicroflow,
    string outputVariableName,
    params (string parameterName, string expression)[] parameters)
    {
        var microflowCallActivity = currentApp.Create<IActionActivity>();
        var microflowCallAction = currentApp.Create<IMicroflowCallAction>();
        microflowCallAction.MicroflowCall = currentApp.Create<IMicroflowCall>();
        microflowCallAction.MicroflowCall.Microflow = calledMicroflow.QualifiedName;
        microflowCallActivity!.Action = microflowCallAction;
        microflowCallAction.OutputVariableName = outputVariableName;

        foreach (var (parameterName, expression) in parameters)
        {
            var parameterInCalledMicroflow = microflowService.GetParameters(calledMicroflow).Single(p => p.Name == parameterName);
            var parameterMapping = currentApp.Create<IMicroflowCallParameterMapping>();
            parameterMapping.Argument = microflowExpressionService.CreateFromString(expression);
            parameterMapping.Parameter = parameterInCalledMicroflow.QualifiedName;
            microflowCallAction.MicroflowCall.AddParameterMapping(parameterMapping);
        }

        microflowService.TryInsertAfterStart(microflowThatCalls, microflowCallActivity);
    }
}