增加ESB回调接口

agent/config.ini

@@ -31,6 +31,7 @@ password = 123456
 [app]
 port=9876
 concurrence=1
+esb_callback=http://xxxxx:xxxx/api/callback
 
 [logging]
 log_path= logs/aitagging-app.log

agent/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "agent"
-version = "0.1.8.2"
+version = "0.1.8.3"
 description = "Default template for PDM package"
 authors = [
     {name = "jiayongqiang", email = "15936285643@163.com"},

agent/src/agent/agent.py

@@ -51,8 +51,8 @@ class Lables(BaseModel):
     """
     labels: list[Lable] = Field(description="List of optimized labels after reflection.")
     
-
-async def reflect_check(context: str,is_marine: bool, labels: list[str]):
+def reflect_check_sync(context: str,is_marine: bool, labels: list[str]):
+    """同步版本的 reflect_check，用于后台任务"""
     agent = create_agent(
         model = llm, 
         response_format=Lables
@@ -60,114 +60,51 @@ async def reflect_check(context: str,is_marine: bool, labels: list[str]):
     prompt = f"""
     一、角色与职责
 你是一名银行智能标签平台中的语义判定模型，负责基于贷款信息文本内容，对候选标签进行相关性判断和筛选。
-你的核心职责是判断现有文本内容是否足以支撑在本笔贷款层面打上某个产业标签，而非识别企业整体行业属性或主营业务。
-你的任务是从“贷款打标”的视角，评估文本中所描述的资产、项目、合同、用途、消费场景或相关经济活动，是否与标签定义所描述的产业活动在语义上存在明确、合理或可延伸的关联，并判断文本是否提供了可引用的内容作为标签命中的依据。
-二、机构属性信息
-本次请求包含机构涉海属性标识：
-是否沿海行社：{is_marine}
-其中：
-- is_marine = 1：
-表示当前请求来自沿海行社，需要启用“涉海宽泛推荐策略”
-- is_marine = 0：
-表示当前请求为普通标准推荐请求，应保持标准语义匹配策略
-
-三、基本工作原则
-在整个判定过程中，你必须遵循以下原则：
-1.仅依据所提供的文本内容进行判断，不得引入外部资料
-2.不要求文本构成完整行业介绍或业务说明
-3.不要求覆盖标签定义全部要素
-4.允许基于上下文进行合理语义理解
-5.所有结论必须能够回溯到具体文本证据
-6.若存在不确定性，应通过置信度和不确定性说明体现，而非直接否定命中
-7.判定目标应服务于产业标签推荐的可用性、覆盖性与可解释性
-
-四、沿海宽泛打标策略（仅沿海行社生效）
-若“是否沿海行社”为“是”，则在海洋经济相关标签判定时，需要采用宽泛匹配策略。
-宽泛匹配策略定义如下：
-1.允许基于沿海区域经济特征进行场景级语义延伸
-即：若文本描述的消费、建设、经营、配套或服务场景，与海洋经济产业链存在合理关联，即使未直接出现“海洋”“海产”“港口”“渔业”等关键词，也可视为有效关联。
-
-2.允许识别涉海间接场景
-例如但不限于：
-- 民宿装修
-- 酒店装修
-- 景区建设
-- 旅游消费
-- 餐饮配套
-- 冷链仓储
-- 物流运输
-- 文旅服务
-
-上述场景在沿海区域可能与：
-- 海洋旅游
-- 涉海消费
-- 海产品流通
-- 海洋文旅
-- 海洋服务产业
-等存在产业关联。
-
-3.允许采用“最相近涉海标签”推荐策略
-对于中性文本，若无法形成严格语义命中，但能够与海洋经济场景形成合理关联，可优先推荐海洋经济标签体系中语义最相近的标签。
-例如：
-- “民宿装修” → “涉海旅游消费”
-- “酒店改造” → “海洋文旅服务”
-- “冷链仓储” → “海产品流通配套”
-
-4.宽泛推荐并不等于无条件命中
-即使采用宽泛策略，仍需满足：
-- 存在合理产业关联
-- 存在可解释的场景链路
-- 能够说明推荐逻辑
-- 不得对明显无关内容强行推荐涉海标签
-
-5.对于宽泛关联场景
-可通过：
-- “弱关联”
-- “场景延伸关联”
-- “区域产业关联”
-等方式体现不确定性。
-
-五、非沿海行社策略
-若“是否沿海行社”为“否”，则：
-- 不进行区域产业延伸
-- 不进行涉海宽泛推荐
-- 保持原有标准语义匹配逻辑
-- 仅依据文本与标签定义之间的直接语义关联进行判定
-六、候选标签
+你的核心职责是从“贷款打标”的视角，评估文本中所描述的资产、项目、合同、用途或相关经济活动，是否与标签定义所描述的产业活动在语义上存在明确、合理、可引用的关联。
+
+二、基本工作原则
+1. 仅依据所提供的文本内容进行判断，不得引入外部资料。
+2. 不要求文本构成完整的行业介绍或业务说明。
+3. 不要求覆盖标签定义的全部要素。
+4. 所有结论必须能够回溯到具体文本证据。
+5. “语义不矛盾”不等于“语义有关联”。仅凭无法排除可能性就推荐标签属于错误判定。
+6. 若存在合理支持但信息不完整，可判定命中并通过不确定性说明体现风险，但绝不允许在没有任何语义连接点的情况下强行命中。
+7. 转贷操作词无效原则：如果文本中出现“无还本续贷”“借新还旧”“二押”“收回再贷”“压降转贷”等表述，这些属于贷款操作形式，其本身不能作为任何产业标签关联的实质依据。判定时必须忽略这些操作词，重点分析文本中括号内补充的内容，或上下文中的“投向”“用途”等字段里的实质性描述。若实质内容缺失，无法判断产业关联，则所有标签均判false。此原则适用于所有产业标签体系。
+
+三、关键判定标准（必须遵守）
+1. 关联性必须具体：文本中必须出现某个实体、行为、商品、服务、场景或用途，能够与标签定义中的产业活动形成直接或可解释的间接关联。
+2. 常识否定原则：若文本所描述的活动具有明显与该标签所属产业体系核心特征相悖的常识性冲突（例如在海洋经济体系中，茶叶种植等典型内陆活动不得推荐涉海标签），则不得推荐该标签。
+3. 排除情形必须严格执行：若文本内容明确符合标签定义中的排除说明，应判定为不命中；若标签定义无明确排除，但常识上显著冲突，也应判定为不命中。
+
+四、海洋经济体系专属规则
+本部分规则仅适用于标签所属产业体系为“海洋经济”的标签。体系归属可通过标签定义中的体系名称或标签路径前缀（如"海洋产业"/"海洋科研教育"/"海洋公共管理服务"/"海洋上游相关产业"/"海洋下游相关产业"等）识别。对于养老产业、科技金融等其他体系的标签，请忽略本部分所有内容，直接进入第五步进行标准语义判定。
+
+当前贷款发起行社的沿海标识为 {is_marine} （1=沿海行社，0=非沿海行社），该参数仅在处理海洋经济体系标签时生效。
+
+1. 教育场景排除规则
+如果文本中的用途涉及“学费”“住宿费”“培训费”“杂费”等教育类支出，且投向描述为“普通高等教育”“大学”“学院”等未明确指向海洋相关专业的学历教育：
+a. 绝对不得推荐“海洋中等职业教育”“海洋社会人文科学研究”及其他海洋教育/科研类标签。
+b. 除非文本中明确出现了“海洋”“航海”“水产”等涉海专业名称或科研机构，否则视为不命中。
+
+2. 沿海行社宽泛匹配规则
+当 {is_marine} = 1 时，启用以下扩展推理授权：
+a. 对于文本中出现的住宿、餐饮、装修、仓储、物流、运输、批发零售等具有服务或流通属性的行业性描述，允许在语义上进行适度延伸，将标签定义中最相近的涉海服务类标签（如“涉海旅游消费”“涉海物流”“涉海批发经营”等）纳入候选判断。
+b. 进行此类延伸时，文本中仍必须存在可关联的实体或行为，不得凭空推荐。延伸推荐的理由中应注明“基于沿海区域宽泛匹配推断，需人工确认”。
+当 {is_marine} = 0 时，禁用上述扩展推理，严格按照标准语义关联进行判断，不允许任何无直接证据的延伸推荐。
+
+五、候选标签
 以下是本次判定所依据的产业标签定义信息：
-{labels}
-
-七、贷款信息
-{context}
-
-八、语义判定任务说明（核心）
-请你基于以上信息，从“贷款打标”的视角完成语义判定，重点判断以下问题：
-
-1.关联性判断
-文本中描述的资产、项目、合同、用途、消费或经营场景，是否与标签定义存在明确、合理或可延伸的产业关联。
-2.证据支持性判断
-文本是否提供了可引用的具体内容（如项目性质、消费场景、建设行为、资产类型、经营活动等），能够作为标签推荐依据。
-3.隐含语义识别
-若文本未直接使用标签术语，但通过对象、行为、交易或场景特征能够合理指向产业语义，可视为有效支持。
-4.沿海场景延伸识别（仅沿海行社）
-对于中性消费、装修、建设、服务类文本，需要结合沿海区域经济特征，识别其是否可能属于海洋经济延伸场景。
-5.排除情形核验
-若文本明确符合标签排除情形，应判定为不命中。
-6.避免过度保守
-“信息不完整”“未完全覆盖定义”不等同于“不应命中”。
-对于存在合理支持但存在信息缺口的情况，应允许命中，并通过不确定性说明体现风险。
-九、判定风格约束
-1.不将“未明确说明”等同于“不支持”
-2.不将“不能完全确认”等同于“不应命中”
-3.不以企业整体行业属性替代对贷款具体内容的判断
-4.沿海场景下，应适度提高海洋经济标签覆盖率
-5.所有判断应服务于产业打标的可用性、覆盖性与可解释性
+    {labels}
+
+六、贷款信息
+    {context}   
+
     """
     uid = uuid.uuid4().hex
     l1 = datetime.now().isoformat()
     logger.info(f"Starting reflection check with uuid {uid}. timestamp: {l1}")
-    response = await agent.ainvoke({
-        "messages": [{"role":"system","content": prompt}]
+    response = agent.invoke({
+        "messages": [{"role":"user","content": prompt}]
     },context = {})
     result = response["structured_response"]
     logger.info(f"{context} LLM result: {result}")

agent/src/agent/api_outter.py

@@ -1,4 +1,5 @@
 import re
+import threading
 from fastapi import APIRouter , UploadFile 
 from pydantic import BaseModel,Field, field_validator
 from requests import request
@@ -6,7 +7,6 @@ from agent.core.sign_check import check
 import agent.core.dao as dao
 from agent.core.vector import get_embeddings
 from agent.core.es import hybrid_search,bm25_vector_search
-from agent.agent import reflect_check
 from datetime import datetime
 import uuid
 from fastapi import BackgroundTasks
@@ -15,12 +15,17 @@ import json
 from agent.logger import logger
 from agent.core.config import get_config_path
 import asyncio
-from agent.core.tagging_state import TAGGING_STATE
+from agent.core.tagging_state import TAGGING_STATE,TAGGING_CHANNEL
 import time
+from concurrent.futures import ThreadPoolExecutor
+import requests
+
 
 config = get_config_path()
 CONCURRENCE = int(config['app']['concurrence'])
-background_semaphore = asyncio.Semaphore(CONCURRENCE)
+# background_semaphore = threading.BoundedSemaphore(CONCURRENCE)
+executor = ThreadPoolExecutor(max_workers=CONCURRENCE)
+ESB_CALLBACK = config['app']['esb_callback']
 
 router = APIRouter(prefix="/v1", tags=["AI Tagging"])
 
@@ -56,7 +61,7 @@ class TaggingRequest(BaseModel):
             return None
         return str(v)
 
-async def execute_reg(log_id:str,tag_category_id:str,phrase: str)-> list:
+def execute_reg(log_id:str,tag_category_id:str,phrase: str)-> list:
     sql = f"""select 
                     tti.id,
                     tti.reg
@@ -70,18 +75,23 @@ async def execute_reg(log_id:str,tag_category_id:str,phrase: str)-> list:
     labels = dao.query(sql)
     # 循环调用reg匹配phrase，匹配成功则返回标签id
     result = [label[0] for label in labels]
-    dao.execute(
-            """UPDATE aitag_tag_log SET reg_result = %s WHERE id = %s""",
-            (str(result), log_id)
-        )
+    if result and len(result) > 0:
+        dao.execute(
+                """UPDATE aitag_tag_log SET reg_result = %s,tagging_channel = %s WHERE id = %s""",
+                (str(result), TAGGING_CHANNEL.REG.value, log_id)    
+            )
     logger.info(f"[{log_id}] Regex filtering result: {result}")
     return result
 
-def vector_similarity_search(phrase: str)-> list:
+def vector_similarity_search(log_id:str,phrase: str)-> list:
     logger.info("Starting vector similarity search...")
     # 这里应该调用向量数据库进行相似度检索，返回相关标签id列表
     query = get_embeddings([phrase])[0]
     results = bm25_vector_search(phrase,query)
+    dao.execute(
+            """UPDATE aitag_tag_log SET tagging_channel = %s WHERE id = %s""",
+            (TAGGING_CHANNEL.VECTOR.value, log_id)    
+        )
     return results
 
 def init_tag_log(request: TaggingRequest):
@@ -158,15 +168,20 @@ def defined_rule_match(phrase: str):
         result = []
     return result
 
-def end_tagging_predefined_rule(id:str, result:str):
+def end_tagging_predefined_rule(id:str, result:str, business_attr: Optional[str] = None):
     dao.execute(
-            """UPDATE aitag_tag_log SET state = %s, result = %s,ai_result_endtime = %s WHERE id = %s""",
-            (TAGGING_STATE.PREDEFINED_RULE_MATCH.value, result,datetime.now(),  id)
+            """UPDATE aitag_tag_log SET state = %s, result = %s,ai_result_endtime = %s,tagging_channel = %s WHERE id = %s""",
+            (TAGGING_STATE.PREDEFINED_RULE_MATCH.value, result,datetime.now(), TAGGING_CHANNEL.RULES.value, id)
         )
+    if business_attr is not None and ESB_CALLBACK is not None:
+        try:
+            requests.get(ESB_CALLBACK,timeout=3, params={"businessAttr": business_attr})
+        except Exception as e:
+            logger.error(f"ESB callback failed: {e}")
 
-async def run_ai_pipeline(log_id: str, tag_category_id: str, phrase: str, instucde: Optional[str] = None):
+def run_ai_pipeline(log_id: str, tag_category_id: str, phrase: str, instucde: Optional[str] = None, business_attr: Optional[str] = None):
     try:
-        async with background_semaphore:
+        # with background_semaphore:
             logger.info(f"开始打标:{log_id}, {phrase}")
             # step0: 开始打标，初始化打标日志，如果是在行社白名单中，标记下
             is_marine = start_tagging(log_id, instucde)
@@ -175,20 +190,21 @@ async def run_ai_pipeline(log_id: str, tag_category_id: str, phrase: str, instuc
             defined_rule_result = defined_rule_match(phrase)    
             if defined_rule_result:
                 logger.info(f"预设规则匹配成功，直接返回结果: {defined_rule_result}")
-                end_tagging_predefined_rule(log_id, json.dumps(defined_rule_result))
+                end_tagging_predefined_rule(log_id, json.dumps(defined_rule_result, business_attr))
                 return
 
             # step1: 正则过滤
-            result = await execute_reg(log_id,tag_category_id,phrase)
+            result = execute_reg(log_id,tag_category_id,phrase)
             # step2: 向量检索
             if not result or len(result) == 0:
-                result = vector_similarity_search(phrase)
+                result = vector_similarity_search(log_id,phrase)
             # step3: LLM 打标
             if result and len(result) > 0:
                 try:
                     tags = dao.query_dict(""" select id,tag_nm as tag_name,tag_code, tag_path,category_id,tag_prompt from aitag_tag_info where id in %s """, (tuple(result),))
                     logger.info(f"筛选结果: {tags}")
-                    result = await reflect_check(phrase,is_marine, tags)
+                    from agent.agent import reflect_check_sync
+                    result = reflect_check_sync(phrase,is_marine, tags)
                 except Exception as e:
                     logger.error(f"LLM reflection check failed: {e}")
                     result = None
@@ -222,13 +238,14 @@ async def ai_tagging(request: TaggingRequest,background_tasks: BackgroundTasks):
     logger.info(f"esb_seq_no: {request.esb_seq_no}, business_attr: {request.business_attr}, phrase: {request.phrase}")
     # 数据库中插入一条记录，记录请求的app_id、timestamp、business_attr、phrase等信息，状态设为“处理中”，后续步骤完成后更新状态和结果
     id = init_tag_log(request)
-    # 执行异步任务
-    background_tasks.add_task(
-        run_ai_pipeline,  # 后台任务函数
+    # 执行异步任务：直接调用同步的 run_ai_pipeline，FastAPI 会在后台线程池中执行
+    future = executor.submit(
+        run_ai_pipeline,  # 直接使用同步的 run_ai_pipeline
         log_id=id,
         tag_category_id=request.tag_category_id,    
         phrase=request.phrase,
-        instucde=request.instucde
+        instucde=request.instucde,
+        business_attr=request.business_attr
     )
     logger.info(f"Started background task for log_id: {id}")
     return {

agent/src/agent/core/tagging_state.py

@@ -17,4 +17,9 @@ class TAGGING_STATE(Enum):
     PUSHED = 3
     BEGIN = 4
     FAIL = 5
-    PREDEFINED_RULE_MATCH = 6
+    PREDEFINED_RULE_MATCH = 6
+
+class TAGGING_CHANNEL(Enum):
+    REG = 0
+    VECTOR = 1
+    RULES = 2

agent/tests/test_tagging.py

@@ -3,23 +3,24 @@ import logging
 logging.basicConfig(level=logging.INFO, force=True,format='%(asctime)s - %(levelname)s - %(message)s')
 logging.info("app starting!")
 
-res = requests.post("http://10.192.72.13:9876/api/aitag/v1/tagging", json={
-    # "app_id": "test_app",
-    # "timestamp": 1234567890,
-    # "sign": "test_sign",
-    "esb_seq_no":"abc",
-    "business_attr": "test_attr10",
-    "phrase": "测试:职业：自由；投向：建筑；用途：旅游设施投资",
-    "instucde": "901020300",
-    "contract_no":"contract_no",
-    "instucde_nm":"instucde_nm",
-    "company_nm":"company_nm",
-    "company_code":"company_code",
-    "user_id":"user_id",
-    "user_nm":"user_nm",
-    "user_org":"user_org",
-    "user_endpoint":"user_endpoint"
-})
+for i in range(10):
+    res = requests.post("http://10.192.72.13:9876/api/aitag/v1/tagging", json={
+        # "app_id": "test_app",
+        # "timestamp": 1234567890,
+        # "sign": "test_sign",
+        "esb_seq_no":"abc",
+        "business_attr": "test_attr14"+str(i),
+        "phrase": "养点生蚝卖",
+        "instucde": "901020300",
+        "contract_no":"contract_no",
+        "instucde_nm":"instucde_nm",
+        "company_nm":"company_nm",
+        "company_code":"company_code",
+        "user_id":"user_id",
+        "user_nm":"user_nm",
+        "user_org":"user_org",
+        "user_endpoint":"user_endpoint"
+    })
+    logging.info(f"i:{i}, res:{res.text}")
 
-logging.info(res.text)
 

agent/update.sql

@@ -140,4 +140,11 @@ COMMENT on column ai_tagging.aitag_predefined_rules.remark is '备注';
 
 
 ALTER TABLE ai_tagging.aitag_predefined_rules modify defined_rule varchar(5000);
-ALTER TABLE ai_tagging.aitag_tag_log modify reg_result varchar(5000);
+ALTER TABLE ai_tagging.aitag_tag_log modify reg_result varchar(5000);
+
+---------- 20260518 -------
+alter table aitag_tag_log add COLUMN  tagging_channel int DEFAULT 0;
+comment on column aitag_tag_log.tagging_channel is '打标渠道，0:reg; 1:vector; 2:rules';
+
+-----20260521
+CREATE INDEX aitag_tag_log_start_uer_org_index ON aitag_tag_log(start_user_org);

server/yusp-tagging-core/src/main/java/cn/com/yusys/yusp/controller/AitagTagLogController.java

@@ -8,6 +8,8 @@ import cn.com.yusys.yusp.domain.dto.TagResultDto;
 import cn.com.yusys.yusp.domain.entity.AitagTagLogEntity;
 import cn.com.yusys.yusp.domain.vo.*;
 import cn.com.yusys.yusp.feign.AdminSmOrg;
+import cn.com.yusys.yusp.feign.OcaOrgListRequest;
+import cn.com.yusys.yusp.feign.OcaOrgListResponse;
 import cn.com.yusys.yusp.feign.OcaUserService;
 import cn.com.yusys.yusp.service.AitagTagLogService;
 import cn.com.yusys.yusp.util.Roles;
@@ -68,17 +70,7 @@ public class AitagTagLogController {
         }
         if(roles.contains(Roles.TAG_ADMIN)){
             role = Roles.TAG_ADMIN;
-            JSONObject org = SessionCommonUtil.getUserOrg();
-            String id = org.getString("id");
-            String code = org.getString("code");
-            List<String> childrens = new ArrayList<>();
-            childrens.add(code);
-            ResultDto<List<AdminSmOrg>> resultDto =  ocaUserService.orgtreequery("A",false,id);
-            if(resultDto!=null && resultDto.getData()!=null && resultDto.getData().size()>0){
-                List<String> codes = resultDto.getData().stream().map(d->d.getOrgCode()).collect(Collectors.toList());
-                childrens.addAll(codes);
-            }
-            taggingResult.setOrgs(childrens);
+            taggingResult.setOrgs(getCurUserSubOrgCodes());
         }
 
         taggingResult.setUserId(userId);
@@ -87,6 +79,25 @@ public class AitagTagLogController {
         return ResultDto.success(dataOverviewDTO);
     }
 
+    private List<String> getCurUserSubOrgCodes(){
+        JSONObject org = SessionCommonUtil.getUserOrg();
+        String id = org.getString("id");
+        String code = org.getString("code");
+        List<String> childrens = new ArrayList<>();
+        childrens.add(code);
+        OcaOrgListRequest request = new OcaOrgListRequest();
+        request.setSupOrgCd(code);
+        OcaOrgListResponse response  =  ocaUserService.sysorglist(request);
+        System.out.println("=========1========");
+        System.out.println(JSON.toJSONString(response));
+        System.out.println("=========2========");
+        if(response!=null && response.getData()!=null && response.getData().size()>0){
+            List<String> codes = response.getData().stream().map(d->d.getOrgCd()).collect(Collectors.toList());
+            childrens.addAll(codes);
+        }
+        return childrens;
+    }
+
 
 
     /**
@@ -106,6 +117,7 @@ public class AitagTagLogController {
         }
         if(roles.contains(Roles.TAG_ADMIN)){
             role = Roles.TAG_ADMIN;
+            taggingTrendReq.setOrgs(getCurUserSubOrgCodes());
         }
         taggingTrendReq.setUserId(userId);
         taggingTrendReq.setRoleCode(role);
@@ -130,6 +142,7 @@ public class AitagTagLogController {
         }
         if(roles.contains(Roles.TAG_ADMIN)){
             role = Roles.TAG_ADMIN;
+            resultDTO.setOrgs(getCurUserSubOrgCodes());
         }
         resultDTO.setUserId(userId);
         resultDTO.setRoleCode(role);
@@ -155,6 +168,7 @@ public class AitagTagLogController {
         }
         if(roles.contains(Roles.TAG_ADMIN)){
             role = Roles.TAG_ADMIN;
+            transactionReqVo.setOrgs(getCurUserSubOrgCodes());
         }
         transactionReqVo.setUserId(userId);
         transactionReqVo.setRoleCode(role);
@@ -193,6 +207,19 @@ public class AitagTagLogController {
     @ApiOperationType("导出数据")
     @PostMapping("/exportData")
     public void exportData(@RequestBody TaggingTransactionReqVo transactionReqVo, HttpServletResponse response) throws IOException {
+        String userId = SessionCommonUtil.getUserId();
+        String role = null;
+        List<String> roles = SessionCommonUtil.getUserRole();
+        if(roles.contains(Roles.TAG_MANAGER)){
+            role = Roles.TAG_MANAGER;
+        }
+        if(roles.contains(Roles.TAG_ADMIN)){
+            role = Roles.TAG_ADMIN;
+            transactionReqVo.setOrgs(getCurUserSubOrgCodes());
+        }
+        transactionReqVo.setUserId(userId);
+        transactionReqVo.setRoleCode(role);
+
         List<AitagTagLogEntity> aitagTagLogEntities = aitagTagLogService.queryConfirmedTagData(transactionReqVo);
         List<ExportDataVo> exportDataVos = new ArrayList<>();
         for (AitagTagLogEntity aitagTagLog:aitagTagLogEntities) {

server/yusp-tagging-core/src/main/java/cn/com/yusys/yusp/feign/OcaOrg.java

@@ -0,0 +1,9 @@
+package cn.com.yusys.yusp.feign;
+
+import lombok.Data;
+
+@Data
+public class OcaOrg {
+    private String pkId;
+    private String orgCd;
+}

server/yusp-tagging-core/src/main/java/cn/com/yusys/yusp/feign/OcaOrgListRequest.java

@@ -0,0 +1,11 @@
+package cn.com.yusys.yusp.feign;
+
+import lombok.Data;
+
+@Data
+public class OcaOrgListRequest {
+    private int page = 1;
+    private int size = 10000;
+    private String supOrgCd;
+    private String supOrgNm;
+}

server/yusp-tagging-core/src/main/java/cn/com/yusys/yusp/feign/OcaOrgListResponse.java

@@ -0,0 +1,11 @@
+package cn.com.yusys.yusp.feign;
+
+
+import lombok.Data;
+
+import java.util.List;
+
+@Data
+public class OcaOrgListResponse {
+    private List<OcaOrg> data;
+}

server/yusp-tagging-core/src/main/java/cn/com/yusys/yusp/feign/OcaUserService.java

@@ -1,12 +1,8 @@
 package cn.com.yusys.yusp.feign;
 
-import cn.com.yusys.yusp.commons.module.adapter.query.QueryModel;
-import cn.com.yusys.yusp.commons.module.adapter.web.rest.ResultDto;
 import org.springframework.cloud.openfeign.FeignClient;
-import org.springframework.web.bind.annotation.GetMapping;
-import org.springframework.web.bind.annotation.RequestParam;
-
-import java.util.List;
+import org.springframework.web.bind.annotation.PostMapping;
+import org.springframework.web.bind.annotation.RequestBody;
 
 /**
  * 用户信息获取客户端.
@@ -18,10 +14,10 @@ import java.util.List;
 public interface OcaUserService {
 
 
-    @GetMapping("/adminsmorg/orgtreequery")
-    ResultDto<List<AdminSmOrg>> orgtreequery(@RequestParam("orgSts")String orgSts,@RequestParam("lazy")boolean lazy,@RequestParam("orgId")String orgId);
+//    @GetMapping("/adminsmorg/orgtreequery")
+//    ResultDto<List<AdminSmOrg>> orgtreequery(@RequestParam("orgSts")String orgSts,@RequestParam("lazy")boolean lazy,@RequestParam("orgId")String orgId);
+
+    @PostMapping("/w/oca/priv/sysorg/list")
+    OcaOrgListResponse sysorglist(@RequestBody OcaOrgListRequest request);
 
-    // 获取机构列表
-    @GetMapping( "/adminsmorg/")
-    public ResultDto<List<AdminSmOrg>> adminsmorg(QueryModel model);
 }

server/yusp-tagging-starter/src/main/resources/bootstrap.yml

@@ -28,4 +28,4 @@ server:
 service:
   name:
     yusp:
-      oca: base-oca
+      oca: cdp-oca

server/yusp-tagging-starter/src/test/java/cn/com/yusys/yusp/TestManagerAuth.java

@@ -1,37 +1,25 @@
 package cn.com.yusys.yusp;
 
-import cn.com.yusys.yusp.commons.module.adapter.web.rest.ResultDto;
 import cn.com.yusys.yusp.detail.App;
-import cn.com.yusys.yusp.domain.vo.SmartTaggingResultVo;
-import cn.com.yusys.yusp.feign.AdminSmOrg;
+import cn.com.yusys.yusp.feign.OcaOrgListRequest;
+import cn.com.yusys.yusp.feign.OcaOrgListResponse;
 import cn.com.yusys.yusp.feign.OcaUserService;
-import cn.com.yusys.yusp.service.AitagTagLogService;
-import cn.com.yusys.yusp.service.impl.AitagTagLogServiceImpl;
-import cn.com.yusys.yusp.util.Roles;
+import com.alibaba.fastjson.JSON;
 import org.junit.jupiter.api.Test;
 import org.springframework.beans.factory.annotation.Autowired;
 import org.springframework.boot.test.context.SpringBootTest;
 
-import java.util.List;
-
 @SpringBootTest(classes = App.class)
 public class TestManagerAuth {
 
     @Autowired
-    private AitagTagLogService aitagTagLogService;
-    @Autowired
     private OcaUserService ocaUserService;
 
     @Test
-    public void test() {
-        SmartTaggingResultVo taggingResult = new SmartTaggingResultVo();
-        taggingResult.setUserId("aaa");
-        taggingResult.setRoleCode(Roles.TAG_MANAGER);
-        aitagTagLogService.dataOverview(taggingResult);
-    }
-
-    @Test
     public void test2() {
-        ResultDto<List<AdminSmOrg>> resultDto =  ocaUserService.orgtreequery("a",false,"0");
+        OcaOrgListRequest request = new OcaOrgListRequest();
+        request.setSupOrgCd(null);
+        OcaOrgListResponse response =  ocaUserService.sysorglist(request);
+        System.out.println(JSON.toJSONString(response));
     }
 }