DSS Util d365fo x++

 DSS Util d365fo x++

Code:

using System.Globalization;

class DSSUtil
{
    private static DSSUtil utilObject;



    public static DSSUtil construct()
    {
        if(!utilObject)
        {
            utilObject = new DSSUtil();
        }
        return utilObject;
    }

    public str getNumberSequence(ExtendedTypeId _edt)
    {
        str                     numberSequenceID;
        SysLastValue            sysLastValue;
        NumberSequenceReference numberSequenceReference = NumberSeqReference::findReference(_edt);
        NumberSequenceTable     numberSequenceTable     = NumberSequenceTable::find(numberSequenceReference.NumberSequenceId);

        if (numberSequenceReference && numberSequenceTable)
        {
            if(!numberSequenceTable.Manual)
            {
                NumberSeq numberSeq = NumberSeq::newGetNumFromId(numberSequenceTable.RecId,true,true,sysLastValue,false);
                numberSequenceID    = (numberSeq) ? numberSeq.num() : '';
            }
        }
        return numberSequenceID;
    }

    public str getNumberSequenceValueFromTableField(RefTableId tableId, RefFieldId fieldId)
    {
        str numberSequenceValue;

        if(tableId && fieldId)
        {
            SysDictTable    dictTable   = new SysDictTable(tableId);
            SysDictField    dictField   = dictTable.fieldObject(fieldId);
            numberSequenceValue = this.getNumberSequence(dictField.typeId());
        }

        return numberSequenceValue;
    }

    public str getInfoLog()
    {
        str error;
        Exception exception;
        SysInfologEnumerator enumerator;
        SysInfologMessageStruct msgStruct;

        enumerator = SysInfologEnumerator::newData(infolog.cut());

        while (enumerator.moveNext())
        {
            msgStruct = new SysInfologMessageStruct(enumerator.currentMessage());
            exception = enumerator.currentException();
            error = strfmt("%1 %2", error, msgStruct.message());
        }

        return error;
    }

    public Common findRecord(TableId _tableId, RecId _recId, Boolean _forUpdate = false, boolean _crossCompany = false)
    {
        Common      common;
        DictTable   dictTable;
        ;

        if(_tableId && _recId)
        {
            dictTable = new DictTable(_tableId);
            common = dictTable.makeRecord();
 
            common.selectForUpdate(_forUpdate);
 
            if(_crossCompany)
            {
                select firstonly crosscompany common where common.RecId == _recId;
            }
            else
            {
                select firstonly common where common.RecId == _recId;
            }
        }
        
        return common;
    }

    public List stringLookupValues(RefTableId _tableId, RefFieldId _fieldId, str _filterField, System.Object _filterValue, str _orderByField)
    {
        str         filterField;
        str         orderBy;
        List        stringValues;
        Common      tableBuffer;
        DictTable   dictTable;
        TableId     tableId;
        FieldId     fieldId;
        System.Object           filterValue;
        SysDaQueryObject        sysDaQuery;
        SysDaSearchObject       searchObject;
        SysDaSearchStatement    searchStmt;
        ;

        try
        {
            filterField = _filterField;
            filterValue = _filterValue;
            orderBy     = _orderByField;
            tableId     = _tableId;
            fieldId     = _fieldId;
            stringValues= new List(Types::String);
            dictTable   = new DictTable(tableId);
            tableBuffer = dictTable.makeRecord();
            sysDaQuery  = new SysDaQueryObject(tableBuffer);
            searchStmt  = new SysDaSearchStatement();
            
            sysDaQuery.projection().add(fieldId2Name(tableId, fieldId));

            if(filterField && filterValue)
                sysDaQuery.whereClause(new SysDaEqualsExpression (new SysDaFieldExpression(tableBuffer, filterField), new SysDaValueExpression(filterValue)));

            if(orderBy)
                sysDaQuery.orderByClause().add(orderBy);

            searchObject = new SysDaSearchObject(sysDaQuery);

            while (searchStmt.nextRecord(searchObject))
            {
                stringValues.addEnd(tableBuffer.(fieldId));
            }
            
        }
        catch
        {
        }

        return stringValues;
    }

    anytype getFirstValueFromList(List list)
    {
        anytype value;
        ListEnumerator enumerator;
        ;

        if(list != null)
        {
            enumerator = list.getEnumerator();

            while(enumerator.moveNext())
            {
                value = enumerator.current();
                break;
            }
        }
        return value;
    }

