org.pentaho.di.job.entries.dostounix.JobEntryDosToUnix.java Source code

Java tutorial

Introduction

Here is the source code for org.pentaho.di.job.entries.dostounix.JobEntryDosToUnix.java

Source

/*! ******************************************************************************
 *
 * Pentaho Data Integration
 *
 * Copyright (C) 2002-2013 by Pentaho : http://www.pentaho.com
 *
 *******************************************************************************
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with
 * the License. You may obtain a copy of the License at
 *
 *    http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 *
 ******************************************************************************/

package org.pentaho.di.job.entries.dostounix;

import java.io.File;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;
import java.util.List;
import java.util.regex.Matcher;
import java.util.regex.Pattern;

import org.apache.commons.vfs.AllFileSelector;
import org.apache.commons.vfs.FileObject;
import org.apache.commons.vfs.FileSelectInfo;
import org.apache.commons.vfs.FileType;
import org.pentaho.di.cluster.SlaveServer;
import org.pentaho.di.core.Const;
import org.pentaho.di.core.Result;
import org.pentaho.di.core.ResultFile;
import org.pentaho.di.core.RowMetaAndData;
import org.pentaho.di.core.database.DatabaseMeta;
import org.pentaho.di.core.exception.KettleDatabaseException;
import org.pentaho.di.core.exception.KettleException;
import org.pentaho.di.core.exception.KettleXMLException;
import org.pentaho.di.core.vfs.KettleVFS;
import org.pentaho.di.core.xml.XMLHandler;
import org.pentaho.di.i18n.BaseMessages;
import org.pentaho.di.job.Job;
import org.pentaho.di.job.entry.JobEntryBase;
import org.pentaho.di.job.entry.JobEntryInterface;
import org.pentaho.di.repository.ObjectId;
import org.pentaho.di.repository.Repository;
import org.pentaho.metastore.api.IMetaStore;
import org.w3c.dom.Node;

/**
 * This defines a 'Dos to Unix' job entry.
 *
 * @author Samatar Hassan
 * @since 26-03-2008
 */

public class JobEntryDosToUnix extends JobEntryBase implements Cloneable, JobEntryInterface {
    private static final int LF = 0x0a;
    private static final int CR = 0x0d;

    private static Class<?> PKG = JobEntryDosToUnix.class; // for i18n purposes, needed by Translator2!!

    public static final String[] ConversionTypeDesc = new String[] {
            BaseMessages.getString(PKG, "JobEntryDosToUnix.ConversionType.Guess.Label"),
            BaseMessages.getString(PKG, "JobEntryDosToUnix.ConversionType.DosToUnix.Label"),
            BaseMessages.getString(PKG, "JobEntryDosToUnix.ConversionType.UnixToDos.Label") };
    public static final String[] ConversionTypeCode = new String[] { "guess", "dostounix", "unixtodos" };

    public static final int CONVERTION_TYPE_GUESS = 0;
    public static final int CONVERTION_TYPE_DOS_TO_UNIX = 1;
    public static final int CONVERTION_TYPE_UNIX_TO_DOS = 2;

    private static final int TYPE_DOS_FILE = 0;
    private static final int TYPE_UNIX_FILE = 1;
    private static final int TYPE_BINAY_FILE = 2;

    public static final String ADD_NOTHING = "nothing";
    public static final String SUCCESS_IF_AT_LEAST_X_FILES_PROCESSED = "success_when_at_least";
    public static final String SUCCESS_IF_ERROR_FILES_LESS = "success_if_error_files_less";
    public static final String SUCCESS_IF_NO_ERRORS = "success_if_no_errors";

    public static final String ADD_ALL_FILENAMES = "all_filenames";
    public static final String ADD_PROCESSED_FILES_ONLY = "only_processed_filenames";
    public static final String ADD_ERROR_FILES_ONLY = "only_error_filenames";

    public boolean arg_from_previous;
    public boolean include_subfolders;

    public String[] source_filefolder;
    public String[] wildcard;
    public int[] conversionTypes;

    private String nr_errors_less_than;
    private String success_condition;
    private String resultfilenames;

