add warning icon when custom and condition weights don't add up, refactor helper methods to make them shareable between components and consistent

Author: danoswaltCL

frontend/projects/upgrade/src/app/core/experiments/condition-helper.service.spec.ts

@@ -7,7 +7,83 @@ import {
   ExperimentCondition,
   UpdateExperimentConditionsRequest,
   ConditionFormData,
+  WeightingMethod,
+  WEIGHTING_METHOD,
 } from './store/experiments.model';
+import { ConditionWeightUpdate } from '../../features/dashboard/experiments/modals/edit-condition-weights-modal/edit-condition-weights-modal.component';
+
+export const WEIGHT_CONFIG = {
+  TOTAL_WEIGHT: 100,
+  DECIMAL_PLACES: 2,
+  VALIDATION_TOLERANCE: 0.1, // Allow rounding errors from equal distribution (e.g., 3 × 33.33 = 99.99)
+} as const;
+
+// ============================================================================
+// Pure Functions (exported for use in selectors and other pure contexts)
+// ============================================================================
+
+/**
+ * Round to configured decimal places (2 decimals)
+ */
+function roundToDecimalPlaces(value: number): number {
+  const multiplier = Math.pow(10, WEIGHT_CONFIG.DECIMAL_PLACES);
+  return Math.round(value * multiplier) / multiplier;
+}
+
+/**
+ * Check if two weights are equal within tolerance
+ */
+function isWeightEqual(actual: number, expected: number): boolean {
+  return Math.abs(actual - expected) < WEIGHT_CONFIG.VALIDATION_TOLERANCE;
+}
+
+/**
+ * Determine the weighting method for a set of conditions.
+ * Returns 'equal' if all weights are the same, 'custom' otherwise.
+ */
+export function determineWeightingMethod(conditions: ExperimentCondition[] | null | undefined): WeightingMethod {
+  if (!conditions || conditions.length === 0) {
+    return WEIGHTING_METHOD.EQUAL; // Default to equal weighting for new experiments
+  }
+
+  const expectedWeight = roundToDecimalPlaces(WEIGHT_CONFIG.TOTAL_WEIGHT / conditions.length);
+  const isEqual = conditions.every((condition) => isWeightEqual(condition.assignmentWeight, expectedWeight));
+
+  return isEqual ? WEIGHTING_METHOD.EQUAL : WEIGHTING_METHOD.CUSTOM;
+}
+
+/**
+ * Distributes weights equally across all conditions.
+ * All conditions get the exact same weight rounded to 2 decimals.
+ * Total may be 99.99% or 100.01% due to rounding - this is acceptable.
+ */
+export function distributeWeightsEqually(conditions: ExperimentCondition[] | ConditionWeightUpdate[]): void {
+  if (!conditions || conditions.length === 0) return;
+
+  const equalWeight = roundToDecimalPlaces(WEIGHT_CONFIG.TOTAL_WEIGHT / conditions.length);
+
+  conditions.forEach((condition) => {
+    condition.assignmentWeight = equalWeight;
+  });
+}
+
+/**
+ * Check if total weights sum to 100 within tolerance.
+ * Used for validation warnings.
+ */
+export function isWeightSumValid(conditions: ExperimentCondition[] | null | undefined): boolean {
+  if (!conditions || conditions.length === 0) {
+    return true;
+  }
+
+  const totalWeight = conditions.reduce((sum, condition) => sum + (condition.assignmentWeight || 0), 0);
+
+  return Math.abs(totalWeight - WEIGHT_CONFIG.TOTAL_WEIGHT) < WEIGHT_CONFIG.VALIDATION_TOLERANCE;
+}
+
+// ============================================================================
+// Service Class (for stateful operations that need dependency injection)
+// ============================================================================
 
 @Injectable({
   providedIn: 'root',
@@ -30,6 +106,12 @@ export class ConditionHelperService {
 
     const updatedConditions = [...currentConditions, newCondition] as ExperimentCondition[];
 
+    // Check if weights should be distributed equally
+    const weightingMethod = determineWeightingMethod(currentConditions);
+    if (weightingMethod === WEIGHTING_METHOD.EQUAL) {
+      distributeWeightsEqually(updatedConditions);
+    }
+
     this.updateExperimentConditions(experiment, updatedConditions);
   }
 
@@ -71,6 +153,14 @@ export class ConditionHelperService {
       ...c,
       order: index + 1,
     }));
+
+    // Check if weights should be redistributed equally
+    const weightingMethod = determineWeightingMethod(currentConditions);
+
+    if (weightingMethod === WEIGHTING_METHOD.EQUAL && reorderedConditions.length > 0) {
+      distributeWeightsEqually(reorderedConditions);
+    }
+
     this.updateExperimentConditions(updatedExperiment, reorderedConditions);
   }
 

frontend/projects/upgrade/src/app/core/experiments/condition-helper.service.ts

@@ -303,9 +303,17 @@ export interface IExperimentGraphInfo {
 }
 
 export interface ExperimentVM extends Experiment {
-  stat: IExperimentEnrollmentDetailStats;
+  stat?: IExperimentEnrollmentDetailStats;
+  weightingMethod?: WeightingMethod;
 }
 
