ccs-digitalmarketplace-frameworks 3.12.17 → 3.12.20

package/frameworks/digital-outcomes-and-specialists-7/questions/services/physicalStudioBookingCost.yml

@@ -11,6 +11,10 @@ fields:
   price: physicalStudioBookingCostPrice
   price_unit: physicalStudioBookingCostUnit
 
+limits:
+  price:
+    - greater_than_zero
+
 units:
   - label: an hour
     value: Hour
@@ -31,7 +35,7 @@ validations:
     message: Enter how much it costs to book a studio
   - name: not_money_format
     field: physicalStudioBookingCostPrice
-    message: Price must be a number, without units, eg 99.95
+    message: Price must be a number greater than 0, without units, eg 99.95
   - name: answer_required
     field: physicalStudioBookingCostUnit
     message: You must select the unit

package/frameworks/digital-outcomes-and-specialists-7/questions/services/virtualStudioBookingCost.yml

@@ -11,6 +11,10 @@ fields:
   price: virtualStudioBookingCostPrice
   price_unit: virtualStudioBookingCostUnit
 
+limits:
+  price:
+    - greater_than_zero
+
 units:
   - label: an hour
     value: Hour
@@ -31,7 +35,7 @@ validations:
     message: Enter how much it costs to book a studio
   - name: not_money_format
     field: virtualStudioBookingCostPrice
-    message: Price must be a number, without units, eg 99.95
+    message: Price must be a number greater than 0, without units, eg 99.95
   - name: answer_required
     field: virtualStudioBookingCostUnit
     message: You must select the unit

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "ccs-digitalmarketplace-frameworks",
-  "version": "3.12.17",
+  "version": "3.12.20",
   "description": "Data files for Digital Marketplace’s procurement frameworks",
   "repository": "git@github.com:Crown-Commercial-Service/ccs-digitalmarketplace-frameworks",
   "author": "enquiries@digitalmarketplace.service.gov.uk"

package/schema_generator/validation.py

@@ -351,7 +351,7 @@ def drop_non_schema_questions(questions):
         questions.pop(key, None)
 
 