    int nrAllErrors = 0;
    int nrErrorFiles = 0;
    int nrProcessedFiles = 0;
    int limitFiles = 0;
    int nrErrors = 0;

    boolean successConditionBroken = false;
    boolean successConditionBrokenExit = false;

    private static String tempFolder;

    public JobEntryDosToUnix(String n) {
        super(n, "");
        resultfilenames = ADD_ALL_FILENAMES;
        arg_from_previous = false;
        source_filefolder = null;
        conversionTypes = null;
        wildcard = null;
        include_subfolders = false;
        nr_errors_less_than = "10";
        success_condition = SUCCESS_IF_NO_ERRORS;
    }

    public JobEntryDosToUnix() {
        this("");
    }

    public Object clone() {
        JobEntryDosToUnix je = (JobEntryDosToUnix) super.clone();
        return je;
    }

    public String getXML() {
        StringBuffer retval = new StringBuffer(300);

        retval.append(super.getXML());
        retval.append("      ").append(XMLHandler.addTagValue("arg_from_previous", arg_from_previous));
        retval.append("      ").append(XMLHandler.addTagValue("include_subfolders", include_subfolders));
        retval.append("      ").append(XMLHandler.addTagValue("nr_errors_less_than", nr_errors_less_than));
        retval.append("      ").append(XMLHandler.addTagValue("success_condition", success_condition));
        retval.append("      ").append(XMLHandler.addTagValue("resultfilenames", resultfilenames));
        retval.append("      <fields>").append(Const.CR);
        if (source_filefolder != null) {
            for (int i = 0; i < source_filefolder.length; i++) {
                retval.append("        <field>").append(Const.CR);
                retval.append("          ")
                        .append(XMLHandler.addTagValue("source_filefolder", source_filefolder[i]));
                retval.append("          ").append(XMLHandler.addTagValue("wildcard", wildcard[i]));
                retval.append("          ").append(
                        XMLHandler.addTagValue("ConversionType", getConversionTypeCode(conversionTypes[i])));
                retval.append("        </field>").append(Const.CR);
            }
        }
        retval.append("      </fields>").append(Const.CR);

        return retval.toString();
    }

    private static String getConversionTypeCode(int i) {
        if (i < 0 || i >= ConversionTypeCode.length) {
            return ConversionTypeCode[0];
        }
        return ConversionTypeCode[i];
    }

    public static String getConversionTypeDesc(int i) {
        if (i < 0 || i >= ConversionTypeDesc.length) {
            return ConversionTypeDesc[0];
        }
        return ConversionTypeDesc[i];
    }

    public static int getConversionTypeByDesc(String tt) {
        if (tt == null) {
            return 0;
        }

        for (int i = 0; i < ConversionTypeDesc.length; i++) {
            if (ConversionTypeDesc[i].equalsIgnoreCase(tt)) {
                return i;
            }
        }

        // If this fails, try to match using the code.
        return getConversionTypeByCode(tt);
    }

    private static int getConversionTypeByCode(String tt) {
        if (tt == null) {
            return 0;
        }

        for (int i = 0; i < ConversionTypeCode.length; i++) {
            if (ConversionTypeCode[i].equalsIgnoreCase(tt)) {
                return i;
            }
        }
        return 0;
    }

    public void loadXML(Node entrynode, List<DatabaseMeta> databases, List<SlaveServer> slaveServers,
            Repository rep, IMetaStore metaStore) throws KettleXMLException {
        try {
            super.loadXML(entrynode, databases, slaveServers);

            arg_from_previous = "Y".equalsIgnoreCase(XMLHandler.getTagValue(entrynode, "arg_from_previous"));
            include_subfolders = "Y".equalsIgnoreCase(XMLHandler.getTagValue(entrynode, "include_subfolders"));

            nr_errors_less_than = XMLHandler.getTagValue(entrynode, "nr_errors_less_than");
            success_condition = XMLHandler.getTagValue(entrynode, "success_condition");
            resultfilenames = XMLHandler.getTagValue(entrynode, "resultfilenames");

            Node fields = XMLHandler.getSubNode(entrynode, "fields");

            // How many field arguments?
            int nrFields = XMLHandler.countNodes(fields, "field");
            source_filefolder = new String[nrFields];
            wildcard = new String[nrFields];
            conversionTypes = new int[nrFields];

            // Read them all...
            for (int i = 0; i < nrFields; i++) {
                Node fnode = XMLHandler.getSubNodeByNr(fields, "field", i);

                source_filefolder[i] = XMLHandler.getTagValue(fnode, "source_filefolder");
                wildcard[i] = XMLHandler.getTagValue(fnode, "wildcard");
                conversionTypes[i] = getConversionTypeByCode(
                        Const.NVL(XMLHandler.getTagValue(fnode, "ConversionType"), ""));
            }
        } catch (KettleXMLException xe) {

            throw new KettleXMLException(BaseMessages.getString(PKG, "JobDosToUnix.Error.Exception.UnableLoadXML"),
                    xe);
        }
    }

