Java ExtDirectMethod类代码示例

import ch.ralscha.extdirectspring.annotation.ExtDirectMethod; //导入依赖的package包/类
@ExtDirectMethod(ExtDirectMethodType.FORM_POST)
public ExtDirectFormPostResult resetRequest(
		@RequestParam("email") String emailOrLoginName) {

	String token = UUID.randomUUID().toString();

	User user = this.mongoDb.getCollection(User.class).findOneAndUpdate(
			Filters.and(
					Filters.or(Filters.eq(CUser.email, emailOrLoginName),
							Filters.eq(CUser.loginName, emailOrLoginName)),
					Filters.eq(CUser.deleted, false)),
			Updates.combine(
					Updates.set(CUser.passwordResetTokenValidUntil,
							Date.from(ZonedDateTime.now(ZoneOffset.UTC).plusHours(4)
									.toInstant())),
					Updates.set(CUser.passwordResetToken, token)),
			new FindOneAndUpdateOptions().returnDocument(ReturnDocument.AFTER)
					.upsert(false));

	if (user != null) {
		this.mailService.sendPasswortResetEmail(user);
	}

	return new ExtDirectFormPostResult();
}
 

import ch.ralscha.extdirectspring.annotation.ExtDirectMethod; //导入依赖的package包/类
@ExtDirectMethod(TREE_LOAD)
public List<Node> getTree(String node) {

	if ("root".equals(node) || !StringUtils.hasText(node)) {

		List<Node> children = this.departmentRepository
				.findAll(new Sort(Direction.ASC, "name")).stream()
				.map(d -> new Node(d.getName(), d.getName(), false, false, null))
				.collect(Collectors.toList());
		Node root = new Node("Company", "Company", false, true, children);

		return Collections.singletonList(root);
	}

	return this.userRepository.findByDepartmentOrderByLastNameAsc(node).stream()
			.map(u -> {
				return new Node(u.getId().toString(),
						u.getLastName() + " " + u.getFirstName(), true, false, null);
			}).collect(Collectors.toList());

}
 

import ch.ralscha.extdirectspring.annotation.ExtDirectMethod; //导入依赖的package包/类
@ExtDirectMethod(FORM_POST)
public ExtDirectFormPostResult handleFormSubmit(FormBean bean,
		MultipartFile screenshot) {

	String resultString = "Server received: \n" + bean.toString() + "\n";

	if (!screenshot.isEmpty()) {
		resultString += "ContentType: " + screenshot.getContentType() + "\n";
		resultString += "Size: " + screenshot.getSize() + "\n";
		resultString += "Name: " + screenshot.getOriginalFilename();
	}

	ExtDirectFormPostResult result = new ExtDirectFormPostResult();
	result.addResultProperty("response", resultString);
	return result;
}
 

import ch.ralscha.extdirectspring.annotation.ExtDirectMethod; //导入依赖的package包/类
@ExtDirectMethod
@Async
public void logClientCrash(@RequestHeader(value = HttpHeaders.USER_AGENT,
		required = false) String userAgent, Map<String, Object> crashData) {

	StringBuilder sb = new StringBuilder();
	sb.append("JavaScript Error");
	sb.append(lineSeparator);
	sb.append("User-Agent: " + userAgent);
	crashData.forEach((k, v) -> {
		sb.append(lineSeparator);
		sb.append(k);
		sb.append(": ");
		sb.append(v);
	});

	Application.logger.error(sb.toString());
}
 

import ch.ralscha.extdirectspring.annotation.ExtDirectMethod; //导入依赖的package包/类
@ExtDirectMethod(STORE_READ)
@Transactional(readOnly = true)
public List<PersistentLogin> readPersistentLogins(
		@AuthenticationPrincipal JpaUserDetails jpaUserDetails) {
	List<PersistentLogin> persistentLogins = this.jpaQueryFactory
			.selectFrom(QPersistentLogin.persistentLogin)
			.where(QPersistentLogin.persistentLogin.user.id
					.eq(jpaUserDetails.getUserDbId()))
			.fetch();

	persistentLogins.forEach(p -> {
		String ua = p.getUserAgent();
		if (StringUtils.hasText(ua)) {
			UserAgent userAgent = UserAgent.parseUserAgentString(ua);
			p.setUserAgentName(userAgent.getBrowser().getGroup().getName());
			p.setUserAgentVersion(userAgent.getBrowserVersion().getMajorVersion());
			p.setOperatingSystem(userAgent.getOperatingSystem().getName());
		}
	});

	return persistentLogins;
}
 

