更新代码，调整逻辑结构

website/db/alg_model/alg_model.py

@@ -0,0 +1,55 @@
+# -*- coding: utf-8 -*-
+
+from sqlalchemy.ext.declarative import declarative_base
+from sqlalchemy import Column, Integer, String, DateTime, func
+from typing import Any, Dict, List, Optional, Tuple, Union
+
+from website.db_mysql import get_session
+from website.util import shortuuid
+
+Base = declarative_base()
+
+"""
+CREATE TABLE `model` (
+  `id` int NOT NULL AUTO_INCREMENT,
+  `suid` varchar(10) DEFAULT NULL COMMENT 'short uuid',
+  `name` varchar(255) NOT NULL DEFAULT '',
+  `model_type` int DEFAULT '1002' COMMENT '模型类型，1001/经典算法，1002/深度学习',
+  `classification` int DEFAULT '0' COMMENT '模型分类的id',
+  `comment` varchar(255) DEFAULT '' COMMENT '备注',
+  `default_version` varchar(100) DEFAULT '',
+  `del` tinyint(1) DEFAULT '0' COMMENT '删除状态，1/删除，0/正常',
+  `create_time` datetime DEFAULT CURRENT_TIMESTAMP,
+  `update_time` datetime DEFAULT NULL,
+  PRIMARY KEY (`id`)
+) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4 COLLATE=utf8mb4_0900_ai_ci COMMENT='模型表';
+"""
+
+class Model(Base):
+    __tablename__ = 'model'
+
+    id = Column(Integer, primary_key=True, autoincrement=True)
+    suid = Column(String(10), comment='short uuid')
+    name = Column(String(255), nullable=False, default='')
+    model_type = Column(Integer, default=1002, comment='模型类型，1001/经典算法，1002/深度学习')
+    classification = Column(Integer, default=0, comment='模型分类的id')
+    comment = Column(String(255), default='', comment='备注')
+    default_version = Column(String(100), default='')
+    delete = Column(Integer, default=0, info={'alias': 'del'}, comment='删除状态，1/删除，0/正常')
+    create_time = Column(DateTime, default=func.now())
+    update_time = Column(DateTime, onupdate=func.now())
+
+    def __repr__(self):
+        return f"Model(id={self.id}, name='{self.name}', model_type={self.model_type})"
+    
+
+class ModelRepositry(object):
+
+    def get_suid(self, model_id: int) -> str:
+        session = get_session()
+        with get_session() as session:
+            model = session.query(Model).filter(Model.id == model_id).first()
+            if not model or not model.suid:
+                return ""
+            
+            return model.suid

website/db/enterprise_busi_model.py

