public List<Product> getProducts(User user, String uuid,
      FilterExpression filter_expr, OrderByExpression order_expr, int skip,
      int top) throws ExceptionVisitExpression, ODataApplicationException
{
   ProductSQLVisitor expV = new ProductSQLVisitor();
   Object visit_result = null;

   if (filter_expr != null)
   {
      visit_result = filter_expr.accept(expV);
   }
   if (order_expr != null)
   {
      visit_result = order_expr.accept(expV);
   }

   return productService.getProducts((DetachedCriteria) visit_result, uuid,
         skip, top);
}
 

@Override
public long getCurrentNumberOfApis(int envId,String componentIdsStrg) throws ParseException {
	
	List<Integer> comIdList = DaoUtil.convertCSVToList(componentIdsStrg);
	
	Session session = sessionFactory.openSession();
	DetachedCriteria subMaxDate = DetachedCriteria.forClass(K8sApiStatusEntity.class);
	subMaxDate.setProjection(Projections.max("statusDate"));
	Criteria crtCurrenrApi = session.createCriteria(K8sApiStatusEntity.class);
	crtCurrenrApi.add(Property.forName("statusDate").eq(subMaxDate));
	DaoUtil.addEnvironmentToCriteria(envId, comIdList, crtCurrenrApi);
	crtCurrenrApi.setProjection(Projections.sum("totalApi"));
	long currentNumberOfApi = (long) (crtCurrenrApi.uniqueResult() == null ? (long)0 : crtCurrenrApi.uniqueResult());
	session.close();
	return currentNumberOfApi;
}
 

public List<SimplePage> getTopLevelPages(final String siteId) {
    // set of all top level pages, actually the items pointing to them                                                                       
	try {
		List<SitePage> sitePages = siteService.getSite(siteId).getOrderedPages();
		if (sitePages.isEmpty()) {
			return null;
		}

		final List<String> sitePageIds = sitePages.stream().map(sp -> sp.getId()).collect(Collectors.toList());

		DetachedCriteria d = DetachedCriteria.forClass(SimplePage.class);
		d.add(Restrictions.in("toolId", sitePageIds));
		d.add(Restrictions.isNull("parent"));

		List<SimplePage> lessonsPages = (List<SimplePage>) getHibernateTemplate().findByCriteria(d);

		return lessonsPages;

	} catch (IdUnusedException e) {
		log.warn("Could not find site: " + siteId, e);
		return null;
	}

}
 

@Override
@SuppressWarnings("unchecked")
public List<?> findByCriteria(final DetachedCriteria criteria, final int firstResult, final int maxResults)
		throws DataAccessException {

	Assert.notNull(criteria, "DetachedCriteria must not be null");
	return nonNull(executeWithNativeSession((HibernateCallback<List<?>>) session -> {
		Criteria executableCriteria = criteria.getExecutableCriteria(session);
		prepareCriteria(executableCriteria);
		if (firstResult >= 0) {
			executableCriteria.setFirstResult(firstResult);
		}
		if (maxResults > 0) {
			executableCriteria.setMaxResults(maxResults);
		}
		return executableCriteria.list();
	}));
}
 

@Override
public List<?> findByCriteria(final DetachedCriteria criteria, final int firstResult, final int maxResults)
		throws DataAccessException {

	Assert.notNull(criteria, "DetachedCriteria must not be null");
	return executeWithNativeSession(new HibernateCallback<List<?>>() {
		@Override
		public List<?> doInHibernate(Session session) throws HibernateException {
			Criteria executableCriteria = criteria.getExecutableCriteria(session);
			prepareCriteria(executableCriteria);
			if (firstResult >= 0) {
				executableCriteria.setFirstResult(firstResult);
			}
			if (maxResults > 0) {
				executableCriteria.setMaxResults(maxResults);
			}
			return executableCriteria.list();
		}
	});
}
 

