import com.avaje.ebean.Expr; //导入依赖的package包/类
/**
 * Get all allocation of an actor for not archived portfolio entries as an
 * expression list.
 *
 * @param actorId
 *            the actor id
 * @param activeOnly
 *            if true, it returns only the allocation for which the end date
 *            is in the future
 */
public static ExpressionList<PortfolioEntryResourcePlanAllocatedActor> getPEPlanAllocatedActorAsExprByActorAndActive(Long actorId, boolean activeOnly, boolean withArchived) {

    ExpressionList<PortfolioEntryResourcePlanAllocatedActor> expr = PortfolioEntryResourcePlanDAO.findPEResourcePlanAllocatedActor.orderBy("endDate")
            .where().eq("deleted", false).eq("actor.id", actorId).eq("portfolioEntryResourcePlan.deleted", false)
            .eq("portfolioEntryResourcePlan.lifeCycleInstancePlannings.deleted", false)
            .eq("portfolioEntryResourcePlan.lifeCycleInstancePlannings.isFrozen", false)
            .eq("portfolioEntryResourcePlan.lifeCycleInstancePlannings.lifeCycleInstance.deleted", false)
            .eq("portfolioEntryResourcePlan.lifeCycleInstancePlannings.lifeCycleInstance.isActive", true)
            .eq("portfolioEntryResourcePlan.lifeCycleInstancePlannings.lifeCycleInstance.portfolioEntry.deleted", false);

    if (!withArchived) {
        expr = expr.add(Expr.eq("portfolioEntryResourcePlan.lifeCycleInstancePlannings.lifeCycleInstance.portfolioEntry.archived", false));
    }

    if (activeOnly) {
        expr = expr.add(Expr.or(Expr.isNull("endDate"), Expr.gt("endDate", new Date())));
    }

    return expr;
}
 

import com.avaje.ebean.Expr; //导入依赖的package包/类
/**
 * Get all allocation of the actors of an org unit for not archived
 * portfolio entries as an expression list.
 *
 * @param orgUnitId
 *            the org unit id
 * @param activeOnly
 *            if true, it returns only the allocation for which the end date
 *            is in the future
 */
public static ExpressionList<PortfolioEntryResourcePlanAllocatedActor> getPEPlanAllocatedActorAsExprByOrgUnitAndActive(Long orgUnitId,
        boolean activeOnly, boolean draftExcluded) {

    ExpressionList<PortfolioEntryResourcePlanAllocatedActor> expr = PortfolioEntryResourcePlanDAO.findPEResourcePlanAllocatedActor.where()
            .eq("deleted", false).eq("actor.isActive", true).eq("actor.deleted", false).eq("actor.orgUnit.id", orgUnitId)
            .eq("portfolioEntryResourcePlan.deleted", false).eq("portfolioEntryResourcePlan.lifeCycleInstancePlannings.deleted", false)
            .eq("portfolioEntryResourcePlan.lifeCycleInstancePlannings.isFrozen", false)
            .eq("portfolioEntryResourcePlan.lifeCycleInstancePlannings.lifeCycleInstance.deleted", false)
            .eq("portfolioEntryResourcePlan.lifeCycleInstancePlannings.lifeCycleInstance.isActive", true)
            .eq("portfolioEntryResourcePlan.lifeCycleInstancePlannings.lifeCycleInstance.portfolioEntry.deleted", false)
            .eq("portfolioEntryResourcePlan.lifeCycleInstancePlannings.lifeCycleInstance.portfolioEntry.archived", false);

    if (activeOnly) {
        expr = expr.add(Expr.or(Expr.isNull("endDate"), Expr.gt("endDate", new Date())));
    }

    if (draftExcluded) {
        expr = expr.not(Expr.eq("portfolioEntryResourcePlanAllocationStatusType", PortfolioEntryResourcePlanDAO.getAllocationStatusByType(PortfolioEntryResourcePlanAllocationStatusType.AllocationStatus.DRAFT)));
    }

    return expr;
}
 

import com.avaje.ebean.Expr; //导入依赖的package包/类
/**
 * Get all allocation of the actors from the given manager for not archived
 * portfolio entries, as an expression list.
 *
 * @param actorId
 *            the manager id
 * @param activeOnly
 *            if true, it returns only the allocation for which the end date
 *            is in the future
 */
