Example #1
0
    def setUpClass(cls):
        cls.inferred_schema = InferredSchema(
            domain=cls.domain,
            case_type=cls.case_type,
        )
        cls.inferred_schema_other = InferredSchema(
            domain=cls.domain,
            case_type='other',
        )

        cls.schemas = [
            cls.inferred_schema,
            cls.inferred_schema_other,
        ]
        for schema in cls.schemas:
            schema.save()
    def test_put_group_schema(self):
        schema = InferredSchema(
            domain='inferred-domain',
            case_type='inferred',
        )
        group_schema = schema.put_group_schema(
            [PathNode(name='random'),
             PathNode(name='table')], )

        self.assertTrue(isinstance(group_schema, InferredExportGroupSchema))
        self.assertTrue(group_schema.inferred)
        self.assertEqual(len(schema.group_schemas), 1)

        # After putting same group schema, should not re-add group schema
        group_schema = schema.put_group_schema(
            [PathNode(name='random'),
             PathNode(name='table')], )
        self.assertEqual(len(schema.group_schemas), 1)
Example #3
0
    def test_put_group_schema(self):
        schema = InferredSchema(
            domain='inferred-domain',
            case_type='inferred',
        )
        group_schema = schema.put_group_schema(
            [PathNode(name='random'), PathNode(name='table')],
        )

        self.assertTrue(isinstance(group_schema, InferredExportGroupSchema))
        self.assertTrue(group_schema.inferred)
        self.assertEqual(len(schema.group_schemas), 1)

        # After putting same group schema, should not re-add group schema
        group_schema = schema.put_group_schema(
            [PathNode(name='random'), PathNode(name='table')],
        )
        self.assertEqual(len(schema.group_schemas), 1)
    def setUpClass(cls):
        cls.current_app = Application.wrap(cls.get_json('basic_application'))

        cls.first_build = Application.wrap(cls.get_json('basic_application'))
        cls.first_build._id = '123'
        cls.first_build.copy_of = cls.current_app.get_id
        cls.first_build.version = 3

        cls.advanced_app = Application.new_app('domain',
                                               "Untitled Application")
        module = cls.advanced_app.add_module(
            AdvancedModule.new_module('Untitled Module', None))
        form = module.new_form("Untitled Form",
                               cls.get_xml('repeat_group_form'))
        form.xmlns = 'repeat-xmlns'
        form.actions.open_cases = [
            AdvancedOpenCaseAction(
                case_type="advanced",
                case_tag="open_case_0",
                name_path="/data/question3/question4",
                repeat_context="/data/question3",
            )
        ]

        cls.apps = [
            cls.current_app,
            cls.first_build,
            cls.advanced_app,
        ]
        with drop_connected_signals(app_post_save):
            for app in cls.apps:
                app.save()

        cls.inferred_schema = InferredSchema(
            domain=cls.domain,
            case_type=cls.case_type,
            group_schemas=[
                InferredExportGroupSchema(
                    path=MAIN_TABLE,
                    items=[
                        ExportItem(path=[
                            PathNode(name='data'),
                            PathNode(name='case_property')
                        ],
                                   label='Inferred 1',
                                   inferred=True),
                        ExportItem(path=[
                            PathNode(name='data'),
                            PathNode(name='case_property_2')
                        ],
                                   label='Inferred 1',
                                   inferred=True),
                    ],
                    inferred=True),
            ])
        cls.inferred_schema.save()
Example #5
0
def add_inferred_export_properties(sender, domain, case_type, properties):
    from corehq.apps.export.models import MAIN_TABLE, PathNode, InferredSchema, ScalarItem
    """
    Adds inferred properties to the inferred schema for a case type.

    :param: sender - The signal sender
    :param: domain
    :param: case_type
    :param: properties - An iterable of case properties to add to the inferred schema
    """

    assert domain, 'Must have domain'
    assert case_type, 'Must have case type'
    assert all(map(lambda prop: '.' not in prop,
                   properties)), 'Properties should not have periods'
    inferred_schema = get_inferred_schema(domain, case_type)
    if not inferred_schema:
        inferred_schema = InferredSchema(
            domain=domain,
            case_type=case_type,
        )
    group_schema = inferred_schema.put_group_schema(MAIN_TABLE)

    for case_property in properties:
        path = [PathNode(name=case_property)]
        system_property_column = filter(
            lambda column: column.item.path == path,
            MAIN_CASE_TABLE_PROPERTIES,
        )

        if system_property_column:
            assert len(system_property_column) == 1
            column = system_property_column[0]
            group_schema.put_item(path,
                                  inferred_from=sender,
                                  item_cls=column.item.__class__)
        else:
            group_schema.put_item(path,
                                  inferred_from=sender,
                                  item_cls=ScalarItem)

    inferred_schema.save()
