Updates: Validation, better domain model

Author: JelteMX

dist/MathModule.mpk

@@ -0,0 +1,67 @@
+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.SimpleExpressionResult;
+import mathmodule.proxies.ComplexExpressionResult;
+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 getComplexExpressionResult(IContext ctx, double value) {
+		IMendixObject result = Core.instantiate(ctx, ComplexExpressionResult.getType());
+		
+		String attrIsValid = ComplexExpressionResult.MemberNames.IsValid.toString();
+		String attrValue = ComplexExpressionResult.MemberNames.Value.toString();
+		String attrStringValue = ComplexExpressionResult.MemberNames.StringValue.toString();
+		String attrHasDecimal = ComplexExpressionResult.MemberNames.HasDecimal.toString();
+		
+		return setExpressionResultObject(ctx, result, value, attrIsValid, attrStringValue, attrValue, attrHasDecimal);
+	}
+	
+	public static IMendixObject getSimpleExpressionResult(IContext ctx, double value) {
+		IMendixObject result = Core.instantiate(ctx, SimpleExpressionResult.getType());
+		
+		String attrIsValid = SimpleExpressionResult.MemberNames.IsValid.toString();
+		String attrValue = SimpleExpressionResult.MemberNames.Value.toString();
+		String attrStringValue = SimpleExpressionResult.MemberNames.StringValue.toString();
+		String attrHasDecimal = SimpleExpressionResult.MemberNames.HasDecimal.toString();
+		
+		return setExpressionResultObject(ctx, result, value, attrIsValid, attrStringValue, attrValue, attrHasDecimal);
+	}
+	
+	private static IMendixObject setExpressionResultObject(IContext ctx, IMendixObject result, double value, String attrIsValid, String attrStringValue, String attrValue, String attrHasDecimal) {
+		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 resultType, String error) {
+		IMendixObject result = Core.instantiate(ctx, resultType);
+		
+		String attrIsValid = ExpressionResult.MemberNames.IsValid.toString();
+		String attrError = ExpressionResult.MemberNames.ErrorMessage.toString();
+
+		result.setValue(ctx, attrIsValid, false);
+		result.setValue(ctx, attrError, error);
+		
+		return result;
+	}
+}

src/MathModule.mpk

@@ -9,9 +9,11 @@
 
 package mathmodule.actions;
 
+import com.mendix.core.Core;
 import com.mendix.systemwideinterfaces.core.IContext;
 import com.mendix.webui.CustomJavaAction;
 import mathmodule.Misc;
+import mathmodule.proxies.ComplexExpressionResult;
 import mathmodule.proxies.ExpressionUseEnum;
 import com.mendix.systemwideinterfaces.core.IMendixObject;
 import org.mariuszgromada.math.mxparser.Expression;
@@ -43,7 +45,7 @@ public IMendixObject executeAction() throws Exception
 		IContext ctx = this.getContext();
 
 		if (this.Expression == "" || this.Expression == null) {
-			return Misc.getExpressionError(ctx, "Expression cannot be empty");
+			return Misc.getExpressionError(ctx, ComplexExpressionResult.getType(), "Expression cannot be empty");
 		}
 
 		Expression expression = new Expression(this.Expression);
@@ -59,14 +61,14 @@ public IMendixObject executeAction() throws Exception
 				Argument arg = new Argument(name, value.doubleValue());
 				expression.addArguments(arg);
 			} else if (enumeration.equals(ExpressionUseEnum.String.name()) && stringValue != null) {
-				double doubleValue = new Double(stringValue);
+				double doubleValue = Double.parseDouble(stringValue);
 				if (!Double.isNaN(doubleValue)) {
 					Argument arg = new Argument(name, doubleValue);
 					expression.addArguments(arg);
 				}
 			}
 		}
