Syncano · opalczynski · Jul 19, 2016 · May 13, 2016 · May 17, 2016 · May 17, 2016
diff --git a/README.rst b/README.rst
@@ -15,8 +15,8 @@ You can also find library reference hosted on GitHub pages [here](http://syncano
 Backwards incompatible changes
 ------------------------------
 
-Version 4.0 is designed for new release of Syncano platform and
-it's **not compatible** with any previous releases.
+Version 4.x and 5.x is designed for new release of Syncano platform and
+is **not compatible** with any previous releases.
 
 Code from `0.6.x` release is avalable on [stable/0.6.x](https://github.com/Syncano/syncano-python/tree/stable/0.6.x) branch
 and it can be installed directly from pip via:

diff --git a/syncano/__init__.py b/syncano/__init__.py
@@ -2,7 +2,7 @@
 import os
 
 __title__ = 'Syncano Python'
-__version__ = '5.1.0'
+__version__ = '5.2.0'
 __author__ = "Daniel Kopka, Michal Kobus, and Sebastian Opalczynski"
 __credits__ = ["Daniel Kopka",
                "Michal Kobus",

diff --git a/syncano/exceptions.py b/syncano/exceptions.py
@@ -75,3 +75,7 @@ class SyncanoDoesNotExist(SyncanoException):
 
 class RevisionMismatchException(SyncanoRequestError):
     """Revision do not match with expected one"""
+
+
+class UserNotFound(SyncanoRequestError):
+    """Special error to handle user not found case."""
diff --git a/syncano/models/accounts.py b/syncano/models/accounts.py
@@ -1,4 +1,4 @@
-
+from syncano.exceptions import SyncanoRequestError, SyncanoValueError, UserNotFound
 
 from . import fields
 from .base import Model
@@ -37,7 +37,7 @@ class Meta:
                 'path': '/admins/{id}/',
             },
             'list': {
-                'methods': ['get'],
+                'methods': ['get', 'post'],
                 'path': '/admins/',
             }
         }
@@ -76,7 +76,7 @@ class Meta:
                 'path': '/objects/{id}/',
             },
             'list': {
-                'methods': ['get'],
+                'methods': ['get', 'post'],
                 'path': '/objects/',
             }
         }
@@ -100,7 +100,8 @@ class User(Model):
     password = fields.StringField(read_only=False, required=True)
     user_key = fields.StringField(read_only=True, required=False)
 
-    profile = fields.ModelField('Profile', read_only=False, default={})
+    profile = fields.ModelField('Profile', read_only=False, default={},
+                                just_pk=False, is_data_object_mixin=True)
 
     links = fields.LinksField()
     created_at = fields.DateTimeField(read_only=True, required=False)
@@ -117,29 +118,64 @@ class Meta:
                 'methods': ['post'],
                 'path': '/users/{id}/reset_key/',
             },
+            'auth': {
+                'methods': ['post'],
+                'path': '/user/auth/',
+            },
             'list': {
-                'methods': ['get'],
+                'methods': ['get', 'post'],
                 'path': '/users/',
             },
             'groups': {
-                'methods': ['get', 'post'],
+                'methods': ['get', 'post', 'delete'],
                 'path': '/users/{id}/groups/',
             }
         }
 
     def reset_key(self):
         properties = self.get_endpoint_data()
-        endpoint = self._meta.resolve_endpoint('reset_key', properties)
+        http_method = 'POST'
+        endpoint = self._meta.resolve_endpoint('reset_key', properties, http_method)
+        connection = self._get_connection()
+        return connection.request(http_method, endpoint)
+
+    def auth(self, username=None, password=None):
+        properties = self.get_endpoint_data()
+        http_method = 'POST'
+        endpoint = self._meta.resolve_endpoint('auth', properties, http_method)
         connection = self._get_connection()
-        return connection.request('POST', endpoint)
+
+        if not (username and password):
+            raise SyncanoValueError('You need provide username and password.')
+
+        data = {
+            'username': username,
+            'password': password
+        }
+
+        return connection.request(http_method, endpoint, data=data)
 
     def _user_groups_method(self, group_id=None, method='GET'):
         properties = self.get_endpoint_data()
-        endpoint = self._meta.resolve_endpoint('groups', properties)
-        if group_id is not None:
+        endpoint = self._meta.resolve_endpoint('groups', properties, method)
+
+        if group_id is not None and method != 'POST':
             endpoint += '{}/'.format(group_id)
         connection = self._get_connection()
