Java Code Examples for org.hibernate.Query#setBoolean()

@SuppressWarnings("unchecked")
public List<DomainName> getAllDomainNames(boolean includeDisabledOrgs)
        throws DbException { 

    try {

        Query query = null;
        if (includeDisabledOrgs) {
            query = session.createQuery("from DomainName");
        }
        else {
            query = session.createQuery("from DomainName where OrganizationId in (from Organization where Enabled = ?)");
            query.setBoolean(0, true);
        }
        return query.list();
    } 
    catch (Exception e) {
        throw handleException(e.getClass().getSimpleName() + " exception in getAllDomainNames", e);
    }

}
 

public int getActualNumberRetake(final Long publishedAssessmentId, final String agentIdString) {

        final HibernateCallback<List<Long>> hcb = session -> {
            Query q = session.createQuery(
                    "select count(*) from AssessmentGradingData a, StudentGradingSummaryData s " +
                            " where a.publishedAssessmentId = :id and a.agentId = :agent and a.forGrade = :forgrade " +
                            " and a.publishedAssessmentId = s.publishedAssessmentId and a.agentId = s.agentId " +
                            " and a.submittedDate > s.createdDate and a.status > :status");
            q.setLong("id", publishedAssessmentId);
            q.setString("agent", agentIdString);
            q.setBoolean("forgrade", true);
            q.setInteger("status", AssessmentGradingData.REMOVED);
            return q.list();
        };
        List<Long> countList = getHibernateTemplate().execute(hcb);
        if (countList != null && !countList.isEmpty()) {
            return Math.toIntExact(countList.get(0));
        }
        return 0;
    }
 

/**
	 * {@inheritDoc}
	 */
@Override
public List<String> getRequestedConnectionUserIdsForUser(final String userId) {
			
	//get friends of this user [and map it automatically to the Friend object]
	//updated: now just returns a List of Strings
	final HibernateCallback<List<String>> hcb = session -> {
           final Query q = session.getNamedQuery(QUERY_GET_FRIEND_REQUESTS_FOR_USER);
           q.setParameter(USER_UUID, userId, StringType.INSTANCE);
           q.setBoolean("false", Boolean.FALSE);
           //q.setResultTransformer(Transformers.aliasToBean(Friend.class));

           return q.list();
       };
  	
  	return getHibernateTemplate().execute(hcb);
}
 

@Override
public BIObjDataSet getObjectDetailDataset(Integer objectId, Session currSession) throws EMFUserError {
	logger.debug("IN");

	BIObjDataSet aBIObjectDataSet = null;
	String hql = "from SbiObjDataSet s where s.sbiObject.biobjId = " + objectId + " AND isDetail = ? ";
	Query hqlQuery = currSession.createQuery(hql);
	hqlQuery.setBoolean(0, true);
	SbiObjDataSet hibDs = (SbiObjDataSet) hqlQuery.uniqueResult();

	if (hibDs != null) {
		aBIObjectDataSet = toBIObjDataSet(hibDs);
	}

	logger.debug("OUT");

	return aBIObjectDataSet;
}
 

public Map<Long, Integer> getActualNumberRetakeHash(final String agentIdString) {
    Map<Long, Integer> actualNumberRetakeHash = new HashMap<>();
    final HibernateCallback<List<Object[]>> hcb = session -> {
        Query q = session.createQuery(
                "select a.publishedAssessmentId, count(*) from AssessmentGradingData a, StudentGradingSummaryData s " +
                        " where a.agentId = :agent and a.forGrade = :forgrade " +
                        " and a.publishedAssessmentId = s.publishedAssessmentId and a.agentId = s.agentId " +
                        " and a.submittedDate > s.createdDate and a.status > :status" +
                        " group by a.publishedAssessmentId");
        q.setString("agent", agentIdString);
        q.setBoolean("forgrade", true);
        q.setInteger("status", AssessmentGradingData.REMOVED);
        return q.list();
    };
    List<Object[]> countList = getHibernateTemplate().execute(hcb);
    for (Object[] o : countList) {
        Long l = (Long) o[1];
        actualNumberRetakeHash.put((Long) o[0], l.intValue());
    }
    return actualNumberRetakeHash;
}
 

/**
 * Find by content and name
 */
