import com.mysema.query.types.Order; //导入依赖的package包/类
/**
 * {@inheritDoc}
 */
@Override
public <T, E extends Comparable<?>> OrderSpecifier<?> createOrderSpecifier(
        PathBuilder<T> entityPath, String fieldName, Class<E> fieldType,
        Order order) {
    OrderSpecifier<?> orderBy = null;

    // Get the OrderSpecifier
    if (order == Order.ASC) {
        orderBy = entityPath.getComparable(fieldName, fieldType).asc();
    }
    else if (order == Order.DESC) {
        orderBy = entityPath.getComparable(fieldName, fieldType).desc();
    }
    return orderBy;
}
 

import com.mysema.query.types.Order; //导入依赖的package包/类
private <T extends Comparable<? super T>> SQLQuery applyListParams(SQLQuery query, ListQuery listQuery, ComparableExpressionBase<T> orderBy) {
	Order order = listQuery.getOrder();
	Long limit = listQuery.getLimit();
	Long offset = listQuery.getOffset();
	
	if(order != null) {
		if(order == Order.ASC) {
			query = query.orderBy(orderBy.asc());
		} else {
			query = query.orderBy(orderBy.desc());
		}
	}
	
	if(limit != null) {
		query = query.limit(limit);
	}
	
	if(offset != null) {
		query = query.offset(offset);
	}
	
	return query;
}
 

import com.mysema.query.types.Order; //导入依赖的package包/类
/**
 * Create an order-by-element in a Query instance
 * 
 * @param entityPath Full path to entity and associations. For example:
 *        {@code Pet} , {@code Pet.owner}
 * @param fieldName Property name in the given entity path. For example:
 *        {@code weight} in {@code Pet} entity, {@code age} in
 *        {@code Pet.owner} entity.
 * @param fieldType Property value {@code Class}. Must implements
 *        {@link Comparable}
 * @param order ascending or descending order
 * @return
 */
public static <T, E extends Comparable<?>> OrderSpecifier<?> createOrderSpecifier(
        PathBuilder<T> entityPath, String fieldName, Class<E> fieldType,
        Order order) {
    OrderSpecifier<?> orderBy = null;

    // Get the OrderSpecifier
    if (order == Order.ASC) {
        orderBy = entityPath.getComparable(fieldName, fieldType).asc();
    }
    else if (order == Order.DESC) {
        orderBy = entityPath.getComparable(fieldName, fieldType).desc();
    }
    return orderBy;
}
 

import com.mysema.query.types.Order; //导入依赖的package包/类
@SuppressWarnings({ "unchecked", "rawtypes" })
protected void addSorting(ExtDirectStoreReadRequest request, JPQLQuery query,
		PathBuilder<?> pathBuilder) {

	Class<?> clazz = getTypeClass();

	if (!request.getSorters().isEmpty()) {
		for (SortInfo sortInfo : request.getSorters()) {

			Order order;
			if (sortInfo.getDirection() == SortDirection.ASCENDING) {
				order = Order.ASC;
			}
			else {
				order = Order.DESC;
			}

			Field field = ReflectionUtils.findField(clazz, sortInfo.getProperty());
			SortProperty sortProperty = field.getAnnotation(SortProperty.class);

			if (sortProperty != null) {
				String[] splittedValue = sortProperty.value().split("\\.");
				field = ReflectionUtils.findField(clazz, splittedValue[0]);
				PathBuilder path = new PathBuilder(field.getType(), splittedValue[0]);
				query.leftJoin(pathBuilder.get(splittedValue[0]), path);
				query.orderBy(new OrderSpecifier(order, path.get(splittedValue[1])));
			}
			else {
				query.orderBy(new OrderSpecifier(order, pathBuilder.get(sortInfo
						.getProperty())));
			}

		}
	}
}
 

