def test_prepare_subsubpreparer(self):
subsubpreparer = FieldsPreparer(fields={
'really': 'yes',
})
subpreparer = FieldsPreparer(fields={
'data': SubPreparer('data', subsubpreparer),
})
preparer = FieldsPreparer(fields={
'wale': SubPreparer('moof.buried', subpreparer),
})
preped = preparer.prepare(self.obj_data)
self.assertEqual(preped, {'wale': {'data': {'really': 'no'}}})
class ObjectResource(CustomFlaskResource):
preparer = AutoPreparer({
'type':
'type',
'attributes':
CollectionSubPreparer(
'attributes',
AutoPreparer({
'type': 'type',
'text': 'text',
'score': 'score',
})),
'links':
CollectionSubPreparer(
'links',
FieldsPreparer(
fields={
'external_id':
'external_id',
'platform':
SubPreparer('platform',
AutoPreparer({
'name': 'name',
'slug': 'slug'
}))
}))
})
def is_authenticated(self):
return True
def list(self):
return ExternalObject.query.all()
def detail(self, pk):
return ExternalObject.query.filter(ExternalObject.id == pk).one()
def create(self):
scrap_id = request.headers.get('x-scrap-id', None)
if scrap_id is None:
raise restless.exceptions.\
BadRequest('Missing `x-scrap-id` header')
try:
scrap = Scrap.query.filter(Scrap.id == scrap_id).one()
except NoResultFound:
raise restless.exceptions.NotFound('Scrap not found')
data = ExternalObject.normalize_dict(self.data)
if data['type'] is None:
raise restless.exceptions.BadRequest('Field "type" is required')
if data['relation'] is not None:
raise restless.exceptions.BadRequest(
'Field "relation" is not allowed on the root object')
obj = ExternalObject.insert_dict(data, scrap)
return obj
def test_prepare_subpreparer(self):
subpreparer = FieldsPreparer(fields={
'id': 'id',
'data': 'data',
})
preparer = FieldsPreparer(fields={
'flying': 'say',
'wale': SubPreparer('moof.buried', subpreparer),
})
preped = preparer.prepare(self.obj_data)
class ScrapResource(CustomFlaskResource):
preparer = AutoPreparer({
'status':
'status',
'date':
'date',
'platform':
SubPreparer('platform', AutoPreparer({
'name': 'name',
})),
})
def is_authenticated(self):
return True
def list(self):
return Scrap.query.all()
def detail(self, pk):
return Scrap.query.filter(Scrap.id == pk).one()
def update(self, pk):
scrap = Scrap.query.filter(Scrap.id == pk).one()
if 'status' in self.data:
status = ScrapStatus.from_name(self.data['status'])
scrap.to_status(status)
if 'stats' in self.data:
scrap.stats = self.data['stats']
db.session.commit()
return scrap
def create(self):
try:
platform = Platform.lookup(self.data['platform'])
except ValueError:
raise restless.exceptions.BadRequest('Missing key `platform`')
if platform is None:
raise restless.exceptions.NotFound('platform not found')
scrap = Scrap(platform=platform)
scrap.status = ScrapStatus.SCHEDULED
if 'status' in self.data:
status = ScrapStatus.from_name(self.data['status'])
scrap.to_status(status)
db.session.add(scrap)
db.session.commit()
return scrap
class RaceResource(BaseResource):
horse_preparer = FieldsPreparer(fields={'id': 'id', 'name': 'name'})
organizer_preparer = FieldsPreparer(fields={'id': 'id', 'name': 'name'})
bet_preparer = FieldsPreparer(fields={'bet': 'bet', 'rating': 'rating'})
participant_preparer = FieldsPreparer(
fields={
'id': 'id',
'horse': SubPreparer('horse', horse_preparer),
'rating': 'rate',
'bets': CollectionSubPreparer('bets.all', bet_preparer)
})
preparer = FieldsPreparer(
fields={
'id':
'id',
'title':
'track',
'dateTime':
'date.timestamp',
'organizer':
SubPreparer('organizer', organizer_preparer),
'participants':
CollectionSubPreparer('participants.all', participant_preparer)
})
def list(self, *args, **kwargs):
return self.get_page(Race.objects.all())
def detail(self, pk):
return Race.objects.get(id=pk)
def wrap_list_response(self, data):
return {"races": data}
class UserResource(BaseResource):
details_preparer = FieldsPreparer(fields={'avatar': 'avatar'})
preparer = FieldsPreparer(
fields={
'id': 'id',
'first_name': 'first_name',
'last_name': 'last_name',
'email': 'email',
'details': SubPreparer('detail.first', details_preparer)
})
def detail(self):
return self.request.client
class ValueResource(CustomFlaskResource):
preparer = AutoPreparer({
'type':
'type',
'external_object':
SubPreparer('external_object', AutoPreparer({
'type': 'type',
})),
'text':
'text',
'score':
'score',
'sources':
CollectionSubPreparer(
'value_sources',
FieldsPreparer(
fields={
'platform':
SubPreparer('platform', AutoPreparer({
'name': 'name',
})),
'score':
'score',
'score_factor':
'score_factor',
})),
})
def is_authenticated(self):
return True
def list(self):
return Value.query.all()
def detail(self, pk):
return Value.query.filter(Value.id == pk).one()
def __init__(self, *args, **kwargs):
super(DefaultServiceResource, self).__init__(self, args, kwargs)
self.fields = {}
for field in self.service.model._meta.get_fields():
if isnot_fk(field):
self.fields[field.name] = field.name
else:
nested_field_names = field.remote_field.model._meta.get_fields()
nested_fields = {f.name: f.name for f in nested_field_names if isnot_fk(f)}
self.fields[field.name] = SubPreparer(field.name, FieldsPreparer(nested_fields))
# Alternative implementation, using dict comprehensions
# model_fields = self.service.model._meta.get_fields()
# flat_fields = {f.name: f.name for f in model_fields if isnot_fk(f)}
# nested = lambda f: {f.name: f.name for f in f.remote_field.model._meta.get_fields() if isnot_fk(f)}
# nested_fields = {f.name: SubPreparer(f.name, FieldsPreparer(nested(f))) for f in model_fields if not isnot_fk(f)}
# self.fields = {**nested_fields, **flat_fields}
self.preparer = FieldsPreparer(self.fields)
class StudentAPI(Base):
lesson_preparer = FieldsPreparer(
fields={
"id": 'id',
"type": 'type',
"teacher_name": 'teacher_name',
"assistant_name": 'assistant_name',
"skype_count": "skype_count",
# "fee":"fee",
"class_level": "class_level",
"if_protocol": "if_protocol"
})
teacher_preparer = FieldsPreparer(fields={"id": "id", "name": "name"})
preparer = FieldsPreparer(
fields={
'id': 'id',
'name': 'name',
'if_old_major': 'if_old_major',
'sex': 'sex',
'qq': 'qq',
'mobile': 'mobile',
'adviser': 'adviser',
'due_year': 'due_year',
'old_school': 'old_school',
'old_major': 'old_major',
'study_status': 'study_status',
'status': 'status',
'apply_time': 'apply_time',
'source': 'source',
'background': 'background',
'qq_group': 'qq_group',
'author': 'author',
'remark': 'remark',
'extend': 'extend',
'teacher_id': 'teacher_id',
'email_sent': 'email_sent',
'major_sent': 'major_sent',
'public_sent': 'public_sent',
'target_school': 'target_school',
'create_time': 'create_time',
'update_time': 'update_time',
'pro': SubPreparer('pro', lesson_preparer),
'com': SubPreparer('com', lesson_preparer),
'eng': SubPreparer('pro', lesson_preparer),
'pol': SubPreparer('com', lesson_preparer),
})
def list(self):
return Student.objects.filter(
qq__icontains=self.request.GET.get('qq', ''),
name__icontains=self.request.GET.get('name', ''),
due_year__icontains=self.request.GET.get('due_year', ''),
target_school__icontains=self.request.GET.get('target_school', ''),
old_major__icontains=self.request.GET.get('old_major', ''),
old_school__icontains=self.request.GET.get('old_school',
'')).order_by('id')
def detail(self, pk):
return Student.objects.get(id=pk)
def create(self):
student = Student()
student.name = self.data['name'] if 'name' in self.data else ''
student.due_year = self.data[
'due_year'] if 'due_year' in self.data else ''
student.target_school = self.data[
'target_school'] if 'target_school' in self.data else ''
student.old_major = self.data[
'old_major'] if 'old_major' in self.data else ''
student.old_school = self.data[
'old_school'] if 'old_school' in self.data else ''
if 'if_old_major' in self.data:
student.if_old_major = self.data['if_old_major']
if 'sex' in self.data:
student.sex = self.data['sex']
if 'qq' in self.data:
student.qq = self.data['qq']
if 'mobile' in self.data:
student.mobile = self.data['mobile']
if 'adviser' in self.data:
student.adviser = self.data['adviser']
if 'study_status' in self.data:
student.study_status = self.data['study_status']
if 'study_status' in self.data:
student.study_status = self.data['study_status']
if 'status' in self.data:
student.status = self.data['status']
if 'apply_time' in self.data:
student.apply_time = self.data['apply_time']
if 'source' in self.data:
student.source = self.data['source']
if 'background' in self.data:
student.background = self.data['background']
if 'qq_group' in self.data:
student.qq_group = self.data['qq_group']
if 'author' in self.data:
student.author = self.data['author']
if 'remark' in self.data:
student.remark = self.data['remark']
if 'extend' in self.data:
student.extend = self.data['extend']
if 'major_sent' in self.data:
student.major_sent = self.data['major_sent']
if 'email_sent' in self.data:
student.email_sent = self.data['email_sent']
if 'public_sent' in self.data:
student.public_sent = self.data['public_sent']
student.save()
if 'pro' in self.data:
data = self.data['pro']
(pro, pro_bool) = Lesson.objects.get_or_create(student=student,
type='pro')
if 'teacher_name' in data:
pro.teacher_name = data['teacher_name']
if 'assistant_name' in data:
pro.assistant_name = data['assistant_name']
if 'skype_count' in data:
pro.skype_count = data['skype_count']
if 'class_level' in data:
pro.class_level = data['class_level']
if 'if_protocol' in data:
pro.if_protocol = data['if_protocol']
pro.save()
if 'com' in self.data:
data = self.data['com']
(com, pro_bool) = Lesson.objects.get_or_create(student=student,
type='com')
if 'teacher_name' in data:
com.teacher_name = data['teacher_name']
if 'assistant_name' in data:
com.assistant_name = data['assistant_name']
if 'skype_count' in data:
com.skype_count = data['skype_count']
if 'class_level' in data:
com.class_level = data['class_level']
if 'if_protocol' in data:
com.if_protocol = data['if_protocol']
com.save()
if 'pol' in self.data:
data = self.data['pol']
(pol, pro_bool) = Lesson.objects.get_or_create(student=student,
type='pol')
if 'teacher_name' in data:
pol.teacher_name = data['teacher_name']
if 'assistant_name' in data:
pol.assistant_name = data['assistant_name']
if 'skype_count' in data:
pol.skype_count = data['skype_count']
if 'class_level' in data:
pol.class_level = data['class_level']
if 'if_protocol' in data:
pol.if_protocol = data['if_protocol']
pol.save()
if 'eng' in self.data:
data = self.data['pro']
(eng, pro_bool) = Lesson.objects.get_or_create(student=student,
type='eng')
if 'teacher_name' in data:
eng.teacher_name = data['teacher_name']
if 'assistant_name' in data:
eng.assistant_name = data['assistant_name']
if 'skype_count' in data:
eng.skype_count = data['skype_count']
if 'class_level' in data:
eng.class_level = data['class_level']
if 'if_protocol' in data:
eng.if_protocol = data['if_protocol']
eng.save()
if 'teacher' in self.data:
student.teacher = Teacher.objects.get(
id=int(self.data['teacher_id']))
student.save()
return student
def update(self, pk):
student = Student.objects.get(id=pk)
student.name = self.data[
'name'] if 'name' in self.data else student.name
student.if_old_major = self.data[
'if_old_major'] if 'if_old_major' in self.data else student.if_old_major
student.sex = self.data['sex'] if 'sex' in self.data else student.sex
student.qq = self.data['qq'] if 'qq' in self.data else student.qq
student.mobile = self.data[
'mobile'] if 'mobile' in self.data else student.mobile
student.adviser = self.data[
'adviser'] if 'adviser' in self.data else student.adviser
student.due_year = self.data[
'due_year'] if 'due_year' in self.data else student.due_year
student.old_school = self.data[
'old_school'] if 'old_school' in self.data else student.old_school
student.old_major = self.data[
'old_major'] if 'old_major' in self.data else student.old_major
student.study_status = self.data[
'study_status'] if 'study_status' in self.data else student.study_status
student.status = self.data[
'status'] if 'status' in self.data else student.status
student.apply_time = self.data[
'apply_time'] if 'apply_time' in self.data else student.apply_time
student.source = self.data[
'source'] if 'source' in self.data else student.source
student.background = self.data[
'background'] if 'background' in self.data else student.background
student.qq_group = self.data[
'qq_group'] if 'qq_group' in self.data else student.qq_group
student.author = self.data[
'author'] if 'author' in self.data else student.author
student.remark = self.data[
'remark'] if 'remark' in self.data else student.remark
student.extend = self.data[
'extend'] if 'extend' in self.data else student.extend
student.name = self.data[
'name'] if 'time' in self.data else student.name
student.major_sent = self.data[
'major_sent'] if 'major_sent' in self.data else student.major_sent
student.email_sent = self.data[
'email_sent'] if 'email_sent' in self.data else student.email_sent
student.public_sent = self.data[
'public_sent'] if 'public_sent' in self.data else student.public_sent
# student.target_major = self.data['target_major'] if 'target_major' in self.data else student.target_major
student.target_school = self.data[
'target_school'] if 'target_school' in self.data else student.target_school
if 'pro' in self.data:
data = self.data['pro']
(pro, pro_bool) = Lesson.objects.get_or_create(student=student,
type='pro')
if data['teacher_name']:
pro.teacher_name = data['teacher_name']
if data['assistant_name']:
pro.assistant_name = data['assistant_name']
if data['skype_count']:
pro.skype_count = data['skype_count']
if data['class_level']:
pro.class_level = data['class_level']
if data['if_protocol']:
pro.if_protocol = data['if_protocol']
pro.save()
if 'com' in self.data:
data = self.data['com']
(com, pro_bool) = Lesson.objects.get_or_create(student=student,
type='com')
if data['teacher_name']:
com.teacher_name = data['teacher_name']
if data['assistant_name']:
com.assistant_name = data['assistant_name']
if data['skype_count']:
com.skype_count = data['skype_count']
if data['class_level']:
com.class_level = data['class_level']
if data['if_protocol']:
com.if_protocol = data['if_protocol']
com.save()
if 'pol' in self.data:
data = self.data['pro']
(pol, pro_bool) = Lesson.objects.get_or_create(student=student,
type='pol')
if data['teacher_name']:
pol.teacher_name = data['teacher_name']
if data['assistant_name']:
pol.assistant_name = data['assistant_name']
if data['skype_count']:
pol.skype_count = data['skype_count']
if data['class_level']:
pol.class_level = data['class_level']
if data['if_protocol']:
pol.if_protocol = data['if_protocol']
pol.save()
if 'eng' in self.data:
data = self.data['pro']
(eng, pro_bool) = Lesson.objects.get_or_create(student=student,
type='eng')
if data['teacher_name']:
eng.teacher_name = data['teacher_name']
if data['assistant_name']:
eng.assistant_name = data['assistant_name']
if data['skype_count']:
eng.skype_count = data['skype_count']
if data['class_level']:
eng.class_level = data['class_level']
if data['if_protocol']:
eng.if_protocol = data['if_protocol']
pro.save()
student.teacher = Teacher.objects.get(
id=int(self.data['teacher_id']
)) if 'teacher_id' in self.data and self.data[
'teacher_id'] else student.teacher
student.save()
return student
def delete(self, pk):
Student.objects.get(id=pk).delete()
class PlatformResource(CustomFlaskResource):
preparer = AutoPreparer({
'name':
'name',
'slug':
'slug',
'url':
'url',
'country':
'country',
'max_rating':
'max_rating',
'base_score':
'base_score',
'group':
SubPreparer('group', AutoPreparer({
'name': 'name',
})),
})
def is_authenticated(self):
return True
def list(self):
return Platform.query.all()
def detail(self, pk):
try:
return Platform.query.filter(Platform.id == pk).one()
except sqlalchemy.orm.exc.NoResultFound:
raise restless.exceptions.NotFound()
def create(self):
# Create or update platform
if 'group' in self.data:
gid = self.data['group']['id'] \
if isinstance(self.data['group'], dict) \
else self.data['group']
try:
group = PlatformGroup.query\
.filter(PlatformGroup.id == gid)\
.one()
except sqlalchemy.orm.exc.NoResultFound:
raise restless.exceptions.NotFound()
self.data['group'] = None
else:
group = None
if 'type' in self.data:
self.data['type'] = PlatformType.from_name(self.data['type'])
if 'slug' in self.data:
self.data['id'] = db.session\
.query(Platform.id)\
.filter(Platform.slug == self.data['slug'])\
.first()
platform = db.session.merge(Platform(**self.data))
platform.group = group
db.session.add(platform)
db.session.commit()
return platform
def update(self, pk):
try:
platform = Platform.query.filter(Platform.id == pk).one()
except sqlalchemy.orm.exc.NoResultFound:
raise restless.exceptions.NotFound()
if 'group' in self.data:
gid = self.data['group']['id'] \
if isinstance(self.data['group'], dict) \
else self.data['group']
try:
platform.group = PlatformGroup.query.filter(
PlatformGroup.id == gid)
except sqlalchemy.orm.exc.NoResultFound:
raise restless.exceptions.NotFound()
if 'name' in self.data:
platform.name = self.data['name']
if 'slug' in self.data:
platform.name = self.data['slug']
if 'url' in self.data:
platform.url = self.data['url']
if 'country' in self.data:
platform.country = self.data['country']
if 'max_rating' in self.data:
platform.max_rating = self.data['max_rating']
if 'base_score' in self.data:
platform.base_score = self.data['base_score']
db.session.commit()
return platform
class ScheduleResource(DjangoResource):
patient_preparer = FieldsPreparer(fields={
'id': 'pk',
'name': 'name',
'email': 'email',
})
procedure_preparer = FieldsPreparer(fields={
'id': 'pk',
'name': 'name',
'description': 'description',
})
preparer = FieldsPreparer(
fields={
'patient': SubPreparer('patient', patient_preparer),
'procedure': SubPreparer('procedure', procedure_preparer),
'detail': 'detail',
'date': 'date',
'start_time': 'start_time',
'end_time': 'end_time',
})
def list(self):
return Schedule.objects.all()
def create(self):
return Schedule.objects.create(
patient=self.data['patient'],
procedure=self.data['procedure'],
detail=self.data['detail'],
date=self.data['date'],
start_time=self.data['start_time'],
end_time=self.data['end_time'],
)
def detail(self, pk):
return get_object_or_404(Schedule, pk=pk)
def update(self, pk):
schedule = self.detail(pk)
schedule.patient = self.data['patient']
schedule.procedure = self.data['procedure']
schedule.detail = self.data['detail']
schedule.date = self.data['date']
schedule.start_time = self.data['start_time']
schedule.end_time = self.data['end_time']
schedule.save()
return schedule
def delete(self, pk):
schedule = self.detail(pk)
schedule.delete()
return "Agendamento Deletado"
def is_authenticated(self):
return True