Merge pull request #17 from octabytes/feature

AxeemHaider · web-flow · commit 06d9fe6f1ac7 · 2019-11-18T12:06:26.000+05:00
Feature
diff --git a/setup.py b/setup.py
@@ -16,7 +16,7 @@
     # Versions should comply with PEP440.  For a discussion on single-sourcing
     # the version across setup.py and the project code, see
     # https://packaging.python.org/en/latest/single_source_version.html
-    version='0.2.0',
+    version='0.3.0',
 
     description="FireO ORM is specifically designed for the Google's Firestore",
     long_description=long_description,
diff --git a/src/fireo/fields/field_attribute.py b/src/fireo/fields/field_attribute.py
@@ -72,8 +72,8 @@ def parse(self, value, ignore_required=False):
 
             # check this field is required or not
             if self.required and value is None and not ignore_required:
-                raise RequiredField(f'"{self.field.__class__.__name__}" is required but received '
-                                    f'no default and no value.')
+                raise RequiredField(f'"{self.field.__class__.__name__}" is required for model {self.field.model_cls} '
+                                    f'but received no default and no value.')
 
             # check if there any custom validation provided by user
             if self.validator is not None:
diff --git a/src/fireo/managers/managers.py b/src/fireo/managers/managers.py
@@ -156,6 +156,10 @@ def create(self, mutable_instance=None, **kwargs,):
                         field_list[f.name] = model_instance._get_fields()
                 else:
                     field_list[k] = v
+            # Create instance for nested model
+            for f in self.model_cls._meta.field_list.values():
+                if isinstance(f, NestedModel):
+                    field_list[f.name] = f.nested_model()._get_fields()
         else:
             field_list = kwargs
 
diff --git a/src/fireo/models/model.py b/src/fireo/models/model.py
@@ -134,6 +134,12 @@ def __init__(self, *args, **kwargs):
         for k, v in kwargs.items():
             setattr(self, k, v)
 
+        # Create instance for nested model
+        # for direct assignment to nested model
+        for f in self._meta.field_list.values():
+            if isinstance(f, fields.NestedModel):
+                setattr(self, f.name, f.nested_model())
+
     # Get all the fields values from meta
     # which are attached with this mode
     # and convert them into corresponding db value
diff --git a/src/fireo/queries/create_query.py b/src/fireo/queries/create_query.py
@@ -1,5 +1,7 @@
+from fireo.fields import NestedModel
 from fireo.queries import query_wrapper
 from fireo.queries.base_query import BaseQuery
+from fireo.utils import utils
 
 
 class CreateQuery(BaseQuery):