@@ -0,0 +1,144 @@
+# -*- coding: utf-8 -*-
+import json
+import copy
+from sqlalchemy.ext.declarative import declarative_base
+from sqlalchemy import Column, Integer, String, DateTime, func
+from typing import Any, Dict, List, Optional, Tuple, Union
+
+from website.db_mysql import get_session
+from website.util import shortuuid
+from website.db.enterprise_entity.enterprise_entity import EnterpriseEntityRepository
+from website.db.enterprise_node import enterprise_node as DB_Node
+from website.db.alg_model import alg_model as DB_alg_model
+
+Base = declarative_base()
+
+"""
+CREATE TABLE `enterprise_busi_model` (
+  `id` int NOT NULL AUTO_INCREMENT,
+  `suid` varchar(10) NOT NULL DEFAULT '' COMMENT 'short uuid',
+  `entity_id` int NOT NULL COMMENT '企业id',
+  `entity_suid` varchar(10) NOT NULL COMMENT '企业uuid',
+  `name` varchar(255) NOT NULL,
+  `comment` varchar(255) DEFAULT '',
+  `basemodel_ids` varchar(255) NOT NULL COMMENT '关联模型，json list, [{"id":123,"suid":"xxx"},...]',
+  `business_logic` varchar(32) DEFAULT NULL COMMENT '业务代码压缩包的md5',
+  `business_conf_file` varchar(32) DEFAULT NULL COMMENT '业务配置参数压缩包的文件md5',
+  `business_conf_param` varchar(255) DEFAULT NULL COMMENT '业务配置的参数，json字符串，eg: ''{"a":1, "b":2}''',
+  `delete` tinyint(1) DEFAULT '0',
+  `create_time` datetime DEFAULT CURRENT_TIMESTAMP ON UPDATE CURRENT_TIMESTAMP,
+  `update_time` datetime DEFAULT CURRENT_TIMESTAMP ON UPDATE CURRENT_TIMESTAMP,
+  PRIMARY KEY (`id`)
+) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4 COLLATE=utf8mb4_0900_ai_ci COMMENT='企业业务模型表';
+
+CREATE TABLE `enterprise_busi_model_node` (
+  `id` int NOT NULL AUTO_INCREMENT,
+  `suid` varchar(10) NOT NULL,
+  `entity_suid` varchar(10) DEFAULT NULL COMMENT '企业suid',
+  `busi_model_id` int DEFAULT NULL,
+  `busi_model_suid` varchar(10) DEFAULT NULL,
+  `node_id` int DEFAULT NULL,
+  `node_suid` varchar(10) DEFAULT NULL,
+  `create_time` datetime DEFAULT CURRENT_TIMESTAMP ON UPDATE CURRENT_TIMESTAMP,
+  PRIMARY KEY (`id`)
+) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4 COLLATE=utf8mb4_0900_ai_ci;
+"""
+
+
+class EnterpriseBusiModel(Base):
+    __tablename__ = 'enterprise_busi_model'
+
+    id = Column(Integer, primary_key=True)
+    suid = Column(String(10), nullable=False, default='')
+    entity_id = Column(Integer, nullable=False)
+    entity_suid = Column(String(10), nullable=False)
+    name = Column(String(255), nullable=False)
+    comment = Column(String(255))
+    basemodel_ids = Column(String(255), nullable=False)
+    business_logic = Column(String(32))
+    business_conf_file = Column(String(32))
+    business_conf_param = Column(String(255))
+    delete = Column(Integer, default=0)
+    create_time = Column(DateTime, default=func.current_timestamp())
+    update_time = Column(DateTime, default=func.current_timestamp(), onupdate=func.current_timestamp())
+
+    def __repr__(self):
+        return f'<EnterpriseBusiModel(id={self.id}, suid={self.suid})>'
+
+class EnterpriseBusiModelNode(Base):
+    __tablename__ = 'enterprise_busi_model_node'
+
+    id = Column(Integer, primary_key=True)
+    suid = Column(String(10), nullable=False, default='')
+    entity_suid = Column(String(10))
+    busi_model_id = Column(Integer)
+    busi_model_suid = Column(String(10))
+    node_id = Column(Integer)
+    node_suid = Column(String(10))
+    create_time = Column(DateTime, default=func.current_timestamp())
+    def __repr__(self):
+        return f'<EnterpriseBusiModelNode(id={self.id}, suid={self.suid})>'
+
+
+class EnterpriseBusiModelRepository(object):
+
+    def get_by_id(self, id: int) -> Optional[EnterpriseBusiModel]:
+        return self.db.query(EnterpriseBusiModel).filter(EnterpriseBusiModel.id == id).first()
+    
+    def insert_busi_model(self, data: Dict):
+        entity_suid = EnterpriseEntityRepository().get_entity_suid(data['entity_id'])
+        data['suid'] = shortuuid.ShortUUID().random(10)
+        data['entity_suid'] = entity_suid
+
+        base_model_ids = [int(model_id) for model_id in data['basemodel_ids'].split(',')]
+        base_model_db = DB_alg_model.ModelRepositry()
+        base_model = []
+        for base_model_id in base_model_ids:
+            base_model_suid = base_model_db.get_suid(base_model_id)
+            base_model.append({
+                'id': base_model_id,
+                'suid': base_model_suid
+                })
+        data['basemodel_ids'] = json.dumps(base_model)
+        new_data = copy.copy(data)
+
+        with get_session() as session:
+            model = EnterpriseBusiModel(**new_data)
+            session.add(model)
+            session.commit()
+
+            return model.id, model.suid
+        
+
+    def get_busi_model_by_id(self, id: int) -> Optional[EnterpriseBusiModel]:
+        with get_session() as session:
+            model = session.query(EnterpriseBusiModel).filter(EnterpriseBusiModel.id == id).first()
+        return model
+        
+    
+
+class EnterpriseBusiModelNodeRepository(object):
+    # def get_by_id(self, id: int) -> Optional[EnterpriseBusiModelNode]:
+    #     return self.db.query(EnterpriseBusiModelNode).filter(EnterpriseBusiModelNode.id == id).first()
+    
+    def insert_busi_model_nodes(self, data: Dict):
+        data['suid'] = shortuuid.ShortUUID().random(10)
+        link_node_ids = [int(node_id) for node_id in data['node_ids'].split(',')]
+        with get_session() as session:
+            for node_id in link_node_ids:
+                node_db = DB_Node.EnterpriseNodeRepository()
+                node = node_db.get_node_by_id(node_id)
+                node_suid = node["suid"]
+                model_node = EnterpriseBusiModelNode(
+                    suid=shortuuid.ShortUUID().random(10),
+                    entity_suid=data['entity_suid'],
+                    busi_model_id=data['busi_model_id'],
+                    busi_model_suid=data['busi_model_suid'],
+                    node_id=node_id,
+                    node_suid=node_suid,
+                )
+                session.add(model_node)
+                session.commit()
+            return 
+        
+