Example #6
0
def _cached_add_inferred_export_properties(sender, domain, case_type, properties):
    from corehq.apps.export.models import MAIN_TABLE, PathNode, InferredSchema, ScalarItem
    """
    Adds inferred properties to the inferred schema for a case type.

    :param: sender - The signal sender
    :param: domain
    :param: case_type
    :param: properties - An iterable of case properties to add to the inferred schema
    """

    assert domain, 'Must have domain'
    assert case_type, 'Must have case type'
    assert all(map(lambda prop: '.' not in prop, properties)), 'Properties should not have periods'
    inferred_schema = get_inferred_schema(domain, case_type)
    if not inferred_schema:
        inferred_schema = InferredSchema(
            domain=domain,
            case_type=case_type,
        )
    group_schema = inferred_schema.put_group_schema(MAIN_TABLE)
    add_properties_to_data_dictionary(domain, case_type, properties)

    for case_property in properties:
        path = [PathNode(name=case_property)]
        system_property_column = filter(
            lambda column: column.item.path == path,
            MAIN_CASE_TABLE_PROPERTIES,
        )

        if system_property_column:
            assert len(system_property_column) == 1
            column = system_property_column[0]
            group_schema.put_item(path, inferred_from=sender, item_cls=column.item.__class__)
        else:
            group_schema.put_item(path, inferred_from=sender, item_cls=ScalarItem)

    inferred_schema.save()
Example #7
0
 def setUpClass(cls):
     super(TestExportInstanceGenerationWithInferredSchema, cls).setUpClass()
     cls.schema = CaseExportDataSchema(
         app_id=cls.app_id,
         case_type=cls.case_type,
         group_schemas=[
             ExportGroupSchema(
                 path=MAIN_TABLE,
                 items=[
                     ExportItem(
                         path=[
                             PathNode(name='data'),
                             PathNode(name='case_property')
                         ],
                         label='Question 1',
                         last_occurrences={cls.app_id: 3},
                     ),
                 ],
                 last_occurrences={cls.app_id: 3},
             ),
         ],
     )
     cls.inferred_schema = InferredSchema(
         case_type=cls.case_type,
         group_schemas=[
             InferredExportGroupSchema(
                 path=MAIN_TABLE,
                 items=[
                     ExportItem(path=[
                         PathNode(name='data'),
                         PathNode(name='case_property')
                     ],
                                label='Inferred 1',
                                inferred=True),
                     ExportItem(path=[
                         PathNode(name='data'),
                         PathNode(name='case_property_2')
                     ],
                                label='Inferred 1',
                                inferred=True),
                 ],
                 inferred=True),
         ])
Example #8
0
    def setUpClass(cls):
        cls.current_app = Application.wrap(cls.get_json('basic_application'))

        cls.first_build = Application.wrap(cls.get_json('basic_application'))
        cls.first_build._id = '123'
        cls.first_build.copy_of = cls.current_app.get_id
        cls.first_build.version = 3

        cls.apps = [
            cls.current_app,
            cls.first_build,
        ]
        with drop_connected_signals(app_post_save):
            for app in cls.apps:
                app.save()

        cls.inferred_schema = InferredSchema(
            domain=cls.domain,
            case_type=cls.case_type,
            group_schemas=[
                InferredExportGroupSchema(
                    path=MAIN_TABLE,
                    items=[
                        ExportItem(path=[
                            PathNode(name='data'),
                            PathNode(name='case_property')
                        ],
                                   label='Inferred 1',
                                   inferred=True),
                        ExportItem(path=[
                            PathNode(name='data'),
                            PathNode(name='case_property_2')
                        ],
                                   label='Inferred 1',
                                   inferred=True),
                    ],
                    inferred=True),
            ])
        cls.inferred_schema.save()