'major': fields.String, 'headline': fields.String, 'about_me': fields.String, 'about_me_html': fields.String, 'avatar': fields.String(attribute=lambda x: x.avatar_url(_external=True)), 'uri': fields.String( attribute=lambda x: url_for('api.user', user_id=x.id, _external=True)), } user_list = { 'items': fields.List(fields.Nested(user_fields)), 'next': fields.String, 'prev': fields.String, 'total': fields.Integer, 'pages_count': fields.Integer, 'current_page': fields.Integer, 'per_page': fields.Integer, } tag_fields = { 'id': fields.Integer, 'name': fields.String, 'books_count': fields.Integer(attribute=lambda x: x.books.count()),
from flask.ext.restful import Resource, fields, marshal, reqparse from server import db from server.models.person import Person company_fields = { 'id': fields.Integer, 'name': fields.String, } person_fields = { 'id': fields.Integer, 'name': fields.String, 'company': fields.Nested(company_fields), 'job_title': fields.String, 'location': fields.String, 'photo': fields.String, 'summary': fields.String, } class PeopleResource(Resource): def __init__(self): self.reqparse = reqparse.RequestParser() self.reqparse.add_argument('name', location='json') self.reqparse.add_argument('job_title', location='json') self.reqparse.add_argument('location', location='json') self.reqparse.add_argument('photo', location='json') self.reqparse.add_argument('summary', location='json') super().__init__()
project_full_resource_fields.pop('region') project_full_resource_fields["description"] = fields.String project_full_resource_fields["motivation"] = fields.String project_full_resource_fields["goal"] = fields.String project_full_resource_fields["about"] = fields.String project_full_resource_fields["currency"] = fields.String project_full_resource_fields["currency_rate"] = fields.Float project_full_resource_fields["scope"] = fields.String project_full_resource_fields["date_created"] = DateTime project_full_resource_fields["date_published"] = DateTime project_full_resource_fields["date_updated"] = DateTime project_full_resource_fields["date_succeeded"] = DateTime project_full_resource_fields["date_closed"] = DateTime project_full_resource_fields["date_passed"] = DateTime project_full_resource_fields["location"] = fields.List( fields.Nested(location_resource_fields)) project_full_resource_fields["user"] = fields.Nested(user_resource_fields) project_full_resource_fields["widget_url"] = fields.String project_full_resource_fields["image_url_big"] = fields.String project_full_resource_fields["image_gallery"] = fields.List( fields.Nested(project_gallery_resource_fields)) project_full_resource_fields["video_url"] = fields.String project_full_resource_fields["rewards"] = fields.List( fields.Nested(project_reward_resource_fields)) project_full_resource_fields["costs"] = fields.List( fields.Nested(project_cost_resource_fields)) project_full_resource_fields["needs"] = fields.List( fields.Nested(project_need_resource_fields)) project_full_resource_fields["categories"] = fields.List( fields.Nested(categories_resource_fields)) project_full_resource_fields["social_commitment_description"] = fields.String
wordcount_plot_fields = { 'title': fields.String, 'ylabel': fields.String, 'start_dates': fields.List(fields.Raw), 'end_dates': fields.List(fields.Raw), 'subgroup_a_counts': fields.List(fields.Raw), 'subgroup_b_counts': fields.List(fields.Raw) } analysis_fields = { 'id': fields.Integer, 'frame': fields.Integer, 'phrase': fields.String, 'start_date': fields.Raw, #DateTime 'end_date': fields.Raw, #DateTime 'topic_plot': fields.Nested(topic_plot_fields), 'frame_plot': fields.Nested(frame_plot_fields), 'wordcount_plot': fields.Nested(wordcount_plot_fields), 'speech_windows': fields.Raw } analysis_marshall = { 'meta': fields.Raw, 'data': fields.Nested(analysis_fields) } class AnalysisListController(Resource): def get(self): parser = reqparse.RequestParser() parser.add_argument('page',
from flask.globals import g from datetime import datetime import six line_report = { "line": PbField(line), "pt_objects": NonNullList(NonNullNested(pt_object)), } line_reports = { "line_reports": NonNullList(NonNullNested(line_report)), "error": PbField(error, attribute='error'), "pagination": NonNullNested(pagination), "disruptions": fields.List(NonNullNested(disruption_marshaller), attribute="impacts"), "warnings": ListLit([fields.Nested(beta_endpoint)]), } class LineReports(ResourceUri, ResourceUtc): def __init__(self): ResourceUri.__init__(self, output_type_serializer=api.LineReportsSerializer) ResourceUtc.__init__(self) parser_get = self.parsers["get"] parser_get.add_argument("depth", type=int, default=1, help="The depth of your object") parser_get.add_argument("count", type=default_count_arg_type, default=25, help="Number of objects per page") parser_get.add_argument("start_page", type=int, default=0, help="The current page") parser_get.add_argument("_current_datetime", type=DateTimeFormat(), schema_metadata={'default': 'now'}, hidden=True,
from jormungandr.interfaces.v1.StatedResource import StatedResource from make_links import add_coverage_link, add_coverage_link, add_collection_links, clean_links from converters_collection_type import collections_to_resource_type from collections import OrderedDict from fields import NonNullNested region_fields = { "id": fields.String(attribute="region_id"), "start_production_date": fields.String, "end_production_date": fields.String, "status": fields.String, "shape": fields.String, "error": NonNullNested({ "code": fields.String, "value": fields.String }) } regions_fields = OrderedDict([("regions", fields.List(fields.Nested(region_fields)))]) collections = collections_to_resource_type.keys() class Coverage(StatedResource): @clean_links() @add_coverage_link() @add_collection_links(collections) @marshal_with(regions_fields) def get(self, region=None, lon=None, lat=None): return i_manager.regions(region, lon, lat), 200
class InstituteStudentList(AuthorizedResource): student_obj = { 'id': fields.Integer, 'name': fields.String, 'email': fields.String, 'target_year': fields.Integer, 'institute': fields.Integer, 'type': fields.Integer, 'mobile_no': fields.String, 'city': fields.String, 'area': fields.String, 'pin': fields.String, 'school': fields.String, 'ntse_score': fields.Float, 'branches': fields.List(fields.String), 'target_exams': fields.List(fields.String), 'roll_no': fields.String, 'father_name': fields.String, 'father_mobile_no': fields.String, 'father_email': fields.String, 'payment_plan_id': fields.String, 'registered_from': fields.String, 'batches': fields.List(fields.Nested({ 'id': fields.Integer, 'name': fields.String })) } get_response = { 'error': fields.Boolean(default=False), 'students': fields.List(fields.Nested(student_obj)), 'total': fields.Integer } post_response = { 'error': fields.Boolean(default=False), 'student': fields.Nested(student_obj) } @marshal_with(get_response) def get(self, *args, **kwargs): parser = reqparse.RequestParser() parser.add_argument('batch_id', type=int) parser.add_argument('batch_type', type=str, choices=app.config['BATCH_TYPE'].keys()) parser.add_argument('target_year', type=int) parser.add_argument('target_exam', type=str, choices=app.config['TARGET_EXAMS'].keys()) parser.add_argument('branches', type=comma_separated_ints_type) parser.add_argument('query', type=str) parser.add_argument('offset', type=int, default=0) parser.add_argument('limit', type=int, default=20) args = parser.parse_args() if args['branches'] is not None: args['branches'] = map(str, args['branches']) if args['batch_id'] is not None: batch = Batch.get(args['batch_id']) if args['batch_type'] is not None and batch.type != args['batch_type']: return {'students': []} if args['target_year'] is not None and batch.target_year != args['target_year']: return {'students': []} if args['target_exam'] is not None and batch.target_exam != args['target_exam']: return {'students': []} student_ids = [sb.student_id for sb in StudentBatches.query.filter(StudentBatches.batch_id == batch.id, StudentBatches.left_at == None).all()] else: batches = {b.id: b for b in Batch.get_filtered(type=args['batch_type'], target_year=args['target_year'], target_exam=args['target_exam'], institute_id=kwargs['user'].id, branches=args['branches'])} student_ids = list({sb.student_id for sb in StudentBatches.query.filter(StudentBatches.batch_id.in_(batches.keys()), StudentBatches.left_at == None).all()}) # for pagination if args['query'] is not None: students = Student.query.filter(Student.id.in_(student_ids), Student.name.ilike('%' + args['query'] + '%')).all() total = len(students) student_ids = [s.id for s in students][args['offset']:args['offset']+args['limit']] else: total = len(student_ids) student_ids = sorted(student_ids)[args['offset']:args['offset']+args['limit']] students = Student.query.filter(Student.id.in_(student_ids)).all() student_batches = {} # get all students whose id is present `student_ids` and have not left the batch and all their batches too for sb in StudentBatches.query.filter(StudentBatches.student_id.in_(student_ids), StudentBatches.left_at == None).all(): if sb.student_id not in student_batches: student_batches[sb.student_id] = [sb.batch_id] else: student_batches[sb.student_id].append(sb.batch_id) # need to make one more batch query because i need all the batches that any student in the result set is part of batches = {b.id: b for b in Batch.get_filtered(include_ids=list(itertools.chain(*student_batches.values())))} for student in students: student.batches = [{'id': b_id, 'name': batches[b_id].name} for b_id in student_batches.get(student.id, [])] return {'students': students, 'total': total} @marshal_with(post_response) def post(self, *args, **kwargs): parser = reqparse.RequestParser() parser.add_argument('name', type=str, required=True) parser.add_argument('email', type=str, required=True) parser.add_argument('password', type=str, required=True) parser.add_argument('mobile_no', type=str, required=True) parser.add_argument('city', type=str) parser.add_argument('area', type=str) parser.add_argument('pin', type=str) parser.add_argument('school', type=str) parser.add_argument('ntse_score', type=float) parser.add_argument('roll_no', type=str, required=True) parser.add_argument('father_name', type=str) parser.add_argument('father_mobile_no', type=str) parser.add_argument('father_email', type=str) parser.add_argument('batch_ids', type=comma_separated_ints_type, required=True) args = parser.parse_args() student = Student.create(name=args['name'], email=args['email'], password=md5(args['password']).hexdigest(), mobile_no=args['mobile_no'], city=args['city'], area=args['area'], pin=args['pin'], school=args['school'], ntse_score=args['ntse_score'], roll_no=args['roll_no'], father_name=args['father_name'], father_mobile_no=args['father_mobile_no'], father_email=args['father_email'], registered_from='institute') target_exams = set() target_year = None batches = Batch.get_filtered(include_ids=args['batch_ids']) engineering_exams = {'1', '2', '3'} medical_exams = {'4', '5'} for batch in batches: if batch.target_exam in engineering_exams: target_exams.update(engineering_exams) if batch.target_exam in medical_exams: target_exams.update(medical_exams) if target_year is None or target_year > batch.target_year: target_year = batch.target_year sb = StudentBatches(batch_id=batch.id, student_id=student.id, joined_at=datetime.datetime.utcnow()) db.session.add(sb) branches = [] if len(target_exams.intersection(engineering_exams)) > 0: branches.append('1') if len(target_exams.intersection(medical_exams)) > 0: branches.append('2') student.target_year = target_year student.target_exams = list(target_exams) student.branches = branches db.session.commit() student.batches = [{'id': b.id, 'name': b.name} for b in batches] return {'student': student}
'rating': fields.String, 'short_description': fields.String, 'description': fields.String, 'genres': fields.List(fields.String), 'actors': fields.List(fields.String), 'cover_thumbnail': fields.String, 'tvchannel': fields.String, 'short_credits': fields.List(fields.String) } tvchannel_resource_fields = { 'id': fields.Integer, 'title': fields.String, 'logo': fields.String, 'logo_thumbnail': fields.String, 'popular_tvseries': fields.Nested(tvseries_resource_fields) } upcoming_episode_resource_fields = { 'id': fields.Integer, 'title': fields.String, 'episode_number': fields.Integer, 'season_number': fields.Integer, 'showed_at': Date, 'tvseries': fields.Nested(tvseries_resource_fields) } episode_resource_fields = { 'id': fields.Integer, 'title': fields.String, 'episode_number': fields.Integer,
self._register_interpreted_parameters(args) return i_manager.dispatch(args, self.endpoint, instance_name=self.region) date_time = { "date_time": SplitDateTime(date='date', time='time'), "additional_informations": additional_informations(), "links": stop_time_properties_links() } row = { "stop_point": PbField(stop_point), "date_times": fields.List(fields.Nested(date_time)) } header = { "display_informations": PbField(display_informations_vj, attribute='pt_display_informations'), "additional_informations": NonNullList(PbEnum(response_pb2.SectionAdditionalInformationType)), "links": UrisToLinks() } table_field = { "rows": fields.List(fields.Nested(row)), "headers": fields.List(fields.Nested(header)) }
class MockTest(AuthorizedResource): response = { 'error': fields.Boolean(default=False), 'mock_test': fields.Nested(MockTestList.mock_test_obj) } @marshal_with(response) def get(self, *args, **kwargs): mock_test = MockTestModel.query.get(kwargs['id']) if mock_test is None: raise InvalidMockTestId return {'mock_test': mock_test} @marshal_with(response) def put(self, *args, **kwargs): parser = reqparse.RequestParser() parser.add_argument('name', type=str) parser.add_argument('is_locked', type=int, choices=[0, 1]) parser.add_argument('question_ids', type=MockTestList.question_ids_json_type) args = parser.parse_args() mock_test = MockTestModel.query.get(kwargs['id']) if mock_test is None: raise InvalidMockTestId if args['name'] is not None: mock_test.name = args['name'] if args['question_ids'] is not None: args['question_ids'] = json.loads(args['question_ids']) for subject_id, data in args['question_ids'].items(): seen_comprehensions = OrderedDict() comp_ques_ids = [] q_ids = data['q_ids'] question_data = Question.get_filtertered_list( include_question_ids=q_ids) questions = question_data['questions'] total = question_data['total'] if total != len(q_ids): raise InvalidQuestionId # sort questions in the order in which they appear in `q_ids` questions = sorted(questions, key=lambda q: q_ids.index(q.id)) for question in questions: if question.comprehension_id is not None: # if comprehension not encountered before if question.comprehension_id not in seen_comprehensions: comp_ques_ids.append(question.id) # comprehension questions in order of their ids, i.e order of their addition comprehension_ques_ids = [ q.id for q in sorted( question.comprehension.questions.all(), key=lambda q: q.id) ] seen_comprehensions[ question.comprehension_id] = sorted( comprehension_ques_ids) i = 0 for comp_id, ques_ids in seen_comprehensions.items(): ques_id_set = set(ques_ids) ques_id_set.remove(comp_ques_ids[i]) # questions ids other than the first encountered question of this comprehension other_comp_ques_ids = ques_id_set # remove qny question ids from `other_comp_ques_ids` if present in `q_ids` for id in other_comp_ques_ids: try: q_ids.remove(id) except: continue # index of first encountered question of this comprehension comp_ques_index = q_ids.index(comp_ques_ids[i]) # add all questions of this comprehension to `q_ids` starting from `comp_ques_index` for index, id in enumerate(ques_ids): q_ids.insert(comp_ques_index + index, id) # finally remove the first encountered question of this comprehension from `q_ids` q_ids.remove(q_ids[comp_ques_index + index + 1]) i += 1 mock_test.question_ids = json.dumps(args['question_ids']) if args['is_locked'] is not None: mock_test.is_locked = args['is_locked'] == 1 db.session.commit() return {'mock_test': mock_test}
"projects_discarded": fields.Integer, "projects_accepted": fields.Integer, "projects_succeeded": fields.Integer, "date_created": DateTime, "active": fields.Boolean } matcher_full_resource_fields = matcher_resource_fields.copy() matcher_full_resource_fields.pop('latitude') matcher_full_resource_fields.pop('region') matcher_full_resource_fields.pop('longitude') matcher_full_resource_fields.pop('radius') matcher_full_resource_fields["terms"] = fields.String matcher_full_resource_fields["date_created"] = DateTime matcher_full_resource_fields["logo_url_big"] = fields.String matcher_full_resource_fields["user"] = fields.Nested(user_resource_fields) matcher_full_resource_fields["location"] = fields.List( fields.Nested(location_resource_fields)) matcher_full_resource_fields['users'] = fields.List( fields.Nested(matcher_users_resource_fields)) matcher_project_resource_fields = project_resource_fields.copy() matcher_project_resource_fields['amount_matcher'] = fields.Float # Add radius location_resource_fields['radius'] = fields.Integer class MatchersListAPI(BaseList): """Matcher list""" @requires_auth() @ratelimit() @swag_from('swagger_specs/matcher_list.yml')
from utils import super_required, success, pagination_get from ...models.cs_models import Building, BuildingTemplate, TagType from .. import auth from ..errors import * node_fields = { 'name': fields.String, 'value': fields.String, } tags_fields = { 'name': fields.String, 'value': fields.String, 'metadata': fields.Raw, 'users': fields.List(fields.String), 'parents': fields.List(fields.Nested(node_fields)), 'ancestors': fields.List(fields.Nested(node_fields)), } building_fields = { 'name': fields.String, 'template': fields.String, 'description': fields.String, 'metadata': fields.Raw, } class BuildingAPI(Resource): decorators = [auth.login_required] def get(self, name):
#!/usr/bin/env python # encoding: utf-8 """ File name: vip.py Function Des: ... ~~~~~~~~~~ author: Jerry <*****@*****.**> <http://www.skyduy.com> """ from flask.ext.restful import fields vip_fields = { 'id': fields.String, 'username': fields.String, 'nickname': fields.String, 'phone': fields.String, } # for get /vips vips_fields = {'vips': fields.List(fields.Nested(vip_fields))}
comment_get_parser, comment_delete_parser, comment_post_parser ) nested_tag_fields = { 'id': fields.Integer(), 'title': fields.String() } post_fields = { 'id': fields.Integer(), 'author': fields.String(attribute=lambda x: x.user.username), 'title': fields.String(), 'text': HTMLField(), 'tags': fields.List(fields.Nested(nested_tag_fields)), 'publish_date': fields.DateTime(dt_format='iso8601') } comment_fields = { 'id': fields.Integer(), 'name': fields.String(), 'text': HTMLField(), 'date': fields.DateTime(dt_format='iso8601'), 'post_id': fields.Integer() } class CommentApi(Resource): @marshal_with(comment_fields) def get(self, comment_id=None):
TABLE_ROW_FIELDS = { "index": fields.Integer, "offset": fields.Integer, "address": fields.String, "label": fields.String, "error": fields.Integer, "opcode": fields.String, "mnemonic": fields.String, "comment": fields.String, "in_use": fields.Boolean, "targets": fields.List(fields.Integer), "is_call_or_branch": fields.Boolean, "is_a_data_defintion_inst": fields.Boolean } TABLE_ROW_LIST_FIELDS = {"rows": fields.List(fields.Nested(TABLE_ROW_FIELDS))} class TableRowList(Resource): """ Simple API to retrieve all rows as JSON. """ @marshal_with(TABLE_ROW_LIST_FIELDS) def get(self): """ Get all of the rows in the store. """ row_data = [row.ToDict() for row in ASSEMBLY_STORE.GetRows()] return {"rows": row_data}
'bss_speed': fields.Raw, 'car_speed': fields.Raw, 'min_bike': fields.Raw, 'min_car': fields.Raw, 'min_bss': fields.Raw, 'min_tc_with_bike': fields.Raw, 'min_tc_with_car': fields.Raw, 'min_tc_with_bss': fields.Raw, 'factor_too_long_journey': fields.Raw, 'min_duration_too_long_journey': fields.Raw, 'max_duration_criteria': fields.Raw, 'max_duration_fallback_mode': fields.Raw, } instance_status_with_parameters = deepcopy(instance_status) instance_status_with_parameters['parameters'] = fields.Nested( instance_parameters, allow_null=True) instance_traveler_types = { 'traveler_type': fields.String, 'walking_speed': fields.Raw, 'bike_speed': fields.Raw, 'bss_speed': fields.Raw, 'car_speed': fields.Raw, 'wheelchair': fields.Boolean(), 'max_walking_duration_to_pt': fields.Raw, 'max_bike_duration_to_pt': fields.Raw, 'max_bss_duration_to_pt': fields.Raw, 'max_car_duration_to_pt': fields.Raw, 'first_section_mode': fields.List(fields.String), 'last_section_mode': fields.List(fields.String), 'is_from_db': fields.Boolean(),
class TeacherList(AuthorizedResource): teacher_obj = { 'id': fields.Integer, 'name': fields.String, 'email': fields.String, 'subject_expert': fields.String, 'specialization': fields.String, 'qualification': fields.String, 'joined_at': fields.DateTime, 'last_activity': fields.DateTime, 'type': fields.Integer } get_response = { 'error': fields.Boolean(default=False), 'teachers': fields.List( fields.Nested({ 'teacher': fields.Nested(teacher_obj), 'questions_categorized': fields.Integer, 'questions_approved': fields.Integer, 'text_solutions_submitted': fields.Integer, 'text_solutions_approved': fields.Integer, 'video_solutions_submitted': fields.Integer, 'video_solutions_approved': fields.Integer, 'reported_resolved': fields.Integer })), 'total': fields.Integer } post_response = { 'error': fields.Boolean(default=False), 'teacher': fields.Nested(teacher_obj) } @marshal_with(get_response) def get(self, *args, **kwargs): parser = reqparse.RequestParser() parser.add_argument('page', type=int, default=1) parser.add_argument('limit', type=int, default=app.config['TEACHER_LIST_LIMIT']) args = parser.parse_args() teachers, total = Teacher.get_list(args['page'], args['limit']) return {'teachers': teachers, 'total': total} @marshal_with(post_response) def post(self, *args, **kwargs): parser = reqparse.RequestParser() parser.add_argument('name', type=str, required=True) parser.add_argument('email', type=str, required=True) parser.add_argument('password', type=str, required=True) parser.add_argument('subject_expert', type=str, required=True) parser.add_argument('specialization', type=str, required=True) parser.add_argument('qualification', type=str, required=True) args = parser.parse_args() teacher = Teacher.create(name=args['name'], email=args['email'], password=md5(args['password']).hexdigest(), subject_expert=args['subject_expert'], specialization=args['specialization'], qualification=args['qualification']) data = { 'name': args['name'], 'email': args['email'], 'password': args['password'] } welcome_admin_email_task.delay(data) return {'teacher': teacher}
committee_fields = { 'committee_id': fields.String, 'name': fields.String, 'designation_full': fields.String, 'designation': fields.String, 'treasurer_name': fields.String, 'organization_type_full': fields.String, 'organization_type': fields.String, 'state': fields.String, 'party_full': fields.String, 'party': fields.String, 'committee_type_full': fields.String, 'committee_type': fields.String, 'expire_date': fields.String, 'original_registration_date': fields.String, 'candidates': fields.Nested(candidate_commitee_fields), } committee_detail_fields = { 'committee_id': fields.String, 'name': fields.String, 'designation_full': fields.String, 'designation': fields.String, 'treasurer_name': fields.String, 'organization_type_full': fields.String, 'organization_type': fields.String, 'state': fields.String, 'party_full': fields.String, 'party': fields.String, 'committee_type_full': fields.String, 'committee_type': fields.String, 'expire_date': fields.String,
from flask.ext.restful import fields from app.utils.gis_json_fields import PointToLatLng from copy import copy success_fields = dict(status=fields.String, message=fields.String) photo_fields = dict(id=fields.Integer, filename=fields.String, type=fields.String, caption=fields.String, src=fields.String) photo_create_fields = dict(status=fields.String, message=fields.String, photo=fields.Nested(photo_fields, allow_null=False)) department_fields = dict(id=fields.Integer, name=fields.String, head_user_id=fields.Integer) employee_fields = dict(id=fields.Integer, first_name=fields.String, last_name=fields.String, middle_name=fields.String, fullname=fields.String, address=fields.String, contact_no=fields.String, designation=fields.String, department=fields.Nested(department_fields, allow_null=False))
def query_blueprint(blueprint_id): return Blueprint.query.filter_by(id=blueprint_id).first() blueprint_fields = { 'name': fields.String, 'users': fields.Integer, 'launched_instances': fields.Integer, 'running_instances': fields.Integer, } result_fields = { 'blueprints': fields.List(fields.Nested(blueprint_fields)), 'overall_running_instances': fields.Integer } class StatsList(restful.Resource): @auth.login_required @requires_admin @marshal_with(result_fields) def get(self): instances = Instance.query.all() overall_running_instances = Instance.query.filter(Instance.state != Instance.STATE_DELETED).count() get_blueprint = memoize(query_blueprint) per_blueprint_results = defaultdict(lambda: {'users': 0, 'launched_instances': 0, 'running_instances': 0})
'url': fields.String, 'summary': fields.String, 'html_url': fields.String, 'comment_url': fields.String, 'shortened_url': fields.String, 'address': fields.String, 'lat': fields.Raw, 'lng': fields.Raw, 'closed_at': fields.Raw, #DateTime, 'acknowledged_at': fields.Raw, #DateTime, 'created_at': fields.Raw, #DateTime, 'updated_at': fields.Raw, #DateTime, 'reporter_id': fields.String, } issue_marshall = {'meta': fields.Raw, 'data': fields.Nested(issue_fields)} parser = reqparse.RequestParser() class IssueController(Resource): @marshal_with(issue_marshall) def get(self, id): issue = Issue.query.get(id) return {'meta': None, 'data': issue.to_dict()} @marshal_with(issue_marshall) def put(self, id): issue = Issue.query.get(id) return {'meta': None, 'data': issue.to_dict()}