Merge pull request #9 from coolsms/feature-message

Feature message

Author: hosysy

.gitignore

@@ -1,4 +1,4 @@
-coolsms.pyc
+*.pyc
 */.idea/*
-*/__pycache__
+*__pycache__
 test.py

examples/coolsms_unit_test.py

@@ -0,0 +1,184 @@
+# vi:set sw=4 ts=4 expandtab:
+
+import sys
+import unittest
+sys.path.insert(0, "../")
+
+from sdk.api.message import Message
+from sdk.api.group_message import GroupMessage
+from sdk.api.sender_id import SenderID
+from sdk.api.image import Image
+from sdk.coolsms import Coolsms 
+from sdk.exceptions import CoolsmsException
+
+import sys,json
+
+def makeSuite(testcase,tests):
+    return unittest.TestSuite(map(testcase,tests)) #testcase를 이용해서 testsuite생성
+
+## @class CoolsmsUnitTest 
+#  @brief Coolsms Python SDK Unit Test
+class CoolsmsUnitTest(unittest.TestCase):
+
+    api_key = "NCS57A43A134D2B9"
+    api_secret = "9BF07E949C74516A70D7C6A4D6B2B0D3"
+
+    def setUp(self):
+        pass
+
+    ## @brief python sdk 'message' resource test
+    def test_message(self):
+        cool = Message(self.api_key, self.api_secret)
+
+        ## send 
+        params = {
+            'type':'sms',
+            'to':'01000000000',
+            'from':'01000000000',
+            'text':'Test Message'
+        }
+        try:
+            cool.send(params)
+        except CoolsmsException as e:
+            # 402는 잔액부족이기 때문에 테스트 실패사유가 안됨
+            if e.code == 402:
+                pass
+            
+        ## status : response 가 None값이 아니라면 성공
+        response = cool.status()
+        self.assertIsNotNone(response[0]['registdate'])
+
+        ## sent
+        try:
+            cool.sent()
+        except CoolsmsException as e:
+            # 404는 메시지 내역이 없는 것이기 때문에 테스트 실패사유가 안됨
+            if e.code == 404:
+                pass
+
+        ## balane
+        response = cool.balance()
+        self.assertIsNotNone(response['deferred_payment'])
+
+        ## cancel
+        params = {
+            'message_id':'TESTMESSAGEID',
+        }
+        self.assertIsNotNone(cool.cancel(params))
+
+    ## @brief python sdk 'group_message' resource test
+    def test_group_message(self):
+        cool = GroupMessage(self.api_key, self.api_secret)
+
+        ## create group
+        response = cool.create_group()
+        group_id = response['group_id']
+        self.assertIsNotNone(group_id)
+
+        ## group list
+        response = cool.get_group_list()
+        self.assertIsNotNone(response['list'][0])
+
+        ## add messages
+        params = {
+            'group_id':group_id,
+            'to':'01000000000',
+            'from':'01000000000',
+            'text':'TestGroupMessage'
+        }
+        response = cool.add_messages(params)
+        self.assertIsNotNone(response['error_count'])
+        
+        ## add messages json
+        params = [ 
+            {"from":"01000000000", "to":"01000000001", "text":"TestGroupMessage"}, 
+            {"from":"01000000000", "to":"01000000002", "text":"TestGroupMessage"} 
+        ]
+        messages = json.dumps(params)
+        response = cool.add_messages_json(group_id, messages)
+        self.assertIsNotNone(response[0]['error_count'])
+
+        ## get message list
+        params = {'group_id':group_id}
+        try:
+            cool.get_message_list(params)
+        except CoolsmsException as e:
+            # 404는 메시지 내역이 없는 것이기 때문에 테스트 실패사유가 안됨
+            if e.code == 404:
+                pass
+
+        ## delete messages
+        message_id = 'TESTMESSAGEID'
+        response = cool.delete_messages(group_id, message_id)
+        self.assertIsNotNone(response['error_count'])
+
+        ## send 
+        try:
+            cool.send(params)
+        except CoolsmsException as e:
+            # 402는 잔액부족이기 때문에 테스트 실패사유가 안됨
+            if e.code == 402:
+                pass
+
+    ## @brief python sdk 'image' resource test
+    def test_image(self):
+        cool = Image(self.api_key, self.api_secret)
+        image = 'image/test.jpg'
+
+        ## upload image
+        response = cool.upload_image(image)
+        image_id = response['image_id'] 
+        
+        ## get image list
+        response = cool.get_image_list()
+        self.assertIsNotNone(response['total_count'])
+
+        ## get image info
+        response = cool.get_image_info(image_id)
+        self.assertIsNotNone(response['file_name'])
+        
+        ## delete images
+        response = cool.delete_images(image_id)
+        self.assertIsNotNone(response['success_count'])
+
+    ## @brief python sdk 'sender_id' resource test
+    def test_sender_id(self):
+        cool = SenderID(self.api_key, self.api_secret)
+
+        ## register
+        phone = "01000000000"
+        response = cool.register(phone)
+        self.assertIsNotNone(response['handle_key'])
+        handle_key = response['handle_key']
+
+        ## verify
+        try:
+            cool.verify(handle_key)
+        except CoolsmsException as e:
+            # 401은 대기중 상태로 테스트 실패사유가 안됨
+            if e.code == 401:
+                pass
+
+        ## delete
+        response = cool.delete(handle_key)
+        self.assertIsNone(response)
+
+        ## get list
+        self.assertIsNotNone(cool.get_list())
+
+        ## set_default
+        self.assertIsNone(cool.set_default(handle_key))
+
+        ## get_default
+        try:
+            cool.get_default()
+        except CoolsmsException as e:
+            # 404는 default sender id가 없는 것이므로 테스트 실패사유가 안됨
+            if e.code == 404:
+                pass
+
+
+if __name__ == "__main__":
+    suite = makeSuite(CoolsmsUnitTest,['test_message', 'test_group_message', 'test_image', 'test_sender_id'])
+    unittest.TextTestRunner(verbosity=2).run(suite)
+    sys.exit()

