示例#1
0
    def test_simple(self):
        related_name = "relate26"
        data = {
            "desc": "some",
            related_name: {
                "dummy1": 1,
                "dummy2": "value1"
            }
        }

        prefix = "provider"
        root_name = "model_test26"
        model_builder = DynamicModelBuilder(model_name_prefix=prefix)
        model_builder.create_models_from_data(data, root_name)
        Object = get_dynamic_model(root_name)
        Objrelate = get_dynamic_model(related_name)
        prefixed_related_name = add_prefix_to_model_label(related_name, prefix)
        self.assertEqual(Object.__name__, add_prefix_to_model_label(root_name, prefix))
        self.assertEqual(Objrelate.__name__, prefixed_related_name)

        instance_builder = DynamicDataInstances(model_name_prefix=prefix)
        inst = instance_builder.create_instances_from_data(data, root_name)

        rel_inst = getattr(inst, prefixed_related_name)
        self.assertTrue(hasattr(inst, prefixed_related_name))
        self.assertTrue(hasattr(rel_inst, "dummy1"))
        self.assertEqual(rel_inst.dummy1, 1)
        self.assertEqual(rel_inst.dummy2, "value1")
示例#2
0
    def test_create_data_from_random_json(self):
        data = {"obj2": {"title": "title1", "obj3": {"title": "title2"}}}
        root_name = "instance_test2"
        model_builder = DynamicModelBuilder()
        model_builder.create_models_from_data(data, root_name)

        instance_builder = DynamicDataInstances()
        instances = instance_builder.create_instances_from_data(
            data, root_name)
        obj2 = get_dynamic_model("obj2").objects.first()
        obj3 = get_dynamic_model("obj3").objects.first()
        assert obj3.title == "title2"
        assert obj2.title == "title1"
    def test_instances_are_being_assigned_nested(self, mock):
        data = {"obj55": {"title8": "title32", "obj66": {"title7": "title44"}}}
        root_name = "user_test4"
        model_builder = DynamicModelBuilder()
        model_builder.create_models_from_data(data, root_name)

        instance_builder = DynamicDataInstances(self.user.pk)
        instances = instance_builder.create_instances_from_data(
            data, root_name)
        obj2 = get_dynamic_model("obj55").objects.first()
        obj3 = get_dynamic_model("obj66").objects.first()
        self.assertEqual(obj3.user_pk, self.user.pk)
        self.assertEqual(obj2.user_pk, self.user.pk)
    def test_create_dynamic_list_of_objects(self):
        data = {
            "prop2":
            1,
            "prop1":
            "test2",
            "related_obj": [
                {
                    "name": "name1",
                    "value": 2
                },
                {
                    "name": "name2",
                    "value": 3
                },
            ]
        }
        root_name = "model_test1"
        model_builder = DynamicModelBuilder()
        ModelObject = model_builder.create_models_from_data(root_name, data)

        instance = ModelObject(prop2=3)
        instance.save()

        # instance_builder = DynamicDataInstances()
        # instances = instance_builder.create_instances_from_data(root_name, data)

        RelObj = get_dynamic_model("related_obj")
        inst1 = RelObj(name="Peter Meyer", value=3, model_test1=instance)
        inst1.save()
        inst1 = RelObj(name="Anders Rikvold", value=3, model_test1=instance)
        inst1.save()
 def test_build_model_with_user_pk(self, mock):
     data = {
         "prop2": 1,
     }
     root_name = "user_test_1"
     model_builder = DynamicModelBuilder()
     model_builder.create_models_from_data(data, root_name)
     ModelObject = get_dynamic_model(root_name)
     inst = ModelObject.objects.create(prop2=3, user_pk=self.user.pk)
示例#6
0
 def test_build_data_from_data_fetch(self):
     with patch(get_method_path(
             DataFetch.execute_on_save_methods)) as mock_method:
         data, data_fetch, user = self.create_data_fetch_objects()
         TransformFilesToData().create_data_file(data, user, data_fetch)
         dynamic_model_tasks.build_models_from_data_files(
             pk=data_fetch.refined_data_file.pk)
         model = get_dynamic_model("activity")
         self.assertIsNotNone(model)
