import org.ligoj.bootstrap.core.SpringUtils; //导入依赖的package包/类
@Override
protected void executeInternal(final JobExecutionContext arg0) throws JobExecutionException {
	// Extract the job data to execute the operation
	final int schedule = arg0.getMergedJobDataMap().getInt("schedule");
	final ApplicationContext context = ObjectUtils.defaultIfNull((ApplicationContext) arg0.getMergedJobDataMap().get("context"),
			SpringUtils.getApplicationContext());
	final VmSchedule entity = context.getBean(VmScheduleRepository.class).findOneExpected(schedule);
	log.info("Executing {} for schedule {}, subscription {}", entity.getOperation(), entity.getId(), entity.getSubscription().getId());

	// Set the user
	context.getBean(SecurityHelper.class).setUserName(SecurityHelper.SYSTEM_USERNAME);

	// Execute the operation
	context.getBean(VmResource.class).execute(entity.getSubscription(), entity.getOperation());
	log.info("Succeed {} for schedule {}, subscription {}", entity.getOperation(), entity.getId(), entity.getSubscription().getId());
}
 

import org.ligoj.bootstrap.core.SpringUtils; //导入依赖的package包/类
@SuppressWarnings("unchecked")
@Before
public void mockApplicationContext() {
	final ApplicationContext applicationContext = Mockito.mock(ApplicationContext.class);
	SpringUtils.setSharedApplicationContext(applicationContext);
	mockLdapResource = Mockito.mock(GroupResource.class);
	final GroupFullLdapTask mockTask = new GroupFullLdapTask();
	mockTask.resource = mockLdapResource;
	mockTask.securityHelper = securityHelper;
	mockTask.containerScopeResource = Mockito.mock(ContainerScopeResource.class);
	Mockito.when(applicationContext.getBean(SessionSettings.class)).thenReturn(new SessionSettings());
	Mockito.when(applicationContext.getBean((Class<?>) ArgumentMatchers.any(Class.class))).thenAnswer((Answer<Object>) invocation -> {
		final Class<?> requiredType = (Class<Object>) invocation.getArguments()[0];
		if (requiredType == GroupFullLdapTask.class) {
			return mockTask;
		}
		return GroupBatchLdapResourceTest.super.applicationContext.getBean(requiredType);
	});

	final ContainerScope container = new ContainerScope();
	container.setId(1);
	container.setName("Fonction");
	container.setType(ContainerType.GROUP);
	Mockito.when(mockTask.containerScopeResource.findByName("Fonction")).thenReturn(container);
}
 

import org.ligoj.bootstrap.core.SpringUtils; //导入依赖的package包/类
@SuppressWarnings("unchecked")
@Before
public void mockApplicationContext() {
	final ApplicationContext applicationContext = Mockito.mock(ApplicationContext.class);
	SpringUtils.setSharedApplicationContext(applicationContext);
	mockLdapResource = Mockito.mock(UserOrgResource.class);
	final UserFullLdapTask mockTask = new UserFullLdapTask();
	mockTask.resource = mockLdapResource;
	mockTask.securityHelper = securityHelper;
	final UserAtomicLdapTask mockTaskUpdate = new UserAtomicLdapTask();
	mockTaskUpdate.resource = mockLdapResource;
	mockTaskUpdate.securityHelper = securityHelper;
	Mockito.when(applicationContext.getBean(SessionSettings.class)).thenReturn(new SessionSettings());
	Mockito.when(applicationContext.getBean((Class<?>) ArgumentMatchers.any(Class.class))).thenAnswer((Answer<Object>) invocation -> {
		final Class<?> requiredType = (Class<Object>) invocation.getArguments()[0];
		if (requiredType == UserFullLdapTask.class) {
			return mockTask;
		}
		if (requiredType == UserAtomicLdapTask.class) {
			return mockTaskUpdate;
		}
		return UserBatchLdapResourceTest.super.applicationContext.getBean(requiredType);
	});

	mockTaskUpdate.jaxrsFactory = ServerProviderFactory.createInstance(null);
}
 

import org.ligoj.bootstrap.core.SpringUtils; //导入依赖的package包/类
/**
 * Build a user LDAP repository from the given node.
 * 
 * @param node
 *            The node, also used as cache key.
 * @return The {@link UserLdapRepository} instance. Cache is involved.
 */
