templates.repository.DAOImpl.ftl Maven / Gradle / Ivy

Go to download
<#if header>
/*
 * Copyright (C) 2019 Yadickson Soto
 *
 * This program is free software: you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation, either version 3 of the License, or
 * (at your option) any later version.
 *
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program.  If not, see .
 */

package ${javaPackage}.${repositoryFolderName};
<#assign importList = ["java.util.Map", "java.util.HashMap", "java.sql.SQLException", "org.springframework.stereotype.Repository"]>
<#list proc.parameters as parameter>
<#if parameter.object || parameter.array>
<#assign importConnectionUtils = 1>
<#assign importList = importList + ["java.sql.Connection"]>
<#if utilFolderName != repositoryFolderName>
<#assign importList = importList + ["${javaPackage}.${utilFolderName}.${prefixUtilityName}ConnectionUtil"]>



<#list proc.outputParameters as parameter>
<#if parameter.date>
<#assign importList = importList + ["java.util.Date"]>
<#elseif parameter.clob>
<#assign importClobUtil = 1>
<#if utilFolderName != repositoryFolderName>
<#assign importList = importList + ["${javaPackage}.${utilFolderName}.${prefixUtilityName}ClobUtil"]>

<#elseif parameter.blob>
<#assign importBlobUtil = 1>
<#if utilFolderName != repositoryFolderName>
<#assign importList = importList + ["${javaPackage}.${utilFolderName}.${prefixUtilityName}BlobUtil"]>



<#list proc.arrayImports as parameter>
<#if arrayFolderName != repositoryFolderName>
<#assign importList = importList + ["${javaPackage}.${arrayFolderName}.${parameter.javaTypeName}BuilderUtil"]>


<#list proc.parameters as parameter>
<#if parameter.resultSet || parameter.returnResultSet>
<#if cursorFolderName != repositoryFolderName>
<#assign importList = importList + ["${javaPackage}.${cursorFolderName}.${parameter.javaTypeName}"]>



<#if proc.hasInput && domainFolderName != repositoryFolderName>
<#assign importList = importList + ["${javaPackage}.${domainFolderName}.${proc.className}IN"]>

<#if proc.hasOutput && domainFolderName != repositoryFolderName>
<#assign importList = importList + ["${javaPackage}.${domainFolderName}.${proc.className}OUT", "${javaPackage}.${domainFolderName}.${proc.className}OUTBuilder"]>

<#if !proc.functionInline>
<#assign importList = importList + ["${javaPackage}.${repositoryFolderName}.sp.${proc.className}SP"]>
<#else>
<#assign importList = importList + ["${javaPackage}.${repositoryFolderName}.sp.${proc.className}SqlQuery"]>

<#if proc.checkResult && utilFolderName != repositoryFolderName>
<#assign importList = importList + ["${javaPackage}.${utilFolderName}.${prefixUtilityName}CheckResult"]>

<#list proc.objectImports as parameter>
<#if objectFolderName != repositoryFolderName>
<#assign importList = importList + ["${javaPackage}.${objectFolderName}.${parameter.javaTypeName}BuilderUtil"]>


<#if proc.hasResultSet>
<#assign importList = importList + ["java.util.List"]>

<#if logger>
<#assign importList = importList + ["org.slf4j.Logger", "org.slf4j.LoggerFactory"]>


<#list importSort(importList) as import>
<#if previousImportMatch?? && !import?starts_with(previousImportMatch)>


import ${import};
<#assign previousImportMatch = import?keep_before_last(".") >

<#if importList?has_content>


<#if documentation>
/**
 * DAO implementation for <#if proc.function>function<#else>stored procedure.
 *
 * ${proc.fullName}
 *
 * @author @GENERATOR.NAME@
 * @version @GENERATOR.VERSION@
 */

@Repository
@SuppressWarnings({"unchecked"})
final class ${proc.className}DAOImpl${'\n'}        implements ${proc.className}DAO {

<#if logger>
<#if documentation>
    /**
     * Logger.
     */

    private static final Logger LOGGER${'\n'}            = LoggerFactory.getLogger(${proc.className}DAOImpl.class);


<#if documentation>
    /**
     * <#if proc.function>Function<#else>Stored procedure.
     *
     * ${proc.fullName}
     *
     */

    private final ${proc.className}<#if !proc.functionInline>SP<#else>SqlQuery <#if proc.function>function<#else>procedure;

<#if importConnectionUtils??>
<#if documentation>
    /**
     * The connection util.
     */

    private final ${prefixUtilityName}ConnectionUtil connectionUtil;


<#if importBlobUtil??>
<#if documentation>
    /**
     * Blob utility.
     */

    private final ${prefixUtilityName}BlobUtil blobUtil;


<#if importClobUtil??>
<#if documentation>
    /**
     * Clob utility.
     */

    private final ${prefixUtilityName}ClobUtil clobUtil;


<#list proc.arrayImports as parameter>
<#if documentation>
    /**
     * ${parameter.javaTypeName} builder utility.
     */

    private final ${parameter.javaTypeName}BuilderUtil ${parameter.javaTypeFieldName}BuilderUtil;


<#list proc.objectImports as parameter>
<#if documentation>
    /**
     * ${parameter.javaTypeName} builder utility.
     */

