Many resources are needed to download a project. Please understand that we have to compensate our server costs. Thank you in advance. Project price only 1 $
You can buy this project and download/modify it how often you want.
/**
* Copyright (C) 2015 BonitaSoft S.A.
* BonitaSoft, 32 rue Gustave Eiffel - 38000 Grenoble
* This library is free software; you can redistribute it and/or modify it under the terms
* of the GNU Lesser General Public License as published by the Free Software Foundation
* version 2.1 of the License.
* This library 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 Lesser General Public License for more details.
* You should have received a copy of the GNU Lesser General Public License along with this
* program; if not, write to the Free Software Foundation, Inc., 51 Franklin Street, Fifth
* Floor, Boston, MA 02110-1301, USA.
**/package org.bonitasoft.engine.persistence;
import java.util.Collections;
import java.util.HashSet;
import java.util.List;
import java.util.Map;
import java.util.Set;
import java.util.SortedSet;
import java.util.TreeSet;
import javax.sql.DataSource;
import org.bonitasoft.engine.commons.ClassReflector;
import org.bonitasoft.engine.log.technical.TechnicalLogSeverity;
import org.bonitasoft.engine.log.technical.TechnicalLoggerService;
import org.bonitasoft.engine.sequence.SequenceManager;
import org.bonitasoft.engine.services.SPersistenceException;
import org.bonitasoft.engine.services.TenantPersistenceService;
import org.bonitasoft.engine.sessionaccessor.STenantIdNotSetException;
/**
* Common implementation to persistence services relying on a database
*
* @author Elias Ricken de Medeiros
* @author Baptiste Mesta
* @author Celine Souchet
* @author Matthieu Chaffotte
*/publicabstractclassAbstractDBPersistenceServiceimplementsTenantPersistenceService{
privatefinal String likeEscapeCharacter;
privatefinal String name;
privatefinal SequenceManager sequenceManager;
protectedfinal DataSource datasource;
privatefinal Set> wordSearchExclusionMappings = new HashSet>();
privatefinalboolean enableWordSearch;
protectedfinal TechnicalLoggerService logger;
publicAbstractDBPersistenceService(final String name, final String likeEscapeCharacter,
finalboolean enableWordSearch, final Set wordSearchExclusionMappings, final TechnicalLoggerService logger)throws ClassNotFoundException {
this.name = name;
sequenceManager = null;
datasource = null;
this.likeEscapeCharacter = likeEscapeCharacter;
this.enableWordSearch = enableWordSearch;
if (wordSearchExclusionMappings != null) {
for (final String wordSearchExclusionMapping : wordSearchExclusionMappings) {
final Class clazz = Class.forName(wordSearchExclusionMapping);
if (!PersistentObject.class.isAssignableFrom(clazz)) {
thrownew RuntimeException("Unable to add a word search exclusion mapping for class " + clazz + " because it does not implements "
+ PersistentObject.class);
}
this.wordSearchExclusionMappings.add((Class) clazz);
}
}
this.logger = logger;
}
publicAbstractDBPersistenceService(final String name,
final String likeEscapeCharacter, final SequenceManager sequenceManager, final DataSource datasource,
finalboolean enableWordSearch, final Set wordSearchExclusionMappings, final TechnicalLoggerService logger)throws ClassNotFoundException {
this.name = name;
this.sequenceManager = sequenceManager;
this.datasource = datasource;
this.likeEscapeCharacter = likeEscapeCharacter;
this.enableWordSearch = enableWordSearch;
this.logger = logger;
if (enableWordSearch && logger.isLoggable(getClass(), TechnicalLogSeverity.WARNING)) {
logger.log(getClass(), TechnicalLogSeverity.WARNING,
"The word based search feature is experimental, using it in production may impact performances.");
}
if (wordSearchExclusionMappings != null && !wordSearchExclusionMappings.isEmpty()) {
if (!enableWordSearch && logger.isLoggable(getClass(), TechnicalLogSeverity.INFO)) {
logger.log(getClass(), TechnicalLogSeverity.INFO, "You defined an exclusion mapping for the word based search feature, but it is not enabled.");
}
for (final String wordSearchExclusionMapping : wordSearchExclusionMappings) {
final Class clazz = Class.forName(wordSearchExclusionMapping);
if (!PersistentObject.class.isAssignableFrom(clazz)) {
thrownew RuntimeException("Unable to add a word search exclusion mapping for class " + clazz + " because it does not implements "
+ PersistentObject.class);
}
this.wordSearchExclusionMappings.add((Class) clazz);
}
}
}
@Overridepublic String getName(){
return name;
}
protectedbooleanisWordSearchEnabled(final Class entityClass){
if (!enableWordSearch || entityClass == null) {
returnfalse;
}
for (final Class exclusion : wordSearchExclusionMappings) {
if (exclusion.isAssignableFrom(entityClass)) {
returnfalse;
}
}
returntrue;
}
@OverridepubliclonggetNumberOfEntities(final Class entityClass, final QueryOptions options, final Map parameters)throws SBonitaReadException {
return getNumberOfEntities(entityClass, null, options, parameters);
}
@OverridepubliclonggetNumberOfEntities(final Class entityClass, final String querySuffix, final QueryOptions options,
final Map parameters)throws SBonitaReadException {
List filters;
if (options == null) {
filters = Collections.emptyList();
} else {
filters = options.getFilters();
}
final String queryName = getQueryName("getNumberOf", querySuffix, entityClass, filters);
final SelectListDescriptor descriptor = new SelectListDescriptor(queryName, parameters, entityClass, Long.class, options);
return selectList(descriptor).get(0);
}
@Overridepublic ListsearchEntity(final Class entityClass, final QueryOptions options, final Map parameters)throws SBonitaReadException {
return searchEntity(entityClass, null, options, parameters);
}
@Overridepublic ListsearchEntity(final Class entityClass, final String querySuffix, final QueryOptions options,
final Map parameters)throws SBonitaReadException {
final String queryName = getQueryName("search", querySuffix, entityClass, options.getFilters());
final SelectListDescriptor descriptor = new SelectListDescriptor(queryName, parameters, entityClass, options);
return selectList(descriptor);
}
private String getQueryName(final String prefix, final String suffix, final Class entityClass,
final List filters){
final SortedSet query = new TreeSet();
for (final FilterOption filter : filters) {
// if filter is just an operator, PersistentClass is not defined:if (filter.getPersistentClass() != null) {
query.add(filter.getPersistentClass().getSimpleName());
}
}
final String searchOnClassName = entityClass.getSimpleName();
query.remove(searchOnClassName);
final StringBuilder builder = new StringBuilder(prefix);
builder.append(searchOnClassName);
if (!query.isEmpty()) {
builder.append("with");
}
for (final String entity : query) {
builder.append(entity);
}
if (suffix != null) {
builder.append(suffix);
}
return builder.toString();
}
/**
* @return
* @throws STenantIdNotSetException
*/protectedabstractlonggetTenantId()throws STenantIdNotSetException;
protected SequenceManager getSequenceManager(){
return sequenceManager;
}
protectedvoidsetId(final PersistentObject entity)throws SPersistenceException {
if (entity == null) {
return;
}
// if this entity has no id, set it
Long id = null;
try {
id = entity.getId();
} catch (final Exception e) {
// this is a new object to save
}
if (id == null || id == -1 || id == 0) {
try {
id = getSequenceManager().getNextId(entity.getClass().getName(), getTenantId());
ClassReflector.invokeSetter(entity, "setId", long.class, id);
} catch (final Exception e) {
thrownew SPersistenceException("Problem while saving entity: " + entity + " with id: " + id, e);
}
}
}
/**
* Get like clause for given term with escaped sql query wildcards and escape character
*/protected String buildLikeEscapeClause(final String term, final String prefixPattern, final String suffixPattern){
return" LIKE '" + (prefixPattern != null ? prefixPattern : "") + escapeTerm(term) + (suffixPattern != null ? suffixPattern : "") + "' ESCAPE '"
+ getLikeEscapeCharacter() + "'";
}
/*
* escape for like
*/protected String escapeTerm(final String term){
// 1) escape ' character by adding another ' character// 2) protect escape character if this character is used in data// 3) escape % character (sql query wildcard) by adding escape character// 4) escape _ character (sql query wildcard) by adding escape characterreturn term
.replaceAll("'", "''")
.replaceAll(getLikeEscapeCharacter(), getLikeEscapeCharacter() + getLikeEscapeCharacter())
.replaceAll("%", getLikeEscapeCharacter() + "%")
.replaceAll("_", getLikeEscapeCharacter() + "_");
}
/*
* escape for other things than like
*/protected String escapeString(final String term){
// 1) escape ' character by adding another ' characterreturn term
.replaceAll("'", "''");
}
protected String getLikeEscapeCharacter(){
return likeEscapeCharacter;
}
}