Start line:  
End line:  

Snippet Preview

Snippet HTML Code

Stack Overflow Questions
  package org.jbpm.services.task.persistence;
  
  
  import static org.kie.internal.query.QueryParameterIdentifiers.*;
  import static org.jbpm.services.task.persistence.TaskQueryManager.*;
  
  import java.util.HashMap;
  import java.util.List;
  import java.util.Map;
 
 import  javax.persistence.EntityExistsException;
 import  javax.persistence.EntityManager;
 import  javax.persistence.FlushModeType;
 import  javax.persistence.LockModeType;
 import  javax.persistence.Query;
 
 import  org.drools.core.util.StringUtils;
 import  org.kie.api.task.model.Attachment;
 import  org.kie.api.task.model.Comment;
 import  org.kie.api.task.model.Content;
 import  org.kie.api.task.model.Group;
 import  org.kie.api.task.model.OrganizationalEntity;
 import  org.kie.api.task.model.Task;
 import  org.kie.api.task.model.User;
 import  org.kie.internal.query.QueryParameterIdentifiers;
 import  org.kie.internal.task.api.TaskPersistenceContext;
 import  org.kie.internal.task.api.model.Deadline;
 import  org.slf4j.Logger;
 import  org.slf4j.LoggerFactory;
 
 public class JPATaskPersistenceContext implements TaskPersistenceContext {
 
     // logger set to public for test reasons, see the org.jbpm.services.task.TaskQueryBuilderLocalTest
 	public final static Logger logger = LoggerFactory.getLogger(JPATaskPersistenceContext.class);
 	
 	private static TaskQueryManager querymanager = TaskQueryManager.get();
 	
 	protected EntityManager em;
     protected final boolean isJTA;
     protected final boolean pessimisticLocking;
     
     public JPATaskPersistenceContext(EntityManager em) {
         this(emtruefalse);
     }
     
     public JPATaskPersistenceContext(EntityManager emboolean isJTA) {
        this(emisJTAfalse); 
     }
     
     public JPATaskPersistenceContext(EntityManager emboolean isJTAboolean locking) {
         this. = em;
         this. = isJTA;
         this. = locking;
         
         .debug("TaskPersistenceManager configured with em {}, isJTA {}, pessimistic locking {}"emisJTAlocking);
     }	
 	
 	public Task findTask(Long taskId) {
 		check();
 		Task task = null;
 		ifthis. ) { 
 			task = this..find( TaskImpl.classtaskId, LockModeType.PESSIMISTIC_FORCE_INCREMENT );
         }
 		task = this..find( TaskImpl.classtaskId );
 		return task;
 	}
 
 	public Task persistTask(Task task) {
 		check();
 		this..persist( task );
         ifthis. ) { 
             return this..find(TaskImpl.classtask.getId(), LockModeType.PESSIMISTIC_FORCE_INCREMENT );
         }
         return task;
 	}
 
 	public Task updateTask(Task task) {
 		check();
 		return this..merge(task);
 	}
 
 	public Task removeTask(Task task) {
 		check();
 		.remove( task );
 		
		return task;
	}
	public Group findGroup(String groupId) {
		ifthis. ) { 
            return this..find( GroupImpl.classgroupId, LockModeType.PESSIMISTIC_FORCE_INCREMENT );
        }
        return this..find( GroupImpl.classgroupId );
	}
	public Group persistGroup(Group group) {
		try {
			this..persist( group );
	        ifthis. ) { 
	            return this..find(GroupImpl.classgroup.getId(), LockModeType.PESSIMISTIC_FORCE_INCREMENT );
	        }
catch (EntityExistsException e) {
    		throw new RuntimeException("Group already exists with " + group 
    				+ " id, please check that there is no group and user with same id");
    	}
        return group;
	}
	public Group updateGroup(Group group) {
		return this..merge(group);
	}
	public Group removeGroup(Group group) {
		.remove( group );
		return group;
	}
	public User findUser(String userId) {
		ifthis. ) { 
            return this..find( UserImpl.classuserId, LockModeType.PESSIMISTIC_FORCE_INCREMENT );
        }
        return this..find( UserImpl.classuserId );
	}
	public User persistUser(User user) {
		try {
			this..persist( user );
	        ifthis. ) { 
	            return this..find(UserImpl.classuser.getId(), LockModeType.PESSIMISTIC_FORCE_INCREMENT );
	        }
catch (EntityExistsException e) {
    		throw new RuntimeException("User already exists with " + user 
    				+ " id, please check that there is no group and user with same id");
    	}
        return user;
	}
	public User updateUser(User user) {
		return this..merge(user);
	}
	public User removeUser(User user) {
		.remove( user );
		return user;
	}
	public OrganizationalEntity findOrgEntity(String orgEntityId) {
		ifthis. ) { 
            return this..find( OrganizationalEntityImpl.classorgEntityId, LockModeType.PESSIMISTIC_FORCE_INCREMENT );
        }
        return this..find( OrganizationalEntityImpl.classorgEntityId );
	}
	public OrganizationalEntity persistOrgEntity(OrganizationalEntity orgEntity) {
	    	
        if (!StringUtils.isEmpty(orgEntity.getId())) {
        	try {
	        	this..persist( orgEntity );
	            ifthis. ) { 
	                return this..find(OrganizationalEntityImpl.classorgEntity.getId(), LockModeType.PESSIMISTIC_FORCE_INCREMENT );
	            }
        	} catch (EntityExistsException e) {
        		throw new RuntimeException("Organizational entity already exists with " + orgEntity 
        				+ " id, please check that there is no group and user with same id");
        	}
        } 
        return orgEntity;
	}
	public OrganizationalEntity updateOrgEntity(OrganizationalEntity orgEntity) {
		return this..merge(orgEntity);
	}
	public OrganizationalEntity removeOrgEntity(OrganizationalEntity orgEntity) {
		.remove( orgEntity );
		return orgEntity;
	}
	public Content findContent(Long contentId) {
		ifthis. ) { 
            return this..find( ContentImpl.classcontentId, LockModeType.PESSIMISTIC_FORCE_INCREMENT );
        }
        return this..find( ContentImpl.classcontentId );
	}
	public Content persistContent(Content content) {
		this..persist( content );
        ifthis. ) { 
            return this..find(ContentImpl.classcontent.getId(), LockModeType.PESSIMISTIC_FORCE_INCREMENT );
        }
        return content;
	}
	public Content updateContent(Content content) {
		return this..merge(content);
	}
	public Content removeContent(Content content) {
		.remove( content );
		return content;
	}
	public Attachment findAttachment(Long attachmentId) {
		ifthis. ) { 
            return this..find( AttachmentImpl.classattachmentId, LockModeType.PESSIMISTIC_FORCE_INCREMENT );
        }
        return this..find( AttachmentImpl.classattachmentId );
	}
	public Attachment persistAttachment(Attachment attachment) {
		this..persist( attachment );
        ifthis. ) { 
            return this..find(AttachmentImpl.classattachment.getId(), LockModeType.PESSIMISTIC_FORCE_INCREMENT );
        }
        return attachment;
	}
	public Attachment updateAttachment(Attachment attachment) {
		return this..merge(attachment);
	}
	public Attachment removeAttachment(Attachment attachment) {
		.remove( attachment );
		return attachment;
	}
	public Comment findComment(Long commentId) {
		ifthis. ) { 
            return this..find( CommentImpl.classcommentId, LockModeType.PESSIMISTIC_FORCE_INCREMENT );
        }
        return this..find( CommentImpl.classcommentId );
	}
	public Comment persistComment(Comment comment) {
		this..persist( comment );
        ifthis. ) { 
            return this..find(CommentImpl.classcomment.getId(), LockModeType.PESSIMISTIC_FORCE_INCREMENT );
        }
        return comment;
	}
	public Comment updateComment(Comment comment) {
		return this..merge(comment);
	}
	public Comment removeComment(Comment comment) {
		.remove( comment );
		return comment;
	}
	public Deadline findDeadline(Long deadlineId) {
		ifthis. ) { 
            return this..find( DeadlineImpl.classdeadlineId, LockModeType.PESSIMISTIC_FORCE_INCREMENT );
        }
        return this..find( DeadlineImpl.classdeadlineId );
	}
	public Deadline persistDeadline(Deadline deadline) {
		this..persist( deadline );
        ifthis. ) { 
            return this..find(DeadlineImpl.classdeadline.getId(), LockModeType.PESSIMISTIC_FORCE_INCREMENT );
        }
        return deadline;
	}
	public Deadline updateDeadline(Deadline deadline) {	
		return this..merge(deadline);
	}
	public Deadline removeDeadline(Deadline deadline) {
		.remove( deadline );
		return deadline;
	}
	public <T> T queryWithParametersInTransaction(String queryName,
			Map<StringObjectparamsClass<T> clazz) {
		Query query = getQueryByName(queryNameparams);
		return queryStringWithParameters(paramsfalse, LockModeType.NONE, clazzquery);
	}
        @Override
	public <T> T queryWithParametersInTransaction(String queryNameboolean singleResult,
			Map<StringObjectparamsClass<T> clazz) {
		Query query = getQueryByName(queryNameparams);
		return queryStringWithParameters(paramssingleResult, LockModeType.NONE, clazzquery);
	}
        
			Map<StringObjectparamsboolean singleResultClass<T> clazz) {
		Query query = getQueryByName(queryNameparams);
		return queryStringWithParameters(paramssingleResult, LockModeType.NONE, clazzquery);
	}
	public <T> T queryInTransaction(String queryNameClass<T> clazz) {
		Query query = this..createNamedQuery(queryName);
		return (T) query.getResultList();
	}
	public <T> T queryStringInTransaction(String queryStringClass<T> clazz) {
		Query query = this..createQuery(queryString);
		return (T) query.getResultList();
	}
	public <T> T queryStringWithParametersInTransaction(String queryString,
			Map<StringObjectparamsClass<T> clazz) {
		String newQueryString = adaptQueryString(new StringBuilder(queryString), params);
		ifnewQueryString != null ) { 
		    queryString = newQueryString;
		}
		// logging
		.debug("QUERY:\n {}"queryString);
		if.isDebugEnabled() ) {
		    StringBuilder paramsStr = new StringBuilder("PARAMS:");
		    Map<StringObjectorderedParams = new TreeMap<StringObject>(params);
		    forEntry<StringObjectentry : orderedParams.entrySet() ) { 
		        paramsStr.append("\n " + entry.getKey() + " : '" + entry.getValue() + "'");
		    }
		    .debug(paramsStr.toString());
		}
		Query query = this..createQuery(queryString);
		return queryStringWithParameters(paramsfalse, LockModeType.NONE, clazzquery);
	}
	public <T> T queryStringWithParametersInTransaction(String queryStringboolean singleResult,
			Map<StringObjectparamsClass<T> clazz) {
		Query query = this..createQuery(queryString);
		return queryStringWithParameters(paramssingleResult, LockModeType.NONE, clazzquery);
	}
			String queryNameMap<StringObjectparamsboolean singleResult,
			Class<T> clazz) {
		Query query = getQueryByName(queryNameparams);
		return queryStringWithParameters(paramssingleResult, LockModeType.PESSIMISTIC_FORCE_INCREMENT, clazzquery);	
	}
	public int executeUpdateString(String updateString) {
		Query query = this..createQuery(updateString);
		return query.executeUpdate();
	}
	public HashMap<StringObjectaddParametersToMap(Object... parameterValues) {
		HashMap<StringObjectparameters = new HashMap<StringObject>();
        
        ifparameterValues.length % 2 != 0 ) { 
            throw new RuntimeException("Expected an even number of parameters, not " + parameterValues.length);
        }
        
        forint i = 0; i < parameterValues.length; ++i ) {
            String parameterName = null;
            ifparameterValues[iinstanceof String ) { 
                parameterName = (StringparameterValues[i];
            } else { 
                throw new RuntimeException("Expected a String as the parameter name, not a " + parameterValues[i].getClass().getSimpleName());
            }
            ++i;
            parameters.put(parameterNameparameterValues[i]);
        }
        
        return parameters;
	}
	public <T> T persist(T object) {
		this..persist( object );        
        return object;
	}
	public <T> T find(Class<T> entityClassObject primaryKey) {
		ifthis. ) { 
            return this..find( entityClassprimaryKey, LockModeType.PESSIMISTIC_FORCE_INCREMENT );
        }
        return this..find( entityClassprimaryKey );
	}
	public <T> T remove(T entity) {
		.remove( entity );
		return entity;
	}
	public <T> T merge(T entity) {
		return this..merge(entity);
	}
	private <T> T queryStringWithParameters(Map<StringObjectparamsboolean singleResult, LockModeType lockMode,
			Class<T> clazz, Query query) {
		;
		if (lockMode != null) {
			query.setLockMode(lockMode);
		}
		if (params != null && !params.isEmpty()) {
			for (Entry<String,ObjectparamEntry : params.entrySet()) {
			    String name = paramEntry.getKey();
				if (FIRST_RESULT.equals(name)) {
					query.setFirstResult((IntegerparamEntry.getValue());
					continue;
else if (MAX_RESULTS.equals(name)) {
					query.setMaxResults((IntegerparamEntry.getValue());
					continue;
else if (FLUSH_MODE.equals(name)) {
					query.setFlushMode(FlushModeType.valueOf((StringparamEntry.getValue()));
					continue;
				// skip control parameters
				else if ( ORDER_TYPE.equals(name)
				        || ORDER_BY.equals(name)
						|| FILTER.equals(name)) {
					continue;
				}
				query.setParameter(nameparams.get(name));
			}
		}
		if (singleResult) {
                    List<T> results = query.getResultList();
                    return (T) ((results.isEmpty() )? null : results.get(0));
		}
		return (T) query.getResultList();
	}
	public boolean isOpen() {
		if (this. == null) {
			return false;
		}
		return this..isOpen();
	}
	public void joinTransaction() {
		if (this. == null) {
			return;
		}
		if (this.) {
			this..joinTransaction();
		}
	}
	public void close() {
		this..close();
	}
	protected void check() {
		if ( == null || !.isOpen()) {
			throw new IllegalStateException("Entity manager is null or is closed, exiting...");
		}
	}
	protected Query getQueryByName(String queryNameMap<StringObjectparams) {
		String queryStr = .getQuery(queryNameparams);
		Query query = null;
		if (queryStr != null) {
			query = this..createQuery(queryStr);
else {
			query = this..createNamedQuery(queryName);
		}
		return query;
	}
New to GrepCode? Check out our FAQ X