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