import com.mysema.query.types.Order; //导入依赖的package包/类
@SuppressWarnings({ "rawtypes", "unchecked" })
public static OrderSpecifier[] createOrderSpecifiers(
		ExtDirectStoreReadRequest request, Class<?> clazz,
		EntityPathBase<?> entityPathBase, Map<String, String> mapGuiColumn2Dbfield,
		Set<String> sortIgnoreProperties) {

	List<OrderSpecifier> orders;

	if (!request.getSorters().isEmpty()) {
		orders = new ArrayList<>();
		PathBuilder<?> entityPath = new PathBuilder<>(clazz,
				entityPathBase.getMetadata());
		for (SortInfo sortInfo : request.getSorters()) {

			if (!sortIgnoreProperties.contains(sortInfo.getProperty())) {
				Order order;
				if (sortInfo.getDirection() == SortDirection.ASCENDING) {
					order = Order.ASC;
				}
				else {
					order = Order.DESC;
				}

				String property = mapGuiColumn2Dbfield.get(sortInfo.getProperty());
				if (property == null) {
					property = sortInfo.getProperty();
				}

				orders.add(new OrderSpecifier(order, entityPath.get(property)));
			}
		}

	}
	else {
		orders = Collections.emptyList();
	}

	return orders.toArray(new OrderSpecifier[orders.size()]);
}
 

import com.mysema.query.types.Order; //导入依赖的package包/类
public void sort(OrderSpecifier<?>... order) {
    Object[] propertyId = new Object[order.length];
    boolean[] ascending = new boolean[order.length];
    for (int i = 0; i < order.length; i++) {
        propertyId[i] = ((Path)order[i].getTarget()).getMetadata().getName();
        ascending[i] = order[i].getOrder() == Order.ASC;
    }
    super.sort(propertyId, ascending);
}
 

import com.mysema.query.types.Order; //导入依赖的package包/类
public GetNotifications (
		final Order order, 
		final Long offset, 
		final Long limit, 
		final boolean includeRejected, 
		final Timestamp since) {
	
	super (order, offset, limit);
	
	this.includeRejected = includeRejected;
	this.since = since;
}
 

import com.mysema.query.types.Order; //导入依赖的package包/类
@SuppressWarnings("unchecked")
private Optional<OrderSpecifier> getOrderSpecifier(QueryParameters parameters, Expression<?>... args) {
	final String sortColumn = parameters.getSortColumn();
	final String sortDirection = parameters.getSortDirection();
	if (StringUtils.hasText(sortColumn) && StringUtils.hasText(sortDirection)) {
		Order order = (Sort.Direction.ASC.compareTo(pageableFactory.getDirection(sortDirection)) == 0) ? Order.ASC : Order.DESC;
		return Optional.of(new OrderSpecifier(order, new EntityPathBase(args[0].getType(), suppressUniquePrefixIfAny(sortColumn))));
	}
	return Optional.absent();
}
 

import com.mysema.query.types.Order; //导入依赖的package包/类
private <T extends Comparable> OrderSpecifier<T> transformOrder(QueryOrder<T> queryOrder) {
    return new OrderSpecifier<>(queryOrder.isAsc() ? Order.ASC : Order.DESC, queryOrder.getTarget());
}
 

import com.mysema.query.types.Order; //导入依赖的package包/类
public ListQuery(Order order, Long offset, Long limit) {
	this.offset = offset;
	this.limit = limit;
	this.order = order;
}
 

import com.mysema.query.types.Order; //导入依赖的package包/类
public Order getOrder() {
	return order;
}
 

import com.mysema.query.types.Order; //导入依赖的package包/类
public GetJobLog(Order order, Set<LogLevel> logLevels) {
	this(order, logLevels, null);
}
 