public Css findByContextAndName(String context, String name) throws DatabaseException {
	log.debug("findByContextAndName({},{})", context, name);
	String qs = "from Css c where c.context=:context and c.name=:name and c.active=:active";
	Session session = null;

	try {
		session = HibernateUtil.getSessionFactory().openSession();
		Query q = session.createQuery(qs);
		q.setString("context", context);
		q.setString("name", name);
		q.setBoolean("active", true);
		Css ret = (Css) q.setMaxResults(1).uniqueResult();
		log.debug("findByContextAndName: {}", ret);
		return ret;
	} catch (HibernateException e) {
		throw new DatabaseException(e.getMessage(), e);
	} finally {
		HibernateUtil.close(session);
	}
}
 

public int getLateSubmissionsNumberByAgentId(final Long publishedAssessmentId, final String agentIdString, final Date dueDate) {
    final HibernateCallback<List<AssessmentGradingData>> hcb = session -> {
        Query q = session.createQuery(
                "from AssessmentGradingData a where a.publishedAssessmentId = :id and a.agentId = :agent and a.forGrade = :forgrade and a.submittedDate > :submitted and a.status > :status");
        q.setLong("id", publishedAssessmentId);
        q.setString("agent", agentIdString);
        q.setBoolean("forgrade", true);
        q.setDate("submitted", dueDate);
        q.setInteger("status", AssessmentGradingData.REMOVED);
        return q.list();
    };
    List<AssessmentGradingData> assessmentGradings = getHibernateTemplate().execute(hcb);

    return assessmentGradings.size();
}
 

public Double getAverageSubmittedAssessmentGrading(final Long publishedAssessmentId, final String agentId) {
    Double averageScore = 0.0;
    AssessmentGradingData ag = null;

    final HibernateCallback<List<AssessmentGradingData>> hcb = session -> {
        Query q = session.createQuery(
                "from AssessmentGradingData a where a.publishedAssessmentId = :id and a.agentId = :agent and a.forGrade = :forgrade and a.status > :status order by  a.submittedDate desc");
        q.setLong("id", publishedAssessmentId);
        q.setString("agent", agentId);
        q.setBoolean("forgrade", true);
        q.setInteger("status", AssessmentGradingData.REMOVED);
        return q.list();
    };
    List<AssessmentGradingData> assessmentGradings = getHibernateTemplate().execute(hcb);

    if (!assessmentGradings.isEmpty()) {
        AssessmentGradingData agd;
        Double cumulativeScore = new Double(0);
        Iterator i = assessmentGradings.iterator();

        while (i.hasNext()) {
            agd = (AssessmentGradingData) i.next();
            cumulativeScore += agd.getFinalScore();
        }
        averageScore = cumulativeScore / assessmentGradings.size();

        DecimalFormat df = new DecimalFormat("0.##");
        DecimalFormatSymbols dfs = new DecimalFormatSymbols();
        dfs.setDecimalSeparator('.');
        df.setDecimalFormatSymbols(dfs);

        averageScore = new Double(df.format((double) averageScore));
    }
    return averageScore;
}
 

public Double getAverageSubmittedAssessmentGrading(final Long publishedAssessmentId, final String agentId) {
    Double averageScore = 0.0;
    AssessmentGradingData ag = null;

    final HibernateCallback<List<AssessmentGradingData>> hcb = session -> {
        Query q = session.createQuery(
                "from AssessmentGradingData a where a.publishedAssessmentId = :id and a.agentId = :agent and a.forGrade = :forgrade and a.status > :status order by  a.submittedDate desc");
        q.setLong("id", publishedAssessmentId);
        q.setString("agent", agentId);
        q.setBoolean("forgrade", true);
        q.setInteger("status", AssessmentGradingData.REMOVED);
        return q.list();
    };
    List<AssessmentGradingData> assessmentGradings = getHibernateTemplate().execute(hcb);

    if (!assessmentGradings.isEmpty()) {
        AssessmentGradingData agd;
        Double cumulativeScore = new Double(0);
        Iterator i = assessmentGradings.iterator();

        while (i.hasNext()) {
            agd = (AssessmentGradingData) i.next();
            cumulativeScore += agd.getFinalScore();
        }
        averageScore = cumulativeScore / assessmentGradings.size();

        DecimalFormat df = new DecimalFormat("0.##");
        DecimalFormatSymbols dfs = new DecimalFormatSymbols();
        dfs.setDecimalSeparator('.');
        df.setDecimalFormatSymbols(dfs);

        averageScore = new Double(df.format((double) averageScore));
    }
    return averageScore;
}
 

