class Term(db.Model): __tablename__ = 'terms' id = db.Column(db.Integer, primary_key=True, autoincrement=True, index=True) name = db.Column(db.String(16)) begin_time = db.Column(db.TIMESTAMP) end_time = db.Column(db.TIMESTAMP) using = db.Column(db.Boolean, default=True) @classmethod def formatter(cls, term): if term is None: return None term_dict = { 'name': term.name, 'begin_time': str(term.begin_time), 'end_time': str(term.end_time) } return term_dict @classmethod def reformatter_insert(cls, data): name = data.get('name', None) if name is None: raise CustomError(500, 200, 'name must be given') parts = name.split('-') if len(parts) != 3: raise CustomError(500, 200, 'name is wrong') year = int(parts[0]) term_num = int(parts[2]) if term_num == 1: begin_year = year end_year = year begin_date = '08-01' end_date = '02-15' else: begin_year = year end_year = year + 1 begin_date = '02-15' end_date = '08-01' data['begin_time'] = convert_string_to_date( str(begin_year) + '-' + begin_date) data['end_time'] = convert_string_to_date( str(end_year) + '-' + end_date) return data @classmethod def reformatter_update(cls, data): return data @classmethod def count(cls, query_dict: dict, unscoped: bool = False): if query_dict is None: query_dict = {} query = Term.query if not unscoped: query = query.filter(Term.using == True) url_condition = UrlCondition(query_dict) try: total = count_query(query, url_condition.filter_dict, url_condition.sort_limit_dict, Term) except Exception as e: raise CustomError(500, 500, str(e)) return total @classmethod def query_terms(cls, query_dict: dict = None, unscoped: bool = False): if query_dict is None: query_dict = dict() url_condition = UrlCondition(query_dict) query = Term.query if not unscoped: query = query.filter(Term.using == True) if 'time' in query_dict: query = query.filter(Term.begin_time < query_dict['time']).filter( Term.end_time >= query_dict['time']) try: query = process_query(query, url_condition.filter_dict, url_condition.sort_limit_dict, Term) (terms, total) = page_query(query, url_condition.page_dict) except Exception as e: raise CustomError(500, 500, str(e)) return [cls.formatter(term) for term in terms], total @classmethod def get_term(cls, term_name: str, unscoped: bool = False): term = Term.query if not unscoped: term = term.filter(Term.using == True) try: term = term.filter(Term.name == term_name).first() except Exception as e: raise CustomError(500, 500, str(e)) return cls.formatter(term) @classmethod def insert_term(cls, ctx: bool = True, data: dict = None): if data is None: data = {} data = cls.reformatter_insert(data) term = Term() for key, value in data.items(): if hasattr(term, key): setattr(term, key, value) db.session.add(term) if ctx: try: db.session.commit() except Exception as e: raise CustomError(500, 500, str(e)) return True
class LessonCase(db.Model): __tablename__ = 'lesson_cases' id = db.Column(db.Integer, primary_key=True, autoincrement=True, index=True) lesson_id = db.Column(db.Integer, default=-1) lesson_room = db.Column(db.String(48), default='') lesson_weekday = db.Column(db.Integer, default=0) lesson_week = db.Column(db.String(48), default='') lesson_time = db.Column(db.String(48), default='') lesson_date = db.Column(db.Date, default=datetime.now) using = db.Column(db.Boolean, default=True) @classmethod def formatter(cls, lesson_case): if lesson_case is None: return None lesson_case_dict = { 'lesson_week': lesson_case.lesson_week, 'lesson_time': str(lesson_case.lesson_time), 'lesson_date': str(lesson_case.lesson_date.strftime('%Y-%m-%d')), 'lesson_weekday': lesson_case.lesson_weekday, 'lesson_room': lesson_case.lesson_room } return lesson_case_dict @classmethod def reformatter_insert(cls, data: dict): return data @classmethod def reformatter_update(cls, data: dict): return data @classmethod def count(cls, query_dict: dict, unscoped: bool = False): if query_dict is None: query_dict = {} query = LessonCase.query if not unscoped: query = query.filter(LessonCase.using == True) url_condition = UrlCondition(query_dict) try: total = count_query(query, url_condition.filter_dict, url_condition.sort_limit_dict, LessonCase) except Exception as e: raise CustomError(500, 500, str(e)) return total @classmethod def get_lesson_case(cls, query_dict: dict, unscoped: bool = False): lesson_case = LessonCase.query if not unscoped: lesson_case = lesson_case.filter(LessonCase.using == True) url_condition = UrlCondition(query_dict) try: lesson_case = process_query(lesson_case, url_condition.filter_dict, url_condition.sort_limit_dict, LessonCase).first() except Exception as e: raise CustomError(500, 500, str(e)) return cls.formatter(lesson_case) @classmethod def insert_lesson_case(cls, ctx: bool = True, data: dict = None): if data is None: data = {} data = cls.reformatter_insert(data) lesson_case = LessonCase() for key, value in data.items(): if hasattr(lesson_case, key): setattr(lesson_case, key, value) db.session.add(lesson_case) if ctx: try: db.session.commit() except Exception as e: raise CustomError(500, 500, str(e)) return True @classmethod def query_lesson_cases(cls, query_dict: dict = None, unscoped: bool = False): if query_dict is None: query_dict = {} query = LessonCase.query if not unscoped: query = query.filter(LessonCase.using == True) url_condition = UrlCondition(query_dict) try: query = process_query(query, url_condition.filter_dict, url_condition.sort_limit_dict, LessonCase) (lesson_cases, total) = page_query(query, url_condition.page_dict) except Exception as e: raise CustomError(500, 500, str(e)) return [cls.formatter(lesson_case) for lesson_case in lesson_cases], total @classmethod def delete_lesson_case(cls, ctx: bool = True, query_dict: dict = None): if query_dict is None: query_dict = {} query = LessonCase.query.filter(LessonCase.using == True) url_condition = UrlCondition(query_dict) try: query = process_query(query, url_condition.filter_dict, url_condition.sort_limit_dict, LessonCase) (lesson_cases, total) = page_query(query, url_condition.page_dict) except Exception as e: raise CustomError(500, 500, str(e)) for lesson_case in lesson_cases: lesson_case.using = False db.session.add(lesson_case) if ctx: try: db.session.commit() except Exception as e: raise CustomError(500, 500, str(e)) return True @classmethod def update_lesson_case(cls, ctx: bool = True, query_dict: dict = None, data: dict = None): if data is None: data = {} if query_dict is None: query_dict = {} data = cls.reformatter_update(data) query = LessonCase.query.filter(LessonCase.using == True) url_condition = UrlCondition(query_dict) try: query = process_query(query, url_condition.filter_dict, url_condition.sort_limit_dict, LessonCase) (lesson_cases, total) = page_query(query, url_condition.page_dict) except Exception as e: raise CustomError(500, 500, str(e)) for lesson_case in lesson_cases: for key, value in data.items(): if hasattr(lesson_case, key): setattr(lesson_case, key, value) db.session.add(lesson_case) if ctx: try: db.session.commit() except Exception as e: raise CustomError(500, 500, str(e)) return True
class NoticeLesson(db.Model): __tablename__ = 'notice_lessons' id = db.Column(db.Integer, primary_key=True, autoincrement=True, index=True) lesson_id = db.Column(db.String(32), default=-1) group_name = db.Column(db.String(32), default='') term = db.Column(db.String(32), default='') lesson_attention_reason = db.Column(db.String(128), default='') using = db.Column(db.Boolean, default=True) @classmethod def formatter(cls, notice_lesson): if notice_lesson is None: return None notice_lesson_dict = { 'id': notice_lesson.id, 'lesson_id': notice_lesson.lesson_id, 'lesson_attention_reason': notice_lesson.lesson_attention_reason, 'group_name': notice_lesson.group_name } return notice_lesson_dict @classmethod def reformatter_insert(cls, data: dict): return data @classmethod def reformatter_update(cls, data: dict): return data @classmethod def count(cls, query_dict: dict, unscoped: bool = False): if query_dict is None: query_dict = {} query = NoticeLesson.query if not unscoped: query = query.filter(NoticeLesson.using == True) url_condition = UrlCondition(query_dict) try: total = count_query(query, url_condition.filter_dict, url_condition.sort_limit_dict, NoticeLesson) except Exception as e: raise CustomError(500, 500, str(e)) return total @classmethod def get_notice_lesson(cls, query_dict: dict, unscoped: bool = False): notice_lesson = NoticeLesson.query if not unscoped: notice_lesson = notice_lesson.filter(NoticeLesson.using == True) url_condition = UrlCondition(query_dict) try: notice_lesson = process_query(notice_lesson, url_condition.filter_dict, url_condition.sort_limit_dict, NoticeLesson).first() except Exception as e: raise CustomError(500, 500, str(e)) return cls.formatter(notice_lesson) @classmethod def insert_notice_lesson(cls, ctx: bool = True, data: dict = None): if data is None: data = {} data = cls.reformatter_insert(data) notice_lesson = NoticeLesson() for key, value in data.items(): if hasattr(notice_lesson, key): setattr(notice_lesson, key, value) db.session.add(notice_lesson) if ctx: try: db.session.commit() except Exception as e: raise CustomError(500, 500, str(e)) return True @classmethod def query_notice_lessons(cls, query_dict: dict = None, unscoped: bool = False): if query_dict is None: query_dict = {} query = NoticeLesson.query if not unscoped: query = query.filter(NoticeLesson.using == True) url_condition = UrlCondition(query_dict) try: query = process_query(query, url_condition.filter_dict, url_condition.sort_limit_dict, NoticeLesson) (notice_lessons, total) = page_query(query, url_condition.page_dict) except Exception as e: raise CustomError(500, 500, str(e)) return [ cls.formatter(notice_lesson) for notice_lesson in notice_lessons ], total @classmethod def delete_notice_lesson(cls, ctx: bool = True, query_dict: dict = None): if query_dict is None: query_dict = {} query = NoticeLesson.query.filter(NoticeLesson.using == True) url_condition = UrlCondition(query_dict) try: query = process_query(query, url_condition.filter_dict, url_condition.sort_limit_dict, NoticeLesson) (notice_lessons, total) = page_query(query, url_condition.page_dict) except Exception as e: raise CustomError(500, 500, str(e)) for notice_lesson in notice_lessons: notice_lesson.using = False db.session.add(notice_lesson) if ctx: try: db.session.commit() except Exception as e: raise CustomError(500, 500, str(e)) return True @classmethod def update_notice_lesson(cls, ctx: bool = True, query_dict: dict = None, data: dict = None): if data is None: data = {} if query_dict is None: query_dict = {} data = cls.reformatter_update(data) query = NoticeLesson.query.filter(NoticeLesson.using == True) url_condition = UrlCondition(query_dict) try: query = process_query(query, url_condition.filter_dict, url_condition.sort_limit_dict, NoticeLesson) (notice_lessons, total) = page_query(query, url_condition.page_dict) except Exception as e: raise CustomError(500, 500, str(e)) for notice_lesson in notice_lessons: for key, value in data.items(): if hasattr(notice_lesson, key): setattr(notice_lesson, key, value) db.session.add(notice_lesson) if ctx: try: db.session.commit() except Exception as e: raise CustomError(500, 500, str(e)) return True
class LessonRecord(db.Model): __tablename__ = 'lesson_records' id = db.Column(db.Integer, primary_key=True, autoincrement=True, index=True) term = db.Column(db.String(32), default='') username = db.Column(db.String(64), nullable=False) name = db.Column(db.String(64), nullable=False) group_name = db.Column(db.String(64), nullable=False, default='') to_be_submitted = db.Column(db.Integer, nullable=False, default=0) has_submitted = db.Column(db.Integer, nullable=False, default=0) total_times = db.Column(db.Integer, nullable=False, default=0) using = db.Column(db.Boolean, nullable=True, default=True) @classmethod def formatter(cls, lesson_record): if lesson_record is None: return None try: lesson_record_dict = { 'id': lesson_record.id, 'username': lesson_record.username, 'name': lesson_record.name, 'term': lesson_record.term, 'group_name': lesson_record.group_name, 'to_be_submitted': lesson_record.to_be_submitted, 'has_submitted': lesson_record.has_submitted, 'total_times': lesson_record.total_times } except Exception as e: raise CustomError(500, 500, str(e)) return lesson_record_dict @classmethod def reformatter_insert(cls, data): return data @classmethod def reformatter_update(cls, data): return data @classmethod def count(cls, query_dict: dict, unscoped: bool = False): if query_dict is None: query_dict = {} query = LessonRecord.query if not unscoped: query = query.filter(LessonRecord.using == True) url_condition = UrlCondition(query_dict) try: total = count_query(query, url_condition.filter_dict, url_condition.sort_limit_dict, LessonRecord) except Exception as e: raise CustomError(500, 500, str(e)) return total @classmethod def get_lesson_record(cls, query_dict: dict, unscoped: bool = False): lesson_record = LessonRecord.query if not unscoped: lesson_record = lesson_record.filter(LessonRecord.using == True) url_condition = UrlCondition(query_dict) try: lesson_record = process_query(lesson_record, url_condition.filter_dict, url_condition.sort_limit_dict, LessonRecord).first() except Exception as e: raise CustomError(500, 500, str(e)) return cls.formatter(lesson_record) @classmethod def insert_lesson_record(cls, ctx: bool = True, data: dict = None): if data is None: data = dict() data = cls.reformatter_insert(data) lesson_record = LessonRecord() for key, value in data.items(): if hasattr(lesson_record, key): setattr(lesson_record, key, value) db.session.add(lesson_record) if ctx: try: db.session.commit() except Exception as e: raise CustomError(500, 500, str(e)) return True @classmethod def query_lesson_records(cls, query_dict: dict = None, unscoped: bool = False): if query_dict is None: query_dict = dict() query = LessonRecord.query if not unscoped: query = query.filter(LessonRecord.using == True) url_condition = UrlCondition(query_dict) try: query = process_query(query, url_condition.filter_dict, url_condition.sort_limit_dict, LessonRecord) (lesson_records, total) = page_query(query, url_condition.page_dict) except Exception as e: raise CustomError(500, 500, str(e)) return [ cls.formatter(lesson_record) for lesson_record in lesson_records ], total @classmethod def delete_lesson_record(cls, ctx: bool = True, query_dict: dict = None): if query_dict is None: query_dict = dict() query = LessonRecord.query.filter(LessonRecord.using == True) url_condition = UrlCondition(query_dict) try: query = process_query(query, url_condition.filter_dict, url_condition.sort_limit_dict, LessonRecord) (lesson_records, total) = page_query(query, url_condition.page_dict) except Exception as e: raise CustomError(500, 500, str(e)) for lesson_record in lesson_records: lesson_record.using = False db.session.add(lesson_record) if ctx: try: db.session.commit() except Exception as e: raise CustomError(500, 500, str(e)) return True @classmethod def update_lesson_record(cls, ctx: bool = True, query_dict: dict = None, data: dict = None): if data is None: data = dict() if query_dict is None: query_dict = dict() data = cls.reformatter_update(data) query = LessonRecord.query.filter(LessonRecord.using == True) url_condition = UrlCondition(query_dict) try: query = process_query(query, url_condition.filter_dict, url_condition.sort_limit_dict, LessonRecord) (lesson_records, total) = page_query(query, url_condition.page_dict) except Exception as e: raise CustomError(500, 500, str(e)) for lesson_record in lesson_records: for key, value in data.items(): if hasattr(lesson_record, key): setattr(lesson_record, key, value) db.session.add(lesson_record) if ctx: try: db.session.commit() except Exception as e: raise CustomError(500, 500, str(e)) return True
class Lesson(db.Model): __tablename__ = 'lessons' id = db.Column(db.Integer, primary_key=True, autoincrement=True, index=True) # lesson_notice id 关注课程id raw_lesson_id = db.Column(db.String(32), default='') lesson_id = db.Column(db.String(32), default='') # 被关注课程的id lesson_attribute = db.Column(db.String(8), default='') lesson_state = db.Column(db.String(8), default='') lesson_level = db.Column(db.String(8), default='') lesson_name = db.Column(db.String(32), default='') lesson_teacher_id = db.Column(db.String(48), default='') lesson_teacher_letter = db.Column(db.String(32), default='') lesson_teacher_name = db.Column(db.String(8), default='') lesson_teacher_unit = db.Column(db.String(16), default='') lesson_unit = db.Column(db.String(16), default='') lesson_year = db.Column(db.String(32), default='') lesson_semester = db.Column(db.Integer, default='') lesson_class = db.Column(db.String(255), default='') lesson_type = db.Column(db.String(8), default='') lesson_grade = db.Column(db.String(64), default='') lesson_model = db.Column(db.String(32), default='') term = db.Column(db.String(32), default='') notices = db.Column(db.Integer, default=0) using = db.Column(db.Boolean, default=True) @classmethod def formatter(cls, lesson): if lesson is None: return None lesson_dict = { 'id': lesson.id, 'lesson_id': lesson.lesson_id, 'lesson_attribute': lesson.lesson_attribute, 'lesson_state': lesson.lesson_state, 'lesson_teacher_id': lesson.lesson_teacher_id, 'lesson_name': lesson.lesson_name, 'lesson_teacher_name': lesson.lesson_teacher_name, 'lesson_semester': lesson.lesson_semester, 'lesson_level': lesson.lesson_level, 'lesson_teacher_unit': lesson.lesson_teacher_unit, 'lesson_unit': lesson.lesson_unit, 'lesson_year': lesson.lesson_year, 'lesson_type': lesson.lesson_type, 'lesson_class': lesson.lesson_class, 'lesson_grade': lesson.lesson_grade, 'lesson_model': lesson.lesson_model, 'term': lesson.term, 'notices': lesson.notices, 'raw_lesson_id': lesson.raw_lesson_id } return lesson_dict @classmethod def reformatter_insert(cls, data: dict): allow_column = [ 'lesson_id', 'lesson_attribute', 'lesson_state', 'lesson_level', 'lesson_name', 'lesson_teacher_id', 'lesson_teacher_letter', 'lesson_teacher_name', 'lesson_teacher_unit', 'lesson_unit', 'lesson_year', 'lesson_semester', 'lesson_class', 'lesson_type', 'lesson_grade', 'lesson_model', 'term', 'notices', 'raw_lesson_id' ] new_data = dict() for key, value in data.items(): if key in allow_column: new_data[key] = value return new_data @classmethod def reformatter_update(cls, data: dict): return data @classmethod def count(cls, query_dict: dict, unscoped: bool = False): if query_dict is None: query_dict = {} query = Lesson.query if not unscoped: query = query.filter(Lesson.using == True) url_condition = UrlCondition(query_dict) try: total = count_query(query, url_condition.filter_dict, url_condition.sort_limit_dict, Lesson) except Exception as e: raise CustomError(500, 500, str(e)) return total @classmethod def get_lesson(cls, query_dict: dict, unscoped: bool = False): lesson = Lesson.query if not unscoped: lesson = lesson.filter(Lesson.using == True) url_condition = UrlCondition(query_dict) try: lesson = process_query(lesson, url_condition.filter_dict, url_condition.sort_limit_dict, Lesson).first() except Exception as e: raise CustomError(500, 500, str(e)) return cls.formatter(lesson) @classmethod def insert_lesson(cls, ctx: bool = True, data: dict = None): if data is None: data = dict() data = cls.reformatter_insert(data) lesson = Lesson() for key, value in data.items(): if hasattr(lesson, key): setattr(lesson, key, value) db.session.add(lesson) if ctx: try: db.session.commit() except Exception as e: raise CustomError(500, 500, str(e)) return True @classmethod def query_lessons(cls, query_dict: dict = None, unscoped: bool = False): if query_dict is None: query_dict = {} query = Lesson.query if not unscoped: query = query.filter(Lesson.using == True) lesson_or_teacher_name = query_dict.get('lesson_or_teacher_name_or', None) if lesson_or_teacher_name is not None and len( lesson_or_teacher_name) != 0: del query_dict['lesson_or_teacher_name_or'] lesson_or_teacher_name = lesson_or_teacher_name[0] query = query.filter( or_( Lesson.lesson_name.like(lesson_or_teacher_name + "%"), Lesson.lesson_teacher_name.like(lesson_or_teacher_name + "%"))) url_condition = UrlCondition(query_dict) try: query = process_query(query, url_condition.filter_dict, url_condition.sort_limit_dict, Lesson) (lessons, total) = page_query(query, url_condition.page_dict) except Exception as e: raise CustomError(500, 500, str(e)) return [cls.formatter(lesson) for lesson in lessons], total @classmethod def delete_lesson(cls, ctx: bool = True, query_dict: dict = None): if query_dict is None: query_dict = {} query = Lesson.query.filter(Lesson.using == True) url_condition = UrlCondition(query_dict) try: query = process_query(query, url_condition.filter_dict, url_condition.sort_limit_dict, Lesson) (lessons, total) = page_query(query, url_condition.page_dict) except Exception as e: raise CustomError(500, 500, str(e)) for lesson in lessons: lesson.using = False db.session.add(lesson) if ctx: try: db.session.commit() except Exception as e: raise CustomError(500, 500, str(e)) return True @classmethod def update_lesson(cls, ctx: bool = True, query_dict: dict = None, data: dict = None): if data is None: data = {} if query_dict is None: query_dict = {} data = cls.reformatter_update(data) query = Lesson.query.filter(Lesson.using == True) url_condition = UrlCondition(query_dict) try: query = process_query(query, url_condition.filter_dict, url_condition.sort_limit_dict, Lesson) (lessons, total) = page_query(query, url_condition.page_dict) except Exception as e: raise CustomError(500, 500, str(e)) for lesson in lessons: for key, value in data.items(): if hasattr(lesson, key): setattr(lesson, key, value) db.session.add(lesson) if ctx: try: db.session.commit() except Exception as e: raise CustomError(500, 500, str(e)) return True @classmethod def query_teacher_names(cls, query_dict: dict = None, unscoped: bool = False): if query_dict is None: query_dict = {} query = Lesson.query.with_entities( Lesson.lesson_teacher_name).distinct() if not unscoped: query = query.filter(Lesson.using == True) url_condition = UrlCondition(query_dict) try: query = process_query(query, url_condition.filter_dict, url_condition.sort_limit_dict, Lesson) (lessons, total) = page_query(query, url_condition.page_dict) except Exception as e: raise CustomError(500, 500, str(e)) return [data.lesson_teacher_name for data in query], total
class ConsultType(db.Model): __tablename__ = 'consult_types' id = db.Column(db.Integer, primary_key=True, autoincrement=True, index=True) name = db.Column(db.String(64), default='') using = db.Column(db.Boolean, default=True) @classmethod def formatter(cls, consult_type): if consult_type is None: return None try: consult_type_dict = { 'id': consult_type.id, 'name': consult_type.name } except Exception as e: raise CustomError(500, 500, str(e)) return consult_type_dict @classmethod def reformatter_insert(cls, data: dict): return data @classmethod def reformatter_update(cls, data: dict): return data @classmethod def count(cls, query_dict: dict, unscoped: bool = False): if query_dict is None: query_dict = {} query = ConsultType.query if not unscoped: query = query.filter(ConsultType.using == True) url_condition = UrlCondition(query_dict) try: total = count_query(query, url_condition.filter_dict, url_condition.sort_limit_dict, ConsultType) except Exception as e: raise CustomError(500, 500, str(e)) return total @classmethod def get_consult_type(cls, query_dict, unscoped: bool = False): consult_type = ConsultType.query if not unscoped: consult_type = consult_type.filter(ConsultType.using == True) url_condition = UrlCondition(query_dict) try: consult_type = process_query(consult_type, url_condition.filter_dict, url_condition.sort_limit_dict, ConsultType).first() except Exception as e: raise CustomError(500, 500, str(e)) return cls.formatter(consult_type) @classmethod def insert_consult_type(cls, ctx: bool = True, data: dict = None): if data is None: data = {} data = cls.reformatter_insert(data) consult_type = ConsultType() for key, value in data.items(): if hasattr(consult_type, key): setattr(consult_type, key, value) db.session.add(consult_type) if ctx: try: db.session.commit() except Exception as e: raise CustomError(500, 500, str(e)) return True @classmethod def query_consult_types(cls, query_dict: dict = None, unscoped: bool = False): if query_dict is None: query_dict = {} query = ConsultType.query if not unscoped: query = query.filter(ConsultType.using == True) url_condition = UrlCondition(query_dict) try: query = process_query(query, url_condition.filter_dict, url_condition.sort_limit_dict, ConsultType) (consult_types, total) = page_query(query, url_condition.page_dict) except Exception as e: raise CustomError(500, 500, str(e)) return [cls.formatter(consult_type) for consult_type in consult_types], total @classmethod def delete_consult_type(cls, ctx: bool = True, query_dict: dict = None): if query_dict is None: query_dict = {} query = ConsultType.query.filter(ConsultType.using == True) url_condition = UrlCondition(query_dict) try: query = process_query(query, url_condition.filter_dict, url_condition.sort_limit_dict, ConsultType) (consult_types, total) = page_query(query, url_condition.page_dict) except Exception as e: raise CustomError(500, 500, str(e)) for consult_type in consult_types: consult_type.using = False db.session.add(consult_type) if ctx: try: db.session.commit() except Exception as e: raise CustomError(500, 500, str(e)) return True @classmethod def update_consult_type(cls, ctx: bool = True, query_dict: dict = None, data: dict = None): if data is None: data = {} if query_dict is None: query_dict = {} data = cls.reformatter_update(data) query = ConsultType.query.filter(ConsultType.using == True) url_condition = UrlCondition(query_dict) try: query = process_query(query, url_condition.filter_dict, url_condition.sort_limit_dict, ConsultType) (consult_types, total) = page_query(query, url_condition.page_dict) except Exception as e: raise CustomError(500, 500, str(e)) for consult_type in consult_types: for key, value in data.items(): if hasattr(consult_type, key): setattr(consult_type, key, value) db.session.add(consult_type) if ctx: try: db.session.commit() except Exception as e: raise CustomError(500, 500, str(e)) return True
class LessonCase(db.Model): # __tablename__ = 'lesson_cases' __abstract__ = True __has_mapped_table__ = False id = db.Column(db.Integer, primary_key=True, autoincrement=True, index=True) lesson_id = db.Column(db.Integer, default=-1) lesson_room = db.Column(db.String(48), default='') lesson_weekday = db.Column(db.Integer, default=0) lesson_week = db.Column(db.String(48), default='') lesson_time = db.Column(db.String(48), default='') lesson_date = db.Column(db.Date, default=datetime.now) inner_lesson_id = db.Column( db.String(255), default='') # 这个是为了课表正常显示 做的区分 一个课有所有的lesson_case 课表显示用这个 using = db.Column(db.Boolean, default=True) @classmethod def formatter(cls, lesson_case): if lesson_case is None: return None lesson_case_dict = { 'lesson_week': lesson_case.lesson_week, 'lesson_time': str(lesson_case.lesson_time), 'lesson_date': str(lesson_case.lesson_date.strftime('%Y-%m-%d')), 'lesson_weekday': lesson_case.lesson_weekday, 'lesson_room': lesson_case.lesson_room, 'inner_lesson_id': lesson_case.inner_lesson_id } return lesson_case_dict @classmethod def reformatter_insert(cls, data: dict): return data @classmethod def reformatter_update(cls, data: dict): return data @classmethod def get_table(cls, term: str): if not cls.__has_mapped_table__: create_all_lesson_case() cls.__has_mapped_table__ = True global lesson_case_function return lesson_case_function[term.replace('-', '_')] @classmethod def count(cls, query_dict: dict, unscoped: bool = False): if query_dict is None: query_dict = {} query = cls.query if not unscoped: query = query.filter(cls.using == True) url_condition = UrlCondition(query_dict) try: total = count_query(query, url_condition.filter_dict, url_condition.sort_limit_dict, cls) except Exception as e: raise CustomError(500, 500, str(e)) return total @classmethod def get_lesson_case(cls, query_dict: dict, unscoped: bool = False): lesson_case = cls.query if not unscoped: lesson_case = lesson_case.filter(cls.using == True) url_condition = UrlCondition(query_dict) try: lesson_case = process_query(lesson_case, url_condition.filter_dict, url_condition.sort_limit_dict, cls).first() except Exception as e: raise CustomError(500, 500, str(e)) return cls.formatter(lesson_case) @classmethod def insert_lesson_case(cls, ctx: bool = True, data: dict = None): if data is None: data = {} data = cls.reformatter_insert(data) lesson_case = cls() for key, value in data.items(): if hasattr(lesson_case, key): setattr(lesson_case, key, value) db.session.add(lesson_case) if ctx: try: db.session.commit() except Exception as e: raise CustomError(500, 500, str(e)) return True @classmethod def query_lesson_cases(cls, query_dict: dict = None, unscoped: bool = False): if query_dict is None: query_dict = {} query = cls.query if not unscoped: query = query.filter(cls.using == True) url_condition = UrlCondition(query_dict) try: query = process_query(query, url_condition.filter_dict, url_condition.sort_limit_dict, cls) (lesson_cases, total) = page_query(query, url_condition.page_dict) except Exception as e: raise CustomError(500, 500, str(e)) return [cls.formatter(lesson_case) for lesson_case in lesson_cases], total @classmethod def delete_lesson_case(cls, ctx: bool = True, query_dict: dict = None): if query_dict is None: query_dict = {} query = cls.query.filter(cls.using == True) url_condition = UrlCondition(query_dict) try: query = process_query(query, url_condition.filter_dict, url_condition.sort_limit_dict, cls) (lesson_cases, total) = page_query(query, url_condition.page_dict) except Exception as e: raise CustomError(500, 500, str(e)) for lesson_case in lesson_cases: lesson_case.using = False db.session.add(lesson_case) if ctx: try: db.session.commit() except Exception as e: raise CustomError(500, 500, str(e)) return True @classmethod def update_lesson_case(cls, ctx: bool = True, query_dict: dict = None, data: dict = None): if data is None: data = {} if query_dict is None: query_dict = {} data = cls.reformatter_update(data) query = cls.query.filter(cls.using == True) url_condition = UrlCondition(query_dict) try: query = process_query(query, url_condition.filter_dict, url_condition.sort_limit_dict, cls) (lesson_cases, total) = page_query(query, url_condition.page_dict) except Exception as e: raise CustomError(500, 500, str(e)) for lesson_case in lesson_cases: for key, value in data.items(): if hasattr(lesson_case, key): setattr(lesson_case, key, value) db.session.add(lesson_case) if ctx: try: db.session.commit() except Exception as e: raise CustomError(500, 500, str(e)) return True
class Event(db.Model): __tablename__ = 'events' id = db.Column(db.Integer, primary_key=True, autoincrement=True, index=True) name = db.Column(db.String(255), default='') username = db.Column(db.String(64), default='') detail = db.Column(db.String(1023), default='') timestamp = db.Column(db.TIMESTAMP, default=datetime.now) using = db.Column(db.Boolean, default=True) @classmethod def formatter(cls, event): if event is None: return None event_dict = { 'id': event.id, 'username': event.username, 'detail': event.detail, 'timestamp': str(event.timestamp), 'using': event.using } return event_dict @classmethod def reformatter_insert(cls, data: dict): return data @classmethod def reformatter_update(cls, data: dict): return data @classmethod def count(cls, query_dict: dict, unscoped: bool = False): if query_dict is None: query_dict = {} query = Event.query if not unscoped: query = query.filter(Event.using == True) url_condition = UrlCondition(query_dict) try: total = count_query(query, url_condition.filter_dict, url_condition.sort_limit_dict, Event) except Exception as e: raise CustomError(500, 500, str(e)) return total @classmethod def get_event(cls, query_dict: dict, unscoped: bool = False): event = Event.query if not unscoped: event = event.filter(Event.using == True) url_condition = UrlCondition(query_dict) try: event = process_query(event, url_condition.filter_dict, url_condition.sort_limit_dict, Event).first() except Exception as e: raise CustomError(500, 500, str(e)) return cls.formatter(event) @classmethod def insert_event(cls, ctx: bool = True, data: dict = None): if data is None: data = {} data = cls.reformatter_insert(data) event = Event() for key, value in data.items(): if hasattr(event, key): setattr(event, key, value) db.session.add(event) if ctx: try: db.session.commit() except Exception as e: raise CustomError(500, 500, str(e)) return True @classmethod def query_events(cls, query_dict: dict = None, unscoped: bool = False): if query_dict is None: query_dict = {} query = Event.query if not unscoped: query = query.filter(Event.using == True) url_condition = UrlCondition(query_dict) try: query = process_query(query, url_condition.filter_dict, url_condition.sort_limit_dict, Event) (events, total) = page_query(query, url_condition.page_dict) except Exception as e: raise CustomError(500, 500, str(e)) return [cls.formatter(event) for event in events], total @classmethod def delete_event(cls, ctx: bool = True, query_dict: dict = None): if query_dict is None: query_dict = {} query = Event.query.filter(Event.using == True) url_condition = UrlCondition(query_dict) try: query = process_query(query, url_condition.filter_dict, url_condition.sort_limit_dict, Event) (events, total) = page_query(query, url_condition.page_dict) except Exception as e: raise CustomError(500, 500, str(e)) for event in events: event.using = False db.session.add(event) if ctx: try: db.session.commit() except Exception as e: raise CustomError(500, 500, str(e)) return True @classmethod def update_event(cls, ctx: bool = True, query_dict: dict = None, data: dict = None): if data is None: data = {} if query_dict is None: query_dict = {} data = cls.reformatter_update(data) query = Event.query.filter(Event.using == True) url_condition = UrlCondition(query_dict) try: query = process_query(query, url_condition.filter_dict, url_condition.sort_limit_dict, Event) (events, total) = page_query(query, url_condition.page_dict) except Exception as e: raise CustomError(500, 500, str(e)) for event in events: for key, value in data.items(): if hasattr(event, key): setattr(event, key, value) db.session.add(event) if ctx: try: db.session.commit() except Exception as e: raise CustomError(500, 500, str(e)) return True
class OtherModelLesson(db.Model): __tablename__ = 'other_model_lessons' id = db.Column(db.Integer, primary_key=True, autoincrement=True, index=True) lesson_name = db.Column(db.String(32), default='') lesson_attribute = db.Column(db.String(32), default='') term = db.Column(db.String(32), default='') lesson_teacher_name = db.Column(db.String(8), default='') unit = db.Column(db.String(32), default='') group_name = db.Column(db.String(32), default='') using = db.Column(db.Boolean, default=True) @classmethod def insert_other_model_lesson(cls, ctx: bool = True, data: dict = None): if data is None: data = {} print(data) data = cls.reformatter_other_model(data) print(data) other_model_lesson = OtherModelLesson() for key, value in data.items(): if hasattr(other_model_lesson, key): setattr(other_model_lesson, key, value) db.session.add(other_model_lesson) if ctx: try: db.session.commit() except Exception as e: raise CustomError(500, 500, str(e)) return True @classmethod def reformatter_other_model(cls, data: dict): allow_column = [ 'lesson_name', 'lesson_attribute', 'term', 'lesson_teacher_name', 'unit', 'group_name', 'using' ] new_data = dict() for key, value in data.items(): if key in allow_column: new_data[key] = value return new_data @classmethod def query_other_model_lessons(cls, query_dict: dict = None, unscoped: bool = False): if query_dict is None: query_dict = {} query = OtherModelLesson.query if not unscoped: query = query.filter(OtherModelLesson.using == True) url_condition = UrlCondition(query_dict) try: query = process_query(query, url_condition.filter_dict, url_condition.sort_limit_dict, OtherModelLesson) (other_model_lessons, total) = page_query(query, url_condition.page_dict) except Exception as e: raise CustomError(500, 500, str(e)) return [ cls.formatter(other_model_lesson) for other_model_lesson in other_model_lessons ], total @classmethod def formatter(cls, other_model_lesson): if other_model_lesson is None: return None # status_dict = {1: '推荐为好评课', 2: '待商榷'} # status = status_dict[other_model_lesson.status] other_model_lesson_dict = { 'id': other_model_lesson.id, 'group_name': other_model_lesson.group_name, 'lesson_name': other_model_lesson.lesson_name, 'lesson_attribute': other_model_lesson.lesson_attribute, 'term': other_model_lesson.term, 'lesson_teacher_name': other_model_lesson.lesson_teacher_name, 'unit': other_model_lesson.unit, 'using': other_model_lesson.using } return other_model_lesson_dict
class Group(db.Model): __tablename__ = 'groups' id = db.Column(db.Integer, primary_key=True, autoincrement=True, index=True) group_name = db.Column(db.String(64), unique=True, default='') leader_name = db.Column(db.String(64), default='') using = db.Column(db.Boolean, default=True) @classmethod def formatter(cls, group): if group is None: return None group_dict = { 'group_name': group.group_name, 'leader_name': group.leader_name } return group_dict @classmethod def count(cls, query_dict: dict, unscoped: bool = False): if query_dict is None: query_dict = {} query = Group.query if not unscoped: query = query.filter(Group.using == True) url_condition = UrlCondition(query_dict) try: total = count_query(query, url_condition.filter_dict, url_condition.sort_limit_dict, Group) except Exception as e: raise CustomError(500, 500, str(e)) return total @classmethod def get_group(cls, group_name: str): try: group = Group.query.filter(Group.using == True).filter( Group.name == group_name).first() except Exception as e: raise CustomError(500, 500, str(e)) return cls.formatter(group) @classmethod def query_groups(cls, query_dict: dict = None): if query_dict is None: query_dict = {} url_condition = UrlCondition(query_dict) query = Group.query.filter(Group.using == True) try: query = process_query(query, url_condition.filter_dict, url_condition.sort_limit_dict, Group) (groups, total) = page_query(query, url_condition.page_dict) except Exception as e: raise CustomError(500, 500, str(e)) return [cls.formatter(data) for data in query], total @classmethod def update_group(cls, ctx=True, query_dict: dict = None, data: dict = None): if data is None: data = {} if query_dict is None: query_dict = {} url_condition = UrlCondition(query_dict) query = Group.query.filter(Group.using == True) try: query = process_query(query, url_condition.filter_dict, url_condition.sort_limit_dict, Group) (groups, total) = page_query(query, url_condition.page_dict) except Exception as e: raise CustomError(500, 500, str(e)) for group in groups: for key, value in data.items(): if hasattr(group, key): setattr(group, key, value) db.session.add(group) if ctx: try: db.session.commit() except Exception as e: db.session.rollback() raise CustomError(500, 500, str(e)) return True
class Supervisor(db.Model): __tablename__ = 'supervisors' id = db.Column(db.Integer, primary_key=True, autoincrement=True, index=True) username = db.Column(db.String(64), default='') name = db.Column(db.String(64), default='') group_name = db.Column(db.String(16), default='') work_state = db.Column(db.String(8), default='') term = db.Column(db.String(32), default='') using = db.Column(db.Boolean, default=True) grouper = db.Column(db.Boolean, default=False) unit = db.Column(db.String) main_grouper = db.Column(db.Boolean, default=False) @classmethod def formatter(cls, supervisor): if supervisor is None: return None supervisor_dict = { "id": supervisor.id, 'group_name': supervisor.group_name, 'username': supervisor.username, 'is_grouper': supervisor.grouper, 'is_main_grouper': supervisor.main_grouper, 'work_state': supervisor.work_state, 'term': supervisor.term, 'name': supervisor.name } return supervisor_dict @classmethod def count(cls, query_dict: dict, unscoped: bool = False): if query_dict is None: query_dict = {} query = Supervisor.query if not unscoped: query = query.filter(Supervisor.using == True) url_condition = UrlCondition(query_dict) try: total = count_query(query, url_condition.filter_dict, url_condition.sort_limit_dict, Supervisor) except Exception as e: raise CustomError(500, 500, str(e)) return total @classmethod def query_supervisors(cls, query_dict: dict, unscoped: bool = False): query = Supervisor.query if not unscoped: query = query.filter(Supervisor.using == True) url_condition = UrlCondition(query_dict) try: query = process_query(query, url_condition.filter_dict, url_condition.sort_limit_dict, Supervisor) (supervisors, total) = page_query(query, url_condition.page_dict) except Exception as e: raise CustomError(500, 500, str(e)) return [cls.formatter(supervisor) for supervisor in supervisors], total @classmethod def get_supervisor(cls, query_dict: dict, unscoped: bool = False): supervisor = Supervisor.query if not unscoped: supervisor = supervisor.filter(Supervisor.using == True) url_condition = UrlCondition(query_dict) try: supervisor = process_query(supervisor, url_condition.filter_dict, url_condition.sort_limit_dict, Supervisor).first() except Exception as e: raise CustomError(500, 500, str(e)) return cls.formatter(supervisor) @classmethod def get_supervisor_by_id(cls, query_dict: dict, unscoped: bool = False): supervisor = Supervisor.query if not unscoped: supervisor = supervisor.filter(Supervisor.using == True) url_condition = UrlCondition(query_dict) try: supervisor = process_query(supervisor, url_condition.filter_dict, url_condition.sort_limit_dict, Supervisor).first() except Exception as e: raise CustomError(500, 500, str(e)) return cls.formatter(supervisor) @classmethod def insert_supervisor(cls, ctx=True, data=None): supervisor = Supervisor() for key, value in data.items(): if hasattr(supervisor, key): setattr(supervisor, key, value) db.session.add(supervisor) if ctx: try: db.session.commit() except Exception as e: raise CustomError(500, 500, str(e)) return True @classmethod def delete_supervisor(cls, ctx: bool = True, query_dict: dict = None): if query_dict is None: query_dict = {} query = Supervisor.query.filter(Supervisor.using == True) url_condition = UrlCondition(query_dict) try: query = process_query(query, url_condition.filter_dict, url_condition.sort_limit_dict, Supervisor) (supervisors, total) = page_query(query, url_condition.page_dict) except Exception as e: raise CustomError(500, 500, str(e)) for supervisor in supervisors: supervisor.using = False db.session.add(supervisor) if ctx: try: db.session.commit() except Exception as e: raise CustomError(500, 500, str(e)) return True @classmethod def update_supervisor(cls, ctx: bool = True, query_dict: dict = None, data: dict = None): if data is None: data = {} if query_dict is None: query_dict = {} query = Supervisor.query.filter(Supervisor.using == True) url_condition = UrlCondition(query_dict) try: query = process_query(query, url_condition.filter_dict, url_condition.sort_limit_dict, Supervisor) (supervisors, total) = page_query(query, url_condition.page_dict) except Exception as e: raise CustomError(500, 500, str(e)) for supervisor in supervisors: for key, value in data.items(): if hasattr(supervisor, key): setattr(supervisor, key, value) db.session.add(supervisor) if ctx: try: db.session.commit() except Exception as e: raise CustomError(500, 500, str(e)) return True
class User(db.Model, UserMixin): __tablename__ = 'users' id = db.Column(db.Integer, primary_key=True, autoincrement=True, index=True) username = db.Column(db.String(64), index=True, default='') name = db.Column(db.String(64), default='') password_hash = db.Column(db.String(128), default='') sex = db.Column(db.String(16), default='男') email = db.Column(db.String(64), default='') phone = db.Column(db.String(16), default='') state = db.Column(db.String(8), default='') unit = db.Column(db.String(8), default='') status = db.Column(db.String(8), default='') prorank = db.Column(db.String(8), default='') skill = db.Column(db.String(16), default='') using = db.Column(db.Boolean, default=True) is_admin = db.Column(db.Boolean, default=False) is_leader = db.Column(db.Boolean, default=False) is_guider = db.Column(db.Boolean, default=False) is_reader = db.Column(db.Boolean, default=False) @classmethod def formatter(cls, user): if user is None: return None user_dict = { 'id': user.id, 'username': user.username, 'name': user.name, 'sex': user.sex, 'email': user.email, 'phone': user.phone, 'state': user.state, 'unit': user.unit, 'status': user.status, 'prorank': user.prorank, 'skill': user.skill, 'is_guider': user.is_guider, 'is_leader': user.is_leader, 'is_admin': user.is_admin, 'is_reader': user.is_reader } return user_dict @classmethod def reformatter_update(cls, data: dict): allow_change_list = [ 'name', 'sex', 'password', 'email', 'phone', 'state', 'unit', 'status', 'prorank', 'skill', 'group_name', 'work_state', 'term', 'is_admin', 'is_leader', 'is_guider', 'is_reader' ] update_data = dict() for key, value in data.items(): if key in allow_change_list: update_data[key] = value return update_data @classmethod def reformatter_insert(cls, data: dict): return data @classmethod def count(cls, query_dict: dict, unscoped: bool = False): if query_dict is None: query_dict = {} query = User.query if not unscoped: query = query.filter(User.using == True) url_condition = UrlCondition(query_dict) try: total = count_query(query, url_condition.filter_dict, url_condition.sort_limit_dict, User) except Exception as e: raise CustomError(500, 500, str(e)) return total @property def password(self): raise AttributeError('password is not a readable attribute') @password.setter def password(self, password): self.password_hash = generate_password_hash(password) @classmethod def login(cls, username: str, password: str): user = User.query.filter(User.username == username).filter( User.using == True).first() if user is None or not check_password_hash(user.password_hash, password): raise CustomError(401, 401, '用户名或密码错误') login_user(user, remember=False) @classmethod def logout(cls): logout_user() @classmethod def get_user(cls, query_dict: dict, unscoped=False): user = User.query if not unscoped: user = user.filter(User.using == True) url_condition = UrlCondition(query_dict) try: user = process_query(user, url_condition.filter_dict, url_condition.sort_limit_dict, User).first() except Exception as e: raise CustomError(500, 500, str(e)) return cls.formatter(user) @classmethod def query_users(cls, query_dict: dict = None, unscoped=False): if query_dict is None: query_dict = {} query = User.query if not unscoped: query = query.filter(User.using == True) url_condition = UrlCondition(query_dict) try: query = process_query(query, url_condition.filter_dict, url_condition.sort_limit_dict, User) (users, total) = page_query(query, url_condition.page_dict) except Exception as e: raise CustomError(500, 500, str(e)) return [cls.formatter(user) for user in users], total @classmethod def insert_user(cls, ctx=True, data=None): if data is None: raise CustomError(500, 200, 'data must be given') data = cls.reformatter_insert(data) user = User() for key, value in data.items(): if key == 'password': user.password = value if hasattr(user, key): setattr(user, key, value) db.session.add(user) if ctx: try: db.session.commit() except Exception as e: db.session.rollback() raise CustomError(500, 500, str(e)) return True @classmethod def delete_user(cls, ctx=True, username: str = None): try: user = User.query.filter(User.username == username).first() except Exception as e: raise CustomError(500, 500, str(e)) user.using = False db.session.add(user) if ctx: try: db.session.commit() except Exception as e: db.session.rollback() raise CustomError(500, 500, str(e)) return True @classmethod def update_user(cls, ctx=True, username: str = None, data: dict = None): if data is None: data = {} data = cls.reformatter_update(data) try: user = User.query.filter(User.username == username).filter( User.using == True).first() except Exception as e: raise CustomError(500, 500, str(e)) for key, value in data.items(): if hasattr(user, key) or key == 'password': setattr(user, key, value) db.session.add(user) if ctx: try: db.session.commit() except Exception as e: db.session.rollback() raise CustomError(500, 500, str(e)) return True
class Activity(db.Model): __tablename__ = 'activities' id = db.Column(db.Integer, primary_key=True, autoincrement=True, index=True) name = db.Column(db.String(64), default='') teacher = db.Column(db.String(64), default='') start_time = db.Column(db.TIMESTAMP, default=datetime.now) end_time = db.Column(db.TIMESTAMP, default=datetime.now) place = db.Column(db.String(128), default='') state = db.Column(db.String(16), default='') information = db.Column(db.String(128), default='') all_num = db.Column(db.Integer, default=0) attend_num = db.Column(db.Integer, default=0) remainder_num = db.Column(db.Integer, default=0) term = db.Column(db.String(32), default='') apply_start_time = db.Column(db.TIMESTAMP, default=datetime.now) apply_end_time = db.Column(db.TIMESTAMP, default=datetime.now) apply_state = db.Column(db.String(32), default='') using = db.Column(db.Boolean, default=True) @classmethod def reformatter_insert(cls, data: dict): return data @classmethod def reformatter_update(cls, data: dict): return data @classmethod def formatter(cls, activity): if activity is None: return None try: activity_dict = { 'id': activity.id, 'name': activity.name, 'teacher': activity.teacher, 'start_time': convert_datetime_to_string(activity.start_time), 'end_time': convert_datetime_to_string(activity.end_time), 'place': activity.place, 'state': activity.state, 'information': activity.information, 'all_num': activity.all_num, 'attend_num': activity.attend_num, 'remainder_num': activity.remainder_num, 'term': activity.term, 'apply_start_time': convert_datetime_to_string(activity.apply_start_time), 'apply_end_time': convert_datetime_to_string(activity.apply_end_time), 'apply_state': activity.apply_state } except Exception as e: raise CustomError(500, 500, str(e)) return activity_dict @classmethod def count(cls, query_dict: dict, unscoped: bool = False): if query_dict is None: query_dict = {} query = Activity.query if not unscoped: query = query.filter(Activity.using == True) url_condition = UrlCondition(query_dict) try: total = count_query(query, url_condition.filter_dict, url_condition.sort_limit_dict, Activity) except Exception as e: raise CustomError(500, 500, str(e)) return total @classmethod def insert_activity(cls, ctx: bool = True, data: dict = None): if data is None: data = {} data = cls.reformatter_insert(data) activity = Activity() for key, value in data.items(): if hasattr(Activity, key): setattr(activity, key, value) db.session.add(activity) if ctx: try: db.session.commit() except Exception as e: raise CustomError(500, 500, str(e)) return True @classmethod def get_activity(cls, query_dict: dict, unscoped: bool = False): activity = Activity.query if not unscoped: activity = activity.filter(Activity.using == True) url_condition = UrlCondition(query_dict) try: activity = process_query(activity, url_condition.filter_dict, url_condition.sort_limit_dict, Activity).first() except Exception as e: raise CustomError(500, 500, str(e)) return cls.formatter(activity) @classmethod def query_activities(cls, query_dict: dict = None, unscoped: bool = False): if query_dict is None: query_dict = {} query = Activity.query if not unscoped: query = query.filter(Activity.using == True) url_condition = UrlCondition(query_dict) try: query = process_query(query, url_condition.filter_dict, url_condition.sort_limit_dict, Activity) (activities, total) = page_query(query, url_condition.page_dict) except Exception as e: raise CustomError(500, 500, str(e)) return [cls.formatter(activity) for activity in activities], total @classmethod def delete_activity(cls, ctx: bool = True, query_dict: dict = None): if query_dict is None: query_dict = {} query = Activity.query.filter(Activity.using == True) url_condition = UrlCondition(query_dict) try: query = process_query(query, url_condition.filter_dict, url_condition.sort_limit_dict, Activity) (activities, total) = page_query(query, url_condition.page_dict) except Exception as e: raise CustomError(500, 500, str(e)) for activity in activities: activity.using = False db.session.add(activity) if ctx: try: db.session.commit() except Exception as e: raise CustomError(500, 500, str(e)) return True @classmethod def update_activity(cls, ctx: bool = True, query_dict: dict = None, data: dict = None): if data is None: data = {} if query_dict is None: query_dict = {} data = cls.reformatter_update(data) query = Activity.query.filter(Activity.using == True) url_condition = UrlCondition(query_dict) try: query = process_query(query, url_condition.filter_dict, url_condition.sort_limit_dict, Activity) (activities, total) = page_query(query, url_condition.page_dict) except Exception as e: raise CustomError(500, 500, str(e)) for activity in activities: for key, value in data.items(): if hasattr(activity, key): setattr(activity, key, value) db.session.add(activity) if ctx: try: db.session.commit() except Exception as e: raise CustomError(500, 500, str(e)) return True
class ActivityUser(db.Model): __tablename__ = 'activity_users' id = db.Column(db.Integer, primary_key=True, autoincrement=True, index=True) username = db.Column(db.String(64), default='') activity_id = db.Column(db.Integer, default=-1) state = db.Column(db.String(16), default='') fin_state = db.Column(db.String(16), default='') using = db.Column(db.Boolean, default=True) @classmethod def reformatter_insert(cls, data: dict): return data @classmethod def reformatter_update(cls, data: dict): return data @classmethod def formatter(cls, activity_user_user): if activity_user_user is None: return None try: activity_user_user_dict = { 'id': activity_user_user.id, 'username': activity_user_user.username, 'activity_id': activity_user_user.activity_id, 'activity_user_id': activity_user_user.id, 'state': activity_user_user.state, 'fin_state': activity_user_user.fin_state } except Exception as e: raise CustomError(500, 500, str(e)) return activity_user_user_dict @classmethod def count(cls, query_dict: dict, unscoped: bool = False): if query_dict is None: query_dict = {} query = ActivityUser.query if not unscoped: query = query.filter(ActivityUser.using == True) url_condition = UrlCondition(query_dict) try: total = count_query(query, url_condition.filter_dict, url_condition.sort_limit_dict, ActivityUser) except Exception as e: raise CustomError(500, 500, str(e)) return total @classmethod def insert_activity_user(cls, ctx: bool = True, data: dict = None): if data is None: data = {} data = cls.reformatter_insert(data) activity_user = ActivityUser() for key, value in data.items(): if hasattr(ActivityUser, key): setattr(activity_user, key, value) db.session.add(activity_user) if ctx: try: db.session.commit() except Exception as e: raise CustomError(500, 500, str(e)) return True @classmethod def get_activity_user(cls, query_dict: dict, unscoped: bool = False): activity_user = ActivityUser.query if not unscoped: activity_user = activity_user.filter(ActivityUser.using == True) url_condition = UrlCondition(query_dict) try: activity_user = process_query(activity_user, url_condition.filter_dict, url_condition.sort_limit_dict, ActivityUser).first() except Exception as e: raise CustomError(500, 500, str(e)) return cls.formatter(activity_user) @classmethod def query_activity_users(cls, query_dict: dict = None, unscoped: bool = False): if query_dict is None: query_dict = {} query = ActivityUser.query if not unscoped: query = query.filter(ActivityUser.using == True) url_condition = UrlCondition(query_dict) try: query = process_query(query, url_condition.filter_dict, url_condition.sort_limit_dict, ActivityUser) (activity_users, total) = page_query(query, url_condition.page_dict) except Exception as e: raise CustomError(500, 500, str(e)) return [ cls.formatter(activity_user) for activity_user in activity_users ], total @classmethod def delete_activity_user(cls, ctx: bool = True, query_dict: dict = None): if query_dict is None: query_dict = {} query = ActivityUser.query.filter(ActivityUser.using == True) url_condition = UrlCondition(query_dict) try: query = process_query(query, url_condition.filter_dict, url_condition.sort_limit_dict, ActivityUser) (activity_users, total) = page_query(query, url_condition.page_dict) except Exception as e: raise CustomError(500, 500, str(e)) for activity_user in activity_users: activity_user.using = False db.session.add(activity_user) if ctx: try: db.session.commit() except Exception as e: raise CustomError(500, 500, str(e)) return True @classmethod def update_activity_user(cls, ctx: bool = True, query_dict: dict = None, data: dict = None): if data is None: data = {} if query_dict is None: query_dict = {} data = cls.reformatter_update(data) query = ActivityUser.query.filter(ActivityUser.using == True) url_condition = UrlCondition(query_dict) try: query = process_query(query, url_condition.filter_dict, url_condition.sort_limit_dict, ActivityUser) (activity_users, total) = page_query(query, url_condition.page_dict) except Exception as e: raise CustomError(500, 500, str(e)) for activity_user in activity_users: for key, value in data.items(): if hasattr(activity_user, key): setattr(activity_user, key, value) db.session.add(activity_user) if ctx: try: db.session.commit() except Exception as e: raise CustomError(500, 500, str(e)) return True
class ModelLesson(db.Model): __tablename__ = 'model_lessons' id = db.Column(db.Integer, primary_key=True, autoincrement=True, index=True) lesson_id = db.Column(db.String(32), default='') term = db.Column(db.String(32), default='') status = db.Column(db.Integer, default=2) # 好评课 推荐课 votes = db.Column(db.Integer, default=0) group_name = db.Column(db.String(32), default='') using = db.Column(db.Boolean, default=True) @classmethod def formatter(cls, model_lesson): if model_lesson is None: return None status_dict = {1: '推荐为好评课', 2: '待商榷'} status = status_dict[model_lesson.status] model_lesson_dict = { 'id': model_lesson.id, 'lesson_id': model_lesson.lesson_id, 'group_name': model_lesson.group_name, 'status': status, 'votes': model_lesson.votes, } return model_lesson_dict @classmethod def reformatter_insert(cls, data: dict): allow_column = ['lesson_id', 'group_name', 'status', 'votes', 'term'] status_dict = {'推荐为好评课': 1, '待商榷': 2} new_data = dict() for key, value in data.items(): if key in allow_column: if key == 'status': value = status_dict[value] new_data[key] = value return new_data @classmethod def reformatter_update(cls, data: dict): if data is None: return dict() new_data = dict() status_dict = {'推荐为好评课': 1, '待商榷': 2} for key, value in data.items(): if key == 'status': value = status_dict[value] new_data[key] = value return new_data @classmethod def count(cls, query_dict: dict, unscoped: bool = False): if query_dict is None: query_dict = {} query = ModelLesson.query if not unscoped: query = query.filter(ModelLesson.using == True) url_condition = UrlCondition(query_dict) try: total = count_query(query, url_condition.filter_dict, url_condition.sort_limit_dict, ModelLesson) except Exception as e: raise CustomError(500, 500, str(e)) return total @classmethod def get_model_lesson(cls, query_dict: dict, unscoped: bool = False): model_lesson = ModelLesson.query if not unscoped: model_lesson = model_lesson.filter(ModelLesson.using == True) url_condition = UrlCondition(query_dict) try: model_lesson = process_query(model_lesson, url_condition.filter_dict, url_condition.sort_limit_dict, ModelLesson).first() except Exception as e: raise CustomError(500, 500, str(e)) return cls.formatter(model_lesson) @classmethod def get_model_lesson_by_lesson_id(cls, query_dict: dict, unscoped: bool = False): model_lesson = ModelLesson.query if not unscoped: model_lesson = model_lesson.filter(ModelLesson.using == True) url_condition = UrlCondition(query_dict) try: model_lesson = process_query(model_lesson, url_condition.filter_dict, url_condition.sort_limit_dict, ModelLesson).first() except Exception as e: raise CustomError(500, 500, str(e)) return cls.formatter(model_lesson) @classmethod def insert_model_lesson(cls, ctx: bool = True, data: dict = None): if data is None: data = {} print(data) data = cls.reformatter_insert(data) print(data) model_lesson = ModelLesson() for key, value in data.items(): if hasattr(model_lesson, key): setattr(model_lesson, key, value) db.session.add(model_lesson) if ctx: try: db.session.commit() except Exception as e: raise CustomError(500, 500, str(e)) return True @classmethod def query_model_lessons(cls, query_dict: dict = None, unscoped: bool = False): if query_dict is None: query_dict = {} query = ModelLesson.query if not unscoped: query = query.filter(ModelLesson.using == True) url_condition = UrlCondition(query_dict) try: query = process_query(query, url_condition.filter_dict, url_condition.sort_limit_dict, ModelLesson) (model_lessons, total) = page_query(query, url_condition.page_dict) except Exception as e: raise CustomError(500, 500, str(e)) return [cls.formatter(model_lesson) for model_lesson in model_lessons], total @classmethod def delete_model_lesson(cls, ctx: bool = True, query_dict: dict = None): if query_dict is None: query_dict = {} query = ModelLesson.query.filter(ModelLesson.using == True) url_condition = UrlCondition(query_dict) try: query = process_query(query, url_condition.filter_dict, url_condition.sort_limit_dict, ModelLesson) (model_lessons, total) = page_query(query, url_condition.page_dict) except Exception as e: raise CustomError(500, 500, str(e)) for model_lesson in model_lessons: model_lesson.using = False db.session.add(model_lesson) if ctx: try: db.session.commit() except Exception as e: raise CustomError(500, 500, str(e)) return True @classmethod def update_model_lesson(cls, ctx: bool = True, query_dict: dict = None, data: dict = None): if data is None: data = {} if query_dict is None: query_dict = {} data = cls.reformatter_update(data) query = ModelLesson.query.filter(ModelLesson.using == True) url_condition = UrlCondition(query_dict) try: query = process_query(query, url_condition.filter_dict, url_condition.sort_limit_dict, ModelLesson) (model_lessons, total) = page_query(query, url_condition.page_dict) except Exception as e: raise CustomError(500, 500, str(e)) for model_lesson in model_lessons: for key, value in data.items(): if hasattr(model_lesson, key): setattr(model_lesson, key, value) db.session.add(model_lesson) if ctx: try: db.session.commit() except Exception as e: raise CustomError(500, 500, str(e)) return True
class OriginLessons(db.Model): __tablename__ = 'origin_lessons' id = db.Column(db.Integer, primary_key=True, autoincrement=True, index=True) lesson_id = db.Column(db.String(32), default='') # 被关注课程的id lesson_attribute = db.Column(db.String(8), default='') lesson_state = db.Column(db.String(8), default='') lesson_level = db.Column(db.String(8), default='') lesson_name = db.Column(db.String(32), default='') lesson_teacher_id = db.Column(db.String(48), default='', index=True) lesson_teacher_letter = db.Column(db.String(32), default='') lesson_teacher_name = db.Column(db.String(8), default='') lesson_teacher_unit = db.Column(db.String(16), default='') lesson_unit = db.Column(db.String(16), default='') lesson_year = db.Column(db.String(32), default='', index=True) lesson_semester = db.Column(db.String(32), default='', index=True) lesson_week = db.Column(db.String(255), default='', index=True) lesson_time = db.Column(db.String(255), default='') lesson_room = db.Column(db.String(255), default='') lesson_class = db.Column(db.String(255), default='', index=True) lesson_type = db.Column(db.String(8), default='') lesson_weekday = db.Column(db.String(8), default='', index=True) lesson_grade = db.Column(db.String(64), default='') assign_group = db.Column(db.String(32), default='') # @classmethod # def formatter(cls, origin_lesson): # if origin_lesson is None: # return None # origin_lesson_dict = { # 'id': origin_lesson.id, # 'lesson_id': origin_lesson.lesson_id, # 'lesson_attribute': origin_lesson.lesson_attribute, # 'lesson_state': origin_lesson.lesson_state, # 'lesson_level': origin_lesson.lesson_level, # 'lesson_name': origin_lesson.lesson_name, # 'lesson_teacher_id': origin_lesson.lesson_teacher_id, # 'lesson_teacher_name': origin_lesson.lesson_teacher_name, # 'lesson_teacher_unit': origin_lesson.lesson_teacher_unit, # 'lesson_unit': origin_lesson.lesson_unit, # 'lesson_year': origin_lesson.lesson_year, # 'lesson_semester': origin_lesson.lesson_semester, # 'lesson_week': origin_lesson.lesson_week, # 'lesson_weekday': origin_lesson.lesson_weekday, # 'lesson_time': origin_lesson.lesson_time, # 'lesson_room': origin_lesson.lesson_room, # 'lesson_class': origin_lesson.lesson_class, # # } # return origin_lesson_dict @classmethod def delete_all(cls): OriginLessons.query.delete() @classmethod def insert(cls, data): raw_lesson = OriginLessons() for key, value in data.items(): if hasattr(raw_lesson, key): setattr(raw_lesson, key, value) db.session.add(raw_lesson) try: db.session.commit() except Exception as e: print(str(e)) db.session.rollback()
class WorkPlan(db.Model): __tablename__ = 'work_plans' id = db.Column(db.Integer, primary_key=True, autoincrement=True, index=True) term = db.Column(db.String(20)) form_meta_name = db.Column(db.String(20)) form_meta_version = db.Column(db.String(20)) status = db.Column(db.String(20)) using = db.Column(db.Boolean, default=True) @classmethod def formatter(cls, work_plan): if work_plan is None: return None try: work_plan_dict = { 'id': work_plan.id, 'term': work_plan.term, 'form_meta_name': work_plan.form_meta_name, 'form_meta_version': work_plan.form_meta_version, 'status': work_plan.status } except Exception as e: raise CustomError(500, 500, str(e)) return work_plan_dict @classmethod def reformatter_insert(cls, data: dict): return data @classmethod def reformatter_update(cls, data: dict): return data @classmethod def insert_work_plan(cls, ctx: bool = True, data: dict = None): if data is None: data = dict() data = cls.reformatter_insert(data) work_plan = WorkPlan() for key, value in data.items(): if hasattr(work_plan, key): setattr(work_plan, key, value) db.session.add(work_plan) if ctx: try: db.session.commit() except Exception as e: raise CustomError(500, 500, str(e)) return True @classmethod def query_work_plan(cls, query_dict: dict = None, unscoped: bool = False): if query_dict is None: query_dict = dict() query = WorkPlan.query if not unscoped: query = query.filter(WorkPlan.using == True) url_condition = mysql_url_condition.UrlCondition(query_dict) try: query = mysql_url_condition.process_query( query, url_condition.filter_dict, url_condition.sort_limit_dict, WorkPlan) (res, total) = mysql_url_condition.page_query(query, url_condition.page_dict) except Exception as e: raise CustomError(500, 500, str(e)) return [cls.formatter(data) for data in res], total @classmethod def get_work_plan(cls, query_dict: dict, unscoped: bool = False): work_plan = WorkPlan.query if not unscoped: work_plan = work_plan.filter(WorkPlan.using == True) url_condition = mysql_url_condition.UrlCondition(query_dict) try: work_plan = mysql_url_condition.process_query( work_plan, url_condition.filter_dict, url_condition.sort_limit_dict, WorkPlan).first() except Exception as e: raise CustomError(500, 500, str(e)) return cls.formatter(work_plan) @classmethod def delete_work_plan(cls, ctx: bool = True, query_dict: dict = None): if query_dict is None: query_dict = dict() query = WorkPlan.query.filter(WorkPlan.using == True) url_condition = mysql_url_condition.UrlCondition(query_dict) try: query = mysql_url_condition.process_query( query, url_condition.filter_dict, url_condition.sort_limit_dict, WorkPlan) (work_plans, total) = mysql_url_condition.page_query(query, url_condition.page_dict) except Exception as e: raise CustomError(500, 500, str(e)) for work_plan in work_plans: work_plan.using = False db.session.add(work_plan) if ctx: try: db.session.commit() except Exception as e: raise CustomError(500, 500, str(e)) return True @classmethod def update_work_plan(cls, ctx: bool = True, query_dict: dict = None, data: dict = None): if data is None: data = dict() if query_dict is None: query_dict = dict() data = cls.reformatter_update(data) query = WorkPlan.query.filter(WorkPlan.using == True) url_condition = mysql_url_condition.UrlCondition(query_dict) try: query = mysql_url_condition.process_query( query, url_condition.filter_dict, url_condition.sort_limit_dict, WorkPlan) (work_plans, total) = mysql_url_condition.page_query(query, url_condition.page_dict) except Exception as e: raise CustomError(500, 500, str(e)) for work_plan in work_plans: for key, value in data.items(): if hasattr(work_plan, key): setattr(work_plan, key, value) db.session.add(work_plan) if ctx: try: db.session.commit() except Exception as e: raise CustomError(500, 500, str(e)) return True
class Consult(db.Model): __tablename__ = 'consults' id = db.Column(db.Integer, primary_key=True, autoincrement=True, index=True) type = db.Column(db.String(16), nullable=False, default='') submit_time = db.Column(db.TIMESTAMP, nullable=False, default=datetime.now) answer_time = db.Column(db.TIMESTAMP, nullable=False, default=datetime.now, server_default=text('NOW()')) term = db.Column(db.String(16), default='') state = db.Column(db.String(16), default='') meta_description = db.Column(db.String(255), default='') phone = db.Column(db.String(24), default='') content = db.Column(db.String(255), default=-1) requester_username = db.Column(db.String(16), default='') responsor_username = db.Column(db.String(16), default='') using = db.Column(db.Boolean, default=True) @classmethod def formatter(cls, consult): if consult is None: return None try: consult_dict = { 'id': consult.id, 'type': consult.type, 'requester_username': consult.requester_username, 'submit_time': str(consult.submit_time), 'answer_time': str(consult.answer_time), 'term': consult.term, 'state': consult.state, 'meta_description': consult.meta_description, 'phone': consult.phone, 'responsor_username': consult.responsor_username, 'content': consult.content } except Exception as e: raise CustomError(500, 500, str(e)) return consult_dict @classmethod def reformatter_insert(cls, data: dict): return data @classmethod def reformatter_update(cls, data: dict): return data @classmethod def count(cls, query_dict: dict, unscoped: bool = False): if query_dict is None: query_dict = {} query = Consult.query if not unscoped: query = query.filter(Consult.using == True) url_condition = UrlCondition(query_dict) try: total = count_query(query, url_condition.filter_dict, url_condition.sort_limit_dict, Consult) except Exception as e: raise CustomError(500, 500, str(e)) return total @classmethod def get_consult(cls, query_dict: dict, unscoped: bool = False): consult = Consult.query if not unscoped: consult = consult.filter(Consult.using == True) url_condition = UrlCondition(query_dict) try: consult = process_query(consult, url_condition.filter_dict, url_condition.sort_limit_dict, Consult).first() except Exception as e: raise CustomError(500, 500, str(e)) return cls.formatter(consult) @classmethod def insert_consult(cls, ctx: bool = True, data: dict = None): if data is None: data = {} data = cls.reformatter_insert(data) consult = Consult() for key, value in data.items(): if hasattr(consult, key): setattr(consult, key, value) db.session.add(consult) if ctx: try: db.session.commit() except Exception as e: raise CustomError(500, 500, str(e)) return True @classmethod def query_consults(cls, query_dict: dict = None, unscoped: bool = False): if query_dict is None: query_dict = {} query = Consult.query if not unscoped: query = query.filter(Consult.using == True) url_condition = UrlCondition(query_dict) try: query = process_query(query, url_condition.filter_dict, url_condition.sort_limit_dict, Consult) (consults, total) = page_query(query, url_condition.page_dict) except Exception as e: raise CustomError(500, 500, str(e)) return [cls.formatter(consult) for consult in consults], total @classmethod def delete_consult(cls, ctx: bool = True, query_dict: dict = None): if query_dict is None: query_dict = {} query = Consult.query.filter(Consult.using == True) url_condition = UrlCondition(query_dict) try: query = process_query(query, url_condition.filter_dict, url_condition.sort_limit_dict, Consult) (consults, total) = page_query(query, url_condition.page_dict) except Exception as e: raise CustomError(500, 500, str(e)) for consult in consults: consult.using = False db.session.add(consult) if ctx: try: db.session.commit() except Exception as e: raise CustomError(500, 500, str(e)) return True @classmethod def update_consult(cls, ctx: bool = True, query_dict: dict = None, data: dict = None): if data is None: data = {} if query_dict is None: query_dict = {} data = cls.reformatter_update(data) query = Consult.query.filter(Consult.using == True) url_condition = UrlCondition(query_dict) try: query = process_query(query, url_condition.filter_dict, url_condition.sort_limit_dict, Consult) (consults, total) = page_query(query, url_condition.page_dict) except Exception as e: raise CustomError(500, 500, str(e)) for consult in consults: for key, value in data.items(): if hasattr(consult, key): setattr(consult, key, value) db.session.add(consult) if ctx: try: db.session.commit() except Exception as e: raise CustomError(500, 500, str(e)) return True