import ch.ralscha.extdirectspring.annotation.ExtDirectMethod; //导入依赖的package包/类
@ExtDirectMethod(STORE_READ)
@Transactional(readOnly = true)
public ExtDirectStoreResult<User> read(ExtDirectStoreReadRequest request) {

	JPQLQuery<User> query = this.jpaQueryFactory.selectFrom(QUser.user);
	if (!request.getFilters().isEmpty()) {
		StringFilter filter = (StringFilter) request.getFilters().iterator().next();

		BooleanBuilder bb = new BooleanBuilder();
		bb.or(QUser.user.loginName.containsIgnoreCase(filter.getValue()));
		bb.or(QUser.user.lastName.containsIgnoreCase(filter.getValue()));
		bb.or(QUser.user.firstName.containsIgnoreCase(filter.getValue()));
		bb.or(QUser.user.email.containsIgnoreCase(filter.getValue()));

		query.where(bb);
	}
	query.where(QUser.user.deleted.isFalse());

	QuerydslUtil.addPagingAndSorting(query, request, User.class, QUser.user);
	QueryResults<User> searchResult = query.fetchResults();

	return new ExtDirectStoreResult<>(searchResult.getTotal(),
			searchResult.getResults());
}
 

import ch.ralscha.extdirectspring.annotation.ExtDirectMethod; //导入依赖的package包/类
@ExtDirectMethod
@Transactional
public UserDetailDto getAuthUser(
		@AuthenticationPrincipal JpaUserDetails jpaUserDetails) {

	if (jpaUserDetails != null) {
		User user = jpaUserDetails.getUser(this.jpaQueryFactory);
		UserDetailDto userDetailDto = new UserDetailDto(jpaUserDetails, user, null);

		if (!jpaUserDetails.isPreAuth()) {
			user.setLastAccess(ZonedDateTime.now(ZoneOffset.UTC));
		}

		return userDetailDto;
	}

	return null;
}
 

import ch.ralscha.extdirectspring.annotation.ExtDirectMethod; //导入依赖的package包/类
@ExtDirectMethod
@RequireAdminAuthority
@Transactional(readOnly = true)
public UserDetailDto switchUser(Long userId) {
	User switchToUser = this.jpaQueryFactory.getEntityManager().find(User.class,
			userId);
	if (switchToUser != null) {

		JpaUserDetails principal = new JpaUserDetails(switchToUser);
		UsernamePasswordAuthenticationToken token = new UsernamePasswordAuthenticationToken(
				principal, null, principal.getAuthorities());

		SecurityContextHolder.getContext().setAuthentication(token);

		return new UserDetailDto(principal, switchToUser, null);
	}

	return null;
}
 

import ch.ralscha.extdirectspring.annotation.ExtDirectMethod; //导入依赖的package包/类
@ExtDirectMethod(STORE_MODIFY)
@Transactional
public ExtDirectStoreValidationResult<T> create(T newEntity) {
	preModify(newEntity);

	List<ValidationError> violations = validateEntity(newEntity);
	if (violations.isEmpty()) {
		this.entityManager.persist(newEntity);
		return new ExtDirectStoreValidationResult<>(newEntity);
	}

	ExtDirectStoreValidationResult<T> result = new ExtDirectStoreValidationResult<>(
			newEntity);
	result.setValidations(violations);
	return result;

}
 

import ch.ralscha.extdirectspring.annotation.ExtDirectMethod; //导入依赖的package包/类
@ExtDirectMethod(STORE_MODIFY)
@Transactional
public ExtDirectStoreValidationResult<T> update(T updatedEntity) {
	preModify(updatedEntity);

	List<ValidationError> violations = validateEntity(updatedEntity);
	if (violations.isEmpty()) {
		return new ExtDirectStoreValidationResult<>(
				this.entityManager.merge(updatedEntity));
	}

	ExtDirectStoreValidationResult<T> result = new ExtDirectStoreValidationResult<>(
			updatedEntity);
	result.setValidations(violations);
	return result;
}
 

