public RuleType type() { return RuleType.valueOf(getField(IssueIndexDefinition.FIELD_ISSUE_TYPE)); }
private Set<String> listAvailableActions(IssueDto issue, ComponentDto project) { Set<String> availableActions = newHashSet(); String login = userSession.getLogin(); if (login == null) { return Collections.emptySet(); } RuleType ruleType = RuleType.valueOf(issue.getType()); availableActions.add(COMMENT_KEY); if (issue.getResolution() != null) { return availableActions; } if (ruleType != RuleType.SECURITY_HOTSPOT) { availableActions.add(ASSIGN_KEY); } availableActions.add("set_tags"); if (!issue.isFromHotspot() && userSession.hasComponentPermission(ISSUE_ADMIN, project)) { availableActions.add(SET_TYPE_KEY); } if ((ruleType != RuleType.SECURITY_HOTSPOT && userSession.hasComponentPermission(ISSUE_ADMIN, project))) { availableActions.add(SET_SEVERITY_KEY); } return availableActions; }
@Override public boolean execute(Map<String, Object> properties, Context context) { String type = verifyTypeParameter(properties); return issueUpdater.setType(context.issue(), RuleType.valueOf(type), context.issueChangeContext()); }
public NewAdHocRule(ScannerReport.AdHocRule ruleFromScannerReport) { Preconditions.checkArgument(isNotBlank(ruleFromScannerReport.getEngineId()), "'engine id' not expected to be null for an ad hoc rule"); Preconditions.checkArgument(isNotBlank(ruleFromScannerReport.getRuleId()), "'rule id' not expected to be null for an ad hoc rule"); Preconditions.checkArgument(isNotBlank(ruleFromScannerReport.getName()), "'name' not expected to be null for an ad hoc rule"); Preconditions.checkArgument(ruleFromScannerReport.getSeverity() != Constants.Severity.UNSET_SEVERITY , "'severity' not expected to be null for an ad hoc rule"); Preconditions.checkArgument(ruleFromScannerReport.getType() != ScannerReport.IssueType.UNSET, "'issue type' not expected to be null for an ad hoc rule"); this.key = RuleKey.of(RuleKey.EXTERNAL_RULE_REPO_PREFIX + ruleFromScannerReport.getEngineId(), ruleFromScannerReport.getRuleId()); this.engineId = ruleFromScannerReport.getEngineId(); this.ruleId = ruleFromScannerReport.getRuleId(); this.name = ruleFromScannerReport.getName(); this.description = trimToNull(ruleFromScannerReport.getDescription()); this.severity = ruleFromScannerReport.getSeverity().name(); this.ruleType = RuleType.valueOf(ruleFromScannerReport.getType().name()); this.hasDetails = true; }
@Override public void handle(Request request, Response response) throws Exception { userSession.checkLoggedIn(); String issueKey = request.mandatoryParam(PARAM_ISSUE); RuleType ruleType = RuleType.valueOf(request.mandatoryParam(PARAM_TYPE)); try (DbSession session = dbClient.openSession(false)) { SearchResponseData preloadedSearchResponseData = setType(session, issueKey, ruleType); responseWriter.write(issueKey, preloadedSearchResponseData, request, response); } }
private static void handleIssue(IssueDto issue, ScannerInput.ServerIssue.Builder issueBuilder, Map<String, String> keysByUUid, OutputStream out) { issueBuilder.setKey(issue.getKey()); String moduleUuid = extractModuleUuid(issue); issueBuilder.setModuleKey(keysByUUid.get(moduleUuid)); ofNullable(issue.getFilePath()).ifPresent(issueBuilder::setPath); issueBuilder.setRuleRepository(issue.getRuleRepo()); issueBuilder.setRuleKey(issue.getRule()); ofNullable(issue.getChecksum()).ifPresent(issueBuilder::setChecksum); ofNullable(issue.getAssigneeUuid()).ifPresent(issueBuilder::setAssigneeLogin); ofNullable(issue.getLine()).ifPresent(issueBuilder::setLine); ofNullable(issue.getMessage()).ifPresent(issueBuilder::setMsg); issueBuilder.setSeverity(org.sonar.scanner.protocol.Constants.Severity.valueOf(issue.getSeverity())); issueBuilder.setManualSeverity(issue.isManualSeverity()); issueBuilder.setStatus(issue.getStatus()); ofNullable(issue.getResolution()).ifPresent(issueBuilder::setResolution); issueBuilder.setType(RuleType.valueOf(issue.getType()).name()); issueBuilder.setCreationDate(issue.getIssueCreationTime()); try { issueBuilder.build().writeDelimitedTo(out); } catch (IOException e) { throw new IllegalStateException("Unable to serialize issue", e); } issueBuilder.clear(); }
.setGapDescription(gapDescription); if (type != null) { rule.setType(RuleType.valueOf(type));
@Test public void valueOf_throws_ISE_if_unsupported_db_constant() { expectedException.expect(IllegalArgumentException.class); expectedException.expectMessage("Unsupported type value : 5"); RuleType.valueOf(5); }
IssueCounter(Collection<IssueGroupDto> groups) { for (IssueGroupDto group : groups) { RuleType ruleType = RuleType.valueOf(group.getRuleType()); if (group.getResolution() == null) { highestSeverityOfUnresolved .computeIfAbsent(ruleType, k -> new HighestSeverity()) .add(group); effortOfUnresolved .computeIfAbsent(ruleType, k -> new Effort()) .add(group); unresolvedBySeverity .computeIfAbsent(group.getSeverity(), k -> new Count()) .add(group); unresolvedByType .computeIfAbsent(ruleType, k -> new Count()) .add(group); unresolved.add(group); } else { byResolution .computeIfAbsent(group.getResolution(), k -> new Count()) .add(group); } if (group.getStatus() != null) { byStatus .computeIfAbsent(group.getStatus(), k -> new Count()) .add(group); } } }
private boolean importIssue(Issue issue) { NewExternalIssue externalIssue = context.newExternalIssue() .engineId(issue.engineId) .ruleId(issue.ruleId) .severity(Severity.valueOf(issue.severity)) .type(RuleType.valueOf(issue.type)); if (issue.effortMinutes != null) { externalIssue.remediationEffortMinutes(Long.valueOf(issue.effortMinutes)); } NewIssueLocation primary = fillLocation(context, externalIssue.newLocation(), issue.primaryLocation); if (primary != null) { knownFiles.add(issue.primaryLocation.filePath); externalIssue.at(primary); if (issue.secondaryLocations != null) { for (Location l : issue.secondaryLocations) { NewIssueLocation secondary = fillLocation(context, externalIssue.newLocation(), l); if (secondary != null) { externalIssue.addLocation(secondary); } } } externalIssue.save(); return true; } else { unknownFiles.add(issue.primaryLocation.filePath); return false; } }
doc.setType(RuleType.valueOf(rs.getInt(22))); String securityStandards = rs.getString(23);
private void assertRuleDefinitionFieldsAreEquals(RuleDefinitionDto r1, RuleForIndexingDto firstRule) { assertThat(firstRule.getId()).isEqualTo(r1.getId()); assertThat(firstRule.getRuleKey()).isEqualTo(r1.getKey()); assertThat(firstRule.getRepository()).isEqualTo(r1.getRepositoryKey()); assertThat(firstRule.getPluginRuleKey()).isEqualTo(r1.getRuleKey()); assertThat(firstRule.getName()).isEqualTo(r1.getName()); assertThat(firstRule.getDescription()).isEqualTo(r1.getDescription()); assertThat(firstRule.getDescriptionFormat()).isEqualTo(r1.getDescriptionFormat()); assertThat(firstRule.getSeverity()).isEqualTo(r1.getSeverity()); assertThat(firstRule.getSeverityAsString()).isEqualTo(SeverityUtil.getSeverityFromOrdinal(r1.getSeverity())); assertThat(firstRule.getStatus()).isEqualTo(r1.getStatus()); assertThat(firstRule.isTemplate()).isEqualTo(r1.isTemplate()); assertThat(firstRule.getSystemTagsAsSet()).isEqualTo(r1.getSystemTags()); assertThat(firstRule.getSecurityStandardsAsSet()).isEqualTo(r1.getSecurityStandards()); assertThat(firstRule.getInternalKey()).isEqualTo(r1.getConfigKey()); assertThat(firstRule.getLanguage()).isEqualTo(r1.getLanguage()); assertThat(firstRule.getType()).isEqualTo(r1.getType()); assertThat(firstRule.getTypeAsRuleType()).isEqualTo(RuleType.valueOf(r1.getType())); assertThat(firstRule.getCreatedAt()).isEqualTo(r1.getCreatedAt()); assertThat(firstRule.getUpdatedAt()).isEqualTo(r1.getUpdatedAt()); }
@Test public void return_all_rule_fields_by_default() { RuleDefinitionDto rule = db.rules().insert(r -> r.setLanguage("java")); indexRules(); Rules.SearchResponse response = ws.newRequest().executeProtobuf(Rules.SearchResponse.class); Rules.Rule result = response.getRules(0); assertThat(result.getCreatedAt()).isNotEmpty(); assertThat(result.getEffortToFixDescription()).isNotEmpty(); assertThat(result.getHtmlDesc()).isNotEmpty(); assertThat(result.hasIsTemplate()).isTrue(); assertThat(result.getLang()).isEqualTo(rule.getLanguage()); assertThat(result.getLangName()).isEqualTo(languages.get(rule.getLanguage()).getName()); assertThat(result.getName()).isNotEmpty(); assertThat(result.getRepo()).isNotEmpty(); assertThat(result.getSeverity()).isNotEmpty(); assertThat(result.getType().name()).isEqualTo(RuleType.valueOf(rule.getType()).name()); }
@Override public void handle(Request request, Response response) throws Exception { ruleWsSupport.checkQProfileAdminPermissionOnDefaultOrganization(); String customKey = request.mandatoryParam(PARAM_CUSTOM_KEY); try (DbSession dbSession = dbClient.openSession(false)) { try { NewCustomRule newRule = NewCustomRule.createForCustomRule(customKey, RuleKey.parse(request.mandatoryParam(PARAM_TEMPLATE_KEY))) .setName(request.mandatoryParam(PARAM_NAME)) .setMarkdownDescription(request.mandatoryParam(PARAM_DESCRIPTION)) .setSeverity(request.mandatoryParam(PARAM_SEVERITY)) .setStatus(RuleStatus.valueOf(request.mandatoryParam(PARAM_STATUS))) .setPreventReactivation(request.mandatoryParamAsBoolean(PARAM_PREVENT_REACTIVATION)); String params = request.param(PARAMS); if (!isNullOrEmpty(params)) { newRule.setParameters(KeyValueFormat.parse(params)); } ofNullable(request.param(PARAM_TYPE)).ifPresent(t -> newRule.setType(RuleType.valueOf(t))); writeResponse(dbSession, request, response, ruleCreator.create(dbSession, newRule)); } catch (ReactivationException e) { response.stream().setStatus(HTTP_CONFLICT); writeResponse(dbSession, request, response, e.ruleKey()); } } }
changed = true; RuleType type = RuleType.valueOf(def.type().name()); if (!ObjectUtils.equals(dto.getType(), type.getDbConstant())) { dto.setType(type);
public DefaultIssue toDefaultIssue() { DefaultIssue issue = new DefaultIssue(); issue.setKey(kee); issue.setType(RuleType.valueOf(type)); issue.setStatus(status); issue.setResolution(resolution);
.setSystemTags(ruleDef.tags()) .setSecurityStandards(ruleDef.securityStandards()) .setType(RuleType.valueOf(ruleDef.type().name())) .setScope(toDtoScope(ruleDef.scope())) .setIsExternal(ruleDef.repository().isExternal())
@Override public boolean execute(Map<String, Object> properties, Context context) { String type = verifyTypeParameter(properties); return issueUpdater.setType(context.issue(), RuleType.valueOf(type), context.issueChangeContext()); }
@Override public void handle(Request request, Response response) throws Exception { userSession.checkLoggedIn(); String issueKey = request.mandatoryParam(PARAM_ISSUE); RuleType ruleType = RuleType.valueOf(request.mandatoryParam(PARAM_TYPE)); try (DbSession session = dbClient.openSession(false)) { SearchResponseData preloadedSearchResponseData = setType(session, issueKey, ruleType); responseWriter.write(issueKey, preloadedSearchResponseData, request, response); } }