Python json.tojson函数代码示例

 def as_dict(self, db_model):
     base = super(Plan, self).as_dict(db_model)
     if self.artifacts is not wsme.Unset:
         base.update({'artifacts': [wjson.tojson(Artifact, art)
                                    for art in self.artifacts]})
     if self.services is not wsme.Unset:
         base.update({'services': [wjson.tojson(ServiceReference, ref)
                                   for ref in self.services]})
     return base

 def as_dict(self, db_model):
     base = super(Plan, self).as_dict_from_keys(['name', 'description'])
     if self.artifacts is not wsme.Unset:
         base.update({'artifacts': [wjson.tojson(Artifact, art)
                                    for art in self.artifacts]})
     if self.services is not wsme.Unset:
         base.update({'services': [wjson.tojson(ServiceReference, ref)
                                   for ref in self.services]})
     if self.parameters is not wsme.Unset:
         base.update({'parameters': self.parameters})
     return base

    def test_after_publishes_payload(self, mock_get_original_resource,
                                     mock_publish):
        n = NotificationHook()

        sample_original_task = TaskWmodel.from_db_model(Task(id=1,
                           creator_id=1,
                           title='Test',
                           status='inprogress',
                           story_id=1,
                           project_id=1,
                           assignee_id=1,
                           priority='medium'))

        sample_modified_task = TaskWmodel.from_db_model(Task(id=1,
                           creator_id=1,
                           title='Test',
                           status='merged',
                           story_id=1,
                           project_id=1,
                           assignee_id=1,
                           priority='medium'))

        sot_json = tojson(TaskWmodel, sample_original_task)
        smt_json = tojson(TaskWmodel, sample_modified_task)

        # Mocking state object to simulate a 'PUT' request for task
        # resource 1
        mock_state = Mock()
        mock_state.request.current_user_id = '1'
        mock_state.request.method = 'PUT'
        mock_state.request.headers = {'Referer': 'http://localhost/'}
        mock_state.request.query_string = ''
        mock_state.request.path = '/v1/tasks/1'
        mock_state.response.status_code = 200
        mock_state.old_entity_values = sot_json
        mock_get_original_resource.return_value = smt_json

        n.after(mock_state)
        mock_publish.assert_called_with(
            author_id=mock_state.request.current_user_id,
            method=mock_state.request.method,
            url=mock_state.request.headers['Referer'],
            path=mock_state.request.path,
            query_string=mock_state.request.query_string,
            status=mock_state.response.status_code,
            resource='task',
            resource_id='1',
            sub_resource=None,
            sub_resource_id=None,
            resource_before=sot_json,
            resource_after=smt_json)

 def _to_property_dict(self, name, value):
     # Convert the model PropertyTypes dict to a JSON string
     json_data = tojson(PropertyType, value)
     db_property_type_dict = dict()
     db_property_type_dict['schema'] = json.dumps(json_data)
     db_property_type_dict['name'] = name
     return db_property_type_dict

def event_create(values):
    new_event = api_base.entity_create(models.TimeLineEvent, values)
    if new_event:
        if new_event.story_id is not None:
            stories_api.story_update_updated_at(new_event.story_id)
        # TODO(SotK): Update board and worklist updated_at when they get events

    if CONF.enable_notifications:
        # Build the payload. Use of None is included to ensure that we don't
        # accidentally blow up the API call, but we don't anticipate it
        # happening.
        event_dict = tojson(TimeLineEvent,
                            TimeLineEvent.from_db_model(new_event))

        publish(author_id=request.current_user_id or None,
                method="POST",
                url=request.headers.get('Referer') or None,
                path=request.path or None,
                query_string=request.query_string or None,
                status=response.status_code or None,
                resource="timeline_event",
                resource_id=new_event.id or None,
                resource_after=event_dict or None)

    return new_event

 def _to_dict(self, model_property_type):
     # Convert the model PropertyTypes dict to a JSON encoding
     db_property_type_dict = dict()
     db_property_type_dict['schema'] = json.tojson(
         PropertyType, model_property_type)
     db_property_type_dict['name'] = model_property_type.name
     return db_property_type_dict