+export type WeightingMethod = 'equal' | 'custom';
+
+export const WEIGHTING_METHOD = {
+  EQUAL: 'equal' as WeightingMethod,
+  CUSTOM: 'custom' as WeightingMethod,
+} as const;
+
 export enum UPSERT_EXPERIMENT_ACTION {
   ADD = 'add',
   EDIT = 'edit',
@@ -533,7 +541,7 @@ export const EXPERIMENT_TRANSLATION_KEYS = {
 
 export const EXPERIMENT_ROOT_DISPLAYED_COLUMNS = Object.values(EXPERIMENT_ROOT_COLUMN_NAMES);
 
-export interface ExperimentState extends EntityState<Experiment> {
+export interface ExperimentState extends EntityState<ExperimentVM> {
   isLoadingExperiment: boolean;
   isLoadingExperimentDetailStats: boolean;
   isPollingExperimentDetailStats: boolean;

frontend/projects/upgrade/src/app/core/experiments/store/experiments.model.ts

@@ -4,12 +4,13 @@ import {
   EXPERIMENT_SEARCH_KEY,
   SORT_AS_DIRECTION,
   EXPERIMENT_SORT_KEY,
+  ExperimentVM,
 } from './experiments.model';
 import { createReducer, on, Action } from '@ngrx/store';
 import * as experimentsAction from './experiments.actions';
 import { createEntityAdapter, EntityAdapter } from '@ngrx/entity';
 
-export const adapter: EntityAdapter<Experiment> = createEntityAdapter<Experiment>();
+export const adapter: EntityAdapter<ExperimentVM> = createEntityAdapter<ExperimentVM>();
 
 export const { selectIds, selectEntities, selectAll, selectTotal } = adapter.getSelectors();
 
@@ -36,6 +37,8 @@ export const initialState: ExperimentState = adapter.getInitialState({
   isLoadingContextMetaData: false,
   currentUserSelectedContext: null,
   isLoadingExperimentDelete: false,
+  stat: null,
+  weightingMethod: 'equal',
 });
 
 const reducer = createReducer(

frontend/projects/upgrade/src/app/core/experiments/store/experiments.reducer.ts

@@ -206,6 +206,8 @@ describe('Experiments Selectors', () => {
         ],
         type: EXPERIMENT_TYPE.SIMPLE,
         assignmentAlgorithm: ASSIGNMENT_ALGORITHM.RANDOM,
+        stat: null,
+        weightingMethod: 'equal',
       },
     },
     isLoadingExperiment: false,

frontend/projects/upgrade/src/app/core/experiments/store/experiments.selector.spec.ts

@@ -1,6 +1,6 @@
 import { createSelector, createFeatureSelector } from '@ngrx/store';
 import { selectAll } from './experiments.reducer';
-import { EXPERIMENT_SEARCH_KEY, ExperimentState, Experiment } from './experiments.model';
+import { EXPERIMENT_SEARCH_KEY, ExperimentState, Experiment, ExperimentVM } from './experiments.model';
 import { selectRouterState } from '../../core.state';
 import { ParticipantListTableRow } from '../../feature-flags/store/feature-flags.model';
 import {
@@ -10,6 +10,7 @@ import {
   CONSISTENCY_RULE_DISPLAY_MAP,
   ASSIGNMENT_UNIT_DISPLAY_MAP,
 } from 'upgrade_types';
+import { determineWeightingMethod, isWeightSumValid } from '../condition-helper.service';
 
 export const selectExperimentState = createFeatureSelector<ExperimentState>('experiments');
 
@@ -32,7 +33,7 @@ export const selectIsLoadingExperimentDetailStats = createSelector(
 export const selectSelectedExperiment = createSelector(
   selectRouterState,
   selectExperimentState,
-  (routerState, experimentState) => {
+  (routerState, experimentState): ExperimentVM => {
     // be very defensive here to make sure routerState is correct
     const experimentId = routerState?.state?.params?.experimentId;
     if (experimentId && experimentState?.entities) {
@@ -45,12 +46,19 @@ export const selectSelectedExperiment = createSelector(
 
       // Merge with stats if available
       const stat = experimentState.stats?.[experimentId] || null;
-      return { ...experiment, stat };
+
+      const weightingMethod = determineWeightingMethod(experiment.conditions || []);
+
+      return { ...experiment, stat, weightingMethod };
     }
     return undefined;
   }
 );
 
+export const selectConditionWeightsValid = createSelector(selectSelectedExperiment, (experiment): boolean => {
+  return isWeightSumValid(experiment?.conditions || []);
+});
+
 export const selectExperimentById = createSelector(
   selectExperimentState,
   (state, { experimentId }) => state.entities[experimentId]

frontend/projects/upgrade/src/app/core/experiments/store/experiments.selectors.ts

@@ -245,7 +245,7 @@ describe('EditConditionWeightsModalComponent', () => {
       };
 
       const { component } = await setupComponent(threeConditionsData);
-      component.distributeWeightsEqually();
+      component.distributeWeightsEquallyInFormControls();
 
       const total = component.getCurrentTotal();
       expect(total).toBe(100);