public CriteriaQuery(Class entityClass,DataTables dataTables) {
	this.curPage = dataTables.getDisplayStart();
	String[] fieldstring=dataTables.getsColumns().split(",");

	this.detachedCriteria = DetachedCriteria.forClass(entityClass);
	//this.detachedCriteria = DetachedCriteriaUtil.createDetachedCriteria(entityClass, "start", "_table",fieldstring);

	
	this.field=dataTables.getsColumns();
	this.entityClass=entityClass;
	this.dataTables=dataTables;
	this.pageSize=dataTables.getDisplayLength();
	this.map = new HashMap<String, Object>();

	this.ordermap = new LinkedHashMap<String, Object>();

	addJqCriteria(dataTables);
}
 

@RequestMapping("goPersonalTeam.htm")
public ModelAndView goPersonalTeam(HttpServletRequest request) {
    String userId = request.getParameter("userId");
    User user1 = userService.findById(User.class, userId);
    DetachedCriteria dCriteria = DetachedCriteria.forClass(UserTeam.class);
    dCriteria.add(Restrictions.eq("user", user1));

    List<UserTeam> userTeam = userService.queryAllOfCondition(UserTeam.class, dCriteria);
    DetachedCriteria dCriteria2 = DetachedCriteria.forClass(Discuss.class);
    dCriteria2.add(Restrictions.eq("user", user1));
    List<Discuss> discussList = userService.queryAllOfCondition(Discuss.class, dCriteria2);

    request.setAttribute("user1", user1);
    request.setAttribute("userTeam", userTeam);
    request.setAttribute("discussList", discussList);
    return new ModelAndView("/userPage/userGroup");
}
 

/**
 * Odata dedicated Services
 */
@Transactional(readOnly = true)
@Cacheable (value = "product_count", key = "{#criteria, #uuid}")
public int countProducts (DetachedCriteria criteria, String uuid)
{
   if (criteria == null)
   {
      criteria = DetachedCriteria.forClass (Product.class);
   }

   // count only processed products
   criteria.add (Restrictions.eq ("processed", true));

   if (uuid != null)
   {
      List<Long> product_ids = collectionService.getProductIds (uuid);
      criteria.add (Restrictions.in ("id", product_ids));
   }
   criteria.setProjection (Projections.rowCount ());
   return productDao.count (criteria);
}
 

@Override
public List<String> getAllCategories(String siteId) throws DataAccessException {
	DetachedCriteria criteria = DetachedCriteria.forClass(
			SignupMeeting.class).setProjection(Projections.distinct(Projections.projectionList()
				    	    .add(Projections.property("category"), "category") )).setResultTransformer(
			Criteria.DISTINCT_ROOT_ENTITY)				
			.addOrder(Order.asc("category")).createCriteria("signupSites")
			.add(Restrictions.eq("siteId", siteId));
	
	List<String> categorys = (List<String>) getHibernateTemplate().findByCriteria(criteria);
	
	if(categorys !=null && !categorys.isEmpty()){
		return categorys;
	}
	
	return null;
}
 

public CriteriaQuery(Class<?> entityClass,DataGrid dg) {
	this.curPage = dg.getPage();
	//String[] fieldstring=dg.getField().split(",");
	//this.detachedCriteria = DetachedCriteriaUtil
	//.createDetachedCriteria(c, "start", "_table",fieldstring);
	this.detachedCriteria = DetachedCriteria.forClass(entityClass);
	//Criteria criteria = null;

	this.field=dg.getField();
	this.entityClass=entityClass;
	this.dataGrid=dg;
	this.pageSize=dg.getRows();
	this.map = new HashMap<String, Object>();

	this.ordermap = new LinkedHashMap<String, Object>();

}
 