-		
+
 		boolean syntaxValid = expression.checkSyntax();
 		if (syntaxValid) {
 
@@ -75,15 +77,31 @@ public IMendixObject executeAction() throws Exception
 
 			if (afterCalculateSatus) {
 				if (Double.isNaN(expressionResult)) {
-					return Misc.getExpressionError(ctx, "Expression result is not a number");
+					return Misc.getExpressionError(ctx, ComplexExpressionResult.getType(), "Expression result is not a number");
 				}
-				return Misc.getExpressionResult(ctx, expressionResult);
+				return Misc.getComplexExpressionResult(ctx, expressionResult);
 			} else {
-				return Misc.getExpressionError(ctx, expression.getErrorMessage());
+				return Misc.getExpressionError(ctx, ComplexExpressionResult.getType(), expression.getErrorMessage());
 			}
 
 		} else {
-			return Misc.getExpressionError(ctx, expression.getErrorMessage());
+			String[] missingArguments = expression.getMissingUserDefinedArguments();
+			IMendixObject complexResult = Misc.getExpressionError(ctx, ComplexExpressionResult.getType(), expression.getErrorMessage());
+			
+			if (missingArguments.length > 0) {
+				String hasMissing = ComplexExpressionResult.MemberNames.HasMissingArguments.toString();
+				complexResult.setValue(ctx, hasMissing, true);
+				
+				for (int i = 0; i < missingArguments.length; i++) {
+					String missing = missingArguments[i];
+					IMendixObject missingObject = Core.instantiate(ctx, mathmodule.proxies.Argument.getType());
+					missingObject.setValue(ctx, mathmodule.proxies.Argument.MemberNames.ArgumentName.toString(), missing);
+					missingObject.setValue(ctx, mathmodule.proxies.Argument.MemberNames.Missing.toString(), complexResult.getId());
+					Core.commit(ctx, missingObject);
+				}
+			}
+			
+			return complexResult;
 		}
 
 		// END USER CODE

src/javasource/mathmodule/Misc.java

@@ -9,12 +9,12 @@
 
 package mathmodule.actions;
 
-import org.mariuszgromada.math.mxparser.Argument;
 import org.mariuszgromada.math.mxparser.Expression;
 import org.mariuszgromada.math.mxparser.RecursiveArgument;
 import com.mendix.systemwideinterfaces.core.IContext;
 import com.mendix.webui.CustomJavaAction;
 import mathmodule.Misc;
+import mathmodule.proxies.SimpleExpressionResult;
 import com.mendix.systemwideinterfaces.core.IMendixObject;
 
 public class RecursiveFunction extends CustomJavaAction<IMendixObject>
@@ -40,11 +40,11 @@ public IMendixObject executeAction() throws Exception
 		IContext ctx = getContext();
 
 		if (this.Function == null || this.Function == "") {
-			return Misc.getExpressionError(ctx, "Function cannot be empty");
+			return Misc.getExpressionError(ctx, SimpleExpressionResult.getType(), "Function cannot be empty");
 		} else if (this.ValueIndex0 == null || this.ValueIndex1 == null) {
-			return Misc.getExpressionError(ctx, "For the recursive function you will need a value for n=0 and n=1");
+			return Misc.getExpressionError(ctx, SimpleExpressionResult.getType(), "For the recursive function you will need a value for n=0 and n=1");
 		} else if (this.FunctionCall == null) {
-			return Misc.getExpressionError(ctx, "The function needs a function call");
+			return Misc.getExpressionError(ctx, SimpleExpressionResult.getType(), "The function needs a function call");
 		}
 
 		RecursiveArgument recursive = new RecursiveArgument(this.Function);
@@ -59,20 +59,20 @@ public IMendixObject executeAction() throws Exception
 			boolean expressionValid = expression.checkSyntax();
 
 			if (!expressionValid) {
-				return Misc.getExpressionError(ctx, expression.getErrorMessage());
+				return Misc.getExpressionError(ctx, SimpleExpressionResult.getType(), expression.getErrorMessage());
 			}
 
 			double value = expression.calculate();
 
 			if (Double.isNaN(value)) {
-				return Misc.getExpressionError(ctx, "Function does not return a number");
+				return Misc.getExpressionError(ctx, SimpleExpressionResult.getType(), "Function does not return a number");
 			}
 
 			// Not sure if needed, maybe clear up memory
 			recursive.resetAllCases();
-			return Misc.getExpressionResult(ctx, value);
+			return Misc.getSimpleExpressionResult(ctx, value);
 		} else {
-			return Misc.getExpressionError(ctx, recursive.getErrorMessage());
+			return Misc.getExpressionError(ctx, SimpleExpressionResult.getType(), recursive.getErrorMessage());
 		}
 		// END USER CODE
 	}

src/mathmodule/actions/ComplexExpression.java renamed to src/javasource/mathmodule/actions/ComplexExpression.java

@@ -13,6 +13,7 @@
 import com.mendix.webui.CustomJavaAction;
 import com.mendix.systemwideinterfaces.core.IMendixObject;
 import mathmodule.Misc;
+import mathmodule.proxies.SimpleExpressionResult;
 import org.mariuszgromada.math.mxparser.Expression;
 
 public class SimpleExpression extends CustomJavaAction<IMendixObject>
