Application strategies part1

adks/e2e-sdk/app/steps/strategies.ts

@@ -1,9 +1,15 @@
-import { Then } from '@cucumber/cucumber';
+import {Given, Then, When} from '@cucumber/cucumber';
 import { SdkWorld } from '../support/world';
 import DataTable from '@cucumber/cucumber/lib/models/data_table';
-import { RolloutStrategy } from '../apis/mr-service';
+import {
+  ApplicationRolloutStrategy,
+  CreateApplicationRolloutStrategy,
+  RolloutStrategy,
+  RolloutStrategyInstance
+} from '../apis/mr-service';
 import waitForExpect from 'wait-for-expect';
 import { expect } from 'chai';
+import {makeid} from "../support/random";
 
 Then(/^I (cannot|can) create custom flag rollout strategies$/, async function(can: string, table: DataTable) {
   const world = this as SdkWorld;
@@ -28,6 +34,112 @@ Then(/^I (cannot|can) create custom flag rollout strategies$/, async function(ca
   }
 });
 
+Given('I create an application strategy tagged {string}', async function(strategyKey: string) {
+  const world = this as SdkWorld;
+
+  expect(world.application, 'You must have an application to create an application strategy').to.not.be.undefined;
+
+  const data = await world.applicationStrategyApi.createApplicationStrategy(world.application.id, new CreateApplicationRolloutStrategy({
+    name: makeid(10), disabled: false, attributes: []
+  }));
+  expect(data.status).to.eq(201);
+  world.applicationStrategies[strategyKey] = data.data;
+});
+
+function validateWorldForApplicationStrategies(world: SdkWorld, strategy: ApplicationRolloutStrategy, strategyKey: string) {
+  expect(strategy, `The strategy referenced by key ${strategyKey} does not exist`).to.not.be.undefined;
+  expect(world.environment).to.not.be.undefined;
+  expect(world.feature).to.not.be.undefined;
+}
+
+When('the application strategy {string} should be used in {int} environment with {int} feature', async function(key: string, envCount: number, featureCount: number) {
+  const world = this as SdkWorld;
+
+  const strategy = world.applicationStrategies[key];
+  validateWorldForApplicationStrategies(world, strategy, key);
+  const appStrategy =  await world.applicationStrategyApi.getApplicationStrategy(world.application.id, strategy.id, undefined, true);
+  expect(appStrategy.status).to.eq(200);
+  expect(appStrategy.data.usage).to.not.be.undefined;
+  expect(appStrategy.data.usage.length).to.eq(envCount);
+  if (envCount > 0) {
+    expect(appStrategy.data.usage[0].featuresCount).to.eq(featureCount);
+  }
+
+  const listStrat = await world.applicationStrategyApi.listApplicationStrategies(world.application.id, undefined, true);
+  expect(listStrat.status).to.eq(200);
+  const s = listStrat.data.items.find(str => str.id == strategy.id);
+  expect(s.usage.length).to.eq(envCount);
+  if (envCount > 0) {
+    expect(s.usage[0].featuresCount).to.eq(featureCount);
+  }
+});
+
+
+
+When('I delete the application strategy called {string} from the current environment feature value', async function (strategyKey: string) {
+  const world = this as SdkWorld;
+
+  const strategy = world.applicationStrategies[strategyKey];
+  validateWorldForApplicationStrategies(world, strategy, strategyKey);
+
+  const featureValue = await world.getFeatureValue();
+  featureValue.rolloutStrategyInstances = featureValue.rolloutStrategyInstances.filter(rsi => rsi.strategyId != strategy.id);
+  const updatedValue = await world.updateFeature(featureValue);
+  expect(updatedValue.rolloutStrategyInstances.find(rsi =>
+    rsi.strategyId === strategy.id)).to.be.undefined;
+});
+
+When('I attach application strategy {string} to the current environment feature value', async function (strategyKey: string) {
+  const world = this as SdkWorld;
+
+  const strategy = world.applicationStrategies[strategyKey];
+  validateWorldForApplicationStrategies(world, strategy, strategyKey);
+
+  const featureValue = await world.getFeatureValue();
+
+  featureValue.rolloutStrategyInstances.push(new RolloutStrategyInstance({ strategyId: strategy.id,
+    value: true }));
+
+  const updatedValue = await world.updateFeature(featureValue);
+  expect(updatedValue.rolloutStrategyInstances.find(rsi =>
+    rsi.strategyId === strategy.id && rsi.value)).to.not.be.undefined;
+});
+
+When('I swap the order of {string} and {string} they remain swapped', async function (key1: string, key2: string) {
+  const world = this as SdkWorld;
+
+  const strategy1 = world.applicationStrategies[key1];
+  validateWorldForApplicationStrategies(world, strategy1, key1);
+  const strategy2 = world.applicationStrategies[key2];
+  validateWorldForApplicationStrategies(world, strategy2, key2);
+
+  const featureValue = await world.getFeatureValue();
+  const key1Index = featureValue.rolloutStrategyInstances.findIndex(s => s.strategyId == strategy1.id);
+  expect(key1Index, `cannot find strategy ${key1} in strategies`).to.not.eq(-1);
+  const key2Index= featureValue.rolloutStrategyInstances.findIndex(s => s.strategyId == strategy2.id);
+  expect(key2Index, `cannot find strategy ${key2} in strategies`).to.not.eq(-1);
+
+  const rsi = featureValue.rolloutStrategyInstances[key1Index];
+  featureValue.rolloutStrategyInstances[key1Index] = featureValue.rolloutStrategyInstances[key2Index];
+  featureValue.rolloutStrategyInstances[key2Index] = rsi;
+
+  const updatedValue = await world.updateFeature(featureValue);
+  expect(updatedValue.rolloutStrategyInstances[key1Index].strategyId, `Strategy 2 did not swap`).to.eq(strategy2.id);
+  expect(updatedValue.rolloutStrategyInstances[key2Index].strategyId).to.eq(strategy1.id);
+});
+
+Then('there is an application strategy called {string} in the current environment feature value', async function (strategyKey: string) {
+  const world = this as SdkWorld;
+
+  const strategy = world.applicationStrategies[strategyKey];
+  validateWorldForApplicationStrategies(world, strategy, strategyKey);
+
+  const featureValue = await world.getFeatureValue();
+
+  expect(featureValue.rolloutStrategyInstances.find(rsi =>
+    rsi.strategyId === strategy.id && rsi.value)).to.not.be.undefined;
+});
+
 Then("the edge repository has a feature {string} with a strategy", async function(key: string, table: DataTable) {
   const world = this as SdkWorld;
 

adks/e2e-sdk/app/support/world.ts

@@ -15,7 +15,7 @@ import {
   ServiceAccountPermission,
   ServiceAccountServiceApi,
   TokenizedPerson,
-  WebhookServiceApi
+  WebhookServiceApi, ApplicationRolloutStrategyServiceApi, ApplicationRolloutStrategy
 } from '../apis/mr-service';
 import { axiosLoggingAttachment, logger } from './logging';
 import globalAxios, { AxiosInstance, InternalAxiosRequestConfig } from 'axios';
@@ -57,6 +57,7 @@ export class SdkWorld extends World {
   public readonly edgeApi: EdgeService;
   public readonly historyApi: FeatureHistoryServiceApi;
   public readonly systemConfigApi: SystemConfigServiceApi;
+  public readonly applicationStrategyApi: ApplicationRolloutStrategyServiceApi;
 
   public readonly webhookApi: WebhookServiceApi;
   private _clientContext: ClientContext;
@@ -66,6 +67,7 @@ export class SdkWorld extends World {
   public person: Person
   public featureGroup: FeatureGroup;
   public serviceAccount?: ServiceAccount;
+  public applicationStrategies: Record<string,ApplicationRolloutStrategy> = {};
 
   constructor(props: any) {
     super(props);
@@ -92,6 +94,7 @@ export class SdkWorld extends World {
     this.webhookApi = new WebhookServiceApi(this.adminApiConfig);
     this.historyApi = new FeatureHistoryServiceApi(this.adminApiConfig);
     this.systemConfigApi = new SystemConfigServiceApi(this.adminApiConfig);
+    this.applicationStrategyApi = new ApplicationRolloutStrategyServiceApi(this.adminApiConfig);
 
     const edgeConfig = new EdgeConfig({ basePath: this.featureUrl, axiosInstance: this.adminApiConfig.axiosInstance});
     this.edgeApi = new EdgeService(edgeConfig);

adks/e2e-sdk/features/app_strategies.feature

@@ -0,0 +1,21 @@
+Feature: We can save, change and retrieve application strategies on feature values
+
+  Background:
+    Given I create a new portfolio
+    And I create an application
+    And I create a service account and full permissions based on the application environments
+
+  @appstrat
+  Scenario: I can create a feature value with an application strategy attached
+    Given I create an application strategy tagged "first"
+    And There is a new feature flag
+    And I set the feature flag to on and unlocked
+    When I attach application strategy "first" to the current environment feature value
+    And the application strategy "first" should be used in 1 environment with 1 feature
+    Then I create an application strategy tagged "second"
+    When I attach application strategy "second" to the current environment feature value
+    And there is an application strategy called "first" in the current environment feature value
+    And I swap the order of "first" and "second" they remain swapped
+    And I delete the application strategy called "second" from the current environment feature value
+#    And I attach application strategy "first" to the current environment feature value
+#    And I set the feature flag to off and locked

admin-frontend/open_admin_app/lib/api/client_api.dart

@@ -135,14 +135,17 @@ class ManagementRepositoryClientBloc implements Bloc {
 
     _landingActions = [];
 
-    for (var action in la) { action(this); }
+    for (var action in la) {
+      action(this);
+    }
   }
 
   void swapRoutes(RouteChange route) {
     // this is for gross route changes, and causes the widget to redraw
     // for multi-tabbed routes, we don't want this to happen, so we separate the two
     if (!_routerRedrawRouteSource.hasValue ||
-        (_routerRedrawRouteSource.hasValue && _routerRedrawRouteSource.value?.route != route.route)) {
+        (_routerRedrawRouteSource.hasValue &&
+            _routerRedrawRouteSource.value?.route != route.route)) {
       _routerRedrawRouteSource.add(route);
     }
 
@@ -205,10 +208,18 @@ class ManagementRepositoryClientBloc implements Bloc {
     return personState.personCanEditFeaturesForApplication(getCurrentAid());
   }
 
+  bool get userHasAppStrategyEditRoleInCurrentApplication {
+    return personState.personCanEditStrategiesForApplication(getCurrentAid());
+  }
+
   bool get userHasFeatureCreationRoleInCurrentApplication {
     return personState.personCanCreateFeaturesForApplication(getCurrentAid());
   }
 
+  bool get userHasAppStrategyCreationRoleInCurrentApplication {
+    return personState.personCanCreateStrategiesForApplication(getCurrentAid());
+  }
+
   bool get userHasFeaturePermissionsInCurrentApplication {
     return personState.personCanAnythingFeaturesForApplication(getCurrentAid());
   }
@@ -247,12 +258,13 @@ class ManagementRepositoryClientBloc implements Bloc {
     webInterface.setOrigin();
 
     // attach a request id from this client to every outgoing request
-    (_client.apiClientDelegate as DioClientDelegate).client.interceptors.add(InterceptorsWrapper(
-      onRequest: (RequestOptions options, RequestInterceptorHandler handler) {
-        options.headers.putIfAbsent("baggage", () => "x-fh-reqid=${requestIdCounter++}" );
-        return handler.next(options);
-      }
-    ));
+    (_client.apiClientDelegate as DioClientDelegate).client.interceptors.add(
+        InterceptorsWrapper(onRequest:
+            (RequestOptions options, RequestInterceptorHandler handler) {
+      options.headers
+          .putIfAbsent("baggage", () => "x-fh-reqid=${requestIdCounter++}");
+      return handler.next(options);
+    }));
 
     _client.passErrorsAsApiResponses = true;
 
@@ -450,7 +462,6 @@ class ManagementRepositoryClientBloc implements Bloc {
   // currently empty
   void personUpdated(Person person) {}
 
-
   bool isPortfolioOrSuperAdminForCurrentPid() {
     return currentPid == null ? false : isPortfolioOrSuperAdmin(currentPid!);
   }
@@ -559,7 +570,6 @@ class ManagementRepositoryClientBloc implements Bloc {
     personState.dispose();
   }
 
-
   String registrationUrl(String token) {
     var tokenizedPart = 'register-url?token=$token';
     final url =

admin-frontend/open_admin_app/lib/common/person_state.dart

@@ -40,32 +40,65 @@ class PersonState {
     _personSource.add(p);
   }
 
-  final _featureCreateRoles = [ApplicationRoleType.EDIT, ApplicationRoleType.EDIT_AND_DELETE, ApplicationRoleType.CREATE];
-  final _featureEditDeleteRoles = [ApplicationRoleType.EDIT, ApplicationRoleType.EDIT_AND_DELETE];
+  final _featureCreateRoles = [
+    ApplicationRoleType.FEATURE_EDIT,
+    ApplicationRoleType.FEATURE_EDIT_AND_DELETE,
+    ApplicationRoleType.FEATURE_CREATE
+  ];
+  final _featureEditDeleteRoles = [
+    ApplicationRoleType.FEATURE_EDIT,
+    ApplicationRoleType.FEATURE_EDIT_AND_DELETE
+  ];
+
+  final _appStrategyCreateRoles = [
+    ApplicationRoleType.FEATURE_EDIT,
+    ApplicationRoleType.FEATURE_EDIT_AND_DELETE,
+    ApplicationRoleType.FEATURE_CREATE
+  ];
+  final _appStrategyEditDeleteRoles = [
+    ApplicationRoleType.FEATURE_EDIT,
+    ApplicationRoleType.FEATURE_EDIT_AND_DELETE
+  ];
 
   bool personCanEditFeaturesForApplication(String? appId) {
-    return _personHasApplicationRoleInApp(appId, _featureEditDeleteRoles );
+    return _personHasApplicationRoleInApp(appId, _featureEditDeleteRoles);
+  }
+
+  bool personCanEditStrategiesForApplication(String? appId) {
+    return _personHasApplicationRoleInApp(appId, _appStrategyEditDeleteRoles);
   }
 
   bool personCanCreateFeaturesForApplication(String? appId) {
-    return _personHasApplicationRoleInApp(appId, _featureCreateRoles );
+    return _personHasApplicationRoleInApp(appId, _featureCreateRoles);
+  }
+
+  bool personCanCreateStrategiesForApplication(String? appId) {
+    return _personHasApplicationRoleInApp(appId, _appStrategyCreateRoles);
   }
 
   // if we add roles that are NOT feature related, this will need to change to exclude them
   bool personCanAnythingFeaturesForApplication(String? appId) {
     return _isUserIsSuperAdmin ||
-        person.groups.any((gp) => gp.applicationRoles.any((ar) => ar.applicationId == appId && ar.roles.isNotEmpty) == true);
+        person.groups.any((gp) =>
+            gp.applicationRoles.any(
+                (ar) => ar.applicationId == appId && ar.roles.isNotEmpty) ==
+            true);
   }
 
-  bool _personHasApplicationRoleInApp(String? appId, List<ApplicationRoleType> roles) {
+  bool _personHasApplicationRoleInApp(
+      String? appId, List<ApplicationRoleType> roles) {
     if (appId == null) {
       return _isUserIsSuperAdmin;
     }
 
     return _isUserIsSuperAdmin ||
-        person.groups.any((gp) => gp.applicationRoles.any((ar) => ar.applicationId == appId &&
-            ( gp.admin == true || ar.roles.any((roleForAppInGroup) => roles.contains(roleForAppInGroup)) )
-        ) == true);
+        person.groups.any((gp) =>
+            gp.applicationRoles.any((ar) =>
+                ar.applicationId == appId &&
+                (gp.admin == true ||
+                    ar.roles.any((roleForAppInGroup) =>
+                        roles.contains(roleForAppInGroup)))) ==
+            true);
   }
 
   bool userHasPortfolioPermission(String? pid) {
@@ -80,7 +113,8 @@ class PersonState {
     if (appId == null) return false;
 
     return person.groups.any((g) =>
-        g.applicationRoles.any((appRole) => appRole.applicationId == appId) == true);
+        g.applicationRoles.any((appRole) => appRole.applicationId == appId) ==
+        true);
   }
 
   // if they are admin in a group where there is no portfolio id, they are super-admin

admin-frontend/open_admin_app/lib/config/route_handlers.dart

@@ -4,10 +4,13 @@ import 'package:open_admin_app/api/client_api.dart';
 import 'package:open_admin_app/api/router.dart';
 import 'package:open_admin_app/routes/admin_service_accounts_route.dart';
 import 'package:open_admin_app/routes/api_keys_route.dart';
+import 'package:open_admin_app/routes/application_strategies_route.dart';
 import 'package:open_admin_app/routes/apps_route.dart';
 import 'package:open_admin_app/routes/create_admin_service_accounts_route.dart';
+import 'package:open_admin_app/routes/create_application_strategy_route.dart';
 import 'package:open_admin_app/routes/create_user_route.dart';
 import 'package:open_admin_app/routes/edit_admin_service_account_route.dart';
+import 'package:open_admin_app/routes/edit_application_strategy_route.dart';
 import 'package:open_admin_app/routes/edit_user_route.dart';
 import 'package:open_admin_app/routes/feature_groups_route.dart';
 import 'package:open_admin_app/routes/features_overview_route.dart';
@@ -23,6 +26,8 @@ import 'package:open_admin_app/routes/oauth2_fail_route.dart';
 import 'package:open_admin_app/routes/register_url_route.dart';
 import 'package:open_admin_app/routes/setup_route.dart';
 import 'package:open_admin_app/routes/signin_route.dart';
+import 'package:open_admin_app/widgets/application-strategies/application_strategy_bloc.dart';
+import 'package:open_admin_app/widgets/application-strategies/edit_application_strategy_bloc.dart';
 import 'package:open_admin_app/widgets/apps/apps_bloc.dart';
 import 'package:open_admin_app/widgets/apps/manage_app_bloc.dart';
 import 'package:open_admin_app/widgets/apps/manage_service_accounts_bloc.dart';
@@ -224,6 +229,28 @@ class RouteCreator {
         child: FeatureGroupsRoute(createApp: _actionCreate(params)));
   }
 
+  Widget applicationStrategies(mrBloc,
+      {Map<String, List<String?>> params = const {}}) {
+    return BlocProvider<ApplicationStrategyBloc>(
+        creator: (context, bag) => ApplicationStrategyBloc(mrBloc),
+        child: ApplicationStrategyRoute(createApp: _actionCreate(params)));
+  }
+
+  Widget createApplicationStrategy(mrBloc,
+      {Map<String, List<String?>> params = const {}}) {
+    return BlocProvider<EditApplicationStrategyBloc>(
+        creator: (context, bag) => EditApplicationStrategyBloc(mrBloc),
+        child: const CreateApplicationStrategyRoute());
+  }
+
+  Widget editApplicationStrategy(mrBloc,
+      {Map<String, List<String?>> params = const {}}) {
+    return BlocProvider<EditApplicationStrategyBloc>(
+        creator: (context, bag) => EditApplicationStrategyBloc(mrBloc,
+            strategyId: params['id']!.elementAt(0)),
+        child: const EditApplicationStrategyRoute());
+  }
+
   Widget serviceEnvsHandler(ManagementRepositoryClientBloc mrBloc,
       {Map<String, List<String>>? params}) {
     return BlocProvider<ServiceAccountEnvBloc>(