From f3e1241ca364d3dc561ef74b4a62c2285dab5704 Mon Sep 17 00:00:00 2001
From: Dylan Hall <dehall@mitre.org>
Date: Thu, 16 Mar 2023 12:53:15 -0400
Subject: [PATCH] add ability to add/remove subconditions for grouped
 conditions

---
 src/components/editor/Conditional.js |  28 +++++--
 src/reducers/analysis.js             | 112 +++++++++++++++++++++++++++
 2 files changed, 132 insertions(+), 8 deletions(-)

diff --git a/src/components/editor/Conditional.js b/src/components/editor/Conditional.js
index 1f12771..6311f99 100644
--- a/src/components/editor/Conditional.js
+++ b/src/components/editor/Conditional.js
@@ -531,15 +531,18 @@ class And extends Component<Props> {
 
   render() {
     let conditional = ((this.props.conditional: any): AndConditional);
+    let onChange = this.props.onChange('conditions');
     return (
       <label> And:
         {conditional.conditions.map((cond, i) => {
           return (
             <div className="section"  key={i}>
-              <ConditionalEditor {...this.props} conditional={cond} onChange={this.props.onChange(`conditions.${i}`)} />
+              <ConditionalEditor {...this.props} conditional={cond} onChange={onChange(`[${i}]`)} />
+              <a className="editable-text delete-button" onClick={() => onChange(`[${i}]`)({val: {id: null}})}>remove</a>
             </div>
           )
         })}
+        <a className='editable-text add-button' onClick={() => onChange(`[${conditional.conditions.length}]`)({val: {id: getTemplate('Type.Condition.Age')}})}>+</a>
       </label>
     );
   }
@@ -550,15 +553,18 @@ class Or extends Component<Props> {
 
   render() {
     let conditional = ((this.props.conditional: any): OrConditional);
+    let onChange = this.props.onChange('conditions');
     return (
       <label> Or:
         {conditional.conditions.map((cond, i) => {
           return (
-              <div className="section" key={i}>
-                <ConditionalEditor {...this.props} conditional={cond} onChange={this.props.onChange(`conditions.${i}`)} />
-              </div>
+            <div className="section"  key={i}>
+              <ConditionalEditor {...this.props} conditional={cond} onChange={onChange(`[${i}]`)} />
+              <a className="editable-text delete-button" onClick={() => onChange(`[${i}]`)({val: {id: null}})}>remove</a>
+            </div>
           )
         })}
+        <a className='editable-text add-button' onClick={() => onChange(`[${conditional.conditions.length}]`)({val: {id: getTemplate('Type.Condition.Age')}})}>+</a>
       </label>
     );
   }
@@ -569,16 +575,19 @@ class AtLeast extends Component<Props> {
 
   render() {
     let conditional = ((this.props.conditional: any): AtLeastConditional);
+    let onChange = this.props.onChange('conditions');
     return (
       <label> At Least
         <RIENumber className='editable-text' value={conditional.minimum||0} propName='minimum' change={this.props.onChange('minimum')} />:
         {conditional.conditions.map((cond, i) => {
           return (
-            <div className="section" key={i}>
-              <ConditionalEditor {...this.props} conditional={cond} onChange={this.props.onChange(`conditions.${i}`)} />
+            <div className="section"  key={i}>
+              <ConditionalEditor {...this.props} conditional={cond} onChange={onChange(`[${i}]`)} />
+              <a className="editable-text delete-button" onClick={() => onChange(`[${i}]`)({val: {id: null}})}>remove</a>
             </div>
           )
         })}
+        <a className='editable-text add-button' onClick={() => onChange(`[${conditional.conditions.length}]`)({val: {id: getTemplate('Type.Condition.Age')}})}>+</a>
       </label>
     );
   }
@@ -589,17 +598,20 @@ class AtMost extends Component<Props> {
 
   render() {
     let conditional = ((this.props.conditional: any): AtMostConditional);
+    let onChange = this.props.onChange('conditions');
     return (
       <label> At Most
         <RIENumber className='editable-text' value={conditional.maximum||0} propName='maximum' change={this.props.onChange('maximum')} />:
 
         {conditional.conditions.map((cond, i) => {
           return (
-            <div className="section" key={i}>
-              <ConditionalEditor {...this.props} conditional={cond} onChange={this.props.onChange(`conditions.${i}`)} />
+            <div className="section"  key={i}>
+              <ConditionalEditor {...this.props} conditional={cond} onChange={onChange(`[${i}]`)} />
+              <a className="editable-text delete-button" onClick={() => onChange(`[${i}]`)({val: {id: null}})}>remove</a>
             </div>
           )
         })}
+        <a className='editable-text add-button' onClick={() => onChange(`[${conditional.conditions.length}]`)({val: {id: getTemplate('Type.Condition.Age')}})}>+</a>
       </label>
     );
   }
diff --git a/src/reducers/analysis.js b/src/reducers/analysis.js
index 3d23710..e2ab527 100644
--- a/src/reducers/analysis.js
+++ b/src/reducers/analysis.js
@@ -338,6 +338,117 @@ const orphanStateWarnings = (module) => {
 
 }
 
+
+const GROUPED_CONDITION_TYPES = ['And', 'Or', 'At Least', 'At Most', 'Not'];
+
+/**
+ * Look for "And", "At Least", "At Most", "Or" type conditionals
+ * and make sure the numbers make sense.
+ */
+const groupedConditionalWarnings = (module) => {
+  debugger;
+  const warnings = [];
+  Object.keys(module.states).forEach(stateName => {
+    const state = module.states[stateName];
+
+    if (state.type == 'Guard') {
+      if (GROUPED_CONDITION_TYPES.includes(state.allow.condition_type)) {
+        const message = checkGroupedCondition(state.allow);
+        if (message) {
+          warnings.push({stateName, message});
+        }
+      }
+    }
+
+    if (state.conditional_transition) {
+      state.conditional_transition.forEach(transition => {
+        if (transition.condition && GROUPED_CONDITION_TYPES.includes(transition.condition.condition_type)) {
+          const message = checkGroupedCondition(transition.condition);
+          if (message) {
+            warnings.push({stateName, message});
+          }
+        }
+      });
+    } else if (state.complex_transition) {
+      state.complex_transition.forEach(transition => {
+        if (transition.condition && GROUPED_CONDITION_TYPES.includes(transition.condition.condition_type)) {
+          const message = checkGroupedCondition(transition.condition);
+          if (message) {
+            warnings.push({stateName, message});
+          }
+        }
+      });
+    }
+  });
+  return warnings;
+}
+
+const checkGroupedCondition = (condition) => {
+  switch(condition.condition_type) {
+  case 'And':
+    if (condition.conditions.length < 2) {
+      return "'And' condition should have at minimum 2 sub-conditions";
+    } else {
+      for (const subcondition of condition.conditions) {
+        if (GROUPED_CONDITION_TYPES.includes(subcondition.condition_type)) {
+          const message = checkGroupedCondition(subcondition);
+          if (message) {
+            return message;
+          }
+        }
+      } 
+    }
+    break;
+  case 'Or':
+    if (condition.conditions.length < 2) {
+      return "'Or' condition should have at minimum 2 sub-conditions";
+    } else {
+      for (const subcondition of condition.conditions) {
+        if (GROUPED_CONDITION_TYPES.includes(subcondition.condition_type)) {
+          const message = checkGroupedCondition(subcondition);
+          if (message) {
+            return message;
+          }
+        }
+      } 
+    }
+    break;
+  case 'At Least':
+    if (condition.conditions.length <= condition.minimum) {
+      return "'At Least' condition should have more sub-conditions than the selected minimum";
+    } else {
+      for (const subcondition of condition.conditions) {
+        if (GROUPED_CONDITION_TYPES.includes(subcondition.condition_type)) {
+          const message = checkGroupedCondition(subcondition);
+          if (message) {
+            return message;
+          }
+        }
+      } 
+    }
+    break;
+  case 'At Most':
+    if (condition.conditions.length <= condition.maximum) {
+      return "'At Most' condition should have more sub-conditions than the selected maximum";
+    } else {
+      for (const subcondition of condition.conditions) {
+        if (GROUPED_CONDITION_TYPES.includes(subcondition.condition_type)) {
+          const message = checkGroupedCondition(subcondition);
+          if (message) {
+            return message;
+          }
+        }
+      } 
+    }
+    break;
+  case 'Not':
+    if (GROUPED_CONDITION_TYPES.includes(condition.condition.condition_type)) {
+      return checkGroupedCondition(condition.condition);
+    }
+    break;
+  }
+}
+
 const libraryModuleCodes = (modules) => {
     const libraryModuleCodes = {};
 
@@ -403,6 +514,7 @@ export default (state = initialState, action) => {
                            ...placeholderCodeWarnings(action.data.module),
                            ...tableTransitionWarnings(action.data.module),
                            ...gmfVersionWarnings(action.data.module),
+                           ...groupedConditionalWarnings(action.data.module),
                            ...telemedicineWarnings(action.data.module)
                           ];