Core: Add host config for ActivityInfrastructure

src/main/java/org/prebid/server/activity/infrastructure/creator/ActivityInfrastructureCreator.java

@@ -1,6 +1,8 @@
 package org.prebid.server.activity.infrastructure.creator;
 
 import org.apache.commons.collections4.ListUtils;
+import org.apache.commons.collections4.MapUtils;
+import org.apache.commons.lang3.ObjectUtils;
 import org.prebid.server.activity.Activity;
 import org.prebid.server.activity.infrastructure.ActivityController;
 import org.prebid.server.activity.infrastructure.ActivityInfrastructure;
@@ -18,12 +20,14 @@
 import org.prebid.server.settings.model.AccountGdprConfig;
 import org.prebid.server.settings.model.AccountPrivacyConfig;
 import org.prebid.server.settings.model.GdprConfig;
+import org.prebid.server.settings.model.HostActivityInfrastructureConfiguration;
 import org.prebid.server.settings.model.Purpose;
 import org.prebid.server.settings.model.PurposeEid;
 import org.prebid.server.settings.model.Purposes;
 import org.prebid.server.settings.model.activity.AccountActivityConfiguration;
 import org.prebid.server.settings.model.activity.privacy.AccountPrivacyModuleConfig;
 import org.prebid.server.settings.model.activity.rule.AccountActivityRuleConfig;
+import org.prebid.server.util.ListUtil;
 
 import java.util.Arrays;
 import java.util.Collections;
@@ -48,16 +52,19 @@ public class ActivityInfrastructureCreator {
     private static final int MODULE_MAX_SKIP_RATE = 100;
 
     private final ActivityRuleFactory activityRuleFactory;
+    private final HostActivityInfrastructureConfiguration hostConfig;
     private final Purpose defaultPurpose4;
     private final Metrics metrics;
     private final JacksonMapper jacksonMapper;
 
     public ActivityInfrastructureCreator(ActivityRuleFactory activityRuleFactory,
+                                         HostActivityInfrastructureConfiguration hostConfig,
                                          GdprConfig gdprConfig,
                                          Metrics metrics,
                                          JacksonMapper jacksonMapper) {
 
         this.activityRuleFactory = Objects.requireNonNull(activityRuleFactory);
+        this.hostConfig = hostConfig;
         this.defaultPurpose4 = Optional.ofNullable(gdprConfig)
                 .map(GdprConfig::getPurposes)
                 .map(Purposes::getP4)
@@ -76,7 +83,8 @@ private ActivityInfrastructureDebug debugWheel(Account account, TraceLevel trace
     }
 
     Map<Activity, ActivityController> parse(Account account, GppContext gppContext, ActivityInfrastructureDebug debug) {
-        final Optional<AccountPrivacyConfig> accountPrivacyConfig = Optional.ofNullable(account.getPrivacy());
+        final Optional<AccountPrivacyConfig> accountPrivacyConfig =
+                Optional.ofNullable(mergeWithHost(account.getPrivacy()));
 
         final Map<Activity, AccountActivityConfiguration> activitiesConfiguration = accountPrivacyConfig
                 .map(AccountPrivacyConfig::getActivities)
@@ -109,10 +117,44 @@ Map<Activity, ActivityController> parse(Account account, GppContext gppContext,
                                 skipPrivacyModules,
                                 gppContext,
                                 debug)),
-                (oldValue, newValue) -> oldValue,
+                (oldValue, _) -> oldValue,
                 enumMapFactory()));
     }
 
