public DefaultRuleFinder(DbClient dbClient, DefaultOrganizationProvider defaultOrganizationProvider) { this.dbClient = dbClient; this.ruleDao = dbClient.ruleDao(); this.defaultOrganizationProvider = defaultOrganizationProvider; }
@CheckForNull private Collection<RuleDefinitionDto> ruleKeysToRuleId(DbSession dbSession, @Nullable Collection<String> rules) { if (rules != null) { return dbClient.ruleDao().selectDefinitionByKeys(dbSession, transform(rules, RuleKey::parse)); } return Collections.emptyList(); }
private Map<Integer, RuleDefinitionDto> getRulesByRuleIds(DbSession dbSession, List<Change> changes) { Set<Integer> ruleIds = changes.stream() .map(c -> c.ruleId) .filter(Objects::nonNull) .collect(toSet()); return dbClient.ruleDao() .selectDefinitionByIds(dbSession, Lists.newArrayList(ruleIds)) .stream() .collect(uniqueIndex(RuleDefinitionDto::getId)); }
private static Map<RuleDefinitionDto, Rule> buildRulesByRuleDefinitionDto(DbClient dbClient, DbSession dbSession) { List<RuleDefinitionDto> dtos = dbClient.ruleDao().selectAllDefinitions(dbSession); Set<RuleKey> ruleKeys = dtos.stream().map(RuleDefinitionDto::getKey).collect(toSet(dtos.size())); ListMultimap<Integer, RuleParamDto> ruleParamsByRuleId = retrieveRuleParameters(dbClient, dbSession, ruleKeys); Map<RuleDefinitionDto, Rule> rulesByDefinition = new HashMap<>(dtos.size()); for (RuleDefinitionDto definition : dtos) { rulesByDefinition.put(definition, toRule(definition, ruleParamsByRuleId.get(definition.getId()))); } return ImmutableMap.copyOf(rulesByDefinition); }
private List<Integer> disableTemplateRulesAndCustomRules(DbSession dbSession) { List<RuleDefinitionDto> rules = dbClient.ruleDao().selectAllDefinitions(dbSession).stream() .filter(r -> r.isTemplate() || r.isCustomRule()) .collect(toList()); rules.forEach(r -> { r.setStatus(RuleStatus.REMOVED); dbClient.ruleDao().update(dbSession, r); }); return rules.stream().map(RuleDefinitionDto::getId).collect(toList()); }
private List<ActiveRuleChange> importProfile(QProfileDto profile, RulesProfile definition, DbSession dbSession) { Map<RuleKey, RuleDefinitionDto> rulesByRuleKey = dbClient.ruleDao().selectAllDefinitions(dbSession) .stream() .collect(MoreCollectors.uniqueIndex(RuleDefinitionDto::getKey)); List<ActiveRule> activeRules = definition.getActiveRules(); List<RuleActivation> activations = activeRules.stream() .map(activeRule -> toRuleActivation(activeRule, rulesByRuleKey)) .filter(Objects::nonNull) .collect(MoreCollectors.toArrayList(activeRules.size())); return qProfileRules.activateAndCommit(dbSession, profile, activations); }
public RuleDefinitionDto getRule(DbSession dbSession, RuleKey ruleKey) { Optional<RuleDefinitionDto> ruleDefinitionDto = dbClient.ruleDao().selectDefinitionByKey(dbSession, ruleKey); RuleDefinitionDto rule = checkFoundWithOptional(ruleDefinitionDto, "Rule with key '%s' not found", ruleKey); checkRequest(!rule.isExternal(), "Operation forbidden for rule '%s' imported from an external rule engine.", ruleKey); return rule; }
@Before public void setUp() throws Exception { when(dbClient.openSession(anyBoolean())).thenReturn(dbSession); when(dbClient.ruleDao()).thenReturn(ruleDao); when(ruleDao.selectAll(any(DbSession.class), eq(ORGANIZATION_UUID))).thenReturn(ImmutableList.of(AB_RULE)); DeprecatedRuleKeyDto abDeprecatedRuleKey1 = deprecatedRuleKeyOf(AB_RULE, AB_RULE_DEPRECATED_KEY_1); DeprecatedRuleKeyDto abDeprecatedRuleKey2 = deprecatedRuleKeyOf(AB_RULE, AB_RULE_DEPRECATED_KEY_2); DeprecatedRuleKeyDto deprecatedRuleOfNonExistingRule = deprecatedRuleKeyOf(77777, DEPRECATED_KEY_OF_NON_EXITING_RULE); when(ruleDao.selectAllDeprecatedRuleKeys(any(DbSession.class))).thenReturn(ImmutableSet.of( abDeprecatedRuleKey1, abDeprecatedRuleKey2, deprecatedRuleOfNonExistingRule)); }
@SafeVarargs public final DeprecatedRuleKeyDto insertDeprecatedKey(Consumer<DeprecatedRuleKeyDto>... deprecatedRuleKeyDtoConsumers) { DeprecatedRuleKeyDto deprecatedRuleKeyDto = newDeprecatedRuleKey(); asList(deprecatedRuleKeyDtoConsumers).forEach(c -> c.accept(deprecatedRuleKeyDto)); db.getDbClient().ruleDao().insert(db.getSession(), deprecatedRuleKeyDto); return deprecatedRuleKeyDto; }
public void delete(RuleKey ruleKey) { try (DbSession dbSession = dbClient.openSession(false)) { RuleDefinitionDto rule = dbClient.ruleDao().selectOrFailDefinitionByKey(dbSession, ruleKey); checkArgument(rule.isCustomRule(), "Rule '%s' cannot be deleted because it is not a custom rule", rule.getKey().toString()); qProfileRules.deleteRule(dbSession, rule); rule.setStatus(RuleStatus.REMOVED); rule.setUpdatedAt(system2.now()); dbClient.ruleDao().update(dbSession, rule); ruleIndexer.commitAndIndex(dbSession, rule.getId()); } } }
@Test public void do_not_update_rules_when_no_changes() { execute(new FakeRepositoryV1()); assertThat(dbClient.ruleDao().selectAllDefinitions(db.getSession())).hasSize(3); when(system.now()).thenReturn(DATE2.getTime()); execute(new FakeRepositoryV1()); RuleDto rule1 = dbClient.ruleDao().selectOrFailByKey(db.getSession(), defaultOrganization, RULE_KEY1); assertThat(rule1.getCreatedAt()).isEqualTo(DATE1.getTime()); assertThat(rule1.getUpdatedAt()).isEqualTo(DATE1.getTime()); }
private void createCustomRuleParams(@Nullable String paramValue, RuleDefinitionDto ruleDto, RuleParamDto templateRuleParam, DbSession dbSession) { RuleParamDto ruleParamDto = RuleParamDto.createFor(ruleDto) .setName(templateRuleParam.getName()) .setType(templateRuleParam.getType()) .setDescription(templateRuleParam.getDescription()) .setDefaultValue(paramValue); dbClient.ruleDao().insertRuleParam(dbSession, ruleDto, ruleParamDto); }
private void insertRule(RuleDefinitionDto ruleDto) { dbClient.ruleDao().insert(dbSession, ruleDto); dbSession.commit(); ruleIndexer.commitAndIndex(dbSession, ruleDto.getId()); }
private ActiveRuleDto createActiveRuleWithParam(RuleDefinitionDto rule, QProfileDto profile, String value) { ActiveRuleDto activeRule = createActiveRule(rule, profile); RuleParamDto paramDto = dbClient.ruleDao().selectRuleParamsByRuleKey(session, rule.getKey()).get(0); ActiveRuleParamDto activeRuleParam = ActiveRuleParamDto.createFor(paramDto).setValue(value); dbClient.activeRuleDao().insertParam(session, activeRule, activeRuleParam); return activeRule; }
@Test public void remove_no_more_defined_external_rule() { RuleDefinitionDto rule = db.rules().insert(r -> r.setRepositoryKey("external_fake") .setStatus(READY) .setIsExternal(true) .setIsAdHoc(false)); execute(); RuleDto reloaded = dbClient.ruleDao().selectByKey(db.getSession(), defaultOrganization, rule.getKey()).get(); assertThat(reloaded.getStatus()).isEqualTo(REMOVED); }
@Test public void do_not_remove_no_more_defined_ad_hoc_rule() { RuleDefinitionDto rule = db.rules().insert(r -> r.setRepositoryKey("external_fake") .setStatus(READY) .setIsExternal(true) .setIsAdHoc(true)); execute(); RuleDto reloaded = dbClient.ruleDao().selectByKey(db.getSession(), defaultOrganization, rule.getKey()).get(); assertThat(reloaded.getStatus()).isEqualTo(READY); }
public RuleDto insertRule(RuleDefinitionDto ruleDefinition, RuleMetadataDto ruleMetadata) { db.getDbClient().ruleDao().insertOrUpdate(db.getSession(), ruleMetadata.setRuleId(ruleDefinition.getId())); db.commit(); return new RuleDto(ruleDefinition, ruleMetadata); } }
@Test public void do_not_persist_existing_external_rules() { RuleKey ruleKey = RuleKey.of("eslint", "no-cond-assign"); db.rules().insert(ruleKey, r -> r.setIsExternal(true)); ruleRepository.addOrUpdateAddHocRuleIfNeeded(ruleKey, () -> new NewAdHocRule(ScannerReport.ExternalIssue.newBuilder().setEngineId("eslint").setRuleId("no-cond-assign").build())); underTest.execute(new TestComputationStepContext()); RuleDao ruleDao = dbClient.ruleDao(); assertThat(ruleDao.selectAllDefinitions(dbClient.openSession(false))).hasSize(1); assertThat(es.countDocuments(RuleIndexDefinition.INDEX_TYPE_RULE)).isZero(); }
public RuleParamDto insertRuleParam(RuleDto rule) { RuleParamDto param = new RuleParamDto(); param.setRuleId(rule.getId()); param.setName(randomAlphabetic(10)); param.setType(RuleParamType.STRING.type()); db.getDbClient().ruleDao().insertRuleParam(db.getSession(), rule.getDefinition(), param); db.commit(); return param; }
@Test public void deactivate_rule_that_has_REMOVED_status() { RuleDefinitionDto rule = createRule(); QProfileDto profile = createProfile(rule); RuleActivation activation = RuleActivation.create(rule.getId()); activate(profile, activation); rule.setStatus(RuleStatus.REMOVED); db.getDbClient().ruleDao().update(db.getSession(), rule); List<ActiveRuleChange> changes = deactivate(profile, rule); verifyNoActiveRules(); assertThatChangeIsDeactivation(changes, rule); }