website/db/enterprise_device/enterprise_device.py

@@ -6,25 +6,45 @@ from sqlalchemy import Column, Integer, String, DateTime, func
 from sqlalchemy.ext.declarative import declarative_base
 
 from website import errors
+from website.db.device_classification.device_classification import DeviceClassification
+from website.db.enterprise_entity.enterprise_entity import EnterpriseEntityRepository
+from website.db.enterprise_node.enterprise_node import EnterpriseNodeRepository
 from website.db_mysql import get_session
 from website.util import shortuuid
-from website.db.enterprise_entity import EnterpriseEntityDB
-from website.db.enterprise_node import EnterpriseNodeDB
-from website.db.device_classification import DeviceClassification
+
 
 def row2dict(row):
-        d = {}
-        for column in row.__table__.columns:
-            d[column.name] = str(getattr(row, column.name))
+    d = {}
+    for column in row.__table__.columns:
+        d[column.name] = str(getattr(row, column.name))
 
-        return d
+    return d
 
 
 Base = declarative_base()
 
 """
-企业设备表
+CREATE TABLE `enterprise_device` (
+  `id` int NOT NULL AUTO_INCREMENT,
+  `suid` varchar(10) DEFAULT NULL COMMENT '设备suid',
+  `entity_id` int NOT NULL COMMENT '企业id',
+  `entity_suid` varchar(10) NOT NULL COMMENT '企业suid',
+  `node_id` int NOT NULL COMMENT '节点id',
+  `node_suid` varchar(10) NOT NULL COMMENT '节点suid',
+  `classification` varchar(10) CHARACTER SET utf8mb4 COLLATE utf8mb4_0900_ai_ci DEFAULT '' COMMENT '分类suid',
+  `name` varchar(255) NOT NULL,
+  `addr` varchar(255) DEFAULT '',
+  `device_model` varchar(255) DEFAULT '' COMMENT '设备型号',
+  `param` varchar(255) DEFAULT '',
+  `comment` varchar(255) DEFAULT '',
+  `del` int DEFAULT '0',
+  `create_time` datetime DEFAULT CURRENT_TIMESTAMP,
+  `update_time` datetime DEFAULT CURRENT_TIMESTAMP,
+  PRIMARY KEY (`id`)
+) ENGINE=InnoDB AUTO_INCREMENT=7 DEFAULT CHARSET=utf8mb4 COLLATE=utf8mb4_0900_ai_ci COMMENT='企业设备表';
 """
+
+
 class EnterpriseDevice(Base):
     __tablename__ = 'enterprise_device'
 
