Feature Management - APIView comments (#46720)

* APIView comments

* Feature to FeatureDefinition

* Renaming a few things

Author: mrm9084

sdk/spring/spring-cloud-azure-feature-management/src/main/java/com/azure/spring/cloud/feature/management/FeatureManager.java

@@ -27,7 +27,7 @@
 import com.azure.spring.cloud.feature.management.models.Allocation;
 import com.azure.spring.cloud.feature.management.models.Conditions;
 import com.azure.spring.cloud.feature.management.models.EvaluationEvent;
-import com.azure.spring.cloud.feature.management.models.Feature;
+import com.azure.spring.cloud.feature.management.models.FeatureDefinition;
 import com.azure.spring.cloud.feature.management.models.FeatureFilterEvaluationContext;
 import com.azure.spring.cloud.feature.management.models.FeatureManagementException;
 import com.azure.spring.cloud.feature.management.models.FilterNotFoundException;
@@ -187,13 +187,13 @@ public Mono<Variant> getVariantAsync(String feature, Object featureContext) {
 
     private Mono<EvaluationEvent> checkFeature(String featureName, Object featureContext)
         throws FilterNotFoundException {
-        List<Feature> featureFlags = featureManagementConfigurations.getFeatureFlags();
+        List<FeatureDefinition> featureFlags = featureManagementConfigurations.getFeatureFlags();
 
         if (featureFlags == null) {
             return Mono.just(new EvaluationEvent(null));
         }
 
-        Feature featureFlag = featureFlags.stream()
+        FeatureDefinition featureFlag = featureFlags.stream()
             .filter(feature -> feature.getId().equals(featureName)).findAny().orElse(null);
 
         EvaluationEvent event = new EvaluationEvent(featureFlag);
@@ -233,7 +233,7 @@ private void publishTelemetryIfEnabled(EvaluationEvent event) {
 
     private Mono<EvaluationEvent> assignAllocation(Mono<EvaluationEvent> monoEvent) {
         return monoEvent.map(event -> {
-            Feature featureFlag = event.getFeature();
+            FeatureDefinition featureFlag = event.getFeature();
 
             if (featureFlag.getVariants() == null || featureFlag.getAllocation() == null) {
                 return event;
@@ -249,7 +249,7 @@ private Mono<EvaluationEvent> assignAllocation(Mono<EvaluationEvent> monoEvent)
     }
 
     private void assignDefaultDisabledReason(EvaluationEvent event) {
-        Feature featureFlag = event.getFeature();
+        FeatureDefinition featureFlag = event.getFeature();
         event.setReason(VariantAssignmentReason.DEFAULT_WHEN_DISABLED);
         if (event.getFeature().getAllocation() == null) {
             return;
@@ -270,7 +270,7 @@ private void assignDefaultEnabledVariant(EvaluationEvent event) {
         }
         this.assignVariantOverride(event.getFeature().getVariants(),
             event.getFeature().getAllocation().getDefaultWhenEnabled(), true, event);
-        Feature featureFlag = event.getFeature();
+        FeatureDefinition featureFlag = event.getFeature();
 
         if (featureFlag.getAllocation() != null) {
             event.setVariant(
@@ -280,7 +280,7 @@ private void assignDefaultEnabledVariant(EvaluationEvent event) {
     }
 
     private void assignVariant(EvaluationEvent event) {
-        Feature featureFlag = event.getFeature();
+        FeatureDefinition featureFlag = event.getFeature();
         if (featureFlag.getVariants().size() == 0 || featureFlag.getAllocation() == null) {
             return;
         }
@@ -376,7 +376,7 @@ private void assignVariantOverride(List<VariantReference> variants, String defau
     }
 
     private Mono<EvaluationEvent> checkFeatureFilters(EvaluationEvent event, Object featureContext) {
-        Feature featureFlag = event.getFeature();
+        FeatureDefinition featureFlag = event.getFeature();
         Conditions conditions = featureFlag.getConditions();
         List<FeatureFilterEvaluationContext> featureFilters = conditions.getClientFilters();
 
@@ -405,7 +405,7 @@ private Mono<EvaluationEvent> checkFeatureFilters(EvaluationEvent event, Object
         return Flux.merge(filterResults).reduce((a, b) -> a || b).single().map(result -> event.setEnabled(result));
     }
 
-    private Variant variantNameToVariant(Feature featureFlag, String variantName) {
+    private Variant variantNameToVariant(FeatureDefinition featureFlag, String variantName) {
         for (VariantReference variant : featureFlag.getVariants()) {
             if (variant.getName().equals(variantName)) {
                 return new Variant(variantName, variant.getConfigurationValue());

sdk/spring/spring-cloud-azure-feature-management/src/main/java/com/azure/spring/cloud/feature/management/filters/TargetingFilter.java

@@ -36,17 +36,17 @@ public class TargetingFilter implements FeatureFilter, ContextualFeatureFilter {
     /**
      * users field in the filter
      */
-    protected static final String USERS = "Users";
+    private static final String USERS = "Users";
 
     /**
      * groups field in the filter
      */
-    protected static final String GROUPS = "Groups";
+    private static final String GROUPS = "Groups";
 
     /**
      * Audience in the filter
      */
-    protected static final String AUDIENCE = "Audience";
+    private static final String AUDIENCE = "Audience";
 
     /**
      * Audience that always returns false
@@ -56,7 +56,7 @@ public class TargetingFilter implements FeatureFilter, ContextualFeatureFilter {
     /**
      * Error message for when the total Audience value is greater than 100 percent.
      */
-    protected static final String OUT_OF_RANGE = "The value is out of the accepted range.";
+    private static final String OUT_OF_RANGE = "The value is out of the accepted range.";
 
     private static final String REQUIRED_PARAMETER = "Value cannot be null.";
 
@@ -69,12 +69,12 @@ public class TargetingFilter implements FeatureFilter, ContextualFeatureFilter {
     /**
      * Accessor for identifying the current user/group when evaluating
      */
-    protected final TargetingContextAccessor contextAccessor;
+    private final TargetingContextAccessor contextAccessor;
 
     /**
      * Options for evaluating the filter
      */
-    protected final TargetingEvaluationOptions options;
+    private final TargetingEvaluationOptions options;
 
     /**
      * Filter for targeting a user/group/percentage of users.

sdk/spring/spring-cloud-azure-feature-management/src/main/java/com/azure/spring/cloud/feature/management/implementation/FeatureManagementProperties.java

@@ -7,7 +7,7 @@
 
 import org.springframework.boot.context.properties.ConfigurationProperties;
 
-import com.azure.spring.cloud.feature.management.models.Feature;
+import com.azure.spring.cloud.feature.management.models.FeatureDefinition;
 import com.fasterxml.jackson.annotation.JsonProperty;
 import com.fasterxml.jackson.databind.ObjectMapper;
 
@@ -20,11 +20,11 @@ public class FeatureManagementProperties {
     private static final ObjectMapper OBJECT_MAPPER = new ObjectMapper();
 
     @JsonProperty("feature-flags")
-    private List<Feature> featureFlags;
+    private List<FeatureDefinition> featureFlags;
 
     //private List<Feature> convertedFeatureFlags;
 
-    public List<Feature> getFeatureFlags() {
+    public List<FeatureDefinition> getFeatureFlags() {
         return featureFlags;
     }
 
@@ -33,19 +33,19 @@ public List<Feature> getFeatureFlags() {
      *
      * @param featureFlags the feature flags to set
      */
-    public void setFeatureFlags(List<Feature> featureFlags) {
+    public void setFeatureFlags(List<FeatureDefinition> featureFlags) {
         if (featureFlags == null || featureFlags.isEmpty()) {
             this.featureFlags = List.of();
             return;
         }
 
         // Check if the first element is a Feature instance to determine if we need conversion
-        if (featureFlags.get(0) instanceof Feature) {
-            List<Feature> features = new ArrayList<>();
+        if (featureFlags.get(0) instanceof FeatureDefinition) {
+            List<FeatureDefinition> features = new ArrayList<>();
             for (Object flag : featureFlags) {
                 // This should always be true based on our check, but we verify each element to be safe
-                if (flag instanceof Feature) {
-                    features.add((Feature) flag);
+                if (flag instanceof FeatureDefinition) {
+                    features.add((FeatureDefinition) flag);
                 }
             }
 
@@ -56,9 +56,9 @@ public void setFeatureFlags(List<Feature> featureFlags) {
         }
 
         // Convert the feature flags to the correct type
-        List<Feature> convertedFlags = new ArrayList<>();
+        List<FeatureDefinition> convertedFlags = new ArrayList<>();
         for (Object feature : featureFlags) {
-            Feature convertedFeature = OBJECT_MAPPER.convertValue(feature, Feature.class);
+            FeatureDefinition convertedFeature = OBJECT_MAPPER.convertValue(feature, FeatureDefinition.class);
             convertedFlags.add(convertedFeature);
         }
         this.featureFlags = convertedFlags;

sdk/spring/spring-cloud-azure-feature-management/src/main/java/com/azure/spring/cloud/feature/management/implementation/models/Recurrence.java

@@ -7,43 +7,48 @@
 
 /**
  * A recurrence definition describing how time window recurs
- * */
+ */
 @JsonIgnoreProperties(ignoreUnknown = true)
 public class Recurrence {
     /**
      * The recurrence pattern specifying how often the time window repeats
-     * */
+     */
     private RecurrencePattern pattern;
+
     /**
      * The recurrence range specifying how long the recurrence pattern repeats
-     * */
+     */
     private RecurrenceRange range;
 
     /**
      * @return the recurrence pattern specifying how often the time window repeats
-     * */
+     */
     public RecurrencePattern getPattern() {
         return pattern;
     }
 
     /**
      * @param pattern the recurrence pattern to be set
-     * */
-    public void setPattern(RecurrencePattern pattern) {
+     * @return the updated Recurrence object
+     */
+    public Recurrence setPattern(RecurrencePattern pattern) {
         this.pattern = pattern;
+        return this;
     }
 
     /**
      * @return the recurrence range specifying how long the recurrence pattern repeats
-     * */
+     */
     public RecurrenceRange getRange() {
         return range;
     }
 
     /**
      * @param range the recurrence range to be set
-     * */
-    public void setRange(RecurrenceRange range) {
+     * @return the updated Recurrence object
+     */
+    public Recurrence setRange(RecurrenceRange range) {
         this.range = range;
+        return this;
     }
 }

sdk/spring/spring-cloud-azure-feature-management/src/main/java/com/azure/spring/cloud/feature/management/implementation/models/RecurrencePattern.java

@@ -13,7 +13,7 @@
 
 /**
  * The recurrence pattern specifying how often the time window repeats
- * */
+ */
 @JsonIgnoreProperties(ignoreUnknown = true)
 public class RecurrencePattern {
     /**
@@ -22,8 +22,8 @@ public class RecurrencePattern {
     private RecurrencePatternType type = RecurrencePatternType.DAILY;
 
     /**
-     * The number of units between occurrences, where units can be in days, weeks, months, or years,
-     * depending on the pattern type. Default value is 1
+     * The number of units between occurrences, where units can be in days, weeks, months, or years, depending on the
+     * pattern type. Default value is 1
      */
     private Integer interval = 1;
 
@@ -34,60 +34,66 @@ public class RecurrencePattern {
 
     /**
      * The first day of the week
-     * */
+     */
     private DayOfWeek firstDayOfWeek = DayOfWeek.SUNDAY;
 
     /**
      * @return the recurrence pattern type
-     * */
+     */
     public RecurrencePatternType getType() {
         return type;
     }
 
     /**
      * @param type pattern type to be set
+     * @return the updated RecurrencePattern object
      * @throws IllegalArgumentException if type is invalid
-     * */
-    public void setType(String type) throws IllegalArgumentException {
+     */
+    public RecurrencePattern setType(String type) throws IllegalArgumentException {
         try {
             this.type = RecurrencePatternType.valueOf(type.toUpperCase());
         } catch (final IllegalArgumentException e) {
             throw new IllegalArgumentException(
-                String.format(RecurrenceConstants.INVALID_VALUE, "Recurrence.Pattern.Type", Arrays.toString(RecurrencePatternType.values())));
+                String.format(RecurrenceConstants.INVALID_VALUE, "Recurrence.Pattern.Type",
+                    Arrays.toString(RecurrencePatternType.values())));
         }
+        return this;
     }
 
     /**
      * @return the number of units between occurrences
-     * */
+     */
     public Integer getInterval() {
         return interval;
     }
 
     /**
      * @param interval the time units to be set
+     * @return the updated RecurrencePattern object
      * @throws IllegalArgumentException if interval is invalid
-     * */
-    public void setInterval(Integer interval) throws IllegalArgumentException {
+     */
+    public RecurrencePattern setInterval(Integer interval) throws IllegalArgumentException {
         if (interval == null || interval <= 0) {
             throw new IllegalArgumentException(
                 String.format(RecurrenceConstants.OUT_OF_RANGE, "Recurrence.Pattern.Interval"));
         }
         this.interval = interval;
+        return this;
     }
 
     /**
      * @return the days of the week on which the time window occurs
-     * */
+     */
     public List<DayOfWeek> getDaysOfWeek() {
         return daysOfWeek;
     }
 
     /**
      * @param daysOfWeek the days that time window occurs
+     * @return the updated RecurrencePattern object
      * @throws IllegalArgumentException if daysOfWeek is null/empty, or has invalid value
-     * */
-    public void setDaysOfWeek(List<String> daysOfWeek) throws IllegalArgumentException {
+     */
+    public RecurrencePattern setDaysOfWeek(List<String> daysOfWeek) throws IllegalArgumentException {
         if (daysOfWeek == null || daysOfWeek.size() == 0) {
             throw new IllegalArgumentException(
                 String.format(RecurrenceConstants.REQUIRED_PARAMETER, "Recurrence.Pattern.DaysOfWeek"));
@@ -99,22 +105,25 @@ public void setDaysOfWeek(List<String> daysOfWeek) throws IllegalArgumentExcepti
             }
         } catch (final IllegalArgumentException e) {
             throw new IllegalArgumentException(
-                String.format(RecurrenceConstants.INVALID_VALUE, "Recurrence.Pattern.DaysOfWeek", Arrays.toString(DayOfWeek.values())));
+                String.format(RecurrenceConstants.INVALID_VALUE, "Recurrence.Pattern.DaysOfWeek",
+                    Arrays.toString(DayOfWeek.values())));
         }
+        return this;
     }
 
     /**
      * @return the first day of the week
-     * */
+     */
     public DayOfWeek getFirstDayOfWeek() {
         return firstDayOfWeek;
     }
 
     /**
      * @param firstDayOfWeek the first day of the week
+     * @return the updated RecurrencePattern object
      * @throws IllegalArgumentException if firstDayOfWeek is invalid
-     * */
-    public void setFirstDayOfWeek(String firstDayOfWeek) throws IllegalArgumentException {
+     */
+    public RecurrencePattern setFirstDayOfWeek(String firstDayOfWeek) throws IllegalArgumentException {
         if (firstDayOfWeek == null) {
             throw new IllegalArgumentException(
                 String.format(RecurrenceConstants.REQUIRED_PARAMETER, "Recurrence.Pattern.FirstDayOfWeek"));
@@ -124,7 +133,9 @@ public void setFirstDayOfWeek(String firstDayOfWeek) throws IllegalArgumentExcep
             this.firstDayOfWeek = DayOfWeek.valueOf(firstDayOfWeek.toUpperCase());
         } catch (final IllegalArgumentException e) {
             throw new IllegalArgumentException(
-                String.format(RecurrenceConstants.INVALID_VALUE, "Recurrence.Pattern.FirstDayOfWeek", Arrays.toString(DayOfWeek.values())));
+                String.format(RecurrenceConstants.INVALID_VALUE, "Recurrence.Pattern.FirstDayOfWeek",
+                    Arrays.toString(DayOfWeek.values())));
         }
+        return this;
     }
 }