public List<AssessmentGradingData> getAllAssessmentGradingByAgentId(final Long publishedAssessmentId, final String agentIdString) {

        final HibernateCallback<List<AssessmentGradingData>> hcb = session -> {
            Query q = session.createQuery(
                    "from AssessmentGradingData a where a.publishedAssessmentId = :id and a.agentId = :agent and a.forGrade = :forgrade and a.status > :status order by a.submittedDate desc");
            q.setLong("id", publishedAssessmentId);
            q.setString("agent", agentIdString);
            q.setBoolean("forgrade", true);
            q.setInteger("status", AssessmentGradingData.REMOVED);
            return q.list();
        };
        return getHibernateTemplate().execute(hcb);
    }
 

public List<AssessmentGradingData> getUnSubmittedAssessmentGradingDataList(final Long publishedAssessmentId, final String agentIdString) {
    final HibernateCallback<List<AssessmentGradingData>> hcb = session -> {
        Query q = session.createQuery(
                "from AssessmentGradingData a where a.publishedAssessmentId = :id and a.agentId = :agent and a.forGrade = :forgrade and a.status > :status order by a.attemptDate desc");
        q.setLong("id", publishedAssessmentId);
        q.setString("agent", agentIdString);
        q.setBoolean("forgrade", false);
        q.setInteger("status", AssessmentGradingData.REMOVED);
        return q.list();
    };
    return getHibernateTemplate().execute(hcb);
}
 

@SuppressWarnings("unchecked")
public List<AssessmentGradingData> getAllSubmissions(final String publishedId) {
    final HibernateCallback<List<AssessmentGradingData>> hcb = session -> {
        Query q = session.createQuery(
                "from AssessmentGradingData a where a.publishedAssessmentId = :id and a.forGrade = :forgrade and a.status > :status");
        q.setLong("id", Long.parseLong(publishedId));
        q.setBoolean("forgrade", true);
        q.setInteger("status", AssessmentGradingData.REMOVED);
        return q.list();
    };
    return getHibernateTemplate().execute(hcb);
}
 

/**
	 * {@inheritDoc}
	 */
@Override
public int getThreadsWithUnreadMessagesCount(final String userId) {
	
	final HibernateCallback<Number> hcb = session -> {
           final Query q = session.getNamedQuery(QUERY_GET_THREADS_WITH_UNREAD_MESSAGES_COUNT);
           q.setParameter(UUID, userId, StringType.INSTANCE);
           q.setBoolean("false", Boolean.FALSE);
           return (Number) q.uniqueResult();
       };
  	
  	return getHibernateTemplate().execute(hcb).intValue();
}
 

/**
	 * {@inheritDoc}
	 */
@Override
public int getAllUnreadMessagesCount(final String userId) {
	
	final HibernateCallback<Number> hcb = session -> {
           final Query q = session.getNamedQuery(QUERY_GET_ALL_UNREAD_MESSAGES_COUNT);
           q.setParameter(UUID, userId, StringType.INSTANCE);
           q.setBoolean("false", Boolean.FALSE);
           return (Number) q.uniqueResult();
       };
  	
  	return getHibernateTemplate().execute(hcb).intValue();
}
 

/**
 * Find current document version
 */
public NodeDocumentVersion findCurrentVersion(Session session, String docUuid) throws HibernateException {
	log.debug("findCurrentVersion({})", docUuid);
	String qs = "from NodeDocumentVersion ndv where ndv.parent=:parent and ndv.current=:current";
	Query q = session.createQuery(qs).setCacheable(true);
	q.setString("parent", docUuid);
	q.setBoolean("current", true);
	NodeDocumentVersion currentVersion = (NodeDocumentVersion) q.setMaxResults(1).uniqueResult();
	return currentVersion;
}
 

public Set<PublishedItemData> getItemSet(final Long publishedAssessmentId, final Long sectionId) {

        final HibernateCallback<List<Long>> hcb = session -> {
            Query q = session.createQuery(
                    "select distinct p.itemId " +
                            "from PublishedItemData p, AssessmentGradingData a, ItemGradingData i " +
                            "where a.publishedAssessmentId = :id and a.forGrade = :forgrade and p.section.id = :sectionid " +
                            "and i.assessmentGradingId = a.assessmentGradingId " +
                            "and p.itemId = i.publishedItemId and a.status > :status ");
            q.setLong("id", publishedAssessmentId);
            q.setBoolean("forgrade", true);
            q.setLong("sectionid", sectionId);
            q.setInteger("status", AssessmentGradingData.REMOVED);
            return q.list();
        };
        List<Long> itemIds = getHibernateTemplate().execute(hcb);

        if (itemIds.isEmpty()) {
            return new HashSet<>();
        }

        final HibernateCallback<List<PublishedItemData>> hcb2 = session -> {

            final Criteria criteria = session.createCriteria(PublishedItemData.class);
            if (itemIds.size() > 1000) {
                final Set<Long> ids = new HashSet<>();
                Disjunction disjunction = Restrictions.disjunction();

                for (Long id : itemIds) {
                    if (ids.size() < 1000) {
                        ids.add(id);
                    } else {
                        criteria.add(disjunction.add(Restrictions.in("itemId", ids)));
                        ids.clear();
                    }
                }
            } else {
                criteria.add(Restrictions.in("itemId", itemIds));
            }
            return criteria.list();
        };

        List<PublishedItemData> publishedItems = getHibernateTemplate().execute(hcb2);

        return new HashSet<>(publishedItems);
    }
 

