mplates.1.2.source-code.PojoServiceBase.ftl Maven / Gradle / Ivy

<#include "license.ftl">
<@license/>
<#assign object = doc.object>
package ${object.@package}.service.base;

import org.jetbrains.annotations.NotNull;
import org.jetbrains.annotations.Nullable;
import com.mysql.jdbc.exceptions.jdbc4.MySQLIntegrityConstraintViolationException;
<#assign stream = "false">
<#list doc["/object/attributes/*"] as att>
    <#if att?node_name == "html">
        <#assign stream = "true">
    <#elseif att?node_name == "string" && att.@maxlength[0]?number > 65000>
        <#assign stream = "true">
    

<#if stream == "true">
import java.io.IOException;
import java.sql.PreparedStatement;

import java.sql.ResultSet;
import java.sql.SQLException;
<#if stream == "true">
import java.sql.Timestamp;

import java.util.ArrayList;
import java.util.Collection;
import java.util.Date;
import java.util.HashSet;
import java.util.List;
import java.util.Map;
import java.util.Set;
import java.util.logging.Logger;
import redora.api.Persistable;
import redora.api.fetch.*;
import redora.exceptions.*;
import redora.service.*;
import ${object.@package}.model.*;
import ${object.@package}.model.fields.*;
import ${object.@package}.service.*;

<#list doc["/object/attributes/enum[@scope='global']"] as att>
import ${object.@package}.model.enums.${att.@class};

<#if object.trashcan == "true">
import redora.configuration.rdo.service.TrashService;


import static ${object.@package}.sql.${object.@name}SQL.*;
import static ${object.@package}.businessrules.${object.@name}BusinessRules.check;
import static java.util.logging.Level.FINE;
import static java.util.logging.Level.SEVERE;
import static redora.db.SQLParameter.*;

/**
* You can work with the pojo's using this service. For example if you create command line J2SE functionality
* or server side logic.

* If you want to use your data in a web application, you also might want to look at {@link ${object.@name}ServiceJSON}
* and {@link ${object.@package}.service.http.${object.@name}Servlet}.

* Whenever business rule logic needs to be checked, it will go through here. For example a web user wants to persist
* some data. He will post this for example as JSON to {@link ${object.@package}.service.http.${object.@name}Servlet}
* which in turn invokes {@link ${object.@name}ServiceJSON} which will serialize the JSON stream into a pojo
* and then will invoke the persist method of this service.
* @author Redora (www.redora.net)
*/
public class ${object.@name}ServiceBase extends ServiceBase {

    static final transient Logger l = Logger.getLogger("${object.@package}.service.${object.@name}Service");

    /**
    * Don't use this directly but use the ServiceFactory instead:
    * 
    * ${object.@name}Service() myService = ServiceFactory.${object.@name?uncap_first}();
    * ... do stuff
    * ServiceFactory.close(myService);
    * 
    * Initializes ${object.@name}Service.
    * @see ${object.@package}.service.ServiceFactory
    */

    protected ${object.@name}ServiceBase() throws ConnectException {
        super("${object.schema[0]!"default"}");
    }

    /**
    * Chains this service object to another service object. The database connection
    * and transaction is managed by the other service.
    * @param chain (Mandatory) Service you want to make this service dependent on.
    */
    protected ${object.@name}ServiceBase(@NotNull ServiceBase chain) {
        super(chain, "${object.schema[0]!"default"}");
        inTransaction = true; //Let the calling service handle the transaction
    }

    /**
    * Simple finder to get ${object.@name} by it's id.
    * @param id (Mandatory) The primary key.
    * @param scope (Mandatory) The allowed fetch scope: Scope.Table, Scope.Form, Scope.List.
    * @return The desired ${object.@name}
    * @throws ObjectNotFoundException When there is no object in the DB with this Id.
    */
    @NotNull
    public ${object.@name} findById(@NotNull Long id, @NotNull Scope scope)
            throws QueryException, CopyException, ObjectNotFoundException {
        ${object.@name} retVal = null;
        String SQL;
        switch (scope) {
            case Table:
                SQL = FIND_BY_ID_TABLE;
                break;
            case Form:
                SQL = FIND_BY_ID_FORM;
                break;
            case List:
                SQL = FIND_BY_ID_LIST;
                break;
            default:
                throw new IllegalArgumentException("Illegal scope for this finder: " + scope);
        }
        SQL = prepare(SQL, id);

        ResultSet rs = null;
        try {
            rs = sqlQuery(SQL);
            if (rs.next()) {
                retVal = new ${object.@name}(rs, 0, scope);
            } else {
                throw new ObjectNotFoundException("Could not find ${object.@name} " + id);
            }
        } catch(SQLException e) {
            l.log(SEVERE, "Failed to run query " + SQL, e);
            throw new QueryException("Failed to run query: " + SQL, e);
        } finally {
            close(rs);
        }
        return retVal;
    }

    /**
    * Finds records by custom SQL. Custom queries should be defined in the queries section in the model.
    * @param sql (Mandatory) The SQL statement you wish to use. See also ${object.@name}SQL.
    * @param params (Optional) List of parameters. When omitted it is assumed there are no parameters.
    * @param page (Mandatory) The Page strategy. Allowed scopes are: Scope.Table, Scope.Form, Scope.List, Scope.Lazy.
    * @return Empty or filled list with ${object.@name}
    */
    @NotNull
    public List<${object.@name}> find(@NotNull String sql, @Nullable List