@CacheResult(cacheName = "ldap-user-repository")
public UserLdapRepository getUserLdapRepository(@CacheKey final String node) {
	log.info("Build ldap template for node {}", node);
	final Map<String, String> parameters = pvResource.getNodeParameters(node);
	final LdapContextSource contextSource = new LdapContextSource();
	contextSource.setReferral(parameters.get(PARAMETER_REFERRAL));
	contextSource.setPassword(parameters.get(PARAMETER_PASSWORD));
	contextSource.setUrl(parameters.get(PARAMETER_URL));
	contextSource.setUserDn(parameters.get(PARAMETER_USER));
	contextSource.setBase(parameters.get(PARAMETER_BASE_BN));
	contextSource.afterPropertiesSet();
	final LdapTemplate template = new LdapTemplate();
	template.setContextSource(contextSource);
	template.setIgnorePartialResultException(true);

	// A new repository instance
	final UserLdapRepository repository = new UserLdapRepository();
	repository.setTemplate(template);
	repository.setPeopleBaseDn(StringUtils.trimToEmpty(parameters.get(PARAMETER_PEOPLE_DN)));
	repository.setPeopleInternalBaseDn(parameters.get(PARAMETER_PEOPLE_INTERNAL_DN));
	repository.setQuarantineBaseDn(StringUtils.trimToEmpty(parameters.get(PARAMETER_QUARANTINE_DN)));
	repository.setDepartmentAttribute(parameters.get(PARAMETER_DEPARTMENT_ATTRIBUTE));
	repository.setLocalIdAttribute(parameters.get(PARAMETER_LOCAL_ID_ATTRIBUTE));
	repository.setUidAttribute(parameters.get(PARAMETER_UID_ATTRIBUTE));
	repository.setLockedAttribute(parameters.get(PARAMETER_LOCKED_ATTRIBUTE));
	repository.setLockedValue(parameters.get(PARAMETER_LOCKED_VALUE));
	repository.setPeopleClass(parameters.get(PARAMETER_PEOPLE_CLASS));
	repository.setCompanyPattern(StringUtils.trimToEmpty(parameters.get(PARAMETER_COMPANY_PATTERN)));

	// Complete the bean
	SpringUtils.getApplicationContext().getAutowireCapableBeanFactory().autowireBean(repository);

	return repository;
}
 

import org.ligoj.bootstrap.core.SpringUtils; //导入依赖的package包/类
/**
 * Build a group LDAP repository from the given node.
 * 
 * @param node
 *            The node, also used as cache key.
 * @param template
 *            The {@link LdapTemplate} used to query the repository.
 * @return The {@link UserLdapRepository} instance. Cache is involved.
 */
public GroupLdapRepository newGroupLdapRepository(final String node, final LdapTemplate template) {
	final Map<String, String> parameters = pvResource.getNodeParameters(node);

	// A new repository instance
	final GroupLdapRepository repository = new GroupLdapRepository();
	repository.setTemplate(template);
	repository.setGroupsBaseDn(StringUtils.trimToEmpty(parameters.get(PARAMETER_GROUPS_DN)));

	// Complete the bean
	SpringUtils.getApplicationContext().getAutowireCapableBeanFactory().autowireBean(repository);
	return repository;
}
 

import org.ligoj.bootstrap.core.SpringUtils; //导入依赖的package包/类
/**
 * Build a group LDAP repository from the given node.
 * 
 * @param node
 *            The node, also used as cache key.
 * @param template
 *            The {@link LdapTemplate} used to query the repository.
 * @return The {@link UserLdapRepository} instance. Cache is involved.
 */
public CompanyLdapRepository newCompanyLdapRepository(final String node, final LdapTemplate template) {
	final Map<String, String> parameters = pvResource.getNodeParameters(node);

	// A new repository instance
	final CompanyLdapRepository repository = new CompanyLdapRepository();
	repository.setTemplate(template);
	repository.setCompanyBaseDn(parameters.get(PARAMETER_COMPANIES_DN));
	repository.setQuarantineBaseDn(parameters.get(PARAMETER_QUARANTINE_DN));

	// Complete the bean
	SpringUtils.getApplicationContext().getAutowireCapableBeanFactory().autowireBean(repository);
	return repository;
}
 

import org.ligoj.bootstrap.core.SpringUtils; //导入依赖的package包/类
/**
 * Daily, clean old recovery requests.
 */
@Scheduled(cron = "0 0 1 1/1 * ?")
public void cleanRecoveries() {
	// @Modifying + @Scheduled + @Transactional [+protected] --> No TX, wait
	// for next release & TU
	SpringUtils.getBean(PasswordResource.class).cleanRecoveriesInternal();
}
 

import org.ligoj.bootstrap.core.SpringUtils; //导入依赖的package包/类
/**
 * Update response for a forbidden access.
 */
