Java AciService类代码示例

import com.autonomy.aci.client.services.AciService; //导入依赖的package包/类
@Bean
@ConditionalOnMissingBean(name = ANSWER_SERVER_ACI_SERVICE_BEAN_NAME)
public AciService answerServerAciService(@Qualifier(ACI_SERVICE_BEAN_NAME)
                                       final AciService aciService,
                                       final ConfigService<C> configService) {
    return new AbstractConfigurableAciService(aciService) {
        @Override
        public AciServerDetails getServerDetails() {
            final AnswerServerConfig answerServerConfig = configService.getConfig().getAnswerServer();
            if (answerServerConfig == null || BooleanUtils.isFalse(answerServerConfig.getEnabled())) {
                throw new IllegalStateException("Attempted to contact AnswerServer but AnswerServer is not configured");
            }

            return answerServerConfig.toAciServerDetails();
        }
    };
}
 

import com.autonomy.aci.client.services.AciService; //导入依赖的package包/类
ValidationResult<?> validate(final AciService aciService, final Collection<Statistic> requiredStatistics, final ProcessorFactory processorFactory, final IdolAnnotationsProcessorFactory annotationsProcessorFactory) {
    final ValidationResult<?> serverResult =  server.validate(aciService, null, processorFactory);

    if (!serverResult.isValid()) {
        return serverResult;
    }

    final Set<Statistic> statistics;

    try {
        statistics = aciService.executeAction(server.toAciServerDetails(), new AciParameters("GetStatus"), new StatisticProcessor(annotationsProcessorFactory));
    } catch (final ProcessorException | AciServiceException ignored) {
        return new ValidationResult<>(false, ValidationKey.CONNECTION_ERROR);
    }

    if (!statistics.containsAll(requiredStatistics)) {
        statistics.stream().filter(statistic -> !requiredStatistics.contains(statistic)).forEach(statistic -> log.debug("Additional statistic present in StatsServer: {}", statistic));

        requiredStatistics.stream().filter(requiredStatistic -> !statistics.contains(requiredStatistic)).forEach(requiredStatistic -> log.debug("Required statistic missing from StatsServer: {}", requiredStatistic));

        return new ValidationResult<>(false, ValidationKey.INVALID_CONFIGURATION);
    }

    return new ValidationResult<>(true);
}
 

import com.autonomy.aci.client.services.AciService; //导入依赖的package包/类
@Autowired
IdolLanguagesServiceImpl(final AciService contentAciService, final ProcessorFactory processorFactory) {
    this.contentAciService = contentAciService;

    getStatusProcessor = processorFactory.getResponseDataProcessor(GetStatusResponseData.class);
    languageSettingsProcessor = processorFactory.getResponseDataProcessor(LanguageSettingsResponseData.class);
}
 

import com.autonomy.aci.client.services.AciService; //导入依赖的package包/类
@Autowired
TermExpandTypeAheadService(
        final AciService contentAciService,
        final ProcessorFactory processorFactory
) {
    this.contentAciService = contentAciService;
    processor = processorFactory.getResponseDataProcessor(TermExpandResponseData.class);
}
 

import com.autonomy.aci.client.services.AciService; //导入依赖的package包/类
@Autowired
QmsTypeAheadService(
        final ConfigService<? extends IdolSearchCapable> configService,
        final AciService qmsAciService,
        final ProcessorFactory processorFactory,
        final HavenSearchAciParameterHandler havenSearchAciParameterHandler) {
    this.configService = configService;
    this.qmsAciService = qmsAciService;
    this.havenSearchAciParameterHandler = havenSearchAciParameterHandler;
    processor = processorFactory.getResponseDataProcessor(TypeAheadResponseData.class);
}
 

import com.autonomy.aci.client.services.AciService; //导入依赖的package包/类
@Bean
@ConditionalOnMissingBean(name = CONTENT_ACI_SERVICE_BEAN_NAME)
public AciService contentAciService(@Qualifier(ACI_SERVICE_BEAN_NAME)
                                    final AciService aciService,
                                    final ConfigService<C> configService) {
    return new AbstractConfigurableAciService(aciService) {
        @Override
        public AciServerDetails getServerDetails() {
            return configService.getConfig().getContentAciServerDetails();
        }
    };
}
 