@@ -45,19 +65,20 @@ class EnterpriseDevice(Base):
     update_time = Column(DateTime, default=func.now())
 
 
-class EnterpriseDeviceDB(object):
+class EnterpriseDeviceRepository(object):
 
     def add_device(self, device):
         entity_id = device["entity_id"]
         node_id = device["node_id"]
-        entity_suid = EnterpriseEntityDB().get_entity_suid(entity_id)
-        node_suid = EnterpriseNodeDB().get_node_uid(node_id)
+        entity_suid = EnterpriseEntityRepository().get_entity_suid(entity_id)
+        node = EnterpriseNodeRepository().get_node_by_id(node_id)
+        node_suid = node["suid"]
 
         device["entity_suid"] = entity_suid
         device["node_suid"] = node_suid
         device["suid"] = shortuuid.ShortUUID().random(10)
         name = device["name"]
-        
+
         with get_session() as session:
             existing_device = session.query(EnterpriseDevice) \
                 .filter_by(node_id=node_id, name=name, delete=0) \
@@ -103,8 +124,6 @@ class EnterpriseDeviceDB(object):
 
         return
 
-    
-
     def list_devices(self, node_id: int, pageNo: int, pageSize: int) -> dict:
         with get_session() as session:
             try:
@@ -112,7 +131,7 @@ class EnterpriseDeviceDB(object):
                     .filter(EnterpriseDevice.node_id == node_id, EnterpriseDevice.delete != 1) \
                     .count()
                 devices = session.query(EnterpriseDevice,
-                    DeviceClassification.name.label("classification_name")) \
+                                        DeviceClassification.name.label("classification_name")) \
                     .join(DeviceClassification, EnterpriseDevice.classification == DeviceClassification.suid) \
                     .filter(EnterpriseDevice.node_id == node_id, EnterpriseDevice.delete != 1) \
                     .order_by(EnterpriseDevice.id.desc()) \
@@ -122,27 +141,27 @@ class EnterpriseDeviceDB(object):
             except Exception as e:
                 logging.error("Failed to list devices")
                 raise e
-            
+
             device_dicts = []
             for device, classification_name in devices:
-                    device_dict = {
-                        "id": device.id,
-                        "suid": device.suid,
-                        "entity_id": device.entity_id,
-                        "entity_suid": device.entity_suid,
-                        "node_id": device.node_id,
-                        "node_suid": device.node_suid,
-                        "classification": classification_name,
-                        "name": device.name,
-                        "addr": device.addr,
-                        "device_model": device.device_model,
-                        "param": device.param,
-                        "comment": device.comment,
-                        "delete": device.delete,
-                        "create_time": device.create_time.strftime('%Y-%m-%d %H:%M:%S'),
-                        "update_time": str(device.update_time)
-                    }
-                    device_dicts.append(device_dict)
+                device_dict = {
+                    "id": device.id,
+                    "suid": device.suid,
+                    "entity_id": device.entity_id,
+                    "entity_suid": device.entity_suid,
+                    "node_id": device.node_id,
+                    "node_suid": device.node_suid,
+                    "classification": classification_name,
+                    "name": device.name,
+                    "addr": device.addr,
+                    "device_model": device.device_model,
+                    "param": device.param,
+                    "comment": device.comment,
+                    "delete": device.delete,
+                    "create_time": device.create_time.strftime('%Y-%m-%d %H:%M:%S'),
+                    "update_time": str(device.update_time)
+                }
+                device_dicts.append(device_dict)
             # for row in devices:
             #     logging.info(row.name)
             logging.info(device_dicts)
@@ -152,8 +171,7 @@ class EnterpriseDeviceDB(object):
                 "total_count": total_count
             }
 
-
-    def get_device(self, device_id: int) -> dict: 
+    def get_device(self, device_id: int) -> dict:
         with get_session() as session:
             try:
                 device = session.query(EnterpriseDevice) \
@@ -174,4 +192,3 @@ class EnterpriseDeviceDB(object):
                 }
 
             return device_dict
-        

website/db/enterprise_entity.py