import ch.ralscha.extdirectspring.annotation.ExtDirectMethod; //导入依赖的package包/类
@ExtDirectMethod(STORE_READ)
public List<PersistentLogin> readPersistentLogins(
		@AuthenticationPrincipal MongoUserDetails userDetails) {

	return StreamSupport
			.stream(this.mongoDb.getCollection(PersistentLogin.class)
					.find(Filters.eq(CPersistentLogin.userId,
							userDetails.getUserDbId()))
					.spliterator(), false)
			.peek(p -> {
				String ua = p.getUserAgent();
				if (StringUtils.hasText(ua)) {
					UserAgent userAgent = UserAgent.parseUserAgentString(ua);
					p.setUserAgentName(userAgent.getBrowser().getGroup().getName());
					p.setUserAgentVersion(
							userAgent.getBrowserVersion().getMajorVersion());
					p.setOperatingSystem(userAgent.getOperatingSystem().getName());
				}
			}).collect(Collectors.toList());

}
 

import ch.ralscha.extdirectspring.annotation.ExtDirectMethod; //导入依赖的package包/类
@ExtDirectMethod
public UserDetailDto getAuthUser(
		@AuthenticationPrincipal MongoUserDetails userDetails) {

	if (userDetails != null) {
		User user = userDetails.getUser(this.mongoDb);
		UserDetailDto userDetailDto = new UserDetailDto(userDetails, user, null);

		if (!userDetails.isPreAuth()) {
			this.mongoDb.getCollection(User.class).updateOne(
					Filters.eq(CUser.id, userDetails.getUserDbId()),
					Updates.set(CUser.lastAccess, new Date()));
		}

		return userDetailDto;
	}

	return null;
}
 

import ch.ralscha.extdirectspring.annotation.ExtDirectMethod; //导入依赖的package包/类
@ExtDirectMethod
@RequireAdminAuthority
public UserDetailDto switchUser(String userId) {
	User switchToUser = this.mongoDb.getCollection(User.class)
			.find(Filters.eq(CUser.id, userId)).first();
	if (switchToUser != null) {

		MongoUserDetails principal = new MongoUserDetails(switchToUser);
		UsernamePasswordAuthenticationToken token = new UsernamePasswordAuthenticationToken(
				principal, null, principal.getAuthorities());

		SecurityContextHolder.getContext().setAuthentication(token);

		return new UserDetailDto(principal, switchToUser, null);
	}

	return null;
}
 

import ch.ralscha.extdirectspring.annotation.ExtDirectMethod; //导入依赖的package包/类
@ExtDirectMethod(STORE_MODIFY)
public ValidationErrorsResult<Customer> create(Customer newCustomer) {
	System.out.println(newCustomer);

	List<ValidationErrors> violations = validateEntity(newCustomer);
	ValidationErrors ve = isEmailUnique(newCustomer);
	if (ve != null) {
		violations.add(ve);
	}		
	ValidationErrorsResult<Customer> result;
	if (violations.isEmpty()) {
		Customer insertedCustomer = this.customerRepository.save(newCustomer);
		System.out.println("NEW CUSTOMER: " + insertedCustomer.getId());
		result = new ValidationErrorsResult<>(insertedCustomer);
	}
	else {
		result = new ValidationErrorsResult<>(newCustomer);
		result.setValidations(violations);
	}
	return result;

}
 

import ch.ralscha.extdirectspring.annotation.ExtDirectMethod; //导入依赖的package包/类
@ExtDirectMethod(STORE_MODIFY)
public ValidationErrorsResult<Customer> update(Customer updatedCustomer) {
	List<ValidationErrors> violations = validateEntity(updatedCustomer);
	ValidationErrors ve = isEmailUnique(updatedCustomer);
	if (ve != null) {
		violations.add(ve);
	}
	ValidationErrorsResult<Customer> result;
	if (violations.isEmpty()) {
		Customer savedCustomer = this.customerRepository.save(updatedCustomer);
		result = new ValidationErrorsResult<>(savedCustomer);
	}
	else {
		result = new ValidationErrorsResult<>(updatedCustomer);
		result.setValidations(violations);
	}
	return result;
}