    public void loadRep(Repository rep, IMetaStore metaStore, ObjectId id_jobentry, List<DatabaseMeta> databases,
            List<SlaveServer> slaveServers) throws KettleException {
        try {
            arg_from_previous = rep.getJobEntryAttributeBoolean(id_jobentry, "arg_from_previous");
            include_subfolders = rep.getJobEntryAttributeBoolean(id_jobentry, "include_subfolders");

            nr_errors_less_than = rep.getJobEntryAttributeString(id_jobentry, "nr_errors_less_than");
            success_condition = rep.getJobEntryAttributeString(id_jobentry, "success_condition");
            resultfilenames = rep.getJobEntryAttributeString(id_jobentry, "resultfilenames");

            // How many arguments?
            int argnr = rep.countNrJobEntryAttributes(id_jobentry, "source_filefolder");
            source_filefolder = new String[argnr];
            wildcard = new String[argnr];
            conversionTypes = new int[argnr];
            // Read them all...
            for (int a = 0; a < argnr; a++) {
                source_filefolder[a] = rep.getJobEntryAttributeString(id_jobentry, a, "source_filefolder");
                wildcard[a] = rep.getJobEntryAttributeString(id_jobentry, a, "wildcard");
                conversionTypes[a] = getConversionTypeByCode(
                        Const.NVL(rep.getJobEntryAttributeString(id_jobentry, "ConversionType"), ""));
            }
        } catch (KettleException dbe) {

            throw new KettleException(
                    BaseMessages.getString(PKG, "JobDosToUnix.Error.Exception.UnableLoadRep") + id_jobentry, dbe);
        }
    }

    public void saveRep(Repository rep, IMetaStore metaStore, ObjectId id_job) throws KettleException {
        try {
            rep.saveJobEntryAttribute(id_job, getObjectId(), "arg_from_previous", arg_from_previous);
            rep.saveJobEntryAttribute(id_job, getObjectId(), "include_subfolders", include_subfolders);
            rep.saveJobEntryAttribute(id_job, getObjectId(), "nr_errors_less_than", nr_errors_less_than);
            rep.saveJobEntryAttribute(id_job, getObjectId(), "success_condition", success_condition);
            rep.saveJobEntryAttribute(id_job, getObjectId(), "resultfilenames", resultfilenames);

            // save the arguments...
            if (source_filefolder != null) {
                for (int i = 0; i < source_filefolder.length; i++) {
                    rep.saveJobEntryAttribute(id_job, getObjectId(), i, "source_filefolder", source_filefolder[i]);
                    rep.saveJobEntryAttribute(id_job, getObjectId(), i, "wildcard", wildcard[i]);
                    rep.saveJobEntryAttribute(id_job, getObjectId(), "ConversionType",
                            getConversionTypeCode(conversionTypes[i]));
                }
            }
        } catch (KettleDatabaseException dbe) {

            throw new KettleException(
                    BaseMessages.getString(PKG, "JobDosToUnix.Error.Exception.UnableSaveRep") + id_job, dbe);
        }
    }