private org.hibernate.Criteria[] createEcrfFieldCriteria(Long probandListEntryId, Long ecrfId) {
	org.hibernate.Criteria ecrfFieldCriteria = this.getSession().createCriteria(ECRFField.class, ServiceUtil.ECRF_FIELD_VALUE_DAO_ECRF_FIELD_ALIAS);
	ecrfFieldCriteria.add(Restrictions.eq("ecrf.id", ecrfId.longValue()));
	org.hibernate.Criteria ecrfFieldValueCriteria = ecrfFieldCriteria.createCriteria("fieldValues", ServiceUtil.ECRF_FIELD_VALUE_DAO_ECRF_FIELD_VALUE_ALIAS,
			CriteriaSpecification.LEFT_JOIN,
			Restrictions.eq(ServiceUtil.ECRF_FIELD_VALUE_DAO_ECRF_FIELD_VALUE_ALIAS + ".listEntry.id", probandListEntryId.longValue()));
	// correlated - slow:
	DetachedCriteria subQuery = createEcrfFieldValueDetachedCriteriaMaxId(ecrfFieldValueCriteria, ecrfFieldCriteria, null, probandListEntryId, null);
	subQuery.add(Restrictions.or(Restrictions.isNull("index"),
			Restrictions.eqProperty("index", ServiceUtil.ECRF_FIELD_VALUE_DAO_ECRF_FIELD_VALUE_ALIAS + ".index")));
	ecrfFieldValueCriteria.add(Restrictions.or(
			Restrictions.isNull("listEntry"),
			Restrictions.and(
					Restrictions.eq("listEntry.id", probandListEntryId.longValue()),
					Subqueries.propertyIn("id", subQuery))));
	return new org.hibernate.Criteria[] { ecrfFieldCriteria, ecrfFieldValueCriteria };
}
 

/**
	 * 通过Criteria来查询
	 * @param criterion
	 * @param order
	 * @return 查询实体对象的结果列表
	 */
	@Transactional
	public List<T> cquery(Collection<Criterion> criterions,
			Collection<Order> orders) {
//		Session session=getSessionBeginTx();
//		
//		Criteria criteria = criteriaQuery(session,criterions, orders);
//		
//		List<T> list= criteria.list();
//		//提交事务
//		closeCommitTx(session);
		DetachedCriteria dc=DetachedCriteria.forClass(entityClass);
		if(criterions!=null){
			for (Criterion criterion : criterions) {
				dc.add(criterion);
			}
		}
		if(orders!=null){
			for (Order order : orders) {
				dc.addOrder(order);
			}
		}
		
		return getHibernateTemplate().findByCriteria(dc);
	}
 

@RequestMapping("createLessonPage.htm")
public ModelAndView createLessonPage(HttpServletRequest req, HttpServletResponse res) {
    String courseId = ServletRequestUtils.getStringParameter(req, "courseId", "");
    Course course = courseService.findById(Course.class, courseId);
    DetachedCriteria detachedCriteria1 = DetachedCriteria.forClass(UserCourse.class)
            .createCriteria("course")
            .add(Restrictions.eq("course", course));
    List<UserCourse> userCourseList = (List<UserCourse>) courseService.queryAllOfCondition(UserCourse.class, detachedCriteria1);
    int lessons = userCourseList.size();
    req.setAttribute("course", course);
    req.setAttribute("lessons", lessons);
    return new ModelAndView("/course/createLesson");
}
 

public SimplePageItem findItemFromStudentPage(long pageId) {
	DetachedCriteria d = DetachedCriteria.forClass(SimpleStudentPage.class).add(Restrictions.eq("pageId", pageId));

	List<SimpleStudentPage> list = (List<SimpleStudentPage>) getHibernateTemplate().findByCriteria(d);

	if(list.size() > 0) {
		return findItem(list.get(0).getItemId());
	}else {
		return null;
	}
}
 

@Override
public SecondKill findById(int id) {
    DetachedCriteria criteria = DetachedCriteria.forClass(SecondKill.class);
    criteria.add(Restrictions.eq("id", id));
    List<SecondKill> resultList = (List<SecondKill>) template.findByCriteria(criteria);
    if (resultList.size() == 0) {
        return null;
    }
    return resultList.get(0);
}
 