sdk/api/__pycache__/__init__.cpython-34.pyc

@@ -2,29 +2,89 @@
 # -*- coding: utf8 -*-
 
 import sys
+import base64
 sys.path.insert(0, "../../")
 
 from sdk.coolsms import Coolsms
-from sdk import exceptions
+from sdk.exceptions import CoolsmsException
+from sdk.exceptions import CoolsmsSDKException
+from sdk.exceptions import CoolsmsSystemException
+from sdk.exceptions import CoolsmsServerException
 
-# class Image
+## @class Image 
+#  @brief management image, using Rest API
 class Image:
-    #
+    # Coolsms Object
+    cool = None
+
+    ## @brief initialize
+    #  @param string api_key [required]
+    #  @param string api_secret [required]
     def __init__(self, api_key, api_secret):
-        Coolsms(api_key, api_secret)
+        self.cool = Coolsms(api_key, api_secret)
+
+    # @brief get image list( HTTP Method GET )
+    # @param string offset [optional]
+    # @param string limit [optional]
+    # @return JSONObject
+    def get_image_list(self, offset=None, limit=None):
+        params = dict()
+
+        if offset:
+            params['offset'] = offset
+        if limit:
+            params['limit'] = limit
+
+        response = self.cool.request_get('image_list', params)
+
+        return response
+
+    # @brief get image info ( HTTP Method GET )
+    # @param string image_id [required]
+    # @return JSONObject
+    # @throws CoolsmsException
+    def get_image_info(self, image_id):
+        if image_id == None:
+            raise CoolsmsSDKException("'image_id' is required", 201);
+
+        resource = "images/" + image_id;
+        response = self.cool.request_get(resource)
+
+        return response
+
+    # @brief upload image ( HTTP Method POST )
+    # @param string image [required]
+    # @return JSONobject
+    def upload_image(self, image):
+        if image == None:
+            raise CoolsmsSDKException("'image' is required", 201);
+
+        params = dict()
+        params = {'image':image}
+        params['image_encoding'] = 'base64'
+
+        files = {}
+        try:
+            with open(image, 'rb') as content_file:
+                content = base64.b64encode(content_file.read())
+                content = content.decode()
+        except Exception as e:
+            raise CoolsmsSystemException(e, 399)
+        files = {'image': {'filename': image, 'content': content}}
 
-    # 
-    def get_image_list(self):
-        return
+        response = self.cool.request_post_multipart("upload_image", params, files)
 
-    # 
-    def get_image_info(self):
-        return
+        return response
 
-    # 
-    def upload_image(self):
-        return 
+    # @brief delete images ( HTTP Method POST )
+    # @param string image_ids [required]
+    # @return JSONObject 
+    def delete_images(self, image_ids):
+        if image_ids == None:
+            raise CoolsmsSDKException("'image_ids' is required", 201);
+        
+        params = dict()
+        params = {'image_ids':image_ids}
+        response = self.cool.request_post('delete_images', params)
 
-    # 
-    def delete_images(self):
-        return
+        return response

sdk/api/__pycache__/group_message.cpython-34.pyc

@@ -3,6 +3,7 @@
 
 import sys
 import platform
+import base64
 sys.path.insert(0, "../../")
 
 from sdk.coolsms import Coolsms
@@ -58,16 +59,17 @@ def send(self, params):
         # type이 mms일때 image file check
         files = {}
         if 'type' in params and params['type'] == 'mms':
-            if params['image'] is None:
+            if 'image' not in params:
                 raise CoolsmsSDKException('image file is required')
 
             try:
                 with open(params['image'], 'rb') as content_file:
-                    content = content_file.read()
+                    content = base64.b64encode(content_file.read())
+                    content = content.decode()
             except Exception as e:
                 raise CoolsmsSystemException(e, 399)
-
-            files = {'image': {'filename': image, 'content': content}}
+            files = {'image': {'filename': params['image'], 'content': content}}
+            params['image_encoding'] = 'base64'
 
         # request post multipart-form
         response = self.cool.request_post_multipart("send", params, files)