Method util in D365fo x++

Method util in D365fo x++

internal final class DSSMethodCalculation
{
    DSSMethodId methodId;
    DSSMethod method;
    DSSUserId userId;
    DSSUsers dssUser;
    DSSTransDate transDate;
    DSSRefRecId refRecId;
    DSSRefTableId refTableId;
    anytype result;
    DSSArgs args;
    Args defaultArgs;
    Common common;

    public static DSSMethodCalculation construct()
    {
        return new DSSMethodCalculation();
    }

    private void new()
    {
    }

    public void parmArgs(DSSArgs _args)
    {
        args = _args;
    }

    public void parmDefaultArgs(Args _args)
    {
        defaultArgs = _args;
    }

    public void parmMethod(DSSMethodId _methodId)
    {
        methodId = _methodId;
    }

    public void parmUserId(DSSUserId _userId)
    {
        userId = _userId;
    }

    public void parmTransDate(DSSTransDate _transDate)
    {
        transDate = _transDate;
    }

    public void parmRefRecId(DSSRefRecId _refRecId)
    {
        refRecId = _refRecId;
    }

    public void parmRefTableId(DSSRefTableId _refTableId)
    {
        refTableId = _refTableId;
    }

    public void parmCommon(Common _common)
    {
        common = _common;
    }

    public anytype getResult()
    {
        return result;
    }

    public anytype getStringResult()
    {
        return any2Str(result);
    }

    public real getRealResult()
    {
        return any2Real(result);
    }

    public void run()
    {
        this.init();

        if(this.validateMethod())
        {
            this.callMethod();
        }
    }

    private void init()
    {
        method = DSSMethod::find(this.methodId);
        dssUser = (!dssUser && args) ? args.dssUser() : dssUser;
        refTableId = (!refTableId && args) ? args.refTableId() : refTableId;
        refRecId = (!refRecId && args) ? args.refRecId() : refRecId;
    }

    private boolean validateMethod()
    {
        return (method && method.IsValid) ? true : checkFailed(strFmt("@DSPLabel:DSP001747", method.MethodId));
    }

    private void callMethod()
    {
        switch(method.ObjectType)
        {
            case DSSPortalObjectType::Class:
                this.callClassMethod();
                break;
            case DSSPortalObjectType::Table:
                this.callTableMethod();
                break;
        }
    }

    private void callTableMethod()
    {
        ClassName objectName;
        MethodName methodName;
        boolean isStaticMethod;
        ;

        objectName = method.ObjectName;
        methodName = method.MethodName;
        isStaticMethod = method.IsStaticMethod;

        if(isStaticMethod)
        {
            var methodResult = this.makeStaticCallForTable(objectName, methodName, this.getParameters());
            result = methodResult;
        }
        else
        {
            var methodResult = this.makeObjectCallForTable(objectName, methodName, this.getParameters(), common);
            result = methodResult;
        }
    }

    private void callClassMethod()
    {
        ClassName objectName;
        MethodName methodName;
        boolean isStaticMethod;
        ;

        objectName = method.ObjectName;
        methodName = method.MethodName;
        isStaticMethod = method.IsStaticMethod;

        if(isStaticMethod)
        {
            var methodResult = this.makeStaticCall(objectName, methodName, this.getParameters());
            result = methodResult;
        }
        else
        {
            var methodResult = this.makeObjectCall(objectName, methodName, this.getParameters());
            result = methodResult;
        }
    }

    private System.Object[] getParameters()
    {
        DSSMethodParameters methodParameters;
        var parameters = new System.Collections.ArrayList();

        while select methodParameters
            order by methodParameters.Sequence
            where methodParameters.MethodIdRef == method.MethodId 
        {
            switch(methodParameters.Type)
            {
                case DSSPortalParameterType::ESSUserId:
                    parameters.Add(userId);
                    break;
                case DSSPortalParameterType::Employee:
                    parameters.Add(dssUser.displayEmployeeId());
                    break;
                case DSSPortalParameterType::Worker:
                    parameters.Add(dssUser.getWorker().RecId);
                    break;
                case DSSPortalParameterType::UserId:
                    parameters.Add(dssUser.getSystemUserId());
                    break;
                case DSSPortalParameterType::Lookup:
                case DSSPortalParameterType::ReferenceLookup:
                case DSSPortalParameterType::Fix:
                    parameters.Add(methodParameters.Value);
                    break;
                case DSSPortalParameterType::Method:

                    DSSMethodCalculation methodCalculation;

                    methodCalculation = DSSMethodCalculation::construct();
                    methodCalculation.parmArgs(args);
                    methodCalculation.parmMethod(methodParameters.Value);
                    methodCalculation.parmTransDate(transDate);
                    methodCalculation.Run();

                    parameters.Add(methodCalculation.getResult());
                    break;
                case DSSPortalParameterType::TransDate:
                    parameters.Add(transDate);
                    break;
                case DSSPortalParameterType::ESSUser:
                    parameters.Add(dssUser);
                    break;
                case DSSPortalParameterType::RefRecId:
                    parameters.Add(refRecId);
                    break;
                case DSSPortalParameterType::RefTableId:
                    parameters.Add(refTableId);
                    break;
                case DSSPortalParameterType::Common:
                    parameters.Add(common ? common : args.record());
                    break;
                case DSSPortalParameterType::Object:
                    parameters.Add(args.object());
                    break;
                case DSSPortalParameterType::DSSArgs:
                    parameters.Add(args);
                    break;
                case DSSPortalParameterType::Args:
                    parameters.Add(defaultArgs);
                    break;
                case DSSPortalParameterType::CommonField:
                    parameters.Add(args.recordValue());
                    break;
                case DSSPortalParameterType::CommonChild:
                    parameters.Add(common);
                    break;
                case DSSPortalParameterType::CommonParent:
                    parameters.Add(args.record());
                    break;
            }
        }

        return parameters.ToArray();
    }

    internal anytype makeStaticCall(str _xppTypeName, str _methodName, System.Object[] _parameters)
    {
        System.Type xppType = Microsoft.Dynamics.Ax.Xpp.ReflectionCallHelper::getType(_xppTypeName);
        var ret = Microsoft.Dynamics.Ax.Xpp.ReflectionCallHelper::MakeStaticCall(xppType, _methodName, _parameters);
        
        return ret;
    }

    internal anytype makeObjectCall(str _xppTypeName, str _methodName, System.Object[] _parameters)
    {
        Object obj = classFactory.createClass(className2Id(_xppTypeName));
        var ret = Microsoft.Dynamics.Ax.Xpp.ReflectionCallHelper::MakeInstanceCall(obj, _methodName, _parameters);
        
        return ret;
    }

    internal anytype makeObjectCallForTable(str _xppTypeName, str _methodName, System.Object[] _parameters, Common _common = nullValueBaseType(Types::Record))
    {
        anytype ret;
        Common callerRecord = _common;
        SysDictTable sysDictTable = new SysDictTable(tableName2Id(_xppTypeName));

        if(!callerRecord.TableId)
        {
            callerRecord = sysDictTable.makeRecord();
        }

        //if(SysDictTable::hasMethod(sysDictTable, _methodName))
        //{
        //    ret = sysDictTable.callObject(_methodName, callerRecord, _parameters);
        //}
        //callerRecord = callerRecord.GetConcreteTable();
        ret = callerRecord.MakeReflectionCall(_methodName, _parameters);

        return ret;
    }

    internal anytype makeStaticCallForTable(str _xppTypeName, str _methodName, System.Object[] _parameters)
    {
        return this.makeStaticCall(_xppTypeName, _methodName, _parameters);;
    }

}