예제 #1
0
    def insert_form(cls, data: dict = None):
        if data is None:
            data = dict()
        meta = data.get('meta', {})
        lesson_id = meta.get('lesson', {}).get('lesson_id', None)
        if lesson_id is None:
            raise CustomError(500, 200, '课程不能为空')
        if not FormService.check_lesson_meta(meta):
            raise CustomError(500, 200, '该督导在该时间段, 听过别的课!时间冲突!')
        dao.Form.insert_form(data)

        form_model = dao.Form.formatter_total(data)
        LessonService.refresh_notices(
            data.get("meta", {}).get("lesson", {}).get("lesson_id"))  #刷新听课次数
        ModelLessonService.refresh_vote_nums(
            data.get("meta", {}).get("lesson", {}).get("lesson_id"))  #刷新好评课程次数
        send_kafka_message(topic='form_service',
                           method='add_form',
                           term=meta.get('term', None),
                           bind_meta_name=form_model.get(
                               'bind_meta_name', None),
                           username=meta.get('guider', None),
                           form_id=form_model.get('_id', ''),
                           lesson_id=lesson_id)
        cls.push_new_form_message(form_model)
        return True
예제 #2
0
 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
예제 #3
0
 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
예제 #4
0
 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
예제 #5
0
 def query_forms(cls, query_dict: dict = None, unscoped: bool = False):
     from app.utils.mongodb import mongo
     if query_dict is None:
         query_dict = dict()
     if not unscoped:
         query_dict['using'] = [True]
     url_condition = mongodb_url_condition.UrlCondition(query_dict)
     if len(url_condition.filter_dict) == 0:
         try:
             datas = mongo.db.form.find()
         except Exception as e:
             raise CustomError(code=500, status_code=500, err_info=str(e))
         return datas, datas.count()
     if '_id' in url_condition.filter_dict:
         url_condition.filter_dict['_id']['$in'] = [
             mongodb_url_condition.ObjectId(item)
             for item in url_condition.filter_dict['_id']['$in']
         ]
     try:
         datas = mongo.db.form.find(url_condition.filter_dict)
     except Exception as e:
         raise CustomError(500, 500, str(e))
     datas = mongodb_url_condition.sort_limit(datas,
                                              url_condition.sort_limit_dict)
     paginate = mongodb_url_condition.Paginate(datas,
                                               url_condition.page_dict)
     datas = paginate.data_page
     return [cls.formatter_simple(data=data)
             for data in datas], paginate.total
예제 #6
0
 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
예제 #7
0
 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
예제 #8
0
    def update_form(cls, _id=None, data: dict = None):
        if data is None:
            data = dict()
        form = dao.Form.get_form(query_dict={'_id': _id})
        if form is None:
            raise CustomError(404, 404, 'form not found')
        dao.Form.update_form({'_id': _id}, data)
        if 'status' in data:
            form = dao.Form.get_form(query_dict={'_id': _id})
            if form is None:
                raise CustomError(404, 404, 'form not found')
            lesson_id = form.get('meta', {}).get('lesson', {}).get('lesson_id', None)
            if data.get('status') == '待提交':
                send_kafka_message(topic='form_service',
                                   method='repulse_form',
                                   term=form.get('meta', {}).get('term', None),
                                   username=form.get('meta', {}).get('guider', None),
                                   form=form,
                                   lesson_id=lesson_id)
                cls.push_put_back_form_message(form)
            if data.get('status') == '已提交':
                send_kafka_message(topic='form_service',
                                   method='add_form',
                                   lesson_id=lesson_id)

        return True
예제 #9
0
 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
예제 #10
0
 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
예제 #11
0
 def delete_form(cls, where_dict: dict = None):
     from app.utils.mongodb import mongo
     if where_dict is None:
         raise CustomError(500, 500, 'condition can not be None')
     try:
         mongo.db.form.update(where_dict, {'$set': {'using': False}})
     except Exception as e:
         raise CustomError(500, 500, str(e))
     return True
예제 #12
0
 def get_form_meta(cls, query_dict: dict = None, unscoped: bool = False):
     if query_dict is None:
         query_dict = dict()
     if not query_dict.get('name', None):
         raise CustomError(500, 200, 'name must be given')
     from app.utils.mongodb import mongo
     if not unscoped:
         query_dict['using'] = [True]
     url_condition = mongodb_url_condition.UrlCondition(query_dict)
     try:
         data = mongo.db.form_meta.find_one(url_condition.filter_dict)
     except Exception as e:
         raise CustomError(500, 500, str(e))
     return cls.formatter_total(data)
예제 #13
0
 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
예제 #14
0
 def update_form(cls, where_dict: dict = None, data: dict = None):
     if data is None:
         data = dict()
     from app.utils.mongodb import mongo
     if where_dict is None:
         condition = dict()
         condition['using'] = True
     if data is None:
         raise CustomError(200, 500, 'change data can not be None')
     try:
         mongo.db.form.update(where_dict, {'$set': data})
     except Exception as e:
         raise CustomError(500, 500, str(e))
     return True
예제 #15
0
 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
예제 #16
0
 def query_teacher_names(cls,
                         query_dict: dict = None,
                         unscoped: bool = False):
     if query_dict is None:
         query_dict = {}
     query = NoticeLesson.query.with_entities(
         NoticeLesson.lesson_teacher_id, NoticeLesson.lesson_teacher_name,
         NoticeLesson.lesson_teacher_unit,
         NoticeLesson.lesson_attention_reason,
         NoticeLesson.group_name).distinct()
     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)
         (lessons, total) = page_query(query, url_condition.page_dict)
         print(lessons)
     except Exception as e:
         raise CustomError(500, 500, str(e))
     return [{
         'lesson_teacher_name': data.lesson_teacher_name,
         'lesson_teacher_id': data.lesson_teacher_id,
         'lesson_teacher_unit': data.lesson_teacher_unit,
         'lesson_attention_reason': data.lesson_attention_reason,
         'group_name': data.group_name
     } for data in lessons], total
예제 #17
0
 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)
예제 #18
0
 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)
예제 #19
0
 def formatter(cls, lesson_record):
     if lesson_record is None:
         return None
     try:
         lesson_record_dict = misc.model_to_dict(lesson_record)
     except Exception as e:
         raise CustomError(500, 500, str(e))
     return lesson_record_dict
예제 #20
0
 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)
예제 #21
0
 def get_now_term(cls):
     date = datetime.now()
     (terms, num) = dao.Term.query_terms(query_dict={
         'begin_time_lte': [str(date)],
         'end_time_gte': [str(date)]
     })
     if num == 0:
         raise CustomError(500, 200, 'term not exist')
     return terms[0]
예제 #22
0
 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
예제 #23
0
 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
예제 #24
0
 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):
             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
예제 #25
0
 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
예제 #26
0
 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
예제 #27
0
 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
예제 #28
0
 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
예제 #29
0
 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)
예제 #30
0
 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)