private void updateForbiddenAccess(final HttpServletResponse response) throws IOException {
	final Response response2 = SpringUtils.getBean(AccessDeniedExceptionMapper.class).toResponse(new AccessDeniedException(""));
	response.setStatus(response2.getStatus());
	response.setContentType(response2.getMediaType().toString());
	response.getOutputStream().write(((String) response2.getEntity()).getBytes(StandardCharsets.UTF_8));
}
 

import org.ligoj.bootstrap.core.SpringUtils; //导入依赖的package包/类
/**
 * Find one with fetched associations.
 */
private T findOne(final K id, final Map<String, JoinType> fetchedAssociations) {
	final CriteriaBuilder builder = em.getCriteriaBuilder();
	final CriteriaQuery<T> query = builder.createQuery(getDomainClass());

	// Apply fetch
	final Root<T> root = query.from(getDomainClass());
	SpringUtils.getBean(FetchHelper.class).applyFetchedAssociations(fetchedAssociations, root);

	// Apply specification
	final Specification<T> specification = (r, q, cb) -> cb.equal(r.get("id"), id);
	query.where(specification.toPredicate(root, query, builder));
	query.select(root);
	return em.createQuery(query).getSingleResult();
}
 

import org.ligoj.bootstrap.core.SpringUtils; //导入依赖的package包/类
/**
 * Create a role and one authorization for user DEFAULT_USER. Only run once.
 */
@Before
public void prepareSecurityContext() {
	if (setUpIsDone) {
		return;
	}

	final RoleResource resource = SpringUtils.getBean(RoleResource.class);
	final UserResource userResource = SpringUtils.getBean(UserResource.class);

	// Create the authorization
	final AuthorizationEditionVo authorization = new AuthorizationEditionVo();
	authorization.setPattern(SESSION_RESOURCE);
	authorization.setType(AuthorizationType.API);
	final List<AuthorizationEditionVo> authorizations = new ArrayList<>();
	authorizations.add(authorization);

	// Create the role
	final SystemRoleVo role = new SystemRoleVo();
	role.setName("test");
	role.setAuthorizations(authorizations);
	final int roleId = resource.create(role);

	final SystemUserEditionVo user = new SystemUserEditionVo();
	user.setLogin(DEFAULT_USER);
	final List<Integer> roles = new ArrayList<>();
	roles.add(roleId);
	user.setRoles(roles);
	userResource.create(user);

	setUpIsDone = true;
}
 

import org.ligoj.bootstrap.core.SpringUtils; //导入依赖的package包/类
/**
 * Restore original Spring application context
 */
@After
@Before
public void restoreApplicationContext() {
	if (applicationContext != null) {
		// This test was running in a Spring context, restore the shared context
		SpringUtils.setSharedApplicationContext(applicationContext);
	}
}
 

import org.ligoj.bootstrap.core.SpringUtils; //导入依赖的package包/类
@Before
public void init() {
	companyRepository = Mockito.mock(CompanyLdapRepository.class);
	groupRepository = Mockito.mock(GroupLdapRepository.class);
	userRepository = Mockito.mock(UserLdapRepository.class);
	iamProvider = Mockito.mock(IamProvider.class);
	final ApplicationContext applicationContext = Mockito.mock(ApplicationContext.class);
	SpringUtils.setSharedApplicationContext(applicationContext);
	final IamConfiguration iamConfiguration = new IamConfiguration();
	iamConfiguration.setCompanyRepository(companyRepository);
	iamConfiguration.setGroupRepository(groupRepository);
	iamConfiguration.setUserRepository(userRepository);
	Mockito.when(iamProvider.getConfiguration()).thenReturn(iamConfiguration);

	companies = new HashMap<>();
	companies.put("company", new CompanyOrg("dnc", "Company"));
	groups = new HashMap<>();
	final Set<String> members = new HashSet<>();
	members.add("u");
	groupLdap = new GroupOrg("dn", "Group", members);
	groups.put("group", groupLdap);
	groupLdap2 = new GroupOrg("dn2", "Group2", new HashSet<>());
	groups.put("group2", groupLdap2);
	user = new UserOrg();
	user.setId("u");
	user.setFirstName("f");
	user.setLastName("l");
	user.setCompany("company");
	final List<String> userGroups = new ArrayList<>();
	userGroups.add("group");
	user.setGroups(userGroups);
	user.setMails(Collections.singletonList("mail"));
	user2 = new UserOrg();
	user2.setId("u2");
	user2.setFirstName("f");
	user2.setLastName("l");
	user2.setCompany("company");
	user2.setGroups(new ArrayList<>());
	users = new HashMap<>();
	users.put("u", user);
	users.put("u2", user2);
	Mockito.when(companyRepository.findAllNoCache()).thenReturn(companies);
	Mockito.when(groupRepository.findAllNoCache()).thenReturn(groups);
	Mockito.when(userRepository.findAllNoCache(groups)).thenReturn(users);
	Mockito.when(companyRepository.findAll()).thenReturn(companies);
	Mockito.when(groupRepository.findAll()).thenReturn(groups);
	Mockito.when(userRepository.findAll()).thenReturn(users);
	CacheManager.getInstance().getCache("ldap").removeAll();
	
	repository = new LdapCacheRepository();
	repository.iamProvider = new IamProvider[] { iamProvider };
	repository.ldapCacheDao = Mockito.mock(LdapCacheDao.class);
}
 