public static ExpressionList<PortfolioEntryResourcePlanAllocatedActor> getPEPlanAllocatedActorAsExprByManager(Long actorId, boolean activeOnly) {

    ExpressionList<PortfolioEntryResourcePlanAllocatedActor> expr = PortfolioEntryResourcePlanDAO.findPEResourcePlanAllocatedActor.where()
            .eq("deleted", false).eq("actor.isActive", true).eq("actor.deleted", false).eq("actor.manager.id", actorId)
            .eq("portfolioEntryResourcePlan.deleted", false).eq("portfolioEntryResourcePlan.lifeCycleInstancePlannings.deleted", false)
            .eq("portfolioEntryResourcePlan.lifeCycleInstancePlannings.isFrozen", false)
            .eq("portfolioEntryResourcePlan.lifeCycleInstancePlannings.lifeCycleInstance.deleted", false)
            .eq("portfolioEntryResourcePlan.lifeCycleInstancePlannings.lifeCycleInstance.isActive", true)
            .eq("portfolioEntryResourcePlan.lifeCycleInstancePlannings.lifeCycleInstance.portfolioEntry.deleted", false)
            .eq("portfolioEntryResourcePlan.lifeCycleInstancePlannings.lifeCycleInstance.portfolioEntry.archived", false);

    if (activeOnly) {
        expr = expr.add(Expr.or(Expr.isNull("endDate"), Expr.gt("endDate", new Date())));
    }

    return expr;
}
 

import com.avaje.ebean.Expr; //导入依赖的package包/类
/**
 * Get all allocation of an org unit for not archived portfolio entries as
 * an expression list.
 *
 * @param orgUnitId
 *            the org unit id
 * @param activeOnly
 *            if true, it returns only the allocation for which the end date
 *            is in the future
 */
public static ExpressionList<PortfolioEntryResourcePlanAllocatedOrgUnit> getPEResourcePlanAllocatedOrgUnitAsExprByOrgUnit(Long orgUnitId,
        boolean activeOnly, boolean draftExcluded) {

    ExpressionList<PortfolioEntryResourcePlanAllocatedOrgUnit> expr = PortfolioEntryResourcePlanDAO.findPEResourcePlanAllocatedOrgUnit.orderBy("endDate")
            .where().eq("deleted", false).eq("orgUnit.id", orgUnitId).eq("portfolioEntryResourcePlan.deleted", false)
            .eq("portfolioEntryResourcePlan.lifeCycleInstancePlannings.deleted", false)
            .eq("portfolioEntryResourcePlan.lifeCycleInstancePlannings.isFrozen", false)
            .eq("portfolioEntryResourcePlan.lifeCycleInstancePlannings.lifeCycleInstance.deleted", false)
            .eq("portfolioEntryResourcePlan.lifeCycleInstancePlannings.lifeCycleInstance.isActive", true)
            .eq("portfolioEntryResourcePlan.lifeCycleInstancePlannings.lifeCycleInstance.portfolioEntry.deleted", false)
            .eq("portfolioEntryResourcePlan.lifeCycleInstancePlannings.lifeCycleInstance.portfolioEntry.archived", false);

    if (activeOnly) {
        expr = expr.add(Expr.or(Expr.isNull("endDate"), Expr.gt("endDate", new Date())));
    }

    if (draftExcluded) {
        expr = expr.not(Expr.eq("portfolioEntryResourcePlanAllocationStatusType", PortfolioEntryResourcePlanDAO.getAllocationStatusByType(PortfolioEntryResourcePlanAllocationStatusType.AllocationStatus.DRAFT)));
    }

    return expr;
}
 

import com.avaje.ebean.Expr; //导入依赖的package包/类
/**
 * Create a search expression from the concatenation of the of the various
 * expressions.<br/>
 * WARNING: return null if no expression can be found
 */
public synchronized Expression getSearchExpression() {
    Expression currentExpression = null;
    for (String columnId : getUserColumnConfigurations().keySet()) {
        UserColumnConfiguration userColumnConfiguration = getUserColumnConfigurations().get(columnId);
        SelectableColumn selectableColumn = getSelectableColumns().get(columnId);
        if (userColumnConfiguration.isFiltered()) {
            String fieldName = selectableColumn.getFieldName();
            Expression temp = selectableColumn.getFilterComponent().getEBeanSearchExpression(userColumnConfiguration.getFilterValue(), fieldName);
            if (currentExpression == null) {
                currentExpression = temp;
            } else {
                if (temp != null) {
                    currentExpression = Expr.and(currentExpression, temp);
                }
            }
            if (log.isDebugEnabled()) {
                log.debug(String.format(">>>>>>>>>>>>>>>>>> Search in column %s for value %s", columnId, userColumnConfiguration.getFilterValue()));
            }
        }
    }
    return currentExpression;
}
 

