def deleteStudent(self, student_id):
''' Delete student entity given student id'''
try:
response = ""
# Create a key for given student id
s_key = ndb.Key(Student, student_id)
# Fetching student entity
#student = Student.get_by_id(student_id)
#print ("Student Record to be deleted = ", student)
if s_key.get():
# check if the student is enrolled in a course or not.
query = Enrollment.query(Enrollment.student == s_key)
if query.get():
# cannot delete student without deleting his enrollments
response = R_DEP_ERR_DELCHILD.format(
"Enrollments", "Student")
else:
# deleting the entity with a given student id
s_key.delete()
response = R_SUCC_DEL.format("Student", str(s_key))
else:
response = R_SERV_ERR.format(
"Unable to retrieve Student entity")
except Exception, e:
response = R_SERV_ERR.format(str(e))
def deleteDept(self, dept_id):
''' delete department given department ID. delete in the order Schedule, Student and Course first'''
# Enhancement. Deleting entity using other details like department name
try:
# Creating the key for given department id
d_key = ndb.Key(Department, int(dept_id))
# Fetching and deleting the entity
dept = Department.get_by_id(dept_id)
''' Dependencies'''
# check if department exists in Student kind
st_query = Student.query(Student.department == d_key)
co_query = Course.query(Course.department == d_key)
sch_query = Schedule.query(Schedule.department == d_key)
if sch_query.get():
# entity found in Schedule. Invoke Dependency error
response = R_DEP_ERR_DELCHILD.format("Schedule", "Department")
elif st_query.get():
# entity found in Student. Invoke Dependency error
response = R_DEP_ERR_DELCHILD.format("Student", "Department")
elif co_query.get():
# entity found in Course. Invoke Dependency error
response = R_DEP_ERR_DELCHILD.format("Course", "Department")
else:
# no dependencies found. delete department
d_key.delete()
response = R_SUCC_DEL.format("Department", str(d_key))
except Exception, e:
response = R_SERV_ERR.format(str(e))
def deleteDept1(self, dept_id):
''' delete entity from department'''
dept_key = ndb.Key(Department, dept_id)
'''Check whether dept data is found in other dependent kinds before deleting'''
dept_key.delete()
return R_SUCC_DEL.format("Department", str(dept_id))
def upsertSchedule(self, year, quarter, d_key, course_id):
''' insert or update Schedule entity'''
schedule = Schedule(year=year,
quarter=quarter,
department=d_key,
course=ndb.Key(Course, course_id))
#print("Inserted the course under dept = ", d_key.get().name)
sch_key = schedule.put()
return R_SUCC_INSERT.format("Schedule", str(sch_key))
def post(self):
insert = self.request.get('insert')
delete = self.request.get('delete')
"""edit = self.request.get('edit')
save = self.request.get('save')"""
if (insert):
''' insert button was pressed'''
# insert
response = self.insertEnrollment(self.request)
# render main page
self.render_enrollments(error=response)
elif (delete):
''' delete button was pressed'''
response = ""
# check if atleast one checkbox checked
delCheck = self.request.get('deleteCheck', allow_multiple=True)
# call delete method
if (delCheck):
for e_key in delCheck:
e_key = ndb.Key(urlsafe=e_key)
#e_key = record['e_key']
response = response + self.deleteEnrollment(
e_key.get()) + "\n"
else:
response = R_CBOX_INP_ERR
# if not checked return error message
self.render_enrollments(error=response)
"""
elif(edit):
''' edit button was pressed'''
# read all input
# check if required fields are populated
# validate inputs
# call upsert method
# render the main page
self.response.out.write('To edit!')
elif(save):
''' save button was pressed from the edit html page'''
# read ID from radio button
# check if one radio is selected or not
# render edit page
# if none selected return error message and render main
self.response.out.write('To save!')
"""
#[END Handlers]
def upsertCourse(self, course_id, name, dept_id, instructor, time, place):
''' insert or update course entity'''
course = Course(id=course_id,
course_id=course_id,
name=name,
department=ndb.Key(Department, dept_id),
instructor=instructor,
time=time,
place=place)
course_key = course.put()
return course_key
def insertSchedule(self, request):
''' insert a course schedule for given quarter. Require course ID, quarter and year.'''
response = ""
# read all inputs
course_id = request.get('course_id')
year = request.get('year')
quarter = request.get('quarter')
# check if required fields are not blank
if (course_id and year and quarter):
# validate inputs
if (is_int(course_id) and is_int(year) and is_int(quarter)):
course_id = int(course_id)
year = int(year)
quarter = int(quarter)
# validate inputs continued
# Get current year
# Year needs to be prev, curr and next year
if (self.validate_year(year)
and self.validate_quarter(quarter)):
# Validate course id
c_key = ndb.Key(Course, course_id)
# Check if entity exists
if c_key.get():
# fetch the respective dept for that course id
d_key = c_key.get().department
# check for duplicate entries
query = Schedule.query(Schedule.course == c_key,
Schedule.quarter == quarter,
Schedule.year == year)
if (not query.get()):
# insert schedule
response = self.upsertSchedule(year=year,
quarter=quarter,
d_key=d_key,
course_id=course_id)
else:
response = R_DUP_ID_ERR.format("Schedule")
else:
response = R_DEP_ERR_INVCOUR
else:
response = R_PROP_VAL_ERR.format(
"Year and Quarter",
"integers of values (previous year, current year and next year) and range(1-4) respectively"
)
else:
response = R_ID_VAL_ERR.format(
"Course ID and Year and Quarter")
else:
response = R_REQ_FIELD_ERR.format("Course ID and Year and Quarter")
return response
def upsertStudent(self, student_id, name, dept_id, phone_number, address):
''' insert or update Student entity'''
student = Student(id=student_id,
student_id=student_id,
name=name,
address=address,
phone_number=phone_number,
department=ndb.Key(Department, dept_id))
#print("Inserting a new record into the datastore",student.put())
s_key = student.put()
return R_SUCC_INSERT.format("Student", str(s_key))
def company_list_favorite(self, query):
# list of companies with favorite boolean attached to favorites
user = endpoints.get_current_user()
for company in query:
company.favorite = False
key = ndb.Key(urlsafe=company.entityKey)
favQuery = Favorite.query(
ancestor=main.get_parent_key(user)).filter(
Favorite.company_entity_key == key)
for favorite in favQuery:
company.favorite = True
return query
def deleteCourse(self, course_id):
'''Delete a course given course ID. Delete course from Schedule first.'''
try:
response = ""
# Creating the key for given course id
c_key = ndb.Key(Course, course_id)
# Check if course exists
if c_key.get():
'''Dependency Check'''
# Check if course exists in schedule
query = Schedule.query(Schedule.course == c_key)
if query.get():
# course exists in schedule. Invoke dependency error
response = R_DEP_ERR_DELCHILD.format("Schedule", "Course")
else:
# Fetching and deleting the entity with given course_id
c_key.delete()
response = R_SUCC_DEL.format("Course", str(c_key))
except Exception, e:
response = R_SERV_ERR.format(str(e))
def company_insert_favorite(self, request):
user = endpoints.get_current_user()
favBool = request.favorite
key = ndb.Key(urlsafe=request.entityKey)
query_favorite = Favorite.query(
ancestor=main.get_parent_key(user)).filter(
Favorite.company_entity_key == key)
my_favorite = Favorite(parent=main.get_parent_key(user),
company_entity_key=key)
found = False
logging.info(favBool)
for item in query_favorite:
logging.info("favorite logged")
my_favorite = item
found = True
logging.info(my_favorite)
if favBool:
logging.info("favorite bool = True")
if not found:
logging.info("creating favorite")
# my_favorite = Favorite(parent=main.get_parent_key(user), company_entity_key=key)
my_favorite.put()
else:
if found:
logging.info("delete")
my_favorite.key.delete()
return request
def getDepartment(self, dept_id):
''' get department entity given department ID'''
dept_key = ndb.Key(Department, dept_id)
return dept_key.get()
def insertEnrollment(self, request):
''' Enrollment a student for a course in a given quarter'''
response = ""
# read all input variables
student_id = request.get('student_id')
course_id = request.get('course_id')
year = request.get('year')
quarter = request.get('quarter')
# check for required fields
if (student_id and course_id and year and quarter):
# validate inputs
if (is_int(student_id) and is_int(course_id)):
if (is_int(year) and is_int(quarter)):
student_id = int(student_id)
course_id = int(course_id)
year = int(year)
quarter = int(quarter)
# validate all the Referential properties
s_key = ndb.Key(Student, student_id)
student = s_key.get()
c_key = ndb.Key(Course, course_id)
# retrieve schedule id from schedule
query = self.getSchedule(c_key, quarter, year)
schedule = query.get()
# Check if schedule exists
if schedule:
#schedule_key = schedule.key
# query for existing enrollment. if student id and schedule id exists, duplicate entry
query = self.getEnrollment(s_key, schedule.key)
enrollment = query.get()
# check if enrollment exists already
if not enrollment:
# validate student ID
if student:
# insert enrollment
enrollment = Enrollment(student=s_key,
schedule=schedule.key)
e_key = enrollment.put()
# add course to student study lists
student.study_lists.append(c_key)
student.put()
response = R_SUCC_INSERT.format(
"Enrollments", str(e_key))
else:
# in valid student ID
response = R_DEP_ERR_INVST
else:
# enrollment already exists
response = R_DUP_ID_ERR.format("Enrollment")
else:
response = R_INV_ID_ERR.format("Enrollments")
else:
response = R_PROP_VAL_ERR.format(
"Year and Quarter",
"integers of values (previous year, current year and next year) and range(1-4)"
)
else:
response = R_ID_VAL_ERR.format("Student and Course")
else:
response = R_REQ_FIELD_ERR.format(
"Student ID, Course ID, Year and Quarter")
return response
def post(self):
insert = self.request.get('insert')
delete = self.request.get('delete')
edit = self.request.get('edit')
save = self.request.get('save')
if (insert):
''' insert button was pressed'''
# insert
response = self.insertSchedule(self.request)
# render main page
self.render_schedule(error=response)
elif (delete):
''' delete button was pressed'''
response = ""
# check if atleast one checkbox checked
delCheck = self.request.get('deleteCheck', allow_multiple=True)
if (delCheck):
# call delete method
for sch in delCheck:
# get ndb model key from urlsafe string
sch_key = ndb.Key(urlsafe=sch)
response = response + self.deleteSchedule(
sch_key.get()) + "\n"
# if not checked return error message
else:
response = R_CBOX_INP_ERR
self.render_schedule(error=response)
elif (edit):
''' edit button was pressed'''
# read ID from radio button
sch = self.request.get('editRadio')
# check if one radio is selected or not
if (sch):
# get key from url safe key string
sch_key = ndb.Key(urlsafe=sch)
# render edit page
self.render_edit(schedule=sch_key.get())
# if none selected return error message and render main
else:
response = R_RAD_INP_ERR
self.render_schedule(error=response)
elif (save):
''' save button was pressed from the edit html page'''
response = ""
# read all input
year = self.request.get('year')
quarter = self.request.get('quarter')
sch_key = ndb.Key(urlsafe=self.request.get('sch_key'))
# check if required fields are not blank
if (year and quarter):
#validate inputs
if (is_int(year) and self.validate_year(year)
and is_int(quarter)
and self.validate_quarter(quarter)):
schedule = sch_key.get()
# update fields
schedule.year = int(year)
schedule.quarter = int(quarter)
# store back to datastore
schedule.put()
response = R_SUCC_UPD.format("Schedule", str(sch_key))
else:
response = R_PROP_VAL_ERR.format(
"Year and Quarter",
"integers of values (previous year, current year and next year) and range(1-4) respectively"
)
else:
response = R_REQ_FIELD_ERR.format("Year and Quarter")
'''
course_id = self.request.get('course_id')
# check if required fields are populated
if(year and quarter and course_id):
# validate inputs
if(is_int(course_id) and is_int(year) and is_int(quarter)):
course_id = int(course_id)
year = int(year)
quarter = int(quarter)
if(year in range(1900, 2017) and quarter in [1,2,3,4]):
# get dept Id for the given course ID
c_key = ndb.Key(Course, course_id)
d_key = c_key.get().department
# call upsert method
response = self.upsertSchedule(year=year, quarter=quarter, d_key = d_key, course_id = course_id)
else:
response = R_PROP_VAL_ERR.format("Year and Quarter", "integers of value between (1900-2017) and (1-4) respectively")
else:
response = R_ID_VAL_ERR.format("Year and Quarter and Course ID")
else:
response = R_REQ_FIELD_ERR.format("Year and Quarter and Course ID")
'''
# render the main page
#self.response.out.write('To save!')
self.render_schedule(error=response)
def getCourse(self, course_id):
''' return course entity given ID'''
c_key = ndb.Key(Course, course_id)
return c_key.get()
def getDepartment(self, dept_id):
''' get department ndb record given a id'''
d_key = ndb.Key(Department, dept_id)
return d_key.get()
def getStudent(self, student_id):
''' get student entity given ID'''
s_key = ndb.Key(Student, student_id)
return s_key.get()
