接口增加异常捕获

src/app/api/data.py

@@ -43,28 +43,32 @@ class TemplateConfigListApi(Resource):
         report_type = request.args.get('report_type')
         template_type = request.args.get('template_type')
 
-        with Session(current_app.engine) as session:
-            stmt = select(Template).where(Template.template_type == template_type)
+        try:
+            with Session(current_app.engine) as session:
+                stmt = select(Template).where(Template.template_type == template_type)
 
-            count = select(func.count(Template.id)).where(Template.template_type == template_type)
-            count_results = session.execute(count).scalars().first()
+                count = select(func.count(Template.id)).where(Template.template_type == template_type)
+                count_results = session.execute(count).scalars().first()
 
-            if template_name:
-                stmt = stmt.where(Template.name == template_name)
+                if template_name:
+                    stmt = stmt.where(Template.name == template_name)
 
-            if template_format:
-                stmt = stmt.where(Template.format == template_format)
+                if template_format:
+                    stmt = stmt.where(Template.format == template_format)
 
-            if report_type:
-                stmt = stmt.where(Template.report_type == report_type)
+                if report_type:
+                    stmt = stmt.where(Template.report_type == report_type)
 
-            stmt = stmt.offset(page_size * (page - 1)).limit(page_size)
+                stmt = stmt.offset(page_size * (page - 1)).limit(page_size)
 
-            results = session.execute(stmt).scalars().all()
+                results = session.execute(stmt).scalars().all()
 
-        save_log(request, Module.DATA, OperationType.INQUIRE, StatesCode.SUCCESS)
+            save_log(request, Module.DATA, OperationType.INQUIRE, StatesCode.SUCCESS)
 
-        return jsonify(code=StatesCode.SUCCESS, message='成功', total=count_results, data=to_dict(results))
+            return jsonify(code=StatesCode.SUCCESS, message='成功', total=count_results, data=to_dict(results))
+        except Exception as e:
+            save_log(request, Module.DATA, OperationType.INQUIRE, StatesCode.UNKNOWN_ERROR)
+            return jsonify(code=StatesCode.UNKNOWN_ERROR, message=str(e))
 
 
 template = reqparse.RequestParser(bundle_errors=True)
@@ -92,15 +96,19 @@ class TemplateConfigApi(Resource):
         template_id = request.args.get('template_id')
 
         if template_id is None:
-            return jsonify(code=StatesCode.UNKNOWN_ERROR, message='模版id不能为空')
+            return jsonify(code=StatesCode.PARA_ERROR, message='模版id不能为空')
 
-        with Session(current_app.engine) as session:
-            stmt = select(Template).where(Template.id == template_id)
-            results = session.execute(stmt).scalars().all()
+        try:
+            with Session(current_app.engine) as session:
+                stmt = select(Template).where(Template.id == template_id)
+                results = session.execute(stmt).scalars().all()
 
-        save_log(request, Module.DATA, OperationType.INQUIRE, StatesCode.SUCCESS)
+            save_log(request, Module.DATA, OperationType.INQUIRE, StatesCode.SUCCESS)
 
-        return jsonify(code=StatesCode.SUCCESS, message='获取成功', data=to_dict(results))
+            return jsonify(code=StatesCode.SUCCESS, message='获取成功', data=to_dict(results))
+        except Exception as e:
+            save_log(request, Module.DATA, OperationType.INQUIRE, StatesCode.UNKNOWN_ERROR)
+            return jsonify(code=StatesCode.UNKNOWN_ERROR, message=str(e))
 
     @ns.doc(id='add_template', description='添加报表模版')
     @ns.expect(building_details)
@@ -114,7 +122,7 @@ class TemplateConfigApi(Resource):
         template_type = request.form.get('template_type')
 
         if template_name is None and template_type is None:
-            return jsonify(code=StatesCode.UNKNOWN_ERROR, message='报表模版名和模版类型不能为空')
+            return jsonify(code=StatesCode.PARA_ERROR, message='报表模版名和模版类型不能为空')
 
         # 模版存储（url），
         if template_file:
@@ -123,32 +131,36 @@ class TemplateConfigApi(Resource):
         else:
             template_url = None
 
-        with Session(current_app.engine) as session:
-            # 判断是否存在
-            stmt = select(Template).where(Template.name == template_name)
-            result = session.execute(stmt).scalars().first()
-            if result:
-                return jsonify(code=StatesCode.UNKNOWN_ERROR, message="模版已存在")
-
-            # 添加
-            stmt = insert(Template).values(
-                name=template_name,
-                format=template_format,
-                introduction=introduction,
-                report_type=report_type,
-                creator=g.user_name,
-                create_time=cn_now(),
-                update_time=cn_now(),
-                template_url=template_url,
-                template_type=template_type
-            )
-            session.execute(stmt)
-
-            session.commit()
-
-        save_log(request, Module.DATA, OperationType.ADD, StatesCode.SUCCESS)
-
-        return jsonify(code=StatesCode.SUCCESS, message='添加成功')
+        try:
+            with Session(current_app.engine) as session:
+                # 判断是否存在
+                stmt = select(Template).where(Template.name == template_name)
+                result = session.execute(stmt).scalars().first()
+                if result:
+                    return jsonify(code=StatesCode.UNKNOWN_ERROR, message="模版已存在")
+
+                # 添加
+                stmt = insert(Template).values(
+                    name=template_name,
+                    format=template_format,
+                    introduction=introduction,
+                    report_type=report_type,
+                    creator=g.user_name,
+                    create_time=cn_now(),
+                    update_time=cn_now(),
+                    template_url=template_url,
+                    template_type=template_type
+                )
+                session.execute(stmt)
+
+                session.commit()
+
+            save_log(request, Module.DATA, OperationType.ADD, StatesCode.SUCCESS)
+
+            return jsonify(code=StatesCode.SUCCESS, message='添加成功')
+        except Exception as e:
+            save_log(request, Module.DATA, OperationType.ADD, StatesCode.UNKNOWN_ERROR)
+            return jsonify(code=StatesCode.UNKNOWN_ERROR, message=str(e))
 
     @ns.doc(id='update_templatet', description='修改模版信息')
     @ns.expect(building_details)
@@ -163,7 +175,7 @@ class TemplateConfigApi(Resource):
         template_type = request.form.get('template_type')
 
         if template_id is None or template_name is None:
-            return jsonify(code=StatesCode.UNKNOWN_ERROR, message="模版id和模版名不能为空")
+            return jsonify(code=StatesCode.PARA_ERROR, message="模版id和模版名不能为空")
 
         # 报表模版存储（url），
         if template_file:
@@ -171,25 +183,28 @@ class TemplateConfigApi(Resource):
             template_url = config.common.TEMPLATE_FILE_URL + template_file.filename
         else:
             template_url = None
+        try:
+            with Session(current_app.engine) as session:
+                stmt = update(Template).where(Template.id == template_id).values(
+                    name=template_name,
+                    format=template_format,
+                    introduction=introduction,
+                    report_type=report_type,
+                    creator=g.user_name,
+                    create_time=cn_now(),
+                    update_time=cn_now(),
+                    template_url=template_url,
+                    template_type=template_type
+                )
+                session.execute(stmt)
+                session.commit()
+
+            save_log(request, Module.DATA, OperationType.UPDATE, StatesCode.SUCCESS)
 
-        with Session(current_app.engine) as session:
-            stmt = update(Template).where(Template.id == template_id).values(
-                name=template_name,
-                format=template_format,
-                introduction=introduction,
-                report_type=report_type,
-                creator=g.user_name,
-                create_time=cn_now(),
-                update_time=cn_now(),
-                template_url=template_url,
-                template_type=template_type
-            )
-            session.execute(stmt)
-            session.commit()
-
-        save_log(request, Module.DATA, OperationType.UPDATE, StatesCode.SUCCESS)
-
-        return jsonify(code=StatesCode.SUCCESS, message='修改成功')
+            return jsonify(code=StatesCode.SUCCESS, message='修改成功')
+        except Exception as e:
+            save_log(request, Module.DATA, OperationType.UPDATE, StatesCode.UNKNOWN_ERROR)
+            return jsonify(code=StatesCode.UNKNOWN_ERROR, message=str(e))
 
     @ns.doc(id='delete_template', description='删除模版')
     @ns.expect(building_details)
@@ -198,16 +213,20 @@ class TemplateConfigApi(Resource):
         template_id = request.form.get('template_id')
 
         if template_id is None:
-            return jsonify(code=StatesCode.UNKNOWN_ERROR, message="模版id不能为空")
+            return jsonify(code=StatesCode.PARA_ERROR, message="模版id不能为空")
 
-        with Session(current_app.engine) as session:
-            stmt = delete(Template).where(Template.id == template_id)
-            session.execute(stmt)
-            session.commit()
+        try:
+            with Session(current_app.engine) as session:
+                stmt = delete(Template).where(Template.id == template_id)
+                session.execute(stmt)
+                session.commit()
 
-        save_log(request, Module.DATA, OperationType.DELETE, StatesCode.SUCCESS)
+            save_log(request, Module.DATA, OperationType.DELETE, StatesCode.SUCCESS)
 
-        return jsonify(code=StatesCode.SUCCESS, message='删除成功')
+            return jsonify(code=StatesCode.SUCCESS, message='删除成功')
+        except Exception as e:
+            save_log(request, Module.DATA, OperationType.DELETE, StatesCode.UNKNOWN_ERROR)
+            return jsonify(code=StatesCode.UNKNOWN_ERROR, message=str(e))
 
 
 batch_delete_template = reqparse.RequestParser(bundle_errors=True)
@@ -227,19 +246,23 @@ class BatchTemplateConfigApi(Resource):
         if template_ids is not None:
             template_ids = json.loads(template_ids)
         else:
-            return jsonify(code=StatesCode.UNKNOWN_ERROR, message='模版id不能为空')
+            return jsonify(code=StatesCode.PARA_ERROR, message='模版id不能为空')
 
-        with Session(current_app.engine) as session:
-            stmt = select(Template).where(Template.id.in_(template_ids))
-            results = session.execute(stmt).scalars().all()
+        try:
+            with Session(current_app.engine) as session:
+                stmt = select(Template).where(Template.id.in_(template_ids))
+                results = session.execute(stmt).scalars().all()
 
-            for result in results:
-                session.delete(result)
-            session.commit()
+                for result in results:
+                    session.delete(result)
+                session.commit()
 
-        save_log(request, Module.DATA, OperationType.BATCH_DELETE, StatesCode.SUCCESS)
+            save_log(request, Module.DATA, OperationType.BATCH_DELETE, StatesCode.SUCCESS)
 
-        return jsonify(code=StatesCode.SUCCESS, message='批量删除成功')
+            return jsonify(code=StatesCode.SUCCESS, message='批量删除成功')
+        except Exception as e:
+            save_log(request, Module.DATA, OperationType.BATCH_DELETE, StatesCode.UNKNOWN_ERROR)
+            return jsonify(code=StatesCode.UNKNOWN_ERROR, message=str(e))
 
 
 company_id = reqparse.RequestParser(bundle_errors=True)
@@ -266,15 +289,20 @@ class CompanyApi(Resource):
         company_id = request.args.get('company_id')
 
         if company_id is None:
-            return jsonify(code=StatesCode.UNKNOWN_ERROR, message='公司id不能为空')
+            return jsonify(code=StatesCode.PARA_ERROR, message='公司id不能为空')
 
-        with Session(current_app.engine) as session:
-            stmt = select(CompanyData).where(CompanyData.id == company_id)
-            results = session.execute(stmt).scalars().all()
+        try:
+            with Session(current_app.engine) as session:
+                stmt = select(CompanyData).where(CompanyData.id == company_id)
+                results = session.execute(stmt).scalars().all()
+
+            save_log(request, Module.DATA, OperationType.INQUIRE, StatesCode.SUCCESS)
 
-        save_log(request, Module.DATA, OperationType.INQUIRE, StatesCode.SUCCESS)
+            return jsonify(code=StatesCode.SUCCESS, message='获取成功', data=to_dict(results))
 
-        return jsonify(code=StatesCode.SUCCESS, message='获取成功', data=to_dict(results))
+        except Exception as e:
+            save_log(request, Module.DATA, OperationType.INQUIRE, StatesCode.UNKNOWN_ERROR)
+            return jsonify(code=StatesCode.UNKNOWN_ERROR, message=str(e))
 
     @ns.doc(id='add_company', description='添加公司信息')
     @ns.expect(company_data)
@@ -297,29 +325,33 @@ class CompanyApi(Resource):
                 picture.save(os.path.join(config.common.COMPANY_PICTURE_PATH, picture.filename))
                 picture_urls.append(config.common.COMPANY_PICTURE_URL + picture.filename)
 