import com.avaje.ebean.Expr; //导入依赖的package包/类
@Override
public Expression getEBeanSearchExpression(Object filterValue, String fieldName) {
    if (filterValue != null) {
        String value = (String) filterValue;
        if (value.contains(JOKER)) {
            value = value.replaceAll("\\" + JOKER, "%");
            return Expr.like(fieldName, value);
        } else {
            Expression expr = Expr.eq(fieldName, value);
            if (value.isEmpty()) {
                return Expr.or(expr, Expr.isNull(fieldName));
            } else {
                return expr;
            }
        }
    }
    return null;
}
 

import com.avaje.ebean.Expr; //导入依赖的package包/类
/**
     * Retrieve a taxonomy by name. The origin of these subjects is from the configuration file.
     * @param title
     * @return taxonomy object
     */
    public static Taxonomy findByNameConf(String name) {
    	Taxonomy res = new Taxonomy();
    	if (name != null && name.length() > 0) {
//    		Logger.debug("p1: " + name);
    		if (name.contains(Const.COMMA)) {
    			name = name.replace(Const.COMMA, Const.COMMA + " "); // in database entry with comma has additional space after comma
    		}
    		res = findTaxonomy.where()
    				.eq(Const.NAME, name)
    				.not(Expr.icontains(Const.PARENT, Const.ACT_URL))
//                Expr.icontains(Const.FIELD_URL_NODE, filter),
//                Expr.icontains(Const.TITLE, filter)
//             ))
//    				.(Const.PARENT, Const.ACT_URL)
    				.findUnique();
    	} else {
    		res.name = Const.NONE;
    	}
//		Logger.debug("res: " + res);
    	return res;
    }
 

import com.avaje.ebean.Expr; //导入依赖的package包/类
/**
 * Return a page of Taxonomy by Type
 *
 * @param page Page to display
 * @param pageSize Number of targets per page
 * @param sortBy Target property used for sorting
 * @param order Sort order (either or asc or desc)
 * @param type Taxonomy type
 * @param filter Filter applied on the name column
 */
public static Page<Taxonomy> pageByTypeAll(int page, int pageSize, String sortBy, String order, 
		String filter) {

    return findTaxonomy.where()
    		.icontains(Const.NAME, filter)
     	.add(Expr.or(
              Expr.icontains(Const.TTYPE, Const.SUBJECT),
              Expr.icontains(Const.TTYPE, Const.SUBSUBJECT)
     		))
     	.add(Expr.or(
              Expr.isNull(Const.PARENT),
              Expr.not(Expr.icontains(Const.PARENT, Const.ACT_URL))
     		))
    		.orderBy(sortBy + " " + order)
    		.findPagingList(pageSize)
    		.setFetchAhead(false)
    		.getPage(page);
}
 

import com.avaje.ebean.Expr; //导入依赖的package包/类
@Transactional
public List<WorkflowRun> findSharedRunsByUser(Long uid) {
    User user = User.find.byId(uid);

    // Get a list of the user's groups
    List<Long> groupIds = new ArrayList<Long>();
    for (UserGroup group : user.getGroups()) {
        groupIds.add(group.getId());
    }

    List<WorkflowRun> shareList = WorkflowRun.find.where().disjunction().add(Expr.eq("users.id", uid)).add(Expr.in("groups.id", groupIds)).findList();

    return shareList;
}
 