import org.ligoj.bootstrap.core.SpringUtils; //导入依赖的package包/类
protected <B extends BatchElement, T extends AbstractLdapBatchTask<B>> long batch(final InputStream uploadedFile, final String[] columns,
		final String encoding, final String[] defaultColumns, final Class<B> batchType, final Class<T> taskType) throws IOException {

	// Public identifier is based on system date
	final long id = System.currentTimeMillis();

	// Check column's name validity
	final String[] sanitizeColumns = ArrayUtils.isEmpty(columns) ? defaultColumns : columns;
	checkHeaders(defaultColumns, sanitizeColumns);

	// Build CSV header from array
	final String csvHeaders = StringUtils.chop(ArrayUtils.toString(sanitizeColumns)).substring(1).replace(',', ';') + "\n";

	// Build entries
	final List<B> entries = csvForBean.toBean(batchType,
			new InputStreamReader(new SequenceInputStream(
					new ByteArrayInputStream(csvHeaders.getBytes(ObjectUtils.defaultIfNull(encoding, StandardCharsets.UTF_8.name()))),
					uploadedFile), ObjectUtils.defaultIfNull(encoding, StandardCharsets.UTF_8.name())));
	entries.removeIf(Objects::isNull);

	// Validate them
	validator.validateCheck(entries);

	// Clone the context for the asynchronous import
	final BatchTaskVo<B> importTask = new BatchTaskVo<>();
	importTask.setEntries(entries);
	importTask.setPrincipal(SecurityContextHolder.getContext().getAuthentication().getName());
	importTask.setId(id);

	// Schedule the import
	final T task = SpringUtils.getBean(taskType);
	task.configure(importTask);
	executor.execute(task);

	// Also cleanup the previous tasks
	cleanup();

	// Expose the task with internal identifier, based on current user PLUS the public identifier
	imports.put(importTask.getPrincipal() + "-" + importTask.getId(), importTask);

	// Return private task identifier
	return id;
}
 

import org.ligoj.bootstrap.core.SpringUtils; //导入依赖的package包/类
@After
public void unmockApplicationContext() {
	SpringUtils.setSharedApplicationContext(super.applicationContext);
}
 

import org.ligoj.bootstrap.core.SpringUtils; //导入依赖的package包/类
@DELETE
@Path("json-mapping")
public void throwJSonMapping() throws IOException {
	SpringUtils.getApplicationContext().getBean("jacksonProvider", com.fasterxml.jackson.jaxrs.json.JacksonJsonProvider.class);
	new ObjectMapperTrim().readValue("{\"dialDouble\":\"A\"}", SystemDialect.class);
}
 

import org.ligoj.bootstrap.core.SpringUtils; //导入依赖的package包/类
@Test
public void getCustomFieldsById() {
	final Map<Integer, CustomFieldEditor> customFieldsById = SpringUtils.getBean(JiraDao.class).getCustomFieldsById(null, new HashSet<>(),
			0);
	Assert.assertEquals(0, customFieldsById.size());
}
 

import org.ligoj.bootstrap.core.SpringUtils; //导入依赖的package包/类
/**
 * Build a User LDAP template from
 * 
 * @param node
 *            The node used as cache key.
 * @return The {@link UserLdapRepository} instance. Cache is forced.
 */
private UserLdapRepository getUserLdapRepositoryInternal(final String node) {
	return SpringUtils.getBean(LdapPluginResource.class).getUserLdapRepository(node);
}
 

import org.ligoj.bootstrap.core.SpringUtils; //导入依赖的package包/类
/**
 * Return the configuration integer value.
 * 
 * @param key
 *            The configuration key name.
 * @param defaultValue
 *            The default integer value when <code>null</code>
 * @return the configuration integer value or the default value.
 */
public int get(final String key, final int defaultValue) {
	return NumberUtils.toInt(SpringUtils.getBean(ConfigurationResource.class).get(key), defaultValue);
}