    public Result execute(Result previousResult, int nr) throws KettleException {
        Result result = previousResult;
        result.setNrErrors(1);
        result.setResult(false);

        List<RowMetaAndData> rows = previousResult.getRows();
        RowMetaAndData resultRow = null;

        nrErrors = 0;
        nrProcessedFiles = 0;
        nrErrorFiles = 0;
        limitFiles = Const.toInt(environmentSubstitute(getNrErrorsLessThan()), 10);
        successConditionBroken = false;
        successConditionBrokenExit = false;
        tempFolder = environmentSubstitute("%%java.io.tmpdir%%");

        // Get source and destination files, also wildcard
        String[] vsourcefilefolder = source_filefolder;
        String[] vwildcard = wildcard;

        if (arg_from_previous) {
            if (isDetailed()) {
                logDetailed(BaseMessages.getString(PKG, "JobDosToUnix.Log.ArgFromPrevious.Found",
                        (rows != null ? rows.size() : 0) + ""));
            }

        }
        if (arg_from_previous && rows != null) // Copy the input row to the (command line) arguments
        {
            for (int iteration = 0; iteration < rows.size() && !parentJob.isStopped(); iteration++) {
                if (successConditionBroken) {
                    if (!successConditionBrokenExit) {
                        logError(BaseMessages.getString(PKG, "JobDosToUnix.Error.SuccessConditionbroken",
                                "" + nrAllErrors));
                        successConditionBrokenExit = true;
                    }
                    result.setEntryNr(nrAllErrors);
                    result.setNrLinesRejected(nrErrorFiles);
                    result.setNrLinesWritten(nrProcessedFiles);
                    return result;
                }

                resultRow = rows.get(iteration);

                // Get source and destination file names, also wildcard
                String vsourcefilefolder_previous = resultRow.getString(0, null);
                String vwildcard_previous = resultRow.getString(1, null);
                int convertion_type = JobEntryDosToUnix.getConversionTypeByCode(resultRow.getString(2, null));

                if (isDetailed()) {
                    logDetailed(BaseMessages.getString(PKG, "JobDosToUnix.Log.ProcessingRow",
                            vsourcefilefolder_previous, vwildcard_previous));
                }

                processFileFolder(vsourcefilefolder_previous, vwildcard_previous, convertion_type, parentJob,
                        result);
            }
        } else if (vsourcefilefolder != null) {
            for (int i = 0; i < vsourcefilefolder.length && !parentJob.isStopped(); i++) {
                if (successConditionBroken) {
                    if (!successConditionBrokenExit) {
                        logError(BaseMessages.getString(PKG, "JobDosToUnix.Error.SuccessConditionbroken",
                                "" + nrAllErrors));
                        successConditionBrokenExit = true;
                    }
                    result.setEntryNr(nrAllErrors);
                    result.setNrLinesRejected(nrErrorFiles);
                    result.setNrLinesWritten(nrProcessedFiles);
                    return result;
                }

                if (isDetailed()) {
                    logDetailed(BaseMessages.getString(PKG, "JobDosToUnix.Log.ProcessingRow", vsourcefilefolder[i],
                            vwildcard[i]));
                }

                processFileFolder(vsourcefilefolder[i], vwildcard[i], conversionTypes[i], parentJob, result);

            }
        }

        // Success Condition
        result.setNrErrors(nrAllErrors);
        result.setNrLinesRejected(nrErrorFiles);
        result.setNrLinesWritten(nrProcessedFiles);
        if (getSuccessStatus()) {
            result.setNrErrors(0);
            result.setResult(true);
        }

        displayResults();

        return result;
    }

    private void displayResults() {
        if (isDetailed()) {
            logDetailed("=======================================");
            logDetailed(BaseMessages.getString(PKG, "JobDosToUnix.Log.Info.Errors", nrErrors));
            logDetailed(BaseMessages.getString(PKG, "JobDosToUnix.Log.Info.ErrorFiles", nrErrorFiles));
            logDetailed(BaseMessages.getString(PKG, "JobDosToUnix.Log.Info.FilesProcessed", nrProcessedFiles));
            logDetailed("=======================================");
        }
    }

    private boolean checkIfSuccessConditionBroken() {
        boolean retval = false;
        if ((nrAllErrors > 0 && getSuccessCondition().equals(SUCCESS_IF_NO_ERRORS))
                || (nrErrorFiles >= limitFiles && getSuccessCondition().equals(SUCCESS_IF_ERROR_FILES_LESS))) {
            retval = true;
        }
        return retval;
    }

