Syncano · opalczynski · Jul 19, 2016 · May 13, 2016 · May 17, 2016 · May 17, 2016
diff --git a/syncano/models/fields.py b/syncano/models/fields.py
@@ -572,10 +572,16 @@ def validate(self, value, model_instance):
             except (ValueError, TypeError):
                 raise SyncanoValueError('Expected an array')
 
-        if not isinstance(value, list):
+        if isinstance(value, dict):
+            if len(value) != 1 or len(set(value.keys()).intersection(['_add', '_remove', '_addunique'])) != 1:
+                raise SyncanoValueError('Wrong value: one operation at the time.')
+
+        elif not isinstance(value, list):
             raise SyncanoValueError('Expected an array')
 
-        for element in value:
+        value_to_check = value if isinstance(value, list) else value.values()[0]
+
+        for element in value_to_check:
             if not isinstance(element, six.string_types + (bool, int, float)):
                 raise SyncanoValueError(
                     'Currently supported types for array items are: string types, bool, float and int')

diff --git a/syncano/models/manager.py b/syncano/models/manager.py
@@ -5,7 +5,7 @@
 from syncano.connection import ConnectionMixin
 from syncano.exceptions import SyncanoRequestError, SyncanoValidationError, SyncanoValueError
 from syncano.models.bulk import ModelBulkCreate, ObjectBulkCreate
-from syncano.models.manager_mixins import IncrementMixin, clone
+from syncano.models.manager_mixins import ArrayOperationsMixin, IncrementMixin, clone
 
 from .registry import registry
 
@@ -874,7 +874,7 @@ def run(self, *args, **kwargs):
         return registry.ScriptEndpointTrace(**response)
 
 
