api message 구현

Author: hosysy

sdk/api/__init__.py

@@ -1 +0,0 @@
-print("CC")

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

@@ -6,17 +6,18 @@
 sys.path.insert(0, "../../")
 
 from sdk.coolsms import Coolsms
+from sdk.exceptions import CoolsmsException
 from sdk.exceptions import CoolsmsSDKException
-
-#import sdk.coolsms
-
-#from coolsms import coolsms
+from sdk.exceptions import CoolsmsSystemException
+from sdk.exceptions import CoolsmsServerException
 
 # class Message 
 class Message:
-    #
+    cool = None
+
+    # initialize
     def __init__(self, api_key, api_secret):
-        Coolsms(api_key, api_secret)
+        self.cool = Coolsms(api_key, api_secret)
 
     # access to send resource
     def send(self, params):
@@ -37,156 +38,75 @@ def send(self, params):
             and more informations, visit 'http://www.coolsms.co.kr/SMS_API_v2#POSTsend'
 
         Returns:
-            A JSON type string will be returned. On failure, thorw Exception
+            A JSON type string will be returned. On failure, raise Exception
         """
-        
-        print("GG")
-        print(type(params))
+        # params type check
         if type(params) is not dict:
-            raise CoolsmsSDKException("params type is no dictionary")
+            raise CoolsmsSDKException("parameter type is not dictionary", 201)
+
+        # require fields check
+        if all (k in params for k in ("to", "from", "text")) == False:
+            raise CoolsmsSDKException("parameter 'to', 'from', 'text' is required", 201)
 
         for key, val in params.items():
             print("Code : {0}, Value : {1}".format(key, val))
+
             if key == "text" and sys.version_info[0] == 2:
                 t_temp = text.decode('utf-8')
                 text = t_temp.encode('utf-8')
                 text = unicode(text, encoding='utf-8')
                 params['text'] = text
 
-            if key == "to" and type(to) == list:
+            # convert list to a comma seperated string
+            if key == "to" and val == list:
                 to = ','.join(to)
 
+            # message type check
+            if key == "type" and val.lower() not in ['sms', 'lms', 'mms', 'ata']:
+                raise CoolsmsSDKException("message type is not supported", 201)
 
+        # system info
         params['os_platform'] = platform.system()
         params['dev_lang'] = "Python %s" % platform.python_version()
         params['sdk_version'] = "sms-python %s" % Coolsms.sdk_version
-         
-        for key, val in params.items():
-            print("Code : {0}, Value : {1}".format(key, val))
 
+        # type이 mms일때 image file check
+        files = {}
+        if 'type' in params and params['type'] == 'mms':
+            if params['image'] is None:
+                raise CoolsmsSDKException('image file is required')
 
-        # convert list to a comma seperated string
-        """
-        
-        if app_version:
-            self.app_version = app_version
-
-        # get authentication info.
-        timestamp, salt, signature = self.__get_signature__()
-
-        fields = {'api_key': self.api_key,
-                  'timestamp': timestamp,
-                  'salt': salt,
-                  'signature': signature.hexdigest(),
-                  'type': mtype,
-                  'os_platform': os_platform,
-                  'dev_lang': dev_lang,
-                  'sdk_version': sdk_version,
-                  'app_version': self.app_version}
-
-        if self.test:
-            fields['mode'] = 'test'
-        if self.srk:
-            fields['srk'] = self.srk
-        if to:
-            fields['to'] = to
-        if text:
-            fields['text'] = text
-        if sender:
-            fields['from'] = sender
-        if subject:
-            fields['subject'] = subject
-        if datetime:
-            fields['datetime'] = datetime
-        if extension:
-            fields['extension'] = extension
-        if country:
-            fields['country'] = country
-
-        if image is None:
-            image = self.imgfile
-
-        if mtype.lower() == 'mms':
-            if image is None:
-                self.__set_error__('image file path input required')
-                return False
             try:
-                with open(image, 'rb') as content_file:
+                with open(params['image'], 'rb') as content_file:
                     content = content_file.read()