    private boolean getSuccessStatus() {
        boolean retval = false;

        if ((nrAllErrors == 0 && getSuccessCondition().equals(SUCCESS_IF_NO_ERRORS))
                || (nrProcessedFiles >= limitFiles
                        && getSuccessCondition().equals(SUCCESS_IF_AT_LEAST_X_FILES_PROCESSED))
                || (nrErrorFiles < limitFiles && getSuccessCondition().equals(SUCCESS_IF_ERROR_FILES_LESS))) {
            retval = true;
        }

        return retval;
    }

    private void updateErrors() {
        nrErrors++;
        updateAllErrors();
        if (checkIfSuccessConditionBroken()) {
            // Success condition was broken
            successConditionBroken = true;
        }
    }

    private void updateAllErrors() {
        nrAllErrors = nrErrors + nrErrorFiles;
    }

    private static int getFileType(FileObject file) throws Exception {
        int aCount = 0; // occurences of LF
        int dCount = 0; // occurences of CR
        FileInputStream in = null;
        try {
            in = new FileInputStream(file.getName().getPathDecoded());
            while (in.available() > 0) {
                int b = in.read();
                if (b == CR) {
                    dCount++;
                    if (in.available() > 0) {
                        b = in.read();
                        if (b == LF) {
                            aCount++;
                        } else {
                            return TYPE_BINAY_FILE;
                        }
                    }
                } else if (b == LF) {
                    aCount++;
                }
            }
        } finally {
            in.close();
        }

        if (aCount == dCount) {
            return TYPE_DOS_FILE;
        } else {
            return TYPE_UNIX_FILE;
        }
    }

    private boolean convert(FileObject file, boolean toUnix) {
        boolean retval = false;
        // CR = CR
        // LF = LF
        try {
            String localfilename = KettleVFS.getFilename(file);
            File source = new File(localfilename);
            if (isDetailed()) {
                if (toUnix) {
                    logDetailed(BaseMessages.getString(PKG, "JobDosToUnix.Log.ConvertingFileToUnix",
                            source.getAbsolutePath()));
                } else {
                    logDetailed(BaseMessages.getString(PKG, "JobDosToUnix.Log.ConvertingFileToDos",
                            source.getAbsolutePath()));
                }
            }
            File tempFile = new File(tempFolder, source.getName() + ".tmp");

            if (isDebug()) {
                logDebug(BaseMessages.getString(PKG, "JobDosToUnix.Log.CreatingTempFile",
                        tempFile.getAbsolutePath()));
            }
            FileOutputStream out = new FileOutputStream(tempFile);
            FileInputStream in = new FileInputStream(localfilename);

            if (toUnix) {
                // Dos to Unix
                while (in.available() > 0) {
                    int b1 = in.read();
                    if (b1 == CR) {
                        int b2 = in.read();
                        if (b2 == LF) {
                            out.write(LF);
                        } else {
                            out.write(b1);
                            out.write(b2);
                        }
                    } else {
                        out.write(b1);
                    }
                }
            } else {
                // Unix to Dos
                while (in.available() > 0) {
                    int b1 = in.read();
                    if (b1 == LF) {
                        out.write(CR);
                        out.write(LF);
                    } else {
                        out.write(b1);
                    }
                }
            }

            in.close();
            out.close();

            if (isDebug()) {
                logDebug(BaseMessages.getString(PKG, "JobDosToUnix.Log.DeletingSourceFile", localfilename));
            }
            file.delete();
            if (isDebug()) {
                logDebug(BaseMessages.getString(PKG, "JobDosToUnix.Log.RenamingTempFile",
                        tempFile.getAbsolutePath(), source.getAbsolutePath()));
            }
            tempFile.renameTo(source);

            retval = true;

        } catch (Exception e) {
            logError(BaseMessages.getString(PKG, "JobDosToUnix.Log.ErrorConvertingFile", file.toString(),
                    e.getMessage()));
        }

        return retval;
    }