def test_date_formatting():
    """ISO 8601 formatted dates with timezones are correctly translated to
    datetime instances and back"""
    d = TypeWithDate()
    d.when = datetime(2015, 2, 28, 1, 2, 3, tzinfo=UTC)
    j = {'when': '2015-02-28T01:02:03+00:00'}
    eq_(tojson(TypeWithDate, d), j)
    eq_(fromjson(TypeWithDate, j).when, d.when)

def encode_result(value, datatype, **options):
    jsondata = tojson(datatype, value)
    if options.get('nest_result', False):
        jsondata = {options.get('nested_result_attrname', 'result'): jsondata}
    if jsondata:
        return json.dumps(jsondata)
    else:
        return ''

    def test_unset_attrs(self):
        class AType(object):
            attr = int

        wsme.types.register_type(AType)

        j = tojson(AType, AType())
        assert j == {}

    def get_original_resource(self, resource, resource_id):
        """Given a resource name and ID, will load that resource and map it
        to a JSON object.
        """
        if not resource or not resource_id or resource not in class_mappings.keys():
            return None

        model_class, wmodel_class = class_mappings[resource]
        entity = api_base.entity_get(model_class, resource_id)
        if entity:
            return tojson(wmodel_class, wmodel_class.from_db_model(entity))
        else:
            # In the case of a DELETE, the entity will be returned as None
            return None

    def index(self, response, result):
        params = dict(response.request.params)
        params.pop('marker', None)
        query = urlparse.urlencode(params)
        result.first = "/v2/metadefs/namespaces"
        result.schema = "/v2/schemas/metadefs/namespaces"
        if query:
            result.first = '%s?%s' % (result.first, query)
        if result.next:
            params['marker'] = result.next
            next_query = urlparse.urlencode(params)
            result.next = '/v2/metadefs/namespaces?%s' % next_query

        ns_json = json.tojson(Namespaces, result)
        response = self.__render(ns_json, response)

    def _format_metadef_object_to_db(self, metadata_object):

        required_str = ",".join(metadata_object.required) if metadata_object.required else None

        # Convert the model PropertyTypes dict to a JSON string
        properties = metadata_object.properties
        db_schema = {}
        if properties:
            for k, v in properties.items():
                json_data = json.tojson(PropertyType, v)
                db_schema[k] = json_data

        db_metadata_object = {
            "name": metadata_object.name,
            "required": required_str,
            "description": metadata_object.description,
            "json_schema": db_schema,
        }
        return db_metadata_object

def event_create(values):
    new_event = api_base.entity_create(models.TimeLineEvent, values)

    if CONF.enable_notifications:
        # Build the payload. Use of None is included to ensure that we don't
        # accidentally blow up the API call, but we don't anticipate it
        # happening.
        event_dict = tojson(TimeLineEvent,
                            TimeLineEvent.from_db_model(new_event))

        publish(author_id=request.current_user_id or None,
                method="POST",
                path=request.path or None,
                status=response.status_code or None,
                resource="timeline_event",
                resource_id=new_event.id or None,
                resource_after=event_dict or None)

    return new_event

    def _format_metadef_object_to_db(self, metadata_object):

        required_str = (",".join(metadata_object.required) if
                        metadata_object.required else None)

        # Convert the model PropertyTypes dict to a JSON string
        properties = metadata_object.properties
        db_schema = {}
        if properties:
            for k, v in properties.items():
                json_data = json.tojson(PropertyType, v)
                db_schema[k] = json_data

        db_metadata_object = {
            'name': metadata_object.name,
            'required': required_str,
            'description': metadata_object.description,
            'json_schema': db_schema
        }
        return db_metadata_object

 def show(self, response, metadata_object):
     metadata_object_json = json.tojson(MetadefObject, metadata_object)
     body = jsonutils.dumps(metadata_object_json, ensure_ascii=False)
     response.unicode_body = six.text_type(body)
     response.content_type = 'application/json'