    List getEnumValues(EnumId _enumId)
    {
        List enumValuesList = new List(Types::String);
        SysDictEnum SysDictEnum = new SysDictEnum(_enumId);
        
        for (int i=0; i<SysDictEnum.values(); i++)
        {
            enumValuesList.addEnd(SysDictEnum.index2Label(i));
        }
        return enumValuesList;
    }

    EnumId getEnumIdFromTableFieldId(RefTableId tableId, RefFieldId fieldId)
    {
        EnumId          enumId;
        SysDictTable    dictTable;
        SysDictField    dictField;

        if(tableId && fieldId)
        {
            dictTable   = new SysDictTable(tableId);
            dictField   = dictTable.fieldObject(fieldId);
            enumId      = dictField.enumId();
        }

        return enumId;
    }

    List getEnumValuesFromField(RefTableId tableId, RefFieldId fieldId)
    {
        return this.getEnumValues(this.getEnumIdFromTableFieldId(tableId, fieldId));
    }

    List getSupportedEnumValuesFromField(Common _common, RefFieldId _fieldId)
    {
        List supportedEnumValues = new List(Types::String);
        boolean hasGetSupportedEnumValues;
        IdentifierName methodName;
        
        methodName = 'getSupportedEnumValues';

        if(_common)
        {
            SysDictTable dictTable = new SysDictTable(_common.TableId);
            hasGetSupportedEnumValues = SysDictTable::hasMethod(dictTable, methodName);

            if(hasGetSupportedEnumValues)
            {
                Set supportedEnumValueSet = dictTable.callObject(methodName, _common, _fieldId);

                if(supportedEnumValueSet)
                {
                    SetEnumerator setEnumerator = supportedEnumValueSet.getEnumerator();
                    //SysDictEnum sysDictEnum = new SysDictEnum(this.getEnumIdFromTableFieldId(_common.TableId, _fieldId));
                    while (setEnumerator.moveNext())
                    {
                        supportedEnumValues.addEnd(enum2Str(setEnumerator.current()));
                    }
                }
            }
        }

        return supportedEnumValues;
    }

    str getImageAsBase64(Bitmap _image)
    {
        Image imgObj;
        BinData bd;
        str result;

        if (_image)
        {
            imgObj = new Image(_image);
            imgObj.saveType(ImageSaveType::PNG);

            bd = new BinData();
            bd.setData(imgObj.getData());
            result = bd.base64Encode();
        }
        else
        {
            result = "";
        }
        return result;
    }

    str str2Base64(str _text)
    {
        BinData binData  = new BinData();
        System.Text.Encoding encoding = System.Text.Encoding::UTF8;
        System.Byte[] array = encoding.GetBytes(_text);
        System.IO.MemoryStream stream = new System.IO.MemoryStream(array);
        binData.setData(Binary::constructFromMemoryStream(stream).getContainer());
        return binData.base64Encode();
    }

    //str base642Str(str _base64)
    //{
    //    BinData binData = BinData::loadFromBase64(_base64Data);
    //    binData.get
    //}

    container getBase64AsImage(str _base64Data)
    {
        return BinData::loadFromBase64(_base64Data);
    }

    public void refreshDataSource(FormDataSource _fds)
    {
        FormDataSource fds;
        ;

        fds = _fds;

        if(fds)
        {
            fds.refresh();
            fds.reread();
            fds.research(true);
        }
    }

    public boolean isValidToSubmit(Common _common)
    {
        boolean ret = true;
        SysDictTable dictTable;
        RefTableId tableId;
        RefRecId recId;
        boolean hasValidToSubmitMethod;
        IdentifierName methodName;
        DictTable dt;
        ;

        methodName = 'isValidToSubmit';

        if(_common)
        {
            tableId = _common.TableId;
            recId = _common.RecId;
            dictTable = new SysDictTable(tableId);
            hasValidToSubmitMethod = SysDictTable::hasMethod(dictTable, methodName);

            if(hasValidToSubmitMethod)
            {
                ret = dictTable.callObject(methodName, _common);
            }
        }

        return ret;
    }