import com.avaje.ebean.Expr; //导入依赖的package包/类
/**
* returns all timeTracks from user, which are between from and to
* @param user
* @param from
* @param to
* @return
* @throws NotFoundException
*/
@Override
public List<TimeTrack> readTimeTracks(User user, DateTime from, DateTime to) {
   if(from.isAfter(to))
      return Collections.emptyList();

   // following query also includes activeTimeTrack, if there is one (case 1)
   List<TimeTrack> _timeTracks =
       Ebean.find(TimeTrack.class)
       .where().and(
           Expr.eq("user_id", user.getId()),
           Expr.or(
              Expr.or(
                 Expr.between("start", "end", from),   // case1
                 Expr.between("start", "end", to)      // case2
              ),

              Expr.and(
                 Expr.ge("start", from),              // case3: when given times are surrounding inspected timeTrack
                 Expr.le("end", to)
              )
           )
       ).setOrderBy("start").findList();

   if(_timeTracks == null) {
       _timeTracks = Collections.emptyList();
   }
    // also include actual timeTrack, if it is in given timeRange
   try {
       TimeTrack activeTimeTrack = readActiveTimeTrack(user);
       if(from.isBefore(activeTimeTrack.getFrom()) && to.isAfter(activeTimeTrack.getFrom())) {
           _timeTracks.add(activeTimeTrack);
       }
   } catch (Exception e) {
       // do anything if no actual timeTrack is available...
   }
   return _timeTracks;
}
 

import com.avaje.ebean.Expr; //导入依赖的package包/类
@Override
public List<Payout> readAcceptedPayoutsFromUser(int userId) throws TimeTrackException {
    List<Payout> payouts =
        Ebean.find(Payout.class)
            .where().and(
                Expr.eq("user_id", userId),
                Expr.eq("state", RequestState.REQUEST_ACCEPTED)
            ).findList();

    if (payouts == null || payouts.isEmpty()) {
        return Collections.emptyList();
    }

    return payouts;
}
 

import com.avaje.ebean.Expr; //导入依赖的package包/类
/**
 * The following things can happen, when reading timetracks from the db which are in range:
 *
 *      +-------------+
 *      |Request range|
 *      +-------------+
 *      .             .
 *  +---------+       .
 *  |  Case1  |       .
 *  +---------+       .
 *      .        +--------+
 *      .        | Case2  |
 *      .        +--------+
 *      .             .
 * +-----------------------+
 * |       Case3           |
 * +-----------------------+
 *      .             .
 *      . +---------+ .
 *      . |  Case4  | .
 *      . +---------+ .
 */
@Override
public List<TimeOff> readTimeOffsFromUser(User user, DateTime from, DateTime to) throws TimeTrackException {

    List<TimeOff> timeOffs =
            Ebean.find(TimeOff.class)
                    .where().and(
                    Expr.eq("user_id", user.getId()),
                    Expr.or(
                            Expr.or(
                                    Expr.between("start", "end", from),     // Case 1
                                    Expr.between("start", "end", to)),      // Case 2
                            Expr.or(
                                    Expr.and(                               // Case 3
                                            Expr.lt("start", from),
                                            Expr.gt("end", to)
                                    ),
                                    Expr.and(                               // Case 4
                                            Expr.gt("start", from),
                                            Expr.lt("end", to)
                                    )
                            )
                    )
            ).findList();

    if(timeOffs == null) {
        return Collections.emptyList();
    }

    return timeOffs;
}
 

import com.avaje.ebean.Expr; //导入依赖的package包/类
/**
 * Define if a user can view the main information of a portfolio entry.
 * 
 * @param portfolioEntryId
 *            the portfolio entry id
 * @param securityService
 *            the security service
 */
public static boolean isPortfolioEntryViewAllowed(Long portfolioEntryId, ISecurityService securityService) {
    try {
        return getPortfolioEntriesViewAllowedAsQuery(securityService).add(Expr.eq("id", portfolioEntryId)).findRowCount() > 0;
    } catch (AccountManagementException e) {
        Logger.error("DefaultDynamicResourceHandler.isPortfolioEntryViewAllowed: impossible to get the user account");
        Logger.error(e.getMessage());
        return false;
    }
}
 

import com.avaje.ebean.Expr; //导入依赖的package包/类
/**
 * Define if a user can view the details of a budget bucket.
 * 
 * @param budgetBucketId
 *            the budget bucket id
 * @param securityService
 *            the security service
 */
public static boolean isBudgetBucketViewAllowed(Long budgetBucketId, ISecurityService securityService) {
    try {
        return getBudgetBucketsViewAllowedAsQuery(Expr.eq("id", budgetBucketId), null, securityService).findRowCount() > 0 ? true : false;
    } catch (AccountManagementException e) {
        Logger.error("BudgetBucketDynamicHelper.isBudgetBucketViewAllowed: impossible to get the user account");
        Logger.error(e.getMessage());
        return false;
    }
}
 

