배치 작업 마법사

                package com.bankwareglobal.ide.bxframework.se.extensions.overriding.impl

                import com.bankwareglobal.ide.bxframework.core.batch.generator.IBatchCodeExtension
                import com.bankwareglobal.ide.bxframework.core.batch.model.BatchChunkTypeDeclarationModel
                import com.bankwareglobal.ide.bxframework.core.generator.ImportManager
                import com.bankwareglobal.ide.bxframework.core.batch.model.BatchMultiWriterTypeDeclarationModel
                import com.bankwareglobal.ide.commons.utils.JavaUtils

                /**
                 * 배치 작업 마법사에서 생성되는 컴포넌트의 메소드 코드를 생성하는 모듈
                 */
                class ExtBatchCodeExtension implements IBatchCodeExtension {

                    /**
                     * Database 유형의 ItemStream open 메소드 내용을 작성합니다.
                     */
                    override assembleDbItemStreamOpen(BatchChunkTypeDeclarationModel model, ImportManager importManager, String readerDbioVarName)'''
                        List<«model.readerDbioDtoClassName»> dbioOut= «readerDbioVarName».«model.readerDbioMethodName»();

                        if(dbioOut == null || dbioOut.isEmpty())
                        {
                            throw new ItemStreamException("Connected result is not prepared.");
                        }

                        iterator = dbioOut.iterator();
                    '''

                    /**
                     * Reader의 Source Fixed 유형의 ItemStream open 메소드 내용을 작성합니다.
                     */
                    override assembleReadSourceFixedItemStreamOpen(BatchChunkTypeDeclarationModel model, ImportManager importManager, String batchFileUtilClassName)'''
                        String readFileName= "";
                        reader= «JavaUtils.getClassName(batchFileUtilClassName)».getFixedFileReader(readFileName, «model.readerDtoClassName».class, "«model.readerFileEncoding»");
                        reader.open(executionContext);
                    '''

                    /**
                     * Reader의 Source Delimited 유형의 ItemStream open 메소드 내용을 작성합니다.
                     */
                    override assembleReadSourceDelimitItemStreamOpen(BatchChunkTypeDeclarationModel model, ImportManager importManager, String batchFileUtilClassName)'''
                        String readFileName= "";
                        reader= «JavaUtils.getClassName(batchFileUtilClassName)».getDelimitedFileReader(readFileName, «model.readerDtoClassName».class, "«model.readerDelimiter»", "«model.readerFileEncoding»");
                        reader.open(executionContext);
                    '''

                    /**
                     * Writer의 Source Fixed 유형의 ItemStream open 메소드 내용을 작성합니다.
                     */
                    override assembleWriteSourceFixedItemStreamOpen(BatchChunkTypeDeclarationModel model, ImportManager importManager, String batchFileUtilClassName)'''
                        String writeFileName= "";
                        writer= «JavaUtils.getClassName(batchFileUtilClassName)».getFixedFileWriter(writeFileName, «model.writerDtoClassName».class, "«model.writerFileEncoding»");
                        writer.open(executionContext);
                    '''

                    /**
                     * Writer의 Source Delimited 유형의 ItemStream open 메소드 내용을 작성합니다.
                     */
                    override assembleWriteSourceDelimitItemStreamOpen(BatchChunkTypeDeclarationModel model, ImportManager importManager, String batchFileUtilClassName)'''
                        String writeFileName= "";
                        writer= «JavaUtils.getClassName(batchFileUtilClassName)».getDelimitedFileWriter(writeFileName, «model.writerDtoClassName».class, "«model.writerDelimiter»");
                        writer.open(executionContext);
                    '''

                    /**
                     * Multi Writer의 Source Fixed 유형의 ItemStream open 메소드 내용을 작성합니다.
                     */
                    override assembleWriteSourceFixedItemStreamOpen(BatchMultiWriterTypeDeclarationModel model, ImportManager importManager, String batchFileUtilClassName)'''
                        String writeFileName= "";
                        writer= «JavaUtils.getClassName(batchFileUtilClassName)».getFixedFileWriter(writeFileName, «model.dtoClassName».class, "«model.fileEncoding»");
                        writer.open(executionContext);
                    '''

                    /**
                     * Multi Writer의 Source Delimited 유형의 ItemStream open 메소드 내용을 작성합니다.
                     */
                    override assembleWriteSourceDelimitItemStreamOpen(BatchMultiWriterTypeDeclarationModel model, ImportManager importManager, String batchFileUtilClassName)'''
                        String writeFileName= "";
                        writer= «JavaUtils.getClassName(batchFileUtilClassName)».getDelimitedFileWriter(writeFileName, «model.dtoClassName».class, "«model.delimiter»");
                        writer.open(executionContext);
                    '''

                    /**
                     * Reader의 Source Fixed 유형의 ItemStream update 메소드 내용을 작성합니다.
                     */
                    override assembleReadSourceFixedItemStreamUpdate(BatchChunkTypeDeclarationModel model, ImportManager importManager)'''
                        if(reader != null) reader.update(executionContext);
                    '''

                    /**
                     * Reader의 Source Delimited 유형의 ItemStream update 메소드 내용을 작성합니다.
                     */
                    override assembleReadSourceDelimitItemStreamUpdate(BatchChunkTypeDeclarationModel model, ImportManager importManager)'''
                        if(reader != null) reader.update(executionContext);
                    '''

                    /**
                     * Writer의 Source Fixed 유형의 ItemStream update 메소드 내용을 작성합니다.
                     */
                    override assembleWriteSourceFixedItemStreamUpdate(BatchChunkTypeDeclarationModel model, ImportManager importManager)'''
                        if(writer != null) writer.update(executionContext);
                    '''

                    /**
                     * Writer의 Source Delimited 유형의 ItemStream update 메소드 내용을 작성합니다.
                     */
                    override assembleWriteSourceDelimitItemStreamUpdate(BatchChunkTypeDeclarationModel model, ImportManager importManager)'''
                        if(writer != null) writer.update(executionContext);
                    '''

                    /**
                     * Multi Writer의 Source Fixed 유형의 ItemStream update 메소드 내용을 작성합니다.
                     */
                    override assembleWriteSourceFixedItemStreamUpdate(BatchMultiWriterTypeDeclarationModel model, ImportManager importManager
                    )'''
                        if(writer != null) writer.update(executionContext);
                    '''

                    /**
                     * Multi Writer의 Source Delimited 유형의 ItemStream update 메소드 내용을 작성합니다.
                     */
                    override assembleWriteSourceDelimitItemStreamUpdate(BatchMultiWriterTypeDeclarationModel model, ImportManager importManager)'''
                        if(writer != null) writer.update(executionContext);
                    '''

                    /**
                     * Database 유형의 ItemStream close 메소드 내용을 작성합니다.
                     */
                    override assembleDbItemStreamClose(BatchChunkTypeDeclarationModel model, ImportManager importManager)'''
                        «importManager.add("bxm.context.das.DasUtils")»
                        DasUtils.disconnectDasExecutor(iterator);
                    '''

                    /**
                     * Reader의 Source Fixed 유형의 ItemStream close 메소드 내용을 작성합니다.
                     */
                    override assembleReadSourceFixedItemStreamClose(BatchChunkTypeDeclarationModel model, ImportManager importManager)'''
                        if(reader != null) reader.close();
                    '''

                    /**
                     * Reader의 Source Delimited 유형의 ItemStream close 메소드 내용을 작성합니다.
                     */
                    override assembleReadSourceDelimitItemStreamClose(BatchChunkTypeDeclarationModel model, ImportManager importManager)'''
                        if(reader != null) reader.close();
                    '''

                    /**
                     * Writer의 Source Fixed 유형의 ItemStream close 메소드 내용을 작성합니다.
                     */
                    override assembleWriteSourceFixedItemStreamClose(BatchChunkTypeDeclarationModel model, ImportManager importManager)'''
                        if(writer != null) writer.close();
                    '''

                    /**
                     * Writer의 Source Delimited 유형의 ItemStream close 메소드 내용을 작성합니다.
                     */
                    override assembleWriteSourceDelimitItemStreamClose(BatchChunkTypeDeclarationModel model, ImportManager importManager)'''
                        if(writer != null) writer.close();
                    '''

                    /**
                     * Multi Writer의 Source Fixed 유형의 ItemStream close 메소드 내용을 작성합니다.
                     */
                    override assembleWriteSourceFixedItemStreamClose(BatchMultiWriterTypeDeclarationModel model, ImportManager importManager)'''
                        if(writer != null) writer.close();
                    '''

                    /**
                     * Multi Writer의 Source Delimited 유형의 ItemStream close 메소드 내용을 작성합니다.
                     */
                    override assembleWriteSourceDelimitItemStreamClose(BatchMultiWriterTypeDeclarationModel model, ImportManager importManager)'''
                        if(writer != null) writer.close();
                    '''

                    /**
                     * Reader의 Database 유형의 read 메소드 내용을 작성합니다.
                     */
                    override assembleDbReader(BatchChunkTypeDeclarationModel model, ImportManager importManager, String dtoMappingLogic)'''
                        «importManager.add(String.join(".", model.readerDbioDtoPackageName, model.readerDbioDtoClassName))»
                        «model.readerDtoClassName» in = null;

                        if(iterator.hasNext())
                        {
                            in = new «model.readerDtoClassName»();

                            «model.readerDbioDtoClassName» input = iterator.next();

                            «dtoMappingLogic»
                        }

                        return in;
                    '''

                    /**
                     * Reader의 Source Fixed 유형의 read 메소드 내용을 작성합니다.
                     */
                    override assembleFileReadSourceFixedReader(BatchChunkTypeDeclarationModel model, ImportManager importManager)'''
                        «model.readerDtoClassName» in= reader.read();

                        return in;
                    '''

                    /**
                     * Reader의 Source Delimited 유형의 read 메소드 내용을 작성합니다.
                     */
                    override assembleFileReadSourcedDelimitReader(BatchChunkTypeDeclarationModel model, ImportManager importManager)'''
                        «model.readerDtoClassName» in= reader.read();

                        return in;
                    '''

                    /**
                     * Processor의 process 메소드 내용을 작성합니다.
                     */
                    override assembleProcessor(BatchChunkTypeDeclarationModel model, ImportManager importManager)'''
                    '''

                    /**
                     * Processor의 Multi Fixed, Multi Delimited 유형의 process 메소드 내용을 작성합니다.
                     */
                    override assembleProcessorMultiTypeReader(BatchChunkTypeDeclarationModel model, ImportManager importManager, String subHeaderDtoQname, String subBodyDtoQname, String subFooterDtoQname)'''
                        «var subHeaderDtoClassName = JavaUtils.getClassName(subHeaderDtoQname)»
                        «var subBodyDtoClassName = JavaUtils.getClassName(subBodyDtoQname)»
                        «var subFooterDtoClassName = JavaUtils.getClassName(subFooterDtoQname)»
                        «subHeaderDtoClassName» readerHeader= null; // Reader Header DTO
                        «subBodyDtoClassName» readerBody= null;     // Reader Body DTO
                        «subFooterDtoClassName» readerFooter= null; // Reader Footer DTO

                        if(in instanceof «subHeaderDtoClassName»)
                        {
                            // Reader Header
                            readerHeader= («subHeaderDtoClassName») in;
                        }
                        else if(in instanceof «subBodyDtoClassName»)
                        {
                            // Reader Body
                            readerBody= («subBodyDtoClassName») in;
                        }
                        else if(in instanceof «subFooterDtoClassName»)
                        {
                            // Reader Footer
                            readerFooter= («subFooterDtoClassName») in;
                        }
                    '''

                    /**
                     * Writer의 Multi Fixed, Multi Delimited 유형의 process 메소드 내용을 작성합니다.
                     */
                    override assembleProcessorMultiTypeWriter(BatchChunkTypeDeclarationModel model, ImportManager importManager, String subHeaderDtoQname, String subBodyDtoQname, String subFooterDtoQname)'''
                        «var subHeaderDtoClassName = JavaUtils.getClassName(subHeaderDtoQname)»
                        «var subBodyDtoClassName = JavaUtils.getClassName(subBodyDtoQname)»
                        «var subFooterDtoClassName = JavaUtils.getClassName(subFooterDtoQname)»
                        «subHeaderDtoClassName» writerHeader= null; // Writer Header DTO
                        «subBodyDtoClassName» writerBody= null;     // Writer Body DTO
                        «subFooterDtoClassName» writerFooter= null; // Writer Footer DTO

                        out.setHeader(writerHeader);

                        out.setBody(writerBody);

                        out.setFooter(writerFooter);
                    '''

                    /**
                     * Writer의 Database 유형의 write 메소드 내용을 작성합니다.
                     */
                    override assembleDbWriter(BatchChunkTypeDeclarationModel model, ImportManager importManager, String writerDbioVarName, String dtoMappingLogic)'''
                        «importManager.add("java.util.ArrayList")»
                        «importManager.add(String.join(".", model.writerDbioDtoPackageName, model.writerDbioDtoClassName))»

                        List<«model.writerDbioDtoClassName»> inDtoList = new ArrayList<«model.writerDbioDtoClassName»>();
                        for(«model.writerDtoClassName» in : inList)
                        {
                            «model.writerDbioDtoClassName» inDto = new «model.writerDbioDtoClassName»();
                            «dtoMappingLogic»
                            inDtoList.add(inDto);
                        }

                        «writerDbioVarName».«model.writerDbioMethodName»(inDtoList);
                    '''

                    /**
                     * Writer의 Source Fixed 유형의 write 메소드 내용을 작성합니다.
                     */
                    override assembleFileWriterSourceFixedWriter(BatchChunkTypeDeclarationModel model, ImportManager importManager)'''
                        writer.write(inList);
                    '''

                    /**
                     * Writer의 Source Delimited 유형의 write 메소드 내용을 작성합니다.
                     */
                    override assembleFileWriterSourceDelimitWriter(BatchChunkTypeDeclarationModel model, ImportManager importManager)'''
                        writer.write(inList);
                    '''

                    /**
                     * Multi Writer의 Database 유형의 write 메소드 내용을 작성합니다.
                     */
                    override assembleDbWriter(BatchMultiWriterTypeDeclarationModel model, ImportManager importManager, String writerDbioVarName, String dtoMappingLogic)'''
                        «importManager.add("java.util.ArrayList")»
                        «importManager.add(String.join(".", model.dbioDtoPackageName, model.dbioDtoClassName))»

                        List<«model.dbioDtoClassName»> inDtoList = new ArrayList<«model.dbioDtoClassName»>();
                        for(«model.dtoClassName» in : inList)
                        {
                            «model.dbioDtoClassName» inDto = new «model.dbioDtoClassName»();
                            «dtoMappingLogic»
                            inDtoList.add(inDto);
                        }

                        «writerDbioVarName».«model.dbioMethodName»(inDtoList);
                    '''

                    /**
                     * Multi Writer의 Source Fixed 유형의 write 메소드 내용을 작성합니다.
                     */
                    override assembleFileWriterSourceFixedWriter(BatchMultiWriterTypeDeclarationModel model, ImportManager importManager)'''
                        writer.write(inList);
                    '''

                    /**
                     * Multi Writer의 Source Delimited 유형의 write 메소드 내용을 작성합니다.
                     */
                    override assembleFileWriterSourceDelimitWriter(BatchMultiWriterTypeDeclarationModel model, ImportManager importManager)'''
                        writer.write(inList);
                    '''

                }

                package com.bankwareglobal.ide.bxframework.se.extensions.overriding.impl

                import com.bankwareglobal.ide.bxframework.core.batch.generator.IBatchJobExtension
                import com.bankwareglobal.ide.bxframework.core.batch.model.BatchChunkTypeDeclarationModel
                import com.bankwareglobal.ide.bxframework.core.batch.model.BatchHelper
                import com.bankwareglobal.ide.bxframework.core.batch.model.BatchMultiWriterTypeDeclarationModel
                import com.bankwareglobal.ide.bxframework.core.batch.model.BatchTaskletTypeDeclarationModel
                import java.util.Map
                import com.bankwareglobal.ide.bxframework.core.batch.model.BatchType
                import com.bankwareglobal.ide.commons.utils.StringUtils

                /**
                 * 배치 작업 마법사에서 생성되는 Job XML 코드를 생성하는 모듈
                 */
                class ExtBatchJobExtension implements IBatchJobExtension {

                    /**
                     * Tasklet 유형의 Job XML 내용을 작성합니다.
                     */
                    override assembleTasklet(BatchTaskletTypeDeclarationModel model)'''
                        «IF model.usePartitioner»
                            <job id="«model.jobId»" xmlns="http://www.bankwareglobal.com/schema/batchex">
                                <author>«StringUtils.nvl(model.author)»</author>
                                <description>
                                </description>
                                <step id="«model.stepId»" parent="parentStep">
                                    <partition partitioner="«model.partitionerClassName»" step="«model.partitionerStepId»">
                                        <handler grid-size="«model.partitionerCount»"/>
                                    </partition>
                                </step>
                            </job>

                            <step id="«model.partitionerStepId»" parent="parentStep" xmlns="http://www.bankwareglobal.com/schema/batchex">
                                <tasklet ref="«model.className»"/>
                            </step>
                        «ELSE»
                            <job id="«model.jobId»" xmlns="http://www.bankwareglobal.com/schema/batchex">
                                <author>«StringUtils.nvl(model.author)»</author>
                                <description>
                                </description>
                                <step id="«model.stepId»" parent="parentStep">
                                    <tasklet ref="«model.className»"/>
                                </step>
                            </job>
                        «ENDIF»
                    '''

                    /**
                     * Reader의 Fixed 유형의 Job XML 내용을 작성합니다.
                     */
                    override assembleFixReader(BatchChunkTypeDeclarationModel model, String readerName)'''
                        <bean id="«readerName»" parent="RFix" scope="step">
                            <property name="resource" value=""/>
                            <property name="encoding" value="«model.readerFileEncoding»"/>
                            <property name="targetType" value="«String.join(".", model.readerDtoPackageName, model.readerDtoClassName)»"/>
                        </bean>
                    '''

                    /**
                     * Reader의 Delimited 유형의 Job XML 내용을 작성합니다.
                     */
                    override assembleDelimitReader(BatchChunkTypeDeclarationModel model, String readerName)'''
                        <bean id="«readerName»" parent="RDelimit" scope="step">
                            <property name="resource" value=""/>
                            <property name="encoding" value="«model.readerFileEncoding»"/>
                            <property name="delimiter" value="«model.readerDelimiter»"/>
                            <property name="targetType" value="«String.join(".", model.readerDtoPackageName, model.readerDtoClassName)»"/>
                        </bean>
                    '''

                    /**
                     * Reader의 Multi Fixed 유형의 Job XML 내용을 작성합니다.
                     */
                    override assembleMultiFixReader(BatchChunkTypeDeclarationModel model, String readerName, String subHeaderDtoQname, String subBodyDtoQname, String subFooterDtoQname)'''
                        <bean id="«readerName»" parent="RMultiTypeFix" scope="step">
                            <property name="resource" value=""/>
                            <property name="encoding" value="«model.readerFileEncoding»"/>
                            <property name="headerLine" value="1"/>
                            <property name="footerLine" value="1"/>
                            <property name="headerTargetType" value="«subHeaderDtoQname»"/>
                            <property name="bodyTargetType" value="«subBodyDtoQname»"/>
                            <property name="footerTargetType" value="«subFooterDtoQname»"/>
                        </bean>
                    '''

                    /**
                     * Reader의 Multi Delimited 유형의 Job XML 내용을 작성합니다.
                     */
                    override assembleMultiDelimitReader(BatchChunkTypeDeclarationModel model, String readerName, String subHeaderDtoQname, String subBodyDtoQname, String subFooterDtoQname)'''
                        <bean id="«readerName»" parent="RMultiTypeDelimit" scope="step">
                            <property name="resource" value=""/>
                            <property name="encoding" value="«model.readerFileEncoding»"/>
                            <property name="delimiter" value="«model.readerDelimiter»"/>
                            <property name="headerLine" value="1"/>
                            <property name="footerLine" value="1"/>
                            <property name="headerTargetType" value="«subHeaderDtoQname»"/>
                            <property name="bodyTargetType" value="«subBodyDtoQname»"/>
                            <property name="footerTargetType" value="«subFooterDtoQname»"/>
                        </bean>
                    '''

                    /**
                     * Reader의 Variable 유형의 Job XML 내용을 작성합니다.
                     */
                    override assembleVariableReader(BatchChunkTypeDeclarationModel model, String readerName)'''
                        <bean id="«readerName»" parent="RVariable" scope="step">
                            <property name="resource" value=""/>
                            <property name="encoding" value="«model.readerFileEncoding»"/>
                        </bean>
                    '''

                    /**
                     * Writer의 Fixed 유형의 Job XML 내용을 작성합니다.
                     */
                    override assembleFixWriter(BatchChunkTypeDeclarationModel model, String writerName)'''
                        <bean id="«writerName»" parent="WFix" scope="step">
                            <property name="resource" value=""/>
                            <property name="encoding" value="«model.writerFileEncoding»"/>
                            <property name="targetType" value="«String.join(".", model.writerDtoPackageName, model.writerDtoClassName)»"/>
                        </bean>
                    '''

                    /**
                     * Writer의 Delimited 유형의 Job XML 내용을 작성합니다.
                     */
                    override assembleDelimitWriter(BatchChunkTypeDeclarationModel model, String writerName)'''
                        <bean id="«writerName»" parent="WDelimit" scope="step">
                            <property name="resource" value=""/>
                            <property name="encoding" value="«model.writerFileEncoding»"/>
                            <property name="delimiter" value="«model.writerDelimiter»"/>
                            <property name="targetType" value="«String.join(".", model.writerDtoPackageName, model.writerDtoClassName)»"/>
                        </bean>
                    '''

                    /**
                     * Writer의 Multi Fixed 유형의 Job XML 내용을 작성합니다.
                     */
                    override assembleMultiFixWriter(BatchChunkTypeDeclarationModel model, String writerName)'''
                        <bean id="«writerName»" parent="WMultiTypeFix" scope="step">
                            <property name="resource" value=""/>
                            <property name="encoding" value="«model.writerFileEncoding»"/>
                            <property name="targetType" value="«String.join(".", model.writerDtoPackageName, model.writerDtoClassName)»"/>
                        </bean>
                    '''

                    /**
                     * Writer의 Multi Delimited 유형의 Job XML 내용을 작성합니다.
                     */
                    override assembleMultiDelimitWriter(BatchChunkTypeDeclarationModel model, String writerName)'''
                        <bean id="«writerName»" parent="WMultiTypeDelimit" scope="step">
                            <property name="resource" value=""/>
                            <property name="encoding" value="«model.writerFileEncoding»"/>
                            <property name="delimiter" value="«model.writerDelimiter»"/>
                            <property name="targetType" value="«String.join(".", model.writerDtoPackageName, model.writerDtoClassName)»"/>
                        </bean>
                    '''

                    /**
                     * Writer의 Variable 유형의 Job XML 내용을 작성합니다.
                     */
                    override assembleVariableWriter(BatchChunkTypeDeclarationModel model, String writerName)'''
                        <bean id="«writerName»" parent="WVariable" scope="step">
                            <property name="resource" value=""/>
                            <property name="encoding" value="«model.writerFileEncoding»"/>
                        </bean>
                    '''

                    /**
                     * Multi Writer의 Job XML 내용을 작성합니다.
                     */
                    override assembleMultiWriter(String writerName, Map<String, BatchMultiWriterTypeDeclarationModel> mainRef, Map<String, BatchMultiWriterTypeDeclarationModel> subEntry, Map<String, BatchMultiWriterTypeDeclarationModel> allBeans)'''
                        <bean id="«writerName»" parent="WMultiWriter">
                            <property name="main">
                                <list>
                                    «IF !mainRef.empty»
                                        «FOR String writerId : mainRef.keySet»
                                            <ref bean="«writerId»"/>
                                        «ENDFOR»
                                    «ENDIF»
                                </list>
                            </property>
                            <property name="sub">
                                <map>
                                    «IF !subEntry.empty»
                                        «FOR String writerId : subEntry.keySet»
                                            «var sub = subEntry.get(writerId)»
                                            <entry key="«writerId»" value="«sub.subFieldName»"/>
                                        «ENDFOR»
                                    «ENDIF»
                                </map>
                            </property>
                        </bean>

                        «FOR String writerId : allBeans.keySet»
                            «var bean = allBeans.get(writerId)»
                            «IF !BatchHelper.isTypeUseItemWriter(bean.type)»
                                «IF BatchType.FIXED.equals(bean.type)»
                                    <bean id="«writerId»" parent="WFix" scope="step">
                                        <property name="resource" value="" />
                                        <property name="encoding" value="«bean.fileEncoding»" />
                                        <property name="targetType" value="«String.join(".", bean.dtoPackageName, bean.dtoClassName)»" />
                                    </bean>
                                «ELSEIF BatchType.DELIMITED.equals(bean.type)»
                                    <bean id="«writerId»" parent="WDelimit" scope="step">
                                        <property name="resource" value="" />
                                        <property name="encoding" value="«bean.fileEncoding»" />
                                        <property name="delimiter" value="«bean.delimiter»" />
                                        <property name="targetType" value="«String.join(".", bean.dtoPackageName, bean.dtoClassName)»" />
                                    </bean>
                                «ELSEIF BatchType.VARIABLE.equals(bean.type)»
                                    <bean id="«writerId»" parent="WVariable" scope="step">
                                        <property name="resource" value="" />
                                        <property name="encoding" value="«bean.fileEncoding»" />
                                    </bean>
                                «ENDIF»
                            «ENDIF»
                        «ENDFOR»
                    '''

                }

                package com.bankwareglobal.ide.bxframework.se.extensions.overriding.impl;

                import java.util.regex.Matcher;
                import java.util.regex.Pattern;

                import org.eclipse.core.resources.IFolder;
                import org.eclipse.core.resources.IResource;
                import org.eclipse.core.runtime.IStatus;
                import org.eclipse.jdt.core.IJavaProject;

                import com.bankwareglobal.ide.bxframework.core.batch.configuration.BatchConfiguration;
                import com.bankwareglobal.ide.bxframework.core.batch.generator.IBatchNamingDeterminator;
                import com.bankwareglobal.ide.bxframework.core.batch.messages.Messages;
                import com.bankwareglobal.ide.bxframework.core.batch.model.BatchChunkTypeDeclarationModel;
                import com.bankwareglobal.ide.bxframework.core.batch.model.BatchMultiWriterTypeDeclarationModel;
                import com.bankwareglobal.ide.bxframework.core.batch.model.BatchTaskletTypeDeclarationModel;
                import com.bankwareglobal.ide.bxframework.core.batch.model.BatchTypeDeclarationModel;
                import com.bankwareglobal.ide.bxframework.core.messages.CommonWord;
                import com.bankwareglobal.ide.bxframework.core.validator.IValidator;
                import com.bankwareglobal.ide.commons.status.BXMStatus;
                import com.bankwareglobal.ide.commons.utils.JavaUtils;
                import com.bankwareglobal.ide.commons.utils.StringUtils;
                import com.bankwareglobal.ide.datatools.constants.SqlStatementType;
                import com.bankwareglobal.ide.datatools.database.DBColumn;
                import com.bankwareglobal.ide.datatools.database.DBTable;

                /**
                 * 배치 작업 마법사를 이용하여 생성되는 모든 자원에 대한 이름(패키지, 클래스, 변수, 메소드 등) 결정자
                 */
                public class ExtBatchNamingDeterminator
                implements IBatchNamingDeterminator {

                    public final static String LINE_SEPARATOR= System.getProperty("line.separator");

                    /**
                     * Tasklet 타입의 배치 빈(Bean)의 패키지 이름을 리턴합니다.
                     */
                    @Override
                    public String getTaskletPackageName(BatchTaskletTypeDeclarationModel model) {
                        return String.join(".", JavaUtils.getStandardPackPrefix(model.getProject().getElementName()), "bat", "bean");
                    }

                    /**
                     * Tasklet 타입의 배치 빈(Bean)의 클래스 이름을 리턴합니다.
                     */
                    @Override
                    public String getTaskletClassName(BatchTaskletTypeDeclarationModel model) {
                        return getBeanClassName(model.getJobId());
                    }

                    /**
                     * Tasklet 타입의 배치 빈(Bean)의 논리 이름을 리턴합니다.
                     */
                    @Override
                    public String getTaskletLogicalName(BatchTaskletTypeDeclarationModel model) {
                        return String.join(" ", getBeanClassName(model.getJobId()), "Tasklet", "Bean");
                    }

                    /**
                     * Chunked 타입의 Reader 패키지 이름을 리턴합니다.
                     */
                    @Override
                    public String getReaderPackageName(BatchChunkTypeDeclarationModel model) {
                        return String.join(".", JavaUtils.getStandardPackPrefix(model.getProject().getElementName()), "bat", "bean");
                    }

                    /**
                     * Chunked 타입의 Reader 클래스 이름을 리턴합니다.
                     */
                    @Override
                    public String getReaderClassName(BatchChunkTypeDeclarationModel model) {
                        return getBeanClassName(model.getJobId());
                    }

                    /**
                     * Chunked 타입의 Reader 논리 이름을 리턴합니다.
                     */
                    @Override
                    public String getReaderLogicalName(BatchChunkTypeDeclarationModel model) {
                        return String.join(" ", getBeanClassName(model.getJobId()), "Bean");
                    }

                    /**
                     * Chunked 타입의 Processor 패키지 이름을 리턴합니다.
                     */
                    @Override
                    public String getProcessorPackageName(BatchChunkTypeDeclarationModel model) {
                        return String.join(".", JavaUtils.getStandardPackPrefix(model.getProject().getElementName()), "bat", "bean");
                    }

                    /**
                     * Chunked 타입의 Processor 클래스 이름을 리턴합니다.
                     */
                    @Override
                    public String getProcessorClassName(BatchChunkTypeDeclarationModel model) {
                        return getBeanClassName(model.getJobId());
                    }

                    /**
                     * Chunked 타입의 Processor 논리 이름을 리턴합니다.
                     */
                    @Override
                    public String getProcessorLogicalName(BatchChunkTypeDeclarationModel model) {
                        return String.join(" ", getBeanClassName(model.getJobId()), "Processor", "Bean");
                    }

                    /**
                     * Chunked 타입의 Writer 패키지 이름을 리턴합니다.
                     */
                    @Override
                    public String getWriterPackageName(BatchChunkTypeDeclarationModel model) {
                        return String.join(".", JavaUtils.getStandardPackPrefix(model.getProject().getElementName()), "bat", "bean");
                    }

                    /**
                     * Chunked 타입의 Writer 클래스 이름을 리턴합니다.
                     */
                    @Override
                    public String getWriterClassName(BatchChunkTypeDeclarationModel model) {
                        return getBeanClassName(model.getJobId());
                    }

                    /**
                     * Chunked 타입의 Writer 논리 이름을 리턴합니다.
                     */
                    @Override
                    public String getWriterLogicalName(BatchChunkTypeDeclarationModel model) {
                        return String.join(" ", getBeanClassName(model.getJobId()), "Writer", "Bean");
                    }

                    /**
                     * Chunked 타입의 Multi Writer 패키지 이름을 리턴합니다.
                     */
                    @Override
                    public String getMultiWriterPackageName(BatchMultiWriterTypeDeclarationModel model) {
                        return String.join(".", JavaUtils.getStandardPackPrefix(model.getProject().getElementName()), "bat", "bean");
                    }

                    /**
                     * Chunked 타입의 Multi Writer 클래스 이름을 리턴합니다.
                     */
                    @Override
                    public String getMultiWriterClassName(BatchMultiWriterTypeDeclarationModel model) {
                        return getBeanClassName(model.getJobId());
                    }

                    /**
                     * Chunked 타입의 Multi Writer 논리 이름을 리턴합니다.
                     */
                    @Override
                    public String getMultiWriterLogicalName(BatchMultiWriterTypeDeclarationModel model) {
                        return String.join(" ", getBeanClassName(model.getJobId()), "MultiWriter", "Bean");
                    }

                    /**
                     * Chunked 타입의 Multi Writer 출력 DTO 패키지 이름을 리턴합니다.
                     */
                    @Override
                    public String getMultiWriterOutputDtoPackageName(BatchMultiWriterTypeDeclarationModel model) {
                        return String.join(".", JavaUtils.getStandardPackPrefix(model.getProject().getElementName()), "bat", "bean.dto");
                    }

                    /**
                     * Chunked 타입의 Multi Writer 출력 DTO 클래스 이름을 리턴합니다.
                     */
                    @Override
                    public String getMultiWriterOutputDtoClassName(BatchMultiWriterTypeDeclarationModel model) {
                        return StringUtils.capitalize(model.getJobId() + "00DtoSub");
                    }

                    /**
                     * Chunked 타입의 Multi Writer 출력 DTO 논리 이름을 리턴합니다.
                     */
                    @Override
                    public String getMultiWriterOutputDtoLogicalName(BatchMultiWriterTypeDeclarationModel model) {
                        return String.join(" ", getBeanClassName(model.getJobId()), CommonWord.OUTPUT_SUB, CommonWord.OUTPUT_IO);
                    }

                    /**
                     * Chunked 타입의 Multi Writer DBIO 입력 DTO 패키지 이름을 리턴합니다.
                     */
                    @Override
                    public String getMultiWriterInputDbioDtoPackageName(BatchMultiWriterTypeDeclarationModel model) {
                        return String.join(".", JavaUtils.getStandardPackPrefix(model.getProject().getElementName()), "bat", "dbio.dto");
                    }

                    /**
                     * Chunked 타입의 Multi Writer DBIO 입력 DTO 클래스 이름을 리턴합니다.
                     */
                    @Override
                    public String getMultiWriterInputDbioDtoClassName(BatchMultiWriterTypeDeclarationModel model) {
                        return model.isMain()?
                                StringUtils.capitalize(model.getJobId() + "00DtoMain")
                                :StringUtils.capitalize(model.getJobId() + "00DtoSub");
                    }

                    /**
                     * Chunked 타입의 Multi Writer DBIO 입력 DTO 논리 이름을 리턴합니다.
                     */
                    @Override
                    public String getMultiWriterInputDbioDtoLogicalName(BatchMultiWriterTypeDeclarationModel model) {
                        return model.isMain()?
                                String.join(" ", getBeanClassName(model.getJobId()), CommonWord.DBIO, CommonWord.INPUT_IO)
                                :String.join(" ", getBeanClassName(model.getJobId()), CommonWord.DBIO, CommonWord.INPUT_SUB, CommonWord.INPUT_IO);
                    }

                    /**
                     * Chunked 타입의 Reader 입력 DTO 패키지 이름을 리턴합니다.
                     */
                    @Override
                    public String getReaderInputDtoPackageName(BatchChunkTypeDeclarationModel model) {
                        return String.join(".", JavaUtils.getStandardPackPrefix(model.getProject().getElementName()), "bat", "bean.dto");
                    }

                    /**
                     * Chunked 타입의 Reader 입력 DTO 클래스 이름을 리턴합니다.
                     */
                    @Override
                    public String getReaderInputDtoClassName(BatchChunkTypeDeclarationModel model) {
                        return String.join("", getBeanClassName(model.getJobId()), "00", "Dto");
                    }

                    /**
                     * Chunked 타입의 Reader 입력 DTO 논리 이름을 리턴합니다.
                     */
                    @Override
                    public String getReaderInputDtoLogicalName(BatchChunkTypeDeclarationModel model) {
                        return String.join(" ", getBeanClassName(model.getJobId()), CommonWord.INPUT_IO);
                    }

                    /**
                     * Chunked 타입의 Reader DBIO 출력 DTO 패키지 이름을 리턴합니다.
                     */
                    @Override
                    public String getReaderOutputDbioDtoPackageName(BatchChunkTypeDeclarationModel model) {
                        return String.join(".", JavaUtils.getStandardPackPrefix(model.getProject().getElementName()), "bat", "dbio.dto");
                    }

                    /**
                     * Chunked 타입의 Reader DBIO 출력 DTO 클래스 이름을 리턴합니다.
                     */
                    @Override
                    public String getReaderOutputDbioDtoClassName(BatchChunkTypeDeclarationModel model) {
                        return String.join("", model.getReaderDbioClassName(), model.getReaderDbioMethodName(), "Dto");
                    }

                    /**
                     * Chunked 타입의 Reader DBIO 출력 DTO 논리 이름을 리턴합니다.
                     */
                    @Override
                    public String getReaderOutputDbioDtoLogicalName(BatchChunkTypeDeclarationModel model) {
                        return String.join(" ", getBeanClassName(model.getJobId()), CommonWord.DBIO, CommonWord.OUTPUT_IO);
                    }

                    /**
                     * Chunked 타입의 Writer 출력 DTO 패키지 이름을 리턴합니다.
                     */
                    @Override
                    public String getWriterOutputDtoPackageName(BatchChunkTypeDeclarationModel model) {
                        return String.join(".", JavaUtils.getStandardPackPrefix(model.getProject().getElementName()), "bat", "bean.dto");
                    }

                    /**
                     * Chunked 타입의 Writer 출력 DTO 클래스 이름을 리턴합니다.
                     */
                    @Override
                    public String getWriterOutputDtoClassName(BatchChunkTypeDeclarationModel model) {
                        return String.join("", getBeanClassName(model.getJobId()), "00", "Dto");
                    }

                    /**
                     * Chunked 타입의 Writer 출력 DTO 논리 이름을 리턴합니다.
                     */
                    @Override
                    public String getWriterOutputDtoLogicalName(BatchChunkTypeDeclarationModel model) {
                        return String.join(" ", getBeanClassName(model.getJobId()), CommonWord.OUTPUT_IO);
                    }

                    /**
                     * Chunked 타입의 Writer DBIO 입력 DTO 패키지 이름을 리턴합니다.
                     */
                    @Override
                    public String getWriterInputDbioDtoPackageName(BatchChunkTypeDeclarationModel model) {
                        return String.join(".", JavaUtils.getStandardPackPrefix(model.getProject().getElementName()), "bat", "dbio.dto");
                    }

                    /**
                     * Chunked 타입의 Writer DBIO 입력 DTO 클래스 이름을 리턴합니다.
                     */
                    @Override
                    public String getWriterInputDbioDtoClassName(BatchChunkTypeDeclarationModel model) {
                        return String.join("", model.getWriterDbioClassName(), model.getWriterDbioMethodName(), "Dto");
                    }

                    /**
                     * Chunked 타입의 Writer DBIO 입력 DTO 논리 이름을 리턴합니다.
                     */
                    @Override
                    public String getWriterInputDbioDtoLogicalName(BatchChunkTypeDeclarationModel model) {
                        return String.join(" ", getBeanClassName(model.getJobId()), CommonWord.DBIO, CommonWord.INPUT_IO);
                    }

                    /**
                     * DBIO 클래스 이름을 리턴합니다.
                     */
                    @Override
                    public String getDbioClassName(String tableName) {
                        return "D" + StringUtils.capitalize( StringUtils.toCamelCase(tableName.toLowerCase()) )+ "001";
                    }

                    /**
                     * DBIO 패키지 이름을 리턴합니다.
                     */
                    @Override
                    public String getDbioPackageName(String projectName, String tableName) {
                        return String.join(".", JavaUtils.getStandardPackPrefix(projectName), "bat", "dbio");
                    }

                    /**
                     * DBIO Fully-Qualified 이름을 리턴합니다.
                     */
                    @Override
                    public String getDbioQName(String projectName, String tableName) {
                        return String.join(".", JavaUtils.getStandardPackPrefix(projectName), "dbio", getDbioClassName(tableName));
                    }

                    /**
                     * DBIO 메소드 이름을 리턴합니다.
                     */
                    @Override
                    public String getDbioMethodName(SqlStatementType sqlType, DBTable table) {
                        String methodPrefix = "";

                        if(SqlStatementType.SELECT.equals(sqlType))
                            methodPrefix = sqlType.getDisplay().toLowerCase() + "List";
                        else
                            methodPrefix = sqlType.getDisplay().toLowerCase();

                        return methodPrefix + "00";
                    }

                    /**
                     * DBIO 메소드 논리 이름을 리턴합니다.
                     */
                    @Override
                    public String getDbioMethodLogicalName(SqlStatementType sqlType, DBTable table) {
                        return String.join(" ", table!=null?table.getComment():"", sqlType.getDisplay()).trim();
                    }

                    /**
                     * 입력 Sub Header DTO Fully-Qualified 이름을 리턴합니다.
                     */
                    @Override
                    public String getInputSubHeaderDtoQName(String beanPackage, String beanName) {
                        return String.join(".", beanPackage, beanName + "00DtoSubHeader");
                    }

                    /**
                     * 입력 Sub Body DTO Fully-Qualified 이름을 리턴합니다.
                     */
                    @Override
                    public String getInputSubBodyDtoQName(String beanPackage, String beanName) {
                        return String.join(".", beanPackage, beanName + "00DtoSubBody");
                    }

                    /**
                     * 입력 Sub Footer DTO Fully-Qualified 이름을 리턴합니다.
                     */
                    @Override
                    public String getInputSubFooterDtoQName(String beanPackage, String beanName) {
                        return String.join(".", beanPackage, beanName + "00DtoSubFooter");
                    }

                    /**
                     * 출력 Sub Header DTO Fully-Qualified 이름을 리턴합니다.
                     */
                    @Override
                    public String getOutputSubHeaderDtoQName(String beanPackage, String beanName) {
                        return String.join(".", beanPackage, beanName + "01DtoSubHeader");
                    }

                    /**
                     * 입력 Sub Body DTO Fully-Qualified 이름을 리턴합니다.
                     */
                    @Override
                    public String getOutputSubBodyDtoQName(String beanPackage, String beanName) {
                        return String.join(".", beanPackage, beanName + "01DtoSubBody");
                    }

                    /**
                     * 입력 Sub Footer DTO Fully-Qualified 이름을 리턴합니다.
                     */
                    @Override
                    public String getOutputSubFooterDtoQName(String beanPackage, String beanName) {
                        return String.join(".", beanPackage, beanName + "01DtoSubFooter");
                    }

                    /**
                     * Job XML 에 작성될 Reader 의 이름을 리턴합니다.
                     */
                    @Override
                    public String getBatchJobReaderName(BatchTypeDeclarationModel model) {
                        return "R" + model.getStepId();
                    }

                    /**
                     * Job XML 에 작성될 Writer 의 이름을 리턴합니다.
                     */
                    @Override
                    public String getBatchJobWriterName(BatchTypeDeclarationModel model) {
                        return "W" + model.getStepId();
                    }

                    /**
                     * Job XML 에 작성될 Multi Writer 의 이름을 리턴합니다.
                     */
                    @Override
                    public String getBatchMultiWriterName(BatchTypeDeclarationModel model) {
                        return "W" + model.getStepId();
                    }

                    /**
                     * Job XML 에 작성될 Multi Writer 의 이름을 index 를 포함하여 리턴합니다.
                     */
                    @Override
                    public String getBatchMultiWriterName(BatchTypeDeclarationModel model, boolean main, int idx) {
                        return "W" + model.getJobId() + String.valueOf(100+idx);
                    }

                    /**
                     * 파티셔너 클래스 이름을 리턴합니다.
                     */
                    @Override
                    public String getBatchPartitionerClassName(String beanName) {
                        return beanName+"Ptr";
                    }

                    /**
                     * 파티셔너 Fully-Qualified 이름을 리턴합니다.
                     */
                    @Override
                    public String getBatchPartitionerQName(String beanPackage, String beanName) {
                        return String.join(".", beanPackage, getBatchPartitionerClassName(beanName));
                    }

                    /**
                     * 테이블 이름으로 getter/setter 호출 로직을 작성하여 리턴합니다.
                     */
                    @Override
                    public String getSetterGetterName(DBTable table, String setter, String getter) {
                        StringBuilder logic = new StringBuilder();

                        for (DBColumn column : table.getColumnList()) {
                            if ("boolean".equals(column.getType())) {
                                logic.append(setter).append(".").append("set").append(getSetPrefix(column.getName()))
                                        .append("(").append(getter).append(".").append("is")
                                        .append(getSetPrefix(column.getName())).append("())").append(";")
                                        .append(LINE_SEPARATOR);
                            } else {
                                logic.append(setter).append(".").append("set").append(getSetPrefix(column.getName()))
                                        .append("(").append(getter).append(".").append("get")
                                        .append(getSetPrefix(column.getName())).append("())").append(";")
                                        .append(LINE_SEPARATOR);
                            }
                        }

                        return logic.toString();
                    }

                    /**
                     * 변수 이름을 리턴합니다.
                     */
                    @Override
                    public String getVariableName(String qualifiedName) {
                        qualifiedName = qualifiedName.replaceAll("\\.", "");

                        return StringUtils.uncapitalize(qualifiedName);
                    }

                    /**
                     * 클래스 필드(변수) 이름을 리턴합니다.
                     */
                    @Override
                    public String getClassFieldName(String qualifiedName, String variableName) {
                        return String.format("private %s %s", qualifiedName, variableName);
                    }

                    protected String getSetPrefix(String str) {
                        String prefix= StringUtils.toCamelCase(str);
                        return prefix.substring(0, 1).toUpperCase() + prefix.substring(1);
                    }

                    private String getBeanClassName(String jobId) {
                        String className = "";

                        jobId = StringUtils.capitalize(jobId);

                        if(jobId.startsWith("B")) {
                            className = "M"+jobId.substring(1)+"Btch";
                        } else {
                            className = "M"+jobId+"Btch";
                        }

                        return className;
                    }

                    /**
                     * Job ID 검증 룰을 리턴합니다.
                     */
                    @Override
                    public IValidator<String> createBatchJobIdValidator(IJavaProject project) {
                        return new IValidator<String>() {
                            private final String JOB_ID_PATTERN = "^([a-zA-Z]+(_*[a-zA-Z0-9]*_*)*)";

                            @Override
                            public IStatus doValidate(String jobId) {
                                if(StringUtils.isEmpty(jobId)) {
                                    return BXMStatus.createErrorStatus(Messages.BATCH_JOB_ID_EMSG01);

                                } else {
                                    Pattern p = Pattern.compile(JOB_ID_PATTERN);
                                    Matcher m = p.matcher(jobId);

                                    if(!m.matches()) {
                                        return BXMStatus.createErrorStatus(Messages.BATCH_JOB_ID_EMSG02);
                                    }

                                    String batchJobPath = BatchConfiguration.BatchJob.getBatchJobPath();

                                    if(project != null) {
                                        IFolder jobFolder= project.getProject().getFolder("META-INF/" + batchJobPath);

                                        if(jobFolder.exists()) {
                                            IResource resource= jobFolder.findMember(jobId + ".xml");

                                            if(resource != null) {
                                                return BXMStatus.createErrorStatus(Messages.BATCH_JOB_ID_EMSG03);
                                            }
                                        }
                                    }
                                }

                                return BXMStatus.createOkStatus();
                            }
                        };
                    }

                    /**
                     * Step ID 검증 룰을 리턴합니다.
                     */
                    @Override
                    public IValidator<String> createBatchStepIdValidator() {
                        return new IValidator<String>() {
                            private final String JOB_STEP_ID_PATTERN = "^([a-zA-Z]+(_*[a-zA-Z0-9]*_*)*)";

                            @Override
                            public IStatus doValidate(String stepId) {
                                if(StringUtils.isEmpty(stepId)) {
                                    return BXMStatus.createErrorStatus(Messages.BATCH_JOB_STEP_ID_EMSG01);

                                } else {
                                    Pattern p = Pattern.compile(JOB_STEP_ID_PATTERN);
                                    Matcher m = p.matcher(stepId);

                                    if(!m.matches()) {
                                        return BXMStatus.createErrorStatus(Messages.BATCH_JOB_STEP_ID_EMSG02);
                                    }
                                }

                                return BXMStatus.createOkStatus();
                            }
                        };
                    }

                    /**
                     * 파티셔너 Step ID 검증 룰을 리턴합니다.
                     */
                    @Override
                    public IValidator<String> createBatchPartitionerStepIdValidator(boolean usePartitioner) {
                        return new IValidator<String>() {
                            private final String JOB_STEP_ID_PATTERN = "^([a-zA-Z]+(_*[a-zA-Z0-9]*_*)*)";

                            @Override
                            public IStatus doValidate(String stepId) {
                                if(usePartitioner) {
                                    if(StringUtils.isEmpty(stepId)) {
                                        return BXMStatus.createErrorStatus(Messages.BATCH_JOB_STEP_ID_EMSG01);

                                    } else {
                                        Pattern p = Pattern.compile(JOB_STEP_ID_PATTERN);
                                        Matcher m = p.matcher(stepId);

                                        if(!m.matches()) {
                                            return BXMStatus.createErrorStatus(Messages.BATCH_JOB_STEP_ID_EMSG02);
                                        }
                                    }
                                }

                                return BXMStatus.createOkStatus();
                            }
                        };
                    }

                    /**
                     * Shell 이름 검증 룰을 리턴합니다.
                     */
                    @Override
                    public IValidator<String> createShellNameValidator(IJavaProject project) {
                        return new IValidator<String>() {
                            private final String SHELL_NAME_PATTERN = "^([a-zA-Z]+(_*[a-zA-Z0-9]*_*)*)";

                            @Override
                            public IStatus doValidate(String shellName) {
                                if(BatchConfiguration.BatchJob.isUseBatchShellScript()) {
                                    if(StringUtils.isEmpty(shellName)) {
                                        return BXMStatus.createErrorStatus(Messages.BATCH_WIZARD_SHELL_NAME_EMPTY_MSG);

                                    } else {
                                        Pattern p = Pattern.compile(SHELL_NAME_PATTERN);
                                        Matcher m = p.matcher(shellName);

                                        if(!m.matches()) {
                                            return BXMStatus.createErrorStatus(Messages.BATCH_WIZARD_SHELL_NAME_VALID_MSG);
                                        }

                                        String batchShellScriptPath = BatchConfiguration.BatchJob.getBatchShellScriptPath();
                                        if(project != null) {
                                            IFolder jobFolder= project.getProject().getFolder("META-INF/" + batchShellScriptPath);

                                            if(jobFolder.exists()) {
                                                IResource resource= jobFolder.findMember(shellName + ".sh");

                                                if(resource != null) {
                                                    return BXMStatus.createErrorStatus(Messages.BATCH_WIZARD_EXIST_SHELL_NAME_MSG);
                                                }
                                            }
                                        }
                                    }
                                }

                                return BXMStatus.createOkStatus();
                            }
                        };
                    }
                }