    public boolean callIsValidToApprove(Common _common)
    {
        boolean ret = true;
        SysDictTable dictTable;
        RefTableId tableId;
        RefRecId recId;
        boolean hasValidToSubmitMethod;
        IdentifierName methodName;
        DictTable dt;
        ;

        methodName = 'isValidToApprove';

        if(_common)
        {
            tableId = _common.TableId;
            recId = _common.RecId;
            dictTable = new SysDictTable(tableId);
            hasValidToSubmitMethod = SysDictTable::hasMethod(dictTable, methodName);

            if(hasValidToSubmitMethod)
            {
                ret = dictTable.callObject(methodName, _common);
            }
        }

        return ret;
    }

    public void callOnEditFormActivated(Common _common)
    {
        SysDictTable dictTable;
        RefTableId tableId;
        RefRecId recId;
        boolean hasOnEditFormActivated;
        IdentifierName methodName;
        DictTable dt;
        ;

        methodName = 'onEditFormActivated';

        if(_common)
        {
            tableId = _common.TableId;
            recId = _common.RecId;
            dictTable = new SysDictTable(tableId);
            hasOnEditFormActivated = SysDictTable::hasMethod(dictTable, methodName);

            if(hasOnEditFormActivated)
            {
                dictTable.callObject(methodName, _common);
            }
        }
    }

    public void setRecordUserScope(Common _common, UserId _userId)
    {
        str scope = strFmt('CurrentUserScope-%1-%2', _common.TableId, _common.RecId);
        container key = ['User'];
        
        new SysGlobalObjectCache().insert(scope, key, [_userId]);
    }

    public void removeRecordUserScope(Common _common)
    {
        str scope = strFmt('CurrentUserScope-%1-%2', _common.TableId, _common.RecId);
        container key = ['User'];

        new SysGlobalObjectCache().remove(scope, key);
    }

    public void callOnEditFormActivatedForUser(Common _common, UserId _userId)
    {   
        this.setRecordUserScope(_common, _userId);

        this.callOnEditFormActivated(_common);

        this.removeRecordUserScope(_common);
    }

    public boolean callOnViewFormActivated(Common _common)
    {
        SysDictTable dictTable;
        RefTableId tableId;
        RefRecId recId;
        boolean hasOnViewFormActivated;
        IdentifierName methodName;
        DictTable dt;
        ;

        methodName = 'onViewFormActivated';

        if(_common)
        {
            tableId = _common.TableId;
            recId = _common.RecId;
            dictTable = new SysDictTable(tableId);
            hasOnViewFormActivated = SysDictTable::hasMethod(dictTable, methodName);

            if(hasOnViewFormActivated)
            {
                dictTable.callObject(methodName, _common);
            }
        }

        return hasOnViewFormActivated;
    }

    public boolean isEditableForUser(Common _common, DSSUserId _userId)
    {
        boolean ret;

        this.setRecordUserScope(_common, _userId);

        ret = this.isEditable(_common);

        this.removeRecordUserScope(_common);

        return ret;
    }

    private boolean isEditable(Common _common)
    {
        boolean ret;
        SysDictTable dictTable;
        RefTableId tableId;
        RefRecId recId;
        boolean hasMethod;
        IdentifierName methodName;
        DictTable dt;
        ;

        methodName = 'isEditable';

        if(_common.TableId)
        {
            tableId = _common.TableId;
            recId = _common.RecId;
            dictTable = new SysDictTable(tableId);
            hasMethod = SysDictTable::hasMethod(dictTable, methodName);

            if(hasMethod)
            {
                ret = dictTable.callObject(methodName, _common);
            }
        }

        return ret;
    }

    public RefRecId getRecId(Common _common)
    {
        RefRecId ret;
        SysDictTable dictTable;
        boolean hasMethod;
        RefTableId tableId;
        IdentifierName methodName;
        ;

        methodName = 'getRecId';

        if(_common)
        {
            tableId = _common.TableId;
            dictTable = new SysDictTable(tableId);
            hasMethod = SysDictTable::hasMethod(dictTable, methodName);

            if(hasMethod)
            {
                ret = dictTable.callObject(methodName, _common);
            }
        }

        if(!ret)
            ret = _common.RecId;

        return ret;
    }

    public DSSRefTableId getTableId(Common _common)
    {
        DSSRefTableId ret;
        SysDictTable dictTable;
        boolean hasMethod;
        RefTableId tableId;
        IdentifierName methodName;
        ;

        methodName = 'getTableId';

        if(_common)
        {
            tableId = _common.TableId;
            dictTable = new SysDictTable(tableId);
            hasMethod = SysDictTable::hasMethod(dictTable, methodName);

            if(hasMethod)
            {
                ret = dictTable.callObject(methodName, _common);
            }
        }

        if(!ret)
            ret = tableId;

        return ret;
    }

