class InstituteList(AuthorizedResource):
institute_obj = {
'id': fields.Integer,
'name': fields.String,
'email': fields.String,
'username': fields.String,
'location': fields.String,
'mobile_no': fields.String,
'logo_url': fields.String,
'joined_at': fields.DateTime,
'last_activity': fields.DateTime,
'type': fields.Integer
}
get_response = {
'error': fields.Boolean(default=False),
'institutes': fields.List(fields.Nested(institute_obj)),
'total': fields.Integer
}
post_response = {
'error': fields.Boolean(default=False),
'institute': fields.Nested(institute_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['INSTITUTE_LIST_LIMIT'])
args = parser.parse_args()
institutes, total = Institute.get_list(args['page'], args['limit'])
return {'institutes': institutes, '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('location', type=str, required=True)
parser.add_argument('username', type=str, required=True)
parser.add_argument('mobile_no', type=str, required=True)
parser.add_argument('logo', type=str)
args = parser.parse_args()
if args['logo'] is not None:
s3 = S3()
mimetype, image_data = parse_base64_string(args['logo'])
mimetype_parts = mimetype.split('/')
if len(mimetype_parts) > 1 and mimetype_parts[-1] in app.config[
'ACCEPTED_IMAGE_EXTENSIONS']:
# if mimetype has an extension and the extension is in the accepted list then proceed with the upload
content_type = mimetype_parts[-1]
url = s3.upload(image_data, content_type)
else:
raise UnAcceptableFileType
else:
url = None
institute = Institute.create(name=args['name'],
email=args['email'],
password=md5(
args['password']).hexdigest(),
username=args['username'],
location=args['location'],
mobile_no=args['mobile_no'],
logo_url=url)
return {'institute': institute}
region_fields = {
"id": fields.String(attribute="region_id"),
"start_production_date": fields.String,
"end_production_date": fields.String,
"last_load_at": FieldDateTime(),
"name": 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):
resp = i_manager.regions(region, lon, lat)
if resp.has_key("regions"):
resp["regions"] = sorted(
resp["regions"],
cmp=lambda reg1, reg2: cmp(reg1.get('name'), reg2.get('name')))
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))
}
#
# Stay tuned using
# twitter @navitia
# IRC #navitia on freenode
# https://groups.google.com/d/forum/navitia
# www.navitia.io
from __future__ import absolute_import, print_function, unicode_literals, division
from flask.ext.restful import Resource, fields, marshal_with
from jormungandr import i_manager
from jormungandr.interfaces.v1.serializer.api import GeoStatusSerializer
from jormungandr.interfaces.v1.decorators import get_serializer
from jormungandr.interfaces.v1.StatedResource import StatedResource
geo_status = {
'geo_status': fields.Nested({'street_network_sources': fields.List(fields.String),
'nb_admins': fields.Raw,
'nb_admins_from_cities': fields.Raw,
'nb_ways': fields.Raw,
'nb_addresses': fields.Raw,
'nb_pois': fields.Raw,
'poi_sources': fields.List(fields.String),
})
}
class GeoStatus(StatedResource):
def __init__(self, *args, **kwargs):
super(GeoStatus, self).__init__(output_type_serializer=GeoStatusSerializer, *args, **kwargs)
@get_serializer(serpy=GeoStatusSerializer, marshall=geo_status)
'max_duration_criteria': fields.Raw,
'max_duration_fallback_mode': fields.Raw,
'max_duration': fields.Raw,
'walking_transfer_penalty': fields.Raw,
'night_bus_filter_max_factor': fields.Raw,
'night_bus_filter_base_factor': fields.Raw,
'priority': fields.Raw,
'bss_provider': fields.Boolean,
'successive_physical_mode_to_limit_id': fields.Raw,
'max_additional_connections': fields.Raw
}
instance_status_with_parameters = deepcopy(instance_status)
instance_status_with_parameters['parameters'] = fields.Nested(
instance_parameters, allow_null=True)
instance_status_with_parameters['realtime_contributors'] = fields.List(
fields.String(), attribute='rt_contributors')
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(),
from flask import jsonify, Blueprint, abort
from flask.ext.restful import (Resource, Api, reqparse, inputs, fields,
marshal, marshal_with, url_for)
import models
course_fields = {
'id': fields.Integer,
'title': fields.String,
'url': fields.String,
'reviews': fields.List(fields.String),
'created_at': fields.DateTime
}
def course_or_404(course_id):
try:
course = models.Course.get(models.Course.id == course_id)
except models.Course.DoesNotExist:
abort(404)
else:
return course
def add_reviews(course):
course.reviews = [
url_for('resources.reviews.review', id=review.id)
for review in course.review_set
]
return course
def post(self):
args = self.reqparse.parse_args()
node = {
'node_id': nodes[-1]['node_id'] + 1,
'node': args['node'],
'centrality': args['centrality']
}
nodes.append(node)
return {'node': marshal(node, node_fields)}, 201
# --------- EDGES -----------------
edge_fields = {
'name': fields.List(fields.String),
# 'v1': fields.String,
# 'v2': fields.String
}
# EdgeAPI
# shows a single edge with and lets you delete a edge
class EdgeAPI(Resource):
def get(self, edge_id):
abort_if_edge_doesnt_exist(edge_id)
return edges[edge_id]
def delete(self, edge_id):
abort_if_edge_doesnt_exist(edge_id)
del edges[edge_id]
'name': fields.String,
'status': fields.String,
'ip': fields.String,
}
instance_fields = {
'id': fields.String,
'name': fields.String,
'path': fields.String,
'archive_url': fields.String,
'git_reference': fields.String,
'status': fields.Nested(status_fields),
'environment': fields.String,
'project': fields.Nested(project_wo_instance_fields),
'host': fields.Nested(host_fields),
'jeto_infos': fields.List(fields.String),
}
class InstancesApi(Resource):
backend = None
def __init__(self):
self.backend = VagrantBackend()
def get(self):
instances = self.backend.get_all_instances()
return {
'instances': map(lambda t: marshal(t, instance_fields), instances),
}
_reqparse = reqparse.RequestParser()
#
# customise by spec.
#
field_inputs_wrap['orderBy']['type'] = validate.str_in_list(
default='name', argument=['name', 'type', 'description'])
field_inputs['srcIpAddrs'] = {
# type attribute for marshal
'type': {
fields.List(
fields.Nested({
'id': {
'type': fields.Integer()
},
'name': {
'type': fields.String(attribute='name')
}
}))
},
# validate attribute for reqparse
'validator': {
fields.List(
fields.Nested({
'id': {
'type': validate.natural(default=1),
'required': True
},
'name': {
'type': validate.str_range(argument={
from .auth import abort_if_no_admin_auth
nested_role_fields = {
'movie_id': fields.Integer(),
'role_name': fields.String()
}
actor_fields = {
'id': fields.Integer(),
'first_name': fields.String(),
'last_name': fields.String(),
'birthday': fields.DateTime(dt_format='iso8601'),
'deathday': fields.DateTime(dt_format='iso8601'),
'hometown': fields.String(),
'bio': fields.String(),
'roles': fields.List(fields.Nested(nested_role_fields)),
}
class ActorAPI(Resource):
@marshal_with(actor_fields)
def get(self, actor_id=None):
if actor_id:
return Actor.query.get_or_404(actor_id)
else:
return Actor.query.all()
def post(self, actor_id=None):
if actor_id:
abort(400)
else:
collections = list(collections_to_resource_type.keys())
coverage_marshall_fields = [("regions",
fields.List(
NonNullNested({
"id":
fields.String(attribute="region_id"),
"start_production_date":
fields.String,
"end_production_date":
fields.String,
"last_load_at":
FieldDateTime(),
"name":
fields.String,
"status":
fields.String,
"shape":
fields.String,
"error":
NonNullNested({
"code": fields.String,
"value": fields.String
}),
"dataset_created_at":
fields.String(),
})))]
class Coverage(StatedResource):
def __init__(self, quota=True, *args, **kwargs):
import requests as req
from flask import request, json
from flask.ext.restful import Resource, fields, marshal
from flask.ext.login import current_user
from jeto.models.auditlog import auditlog
from jeto import app
htpassword_list_fields = {
'slug': fields.String,
'users': fields.List(fields.String),
}
class HtpasswordService(object):
def _get_url(self):
return 'http://' + app.config.get('HTPASSWORD_API_URL') + ':' +\
app.config.get('HTPASSWORD_API_PORT')
def _get_headers(self):
return {
"Content-Type": "application/json",
}
class HtpasswordApi(Resource, HtpasswordService):
def get(self):
r = req.get(self._get_url())
items = r.json()['lists']
return {
class upload(DepositionType):
"""
Zenodo deposition workflow
"""
workflow = [
p.IF_ELSE(
has_submission,
# Existing deposition
[
# Load initial record
load_record(draft_id='_edit', post_process=process_draft),
# Render the form and wait until it is completed
render_form(draft_id='_edit'),
],
# New deposition
[
# Load pre-filled data from cache
prefill_draft(draft_id='_default'),
# Render the form and wait until it is completed
render_form(draft_id='_default'),
# Test if all files are available for API
api_validate_files(),
]),
# Create the submission information package by merging data
# from all drafts - i.e. generate the recjson.
prepare_sip(),
p.IF_ELSE(
has_submission,
[
# Process SIP recjson
process_sip_metadata(process_recjson_edit),
# Merge SIP metadata into record and generate MARC
merge_record(
draft_id='_edit',
post_process_load=process_draft,
process_export=process_recjson_edit,
merge_func=merge,
),
# Set file restrictions
process_bibdocfile(process=process_files),
],
[
# Check for reserved recids.
reserved_recid(),
# Reserve a new record id
create_recid(),
# Register DOI in internal pid store.
mint_pid(
pid_field='doi',
pid_store_type='doi',
pid_creator=lambda recjson: create_doi(recid=recjson[
'recid'])['doi'],
existing_pid_checker=check_existing_pid,
),
# Process SIP metadata
process_sip_metadata(process_recjson_new),
]),
# Generate MARC based on recjson structure
finalize_record_sip(),
p.IF_ELSE(
has_submission,
[
# Seal the SIP and write MARCXML file and call bibupload on it
upload_record_sip(),
# Schedule background tasks.
run_tasks(update=True),
],
[
# Note: after upload_record_sip(), has_submission will return
# True no matter if it's a new or editing of a deposition.
upload_record_sip(),
run_tasks(update=False),
]),
]
name = "Upload"
name_plural = "Uploads"
editable = True
stopable = True
enabled = True
default = True
api = True
draft_definitions = {
'_default': ZenodoForm,
'_edit': ZenodoEditForm,
}
marshal_metadata_fields = dict(
access_right=fields.String,
communities=fields.List(fields.Raw),
conference_acronym=fields.String,
conference_dates=fields.String,
conference_place=fields.String,
conference_title=fields.String,
conference_url=fields.String,
conference_session=fields.String,
conference_session_part=fields.String,
creators=fields.Raw(default=[]),
description=fields.String,
doi=fields.String(default=''),
embargo_date=ISODate,
grants=fields.List(fields.Raw),
image_type=fields.String(default=''),
imprint_isbn=fields.String,
imprint_place=fields.String,
imprint_publisher=fields.String,
journal_issue=fields.String,
journal_pages=fields.String,
journal_title=fields.String,
journal_volume=fields.String,
keywords=fields.Raw(default=[]),
license=fields.String,
notes=fields.String(default=''),
partof_pages=fields.String,
partof_title=fields.String,
prereserve_doi=fields.Raw,
publication_date=ISODate,
publication_type=fields.String(default=''),
references=fields.List(fields.String, default=[]),
related_identifiers=fields.Raw(default=[]),
thesis_supervisors=fields.Raw(default=[]),
title=fields.String,
upload_type=fields.String,
)
marshal_metadata_edit_fields = marshal_metadata_fields.copy()
del marshal_metadata_edit_fields['prereserve_doi']
#marshal_metadata_edit_fields.update(dict(
# recid=fields.Integer,
# version_id=UTCISODateTime,
#))
marshal_deposition_fields = DepositionType.marshal_deposition_fields.copy()
del marshal_deposition_fields['drafts']
marshal_draft_fields = DepositionType.marshal_draft_fields.copy()
marshal_draft_fields['metadata'] = fields.Nested(marshal_metadata_fields,
attribute='values')
del marshal_draft_fields['id']
del marshal_draft_fields['completed']
@classmethod
def default_draft_id(cls, deposition):
if deposition.has_sip() and '_edit' in deposition.drafts:
return '_edit'
return '_default'
@classmethod
def marshal_deposition(cls, deposition):
"""
Generate a JSON representation for REST API of a Deposition
"""
# Get draft
if deposition.has_sip() and '_edit' in deposition.drafts:
draft = deposition.get_draft('_edit')
metadata_fields = cls.marshal_metadata_edit_fields
elif deposition.has_sip():
# FIXME: Not based on latest available data in record.
sip = deposition.get_latest_sip(sealed=True)
draft = record_to_draft(Record.create(sip.package,
master_format='marc'),
post_process=process_draft)
metadata_fields = cls.marshal_metadata_edit_fields
else:
draft = deposition.get_or_create_draft('_default')
metadata_fields = cls.marshal_metadata_fields
# Fix known differences in marshalling
draft.values = filter_empty_elements(draft.values)
if 'grants' not in draft.values:
draft.values['grants'] = []
# Set disabled values to None in output
for field, flags in draft.flags.items():
if 'disabled' in flags and field in draft.values:
del draft.values[field]
# Marshal deposition
obj = marshal(deposition, cls.marshal_deposition_fields)
# Marshal the metadata attribute
obj['metadata'] = marshal(unicodifier(draft.values), metadata_fields)
# Add record and DOI information from latest SIP
for sip in deposition.sips:
if sip.is_sealed():
recjson = sip.metadata
if recjson.get('recid'):
obj['record_id'] = fields.Integer().format(
recjson.get('recid'))
obj['record_url'] = fields.String().format(
url_for('record.metadata',
recid=recjson.get('recid'),
_external=True))
if recjson.get('doi') and \
recjson.get('doi').startswith(cfg['CFG_DATACITE_DOI_PREFIX']
+"/"):
obj['doi'] = fields.String().format(recjson.get('doi'))
obj['doi_url'] = fields.String().format(
"http://dx.doi.org/%s" % obj['doi'])
break
return obj
@classmethod
def marshal_draft(cls, obj):
"""
Generate a JSON representation for REST API of a DepositionDraft
"""
return marshal(obj, cls.marshal_draft_fields)
@classmethod
def api_action(cls, deposition, action_id):
if action_id == 'publish':
return deposition.run_workflow(headless=True)
elif action_id == 'edit':
# Trick: Works in combination with load_record task to provide
# proper response codes to API clients.
if deposition.state == 'done' or deposition.drafts:
deposition.reinitialize_workflow()
return deposition.run_workflow(headless=True)
elif action_id == 'discard':
deposition.stop_workflow()
deposition.save()
return deposition.marshal(), 201
raise InvalidApiAction(action_id)
@classmethod
def api_metadata_schema(cls, draft_id):
schema = super(upload, cls).api_metadata_schema(draft_id)
if schema and draft_id == '_edit':
if 'recid' in schema['schema']:
del schema['schema']['recid']
if 'modification_date' in schema['schema']:
del schema['schema']['modification_date']
return schema
@classmethod
def render_completed(cls, d):
"""
Render page when deposition was successfully completed
"""
ctx = dict(
deposition=d,
deposition_type=(None if d.type.is_default() else
d.type.get_identifier()),
uuid=d.id,
my_depositions=Deposition.get_depositions(current_user,
type=d.type),
sip=d.get_latest_sip(),
format_record=format_record,
)
return render_template('deposit/completed.html', **ctx)
'found': fields.Boolean(),
'links': FareLinks(attribute="ticket_id")
}
journey = {
'duration': fields.Integer(),
'nb_transfers': fields.Integer(),
'departure_date_time': DateTime(),
'arrival_date_time': DateTime(),
'requested_date_time': DateTime(),
'sections': NonNullList(NonNullNested(section)),
'from': PbField(place, attribute='origin'),
'to': PbField(place, attribute='destination'),
'type': fields.String(),
'fare': NonNullNested(fare),
'tags': fields.List(fields.String),
"status": enum_type(attribute="message_status"),
"calendars": NonNullList(NonNullNested(calendar)),
}
ticket = {
"id": fields.String(),
"name": fields.String(),
"comment": fields.String(),
"found": fields.Boolean(),
"cost": NonNullNested(cost),
"links": TicketLinks(attribute="section_id")
}
journeys = {
"journeys": NonNullList(NonNullNested(journey)),
"error": PbField(error, attribute='error'),
project_full_resource_fields.pop('longitude')
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_translate_resource_fields = {
k: v
class GeocodejsonFeature(fields.Raw):
def format(self, place):
type_ = place.get('properties', {}).get('geocoding', {}).get('type')
if type_ not in geocode_feature_func_mapping:
logging.getLogger(__name__).error(
'Place not serialized (unknown type): {}'.format(place))
return None
return marshal(place, geocode_feature_func_mapping[type_])
geocodejson = {
"places":
fields.List(GeocodejsonFeature, attribute='features'),
"warnings":
ListLit([fields.Nested(beta_endpoint)]),
"feed_publishers":
ListLit([
fields.Nested(feed_publisher_bano),
fields.Nested(feed_publisher_osm)
])
}
class GeocodeJson(AbstractAutocomplete):
"""
Autocomplete with an external service returning geocodejson
(https://github.com/geocoders/geocodejson-spec/)
'committee_name': fields.String,
'link_date': fields.String,
'expire_date': fields.String,
'committee_type': fields.String,
'committee_type_full': fields.String,
'committee_designation': fields.String,
'committee_designation_full': fields.String,
'election_year': fields.Integer,
}
candidate_fields = {
'candidate_id': fields.String,
'candidate_status_full': fields.String,
'candidate_status': fields.String,
'district': fields.String,
'active_through': fields.Integer,
'election_years': fields.List(fields.Integer),
'incumbent_challenge_full': fields.String,
'incumbent_challenge': fields.String,
'office_full': fields.String,
'office': fields.String,
'party_full': fields.String,
'party': fields.String,
'state': fields.String,
'name': fields.String,
}
candidate_detail_fields = {
'candidate_id': fields.String,
'candidate_status_full': fields.String,
'candidate_status': fields.String,
'district': fields.String,
'active_through': fields.Integer,
"min_duration": fields.Integer(),
'from': PbField(place, attribute='origin'),
"to": PbField(place, attribute="destination"),
'requested_date_time': DateTime(),
'min_date_time': DateTime(),
'max_date_time': DateTime()
}
graphical_isochrones = {
"isochrones":
NonNullList(NonNullNested(graphical_isochrone),
attribute="graphical_isochrones"),
"error":
PbField(error, attribute='error'),
"feed_publishers":
fields.List(NonNullNested(feed_publisher)),
"links":
fields.List(Links()),
"warnings":
ListLit([fields.Nested(beta_endpoint)]),
}
class GraphicalIsochrone(JourneyCommon):
def __init__(self):
super(GraphicalIsochrone,
self).__init__(output_type_serializer=None
) #TODO implement and change to a real one
parser_get = self.parsers["get"]
parser_get.add_argument("min_duration",
type=UnsignedInteger(),
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(),
'data_freshness': enum_type(attribute='realtime_level'),
}
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))
}
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):
def __init__(self):
ResourceUri.__init__(self,
output_type_serializer=api.LineReportsSerializer)
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",
def get_answer_pairings_new():
ret = {
'id': fields.Integer,
'answers': fields.List(fields.Nested(get_posts_for_answers())),
}
return ret
class QuestionUploadSetList(AuthorizedResource):
mock_test_obj = {
'name': fields.String
}
upload_set_obj = {
'id': fields.Integer,
'name': fields.String,
'errors_exist': fields.Boolean,
'mock_test_id': fields.Integer,
'mock_test': fields.Nested(mock_test_obj),
'questions_added': fields.Boolean,
}
get_response = {
'total': fields.Integer,
'error': fields.Boolean(default=False),
'upload_sets': fields.List(fields.Nested(upload_set_obj)),
}
post_response = {
'error': fields.Boolean(default=False),
'upload_set': fields.Nested(upload_set_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['UPLOAD_SET_LIST_LIMIT'])
args = parser.parse_args()
# get a list of all the upload sets in the DB (without the questions)
upload_set_pag_obj = QuestionUploadSet.query.filter().order_by(QuestionUploadSet.created_at.desc()).paginate(args['page'], args['limit'])
upload_sets = upload_set_pag_obj.items
total = upload_set_pag_obj.total
# return a list of tests
return {'upload_sets': upload_sets, 'total': total}
@marshal_with(post_response)
def post(self, *args, **kwargs):
parse = reqparse.RequestParser()
parse.add_argument('name', type=str, required=True)
parse.add_argument('archive_key', type=str, required=True)
parse.add_argument('mock_test_id', type=str, required=True)
args = parse.parse_args()
parse_upload_set_async.delay(args['name'], args['archive_key'], args['mock_test_id'])
print 'this is done'
return 'this is good shit'
#print 'Checking S3 key'
# check if the s3 key exists
conn = S3Connection(app.config['S3_ACCESS_KEY'], app.config['S3_SECRET'])
bucket = conn.get_bucket(app.config['S3_UPLOAD_SET_ARCHIVES_BUCKET'])
archive_s3 = bucket.get_key(args['archive_key'])
if not archive_s3:
raise ArchiveS3KeyDoesNotExist
#print 'S3 key checked'
#print 'Checking mock test'
# check if the mock test is open and has no questions
mock_test_id = args['mock_test_id']
mock_test = MockTest.query.get(mock_test_id)
if not mock_test:
raise InvalidMockTestId
if not mock_test.question_ids is None:
raise QuestionUploadSetMockSetNotEmpty
#print 'Mock test checked'
#print 'Getting contents from S3'
# parse the paper and store it in json
archive = StringIO()
archive_s3.get_contents_to_file(archive)
#print 'Contents from S3 got'
#print 'parsing questions'
parsed_questions = parse_paper(archive)
#print 'questions parsed'
# check the parsed questions for any `overall` errors. if there are then don't proceed
if parsed_questions['is_overall_error']:
error_message = '\n'.join([ exc.message for exc in parsed_questions['overall_errors'] ])
raise OverallQuestionParsingError(error_message)
# check if any errors exist or not
errors = False
try:
check_if_errors_exist_in_parsed_questions(parsed_questions)
except Exception as e:
errors = True
# store the parsed questions in the DB
upload_set = QuestionUploadSet.create(
name=args['name'],
errors_exist=errors,
mock_test_id=mock_test.id,
parsed_questions=ExceptionJSONEncoder().encode(parsed_questions['questions']),
parsed_comprehensions=ExceptionJSONEncoder().encode(parsed_questions['comprehensions'])
)
return {'upload_set': upload_set}
client = MongoClient()
print("Connected to MongoDB@localhost")
db = client.eduvideo
video_col = db.video
user_col = db.user
channel_col = db.channel
chunks_col = db.fs.chunks
files_col = db.fs.files
app = Flask(__name__, static_url_path="")
api = Api(app)
CORS(app)
usr_rates = {
'good': fields.List(fields.String),
'avg': fields.List(fields.String),
'poor': fields.List(fields.String)
}
user_fields = {
'username': fields.String,
'password': fields.String,
'usertype': fields.String,
'_id': fields.String,
'email': fields.String,
'history': fields.List(fields.String),
'rates': fields.Nested(usr_rates),
'channel_ids': fields.List(fields.String),
'subscribed_ids': fields.List(fields.String),
'watch_later_ids': fields.List(fields.String),
'found': fields.Boolean(),
'links': FareLinks(attribute="ticket_id")
}
journey = {
'duration': fields.Integer(),
'nb_transfers': fields.Integer(),
'departure_date_time': DateTime(),
'arrival_date_time': DateTime(),
'requested_date_time': DateTime(),
'sections': NonNullList(NonNullNested(section)),
'from': PbField(place, attribute='origin'),
'to': PbField(place, attribute='destination'),
'type': fields.String(),
'fare': NonNullNested(fare),
'tags': fields.List(fields.String),
"status": fields.String(attribute="most_serious_disruption_effect"),
"calendars": NonNullList(NonNullNested(calendar)),
"co2_emission": NonNullNested({
'value': fields.Raw,
'unit': fields.String
}),
"durations": Durations(),
"debug": JourneyDebugInfo()
}
ticket = {
"id": fields.String(),
"name": fields.String(),
"comment": fields.String(),
"found": fields.Boolean(),
"name": fields.String,
"address": {
"id":
fields.String,
"coord": {
"lon": fields.Float(attribute="coord.lon"),
"lat": fields.Float(attribute="coord.lat"),
},
"house_number":
fields.String,
"label":
fields.String(attribute="name"),
"name":
fields.String(attribute="street.street_name"),
"administrative_regions":
fields.List(fields.Nested(ww_admin),
attribute="street.administrative_region")
}
}
ww_street = {
"embeded_type": Lit("address"),
#"id": id,
"name": fields.String,
"address": {
#"id": id,
#"coord": source["coord"],
#"house_number": 0,
"label":
fields.String(attribute="name"),
"name":
fields.String(attribute="street_name"),
area=PolygonToLatLng(attribute='area'),
dimension=fields.String,
lot_area=fields.Float,
price_per_sq_mtr=fields.Float,
amount=fields.Float,
or_no=fields.String,
date_purchased=fields.DateTime("iso8601"),
status=fields.String,
remarks=fields.String,
date_created=fields.DateTime("iso8601"),
date_modified=fields.DateTime("iso8601"))
lot_create_fields = dict(status=fields.String,
message=fields.String,
lot=fields.Nested(lot_fields, allow_null=False))
ok_response = dict(status=fields.String, message=fields.String)
lot_client_create_fields = dict(
status=fields.String,
message=fields.String,
client=fields.Nested(client_fields),
lot=fields.Nested(lot_fields),
)
lot_complete_fields = copy(lot_fields)
lot_complete_fields['deceased'] = fields.List(fields.Nested(deceased_fields))
lot_complete_fields['client'] = fields.Nested(client_fields)
# lot_complete_fields['block'] = fields.Nested(block_basic_fields)
'id': fields.Integer,
'name': fields.String,
'capacity': fields.Integer,
'number_players': fields.Integer
}
enrollment_fields = {
'number_players': fields.Integer,
'team': fields.Nested(team_fields)
}
user_fields = {
'id': fields.Integer,
'username': fields.String,
'email': fields.String,
'teams_created': fields.List(fields.Nested(team_fields)),
'teams': fields.List(fields.Nested(enrollment_fields))
}
class UserAPI(Resource):
def get(self, id):
user = User.query.get(id)
if not user:
return 'User not found', 404
return {'user': marshal(user, user_fields)}
class UsersAPI(Resource):
def __init__(self):
self.reqparse = reqparse.RequestParser()
from jormungandr.interfaces.v1.fields import DateTime
from jormungandr.interfaces.v1.serializer.api import HeatMapSerializer
from jormungandr.interfaces.v1.decorators import get_serializer
heat_map = {
"heat_matrix": JsonString(),
'from': PbField(place, attribute='origin'),
"to": PbField(place, attribute="destination"),
'requested_date_time': DateTime()
}
heat_maps = {
"heat_maps": NonNullList(NonNullNested(heat_map)),
"error": PbField(error, attribute='error'),
"links": fields.List(Links()),
"warnings": ListLit([fields.Nested(beta_endpoint)]),
"feed_publishers": fields.List(NonNullNested(feed_publisher)),
}
class HeatMap(JourneyCommon):
def __init__(self):
super(HeatMap, self).__init__(output_type_serializer=HeatMapSerializer)
parser_get = self.parsers["get"]
parser_get.add_argument("resolution", type=UnsignedInteger(), default=500)
@get_serializer(serpy=HeatMapSerializer, marshall=heat_maps)
@ManageError()
def get(self, region=None, uri=None):
api = Api(app)
element_fields = {
'id': fields.Integer,
'name': fields.String,
'description': fields.String,
'status': fields.Integer,
'controller_id': fields.Integer
# 'uri': fields.Url('controller')
}
controller_fields = {
'id': fields.Integer,
'name': fields.String,
'description': fields.String,
'status': fields.Integer,
'elements': fields.List(fields.Nested(element_fields)),
'pipeRead': fields.String,
'pipeWrite': fields.String
}
class ElementAPI(Resource):
def __init__(self):
#Will be used to parse our answers
self.reqparse = reqparse.RequestParser()
self.reqparse.add_argument('name', type=str, location='json')
self.reqparse.add_argument('description', type=str, location='json')
self.reqparse.add_argument('status', type=int, location='json')
self.reqparse.add_argument('controller_id', type=int, location='json')
super(ElementAPI, self).__init__()
comment_fields = {
'id': fields.Integer,
'detail': fields.String,
'create_at': TimeFormat(attribute='createAt'),
'author': fields.Nested(user_fields)
}
comment_page_fields = {
'total': fields.Integer,
'has_prev': fields.Boolean,
'prev_num': fields.Integer,
'page': fields.Integer,
'pages': fields.Integer,
'has_next': fields.Boolean,
'next_num': fields.Integer,
'items': fields.List(fields.Nested(comment_fields))
}
blog_list_fields = {
'id': fields.Integer,
'title': fields.String,
'content': ContentFormat,
'create_at': DateFormat(attribute='createAt'), #重命名属性
'author': AuthorFormat, #格式化属性
'ccount': fields.Integer
}
blog_fields = {
'id': fields.Integer,
'title': fields.String,
'content': fields.String,
