Merge pull request #21 from icoxfog417/comment_api

implements comment api

Author: icoxfog417

README.md

@@ -78,6 +78,33 @@ record = app.get(result.record_id).model(MyFolder)
 files = [f.download(app) for f in record.my_files]
 ```
 
+
+## Record Comment
+
+```python
+import pykintone
+from pykintone import model
+
+
+class Report(model.kintoneModel):
+
+    def __init__(self, title="", detail=""):
+        super(Report, self).__init__()
+        self.title = title
+        self.detail = detail
+
+
+app = pykintone.load("path_to_account_setting").app()
+
+# create record
+report = Report(title="about today", detail="I used pykintone.")
+created_id = app.create(report).record_id
+
+# create comment
+app.comment(created_id).create("Good Job!")
+
+```
+
 ## Application Administration
 
 ```python

pykintone/application.py

@@ -240,6 +240,10 @@ def administration(self):
         from pykintone.application_settings.administrator import Administrator
         return Administrator(self.account, self.api_token, self.requests_options, self.app_id)
 
+    def comment(self, record_id):
+        from pykintone.comment_api import CommentAPI
+        return CommentAPI(self.account, self.app_id, record_id, self.api_token, self.requests_options)
+
     def __str__(self):
         info = str(self.account)
         info += "\napp:\n"

pykintone/comment.py

@@ -0,0 +1,33 @@
+import pykintone.structure as ps
+
+
+class Mention():
+
+    def __init__(self, code, target_type):
+        self.code = code
+        self.target_type = target_type
+
+    @classmethod
+    def deserialize(cls, mention_dict):
+        return Mention(mention_dict["code"], mention_dict["type"])
+
+    def serialize(self):
+        return {
+            "code": self.code,
+            "type": self.target_type
+        }
+
+
+class RecordComment(ps.kintoneStructure):
+
+    def __init__(self):
+        super(RecordComment, self).__init__()
+        self.comment_id = -1
+        self.created_at = None
+        self.creator = None
+        self.mentions = []
+
+        self._property_details.append(ps.PropertyDetail("comment_id", field_name="id"))
+        self._property_details.append(ps.PropertyDetail("created_at", ps.FieldType.CREATED_TIME, field_name="createdAt"))
+        self._property_details.append(ps.PropertyDetail("creator", ps.FieldType.CREATOR))
+

pykintone/comment_api.py

@@ -0,0 +1,104 @@
+import json
+import requests
+import pykintone.comment_result as cr
+from pykintone.comment import Mention
+
+
+class CommentAPI(object):
+    API_ROOT = "https://{0}.cybozu.com/k/v1/record/comment.json"
+
+    def __init__(self, account, app_id, record_id, api_token="", requests_options=()):
+        self.account = account
+        self.app_id = app_id
+        self.record_id = record_id
+        self.api_token = api_token
+        self.requests_options = {} if len(requests_options) == 0 else requests_options
+        self._url = self.API_ROOT.format(self.account.domain)
+
+    def select(self, order_asc=None, offset=-1, limit=-1):
+        url = self._url.replace("comment.json", "comments.json")
+        data = {
+            "app": self.app_id,
+            "record": self.record_id
+        }
+
+        if order_asc is not None:
+            if order_asc:
+                data["order"] = "asc"
+            else:
+                data["order"] = "desc"
+
+        if offset > -1:
+            data["offset"] = offset
+
+        if limit > -1:
+            data["limit"] = limit
+
+        resp = self._request("GET", url, data)
+        r = cr.SelectCommentResult(resp)
+        return r
+
+
+    def create(self, comment, mentions=()):
+        """
+        create comment
+        :param comment:
+        :param mentions: list of pair of code and type("USER", "GROUP", and so on)
+        :return:
+        """
+
+        data = {
+            "app": self.app_id,
+            "record": self.record_id,
+            "comment": {
+                "text": comment,
+            }
+        }
+
+        if len(mentions) > 0:
+            _mentions = []
+            for m in mentions:
+                if isinstance(m, (list, tuple)):
+                    if len(m) == 2:
+                        _mentions.append({
+                            "code": m[0],
+                            "type": m[1]
+                        })
+                    else:
+                        raise Exception("mention have to have code and target type. ex.[('user_1', 'USER')]")
+                elif isinstance(m, Mention):
+                    _mentions.append(m.serialize())
+
+            data["comment"]["mentions"] = _mentions
+
+        resp = self._request("POST", self._url, data)
+        r = cr.CreateCommentResult(resp)
+        return r
+
+    def delete(self, comment_id):
+
+        data = {
+            "app": self.app_id,
+            "record": self.record_id,
+            "comment": comment_id
+        }
+
+        resp = self._request("DELETE", self._url, data)
+        r = cr.Result(resp)
+        return r
+
+
+    def _request(self, method, url, params_or_data, headers=None, use_api_token=True):
+        m = method.upper()
+        h = headers
+        token = self.api_token if use_api_token else ""
+        r = None
+
+        if m == "GET":
+            h = h if h else self.account.to_header(api_token=token, with_content_type=False)
+            r = requests.get(url, params=params_or_data, headers=h, **self.requests_options)
+        else:
+            h = h if h else self.account.to_header(api_token=token)
+            r = requests.request(m, url, data=json.dumps(params_or_data), headers=h, **self.requests_options)
+
+        return r

