class MyUserResource(DjangoResource):
"""Restless MyUser resource"""
preparer = FieldsPreparer(fields={
'id':'id',
'username':'******',
'email':'user.email',
'type':'type.name',
})
def is_authenticated(self):
"""API authentication"""
# Always True (allow all requests) for testing purposes
# return True
# For viewing in browser
if self.request.user.is_authenticated():
return True
# For incoming requests
try:
token = MyAuthToken.objects.get(token=self.request.META.get('HTTP_AUTHORIZATION','').replace('Token ', ''))
return True
except:
return False
def list(self):
"""GET /users/"""
return MyUser.objects.all()
def detail(self, pk):
"""GET /users/id/"""
return get_object_or_404(MyUser, pk=pk)
def create(self):
"""POST /users/"""
new_user = User.objects.create_user(
email = self.data['email'],
username=self.data['email'].split('@')[0],
password=self.data['password']
)
return MyUser.objects.create(
type=UserType.objects.get(name=self.data['type']),
user=new_user)
def update(self, pk):
"""PUT /users/id/"""
myuser = get_object_or_404(MyUser, pk=pk)
try:
myuser.type=UserType.objects.get(name=self.data['type'])
except KeyError:
pass
except UserType.DoesNotExist:
# return myuser
pass # if new type is invalid, skip assigning type, but proceed
try:
myuser.user.email = self.data['email']
myuser.user.username = myuser.user.email.split('@')[0] #TODO: make this a proper method
except KeyError:
pass
try:
myuser.user.set_password(self.data['password'])
except KeyError:
pass
myuser.save()
myuser.user.save()
return myuser
def delete(self, pk):
"""DELETE /users/id/"""
MyUser.objects.get(id=pk).user.delete()
class EventResource(DjangoResource):
preparer = FieldsPreparer(
fields={
'id': 'pk',
'start': 'start',
'end': 'end',
'title': 'title',
'calendar': 'calendar.id',
'location': 'location',
'description': 'description',
'recurrence_type': 'recurrence_type.type',
})
# Authentication!
def is_authenticated(self):
return self.request.user.is_authenticated()
# GET /api/events/
# Gets a list of events that belong to the current user within a certain time range.
def list(self):
errors = defaultdict(list)
start = self.request.GET.get('range_start', None)
end = self.request.GET.get('range_end', None)
event_id = self.request.GET.get('event_id', None)
range_start = range_end = None
if start is not None:
try:
range_start = datetime.strptime(start, '%Y-%m-%d %H:%M')
except ValueError:
errors['start'].append("Start not in the correct format")
if end is not None:
try:
range_end = datetime.strptime(end, '%Y-%m-%d %H:%M')
except ValueError:
errors['end'].append("End not in the correct format")
if errors:
raise BadRequest(str(errors))
calendar = self.request.user.profile.calendars.get(title="Default")
query = calendar.events.get(id=event_id) if event_id else calendar
events = query.get_between(range_start, range_end)
return events
# GET /api/events/<pk>/
# Gets detail on a specific event.
def detail(self, pk):
return Event.objects.get(id=pk,
calendar__owner=self.request.user.profile)
# PUT /api/events/<pk>/
# Updates some fields on a specified event.
def update(self, pk):
# Helper function to shift days_of_week array by some integer offset
def shift_days(days_of_week, offset):
offset = -(offset % 7)
return days_of_week[offset:] + days_of_week[:offset]
event = Event.objects.get(id=pk,
calendar__owner=self.request.user.profile)
errors = defaultdict(list)
is_recurring = False
start_diff = 0
end_diff = 0
if 'start_delta' in self.data:
start_diff = self.data['start_delta']
if 'end_delta' in self.data:
end_diff = self.data['end_delta']
if self.data.get('recurrence_type') == 'weekly':
try:
recurrence = WeeklyRecurrence.objects.get(event=event)
is_recurring = True
except WeeklyRecurrence.DoesNotExist:
errors['recurrence_type'].append(
"Event is not a weekly recurrence")
else:
try:
recurrence = SingleRecurrence.objects.get(event=event)
except SingleRecurrence.DoesNotExist:
errors['recurrence_type'].append(
"Event is not a single recurrence")
if 'start' in self.data:
try:
data_start = datetime.strptime(self.data['start'],
'%Y-%m-%d %H:%M')
if not is_recurring:
event.start = data_start
else:
event.start = event.start + timedelta(
milliseconds=start_diff)
recurrence.last_event_end = recurrence.last_event_end + timedelta(
milliseconds=start_diff)
start_days = timedelta(milliseconds=start_diff).days
recurrence.days_of_week = shift_days(
recurrence.days_of_week, start_days)
recurrence.save()
except ValueError:
errors['start'].append("Start not in the correct format")
if 'end' in self.data:
try:
if not is_recurring:
event.end = datetime.strptime(self.data['end'],
'%Y-%m-%d %H:%M')
else:
event.end = event.end + timedelta(milliseconds=end_diff)
except ValueError:
errors['end'].append("End not in the correct format")
if 'title' in self.data:
event.title = self.data['title']
if 'description' in self.data:
event.description = self.data['description']
if 'location' in self.data:
event.location = self.data['location']
if errors:
raise BadRequest(str(errors))
event.save()
return event
# POST /api/events/
# Create an event for the given user.
def create(self):
# Error check event fields: calendar, title, start, end
errors = defaultdict(list)
start = recurrence_type = days_of_week = frequency = last_event = None
if 'start' not in self.data:
errors['start'].append("Start not provided")
else:
try:
start = datetime.strptime(self.data['start'], '%Y-%m-%d %H:%M')
except ValueError:
errors['start'].append("Start not in the correct format")
end = None
if 'end' not in self.data:
errors['end'].append("End not provided")
else:
try:
end = datetime.strptime(self.data['end'], '%Y-%m-%d %H:%M')
except ValueError:
errors['end'].append("End not in the correct format")
title = None
if 'title' not in self.data:
errors['title'].append("Title not provided")
else:
title = self.data['title']
calendar_title = None
if 'calendar' not in self.data:
errors['calendar'].append("Calendar not provided")
else:
calendar_title = self.data['calendar']
# Error check recurrence type
if 'recurrence_type' not in self.data:
errors['recurrence_type'].append("Recurrence type not provided")
elif self.data['recurrence_type'] != 'weekly' and self.data[
'recurrence_type'] != 'single':
errors['recurrence_type'].append(
"recurrence_type not single or weekly")
else:
recurrence_type = self.data['recurrence_type']
# Additional error checks for weekly recurrence
if recurrence_type == "weekly":
if 'last_event' not in self.data:
errors['last_event'].append("Last event not provided")
else:
try:
last_event = datetime.strptime(self.data['last_event'],
'%Y-%m-%d %H:%M')
except ValueError:
errors['last_event'].append(
"Last_event not in the correct format")
if 'frequency' not in self.data:
errors['frequency'].append("Frequency not provided")
else:
frequency = self.data['frequency']
if frequency < 1:
errors['frequency'].append("Frequency not valid")
if 'days_of_week' not in self.data:
errors['days_of_week'].append("Days of week not provided")
else:
days_of_week = self.data['days_of_week']
if not re.match(r'^[01]{7}$', days_of_week):
errors['days_of_week'].append(
"Days of week in incorrect format")
if errors:
raise BadRequest(str(errors))
event = Event.objects.create(
start=start,
end=end,
title=title,
calendar=Calendar.objects.get(owner=self.request.user.profile,
title=calendar_title),
description=self.data.get('description', ''),
location=self.data.get('location', ''))
if recurrence_type == "single":
SingleRecurrence.objects.create(event=event)
else:
WeeklyRecurrence.objects.create(days_of_week=days_of_week,
frequency=frequency,
last_event_end=last_event,
event=event)
return event
# DELETE /api/events/<pk>/
# Deletes a specified event.
def delete(self, pk):
Event.objects.get(id=pk, calendar__owner=self.request.user.profile
).recurrence_type.delete()
Event.objects.get(id=pk,
calendar__owner=self.request.user.profile).delete()
class FOIARequestResource(DjangoResource):
preparer = FieldsPreparer(fields={
'status': 'status',
'tracking_id': 'pk',
})
def _convert_date(self, date):
return datetime.datetime.strptime(date, '%B %d, %Y')
def check_submittable(self, email_list):
""" If there is no email for this agency or office, we can not accept a
FOIA request. """
if len(email_list) == 0:
raise BadRequest(
msg="Agency or Office has no email address for submission")
# POST /
def create(self):
foia = None
with transaction.atomic():
# Is this request to an Agency, or an Office?
if self.data.get('office') and self.data.get('agency'):
office = Office.objects.get(
agency__slug=self.data['agency'],
office_slug=self.data['office'],
)
agency = None
emails = office.emails
elif self.data.get('agency'):
agency = Agency.objects.get(slug=self.data['agency'])
office = None
emails = agency.emails
# Not sure yet what this actually returns.
# restless docs could be better on this point.
else:
raise Exception("No agency or office given.")
self.check_submittable(emails)
requester = Requester.objects.create(
first_name=self.data['first_name'],
last_name=self.data['last_name'],
email=self.data['email'])
if self.data.get("documents_start"):
start = self._convert_date(self.data['documents_start'])
else:
start = None
if self.data.get("documents_end"):
end = self._convert_date(self.data['documents_end'])
else:
end = None
foia = FOIARequest.objects.create(
status='O',
requester=requester,
office=office,
agency=agency,
emails=emails,
date_start=start,
date_end=end,
request_body=self.data['body'],
)
return foia
# GET /
def list(self):
return FOIARequest.objects.all()
# Open everything wide!
# DANGEROUS, DO NOT DO IN PRODUCTION.
# more info here:
# https://github.com/toastdriven/restless/blob/master/docs/tutorial.rst
def is_authenticated(self):
return True
class CandidateDetailResource(DjangoResource):
bill_preparer = FieldsPreparer(
fields={"name": "name", "keywords": "keywords", "url": "url"}
)
preparer = FieldsPreparer(
fields={
"id": "id",
"name": "name",
"image": "image",
"ballot_name": "ballot_name",
"ballot_number": "number",
"city": "politician.current_affiliation.city.name",
"state": "state",
"party": "party.name",
"party_abbreviation": "party.abbreviation",
"affiliation_history": "affiliation_history",
"asset_history": "asset_history",
"elections": "elections",
"elections_won": "elections_won",
"election_history": "election_history",
"date_of_birth": "date_of_birth",
"city_of_birth": "place_of_birth.name",
"state_of_birth": "place_of_birth.state",
"gender": "gender",
"email": "email",
"age": "get_age",
"ethnicity": "ethnicity",
"marital_status": "marital_status",
"education": "education",
"nationality": "nationality",
"occupation": "occupation",
"post": "post",
"post_code": "post_code",
"number": "number",
"coalition_name": "coalition_name",
"coalition_description": "coalition_description",
"coalition_short_name": "coalition_short_name",
"bills": CollectionSubPreparer("bills", bill_preparer),
"bill_keywords": "bill_keywords",
"rosies_suspicions": "rosies_suspicions",
}
)
@cached_property
def api_fields(self):
"""Define fields to select in the QuerySet based on preparer fields"""
fields = ["year", "sequential"]
methods = {
"elections",
"elections_won",
"image",
"get_age",
"rosies_suspicions",
}
for field in self.preparer.fields.values():
if field in methods or not isinstance(field, str):
continue
if field == "election_history":
field = "politician__election_history"
if field == "affiliation_history":
field = "politician__affiliation_history"
if field == "asset_history":
field = "politician__asset_history"
if field == "bill_keywords":
field = "politician__bill_keywords"
fields.append(field.replace(".", "__"))
return tuple(fields)
def detail(self, pk):
return (
Candidate.objects.select_related("party", "politician", "place_of_birth")
.only(*self.api_fields)
.get(pk=pk)
)
class officeResource(Base):
# Controls what data is included in the serialized output.
office_preparer = FieldsPreparer(fields={
'id': 'id',
'name': 'name',
})
preparer = FieldsPreparer(
fields={
'id': 'id',
'office_name': 'office_name',
'exam_name': 'exam_name',
'register_username': '******',
'register_password': '******',
'register_userid': 'user.id',
'admin_name': 'admin_name',
'admin_phone': 'admin_phone'
})
def is_authenticated(self):
return True
# GET /
def list(self):
return Office.objects.filter(
office_name__contains=self.request.GET.get('search', ''))
# GET /pk/
def detail(self, pk):
return Office.objects.get(id=pk)
# POST /
def create(self):
user = User.objects.create(username=self.data['register_username'],
password=make_password(
self.data['register_password']))
return Office.objects.create(user=user,
office_name=self.data['office_name'],
exam_name=self.data['exam_name'],
admin_name=self.data['admin_name'],
admin_phone=self.data['admin_phone'])
# return Teacher.objects.create(
# name=self.data['name'],
# phone=self.data['phone'],
# idcard=self.data['idcard'],
# bankcard=self.data['bankcard'],
# bankinfo=self.data['bankinfo'],
# office=self.request.user.office
# )
# PUT /pk/
def update(self, pk):
user = User.objects.get(id=int(self.data['register_userid']))
user.username = self.data['register_username']
if self.data['change_password']:
user.password = make_password(self.data['register_password'])
user.save()
office = Office.objects.get(id=pk)
office.office_name = self.data['office_name']
office.exam_name = self.data['exam_name']
office.admin_name = self.data['admin_name']
office.admin_phone = self.data['admin_phone']
office.save()
return office
# DELETE /pk/
def delete(self, pk):
Office.objects.get(id=pk).delete()
class FriendResource(DjangoResource):
preparer = FieldsPreparer(
fields={
'id': 'pk',
'username': '******',
'email': 'email',
'first_name': 'first_name',
'last_name': 'last_name',
'full_name': 'full_name',
'bio': 'bio',
'phone': 'phone',
'favorite': 'favorite',
'accepted': 'accepted',
'gravatar_url': 'gravatar_url',
'profile_url': 'profile_url',
'is_free': 'is_free',
})
# Authenticate if the user is currently logged in
def is_authenticated(self):
return self.request.user.is_authenticated()
# GET /api/friends/?type=(accepted|incoming|outgoing)
# Gets a list of friends of the current user.
# Returns accepted friends if "type" is not specified.
def list(self):
# Set accepted, favorite fields for each friend
def add_friendship_fields(from_friend, to_friend):
friendship = Friendship.objects.get(from_friend=from_friend,
to_friend=to_friend)
# Return the friend (not current user)
if from_friend == self.request.user.profile:
return_friend = to_friend
else:
return_friend = from_friend
return_friend.accepted = friendship.accepted
return_friend.favorite = friendship.favorite
return return_friend
list_type = self.request.GET.get('type', 'accepted')
if list_type == 'incoming':
return [
add_friendship_fields(f, self.request.user.profile)
for f in self.request.user.profile.pending_incoming_friends
]
elif list_type == 'outgoing':
return [
add_friendship_fields(self.request.user.profile, f)
for f in self.request.user.profile.pending_outgoing_friends
]
return [
add_friendship_fields(self.request.user.profile, f)
for f in self.request.user.profile.friends
]
# GET /api/friends/<pk>/
# Gets info on a specific user or friend.
# If no friendship from current user -> 'pk', responds with 404.
def detail(self, pk):
other = UserProfile.objects.get(user__id=pk)
friendship = self.request.user.profile.get_friendship(other)
other.accepted = friendship.accepted
other.favorite = friendship.favorite
return other
# POST /api/friends/<pk>/
# Adds a friendship of current user -> 'pk'
def create_detail(self, pk):
other = UserProfile.objects.get(user__id=pk)
friendship, created = self.request.user.profile.add_friend(other)
other.accepted = friendship.accepted
other.favorite = friendship.favorite
return other
# PUT /api/friends/<pk>/
# Edits favorite status of friend 'pk'
# data: {'favorite': boolean}
def update(self, pk):
other = UserProfile.objects.get(user__id=pk)
friendship = self.request.user.profile.get_friendship(other)
if not friendship.accepted:
raise Unauthorized("Can't set favorite status of a user "
"that isn't a friend.")
try:
if isinstance(self.data['favorite'], bool):
friendship.favorite = self.data['favorite']
else:
raise BadRequest("'favorite' is not a boolean.")
except KeyError:
raise BadRequest("'favorite' not found in sent data.")
friendship.save()
other.accepted = friendship.accepted
other.favorite = friendship.favorite
return other
# DELETE /api/friends/<pk>/
# Removes a friendship of current user <-> 'pk'
def delete(self, pk):
other = UserProfile.objects.get(user__id=pk)
self.request.user.profile.del_friend(other)
class UpdateResource(BaseResource):
model = InstalledApp
preparer = FieldsPreparer(fields={
"version":"version",
"device":"device.uuid",
"pkg":"pkg",
"checksum":"checksum",
})
def is_debug(self):
return True
def _authenticated(self):
''' Replicate BaseResource method on GET'''
bearer_token = self.request.META.get("HTTP_AUTHORIZATION", None)
if not bearer_token:
return False
# Authorization: Bearer #####
device_token = bearer_token.split(' ')[1]
try:
self.device = Device.objects.get(token=device_token)
except Device.DoesNotExist:
return False
else:
return True
def is_authenticated(self):
# We use the provisioning password
return True
def is_file(self,data):
return isinstance(data, File) or isinstance(data, FieldFile) or isinstance(data,FileField) or (type(data) == bytes)
def build_response(self, data, status=200):
if self.is_file(data):
return self.build_response_file(data,status=status)
else:
return super(UpdateResource, self).build_response(data, status=status)
def build_response_file(self, data, status=200):
# get the size and filename
if isinstance(data, File) or isinstance(data, FieldFile) or isinstance(data,FileField):
fname = data.name.split('/')[-1]
content_length = data.size
elif type(data) == bytes:
fname = "update.apk"
content_length = len(data)
# Build the response
response = HttpResponse(data,
content_type='application/vnd.android.package-archive')
response['Content-Disposition'] = 'attachment; filename=%s' % fname
response['Content-Length'] = content_length
response.status_code = status
return response
def serialize(self, method, endpoint, data):
if data and not getattr(data, 'should_prepare', True):
# check if data has value set
val = data.value if hasattr(data, 'value') else None
# set is None
value = val if val else bytes()
if self.is_file(value):
return value
return super(BaseResource, self).serialize(method, endpoint, data.value)
def list(self):
if not self._authenticated():
raise Unauthorized
self.device.lastUpdated = DefaultFuncs.getNow()
self.device.save()
# Fetch from the file server
try:
headers = {
"Authorization": "Bearer " + settings.UPDATE_API_KEY
}
request = urllib.request.Request(
url=settings.UPDATE_URL_REDIRECT,
headers=headers
)
response = urllib.request.urlopen(request)
value = response.read()
except:
value = bytes()
return Data(value, should_prepare=False)
def create(self):
# Use the provisioning password to authenticate
# self.provisioning_password = self.data["provisioning_password"] if "provisioning_password" in self.data else ""
# if not DEVICE_PROVISIONING_PASSWORD == self.provisioning_password:
# raise Unauthorized()
# Record the installed app version first
self.device = Device.objects.get(uuid=self.data['device'])
version = self.data['version']
self.device.currentVersion = version
self.device.save()
# Record the installed version here
try:
iapp = InstalledApp.objects.get(device__uuid=self.device.uuid)
except:
iapp = InstalledApp.objects.create(device=self.device, version=version)
# Initialize response to no-update
result = {
"version": "0",
"device": self.device,
"pkg": "update.apk",
"checksum": "00000000000000000000000000000000",
}
# Rlay to the file server - uses POST to mimic pchr web app
try:
headers = {
"Authorization": "Bearer " + settings.UPDATE_API_KEY
}
data = {"version":"latest"}
request = urllib.request.Request(
url=settings.UPDATE_URL_VERSION,
headers=headers,
)
response = urllib.request.urlopen(request)
encoding =response.info().get_param('charset') or 'utf-8'
data = json.loads(response.read().decode(encoding))
# load data from file server
result["version"] = data.get("version","0")
result["checksum"] = data.get("checksum", "00000000000000000000000000000000")
result["pkg"] = data.get("pkg","update-error.apk")
except:
pass
return Data(result, should_prepare=False)
class BaseResource(DjangoResource):
DEFAULT_PAGINATOR = 10
dict_filters = {}
preparer = FieldsPreparer(fields={})
def filters(self, request):
items = {}
for key, value in self.request.GET.items():
if key in self.dict_filters:
items[self.dict_filters.get(key)] = value
return items
def is_authenticated(self):
try:
self.token = Token.objects.get(token=self.request.GET.get('token'))
return True
except Token.DoesNotExist:
raise Unauthorized(
msg="Token {0} unauthorized or inexistent".format(
self.request.GET.get('token')))
def serialize_list(self, data):
data = self.paginate(data)
self.meta = data.get('meta')
return super(BaseResource, self).serialize_list(data.get('objects'))
def wrap_list_response(self, data):
return {
'meta': self.meta,
'objects': data,
}
def paginate(self, queryset):
data = dict()
limit = int(self.request.GET.get('limit', self.DEFAULT_PAGINATOR))
self.paginator = Paginator(queryset, limit)
self.page = int(self.request.GET.get('page', 1))
meta = {
'limit': limit,
'next': self.paginator.page(self.page).has_next(),
'previous': self.paginator.page(self.page).has_previous(),
'total_count': self.paginator.count,
'page': self.page,
}
data['meta'] = meta
data['objects'] = self.paginator.page(self.page).object_list
return data
def get_graph_facebook_info(self, facebook_id):
try:
logger.info(
(u"Get Facebook User with ID {0} from Graph API".format(
facebook_id)))
response = requests.get(
'https://graph.facebook.com/' + str(facebook_id) +
'?access_token={0}'.format(settings.FACEBOOK_TOKEN),
timeout=5).json()
logger.info(
(u"Get Facebook User with ID {0} to prepare with success".
format(facebook_id)))
return self.prepare_graph_info(response).value
except:
logger.error(
u"Facebook User with ID {0} not found".format(facebook_id))
raise HttpError(
msg=u"Facebook User with ID {0} not found".format(facebook_id))
@skip_prepare
def prepare_graph_info(self, graph_info):
try:
gender = graph_info['gender']
except:
get_first_name = graph_info['name'].split(' ')[0]
get_gender = requests.get(
'https://api.genderize.io/?name={0}'.format(get_first_name),
timeout=5).json()
gender = get_gender['gender']
return {
'facebook_id': graph_info['id'],
'link': graph_info['link'],
'name': graph_info['name'],
'gender': gender,
}
class UserProfileResource(DjangoResource):
preparer = FieldsPreparer(
fields={
'id': 'pk',
'username': '******',
'email': 'email',
'first_name': 'first_name',
'last_name': 'last_name',
'full_name': 'full_name',
'bio': 'bio',
'phone': 'phone',
'gravatar_url': 'gravatar_url',
'profile_url': 'profile_url',
'is_free': 'is_free',
})
# POST data fields that are accepted
MODIFIABLE_FIELDS = {
'profile': ['phone', 'bio'],
'user': ['email', 'first_name', 'last_name'],
}
# Authenticate if the user is currently logged in
def is_authenticated(self):
return self.request.user.is_authenticated()
# GET /api/users/
# Gets a list of all active users
def list(self):
return UserProfile.objects.filter(user__is_active=True)
# GET /api/users/<pk>/
# Gets info of user with id=pk
# Requested user must be active.
def detail(self, pk):
return UserProfile.objects.get(user__id=pk, user__is_active=True)
# PUT /api/users/<pk>/
# Updates a user's info with id=pk. Assumes specified user exists,
# otherwise error is returned. This is to prevent user creation.
# NOTE: for AJAX calls through jQuery, use JSON.stringify on your data
def update(self, pk):
if self.request.user.id != int(pk):
raise Unauthorized("Not authorized to update "
"another user's profile.")
profile = self.request.user.profile
# Grab and save all modifiable fields from POST data
for category in self.MODIFIABLE_FIELDS:
target = profile
if category == 'user':
target = profile.user
for field in self.MODIFIABLE_FIELDS[category]:
if field in self.data:
setattr(target, field, escape(self.data[field]))
profile.user.save()
profile.save()
return profile
class TeacherAPI(Base):
stu_preparer = FieldsPreparer(fields={"id": 'id', "name": "name"})
preparer = FieldsPreparer(
fields={
'id': 'id',
'name': 'name',
'sex': 'sex',
'mobile': 'mobile',
'qq': 'qq',
'student': CollectionSubPreparer("student", stu_preparer),
'remark': 'remark',
'is_xiaoqugroup': 'is_xiaoqugroup',
'train_records': 'train_records',
'is_xieyi_back': 'is_xieyi_back',
'is_xieyi_send': 'is_xieyi_send',
"is_weixunqun": 'is_weixunqun',
'birth': 'birth',
'is_stay': 'is_stay',
'final_rank': 'final_rank',
'second_rank': 'second_rank',
'second_score': 'second_score',
"first_rank": 'first_rank',
'politic_class_score': 'politic_class_score',
'english_class_score': 'english_class_score',
'pro_class_score': 'pro_class_score',
'first_total': 'first_total',
'study_type': 'study_type',
'study_year': 'study_year',
'join_year': 'join_year',
'passed_type': 'passed_type',
'is_passed': 'is_passed',
'is_wokring': 'is_wokring',
'is_cross_major': 'is_cross_major',
'is_war_more': 'is_war_more',
'school_312': 'school_312',
'fudao_school': 'fudao_school',
'bachelor_major': 'bachelor_major',
'bachelor_school': 'bachelor_school',
'job': 'job',
'bank_name': 'bank_name',
'bank_number': 'bank_number',
'idcard': 'idcard',
'is_zhinanqun': 'is_zhinanqun',
'is_fudaogongzuoqun': 'is_fudaogongzuoqun'
})
def list(self):
return Teacher.objects.filter(
name__icontains=self.request.GET.get('name', ''),
job__icontains=self.request.GET.get('job', ''),
is_stay__icontains=self.request.GET.get('is_stay', ''),
fudao_school__icontains=self.request.GET.get('fudao_school', ''),
is_cross_major__icontains=self.request.GET.get(
'is_cross_major', ''),
is_war_more__icontains=self.request.GET.get('is_war_more', ''),
is_wokring__icontains=self.request.GET.get('is_working', ''),
study_type__icontains=self.request.GET.get('study_type',
'')).order_by('id')
def detail(self, pk):
return Teacher.objects.get(id=pk)
def create(self):
data = self.data
t = Teacher()
t.name = data['name'] if 'name' in data else ''
t.sex = data['sex'] if 'sex' in data else ''
t.qq = data['qq'] if 'qq' in data else ''
t.mobile = data['mobile'] if 'mobile' in data else ''
t.idcard = data['idcard'] if 'idcard' in data else ''
t.bank_number = data['bank_number'] if 'bank_number' in data else ''
t.job = data['job'] if 'job' in data else ''
t.bachelor_school = data[
'bachelor_school'] if 'bachelor_school' in data else ''
t.bachelor_major = data[
'bachelor_major'] if 'bachelor_major' in data else ''
t.fudao_school = data['fudao_school'] if 'fudao_school' in data else ''
t.school_312 = data['school_312'] if 'school_312' in data else ''
t.is_war_more = data['is_war_more'] if 'is_war_more' in data else ''
t.is_cross_major = data[
'is_cross_major'] if 'is_cross_major' in data else ''
t.is_wokring = data['is_wokring'] if 'is_wokring' in data else ''
t.is_passed = data['is_passed'] if 'is_passed' in data else ''
t.passed_type = data['passed_type'] if 'passed_type' in data else ''
t.join_year = data['join_year'] if 'join_year' in data else ''
t.study_year = data['study_year'] if 'study_year' in data else ''
t.study_type = data['study_type'] if 'study_type' in data else ''
t.first_total = data['first_total'] if 'first_total' in data else ''
t.pro_class_score = data[
'pro_class_score'] if 'pro_class_score' in data else ''
t.english_class_score = data[
'english_class_score'] if 'english_class_score' in data else ''
t.politic_class_score = data[
'politic_class_score'] if 'politic_class_score' in data else ''
t.first_rank = data['first_rank'] if 'first_rank' in data else ''
t.second_score = data['second_score'] if 'second_score' in data else ''
t.second_rank = data['second_rank'] if 'second_rank' in data else ''
t.final_rank = data['final_rank'] if 'final_rank' in data else ''
t.is_stay = data['is_stay'] if 'is_stay' in data else ''
t.birth = data['birth'] if 'birth' in data else ''
t.is_zhinanqun = data['is_zhinanqun'] if 'is_zhinanqun' in data else ''
t.is_fudaogongzuoqun = data[
'is_fudaogongzuoqun'] if 'is_fudaogongzuoqun' in data else ''
t.is_weixunqun = data['is_weixunqun'] if 'is_weixunqun' in data else ''
t.is_xieyi_send = data[
'is_xieyi_send'] if 'is_xieyi_send' in data else ''
t.is_xieyi_back = data[
'is_xieyi_back'] if 'is_xieyi_back' in data else ''
t.is_xiaoqugroup = data[
'is_xiaoqugroup'] if 'is_xiaoqugroup' in data else ''
t.train_records = data[
'train_records'] if 'train_records' in data else ''
t.remark = data['remark'] if 'remark' in data else ''
t.save()
return t
def update(self, pk):
t = Teacher.objects.get(id=int(pk))
data = self.data
t.name = data['name'] if 'name' in data else ''
t.sex = data['sex'] if 'sex' in data else ''
t.qq = data['qq'] if 'qq' in data else ''
t.mobile = data['mobile'] if 'mobile' in data else ''
t.idcard = data['idcard'] if 'idcard' in data else ''
t.bank_number = data['bank_number'] if 'bank_number' in data else ''
t.job = data['job'] if 'job' in data else ''
t.bachelor_school = data[
'bachelor_school'] if 'bachelor_school' in data else ''
t.bachelor_major = data[
'bachelor_major'] if 'bachelor_major' in data else ''
t.fudao_school = data['fudao_school'] if 'fudao_school' in data else ''
t.school_312 = data['school_312'] if 'school_312' in data else ''
t.is_war_more = data['is_war_more'] if 'is_war_more' in data else ''
t.is_cross_major = data[
'is_cross_major'] if 'is_cross_major' in data else ''
t.is_wokring = data['is_wokring'] if 'is_wokring' in data else ''
t.is_passed = data['is_passed'] if 'is_passed' in data else ''
t.passed_type = data['passed_type'] if 'passed_type' in data else ''
t.join_year = data['join_year'] if 'join_year' in data else ''
t.study_year = data['study_year'] if 'study_year' in data else ''
t.study_type = data['study_type'] if 'study_type' in data else ''
t.first_total = data['first_total'] if 'first_total' in data else ''
t.pro_class_score = data[
'pro_class_score'] if 'pro_class_score' in data else ''
t.english_class_score = data[
'english_class_score'] if 'english_class_score' in data else ''
t.politic_class_score = data[
'politic_class_score'] if 'politic_class_score' in data else ''
t.first_rank = data['first_rank'] if 'first_rank' in data else ''
t.second_score = data['second_score'] if 'second_score' in data else ''
t.second_rank = data['second_rank'] if 'second_rank' in data else ''
t.final_rank = data['final_rank'] if 'final_rank' in data else ''
t.is_stay = data['is_stay'] if 'is_stay' in data else ''
t.birth = data['birth'] if 'birth' in data else ''
t.is_zhinanqun = data['is_zhinanqun'] if 'is_zhinanqun' in data else ''
t.is_fudaogongzuoqun = data[
'is_fudaogongzuoqun'] if 'is_fudaogongzuoqun' in data else ''
t.is_weixunqun = data['is_weixunqun'] if 'is_weixunqun' in data else ''
t.is_xieyi_send = data[
'is_xieyi_send'] if 'is_xieyi_send' in data else ''
t.is_xieyi_back = data[
'is_xieyi_back'] if 'is_xieyi_back' in data else ''
t.is_xiaoqugroup = data[
'is_xiaoqugroup'] if 'is_xiaoqugroup' in data else ''
t.train_records = data[
'train_records'] if 'train_records' in data else ''
t.remark = data['remark'] if 'remark' in data else ''
t.save()
return t
def delete(self, pk):
Teacher.objects.get(id=pk).delete()
class DjTestResource(DjangoResource):
preparer = FieldsPreparer(fields={
'id': 'id',
'title': 'title',
'author': 'username',
'body': 'content'
})
fake_db = []
def __init__(self, *args, **kwargs):
super(DjTestResource, self).__init__(*args, **kwargs)
self.http_methods.update({'schema': {
'GET': 'schema',
}})
def fake_init(self):
# Just for testing.
self.__class__.fake_db = [
FakeModel(id=2,
title='First post',
username='******',
content='Hello world!'),
FakeModel(id=4,
title='Another',
username='******',
content='Stuff here.'),
FakeModel(id=5, title='Last', username='******', content="G'bye!"),
]
def is_authenticated(self):
if self.request_method() == 'DELETE':
return False
return True
def list(self):
return self.fake_db
def detail(self, pk):
for item in self.fake_db:
if item.id == pk:
return item
# If it wasn't found in our fake DB, raise a Django-esque exception.
raise ObjectDoesNotExist("Model with pk {0} not found.".format(pk))
def create(self):
self.fake_db.append(FakeModel(**self.data))
def update(self, pk):
for item in self.fake_db:
if item.id == pk:
for k, v in self.data:
setattr(item, k, v)
return
def create_detail(self):
raise ValueError("This is a random & crazy exception.")
@skip_prepare
def schema(self):
# A WILD SCHEMA VIEW APPEARS!
return {
'fields': {
'id': {
'type': 'integer',
'required': True,
'help_text': 'The unique id for the post',
},
'title': {
'type': 'string',
'required': True,
'help_text': "The post's title",
},
'author': {
'type': 'string',
'required': True,
'help_text': 'The username of the author of the post',
},
'body': {
'type': 'string',
'required': False,
'default': '',
'help_text': 'The content of the post',
}
},
'format': 'application/json',
'allowed_list_http_methods': ['GET', 'POST'],
'allowed_detail_http_methods': ['GET', 'PUT', 'DELETE'],
}
from restless.preparers import FieldsPreparer
REPORT = {
"destination": "destination",
"call_start_date": "call_start_date",
"call_start_time": "call_start_time",
"call_duration": "call_duration",
"call_duration": "call_duration",
"price": "price_label",
}
REPORT_PREPARER = FieldsPreparer(fields=REPORT)
class ApprovalResource(DjangoResource):
preparer = FieldsPreparer(fields={
'id': 'id',
'created_date': 'created_date',
'requester': 'requester.email',
'approver': 'approver.email',
'proposal_url': 'proposal_url',
'proposal_desc': 'proposal_desc',
'confirmed_date': 'confirmed_date',
})
def is_authenticated(self):
return self.request.user.is_authenticated()
def list(self):
return Approval.objects.all()
def detail(self, pk):
return Approval.objects.get(pk=pk)
def create(self):
"""POST request requires approver (email), proposal_url and/or
proposal_desc parameters.
"""
if 'approver' not in self.data:
raise BadRequest('Missing parameter: approver')
requester = DepartmentUser.objects.get(email__iexact=self.request.user.email)
approver = DepartmentUser.objects.get(email__iexact=self.data['approver'])
self.data['approver'] = approver.pk # ModelForm requires an approver by PK, not email.
form = ApprovalForm(self.data)
if not form.is_valid():
raise BadRequest(form.errors.as_json())
return Approval.objects.create(
requester=requester,
approver=approver,
proposal_url=form.cleaned_data['proposal_url'],
proposal_desc=form.cleaned_data['proposal_desc']
)
def update(self, pk):
"""PUT request should only change confirmed_date when a matching guid
is provided.
"""
if 'guid' not in self.data:
raise BadRequest('Missing parameter: guid')
try:
approval = Approval.objects.get(pk=pk)
except Approval.DoesNotExist:
raise BadRequest('Approval not found')
if approval.confirmed_date:
raise BadRequest('Approval is already confirmed')
# Disallow anyone but the approver from confirming a request.
elif self.request.user.email.lower() != approval.approver.email.lower():
raise BadRequest('Only {} may confirm the approval request'.format(approval.approver))
elif self.data['guid'] != str(approval.guid):
raise BadRequest('Incorrect GUID')
approval.confirmed_date = datetime.now()
approval.save()
return approval
def test_prepare_simple(self):
preparer = FieldsPreparer(fields={
'flying': 'say',
})
preped = preparer.prepare(self.obj_data)
self.assertEqual(preped, {'flying': 'what'})
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
class SchoolExamResource(Base):
# Controls what data is included in the serialized output.
exam_preparer = FieldsPreparer(fields={
'id': 'id',
'name': 'time',
'total': 'total',
'desc': 'desc'
})
teacher_preparer = FieldsPreparer(fields={
'id': 'id',
})
preparer = FieldsPreparer(
fields={
'id': 'id',
'exam_id': 'exam.id',
'exam_time': 'exam.time',
'exam_desc': 'exam.desc',
'exam_total': 'exam.total',
"school_id": 'school.id',
'school_name': 'school.name',
'total': 'total',
'status': 'status',
'lock2': 'lock2'
})
def is_authenticated(self):
return True
# GET /
def list(self):
if 'school_id' in self.request.GET:
id = int(self.request.GET['school_id'])
school = School.objects.get(id=id)
return Schoolexam.objects.filter(school=school)
if 'exam_id' in self.request.GET:
id = int(self.request.GET['exam_id'])
exam = Exam.objects.get(id=id)
return Schoolexam.objects.filter(
exam=exam,
school__name__contains=self.request.GET.get('search', ''))
return Schoolexam.objects.all()
# GET /pk/
def detail(self, pk):
return Schoolexam.objects.get(id=pk)
# POST /
def create(self):
exam = Exam.objects.get(id=int(self.data['exam_id']))
if exam.lock:
return
return Schoolexam.objects.create(
exam=Exam.objects.get(id=int(self.data['exam_id'])),
school=School.objects.get(id=int(self.data['school_id'])),
total=self.data['total'])
# PUT /pk/
def update(self, pk):
schoolexam = Schoolexam.objects.get(id=pk)
exam = schoolexam.exam
if exam.lock:
return schoolexam
schoolexam.total = self.data[
'total'] if 'total' in self.data else schoolexam.total
schoolexam.lock2 = self.data[
'lock2'] if 'lock2' in self.data else schoolexam.lock2
schoolexam.save()
return schoolexam
# DELETE /pk/
def delete(self, pk):
schoolexam = Schoolexam.objects.get(id=pk)
exam = schoolexam.exam
if exam.lock:
return schoolexam
return Schoolexam.objects.get(id=pk).delete()