-def text_property(question):
+def text_property(question, _dependent_follow_up_map):
     data = {
         "type": "string",
         "minLength": 0 if question.get('optional') else 1,
@@ -366,11 +366,11 @@ def text_property(question):
     return {question['id']: data}
 
 
-def date_property(question):
+def date_property(question, _dependent_follow_up_map):
     return {question['id']: {"type": "string", "format": "date"}}
 
 
-def uri_property(question):
+def uri_property(question, _dependent_follow_up_map):
     return {question['id']: {
         "type": "string",
         "format": "uri",
@@ -381,12 +381,12 @@ def has_dependent_follow_up(property_func):
     """
     Adds the additional dependent follow up schema to the property
     """
-    def inner_func(question):
-        schema = property_func(question)
+    def inner_func(question, dependent_follow_up_map):
+        schema = property_func(question, dependent_follow_up_map)
         schema_addition = {}
 
         if question.get('dependent_follow_up'):
-            schema_addition = _dependent_follow_up(question)
+            schema_addition = _dependent_follow_up(question, dependent_follow_up_map)
 
         return schema, schema_addition
 
@@ -394,7 +394,7 @@ def has_dependent_follow_up(property_func):
 
 
 @has_dependent_follow_up
-def checkbox_property(question):
+def checkbox_property(question, _dependent_follow_up_map):
     """
     Convert a checkbox question into JSON Schema.
     """
@@ -414,7 +414,7 @@ def checkbox_property(question):
     }
 
 
-def checkbox_tree_property(question):
+def checkbox_tree_property(question, _dependent_follow_up_map):
     """
     Convert a checkbox tree question into JSON Schema by flattening the tree structure. Only leaf
     nodes can be selected.
@@ -447,7 +447,7 @@ def checkbox_tree_property(question):
     return schema_fragment
 
 
-def radios_property(question):
+def radios_property(question, _dependent_follow_up_map):
     return {question['id']: {
         "enum": [
             option.get('value', option['label'])
@@ -456,14 +456,14 @@ def radios_property(question):
     }}
 
 
-def boolean_property(question):
+def boolean_property(question, _dependent_follow_up_map):
     data = {"type": "boolean"}
     if question.get("required_value") is not None:
         data = {"enum": [question["required_value"]]}
     return {question['id']: data}
 
 
-def list_property(question):
+def list_property(question, _dependent_follow_up_map):
     items = {
         "type": "string",
         "maxLength": 100,
@@ -480,7 +480,7 @@ def list_property(question):
     }}
 
 
-def boolean_list_property(question):
+def boolean_list_property(question, _dependent_follow_up_map):
     return {question['id']: {
         "type": "array",
         "minItems": 0 if question.get('optional') else 1,
@@ -491,7 +491,7 @@ def boolean_list_property(question):
     }}
 
 
-def price_string(optional, decimal_place_restriction=False, digit_limit=None):
+def price_string(optional, decimal_place_restriction=False, digit_limit=None, limits=None):
     if digit_limit is None:
         digit_limit = 15
 
@@ -504,25 +504,34 @@ def price_string(optional, decimal_place_restriction=False, digit_limit=None):
         pattern = restricted_pattern
     if optional:
         pattern = r"^$|" + pattern
+    if limits:
+        for limit in limits:
+            if limit == 'greater_than_zero':
+                pattern = '^(?!0(?:\\.0+)?$)' + pattern.split('^')[1]
     return {
         "type": "string",
         "pattern": pattern,
     }
 
 
-def pricing_property(question):
+def pricing_property(question, _dependent_follow_up_map):
     pricing = {}
     for price_key in ['price', 'minimum_price', 'maximum_price']:
         if price_key in question.fields:
             digit_limit = None
+            limits = []
 
             if 'digit_limits' in question:
                 digit_limit = question['digit_limits'].get(price_key)
 
+            if 'limits' in question:
+                limits = question['limits'].get(price_key)
+
             pricing[question.fields[price_key]] = price_string(
                 price_key in question.get('optional_fields', []),
                 question.decimal_place_restriction,
-                digit_limit=digit_limit
+                digit_limit=digit_limit,
+                limits=limits,
             )
 
     if 'price_unit' in question.fields:
@@ -589,7 +598,7 @@ def pricing_property(question):
     return pricing
 
 
-def number_property(question):
+def number_property(question, _dependent_follow_up_map):
     limits = question.get('limits', {})
     output = {question['id']: {
         "minimum": limits.get('min_value') or 0,
@@ -601,15 +610,15 @@ def number_property(question):
     return output
 
 
-def multiquestion(question):
+def multiquestion(question, dependent_follow_up_map):
     """
     Moves subquestions of multiquestions into fully fledged questions.
     """
 
     if question._data['type'] == 'dynamic_list':
-        return _dynamic_list(question)
+        return _dynamic_list(question, dependent_follow_up_map)
     else:
-        property_schema, schema_addition = _flat_multiquestion(question)
+        property_schema, schema_addition = _flat_multiquestion(question, dependent_follow_up_map)
         required_fields = _flat_multiquestion_required(question)
         if required_fields:
             required_schema = {"required": _flat_multiquestion_required(question)}
@@ -618,19 +627,19 @@ def multiquestion(question):
         return property_schema, schema_addition
 
 
-def list_multiquestion(question):
+def list_multiquestion(question, dependent_follow_up_map):
     return {
         question['id']: {
             "type": "array",
             "minItems": 1,
             "maxItems": question.number_of_items,
             "uniqueItems": True,
-            "items": _nested_multiquestion(question)[question['id']]
+            "items": _nested_multiquestion(question, dependent_follow_up_map)[question['id']]
         }
     }
 
 
-def _dynamic_list(question):
+def _dynamic_list(question, dependent_follow_up_map):
     # Some dynamic list questions use `{{ item }}` in temlate fields.
     # This call to filter ensures that `item` is in the template context
     # (yes, filter() can mutate objects, go figure).
@@ -641,7 +650,7 @@ def _dynamic_list(question):
         question['id']: {
             "type": "array",
             "minItems": 0 if question.get('optional') else 1,
-            "items": _nested_multiquestion(question)[question['id']]
+            "items": _nested_multiquestion(question, dependent_follow_up_map)[question['id']]
         }
     }
 
@@ -695,49 +704,50 @@ def _followup(question, root):
     return {'allOf': schemas}
 
 
-def _dependent_follow_up(question):
+def _dependent_follow_up(question, dependent_follow_up_map):
     schemas = []
     question_values = [
         option.get('value', option['label'])
         for option in question.options
     ]
     for dependent_follow_up_field, values in question["dependent_follow_up"].items():
-        non_dependent_question_values = [
-            value
-            for value in question_values
-            if value not in values
-        ]
-        should_not_have_followup = {
-            "items": {"enum": non_dependent_question_values}
-        }
-        should_have_followup = {
-            "not": {"items": {"enum": non_dependent_question_values}}
-        }
+        if dependent_follow_up_field in dependent_follow_up_map.get(question.id, []):
+            non_dependent_question_values = [
+                value
+                for value in question_values
+                if value not in values
+            ]
+            should_not_have_followup = {
+                "items": {"enum": non_dependent_question_values}
+            }
+            should_have_followup = {
+                "not": {"items": {"enum": non_dependent_question_values}}
+            }
 
-        schemas.append({
-            'oneOf': [
-                {
-                    "properties": {
-                        question['id']: should_not_have_followup,
-                        dependent_follow_up_field: {"type": "null"}
+            schemas.append({
+                'oneOf': [
+                    {
+                        "properties": {
+                            question['id']: should_not_have_followup,
+                            dependent_follow_up_field: {"type": "null"}
+                        },
                     },
-                },
-                {
-                    "properties": {
-                        question['id']: should_have_followup,
+                    {
+                        "properties": {
+                            question['id']: should_have_followup,
+                        },
+                        "required": [dependent_follow_up_field]
                     },
-                    "required": [dependent_follow_up_field]
-                },
-            ]
-        })
+                ]
+            })
 
     return {'allOf': schemas}
 
 
-def _flat_multiquestion(question):
+def _flat_multiquestion(question, dependent_follow_up_map):
     properties = {}
     for nested_question in question.questions:
-        build_question_properties_results = build_question_properties(nested_question)
+        build_question_properties_results = build_question_properties(nested_question, dependent_follow_up_map)
 
         if isinstance(build_question_properties_results, dict):
             build_question_properties_results = (build_question_properties_results,)
@@ -758,8 +768,8 @@ def _flat_multiquestion(question):
     return properties, schema_addition
 
 
-def _nested_multiquestion(question):
-    properties, schema_addition = _flat_multiquestion(question)
+def _nested_multiquestion(question, dependent_follow_up_map):
+    properties, schema_addition = _flat_multiquestion(question, dependent_follow_up_map)
 
     object_schema = merge_schemas({
         "type": "object",
@@ -932,8 +942,8 @@ def add_assurance(value_schema, assurance_approach):
     }
 
 
-def build_question_properties(question):
-    question_data = QUESTION_TYPES[question['type']](question)
+def build_question_properties(question, dependent_follow_up_map):
+    question_data = QUESTION_TYPES[question['type']](question, dependent_follow_up_map)
     if question.get('assuranceApproach'):
         if isinstance(question_data, tuple):
             for key, value_schema in question_data[0].items():
@@ -953,8 +963,10 @@ def build_any_of(any_of, fields):
 
 
 def build_schema_properties(schema, questions):
+    dependent_follow_up_map = _generate_dependent_follow_up_map(questions)
+
     for question in questions.values():
-        property_schema = build_question_properties(question)
+        property_schema = build_question_properties(question, dependent_follow_up_map)
         if isinstance(property_schema, tuple):
             property_schema, schema_addition = property_schema
             schema['properties'].update(property_schema)
@@ -1011,6 +1023,22 @@ def _multiquestion_dependencies(questions):
     return {'dependencies': dependencies} if dependencies else {}
 
 
+def _generate_dependent_follow_up_map(questions):
+    dependent_follow_up_map = {}
+
+    for question_id, question in questions.items():
+        if question.get('dependent_follow_up'):
+            dependent_follow_up_map[question_id] = list(question["dependent_follow_up"].keys())
+
+    for dependent_question_id, dependent_question_list in dependent_follow_up_map.items():
+        for question_id, question_list in dependent_follow_up_map.items():
+            if dependent_question_id != question_id and dependent_question_id in question_list:
+                for q_id in dependent_question_list:
+                    question_list.remove(q_id)
+
+    return dependent_follow_up_map
+
+
 def _generate_question_schema(schema_type, schema_name, framework_slug, lot_slug):
     questions = load_questions(schema_type, framework_slug, lot_slug)
     drop_non_schema_questions(questions)

package/schemas/questions.json

@@ -303,7 +303,8 @@
         "format": {"type": "string"},
         "max_value": {"type": "number"},
         "min_value": {"type": "number"},
-        "integer_only": {"type": "boolean"}
+        "integer_only": {"type": "boolean"},
+        "price": {"type": "array"}
       }
     },
     "empty_message": {

package/tests/test_generate_validation_schema.py

@@ -119,25 +119,25 @@ def test_empty_schema():
 
 @given(st.text())
 def test_text_property(id_name):
-    result = text_property({"id": id_name})
+    result = text_property({"id": id_name}, {})
     assert result == {id_name: {"type": "string", "minLength": 1}}
 
 
 @given(st.text(), st.booleans())
 def test_optional_text_property(id_name, optional):
-    result = text_property({"id": id_name, "optional": optional})
+    result = text_property({"id": id_name, "optional": optional}, {})
     assert result == {id_name: {"type": "string", "minLength": 0 if optional else 1}}
 
 
 @given(st.text())
 def test_text_property_format(id_name):
-    result = text_property({"id": id_name, "limits": {"format": "email"}})
+    result = text_property({"id": id_name, "limits": {"format": "email"}}, {})
     assert result == {id_name: {"type": "string", "format": "email", "minLength": 1}}
 
 
 @given(st.text())
 def test_uri_property(id_name):
-    result = uri_property({"id": id_name})
+    result = uri_property({"id": id_name}, {})
     assert result == {id_name: {
         "type": "string",
         "format": "uri"}}
@@ -275,12 +275,12 @@ def test_checkbox_property(id, options):
         "id": id,
         "options": options
     }
-    result, additional_schema = checkbox_property(question)
+    result, additional_schema = checkbox_property(question, {})
     assert result[id]['minItems'] == 1
     assert additional_schema == {}
 
     question['optional'] = True
-    result, additional_schema = checkbox_property(question)
+    result, additional_schema = checkbox_property(question, {})
     assert result[id]['minItems'] == 0
     assert additional_schema == {}
 
@@ -316,7 +316,7 @@ def test_checkbox_property_with_dependent_follow_up():
             ]
         }
     })
-    result, additional_schema = checkbox_property(question)
+    result, additional_schema = checkbox_property(question, {"q1": ["a", "b", "c"]})
     assert result['q1']['minItems'] == 1
 
     enum = result['q1']['items']['enum']
@@ -374,6 +374,60 @@ def test_checkbox_property_with_dependent_follow_up():
     }
 
 
+def test_checkbox_property_with_dependent_follow_up_with_map():
+    options = [
+        {"value": "1", "label": "One"},
+        {"label": "Two"},
+        {"value": "3", "label": "Three"}
+    ]
+
+    question = ContentQuestion({
+        "id": "q1",
+        "options": options,
+        "dependent_follow_up": {
+            "a": [
+                "1",
+                "Two"
+            ],
+            "b": [
+                "Two",
+            ],
+            "c": [
+                "1",
+                "3"
+            ]
+        }
+    })
+    result, additional_schema = checkbox_property(question, {"q1": ["b"]})
+    assert result['q1']['minItems'] == 1
+
+    enum = result['q1']['items']['enum']
+    assert len(enum) == len(options)
+    assert all(option['value'] in enum
+               for option in options if 'value' in option)
+    assert all(option['label'] in enum
+               for option in options if 'value' not in option)
+
+    assert additional_schema == {
+        "allOf": [
+            {
+                "oneOf": [
+                    {
+                        "properties": {
+                            "q1": {"items": {"enum": ["1", "3"]}},
+                            "b": {"type": "null"},
+                        }
+                    },
+                    {
+                        "properties": {"q1": {"not": {"items": {"enum": ["1", "3"]}}}},
+                        "required": ["b"],
+                    },
+                ]
+            },
+        ]
+    }
+
+
 @settings(suppress_health_check=[HealthCheck.too_slow])
 @given(st.text(), nested_checkboxes_list(), st.integers(min_value=1))
 def test_checkbox_tree_property(id, options, number_of_items):
@@ -384,11 +438,11 @@ def test_checkbox_tree_property(id, options, number_of_items):
         "options": options,
         "number_of_items": number_of_items
     }
-    result = checkbox_tree_property(question)
+    result = checkbox_tree_property(question, {})
     assert result[id]['minItems'] == 1
 
     question['optional'] = True
-    result = checkbox_tree_property(question)
+    result = checkbox_tree_property(question, {})
     assert result[id]['minItems'] == 0
     assert result[id]['maxItems'] == number_of_items
 
@@ -410,7 +464,7 @@ def test_checkbox_tree_property(id, options, number_of_items):
 @given(st.text(), st.lists(radios()))
 def test_radios_property(id, options):
     question = {"id": id, "options": options}
-    result = radios_property(question)
+    result = radios_property(question, {})
     assert isinstance(result, dict)
     assert id in result.keys()
     enum = result[id]['enum']
@@ -427,7 +481,7 @@ def test_list_property(id):
         'id': id,
         'optional': True
     }
-    result = list_property(question)
+    result = list_property(question, {})
     assert id in result.keys()
     assert result[id]['minItems'] == 0
     assert result[id]['items'] == {
@@ -441,7 +495,7 @@ def test_boolean_property():
     question = {
         'id': "Test",
     }
-    result = boolean_property(question)
+    result = boolean_property(question, {})
     assert result["Test"]["type"] == "boolean"
     assert "enum" not in result["Test"]
 
@@ -452,7 +506,7 @@ def test_boolean_property_with_required_value(boolean):
         'id': "Test",
         'required_value': boolean
     }
-    result = boolean_property(question)
+    result = boolean_property(question, {})
     assert result["Test"]["enum"] == [boolean]
     assert "type" not in result["Test"]
 
@@ -463,7 +517,7 @@ def test_boolean_list_property(id):
         'id': id,
         'optional': True
     }
-    result = boolean_list_property(question)
+    result = boolean_list_property(question, {})
     assert id in result.keys()
     assert result[id]['minItems'] == 0
 
@@ -524,7 +578,7 @@ def test_pricing_property_minmax_price():
         }
     }
     cq = ContentQuestion(manifest)
-    result = pricing_property(cq)
+    result = pricing_property(cq, {})
     assert not result['priceMin']['pattern'].startswith("^$|")
     assert not result['priceMax']['pattern'].startswith("^$|")
 
@@ -543,7 +597,7 @@ def test_pricing_property_minmax_price_optional():
         ]
     }
     cq = ContentQuestion(manifest)
-    result = pricing_property(cq)
+    result = pricing_property(cq, {})
     assert result['priceMin']['pattern'].startswith("^$|")
     assert result['priceMax']['pattern'].startswith("^$|")
 
@@ -558,7 +612,7 @@ def test_pricing_property_price_unit_and_interval():
         }
     }
     cq = ContentQuestion(manifest)
-    result = pricing_property(cq)
+    result = pricing_property(cq, {})
     assert result['priceUnit']['enum'] == [
         "Unit",
         "Person",
@@ -600,7 +654,7 @@ def test_pricing_property_price_unit_and_interval_optional():
         ]
     }
     cq = ContentQuestion(manifest)
-    result = pricing_property(cq)
+    result = pricing_property(cq, {})
     assert "" in result['priceUnit']['enum']
     assert "" in result['priceInterval']['enum']
 
@@ -614,7 +668,7 @@ def test_hours_for_price():
         }
     }
     cq = ContentQuestion(manifest)
-    result = pricing_property(cq)
+    result = pricing_property(cq, {})
     assert "enum" in result['pfh'].keys()
 
 
@@ -631,7 +685,7 @@ def test_pricing_property_digit_limits():
         }
     }
     cq = ContentQuestion(manifest)
-    result = pricing_property(cq)
+    result = pricing_property(cq, {})
 
     assert '{1,15}' in result['priceMin']['pattern']
     assert '{1,5}' in result['priceMax']['pattern']
@@ -651,7 +705,7 @@ def test_pricing_property_digit_limits_decimal_place_restriction():
         }
     }
     cq = ContentQuestion(manifest)
-    result = pricing_property(cq)
+    result = pricing_property(cq, {})
 
     assert '{1,4}' in result['priceMin']['pattern']
     assert '{1,14}' in result['priceMax']['pattern']
@@ -666,7 +720,7 @@ def test_pricing_property_price():
         }
     }
     cq = ContentQuestion(manifest)
-    result = pricing_property(cq)
+    result = pricing_property(cq, {})
     assert not result['price']['pattern'].startswith("^$|")
 
 
@@ -693,7 +747,7 @@ def test_pricing_property_custom_units():
         ]
     }
     cq = ContentQuestion(manifest)
-    result = pricing_property(cq)
+    result = pricing_property(cq, {})
     assert result['priceUnit']['enum'] == [
         "Option 1",
         "option-2",
@@ -723,7 +777,7 @@ def test_pricing_property_custom_intervals():
         ]
     }
     cq = ContentQuestion(manifest)
-    result = pricing_property(cq)
+    result = pricing_property(cq, {})
     assert result['priceInterval']['enum'] == [
         "option-1",
         "Option 2",
@@ -731,9 +785,29 @@ def test_pricing_property_custom_intervals():
     ]
 
 
+def test_pricing_property_limits_greater_than_zero():
+    manifest = {
+        "id": "Test",
+        "type": "pricing",
+        "fields": {
+            "price": "price",
+        },
+        "limits": {
+            "price": [
+                "greater_than_zero"
+            ]
+        }
+    }
+
+    cq = ContentQuestion(manifest)
+    result = pricing_property(cq, {})
+
+    assert '(?!0(?:\\.0+)?$)' in result['price']['pattern']
+
+
 @given(st.text())
 def test_number_property(id):
-    actual = number_property({'id': id, 'type': 'number'})
+    actual = number_property({'id': id, 'type': 'number'}, {})
     expected = {id: {
         "exclusiveMaximum": 100,
         "minimum": 0,
@@ -744,9 +818,16 @@ def test_number_property(id):
 
 @given(st.integers(), st.integers(), st.booleans())
 def test_number_property_limits(max_value, min_value, integer_only):
-    actual = number_property({'id': 'number-question', 'type': 'number', 'limits': {
-        'max_value': max_value, 'min_value': min_value, 'integer_only': integer_only
-    }})
+    actual = number_property(
+        {
+            'id': 'number-question',
+            'type': 'number',
+            'limits': {
+                'max_value': max_value, 'min_value': min_value, 'integer_only': integer_only
+            }
+        },
+        {}
+    )
     expected = {"number-question": {
         "minimum": min_value,
         "type": "integer" if integer_only else "number"
@@ -774,7 +855,7 @@ def test_multiquestion():
         ]
     })
 
-    result, schema_addition = multiquestion(question)
+    result, schema_addition = multiquestion(question, {})
     assert 'subquestion1' in result.keys()
     assert 'subquestion2' in result.keys()
 
@@ -801,7 +882,7 @@ def test_dynamic_list():
         ]
     })
 
-    result = multiquestion(question)
+    result = multiquestion(question, {})
 
     assert set(result["q1"]["items"]["properties"].keys()) \
         == {"q1a", "q1b"}
@@ -833,7 +914,7 @@ def test_dynamic_list_with_dynamic_content():
         ]
     })
 
-    result = multiquestion(question)
+    result = multiquestion(question, {})
 
     assert set(result["q"]["items"]["properties"].keys()) \
         == {"q1"}
@@ -868,7 +949,7 @@ def test_list_multiquestion():
         ]
     })
 
-    result = list_multiquestion(question)
+    result = list_multiquestion(question, {})
 
     assert set(result["example"]["items"]["properties"].keys()) == {"example2", "example3"}
 
@@ -903,7 +984,7 @@ def test_followup():
         ]
     })
 
-    result, schema_addition = multiquestion(question)
+    result, schema_addition = multiquestion(question, {})
     assert 'subquestion1' in result.keys()
     assert 'subquestion2' in result.keys()
 
@@ -949,7 +1030,7 @@ def test_checkboxes_followup():
         ]
     })
 
-    result, schema_addition = multiquestion(question)
+    result, schema_addition = multiquestion(question, {})
     assert 'subquestion1' in result.keys()
     assert 'subquestion2' in result.keys()