-            except IOError as e:
-                self.__set_error__("I/O error({0}): {1}".format(e.errno, e.strerror))
-                return False
-            except:
-                self.__set_error__("Unknown error")
-                return False
+            except Exception as e:
+                raise CoolsmsSystemException(e, 399)
+
             files = {'image': {'filename': image, 'content': content}}
-        else:
-            files = {}
 
         # request post multipart-form
-        host = self.host + ':' + str(self.port)
-        selector = "/sms/%s/send" % self.api_version
-
-        try:
-            status, reason, response = post_multipart(host, selector, fields, files)
-        except Exception as e:
-            print(e)
-            self.__set_error__("could not connect to server")
-            return False
-        if status != 200:
-            try:
-                err = json.loads(response)
-            except:
-                self.__set_error__("%u:%s" % (status, reason))
-                return False
-            self.__set_error__("%s:%s" % (err['code'], reason))
-            return False
-        return json.loads(response)
-        """
+        response = self.cool.request_post_multipart("send", params, files)
+        return response
 
-    # access to sent resource
-    def status(self, page=1, count=20, s_rcpt=None, s_start=None, s_end=None, mid=None):
-        params = dict()
-        if page:
-            params['page'] = page
-        if count:
-            params['count'] = count
-        if s_rcpt:
-            params['s_rcpt'] = s_rcpt
-        if s_start:
-            params['s_start'] = s_start
-        if s_end:
-            params['s_end'] = s_end
-        if mid:
-            params['mid'] = mid
-        response, obj = self.request_get('sent', params)
-        return obj
+    # access to statusresource
+    def status(self, params=None):
+        response = self.cool.request_get('status', params)
+        return response 
 
     # access to status resource
-    def line_status(self, count=1):
-        params = dict()
-        if count:
-            params['count'] = count
-        response, obj = self.request_get('status', params)
-        return obj
+    def sent(self, params=None):
+        response = self.cool.request_get('sent', params)
+        return response 
 
     # access to balance resource
     def balance(self):
-        response, obj = self.request_get('balance')
-        return int(obj['cash']), int(obj['point'])
+        response = self.cool.request_get('balance')
+        return response
 
     # access to cancel resource
-    def cancel(self, mid=None, gid=None):
-        if mid is None and gid is None:
-            return False
-
-        params = dict()
-        if mid:
-            params['mid'] = mid
-        if gid:
-            params['gid'] = gid
-
-        response, obj = self.request_post('cancel', params)
-        if response.status == 200:
-            return True
-        return False
+    def cancel(self, params):
+        if 'message_id' not in params and 'group_id' not in params:
+            raise CoolsmsSDKException("message_id or group_id either one must be entered", 202)
+
+        response = self.cool.request_post('cancel', params)
+        return response

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

@@ -9,6 +9,8 @@
 import time
 import platform
 
+from sdk.exceptions import CoolsmsServerException
+
 # sys.version_info.major is available in python version 2.7
 # use sys.version_info[0] for python 2.6
 if sys.version_info[0] == 2:
@@ -28,6 +30,9 @@ class Coolsms:
     # SDK Version
     sdk_version = "2.0"
 
+    # API Version
+    api_version = "2"
+
     # SMS Gateway address
     host = 'api.coolsms.co.kr'
 
@@ -65,57 +70,86 @@ def get_error(self):
 
     # http GET request 
     def request_get(self, resource, params=None):
-        timestamp, salt, signature = self.__get_signature__()
-        base_params = {'api_key': self.api_key, 'timestamp': timestamp,
-                       'salt': salt, 'signature': signature.hexdigest()}
-        if params:
-            base_params.update(params.items())
+        if params == None:
+            params = dict()
+
+        params = self.set_base_params(params)
         params_str = urlencode(base_params)
         headers = {"Content-type": "application/x-www-form-urlencoded", "Accept": "text/plain",
                    "User-Agent": "sms-python"}
         conn = HTTPSConnection(self.host, self.port)
         conn.request("GET", "/sms/%s/%s?" % (self.api_version, resource) + params_str, None, headers)
         response = conn.getresponse()
-        data = response.read()
+        data = response.read().decode()
         conn.close()
-        obj = response, json.loads(data)
+
+        # https status code is not 200, raise Exception
+        if response.status != 200:
+            raise CoolsmsServerException(response.reason, response.status)
+
+        # response data parsing
+        obj = None
+        if data:
+            obj = json.loads(data)
+
         return obj
 
     # http POST request
     def request_post(self, resource, params=None):
-        timestamp, salt, signature = self.__get_signature__()
-        base_params = {'api_key': self.api_key, 'timestamp': timestamp, 'salt': salt,
-                       'signature': signature.hexdigest()}
-        if params:
-            base_params.update(params)
-        params_str = urlencode(base_params)
+        if params == None:
+            params = dict()
+
+        params = self.set_base_params(params)
+        params_str = urlencode(params)
         headers = {"Content-type": "application/x-www-form-urlencoded", "Accept": "text/plain",
                    "User-Agent": "sms-python"}
         conn = HTTPSConnection(self.host, self.port)
         conn.request("POST", "/sms/%s/%s" % (self.api_version, resource), params_str, headers)
         response = conn.getresponse()
-        data = response.read()
+        data = response.read().decode()
         conn.close()
-        json_obj = None
+
+        # https status code is not 200, raise Exception
+        if response.status != 200:
+            raise CoolsmsServerException(response.reason, response.status)
+
+        obj = None
         if data:
-            json_obj = json.loads(data)
-        return response, json_obj
+            obj = json.loads(data)
+
+        return obj
 
     # send multipart form to the server
-    def request_post_multipart(host, selector, fields, files):
-        content_type, body = encode_multipart_formdata(fields, files)
-        h = HTTPSConnection(host)
-        h.putrequest('POST', selector)
-        h.putheader('content-type', content_type)
-        h.putheader('content-length', str(len(body.encode('utf-8'))))
-        h.putheader('User-Agent', 'sms-python')
-        h.endheaders()
-        h.send(body.encode('utf-8'))
-        resp = h.getresponse()
-        return resp.status, resp. reason, resp.read().decode()
+    def request_post_multipart(self, resource, params, files):
+        host = self.host + ':' + str(self.port)
+        selector = "/sms/%s/%s" % (self.api_version, resource)
+
+        params = self.set_base_params(params)
+        content_type, body = self.encode_multipart_formdata(params, files)
+        conn = HTTPSConnection(host)
+        conn.putrequest('POST', selector)
+        conn.putheader('content-type', content_type)
+        conn.putheader('content-length', str(len(body.encode('utf-8'))))
+        conn.putheader('User-Agent', 'sms-python')
+        conn.endheaders()
+        conn.send(body.encode('utf-8'))
+        response = conn.getresponse()
+        data = response.read().decode()
+        conn.close()
+
+        # https status code is not 200, raise Exception
+        if response.status != 200:
+            raise CoolsmsServerException(response.reason, response.status)
+
+        # response data parsing
+        obj = None
+        if data:
+            obj = json.loads(data)
+
+        return obj
 
     # format multipart form
-    def encode_multipart_formdata(fields, files):
+    def encode_multipart_formdata(self, fields, files):
         boundary = str(uuid.uuid1())
         crlf = '\r\n'
         l = []
@@ -140,3 +174,11 @@ def encode_multipart_formdata(fields, files):
     # get content type
     def get_content_type(filename):
         return mimetypes.guess_type(filename)[0] or 'application/octet-stream'
+
+    # set base parameter
+    def set_base_params(self, params):
+        timestamp, salt, signature = self.__get_signature__()
+        base_params = {'api_key': self.api_key, 'timestamp': timestamp, 'salt': salt,
+                       'signature': signature.hexdigest()}
+        params.update(base_params)
+        return params

sdk/api/message.py

@@ -2,7 +2,9 @@
 # -*- coding: utf8 -*-
 
 class CoolsmsException(Exception):
-	pass
+    def __init__(self, message, code):
+        self.code = code
+        self.msg = message
 
 class CoolsmsSDKException(CoolsmsException):
 	pass