diff --git a/src/main/java/org/apache/nifi/parameter/Parameter.java b/src/main/java/org/apache/nifi/parameter/Parameter.java index ff3030f..be3c48b 100644 --- a/src/main/java/org/apache/nifi/parameter/Parameter.java +++ b/src/main/java/org/apache/nifi/parameter/Parameter.java @@ -29,6 +29,7 @@ public class Parameter { private final String parameterContextId; private final boolean provided; private final List referencedAssets; + private final List tags; private Parameter(final Builder builder) { this.descriptor = new ParameterDescriptor.Builder() @@ -39,6 +40,7 @@ private Parameter(final Builder builder) { this.parameterContextId = builder.parameterContextId; this.provided = builder.provided; + this.tags = builder.tags; this.referencedAssets = builder.referencedAssets; if (this.referencedAssets == null || this.referencedAssets.isEmpty()) { @@ -67,6 +69,13 @@ public String getParameterContextId() { return parameterContextId; } + /** + * @return The list of tags associated with this parameter, never null + */ + public List getTags() { + return tags; + } + @Override public boolean equals(final Object o) { if (this == o) { @@ -81,12 +90,13 @@ public boolean equals(final Object o) { return Objects.equals(descriptor, parameter.descriptor) && Objects.equals(value, parameter.value) && Objects.equals(parameterContextId, parameter.parameterContextId) - && Objects.equals(referencedAssets, parameter.referencedAssets); + && Objects.equals(referencedAssets, parameter.referencedAssets) + && Objects.equals(tags, parameter.tags); } @Override public int hashCode() { - return Objects.hash(descriptor, value); + return Objects.hash(descriptor, value, tags); } /** @@ -105,12 +115,14 @@ public static class Builder { private String parameterContextId; private boolean provided; private List referencedAssets = List.of(); + private List tags = List.of(); public Builder fromParameter(final Parameter parameter) { descriptor(parameter.getDescriptor()); this.parameterContextId = parameter.getParameterContextId(); this.provided = parameter.isProvided(); this.referencedAssets = parameter.getReferencedAssets() == null ? List.of() : parameter.getReferencedAssets(); + this.tags = parameter.getTags() == null ? List.of() : parameter.getTags(); if (this.referencedAssets.isEmpty()) { this.value = parameter.getValue(); } @@ -165,6 +177,11 @@ public Builder referencedAssets(final List referencedAssets) { return this; } + public Builder tags(final List tags) { + this.tags = tags == null ? List.of() : tags; + return this; + } + public Parameter build() { if (name == null) { throw new IllegalStateException("Name or Descriptor is required"); diff --git a/src/main/java/org/apache/nifi/parameter/ParameterTag.java b/src/main/java/org/apache/nifi/parameter/ParameterTag.java new file mode 100644 index 0000000..aea70cc --- /dev/null +++ b/src/main/java/org/apache/nifi/parameter/ParameterTag.java @@ -0,0 +1,71 @@ +/* + * Licensed to the Apache Software Foundation (ASF) under one or more + * contributor license agreements. See the NOTICE file distributed with + * this work for additional information regarding copyright ownership. + * The ASF licenses this file to You under the Apache License, Version 2.0 + * (the "License"); you may not use this file except in compliance with + * the License. You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ +package org.apache.nifi.parameter; + +import java.util.Objects; + +/** + * Represents a tag associated with a parameter, consisting of a key-value pair. + * Tags can be used to store metadata about parameters, such as information + * retrieved from external parameter providers that support tagging. + */ +public class ParameterTag { + private final String key; + private final String value; + + public ParameterTag(final String key, final String value) { + this.key = Objects.requireNonNull(key, "Tag key is required"); + this.value = value; + } + + /** + * @return The key of the tag + */ + public String getKey() { + return key; + } + + /** + * @return The value of the tag, may be null + */ + public String getValue() { + return value; + } + + @Override + public boolean equals(final Object o) { + if (this == o) { + return true; + } + if (o == null || getClass() != o.getClass()) { + return false; + } + final ParameterTag that = (ParameterTag) o; + return Objects.equals(key, that.key) && Objects.equals(value, that.value); + } + + @Override + public int hashCode() { + return Objects.hash(key, value); + } + + @Override + public String toString() { + return "ParameterTag[key=" + key + ", value=" + value + "]"; + } +} + diff --git a/src/test/java/org/apache/nifi/parameter/TestParameter.java b/src/test/java/org/apache/nifi/parameter/TestParameter.java index cc366ff..018d589 100644 --- a/src/test/java/org/apache/nifi/parameter/TestParameter.java +++ b/src/test/java/org/apache/nifi/parameter/TestParameter.java @@ -175,6 +175,59 @@ public void testCreateParameterFromOtherThenOverrideWithDifferentValue() { assertEquals(0, parameter.getReferencedAssets().size()); } + @Test + public void testCreateParameterWithTags() { + final List tags = List.of( + new ParameterTag("environment", "production"), + new ParameterTag("sensitive", "false") + ); + + final Parameter parameter = new Parameter.Builder() + .name("A") + .value("value") + .tags(tags) + .build(); + + assertEquals("A", parameter.getDescriptor().getName()); + assertEquals("value", parameter.getValue()); + assertNotNull(parameter.getTags()); + assertEquals(2, parameter.getTags().size()); + assertEquals("environment", parameter.getTags().get(0).getKey()); + assertEquals("production", parameter.getTags().get(0).getValue()); + assertEquals("sensitive", parameter.getTags().get(1).getKey()); + assertEquals("false", parameter.getTags().get(1).getValue()); + } + + @Test + public void testCreateParameterWithoutTags() { + final Parameter parameter = new Parameter.Builder() + .name("A") + .value("value") + .build(); + + assertNotNull(parameter.getTags()); + assertTrue(parameter.getTags().isEmpty()); + } + + @Test + public void testCreateParameterFromOtherWithTags() { + final List tags = List.of(new ParameterTag("key", "value")); + + final Parameter original = new Parameter.Builder() + .name("A") + .value("value") + .tags(tags) + .build(); + + final Parameter parameter = new Parameter.Builder() + .fromParameter(original) + .build(); + + assertEquals(1, parameter.getTags().size()); + assertEquals("key", parameter.getTags().getFirst().getKey()); + assertEquals("value", parameter.getTags().getFirst().getValue()); + } + private static class MockAsset implements Asset { private final String identifier; private final String parameterContextIdentifier;