Python JSONParser.to_collection方法代码示例

# 需要导入模块: from wikilife_utils.parsers.json_parser import JSONParser [as 别名]
# 或者: from wikilife_utils.parsers.json_parser.JSONParser import to_collection [as 别名]
 def put(self, app_id, developer_id):
     """
     Update app
     """
     dto = JSONParser.to_collection(self.sanitize_raw_data(self.request.body))
     updated_app = self._app_srv.update_app(app_id, dto["name"], dto["callbackUrl"], developer_id)
     self.success(updated_app)

# 需要导入模块: from wikilife_utils.parsers.json_parser import JSONParser [as 别名]
# 或者: from wikilife_utils.parsers.json_parser.JSONParser import to_collection [as 别名]
    def test_edit_pin(self):
        """
        Sample API-1 request/response:

        http://qaapi.wikilife.org/1/account/pin/edit.json
        POST:
        {"pin": "7777", "user_id": "CSQTMG", "new_pin": "7776"}

        RESP:
        {"status": "OK", "message": "User pin changed successfully"}
        """

        url = self.get_service_url("/1/account/pin/edit.json")
        new_pin = "%s_upd" % TEST_USER_NAME
        user_info = {"user_id": TEST_USER_NAME, "pin": TEST_USER_NAME, "new_pin": new_pin}

        #invoke ws
        try:
            body = JSONParser.to_json(user_info)
            raw_response = self.rest_post(url, body)
            print raw_response
            response = JSONParser.to_collection(raw_response)
        except Exception, e:
            print e
            assert False

# 需要导入模块: from wikilife_utils.parsers.json_parser import JSONParser [as 别名]
# 或者: from wikilife_utils.parsers.json_parser.JSONParser import to_collection [as 别名]
    def test_meta_search_by_name(self):
        expected = {
            "items": [
                {
                    "name": "Lower Abdominal Pain",
                    "parentIds": [
                        15
                    ],
                    "origId": 253273,
                    "otherNames": "Lower abdominal pain, R10.3",
                    "type": "MetaNode",
                    "id": 1251
                }
            ],
            "pageIndex": 0,
            "pageSize": 25,
            "pageCount": 1
        }

        params = {"name": "Lower Abdominal Pain"}
        url = self.get_service_url("/4/meta/search/")
        response_code, response_headers, response_body = self.rest_get(url, params)
        result = JSONParser.to_collection(response_body)

        self.assertEquals(response_code, 200)
        self.assertDictEqual(expected, result)

# 需要导入模块: from wikilife_utils.parsers.json_parser import JSONParser [as 别名]
# 或者: from wikilife_utils.parsers.json_parser.JSONParser import to_collection [as 别名]
 def post(self, developer_id):
     """
     Add app
     """
     dto = JSONParser.to_collection(self.sanitize_raw_data(self.request.body))
     app = self._app_srv.add_app(dto["name"], dto["callbackUrl"], developer_id)
     self.success(app)

# 需要导入模块: from wikilife_utils.parsers.json_parser import JSONParser [as 别名]
# 或者: from wikilife_utils.parsers.json_parser.JSONParser import to_collection [as 别名]
    def test_meta_node_ancestors(self):
        node_id = 10
        expected = [
            {
                "name": "Exercise",
                "parentIds": [
                    1
                ],
                "origId": 49,
                "otherNames": "",
                "type": "MetaNode",
                "id": 6
            },
            {
                "name": "Life Variable",
                "parentIds": [ ],
                "origId": 1,
                "otherNames": "Wikilife",
                "type": "MetaNode",
                "id": 1
            }
        ]

        url = self.get_service_url("/4/meta/ancestors/%s" %node_id)
        response_code, response_headers, response_body = self.rest_get(url)
        result = JSONParser.to_collection(response_body)

        self.assertEquals(response_code, 200)
        self.assertListEqual(expected, result)

# 需要导入模块: from wikilife_utils.parsers.json_parser import JSONParser [as 别名]
# 或者: from wikilife_utils.parsers.json_parser.JSONParser import to_collection [as 别名]
    def post(self):
        """
        Creates user account

        Request::

            {
              "userName": "docApi",
              "pin": "1234",
              "city": "Bahia Blanca",
              "timezone": "America\/Argentina\/San_Luis",
              "gender": "Male",
              "height": "1.70",
              "weight": "69.9",
              "device_id": "317a129728d554ff9e14dd72280fcf0000000000",
              "region": "Buenos Aires",
              "birthdate": "1995-10-29",
              "country": "ARG"
            }

        Response::

        """
        account_srv = self._services["account"]
        user_info = JSONParser.to_collection(self.request.body)
        self.add_user_source(user_info, self.request.headers)
        account_srv.create_account(user_info)
        self.success()

# 需要导入模块: from wikilife_utils.parsers.json_parser import JSONParser [as 别名]
# 或者: from wikilife_utils.parsers.json_parser.JSONParser import to_collection [as 别名]
    def test_edit_single_log(self):
        log_id, execute_time = self._add_single_log()

        #create test delete log
        logs = []
        value_upd = "120"
        log = self._get_sample_edit_log(log_id, TEST_USER_ID, value_upd, execute_time)
        logs.append(log)

        body = JSONParser.to_json(logs)
        raw_response = self.rest_post("http://localhost:7080/2/logs/edit", body)
        print raw_response
        response = JSONParser.to_collection(raw_response)

        print response
        assert response != None
        assert response["status"] == STATUS_SUCCESS

        #check write-only logs db
        log_dao = self.get_dao_builder().build_log_dao()
        edited_log_id = response["data"][0]
        found_log = log_dao.get_log_by_id(edited_log_id)
        assert found_log != None
        assert found_log["oper"] == "u"
        assert found_log["nodes"][0]["value"] == value_upd