-        with Session(current_app.engine) as session:
-            # 判断是否存在
-            stmt = select(CompanyData).where(CompanyData.management_unit == management_unit)
-            result = session.execute(stmt).scalars().first()
-            if result:
-                return jsonify(code=StatesCode.UNKNOWN_ERROR, message="管理单位已存在")
-
-            # 添加
-            stmt = insert(CompanyData).values(
-                management_unit=management_unit,
-                custodian_unit=custodian_unit,
-                introduction=introduction,
-                contact_person=contact_person,
-                contact_information=contact_information,
-                picture=json.dumps(picture_urls),
-            )
-            session.execute(stmt)
+        try:
+            with Session(current_app.engine) as session:
+                # 判断是否存在
+                stmt = select(CompanyData).where(CompanyData.management_unit == management_unit)
+                result = session.execute(stmt).scalars().first()
+                if result:
+                    return jsonify(code=StatesCode.UNKNOWN_ERROR, message="管理单位已存在")
+
+                # 添加
+                stmt = insert(CompanyData).values(
+                    management_unit=management_unit,
+                    custodian_unit=custodian_unit,
+                    introduction=introduction,
+                    contact_person=contact_person,
+                    contact_information=contact_information,
+                    picture=json.dumps(picture_urls),
+                )
+                session.execute(stmt)
 
-            session.commit()
+                session.commit()
 
-        save_log(request, Module.DATA, OperationType.ADD, StatesCode.SUCCESS)
+            save_log(request, Module.DATA, OperationType.ADD, StatesCode.SUCCESS)
 
-        return jsonify(code=StatesCode.SUCCESS, message='新增成功')
+            return jsonify(code=StatesCode.SUCCESS, message='新增成功')
+        except Exception as e:
+            save_log(request, Module.DATA, OperationType.ADD, StatesCode.UNKNOWN_ERROR)
+            return jsonify(code=StatesCode.UNKNOWN_ERROR, message=str(e))
 
     @ns.doc(id='update_company', description='修改公司信息')
     @ns.expect(company_data)
@@ -335,7 +367,7 @@ class CompanyApi(Resource):
         pictures = request.files.getlist('picture')
 
         if company_id is None:
-            return jsonify(code=StatesCode.UNKNOWN_ERROR, message='公司id不能为空')
+            return jsonify(code=StatesCode.PARA_ERROR, message='公司id不能为空')
 
         # 多图片存储（url），
         picture_urls = []
@@ -344,22 +376,26 @@ class CompanyApi(Resource):
                 picture.save(os.path.join(config.common.COMPANY_PICTURE_PATH, picture.filename))
                 picture_urls.append(config.common.COMPANY_PICTURE_URL + picture.filename)
 
-        with Session(current_app.engine) as session:
-            stmt = update(CompanyData).where(CompanyData.id == company_id).values(
-                management_unit=management_unit,
-                custodian_unit=custodian_unit,
-                introduction=introduction,
-                contact_person=contact_person,
-                contact_information=contact_information,
-                picture=json.dumps(picture_urls),
-            )
+        try:
+            with Session(current_app.engine) as session:
+                stmt = update(CompanyData).where(CompanyData.id == company_id).values(
+                    management_unit=management_unit,
+                    custodian_unit=custodian_unit,
+                    introduction=introduction,
+                    contact_person=contact_person,
+                    contact_information=contact_information,
+                    picture=json.dumps(picture_urls),
+                )
 
-            session.execute(stmt)
-            session.commit()
+                session.execute(stmt)
+                session.commit()
 
-        save_log(request, Module.DATA, OperationType.UPDATE, StatesCode.SUCCESS)
+            save_log(request, Module.DATA, OperationType.UPDATE, StatesCode.SUCCESS)
 
-        return jsonify(code=StatesCode.SUCCESS, message='修改成功')
+            return jsonify(code=StatesCode.SUCCESS, message='修改成功')
+        except Exception as e:
+            save_log(request, Module.DATA, OperationType.UPDATE, StatesCode.UNKNOWN_ERROR)
+            return jsonify(code=StatesCode.UNKNOWN_ERROR, message=str(e))
 
 
 @ns.route('/building_list')
@@ -369,14 +405,17 @@ class BuildingListApi(Resource):
     @ns.doc(id='building_list', description='获取楼宇列表')
     def get(self):
         """获取楼宇列表"""
+        try:
+            with Session(current_app.engine) as session:
+                stmt = select(Building)
+                results = session.execute(stmt).scalars().all()
 
-        with Session(current_app.engine) as session:
-            stmt = select(Building)
-            results = session.execute(stmt).scalars().all()
-
-        save_log(request, Module.DATA, OperationType.INQUIRE, StatesCode.SUCCESS)
+            save_log(request, Module.DATA, OperationType.INQUIRE, StatesCode.SUCCESS)
 
-        return jsonify(code=StatesCode.SUCCESS, message='获取成功', data=to_dict(results))
+            return jsonify(code=StatesCode.SUCCESS, message='获取成功', data=to_dict(results))
+        except Exception as e:
+            save_log(request, Module.DATA, OperationType.INQUIRE, StatesCode.UNKNOWN_ERROR)
+            return jsonify(code=StatesCode.UNKNOWN_ERROR, message=str(e))
 
 
 building = reqparse.RequestParser(bundle_errors=True)
@@ -406,15 +445,19 @@ class BuildingApi(Resource):
         building_id = request.args.get('building_id')
 
         if building_id is None:
-            return jsonify(code=StatesCode.UNKNOWN_ERROR, message='楼宇id不能为空')
+            return jsonify(code=StatesCode.PARA_ERROR, message='楼宇id不能为空')
 
-        with Session(current_app.engine) as session:
-            stmt = select(Building).where(Building.id == building_id)
-            results = session.execute(stmt).scalars().all()
+        try:
+            with Session(current_app.engine) as session:
+                stmt = select(Building).where(Building.id == building_id)
+                results = session.execute(stmt).scalars().all()
 
-        save_log(request, Module.DATA, OperationType.INQUIRE, StatesCode.SUCCESS)
+            save_log(request, Module.DATA, OperationType.INQUIRE, StatesCode.SUCCESS)
 
-        return jsonify(code=StatesCode.SUCCESS, message='获取成功', data=to_dict(results))
+            return jsonify(code=StatesCode.SUCCESS, message='获取成功', data=to_dict(results))
+        except Exception as e:
+            save_log(request, Module.DATA, OperationType.INQUIRE, StatesCode.UNKNOWN_ERROR)
+            return jsonify(code=StatesCode.UNKNOWN_ERROR, message=str(e))
 
     @ns.doc(id='add_building', description='增加楼宇')
     @ns.expect(building_details)
@@ -440,24 +483,28 @@ class BuildingApi(Resource):
                 picture.save(os.path.join(config.common.BUILDING_PICTURE_PATH, picture.filename))
                 picture_urls.append(config.common.BUILDING_PICTURE_URL + picture.filename)
 
-        with Session(current_app.engine) as session:
-            stmt = insert(Building).values(
-                name=building_name,
-                area=building_area,
-                floor=building_floor,
-                trem=trem,
-                date=date,
-                contact_person=contact_person,
-                contact_information=contact_information,
-                introduction=building_introduction,
-                picture=json.dumps(picture_urls)
-            )
-            session.execute(stmt)
-            session.commit()
-
-        save_log(request, Module.DATA, OperationType.ADD, StatesCode.SUCCESS)
-
-        return jsonify(code=StatesCode.SUCCESS, message='添加成功')
+        try:
+            with Session(current_app.engine) as session:
+                stmt = insert(Building).values(
+                    name=building_name,
+                    area=building_area,
+                    floor=building_floor,
+                    trem=trem,
+                    date=date,
+                    contact_person=contact_person,
+                    contact_information=contact_information,
+                    introduction=building_introduction,
+                    picture=json.dumps(picture_urls)
+                )
+                session.execute(stmt)
+                session.commit()
+
+            save_log(request, Module.DATA, OperationType.ADD, StatesCode.SUCCESS)
+
+            return jsonify(code=StatesCode.SUCCESS, message='添加成功')
+        except Exception as e:
+            save_log(request, Module.DATA, OperationType.ADD, StatesCode.UNKNOWN_ERROR)
+            return jsonify(code=StatesCode.UNKNOWN_ERROR, message=str(e))
 
     @ns.doc(id='update_building', description='修改楼宇')
     @ns.expect(building_details)
@@ -484,24 +531,28 @@ class BuildingApi(Resource):
                 picture.save(os.path.join(config.common.BUILDING_PICTURE_PATH, picture.filename))
                 picture_urls.append(config.common.BUILDING_PICTURE_URL + picture.filename)
 
-        with Session(current_app.engine) as session:
-            stmt = update(Building).where(Building.id == building_id).values(
-                name=building_name,
-                area=building_area,
-                floor=building_floor,
-                trem=trem,
-                date=date,
-                contact_person=contact_person,
-                contact_information=contact_information,
-                introduction=building_introduction,
-                picture=json.dumps(picture_urls)
-            )
-            session.execute(stmt)
-            session.commit()
-
-        save_log(request, Module.DATA, OperationType.UPDATE, StatesCode.SUCCESS)
-
-        return jsonify(code=StatesCode.SUCCESS, message='修改成功')
+        try:
+            with Session(current_app.engine) as session:
+                stmt = update(Building).where(Building.id == building_id).values(
+                    name=building_name,
+                    area=building_area,
+                    floor=building_floor,
+                    trem=trem,
+                    date=date,
+                    contact_person=contact_person,
+                    contact_information=contact_information,
+                    introduction=building_introduction,
+                    picture=json.dumps(picture_urls)
+                )
+                session.execute(stmt)
+                session.commit()
+
+            save_log(request, Module.DATA, OperationType.UPDATE, StatesCode.SUCCESS)
+
+            return jsonify(code=StatesCode.SUCCESS, message='修改成功')
+        except Exception as e:
+            save_log(request, Module.DATA, OperationType.UPDATE, StatesCode.UNKNOWN_ERROR)
+            return jsonify(code=StatesCode.UNKNOWN_ERROR, message=str(e))
 
     @ns.doc(id='delete_building', description='删除楼宇')
     @ns.expect(building_details)
@@ -511,14 +562,18 @@ class BuildingApi(Resource):
         if building_id is None:
             return jsonify(code=StatesCode.UNKNOWN_ERROR, message='楼宇id不能为空')
 
-        with Session(current_app.engine) as session:
-            stmt = delete(Building).where(Building.id == building_id)
-            session.execute(stmt)
-            session.commit()
+        try:
+            with Session(current_app.engine) as session:
+                stmt = delete(Building).where(Building.id == building_id)
+                session.execute(stmt)
+                session.commit()
 
-        save_log(request, Module.DATA, OperationType.DELETE, StatesCode.SUCCESS)
+            save_log(request, Module.DATA, OperationType.DELETE, StatesCode.SUCCESS)
 
-        return jsonify(code=StatesCode.SUCCESS, message='删除成功')
+            return jsonify(code=StatesCode.SUCCESS, message='删除成功')
+        except Exception as e:
+            save_log(request, Module.DATA, OperationType.DELETE, StatesCode.UNKNOWN_ERROR)
+            return jsonify(code=StatesCode.UNKNOWN_ERROR, message=str(e))
 
 
 underlying_system = reqparse.RequestParser(bundle_errors=True)
@@ -534,11 +589,17 @@ class UnderlyingSystemMessageApi(Resource):
     def get(self):
         """获取底层系统"""
 
-        with Session(current_app.engine) as session:
-            stmt = select(UnderlyingSystem)
-            results = session.execute(stmt).scalars().all()
+        try:
+            with Session(current_app.engine) as session:
+                stmt = select(UnderlyingSystem)
+                results = session.execute(stmt).scalars().all()
+
+            save_log(request, Module.DATA, OperationType.INQUIRE, StatesCode.SUCCESS)
 
-        return jsonify(code=StatesCode.SUCCESS, message='添加成功', data=to_dict(results))
+            return jsonify(code=StatesCode.SUCCESS, message='成功', data=to_dict(results))
+        except Exception as e:
+            save_log(request, Module.DATA, OperationType.INQUIRE, StatesCode.UNKNOWN_ERROR)
+            return jsonify(code=StatesCode.UNKNOWN_ERROR, message=str(e))
 
     @ns.doc(id='update_underlying_system', description='添加底层系统')
     @ns.expect(underlying_system)
@@ -551,11 +612,18 @@ class UnderlyingSystemMessageApi(Resource):
             picture.save(os.path.join(config.common.UNDERLYING_SYSTEM_PICTURE_PATH, picture.filename))
             picture_url = config.common.UNDERLYING_SYSTEM_PICTURE_URL + picture.filename
 
