def deleteDept(self, request):
        ''' 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(request.id))
            # Fetching and deleting the entity
            dept = Department.get_by_id(request.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 = STORED_RESPONSES.items[DEP_ERR_DEPT_SCH_ID]
            elif st_query.get():
                # entity found in Student. Invoke Dependency error
                response = STORED_RESPONSES.items[DEP_ERR_DEPT_ST_ID]
            elif co_query.get():
                # entity found in Course. Invoke Dependency error
                response = STORED_RESPONSES.items[DEP_ERR_DEPT_CO_ID]
            else:
                # no dependencies found. delete department
                print("Department to be deleted = ", dept)
                d_key.delete()
                response = STORED_RESPONSES.items[DELETE_ID]
            return response

        except:
            raise endpoints.EndpointsErrorMessage(
                "Unable to delete entity. Please try again later!")
Exemple #2
0
    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 view_dept_courses(self, request):
     ''' Allows user to list courses a department provides in a specific quarter'''
     d_key = ndb.Key(Department, request.department_id)
     query = Schedule.query(Schedule.department == d_key,
                            Schedule.quarter == request.quarter,
                            Schedule.year == request.year)
     print("view_dept_courses method: converting query to messages")
     return self.queryToCoursesMessage(query)
Exemple #4
0
    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 deleteSchedule(self, request):
        ''' delete a schedule given course ID quarter and year'''
        try:
            # Get Course id
            c_key = ndb.Key(Course, int(request.course_id))
            print("deleteSchedule Method: Going to query object")
            # Get schedule id from given year, quarter and course
            query = Schedule.query(Schedule.course == c_key,
                                   Schedule.quarter == request.quarter,
                                   Schedule.year == request.year)
            print("deleteSchedule method: After query = ", query)
            schedule = query.get()
            if schedule:
                print("deleteSchedule method: schedule -", schedule.key,
                      " exists for course key = ", c_key)
                # delete all enrollments for that schedule
                query = Enrollment.query(
                    Enrollment.schedule ==
                    schedule.key)  #ndb.Key(Schedule, schedule.id))
                for enrollment in query.fetch():
                    print("deleteSchedule Method: Fetching query = ",
                          enrollment)
                    # delete course from Student model
                    student = enrollment.student.get()
                    print("===========Student list for course========",
                          student)
                    if (c_key in student.study_lists):
                        student.study_lists.remove(c_key)
                        # update student entity
                        student.put()
                        print(
                            "deleteSchedule method: course not in student list"
                        )
                    print(
                        "deleteSchedule method: Going to delete enrollment with Key = ",
                        enrollment.key)
                    # delete enrollment
                    #enrollment = q.get()
                    #ndb.Key(Enrollment, enrollment.id).delete()
                    enrollment.key.delete()
                    print(
                        "deleteSchedule method: deleted enrollment successfully"
                    )
                    #ndb.Key(Enrollment, q.id).delete()
                # delete schedule
                schedule.key.delete()
        except:
            raise endpoints.EndpointsErrorMessage(
                'Error while deleting a schedule.')

        return STORED_RESPONSES.items[DELETE_ID]
 def view_students_in_course(self, request):
     ''' List students enrolled in a course'''
     # fetch schedule ids containing the course listed
     c_key = ndb.Key(Course, request.course_id)
     query = Schedule.query(Schedule.course == c_key)
     schedule_keys = []
     for key in query.iter(keys_only=True):
         schedule_keys.append(key)
     # query for enrollments with matching schedule_keys
     query = Enrollment.query(Enrollment.schedule.IN(schedule_keys))
     print(
         "view_students_in_course method: going to convert query to student names message"
     )
     return self.enrollmentToStudentsMessage(query)
Exemple #7
0
 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 insertSchedule(self, request):
        ''' insert a course schedule for given quarter. Require course ID, quarter and year.'''
        response = ""
        # Validate course id
        c_key = ndb.Key(Course, request.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 == request.quarter,
                                   Schedule.year == request.year)
            if not query.get():
                # insert schedule
                response = self.upsertSchedule(request, d_key, ADD_ID)
            else:
                response = STORED_RESPONSES.items[DUPLICATE_ID]
        else:
            response = STORED_RESPONSES.items[INV_COURSE_ID]
        return response
 def deleteCourse(self, request):
     '''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, request.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 = STORED_RESPONSES.items[DEP_ERR_COURSE_ID]
             else:
                 # Fetching and deleting the entity with given course_id
                 c_key.delete()
                 response = STORED_RESPONSES.items[DELETE_ID]
         return response
     except:
         raise endpoints.EndpointsErrorMessage(
             'Unable to delete course entity. Please try again later. ')
Exemple #10
0
 def getSchedule(self, course_key, quarter, year):
     return Schedule.query(Schedule.course == course_key,
                           Schedule.quarter == quarter,
                           Schedule.year == year)