import com.mysema.query.types.Order; //导入依赖的package包/类
private CompletableFuture<Page<Notification>> handleListActiveNotifications (final ListActiveNotifications listNotifications) {
	final long page = listNotifications.getPage () != null ? Math.max (1, listNotifications.getPage ()) : 1;
	final long limit = listNotifications.getLimit () != null ? Math.max (1, listNotifications.getLimit ()) : DEFAULT_ITEMS_PER_PAGE;
	final long offset = Math.max (0, (page - 1) * limit);
	
	final CompletableFuture<List<Notification>> importNotificationsFuture = 
		f.ask(
			database, 
			new GetNotifications(
				Order.DESC,
				offset,
				limit,
				listNotifications.isIncludeRejected(),
				listNotifications.getSince()),
			InfoList.class)
				.thenApply(storedNotifications ->
					((InfoList<StoredNotification>)storedNotifications).getList().stream()
						.map(this::createNotification)
						.collect(Collectors.toList()));
	
	final CompletableFuture<List<Notification>> harvestNotificationsFuture = db.query().from(harvestNotification)
		.join(sourceDatasetVersion).on(sourceDatasetVersion.id.eq(harvestNotification.sourceDatasetVersionId))
		.join(sourceDataset).on(sourceDataset.id.eq(harvestNotification.sourceDatasetId))
		.where(harvestNotification.done.eq(false))
		.orderBy(harvestNotification.createTime.desc())
		.list(harvestNotification.id, harvestNotification.notificationType, 
				harvestNotification.sourceDatasetId, sourceDataset.identification, sourceDatasetVersion.name)
		.thenApply(typedList -> {
			List<Tuple> listTuple = typedList.list().stream().collect(Collectors.toList());
			
			return listTuple.stream()
				.limit(limit)
				.map(t ->
					new Notification("" + t.get(harvestNotification.id),
						new Message(
								HarvestNotificationType.getHarvestNotificationType
									(t.get(harvestNotification.notificationType)),
							new NotificationProperties(
								EntityType.SOURCE_DATASET,
								t.get(sourceDataset.identification),
								t.get(sourceDatasetVersion.name),
								null,
								null))))
			.collect(Collectors.toList());
		});
	
	return 
		importNotificationsFuture.thenCompose(importNotifications -> 
		harvestNotificationsFuture.thenApply(harvestNotifications -> {
		
		final Page.Builder<Notification> dashboardNotifications = new Page.Builder<Notification>();
		
		dashboardNotifications.addAll(harvestNotifications);
		dashboardNotifications.addAll(importNotifications);
		
		// Paging:
		long count = importNotifications.size() + harvestNotifications.size();
		long pages = count / limit + Math.min(1, count % limit);
		
		if(pages > 1) {
			dashboardNotifications
				.setHasMorePages(true)
				.setPageCount(pages)
				.setCurrentPage(page);
		}
		
		return dashboardNotifications.build();
	}));
}
 

import com.mysema.query.types.Order; //导入依赖的package包/类
private CompletableFuture<Page<Issue>> handleListIssues (final ListIssues listIssues) {
	log.debug("handleListIssues logLevels=" + listIssues.getLogLevels () + ", since=" + listIssues.getSince () + ", page=" + listIssues.getPage () + ", limit=" + listIssues.getLimit ());
	
	final Long page = listIssues.getPage () != null ? Math.max (1, listIssues.getPage ()) : 1;
	final long limit = listIssues.getLimit () != null ? Math.max (1, listIssues.getLimit ()) : DEFAULT_ITEMS_PER_PAGE;
	final long offset = Math.max (0, (page - 1) * limit);
	
	final CompletableFuture<Object> issues = f.ask (database, new GetJobLog (Order.DESC, offset, limit, listIssues.getLogLevels (), listIssues.getSince ()));
	
	return issues.thenApply(msg -> {
		final Page.Builder<Issue> dashboardIssues = new Page.Builder<Issue>();
		
		@SuppressWarnings("unchecked")
		InfoList<StoredJobLog> jobLogs = (InfoList<StoredJobLog>)msg;
		for(StoredJobLog jobLog : jobLogs.getList ()) {
			JobInfo job = jobLog.getJob();
			
			MessageType<?> type = jobLog.getType();
			
			dashboardIssues.add(
				new Issue(
					"" + job.getId(),
					new Message(
						type,
						jobLog.getContent ()
					),
					jobLog.getLevel(),
					job.getJobType(),
					jobLog.getWhen ()
				)
			);
			
		}

		// Paging:
		long count = jobLogs.getCount();
		long pages = count / limit + Math.min(1, count % limit);
		
		if(pages > 1) {
			dashboardIssues
				.setHasMorePages(true)
				.setPageCount(pages)
				.setCurrentPage(page);
		}
		
		return dashboardIssues.build();
	});	
}
 

import com.mysema.query.types.Order; //导入依赖的package包/类
/**
 * Create an order-by-element in a Query instance
 * 
 * @param entityPath Full path to entity and associations. For example:
 *        {@code Pet} , {@code Pet.owner}
 * @param fieldName Property name in the given entity path. For example:
 *        {@code weight} in {@code Pet} entity, {@code age} in
 *        {@code Pet.owner} entity.
 * @param fieldType Property value {@code Class}. Must implements
 *        {@link Comparable}
 * @param order ascending or descending order
 * @return
 */
public <T, E extends Comparable<?>> OrderSpecifier<?> createOrderSpecifier(
        PathBuilder<T> entityPath, String fieldName, Class<E> fieldType,
        Order order);