/**
	 * 方法描述:  成员列表dataGrid
	 * 作    者： yiming.zhang
	 * 日    期： Dec 4, 2013-10:40:17 PM
	 * @param user
	 * @param request
	 * @param response
	 * @param dataGrid 
	 * 返回类型： void
	 */
	@RequestMapping(params = "userDatagrid")
	public void userDatagrid(TSUser user,HttpServletRequest request, HttpServletResponse response, DataGrid dataGrid) {
		if(user!=null&&user.getDepartid()!=null){
			user.setDepartid(null);//设置用户的所属部门的查询条件为空；
		}
		CriteriaQuery cq = new CriteriaQuery(TSUser.class, dataGrid);
		//查询条件组装器
		org.jeecgframework.core.extend.hqlsearch.HqlGenerateUtil.installHql(cq, user);
		String departid = oConvertUtils.getString(request.getParameter("departid"));
		if (!StringUtil.isEmpty(departid)) {
			DetachedCriteria dc = cq.getDetachedCriteria();
			DetachedCriteria dcDepart = dc.createCriteria("userOrgList");
			dcDepart.add(Restrictions.eq("tsDepart.id", departid));
            // 这种方式也是可以的
//            DetachedCriteria dcDepart = dc.createAlias("userOrgList", "userOrg");
//            dcDepart.add(Restrictions.eq("userOrg.tsDepart.id", departid));

		}
		Short[] userstate = new Short[] { Globals.User_Normal, Globals.User_ADMIN };
		cq.in("status", userstate);

        //cq.eq("deleteFlag", Globals.Delete_Normal);//删除状态，不删除
        //cq.eq("userType",Globals.USER_TYPE_SYSTEM);//系统用户

		cq.add();
		this.systemService.getDataGridReturn(cq, true);
		TagUtil.datagrid(response, dataGrid);
	}
 

@Override
public Merchant findById(int id) {
    DetachedCriteria criteria = DetachedCriteria.forClass(Merchant.class);
    criteria.add(Restrictions.eq("id", id));
    List<Merchant> resultList = (List<Merchant>) template.findByCriteria(criteria);
    if (resultList.size() == 0) {
        return null;
    }
    return resultList.get(0);
}
 

public SimplePageQuestionResponse findQuestionResponse(long questionId, String userId) {
       DetachedCriteria d = DetachedCriteria.forClass(SimplePageQuestionResponse.class).add(Restrictions.eq("questionId", questionId))
       		.add(Restrictions.eq("userId", userId));

       List<SimplePageQuestionResponse> list = (List<SimplePageQuestionResponse>) getHibernateTemplate().findByCriteria(d);
       if(list != null && list.size() > 0) {
       	return list.get(0);
       }else {
       	return null;
       }
}
 

public List<SimplePageComment> findCommentsOnItemByAuthor(long commentWidgetId, String author) {
	DetachedCriteria d = DetachedCriteria.forClass(SimplePageComment.class)
	    .add(Restrictions.eq("itemId", commentWidgetId))
	    .add(Restrictions.eq("author", author));

	return (List<SimplePageComment>) getHibernateTemplate().findByCriteria(d);
}
 

@Transactional(readOnly = true)
public Product getProductByOrigin (final String origin)
{
   DetachedCriteria criteria = DetachedCriteria.forClass (Product.class);
   criteria.add (Restrictions.eq ("origin", origin));
   return productDao.uniqueResult (criteria);
}
 

@SuppressWarnings("unchecked")
@RequestMapping("myFavorite.htm")
public ModelAndView myFavotite(HttpServletRequest req, HttpServletResponse res) throws MarsException {
    User user = (User) req.getSession().getAttribute("user");
    DetachedCriteria dCriteria = DetachedCriteria.forClass(Favorite.class)
            .add(Restrictions.eq("user", user));

    int pageSize = 5;
    int totalPage = favoriteService.countTotalPage(dCriteria, pageSize);
    PageHelper.forPage(totalPage, pageSize);
    List<Favorite> favorites = (List<Favorite>) favoriteService.getByPage(dCriteria, pageSize);
    req.setAttribute("favorites", favorites);
    return new ModelAndView("/favorite/myFavorite");
}
 

@Override
public AdminGroup findById(int id) {
    DetachedCriteria criteria = DetachedCriteria.forClass(AdminGroup.class);
    criteria.add(Restrictions.eq("id", id));
    List<AdminGroup> resultList = (List<AdminGroup>) template.findByCriteria(criteria);

    if (resultList.size() == 0) {
        return null;
    }
    return resultList.get(0);
}
 

/**
 * Creates a Criteria for the implementation Class type.
 * <p>
 * Please note that sharing is not considered.
 *
 * @return a Criteria instance.
 */
@Deprecated
public final Criteria getCriteria()
{
    DetachedCriteria criteria = DetachedCriteria.forClass( getClazz() );

    preProcessDetachedCriteria( criteria );

    return getExecutableCriteria( criteria );
}
 