def create_view_instances(selected_model_name, search_query, user_pk, page):
    if selected_model_name == "":
        return []
    models = [get_dynamic_model(selected_model_name)
              ] if selected_model_name != "ALL" else get_all_dynamic_models()
    view_instances = []
    for model in models:
        instances = query_instances(model, search_query, user_pk)
        # TODO figure out a smart way to only create dynamicViewObjects of instances in page
        view_instances.extend([DynamicViewObject(inst) for inst in instances])
    paged_view_instances = make_paginator(page, view_instances)
    return paged_view_instances
 def test_instances_are_being_assigned(self, mock):
     data = {
         "obj22": {
             "title": "title324",
         }
     }
     root_name = "user_test3"
     model_builder = DynamicModelBuilder()
     model_builder.create_models_from_data(data, root_name)
     self.assertTrue(len(model_builder.failed_objects) is 0)
     instance_builder = DynamicDataInstances(self.user.pk)
     instances = instance_builder.create_instances_from_data(
         data, root_name)
     obj2 = get_dynamic_model("obj22").objects.first()
     self.assertEqual(obj2.user_pk, self.user.pk)
    def test_create_dynamic_simple(self):
        data = {"desc": "some", "relate": {"dummy1": 1, "dummy2": "value1"}}

        root_name = "model_test0"
        model_builder = DynamicModelBuilder()
        Object = model_builder.create_models_from_data(root_name, data)

        inst = Object(desc="soemthing")
        inst.save()
        Objrelate = get_dynamic_model("relate")
        inst2 = Objrelate(model_test0=inst, dummy1=2, dummy2="value2")
        inst2.save()

        assert hasattr(inst, "relate")
        assert hasattr(inst.relate, "dummy1")
        assert hasattr(inst.relate, "dummy2")
        assert inst.relate.dummy1 == 2
        assert inst.relate.dummy2 == "value2"
    def test_if_list_of_objects_with_some_errors_are_caught_correctly(self):
        data = {
            "newobj3": {
                "related2": [{
                    "attribute": 0,
                }, {
                    "attribute": 1,
                }, {
                    "attribute": 0,
                }, {
                    "attribute": 1,
                }]
            }
        }

        root_name = "model_test4"
        model_builder = DynamicModelBuilder()
        model_builder.handle_attribute = Mock(
            side_effect=make_attributes_with_value_0_fail)
        ModelObject = model_builder.create_models_from_data(root_name, data)
        assert len(model_builder.failed_objects) == 2
        relatedOb = get_dynamic_model("related2")
        assert relatedOb is not None
示例#11
0
 def test_get_dynamic_model(self):
     obj = dynamic_model_utils.get_dynamic_model("newobj1")
     self.assertIsNotNone(obj)
示例#12
0
def build_object_list_view(request, provider_name, object_label):
    # object_label = request.GET.get("object_label")
    model = get_dynamic_model(object_label)
    attrs = {"model": model}
    list_view = type(f"{model.__name__}ListView", (generic.ListView,), attrs)
    return list_view
示例#13
0
def model_list_view(request, object_label):
    model = get_dynamic_model(object_label)
    fields = model._meta.fields
    instances = model.objects.all()
    return render(request, 'object_list.html', {'object_label': object_label, 'instances': instances})
示例#14
0
def build_object_detail_view(request, provider_name, object_label):
    # object_label = request.GET.get("object_label")
    model = get_dynamic_model(object_label)
    attrs = {"model": model}
    return type(f"{model.__name__}DetailView", (generic.DetailView,), attrs)  # .as_view()
def dynamic_data_detail_view(request, model_name, pk):
    user_pk = request.user.pk
    model = get_dynamic_model(model_name)
    instance = model.objects.get(pk=pk, user_pk=user_pk)
    html_params = {"instance": DynamicViewObject(instance)}
    return render(request, 'dynamic_data_detail.html', html_params)
 def pre_handle_object(self, parent_ref: Model, object_label: str, data):
     DjangoModel = dm_utils.get_dynamic_model(model_name=object_label,
                                              prefix=self.model_name_prefix)
     instance = DjangoModel()
     return instance