@@ -84,10 +86,32 @@ class User(Model):
         in this case it will be like this
         `{full_name: "Azeem", age=25}`
         """
-        return {
-            f.db_column_name: f.get_value(self.query.get(f.name))
-            for f in self.model._meta.field_list.values()
-        }
+        field_list = {}
+        for f in self.model._meta.field_list.values():
+            if isinstance(f, NestedModel):
+                self._nested_field_list(f, field_list, f.name)
+            else:
+                field_list[f.db_column_name] = f.get_value(self.query.get(f.name))
+        return field_list
+
+    def _nested_field_list(self, f, fl, *name):
+        """Get Nested Fields"""
+        required_nested_model = f.raw_attributes.get('required')
+        if required_nested_model is None or required_nested_model is False:
+            ignore_required = True
+        else:
+            ignore_required = False
+        nested_field_list = {}
+        for n_f in f.nested_model._meta.field_list.values():
+            if isinstance(n_f, NestedModel):
+                n = (*name, n_f.name)
+                self._nested_field_list(n_f, nested_field_list, *n)
+            else:
+                nested_field_list[n_f.db_column_name] = n_f.get_value(
+                    utils.get_nested(self.query, *name).get(n_f.name),
+                    ignore_required
+                )
+        fl[f.db_column_name] = nested_field_list
 
     def _raw_exec(self):
         """save model into firestore and return the document"""
diff --git a/src/fireo/queries/filter_query.py b/src/fireo/queries/filter_query.py
@@ -1,4 +1,5 @@
 from fireo.database import db
+from fireo.fields.errors import FieldNotFound
 from fireo.queries import query_wrapper
 from fireo.queries.base_query import BaseQuery
 from fireo.queries.delete_query import DeleteQuery
@@ -110,7 +111,32 @@ def parse_where(self):
             else:
                 self.cursor_dict['filters'] = [w]
 
-            f_name = self.model._meta.get_field(name).db_column_name
+            # Check it is nested model field
+            if '.' in name:
+                # m, f = name.split('.')
+                # model_field = self.model._meta.get_field(m)
+                # model_name = model_field.db_column_name
+                # nested_model = model_field.nested_model
+                # field_name = nested_model._meta.get_field(f).db_column_name
+                # f_name = model_name + '.' + field_name
+                model_names = []
+                nested_model = None
+                *models, field = name.split('.')
+                for m in models:
+                    try:
+                        model_field = self.model._meta.get_field(m)
+                    except FieldNotFound:
+                        model_field = nested_model._meta.get_field(m)
+
+                    nested_model = model_field.nested_model
+                    name = model_field.db_column_name
+
+                    model_names.append(name)
+                model_name = '.'.join(model_names)
+                field_name = nested_model._meta.get_field(field).db_column_name
+                f_name = model_name + '.' + field_name
+            else:
+                f_name = self.model._meta.get_field(name).db_column_name
             filters.append((f_name, op, val))
         return filters
 
diff --git a/src/fireo/queries/update_query.py b/src/fireo/queries/update_query.py
@@ -1,6 +1,7 @@
 from fireo.fields import NestedModel
 from fireo.queries import query_wrapper
 from fireo.queries.base_query import BaseQuery
+from fireo.utils import utils
 
 
 class UpdateQuery(BaseQuery):
@@ -51,25 +52,27 @@ class User(Model):
             # Check if it is nested model
             if isinstance(f, NestedModel):
                 # Get nested model field
-                for nested_f in f.nested_model._meta.field_list.values():
-                    v = nested_f.get_value(self.query.get(f.name+"."+nested_f.name), ignore_required=True)
-                    if v:
-                        # create the name with parent field name and child name
-                        # For example:
-                        #   class User(Model):
-                        #       address = TextField()
-                        #   class Student(Model):
-                        #       age = NumberField()
-                        #       user = NestedModel(User)
-                        #
-                        # Then the field name for nested model will be "user.address"
-                        field_dict[f.db_column_name+"."+nested_f.db_column_name] = v
+                self._nested_field_list(f, field_dict, f.name)
             else:
                 v = f.get_value(self.query.get(f.name), ignore_required=True)
                 if v:
                     field_dict[f.db_column_name] = v
         return field_dict
 
+    def _nested_field_list(self, f, fl, *name):
+        """Get Nested Fields"""
+        nested_field_list = {}
+        for n_f in f.nested_model._meta.field_list.values():
+            if isinstance(n_f, NestedModel):
+                n = (*name, n_f.name)
+                self._nested_field_list(n_f, nested_field_list, *n)
+            else:
+                nested_field_list[n_f.db_column_name] = n_f.get_value(
+                    utils.get_nested(self.query, *name).get(n_f.name),
+                    ignore_required=True
+                )
+        fl[f.db_column_name] = nested_field_list
+
     def _raw_exec(self):
         """Update document in firestore and return the document"""
         ref = self._doc_ref()
diff --git a/src/fireo/utils/utils.py b/src/fireo/utils/utils.py
@@ -31,4 +31,12 @@ def get_id(key):
 
 
 def GeoPoint(latitude: float, longitude: float):
-    return firestore.GeoPoint(latitude, longitude)
+    return firestore.GeoPoint(latitude, longitude)
+
+
+def get_nested(dict, *args):
+    if args and dict:
+        element = args[0]
+        if element:
+            value = dict.get(element)
+            return value if len(args) == 1 else get_nested(value, *args[1:])
diff --git a/src/tests/v020/test_cursor.py b/src/tests/v020/test_cursor.py
@@ -94,4 +94,10 @@ def test_parent_cursor_fetch():
 
     for c in childs:
         assert utils.get_parent_doc(c.key) == parent_key
-        assert c.age in [4,5,6]
+        assert c.age in [4,5,6]
+
+
+def test_delete_all_cursor_fetch():
+    CursorPages.collection.delete()
+    CursorParentFetch.collection.delete()
+    CursorChildFetch.collection.delete()
diff --git a/src/tests/v020/test_next_fetch.py b/src/tests/v020/test_next_fetch.py
@@ -97,4 +97,8 @@ def test_fetch_without_next():
         assert page.name in page_list
         index += 1
 
-    assert index == 6
+    assert index == 6
+
+
+def test_delete_all_next_fetch():
+    NextFetchModel.collection.delete()
diff --git a/src/tests/v030/test_deep_nested.py b/src/tests/v030/test_deep_nested.py
@@ -0,0 +1,122 @@
+import pytest
+
+from fireo.fields import TextField, NumberField, NestedModel
+from fireo.fields.errors import RequiredField
+from fireo.models import Model
+
+
+class DeepNestedUser(Model):
+    name = TextField()
+    age = NumberField(default=26)
+
+
+class DeepNestedStudent(Model):
+    uni = TextField(required=True)
+    user = NestedModel(DeepNestedUser)
+
+
+class DeepNestedUni(Model):
+    dept = TextField()
+    student = NestedModel(DeepNestedStudent)
+
+
+def test_simple_deep_nested():
+    u = DeepNestedUni()
+    u.dept = 'Math'
+    u.student.uni = 'Abc'
+    u.student.user.name = 'Azeem'
+    u.save()
+
+    u = DeepNestedUni.collection.get(u.key)
+
+    assert u.dept == 'Math'
+    assert u.student.uni == 'Abc'
+    assert u.student.user.name == 'Azeem'
+    assert u.student.user.age == 26
+
+
+def test_simple_deep_nested_update():
+    u = DeepNestedUni()
+    u.dept = 'Math'
+    u.student.uni = 'Abc'
+    u.student.user.name = 'Azeem'
+    u.save()
+
+    u2 = DeepNestedUni()
+    u2.student.uni = 'Def'
+    u2.student.user.name = 'Arfan'
+    u2.update(u.key)
+
+    u3 = DeepNestedUni.collection.get(u2.key)
+
+    assert u3.dept == 'Math'
+    assert u3.student.uni == 'Def'
+    assert u3.student.user.name == 'Arfan'
+    assert u3.student.user.age == 26
+
+class DeepNestedUser2(Model):
+    name = TextField()
+    age = NumberField(default=26)
+
+
+class DeepNestedStudent2(Model):
+    uni = TextField(required=True)
+    user = NestedModel(DeepNestedUser2)
+
+
+class DeepNestedUni2(Model):
+    dept = TextField()
+    student = NestedModel(DeepNestedStudent2)
+
+
+def test_deep_nested_with_required_fields_without_value():
+    u = DeepNestedUni2()
+    u.dept = 'Math'
+    u.student.user.name = 'Azeem'
+    u.save()
+
+    u = DeepNestedUni2.collection.get(u.key)
+
+    assert u.dept == 'Math'
+    assert u.student.uni is None
+    assert u.student.user.name == 'Azeem'
+    assert u.student.user.age == 26
+
+
+class DeepNestedUser3(Model):
+    name = TextField()
+    age = NumberField(default=26)
+
+
+class DeepNestedStudent3(Model):
+    uni = TextField(required=True)
+    user = NestedModel(DeepNestedUser3)
+
+
+class DeepNestedUni3(Model):
+    dept = TextField()
+    student = NestedModel(DeepNestedStudent3, required=True)
+
+
+def test_deep_nested_with_required_fields():
+    u = DeepNestedUni3()
+    u.dept = 'Math'
+    u.student.user.name = 'Azeem'
+
+    with pytest.raises(RequiredField):
+        u.save()
+
+
+class DeepDirectNestedModel(Model):
+    name = TextField()
+
+
+class DirectNestedModel(Model):
+    age = NumberField()
+    user = NestedModel(DeepDirectNestedModel)
+
+
+def test_direct_create_nested_model():
+    u = DirectNestedModel.collection.create(age=26)
+
+    assert u.age == 26
diff --git a/src/tests/v030/test_nested_filter.py b/src/tests/v030/test_nested_filter.py