public List<SimplePageItem> findTopLevelPageItemsBySakaiIds(List<String> ids) {
	DetachedCriteria d = DetachedCriteria.forClass(SimplePageItem.class)
		.add(Restrictions.in("sakaiId", ids))
		.add(Restrictions.eq("pageId", 0L))
		.add(Restrictions.eq("type",SimplePageItem.PAGE));

	List<SimplePageItem> list = (List<SimplePageItem>) getHibernateTemplate().findByCriteria(d);

	if (list == null || list.size() < 1) {
		return null;
	}

	return list;
}
 

@Override
@SuppressWarnings( "unchecked" )
public int count( Query query )
{
    Schema schema = query.getSchema();
    InternalHibernateGenericStore<?> store = getStore( (Class<? extends IdentifiableObject>) schema.getKlass() );

    if ( store == null )
    {
        return 0;
    }

    if ( query.getUser() == null )
    {
        query.setUser( currentUserService.getCurrentUser() );
    }

    if ( !query.isPlannedQuery() )
    {
        QueryPlan queryPlan = queryPlanner.planQuery( query, true );
        query = queryPlan.getPersistedQuery();
    }

    DetachedCriteria detachedCriteria = buildCriteria( store.getSharingDetachedCriteria( query.getUser() ), query );
    Criteria criteria = store.getCriteria();

    if ( criteria == null )
    {
        return 0;
    }

    return ((Number) criteria.add( Subqueries.propertyIn( "id", detachedCriteria ) )
        .setProjection( Projections.countDistinct( "id" ) )
        .uniqueResult()).intValue();
}
 

@Override
public int getCountByGoodsId(int goodsId) {
    DetachedCriteria criteria = DetachedCriteria.forClass(GoodsComment.class);

    criteria.add(Restrictions.eq("goodsid", goodsId));
    criteria.setProjection(Projections.rowCount());

    Object obj  = template.findByCriteria(criteria).get(0);
    Long longObj = (Long) obj;
    int count = longObj.intValue();
    return count;
}
 

public List<SimplePage> getSitePages(String siteId) {
    DetachedCriteria d = DetachedCriteria.forClass(SimplePage.class).add(Restrictions.eq("siteId", siteId))
	    .add(Restrictions.disjunction()
			    .add(Restrictions.isNull("owner"))
			    .add(Restrictions.eq("owned", true))
	    );

	List<SimplePage> l = (List<SimplePage>) getHibernateTemplate().findByCriteria(d);

	if (l != null && l.size() > 0) {
	    return l;
	} else {
	    return null;
	}
}
 

public List<SimplePageLogEntry> getStudentPageLogEntries(long itemId, String userId) {		
	DetachedCriteria d = DetachedCriteria.forClass(SimplePageLogEntry.class).add(Restrictions.eq("userId", userId))
			.add(Restrictions.eq("itemId", itemId))
			.add(Restrictions.isNotNull("studentPageId"));

	return (List<SimplePageLogEntry>) getHibernateTemplate().findByCriteria(d);
}
 

/**
 * {@inheritDoc}
 */
@SuppressWarnings("unchecked")
public List<SignupMeeting> getAutoReminderSignupMeetings(Date startDate,
		Date endDate) {
	DetachedCriteria criteria = DetachedCriteria.forClass(
			SignupMeeting.class).setResultTransformer(
			Criteria.DISTINCT_ROOT_ENTITY).add(Restrictions.eq("autoReminder", true))
			//.add(Restrictions.between("startTime", startDate, endDate))
			.add(Restrictions.le("startTime", endDate))
			.add(Restrictions.ge("endTime",startDate))
			.addOrder(Order.asc("startTime"));		

	return (List<SignupMeeting>) getHibernateTemplate().findByCriteria(criteria);
}
 

public SimplePageComment findCommentById(long commentId) {
	DetachedCriteria d = DetachedCriteria.forClass(SimplePageComment.class).add(Restrictions.eq("id", commentId));
	List<SimplePageComment> list = (List<SimplePageComment>) getHibernateTemplate().findByCriteria(d);
	
	if(list.size() > 0) {
		return list.get(0);
	}else {
		return null;
	}
}