@@ -1,18 +0,0 @@
-# -*- coding: utf-8 -*-
-
-import logging
-from website.db_mysql import get_session, to_json
-from sqlalchemy import text
-
-class EnterpriseEntityDB(object):
-    def __init__(self):
-        pass
-
-        
-    def get_entity_suid(self, entity_id: int) -> str:
-        with get_session() as session:
-            res = session.execute(text("select suid from enterprise where id=:id"), 
-                {"id": entity_id})
-            entity = to_json(res)
-
-            return entity["suid"] if entity else ""

website/db/enterprise_entity/enterprise_entity.py

@@ -0,0 +1,41 @@
+# -*- coding: utf-8 -*-
+
+import logging
+from website.db_mysql import get_session, to_json
+from sqlalchemy import text
+
+"""
+CREATE TABLE `enterprise` (
+  `id` int NOT NULL AUTO_INCREMENT,
+  `suid` varchar(10) CHARACTER SET utf8mb4 COLLATE utf8mb4_0900_ai_ci DEFAULT '',
+  `name` varchar(255) NOT NULL,
+  `province` varchar(50) NOT NULL,
+  `city` varchar(50) NOT NULL,
+  `addr` varchar(255) NOT NULL,
+  `industry` int NOT NULL,
+  `contact` varchar(100) NOT NULL,
+  `phone` varchar(50) NOT NULL,
+  `summary` varchar(255) DEFAULT NULL,
+  `logo` text,
+  `account` varchar(20) DEFAULT NULL,
+  `pwd` varchar(100) DEFAULT NULL,
+  `del` int DEFAULT '0',
+  `create_time` datetime DEFAULT CURRENT_TIMESTAMP,
+  PRIMARY KEY (`id`),
+  KEY `idx_suid` (`suid`)
+) ENGINE=InnoDB AUTO_INCREMENT=17 DEFAULT CHARSET=utf8mb4 COLLATE=utf8mb4_0900_ai_ci COMMENT='企业信息表';
+"""
+
+
+class EnterpriseEntityRepository(object):
+    def __init__(self):
+        pass
+
+        
+    def get_entity_suid(self, entity_id: int) -> str:
+        with get_session() as session:
+            res = session.execute(text("select suid from enterprise where id=:id"), 
+                {"id": entity_id})
+            entity = to_json(res)
+
+            return entity["suid"] if entity else ""

website/db/enterprise_node/enterprise_node.py