pykintone/comment_result.py

@@ -0,0 +1,34 @@
+from pykintone.result import Result
+from pykintone.comment import RecordComment, Mention
+
+
+class CreateCommentResult(Result):
+
+    def __init__(self, response):
+        super(CreateCommentResult, self).__init__(response)
+        self.comment_id = -1
+        if self.ok:
+            serialized = response.json()
+            if "id" in serialized:
+                self.comment_id = int(serialized["id"])
+
+
+class SelectCommentResult(Result):
+
+    def __init__(self, response):
+        super(SelectCommentResult, self).__init__(response)
+        self.raw_comments = []
+        self.older = False
+        self.newer = False
+        if self.ok:
+            serialized = response.json()
+            if "comments" in serialized:
+                self.raw_comments = serialized["comments"]
+                self.older = serialized["older"]
+                self.newer = serialized["newer"]
+
+    def comments(self):
+        cs = [RecordComment.deserialize(cd) for cd in self.raw_comments]
+        for c in cs:
+            c.mentions = [Mention.deserialize(m) for m in c.mentions]
+        return cs

setup.py

@@ -13,12 +13,12 @@
         'pytz',
         'tzlocal'
     ],
-    version='0.3.8',
+    version='0.3.9',
     description='Python library to access kintone',
     author='icoxfog417',
     author_email='icoxfog417@yahoo.co.jp',
     url='https://github.com/icoxfog417/pykintone',
-    download_url='https://github.com/icoxfog417/pykintone/tarball/0.3.8',
+    download_url='https://github.com/icoxfog417/pykintone/tarball/0.3.9',
     keywords=['kintone'],
     classifiers=[],
 )

tests/test_comment.py

@@ -0,0 +1,51 @@
+# -*- coding: utf-8 -*-
+import unittest
+import pykintone
+from pykintone.model import kintoneModel
+import tests.envs as envs
+
+
+class TestAppModelSimple(kintoneModel):
+
+    def __init__(self):
+        super(TestAppModelSimple, self).__init__()
+        self.my_key = ""
+        self.stringField = ""
+
+
+class TestComment(unittest.TestCase):
+
+    def test_comment(self):
+        app = pykintone.load(envs.FILE_PATH).app()
+
+        model = TestAppModelSimple()
+        model.my_key = "comment_test"
+        model.stringField = "comment_test_now"
+
+        result = app.create(model)
+        self.assertTrue(result.ok)  # confirm create the record to test comment
+        _record_id = result.record_id
+
+        # create comment
+        r_created = app.comment(_record_id).create("コメントのテスト")
+        self.assertTrue(r_created.ok)
+        # it requires Administrator user is registered in kintone
+        r_created_m = app.comment(_record_id).create("メンションのテスト", [("Administrator", "USER")])
+        self.assertTrue(r_created_m.ok)
+
+        # select comment
+        r_selected = app.comment(_record_id).select(True, 0, 10)
+        self.assertTrue(r_selected.ok)
+        self.assertTrue(2, len(r_selected.raw_comments))
+        comments = r_selected.comments()
+        self.assertTrue(1, len(comments[-1].mentions))
+
+        # delete comment
+        for c in comments:
+            r_deleted = app.comment(_record_id).delete(c.comment_id)
+            self.assertTrue(r_deleted.ok)
+        r_selected = app.comment(_record_id).select()
+        self.assertEqual(0, len(r_selected.raw_comments))
+
+        # done test
+        app.delete(_record_id)