Wednesday, April 12, 2017

AX 2012: Reading files from directory through X++

Following code can be used to read files from the specified path. With this example, I am reading a CSV files from a directory.

Class declaration

class readFilesFromDirectory extends RunBase

{
    FilePath            filePath;
    Filename            filename;
    CommaTextIo         fileIO;
    Set                 fileSet;
    CommaIo             commaIo;
    str                 currentFile;
    container           lineCon;
    #File
    #AviFiles
}

main method

Public static void main(Args _args)

{
    readFilesFromDirectory  readFiles = readFilesFromDirectory::construct();
    readFiles.readFilesFromDirtecory();
}

Construct


Public static readFilesFromDirectory construct()

{
    return new readFilesFromDirectory();
}

readFileFromDirectory method


private void readFilesFromDirtecory()

{
    SetEnumerator           sE;
    int                     row = 1;
    filePath = @"C:\Temp\FilesToRead";
    this.getFiles();
    sE = fileSet.getEnumerator();
    while (sE.moveNext()) // loop through all files
    {
        filename = sE.current();
        this.openFile();
        while(this.readLine()) // loop through all lines from current file
        {
            this.processRow(row, lineCon);
            row++;
        }
    }
}

getFiles method


private void getFiles()
{
    System.String[]                 files;
    System.Collections.IEnumerator  enumerator;
    str file;
    try
    {
        fileSet = new Set(Types::Container);
        files = System.IO.Directory::GetFiles(filePath, '*.csv');
        enumerator = files.GetEnumerator();
        while (enumerator.MoveNext())
        {
            file = enumerator.get_Current();
            fileSet.add([file]);
        }
    }
    catch (Exception::Internal)
    {
        this.processCLRErrorException();
    }
    catch (Exception::CLRError)
    {
        this.processCLRErrorException();
    }
}

openFile method


private void openFile()

{
    FileIOPermission fileIOPermission;
    fileIOPermission = new FileIOPermission(filename, #io_read);
    fileIOPermission.assert();
    commaIo = new CommaIo(filename, #io_read);
    if (commaIo && commaIo.status() == IO_Status::Ok)
    {
        commaIo.inRecordDelimiter(#delimiterCRLF);
    }
    else
    {
        throw error(strFmt("Error when opening file %1", filename));
    }
}

readLine method

private boolean readLine()

{
    boolean readLine;
    if (commaIo && commaIo.status() == IO_Status::Ok)
    {
        lineCon = commaIo.read();
        readLine = lineCon != conNull();
    }
    else
    {
        lineCon = conNull();
        readLine = false;
    }
    return readLine;
}

processRow method

private void processRow(int _rowIdx, container  _row)

{
    //conpeek(_row, 1);
    //conpeek(_row, 2);
    //conpeek(_row, 3);
    //conpeek(_row, 4);
    //conpeek(_row, 5);
    //conpeek(_row, 6);
    //conpeek(_row, 7);
    //conpeek(_row, 8);
    //conpeek(_row, 9);
    //conpeek(_row, 10);
}

processCLRErrorException method
private void processCLRErrorException(
    boolean _throw = true
    )
{
    str strError;
    CLRObject exc;
    CLRObject innerExc;
    CLRObject clrExcMessage;
    exc = CLRInterop::getLastException();
    if (exc)
    {
        clrExcMessage = exc.get_Message();
        innerExc = exc.get_InnerException();
        while (innerExc != null)
        {
            clrExcMessage = innerExc.get_Message();
            innerExc = innerExc.get_InnerException();
        }
        strError = CLRInterop::getAnyTypeForObject(clrExcMessage);
        error(strError);
        if (_throw)
        {
            throw error("Update has been cancelled");
        }
    }
}