    List getFieldGroupFieldList(TableId _tableId, str _fieldGroupName)
    {
        List fieldList;
        TableId tableId;
        FieldId fieldId;
        str fieldGroupName;
        DictTable dictTable;
        DictFieldGroup fieldGroup;
        ;

        fieldList = new List(Types::Integer);
        tableId = _tableId;
        fieldGroupName = _fieldGroupName;

        dictTable = new SysDictTable(tableId);
        fieldGroup = new DictFieldGroup(tableId, fieldGroupName);

        for (int i = 1; i <= fieldGroup.numberOfFields(); i++)
        {
            if (fieldGroup && fieldGroup.numberOfFields())
            {
                fieldId = fieldGroup.field(i);
                if(fieldId)
                {
                    fieldList.addEnd(fieldId);
                }
            }
        }

        return fieldList;
    }

    List getTableFieldGroupLookupFieldContractList(TableId _tableId, str _fieldGroupName)
    {
        List selectionList;
        TableId tableId;
        FieldId fieldId;
        str fieldGroupName;
        DictTable dictTable;
        DictFieldGroup fieldGroup;
        DSSLookupFieldContract fieldContract;
        ;

        selectionList = new List(Types::Class);
        tableId = _tableId;
        fieldGroupName = _fieldGroupName;

        dictTable = new SysDictTable(tableId);
        fieldGroup = new DictFieldGroup(tableId, fieldGroupName);

        for (int i = 1; i <= fieldGroup.numberOfFields(); i++)
        {
            fieldContract = new DSSLookupFieldContract();
            DictField dictField = dictTable.fieldObject(fieldGroup.field(i));
            
            if (fieldGroup.methodName(fieldGroup.field(i)))
            {
                MethodName methodName = fieldGroup.methodName(fieldGroup.field(i));
                
                fieldContract.parmFieldId(0);
                fieldContract.parmLabel(methodName);
                fieldContract.parmMethodName(methodName);
                fieldContract.parmReferenceType(DSSReferenceType::Method);
            }
            else if (dictField)
            {
                fieldId = fieldGroup.field(i);

                fieldContract.parmFieldId(fieldId);
                fieldContract.parmLabel(dictField.label());
                fieldContract.parmMethodName('');
                fieldContract.parmReferenceType(DSSReferenceType::Field);
            }

            selectionList.addEnd(fieldContract);
        }

        return selectionList;
    }

    internal str encrypt(str _txtToEncrypt)
    {
        return AdBaseCryptography_Rijndael::construct().encrypt(_txtToEncrypt);
    }

    internal str decrypt(str _encryptedString)
    {        
        return AdBaseCryptography_Rijndael::construct().decrypt(_encryptedString);
    }

    public void refreshCaller(FormRun _fRun)
    {
        FormRun callerForm;
        ;

        callerForm = _fRun.args().caller();

        if(callerForm)
        {
            this.refreshForm(callerForm);
        }
    }

    public void refreshForm(FormRun _fRun)
    {
        FormDataSource fds;
        ;

        fds = _fRun.dataSource();

        this.refreshDataSource(fds);
    }

    public str generateRandomString(int _stringLength = 8)
    {
        int i;
        str randomString;
        RandomGenerate random = new RandomGenerate();

        for (i=1; i<= _stringLength; i++)
        {
            if (i mod 3)
            randomString += num2char(random.randomInt(char2num('a', 1), char2num('z', 1)));
            else
            randomString += num2char(random.randomInt(char2num('0', 1), char2num('9', 1)));
        }

        return randomString;
    }

    public boolean validatePassword(DSSPassword _password)
    {
        int MIN_LENGTH = 8;
        int MAX_LENGTH = 100;
        int passwordLength;
        DSSPassword password;
        boolean result;
        ;
        
        password = _password;
        passwordLength = strLen(password);
        result = (passwordLength >= MIN_LENGTH) ? true : false;

        this.throwError(!result, strFmt("@DSSLabel:DSS000075", MIN_LENGTH));

        result = (passwordLength <= MAX_LENGTH) ? true : false;
        
        this.throwError(!result, strFmt("@DSSLabel:DSS000076", MAX_LENGTH));
        
        return result;
    }

    public void showWarning(boolean _show, str _warning)
    {
        if(_show)
            warning(_warning);
    }

