Additional parameters in RunBaseBatch class extension

 Old good pack/unpack patterns with SysPackExtension call. Say, we need to augment RunBaseBatch based class <ClassName>.

/// <summary>
/// We are going to use a new additional parameter

/// </summary>
[ExtensionOf(classStr(<ClassName>))]
public final class My<ClassName>_Extension

{
    private boolean     myNewParm;   

    #define.CurrentVersion(1)
    #localmacro.CurrentList
        myNewParm
    #endmacro

    
    /// <summary>
    /// myNewParm access
    /// </summary>
    /// <param name = "_parm">boolean</param>
    /// <returns>boolean</returns>
    public boolean parmMyNewParm(boolean _parm = myNewParm)
    {
        myNewParm= _parm;
        return myNewParm;
    }

    /// <summary>
    /// Extends Pack
    /// </summary>
    /// <returns>container</returns>
    public container pack()
    {
        container packedClass = next pack();
        return SysPackExtensions::appendExtension(packedClass, classStr(My<ClassName>_Extension), this.myPack());
    }

    /// <summary>
    /// Extends Unpack
    /// </summary>
    /// <param name = "packedClass">container</param>
    /// <returns>boolean</returns>
    private boolean myUnpack(container packedClass)
    {
        Integer version = RunBase::getVersion(packedClass);
        switch (version)
        {
            case #CurrentVersion:
                [version, #currentList] = packedClass;
                break;
            default:
                return false;
        }
        return true;
    }

    /// <summary>
    /// Packs my locals
    /// </summary>
    /// <returns>container</returns>
    private container myPack()
    {
        return [#CurrentVersion, #CurrentList];
    }

    /// <summary>
    /// Extends unpack
    /// </summary>
    /// <param name = "_packedClass">container</param>
    /// <returns>boolean</returns>
    public boolean unpack(container _packedClass)
    {
        boolean result = next unpack(_packedClass);

        if (result)
        {
            container myState = SysPackExtensions::findExtension(_packedClass, classStr(My<ClassName>_Extension));
            //Also unpack the extension
            if (!this.myUnpack(myState))
            {
                result = false;
            }
        }

        return result;
    }

}

Overload a method for a new button in Form extension

 This can be used as a copy-paste pattern, when you need to change a standard method for new form controls added as a form extensions.

At the form initialization step we can overload any form control methods with registerOverrideMethod.

[ExtensionOf(formStr(<FormName>))]
public final class my<FormName>_MyNewButton_Extension
{
   public void init()
    {
        next init();
		// MyNewButton button added in an extension to <FormName>
        FormButtonControl myButton = this.design().controlName(formControlStr(<FormName>, myNewButton));
		// Here we can overload its standard clicked() method in run-time		
        myButton.registerOverrideMethod(methodStr(FormButtonControl, clicked), formMethodStr(<FormName>, myNewButtonClicked), this);
    }

    public void myNewButtonClicked(FormButtonControl _sender)
    {
		<run some logic>
        _sender.clicked();
    }
}

Check this article for more complicated scenario https://alexvoy.blogspot.com/2018/09/lookup-and-modified-methods-for.html

How to validate filename with regular expressions

 I took the idea from this forum https://stackoverflow.com/questions/62771/how-do-i-check-if-a-given-string-is-a-legal-valid-file-name-under-windows

We can use regular expressions to check if a given file name is valid.

    /// <summary>
    /// Validates a filename for incorrect characters
    /// </summary>
    /// <param name = "_fileName"></param>
    /// <returns></returns>
    public boolean checkFileName(Filename _fileName)
    {
        var bad = System.IO.Path::GetInvalidFileNameChars();
        var esc = System.Text.RegularExpressions.Regex::Escape(new System.String(bad));
        var exp = new System.Text.RegularExpressions.Regex("[" + esc + "]");
        
        if (exp.IsMatch(_fileName))
        {
            return checkFailed(strFmt("@SYS339524")); // The specified filename is invalid.
        }
        return true;
    }