    private boolean processFileFolder(String sourcefilefoldername, String wildcard, int convertion, Job parentJob,
            Result result) {
        boolean entrystatus = false;
        FileObject sourcefilefolder = null;
        FileObject CurrentFile = null;

        // Get real source file and wilcard
        String realSourceFilefoldername = environmentSubstitute(sourcefilefoldername);
        if (Const.isEmpty(realSourceFilefoldername)) {
            logError(BaseMessages.getString(PKG, "JobDosToUnix.log.FileFolderEmpty", sourcefilefoldername));
            // Update Errors
            updateErrors();

            return entrystatus;
        }
        String realWildcard = environmentSubstitute(wildcard);

        try {
            sourcefilefolder = KettleVFS.getFileObject(realSourceFilefoldername);

            if (sourcefilefolder.exists()) {
                if (isDetailed()) {
                    logDetailed(BaseMessages.getString(PKG, "JobDosToUnix.Log.FileExists",
                            sourcefilefolder.toString()));
                }
                if (sourcefilefolder.getType() == FileType.FILE) {
                    entrystatus = convertOneFile(sourcefilefolder, convertion, result, parentJob);

                } else if (sourcefilefolder.getType() == FileType.FOLDER) {
                    FileObject[] fileObjects = sourcefilefolder.findFiles(new AllFileSelector() {
                        public boolean traverseDescendents(FileSelectInfo info) {
                            return info.getDepth() == 0 || include_subfolders;
                        }

                        public boolean includeFile(FileSelectInfo info) {

                            FileObject fileObject = info.getFile();
                            try {
                                if (fileObject == null) {
                                    return false;
                                }
                                if (fileObject.getType() != FileType.FILE) {
                                    return false;
                                }
                            } catch (Exception ex) {
                                // Upon error don't process the file.
                                return false;
                            } finally {
                                if (fileObject != null) {
                                    try {
                                        fileObject.close();
                                    } catch (IOException ex) { /* Ignore */
                                    }
                                }

                            }
                            return true;
                        }
                    });

                    if (fileObjects != null) {
                        for (int j = 0; j < fileObjects.length && !parentJob.isStopped(); j++) {
                            if (successConditionBroken) {
                                if (!successConditionBrokenExit) {
                                    logError(BaseMessages.getString(PKG,
                                            "JobDosToUnix.Error.SuccessConditionbroken", "" + nrAllErrors));
                                    successConditionBrokenExit = true;
                                }
                                return false;
                            }
                            // Fetch files in list one after one ...
                            CurrentFile = fileObjects[j];

                            if (!CurrentFile.getParent().toString().equals(sourcefilefolder.toString())) {
                                // Not in the Base Folder..Only if include sub folders
                                if (include_subfolders) {
                                    if (GetFileWildcard(CurrentFile.toString(), realWildcard)) {
                                        convertOneFile(CurrentFile, convertion, result, parentJob);
                                    }
                                }

                            } else {
                                // In the base folder
                                if (GetFileWildcard(CurrentFile.toString(), realWildcard)) {
                                    convertOneFile(CurrentFile, convertion, result, parentJob);
                                }
                            }
                        }
                    }
                } else {
                    logError(BaseMessages.getString(PKG, "JobDosToUnix.Error.UnknowFileFormat",
                            sourcefilefolder.toString()));
                    // Update Errors
                    updateErrors();
                }
            } else {
                logError(BaseMessages.getString(PKG, "JobDosToUnix.Error.SourceFileNotExists",
                        realSourceFilefoldername));
                // Update Errors
                updateErrors();
            }
        } catch (Exception e) {
            logError(BaseMessages.getString(PKG, "JobDosToUnix.Error.Exception.Processing",
                    realSourceFilefoldername.toString(), e.getMessage()));
            // Update Errors
            updateErrors();
        } finally {
            if (sourcefilefolder != null) {
                try {
                    sourcefilefolder.close();
                } catch (IOException ex) {
                    /* Ignore */
                }

            }
            if (CurrentFile != null) {
                try {
                    CurrentFile.close();
                } catch (IOException ex) { /* Ignore */
                }
            }
        }
        return entrystatus;
    }