    public void showError(boolean _show, str _error)
    {
        if(_show)
            error(_error);
    }

    public void throwError(boolean _throw, str _error)
    {
        if(_throw)
            throw error(_error);
    }

    public str getRecordTitleFields(Common _record)
    {
        str title1;
        str title2;
        str recordTitle;
        ;

        title1 = this.getRecordTitleField(_record);
        title2 = this.getRecordTitleField(_record, false);
        title2 = (title1 && title2) ? strFmt(' - %1', title2) : title2;
        recordTitle = strFmt('%1%2', title1, title2);
        return recordTitle;
    }

    public str getRecordTitleField(Common _record, boolean _getFirst = true)
    {
        DictTable dictTable;
        Common record;
        TableId tableId;
        FieldId titleFieldId;
        str titleFieldValue;
        ;

        record = _record;
        tableId = record.TableId;

        if(record && tableId)
        {
            dictTable = new SysDictTable(tableId);
            titleFieldId = (_getFirst) ? dictTable.titleField1() : dictTable.titleField2();
            titleFieldValue = (titleFieldId) ? record.(titleFieldId) : '';
        }

        return titleFieldValue;
        
    }

    public DSSUserId getEmployeeUserId(DSSEmployeeId _employeeId)
    {
        HcmWorker worker;
        DirPersonUser personUser;
        UserId  userId;
        HcmPersonnelNumberId personnelNumberId;
        ;

        personnelNumberId = _employeeId;

        // Verify selected worker has user attached
        if(personnelNumberId)
        {
            select firstonly1 User
                from personUser
                join worker
                where personUser.PersonParty == worker.Person
                && worker.PersonnelNumber == personnelNumberId;

            userId = personUser.User;
        }

        return userId;
    }

    public int getRandomIntColor()
    {
        int MAX_COLOR = 16777216;
        int MID_COLOR = MAX_COLOR / 2;
        int START_FROM = 100;

        return RandomGenerate::construct().randomInt(START_FROM, MID_COLOR);
    }

    public int hex2ColorInt(str _hex)
    {
        int colorInt;
        int rValue, gValue, bValue;

        if(match('[A-F0-9]',_hex))
        {
            rValue  = hex2Int(subStr(_hex, 0, 2));
            gValue  = hex2Int(subStr(_hex, 3, 2));
            bValue  = hex2Int(subStr(_hex, 5, 2));
            colorInt= WinAPI::RGB2int(rValue, gValue, bValue);
        }

        return colorInt;
    }

    private str intColor2Hex(int _color)
    {
        container colorcon;
        str colorhex;
        ;
        colorcon=WinApi::RGBint2Con(_color);
        colorhex=Global::int2Hex(conpeek(colorcon,1),2);
        colorhex+=Global::int2Hex(conpeek(colorcon,2),2);
        colorhex+=Global::int2Hex(conpeek(colorcon,3),2);
        
        return colorhex;
    }

    public str getRamdomColorHex()
    {
        return this.intColor2Hex(this.getRandomIntColor());
    }

    public System.IO.MemoryStream getStreamFromContainer(container _c)
    {
        System.IO.MemoryStream stream = Binary::constructFromContainer(_c).getMemoryStream();
        return stream;
    }

    public container getContainerFromStream(System.IO.MemoryStream _memoryStream)
    {
        return Binary::constructFromMemoryStream(_memoryStream).getContainer();
    }

    public List map2List(Map map)
    {
        List list;

        if(map)
        {
            MapEnumerator enumerator = map.getEnumerator();
            list = new List(map.valueType());
            while(enumerator.moveNext())
            {
                list.addEnd(enumerator.currentValue());
            }
        }
        return list;
    }

    public str dateToStringWithFormat(date _date, str _format)
    {
        new InteropPermission(InteropKind::ClrInterop).assert();
        
        System.DateTime dateTime = _date;
        return dateTime.ToString(_format);
    }

    public str dateToStringForLocale(date _date, str _locale)
    {
        new InteropPermission(InteropKind::ClrInterop).assert();
        
        System.DateTime dateTime = _date;
        return dateTime.ToString('d', this.getDateTimeFormatInfoFromLocale(_locale));
    }

    public str dateTimeToStringForLocaleAndTimeZone(utcdatetime _dateTime, str _locale, Timezone _timeZone)
    {
        new InteropPermission(InteropKind::ClrInterop).assert();
        
        System.DateTime dateTime = DateTimeUtil::applyTimeZoneOffset(_dateTime,_timeZone);
        return dateTime.ToString('g', this.getDateTimeFormatInfoFromLocale(_locale));
    }