@@ -24,7 +24,7 @@ CREATE TABLE `enterprise_node` (
 """
 
 
-class EnterpriseNodeDB(object):
+class EnterpriseNodeRepository(object):
 
     def insert_node(self, node: dict) -> int:
         with get_session() as session:
@@ -121,10 +121,10 @@ class EnterpriseNodeDB(object):
             session.execute(text(sql), param)
         return 0
     
-    def get_node_uid(self, node_id: int) -> str:
+    def get_node_by_id(self, node_id: int) -> dict:
         with get_session() as session:
-            sql = ("select suid from enterprise_node where id=:id")
+            sql = ("select suid, name from enterprise_node where id=:id")
             param = {"id": node_id}
             res = session.execute(text(sql), param)
-            node_list = to_json(res)
-            return node_list["suid"] if node_list else ""
+            node = to_json(res)
+            return node

website/db_mysql.py

@@ -48,10 +48,10 @@ app_engine = create_engine(
         settings.mysql_app['database']
     ),  # SQLAlchemy 数据库连接串，格式见下面
     echo=bool(settings.SQLALCHEMY_ECHO),  # 是不是要把所执行的SQL打印出来，一般用于调试
-    # pool_pre_ping=True,
-    # pool_size=int(settings.SQLALCHEMY_POOL_SIZE),  # 连接池大小
-    # max_overflow=int(settings.SQLALCHEMY_POOL_MAX_SIZE),  # 连接池最大的大小
-    # pool_recycle=int(settings.SQLALCHEMY_POOL_RECYCLE),  # 多久时间回收连接
+    pool_pre_ping=True,
+    pool_size=int(settings.SQLALCHEMY_POOL_SIZE),  # 连接池大小
+    max_overflow=int(settings.SQLALCHEMY_POOL_MAX_SIZE),  # 连接池最大的大小
+    pool_recycle=int(settings.SQLALCHEMY_POOL_RECYCLE),  # 多久时间回收连接
 )
 
 Session = sessionmaker(bind=app_engine)

website/handlers/enterprise_busi_model/handler.py

@@ -0,0 +1,149 @@
+# -*- coding: utf-8 -*-
+
+import logging
+from sqlalchemy import text
+
+from website import db_mysql, errors
+from website.handler import APIHandler, authenticated
+from website.util import shortuuid
+from website.db import enterprise_busi_model as DB_BusiModel
+
+
+class ListHandler(APIHandler):
+    """
+    
+    """
+    @authenticated
+    def post(self):
+
+        self.finish()
+
+
+class AddHandler(APIHandler):
+    """
+    - 描述：添加企业部署的业务模型
+    - 请求方式：post
+    - 请求参数：
+    > - entity_id, int, 企业id
+    > - name, string, 业务模型名称
+    > - comment, string, 简介
+    > - basemodel_ids, string, 基础模型id, 多个使用逗号分割
+    > - business_logic, string, 业务代码压缩包的md5
+    > - business_conf_file, string, 业务配置压缩包的文件md5
+    > - business_conf_param, string, 业务配置的参数，json字符串，eg: '{"a":1, "b":2}'
+    > - link_node_ids, string, 关联节点id, 多个节点逗号分割
+    - 返回值：无
+    """
+    @authenticated
+    def post(self):
+        entity_id = self.get_argument("entity_id")
+        name = self.get_escaped_argument("name", "")
+        comment = self.get_escaped_argument("comment", "")
+        basemodel_ids = self.get_escaped_argument("basemodel_ids", "")
+        business_logic = self.get_escaped_argument("business_logic", "")
+        business_conf_file = self.get_escaped_argument("business_conf_file", "")
+        business_conf_param = self.get_escaped_argument("business_conf_param", "")
+        link_node_ids = self.get_escaped_argument("link_node_ids", "")
+    
+        if not entity_id or not name or not basemodel_ids:
+            raise errors.HTTPAPIError(errors.ERROR_BAD_REQUEST, "参数错误")
+    
+        if not business_logic:
+            raise errors.HTTPAPIError(errors.ERROR_BAD_REQUEST, "业务代码参数错误")
+        
+        if not business_conf_file and not business_conf_param:
+            raise errors.HTTPAPIError(errors.ERROR_BAD_REQUEST, "业务配置参数错误")
+        
+        if not link_node_ids:
+            raise errors.HTTPAPIError(errors.ERROR_BAD_REQUEST, "关联节点参数错误")
+
+        model_data = {
+            "entity_id": entity_id,
+            "name": name,
+            "comment": comment,
+            "basemodel_ids": basemodel_ids,
+            "business_logic": business_logic,
+            "business_conf_file": business_conf_file,
+            "business_conf_param": business_conf_param,
+            "link_node_ids": link_node_ids,
+        }
+
+        db_busimodel = DB_BusiModel.EnterpriseBusiModelRepository()
+        busimodel_id, busimodel_suid = db_busimodel.insert_busi_model(model_data)
+
+        model_node_data = {
+            "entity_id": entity_id,
+            "busimodel_id": busimodel_id,
+            "busimodel_suid": busimodel_suid,
+            "node_ids": link_node_ids
+        }
+        db_model_node = DB_BusiModel.EnterpriseBusiModelNodeRepository()
+        db_model_node.insert_busi_model_nodes(model_node_data)
+
+        self.finish()
+
+
+class InfoHandler(APIHandler):
+    """
+    - 描述：企业部署的业务模型详情
+    - 请求方式：post
+    - 请求参数：
+    > - id, int, 业务模型id
+    - 返回值：
+    ```
+        {
+            "name": "xxx", 
+            "comment": "xxx",
+            "basemodel_list": "xxx,xx,xx",
+            "business_logic": "xxx",
+            "business_conf_file": "xxx",
+            "business_conf_param": "xxx",
+            "link_node_list": "xxx,xx,xx"
+        }
+    ```
+    """
+    @authenticated
+    def post(self):
+        busimodel_id = self.get_argument("id")
+    
+        if not busimodel_id:
+            raise errors.HTTPAPIError(errors.ERROR_BAD_REQUEST, "参数错误")
+    
+        db_busimodel = DB_BusiModel.EnterpriseBusiModelRepository()
+        busi_model_data = db_busimodel.get_busi_model_by_id(busimodel_id)
+
+        if not busi_model_data:
+            raise errors.HTTPAPIError(errors.ERROR_BAD_REQUEST, "业务模型不存在")
+    
+        
+
+        model_data = {
+            "name": busi_model_data.name, 
+            "comment": busi_model_data.comment,
+            "basemodel_ids": ",".join([str(x) for x in busi_model_data.basemodel_list]),
+            "business_logic": busi_model_data.business_logic,
+            "business_conf_file": busi_model_data.business_conf_file,
+            "business_conf_param": busi_model_data.business_conf
+        }
+
+
+        self.finish({
+            "name": model_data["name"], 
+            "comment": model_data["comment"],
+            "basemodel_list": model_data["basemodel_ids"],
+            "business_logic": model_data["business_logic"],
+            "business_conf_file": model_data["business_conf_file"],
+            "business_conf_param": model_data["business_conf_param"],
+            "link_node_list": model_data["link_node_ids"]
+        })
+
+
+
+class EditHandler(APIHandler):
+    """
+    
+    """
+    @authenticated
+    def post(self):
+
+        self.finish()

website/handlers/enterprise_busi_model/url.py

@@ -0,0 +1,15 @@
+# -*- coding: utf-8 -*-
+
+from website.handlers.enterprise_busi_model import handler
+
+
+handlers = [
+    ("/enterprise/model/deployment/list", handler.ListHandler),
+    ("/enterprise/model/deployment/add", handler.AddHandler),
+    ("/enterprise/model/deployment/info", handler.InfoHandler),
+    ("/enterprise/model/deployment/edit", handler.EditHandler),
+
+]
+page_handlers = [
+
+]

website/handlers/enterprise_device/handler.py

@@ -5,7 +5,7 @@ from sqlalchemy import text
 from website import db_mysql, errors
 from website.handler import APIHandler, authenticated
 from website.util import shortuuid
-from website.db import enterprise_device as DB_Device
+from website.db.enterprise_device import enterprise_device as DB_Device
 
 class DeviceClassificationAddHandler(APIHandler):
     """
@@ -143,7 +143,7 @@ class DeviceAddHandler(APIHandler):
             "comment": comment
         }
 