# 需要导入模块: from wikilife_utils.parsers.json_parser import JSONParser [as 别名]
# 或者: from wikilife_utils.parsers.json_parser.JSONParser import to_collection [as 别名]
    def test_meta_search_large_results(self):
        params = {"name": "a"}
        url = self.get_service_url("/4/meta/search/")
        response_code, response_headers, response_body = self.rest_get(url, params)
        result = JSONParser.to_collection(response_body)

        self.assertEquals(response_code, 200)
        self.assertGreaterEqual(result["pageCount"], 2)

# 需要导入模块: from wikilife_utils.parsers.json_parser import JSONParser [as 别名]
# 或者: from wikilife_utils.parsers.json_parser.JSONParser import to_collection [as 别名]
    def post(self, user_id):
        """
        Request body:
        {"roots":[""],"active":True,"access_token_secret":"","access_token_key":""}
        """

        twitter_settings = JSONParser.to_collection(self.request.body)
        self._twitter_user_srv.set_twitter_settings(user_id, twitter_settings)
        self.success()

# 需要导入模块: from wikilife_utils.parsers.json_parser import JSONParser [as 别名]
# 或者: from wikilife_utils.parsers.json_parser.JSONParser import to_collection [as 别名]
    def get_logs(self, request_body, user_id):
        logs = JSONParser.to_collection(self.request.body)

        for log in logs:
            log["userId"] = user_id

        self.add_log_source(logs, self.request.headers)
        
        return logs

# 需要导入模块: from wikilife_utils.parsers.json_parser import JSONParser [as 别名]
# 或者: from wikilife_utils.parsers.json_parser.JSONParser import to_collection [as 别名]
    def _internal_callback(self, ch, method, properties, body):
        try:
            data = JSONParser.to_collection(body)
            success = self._callback(data)

            if success:
                ch.basic_ack(delivery_tag=method.delivery_tag)

        except JSONParserException, e:
            self._logger.error(e)
            ch.basic_ack(delivery_tag=method.delivery_tag)

# 需要导入模块: from wikilife_utils.parsers.json_parser import JSONParser [as 别名]
# 或者: from wikilife_utils.parsers.json_parser.JSONParser import to_collection [as 别名]
    def _post_twitter_settings(self, internal_user_id, twitter_settings):
        url = self.get_service_url(SRV_ROUTE_TPL %internal_user_id)

        try:
            body = JSONParser.to_json(twitter_settings)
            raw_response = self.rest_post(url, body)
            print raw_response 
            response = JSONParser.to_collection(raw_response)

        except Exception, e:
            print e
            assert False

# 需要导入模块: from wikilife_utils.parsers.json_parser import JSONParser [as 别名]
# 或者: from wikilife_utils.parsers.json_parser.JSONParser import to_collection [as 别名]
    def test_get_update_notification(self):

        url = self.get_service_url("/1/notifications.json")
        params = {}

        #invoke ws
        try:
            raw_response = self.rest_get(url, params)
            print raw_response
            response = JSONParser.to_collection(raw_response)
        except Exception, e:
            print e
            assert False

# 需要导入模块: from wikilife_utils.parsers.json_parser import JSONParser [as 别名]
# 或者: from wikilife_utils.parsers.json_parser.JSONParser import to_collection [as 别名]
    def test_get_notification(self):

        url = self.get_service_url("/1/notifications.json")
        params = {"client_id": "317A1297-28D5-54FF-9E14-DD72280FCF00", "client_version": "0.9.1.6", "client_tree_version": "meta_11.0.0", "client_api_version": "R11.0.0"}

        #invoke ws
        try:
            raw_response = self.rest_get(url, params)
            print raw_response
            response = JSONParser.to_collection(raw_response)
        except Exception, e:
            print e
            assert False

# 需要导入模块: from wikilife_utils.parsers.json_parser import JSONParser [as 别名]
# 或者: from wikilife_utils.parsers.json_parser.JSONParser import to_collection [as 别名]
def test():
    """
    Sample Request
    
        GET /user HTTP/1.1
        Host: api.runkeeper.com
        Authorization: Bearer xxxxxxxxxxxxxxxx
        Accept: application/vnd.com.runkeeper.User+json
    
    Sample Response
    
        HTTP/1.1 200 OK
        Content-Type: application/vnd.com.runkeeper.User+json
        Content-Length: nnn
    
        {
        "userID": 1234567890,
        "profile": "/profile",
        "settings": "/settings",
        "fitness_activities": "/fitnessActivities",
        "strength_training_activities": "/strengthTrainingActivities",
        "background_activities": "/backgroundActivities",
        "sleep": "/sleep",
        "nutrition": "/nutrition",
        "weight": "/weight",
        "general_measurements": "/generalMeasurements",
        "diabetes": "/diabetes",
        "records": "/records",
        "team": "/team"
        }
    """
    access_token = "e573745473d04b3c99bce634c2349bc6"
    url = "http://api.runkeeper.com/user?access_token=%s" %access_token


    headers = {}
    headers["Authorization"] = "Bearer %s" %access_token
    headers["Accept"] = "application/vnd.com.runkeeper.User+json"

    #request = urllib2.Request(url, headers=headers)
    request = urllib2.Request(url)
    response = urllib2.urlopen(request)
    response_code = response.code
    response_headers = response.headers.dict
    response_body = response.read()
    response_content = JSONParser.to_collection(response_body)

    print response_code
    print response_headers
    print response_content