-class ObjectManager(IncrementMixin, Manager):
+class ObjectManager(IncrementMixin, ArrayOperationsMixin, Manager):
     """
     Custom :class:`~syncano.models.manager.Manager`
     class for :class:`~syncano.models.base.Object` model.

diff --git a/syncano/models/manager_mixins.py b/syncano/models/manager_mixins.py
@@ -110,3 +110,157 @@ def _check_field_type_for_increment(cls, model, field_name):
             return True
 
         return False
+
+
+class ArrayOperationsMixin(object):
+
+    @clone
+    def add(self, field_name, value, **kwargs):
+        """
+        A manager method that will add a values to the array field.
+
+        Usage::
+
+            data_object = Object.please.add(
+                field_name='array',
+                value=[10],
+                class_name='arr_test',
+                id=155
+            )
+
+        Consider example:
+
+        data_object.array = [1]
+
+        after running::
+
+            data_object = Object.please.add(
+                field_name='array',
+                value=[3],
+                id=data_object.id,
+            )
+
+        data_object.array will be equal: [1, 3]
+
+        and after::
+
+            data_object = Object.please.add(
+               field_name='array',
+               value=[1],
+               id=data_object.id,
+            )
+
+        data_object.array will be equal: [1, 3, 1]
+
+        :param field_name: the array field name to which elements will be added;
+        :param value: the list of values to add;
+        :param kwargs: class_name and id usually;
+        :return: the processed data object;
+        """
+        self.properties.update(kwargs)
+        model = self.model.get_subclass_model(**self.properties)
+
+        self.array_validate(field_name, value, model)
+        return self.array_process(field_name, value, operation_type='add')
+
+    def remove(self, field_name, value, **kwargs):
+        """
+        A manager method that will remove a values from the array field.
+
+        Usage::
+
+            data_object = Object.please.remove(
+                field_name='array',
+                value=[10],
+                class_name='arr_test',
+                id=155
+            )
+
+        :param field_name: the array field name from which elements will be removed;
+        :param value: the list of values to remove;
+        :param kwargs: class_name and id usually;
+        :return: the processed data object;
+        """
+        self.properties.update(kwargs)
+        model = self.model.get_subclass_model(**self.properties)
+
+        self.array_validate(field_name, value, model)
+        return self.array_process(field_name, value, operation_type='remove')
+
+    def add_unique(self, field_name, value, **kwargs):
+        """
+        A manager method that will add an unique values to the array field.
+
+        Usage::
+
+            data_object = Object.please.add_unique(
+                field_name='array',
+                value=[10],
+                class_name='arr_test',
+                id=155
+            )
+
+        The main distinction between add and add unique is that: add unique will not repeat elements.
+        Consider example::
+
+        data_object.array = [1]
+
+        after running::
+
+            data_object = Object.please.add_unique(
+                field_name='array',
+                value=[1],
+                id=data_object.id,
+            )
+
+        data_object.array will be equal: [1]
+
+        But if only add will be run the result will be as follow:
+
+        data_object.array will be equal: [1, 1]
+
+        :param field_name: field_name: the array field name to which elements will be added unique;
+        :param value: the list of values to add unique;
+        :param kwargs: class_name and id usually;
+        :return: the processed data object;
+        """
+        self.properties.update(kwargs)
+        model = self.model.get_subclass_model(**self.properties)
+
+        self.array_validate(field_name, value, model)
+        return self.array_process(field_name, value, operation_type='add_unique')
+
+    @classmethod
+    def array_validate(cls, field_name, value, model):
+
+        fields = {field.name: field for field in model._meta.fields}
+        if field_name not in fields:
+            raise SyncanoValueError('Object has not specified field.')
+
+        from syncano.models import ArrayField
+        if not isinstance(fields[field_name], ArrayField):
+            raise SyncanoValueError('Field must be of array type')
+
+        if not isinstance(value, list):
+            raise SyncanoValueError('List of values expected')
+
+    def array_process(self, field_name, value, operation_type, **kwargs):
+        self.endpoint = 'detail'
+        self.method = self.get_allowed_method('PATCH', 'PUT', 'POST')
+        self.data = kwargs.copy()
+
+        if operation_type == 'add':
+            array_data = {'_add': value}
+        elif operation_type == 'remove':
+            array_data = {'_remove': value}
+        elif operation_type == 'add_unique':
+            array_data = {'_addunique': value}
+        else:
+            raise SyncanoValueError('Operation not supported')
+
+        self.data.update(
+            {field_name: array_data}
+        )
+
+        response = self.request()
+        return response
diff --git a/tests/integration_test.py b/tests/integration_test.py
@@ -231,6 +231,7 @@ def setUpClass(cls):
                 {'type': 'float', 'name': 'cost'},
                 {'type': 'boolean', 'name': 'available'},
                 {'type': 'datetime', 'name': 'published_at'},
+                {'type': 'array', 'name': 'array'},
                 {'type': 'file', 'name': 'cover'},
                 {'type': 'reference', 'name': 'author',
                  'order_index': True, 'filter_index': True, 'target': cls.author.name},
@@ -369,6 +370,60 @@ def test_increment_and_decrement_on_float(self):
 
         self.assertEqual(decremented_book.cost, 8.4)
 
+    def test_add_array(self):
+        book = self.model.please.create(
+            instance_name=self.instance.name, class_name=self.book.name,
+            name='test', description='test', quantity=10, cost=10.5,
+            published_at=datetime.now(), available=True, array=[10])
+
+        book = Object.please.add(
+            'array',
+            [11],
+            class_name=self.book.name,
+            id=book.id
+        )
+
+        self.assertEqual(book.array, [10, 11])
+
+    def test_remove_array(self):
+        book = self.model.please.create(
+            instance_name=self.instance.name, class_name=self.book.name,
+            name='test', description='test', quantity=10, cost=10.5,
+            published_at=datetime.now(), available=True, array=[10])
+
+        book = Object.please.remove(
+            'array',
+            [10],
+            class_name=self.book.name,
+            id=book.id
+        )
+
+        self.assertEqual(book.array, [])
+
+    def test_addunique_array(self):
+        book = self.model.please.create(
+            instance_name=self.instance.name, class_name=self.book.name,
+            name='test', description='test', quantity=10, cost=10.5,
+            published_at=datetime.now(), available=True, array=[10])
+
+        book = Object.please.add_unique(
+            'array',
+            [10],
+            class_name=self.book.name,
+            id=book.id
+        )
+
+        self.assertEqual(book.array, [10])
+
+        book = Object.please.add_unique(
+            'array',
+            [11],
+            class_name=self.book.name,
+            id=book.id
+        )
+
+        self.assertEqual(book.array, [10, 11])
+
 
 class ScriptIntegrationTest(InstanceMixin, IntegrationTest):
     model = Script