How to use

IssueFieldsSetter

in

org.sonar.server.issue

@Override
public Function.Context setAssignee(@Nullable UserDto user) {
 updater.assign(issue, user, changeContext);
 return this;
}

@Override
public Function.Context setResolution(@Nullable String s) {
 updater.setResolution(issue, s, changeContext);
 return this;
}

public void doAutomaticTransition(DefaultIssue issue, IssueChangeContext issueChangeContext) {
 Transition transition = stateOf(issue).outAutomaticTransition(issue);
 if (transition != null) {
  functionExecutor.execute(transition.functions(), issue, issueChangeContext);
  updater.setStatus(issue, transition.to(), issueChangeContext);
 }
}

 private Collection<? extends DefaultIssue> migrateIssuesToTheRoot(List<DefaultIssue> issuesOnModule, String modulePath) {
  for (DefaultIssue i : issuesOnModule) {
   // changes the issue's component uuid, add a change and set issue as changed to enforce it is persisted to DB
   IssueChangeContext context = IssueChangeContext.createUser(new Date(analysisMetadataHolder.getAnalysisDate()), null);
   if (StringUtils.isNotBlank(modulePath)) {
    issueUpdater.setMessage(i, "[" + modulePath + "] " + i.getMessage(), context);
   }
   issueUpdater.setIssueMoved(i, component.getUuid(), context);
   // other fields (such as module, modulePath, componentKey) are read-only and set/reset for consistency only
   i.setComponentKey(component.getKey());
   i.setModuleUuid(null);
   i.setModuleUuidPath(null);
  }
  return issuesOnModule;
 }
}

 updater.setType(raw, RuleType.SECURITY_HOTSPOT, changeContext);
 updater.setStatus(raw, Issue.STATUS_REOPENED, changeContext);
 updater.setResolution(raw, null, changeContext);
 raw.setSeverity(base.severity());
} else {
 updater.setPastSeverity(raw, base.severity(), changeContext);
updater.setPastLine(raw, base.getLine());
updater.setPastLocations(raw, base.getLocations());
updater.setPastMessage(raw, base.getMessage(), changeContext);
updater.setPastGap(raw, base.gap(), changeContext);
updater.setPastEffort(raw, base.effort(), changeContext);

 .containsOnly(entry("file", new FieldDiffs.Diff("A", "B")));
verify(updater).setPastSeverity(raw, BLOCKER, issueChangeContext);
verify(updater).setPastLine(raw, 10);
verify(updater).setPastMessage(raw, "message", issueChangeContext);
verify(updater).setPastEffort(raw, Duration.create(15L), issueChangeContext);
verify(updater).setPastLocations(raw, issueLocations);

public boolean setPastSeverity(DefaultIssue issue, @Nullable String previousSeverity, IssueChangeContext context) {
 String currentSeverity = issue.severity();
 issue.setSeverity(previousSeverity);
 return setSeverity(issue, currentSeverity, context);
}

 @Override
 public Function.Context setType(RuleType type) {
  updater.setType(issue, type, changeContext);
  return this;
 }
}

public boolean setPastMessage(DefaultIssue issue, @Nullable String previousMessage, IssueChangeContext context) {
 String currentMessage = issue.message();
 issue.setMessage(previousMessage);
 return setMessage(issue, currentMessage, context);
}

@Test
public void set_past_technical_debt_without_previous_value() {
 Duration newDebt = Duration.create(15 * 8 * 60);
 issue.setEffort(newDebt);
 boolean updated = underTest.setPastEffort(issue, null, context);
 assertThat(updated).isTrue();
 assertThat(issue.effort()).isEqualTo(newDebt);
 assertThat(issue.mustSendNotifications()).isFalse();
 FieldDiffs.Diff diff = issue.currentChange().get(TECHNICAL_DEBT);
 assertThat(diff.oldValue()).isNull();
 assertThat(diff.newValue()).isEqualTo(15L * 8 * 60);
}

@Test
public void set_past_line() {
 issue.setLine(42);
 boolean updated = underTest.setPastLine(issue, 123);
 assertThat(updated).isTrue();
 assertThat(issue.isChanged()).isTrue();
 assertThat(issue.line()).isEqualTo(42);
 assertThat(issue.mustSendNotifications()).isFalse();
 // do not save change
 assertThat(issue.currentChange()).isNull();
}