-        db_device = DB_Device.EnterpriseDeviceDB()
+        db_device = DB_Device.EnterpriseDeviceRepository()
         db_device.add_device(device_data)
 
         self.finish()
@@ -188,7 +188,7 @@ class DeviceEditHandler(APIHandler):
             "comment": comment
         }
 
-        db_device = DB_Device.EnterpriseDeviceDB()
+        db_device = DB_Device.EnterpriseDeviceRepository()
         db_device.edit_device(device_data)
         self.finish()
 
@@ -211,7 +211,7 @@ class DeviceDeleteHandler(APIHandler):
         device_id = self.get_int_argument('device_id')
         if not device_id:
             raise errors.HTTPAPIError(errors.ERROR_BAD_REQUEST, '企业节点或设备不能为空')
-        db_device = DB_Device.EnterpriseDeviceDB()
+        db_device = DB_Device.EnterpriseDeviceRepository()
         db_device.delete_device(device_id)
         self.finish()
 
@@ -248,7 +248,7 @@ class DeviceListHandler(APIHandler):
         pageSize = self.get_int_argument('pageSize', 20)
         if not node_id:
             raise errors.HTTPAPIError(errors.ERROR_BAD_REQUEST, '企业节点不能为空')
-        db_device = DB_Device.EnterpriseDeviceDB()
+        db_device = DB_Device.EnterpriseDeviceRepository()
         devices = db_device.list_devices(node_id=node_id, pageNo=pageNo, pageSize=pageSize)
 
         logging.info(devices)