    private final ${parameter.javaTypeName}BuilderUtil ${parameter.javaTypeFieldName}BuilderUtil;


<#if proc.checkResult>
<#if documentation>
    /**
     * Check result utility.
     */

    private final ${prefixUtilityName}CheckResult checkResult;


<#if documentation>
    /**
     * Class constructor.
     *
     * ${proc.className}DAOImpl
     */

    public ${proc.className}DAOImpl(${'\n'}            final ${proc.className}<#if !proc.functionInline>SP<#else>SqlQuery <#if proc.function>function<#else>procedure<#if importConnectionUtils??>,${'\n'}            final ${prefixUtilityName}ConnectionUtil connectionUtil<#if importBlobUtil??>,${'\n'}            final ${prefixUtilityName}BlobUtil blobUtil<#if importClobUtil??>,${'\n'}            final ${prefixUtilityName}ClobUtil clobUtil<#list proc.objectImports as parameter>,${'\n'}            final ${parameter.javaTypeName}BuilderUtil ${parameter.javaTypeFieldName}BuilderUtil<#list proc.arrayImports as parameter>,${'\n'}            final ${parameter.javaTypeName}BuilderUtil ${parameter.javaTypeFieldName}BuilderUtil<#if proc.checkResult>,${'\n'}            final ${prefixUtilityName}CheckResult checkResult${'\n'}    ) {
        this.<#if proc.function>function<#else>procedure = <#if proc.function>function<#else>procedure;
<#if importConnectionUtils??>
        this.connectionUtil = connectionUtil;

<#if importBlobUtil??>
        this.blobUtil = blobUtil;

<#if importClobUtil??>
        this.clobUtil = clobUtil;

<#list proc.objectImports as parameter>
        this.${parameter.javaTypeFieldName}BuilderUtil = ${parameter.javaTypeFieldName}BuilderUtil;

<#list proc.arrayImports as parameter>
        this.${parameter.javaTypeFieldName}BuilderUtil = ${parameter.javaTypeFieldName}BuilderUtil;

<#if proc.checkResult>
        this.checkResult = checkResult;

    }

<#if documentation>
    /**
     * Execute <#if proc.function>function<#else>stored procedure.
     *
     * ${proc.fullName}
     *
<#if proc.hasInput>
     * @param params input parameters

<#if proc.hasOutput>
     * @return output parameters

     * @throws SQLException if error.
     */

    @Override
    public <#if proc.hasOutput>${proc.className}OUT<#else>void execute(<#if proc.hasInput>${'\n'}            final ${proc.className}IN params${'\n'}    ) throws SQLException {

        Map in${proc.className} = new HashMap<<#if !diamond>String, Object>();
<#if proc.hasOutput>
        Map out${proc.className};

<#if importConnectionUtils??>

        Connection connection = null;


        try {
<#if importConnectionUtils??>

            connection = connectionUtil.process();

<#list proc.inputParameters as parameter>
<#if parameter.array || parameter.object>
            Object ${parameter.fieldName};


<#list proc.inputParameters as parameter>
<#if parameter.object || parameter.array>

            ${parameter.fieldName} = ${parameter.javaTypeFieldName}BuilderUtil.process(
                    connection,
                    params.get${parameter.propertyName}()
            );




<#list proc.inputParameters as parameter>
<#if parameter.array || parameter.object>
            in${proc.className}.put("${parameter.prefix}${parameter.name}",
                    ${parameter.fieldName}
            );
<#else>
            in${proc.className}.put("${parameter.prefix}${parameter.name}",
                    params.get${parameter.propertyName}()
            );


<#if proc.hasInput>


            <#if proc.hasOutput>out${proc.className} = <#if proc.function>function<#else>procedure.execute(in${proc.className});

        } catch (Exception ex) {
<#if logger>
            LOGGER.error(ex.getMessage(), ex);

            throw new SQLException(ex.getMessage(), "${successCode}", ex);
<#if importConnectionUtils??> 
        } finally {
            connectionUtil.release(connection);
        }
<#else>
        }

<#if proc.hasOutput>
<#if proc.checkResult>

        checkResult.check(out${proc.className});


<#list proc.outputParameters as parameter>
<#if parameter.resultSet || parameter.returnResultSet>
        List<${parameter.javaTypeName}> ${parameter.fieldName}${proc.className};
<#else>
        ${parameter.javaTypeName} ${parameter.fieldName}${proc.className};



<#list proc.outputParameters as parameter>
<#if parameter.resultSet || parameter.returnResultSet>
        ${parameter.fieldName}${proc.className} = (List) out${proc.className}.get("${parameter.prefix}${parameter.name}");
<#elseif parameter.clob>
        ${parameter.fieldName}${proc.className} = clobUtil.process(out${proc.className}.get("${parameter.prefix}${parameter.name}"));
<#elseif parameter.blob>
        ${parameter.fieldName}${proc.className} = blobUtil.process(out${proc.className}.get("${parameter.prefix}${parameter.name}"));
<#else>
        ${parameter.fieldName}${proc.className} = (${parameter.javaTypeName}) out${proc.className}.get("${parameter.prefix}${parameter.name}");



        return new ${proc.className}OUTBuilder()<#list proc.outputParameters as parameter>${'\n'}            .${parameter.fieldName}(${parameter.fieldName}${proc.className})${'\n'}            .build();

    }

}