    private boolean convertOneFile(FileObject file, int convertion, Result result, Job parentJob)
            throws KettleException {
        boolean retval = false;
        try {
            // We deal with a file..

            boolean convertToUnix = true;

            if (convertion == CONVERTION_TYPE_GUESS) {
                // Get file Type
                int fileType = getFileType(file);
                if (fileType == TYPE_DOS_FILE) {
                    // File type is DOS
                    // We need to convert it to UNIX
                    convertToUnix = true;
                } else {
                    // File type is not DOS
                    // so let's convert it to DOS
                    convertToUnix = false;
                }
            } else if (convertion == CONVERTION_TYPE_DOS_TO_UNIX) {
                convertToUnix = true;
            } else {
                convertToUnix = false;
            }

            retval = convert(file, convertToUnix);

            if (!retval) {
                logError(BaseMessages.getString(PKG, "JobDosToUnix.Error.FileNotConverted", file.toString()));
                // Update Bad files number
                updateBadFormed();
                if (resultfilenames.equals(ADD_ALL_FILENAMES) || resultfilenames.equals(ADD_ERROR_FILES_ONLY)) {
                    addFileToResultFilenames(file, result, parentJob);
                }
            } else {
                if (isDetailed()) {
                    logDetailed("---------------------------");
                    logDetailed(BaseMessages.getString(PKG, "JobDosToUnix.Error.FileConverted", file,
                            convertToUnix ? "UNIX" : "DOS"));
                }
                // Update processed files number
                updateProcessedFormed();
                if (resultfilenames.equals(ADD_ALL_FILENAMES) || resultfilenames.equals(ADD_PROCESSED_FILES_ONLY)) {
                    addFileToResultFilenames(file, result, parentJob);
                }
            }

        } catch (Exception e) {
            throw new KettleException("Unable to convert file '" + file.toString() + "'", e);
        }
        return retval;
    }

    private void updateProcessedFormed() {
        nrProcessedFiles++;
    }

    private void updateBadFormed() {
        nrErrorFiles++;
        updateAllErrors();
    }

    private void addFileToResultFilenames(FileObject fileaddentry, Result result, Job parentJob) {
        try {
            ResultFile resultFile = new ResultFile(ResultFile.FILE_TYPE_GENERAL, fileaddentry,
                    parentJob.getJobname(), toString());
            result.getResultFiles().put(resultFile.getFile().toString(), resultFile);

            if (isDetailed()) {
                logDetailed(
                        BaseMessages.getString(PKG, "JobDosToUnix.Log.FileAddedToResultFilesName", fileaddentry));
            }

        } catch (Exception e) {
            logError(BaseMessages.getString(PKG, "JobDosToUnix.Error.AddingToFilenameResult",
                    fileaddentry.toString(), e.getMessage()));
        }
    }

    /**********************************************************
     *
     * @param selectedfile
     * @param wildcard
     * @return True if the selectedfile matches the wildcard
     **********************************************************/
    private boolean GetFileWildcard(String selectedfile, String wildcard) {
        Pattern pattern = null;
        boolean getIt = true;

        if (!Const.isEmpty(wildcard)) {
            pattern = Pattern.compile(wildcard);
            // First see if the file matches the regular expression!
            if (pattern != null) {
                Matcher matcher = pattern.matcher(selectedfile);
                getIt = matcher.matches();
            }
        }

        return getIt;
    }

    public void setIncludeSubfolders(boolean include_subfoldersin) {
        this.include_subfolders = include_subfoldersin;
    }

    public void setArgFromPrevious(boolean argfrompreviousin) {
        this.arg_from_previous = argfrompreviousin;
    }

    public void setNrErrorsLessThan(String nr_errors_less_than) {
        this.nr_errors_less_than = nr_errors_less_than;
    }

    public String getNrErrorsLessThan() {
        return nr_errors_less_than;
    }

    public void setSuccessCondition(String success_condition) {
        this.success_condition = success_condition;
    }

    public String getSuccessCondition() {
        return success_condition;
    }

    public void setResultFilenames(String resultfilenames) {
        this.resultfilenames = resultfilenames;
    }

    public String getResultFilenames() {
        return resultfilenames;
    }

    public boolean evaluates() {
        return true;
    }

}