/**
 * for public QueryResult getList... doInHibernate
 * @param query		 JPA-Style : from TB_ACCOUNT where account = ?0 
 * @param position   JPA-Style : "0", "1" .....
 * @param params
 */
@SuppressWarnings("rawtypes")
private void setQueryParams(Query query, String position, Object params) {
	if (params instanceof java.lang.String ) {
		query.setString(position, (java.lang.String)params);
		return;
	}
	if (params instanceof java.lang.Character) {
		query.setCharacter(position, (java.lang.Character)params);
		return;
	}
	if (params instanceof java.lang.Double ) {
		query.setDouble(position, (java.lang.Double)params);	
		return;
	}							
	if (params instanceof java.lang.Byte ) {
		query.setByte(position, (java.lang.Byte)params);
		return;
	}														
	if (params instanceof java.lang.Integer ) {
		query.setInteger(position, (java.lang.Integer)params);
		return;
	}
	if (params instanceof java.lang.Long ) {
		query.setLong(position, (java.lang.Long)params);
		return;
	}							
	if (params instanceof java.lang.Boolean ) {
		query.setBoolean(position, (java.lang.Boolean)params);
		return;
	}
	if (params instanceof java.math.BigDecimal ) {
		query.setBigDecimal(position, (java.math.BigDecimal)params);
		return;
	}							
	if (params instanceof java.util.Date ) {
		query.setDate(position, (java.util.Date)params);
		return;
	}		
	if (params instanceof java.util.List ) {
		List listParams=(List)params;
		this.setQueryParamsOfList(query, position, listParams);
		return;
	}
}
 

/**
 * Counts number of existent DataSets
 *
 * @return Integer, number of existent DataSets
 * @throws EMFUserError the EMF user error
 */
@Override
public Integer countDatasets() {
	logger.debug("IN");
	Session session = null;
	Transaction transaction = null;
	Long resultNumber;
	try {
		session = getSession();
		transaction = session.beginTransaction();
		List<Domain> devCategories = new LinkedList<Domain>();
		boolean isDev = fillDevCategories(devCategories);
		if (isDev) {
			List idsCat = createIdsCatogriesList(devCategories);
			String owner = ((UserProfile) getUserProfile()).getUserId().toString();
			Query countQuery;
			if (idsCat == null || idsCat.size() == 0) {
				countQuery = session.createQuery("select count(*) from SbiDataSet sb where sb.active = ? and owner = :owner");
				countQuery.setBoolean(0, true);
				countQuery.setString("owner", owner);
			} else {
				countQuery = session
						.createQuery("select count(*) from SbiDataSet sb where sb.active = ? and (sb.category.valueId IN (:idsCat) or owner = :owner)");
				countQuery.setBoolean(0, true);
				countQuery.setParameterList("idsCat", idsCat);
				countQuery.setString("owner", owner);
			}

			resultNumber = (Long) countQuery.uniqueResult();
		} else {
			String hql = "select count(*) from SbiDataSet ds where ds.active = ? ";
			Query hqlQuery = session.createQuery(hql);
			hqlQuery.setBoolean(0, true);
			resultNumber = (Long) hqlQuery.uniqueResult();
		}
	} catch (Throwable t) {
		if (transaction != null && transaction.isActive()) {
			transaction.rollback();
		}
		throw new SpagoBIDAOException("Error while loading the list of SbiDataSet", t);
	} finally {
		if (session != null && session.isOpen()) {
			session.close();
		}
		logger.debug("OUT");
	}
	return new Integer(resultNumber.intValue());
}
 

/**
 * This returns a hashmap of all the latest item entries, keyed by
 * item id for easy retrieval.
 *
 * @param publishedId
 * @param agentId
 * @return
 */