import com.avaje.ebean.Expr; //导入依赖的package包/类
/**
 * Define if a user can view the details of a portfolio.
 * 
 * @param portfolioId
 *            the portfolio id
 * @param securityService
 *            the security service
 */
public static boolean isPortfolioViewAllowed(Long portfolioId, ISecurityService securityService) {
    try {
        return getPortfoliosViewAllowedAsQuery(Expr.eq("id", portfolioId), null, securityService).findRowCount() > 0 ? true : false;
    } catch (AccountManagementException e) {
        Logger.error("PortfolioDynamicHelper.isPortfolioViewAllowed: impossible to get the user account");
        Logger.error(e.getMessage());
        return false;
    }
}
 

import com.avaje.ebean.Expr; //导入依赖的package包/类
/**
 * Define if a user can display and provide approval for a timesheet report.
 * 
 * @param timesheetReportId
 *            the timesheet report id
 * @param securityService
 *            the security service
 */
public static boolean isTimesheetReportApprovalAllowed(Long timesheetReportId, ISecurityService securityService) {
    try {
        return getTimesheetReportsApprovalAllowedAsQuery(Expr.eq("id", timesheetReportId), null, securityService).findRowCount() > 0 ? true : false;
    } catch (AccountManagementException e) {
        Logger.error(e.getMessage());
        return false;
    }
}
 

import com.avaje.ebean.Expr; //导入依赖的package包/类
/**
 * Define if a user can view the details of an org unit.
 * 
 * @param orgUnitId
 *            the org unit id
 * @param securityService
 *            the security service
 */
public static boolean isOrgUnitViewAllowed(Long orgUnitId, ISecurityService securityService) {
    try {
        return getOrgUnitsViewAllowedAsQuery(Expr.eq("id", orgUnitId), null, securityService).findRowCount() > 0 ? true : false;
    } catch (AccountManagementException e) {
        Logger.error("OrgUnitDynamicHelper.isOrgUnitViewAllowed: impossible to get the user account");
        Logger.error(e.getMessage());
        return false;
    }
}
 

import com.avaje.ebean.Expr; //导入依赖的package包/类
/**
 * Define if a user can view the details of an actor.
 * 
 * @param actorId
 *            the actor id
 * @param securityService
 *            the security service
 */
public static boolean isActorViewAllowed(Long actorId, ISecurityService securityService) {
    try {
        return getActorsViewAllowedAsQuery(Expr.eq("id", actorId), null, securityService).findRowCount() > 0 ? true : false;
    } catch (AccountManagementException e) {
        Logger.error("ActorDynamicHelper.isActorViewAllowed: impossible to get the user account");
        Logger.error(e.getMessage());
        return false;
    }
}
 

import com.avaje.ebean.Expr; //导入依赖的package包/类
/**
 * Define if a user can view the details of a report.
 * 
 * @param reportingId
 *            the report id
 * @param securityService
 *            the security service
 */
public static boolean isReportViewAllowed(Long reportingId, ISecurityService securityService) {
    try {
        return getReportsViewAllowedAsQuery(Expr.eq("id", reportingId), null, securityService).query().setDistinct(true).findRowCount() > 0 ? true
                : false;
    } catch (AccountManagementException e) {
        Logger.error("ReportingDynamicHelper.isReportViewAllowed: impossible to get the user account");
        Logger.error(e.getMessage());
        return false;
    }
}
 

import com.avaje.ebean.Expr; //导入依赖的package包/类
/**
 * Get all allocation of an actor as an expression list.
 * 
 * @param actorId
 *            the actor id
 * @param activeOnly
 *            if true, it returns only the allocation for which the end date
 *            is in the future
 */
public static ExpressionList<TimesheetActivityAllocatedActor> getTimesheetActivityAllocatedActorAsExprByActor(Long actorId, boolean activeOnly) {

    ExpressionList<TimesheetActivityAllocatedActor> expr = findTimesheetActivityAllocatedActor.orderBy("endDate").where().eq("deleted", false)
            .eq("actor.id", actorId).eq("timesheetActivity.deleted", false);

    if (activeOnly) {
        expr = expr.add(Expr.or(Expr.isNull("endDate"), Expr.gt("endDate", new Date())));
    }

    return expr;
}