-            with Session(current_app.engine) as session:
-                stmt = insert(UnderlyingSystem).values(
-                    picture=picture_url
-                )
-                session.execute(stmt)
-                session.commit()
+            try:
+                with Session(current_app.engine) as session:
+                    stmt = insert(UnderlyingSystem).values(
+                        picture=picture_url
+                    )
+                    session.execute(stmt)
+                    session.commit()
+
+                save_log(request, Module.DATA, OperationType.ADD, StatesCode.SUCCESS)
+
+                return jsonify(code=StatesCode.SUCCESS, message='成功')
 
-            return jsonify(code=StatesCode.SUCCESS, message='成功')
+            except Exception as e:
+                save_log(request, Module.DATA, OperationType.ADD, StatesCode.UNKNOWN_ERROR)
+                return jsonify(code=StatesCode.UNKNOWN_ERROR, message=str(e))

src/app/api/device.py

@@ -41,6 +41,7 @@ class DeviceTypeApi(Resource):
 
             return jsonify(code=StatesCode.SUCCESS, message='成功', data=to_dict(results))
 
+
         except Exception as e:
             save_log(request, Module.DEVICE, OperationType.INQUIRE, StatesCode.UNKNOWN_ERROR)
             return jsonify(code=StatesCode.UNKNOWN_ERROR, message=str(e))
@@ -354,11 +355,11 @@ class ImportDeviceApi(Resource):
             response.headers['Content-Type'] = 'application/octet-stream'
             response.headers['Content-Disposition'] = 'attachment; filename=%s' % 'device.xls'
 
-            save_log(request, Module.DEVICE, OperationType.IMPORT, StatesCode.SUCCESS)
+            save_log(request, Module.DEVICE, OperationType.EXPORT, StatesCode.SUCCESS)
 
             return response
         except Exception as e:
-            save_log(request, Module.DEVICE, OperationType.IMPORT, StatesCode.UNKNOWN_ERROR)
+            save_log(request, Module.DEVICE, OperationType.EXPORT, StatesCode.UNKNOWN_ERROR)
             return jsonify(code=StatesCode.UNKNOWN_ERROR, message=str(e))
 
     @ns.doc(id='import_device', description='设备导入')
@@ -374,32 +375,35 @@ class ImportDeviceApi(Resource):
         if device_group_id is None:
             return jsonify(code=StatesCode.PARA_ERROR, message='设备类型id不能为空')
 
+        try:
+            xlsx = xlrd.open_workbook(file_contents=device_file.read())
 
-        xlsx = xlrd.open_workbook(file_contents=device_file.read())
-
-        with Session(current_app.engine) as session:
-
-            for sheet in xlsx.sheets():
+            with Session(current_app.engine) as session:
 
-                # 添加设备数据
-                for i in range(1, sheet.nrows):  # 逐行打印sheet数据
-                    value = sheet.row_values(i)
-                    add_device = insert(SecurityDevice).values(
-                        device_name=value[0],
-                        device_id=value[1],
-                        device_type=int(value[2]) if value[2] != '' else None,
-                        device_location=value[3],
-                        device_age=int(value[4]) if value[4] != '' else None,
-                        company_id=value[5],
-                        user_id=value[6],
-                        device_group=device_group_id,
-                        status=int(value[7]) if value[7] != '' else None,
-                        floor_id=int(value[8]) if value[8] != '' else None,
-                        third_id=value[9]
-                    )
-                    session.execute(add_device)
-                    session.commit()
+                for sheet in xlsx.sheets():
+
+                    # 添加设备数据
+                    for i in range(1, sheet.nrows):  # 逐行打印sheet数据
+                        value = sheet.row_values(i)
+                        add_device = insert(SecurityDevice).values(
+                            device_name=value[0],
+                            device_id=value[1],
+                            device_type=int(value[2]) if value[2] != '' else None,
+                            device_location=value[3],
+                            device_age=int(value[4]) if value[4] != '' else None,
+                            company_id=value[5],
+                            user_id=value[6],
+                            device_group=device_group_id,
+                            status=int(value[7]) if value[7] != '' else None,
+                            floor_id=int(value[8]) if value[8] != '' else None,
+                            third_id=value[9]
+                        )
+                        session.execute(add_device)
+                        session.commit()
 
-        save_log(request, Module.DEVICE, OperationType.IMPORT, StatesCode.SUCCESS)
+            save_log(request, Module.DEVICE, OperationType.IMPORT, StatesCode.SUCCESS)
 
-        return jsonify(code=StatesCode.SUCCESS, message='成功')
+            return jsonify(code=StatesCode.SUCCESS, message='成功')
+        except Exception as e:
+            save_log(request, Module.DEVICE, OperationType.IMPORT, StatesCode.UNKNOWN_ERROR)
+            return jsonify(code=StatesCode.UNKNOWN_ERROR, message=str(e))

src/app/api/information.py

@@ -1,5 +1,3 @@
-import datetime
-import json
 import os
 
 from flask import request, jsonify, current_app, g
@@ -38,24 +36,29 @@ class InformationTypeApi(Resource):
         information_type = config.common.INFORMATION_TYPE
 
         data = {}
-        with Session(current_app.engine) as session:
+        try:
+            with Session(current_app.engine) as session:
 
-            for information in information_type:
-                if information == '楼层地图信息配置':
+                for information in information_type:
+                    if information == '楼层地图信息配置':
 
-                    stmt = select(FloorConfiguration.id, FloorConfiguration.name)
+                        stmt = select(FloorConfiguration.id, FloorConfiguration.name)
 
-                    data[information] = information_list(session.execute(stmt))
+                        data[information] = information_list(session.execute(stmt))
 
-                elif information == '安保人员信息配置':
+                    elif information == '安保人员信息配置':
 
-                    stmt = select(StaffConfiguration.id, StaffConfiguration.name)
+                        stmt = select(StaffConfiguration.id, StaffConfiguration.name)
 
-                    data[information] = information_list(session.execute(stmt))
+                        data[information] = information_list(session.execute(stmt))
 
-        save_log(request, Module.INFORMATION, OperationType.INQUIRE, StatesCode.SUCCESS)
+            save_log(request, Module.INFORMATION, OperationType.INQUIRE, StatesCode.SUCCESS)
 
-        return jsonify(code=StatesCode.SUCCESS, message='成功', data=data)
+            return jsonify(code=StatesCode.SUCCESS, message='成功', data=data)
+
+        except Exception as e:
+            save_log(request, Module.INFORMATION, OperationType.INQUIRE, StatesCode.UNKNOWN_ERROR)
+            return jsonify(code=StatesCode.UNKNOWN_ERROR, message=str(e))
 
 
 floor_configuration_details = reqparse.RequestParser(bundle_errors=True)
@@ -81,13 +84,17 @@ class FloorConfigurationApi(Resource):
 
         floor_configuration_id = request.args.get('id')
 
-        with Session(current_app.engine) as session:
-            stmt = select(FloorConfiguration).where(FloorConfiguration.id == floor_configuration_id)
-            results = session.execute(stmt).scalars().all()
+        try:
+            with Session(current_app.engine) as session:
+                stmt = select(FloorConfiguration).where(FloorConfiguration.id == floor_configuration_id)
+                results = session.execute(stmt).scalars().all()
 
-        save_log(request, Module.INFORMATION, OperationType.INQUIRE, StatesCode.SUCCESS)
+            save_log(request, Module.INFORMATION, OperationType.INQUIRE, StatesCode.SUCCESS)
 
-        return jsonify(code=StatesCode.SUCCESS, message='成功', data=to_dict(results))
+            return jsonify(code=StatesCode.SUCCESS, message='成功', data=to_dict(results))
+        except Exception as e:
+            save_log(request, Module.INFORMATION, OperationType.INQUIRE, StatesCode.UNKNOWN_ERROR)
+            return jsonify(code=StatesCode.UNKNOWN_ERROR, message=str(e))
 
     @ns.doc(id='add_floor_configuration', description='添加楼层地图信息配置')
     @ns.expect(floor_configuration)
@@ -109,21 +116,25 @@ class FloorConfigurationApi(Resource):
         else:
             attachment_url = None
 
-        with Session(current_app.engine) as session:
-            stmt = insert(FloorConfiguration).values(
-                name=name,
-                location=location,
-                use=use,
-                remark=remark,
-                attachment=attachment_url,
-                account=g.user_name
-            )
-            session.execute(stmt)
-            session.commit()
-
-        save_log(request, Module.INFORMATION, OperationType.ADD, StatesCode.SUCCESS)
-
-        return jsonify(code=StatesCode.SUCCESS, message='添加成功')
+        try:
+            with Session(current_app.engine) as session:
+                stmt = insert(FloorConfiguration).values(
+                    name=name,
+                    location=location,
+                    use=use,
+                    remark=remark,
+                    attachment=attachment_url,
+                    account=g.user_name
+                )
+                session.execute(stmt)
+                session.commit()
+
+            save_log(request, Module.INFORMATION, OperationType.ADD, StatesCode.SUCCESS)
+
+            return jsonify(code=StatesCode.SUCCESS, message='添加成功')
+        except Exception as e:
+            save_log(request, Module.INFORMATION, OperationType.ADD, StatesCode.UNKNOWN_ERROR)
+            return jsonify(code=StatesCode.UNKNOWN_ERROR, message=str(e))
 
     @ns.doc(id='update_floor_configuration', description='修改楼层地图信息配置')
     @ns.expect(floor_configuration)
@@ -147,21 +158,25 @@ class FloorConfigurationApi(Resource):
         else:
             attachment_url = None
 
-        with Session(current_app.engine) as session:
-            stmt = update(FloorConfiguration).where(FloorConfiguration.id == floor_configuration_id).values(
-                name=name,
-                location=location,
-                use=use,
-                remark=remark,
-                attachment=attachment_url,
-                account=g.user_name
-            )
-            session.execute(stmt)
-            session.commit()
-
-        save_log(request, Module.INFORMATION, OperationType.UPDATE, StatesCode.SUCCESS)
-
-        return jsonify(code=StatesCode.SUCCESS, message='修改成功')
+        try:
+            with Session(current_app.engine) as session:
+                stmt = update(FloorConfiguration).where(FloorConfiguration.id == floor_configuration_id).values(
+                    name=name,
+                    location=location,
+                    use=use,
+                    remark=remark,
+                    attachment=attachment_url,
+                    account=g.user_name
+                )
+                session.execute(stmt)
+                session.commit()
+
+            save_log(request, Module.INFORMATION, OperationType.UPDATE, StatesCode.SUCCESS)
+
+            return jsonify(code=StatesCode.SUCCESS, message='修改成功')
+        except Exception as e:
+            save_log(request, Module.INFORMATION, OperationType.UPDATE, StatesCode.UNKNOWN_ERROR)
+            return jsonify(code=StatesCode.UNKNOWN_ERROR, message=str(e))
 
     @ns.doc(id='delete_floor_configuration', description='删除楼层地图信息配置')
     @ns.expect(floor_configuration)
@@ -172,14 +187,18 @@ class FloorConfigurationApi(Resource):
         if floor_configuration_id is None:
             return jsonify(code=StatesCode.UNKNOWN_ERROR, message="配置id不能为空")
 
-        with Session(current_app.engine) as session:
-            stmt = delete(FloorConfiguration).where(FloorConfiguration.id == floor_configuration_id)
-            session.execute(stmt)
-            session.commit()
+        try:
+            with Session(current_app.engine) as session:
+                stmt = delete(FloorConfiguration).where(FloorConfiguration.id == floor_configuration_id)
+                session.execute(stmt)
+                session.commit()
 
-        save_log(request, Module.ORGANIZATION, OperationType.DELETE, StatesCode.SUCCESS)
+            save_log(request, Module.INFORMATION, OperationType.DELETE, StatesCode.SUCCESS)
 
-        return jsonify(code=StatesCode.SUCCESS, message="删除成功")
+            return jsonify(code=StatesCode.SUCCESS, message="删除成功")
+        except Exception as e:
+            save_log(request, Module.INFORMATION, OperationType.DELETE, StatesCode.UNKNOWN_ERROR)
+            return jsonify(code=StatesCode.UNKNOWN_ERROR, message=str(e))
 
 
 class StaffConfigurationApi(Resource):

src/app/api/log.py

@@ -43,29 +43,33 @@ class LogList(Resource):
         start_time = request.args.get('start_time')
         end_time = request.args.get('end_time')
 
-        with Session(current_app.engine) as session:
-            stmt = select(Log)
+        try:
+            with Session(current_app.engine) as session:
+                stmt = select(Log)
 
-            count = select(func.count(Log.id))
-            count_results = session.execute(count).scalars().first()
+                count = select(func.count(Log.id))
+                count_results = session.execute(count).scalars().first()
 