@@ -278,7 +278,7 @@ class DeviceInfoHandler(APIHandler):
         device_id = self.get_int_argument('device_id')
         if not device_id:
             raise errors.HTTPAPIError(errors.ERROR_BAD_REQUEST, '企业节点或设备不能为空')
-        db_device = DB_Device.EnterpriseDeviceDB()
+        db_device = DB_Device.EnterpriseDeviceRepository()
         device = db_device.get_device(device_id=device_id)
         logging.info(device)
         self.finish(device)

website/handlers/enterprise_node/handler.py

@@ -2,8 +2,8 @@
 
 from website import errors
 from website.handler import APIHandler, authenticated
-from website.db import enterprise_entity as DB_Entity
-from website.db import enterprise_node as DB_Node
+from website.db.enterprise_entity import enterprise_entity as DB_Entity
+from website.db.enterprise_node import enterprise_node as DB_Node
 from website.util import shortuuid
 
 
@@ -38,10 +38,10 @@ class AddHandler(APIHandler):
         if not entity_id or not name:
             raise errors.HTTPAPIError(errors.ERROR_BAD_REQUEST, "参数错误")
 
-        db_entity = DB_Entity.EnterpriseEntityDB()
+        db_entity = DB_Entity.EnterpriseEntityRepository()
         entity_suid = db_entity.get_entity_suid(entity_id)
 
-        db_node = DB_Node.EnterpriseNodeDB()
+        db_node = DB_Node.EnterpriseNodeRepository()
         db_node.insert_node({
             "suid": shortuuid.ShortUUID().random(length=10),
             "entity_id": entity_id,
@@ -88,7 +88,7 @@ class EditHandler(APIHandler):
         if not node_id or not name:
             raise errors.HTTPAPIError(errors.ERROR_BAD_REQUEST, "参数错误")
 
-        db_node = DB_Node.EnterpriseNodeDB()
+        db_node = DB_Node.EnterpriseNodeRepository()
         db_node.update_node({
             "node_id": node_id,
             "name": name,
@@ -146,7 +146,7 @@ class TreeHandler(APIHandler):
         if not entity_id:
             raise errors.HTTPAPIError(errors.ERROR_BAD_REQUEST, "参数错误")
 
-        db_node = DB_Node.EnterpriseNodeDB()
+        db_node = DB_Node.EnterpriseNodeRepository()
         nodes = db_node.select_tree(entity_id, name)
         self.finish({
             "data": nodes
@@ -180,7 +180,7 @@ class InfoHandler(APIHandler):
         if not node_id:
             raise errors.HTTPAPIError(errors.ERROR_BAD_REQUEST, "参数错误")
 
-        db_node = DB_Node.EnterpriseNodeDB()
+        db_node = DB_Node.EnterpriseNodeRepository()
         node = db_node.select_node(node_id)
         node = node and node or {}
         self.finish(node)
@@ -193,6 +193,6 @@ class DeleteHandler(APIHandler):
         node_id = self.get_int_argument("node_id")
         if not node_id:
             raise errors.HTTPAPIError(errors.ERROR_BAD_REQUEST, "参数错误")
-        db_node = DB_Node.EnterpriseNodeDB()
+        db_node = DB_Node.EnterpriseNodeRepository()
         db_node.delete_node(node_id)
         self.finish()

website/settings.py

@@ -1,4 +1,5 @@
 # -*- coding: utf-8 -*-
+import os
 
 # sqlalchemy
 SQLALCHEMY_ECHO = 0
@@ -12,6 +13,9 @@ mysql_app = {
     "time_zone": "+8:00"
 }
 
+SQLALCHEMY_POOL_SIZE = 10 * os.cpu_count() # 连接池的大小
+SQLALCHEMY_POOL_MAX_SIZE = 2 * SQLALCHEMY_POOL_SIZE # 连接池的最大大小
+SQLALCHEMY_POOL_RECYCLE = 3600 # 连接池的回收时间
 
 redis_app = ("127.0.0.1", 6382, 0, "")