import com.autonomy.aci.client.services.AciService; //导入依赖的package包/类
@Bean
@ConditionalOnMissingBean(name = QMS_ACI_SERVICE_BEAN_NAME)
public AciService qmsAciService(@Qualifier(ACI_SERVICE_BEAN_NAME)
                                final AciService aciService,
                                final ConfigService<C> configService) {
    return new AbstractConfigurableAciService(aciService) {
        @Override
        public AciServerDetails getServerDetails() {
            final QueryManipulation queryManipulation = configService.getConfig().getQueryManipulation();
            return queryManipulation != null ? queryManipulation.getServer().toAciServerDetails() : null;
        }
    };
}
 

import com.autonomy.aci.client.services.AciService; //导入依赖的package包/类
@Bean
@ConditionalOnMissingBean(name = VIEW_ACI_SERVICE_BEAN_NAME)
public AciService viewAciService(@Qualifier(ACI_SERVICE_BEAN_NAME)
                                 final AciService aciService,
                                 final ConfigService<C> configService) {
    return new AbstractConfigurableAciService(aciService) {
        @Override
        public AciServerDetails getServerDetails() {
            return configService.getConfig().getViewConfig().toAciServerDetails();
        }
    };
}
 

import com.autonomy.aci.client.services.AciService; //导入依赖的package包/类
@Autowired
AnswerServerSystemServiceImpl(final AciService aciService,
                              final AciService answerServerAciService,
                              final ProcessorFactory processorFactory) {
    this.aciService = aciService;
    this.answerServerAciService = answerServerAciService;
    processor = processorFactory.getResponseDataProcessor(GetStatusResponsedata.class);
}
 

import com.autonomy.aci.client.services.AciService; //导入依赖的package包/类
@Autowired
IdolFieldsServiceImpl(final AciService contentAciService,
                      final TagNameFactory tagNameFactory,
                      final ProcessorFactory aciResponseProcessorFactory) {
    this.contentAciService = contentAciService;
    this.tagNameFactory = tagNameFactory;
    tagNamesResponseProcessor = aciResponseProcessorFactory.getResponseDataProcessor(GetTagNamesResponseData.class);
}
 

import com.autonomy.aci.client.services.AciService; //导入依赖的package包/类
@Autowired
public IdolStatsService(
        final AciService statsServerAciService,
        final ProcessorFactory processorFactory,
        final XmlMapper xmlMapper,
        final ConfigService<IdolFindConfig> configService
) {
    this.statsServerAciService = statsServerAciService;
    this.processorFactory = processorFactory;
    this.xmlMapper = xmlMapper;
    this.configService = configService;
}
 

import com.autonomy.aci.client.services.AciService; //导入依赖的package包/类
@Bean
public AciService statsServerAciService(@Qualifier("postingAciService") final AciService aciService, final ConfigService<IdolFindConfig> configService) {
    return new AbstractConfigurableAciService(aciService) {
        @Override
        public AciServerDetails getServerDetails() {
            return configService.getConfig().getStatsServer().getServer().toAciServerDetails();
        }
    };
}
 

import com.autonomy.aci.client.services.AciService; //导入依赖的package包/类
@Bean
public AciService postingAciService(final HttpClient httpClient) {
    final AciHttpClientImpl aciHttpClient = new AciHttpClientImpl(httpClient);
    aciHttpClient.setUsePostMethod(true);

    return new AciServiceImpl(aciHttpClient);
}
 

import com.autonomy.aci.client.services.AciService; //导入依赖的package包/类
@Autowired
public IdolDatabasesServiceImpl(final AciService contentAciService, final ProcessorFactory processorFactory) {
    this.contentAciService = contentAciService;

    responseProcessor = processorFactory.getResponseDataProcessor(GetStatusResponseData.class);
}
 

import com.autonomy.aci.client.services.AciService; //导入依赖的package包/类
public ViewConfigValidator(final AciService validatorAciService, final ProcessorFactory processorFactory) {
    this.validatorAciService = validatorAciService;
    this.processorFactory = processorFactory;
}