Merge pull request #31 from ets-labs/8-get_model_data

Issue #8: Implementation of DomainModel.get_data() method.

Author: boonya

CONTRIBUTORS.rst

@@ -2,4 +2,4 @@ Domain Models Contributors
 ==========================
 
 + Roman Mogilatov
-
++ Sergii [boonya] Buinytskyi

domain_models/__init__.py

@@ -1,3 +1,3 @@
 """Domain models."""
 
-VERSION = '0.0.3'
+VERSION = '0.0.4'

domain_models/fields.py

@@ -55,6 +55,7 @@ def get_value(self, model, default=None):
 
         :param DomainModel model:
         :param mixed default:
+        :rtype object:
         """
         if default is not None:
             default = self._converter(default)
@@ -63,7 +64,11 @@ def get_value(self, model, default=None):
         return value if value is not None else default
 
     def set_value(self, model, value):
-        """Set field's value."""
+        """Set field's value.
+
+        :param DomainModel model:
+        :param mixed value:
+        """
         if value is None and self.required:
             raise AttributeError("This field is required.")
 
@@ -72,6 +77,14 @@ def set_value(self, model, value):
 
         setattr(model, self.storage_name, value)
 
+    def get_builtin_type(self, model):
+        """Return built-in type representation of Field.
+
+        :param DomainModel model:
+        :rtype object:
+        """
+        return self.get_value(model)
+
     def _converter(self, value):
         """Convert raw input value of the field."""
         return value
@@ -154,6 +167,14 @@ def _converter(self, value):
                                                   self.related_model_cls))
         return value
 
+    def get_builtin_type(self, model):
+        """Return built-in type representation of Model.
+
+        :param DomainModel model:
+        :rtype dict:
+        """
+        return self.get_value(model).get_data()
+
 
 class Collection(Field):
     """Models collection relation field."""
@@ -168,3 +189,12 @@ def _converter(self, value):
         if type(value) is not self.related_model_cls.Collection:
             value = self.related_model_cls.Collection(value)
         return value
+
+    def get_builtin_type(self, model):
+        """Return built-in type representation of Collection.
+
+        :param DomainModel model:
+        :rtype list:
+        """
+        return [item.get_data() if isinstance(item, self.related_model_cls)
+                else item for item in self.get_value(model)]

domain_models/models.py

@@ -180,13 +180,6 @@ def __str__(self):
                                               str(field.get_value(self))))
                                     for field in self.__class__.__view_key__))
 
-    @property
-    def __data__(self):
-        """Read only dictionary of model fields/values."""
-        return dict((name, field.get_value(self))
-                    for name, field in
-                    six.iteritems(self.__class__.__fields__))
-
     def get(self, field_name, default=None):
         """Return the value of the field.
 
@@ -209,3 +202,12 @@ def get(self, field_name, default=None):
                 "Field {0} does not exist.".format(field_name))
         else:
             return field.get_value(self, default)
+
+    def get_data(self):
+        """Read only dictionary of model fields/values.
+
+        :rtype dict:
+        """
+        return dict((name, field.get_builtin_type(self))
+                    for name, field in
+                    six.iteritems(self.__class__.__fields__))

tests/test_models.py

@@ -57,47 +57,6 @@ class User(models.DomainModel):
         self.assertEqual(user2.gender, 'female')
         self.assertEqual(user2.birth_date, '05/04/1985')
 
-    def test_data_attr(self):
-        """Test model's __data__ attribute."""
-        class User(models.DomainModel):
-            """Test user domain model."""
-
-            id = fields.Int()
-            email = fields.String()
-            first_name = fields.String()
-            last_name = fields.String()
-            gender = fields.String()
-            birth_date = fields.String()
-
-        user1 = User()
-        user1.id = 1
-        user1.email = 'example1@example.com'
-        user1.first_name = 'John'
-        user1.last_name = 'Smith'
-        user1.gender = 'male'
-        user1.birth_date = '05/04/1988'
-
-        user2 = User()
-        user2.id = 2
-        user2.email = 'example2@example.com'
-        user2.first_name = 'Jane'
-        user2.last_name = 'Smith'
-        user2.gender = 'female'
-        user2.birth_date = '05/04/1985'
-
-        self.assertEquals(user1.__data__, dict(id=1,
-                                               email='example1@example.com',
-                                               first_name='John',
-                                               last_name='Smith',
-                                               gender='male',
-                                               birth_date='05/04/1988'))
-        self.assertEquals(user2.__data__, dict(id=2,
-                                               email='example2@example.com',
-                                               first_name='Jane',
-                                               last_name='Smith',
-                                               gender='female',
-                                               birth_date='05/04/1985'))
-
     def test_not_valid_unique_key_field(self):
         """Test that error is raised when unique key is not correct."""
         with self.assertRaises(errors.Error):
@@ -324,6 +283,40 @@ def test_get_method_on_collection(self):
         """Test method get on Collection of Model."""
         self.skipTest("Test is not implemented yet")
 
+    def test_get_data_method(self):
+        class Photo(models.DomainModel):
+            id = fields.Int()
+            url = fields.String()
+
+        class Profile(models.DomainModel):
+            id = fields.Int()
+            name = fields.String()
+            main_photo = fields.Model(Photo)
+            photos = fields.Collection(Photo)
+            birth_date = fields.Date()
+            sequence = fields.Collection(fields.Int)
+
+        photo1 = Photo(id=1, url='http://boonya.info/wat.jpg?1')
+        photo2 = Photo(id=2, url='http://boonya.info/wat.jpg?2')
+        profile = Profile(id=1, name='John', main_photo=photo1,
+                          photos=[photo1, photo2],
+                          sequence=[1, 1, 2, 3, 5, 8, 13],
+                          birth_date=datetime.date(year=1986, month=4,
+                                                   day=26))
+
+        self.assertDictEqual(profile.get_data(), {
+            'id': 1,
+            'name': 'John',
+            'main_photo': {'id': 1,
+                           'url': 'http://boonya.info/wat.jpg?1'},
+            'photos': [
+                {'id': 1, 'url': 'http://boonya.info/wat.jpg?1'},
+                {'id': 2, 'url': 'http://boonya.info/wat.jpg?2'}
+            ],
+            'sequence': [1, 1, 2, 3, 5, 8, 13],
+            'birth_date': datetime.date(year=1986, month=4, day=26)
+        })
+
 
 class ModelReprTests(unittest.TestCase):
     """Tests for model Pythonic representation."""