-        return connection.request(method, endpoint)
+
+        data = {}
+        if method == 'POST':
+            data = {'group': group_id}
+
+        response = connection.request(method, endpoint, data=data)
+
+        if method == 'DELETE':  # no response here;
+            return
+
+        if 'objects' in response:
+            return [Group(**group_response['group']) for group_response in response['objects']]
+
+        return Group(**response['group'])
 
     def add_to_group(self, group_id):
         return self._user_groups_method(group_id, method='POST')
@@ -180,7 +216,7 @@ class Meta:
                 'path': '/groups/{id}/',
             },
             'list': {
-                'methods': ['get'],
+                'methods': ['get', 'post'],
                 'path': '/groups/',
             },
             'users': {
@@ -191,11 +227,29 @@ class Meta:
 
     def _group_users_method(self, user_id=None, method='GET'):
         properties = self.get_endpoint_data()
-        endpoint = self._meta.resolve_endpoint('users', properties)
-        if user_id is not None:
+        endpoint = self._meta.resolve_endpoint('users', properties, method)
+        if user_id is not None and method != 'POST':
             endpoint += '{}/'.format(user_id)
         connection = self._get_connection()
-        return connection.request(method, endpoint)
+
+        data = {}
+        if method == 'POST':
+            data = {'user': user_id}
+
+        try:
+            response = connection.request(method, endpoint, data=data)
+        except SyncanoRequestError as e:
+            if e.status_code == 404:
+                raise UserNotFound(e.status_code, 'User not found.')
+            raise
+
+        if method == 'DELETE':
+            return
+
+        if 'objects' in response:
+            return [User(**user_response['user']) for user_response in response['objects']]
+
+        return User(**response['user'])
 
     def list_users(self):
         return self._group_users_method()

diff --git a/syncano/models/archetypes.py b/syncano/models/archetypes.py
@@ -134,7 +134,7 @@ def save(self, **kwargs):
             if 'put' in methods:
                 method = 'PUT'
 
-        endpoint = self._meta.resolve_endpoint(endpoint_name, properties)
+        endpoint = self._meta.resolve_endpoint(endpoint_name, properties, method)
         if 'expected_revision' in kwargs:
             data.update({'expected_revision': kwargs['expected_revision']})
         request = {'data': data}
@@ -171,9 +171,10 @@ def delete(self, **kwargs):
             raise SyncanoValidationError('Method allowed only on existing model.')
 
         properties = self.get_endpoint_data()
-        endpoint = self._meta.resolve_endpoint('detail', properties)
+        http_method = 'DELETE'
+        endpoint = self._meta.resolve_endpoint('detail', properties, http_method)
         connection = self._get_connection(**kwargs)
-        connection.request('DELETE', endpoint)
+        connection.request(http_method, endpoint)
         if self.__class__.__name__ == 'Instance':  # avoid circular import;
             registry.clear_used_instance()
         self._raw_data = {}
@@ -185,9 +186,10 @@ def reload(self, **kwargs):
             raise SyncanoValidationError('Method allowed only on existing model.')
 
         properties = self.get_endpoint_data()
-        endpoint = self._meta.resolve_endpoint('detail', properties)
+        http_method = 'GET'
+        endpoint = self._meta.resolve_endpoint('detail', properties, http_method)
         connection = self._get_connection(**kwargs)
-        response = connection.request('GET', endpoint)
+        response = connection.request(http_method, endpoint)
         self.to_python(response)
 
     def validate(self):
@@ -225,10 +227,19 @@ def to_python(self, data):
         :type data: dict
         :param data: Raw data
         """
+
         for field in self._meta.fields:
             field_name = field.name
 
-            if field.mapping is not None and self.pk:
+            # some explanation needed here:
+            # When data comes from Syncano Platform the 'class' field is there
+            # so to map correctly the 'class' value to the 'class_name' field
+            # the mapping is required.
+            # But. When DataEndpoint (and probably others models with mapping) is created from
+            # syncano LIB directly: DataEndpoint(class_name='some_class')
+            # the data dict has only 'class_name' key - not the 'class',
+            # later the transition between class_name and class is made in to_native on model;
+            if field.mapping is not None and field.mapping in data and self.is_new():
                 field_name = field.mapping
 
             if field_name in data:

diff --git a/syncano/models/backups.py b/syncano/models/backups.py
@@ -0,0 +1,78 @@
+# -*- coding: utf-8 -*-
+from . import fields
+from .base import Model
+from .instances import Instance
+
+
+class Backup(Model):
+    """
+    OO wrapper around backups `link <http://docs.syncano.com/docs/full-backups>`_.
+
+    :ivar label: :class:`~syncano.models.fields.StringField`
+    :ivar description: :class:`~syncano.models.fields.StringField`
+    :ivar instance: :class:`~syncano.models.fields.StringField`
+    :ivar size: :class:`~syncano.models.fields.IntegerField`
+    :ivar status: :class:`~syncano.models.fields.StringField`
+    :ivar status_info: :class:`~syncano.models.fields.StringField`
+    :ivar author: :class:`~syncano.models.fields.ModelField`
+    :ivar details: :class:`~syncano.models.fields.JSONField`
+    :ivar updated_at: :class:`~syncano.models.fields.DateTimeField`
+    :ivar created_at: :class:`~syncano.models.fields.DateTimeField`
+    :ivar links: :class:`~syncano.models.fields.HyperlinkedField`
+    """
+
+    label = fields.StringField(read_only=True)
+    description = fields.StringField(read_only=True)
+
+    instance = fields.StringField(read_only=True)
+    size = fields.IntegerField(read_only=True)
+    status = fields.StringField(read_only=True)
+    status_info = fields.StringField(read_only=True)
+    author = fields.ModelField('Admin')
+    details = fields.JSONField(read_only=True)
+
+    updated_at = fields.DateTimeField(read_only=True, required=False)
+    created_at = fields.DateTimeField(read_only=True, required=False)
+    links = fields.LinksField()
+
+    class Meta:
+        parent = Instance
+        endpoints = {
+            'detail': {
+                'methods': ['get', 'delete'],
+                'path': '/backups/full/{id}/',
+            },
+            'list': {
+                'methods': ['post', 'get'],
+                'path': '/backups/full/',
+            },
+        }
+
+    def schedule_restore(self):
+        restore = Restore(backup=self.id).save()
+        return restore
+
+
+class Restore(Model):
+
+    author = fields.ModelField('Admin')
+    status = fields.StringField(read_only=True)
+    status_info = fields.StringField(read_only=True)
+    updated_at = fields.DateTimeField(read_only=True, required=False)
+    created_at = fields.DateTimeField(read_only=True, required=False)
+    links = fields.LinksField()
+    backup = fields.StringField()
+    archive = fields.StringField(read_only=True)
+
+    class Meta:
+        parent = Instance
+        endpoints = {
+            'list': {
+                'methods': ['get', 'post'],
+                'path': '/restores/',
+            },
+            'detail': {
+                'methods': ['get'],
+                'path': '/restores/{id}/',
+            }
+        }
diff --git a/syncano/models/base.py b/syncano/models/base.py
@@ -10,3 +10,5 @@
 from .traces import *  # NOQA
 from .push_notification import *  # NOQA
 from .geo import *  # NOQA
+from .backups import *  # NOQA
+from .data_views import DataEndpoint as EndpointData  # NOQA
diff --git a/syncano/models/channels.py b/syncano/models/channels.py
@@ -138,7 +138,7 @@ class Meta:
 
     def poll(self, room=None, last_id=None, callback=None, error=None, timeout=None):
         properties = self.get_endpoint_data()
-        endpoint = self._meta.resolve_endpoint('poll', properties)
+        endpoint = self._meta.resolve_endpoint('poll', properties, http_method='GET')
         connection = self._get_connection()
 
         thread = PollThread(connection, endpoint, callback, error, timeout=timeout,
@@ -148,10 +148,11 @@ def poll(self, room=None, last_id=None, callback=None, error=None, timeout=None)
 
     def publish(self, payload, room=None):
         properties = self.get_endpoint_data()
-        endpoint = self._meta.resolve_endpoint('publish', properties)
+        http_method = 'POST'
+        endpoint = self._meta.resolve_endpoint('publish', properties, http_method)
         connection = self._get_connection()
         request = {'data': Message(payload=payload, room=room).to_native()}
-        response = connection.request('POST', endpoint, **request)
+        response = connection.request(http_method, endpoint, **request)
         return Message(**response)
 
 
@@ -189,7 +190,7 @@ class Meta:
                 'path': '/history/{pk}/',
             },
             'list': {
-                'methods': ['get'],
+                'methods': ['get', 'post'],
                 'path': '/history/',
             },
         }
diff --git a/syncano/models/classes.py b/syncano/models/classes.py
@@ -156,7 +156,7 @@ def _set_up_object_class(cls, model):
 
     @classmethod
     def _get_instance_name(cls, kwargs):
-        return kwargs.get('instance_name')
+        return kwargs.get('instance_name') or registry.instance_name
 
     @classmethod
     def _get_class_name(cls, kwargs):