Webhooks, Organisations Administration, Repo migrate, List user repos

.gitignore

@@ -91,3 +91,5 @@ ENV/
 # IDE files
 .idea/
 
+# DRONE file
+.drone.yml

docs/entities.rst

@@ -17,3 +17,12 @@ This pages documents classes provided by ``gogs_client`` module that represent e
 
 .. autoclass:: gogs_client.entities::GogsRepo.Permissions()
     :members:
+
+.. autoclass:: gogs_client.entities::GogsRepo.Hook()
+    :members:
+
+.. autoclass:: gogs_client.entities::GogsOrg()
+    :members:
+
+.. autoclass:: gogs_client.entities::GogsOrg.Team()
+    :members:

docs/updates.rst

@@ -8,3 +8,9 @@ Updates
 
 .. autoclass:: gogs_client.updates::GogsUserUpdate.Builder()
     :members:
+
+.. autoclass:: GogsHookUpdate()
+    :members:
+
+.. autoclass:: gogs_client.updates::GogsHookUpdate.Builder()
+    :members:

gogs_client/__init__.py

@@ -1,4 +1,4 @@
 from gogs_client.auth import Authentication, Token, UsernamePassword
-from gogs_client.entities import GogsUser, GogsRepo
+from gogs_client.entities import GogsUser, GogsRepo, GogsOrg
 from gogs_client.interface import GogsApi, ApiFailure, NetworkFailure
-from gogs_client.updates import GogsUserUpdate
+from gogs_client.updates import GogsUserUpdate, GogsHookUpdate

gogs_client/_implementation/http_utils.py

@@ -36,13 +36,13 @@ def options(self, relative_path, params=None, **kwargs):
         return self.session.options(self.absolute_url(relative_path), params=params, **kwargs)
 
     def patch(self, relative_path, data=None, **kwargs):
-        return self.session.patch(self.absolute_url(relative_path), data=data, **kwargs)
+        return self.session.patch(self.absolute_url(relative_path), json=data, **kwargs)
 
     def post(self, relative_path, data=None, **kwargs):
-        return self.session.post(self.absolute_url(relative_path), data=data, **kwargs)
+        return self.session.post(self.absolute_url(relative_path), json=data, **kwargs)
 
     def put(self, relative_path, params=None, data=None, **kwargs):
-        return self.session.put(self.absolute_url(relative_path), params=params, data=data, **kwargs)
+        return self.session.put(self.absolute_url(relative_path), params=params, json=data, **kwargs)
 
 
 def append_url(base_url, path):

gogs_client/entities.py

