🔥 First release

Author: JelteMX

.gitignore

@@ -0,0 +1,2 @@
+.DS_Store
+dist/tmp

LICENSE

@@ -0,0 +1,15 @@
+The Apache License v2.0
+
+Copyright Jelte Lagendijk <[email protected]> 2020
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.

README.md

@@ -0,0 +1,55 @@
+[![Support](https://img.shields.io/badge/Support-Community%20(no%20active%20support)-orange.svg)](https://docs.mendix.com/developerportal/app-store/app-store-content-support)
+[![Studio](https://img.shields.io/badge/Studio%20version-8.0%2B-blue.svg)](https://appstore.home.mendix.com/link/modeler/)
+![GitHub release](https://img.shields.io/github/release/JelteMX/mendix-math-module)
+![GitHub issues](https://img.shields.io/github/issues/JelteMX/mendix-math-module)
+
+# Math Module for Mendix
+
+![Icon](/assets/AppStoreIcon.png)
+
+Do you feel the need to do more complex calculations in Mendix, but see a lack in capabilities in your Microflows? No worries, the Math Module is here to help you out. This uses the excellent [mXparser libary](https://mathparser.org/) to extend your workflows with more complex calculations.
+
+> **See a demo in action [HERE](https://mathenginetestapp-sandbox.mxapps.io/p/simple)!**
+
+> I am looking for skilled Mendix+Java developers to help me make this even greater. The current set of Java actions are very flexible, but we can make more complex and dedicated actions available in the future. Feel free to contact me on Gitthub or through my [Mendix Developer profile](https://developer.mendixcloud.com/link/profile/overview/24785)
+
+![screenshot](/assets/screenshot-simple.png)
+![screenshot](/assets/screenshot-complex.png)
+
+## Java Actions
+
+### Expressions
+
+- **SimpleExpression** - calculate a simple expression that uses a formula you define as a String
+- **ComplexExpression** - calculate a more complex expression that uses Arguments
+
+### Function
+
+- **RecursiveFunction** - Do you need to calculate `f(10)` for `f(n)=f(n-2)+f(n-1)`? A recursive function might help you out
+
+### Decimals
+
+- **MoveDecimalPoint** - Move a decimal point in a Decimal
+
+### Conversion
+
+- **ConvertIntToBaseString** - Do you need to represent an Integer (base10) into another form, for example Octal (base8) or Hex (base16)?
+
+## Syntax
+
+The expressions and functions you write can use a whole range of built-in functions and constants. These can be found at [https://github.com/mariuszgromada/MathParser.org-mXparser#built-in-tokens](https://github.com/mariuszgromada/MathParser.org-mXparser#built-in-tokens)
+
+## Libraries used
+
+- mXparser library
+    - Version 4.3.3
+    - License: Simplified BSD - Mariusz Gromada
+    - [link](https://github.com/mariuszgromada/MathParser.org-mXparser/blob/master/LICENSE.txt)
+
+## Adding new Java Actions
+
+You can create new Java Actions using the mXparser library. See [API docs](http://mathparser.org/api/org/mariuszgromada/math/mxparser/package-summary.html).
+
+## License
+
+Apache 2

assets/AppStoreIcon.png

@@ -0,0 +1,51 @@
+package mathmodule;
+
+import java.math.BigDecimal;
+
+import com.mendix.core.Core;
+import com.mendix.systemwideinterfaces.core.IContext;
+import com.mendix.systemwideinterfaces.core.IMendixObject;
+
+import mathmodule.proxies.ExpressionResult;
+
+public class Misc {
+	
+	public static final double MAX_DECIMAL_VALUE = Math.pow(10, 20) - 1;
+	public static final double MAX_INT_VALUE = Math.pow(2, 31) - 1;
+	public static final double MAX_LONG_VALUE = Math.pow(2, 63) - 1;
+	
+	public static IMendixObject getExpressionResult(IContext ctx, double value) {
+		IMendixObject result = Core.instantiate(ctx, ExpressionResult.getType());
+		
+		String attrIsValid = ExpressionResult.MemberNames.IsValid.toString();
+		String attrValue = ExpressionResult.MemberNames.Value.toString();
+		String attrStringValue = ExpressionResult.MemberNames.StringValue.toString();
+		String attrHasDecimal = ExpressionResult.MemberNames.HasDecimal.toString();
+
+		result.setValue(ctx, attrIsValid, true);
+		result.setValue(ctx, attrStringValue, String.format("%.16f", value));
+		
+		if (value > MAX_DECIMAL_VALUE || value < (0 - MAX_DECIMAL_VALUE)) {
+			result.setValue(ctx, attrHasDecimal, false);
+			result.setValue(ctx, attrValue, null);
+		} else {
+			result.setValue(ctx, attrHasDecimal, true);
+			result.setValue(ctx, attrValue, new BigDecimal(value));
+		}
+		
+		
+		return result;
+	}
+	
+	public static IMendixObject getExpressionError(IContext ctx, String error) {
+		IMendixObject result = Core.instantiate(ctx, ExpressionResult.getType());
+		
+		String attrIsValid = ExpressionResult.MemberNames.IsValid.toString();
+		String attrError = ExpressionResult.MemberNames.ErrorMessage.toString();
+
+		result.setValue(ctx, attrIsValid, false);
+		result.setValue(ctx, attrError, error);
+		
+		return result;
+	}
+}

assets/screenshot-complex.png

@@ -0,0 +1,103 @@
+// This file was generated by Mendix Studio Pro.
+//
+// WARNING: Only the following code will be retained when actions are regenerated:
+// - the import list
+// - the code between BEGIN USER CODE and END USER CODE
+// - the code between BEGIN EXTRA CODE and END EXTRA CODE
+// Other code you write will be lost the next time you deploy the project.
+// Special characters, e.g., é, ö, à, etc. are supported in comments.
+
+package mathmodule.actions;
+
+import com.mendix.systemwideinterfaces.core.IContext;
+import com.mendix.webui.CustomJavaAction;
+import mathmodule.Misc;
+import mathmodule.proxies.ExpressionUseEnum;
+import com.mendix.systemwideinterfaces.core.IMendixObject;
+import org.mariuszgromada.math.mxparser.Expression;
+import java.math.BigDecimal;
+import org.mariuszgromada.math.mxparser.Argument;
+
+public class ComplexExpression extends CustomJavaAction<IMendixObject>
+{
+	private java.lang.String Expression;
+	private java.util.List<IMendixObject> __Arguments;
+	private java.util.List<mathmodule.proxies.Argument> Arguments;
+
+	public ComplexExpression(IContext context, java.lang.String Expression, java.util.List<IMendixObject> Arguments)
+	{
+		super(context);
+		this.Expression = Expression;
+		this.__Arguments = Arguments;
+	}
+
+	@java.lang.Override
+	public IMendixObject executeAction() throws Exception
+	{
+		this.Arguments = new java.util.ArrayList<mathmodule.proxies.Argument>();
+		if (__Arguments != null)
+			for (IMendixObject __ArgumentsElement : __Arguments)
+				this.Arguments.add(mathmodule.proxies.Argument.initialize(getContext(), __ArgumentsElement));
+
+		// BEGIN USER CODE
+		IContext ctx = this.getContext();
+		
+		if (this.Expression == "" || this.Expression == null) {
+			return Misc.getExpressionError(ctx, "Expression cannot be empty");
+		}
+		
+		Expression expression = new Expression(this.Expression);
+		for(mathmodule.proxies.Argument argument : this.Arguments) {
+			IMendixObject obj = argument.getMendixObject();
+			
+			String name = obj.getValue(ctx, mathmodule.proxies.Argument.MemberNames.ArgumentName.toString());
+			BigDecimal value = obj.getValue(ctx, mathmodule.proxies.Argument.MemberNames.Value.toString());
+			String stringValue = obj.getValue(ctx, mathmodule.proxies.Argument.MemberNames.StringValue.toString());
+			String enumeration = obj.getValue(ctx, mathmodule.proxies.Argument.MemberNames.Use.toString());
+			
+			if (enumeration.equals(ExpressionUseEnum.Decimal.name()) && value != null) {
+				Argument arg = new Argument(name, value.doubleValue());
+				expression.addArguments(arg);
+			} else if (enumeration.equals(ExpressionUseEnum.String.name()) && stringValue != null) {
+				double doubleValue = new Double(stringValue);
+				if (!Double.isNaN(doubleValue)) {
+					Argument arg = new Argument(name, doubleValue);
+					expression.addArguments(arg);
+				}
+			}
+		}
+		
+		boolean syntaxValid = expression.checkSyntax();
+		if (syntaxValid) {
+				
+			double expressionResult = expression.calculate();
+			boolean afterCalculateSatus = expression.checkSyntax();
+			
+			if (afterCalculateSatus) {
+				if (Double.isNaN(expressionResult)) {
+					return Misc.getExpressionError(ctx, "Expression result is not a number");
+				}
+				return Misc.getExpressionResult(ctx, expressionResult);
+			} else {
+				return Misc.getExpressionError(ctx, expression.getErrorMessage());
+			}
+
+		} else {
+			return Misc.getExpressionError(ctx, expression.getErrorMessage());
+		}
+		
+		// END USER CODE
+	}
+
+	/**
+	 * Returns a string representation of this action
+	 */
+	@java.lang.Override
+	public java.lang.String toString()
+	{
+		return "ComplexExpression";
+	}
+
+	// BEGIN EXTRA CODE
+	// END EXTRA CODE
+}

assets/screenshot-domain.png

@@ -0,0 +1,50 @@
+// This file was generated by Mendix Studio Pro.
+//
+// WARNING: Only the following code will be retained when actions are regenerated:
+// - the import list
+// - the code between BEGIN USER CODE and END USER CODE
+// - the code between BEGIN EXTRA CODE and END EXTRA CODE
+// Other code you write will be lost the next time you deploy the project.
+// Special characters, e.g., é, ö, à, etc. are supported in comments.
+
+package mathmodule.actions;
+
+import com.mendix.systemwideinterfaces.core.IContext;
+import com.mendix.webui.CustomJavaAction;
+import org.mariuszgromada.math.mxparser.mathcollection.NumberTheory;
+
+public class ConvertIntToBaseString extends CustomJavaAction<java.lang.String>
+{
+	private java.lang.Long Input;
+	private java.lang.Long Base;
+	private java.lang.Boolean IncludeBase;
+
+	public ConvertIntToBaseString(IContext context, java.lang.Long Input, java.lang.Long Base, java.lang.Boolean IncludeBase)
+	{
+		super(context);
+		this.Input = Input;
+		this.Base = Base;
+		this.IncludeBase = IncludeBase;
+	}
+
+	@java.lang.Override
+	public java.lang.String executeAction() throws Exception
+	{
+		// BEGIN USER CODE
+		int baseInclude = (this.IncludeBase == null ? false : this.IncludeBase) ? 1 : 0;
+		return NumberTheory.convDecimal2OthBase(this.Input, this.Base.intValue(), baseInclude);
+		// END USER CODE
+	}
+
+	/**
+	 * Returns a string representation of this action
+	 */
+	@java.lang.Override
+	public java.lang.String toString()
+	{
+		return "ConvertIntToBaseString";
+	}
+
+	// BEGIN EXTRA CODE
+	// END EXTRA CODE
+}

assets/screenshot-simple.png

@@ -0,0 +1,59 @@
+// This file was generated by Mendix Studio Pro.
+//
+// WARNING: Only the following code will be retained when actions are regenerated:
+// - the import list
+// - the code between BEGIN USER CODE and END USER CODE
+// - the code between BEGIN EXTRA CODE and END EXTRA CODE
+// Other code you write will be lost the next time you deploy the project.
+// Special characters, e.g., é, ö, à, etc. are supported in comments.
+
+package mathmodule.actions;
+
+import com.mendix.systemwideinterfaces.core.IContext;
+import com.mendix.webui.CustomJavaAction;
+import mathmodule.proxies.DecimalMoveDirection;
+
+public class DecimalMovePoint extends CustomJavaAction<java.math.BigDecimal>
+{
+	private java.math.BigDecimal Input;
+	private java.lang.Long MoveAmount;
+	private mathmodule.proxies.DecimalMoveDirection Direction;
+
+	public DecimalMovePoint(IContext context, java.math.BigDecimal Input, java.lang.Long MoveAmount, java.lang.String Direction)
+	{
+		super(context);
+		this.Input = Input;
+		this.MoveAmount = MoveAmount;
+		this.Direction = Direction == null ? null : mathmodule.proxies.DecimalMoveDirection.valueOf(Direction);
+	}
+
+	@java.lang.Override
+	public java.math.BigDecimal executeAction() throws Exception
+	{
+		// BEGIN USER CODE
+		if (this.Input == null) {
+			return null;
+		}
+		if (this.MoveAmount == null) {
+			return this.Input;
+		}
+		int amount = this.MoveAmount.intValue();
+		if (this.Direction.equals(DecimalMoveDirection.left)) {
+			return this.Input.movePointLeft(amount);
+		}
+		return this.Input.movePointRight(amount);
+		// END USER CODE
+	}
+
+	/**
+	 * Returns a string representation of this action
+	 */
+	@java.lang.Override
+	public java.lang.String toString()
+	{
+		return "DecimalMovePoint";
+	}
+
+	// BEGIN EXTRA CODE
+	// END EXTRA CODE
+}