-            if module:
-                stmt = stmt.where(Log.module == module)
-            if name:
-                stmt = stmt.where(Log.operation_staff == name)
-            if operation_type:
-                stmt = stmt.where(Log.operation_type == operation_type)
-            if operation_status:
-                stmt = stmt.where(Log.operation_status == operation_status)
-            if start_time and end_time:
-                stmt = stmt.where(Log.operation_time.between(start_time, end_time))
+                if module:
+                    stmt = stmt.where(Log.module == module)
+                if name:
+                    stmt = stmt.where(Log.operation_staff == name)
+                if operation_type:
+                    stmt = stmt.where(Log.operation_type == operation_type)
+                if operation_status:
+                    stmt = stmt.where(Log.operation_status == operation_status)
+                if start_time and end_time:
+                    stmt = stmt.where(Log.operation_time.between(start_time, end_time))
 
-            stmt = stmt.offset(page_size * (page - 1)).limit(page_size)
-            results = session.execute(stmt).scalars().all()
+                stmt = stmt.offset(page_size * (page - 1)).limit(page_size)
+                results = session.execute(stmt).scalars().all()
 
-        save_log(request, Module.LOG, OperationType.INQUIRE, StatesCode.SUCCESS)
+            save_log(request, Module.LOG, OperationType.INQUIRE, StatesCode.SUCCESS)
 
-        return jsonify(code=StatesCode.SUCCESS, message='成功', total=count_results, data=to_dict(results))
+            return jsonify(code=StatesCode.SUCCESS, message='成功', total=count_results, data=to_dict(results))
+        except Exception as e:
+            save_log(request, Module.LOG, OperationType.INQUIRE, StatesCode.UNKNOWN_ERROR)
+            return jsonify(code=StatesCode.UNKNOWN_ERROR, message=str(e))
 
 
 @ns.route('/log_export')
@@ -75,14 +79,19 @@ class LogExportApi(Resource):
     @ns.doc(id='log_export', description='日志导出')
     def get(self):
         """日志导出"""
-        with Session(current_app.engine) as session:
-            stmt = select(Log)
-            results = session.execute(stmt).scalars().all()
 
-        response = Response(StringIO(json.dumps(to_dict(results))))
-        response.headers['Content-Type'] = 'application/octet-stream'
-        response.headers['Content-Disposition'] = 'attachment; filename=%s' % 'log.json'
+        try:
+            with Session(current_app.engine) as session:
+                stmt = select(Log)
+                results = session.execute(stmt).scalars().all()
 
-        save_log(request, Module.LOG, OperationType.EXPORT, StatesCode.SUCCESS)
+            response = Response(StringIO(json.dumps(to_dict(results))))
+            response.headers['Content-Type'] = 'application/octet-stream'
+            response.headers['Content-Disposition'] = 'attachment; filename=%s' % 'log.json'
 
-        return response
+            save_log(request, Module.LOG, OperationType.EXPORT, StatesCode.SUCCESS)
+
+            return response
+        except Exception as e:
+            save_log(request, Module.LOG, OperationType.EXPORT, StatesCode.UNKNOWN_ERROR)
+            return jsonify(code=StatesCode.UNKNOWN_ERROR, message=str(e))

src/app/api/message.py

@@ -28,19 +28,23 @@ class MessageTypeApi(Resource):
     def get(self):
         """获取消息列表"""
         data = {}
-        for message in config.common.MESSAGR_TYPE:
-            with Session(current_app.engine) as session:
-                stmt = select(Message.id, Message.name).where(Message.type == message)
+        try:
+            for message in config.common.MESSAGR_TYPE:
+                with Session(current_app.engine) as session:
+                    stmt = select(Message.id, Message.name).where(Message.type == message)
 
-                for row in session.execute(stmt):
-                    if data.get(message):
-                        data[message].append({"id": row.id, "name": row.name})
-                    else:
-                        data[message] = [{"id": row.id, "name": row.name}]
+                    for row in session.execute(stmt):
+                        if data.get(message):
+                            data[message].append({"id": row.id, "name": row.name})
+                        else:
+                            data[message] = [{"id": row.id, "name": row.name}]
 
-        save_log(request, Module.MESSAGE, OperationType.INQUIRE, StatesCode.SUCCESS)
+            save_log(request, Module.MESSAGE, OperationType.INQUIRE, StatesCode.SUCCESS)
 
-        return jsonify(code=StatesCode.SUCCESS, message='成功', data=data)
+            return jsonify(code=StatesCode.SUCCESS, message='成功', data=data)
+        except Exception as e:
+            save_log(request, Module.MESSAGE, OperationType.INQUIRE, StatesCode.UNKNOWN_ERROR)
+            return jsonify(code=StatesCode.UNKNOWN_ERROR, message=str(e))
 
 
 message_details = reqparse.RequestParser(bundle_errors=True)
@@ -73,13 +77,17 @@ class MessageApi(Resource):
         if message_id is None:
             return jsonify(code=StatesCode.UNKNOWN_ERROR, message='消息id不能为空')
 
-        with Session(current_app.engine) as session:
-            stmt = select(Message).where(Message.id == message_id)
-            results = session.execute(stmt).scalars().all()
+        try:
+            with Session(current_app.engine) as session:
+                stmt = select(Message).where(Message.id == message_id)
+                results = session.execute(stmt).scalars().all()
 
-        save_log(request, Module.MESSAGE, OperationType.INQUIRE, StatesCode.SUCCESS)
+            save_log(request, Module.MESSAGE, OperationType.INQUIRE, StatesCode.SUCCESS)
 
-        return jsonify(code=StatesCode.SUCCESS, message='成功', data=to_dict(results))
+            return jsonify(code=StatesCode.SUCCESS, message='成功', data=to_dict(results))
+        except Exception as e:
+            save_log(request, Module.MESSAGE, OperationType.INQUIRE, StatesCode.UNKNOWN_ERROR)
+            return jsonify(code=StatesCode.UNKNOWN_ERROR, message=str(e))
 
     @ns.doc(id='add_message', description='新增消息')
     @ns.expect(message)
@@ -101,68 +109,70 @@ class MessageApi(Resource):
 
         staff_list = []
 
-        with Session(current_app.engine) as session:
-            if staff == 'all':
-                stmt = select(User.user_name)
-                staff_list.extend(session.execute(stmt).scalars().all())
+        try:
+            with Session(current_app.engine) as session:
+                if staff == 'all':
+                    stmt = select(User.user_name)
+                    staff_list.extend(session.execute(stmt).scalars().all())
 
-            elif staff.split(':')[0] == 'company':
-                stmt = select(User.user_name).where(User.company == staff.split(':')[1])
-                staff_list.extend(session.execute(stmt).scalars().all())
+                elif staff.split(':')[0] == 'company':
+                    stmt = select(User.user_name).where(User.company == staff.split(':')[1])
+                    staff_list.extend(session.execute(stmt).scalars().all())
 
-            elif staff.split(':')[0] == 'role':
-                stmt = select(User.user_name).where(User.role == staff.split(':')[1])
-                staff_list.extend(session.execute(stmt).scalars().all())
+                elif staff.split(':')[0] == 'role':
+                    stmt = select(User.user_name).where(User.role == staff.split(':')[1])
+                    staff_list.extend(session.execute(stmt).scalars().all())
 
-            else:
-                return jsonify(code=StatesCode.UNKNOWN_ERROR, message='无效的人员配置')
+                else:
+                    return jsonify(code=StatesCode.UNKNOWN_ERROR, message='无效的人员配置')
 
-        try:
             if send_time != 'immediately':
                 datetime.datetime.strptime(send_time, '%Y-%m-%d %H:%M:%S')