    public str dateTimeToUTCDateTimeString(utcdatetime _dateTime, Timezone _timeZone)
    {
        new InteropPermission(InteropKind::ClrInterop).assert();
        
        System.DateTime dateTime = DateTimeUtil::applyTimeZoneOffset(_dateTime,_timeZone);
        return dateTime.ToString('u');
    }

    public str timeToString(int _time)
    {
        str timeString;
        ;
       
        timeString = time2StrHMLeadingZero(_time);

        return timeString;
    }

    public TempStr time2StrAMPM(int timE)
    {
        str hourStr;
        str minuteStr;
        str amPmStr;

        int hour = timE / 3600;
        int minute = (timE mod 3600) / 60;

        if (hour >= 12)
        {
            amPmStr = "PM";
            if (hour > 12)
            {
                hour -= 12;
            }
        }
        else
        {
            amPmStr = "AM";
            if (hour == 0)
            {
                hour = 12;
            }
        }

        hourStr = num2str(hour, 2, 0, 0, 0);
        hourStr = strReplace(hourStr, ' ', '0');
        minuteStr = num2Str0(minute, 2, 0, 0, 0);

        return hourStr + ':' + minuteStr + ' ' + amPmStr;
    }

    public date stringToDateWithFormat(str _dateStr, str _format)
    {
        new InteropPermission(InteropKind::ClrInterop).assert();

        const DateTimeStyles dateTimeStyles =
            DateTimeStyles::NoCurrentDateDefault
            | DateTimeStyles::AllowLeadingWhite
            | DateTimeStyles::AllowTrailingWhite;

        System.DateTime dateTime;
        boolean valid = System.DateTime::TryParse(_dateStr, byref dateTime);
        
        if (valid)
        {
            dateTime = dateTime.get_Date();
        }
        else
        {
            System.DateTime minDate = System.DateTime::MinValue;
            dateTime = minDate.get_Date();
        }

        return dateTime;
    }

    public date stringToDateForLocale(str _dateStr, str _locale)
    {
        new InteropPermission(InteropKind::ClrInterop).assert();

        const DateTimeStyles dateTimeStyles =
            DateTimeStyles::NoCurrentDateDefault
            | DateTimeStyles::AllowLeadingWhite
            | DateTimeStyles::AllowTrailingWhite;

        System.DateTime dateTime;
        boolean valid = System.DateTime::TryParse(
                            _dateStr,
                            this.getDateTimeFormatInfoFromLocale(_locale),
                            dateTimeStyles,
                            byref dateTime);
        
        if (valid)
        {
            dateTime = dateTime.get_Date();
        }
        else
        {
            System.DateTime minDate = System.DateTime::MinValue;
            dateTime = minDate.get_Date();
        }

        return dateTime;
    }

    public DSSShortDatePattern getDatePattern(str _locale)
    {
        DSSShortDatePattern shortDatePattern;

        shortDatePattern = this.cultureInfo(_locale).get_DateTimeFormat().ShortDatePattern.ToString();

        return shortDatePattern;
    }

    public DateTimeFormatInfo getDateTimeFormatInfoFromLocale(str _locale)
    {
        return this.cultureInfo(_locale).get_DateTimeFormat();
    }

    public CultureInfo cultureInfo(str _locale)
    {
        str locale = _locale;

        new InteropPermission(InteropKind::ClrInterop).assert();
        // We need to use a two parameter version because the wrong overload is chosen
        // when only one parameter is supplied
        return CultureInfo::GetCultureInfo(locale, locale);
    }

    public str getRecIdValue(TableId _tableId, FieldId _fieldId, RefRecId _refRecId)
    {
        DictTable       dictTable;
        DictRelation    dictRelation;
        DictIndex       dictIndex;
        TableId         relTable;
        FieldId         relField;
        Common          common;
        str             ret;
    
        dictRelation = new DictRelation(_tableId);
        dictRelation.loadFieldRelation(_fieldId);
        relTable = dictRelation.externTable();
    
        dictTable = new DictTable(relTable);
    
        common = dictTable.makeRecord();
        select common where common.recId == _refRecId;
    
        dictIndex = new dictIndex(relTable, dictTable.replacementKey());
        relField = dictIndex.field(1); //Replacement key should only have 1 value
        //dictIndex.numberOfFields
        ret = common.(relField);
    
        return ret;
    }