@@ -31,7 +32,7 @@ public IMendixObject executeAction() throws Exception
 		// BEGIN USER CODE
 		IContext ctx = this.getContext();
 		if (this.Expression == "" || this.Expression == null) {
-			return Misc.getExpressionError(ctx, "Expression cannot be empty");
+			return Misc.getExpressionError(ctx, SimpleExpressionResult.getType(), "Expression cannot be empty");
 		}
 		Expression simpleExpression = new Expression(this.Expression);
 		boolean syntaxValid = simpleExpression.checkSyntax();
@@ -42,15 +43,15 @@ public IMendixObject executeAction() throws Exception
 			boolean afterCalculateSatus = simpleExpression.checkSyntax();
 			if (afterCalculateSatus) {
 				if (Double.isNaN(expressionResult)) {
-					return Misc.getExpressionError(ctx, "Expression result is not a number");
+					return Misc.getExpressionError(ctx, SimpleExpressionResult.getType(), "Expression result is not a number");
 				}
-				return Misc.getExpressionResult(ctx, expressionResult);
+				return Misc.getSimpleExpressionResult(ctx, expressionResult);
 			} else {
-				return Misc.getExpressionError(ctx, simpleExpression.getErrorMessage());
+				return Misc.getExpressionError(ctx, SimpleExpressionResult.getType(), simpleExpression.getErrorMessage());
 			}
 
 		} else {
-			return Misc.getExpressionError(ctx, simpleExpression.getErrorMessage());
+			return Misc.getExpressionError(ctx, SimpleExpressionResult.getType(), simpleExpression.getErrorMessage());
 		}
 		// END USER CODE
 	}

src/mathmodule/actions/ConvertIntToBaseString.java renamed to src/javasource/mathmodule/actions/ConvertIntToBaseString.java

@@ -0,0 +1,86 @@
+// 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 java.util.ArrayList;
+import java.util.List;
+import org.mariuszgromada.math.mxparser.Expression;
+import com.mendix.core.Core;
+import com.mendix.systemwideinterfaces.core.IContext;
+import com.mendix.webui.CustomJavaAction;
+import mathmodule.Misc;
+import mathmodule.proxies.ComplexValidation;
+import com.mendix.systemwideinterfaces.core.IMendixObject;
+
+public class ValidateComplexExpression extends CustomJavaAction<IMendixObject>
+{
+	private java.lang.String Expression;
+
+	public ValidateComplexExpression(IContext context, java.lang.String Expression)
+	{
+		super(context);
+		this.Expression = Expression;
+	}
+
+	@java.lang.Override
+	public IMendixObject executeAction() throws Exception
+	{
+		// BEGIN USER CODE
+		IContext ctx = this.getContext();
+		
+		if (this.Expression == "" || this.Expression == null) {
+			return Misc.getExpressionError(ctx, ComplexValidation.getType(), "Expression cannot be empty");
+		}
+		
+		Expression expression = new Expression(this.Expression);
+		
+		boolean status = expression.checkLexSyntax();
+		if (status) {
+			expression.checkSyntax();
+			
+			IMendixObject result = Core.instantiate(ctx, ComplexValidation.getType());
+			List<IMendixObject> argumentsList = new ArrayList<IMendixObject>();
+
+			result.setValue(ctx, ComplexValidation.MemberNames.IsValid.toString(), true);
+			
+			String[] usedArguments = expression.getMissingUserDefinedArguments();
+			if (usedArguments.length > 0) {
+				for (int i = 0; i < usedArguments.length; i++) {
+					String arg = usedArguments[i];
+					IMendixObject argObj = Core.instantiate(ctx, mathmodule.proxies.Argument.getType());
+					
+					argObj.setValue(ctx, mathmodule.proxies.Argument.MemberNames.ArgumentName.toString(), arg);
+					argObj.setValue(ctx, mathmodule.proxies.Argument.MemberNames.Needed.toString(), result.getId());
+
+					argumentsList.add(argObj);
+				}
+				Core.commit(ctx, argumentsList);
+			}
+			
+			return result;
+		} else {
+			String error = expression.getErrorMessage();
+			return Misc.getExpressionError(ctx, ComplexValidation.getType(), error);
+		}
+		// END USER CODE
+	}
+
+	/**
+	 * Returns a string representation of this action
+	 */
+	@java.lang.Override
+	public java.lang.String toString()
+	{
+		return "ValidateComplexExpression";
+	}
+
+	// BEGIN EXTRA CODE
+	// END EXTRA CODE
+}