-        except Exception:
-            return jsonify(code=StatesCode.UNKNOWN_ERROR, message='时间格式错误。例：2023-10-10 12:12:12')
-
-        # 添加数据库
-        with Session(current_app.engine) as session:
-            stmt = insert(Message).values(
-                name=name,
-                pipeline=pipeline,
-                staff=staff,
-                send_time=send_time,
-                title=title,
-                content=content,
-                style=style,
-                type=message_type
+
+            # 添加数据库
+            with Session(current_app.engine) as session:
+                stmt = insert(Message).values(
+                    name=name,
+                    pipeline=pipeline,
+                    staff=staff,
+                    send_time=send_time,
+                    title=title,
+                    content=content,
+                    style=style,
+                    type=message_type
+                )
+                session.execute(stmt)
+                session.commit()
+
+            message_data = json.dumps(
+                {
+                    "staff": staff_list,
+                    "name": name,
+                    "title": title,
+                    "content": content,
+                    "style": style
+                }
             )
-            session.execute(stmt)
-            session.commit()
-
-        message_data = json.dumps(
-            {
-                "staff": staff_list,
-                "name": name,
-                "title": title,
-                "content": content,
-                "style": style
-            }
-        )
-
-        # 判断发送时间，立即发送，或添加添加定时任务
-        if send_time == 'immediately':
-            add_message(message_data)
-
-        else:
-            current_app.scheduler.add_job(id=name,
-                                          func=add_message,
-                                          trigger='date',
-                                          run_date=datetime.datetime.strptime(send_time, '%Y-%m-%d %H:%M:%S'),
-                                          args=[message_data]
-                                          )
-
-        save_log(request, Module.MESSAGE, OperationType.ADD, StatesCode.SUCCESS)
-
-        return jsonify(code=StatesCode.SUCCESS, message='成功')
+
+            # 判断发送时间，立即发送，或添加添加定时任务
+            if send_time == 'immediately':
+                add_message(message_data)
+
+            else:
+                current_app.scheduler.add_job(id=name,
+                                              func=add_message,
+                                              trigger='date',
+                                              run_date=datetime.datetime.strptime(send_time, '%Y-%m-%d %H:%M:%S'),
+                                              args=[message_data]
+                                              )
+
+            save_log(request, Module.MESSAGE, OperationType.ADD, StatesCode.SUCCESS)
+
+            return jsonify(code=StatesCode.SUCCESS, message='成功')
+
+        except Exception as e:
+            save_log(request, Module.MESSAGE, OperationType.ADD, StatesCode.UNKNOWN_ERROR)
+            return jsonify(code=StatesCode.UNKNOWN_ERROR, message=str(e))
 
     @ns.doc(id='update_message', description='修改消息')
     @ns.expect(message)
@@ -185,65 +195,69 @@ class MessageApi(Resource):
 
         staff_list = []
 
-        with Session(current_app.engine) as session:
-            if staff == 'all':
-                stmt = select(User.user_name)
-                staff_list.extend(session.execute(stmt).scalars().all())
+        try:
+            with Session(current_app.engine) as session:
+                if staff == 'all':
+                    stmt = select(User.user_name)
+                    staff_list.extend(session.execute(stmt).scalars().all())
 
-            elif staff.split(':')[0] == 'company':
-                stmt = select(User.user_name).where(User.company == staff.split(':')[1])
-                staff_list.extend(session.execute(stmt).scalars().all())
+                elif staff.split(':')[0] == 'company':
+                    stmt = select(User.user_name).where(User.company == staff.split(':')[1])
+                    staff_list.extend(session.execute(stmt).scalars().all())
 
-            elif staff.split(':')[0] == 'role':
-                stmt = select(User.user_name).where(User.role == staff.split(':')[1])
-                staff_list.extend(session.execute(stmt).scalars().all())
+                elif staff.split(':')[0] == 'role':
+                    stmt = select(User.user_name).where(User.role == staff.split(':')[1])
+                    staff_list.extend(session.execute(stmt).scalars().all())
 
-            else:
-                return jsonify(code=StatesCode.UNKNOWN_ERROR, message='无效的人员配置')
+                else:
+                    return jsonify(code=StatesCode.UNKNOWN_ERROR, message='无效的人员配置')
 
-        try:
-            if send_time != 'immediately':
-                datetime.datetime.strptime(send_time, '%Y-%m-%d %H:%M:%S')
-        except Exception:
-            return jsonify(code=StatesCode.UNKNOWN_ERROR, message='时间格式错误。例：2023-10-10 12:12:12')
-
-        # 添加数据库
-        with Session(current_app.engine) as session:
-            stmt = update(Message).where(Message.id == message_id).values(
-                name=name,
-                pipeline=pipeline,
-                staff=staff,
-                send_time=send_time,
-                title=title,
-                content=content,
-                style=style,
-                type=message_type
+            try:
+                if send_time != 'immediately':
+                    datetime.datetime.strptime(send_time, '%Y-%m-%d %H:%M:%S')
+            except Exception:
+                return jsonify(code=StatesCode.UNKNOWN_ERROR, message='时间格式错误。例：2023-10-10 12:12:12')
+
+            # 添加数据库
+            with Session(current_app.engine) as session:
+                stmt = update(Message).where(Message.id == message_id).values(
+                    name=name,
+                    pipeline=pipeline,
+                    staff=staff,
+                    send_time=send_time,
+                    title=title,
+                    content=content,
+                    style=style,
+                    type=message_type
+                )
+                session.execute(stmt)
+                session.commit()
+
+            message_data = json.dumps(
+                {
+                    "staff": staff_list,
+                    "name": name,
+                    "title": title,
+                    "content": content,
+                    "style": style
+                }
             )
-            session.execute(stmt)
-            session.commit()
-
-        message_data = json.dumps(
-            {
-                "staff": staff_list,
-                "name": name,
-                "title": title,
-                "content": content,
-                "style": style
-            }
-        )
-
-        # 判断发送时间，立即发送，或添加添加定时任务
-        if send_time == 'immediately':
-            add_message(message_data)
-
-        else:
-            current_app.scheduler.add_job(id=name,
-                                          func=add_message,
-                                          trigger='date',
-                                          run_date=datetime.datetime.strptime(send_time, '%Y-%m-%d %H:%M:%S'),
-                                          args=[message_data]
-                                          )
-
-        save_log(request, Module.MESSAGE, OperationType.UPDATE, StatesCode.SUCCESS)
-
-        return jsonify(code=StatesCode.SUCCESS, message='成功')
+
+            # 判断发送时间，立即发送，或添加添加定时任务
+            if send_time == 'immediately':
+                add_message(message_data)
+
+            else:
+                current_app.scheduler.add_job(id=name,
+                                              func=add_message,
+                                              trigger='date',
+                                              run_date=datetime.datetime.strptime(send_time, '%Y-%m-%d %H:%M:%S'),
+                                              args=[message_data]
+                                              )
+
+            save_log(request, Module.MESSAGE, OperationType.UPDATE, StatesCode.SUCCESS)
+
+            return jsonify(code=StatesCode.SUCCESS, message='成功')
+        except Exception as e:
+            save_log(request, Module.MESSAGE, OperationType.UPDATE, StatesCode.UNKNOWN_ERROR)
+            return jsonify(code=StatesCode.UNKNOWN_ERROR, message=str(e))

src/app/api/organization.py

@@ -35,16 +35,21 @@ class CompanyListApi(Resource):
         page_size = int(request.args.get('page_size', 20))
         page = int(request.args.get('page', 1))
 
-        with Session(current_app.engine) as session:
-            count = select(func.count(Company.id))
-            count_results = session.execute(count).scalars().first()
+        try:
+            with Session(current_app.engine) as session:
+                count = select(func.count(Company.id))
+                count_results = session.execute(count).scalars().first()
 
-            stmt = select(Company).offset(page_size * (page - 1)).limit(page_size)
-            results = session.execute(stmt).scalars().all()
+                stmt = select(Company).offset(page_size * (page - 1)).limit(page_size)
+                results = session.execute(stmt).scalars().all()
 
-        save_log(request, Module.ORGANIZATION, OperationType.INQUIRE, StatesCode.SUCCESS)
+            save_log(request, Module.ORGANIZATION, OperationType.INQUIRE, StatesCode.SUCCESS)
 
-        return jsonify(code=StatesCode.SUCCESS, message='成功', total=count_results, data=to_dict(results))
+            return jsonify(code=StatesCode.SUCCESS, message='成功', total=count_results, data=to_dict(results))
+
+        except Exception as e:
+            save_log(request, Module.ORGANIZATION, OperationType.INQUIRE, StatesCode.UNKNOWN_ERROR)
+            return jsonify(code=StatesCode.UNKNOWN_ERROR, message=str(e))
 
 
 company_details = reqparse.RequestParser(bundle_errors=True)
@@ -79,15 +84,19 @@ class CompanyApi(Resource):
         company_id = request.args.get('company_id')
 
         if company_id is None:
-            return jsonify(code=StatesCode.UNKNOWN_ERROR, message="公司id不能为空")
+            return jsonify(code=StatesCode.PARA_ERROR, message="公司id不能为空")
 
-        with Session(current_app.engine) as session:
-            stmt = select(Company).where(Company.id == company_id)
-            results = session.execute(stmt).scalars().all()
+        try:
+            with Session(current_app.engine) as session:
+                stmt = select(Company).where(Company.id == company_id)
+                results = session.execute(stmt).scalars().all()
 
-        save_log(request, Module.ORGANIZATION, OperationType.INQUIRE, StatesCode.SUCCESS)
+            save_log(request, Module.ORGANIZATION, OperationType.INQUIRE, StatesCode.SUCCESS)
 
-        return jsonify(code=StatesCode.SUCCESS, message='成功', data=to_dict(results))
+            return jsonify(code=StatesCode.SUCCESS, message='成功', data=to_dict(results))
+        except Exception as e:
+            save_log(request, Module.ORGANIZATION, OperationType.INQUIRE, StatesCode.UNKNOWN_ERROR)
+            return jsonify(code=StatesCode.UNKNOWN_ERROR, message=str(e))
 
     @ns.doc(id='add_company', description='添加公司')
     @ns.expect(company_details)
@@ -106,7 +115,7 @@ class CompanyApi(Resource):
         on_guard_size = request.form.get('on_guard_size')
 
         if company_name is None:
-            return jsonify(code=StatesCode.UNKNOWN_ERROR, message="公司名不能为空")
+            return jsonify(code=StatesCode.PARA_ERROR, message="公司名不能为空")
 
         # 公司商标存储（url），
         if logo:
@@ -115,33 +124,37 @@ class CompanyApi(Resource):
         else:
             logo_url = None
 
-        with Session(current_app.engine) as session:
-            # 判断公司是否存在
-            stmt = select(Company).where(Company.company_name == company_name)
-            result = session.execute(stmt).scalars().first()
-            if result:
-                return jsonify(code=StatesCode.UNKNOWN_ERROR, message="公司已存在")
-
-            # 添加公司
-            stmt = insert(Company).values(
-                company_name=company_name,
-                logo=logo_url,
-                abbreviation=abbreviation,
-                code=code,
-                registered_address=registered_address,
-                business_address=business_address,
-                legal_person_name=legal_person_name,
-                company_code=company_code,
-                staff_size=staff_size,
-                on_guard_size=on_guard_size
-            )
-            session.execute(stmt)
-
-            session.commit()
-
-        save_log(request, Module.ORGANIZATION, OperationType.ADD, StatesCode.SUCCESS)
-
-        return jsonify(code=StatesCode.SUCCESS, message='添加成功')
+        try:
+            with Session(current_app.engine) as session:
+                # 判断公司是否存在
+                stmt = select(Company).where(Company.company_name == company_name)
+                result = session.execute(stmt).scalars().first()
+                if result:
+                    return jsonify(code=StatesCode.UNKNOWN_ERROR, message="公司已存在")
+
+                # 添加公司
+                stmt = insert(Company).values(
+                    company_name=company_name,
+                    logo=logo_url,
+                    abbreviation=abbreviation,
+                    code=code,
+                    registered_address=registered_address,
+                    business_address=business_address,
+                    legal_person_name=legal_person_name,
+                    company_code=company_code,
+                    staff_size=staff_size,
+                    on_guard_size=on_guard_size
+                )
+                session.execute(stmt)
+
+                session.commit()
+
+            save_log(request, Module.ORGANIZATION, OperationType.ADD, StatesCode.SUCCESS)
+
+            return jsonify(code=StatesCode.SUCCESS, message='添加成功')
+        except Exception as e:
+            save_log(request, Module.ORGANIZATION, OperationType.ADD, StatesCode.UNKNOWN_ERROR)
+            return jsonify(code=StatesCode.UNKNOWN_ERROR, message=str(e))
 
     @ns.doc(id='update_company_details', description='修改公司详情')
     @ns.expect(company_details)
@@ -160,7 +173,7 @@ class CompanyApi(Resource):
         on_guard_size = request.form.get('on_guard_size')
 
         if company_name is None:
-            return jsonify(code=StatesCode.UNKNOWN_ERROR, message="公司名不能为空")
+            return jsonify(code=StatesCode.PARA_ERROR, message="公司名不能为空")
 
         # 公司商标存储（url），
         if logo:
@@ -169,25 +182,29 @@ class CompanyApi(Resource):
         else:
             logo_url = None
 
-        with Session(current_app.engine) as session:
-            stmt = update(Company).where(Company.id == company_id).values(
-                company_name=company_name,
-                logo=logo_url,
-                abbreviation=abbreviation,
-                code=code,
-                registered_address=registered_address,
-                business_address=business_address,
-                legal_person_name=legal_person_name,
-                company_code=company_code,
-                staff_size=staff_size,
-                on_guard_size=on_guard_size
-            )
-            session.execute(stmt)
-            session.commit()
-
-        save_log(request, Module.ORGANIZATION, OperationType.UPDATE, StatesCode.SUCCESS)
-
-        return jsonify(code=StatesCode.SUCCESS, message='修改成功')
+        try:
+            with Session(current_app.engine) as session:
+                stmt = update(Company).where(Company.id == company_id).values(
+                    company_name=company_name,
+                    logo=logo_url,
+                    abbreviation=abbreviation,
+                    code=code,
+                    registered_address=registered_address,
+                    business_address=business_address,
+                    legal_person_name=legal_person_name,
+                    company_code=company_code,
+                    staff_size=staff_size,
+                    on_guard_size=on_guard_size
+                )
+                session.execute(stmt)
+                session.commit()
+
+            save_log(request, Module.ORGANIZATION, OperationType.UPDATE, StatesCode.SUCCESS)
+
+            return jsonify(code=StatesCode.SUCCESS, message='修改成功')
+        except Exception as e:
+            save_log(request, Module.ORGANIZATION, OperationType.UPDATE, StatesCode.UNKNOWN_ERROR)
+            return jsonify(code=StatesCode.UNKNOWN_ERROR, message=str(e))
 
     @ns.doc(id='delete_company', description='删除公司')
     @ns.expect(company_details)
@@ -196,17 +213,21 @@ class CompanyApi(Resource):
         company_id = request.form.get('company_id')
 
         if company_id is None:
-            return jsonify(code=StatesCode.UNKNOWN_ERROR, message="公司id不能为空")
+            return jsonify(code=StatesCode.PARA_ERROR, message="公司id不能为空")
 
-        with Session(current_app.engine) as session:
-            stmt = delete(Company).where(Company.id == company_id)
+        try:
+            with Session(current_app.engine) as session:
+                stmt = delete(Company).where(Company.id == company_id)
 
-            session.execute(stmt)
-            session.commit()
+                session.execute(stmt)
+                session.commit()
 
-        save_log(request, Module.ORGANIZATION, OperationType.DELETE, StatesCode.SUCCESS)
+            save_log(request, Module.ORGANIZATION, OperationType.DELETE, StatesCode.SUCCESS)
 
-        return jsonify(code=StatesCode.SUCCESS, message="删除成功")
+            return jsonify(code=StatesCode.SUCCESS, message="删除成功")
+        except Exception as e:
+            save_log(request, Module.ORGANIZATION, OperationType.DELETE, StatesCode.UNKNOWN_ERROR)
+            return jsonify(code=StatesCode.UNKNOWN_ERROR, message=str(e))
 
 
 department_details = reqparse.RequestParser(bundle_errors=True)
@@ -235,19 +256,23 @@ class DepartmentListApi(Resource):
         company_id = request.args.get('company_id')
 
         if company_id is None:
-            return jsonify(code=StatesCode.UNKNOWN_ERROR, message="公司id不能为空")
+            return jsonify(code=StatesCode.PARA_ERROR, message="公司id不能为空")
 
-        with Session(current_app.engine) as session:
-            stmt = select(Department.id, Department.department_name).where(Department.company_id == company_id)
-            results = session.execute(stmt)
+        try:
+            with Session(current_app.engine) as session:
+                stmt = select(Department.id, Department.department_name).where(Department.company_id == company_id)
+                results = session.execute(stmt)
 
-        data = []
-        for result in results:
-            data.append({"id": result.id, "department_name": result.department_name})
+            data = []
+            for result in results:
+                data.append({"id": result.id, "department_name": result.department_name})
 
-        save_log(request, Module.ORGANIZATION, OperationType.INQUIRE, StatesCode.SUCCESS)
+            save_log(request, Module.ORGANIZATION, OperationType.INQUIRE, StatesCode.SUCCESS)
 
-        return jsonify(code=StatesCode.SUCCESS, message='成功', data=data)
+            return jsonify(code=StatesCode.SUCCESS, message='成功', data=data)
+        except Exception as e:
+            save_log(request, Module.ORGANIZATION, OperationType.INQUIRE, StatesCode.UNKNOWN_ERROR)
+            return jsonify(code=StatesCode.UNKNOWN_ERROR, message=str(e))
 
 
 get_department = reqparse.RequestParser(bundle_errors=True)
@@ -266,15 +291,19 @@ class DepartmentApi(Resource):
         department_id = request.args.get('department_id')
 
         if department_id is None:
-            return jsonify(code=StatesCode.UNKNOWN_ERROR, message="部门id不能为空")
+            return jsonify(code=StatesCode.PARA_ERROR, message="部门id不能为空")
 
-        with Session(current_app.engine) as session:
-            stmt = select(Department).where(Department.id == department_id)
-            results = session.execute(stmt).scalars().all()
+        try:
+            with Session(current_app.engine) as session:
+                stmt = select(Department).where(Department.id == department_id)
+                results = session.execute(stmt).scalars().all()
 
-        save_log(request, Module.ORGANIZATION, OperationType.INQUIRE, StatesCode.SUCCESS)
+            save_log(request, Module.ORGANIZATION, OperationType.INQUIRE, StatesCode.SUCCESS)
 
-        return jsonify(code=StatesCode.SUCCESS, message="成功", data=to_dict(results))
+            return jsonify(code=StatesCode.SUCCESS, message="成功", data=to_dict(results))
+        except Exception as e:
+            save_log(request, Module.ORGANIZATION, OperationType.INQUIRE, StatesCode.UNKNOWN_ERROR)
+            return jsonify(code=StatesCode.UNKNOWN_ERROR, message=str(e))
 
     @ns.doc(id='add_department', description='添加部门')
     @ns.expect(department_details)
@@ -292,28 +321,32 @@ class DepartmentApi(Resource):
         censure = request.form.get('censure')
 
         if company_id is None or department_name is None:
-            return jsonify(code=StatesCode.UNKNOWN_ERROR, message="上级公司和部门名称不能为空")
-
-        with Session(current_app.engine) as session:
-            stmt = insert(Department).values(
-                company_id=company_id,
-                department_name=department_name,
-                principal=principal,
-                liaison_officer=liaison_officer,
-                duplicate_name=duplicate_name,
-                on_guard=on_guard,
-                freelance_staff=freelance_staff,
-                cooperation_staff=cooperation_staff,
-                thirdparty_staff=thirdparty_staff,
-                censure=censure,
-
-            )
-            session.execute(stmt)
-            session.commit()
-
-        save_log(request, Module.ORGANIZATION, OperationType.ADD, StatesCode.SUCCESS)
-
-        return {"code": StatesCode.SUCCESS, "message": "成功"}
+            return jsonify(code=StatesCode.PARA_ERROR, message="上级公司和部门名称不能为空")
+
+        try:
+            with Session(current_app.engine) as session:
+                stmt = insert(Department).values(
+                    company_id=company_id,
+                    department_name=department_name,
+                    principal=principal,
+                    liaison_officer=liaison_officer,
+                    duplicate_name=duplicate_name,
+                    on_guard=on_guard,
+                    freelance_staff=freelance_staff,
+                    cooperation_staff=cooperation_staff,
+                    thirdparty_staff=thirdparty_staff,
+                    censure=censure,
+
+                )
+                session.execute(stmt)
+                session.commit()
+
+            save_log(request, Module.ORGANIZATION, OperationType.ADD, StatesCode.SUCCESS)
+
+            return jsonify(code=StatesCode.SUCCESS, message='成功')
+        except Exception as e:
+            save_log(request, Module.ORGANIZATION, OperationType.INQUIRE, StatesCode.UNKNOWN_ERROR)
+            return jsonify(code=StatesCode.UNKNOWN_ERROR, message=str(e))
 
     @ns.doc(id='update_company_details', description='修改部门详情')
     @ns.expect(department_details)
@@ -333,28 +366,32 @@ class DepartmentApi(Resource):
         censure = request.form.get('censure')
 
         if company_id is None or department_name is None:
-            return jsonify(code=StatesCode.UNKNOWN_ERROR, message="上级公司和部门名称不能为空")
-
-        with Session(current_app.engine) as session:
-            stmt = update(Department).where(Department.id == department_id).values(
-                company_id=company_id,
-                department_name=department_name,
-                principal=principal,
-                liaison_officer=liaison_officer,
-                duplicate_name=duplicate_name,
-                on_guard=on_guard,
-                freelance_staff=freelance_staff,
-                cooperation_staff=cooperation_staff,
-                thirdparty_staff=thirdparty_staff,
-                censure=censure,
-
-            )
-            session.execute(stmt)
-            session.commit()
-
-        save_log(request, Module.ORGANIZATION, OperationType.UPDATE, StatesCode.SUCCESS)
-
-        return jsonify(code=StatesCode.SUCCESS, message="成功")
+            return jsonify(code=StatesCode.PARA_ERROR, message="上级公司和部门名称不能为空")
+
+        try:
+            with Session(current_app.engine) as session:
+                stmt = update(Department).where(Department.id == department_id).values(
+                    company_id=company_id,
+                    department_name=department_name,
+                    principal=principal,
+                    liaison_officer=liaison_officer,
+                    duplicate_name=duplicate_name,
+                    on_guard=on_guard,
+                    freelance_staff=freelance_staff,
+                    cooperation_staff=cooperation_staff,
+                    thirdparty_staff=thirdparty_staff,
+                    censure=censure,
+
+                )
+                session.execute(stmt)
+                session.commit()
+
+            save_log(request, Module.ORGANIZATION, OperationType.UPDATE, StatesCode.SUCCESS)
+
+            return jsonify(code=StatesCode.SUCCESS, message="成功")
+        except Exception as e:
+            save_log(request, Module.ORGANIZATION, OperationType.UPDATE, StatesCode.UNKNOWN_ERROR)
+            return jsonify(code=StatesCode.UNKNOWN_ERROR, message=str(e))
 
     @ns.doc(id='delete_company_details', description='删除部门')
     @ns.expect(department_details)
@@ -363,16 +400,20 @@ class DepartmentApi(Resource):
         department_id = request.form.get('department_id')
 
         if department_id is None:
-            return jsonify(code=StatesCode.UNKNOWN_ERROR, message="部门id不能为空")
+            return jsonify(code=StatesCode.PARA_ERROR, message="部门id不能为空")
 
-        with Session(current_app.engine) as session:
-            stmt = delete(Department).where(Department.id == department_id)
-            session.execute(stmt)
-            session.commit()
+        try:
+            with Session(current_app.engine) as session:
+                stmt = delete(Department).where(Department.id == department_id)
+                session.execute(stmt)
+                session.commit()
 
-        save_log(request, Module.ORGANIZATION, OperationType.DELETE, StatesCode.SUCCESS)
+            save_log(request, Module.ORGANIZATION, OperationType.DELETE, StatesCode.SUCCESS)
 
-        return {"code": StatesCode.SUCCESS, "message": "成功", "data": '删除部门'}
+            return jsonify(code=StatesCode.SUCCESS, message='成功')
+        except Exception as e:
+            save_log(request, Module.ORGANIZATION, OperationType.DELETE, StatesCode.UNKNOWN_ERROR)
+            return jsonify(code=StatesCode.UNKNOWN_ERROR, message=str(e))
 
 
 batch_delete_company = reqparse.RequestParser(bundle_errors=True)
@@ -392,16 +433,20 @@ class BatchDeletecompanyApi(Resource):
         if company_ids is not None:
             company_ids = json.loads(company_ids)
         else:
-            return jsonify(code=StatesCode.UNKNOWN_ERROR, message='公司id不能为空')
+            return jsonify(code=StatesCode.PARA_ERROR, message='公司id不能为空')
 
-        with Session(current_app.engine) as session:
-            stmt = select(Company).where(Company.id.in_(company_ids))
-            results = session.execute(stmt).scalars().all()
+        try:
+            with Session(current_app.engine) as session:
+                stmt = select(Company).where(Company.id.in_(company_ids))
+                results = session.execute(stmt).scalars().all()
 
-            for result in results:
-                session.delete(result)
-            session.commit()
+                for result in results:
+                    session.delete(result)
+                session.commit()
 
-        save_log(request, Module.ORGANIZATION, OperationType.BATCH_DELETE, StatesCode.SUCCESS)
+            save_log(request, Module.ORGANIZATION, OperationType.BATCH_DELETE, StatesCode.SUCCESS)
 
-        return jsonify(code=StatesCode.SUCCESS, message='批量删除成功')
+            return jsonify(code=StatesCode.SUCCESS, message='批量删除成功')
+        except Exception as e:
+            save_log(request, Module.ORGANIZATION, OperationType.BATCH_DELETE, StatesCode.UNKNOWN_ERROR)
+            return jsonify(code=StatesCode.UNKNOWN_ERROR, message=str(e))

src/app/api/permission.py

@@ -53,16 +53,19 @@ class AuthPermissionApi(Resource):
         """权限认证"""
         path = request.args.get('path')
 
-        with Session(current_app.engine) as session:
-            # 根据用户id获取角色id
-            stmt = select(User.role).where(User.id == g.user_id)
-            role_id = session.execute(stmt).scalars().first()
-            # 根据角色id获取权限id
-            stmt = select(Role.role_permission).where(Role.id == role_id)
-            role_permission = session.execute(stmt).scalars().first()
-            # 根据权限id获取可访问的接口
-            stmt = select(Menus.router).where(Menus.id.in_(role_permission))
-            results = session.execute(stmt).scalars().all()
-            # 判断传入接口是否在可访问的接口中
-            if path not in results:
-                return jsonify(code=StatesCode.UNKNOWN_ERROR, message='无权限')
+        try:
+            with Session(current_app.engine) as session:
+                # 根据用户id获取角色id
+                stmt = select(User.role).where(User.id == g.user_id)
+                role_id = session.execute(stmt).scalars().first()
+                # 根据角色id获取权限id
+                stmt = select(Role.role_permission).where(Role.id == role_id)
+                role_permission = session.execute(stmt).scalars().first()
+                # 根据权限id获取可访问的接口
+                stmt = select(Menus.router).where(Menus.id.in_(role_permission))
+                results = session.execute(stmt).scalars().all()
+                # 判断传入接口是否在可访问的接口中
+                if path not in results:
+                    return jsonify(code=StatesCode.UNKNOWN_ERROR, message='无权限')
+        except Exception as e:
+            return jsonify(code=StatesCode.UNKNOWN_ERROR, message=str(e))

src/app/api/role.py

@@ -31,17 +31,21 @@ class GetUserListApi(Resource):
         page_size = int(request.args.get('page_size', 20))
         page = int(request.args.get('page', 1))
 
-        with Session(current_app.engine) as session:
+        try:
+            with Session(current_app.engine) as session:
 
-            count = select(func.count(Role.id))
-            count_results = session.execute(count).scalars().first()
+                count = select(func.count(Role.id))
+                count_results = session.execute(count).scalars().first()
 
-            stmt = select(Role).offset(page_size * (page - 1)).limit(page_size)
-            results = session.execute(stmt).scalars().all()
+                stmt = select(Role).offset(page_size * (page - 1)).limit(page_size)
+                results = session.execute(stmt).scalars().all()
 
-        save_log(request, Module.ROLE, OperationType.INQUIRE, StatesCode.SUCCESS)
+            save_log(request, Module.ROLE, OperationType.INQUIRE, StatesCode.SUCCESS)
 
-        return jsonify(code=StatesCode.SUCCESS, message='成功', total=count_results, data=to_dict(results))
+            return jsonify(code=StatesCode.SUCCESS, message='成功', total=count_results, data=to_dict(results))
+        except Exception as e:
+            save_log(request, Module.ROLE, OperationType.INQUIRE, StatesCode.UNKNOWN_ERROR)
+            return jsonify(code=StatesCode.UNKNOWN_ERROR, message=str(e))
 
 
 role = reqparse.RequestParser(bundle_errors=True)
@@ -65,15 +69,19 @@ class RoleApi(Resource):
         role_id = request.args.get('role_id')
 
         if role_id is None:
-            return jsonify(code=StatesCode.UNKNOWN_ERROR, message="角色id不能为空")
+            return jsonify(code=StatesCode.PARA_ERROR, message="角色id不能为空")
 
-        with Session(current_app.engine) as session:
-            stmt = select(Role).where(Role.id == role_id)
-            results = session.execute(stmt).scalars().all()
+        try:
+            with Session(current_app.engine) as session:
+                stmt = select(Role).where(Role.id == role_id)
+                results = session.execute(stmt).scalars().all()
 
-        save_log(request, Module.ROLE, OperationType.INQUIRE, StatesCode.SUCCESS)
+            save_log(request, Module.ROLE, OperationType.INQUIRE, StatesCode.SUCCESS)
 
-        return {"code": StatesCode.SUCCESS, "message": "成功", "data": to_dict(results)}
+            return {"code": StatesCode.SUCCESS, "message": "成功", "data": to_dict(results)}
+        except Exception as e:
+            save_log(request, Module.ROLE, OperationType.INQUIRE, StatesCode.UNKNOWN_ERROR)
+            return jsonify(code=StatesCode.UNKNOWN_ERROR, message=str(e))
 
     @ns.doc(id='add_role', description='添加角色')
     @ns.expect(role)
@@ -85,25 +93,29 @@ class RoleApi(Resource):
         role_permission = request.form.get('role_permission')
 
         if role_name is None:
-            return jsonify(code=StatesCode.UNKNOWN_ERROR, message="角色名不能为空")
+            return jsonify(code=StatesCode.PARA_ERROR, message="角色名不能为空")
 
         if role_permission:
             role_permission = json.loads(role_permission)
 
-        with Session(current_app.engine) as session:
+        try:
+            with Session(current_app.engine) as session:
 
-            stmt = insert(Role).values(
-                role_name=role_name,
-                role_describe=role_describe,
-                role_permission=role_permission
-            )
+                stmt = insert(Role).values(
+                    role_name=role_name,
+                    role_describe=role_describe,
+                    role_permission=role_permission
+                )
 
-            session.execute(stmt)
-            session.commit()
+                session.execute(stmt)
+                session.commit()
 
-        save_log(request, Module.ROLE, OperationType.ADD, StatesCode.SUCCESS)
+            save_log(request, Module.ROLE, OperationType.ADD, StatesCode.SUCCESS)
 
-        return jsonify(code=StatesCode.SUCCESS, message='成功')
+            return jsonify(code=StatesCode.SUCCESS, message='成功')
+        except Exception as e:
+            save_log(request, Module.ROLE, OperationType.ADD, StatesCode.UNKNOWN_ERROR)
+            return jsonify(code=StatesCode.UNKNOWN_ERROR, message=str(e))
 
     @ns.doc(id='modify_role', description='修改角色')
     @ns.expect(role)
@@ -115,24 +127,28 @@ class RoleApi(Resource):
         role_permission = request.form.get('role_permission')
 
         if role_name is None or role_id is None:
-            return jsonify(code=StatesCode.UNKNOWN_ERROR, message="角色名和角色id不能为空")
+            return jsonify(code=StatesCode.PARA_ERROR, message="角色名和角色id不能为空")
 
         if role_permission:
             role_permission = json.loads(role_permission)
 
-        with Session(current_app.engine) as session:
+        try:
+            with Session(current_app.engine) as session:
 
-            stmt = update(Role).where(Role.id == role_id).values(
-                role_name=role_name,
-                role_describe=role_describe,
-                role_permission=role_permission
-            )
-            session.execute(stmt)
-            session.commit()
+                stmt = update(Role).where(Role.id == role_id).values(
+                    role_name=role_name,
+                    role_describe=role_describe,
+                    role_permission=role_permission
+                )
+                session.execute(stmt)
+                session.commit()
 
-        save_log(request, Module.ROLE, OperationType.UPDATE, StatesCode.SUCCESS)
+            save_log(request, Module.ROLE, OperationType.UPDATE, StatesCode.SUCCESS)
 
-        return jsonify(code=StatesCode.SUCCESS, message="添加角色成功")
+            return jsonify(code=StatesCode.SUCCESS, message="添加角色成功")
+        except Exception as e:
+            save_log(request, Module.ROLE, OperationType.UPDATE, StatesCode.UNKNOWN_ERROR)
+            return jsonify(code=StatesCode.UNKNOWN_ERROR, message=str(e))
 
     @ns.doc(id='delete_role', description='删除角色')
     @ns.expect(role)
@@ -141,23 +157,27 @@ class RoleApi(Resource):
         role_id = request.form.get('role_id')
 
         if role_id is None:
-            return jsonify(code=StatesCode.UNKNOWN_ERROR, message="角色名和角色id不能为空")
+            return jsonify(code=StatesCode.PARA_ERROR, message="角色名和角色id不能为空")
 
-        # 查询用户，用户的角色为当前角色，无法删除角色
-        with Session(current_app.engine) as session:
-            stmt = select(func.count(User.role)).where(User.role == role_id)
-            results = session.execute(stmt).scalars().first()
+        try:
+            # 查询用户，用户的角色为当前角色，无法删除角色
+            with Session(current_app.engine) as session:
+                stmt = select(func.count(User.role)).where(User.role == role_id)
+                results = session.execute(stmt).scalars().first()
 
-            if results > 0:
-                return jsonify(code=StatesCode.UNKNOWN_ERROR, message="该角色组存在用户，无法删除")
-            else:
-                stmt = delete(Role).where(Role.id == role_id)
-                session.execute(stmt)
-                session.commit()
+                if results > 0:
+                    return jsonify(code=StatesCode.UNKNOWN_ERROR, message="该角色组存在用户，无法删除")
+                else:
+                    stmt = delete(Role).where(Role.id == role_id)
+                    session.execute(stmt)
+                    session.commit()
 
-        save_log(request, Module.ROLE, OperationType.DELETE, StatesCode.SUCCESS)
+            save_log(request, Module.ROLE, OperationType.DELETE, StatesCode.SUCCESS)
 
-        return jsonify(code=StatesCode.SUCCESS, message="删除角色成功")
+            return jsonify(code=StatesCode.SUCCESS, message="删除角色成功")
+        except Exception as e:
+            save_log(request, Module.ROLE, OperationType.DELETE, StatesCode.UNKNOWN_ERROR)
+            return jsonify(code=StatesCode.UNKNOWN_ERROR, message=str(e))
 
 
 get_member = reqparse.RequestParser(bundle_errors=True)
@@ -181,15 +201,19 @@ class RoleMemberApi(Resource):
         role_id = request.args.get('role_id')
 
         if role_id is None:
-            return jsonify(code=StatesCode.UNKNOWN_ERROR, message='角色id不能为空')
+            return jsonify(code=StatesCode.PARA_ERROR, message='角色id不能为空')
 
-        with Session(current_app.engine) as session:
-            stmt = select(User).where(User.role == role_id)
-            results = session.execute(stmt).scalars().all()
+        try:
+            with Session(current_app.engine) as session:
+                stmt = select(User).where(User.role == role_id)
+                results = session.execute(stmt).scalars().all()
 
-        save_log(request, Module.ROLE, OperationType.INQUIRE, StatesCode.SUCCESS)
+            save_log(request, Module.ROLE, OperationType.INQUIRE, StatesCode.SUCCESS)
 
-        return jsonify(code=StatesCode.SUCCESS, message='成功', data=to_dict(results))
+            return jsonify(code=StatesCode.SUCCESS, message='成功', data=to_dict(results))
+        except Exception as e:
+            save_log(request, Module.ROLE, OperationType.INQUIRE, StatesCode.UNKNOWN_ERROR)
+            return jsonify(code=StatesCode.UNKNOWN_ERROR, message=str(e))
 
     @ns.doc(id='delete_role_member', description='移除角色成员')
     @ns.expect(del_member)
@@ -198,16 +222,20 @@ class RoleMemberApi(Resource):
         user_id = request.form.get('user_id')
 
         if user_id is None:
-            return jsonify(code=StatesCode.UNKNOWN_ERROR, message='用户id不能为空')
+            return jsonify(code=StatesCode.PARA_ERROR, message='用户id不能为空')
 
-        with Session(current_app.engine) as session:
-            stmt = update(User).where(User.id == user_id).values(role=None)
-            session.execute(stmt)
-            session.commit()
+        try:
+            with Session(current_app.engine) as session:
+                stmt = update(User).where(User.id == user_id).values(role=None)
+                session.execute(stmt)
+                session.commit()
 
-        save_log(request, Module.ROLE, OperationType.DELETE, StatesCode.SUCCESS)
+            save_log(request, Module.ROLE, OperationType.DELETE, StatesCode.SUCCESS)
 
-        return jsonify(code=StatesCode.SUCCESS, message="移除成功")
+            return jsonify(code=StatesCode.SUCCESS, message="移除成功")
+        except Exception as e:
+            save_log(request, Module.ROLE, OperationType.DELETE, StatesCode.UNKNOWN_ERROR)
+            return jsonify(code=StatesCode.UNKNOWN_ERROR, message=str(e))
 
     # class BatchDeleteRoleMember(Resource):
     @ns.doc(id='batch_delete_role_member', description='批量移除角色成员')
@@ -219,19 +247,23 @@ class RoleMemberApi(Resource):
         if users_id is not None:
             users_id = json.loads(users_id)
         else:
-            return jsonify(code=StatesCode.UNKNOWN_ERROR, message='用户id不能为空')
-
-        values = []
-        for user_id in users_id:
-            values.append({"id": user_id, "role": None})
-
-        with Session(current_app.engine) as session:
-            session.execute(
-                update(User),
-                values
-            )
-            session.commit()
+            return jsonify(code=StatesCode.PARA_ERROR, message='用户id不能为空')
+
+        try:
+            values = []
+            for user_id in users_id:
+                values.append({"id": user_id, "role": None})
+
+            with Session(current_app.engine) as session:
+                session.execute(
+                    update(User),
+                    values
+                )
+                session.commit()
 
-        save_log(request, Module.ROLE, OperationType.BATCH_DELETE, StatesCode.SUCCESS)
+            save_log(request, Module.ROLE, OperationType.BATCH_DELETE, StatesCode.SUCCESS)
 
-        return jsonify(code=StatesCode.SUCCESS, message='批量移除成功')
+            return jsonify(code=StatesCode.SUCCESS, message='批量移除成功')
+        except Exception as e:
+            save_log(request, Module.ROLE, OperationType.BATCH_DELETE, StatesCode.UNKNOWN_ERROR)
+            return jsonify(code=StatesCode.UNKNOWN_ERROR, message=str(e))

src/app/api/users.py

@@ -33,18 +33,22 @@ class GetUserListApi(Resource):
         page = int(request.args.get('page', 1))
 
         if status is None:
-            return jsonify(code=StatesCode.UNKNOWN_ERROR, message='用户状态不能为空')
+            return jsonify(code=StatesCode.PARA_ERROR, message='用户状态不能为空')
+        try:
+            with Session(current_app.engine) as session:
+                count = select(func.count(User.id)).where(User.account_status == status)
+                count_results = session.execute(count).scalars().first()
 
-        with Session(current_app.engine) as session:
-            count = select(func.count(User.id)).where(User.account_status == status)
-            count_results = session.execute(count).scalars().first()
+                stmt = select(User).where(User.account_status == status).offset(page_size * (page - 1)).limit(page_size)
+                results = session.execute(stmt).scalars().all()
 
-            stmt = select(User).where(User.account_status == status).offset(page_size * (page - 1)).limit(page_size)
-            results = session.execute(stmt).scalars().all()
+            save_log(request, Module.USER, OperationType.INQUIRE, StatesCode.SUCCESS)
 
-        save_log(request, Module.USER, OperationType.INQUIRE, StatesCode.SUCCESS)
+            return jsonify(code=StatesCode.SUCCESS, message="成功", total=count_results, data=to_dict(results))
 
-        return jsonify(code=StatesCode.SUCCESS, message="成功", total=count_results, data=to_dict(results))
+        except Exception as e:
+            save_log(request, Module.USER, OperationType.INQUIRE, StatesCode.UNKNOWN_ERROR)
+            return jsonify(code=StatesCode.UNKNOWN_ERROR, message=str(e))
 
 
 add_user = reqparse.RequestParser(bundle_errors=True)
@@ -78,15 +82,19 @@ class UsersApi(Resource):
         user_id = request.args.get('id')
 
         if user_id is None:
-            return jsonify(code=StatesCode.UNKNOWN_ERROR, message="用户id不能为空")
+            return jsonify(code=StatesCode.PARA_ERROR, message="用户id不能为空")
 
-        with Session(current_app.engine) as session:
-            stmt = select(User).where(User.id == user_id)
-            results = session.execute(stmt).scalars().all()
+        try:
+            with Session(current_app.engine) as session:
+                stmt = select(User).where(User.id == user_id)
+                results = session.execute(stmt).scalars().all()
 
-        save_log(request, Module.USER, OperationType.INQUIRE, StatesCode.SUCCESS)
+            save_log(request, Module.USER, OperationType.INQUIRE, StatesCode.SUCCESS)
 
-        return jsonify(code=StatesCode.SUCCESS, message='成功', data=to_dict(results))
+            return jsonify(code=StatesCode.SUCCESS, message='成功', data=to_dict(results))
+        except Exception as e:
+            save_log(request, Module.USER, OperationType.INQUIRE, StatesCode.UNKNOWN_ERROR)
+            return jsonify(code=StatesCode.UNKNOWN_ERROR, message=str(e))
 
     @ns.doc(id='add_users', description='添加用户')
     @ns.expect(add_user)
@@ -107,41 +115,44 @@ class UsersApi(Resource):
         nationality = request.form.get('nationality')
 
         if username is None or password is None:
-            return jsonify(code=StatesCode.UNKNOWN_ERROR, message="用户名或密码不能为空")
-
-        with Session(current_app.engine) as session:
-
-            # 判断用户是否存在
-            stmt = select(User).where(User.user_name == username)
-            result = session.execute(stmt).scalars().first()
-            if result:
-                return jsonify(code=StatesCode.UNKNOWN_ERROR, message="用户已存在")
-
-            # 添加用户
-            session.execute(
-                insert(User).values(
-                    user_name=username,
-                    password=User().generate_password(password),
-                    photograph=photograph,
-                    name=name,
-                    phone=phone,
-                    email=email,
-                    company=company,
-                    department=department,
-                    role=role,
-                    permission=permission,
-                    on_job_status=on_job_status,
-                    duty=duty,
-                    nationality=nationality,
-
+            return jsonify(code=StatesCode.PARA_ERROR, message="用户名或密码不能为空")
+
+        try:
+            with Session(current_app.engine) as session:
+                # 判断用户是否存在
+                stmt = select(User).where(User.user_name == username)
+                result = session.execute(stmt).scalars().first()
+                if result:
+                    return jsonify(code=StatesCode.UNKNOWN_ERROR, message="用户已存在")
+
+                # 添加用户
+                session.execute(
+                    insert(User).values(
+                        user_name=username,
+                        password=User().generate_password(password),
+                        photograph=photograph,
+                        name=name,
+                        phone=phone,
+                        email=email,
+                        company=company,
+                        department=department,
+                        role=role,
+                        permission=permission,
+                        on_job_status=on_job_status,
+                        duty=duty,
+                        nationality=nationality,
+
+                    )
                 )
-            )
 
-            session.commit()
+                session.commit()
 
-        save_log(request, Module.USER, OperationType.ADD, StatesCode.SUCCESS)
+            save_log(request, Module.USER, OperationType.ADD, StatesCode.SUCCESS)
 
-        return jsonify(code=StatesCode.SUCCESS, message="添加用户成功")
+            return jsonify(code=StatesCode.SUCCESS, message="添加用户成功")
+        except Exception as e:
+            save_log(request, Module.USER, OperationType.ADD, StatesCode.UNKNOWN_ERROR)
+            return jsonify(code=StatesCode.UNKNOWN_ERROR, message=str(e))
 
     @ns.doc(id='update_users_details', description='更新用户详情')
     @ns.expect(add_user)
@@ -163,28 +174,34 @@ class UsersApi(Resource):
         duty = request.form.get('duty')
         nationality = request.form.get('nationality')
 
-        with Session(current_app.engine) as session:
-            stmt = update(User).where(User.id == user_id).values(
-                user_name=username,
-                password=User().generate_password(password),
-                photograph=photograph,
-                name=name,
-                phone=phone,
-                email=email,
-                company=company,
-                department=department,
-                role=role,
-                permission=permission,
-                on_job_status=on_job_status,
-                duty=duty,
-                nationality=nationality,
-            )
-            session.execute(stmt)
-            session.commit()
-
-        save_log(request, Module.USER, OperationType.UPDATE, StatesCode.SUCCESS)
-
-        return jsonify(code=StatesCode.SUCCESS, message='修改成功')
+        if user_id is None:
+            return jsonify(code=StatesCode.PARA_ERROR, message='用户id不能为空')
+        try:
+            with Session(current_app.engine) as session:
+                stmt = update(User).where(User.id == user_id).values(
+                    user_name=username,
+                    password=User().generate_password(password),
+                    photograph=photograph,
+                    name=name,
+                    phone=phone,
+                    email=email,
+                    company=company,
+                    department=department,
+                    role=role,
+                    permission=permission,
+                    on_job_status=on_job_status,
+                    duty=duty,
+                    nationality=nationality,
+                )
+                session.execute(stmt)
+                session.commit()
+
+            save_log(request, Module.USER, OperationType.UPDATE, StatesCode.SUCCESS)
+
+            return jsonify(code=StatesCode.SUCCESS, message='修改成功')
+        except Exception as e:
+            save_log(request, Module.USER, OperationType.UPDATE, StatesCode.UNKNOWN_ERROR)
+            return jsonify(code=StatesCode.UNKNOWN_ERROR, message=str(e))
 
     @ns.doc(id='delete_users', description='删除用户')
     @ns.expect(add_user)
@@ -193,16 +210,20 @@ class UsersApi(Resource):
         user_id = request.form.get('id')
 
         if user_id is None:
-            return jsonify(code=StatesCode.UNKNOWN_ERROR, message="用户id不能为空")
+            return jsonify(code=StatesCode.PARA_ERROR, message="用户id不能为空")
 
-        with Session(current_app.engine) as session:
-            stmt = delete(User).where(User.id == user_id)
-            session.execute(stmt)
-            session.commit()
+        try:
+            with Session(current_app.engine) as session:
+                stmt = delete(User).where(User.id == user_id)
+                session.execute(stmt)
+                session.commit()
 
-        save_log(request, Module.USER, OperationType.DELETE, StatesCode.SUCCESS)
+            save_log(request, Module.USER, OperationType.DELETE, StatesCode.SUCCESS)
 
-        return jsonify(code=StatesCode.SUCCESS, message="删除成功")
+            return jsonify(code=StatesCode.SUCCESS, message="删除成功")
+        except Exception as e:
+            save_log(request, Module.USER, OperationType.DELETE, StatesCode.UNKNOWN_ERROR)
+            return jsonify(code=StatesCode.UNKNOWN_ERROR, message=str(e))
 
 
 users_status = reqparse.RequestParser(bundle_errors=True)
@@ -222,16 +243,20 @@ class GetUsersApi(Resource):
         account_status = int(request.form.get('status'))
 
         if user_id is None or account_status is None:
-            return jsonify(code=StatesCode.UNKNOWN_ERROR, message="用户id或用户状态不能为空")
+            return jsonify(code=StatesCode.PARA_ERROR, message="用户id或用户状态不能为空")
 
-        with Session(current_app.engine) as session:
-            stmt = update(User).where(User.id == user_id).values(account_status=account_status)
-            session.execute(stmt)
-            session.commit()
+        try:
+            with Session(current_app.engine) as session:
+                stmt = update(User).where(User.id == user_id).values(account_status=account_status)
+                session.execute(stmt)
+                session.commit()
 
-        save_log(request, Module.USER, OperationType.UPDATE, StatesCode.SUCCESS)
+            save_log(request, Module.USER, OperationType.UPDATE, StatesCode.SUCCESS)
 
-        return jsonify(code=StatesCode.SUCCESS, message="修改用户状态成功")
+            return jsonify(code=StatesCode.SUCCESS, message="修改用户状态成功")
+        except Exception as e:
+            save_log(request, Module.USER, OperationType.UPDATE, StatesCode.UNKNOWN_ERROR)
+            return jsonify(code=StatesCode.UNKNOWN_ERROR, message=str(e))
 
 
 batch_delete_user = reqparse.RequestParser(bundle_errors=True)
@@ -251,19 +276,23 @@ class BatchDeleteUserApi(Resource):
         if users_id is not None:
             users_id = json.loads(users_id)
         else:
-            return jsonify(code=StatesCode.UNKNOWN_ERROR, message='用户id不能为空')
+            return jsonify(code=StatesCode.PARA_ERROR, message='用户id不能为空')
 
-        with Session(current_app.engine) as session:
-            stmt = select(User).where(User.id.in_(users_id))
-            results = session.execute(stmt).scalars().all()
+        try:
+            with Session(current_app.engine) as session:
+                stmt = select(User).where(User.id.in_(users_id))
+                results = session.execute(stmt).scalars().all()
 
-            for result in results:
-                session.delete(result)
-            session.commit()
+                for result in results:
+                    session.delete(result)
+                session.commit()
 
-        save_log(request, Module.USER, OperationType.BATCH_DELETE, StatesCode.SUCCESS)
+            save_log(request, Module.USER, OperationType.BATCH_DELETE, StatesCode.SUCCESS)
 
-        return jsonify(code=StatesCode.SUCCESS, message='批量删除成功')
+            return jsonify(code=StatesCode.SUCCESS, message='批量删除成功')
+        except Exception as e:
+            save_log(request, Module.USER, OperationType.BATCH_DELETE, StatesCode.UNKNOWN_ERROR)
+            return jsonify(code=StatesCode.UNKNOWN_ERROR, message=str(e))
 
 
 batch_modify_user_status = reqparse.RequestParser(bundle_errors=True)
@@ -287,22 +316,26 @@ class BatchModifyUsersStatusApi(Resource):
         if users_id is not None and account_status is not None:
             users_id = json.loads(users_id)
         else:
-            return jsonify(code=StatesCode.UNKNOWN_ERROR, message='用户id和状态不能为空')
+            return jsonify(code=StatesCode.PARA_ERROR, message='用户id和状态不能为空')
 
-        values = []
-        for user_id in users_id:
-            values.append({"id": user_id, "account_status": account_status})
+        try:
+            values = []
+            for user_id in users_id:
+                values.append({"id": user_id, "account_status": account_status})
 
-        with Session(current_app.engine) as session:
-            session.execute(
-                update(User),
-                values
-            )
-            session.commit()
+            with Session(current_app.engine) as session:
+                session.execute(
+                    update(User),
+                    values
+                )
+                session.commit()
 
-        save_log(request, Module.USER, OperationType.BATCH_UPDATE, StatesCode.SUCCESS)
+            save_log(request, Module.USER, OperationType.BATCH_UPDATE, StatesCode.SUCCESS)
 
-        return jsonify(code=StatesCode.SUCCESS, message='批量修改用户状态成功')
+            return jsonify(code=StatesCode.SUCCESS, message='批量修改用户状态成功')
+        except Exception as e:
+            save_log(request, Module.USER, OperationType.BATCH_UPDATE, StatesCode.UNKNOWN_ERROR)
+            return jsonify(code=StatesCode.UNKNOWN_ERROR, message=str(e))
 
 
 @ns.route('/export_data')
@@ -312,35 +345,41 @@ class ExportDataApi(Resource):
     @ns.doc(id='export_data', description='导出用户数据')
     def get(self):
         """导出用户数据"""
-        with Session(current_app.engine) as session:
-            stmt = select(User)
-            results = session.execute(stmt).scalars().all()
-
-        my_xlwt = MyXlwt()
-
-        title = ['id', 'user_name', 'password', 'photograph', 'name', 'phone', 'email', 'company', 'department', 'role',
-                 'permission', 'on_job_status', 'duty', 'account_status', 'nationality', 'register_time',
-                 'common_menus']
-
-        # 写入标题
-        my_xlwt.write_row(0, 0, title)
-        # 写入内容
-        start_row = 1  # 内容起始行
-        for result in results:
-            data = [result.id, result.user_name, result.password, result.photograph, result.name, result.phone,
-                    result.email, result.company, result.department, result.role, result.permission,
-                    result.on_job_status,
-                    result.duty, result.account_status, result.nationality, result.register_time, result.common_menus]
-            my_xlwt.write_row(start_row, 0, data)
-
-            start_row += 1
-
-        output = BytesIO()
-        my_xlwt.save(output)
-        response = Response(output.getvalue())
-        response.headers['Content-Type'] = 'application/octet-stream'
-        response.headers['Content-Disposition'] = 'attachment; filename=%s' % 'users.xls'
-
-        save_log(request, Module.USER, OperationType.EXPORT, StatesCode.SUCCESS)
-
-        return response
+        try:
+            with Session(current_app.engine) as session:
+                stmt = select(User)
+                results = session.execute(stmt).scalars().all()
+
+            my_xlwt = MyXlwt()
+
+            title = ['id', 'user_name', 'password', 'photograph', 'name', 'phone', 'email', 'company', 'department',
+                     'role',
+                     'permission', 'on_job_status', 'duty', 'account_status', 'nationality', 'register_time',
+                     'common_menus']
+
+            # 写入标题
+            my_xlwt.write_row(0, 0, title)
+            # 写入内容
+            start_row = 1  # 内容起始行
+            for result in results:
+                data = [result.id, result.user_name, result.password, result.photograph, result.name, result.phone,
+                        result.email, result.company, result.department, result.role, result.permission,
+                        result.on_job_status,
+                        result.duty, result.account_status, result.nationality, result.register_time,
+                        result.common_menus]
+                my_xlwt.write_row(start_row, 0, data)
+
+                start_row += 1
+
+            output = BytesIO()
+            my_xlwt.save(output)
+            response = Response(output.getvalue())
+            response.headers['Content-Type'] = 'application/octet-stream'
+            response.headers['Content-Disposition'] = 'attachment; filename=%s' % 'users.xls'
+
+            save_log(request, Module.USER, OperationType.EXPORT, StatesCode.SUCCESS)
+
+            return response
+        except Exception as e:
+            save_log(request, Module.USER, OperationType.EXPORT, StatesCode.UNKNOWN_ERROR)
+            return jsonify(code=StatesCode.UNKNOWN_ERROR, message=str(e))