@@ -240,3 +240,329 @@ def pull(self):
             :rtype: bool
             """
             return self._pull
+
+    class Hook(object):
+        def __init__(self, hook_id, hook_type, events, active, config):
+            self._id = hook_id
+            self._type = hook_type
+            self._events = events
+            self._active = active
+            self._config = config
+
+        @staticmethod
+        def from_json(parsed_json):
+            hook_id = json_get(parsed_json, "id")
+            hook_type = json_get(parsed_json, "type")
+            events = json_get(parsed_json, "events")
+            active = json_get(parsed_json, "active")
+            config = json_get(parsed_json, "config")
+
+            return GogsRepo.Hook(hook_id=hook_id, hook_type=hook_type, events=events, active=active, 
+                            config=config)
+
+        def as_dict(self):
+            fields = {
+                "id": self._id,
+                "type": self._type,
+                "events": self._events,
+                "config": self._config,
+                "active": self._active,
+            }
+            return {k: v for (k, v) in fields.items() if v is not None}
+
+        @property  # named hook_id to avoid conflict with built-in id
+        def hook_id(self):
+            """
+            The hook's id number
+
+            :rtype: int
+            """
+            return self._id
+
+        @property  # named hook_type to avoid conflict with built-in type
+        def hook_type(self):
+            """
+            The hook's type (gogs, slack, etc.)
+
+            :rtype: str
+            """
+            return self._type
+
+        @property
+        def events(self):
+            """
+            The events that fire the hook
+
+            :rtype: List[str]
+            """
+            return self._events
+
+        @property
+        def active(self):
+            """
+            Whether the hook is active
+
+            :rtype: bool
+            """
+            return self._active
+
+        @property
+        def config(self):
+            """
+            Config of the hook. Contains max. 3 keys:
+                - content_type
+                - url
+                - secret
+
+            :rtype: dict
+            """
+            return self._config
+
+    class DeployKey(object):
+        def __init__(self, key_id, key, url, title, created_at, read_only):
+            self._id = key_id
+            self._key = key
+            self._url = url
+            self._title = title
+            self._created_at = created_at
+            self._read_only = read_only
+
+        @staticmethod
+        def from_json(parsed_json):
+            key_id = json_get(parsed_json, "id")
+            key = json_get(parsed_json, "key")
+            url = json_get(parsed_json, "url")
+            title = json_get(parsed_json, "title")
+            created_at = json_get(parsed_json, "created_at")
+            read_only = json_get(parsed_json, "read_only")
+
+            return GogsRepo.DeployKey(key_id=key_id, key=key, url=url, 
+                            title=title, created_at=created_at, read_only=read_only)
+
+        def as_dict(self):
+            fields = {
+                "id": self._id,
+                "key": self._key,
+                "url": self._url,
+                "title": self._title,
+                "created_at": self._created_at,
+                "read_only": self._read_only,
+            }
+            return {k: v for (k, v) in fields.items() if v is not None}
+
+        @property  # named key_id to avoid conflict with built-in id
+        def key_id(self):
+            """
+            The key's id number
+
+            :rtype: int
+            """
+            return self._id
+
+        @property
+        def key(self):
+            """
+            The content of the key
+
+            :rtype: str
+            """
+            return self._key
+
+        @property
+        def url(self):
+            """
+            Url where the key can be found
+
+            :rtype: str
+            """
+            return self._url
+
+        @property
+        def title(self):
+            """
+            The name of the key
+
+            :rtype: str
+            """
+            return self._title
+
+        @property
+        def created_at(self):
+            """
+            Creation date of the key.
+            :rtype: str
+            """
+            return self._created_at
+
+        @property
+        def read_only(self):
+            """
+            Whether key is read-only.
+            :rtype: bool
+            """
+            return self._read_only
+
+class GogsOrg(object):
+    """
+     An immutable representation of a Gogs Organization.
+    """
+    def __init__(self, org_id, username, full_name, avatar_url, description, website, location):
+        self._id = org_id
+        self._username = username
+        self._full_name = full_name
+        self._avatar_url = avatar_url
+        self._description = description
+        self._website = website
+        self._location = location
+
+    @staticmethod
+    def from_json(parsed_json):
+        org_id = json_get(parsed_json, "id")
+        username = json_get(parsed_json, "username")
+        full_name = json_get(parsed_json, "full_name")
+        avatar_url = json_get(parsed_json, "avatar_url")
+        description = json_get(parsed_json, "description")
+        website = json_get(parsed_json, "website")
+        location = json_get(parsed_json, "location")
+        return GogsOrg(org_id=org_id, username=username, full_name=full_name,
+                        avatar_url=avatar_url, description=description,
+                        website=website, location=location)
+
+    def as_dict(self):
+        fields = {
+            "id": self._id,
+            "username": self._username,
+            "full_name": self._full_name,
+            "avatar_url": self._avatar_url,
+            "description": self._description,
+            "website": self._website,
+            "location": self._location
+        }
+        return {k: v for (k, v) in fields.items() if v is not None}
+
+    @property  # named org_id to avoid conflict with built-in id
+    def org_id(self):
+        """
+        The organization's id
+
+        :rtype: int
+        """
+        return self._id
+
+    @property  
+    def username(self):
+        """
+        Organization's username
+
+        :rtype: str
+        """
+        return self._username
+
+    @property  
+    def full_name(self):
+        """
+        Organization's full name
+
+        :rtype: str
+        """
+        return self._full_name 
+
+    @property  
+    def avatar_url(self):
+        """
+        Organization's avatar url
+
+        :rtype: str
+        """
+        return self._avatar_url 
+
+    @property  
+    def description(self):
+        """
+        Organization's description
+
+        :rtype: str
+        """
+        return self._description 
+
+    @property  
+    def website(self):
+        """
+        Organization's website address
+
+        :rtype: str
+        """
+        return self._website 
+
+    @property  
+    def location(self):
+        """
+        Organization's location
+
+        :rtype: str
+        """
+        return self._location 
+
+    class Team(object):
+        """
+        Team of an organization
+        """
+        def __init__(self, team_id, name, description, permission):
+            self._id = team_id
+            self._name = name
+            self._description = description
+            self._permission = permission
+
+        @staticmethod
+        def from_json(parsed_json):
+            team_id = json_get(parsed_json, "id")
+            name = json_get(parsed_json, "name")
+            description = json_get(parsed_json, "description")
+            permission = json_get(parsed_json, "permission")
+            return GogsOrg.Team(team_id=team_id, name=name, description=description, permission=permission)
+
+        def as_dict(self):
+            fields = {
+                "team_id": self._id,
+                "name": self._name,
+                "description": self._description,
+                "permission": self._permission,
+            }
+            return {k: v for (k, v) in fields.items() if v is not None}
+
+        @property  # named team_id to avoid conflict with built-in id
+        def team_id(self):
+            """
+            Team's id
+
+            :rtype: int
+            """
+            return self._id 
+
+        @property
+        def name(self):
+            """
+            Team name
+
+            :rtype: str
+            """
+            return self._name
+
+        @property
+        def description(self):
+            """
+            Description to the team
+
+            :rtype: str
+            """
+            return self._description
+
+        @property
+        def permission(self):
+            """
+            Team permission, can be read, write or admin, default is read
+
+            :rtype: int
+            """
+            return self._permission
+