public Map<Long, List<ItemGradingData>> getLastItemGradingData(final Long publishedId, final String agentId) {
    try {
        final HibernateCallback<List<AssessmentGradingData>> hcb = session -> {
            // I am debating should I use (a.forGrade=false and a.status=NO_SUBMISSION) or attemptDate is not null
            Query q = session.createQuery(
                    "from AssessmentGradingData a where a.publishedAssessmentId = :id " +
                            "and a.agentId = :agent and a.forGrade = :forgrade and a.status <> :status and a.status <> :removed " +
                            "order by a.submittedDate DESC");
            q.setLong("id", publishedId);
            q.setString("agent", agentId);
            q.setBoolean("forgrade", false);
            q.setInteger("status", AssessmentGradingData.NO_SUBMISSION);
            q.setInteger("removed", AssessmentGradingData.REMOVED);
            return q.list();
        };
        List<AssessmentGradingData> scores = getHibernateTemplate().execute(hcb);

        if (scores.isEmpty()) {
            return new HashMap<>();
        }
        HashMap<Long, List<ItemGradingData>> map = new HashMap<>();
        AssessmentGradingData gdata = scores.get(0);
        // initialize itemGradingSet
        gdata.setItemGradingSet(getItemGradingSet(gdata.getAssessmentGradingId()));
        if (gdata.getForGrade()) {
            return new HashMap<>();
        }
        for (ItemGradingData data : gdata.getItemGradingSet()) {
            List<ItemGradingData> thisone = map.get(data.getPublishedItemId());
            if (thisone == null) {
                thisone = new ArrayList<>();
            }
            thisone.add(data);
            map.put(data.getPublishedItemId(), thisone);
        }
        return map;
    } catch (Exception e) {
        log.warn(e.getMessage(), e);
        return new HashMap<>();
    }
}
 

public Map<Long, List<ItemGradingData>> getSubmitData(final Long publishedId, final String agentId, final Integer scoringoption, final Long assessmentGradingId) {
    try {
        final HibernateCallback<List<AssessmentGradingData>> hcb = session -> {
            log.debug("scoringoption = " + scoringoption);
            if (EvaluationModelIfc.LAST_SCORE.equals(scoringoption)) {
                // last submission
                Query q;
                if (assessmentGradingId == null) {
                    q = session.createQuery(
                            "from AssessmentGradingData a where a.publishedAssessmentId = :id and a.agentId = :agent and a.forGrade = :forgrade and a.status > :status order by a.submittedDate DESC");
                    q.setLong("id", publishedId);
                    q.setString("agent", agentId);
                    q.setBoolean("forgrade", true);
                    q.setInteger("status", AssessmentGradingData.REMOVED);
                } else {
                    q = session.createQuery("from AssessmentGradingData a where a.assessmentGradingId = :id");
                    q.setLong("id", assessmentGradingId);
                }
                return q.list();
            } else {
                //highest submission
                Query q1 = null;
                if (assessmentGradingId == null) {
                    q1 = session.createQuery(
                            "from AssessmentGradingData a where a.publishedAssessmentId = :id and a.agentId = :agent and a.forGrade = :forgrade and a.status > :status order by a.finalScore DESC, a.submittedDate DESC");
                    q1.setLong("id", publishedId);
                    q1.setString("agent", agentId);
                    q1.setBoolean("forgrade", true);
                    q1.setInteger("status", AssessmentGradingData.REMOVED);
                } else {
                    q1 = session.createQuery("from AssessmentGradingData a where a.assessmentGradingId = :id");
                    q1.setLong("id", assessmentGradingId);
                }
                return q1.list();
            }
        };
        List<AssessmentGradingData> scores = getHibernateTemplate().execute(hcb);

        HashMap<Long, List<ItemGradingData>> map = new HashMap<>();
        if (scores.isEmpty()) {
            return new HashMap<>();
        }
        AssessmentGradingData gdata = scores.get(0);
        Map<Long, Set<ItemGradingAttachment>> attachmentMap = getItemGradingAttachmentMapByAssessmentGradingId(
                gdata.getAssessmentGradingId());
        gdata.setItemGradingSet(getItemGradingSet(gdata.getAssessmentGradingId()));
        for (ItemGradingData data : gdata.getItemGradingSet()) {
            if (attachmentMap.get(data.getItemGradingId()) != null) {
                data.setItemGradingAttachmentSet(attachmentMap.get(data.getItemGradingId()));
            } else {
                data.setItemGradingAttachmentSet(new HashSet<>());
            }

            List<ItemGradingData> thisone = map.get(data.getPublishedItemId());
            if (thisone == null) {
                thisone = new ArrayList<>();
            }
            thisone.add(data);
            map.put(data.getPublishedItemId(), thisone);
        }
        return map;
    } catch (Exception e) {
        log.warn(e.getMessage(), e);
        return new HashMap<>();
    }
}