package com.smtaiserver.smtaiserver.core;
|
|
import com.alibaba.druid.pool.DruidDataSource;
|
import com.smtaiserver.smtaiserver.attach.SMTAIAttachMetricDef;
|
import com.smtaiserver.smtaiserver.attach.SMTAIAttachTableDef;
|
import com.smtaiserver.smtaiserver.database.SMTDatabase;
|
import com.smtaiserver.smtaiserver.gismap.SMTGisMapLayerDef;
|
import com.smtaiserver.smtaiserver.gismap.SMTMapOtypeDef;
|
import com.smtaiserver.smtaiserver.gismap.SMTMapVPropDef;
|
import com.smtaiserver.smtaiserver.gismap.tabledef.SMTMapTableDef;
|
import com.smtaiserver.smtaiserver.gismap.theme.SMTMapThemeDef;
|
import com.smtaiserver.smtaiserver.gismap.theme.SMTMapThemeTableDef;
|
import com.smtaiserver.smtaiserver.javaai.ast.ASTQuestionReplace;
|
import com.smtaiserver.smtaiserver.javaai.datasource.SMTDataSource;
|
import com.smtaiserver.smtaiserver.javaai.jsonflow.core.SMTJsonFlowManager;
|
import com.smtaiserver.smtaiserver.javaai.jsonflow.core.SMTJsonFlowScriptJet;
|
import com.smtaiserver.smtaiserver.javaai.llm.core.SMTLLMConnect;
|
import com.smtaiserver.smtaiserver.javaai.llm.core.SMTLLMFactory;
|
import com.smtaiserver.smtaiserver.javaai.metrics.base.SMTDimensionDef;
|
import com.smtaiserver.smtaiserver.javaai.metrics.base.SMTMetricsDef;
|
import com.smtaiserver.smtaiserver.javaai.querydetail.SMTAIQueryDetail;
|
import com.smtaiserver.smtaiserver.javaai.qwen.SMTQwenAgentManager;
|
import com.smtaiserver.smtaiserver.javaai.qwen.SMTQwenApp;
|
import com.smtaiserver.smtaiserver.javaai.sse.SMTSSEBroadcastChat;
|
import com.smtservlet.core.SMTApp;
|
import com.smtservlet.core.SMTApp.SMTEhCacheManagerInitialize;
|
import com.smtservlet.util.Json;
|
import com.smtservlet.util.SMTHttpClient;
|
import com.smtservlet.util.SMTJsonWriter;
|
import com.smtservlet.util.SMTStatic;
|
import java.io.*;
|
import java.net.URLEncoder;
|
import java.sql.Connection;
|
import java.sql.DriverManager;
|
import java.util.ArrayList;
|
import java.util.Date;
|
import java.util.HashMap;
|
import java.util.HashSet;
|
import java.util.List;
|
import java.util.Map;
|
import java.util.Map.Entry;
|
import java.util.Set;
|
import java.util.regex.Matcher;
|
import java.util.regex.Pattern;
|
import javax.servlet.http.HttpSessionEvent;
|
import net.sf.ehcache.Cache;
|
import net.sf.ehcache.CacheManager;
|
import org.apache.logging.log4j.LogManager;
|
import org.apache.logging.log4j.Logger;
|
import org.apache.pdfbox.pdmodel.PDDocument;
|
import org.apache.pdfbox.text.PDFTextStripper;
|
import org.apache.poi.hwpf.HWPFDocument;
|
import org.apache.poi.hwpf.extractor.WordExtractor;
|
import org.apache.poi.xwpf.extractor.XWPFWordExtractor;
|
import org.apache.poi.xwpf.usermodel.XWPFDocument;
|
import org.dom4j.Document;
|
import org.dom4j.io.OutputFormat;
|
import org.dom4j.io.XMLWriter;
|
import org.locationtech.proj4j.CoordinateTransform;
|
import org.locationtech.proj4j.ProjCoordinate;
|
import org.mozilla.javascript.ConsString;
|
import org.mozilla.javascript.Context;
|
import org.mozilla.javascript.Function;
|
import org.mozilla.javascript.NativeArray;
|
import org.mozilla.javascript.NativeObject;
|
import org.mozilla.javascript.Undefined;
|
import org.mozilla.javascript.Wrapper;
|
import org.springframework.beans.factory.annotation.Value;
|
import org.springframework.cache.ehcache.EhCacheCacheManager;
|
import org.springframework.web.context.WebApplicationContext;
|
import org.springframework.web.multipart.MultipartFile;
|
|
public class SMTAIServerApp extends SMTApp implements SMTEhCacheManagerInitialize,SMTApp.SMTSessionListenerEvent
|
{
|
private static class SessionChatStreamReply
|
{
|
public String _replyId;
|
public Json _jsonReply;
|
|
public SessionChatStreamReply(String replyId, Json jsonReply)
|
{
|
_replyId = replyId;
|
_jsonReply = jsonReply;
|
}
|
}
|
|
|
protected Json _jsonSwaggerApiDoc;
|
protected DruidDataSource _dsDataSource;
|
|
@Value("${hswater.logger.sql}")
|
protected Boolean _logSQL;
|
|
// 数据库连接信息，暂时和系统库一致，将来可以改成其他地方
|
@Value("${spring.datasource.driver-class-name}")
|
protected String _dbDriver;
|
@Value("${spring.datasource.url}")
|
protected String _dbUrl;
|
@Value("${spring.datasource.username}")
|
protected String _dbUser;
|
@Value("${spring.datasource.password}")
|
protected String _dbPass;
|
@Value("${spring.datasource.druid.validation-query}")
|
protected String _dbAlidationQuery;
|
@Value("${spring.datasource.druid.max-active}")
|
protected int _dbMaxActive;
|
@Value("${spring.datasource.druid.initial-size}")
|
protected int _dbInitialSize;
|
@Value("${spring.datasource.druid.min-idle}")
|
protected int _dbMinIdle;
|
@Value("${spring.datasource.druid.max-wait}")
|
protected int _dbMaxWait;
|
@Value("${spring.datasource.druid.time-between-eviction-runs-millis}")
|
protected int _dbTimeBetweenEvictionRunsMillis;
|
@Value("${spring.datasource.druid.min-evictable-idle-time-millis}")
|
protected int _dbMinEvictableIdleTimeMillis;
|
@Value("${spring.datasource.druid.test-while-idle}")
|
protected boolean _dbTestWhileIdle;
|
@Value("${spring.datasource.druid.test-on-borrow}")
|
protected boolean _dbTestOnBorrow;
|
@Value("${spring.datasource.druid.test-on-return}")
|
protected boolean _dbTestOnReturn;
|
@Value("${spring.datasource.druid.pool-prepared-statements}")
|
protected boolean _dbPoolPreparedStatements;
|
@Value("${spring.datasource.druid.max-pool-prepared-statement-per-connection-size}")
|
protected int _dbMaxPoolPreparedStatementPerConnectionSize;
|
@Value("${wiai.debug_mode}")
|
protected boolean _isDebugMode;
|
|
@Value("${wiai.table_data_source}")
|
protected String _tableDataSource;
|
|
protected SMTAIServerEncache _serverEncache;
|
|
protected Map<String, Map<String, String>> _mapSess2AsyncProcId2Process = new HashMap<>();
|
protected Map<String, SessionChatStreamReply> _mapSess2ChatStreamReply = new HashMap<>();
|
protected SMTJsonFlowScriptJet _scriptEsprima = null;
|
protected Function _funcEsprima = null;
|
protected Object _lockScriptEsprima = new Object();
|
|
protected Map<String, SMTSSEBroadcastChat> _mapUser2SMTSSEBroadcastChat = new HashMap<>();
|
|
private static Pattern _patGroupStep = Pattern.compile("(\\d+)\\s*(minutes|hours|days|months|years|month|hour|year|day|minute)");
|
private static Pattern _patGlobalMacro = Pattern.compile("\\{\\{\\{([\\w\\.]+)\\}\\}\\}");
|
private static Logger _logger = LogManager.getLogger(SMTQwenApp.class);
|
private static Pattern _patIsNumber = Pattern.compile("^[1-9]\\d*$");
|
|
private static String[] _encacheIdList = {
|
"GlobalConfig",
|
"MetricsDefMap",
|
"DataSourceMap",
|
"DimensionMap",
|
"QwenAgentManager",
|
"AIQuestionReplace",
|
"GISTransform",
|
"queryDetailMap",
|
"getLLMFactoryMap",
|
"getGroupTypeMap",
|
"getMapLayerDef",
|
"getMapTableDefMap",
|
"getMapVPropDefMap",
|
"getMapThemeTableDefMap",
|
"getMapThemeDefMap",
|
"getAttachTableDefMap",
|
"getAttachMetricDefMap"
|
};
|
|
public static SMTAIServerApp getApp()
|
{
|
return (SMTAIServerApp)SMTApp._ThisPtr;
|
}
|
|
public String getDefaultLLMId() throws Exception
|
{
|
String defaultLLMId = System.getProperty("default_llm_id");
|
if(SMTStatic.isNullOrEmpty(defaultLLMId))
|
return (String)SMTAIServerApp.getApp().getGlobalConfig("llm.default.id");
|
|
return defaultLLMId;
|
}
|
|
public String getTableDataSource()
|
{
|
return _tableDataSource;
|
}
|
|
public boolean isAppDebugMode()
|
{
|
return _isDebugMode;
|
}
|
|
public SMTSSEBroadcastChat allocBroadcastChat(String userId)
|
{
|
synchronized(_mapUser2SMTSSEBroadcastChat)
|
{
|
SMTSSEBroadcastChat chat = _mapUser2SMTSSEBroadcastChat.get(userId);
|
if(chat == null)
|
{
|
chat = new SMTSSEBroadcastChat(userId);
|
_mapUser2SMTSSEBroadcastChat.put(userId, chat);
|
}
|
|
return chat;
|
}
|
}
|
|
public SMTSSEBroadcastChat getBroadcastChat(String userId)
|
{
|
synchronized(_mapUser2SMTSSEBroadcastChat)
|
{
|
SMTSSEBroadcastChat chat = _mapUser2SMTSSEBroadcastChat.get(userId);
|
return chat;
|
}
|
}
|
|
public void setServiceEncache(SMTAIServerEncache serverEncache)
|
{
|
_serverEncache = serverEncache;
|
}
|
|
public Map<String, Map<String, SMTMetricsDef>> getMetricsMapGroupMap() throws Exception
|
{
|
return _serverEncache.queryMetricsMapGroup();
|
}
|
|
public Map<String, SMTMetricsDef> getMetricsMap(String groupId) throws Exception
|
{
|
Map<String, Map<String, SMTMetricsDef>> mapMapMetrics = _serverEncache.queryMetricsMapGroup();
|
Map<String, SMTMetricsDef> mapResult = mapMapMetrics.get(groupId);
|
|
if(mapResult == null)
|
return new HashMap<String, SMTMetricsDef>();
|
|
return mapResult;
|
}
|
|
public DruidDataSource createDruidDataSource(String driver, String dbUrl, String dbUser, String dbPass)
|
{
|
DruidDataSource dsDataSource = new DruidDataSource();
|
dsDataSource.setDriverClassName(driver);
|
dsDataSource.setUrl(dbUrl);
|
dsDataSource.setUsername(dbUser);
|
dsDataSource.setPassword(dbPass);
|
// dsDataSource.setValidationQuery(_dbAlidationQuery);
|
dsDataSource.setMaxActive(_dbMaxActive);
|
dsDataSource.setInitialSize(0);
|
dsDataSource.setMinIdle(0);
|
dsDataSource.setMaxWait(_dbMaxWait);
|
dsDataSource.setTimeBetweenEvictionRunsMillis(_dbTimeBetweenEvictionRunsMillis);
|
dsDataSource.setMinEvictableIdleTimeMillis(_dbMinEvictableIdleTimeMillis);
|
dsDataSource.setTestWhileIdle(_dbTestWhileIdle);
|
dsDataSource.setTestOnBorrow(_dbTestOnBorrow);
|
dsDataSource.setTestOnReturn(_dbTestOnReturn);
|
dsDataSource.setPoolPreparedStatements(_dbPoolPreparedStatements);
|
dsDataSource.setMaxPoolPreparedStatementPerConnectionSize(_dbMaxPoolPreparedStatementPerConnectionSize);
|
|
return dsDataSource;
|
}
|
|
@Override
|
protected void onWebStartup(WebApplicationContext webApplicationContext) throws Exception
|
{
|
System.out.println("=====================================================>onWebStartup:你好");
|
_logger.info("=====================================================>onWebStartup:你好");
|
|
// 创建数据源
|
DruidDataSource dsDataSource = new DruidDataSource();
|
dsDataSource.setDriverClassName(_dbDriver);
|
dsDataSource.setUrl(_dbUrl);
|
dsDataSource.setUsername(_dbUser);
|
dsDataSource.setPassword(_dbPass);
|
dsDataSource.setValidationQuery(_dbAlidationQuery);
|
dsDataSource.setMaxActive(_dbMaxActive);
|
dsDataSource.setInitialSize(_dbInitialSize);
|
dsDataSource.setMinIdle(_dbMinIdle);
|
dsDataSource.setMaxWait(_dbMaxWait);
|
dsDataSource.setTimeBetweenEvictionRunsMillis(_dbTimeBetweenEvictionRunsMillis);
|
dsDataSource.setMinEvictableIdleTimeMillis(_dbMinEvictableIdleTimeMillis);
|
dsDataSource.setTestWhileIdle(_dbTestWhileIdle);
|
dsDataSource.setTestOnBorrow(_dbTestOnBorrow);
|
dsDataSource.setTestOnReturn(_dbTestOnReturn);
|
dsDataSource.setPoolPreparedStatements(_dbPoolPreparedStatements);
|
dsDataSource.setMaxPoolPreparedStatementPerConnectionSize(_dbMaxPoolPreparedStatementPerConnectionSize);
|
_dsDataSource = dsDataSource;
|
|
|
super.onWebStartup(webApplicationContext);
|
|
|
_serverEncache.getQueryDetailMap();
|
_serverEncache.getLLMFactoryMap();
|
_serverEncache.getMapLayerDef();
|
_serverEncache.getMapTableDefMap();
|
_serverEncache.getMapVPropDefMap();
|
_serverEncache.getMapThemeTableDefMap();
|
_serverEncache.getMapThemeDefMap();
|
_serverEncache.getAttachTableDefMap();
|
_serverEncache.getAttachMetricDefMap();
|
_serverEncache.getQwenAgentManager();
|
}
|
|
public SMTMapTableDef getMapTableDef(String tableId) throws Exception
|
{
|
SMTMapTableDef tableDef = _serverEncache.getMapTableDefMap().get(tableId);
|
if(tableDef == null)
|
throw new Exception("can't find table id : " + tableId);
|
return tableDef;
|
}
|
|
public SMTMapVPropDef getMapVPropDefMap(String OTYPE, String VPROP) throws Exception
|
{
|
SMTMapOtypeDef otypeDef = _serverEncache.getMapVPropDefMap().get(OTYPE);
|
if(otypeDef == null)
|
throw new Exception("can't get otype : " + OTYPE);
|
SMTMapVPropDef vpropDef = otypeDef.getVPropDef(VPROP);
|
|
return vpropDef;
|
}
|
|
public SMTMapOtypeDef getMapOTypeDef(String OTYPE) throws Exception
|
{
|
SMTMapOtypeDef otypeDef = _serverEncache.getMapVPropDefMap().get(OTYPE);
|
return otypeDef;
|
}
|
|
public String esprimaJs2ASTStr(String code1) throws Exception
|
{
|
synchronized(_lockScriptEsprima)
|
{
|
if(_scriptEsprima == null)
|
{
|
// 创建esprima脚本引擎
|
_scriptEsprima = new SMTJsonFlowScriptJet();
|
Context cx = _scriptEsprima.entryContext();
|
try
|
{
|
InputStream is = SMTJsonFlowManager.class.getResourceAsStream("/javascript/esprima.min.js");
|
try
|
{
|
String code = SMTStatic.readTextStream(is);
|
_scriptEsprima.executeScript(cx, code);
|
|
_funcEsprima = _scriptEsprima.compileFunction(cx, "esprimaJs2AST", "function(code){return JSON.stringify(esprima.parse(code));};");
|
}
|
finally
|
{
|
is.close();
|
}
|
}
|
finally
|
{
|
Context.exit();
|
}
|
|
}
|
|
Context cx = _scriptEsprima.entryContext();
|
try
|
{
|
String strJson = (String)_scriptEsprima.callFunction(cx, _funcEsprima, new Object[] {code1});
|
|
return strJson;
|
}
|
finally
|
{
|
Context.exit();
|
}
|
}
|
}
|
|
public SMTDatabase allocDatabase() throws Exception
|
{
|
if(_dsDataSource == null)
|
return null;
|
|
Connection conn = _dsDataSource.getConnection();
|
|
return new SMTDatabase(conn);
|
}
|
|
public SMTDatabase allocNativeDatabase() throws Exception
|
{
|
Connection conn = DriverManager.getConnection(_dbUrl, _dbUser, _dbPass);
|
return new SMTDatabase(conn);
|
}
|
|
|
public boolean isLogSQL()
|
{
|
return (_logSQL == null) ? false : _logSQL;
|
}
|
|
public void readSwaggerJson(SMTJsonWriter jsonWr)
|
{
|
for(Entry<String, SMTRequestConfig> entry : this._mapName2RequestConfig.entrySet())
|
{
|
String url = "/" + entry.getKey();
|
SMTRequestConfig requestConfig = entry.getValue();
|
|
if(requestConfig._jsonConfig == null)
|
continue;
|
|
Json jsonSwaggers = requestConfig._jsonConfig.safeGetJson("swaggers");
|
if(jsonSwaggers == null)
|
continue;
|
|
List<Json> listJsonSwagger = jsonSwaggers.asJsonList();
|
if(listJsonSwagger.size() > 0)
|
{
|
int index = 0;
|
|
Json jsonSwagger = listJsonSwagger.get(index);
|
jsonWr.addKeyRaw(url, jsonSwagger);
|
}
|
}
|
}
|
|
public synchronized Json readSwaggerApiDocJson()
|
{
|
if(_jsonSwaggerApiDoc == null)
|
{
|
Set<String> setGroups = new HashSet<String>();
|
SMTJsonWriter jsonWr = new SMTJsonWriter(false);
|
jsonWr.addKeyValue("swagger", "2.0");
|
jsonWr.beginMap("info");
|
{
|
jsonWr.addKeyValue("title", "Swagger操作");
|
jsonWr.addKeyValue("description", "WI水务智能系统Swagger操作页面");
|
jsonWr.addKeyValue("version", "1.0.0");
|
}
|
jsonWr.endMap();
|
jsonWr.beginMap("paths");
|
for(Entry<String, SMTRequestConfig> entry : this._mapName2RequestConfig.entrySet())
|
{
|
String url = "/" + entry.getKey();
|
SMTRequestConfig requestConfig = entry.getValue();
|
|
if(requestConfig._jsonConfig == null)
|
continue;
|
|
Json jsonSwaggers = requestConfig._jsonConfig.safeGetJson("swaggers");
|
if(jsonSwaggers == null)
|
continue;
|
|
List<Json> listJsonSwagger = jsonSwaggers.asJsonList();
|
int count = listJsonSwagger.size();
|
for(int index = 0; index < count; index ++)
|
{
|
Json jsonSwagger = listJsonSwagger.get(index);
|
jsonWr.beginMap(url + (count == 1 ? "" : String.format("?dummy=%d", index)));
|
{
|
String groupName = jsonSwagger.safeGetStr("group", null);
|
if(!SMTStatic.isNullOrEmpty(groupName))
|
{
|
jsonWr.addKeyValue("hwngroup", groupName);
|
setGroups.add(groupName);
|
}
|
|
jsonWr.beginMap("post");
|
{
|
// 设置入参类型
|
jsonWr.beginArray("consumes");
|
jsonWr.addKeyValue(null, jsonSwagger.safeGetStr("consumes", "application/x-www-form-urlencoded"));
|
jsonWr.endArray();
|
|
// 设置出参类型
|
jsonWr.beginArray("produces");
|
jsonWr.addKeyValue(null, "application/json");
|
jsonWr.endArray();
|
|
// 设置返回类型
|
jsonWr.beginMap("responses");
|
{
|
jsonWr.beginMap("200");
|
{
|
jsonWr.addKeyValue("description", "OK");
|
jsonWr.beginMap("schema");
|
jsonWr.addKeyValue("type", "object");
|
Json jsonResponses = jsonSwagger.safeGetJson("responses");
|
if(jsonResponses != null)
|
{
|
jsonWr.beginMap("properties");
|
parseSwaggerRespnseJson(jsonResponses, jsonWr);
|
jsonWr.endMap();
|
}
|
jsonWr.endMap();
|
}
|
jsonWr.endMap();
|
}
|
jsonWr.endMap();
|
|
// 设置接口所属分组
|
jsonWr.addKeyRaw("tags", jsonSwagger.getJson("tags"));
|
|
// 设置接口说明
|
jsonWr.addKeyValue("summary", jsonSwagger.getJson("title"));
|
|
// 设置参数
|
jsonWr.beginArray("parameters");
|
|
Json jsonParams = jsonSwagger.safeGetJson("parameters");
|
if(jsonParams != null)
|
{
|
for(Json jsonParam : jsonParams.asJsonList())
|
{
|
jsonWr.beginMap(null);
|
{
|
jsonWr.addKeyValue("in", "formData");
|
jsonWr.addKeyValue("name", jsonParam.getJson("name").asString());
|
jsonWr.addKeyValue("description", jsonParam.getJson("title").asString());
|
jsonWr.addKeyValue("required", jsonParam.safeGetBoolean("required", false));
|
jsonWr.addKeyValue("type", jsonParam.safeGetStr("type", "string"));
|
String defValue = jsonParam.safeGetStr("default", null);
|
if(!SMTStatic.isNullOrEmpty(defValue))
|
{
|
jsonWr.addKeyValue("default", defValue);
|
}
|
}
|
jsonWr.endMap();
|
}
|
}
|
|
|
jsonWr.endArray();
|
|
}
|
jsonWr.endMap();
|
}
|
jsonWr.endMap();
|
}
|
}
|
jsonWr.endMap();
|
|
jsonWr.beginArray("hwngroups");
|
for(String groupName : setGroups)
|
{
|
jsonWr.addKeyValue(null, groupName);
|
}
|
jsonWr.endArray();
|
|
_jsonSwaggerApiDoc = jsonWr.getRootJson();
|
|
}
|
return _jsonSwaggerApiDoc;
|
}
|
|
private void parseSwaggerRespnseJson(Json jsonResponses, SMTJsonWriter jsonWr)
|
{
|
for(Json jsonResponse : jsonResponses.asJsonList())
|
{
|
String type = jsonResponse.safeGetStr("type", "string");
|
String name = jsonResponse.getJson("name").asString();
|
String title = jsonResponse.safeGetStr("title", null);
|
String defValue = jsonResponse.safeGetStr("default", null);
|
boolean required = jsonResponse.safeGetBoolean("required", true);
|
String subType = null;
|
|
if(type.endsWith("[]"))
|
{
|
subType = type.substring(0, type.length() - 2);
|
type = "array";
|
}
|
|
jsonWr.beginMap(name);
|
{
|
jsonWr.addKeyValue("type", type);
|
jsonWr.addKeyValue("required", required);
|
if(!SMTStatic.isNullOrEmpty(defValue))
|
jsonWr.addKeyValue("default", title);
|
if(!SMTStatic.isNullOrEmpty(title))
|
jsonWr.addKeyValue("description", title);
|
|
if("array".equals(type))
|
{
|
jsonWr.beginMap("items");
|
{
|
jsonWr.addKeyValue("type", subType);
|
if("object".equals(subType))
|
{
|
jsonWr.beginMap("properties");
|
parseSwaggerRespnseJson(jsonResponse.getJson("children"), jsonWr);
|
jsonWr.endMap();
|
}
|
}
|
jsonWr.endMap();
|
}
|
else if("object".equals(type))
|
{
|
jsonWr.beginMap("properties");
|
parseSwaggerRespnseJson(jsonResponse.getJson("children"), jsonWr);
|
jsonWr.endMap();
|
}
|
}
|
jsonWr.endMap();
|
}
|
}
|
|
@Override
|
public void initEhCacheManager(CacheManager cacheManager)
|
{
|
for(String encacheId : _encacheIdList)
|
{
|
cacheManager.addCache(new Cache(encacheId, 1000, false, true, 100, 100));
|
}
|
|
}
|
|
@Override
|
public void clearEhCacheManager(CacheManager cacheManager)
|
{
|
for(String encacheId : _encacheIdList)
|
{
|
cacheManager.getCache(encacheId).removeAll();
|
}
|
}
|
|
public Object getGlobalConfig(String key, Object defValue) throws Exception
|
{
|
Map<String, Object> map = _serverEncache.queryGlobalConfigMap();
|
Object value = map.get(key);
|
if(value == null)
|
return defValue;
|
|
return value;
|
}
|
|
public Object getGlobalConfig(String key) throws Exception
|
{
|
Object value = getGlobalConfig(key, null);
|
if(value == null)
|
throw new Exception("can't find global key : " + key);
|
|
return value;
|
}
|
|
public Json queryAIPythonServer(String url, SMTJsonWriter jsonWr) throws Exception
|
{
|
String urlRoot = (String) getGlobalConfig("aipython.url");
|
SMTHttpClient web = new SMTHttpClient();
|
return web.postHttpBodyToJson(urlRoot + url, jsonWr.getFullJson(), null);
|
}
|
|
public String createQuestionSession(SMTDatabase db, String question, SMTJsonWriter jsonResult) throws Exception
|
{
|
String sessionId = SMTStatic.newUUID();
|
db.executeSQL(
|
"INSERT INTO ai_question_session(session_id, create_time, question, result_json)VALUES(?, ?, ?, ?)", new Object[] {
|
sessionId,
|
new Date(),
|
question,
|
jsonResult.getFullJson()
|
});
|
|
return sessionId;
|
}
|
|
@Override
|
public void sessionCreated(HttpSessionEvent event) throws Exception
|
{
|
synchronized(_mapSess2AsyncProcId2Process)
|
{
|
_mapSess2AsyncProcId2Process.put(event.getSession().getId(), new HashMap<>());
|
}
|
|
}
|
|
@Override
|
public void sessionDestroyed(HttpSessionEvent event) throws Exception
|
{
|
String sessionId = event.getSession().getId();
|
|
synchronized(_mapSess2AsyncProcId2Process)
|
{
|
_mapSess2AsyncProcId2Process.remove(sessionId);
|
}
|
|
synchronized(_mapSess2ChatStreamReply)
|
{
|
_mapSess2ChatStreamReply.remove(sessionId);
|
}
|
|
synchronized(_mapUser2SMTSSEBroadcastChat)
|
{
|
// 因为不知道所属用户，所以需要扫描一下用户
|
for(SMTSSEBroadcastChat chat : _mapUser2SMTSSEBroadcastChat.values())
|
{
|
if(chat.removeSSEConnect(sessionId))
|
break;
|
}
|
}
|
}
|
|
public void clearChatStreamReply(String sessionId)
|
{
|
synchronized(_mapSess2ChatStreamReply)
|
{
|
_mapSess2ChatStreamReply.remove(sessionId);
|
}
|
}
|
|
public void setChatStreamReply(String sessionId, String replyId, Json jsonReply)
|
{
|
synchronized(_mapSess2ChatStreamReply)
|
{
|
_mapSess2ChatStreamReply.put(sessionId, new SessionChatStreamReply(replyId, jsonReply));
|
}
|
}
|
|
public Json getChatStreamReply(String sessionId, String replyId)
|
{
|
SessionChatStreamReply reply = null;
|
synchronized(_mapSess2ChatStreamReply)
|
{
|
reply = _mapSess2ChatStreamReply.get(sessionId);
|
if(reply == null || !reply._replyId.equals(replyId))
|
return null;
|
|
return reply._jsonReply;
|
}
|
|
|
}
|
|
public void removeAsyncProcessText(String sessionId, String processId)
|
{
|
synchronized(_mapSess2AsyncProcId2Process)
|
{
|
Map<String, String> mapId2Process = _mapSess2AsyncProcId2Process.get(sessionId);
|
if(mapId2Process == null)
|
return;
|
mapId2Process.remove(processId);
|
}
|
}
|
|
public void setAsyncProcessText(String sessionId, String processId, String text)
|
{
|
synchronized(_mapSess2AsyncProcId2Process)
|
{
|
Map<String, String> mapId2Process = _mapSess2AsyncProcId2Process.get(sessionId);
|
if(mapId2Process == null)
|
return;
|
mapId2Process.put(processId, text);
|
}
|
}
|
|
public String getAsyncProcessText(String sessionId, String processId)
|
{
|
synchronized(_mapSess2AsyncProcId2Process)
|
{
|
Map<String, String> mapId2Process = _mapSess2AsyncProcId2Process.get(sessionId);
|
if(mapId2Process == null)
|
return null;
|
|
return mapId2Process.get(processId);
|
|
}
|
}
|
|
public Map<String, SMTDataSource> getDataSourceMap() throws Exception
|
{
|
return _serverEncache.queryDataSourceMap();
|
}
|
|
public SMTDataSource getDataSource(String id) throws Exception
|
{
|
Map<String, SMTDataSource> map = getDataSourceMap();
|
SMTDataSource result = map.get(id);
|
if(result == null)
|
throw new Exception("data source is not exist : " + id);
|
|
return result;
|
}
|
|
public SMTDimensionDef getDimensionDef(String id) throws Exception
|
{
|
Map<String, SMTDimensionDef> map = _serverEncache.queryDimensionMap();
|
SMTDimensionDef dimDef = map.get(id);
|
if(dimDef == null)
|
throw new Exception("can't find dimension def : " + id);
|
|
return dimDef;
|
}
|
|
public Map<String, SMTDimensionDef> getDimensionDefMap() throws Exception
|
{
|
return _serverEncache.queryDimensionMap();
|
}
|
|
public String convGlobalMacroString(String str, Json jsonExtMacro) throws Exception
|
{
|
while(true)
|
{
|
boolean hasMatcher = false;
|
Matcher m = _patGlobalMacro.matcher(str);
|
String newStr = str;
|
while(m.find())
|
{
|
hasMatcher = true;
|
|
String newValue = null;
|
|
if(jsonExtMacro != null)
|
newValue = jsonExtMacro.safeGetStr(m.group(1), null);
|
if(newValue != null)
|
{
|
newStr = str.replace(m.group(), newValue);
|
}
|
else
|
{
|
newStr = str.replace(m.group(), (String)this.getGlobalConfig(m.group(1)));
|
}
|
}
|
str = newStr;
|
if(!hasMatcher)
|
return newStr;
|
}
|
|
}
|
|
public static String formatXmlToNoRootStr(Document doc) throws Exception
|
{
|
OutputFormat format = OutputFormat.createPrettyPrint();
|
format.setEncoding("UTF-8");
|
format.setNewLineAfterDeclaration(false);
|
format.setNewlines(true);
|
format.setTrimText(false);
|
ByteArrayOutputStream bos = new ByteArrayOutputStream();
|
XMLWriter writer= new XMLWriter(bos,format);
|
writer.setEscapeText(true);
|
|
writer.write(doc);
|
writer.close();
|
String str = bos.toString("UTF-8");
|
|
int posS = str.indexOf("<ROOT>");
|
if(posS < 0)
|
throw new Exception("can't find <ROOT>");
|
int posE = str.lastIndexOf("</ROOT>");
|
if(posE < 0)
|
throw new Exception("can't find </ROOT>");
|
|
String[] lines = str.substring(posS + 6, posE).replace("\r\n", "\n").split("\n");
|
StringBuilder sb = new StringBuilder();
|
for(String line : lines)
|
{
|
if(line.trim().length() == 0)
|
continue;
|
sb.append(line + "\n");
|
}
|
|
return sb.toString();
|
}
|
|
public SMTQwenAgentManager getQwenAgentManager() throws Exception
|
{
|
return this._serverEncache.getQwenAgentManager();
|
}
|
|
public int getOutputAITableMax() throws Exception
|
{
|
return SMTStatic.toInt(getGlobalConfig("ai_table_output.max_rows", "100"));
|
}
|
|
public void clearQwenAgentManager() throws Exception
|
{
|
EhCacheCacheManager springCacheManager = SMTApp.getBean(EhCacheCacheManager.class);
|
if(springCacheManager != null)
|
{
|
CacheManager cacheManager = springCacheManager.getCacheManager();
|
cacheManager.getCache("QwenAgentManager").removeAll();
|
}
|
}
|
|
public static String convTimeStepToUnitStr(int unit, int value)
|
{
|
if(unit == 0)
|
{
|
int deltaDay = 24 * 60;
|
if((value % deltaDay) == 0)
|
return SMTStatic.toString(value / deltaDay) + " days";
|
|
if((value % 60) == 0)
|
return SMTStatic.toString(value / 60) + " hours";
|
|
return SMTStatic.toString(value) + " minutes";
|
}
|
else
|
{
|
if((value % 12) == 0)
|
return SMTStatic.toString(value / 12) + " years";
|
|
return SMTStatic.toString(value) + " months";
|
}
|
|
}
|
|
public static String convTimeStepToStr(int unit, int value)
|
{
|
if(unit == 0)
|
{
|
int deltaDay = 24 * 60;
|
if((value % deltaDay) == 0)
|
return SMTStatic.toString(value / deltaDay) + "天";
|
|
if((value % 60) == 0)
|
return SMTStatic.toString(value / 60) + "时";
|
|
return SMTStatic.toString(value) + "分";
|
}
|
else
|
{
|
if((value % 12) == 0)
|
return SMTStatic.toString(value / 12) + "年";
|
|
return SMTStatic.toString(value) + "月";
|
}
|
|
}
|
|
public static int[] convStrToTimeStep(String sTimeStep)
|
{
|
int _timeStepUnit = 0;
|
int _timeStepValue = 0;
|
|
Matcher m = _patGroupStep.matcher(sTimeStep);
|
if(!m.find())
|
return null;
|
|
int groupStep = SMTStatic.toInt(m.group(1));
|
String sGroupUnit = m.group(2);
|
if("minutes".equals(sGroupUnit))
|
{
|
_timeStepUnit = 0;
|
_timeStepValue = groupStep;
|
}
|
else if("hours".equals(sGroupUnit) || "hour".equals(sGroupUnit))
|
{
|
_timeStepUnit = 0;
|
_timeStepValue = groupStep * 60;
|
}
|
else if("days".equals(sGroupUnit) || "day".equals(sGroupUnit))
|
{
|
_timeStepUnit = 0;
|
_timeStepValue = groupStep * 60 * 24;
|
}
|
else if("months".equals(sGroupUnit) || "month".equals(sGroupUnit))
|
{
|
_timeStepUnit = 1;
|
_timeStepValue = groupStep;
|
}
|
else if("years".equals(sGroupUnit) || "year".equals(sGroupUnit))
|
{
|
_timeStepUnit = 1;
|
_timeStepValue = groupStep * 12;
|
}
|
|
return new int[] {_timeStepUnit, _timeStepValue};
|
}
|
|
public ASTQuestionReplace getQueryAIQuestionReplace() throws Exception
|
{
|
return _serverEncache.getQueryAIQuestionReplace();
|
}
|
|
public double[] convMapToGisTransform(double[] pos) throws Exception
|
{
|
CoordinateTransform[] transforms = _serverEncache.getGisTransform();
|
|
double[] result = new double[pos.length];
|
for(int i = 0; i < pos.length; i += 2)
|
{
|
ProjCoordinate sourceCoord = new ProjCoordinate(pos[i + 0], pos[i + 1]);
|
ProjCoordinate targetCoord = new ProjCoordinate();
|
transforms[1].transform(sourceCoord, targetCoord);
|
result[i + 0] = targetCoord.x;
|
result[i + 1] = targetCoord.y;
|
}
|
|
return result;
|
}
|
|
public double[] convGisToMapTransform(double[] pos) throws Exception
|
{
|
CoordinateTransform[] transforms = _serverEncache.getGisTransform();
|
|
double[] result = new double[pos.length];
|
for(int i = 0; i < pos.length; i += 2)
|
{
|
ProjCoordinate sourceCoord = new ProjCoordinate(pos[i + 0], pos[i + 1]);
|
ProjCoordinate targetCoord = new ProjCoordinate();
|
transforms[0].transform(sourceCoord, targetCoord);
|
result[i + 0] = targetCoord.x;
|
result[i + 1] = targetCoord.y;
|
}
|
|
return result;
|
}
|
|
public SMTAIQueryDetail getQueryDetail(String id) throws Exception
|
{
|
SMTAIQueryDetail queryDetail = _serverEncache.getQueryDetailMap().get(id);
|
if(queryDetail == null)
|
throw new Exception("can't find query detail id : " + id);
|
|
return queryDetail;
|
}
|
|
public static Object unwrapObject(Object value)
|
{
|
if(value == null)
|
return null;
|
|
if(value instanceof Wrapper)
|
value = ((Wrapper)value).unwrap();
|
|
if(value instanceof Undefined)
|
return null;
|
|
if(value instanceof ConsString)
|
value = ((ConsString)value).toString();
|
|
return value;
|
}
|
|
public static void convJSToJsonWriter(Object jsObject, SMTJsonWriter jsonWr)
|
{
|
if(jsObject instanceof NativeObject)
|
{
|
NativeObject nvObject = (NativeObject)jsObject;
|
for(Entry<Object, Object> entry : nvObject.entrySet())
|
{
|
String key = SMTStatic.toString(unwrapObject(entry.getKey()));
|
putJSToJsonWriter(jsonWr, key, entry.getValue());
|
}
|
}
|
else if(jsObject instanceof NativeArray)
|
{
|
NativeArray arrObject =(NativeArray)jsObject;
|
for(int i = 0; i < arrObject.size(); i ++)
|
{
|
putJSToJsonWriter(jsonWr, null, arrObject.get(i));
|
}
|
}
|
}
|
|
public static void putJSToJsonWriter(SMTJsonWriter jsonWr, String jsonKey, Object jsObject)
|
{
|
if(jsObject instanceof NativeObject)
|
{
|
NativeObject nvObject = (NativeObject)jsObject;
|
jsonWr.beginMap(jsonKey);
|
for(Entry<Object, Object> entry : nvObject.entrySet())
|
{
|
String key = SMTStatic.toString(unwrapObject(entry.getKey()));
|
putJSToJsonWriter(jsonWr, key, entry.getValue());
|
}
|
jsonWr.endMap();
|
}
|
else if(jsObject instanceof NativeArray)
|
{
|
NativeArray arrObject =(NativeArray)jsObject;
|
jsonWr.beginArray(jsonKey);
|
for(int i = 0; i < arrObject.size(); i ++)
|
{
|
putJSToJsonWriter(jsonWr, null, arrObject.get(i));
|
}
|
jsonWr.endArray();
|
}
|
else
|
{
|
jsonWr.addKeyValue(jsonKey, unwrapObject(jsObject));
|
}
|
}
|
|
public static Object convJsonToJS(Json json)
|
{
|
if(json.isObject())
|
{
|
NativeObject nv = new NativeObject();
|
for(Entry<String, Json> entry : json.asJsonMap().entrySet())
|
{
|
putJSNotNullValue(nv, entry.getKey(), convJsonToJS(entry.getValue()));
|
}
|
return nv;
|
}
|
else if(json.isArray())
|
{
|
List<Object> list = new ArrayList<Object>();
|
for(Json subJson : json.asJsonList())
|
{
|
list.add(convJsonToJS(subJson));
|
}
|
|
return new NativeArray(list.toArray(new Object[list.size()]));
|
}
|
else if(json.isNull())
|
return null;
|
else
|
return json.getValue();
|
}
|
|
public static void putJSNotNullValue(NativeObject nv, String key, Object value)
|
{
|
if(value == null)
|
return;
|
if(_patIsNumber.matcher(key).find())
|
nv.put(Integer.parseInt(key), nv, value);
|
else
|
nv.put(key, nv, value);
|
}
|
|
public static Object getJSValue(NativeObject nv, String key) throws Exception
|
{
|
if(!nv.containsKey(key))
|
throw new Exception("NativeObject can't find key : " + key);
|
Object value = unwrapObject(nv.get(key));
|
if(value == null)
|
throw new Exception("NativeObject can't find key : " + key);
|
return value;
|
}
|
|
public static Object getJSValue(NativeObject nv, String key, Object defValue) throws Exception
|
{
|
Object okey;
|
if(_patIsNumber.matcher(key).find())
|
okey = Long.parseLong(key);
|
else
|
okey = key;
|
if(!nv.containsKey(okey))
|
return defValue;
|
Object value = unwrapObject(nv.get(okey));
|
if(value == null)
|
return defValue;
|
|
return value;
|
}
|
|
public SMTLLMConnect allocLLMConnect(String llmId) throws Exception
|
{
|
if(SMTStatic.isNullOrEmpty(llmId))
|
llmId = (String) getDefaultLLMId();
|
|
Map<String, SMTLLMFactory> map = _serverEncache.getLLMFactoryMap();
|
SMTLLMFactory factory = map.get(llmId);
|
if(factory == null)
|
throw new Exception("can't find llm factory : " + llmId);
|
|
return factory.allocLLM();
|
}
|
|
public String getGroupTypeByGroupId(String groupId) throws Exception
|
{
|
String groupType = _serverEncache.getGroupTypeMap().get(groupId);
|
if(groupType == null)
|
throw new Exception("can't find group id : " + groupId);
|
|
return groupType;
|
}
|
|
public SMTGisMapLayerDef getMapLayerDef(String layerId) throws Exception
|
{
|
SMTGisMapLayerDef mapLayerDef = _serverEncache.getMapLayerDef().get(layerId);
|
if(mapLayerDef == null)
|
throw new Exception("can't find layer id : " + layerId);
|
|
return mapLayerDef;
|
}
|
|
public Map<String, SMTGisMapLayerDef> getMapLayerDefMap() throws Exception
|
{
|
Map<String, SMTGisMapLayerDef> map = _serverEncache.getMapLayerDef();
|
|
return map;
|
}
|
|
public Map<String, SMTMapOtypeDef> getMapVPropDefMap() throws Exception
|
{
|
Map<String, SMTMapOtypeDef> map = _serverEncache.getMapVPropDefMap();
|
|
return map;
|
}
|
|
public SMTMapThemeTableDef getMapThemeTableDefMap(String id) throws Exception
|
{
|
SMTMapThemeTableDef themeTableDef = _serverEncache.getMapThemeTableDefMap().get(id);
|
if(themeTableDef == null)
|
throw new Exception("can't find theme table : " + id);
|
|
return themeTableDef;
|
}
|
|
public Map<String, SMTMapThemeDef> getMapThemeDefMap() throws Exception
|
{
|
return _serverEncache.getMapThemeDefMap();
|
}
|
|
public SMTMapThemeTableDef getMapThemeTableDef(String id) throws Exception
|
{
|
SMTMapThemeTableDef themeTableDef = _serverEncache.getMapThemeTableDefMap().get(id);
|
if(themeTableDef == null)
|
throw new Exception("can't find theme table define : " + id);
|
|
return themeTableDef;
|
}
|
|
public SMTMapThemeDef getMapThemeDef(String id) throws Exception
|
{
|
SMTMapThemeDef themeDef = _serverEncache.getMapThemeDefMap().get(id);
|
if(themeDef == null)
|
throw new Exception("can't find theme def : " + id);
|
|
return themeDef;
|
}
|
|
public Map<String, SMTAIAttachTableDef> getAttachTableDefMap() throws Exception
|
{
|
return _serverEncache.getAttachTableDefMap();
|
}
|
|
public SMTAIAttachTableDef getAttachTableDef(String id) throws Exception
|
{
|
SMTAIAttachTableDef attachTableDef = _serverEncache.getAttachTableDefMap().get(id);
|
if(attachTableDef == null)
|
throw new Exception("can't find attach table define : " + id);
|
|
return attachTableDef;
|
}
|
|
public Map<String, SMTAIAttachMetricDef> getAttachMetricDefMap() throws Exception
|
{
|
return _serverEncache.getAttachMetricDefMap();
|
}
|
|
public SMTAIAttachMetricDef getAttachMetricDef(String id) throws Exception
|
{
|
SMTAIAttachMetricDef attachMetricDef = _serverEncache.getAttachMetricDefMap().get(id);
|
if(attachMetricDef == null)
|
throw new Exception("can't find attach metric def : " + id);
|
|
return attachMetricDef;
|
}
|
|
/**
|
* 文件(word、pdf)转txt
|
*/
|
public static String fileTranslTxt(MultipartFile file) throws Exception {
|
InputStream inputStream = file.getInputStream();
|
try (BufferedInputStream bis = new BufferedInputStream(file.getInputStream())) {
|
String mimeType = file.getContentType();
|
if (mimeType != null) {
|
switch (mimeType) {
|
case "application/pdf":
|
_logger.info("文件类型是 PDF");
|
PDDocument document = PDDocument.load(inputStream);
|
PDFTextStripper stripper = new PDFTextStripper();
|
return stripper.getText(document);
|
case "application/vnd.openxmlformats-officedocument.wordprocessingml.document":
|
_logger.info("文件类型是 Word (DOCX)");
|
try (XWPFDocument docx = new XWPFDocument(bis)) {
|
XWPFWordExtractor docxExtractor = new XWPFWordExtractor(docx);
|
return docxExtractor.getText();
|
}
|
case "application/msword":
|
_logger.info("文件类型是 Word (DOC)");
|
try (HWPFDocument doc = new HWPFDocument(bis)) {
|
WordExtractor wordExtractor = new WordExtractor(doc);
|
return wordExtractor.getText();
|
}
|
case "text/plain":
|
_logger.info("文件类型是 TXT");
|
byte[] fileData = readAttachFile(file);
|
return new String(fileData, "UTF-8");
|
default:
|
_logger.info("未知文件类型: " + mimeType);
|
break;
|
}
|
} else {
|
_logger.info("无法获取文件类型");
|
}
|
} catch (Exception e) {
|
_logger.error("文件处理失败: " + e.getMessage());
|
throw new Exception("文件处理失败: " + e.getMessage());
|
}
|
return "";
|
}
|
public static byte[] readAttachFile(MultipartFile file) throws Exception
|
{
|
InputStream is = file.getInputStream();
|
ByteArrayOutputStream bos = new ByteArrayOutputStream();
|
byte[] data = new byte[1024 * 1024];
|
while(true)
|
{
|
int size = is.read(data);
|
if(size <= 0)
|
return bos.toByteArray();
|
|
bos.write(data, 0, size);
|
}
|
}
|
|
public static String buildUrl(
|
String active,
|
String tags,
|
String name,
|
String projectId,
|
String excludePinnedData,
|
int limit)
|
throws Exception {
|
// 使用Map来存储参数
|
Map<String, String> params = new HashMap<>();
|
params.put("active", active);
|
params.put("tags", tags);
|
params.put("name", name != null ? URLEncoder.encode(name, "UTF-8") : null);
|
params.put("projectId", projectId);
|
params.put("excludePinnedData", excludePinnedData);
|
params.put("limit", String.valueOf(limit));
|
|
String workflows = (String)SMTAIServerApp.getApp().getGlobalConfig("n8n_workflows");
|
// 基本URL
|
StringBuilder urlBuilder = new StringBuilder(workflows);
|
|
// 遍历map并构建URL
|
for (Map.Entry<String, String> entry : params.entrySet()) {
|
if (entry.getValue() != null) {
|
urlBuilder.append(entry.getKey())
|
.append("=")
|
.append(entry.getValue())
|
.append("&");
|
}
|
}
|
// 去除最后一个多余的&符号
|
String requestUrl = urlBuilder.toString();
|
if (requestUrl.endsWith("&")) {
|
requestUrl = requestUrl.substring(0, requestUrl.length() - 1);
|
}
|
return requestUrl;
|
}
|
public static List<String> extractParts(String input, Pattern pattern) {
|
Matcher matcher = pattern.matcher(input);
|
List<String> results = new ArrayList<>();
|
while (matcher.find()) {
|
results.add(matcher.group(1)); // 提取第一个捕获组内容
|
}
|
return results;
|
}
|
}
|