    public MethodName getTableDisplayMethodName(TableId _tableId)
    {
        #ResAppl
        FormRun         formRun;
        container       tableMethods;
        SysDictTable    dt = new SysDictTable(_tableId);
        list            methodList;
        listEnumerator  methodListEnumerator;
        ;
    
        formRun = classFactory.createPicklist();
        formRun.init();
    
        methodList = dt.getListOfDisplayMethods();
    
        methodListEnumerator = methodList.getEnumerator();
        while (methodListEnumerator.moveNext())
        {
            tableMethods += methodListEnumerator.current();
        }
    
        formRun.choices(tableMethods, #ImageClass);
        formRun.caption("@ENG5005");
        formRun.run();
        formRun.wait();
        if (formRun.choice())
        {
            return formRun.choice();
        }
        else
        {
            return '';
        }
    }

    public str decodeJWT(str _token)
    {
        //System.IdentityModel.Tokens.jwt
        //var handler = new JwtSecurityTokenHandler();
        //var decodedValue = handler.ReadJwtToken(_token);

        return '';
    }

    public void lookupFormForContainer(FormStringControl _ctrl, container _container, str _caption)
    {
        #ResAppl
        FormRun  formRun;
        formRun = classFactory.createSysLookupPicklist();
        formRun.init();

        formRun.choices(_container, #ImageTable);
        formRun.caption(_caption);
        _ctrl.performFormLookup(formRun);
    }

    public container getTableRelations(RefTableId _refTableId)
    {
        container tableRelations;
        SysDictTable sdt = new SysDictTable(_refTableId);
        SysDictRelation sdr = new SysDictRelation(_refTableId);
                
        
        for (int i = 1; i <= sdt.relationCnt(); i++)
        {
            tableRelations += sdt.relation(i);          
        }

        return tableRelations;
    }

    public void tableFieldsLookup(FormStringControl _formStringControl, RefTableId _refTableId)
    {
        Query q;
        QueryBuildDataSource qbds;

        q = new Query();
        qbds = q.addDataSource(tableNum(SqlDictionary));
        qbds.addRange(fieldNum(SqlDictionary, fieldId)).value(SysQuery::valueNot(0));
        qbds.addRange(fieldNum(SqlDictionary, array)).value(SysQuery::valueNot(0));
        qbds.addRange(fieldNum(SqlDictionary, tabId)).value(queryValue(_refTableId));
        SysTableLookup tablelookup = SysTableLookup::newParameters(tableNum(SqlDictionary), _formStringControl, true);

        tablelookup.addLookupfield(fieldNum(SqlDictionary, name));
        tablelookup.addLookupfield(fieldNum(SqlDictionary, sqlName));
        tablelookup.parmQuery(q);
        tablelookup.performFormLookup();
    }

    public  System.Byte[] getBytesFromContainer(container c)
    {
        System.Byte[] byteArray = null;

        System.IO.MemoryStream publicKeyStream = new System.IO.MemoryStream();

        Binary binary = Binary::constructFromContainer(c);
        using (System.IO.MemoryStream stream = binary.getMemoryStream())
        {
            byteArray = stream.ToArray();
            return byteArray;
        }
    }

    public Query getEmployeeReportToMeQuery(DSSEmployeeId _employeeId)
    {
        Query query = new Query();
        QueryBuildDataSource    qbdsWorker,qbdsPositionWorkerAssignemnt, qbdsPositionDetail,qbdsPosition,qbdsPostion,qbdsPositionHirarchy,qbdsPositionHierarchyType;
        HcmWorkerLookup         workerLookup = HcmWorkerLookup::newActiveWorkers();
        HRMParameters   hrmParameters = HRMParameters::find();
        HcmPositionHierarchySystemType positionHierarchyType = hrmParameters.PositionHierarchyType;
        HcmPositionHierarchyName positionHierarchyName = hrmParameters.PositionHierarchyName;
        ;

        workerLookup.parmIncludeTerminated(false);
        query = new Query(workerLookup.updateQuery());

        HcmPositionRecId  CurrentEmployeePositionRecId;

        CurrentEmployeePositionRecId = HcmPosition::findByPosition(HcmWorker::findByPersonnelNumber(_employeeId).primaryPositionId()).RecId;
         
        //qbdsWorker = q.addDataSource(tableNum(HcmWorker));
        // qbdsPositionWorkerAssignemnt = qbdsWorker.addDataSource(tableNum(HcmPositionWorkerAssignment));
  
        qbdsPositionWorkerAssignemnt = query.dataSourceTable(tableNum(HcmWorker)).addDataSource(tableNum(HcmPositionWorkerAssignment));
        
        qbdsPositionWorkerAssignemnt.relations(false);
        qbdsPositionWorkerAssignemnt.joinMode(JoinMode::ExistsJoin);
        qbdsPositionWorkerAssignemnt.addLink(fieldNum(HcmWorker,Recid),fieldNum(HcmPositionWorkerAssignment,Worker));
    
     
        qbdsPositionDetail = qbdsPositionWorkerAssignemnt.addDataSource(tableNum(HcmPositionDetail));
        qbdsPositionDetail.relations(false);
        qbdsPositionDetail.joinMode(JoinMode::ExistsJoin);
        qbdsPositionDetail.addLink(fieldNum(HcmPositionWorkerAssignment,Position),fieldNum(HcmPositionDetail,Position));

        qbdsPosition = qbdsPositionDetail.addDataSource(tableNum(HCMPosition));
        qbdsPosition.relations(false);
        qbdsPosition.joinMode(JoinMode::ExistsJoin);
        qbdsPosition.addLink(fieldNum(HcmPositionDetail,Position),fieldNum(HCMPosition,RecId));

        qbdsPositionHirarchy = qbdsPosition.addDataSource(tableNum(HcmPositionHierarchy));
        qbdsPositionHirarchy.relations(false);
        qbdsPositionHirarchy.joinMode(JoinMode::ExistsJoin);
        qbdsPositionHirarchy.addLink(fieldNum(HcmPosition,RecId),fieldNum(HcmPositionHierarchy,Position));
        //qbdsPositionHirarchy.addRange(fieldNum(HcmPositionHierarchy,parentposition)).value(queryValue(CurrentEmployeePositionRecId));

        qbdsPositionHierarchyType = qbdsPositionHirarchy.addDataSource(tablenum (HcmPositionHierarchyType));
        qbdsPositionHierarchyType.relations(false);
        qbdsPositionHierarchyType.joinMode(JoinMode::ExistsJoin);
        qbdsPositionHierarchyType.addLink(fieldNum(HcmPositionHierarchy,PositionHierarchyType),fieldnum(HcmPositionHierarchyType,RecId));
        //qbdsPositionHierarchyType.addRange(fieldNum(HcmPositionHierarchyType,HierarchyType)).value(queryValue(HcmPositionHierarchySystemType::Line));

        // <10-28-2020 Abdul Ghani //Reason On Behalf of Requirment>
        //SysQuery::findOrCreateRange(qbdsPositionHierarchyType,fieldNum(HcmPositionHierarchyType,HierarchyType)).value(strFmt("%1",HcmPositionHierarchySystemType::Line));

        SysQuery::findOrCreateRange(qbdsPositionHierarchyType,fieldNum(HcmPositionHierarchyType,HierarchyType)).value(queryValue(positionHierarchyType));

        if(positionHierarchyName && positionHierarchyType == HcmPositionHierarchySystemType::Other)
            SysQuery::findOrCreateRange(qbdsPositionHierarchyType,fieldNum(HcmPositionHierarchyType, Name)).value(queryValue(positionHierarchyName));

        SysQuery::findOrCreateRange(qbdsPositionHirarchy,fieldNum(HcmPositionHierarchy,parentposition)).value(strfmt('((parentposition = %1))',CurrentEmployeePositionRecId)); // current employee position
  
        return query;
    }

    public void createEmailNotification(DSSEmployeeId _employeeId, DSSTitle _subject, DSSBody _body)
    {
        Email email = HcmWorker::findByPersonnelNumber(_employeeId).email();
        SysEmailSystemTable table = SysEmailSystemTable::find(DSSParameters::find().WorkflowEmailId);
        if(email && _subject && _body && table)
        {
            SysEmailBatch batch = SysEmailBatch::construct();

            batch.parmEmailAddr(email);
            batch.parmMessageBody(_body);
            batch.parmSenderAddr(table.SenderAddr);
            batch.parmSendername(table.SenderName);
            batch.parmSubject(_subject);
            batch.parmPriority(table.Priority);

            if (table.BatchGroupId)
                    batch.sendToBatch(table.BatchGroupId);
            else
                    batch.runOperation();
        }
    }

}