+    private AccountPrivacyConfig mergeWithHost(AccountPrivacyConfig accountPrivacyConfig) {
+        if (hostConfig == null) {
+            return accountPrivacyConfig;
+        }
+        if (accountPrivacyConfig == null) {
+            return AccountPrivacyConfig.builder().activities(hostConfig.getActivities()).build();
+        }
+
+        final Map<Activity, AccountActivityConfiguration> activities = new EnumMap<>(Activity.class);
+        for (Activity activity : Activity.values()) {
+            final AccountActivityConfiguration merged = mergeWithHost(
+                    MapUtils.emptyIfNull(accountPrivacyConfig.getActivities()).get(activity),
+                    MapUtils.emptyIfNull(hostConfig.getActivities()).get(activity));
+
+            if (merged != null) {
+                activities.put(activity, merged);
+            }
+        }
+
+        return accountPrivacyConfig.toBuilder().activities(activities).build();
+    }
+
+    private static AccountActivityConfiguration mergeWithHost(AccountActivityConfiguration account,
+                                                              AccountActivityConfiguration host) {
+
+        return account == null || host == null
+                ? ObjectUtils.getIfNull(account, host)
+                : AccountActivityConfiguration.of(
+                ObjectUtils.getIfNull(account.getAllow(), host.getAllow()),
+                ListUtil.union(
+                        ListUtils.emptyIfNull(account.getRules()),
+                        ListUtils.emptyIfNull(host.getRules())));
+    }
+
     private BinaryOperator<AccountPrivacyModuleConfig> takeFirstAndLogDuplicates(String accountId) {
         return (first, second) -> {
             logger.warn("Duplicate configuration found for privacy module %s for account %s"

src/main/java/org/prebid/server/settings/model/HostActivityInfrastructureConfiguration.java

@@ -0,0 +1,15 @@
+package org.prebid.server.settings.model;
+
+import com.fasterxml.jackson.annotation.JsonProperty;
+import lombok.Value;
+import org.prebid.server.activity.Activity;
+import org.prebid.server.settings.model.activity.AccountActivityConfiguration;
+
+import java.util.Map;
+
+@Value(staticConstructor = "of")
+public class HostActivityInfrastructureConfiguration {
+
+    @JsonProperty("allowactivities")
+    Map<Activity, AccountActivityConfiguration> activities;
+}

src/main/java/org/prebid/server/spring/config/ActivityInfrastructureConfiguration.java

@@ -14,7 +14,10 @@
 import org.prebid.server.json.JsonLogic;
 import org.prebid.server.metric.Metrics;
 import org.prebid.server.settings.model.GdprConfig;
+import org.prebid.server.settings.model.HostActivityInfrastructureConfiguration;
+import org.springframework.beans.factory.annotation.Autowired;
 import org.springframework.beans.factory.annotation.Value;
+import org.springframework.boot.autoconfigure.condition.ConditionalOnProperty;
 import org.springframework.context.annotation.Bean;
 import org.springframework.context.annotation.Configuration;
 
@@ -87,17 +90,28 @@ PrivacyModulesRuleCreator privacyModulesRuleCreator(List<PrivacyModuleCreator> p
         }
     }
 
+    @Bean
+    @ConditionalOnProperty("activity-infrastructure")
+    HostActivityInfrastructureConfiguration hostActivityInfrastructureConfiguration(
+            @Value("activity-infrastructure") String configAsString,
+            JacksonMapper mapper) {
+
+        return mapper.decodeValue(configAsString, HostActivityInfrastructureConfiguration.class);
+    }
+
     @Bean
     ActivityRuleFactory activityRuleFactory(List<RuleCreator<?>> ruleCreators) {
         return new ActivityRuleFactory(ruleCreators);
     }
 
     @Bean
-    ActivityInfrastructureCreator activityInfrastructureCreator(ActivityRuleFactory activityRuleFactory,
-                                                                GdprConfig gdprConfig,
-                                                                Metrics metrics,
-                                                                JacksonMapper jacksonMapper) {
-
-        return new ActivityInfrastructureCreator(activityRuleFactory, gdprConfig, metrics, jacksonMapper);
+    ActivityInfrastructureCreator activityInfrastructureCreator(
+            ActivityRuleFactory activityRuleFactory,
+            @Autowired(required = false) HostActivityInfrastructureConfiguration hostConfig,
+            GdprConfig gdprConfig,
+            Metrics metrics,
+            JacksonMapper jacksonMapper) {
+
+        return new ActivityInfrastructureCreator(activityRuleFactory, hostConfig, gdprConfig, metrics, jacksonMapper);
     }
 }

src/test/java/org/prebid/server/activity/infrastructure/ActivityControllerTest.java

@@ -26,7 +26,7 @@ public class ActivityControllerTest {
     @Test
     public void isAllowedShouldReturnDefaultResultIfAllRulesReturnsAbstain() {
         // given
-        final Rule rule = TestRule.disallowIfMatches(payload -> false);
+        final Rule rule = TestRule.noMatchAndDisallow();
         final ActivityController activityController = ActivityController.of(true, singletonList(rule), debug);
 
         // when
@@ -44,9 +44,10 @@ public void isAllowedShouldReturnFalse() {
         final ActivityController activityController = ActivityController.of(
                 true,
                 asList(
-                        TestRule.allowIfMatches(payload -> false),
-                        TestRule.disallowIfMatches(payload -> true),
-                        TestRule.disallowIfMatches(payload -> false)),
+                        TestRule.noMatchAndAllow(),
+                        TestRule.noMatchAndDisallow(),
+                        TestRule.matchAndDisallow(),
+                        TestRule.matchAndAllow()),
                 debug);
 
         // when
@@ -55,7 +56,7 @@ public void isAllowedShouldReturnFalse() {
         // then
         assertThat(result).isFalse();
         verify(debug).emitActivityInvocationDefaultResult(true);
-        verify(debug, times(2)).emitProcessedRule(any(), any());
+        verify(debug, times(3)).emitProcessedRule(any(), any());
     }
 
     @Test
@@ -64,9 +65,10 @@ public void isAllowedShouldReturnTrue() {
         final ActivityController activityController = ActivityController.of(
                 false,
                 asList(
-                        TestRule.allowIfMatches(payload -> false),
-                        TestRule.allowIfMatches(payload -> true),
-                        TestRule.disallowIfMatches(payload -> false)),
+                        TestRule.noMatchAndAllow(),
+                        TestRule.noMatchAndDisallow(),
+                        TestRule.matchAndAllow(),
+                        TestRule.matchAndDisallow()),
                 debug);
 
         // when
@@ -75,6 +77,6 @@ public void isAllowedShouldReturnTrue() {
         // then
         assertThat(result).isTrue();
         verify(debug).emitActivityInvocationDefaultResult(false);
-        verify(debug, times(2)).emitProcessedRule(any(), any());
+        verify(debug, times(3)).emitProcessedRule(any(), any());
     }
 }