@Test
public void set_past_severity() {
 issue.setSeverity("BLOCKER");
 boolean updated = underTest.setPastSeverity(issue, "INFO", context);
 assertThat(updated).isTrue();
 assertThat(issue.severity()).isEqualTo("BLOCKER");
 assertThat(issue.mustSendNotifications()).isFalse();
 FieldDiffs.Diff diff = issue.currentChange().get(SEVERITY);
 assertThat(diff.oldValue()).isEqualTo("INFO");
 assertThat(diff.newValue()).isEqualTo("BLOCKER");
}

@Test
public void set_past_message() {
 issue.setMessage("new message");
 boolean updated = underTest.setPastMessage(issue, "past message", context);
 assertThat(updated).isTrue();
 assertThat(issue.message()).isEqualTo("new message");
 // do not save change
 assertThat(issue.currentChange()).isNull();
 assertThat(issue.mustSendNotifications()).isFalse();
}

assertThat(raw.isChanged()).isTrue();
verify(updater).setType(raw, RuleType.SECURITY_HOTSPOT, issueChangeContext);
verify(updater).setStatus(raw, Issue.STATUS_REOPENED, issueChangeContext);
verify(updater).setResolution(raw, null, issueChangeContext);
verify(updater).setPastSeverity(raw, BLOCKER, issueChangeContext);
verify(updater).setPastLine(raw, 10);
verify(updater).setPastMessage(raw, "message", issueChangeContext);
verify(updater).setPastEffort(raw, Duration.create(15L), issueChangeContext);
verify(updater).setPastLocations(raw, issueLocations);

public void mergeExistingOpenIssue(DefaultIssue raw, DefaultIssue base) {
 raw.setKey(base.key());
 raw.setNew(false);
 copyFields(raw, base);
 if (base.manualSeverity()) {
  raw.setManualSeverity(true);
  raw.setSeverity(base.severity());
 } else {
  updater.setPastSeverity(raw, base.severity(), changeContext);
 }
 // set component/module related fields from base in case current component has been moved
 // (in which case base issue belongs to original file and raw issue to component)
 raw.setComponentUuid(base.componentUuid());
 raw.setComponentKey(base.componentKey());
 raw.setModuleUuid(base.moduleUuid());
 raw.setModuleUuidPath(base.moduleUuidPath());
 // fields coming from raw
 updater.setPastLine(raw, base.getLine());
 updater.setPastLocations(raw, base.getLocations());
 updater.setPastMessage(raw, base.getMessage(), changeContext);
 updater.setPastGap(raw, base.gap(), changeContext);
 updater.setPastEffort(raw, base.effort(), changeContext);
}

@Test
public void not_revert_manual_severity() {
 issue.setSeverity("MINOR").setManualSeverity(true);
 try {
  underTest.setSeverity(issue, "MAJOR", context);
 } catch (IllegalStateException e) {
  assertThat(e).hasMessage("Severity can't be changed");
 }
}

@Override
public boolean execute(Map<String, Object> properties, Context context) {
 String type = verifyTypeParameter(properties);
 return issueUpdater.setType(context.issue(), RuleType.valueOf(type), context.issueChangeContext());
}

@Test
public void set_message() {
 boolean updated = underTest.setMessage(issue, "the message", context);
 assertThat(updated).isTrue();
 assertThat(issue.isChanged()).isTrue();
 assertThat(issue.message()).isEqualTo("the message");
 assertThat(issue.mustSendNotifications()).isFalse();
}

@Test
public void set_past_technical_debt() {
 Duration newDebt = Duration.create(15 * 8 * 60);
 Duration previousDebt = Duration.create(10 * 8 * 60);
 issue.setEffort(newDebt);
 boolean updated = underTest.setPastEffort(issue, previousDebt, context);
 assertThat(updated).isTrue();
 assertThat(issue.effort()).isEqualTo(newDebt);
 assertThat(issue.mustSendNotifications()).isFalse();
 FieldDiffs.Diff diff = issue.currentChange().get(TECHNICAL_DEBT);
 assertThat(diff.oldValue()).isEqualTo(10L * 8 * 60);
 assertThat(diff.newValue()).isEqualTo(15L * 8 * 60);
}

@Test
public void set_past_line_has_no_effect_if_line_already_had_value() {
 issue.setLine(42);
 boolean updated = underTest.setPastLine(issue, 42);
 assertThat(updated).isFalse();
 assertThat(issue.isChanged()).isFalse();
 assertThat(issue.line()).isEqualTo(42);
 assertThat(issue.mustSendNotifications()).isFalse();
 // do not save change
 assertThat(issue.currentChange()).isNull();
}