添加敏感词

dbgpt/app/apps/vadmin/word/crud.py

@@ -14,7 +14,7 @@ from sqlalchemy.orm import joinedload, aliased
 from sqlalchemy.orm.strategy_options import _AbstractLoad, contains_eager
 from dbgpt.app.apps.core.exception import CustomException
 from fastapi.encoders import jsonable_encoder
-from sqlalchemy import select, false, and_
+from sqlalchemy import select, false, and_, update
 from dbgpt.app.apps.core.crud import DalBase
 from sqlalchemy.ext.asyncio import AsyncSession
 from dbgpt.app.apps.core.validator import vali_telephone
@@ -27,7 +27,7 @@ from dbgpt.app.apps.utils.tools import test_password
 
 from . import models, schemas
 from .params.similar import SimilarParams
-from .schemas.similar import SimilarIn
+from .schemas.similar import SimilarIn,SimilarUpdate
 from .schemas.sensitive import SensitiveIn
 from .models import sensitive
 
@@ -69,17 +69,14 @@ class SimilarDal(DalBase):
         else:
             print(f"编号：{similar1.id} 词条：{similar1.word_name} 近义词：{similar1.similar_name} ")
 
-    async def delete_similar_byid(self, qid):
-        """
-        根据ID删除一个近义词
-        """
-        sql1 = self.delete_datas(qid)
-        queryset1 = await self.db.scalars(sql1)
-        similar1 = queryset1.unique().first()
-        if similar1 is None:
-            print('similar1 is None')
-        else:
-            print(f"编号：{similar1.id} 词条：{similar1.word_name} 近义词：{similar1.similar_name} ")
+    async def update_similars(self, ids: [], data: SimilarUpdate):
+        await self.db.execute(
+            update(self.model).where(self.model.id.in_(ids)).values(
+                update_datetime=datetime.now().strftime("%Y-%m-%d %H:%M:%S"),
+                word_name=data.word_name,
+                similar_name=data.similar_name
+            )
+        )
 
     async def create_similar_data(
             self,
@@ -121,4 +118,44 @@ class SensitiveDal(DalBase):
         self.model = models.sensitive.VadminWordSensitive
         self.schema = schemas.sensitive.SensitiveSchemas
 
+    async def create_sensitive_data(
+            self,
+            data: SensitiveIn,
+            v_options: list[_AbstractLoad] = None,
+            v_return_obj: bool = False,
+            v_schema: Any = None
+    ) -> Any:
+        """
+        创建敏感词
+        :param data:
+        :param v_options:
+        :param v_return_obj:
+        :param v_schema:
+        :return:
+        """
+        if data is None:
+            raise CustomException("data is None！", code=status.HTTP_ERROR)
+
+        unique = await self.get_data(word_name=data.word_name, v_return_none=True)
+        if unique:
+            raise CustomException("词条已存在！", code=status.HTTP_ERROR)
+
+        obj = self.model()
+        obj.word_name = data.word_name
+
+        #await self.flush(obj)
+        #return await self.out_dict(obj, v_options, v_return_obj, v_schema)
+        self.db.add(obj)
+        await self.db.commit()
+        return None
+
+    async def get_sensitives(self)-> Any:
+        sql = select(models.sensitive.VadminWordSensitive).where(models.sensitive.VadminWordSensitive.is_delete == false())
+        queryset = await self.db.scalars(sql)
+        """
+        for row in dataqs:
+            print(f"编号：{row.id} 词条：{row.word_name} ")
+        """
+        return list(queryset.all())
+
 

dbgpt/app/apps/vadmin/word/schemas/sensitive.py

@@ -21,13 +21,9 @@ class SensitiveSchemas(BaseModel):
 
 class SensitiveIn(SensitiveSchemas):
     """
-    创建近义词
+    创建敏感词
     """
     word_name: str | None = ""
-    is_delete: int | None = 0
-    create_datetime: datetime | None = None
-    update_datetime: datetime | None = None
-    delete_datetime: datetime | None = None
 
 class SensitiveOut(SensitiveSchemas):
     word_name: str | None = ""
@@ -38,7 +34,7 @@ class SensitiveOut(SensitiveSchemas):
 
 class SensitiveUpdate(BaseModel):
     """
-    更新近义词信息
+    更新敏感词信息
     """
     word_name: str | None = ""
     is_delete: int | None = 0

dbgpt/app/apps/vadmin/word/schemas/similar.py

@@ -39,13 +39,9 @@ class SimilarOut(SimilarSchemas):
     update_datetime: datetime | None = None
     delete_datetime: datetime | None = None
 
-class SimilarUpdate(BaseModel):
+class SimilarUpdate(SimilarSchemas):
     """
     更新近义词信息
     """
     word_name: str | None = ""
     similar_name: str | None = ""
-    is_delete: int | None = 0
-    create_datetime: datetime | None = None
-    update_datetime: datetime | None = None
-    delete_datetime: datetime | None = None

dbgpt/app/apps/vadmin/word/views.py

@@ -9,7 +9,8 @@ from dbgpt.app.apps.vadmin.auth.utils.validation.auth import Auth
 from . import schemas, crud, models
 from dbgpt.app.apps.vadmin.word.models.similar import VadminWordSimilar
 from dbgpt.app.apps.vadmin.word.params.similar import SimilarParams
-from dbgpt.app.apps.vadmin.word.schemas.similar import SimilarSchemas, SimilarIn
+from dbgpt.app.apps.vadmin.word.schemas.similar import SimilarSchemas, SimilarIn,SimilarUpdate
+from dbgpt.app.apps.vadmin.word.schemas.sensitive import SensitiveSchemas, SensitiveIn
 from dbgpt.app.apps.vadmin.word import crud
 from fastapi.encoders import jsonable_encoder
 
@@ -40,15 +41,15 @@ async def create_similar(data: Request, auth: Auth = Depends(OpenAuth())):
     else:
         print(f"req词条：{data.query_params['word_name']} req近义词：{data.query_params['similar_name']} ")
 
-    data: SimilarIn
-    data.word_name = data.query_params['word_name']
-    data.similar_name = data.query_params['similar_name']
-    data.is_delete = 0
-    data.create_datetime = ''
-    data.update_datetime = ''
-    data.delete_datetime = ''
+    sdata = SimilarIn()
+    sdata.word_name = data.query_params['word_name']
+    sdata.similar_name = data.query_params['similar_name']
+    sdata.is_delete = 0
+    sdata.create_datetime = ''
+    sdata.update_datetime = ''
+    sdata.delete_datetime = ''
 
-    await crud.SimilarDal(auth.db).create_similar_data(data=data)
+    await crud.SimilarDal(auth.db).create_similar_data(data=sdata)
 
     datas = []
     return SuccessResponse(datas, count=1)
@@ -67,18 +68,60 @@ async def delete_similars(data: Request, auth: Auth = Depends(OpenAuth())):
     await crud.SimilarDal(auth.db).delete_datas(ids=similarids, v_soft=True)
     return SuccessResponse("删除成功")
 
-@router.get("/update_similar_byid", summary="根据id修改同义词")
-async def update_similar_byid(auth: Auth = Depends(OpenAuth())):
-    model = VadminWordSimilar
-    print(f"编号：{model.id} 近义词：{model.word_name}")
+@router.post("/update_similar_byid", summary="根据id修改同义词")
+async def update_similar_byid(data: Request, auth: Auth = Depends(OpenAuth())):
+    if data is None:
+        print('SimilarIn is None')
+        return ErrorResponse("不能修改当前近义词")
+    else:
+        print(f"word_id：{data.query_params['word_id']} req词条：{data.query_params['word_name']} req词条：{data.query_params['word_name']} req近义词：{data.query_params['similar_name']} ")
 
-    datas = await crud.SimilarDal(auth.db).get_similars()
+    data_id = data.query_params['word_id']
+
+    sdata = SimilarUpdate
+    sdata.word_name = data.query_params['word_name']
+    sdata.similar_name = data.query_params['similar_name']
+
+    similarids = []
+    similarids.append(data_id)
+
+    await crud.SimilarDal(auth.db).update_similars(similarids, sdata)
+    return SuccessResponse("修改成功")
+
+###########################################################
+#    敏感词管理
+###########################################################
+@router.post("/create_sensitive", summary="创建敏感词")
+async def create_sensitive(req: Request, auth: Auth = Depends(OpenAuth())):
+    if req is None:
+        print('SimilarIn is None')
+        return ErrorResponse("不能创建当前敏感词")
+    else:
+        print(f"req词条：{req.query_params['word_name']} ")
+
+    """
+    sdata = SensitiveSchemas()
+    sdata.word_name = req.query_params['word_name']
+    return SuccessResponse(await crud.SensitiveDal(auth.db).create_data(data=sdata))
+    """
+
+    sdata = SensitiveIn
+    sdata.word_name = req.query_params['word_name']
+    sdata.is_delete = 0
+    sdata.create_datetime = ''
+    sdata.update_datetime = ''
+    sdata.delete_datetime = ''
+
+    await crud.SensitiveDal(auth.db).create_sensitive_data(data=sdata)
+
+    return SuccessResponse("请求成功!")
+
+@router.get("/get_sensitives", summary="获取敏感词列表")
+async def get_sensitives(auth: Auth = Depends(OpenAuth())):
+
+    datas = await crud.SensitiveDal(auth.db).get_sensitives()
     jsondatas = jsonable_encoder(datas)
 
     for row in datas:
-        print(f"编号：{row.id} 词条：{row.word_name} 近义词：{row.similar_name} ")
+        print(f"编号：{row.id} 词条：{row.word_name} ")
     return SuccessResponse(jsondatas, count=1)
\ No newline at end of file
-
-@router.post("/create_sensitive", summary="创建敏感词")
-async def create_user(data: schemas.SensitiveIn, auth: Auth = Depends(OpenAuth())):
-    return SuccessResponse(await crud.SensitiveDal(auth.db).create_data(data=data))
\ No newline at end of file