change

@@ -128,7 +128,7 @@ def data_entry_center():
 
 
             if inter_size < configure.entry_data_thread:
             if inter_size < configure.entry_data_thread:
                 # 锁表啊
                 # 锁表啊
-                ready_task:Task = sys_session.query(Task).filter_by(state=0).order_by(Task.create_time).with_lockmode("update").limit(1).one_or_none()
+                ready_task:Task = sys_session.query(Task).filter_by(state=0,task_type=1).order_by(Task.create_time).with_lockmode("update").limit(1).one_or_none()
                 if ready_task:
                 if ready_task:
 
 
                     try:
                     try:

@@ -72,6 +72,8 @@ class Table(db.Model):
 
 
     #用户
     #用户
     creator = Column(Text)
     creator = Column(Text)
+    #是否已抽稀
+    is_vacuate=Column(Integer,default=0)
 
 
     # 目录外键
     # 目录外键
     catalog_guid = Column(String(256), ForeignKey('dmdms_catalog.guid'))
     catalog_guid = Column(String(256), ForeignKey('dmdms_catalog.guid'))
@@ -122,6 +124,10 @@ class Task(db.Model):
     # 目录外键
     # 目录外键
     catalog_guid = Column(String(256), ForeignKey('dmdms_catalog.guid'))
     catalog_guid = Column(String(256), ForeignKey('dmdms_catalog.guid'))
 
 
+    table_guid =  Column(String(256))
+    #任务类型
+    task_type=Column(Integer)
+
     creator = Column(Text)
     creator = Column(Text)
     file_name = Column(Text)
     file_name = Column(Text)
 
 

-# coding=utf-8
-# author:        4N
-# createtime:    2020/8/27
-# email:         nheweijun@sina.com
+# coding=utf-8
+# author:        4N
+# createtime:    2020/8/27
+# email:         nheweijun@sina.com

-# coding=utf-8
-#author:        4N
-#createtime:    2021/3/1
-#email:         nheweijun@sina.com
-
-
-from flasgger import swag_from
-from flask import Blueprint
-from app.util import BlueprintApi
-from . import catalog_create
-from . import catalog_next
-from . import catalog_tree
-from . import catalog_delete
-from . import catalog_edit
-from . import catalog_real_tree
-
-
-class DataManager(BlueprintApi):
-
-    bp = Blueprint("Category", __name__, url_prefix="/API/Category")
-
-
-    @staticmethod
-    @bp.route('/Create', methods=['POST'])
-    @swag_from(catalog_create.Api.api_doc)
-    def catalog_create():
-        """
-        创建目录
-        """
-        return catalog_create.Api().result
-
-    @staticmethod
-    @bp.route('/Next', methods=['POST'])
-    @swag_from(catalog_next.Api.api_doc)
-    def catalog_next():
-        """
-        下一级目录
-        """
-        return catalog_next.Api().result
-
-    @staticmethod
-    @bp.route('/Tree', methods=['POST'])
-    @swag_from(catalog_tree.Api.api_doc)
-    def catalog_tree():
-        """
-        目录树
-        """
-        return catalog_tree.Api().result
-
-
-    @staticmethod
-    @bp.route('/RealTree', methods=['POST'])
-    @swag_from(catalog_real_tree.Api.api_doc)
-    def catalog_real_tree():
-        """
-        目录树
-        """
-        return catalog_real_tree.Api().result
-
-
-    @staticmethod
-    @bp.route('/Edit', methods=['POST'])
-    @swag_from(catalog_edit.Api.api_doc)
-    def catalog_edit():
-        """
-        修改目录
-        """
-        return catalog_edit.Api().result
-
-    @staticmethod
-    @bp.route('/Delete', methods=['POST'])
-    @swag_from(catalog_delete.Api.api_doc)
-    def catalog_delete():
-        """
-        删除目录
-        """
+# coding=utf-8
+#author:        4N
+#createtime:    2021/3/1
+#email:         nheweijun@sina.com
+
+
+from flasgger import swag_from
+from flask import Blueprint
+from app.util import BlueprintApi
+from . import catalog_create
+from . import catalog_next
+from . import catalog_tree
+from . import catalog_delete
+from . import catalog_edit
+from . import catalog_real_tree
+
+
+class DataManager(BlueprintApi):
+
+    bp = Blueprint("Category", __name__, url_prefix="/API/Category")
+
+
+    @staticmethod
+    @bp.route('/Create', methods=['POST'])
+    @swag_from(catalog_create.Api.api_doc)
+    def catalog_create():
+        """
+        创建目录
+        """
+        return catalog_create.Api().result
+
+    @staticmethod
+    @bp.route('/Next', methods=['POST'])
+    @swag_from(catalog_next.Api.api_doc)
+    def catalog_next():
+        """
+        下一级目录
+        """
+        return catalog_next.Api().result
+
+    @staticmethod
+    @bp.route('/Tree', methods=['POST'])
+    @swag_from(catalog_tree.Api.api_doc)
+    def catalog_tree():
+        """
+        目录树
+        """
+        return catalog_tree.Api().result
+
+
+    @staticmethod
+    @bp.route('/RealTree', methods=['POST'])
+    @swag_from(catalog_real_tree.Api.api_doc)
+    def catalog_real_tree():
+        """
+        目录树
+        """
+        return catalog_real_tree.Api().result
+
+
+    @staticmethod
+    @bp.route('/Edit', methods=['POST'])
+    @swag_from(catalog_edit.Api.api_doc)
+    def catalog_edit():
+        """
+        修改目录
+        """
+        return catalog_edit.Api().result
+
+    @staticmethod
+    @bp.route('/Delete', methods=['POST'])
+    @swag_from(catalog_delete.Api.api_doc)
+    def catalog_delete():
+        """
+        删除目录
+        """
         return catalog_delete.Api().result
         return catalog_delete.Api().result

-# coding=utf-8
-#author:        4N
-#createtime:    2021/3/9
-#email:         nheweijun@sina.com
-
-import uuid
-from app.models import *
-from app.util.component.ApiTemplate import ApiTemplate
-class Api(ApiTemplate):
-    api_name = "创建目录"
-    def para_check(self):
-        if not self.para.get("database_guid"):
-            raise Exception("缺乏database_guid参数")
-        if not self.para.get("pguid"):
-            raise Exception("缺乏pguid参数")
-        if not self.para.get("name"):
-            raise Exception("缺乏name参数")
-
-    def process(self):
-  
-        # 返回结果
-        res = {}
-        res["result"] = False
-        try:
-            # 业务逻辑
-    
-            if not Database.query.filter_by(guid=self.para.get("database_guid")).one_or_none():
-                res["msg"]="数据库不存在！"
-                return res
-
-    
-            # 可以创建已有数据目录的子目录
-            # if Table.query.filter_by(catalog_guid=self.para.get("pguid")).all():
-            #     raise Exception("父目录挂载了数据，不能创建子目录")
-    
-            if Catalog.query.filter_by(name=self.para.get("name"),pguid=self.para.get("pguid"),database_guid=self.para.get("database_guid")).one_or_none():
-                res["msg"]="目录已经存在！"
-                return res
-
-    
-            # if Catalog.query.filter_by(pguid="0",database_guid=self.para.get("database_guid")).one_or_none() and self.para.get("pguid").__eq__("0"):
-            #     raise Exception("只能有一个根目录！")
-    
-            guid = uuid.uuid1().__str__()
-            path = guid
-    
-            # 获得目录的全路径
-            pguid = self.para.get("pguid")
-            count = 0
-            while pguid !="0" and count<100:
-                count+=1
-                path = pguid+":"+path
-                p_catalog = Catalog.query.filter_by(guid=pguid).one_or_none()
-                pguid = p_catalog.pguid
-            if count==100:
-                raise Exception("目录结构出现问题！")
-            path = "0" + ":" + path
-    
-            sort = Catalog.query.filter_by(pguid=self.para.get("pguid")).count()
-    
-            catalog = Catalog(guid=guid,pguid=self.para.get("pguid"),name=self.para.get("name"),
-                              sort=sort,description=self.para.get("description"),
-                              database_guid=self.para.get("database_guid"),path=path)
-            db.session.add(catalog)
-            db.session.commit()
-
-
-            res["msg"] = "目录创建成功！"
-            res["data"] = guid
-            res["result"] = True
-        except Exception as e:
-            db.session.rollback()
-            raise e
-        return res
-    
-    api_doc={
-    
-    "tags":["目录接口"],
-    "parameters":[
-        {"name": "name",
-         "in": "formData",
-         "type": "string",
-         "description":"目录名"},
-        {"name": "pguid",
-         "in": "formData",
-         "type": "string","description":"父目录guid，创建根目录时为0"},
-        {"name": "database_guid",
-         "in": "formData",
-         "type": "string","description":"数据库guid"}
-    
-    ],
-    "responses":{
-        200:{
-            "schema":{
-                "properties":{
-                }
-            }
-            }
-        }
+# coding=utf-8
+#author:        4N
+#createtime:    2021/3/9
+#email:         nheweijun@sina.com
+
+import uuid
+from app.models import *
+from app.util.component.ApiTemplate import ApiTemplate
+class Api(ApiTemplate):
+    api_name = "创建目录"
+    def para_check(self):
+        if not self.para.get("database_guid"):
+            raise Exception("缺乏database_guid参数")
+        if not self.para.get("pguid"):
+            raise Exception("缺乏pguid参数")
+        if not self.para.get("name"):
+            raise Exception("缺乏name参数")
+
+    def process(self):
+  
+        # 返回结果
+        res = {}
+        res["result"] = False
+        try:
+            # 业务逻辑
+    
+            if not Database.query.filter_by(guid=self.para.get("database_guid")).one_or_none():
+                res["msg"]="数据库不存在！"
+                return res
+
+    
+            # 可以创建已有数据目录的子目录
+            # if Table.query.filter_by(catalog_guid=self.para.get("pguid")).all():
+            #     raise Exception("父目录挂载了数据，不能创建子目录")
+    
+            if Catalog.query.filter_by(name=self.para.get("name"),pguid=self.para.get("pguid"),database_guid=self.para.get("database_guid")).one_or_none():
+                res["msg"]="目录已经存在！"
+                return res
+
+    
+            # if Catalog.query.filter_by(pguid="0",database_guid=self.para.get("database_guid")).one_or_none() and self.para.get("pguid").__eq__("0"):
+            #     raise Exception("只能有一个根目录！")
+    
+            guid = uuid.uuid1().__str__()
+            path = guid
+    
+            # 获得目录的全路径
+            pguid = self.para.get("pguid")
+            count = 0
+            while pguid !="0" and count<100:
+                count+=1
+                path = pguid+":"+path
+                p_catalog = Catalog.query.filter_by(guid=pguid).one_or_none()
+                pguid = p_catalog.pguid
+            if count==100:
+                raise Exception("目录结构出现问题！")
+            path = "0" + ":" + path
+    
+            sort = Catalog.query.filter_by(pguid=self.para.get("pguid")).count()
+    
+            catalog = Catalog(guid=guid,pguid=self.para.get("pguid"),name=self.para.get("name"),
+                              sort=sort,description=self.para.get("description"),
+                              database_guid=self.para.get("database_guid"),path=path)
+            db.session.add(catalog)
+            db.session.commit()
+
+
+            res["msg"] = "目录创建成功！"
+            res["data"] = guid
+            res["result"] = True
+        except Exception as e:
+            db.session.rollback()
+            raise e
+        return res
+    
+    api_doc={
+    
+    "tags":["目录接口"],
+    "parameters":[
+        {"name": "name",
+         "in": "formData",
+         "type": "string",
+         "description":"目录名"},
+        {"name": "pguid",
+         "in": "formData",
+         "type": "string","description":"父目录guid，创建根目录时为0"},
+        {"name": "database_guid",
+         "in": "formData",
+         "type": "string","description":"数据库guid"}
+    
+    ],
+    "responses":{
+        200:{
+            "schema":{
+                "properties":{
+                }
+            }
+            }
+        }
     }
     }

-# coding=utf-8
-#author:        4N
-#createtime:    2021/3/9
-#email:         nheweijun@sina.com
-
-
-
-from app.models import *
-from app.util.component.ApiTemplate import ApiTemplate
-class Api(ApiTemplate):
-    api_name = "删除目录"
-    def process(self):
-
-    
-        # 返回结果
-        res = {}
-        try:
-            # 业务逻辑
-    
-    
-            # 啥情况都能删
-            # if Table.query.filter_by(catalog_guid=self.para.get("guid")).all():
-            #     raise Exception("目录挂载了数据，不可删除，可将数据移出目录后删除！")
-            # if Catalog.query.filter_by(pguid=self.para.get("guid")).all():
-            #     raise Exception("目录非子目录，不可删除，请先将子目录删除!")
-    
-            catalog_guid = self.para.get("guid")
-    
-            catalog =  Catalog.query.filter_by(guid=catalog_guid).one_or_none()
-            if not catalog:
-                res["msg"]="目录不存在!"
-                return res
-
-            else:
-    
-                # 转移目录下的数据
-    
-                # # 删除根节点
-                # if catalog.pguid.__eq__("0"):
-                #     database_guid = catalog.database_guid
-                #     Table.query.filter_by(database_guid=database_guid).update({"catalog_guid": None})
-                #     catalogs = Catalog.query.filter(Catalog.path.like("%" + catalog_guid + "%")).all()
-                #     for cata in catalogs:
-                #         db.session.delete(cata)
-                #
-                # # 获取所有子目录：
-                # else:
-    
-                pguid = catalog.pguid
-                # 所有目录
-                catalogs = Catalog.query.filter(Catalog.path.like("%" + catalog_guid + "%")).all()
-                for cata in catalogs:
-                    if pguid.__eq__("0"):
-                        Table.query.filter_by(catalog_guid=cata.guid).update({"catalog_guid": None})
-                        db.session.delete(cata)
-                    else:
-                        Table.query.filter_by(catalog_guid=cata.guid).update({"catalog_guid": pguid})
-                        db.session.delete(cata)
-    
-                db.session.commit()
-                res["msg"] = "目录删除成功！"
-                res["result"] = True
-        except Exception as e:
-            db.session.rollback()
-            raise e
-        return res
-    
-    
-    api_doc = {
-        "tags": ["目录接口"],
-        "parameters": [
-            {"name": "guid",
-             "in": "formData",
-             "type": "string",
-             "description": "目录guid", "required": "true"},
-        ],
-        "responses": {
-            200: {
-                "schema": {
-                    "properties": {
-                    }
-                }
-            }
-        }
-    }
+# coding=utf-8
+#author:        4N
+#createtime:    2021/3/9
+#email:         nheweijun@sina.com
+
+
+
+from app.models import *
+from app.util.component.ApiTemplate import ApiTemplate
+class Api(ApiTemplate):
+    api_name = "删除目录"
+    def process(self):
+
+    
+        # 返回结果
+        res = {}
+        try:
+            # 业务逻辑
+    
+    
+            # 啥情况都能删
+            # if Table.query.filter_by(catalog_guid=self.para.get("guid")).all():
+            #     raise Exception("目录挂载了数据，不可删除，可将数据移出目录后删除！")
+            # if Catalog.query.filter_by(pguid=self.para.get("guid")).all():
+            #     raise Exception("目录非子目录，不可删除，请先将子目录删除!")
+    
+            catalog_guid = self.para.get("guid")
+    
+            catalog =  Catalog.query.filter_by(guid=catalog_guid).one_or_none()
+            if not catalog:
+                res["msg"]="目录不存在!"
+                return res
+
+            else:
+    
+                # 转移目录下的数据
+    
+                # # 删除根节点
+                # if catalog.pguid.__eq__("0"):
+                #     database_guid = catalog.database_guid
+                #     Table.query.filter_by(database_guid=database_guid).update({"catalog_guid": None})
+                #     catalogs = Catalog.query.filter(Catalog.path.like("%" + catalog_guid + "%")).all()
+                #     for cata in catalogs:
+                #         db.session.delete(cata)
+                #
+                # # 获取所有子目录：
+                # else:
+    
+                pguid = catalog.pguid
+                # 所有目录
+                catalogs = Catalog.query.filter(Catalog.path.like("%" + catalog_guid + "%")).all()
+                for cata in catalogs:
+                    if pguid.__eq__("0"):
+                        Table.query.filter_by(catalog_guid=cata.guid).update({"catalog_guid": None})
+                        db.session.delete(cata)
+                    else:
+                        Table.query.filter_by(catalog_guid=cata.guid).update({"catalog_guid": pguid})
+                        db.session.delete(cata)
+    
+                db.session.commit()
+                res["msg"] = "目录删除成功！"
+                res["result"] = True
+        except Exception as e:
+            db.session.rollback()
+            raise e
+        return res
+    
+    
+    api_doc = {
+        "tags": ["目录接口"],
+        "parameters": [
+            {"name": "guid",
+             "in": "formData",
+             "type": "string",
+             "description": "目录guid", "required": "true"},
+        ],
+        "responses": {
+            200: {
+                "schema": {
+                    "properties": {
+                    }
+                }
+            }
+        }
+    }

-# coding=utf-8
-#author:        4N
-#createtime:    2021/3/9
-#email:         nheweijun@sina.com
-
-from app.models import *
-
-from app.util.component.ApiTemplate import ApiTemplate
-class Api(ApiTemplate):
-    api_name = "修改目录"
-    def process(self):
- 
-
-        # 返回结果
-        res = {}
-        try:
-            # 业务逻辑
-            if not Catalog.query.filter_by(guid=self.para.get("guid")).one_or_none():
-                res["msg"]="目录不存在!"
-                res["result"]=False
-                return res
-            else:
-                if self.para.get("name"):
-                    Catalog.query.filter_by(guid=self.para.get("guid")).update({"name":self.para.get("name")})
-                if self.para.__contains__("description"):
-                    Catalog.query.filter_by(guid=self.para.get("guid")).update({"description":self.para.get("description")})
-                db.session.commit()
-                res["msg"] = "目录修改成功！"
-                res["result"] = True
-        except Exception as e:
-            db.session.rollback()
-            raise e
-        return res
-    
-    
-    api_doc = {
-        "tags": ["目录接口"],
-        "parameters": [
-            {"name": "guid",
-             "in": "formData",
-             "type": "string",
-             "description": "目录guid", "required": "true"},
-            {"name": "name",
-             "in": "formData",
-             "type": "string",
-             "description": "目录名", "required": "true"}
-        ],
-        "responses": {
-            200: {
-                "schema": {
-                    "properties": {
-                    }
-                }
-            }
-        }
-    }
+# coding=utf-8
+#author:        4N
+#createtime:    2021/3/9
+#email:         nheweijun@sina.com
+
+from app.models import *
+
+from app.util.component.ApiTemplate import ApiTemplate
+class Api(ApiTemplate):
+    api_name = "修改目录"
+    def process(self):
+ 
+
+        # 返回结果
+        res = {}
+        try:
+            # 业务逻辑
+            if not Catalog.query.filter_by(guid=self.para.get("guid")).one_or_none():
+                res["msg"]="目录不存在!"
+                res["result"]=False
+                return res
+            else:
+                if self.para.get("name"):
+                    Catalog.query.filter_by(guid=self.para.get("guid")).update({"name":self.para.get("name")})
+                if self.para.__contains__("description"):
+                    Catalog.query.filter_by(guid=self.para.get("guid")).update({"description":self.para.get("description")})
+                db.session.commit()
+                res["msg"] = "目录修改成功！"
+                res["result"] = True
+        except Exception as e:
+            db.session.rollback()
+            raise e
+        return res
+    
+    
+    api_doc = {
+        "tags": ["目录接口"],
+        "parameters": [
+            {"name": "guid",
+             "in": "formData",
+             "type": "string",
+             "description": "目录guid", "required": "true"},
+            {"name": "name",
+             "in": "formData",
+             "type": "string",
+             "description": "目录名", "required": "true"}
+        ],
+        "responses": {
+            200: {
+                "schema": {
+                    "properties": {
+                    }
+                }
+            }
+        }
+    }

-# coding=utf-8
-#author:        4N
-#createtime:    2021/3/9
-#email:         nheweijun@sina.com
-
-
-from app.models import *
-
-from app.util.component.ApiTemplate import ApiTemplate
-from app.util.component.ModelVisitor import ModelVisitor
-class Api(ApiTemplate):
-    api_name = "下一级目录"
-    def process(self):
-
-        # 返回结果
-        res = {}
-        try:
-            # 业务逻辑
-
-            res["data"] = []
-            catalogs = Catalog.query.filter_by(pguid=self.para.get("catalog_guid"),database_guid=self.para.get("database_guid")).all()
-            for cata in catalogs:
-                catalog_guids = [c.guid for c in Catalog.query.filter(Catalog.path.like("%" + cata.guid + "%")).all()]
-                table_count = Table.query.filter(Table.catalog_guid.in_(catalog_guids)).count()
-                database_alias = cata.relate_database.alias
-                cata_json = ModelVisitor.object_to_json(cata)
-                cata_json["table_count"]=table_count
-                cata_json["database_alias"] = database_alias
-
-                res["data"].append(cata_json)
-            res["result"] = True
-        except Exception as e:
-            raise e
-        return res
-
-    api_doc={
-
-    "tags":["目录接口"],
-    "parameters":[
-        {"name": "catalog_guid",
-         "in": "formData",
-         "type": "string",
-         "description":"目录guid","required": "true"},
-        {"name": "database_guid",
-         "in": "formData",
-         "type": "string",
-         "description": "数据库guid", "required": "true"},
-
-    ],
-    "responses":{
-        200:{
-            "schema":{
-                "properties":{
-                }
-            }
-            }
-        }
+# coding=utf-8
+#author:        4N
+#createtime:    2021/3/9
+#email:         nheweijun@sina.com
+
+
+from app.models import *
+
+from app.util.component.ApiTemplate import ApiTemplate
+from app.util.component.ModelVisitor import ModelVisitor
+class Api(ApiTemplate):
+    api_name = "下一级目录"
+    def process(self):
+
+        # 返回结果
+        res = {}
+        try:
+            # 业务逻辑
+
+            res["data"] = []
+            catalogs = Catalog.query.filter_by(pguid=self.para.get("catalog_guid"),database_guid=self.para.get("database_guid")).all()
+            for cata in catalogs:
+                catalog_guids = [c.guid for c in Catalog.query.filter(Catalog.path.like("%" + cata.guid + "%")).all()]
+                table_count = Table.query.filter(Table.catalog_guid.in_(catalog_guids)).count()
+                database_alias = cata.relate_database.alias
+                cata_json = ModelVisitor.object_to_json(cata)
+                cata_json["table_count"]=table_count
+                cata_json["database_alias"] = database_alias
+
+                res["data"].append(cata_json)
+            res["result"] = True
+        except Exception as e:
+            raise e
+        return res
+
+    api_doc={
+
+    "tags":["目录接口"],
+    "parameters":[
+        {"name": "catalog_guid",
+         "in": "formData",
+         "type": "string",
+         "description":"目录guid","required": "true"},
+        {"name": "database_guid",
+         "in": "formData",
+         "type": "string",
+         "description": "数据库guid", "required": "true"},
+
+    ],
+    "responses":{
+        200:{
+            "schema":{
+                "properties":{
+                }
+            }
+            }
+        }
     }
     }

-# coding=utf-8
-#author:        4N
-#createtime:    2021/3/9
-#email:         nheweijun@sina.com
-
-
-from app.models import *
-
-from app.util.component.ApiTemplate import ApiTemplate
-class Api(ApiTemplate):
-    api_name = "目录树"
-    def process(self):
-
-        # 返回结果
-        res = {}
-        try:
-            # 业务逻辑
-            database_guid = self.para.get("database_guid")
-            catalogs = Catalog.query.filter_by(database_guid=database_guid).all()
-
-            tree_origin = []
-            for cata in catalogs:
-                catalog_guids = [c.guid for c in Catalog.query.filter(Catalog.path.like("%" + cata.guid + "%")).all()]
-                table_count = Table.query.filter(Table.catalog_guid.in_(catalog_guids)).count()
-    
-                # cata_json = object_to_json(cata)
-                cata_json ={}
-                cata_json["database_guid"]=cata.database_guid
-                cata_json["description"] = cata.description
-                cata_json["guid"] = cata.guid
-                cata_json["name"] = cata.name
-                cata_json["path"] = cata.path
-                cata_json["pguid"] = cata.pguid
-                cata_json["sort"] = cata.sort
-                cata_json["table_count"]=table_count
-                cata_json["children"] = []
-                tree_origin.append(cata_json)
-
-            for cata in tree_origin:
-                cata_pguid = cata["pguid"]
-                if not cata_pguid=="0":
-                    for c in tree_origin:
-                        if c["guid"].__eq__(cata_pguid):
-                            c["children"].append(cata)
-
-            res["data"] = [cata for cata in tree_origin if cata["pguid"].__eq__("0")]
-            res["result"] = True
-        except Exception as e:
-            raise e
-        return res
-
-    api_doc={
-    
-    "tags":["目录接口"],
-    "parameters":[
-        {"name": "database_guid",
-         "in": "formData",
-         "type": "string",
-         "description": "数据库guid", "required": "true"},
-    
-    ],
-    "responses":{
-        200:{
-            "schema":{
-                "properties":{
-                }
-            }
-            }
-        }
+# coding=utf-8
+#author:        4N
+#createtime:    2021/3/9
+#email:         nheweijun@sina.com
+
+
+from app.models import *
+
+from app.util.component.ApiTemplate import ApiTemplate
+class Api(ApiTemplate):
+    api_name = "目录树"
+    def process(self):
+
+        # 返回结果
+        res = {}
+        try:
+            # 业务逻辑
+            database_guid = self.para.get("database_guid")
+            catalogs = Catalog.query.filter_by(database_guid=database_guid).all()
+
+            tree_origin = []
+            for cata in catalogs:
+                catalog_guids = [c.guid for c in Catalog.query.filter(Catalog.path.like("%" + cata.guid + "%")).all()]
+                table_count = Table.query.filter(Table.catalog_guid.in_(catalog_guids)).count()
+    
+                # cata_json = object_to_json(cata)
+                cata_json ={}
+                cata_json["database_guid"]=cata.database_guid
+                cata_json["description"] = cata.description
+                cata_json["guid"] = cata.guid
+                cata_json["name"] = cata.name
+                cata_json["path"] = cata.path
+                cata_json["pguid"] = cata.pguid
+                cata_json["sort"] = cata.sort
+                cata_json["table_count"]=table_count
+                cata_json["children"] = []
+                tree_origin.append(cata_json)
+
+            for cata in tree_origin:
+                cata_pguid = cata["pguid"]
+                if not cata_pguid=="0":
+                    for c in tree_origin:
+                        if c["guid"].__eq__(cata_pguid):
+                            c["children"].append(cata)
+
+            res["data"] = [cata for cata in tree_origin if cata["pguid"].__eq__("0")]
+            res["result"] = True
+        except Exception as e:
+            raise e
+        return res
+
+    api_doc={
+    
+    "tags":["目录接口"],
+    "parameters":[
+        {"name": "database_guid",
+         "in": "formData",
+         "type": "string",
+         "description": "数据库guid", "required": "true"},
+    
+    ],
+    "responses":{
+        200:{
+            "schema":{
+                "properties":{
+                }
+            }
+            }
+        }
     }
     }

-# coding=utf-8
-#author:        4N
-#createtime:    2021/3/9
-#email:         nheweijun@sina.com
-
-
-from app.models import *
-
-from app.util.component.ApiTemplate import ApiTemplate
-class Api(ApiTemplate):
-    api_name = "目录"
-    def process(self):
-
-        # 返回结果
-        res = {}
-        try:
-            # 业务逻辑
-            database_guid = self.para.get("database_guid")
-            catalogs = Catalog.query.filter_by(database_guid=database_guid).all()
-            res["data"]=[]
-            for cata in catalogs:
-                catalog_guids = [c.guid for c in Catalog.query.filter(Catalog.path.like("%" + cata.guid + "%")).all()]
-                table_count = Table.query.filter(Table.catalog_guid.in_(catalog_guids)).count()
-    
-                # cata_json = object_to_json(cata)
-                cata_json ={}
-                cata_json["database_guid"]=cata.database_guid
-                cata_json["description"] = cata.description
-                cata_json["guid"] = cata.guid
-                cata_json["name"] = cata.name
-                cata_json["path"] = cata.path
-                cata_json["pguid"] = cata.pguid
-                cata_json["sort"] = cata.sort
-                cata_json["table_count"]=table_count
-                res["data"].append(cata_json)
-    
-            res["result"] = True
-    
-        except Exception as e:
-            raise e
-        return res
-    
-    api_doc={
-    
-    "tags":["目录接口"],
-    "parameters":[
-        {"name": "database_guid",
-         "in": "formData",
-         "type": "string",
-         "description": "数据库guid", "required": "true"},
-    
-    ],
-    "responses":{
-        200:{
-            "schema":{
-                "properties":{
-                }
-            }
-            }
-        }
+# coding=utf-8
+#author:        4N
+#createtime:    2021/3/9
+#email:         nheweijun@sina.com
+
+
+from app.models import *
+
+from app.util.component.ApiTemplate import ApiTemplate
+class Api(ApiTemplate):
+    api_name = "目录"
+    def process(self):
+
+        # 返回结果
+        res = {}
+        try:
+            # 业务逻辑
+            database_guid = self.para.get("database_guid")
+            catalogs = Catalog.query.filter_by(database_guid=database_guid).all()
+            res["data"]=[]
+            for cata in catalogs:
+                catalog_guids = [c.guid for c in Catalog.query.filter(Catalog.path.like("%" + cata.guid + "%")).all()]
+                table_count = Table.query.filter(Table.catalog_guid.in_(catalog_guids)).count()
+    
+                # cata_json = object_to_json(cata)
+                cata_json ={}
+                cata_json["database_guid"]=cata.database_guid
+                cata_json["description"] = cata.description
+                cata_json["guid"] = cata.guid
+                cata_json["name"] = cata.name
+                cata_json["path"] = cata.path
+                cata_json["pguid"] = cata.pguid
+                cata_json["sort"] = cata.sort
+                cata_json["table_count"]=table_count
+                res["data"].append(cata_json)
+    
+            res["result"] = True
+    
+        except Exception as e:
+            raise e
+        return res
+    
+    api_doc={
+    
+    "tags":["目录接口"],
+    "parameters":[
+        {"name": "database_guid",
+         "in": "formData",
+         "type": "string",
+         "description": "数据库guid", "required": "true"},
+    
+    ],
+    "responses":{
+        200:{
+            "schema":{
+                "properties":{
+                }
+            }
+            }
+        }
     }
     }

-# coding=utf-8
-#author:        4N
-#createtime:    2021/3/9
-#email:         nheweijun@sina.com
-
-
-
-from flasgger import swag_from
-from flask import Blueprint
-from app.util import BlueprintApi
-
-from . import database_register
-from . import database_test
-from . import database_list
-from . import database_delete
-from . import database_edit
-from . import database_alias_check
-from . import database_connect_test
-from . import database_info
-
-class DataManager(BlueprintApi):
-
-    bp = Blueprint("Database", __name__, url_prefix="/API/Database")
-
-
-    @staticmethod
-    @bp.route('/Register', methods=['POST'])
-    @swag_from(database_register.Api.api_doc)
-    def api_database_register():
-        """
-        数据源注册
-        """
-        return database_register.Api().result
-
-    @staticmethod
-    @bp.route('/List', methods=['POST'])
-    @swag_from(database_list.Api.api_doc)
-    def api_database_list():
-        """
-        数据源列表
-        """
-        return database_list.Api().result
-
-    @staticmethod
-    @bp.route('/Delete', methods=['POST'])
-    @swag_from(database_delete.Api.api_doc)
-    def api_database_delete():
-        """
-        数据源注销
-        """
-        return database_delete.Api().result
-
-    @staticmethod
-    @bp.route('/Edit', methods=['POST'])
-    @swag_from(database_edit.Api.api_doc)
-    def database_edit():
-        """
-        修改数据源
-        """
-        return database_edit.Api().result
-
-    @staticmethod
-    @bp.route('/Test', methods=['POST'])
-    @swag_from(database_test.Api.api_doc)
-    def api_database_test():
-        """
-        数据源测试
-        """
-        return database_test.Api().result
-
-    @staticmethod
-    @bp.route('/CheckAlias', methods=['POST'])
-    @swag_from(database_alias_check.Api.api_doc)
-    def api_database_alias_check():
-        """
-        数据源别名测试
-        """
-        return database_alias_check.Api().result
-
-    @staticmethod
-    @bp.route('/CheckConnect', methods=['POST'])
-    @swag_from(database_connect_test.Api.api_doc)
-    def api_database_connect_test():
-        """
-        数据源连接测试
-        """
-        return database_connect_test.Api().result
-
-
-    @staticmethod
-    @bp.route('/Info', methods=['POST'])
-    @swag_from(database_info.Api.api_doc)
-    def api_database_info():
-        """
-        数据源信息
-        """
+# coding=utf-8
+#author:        4N
+#createtime:    2021/3/9
+#email:         nheweijun@sina.com
+
+
+
+from flasgger import swag_from
+from flask import Blueprint
+from app.util import BlueprintApi
+
+from . import database_register
+from . import database_test
+from . import database_list
+from . import database_delete
+from . import database_edit
+from . import database_alias_check
+from . import database_connect_test
+from . import database_info
+
+class DataManager(BlueprintApi):
+
+    bp = Blueprint("Database", __name__, url_prefix="/API/Database")
+
+
+    @staticmethod
+    @bp.route('/Register', methods=['POST'])
+    @swag_from(database_register.Api.api_doc)
+    def api_database_register():
+        """
+        数据源注册
+        """
+        return database_register.Api().result
+
+    @staticmethod
+    @bp.route('/List', methods=['POST'])
+    @swag_from(database_list.Api.api_doc)
+    def api_database_list():
+        """
+        数据源列表
+        """
+        return database_list.Api().result
+
+    @staticmethod
+    @bp.route('/Delete', methods=['POST'])
+    @swag_from(database_delete.Api.api_doc)
+    def api_database_delete():
+        """
+        数据源注销
+        """
+        return database_delete.Api().result
+
+    @staticmethod
+    @bp.route('/Edit', methods=['POST'])
+    @swag_from(database_edit.Api.api_doc)
+    def database_edit():
+        """
+        修改数据源
+        """
+        return database_edit.Api().result
+
+    @staticmethod
+    @bp.route('/Test', methods=['POST'])
+    @swag_from(database_test.Api.api_doc)
+    def api_database_test():
+        """
+        数据源测试
+        """
+        return database_test.Api().result
+
+    @staticmethod
+    @bp.route('/CheckAlias', methods=['POST'])
+    @swag_from(database_alias_check.Api.api_doc)
+    def api_database_alias_check():
+        """
+        数据源别名测试
+        """
+        return database_alias_check.Api().result
+
+    @staticmethod
+    @bp.route('/CheckConnect', methods=['POST'])
+    @swag_from(database_connect_test.Api.api_doc)
+    def api_database_connect_test():
+        """
+        数据源连接测试
+        """
+        return database_connect_test.Api().result
+
+
+    @staticmethod
+    @bp.route('/Info', methods=['POST'])
+    @swag_from(database_info.Api.api_doc)
+    def api_database_info():
+        """
+        数据源信息
+        """
         return database_info.Api().result
         return database_info.Api().result

-# coding=utf-8
-#author:        4N
-#createtime:    2021/3/9
-#email:         nheweijun@sina.com
-
-from app.models import Database,db
-
-
-
-from app.util.component.ApiTemplate import ApiTemplate
-class Api(ApiTemplate):
-    api_name = "测试数据库别名"
-
-    def process(self):
-        res ={}
-        try:
-            database = db.session.query(Database).filter_by(alias=self.para.get("alias")).one_or_none()
-            if database:
-                res["msg"]="数据库重名！"
-                res["result"]=False
-            else:
-                res["result"] = True
-        except Exception as e:
-            raise e
-        return res
-
-    api_doc={
-    "tags":["数据库接口"],
-    "parameters":[
-        {"name": "alias",
-         "in": "formData",
-         "type": "string","description":"数据库别名","required": "true"},
-    
-    ],
-    "responses":{
-        200:{
-            "schema":{
-                "properties":{
-                }
-            }
-            }
-        }
+# coding=utf-8
+#author:        4N
+#createtime:    2021/3/9
+#email:         nheweijun@sina.com
+
+from app.models import Database,db
+
+
+
+from app.util.component.ApiTemplate import ApiTemplate
+class Api(ApiTemplate):
+    api_name = "测试数据库别名"
+
+    def process(self):
+        res ={}
+        try:
+            database = db.session.query(Database).filter_by(alias=self.para.get("alias")).one_or_none()
+            if database:
+                res["msg"]="数据库重名！"
+                res["result"]=False
+            else:
+                res["result"] = True
+        except Exception as e:
+            raise e
+        return res
+
+    api_doc={
+    "tags":["数据库接口"],
+    "parameters":[
+        {"name": "alias",
+         "in": "formData",
+         "type": "string","description":"数据库别名","required": "true"},
+    
+    ],
+    "responses":{
+        200:{
+            "schema":{
+                "properties":{
+                }
+            }
+            }
+        }
     }
     }

-# coding=utf-8
-# author:        4N
-# createtime:    2020/6/22
-# email:         nheweijun@sina.com
-from contextlib import closing
-
-from sqlalchemy import create_engine
-
-from app.models import DES,Database
-
-
-from app.util.component.ApiTemplate import ApiTemplate
-class Api(ApiTemplate):
-    api_name = "测试数据库连接"
-    def process(self):
-        res = {}
-        try:
-            guid = self.para.get("guid")
-            database = Database.query.filter_by(guid=guid)
-            dbase:Database = database.one_or_none()
-            engine = create_engine(DES.decode(dbase.sqlalchemy_uri), connect_args={'connect_timeout': 1})
-            with closing(engine.connect()):
-                pass
-            res["result"]=True
-            res["msg"] = "测试连接成功！"
-        except:
-            raise Exception("测试连接失败！")
-        return res
-
-    api_doc={
-    "tags":["数据库接口"],
-    "parameters":[
-    
-        {"name": "guid",
-         "in": "formData",
-         "type": "string", "required": "true"},
-    
-    
-    ],
-    "responses":{
-        200:{
-            "schema":{
-                "properties":{
-                }
-            }
-            }
-        }
+# coding=utf-8
+# author:        4N
+# createtime:    2020/6/22
+# email:         nheweijun@sina.com
+from contextlib import closing
+
+from sqlalchemy import create_engine
+
+from app.models import DES,Database
+
+
+from app.util.component.ApiTemplate import ApiTemplate
+class Api(ApiTemplate):
+    api_name = "测试数据库连接"
+    def process(self):
+        res = {}
+        try:
+            guid = self.para.get("guid")
+            database = Database.query.filter_by(guid=guid)
+            dbase:Database = database.one_or_none()
+            engine = create_engine(DES.decode(dbase.sqlalchemy_uri), connect_args={'connect_timeout': 1})
+            with closing(engine.connect()):
+                pass
+            res["result"]=True
+            res["msg"] = "测试连接成功！"
+        except:
+            raise Exception("测试连接失败！")
+        return res
+
+    api_doc={
+    "tags":["数据库接口"],
+    "parameters":[
+    
+        {"name": "guid",
+         "in": "formData",
+         "type": "string", "required": "true"},
+    
+    
+    ],
+    "responses":{
+        200:{
+            "schema":{
+                "properties":{
+                }
+            }
+            }
+        }
     }
     }

-# coding=utf-8
-#author:        4N
-#createtime:    2021/3/9
-#email:         nheweijun@sina.com
-
-
-from app.models import Database,db
-
-
-from app.util.component.ApiTemplate import ApiTemplate
-class Api(ApiTemplate):
-    api_name = "删除数据库"
-    def process(self):
-        res ={}
-        try:
-    
-            database = db.session.query(Database).filter_by(guid=self.para.get("guid")).one_or_none()
-            if database:
-                db.session.delete(database)
-                db.session.commit()
-                res["msg"] = "数据库删除成功！"
-                res["result"] = True
-            else:
-                res["msg"] = "数据库不存在!"
-                res["result"] = False
-        except Exception as e:
-            db.session.rollback()
-            raise e
-        return res
-    
-    
-    
-    api_doc={
-    "tags":["数据库接口"],
-    "parameters":[
-        {"name": "guid",
-         "in": "formData",
-         "type": "string","description":"数据库guid","required": "true"},
-    
-    ],
-    "responses":{
-        200:{
-            "schema":{
-                "properties":{
-                }
-            }
-            }
-        }
+# coding=utf-8
+#author:        4N
+#createtime:    2021/3/9
+#email:         nheweijun@sina.com
+
+
+from app.models import Database,db
+
+
+from app.util.component.ApiTemplate import ApiTemplate
+class Api(ApiTemplate):
+    api_name = "删除数据库"
+    def process(self):
+        res ={}
+        try:
+    
+            database = db.session.query(Database).filter_by(guid=self.para.get("guid")).one_or_none()
+            if database:
+                db.session.delete(database)
+                db.session.commit()
+                res["msg"] = "数据库删除成功！"
+                res["result"] = True
+            else:
+                res["msg"] = "数据库不存在!"
+                res["result"] = False
+        except Exception as e:
+            db.session.rollback()
+            raise e
+        return res
+    
+    
+    
+    api_doc={
+    "tags":["数据库接口"],
+    "parameters":[
+        {"name": "guid",
+         "in": "formData",
+         "type": "string","description":"数据库guid","required": "true"},
+    
+    ],
+    "responses":{
+        200:{
+            "schema":{
+                "properties":{
+                }
+            }
+            }
+        }
     }
     }

-# coding=utf-8
-#author:        4N
-#createtime:    2021/3/9
-#email:         nheweijun@sina.com
-
-from app.models import Database,db
-from contextlib import closing
-
-from sqlalchemy import create_engine
-
-from app.models import DES
-import datetime
-from . import database_alias_check
-
-from app.util.component.ApiTemplate import ApiTemplate
-
-from app.util.component.PGUtil import PGUtil
-class Api(ApiTemplate):
-    api_name = "修改数据库"
-    def process(self):
-        
-        res = {}
-        res["result"] = False
-        try:
-            guid = self.para.get("guid")
-            alias = self.para.get("alias")
-    
-            passwd = self.para.get("passwd")
-            database = Database.query.filter_by(guid=guid)
-            dbase:Database = database.one_or_none()
-
-            update_dict={}
-    
-            if not dbase:
-                res["msg"] = "数据库不存在！"
-                return res
-            if not alias and not passwd:
-                res["msg"] = "请填写参数！"
-                return res
-
-    
-            if alias:
-                # 检测一波别名
-                check_alias = database_alias_check.Api().result
-                if not check_alias["result"]:
-                    return check_alias
-                update_dict["alias"]=alias
-    
-            if passwd:
-                try:
-                    user, password, host, port, database = PGUtil.get_info_from_sqlachemy_uri(DES.decode(dbase.sqlalchemy_uri))
-
-                    sqlalchemy_uri = "postgresql://{}:{}@{}:{}/{}".format(user, passwd,host,
-                                                                          port, database)
-
-                    connectsrt = "hostaddr={} port={} dbname='{}' user='{}' password='{}'".format(host, port, database, user,
-                                                                                                  passwd)
-                    engine = create_engine(sqlalchemy_uri, connect_args={'connect_timeout': 2})
-                    with closing(engine.connect()):
-                        pass
-
-                except :
-                    res["msg"] = "密码错误！"
-                    return res
-
-                update_dict["sqlalchemy_uri"]= DES.encode(sqlalchemy_uri)
-                update_dict["connectstr"] = DES.encode(connectsrt)
-    
-            if update_dict:
-                update_dict["update_time"]=datetime.datetime.now()
-                Database.query.filter_by(guid=guid).update(update_dict)
-                db.session.commit()
-            res["result"] = True
-            res["msg"] = "数据修改成功！"
-        except Exception as e:
-            db.session.rollback()
-            raise e
-        return res
-    
-    
-    
-    api_doc={
-    "tags":["数据库接口"],
-    "parameters":[
-        {"name": "guid",
-         "in": "formData",
-         "type": "string"},
-        {"name": "alias",
-         "in": "formData",
-         "type": "string","description":"数据库别名"},
-        {"name": "passwd",
-         "in": "formData",
-         "type": "string", "description": "数据库密码"}
-    ],
-    "responses":{
-        200:{
-            "schema":{
-                "properties":{
-                }
-            }
-            }
-        }
+# coding=utf-8
+#author:        4N
+#createtime:    2021/3/9
+#email:         nheweijun@sina.com
+
+from app.models import Database,db
+from contextlib import closing
+
+from sqlalchemy import create_engine
+
+from app.models import DES
+import datetime
+from . import database_alias_check
+
+from app.util.component.ApiTemplate import ApiTemplate
+
+from app.util.component.PGUtil import PGUtil
+class Api(ApiTemplate):
+    api_name = "修改数据库"
+    def process(self):
+        
+        res = {}
+        res["result"] = False
+        try:
+            guid = self.para.get("guid")
+            alias = self.para.get("alias")
+    
+            passwd = self.para.get("passwd")
+            database = Database.query.filter_by(guid=guid)
+            dbase:Database = database.one_or_none()
+
+            update_dict={}
+    
+            if not dbase:
+                res["msg"] = "数据库不存在！"
+                return res
+            if not alias and not passwd:
+                res["msg"] = "请填写参数！"
+                return res
+
+    
+            if alias:
+                # 检测一波别名
+                check_alias = database_alias_check.Api().result
+                if not check_alias["result"]:
+                    return check_alias
+                update_dict["alias"]=alias
+    
+            if passwd:
+                try:
+                    user, password, host, port, database = PGUtil.get_info_from_sqlachemy_uri(DES.decode(dbase.sqlalchemy_uri))
+
+                    sqlalchemy_uri = "postgresql://{}:{}@{}:{}/{}".format(user, passwd,host,
+                                                                          port, database)
+
+                    connectsrt = "hostaddr={} port={} dbname='{}' user='{}' password='{}'".format(host, port, database, user,
+                                                                                                  passwd)
+                    engine = create_engine(sqlalchemy_uri, connect_args={'connect_timeout': 2})
+                    with closing(engine.connect()):
+                        pass
+
+                except :
+                    res["msg"] = "密码错误！"
+                    return res
+
+                update_dict["sqlalchemy_uri"]= DES.encode(sqlalchemy_uri)
+                update_dict["connectstr"] = DES.encode(connectsrt)
+    
+            if update_dict:
+                update_dict["update_time"]=datetime.datetime.now()
+                Database.query.filter_by(guid=guid).update(update_dict)
+                db.session.commit()
+            res["result"] = True
+            res["msg"] = "数据修改成功！"
+        except Exception as e:
+            db.session.rollback()
+            raise e
+        return res
+    
+    
+    
+    api_doc={
+    "tags":["数据库接口"],
+    "parameters":[
+        {"name": "guid",
+         "in": "formData",
+         "type": "string"},
+        {"name": "alias",
+         "in": "formData",
+         "type": "string","description":"数据库别名"},
+        {"name": "passwd",
+         "in": "formData",
+         "type": "string", "description": "数据库密码"}
+    ],
+    "responses":{
+        200:{
+            "schema":{
+                "properties":{
+                }
+            }
+            }
+        }
     }
     }

-# coding=utf-8
-#author:        4N
-#createtime:    2021/3/9
-#email:         nheweijun@sina.com
-from app.models import Database,DES
-from contextlib import closing
-from sqlalchemy import create_engine,or_
-
-from app.models import Database,Catalog,Table
-
-
-from app.util.component.ApiTemplate import ApiTemplate
-
-
-class Api(ApiTemplate):
-    api_name = "获取数据库信息"
-    def process(self):
-        # 返回结果
-        res = {}
-        try:
-            # 业务逻辑
-            database_guid = self.para.get("guid")
-            table_type = self.para.get("table_type")
-            catalogs = Catalog.query.filter_by(database_guid=database_guid).all()
-
-            tree_origin = []
-            for cata in catalogs:
-                cata_json = {}
-                cata_json["type"] = "catalog"
-                cata_json["guid"] = cata.guid
-                cata_json["name"] = cata.name
-                cata_json["pguid"] = cata.pguid
-                cata_json["children"] = []
-                tree_origin.append(cata_json)
-
-                #挂接表
-                tables =Table.query.filter_by(database_guid=database_guid,catalog_guid=cata.guid).filter(Table.table_type != 0)
-                if table_type:
-                    tables = tables.filter_by(table_type=table_type)
-                tables = tables.order_by(Table.name).all()
-
-                for table in tables:
-                    table_json= {}
-                    table_json["name"]=table.name
-                    table_json["alias"] = table.alias
-                    table_json["guid"] = table.guid
-                    table_json["type"] = "table"
-                    table_json["table_type"] = table.table_type
-                    cata_json["children"].append(table_json)
-
-            for cata in tree_origin:
-                cata_pguid = cata["pguid"]
-                if not cata_pguid == "0":
-                    for c in tree_origin:
-                        if c["guid"].__eq__(cata_pguid):
-                            c["children"].append(cata)
-            res["data"] = [cata for cata in tree_origin if cata["pguid"].__eq__("0")]
-
-            # 挂接表
-            tables = Table.query.filter_by(database_guid=database_guid, catalog_guid=None).filter(
-                Table.table_type != 0)
-            if table_type:
-                tables = tables.filter_by(table_type=table_type)
-            tables = tables.order_by(Table.name).all()
-
-            for table in tables:
-                table_json = {}
-                table_json["name"] = table.name
-                table_json["alias"] = table.alias
-                table_json["guid"] = table.guid
-                table_json["type"] = "table"
-                table_json["table_type"] = table.table_type
-                res["data"].append(table_json)
-
-            res["result"] = True
-        except Exception as e:
-            raise e
-        return res
-
-    api_doc={
-    "tags":["数据库接口"],
-    "parameters":[
-        {"name": "guid",
-         "in": "formData",
-         "type": "string", "description": "数据库guid"},
-        {"name": "table_type",
-         "in": "formData",
-         "type": "int", "description": "表类型","enum":[1,2,3]}
-    ],
-    "responses":{
-        200:{
-            "schema":{
-                "properties":{
-                }
-            }
-            }
-        }
-    }
+# coding=utf-8
+#author:        4N
+#createtime:    2021/3/9
+#email:         nheweijun@sina.com
+from app.models import Database,DES
+from contextlib import closing
+from sqlalchemy import create_engine,or_
+
+from app.models import Database,Catalog,Table
+
+
+from app.util.component.ApiTemplate import ApiTemplate
+
+
+class Api(ApiTemplate):
+    api_name = "获取数据库信息"
+    def process(self):
+        # 返回结果
+        res = {}
+        try:
+            # 业务逻辑
+            database_guid = self.para.get("guid")
+            table_type = self.para.get("table_type")
+            catalogs = Catalog.query.filter_by(database_guid=database_guid).all()
+
+            tree_origin = []
+            for cata in catalogs:
+                cata_json = {}
+                cata_json["type"] = "catalog"
+                cata_json["guid"] = cata.guid
+                cata_json["name"] = cata.name
+                cata_json["pguid"] = cata.pguid
+                cata_json["children"] = []
+                tree_origin.append(cata_json)
+
+                #挂接表
+                tables =Table.query.filter_by(database_guid=database_guid,catalog_guid=cata.guid).filter(Table.table_type != 0)
+                if table_type:
+                    tables = tables.filter_by(table_type=table_type)
+                tables = tables.order_by(Table.name).all()
+
+                for table in tables:
+                    table_json= {}
+                    table_json["name"]=table.name
+                    table_json["alias"] = table.alias
+                    table_json["guid"] = table.guid
+                    table_json["type"] = "table"
+                    table_json["table_type"] = table.table_type
+                    cata_json["children"].append(table_json)
+
+            for cata in tree_origin:
+                cata_pguid = cata["pguid"]
+                if not cata_pguid == "0":
+                    for c in tree_origin:
+                        if c["guid"].__eq__(cata_pguid):
+                            c["children"].append(cata)
+            res["data"] = [cata for cata in tree_origin if cata["pguid"].__eq__("0")]
+
+            # 挂接表
+            tables = Table.query.filter_by(database_guid=database_guid, catalog_guid=None).filter(
+                Table.table_type != 0)
+            if table_type:
+                tables = tables.filter_by(table_type=table_type)
+            tables = tables.order_by(Table.name).all()
+
+            for table in tables:
+                table_json = {}
+                table_json["name"] = table.name
+                table_json["alias"] = table.alias
+                table_json["guid"] = table.guid
+                table_json["type"] = "table"
+                table_json["table_type"] = table.table_type
+                res["data"].append(table_json)
+
+            res["result"] = True
+        except Exception as e:
+            raise e
+        return res
+
+    api_doc={
+    "tags":["数据库接口"],
+    "parameters":[
+        {"name": "guid",
+         "in": "formData",
+         "type": "string", "description": "数据库guid"},
+        {"name": "table_type",
+         "in": "formData",
+         "type": "int", "description": "表类型","enum":[1,2,3]}
+    ],
+    "responses":{
+        200:{
+            "schema":{
+                "properties":{
+                }
+            }
+            }
+        }
+    }

-# coding=utf-8
-#author:        4N
-#createtime:    2021/3/9
-#email:         nheweijun@sina.com
-from app.models import Database,DES
-from contextlib import closing
-from sqlalchemy import create_engine
-
-from app.models import Database
-
-
-from app.util.component.ApiTemplate import ApiTemplate
-from app.util.component.ModelVisitor import ModelVisitor
-class Api(ApiTemplate):
-    api_name = "获取数据库列表"
-    def process(self):
-        res = {}
-        res["data"]={}
-        try:
-            page_index = int(self.para.get("pageIndex", "0"))
-            page_size = int(self.para.get("pageSize", "10"))
-            alias = self.para.get("alias")
-            database_guid = self.para.get("guid")
-            database = Database.query.order_by(Database.create_time.desc())
-    
-            if alias:
-                database = database.filter(Database.alias.like("%" + alias + "%"))
-            if database_guid:
-                database = database.filter_by(guid = database_guid)
-
-            res["data"]["count"] = database.count()
-    
-            database = database.limit(page_size).offset(page_index * page_size).all()
-            res["data"]["list"] =[]
-            for datab in database:
-                # 测试连接
-                try:
-                    engine = create_engine(DES.decode(datab.sqlalchemy_uri), connect_args={'connect_timeout': 1})
-                    with closing(engine.connect()):
-                        pass
-                    available=1
-                except:
-                    available=-1
-                table_count = datab.relate_tables.count()
-                datab_json = ModelVisitor.database_to_json(datab)
-                datab_json["table_count"] = table_count
-                datab_json["available"] = available
-                res["data"]["list"].append(datab_json)
-
-            # 可用非可用排序
-            sorted_list = [dat for dat in res["data"]["list"] if dat["available"]==1]
-            sorted_list.extend([dat for dat in res["data"]["list"] if dat["available"] == -1])
-            res["data"]["list"] = sorted_list
-            res["result"]=True
-        except Exception as e:
-            raise e
-        return res
-    
-    
-    
-    api_doc={
-    "tags":["数据库接口"],
-    "parameters":[
-        {"name": "page_index",
-         "in": "formData",
-         "type": "int",
-         "default": "0"},
-        {"name": "page_size",
-         "in": "formData",
-         "type": "int",
-         "default": "10"},
-        {"name": "alias",
-         "in": "formData",
-         "type": "string","description":"数据库别名"},
-        {"name": "guid",
-         "in": "formData",
-         "type": "string", "description": "数据库guid"}
-    ],
-    "responses":{
-        200:{
-            "schema":{
-                "properties":{
-                }
-            }
-            }
-        }
-    }
+# coding=utf-8
+#author:        4N
+#createtime:    2021/3/9
+#email:         nheweijun@sina.com
+from app.models import Database,DES
+from contextlib import closing
+from sqlalchemy import create_engine
+
+from app.models import Database
+
+
+from app.util.component.ApiTemplate import ApiTemplate
+from app.util.component.ModelVisitor import ModelVisitor
+class Api(ApiTemplate):
+    api_name = "获取数据库列表"
+    def process(self):
+        res = {}
+        res["data"]={}
+        try:
+            page_index = int(self.para.get("pageIndex", "0"))
+            page_size = int(self.para.get("pageSize", "10"))
+            alias = self.para.get("alias")
+            database_guid = self.para.get("guid")
+            database = Database.query.order_by(Database.create_time.desc())
+    
+            if alias:
+                database = database.filter(Database.alias.like("%" + alias + "%"))
+            if database_guid:
+                database = database.filter_by(guid = database_guid)
+
+            res["data"]["count"] = database.count()
+    
+            database = database.limit(page_size).offset(page_index * page_size).all()
+            res["data"]["list"] =[]
+            for datab in database:
+                # 测试连接
+                try:
+                    engine = create_engine(DES.decode(datab.sqlalchemy_uri), connect_args={'connect_timeout': 1})
+                    with closing(engine.connect()):
+                        pass
+                    available=1
+                except:
+                    available=-1
+                table_count = datab.relate_tables.count()
+                datab_json = ModelVisitor.database_to_json(datab)
+                datab_json["table_count"] = table_count
+                datab_json["available"] = available
+                res["data"]["list"].append(datab_json)
+
+            # 可用非可用排序
+            sorted_list = [dat for dat in res["data"]["list"] if dat["available"]==1]
+            sorted_list.extend([dat for dat in res["data"]["list"] if dat["available"] == -1])
+            res["data"]["list"] = sorted_list
+            res["result"]=True
+        except Exception as e:
+            raise e
+        return res
+    
+    
+    
+    api_doc={
+    "tags":["数据库接口"],
+    "parameters":[
+        {"name": "page_index",
+         "in": "formData",
+         "type": "int",
+         "default": "0"},
+        {"name": "page_size",
+         "in": "formData",
+         "type": "int",
+         "default": "10"},
+        {"name": "alias",
+         "in": "formData",
+         "type": "string","description":"数据库别名"},
+        {"name": "guid",
+         "in": "formData",
+         "type": "string", "description": "数据库guid"}
+    ],
+    "responses":{
+        200:{
+            "schema":{
+                "properties":{
+                }
+            }
+            }
+        }
+    }

-# coding=utf-8
-#author:        4N
-#createtime:    2021/3/9
-#email:         nheweijun@sina.com
-import datetime
-from app.models import Database,db,DES,Table,Columns,TableVacuate
-# from app.util import get_db_session,get_info_from_sqlachemy_uri
-import uuid
-from . import database_test
-# from app.util import open_pg_data_source
-from osgeo.ogr import DataSource,Layer,FeatureDefn,FieldDefn,Feature
-from sqlalchemy.orm import Session
-from sqlalchemy import create_engine
-from sqlalchemy.orm import sessionmaker
-from app.util.component.ApiTemplate import ApiTemplate
-from app.util.component.PGUtil import PGUtil
-from app.util.component.GeometryAdapter import GeometryAdapter
-class Api(ApiTemplate):
-    api_name = "数据库注册"
-    def process(self):
-        res ={}
-        res["result"] = False
-        try:
-            host = self.para.get("host")
-            port = self.para.get("port")
-            user = self.para.get("user")
-            passwd = self.para.get("passwd")
-            database = self.para.get("database")
-            encryption = int(self.para.get("encryption","0"))
-            if encryption:
-                passwd = DES.decode(passwd)
-    
-            sqlalchemy_uri = "postgresql://{}:{}@{}:{}/{}".format(user,passwd,host,port,database)
-            connectsrt = "hostaddr={} port={} dbname='{}' user='{}' password='{}'".format(host,port,database,user,passwd)
-    
-            #测试连接
-            test = database_test.Api().result
-    
-            if not test["result"]:
-                return test
-    
-            #判断数据库是否存在
-            database = db.session.query(Database).filter_by(alias=self.para.get("alias")).one_or_none()
-    
-            #真实的数据库
-            real_database = db.session.query(Database).filter_by(connectstr=DES.encode(connectsrt)).all()
-    
-            if database:
-                res["msg"] = "数据库已存在,请修改别名！"
-                return res
-
-            elif real_database:
-                res["msg"] = "数据库连接已存在,请修改数据库连接！"
-                return res
-            elif not self.check_space(sqlalchemy_uri):
-                res["msg"] = "数据不是空间数据库！"
-                return res
-
-            else:
-                this_time = datetime.datetime.now()
-                database_guid = uuid.uuid1().__str__()
-    
-                db_tuple = PGUtil.get_info_from_sqlachemy_uri(sqlalchemy_uri)
-    
-                database = Database(guid= database_guid,
-                                    name = db_tuple[4],
-                                    alias=self.para.get("alias"),
-                                    sqlalchemy_uri=DES.encode(sqlalchemy_uri),
-                                    description=self.para.get("description"),
-                                    creator=self.para.get("creator"),
-                                    create_time=this_time,
-                                    update_time=this_time,
-                                    connectstr=DES.encode(connectsrt))
-                db.session.add(database)
-
-                # 将该库中的数据都注册进来
-                self.register_table(database)
-                db.session.commit()
-                res["msg"] = "注册成功！"
-                res["result"]=True
-                res["data"] = database_guid
-        except Exception as e:
-            db.session.rollback()
-            raise e
-        return res
-
-
-    def register_table(self,database):
-        this_time = datetime.datetime.now()
-        pg_ds: DataSource = PGUtil.open_pg_data_source(1, DES.decode(database.sqlalchemy_uri))
-
-        # 注册空间表
-        spatial_table_name,tables = self.register_spatial_table(pg_ds, database, this_time)
-
-        #注册抽稀表
-        self.regiser_vacuate_talbe(pg_ds,tables)
-
-        #注册普通表
-        self.register_common_table(this_time,database,spatial_table_name)
-
-        pg_ds.Destroy()
-
-
-    def register_spatial_table(self,pg_ds,database,this_time):
-        spatial_table_name =[]
-        tables=[]
-        for i in range(pg_ds.GetLayerCount()):
-            layer: Layer = pg_ds.GetLayer(i)
-            l_name = layer.GetName()
-            # 只注册public的空间表,其他表空间的表名会有.
-            if layer.GetName().__contains__("."):
-                continue
-
-            # 不注册抽稀表
-            if layer.GetName().__contains__("_vacuate_"):
-                spatial_table_name.append(layer.GetName())
-                continue
-
-            # 范围统计和数量统计以100w为界限
-            query_count_layer: Layer = pg_ds.ExecuteSQL(
-                "SELECT reltuples::bigint AS ec FROM pg_class WHERE  oid = 'public.{}'::regclass".format(l_name))
-            feature_count = query_count_layer.GetFeature(0).GetField("ec")
-            # 要素少于100w可以精确统计
-            if feature_count < 1000000:
-                feature_count = layer.GetFeatureCount()
-                ext = layer.GetExtent()
-            else:
-                query_ext_layer: Layer = pg_ds.ExecuteSQL(
-                    "select geometry(ST_EstimatedExtent('public', '{}','{}'))".format(l_name,
-                                                                                       layer.GetGeometryColumn()))
-                ext = query_ext_layer.GetExtent()
-            if ext[0] < 360:
-                ext = [round(e, 6) for e in ext]
-            else:
-                ext = [round(e, 2) for e in ext]
-            extent = "{},{},{},{}".format(ext[0], ext[1], ext[2], ext[3])
-
-            table_guid = uuid.uuid1().__str__()
-
-            table = Table(guid=table_guid,
-                          database_guid=database.guid,
-                          # alias=layer.GetName(),
-                          name=layer.GetName(), create_time=this_time, update_time=this_time,
-                          table_type=GeometryAdapter.get_table_type(layer.GetGeomType()),
-                          extent=extent,
-                          feature_count=feature_count
-                          )
-
-            db.session.add(table)
-            tables.append(table)
-
-            feature_defn: FeatureDefn = layer.GetLayerDefn()
-
-            for i in range(feature_defn.GetFieldCount()):
-                field_defn: FieldDefn = feature_defn.GetFieldDefn(i)
-                field_name = field_defn.GetName().lower()
-                field_alias = field_name if field_defn.GetAlternativeName() is None or field_defn.GetAlternativeName().__eq__(
-                    "") else field_defn.GetAlternativeName()
-                column = Columns(guid=uuid.uuid1().__str__(), table_guid=table_guid,
-                                 name=field_name, alias=field_alias, create_time=this_time, update_time=this_time)
-                db.session.add(column)
-
-            spatial_table_name.append(layer.GetName())
-        return spatial_table_name,tables
-
-
-    def register_common_table(self,this_time,database,spatial_table_name):
-        # 注册普通表
-        db_session: Session = PGUtil.get_db_session(DES.decode(database.sqlalchemy_uri))
-
-        # 只注册public中的表
-        result = db_session.execute(
-            "select relname as tabname from pg_class c where  relkind = 'r' and relnamespace=2200 and relname not like 'pg_%' and relname not like 'sql_%' order by relname").fetchall()
-        for re in result:
-            table_name = re[0]
-            if table_name not in spatial_table_name:
-
-                table_guid = uuid.uuid1().__str__()
-                count = db_session.execute('select count(*) from "{}"'.format(table_name)).fetchone()[0]
-
-                table = Table(guid=table_guid,
-                              database_guid=database.guid,
-                              # alias=layer.GetName(),
-                              name=table_name, create_time=this_time, update_time=this_time,
-                              table_type=0,
-                              feature_count=count
-                              )
-
-                db.session.add(table)
-
-                sql = '''
-                SELECT
-                    a.attnum,
-                    a.attname AS field
-                FROM
-                    pg_class c,
-                    pg_attribute a,
-                    pg_type t
-                WHERE
-                    c.relname = '{}'
-                    and a.attnum > 0
-                    and a.attrelid = c.oid
-                    and a.atttypid = t.oid
-                ORDER BY a.attnum 
-                '''.format(table_name)
-
-                cols = db_session.execute(sql).fetchall()
-                for col in cols:
-                    column = Columns(guid=uuid.uuid1().__str__(), table_guid=table_guid,
-                                     name=col[1], create_time=this_time, update_time=this_time)
-                    db.session.add(column)
-        db_session.close()
-
-    def regiser_vacuate_talbe(self,pg_ds,tables):
-
-        # 注册抽稀表
-        for i in range(pg_ds.GetLayerCount()):
-            layer:Layer = pg_ds.GetLayer(i)
-            l_name = layer.GetName()
-            if l_name.__contains__("_vacuate_"):
-                base_layer_name=l_name.split("_vacuate_")[0]
-                level = l_name.split("_")[-2]
-                pixel_distance_str: str ="0"
-                try:
-                    pixel_distance_str :str=  l_name.split("_")[-1]
-                    if pixel_distance_str.startswith("0"):
-                        pixel_distance_str="0.{}".format(pixel_distance_str)
-                except:
-                    pass
-                base_table = [table for table in tables if table.name.__eq__(base_layer_name)][0]
-                table_vacuate = TableVacuate(guid=uuid.uuid1().__str__(),
-                                             table_guid=base_table.guid,
-                                             level=level,
-                                             name=l_name,
-                                             pixel_distance=float(pixel_distance_str))
-                db.session.add(table_vacuate)
-
-
-    
-    def check_space(self,sqlachemy_uri):
-        system_session = None
-        check = True
-        try:
-            test_sql = "select st_geometryfromtext('POINT(1 1)')"
-            engine = create_engine(sqlachemy_uri)
-            system_session = sessionmaker(bind=engine)()
-            system_session.execute(test_sql).fetchone()
-
-        except:
-            check = False
-        finally:
-            if system_session:
-                system_session.close()
-    
-        return check
-    
-    api_doc={
-    "tags":["数据库接口"],
-    "parameters":[
-        {"name": "host",
-         "in": "formData",
-         "type": "string", "required": "true"},
-        {"name": "port",
-         "in": "formData",
-         "type": "string", "required": "true"},
-        {"name": "user",
-         "in": "formData",
-         "type": "string", "required": "true"},
-        {"name": "passwd",
-         "in": "formData",
-         "type": "string", "required": "true"},
-        {"name": "database",
-         "in": "formData",
-         "type": "string", "required": "true"},
-        {"name": "creator",
-         "in": "formData",
-         "type": "string", "required": "true"},
-    
-        {"name": "alias",
-         "in": "formData",
-         "type": "string","description":"数据库别名","required": "true"},
-
-        {"name": "encryption",
-         "in": "formData",
-         "type": "integer", "description": "密码是否加密", "enum": [0,1]},
-    ],
-    "responses":{
-        200:{
-            "schema":{
-                "properties":{
-                }
-            }
-            }
-        }
+# coding=utf-8
+#author:        4N
+#createtime:    2021/3/9
+#email:         nheweijun@sina.com
+import datetime
+from app.models import Database,db,DES,Table,Columns,TableVacuate
+# from app.util import get_db_session,get_info_from_sqlachemy_uri
+import uuid
+from . import database_test
+# from app.util import open_pg_data_source
+from osgeo.ogr import DataSource,Layer,FeatureDefn,FieldDefn,Feature
+from sqlalchemy.orm import Session
+from sqlalchemy import create_engine
+from sqlalchemy.orm import sessionmaker
+from app.util.component.ApiTemplate import ApiTemplate
+from app.util.component.PGUtil import PGUtil
+from app.util.component.GeometryAdapter import GeometryAdapter
+class Api(ApiTemplate):
+    api_name = "数据库注册"
+    def process(self):
+        res ={}
+        res["result"] = False
+        try:
+            host = self.para.get("host")
+            port = self.para.get("port")
+            user = self.para.get("user")
+            passwd = self.para.get("passwd")
+            database = self.para.get("database")
+            encryption = int(self.para.get("encryption","0"))
+            if encryption:
+                passwd = DES.decode(passwd)
+    
+            sqlalchemy_uri = "postgresql://{}:{}@{}:{}/{}".format(user,passwd,host,port,database)
+            connectsrt = "hostaddr={} port={} dbname='{}' user='{}' password='{}'".format(host,port,database,user,passwd)
+    
+            #测试连接
+            test = database_test.Api().result
+    
+            if not test["result"]:
+                return test
+    
+            #判断数据库是否存在
+            database = db.session.query(Database).filter_by(alias=self.para.get("alias")).one_or_none()
+    
+            #真实的数据库
+            real_database = db.session.query(Database).filter_by(connectstr=DES.encode(connectsrt)).all()
+    
+            if database:
+                res["msg"] = "数据库已存在,请修改别名！"
+                return res
+
+            elif real_database:
+                res["msg"] = "数据库连接已存在,请修改数据库连接！"
+                return res
+            elif not self.check_space(sqlalchemy_uri):
+                res["msg"] = "数据不是空间数据库！"
+                return res
+
+            else:
+                this_time = datetime.datetime.now()
+                database_guid = uuid.uuid1().__str__()
+    
+                db_tuple = PGUtil.get_info_from_sqlachemy_uri(sqlalchemy_uri)
+    
+                database = Database(guid= database_guid,
+                                    name = db_tuple[4],
+                                    alias=self.para.get("alias"),
+                                    sqlalchemy_uri=DES.encode(sqlalchemy_uri),
+                                    description=self.para.get("description"),
+                                    creator=self.para.get("creator"),
+                                    create_time=this_time,
+                                    update_time=this_time,
+                                    connectstr=DES.encode(connectsrt))
+                db.session.add(database)
+
+                # 将该库中的数据都注册进来
+                self.register_table(database)
+                db.session.commit()
+                res["msg"] = "注册成功！"
+                res["result"]=True
+                res["data"] = database_guid
+        except Exception as e:
+            db.session.rollback()
+            raise e
+        return res
+
+
+    def register_table(self,database):
+        this_time = datetime.datetime.now()
+        pg_ds: DataSource = PGUtil.open_pg_data_source(1, DES.decode(database.sqlalchemy_uri))
+
+        # 注册空间表
+        spatial_table_name,tables = self.register_spatial_table(pg_ds, database, this_time)
+
+        #注册抽稀表
+        self.regiser_vacuate_talbe(pg_ds,tables)
+
+        #注册普通表
+        self.register_common_table(this_time,database,spatial_table_name)
+
+        pg_ds.Destroy()
+
+
+    def register_spatial_table(self,pg_ds,database,this_time):
+        spatial_table_name =[]
+        tables=[]
+        for i in range(pg_ds.GetLayerCount()):
+            layer: Layer = pg_ds.GetLayer(i)
+            l_name = layer.GetName()
+            # 只注册public的空间表,其他表空间的表名会有.
+            if layer.GetName().__contains__("."):
+                continue
+
+            # 不注册抽稀表
+            if layer.GetName().__contains__("_vacuate_"):
+                spatial_table_name.append(layer.GetName())
+                continue
+
+            # 范围统计和数量统计以100w为界限
+            query_count_layer: Layer = pg_ds.ExecuteSQL(
+                "SELECT reltuples::bigint AS ec FROM pg_class WHERE  oid = 'public.{}'::regclass".format(l_name))
+            feature_count = query_count_layer.GetFeature(0).GetField("ec")
+            # 要素少于100w可以精确统计
+            if feature_count < 1000000:
+                feature_count = layer.GetFeatureCount()
+                ext = layer.GetExtent()
+            else:
+                query_ext_layer: Layer = pg_ds.ExecuteSQL(
+                    "select geometry(ST_EstimatedExtent('public', '{}','{}'))".format(l_name,
+                                                                                       layer.GetGeometryColumn()))
+                ext = query_ext_layer.GetExtent()
+            if ext[0] < 360:
+                ext = [round(e, 6) for e in ext]
+            else:
+                ext = [round(e, 2) for e in ext]
+            extent = "{},{},{},{}".format(ext[0], ext[1], ext[2], ext[3])
+
+            table_guid = uuid.uuid1().__str__()
+
+            table = Table(guid=table_guid,
+                          database_guid=database.guid,
+                          # alias=layer.GetName(),
+                          name=layer.GetName(), create_time=this_time, update_time=this_time,
+                          table_type=GeometryAdapter.get_table_type(layer.GetGeomType()),
+                          extent=extent,
+                          feature_count=feature_count
+                          )
+
+            db.session.add(table)
+            tables.append(table)
+
+            feature_defn: FeatureDefn = layer.GetLayerDefn()
+
+            for i in range(feature_defn.GetFieldCount()):
+                field_defn: FieldDefn = feature_defn.GetFieldDefn(i)
+                field_name = field_defn.GetName().lower()
+                field_alias = field_name if field_defn.GetAlternativeName() is None or field_defn.GetAlternativeName().__eq__(
+                    "") else field_defn.GetAlternativeName()
+                column = Columns(guid=uuid.uuid1().__str__(), table_guid=table_guid,
+                                 name=field_name, alias=field_alias, create_time=this_time, update_time=this_time)
+                db.session.add(column)
+
+            spatial_table_name.append(layer.GetName())
+        return spatial_table_name,tables
+
+
+    def register_common_table(self,this_time,database,spatial_table_name):
+        # 注册普通表
+        db_session: Session = PGUtil.get_db_session(DES.decode(database.sqlalchemy_uri))
+
+        # 只注册public中的表
+        result = db_session.execute(
+            "select relname as tabname from pg_class c where  relkind = 'r' and relnamespace=2200 and relname not like 'pg_%' and relname not like 'sql_%' order by relname").fetchall()
+        for re in result:
+            table_name = re[0]
+            if table_name not in spatial_table_name:
+
+                table_guid = uuid.uuid1().__str__()
+                count = db_session.execute('select count(*) from "{}"'.format(table_name)).fetchone()[0]
+
+                table = Table(guid=table_guid,
+                              database_guid=database.guid,
+                              # alias=layer.GetName(),
+                              name=table_name, create_time=this_time, update_time=this_time,
+                              table_type=0,
+                              feature_count=count
+                              )
+
+                db.session.add(table)
+
+                sql = '''
+                SELECT
+                    a.attnum,
+                    a.attname AS field
+                FROM
+                    pg_class c,
+                    pg_attribute a,
+                    pg_type t
+                WHERE
+                    c.relname = '{}'
+                    and a.attnum > 0
+                    and a.attrelid = c.oid
+                    and a.atttypid = t.oid
+                ORDER BY a.attnum 
+                '''.format(table_name)
+
+                cols = db_session.execute(sql).fetchall()
+                for col in cols:
+                    column = Columns(guid=uuid.uuid1().__str__(), table_guid=table_guid,
+                                     name=col[1], create_time=this_time, update_time=this_time)
+                    db.session.add(column)
+        db_session.close()
+
+    def regiser_vacuate_talbe(self,pg_ds,tables):
+
+        # 注册抽稀表
+        for i in range(pg_ds.GetLayerCount()):
+            layer:Layer = pg_ds.GetLayer(i)
+            l_name = layer.GetName()
+            if l_name.__contains__("_vacuate_"):
+                base_layer_name=l_name.split("_vacuate_")[0]
+                level = l_name.split("_")[-2]
+                pixel_distance_str: str ="0"
+                try:
+                    pixel_distance_str :str=  l_name.split("_")[-1]
+                    if pixel_distance_str.startswith("0"):
+                        pixel_distance_str="0.{}".format(pixel_distance_str)
+                except:
+                    pass
+                base_table = [table for table in tables if table.name.__eq__(base_layer_name)][0]
+                table_vacuate = TableVacuate(guid=uuid.uuid1().__str__(),
+                                             table_guid=base_table.guid,
+                                             level=level,
+                                             name=l_name,
+                                             pixel_distance=float(pixel_distance_str))
+
+                Table.query.filter_by(guid=base_table.guid).update({"is_vacuate": 1})
+                db.session.add(table_vacuate)
+
+
+    
+    def check_space(self,sqlachemy_uri):
+        system_session = None
+        check = True
+        try:
+            test_sql = "select st_geometryfromtext('POINT(1 1)')"
+            engine = create_engine(sqlachemy_uri)
+            system_session = sessionmaker(bind=engine)()
+            system_session.execute(test_sql).fetchone()
+
+        except:
+            check = False
+        finally:
+            if system_session:
+                system_session.close()
+    
+        return check
+    
+    api_doc={
+    "tags":["数据库接口"],
+    "parameters":[
+        {"name": "host",
+         "in": "formData",
+         "type": "string", "required": "true"},
+        {"name": "port",
+         "in": "formData",
+         "type": "string", "required": "true"},
+        {"name": "user",
+         "in": "formData",
+         "type": "string", "required": "true"},
+        {"name": "passwd",
+         "in": "formData",
+         "type": "string", "required": "true"},
+        {"name": "database",
+         "in": "formData",
+         "type": "string", "required": "true"},
+        {"name": "creator",
+         "in": "formData",
+         "type": "string", "required": "true"},
+    
+        {"name": "alias",
+         "in": "formData",
+         "type": "string","description":"数据库别名","required": "true"},
+
+        {"name": "encryption",
+         "in": "formData",
+         "type": "integer", "description": "密码是否加密", "enum": [0,1]},
+    ],
+    "responses":{
+        200:{
+            "schema":{
+                "properties":{
+                }
+            }
+            }
+        }
 }
 }

-# coding=utf-8
-# author:        4N
-# createtime:    2020/6/22
-# email:         nheweijun@sina.com
-from contextlib import closing
-
-from sqlalchemy import create_engine
-
-from app.models import DES,Database,db
-
-from sqlalchemy.orm import sessionmaker
-from app.util.component.ApiTemplate import ApiTemplate
-class Api(ApiTemplate):
-    api_name = "数据库连接测试"
-    def process(self):
-        res = {}
-        res["result"] = False
-        try:
-
-    
-            host = self.para.get("host")
-            port = self.para.get("port")
-            user = self.para.get("user")
-            passwd = self.para.get("passwd")
-            database = self.para.get("database")
-
-            encryption = int(self.para.get("encryption", "0"))
-            if encryption:
-                passwd = DES.decode(passwd)
-    
-    
-            sqlalchemy_uri = "postgresql://{}:{}@{}:{}/{}".format(user,passwd,host,port,database)
-    
-            # if is_encrypt == "1":
-            #     sqlalchemy_uri=DES.decode(sqlalchemy_uri)
-    
-            engine = create_engine(sqlalchemy_uri, connect_args={'connect_timeout': 2})
-            with closing(engine.connect()):
-                pass
-    
-    
-            #判断数据库是否存在
-            datab = db.session.query(Database).filter_by(alias=self.para.get("alias")).one_or_none()
-            #真实的数据库
-            connectsrt = "hostaddr={} port={} dbname='{}' user='{}' password='{}'".format(host, port, database, user,
-                                                                                          passwd)
-            real_database = db.session.query(Database).filter_by(connectstr=DES.encode(connectsrt)).all()
-    
-            if datab:
-                res["msg"] = "数据库已存在,请修改别名！"
-                return res
-
-            elif real_database:
-                res["msg"] = "数据库连接已存在,请修改数据库连接！"
-                return res
-
-            elif not self.check_space(sqlalchemy_uri):
-                res["msg"] = "数据不是空间数据库！"
-                return res
-            else:
-                res["result"] = True
-                res["msg"] = "测试连接成功"
-        except:
-            raise Exception("测试连接失败！")
-        return res
-    
-    
-    def check_space(self,sqlachemy_uri):
-        system_session = None
-        check = True
-        try:
-            test_sql = "select st_geometryfromtext('POINT(1 1)')"
-            engine = create_engine(sqlachemy_uri)
-            system_session = sessionmaker(bind=engine)()
-            system_session.execute(test_sql).fetchone()
-        except:
-            check = False
-        finally:
-            if system_session:
-                system_session.close()
-    
-        return check
-    
-    api_doc={
-    "tags":["数据库接口"],
-    "parameters":[
-        # {"name": "sqlalchemy_uri",
-        #  "in": "formData",
-        #  "type": "string","description":"数据库uri","required": "true"},
-        {"name": "host",
-         "in": "formData",
-         "type": "string", "required": "true"},
-        {"name": "port",
-         "in": "formData",
-         "type": "string", "required": "true"},
-        {"name": "user",
-         "in": "formData",
-         "type": "string", "required": "true"},
-        {"name": "passwd",
-         "in": "formData",
-         "type": "string", "required": "true"},
-        {"name": "database",
-         "in": "formData",
-         "type": "string", "required": "true"},
-        # {"name": "alias",
-        #  "in": "formData",
-        #  "type": "string", "required": "true"},
-        {"name": "encryption",
-         "in": "formData",
-         "type": "int", "description": "密码是否加密", "enum": [0, 1]},
-
-    ],
-    "responses":{
-        200:{
-            "schema":{
-                "properties":{
-                }
-            }
-            }
-        }
+# coding=utf-8
+# author:        4N
+# createtime:    2020/6/22
+# email:         nheweijun@sina.com
+from contextlib import closing
+
+from sqlalchemy import create_engine
+
+from app.models import DES,Database,db
+
+from sqlalchemy.orm import sessionmaker
+from app.util.component.ApiTemplate import ApiTemplate
+class Api(ApiTemplate):
+    api_name = "数据库连接测试"
+    def process(self):
+        res = {}
+        res["result"] = False
+        try:
+
+    
+            host = self.para.get("host")
+            port = self.para.get("port")
+            user = self.para.get("user")
+            passwd = self.para.get("passwd")
+            database = self.para.get("database")
+
+            encryption = int(self.para.get("encryption", "0"))
+            if encryption:
+                passwd = DES.decode(passwd)
+    
+    
+            sqlalchemy_uri = "postgresql://{}:{}@{}:{}/{}".format(user,passwd,host,port,database)
+    
+            # if is_encrypt == "1":
+            #     sqlalchemy_uri=DES.decode(sqlalchemy_uri)
+    
+            engine = create_engine(sqlalchemy_uri, connect_args={'connect_timeout': 2})
+            with closing(engine.connect()):
+                pass
+    
+    
+            #判断数据库是否存在
+            datab = db.session.query(Database).filter_by(alias=self.para.get("alias")).one_or_none()
+            #真实的数据库
+            connectsrt = "hostaddr={} port={} dbname='{}' user='{}' password='{}'".format(host, port, database, user,
+                                                                                          passwd)
+            real_database = db.session.query(Database).filter_by(connectstr=DES.encode(connectsrt)).all()
+    
+            if datab:
+                res["msg"] = "数据库已存在,请修改别名！"
+                return res
+
+            elif real_database:
+                res["msg"] = "数据库连接已存在,请修改数据库连接！"
+                return res
+
+            elif not self.check_space(sqlalchemy_uri):
+                res["msg"] = "数据不是空间数据库！"
+                return res
+            else:
+                res["result"] = True
+                res["msg"] = "测试连接成功"
+        except:
+            raise Exception("测试连接失败！")
+        return res
+    
+    
+    def check_space(self,sqlachemy_uri):
+        system_session = None
+        check = True
+        try:
+            test_sql = "select st_geometryfromtext('POINT(1 1)')"
+            engine = create_engine(sqlachemy_uri)
+            system_session = sessionmaker(bind=engine)()
+            system_session.execute(test_sql).fetchone()
+        except:
+            check = False
+        finally:
+            if system_session:
+                system_session.close()
+    
+        return check
+    
+    api_doc={
+    "tags":["数据库接口"],
+    "parameters":[
+        # {"name": "sqlalchemy_uri",
+        #  "in": "formData",
+        #  "type": "string","description":"数据库uri","required": "true"},
+        {"name": "host",
+         "in": "formData",
+         "type": "string", "required": "true"},
+        {"name": "port",
+         "in": "formData",
+         "type": "string", "required": "true"},
+        {"name": "user",
+         "in": "formData",
+         "type": "string", "required": "true"},
+        {"name": "passwd",
+         "in": "formData",
+         "type": "string", "required": "true"},
+        {"name": "database",
+         "in": "formData",
+         "type": "string", "required": "true"},
+        # {"name": "alias",
+        #  "in": "formData",
+        #  "type": "string", "required": "true"},
+        {"name": "encryption",
+         "in": "formData",
+         "type": "int", "description": "密码是否加密", "enum": [0, 1]},
+
+    ],
+    "responses":{
+        200:{
+            "schema":{
+                "properties":{
+                }
+            }
+            }
+        }
 }
 }

-# coding=utf-8
-#author:        4N
-#createtime:    2021/2/23
-#email:         nheweijun@sina.com
-
-from flask import Blueprint
-from app.util import BlueprintApi
-from flasgger import swag_from
-from . import index
-from . import release
-from . import get_app_name
-class Template(BlueprintApi):
-
-    bp = Blueprint("Index", __name__, url_prefix="/")
-
-    @staticmethod
-    @bp.route('/', methods=['GET'])
-    @swag_from(index.Api.api_doc)
-    def api_index():
-        """
-        Index接口
-        """
-        return index.Api().result
-
-    @staticmethod
-    @bp.route('/release', methods=['GET'])
-    @swag_from(release.Api.api_doc)
-    def release():
-        """
-        release接口
-        """
-        return release.Api().result
-
-    @staticmethod
-    @bp.route('/GetAppName', methods=['GET'])
-    @swag_from(get_app_name.Api.api_doc)
-    def get_app_name():
-        """
-        GetAppName接口
-        """
+# coding=utf-8
+#author:        4N
+#createtime:    2021/2/23
+#email:         nheweijun@sina.com
+
+from flask import Blueprint
+from app.util import BlueprintApi
+from flasgger import swag_from
+from . import index
+from . import release
+from . import get_app_name
+class Template(BlueprintApi):
+
+    bp = Blueprint("Index", __name__, url_prefix="/")
+
+    @staticmethod
+    @bp.route('/', methods=['GET'])
+    @swag_from(index.Api.api_doc)
+    def api_index():
+        """
+        Index接口
+        """
+        return index.Api().result
+
+    @staticmethod
+    @bp.route('/release', methods=['GET'])
+    @swag_from(release.Api.api_doc)
+    def release():
+        """
+        release接口
+        """
+        return release.Api().result
+
+    @staticmethod
+    @bp.route('/GetAppName', methods=['GET'])
+    @swag_from(get_app_name.Api.api_doc)
+    def get_app_name():
+        """
+        GetAppName接口
+        """
         return get_app_name.Api().result
         return get_app_name.Api().result

-# coding=utf-8
-#author:        4N
-#createtime:    2021/7/20
-#email:         nheweijun@sina.com
-
-import hashlib
-from flask import current_app as app
-import socket
-import configure
-
-from app.util.component.ApiTemplate import ApiTemplate
-class Api(ApiTemplate):
-
-    def process(self):
-        return configure.application_name
-
-    api_doc={
-    "tags":["Index接口"],
-    "description":"Index接口",
-    "parameters":[
-    ],
-    "responses":{
-        200:{
-            "schema":{
-                "properties":{
-                    "content":{
-                        "type": "string",
-                        "description": "The name of the user"
-                    }
-                }
-            }
-            }
-        }
+# coding=utf-8
+#author:        4N
+#createtime:    2021/7/20
+#email:         nheweijun@sina.com
+
+import hashlib
+from flask import current_app as app
+import socket
+import configure
+
+from app.util.component.ApiTemplate import ApiTemplate
+class Api(ApiTemplate):
+
+    def process(self):
+        return configure.application_name
+
+    api_doc={
+    "tags":["Index接口"],
+    "description":"Index接口",
+    "parameters":[
+    ],
+    "responses":{
+        200:{
+            "schema":{
+                "properties":{
+                    "content":{
+                        "type": "string",
+                        "description": "The name of the user"
+                    }
+                }
+            }
+            }
+        }
     }
     }

-# coding=utf-8
-#author:        4N
-#createtime:    2021/2/23
-#email:         nheweijun@sina.com
-import hashlib
-from flask import current_app as app
-import socket
-
-from app.util.component.ApiTemplate import ApiTemplate
-class Api(ApiTemplate):
-
-    def process(self):
-        return {"Name":socket.gethostname(),"Type":"DMapDMS"}
-
-    api_doc={
-    "tags":["Index接口"],
-    "description":"Index接口",
-    "parameters":[
-    ],
-    "responses":{
-        200:{
-            "schema":{
-                "properties":{
-                    "content":{
-                        "type": "string",
-                        "description": "The name of the user"
-                    }
-                }
-            }
-            }
-        }
+# coding=utf-8
+#author:        4N
+#createtime:    2021/2/23
+#email:         nheweijun@sina.com
+import hashlib
+from flask import current_app as app
+import socket
+
+from app.util.component.ApiTemplate import ApiTemplate
+class Api(ApiTemplate):
+
+    def process(self):
+        return {"Name":socket.gethostname(),"Type":"DMapDMS"}
+
+    api_doc={
+    "tags":["Index接口"],
+    "description":"Index接口",
+    "parameters":[
+    ],
+    "responses":{
+        200:{
+            "schema":{
+                "properties":{
+                    "content":{
+                        "type": "string",
+                        "description": "The name of the user"
+                    }
+                }
+            }
+            }
+        }
     }
     }

-# coding=utf-8
-#author:        4N
-#createtime:    2021/2/23
-#email:         nheweijun@sina.com
-import hashlib
-from flask import current_app as app
-import socket
-
-from app.util.component.ApiTemplate import ApiTemplate
-from app.models import Task,InsertingLayerName,db
-import datetime
-import traceback
-from sqlalchemy import or_
-class Api(ApiTemplate):
-
-    def process(self):
-        try:
-            # 遗留任务变成失败
-            last_tasks = db.session.query(Task).filter(or_(Task.state == 0, Task.state == 2))
-            last_tasks.update({"state": -1,"process":"入库失败","update_time":datetime.datetime.now()})
-            last_lins = db.session.query(InsertingLayerName).all()
-            if last_lins:
-                for lin in last_lins:
-                    db.session.delete(lin)
-            db.session.commit()
-        except Exception as e:
-            # print(e)
-            print(traceback.format_exc())
-
-        return {"state": 1}
-
-    api_doc={
-    "tags":["Index接口"],
-    "description":"Index接口",
-    "parameters":[
-    ],
-    "responses":{
-        200:{
-            "schema":{
-                "properties":{
-                    "content":{
-                        "type": "string",
-                        "description": "The name of the user"
-                    }
-                }
-            }
-            }
-        }
+# coding=utf-8
+#author:        4N
+#createtime:    2021/2/23
+#email:         nheweijun@sina.com
+import hashlib
+from flask import current_app as app
+import socket
+
+from app.util.component.ApiTemplate import ApiTemplate
+from app.models import Task,InsertingLayerName,db
+import datetime
+import traceback
+from sqlalchemy import or_
+class Api(ApiTemplate):
+
+    def process(self):
+        try:
+            # 遗留任务变成失败
+            last_tasks = db.session.query(Task).filter(or_(Task.state == 0, Task.state == 2))
+            last_tasks.update({"state": -1,"process":"入库失败","update_time":datetime.datetime.now()})
+            last_lins = db.session.query(InsertingLayerName).all()
+            if last_lins:
+                for lin in last_lins:
+                    db.session.delete(lin)
+            db.session.commit()
+        except Exception as e:
+            # print(e)
+            print(traceback.format_exc())
+
+        return {"state": 1}
+
+    api_doc={
+    "tags":["Index接口"],
+    "description":"Index接口",
+    "parameters":[
+    ],
+    "responses":{
+        200:{
+            "schema":{
+                "properties":{
+                    "content":{
+                        "type": "string",
+                        "description": "The name of the user"
+                    }
+                }
+            }
+            }
+        }
     }
     }

-# coding=utf-8
-#author:        4N
-#createtime:    2020/12/8
-#email:         nheweijun@sina.com
-from flasgger import swag_from
-from flask import Blueprint
-from app.util import BlueprintApi
-
-from flask import send_from_directory,current_app,send_file
-import os
-import shutil
-from . import data_download
-from . import get_meta
-from . import data_entry_by_meta
-from . import get_data_list
-from flask import after_this_request
-import time
-
-class DataManager(BlueprintApi):
-
-    bp:Blueprint = Blueprint("DataTool", __name__, url_prefix="/API/IO")
-
-
-    @staticmethod
-    @bp.route('/Download/<file>', methods=['GET'])
-    def table_download_file(file):
-        parent = os.path.dirname(os.path.dirname(os.path.realpath(__file__)))
-        dirpath = os.path.join(parent,"file_tmp")
-
-        # @staticmethod
-        # @after_this_request
-        # def delete(response):
-        #     try:
-        #         os.remove(os.path.join(dirpath,file))
-        #         # shutil.rmtree(dirpath)
-        #         print("删除文件成功！")
-        #     except Exception as e:
-        #         print(e)
-        #         print("删除文件失败！")
-        #     return response
-
-        return send_from_directory(dirpath, filename=file, as_attachment=True)
-
-    @staticmethod
-    @bp.route('/DeleteFile/<file>', methods=['GET'])
-    def d_file(file):
-        parent = os.path.dirname(os.path.dirname(os.path.realpath(__file__)))
-        dirpath = os.path.join(parent, "file_tmp")
-
-        result={}
-        try:
-            os.remove(os.path.join(dirpath, file))
-            # shutil.rmtree(dirpath)
-            result["message"]="删除文件成功！"
-        except Exception as e:
-            print(e)
-            result["message"] ="删除文件失败！"
-        return result
-
-    @staticmethod
-    @bp.route('/DataDownload', methods=['POST'])
-    @swag_from(data_download.Api.api_doc)
-    def table_download():
-        """
-        下载数据
-        """
-        return data_download.Api().result
-
-
-    @staticmethod
-    @bp.route('/GetMeta', methods=['POST'])
-    @swag_from(get_meta.Api.api_doc)
-    def get_meta():
-        """
-        数据Meta
-        """
-        return get_meta.Api().result
-
-    @staticmethod
-    @bp.route('/GetDataList', methods=['POST'])
-    @swag_from(get_data_list.Api.api_doc)
-    def get_data_list():
-        """
-        本地数据list
-        """
-        return get_data_list.Api().result
-
-    @staticmethod
-    @bp.route('/DataEntryByMeta', methods=['POST'])
-    @swag_from(data_entry_by_meta.Api.api_doc)
-    def data_entry_by_meta():
-        """
-        数据入库ByMeta
-        """
+# coding=utf-8
+#author:        4N
+#createtime:    2020/12/8
+#email:         nheweijun@sina.com
+from flasgger import swag_from
+from flask import Blueprint
+from app.util import BlueprintApi
+
+from flask import send_from_directory,current_app,send_file
+import os
+import shutil
+from . import data_download
+from . import get_meta
+from . import data_entry_by_meta
+from . import get_data_list
+from flask import after_this_request
+import time
+
+class DataManager(BlueprintApi):
+
+    bp:Blueprint = Blueprint("DataTool", __name__, url_prefix="/API/IO")
+
+
+    @staticmethod
+    @bp.route('/Download/<file>', methods=['GET'])
+    def table_download_file(file):
+        parent = os.path.dirname(os.path.dirname(os.path.realpath(__file__)))
+        dirpath = os.path.join(parent,"file_tmp")
+
+        # @staticmethod
+        # @after_this_request
+        # def delete(response):
+        #     try:
+        #         os.remove(os.path.join(dirpath,file))
+        #         # shutil.rmtree(dirpath)
+        #         print("删除文件成功！")
+        #     except Exception as e:
+        #         print(e)
+        #         print("删除文件失败！")
+        #     return response
+
+        return send_from_directory(dirpath, filename=file, as_attachment=True)
+
+    @staticmethod
+    @bp.route('/DeleteFile/<file>', methods=['GET'])
+    def d_file(file):
+        parent = os.path.dirname(os.path.dirname(os.path.realpath(__file__)))
+        dirpath = os.path.join(parent, "file_tmp")
+
+        result={}
+        try:
+            os.remove(os.path.join(dirpath, file))
+            # shutil.rmtree(dirpath)
+            result["message"]="删除文件成功！"
+        except Exception as e:
+            print(e)
+            result["message"] ="删除文件失败！"
+        return result
+
+    @staticmethod
+    @bp.route('/DataDownload', methods=['POST'])
+    @swag_from(data_download.Api.api_doc)
+    def table_download():
+        """
+        下载数据
+        """
+        return data_download.Api().result
+
+
+    @staticmethod
+    @bp.route('/GetMeta', methods=['POST'])
+    @swag_from(get_meta.Api.api_doc)
+    def get_meta():
+        """
+        数据Meta
+        """
+        return get_meta.Api().result
+
+    @staticmethod
+    @bp.route('/GetDataList', methods=['POST'])
+    @swag_from(get_data_list.Api.api_doc)
+    def get_data_list():
+        """
+        本地数据list
+        """
+        return get_data_list.Api().result
+
+    @staticmethod
+    @bp.route('/DataEntryByMeta', methods=['POST'])
+    @swag_from(data_entry_by_meta.Api.api_doc)
+    def data_entry_by_meta():
+        """
+        数据入库ByMeta
+        """
         return data_entry_by_meta.Api().result
         return data_entry_by_meta.Api().result

-# coding=utf-8
-# author:        4N
-# createtime:    2021/1/27
-# email:         nheweijun@sina.com
-
-from osgeo.ogr import *
-import uuid
-
-import time
-from app.models import *
-import json
-import re
-from app.util.component.ApiTemplate import ApiTemplate
-from app.util.component.PGUtil import PGUtil
-
-
-class Api(ApiTemplate):
-    api_name = "检查meta"
-    def process(self):
-
-        # 设置任务信息
-        self.para["task_guid"] = uuid.uuid1().__str__()
-        self.para["task_time"] = time.time()
-
-        # 返回结果
-        res = {}
-
-        try:
-
-
-            # 图层重名检查
-
-            meta_list: list = json.loads(self.para.get("meta").__str__())
-            check_meta_only = int(self.para.get("check_meta_only", 0))
-
-            res["data"] = {}
-
-
-            database = Database.query.filter_by(guid=self.para.get("database_guid")).one_or_none()
-            if not database:
-                raise Exception("数据库不存在！")
-            pg_ds: DataSource = PGUtil.open_pg_data_source(1, DES.decode(database.sqlalchemy_uri))
-
-            res["result"] = True
-
-            for meta in meta_list:
-                layers: dict = meta.get("layer")
-                for layer_name_origin in layers.keys():
-                    layer_name = layers.get(layer_name_origin)
-                    if pg_ds.GetLayerByName(layer_name) or InsertingLayerName.query.filter_by(
-                            name=layer_name).one_or_none():
-                        res["data"][layer_name_origin] = 0
-                        res["result"] = False
-                    # 判断特殊字符
-                    elif re.search(r"\W", layer_name):
-                        res["data"][layer_name_origin] = -1
-                        res["result"] = False
-                    else:
-                        res["data"][layer_name_origin] = 1
-                if pg_ds:
-                    try:
-                        pg_ds.Destroy()
-                    except:
-                        print("关闭数据库失败！")
-
-        except Exception as e:
-            raise e
-
-        return res
-
-    api_doc = {
-        "tags": ["IO接口"],
-        "parameters": [
-            {"name": "meta",
-             "in": "formData",
-             "type": "string",
-             "description": "数据meta"}
-        ],
-        "responses": {
-            200: {
-                "schema": {
-                    "properties": {
-                    }
-                }
-            }
-        }
+# coding=utf-8
+# author:        4N
+# createtime:    2021/1/27
+# email:         nheweijun@sina.com
+
+from osgeo.ogr import *
+import uuid
+
+import time
+from app.models import *
+import json
+import re
+from app.util.component.ApiTemplate import ApiTemplate
+from app.util.component.PGUtil import PGUtil
+
+
+class Api(ApiTemplate):
+    api_name = "检查meta"
+    def process(self):
+
+        # 设置任务信息
+        self.para["task_guid"] = uuid.uuid1().__str__()
+        self.para["task_time"] = time.time()
+
+        # 返回结果
+        res = {}
+
+        try:
+
+
+            # 图层重名检查
+
+            meta_list: list = json.loads(self.para.get("meta").__str__())
+            check_meta_only = int(self.para.get("check_meta_only", 0))
+
+            res["data"] = {}
+
+
+            database = Database.query.filter_by(guid=self.para.get("database_guid")).one_or_none()
+            if not database:
+                raise Exception("数据库不存在！")
+            pg_ds: DataSource = PGUtil.open_pg_data_source(1, DES.decode(database.sqlalchemy_uri))
+
+            res["result"] = True
+
+            for meta in meta_list:
+                layers: dict = meta.get("layer")
+                for layer_name_origin in layers.keys():
+                    layer_name = layers.get(layer_name_origin)
+                    if pg_ds.GetLayerByName(layer_name) or InsertingLayerName.query.filter_by(
+                            name=layer_name).one_or_none():
+                        res["data"][layer_name_origin] = 0
+                        res["result"] = False
+                    # 判断特殊字符
+                    elif re.search(r"\W", layer_name):
+                        res["data"][layer_name_origin] = -1
+                        res["result"] = False
+                    else:
+                        res["data"][layer_name_origin] = 1
+                if pg_ds:
+                    try:
+                        pg_ds.Destroy()
+                    except:
+                        print("关闭数据库失败！")
+
+        except Exception as e:
+            raise e
+
+        return res
+
+    api_doc = {
+        "tags": ["IO接口"],
+        "parameters": [
+            {"name": "meta",
+             "in": "formData",
+             "type": "string",
+             "description": "数据meta"}
+        ],
+        "responses": {
+            200: {
+                "schema": {
+                    "properties": {
+                    }
+                }
+            }
+        }
     }
     }

-# coding=utf-8
-#author:        4N
-#createtime:    2020/11/27
-#email:         nheweijun@sina.com
-
-
-from app.models import *
-
-import traceback
-
-from osgeo.ogr import DataSource,Layer,FeatureDefn,FieldDefn
-from osgeo import gdal ,ogr
-import os
-import uuid
-import configure
-from app.util.component.ApiTemplate import ApiTemplate
-from app.util.component.PGUtil import PGUtil
-from app.util.component.ZipUtil import ZipUtil
-class Api(ApiTemplate):
-
-    api_name = "下载数据"
-    def process(self):
-        #获取参数
-    
-        #返回结果
-        res={}
-        #设置编码
-        encoding = self.para.get("encoding")
-        if encoding:
-            gdal.SetConfigOption("SHAPE_ENCODING",encoding)
-        else:
-            gdal.SetConfigOption("SHAPE_ENCODING", "GBK")
-    
-        ds:DataSource = None
-        try:
-            table_names = self.para.get("table_name").split(",")
-            database_guid = self.para.get("database_guid")
-            database = Database.query.filter_by(guid=database_guid).one_or_none()
-            if not database:
-                raise Exception("数据库不存在！")
-    
-            ds:DataSource = PGUtil.open_pg_data_source(0,DES.decode(database.sqlalchemy_uri))
-    
-            download_type = self.para.get("download_type")
-    
-            data = None
-            if download_type.__eq__("shp"):
-                data = self.download_shp(table_names,ds)
-            if download_type.__eq__("gdb"):
-                data = self.download_gdb(table_names, ds,database_guid)
-    
-            res["data"] = data
-            res["result"] = True
-        except Exception as e:
-            print(traceback.format_exc())
-            res["msg"]= e.__str__()
-            res["result"]=False
-        finally:
-            if ds:
-                ds.Destroy()
-        return res
-    
-    
-    def download_shp(self,table_names,ds):
-        data = []
-        for table_name in table_names:
-            url = self.download_one(ds, table_name)
-            data.append({"name": table_name, "download_url": url})
-        return data
-    
-    def download_one(self,ds,table_name):
-    
-        layer: Layer = ds.GetLayerByName(table_name)
-        driver = ogr.GetDriverByName("ESRI Shapefile")
-        uuid_ = uuid.uuid1().__str__()
-        parent = os.path.dirname(os.path.dirname(os.path.realpath(__file__)))
-        dirpath = os.path.join(parent, "file_tmp", uuid_)
-        os.makedirs(dirpath)
-        data_source: DataSource = driver.CreateDataSource(dirpath + "/{}.shp".format(table_name))
-        data_source.CopyLayer(layer, table_name)
-        data_source.Destroy()
-        ZipUtil.create_zip(os.path.join(parent, "file_tmp", table_name+"_"+uuid_) + ".zip", [dirpath])
-        return "http://" + configure.deploy_ip_host + "/API/IO/Download/{}".format(table_name+"_"+uuid_ + ".zip")
-    
-    
-    def download_gdb(self,table_names,ds,database_guid):
-        ogr.RegisterAll()
-        data = []
-        gdal.UseExceptions()
-        gdal.SetConfigOption("GDAL_FILENAME_IS_UTF8", "YES")
-    
-        # 创建一个gdb datasource
-        gdb_driver = ogr.GetDriverByName('FileGDB')
-        uuid_ = uuid.uuid1().__str__()
-        parent = os.path.dirname(os.path.dirname(os.path.realpath(__file__)))
-        gdb_path = os.path.join(parent, "file_tmp", uuid_+".gdb")
-        gdb_ds: DataSource = gdb_driver.CreateDataSource(gdb_path)
-    
-    
-        for table_name in table_names:
-    
-            layer: Layer = ds.GetLayerByName(table_name)
-            table = Table.query.filter_by(name=table_name, database_guid=database_guid).one_or_none()
-            feature_defn: FeatureDefn = layer.GetLayerDefn()
-    
-            for i in range(feature_defn.GetFieldCount()):
-                field_defn:FieldDefn = feature_defn.GetFieldDefn(i)
-                field_alias = Columns.query.filter_by(table_guid=table.guid,name=field_defn.GetName()).one_or_none().alias
-                field_defn.SetAlternativeName(field_alias)
-    
-            table_alias= table.alias
-    
-            # if is_chinese(table_name):
-            #     if not table_alias:
-            #         table_alias = table_name
-            #     table_name = "table{}".format(table_name.__hash__())
-    
-            gdb_ds.CopyLayer(layer, table_name,["LAYER_ALIAS={}".format(table_alias)])
-    
-        gdb_ds.Destroy()
-        ZipUtil.create_zip(gdb_path + ".zip", [gdb_path])
-        data.append({"name": ",".join(table_names), "download_url": "http://" + configure.deploy_ip_host + "/API/IO/Download/{}".format(uuid_+".gdb" + ".zip")})
-    
-    
-        return data
-    
-    
-    
-    api_doc={
-    "tags":["IO接口"],
-    "description":"下载数据",
-    "parameters":[
-        {"name": "table_name",
-         "in": "formData",
-         "type":"string","description":"支持多图层下载，以逗号相隔","required":"true"},
-        {"name": "encoding",
-         "in": "formData",
-         "type": "string",
-         "enum":["GBK","UTF-8"]},
-        {"name": "download_type",
-        "in": "formData",
-        "type": "string",
-        "enum": ["shp", "gdb"],"required":"true"
-        },
-        {"name": "database_guid",
-         "in": "formData",
-         "type": "string","required":"true"
-         }
-    ],
-    "responses":{
-        200:{
-            "schema":{
-                "properties":{
-                    "content":{
-                        "type": "string",
-                        "description": "The name of the user"
-                    }
-                }
-            }
-            }
-        }
+# coding=utf-8
+#author:        4N
+#createtime:    2020/11/27
+#email:         nheweijun@sina.com
+
+
+from app.models import *
+
+import traceback
+
+from osgeo.ogr import DataSource,Layer,FeatureDefn,FieldDefn
+from osgeo import gdal ,ogr
+import os
+import uuid
+import configure
+from app.util.component.ApiTemplate import ApiTemplate
+from app.util.component.PGUtil import PGUtil
+from app.util.component.ZipUtil import ZipUtil
+class Api(ApiTemplate):
+
+    api_name = "下载数据"
+    def process(self):
+        #获取参数
+    
+        #返回结果
+        res={}
+        #设置编码
+        encoding = self.para.get("encoding")
+        if encoding:
+            gdal.SetConfigOption("SHAPE_ENCODING",encoding)
+        else:
+            gdal.SetConfigOption("SHAPE_ENCODING", "GBK")
+    
+        ds:DataSource = None
+        try:
+            table_names = self.para.get("table_name").split(",")
+            database_guid = self.para.get("database_guid")
+            database = Database.query.filter_by(guid=database_guid).one_or_none()
+            if not database:
+                raise Exception("数据库不存在！")
+    
+            ds:DataSource = PGUtil.open_pg_data_source(0,DES.decode(database.sqlalchemy_uri))
+    
+            download_type = self.para.get("download_type")
+    
+            data = None
+            if download_type.__eq__("shp"):
+                data = self.download_shp(table_names,ds)
+            if download_type.__eq__("gdb"):
+                data = self.download_gdb(table_names, ds,database_guid)
+    
+            res["data"] = data
+            res["result"] = True
+        except Exception as e:
+            print(traceback.format_exc())
+            res["msg"]= e.__str__()
+            res["result"]=False
+        finally:
+            if ds:
+                ds.Destroy()
+        return res
+    
+    
+    def download_shp(self,table_names,ds):
+        data = []
+        for table_name in table_names:
+            url = self.download_one(ds, table_name)
+            data.append({"name": table_name, "download_url": url})
+        return data
+    
+    def download_one(self,ds,table_name):
+    
+        layer: Layer = ds.GetLayerByName(table_name)
+        driver = ogr.GetDriverByName("ESRI Shapefile")
+        uuid_ = uuid.uuid1().__str__()
+        parent = os.path.dirname(os.path.dirname(os.path.realpath(__file__)))
+        dirpath = os.path.join(parent, "file_tmp", uuid_)
+        os.makedirs(dirpath)
+        data_source: DataSource = driver.CreateDataSource(dirpath + "/{}.shp".format(table_name))
+        data_source.CopyLayer(layer, table_name)
+        data_source.Destroy()
+        ZipUtil.create_zip(os.path.join(parent, "file_tmp", table_name+"_"+uuid_) + ".zip", [dirpath])
+        return "http://" + configure.deploy_ip_host + "/API/IO/Download/{}".format(table_name+"_"+uuid_ + ".zip")
+    
+    
+    def download_gdb(self,table_names,ds,database_guid):
+        ogr.RegisterAll()
+        data = []
+        gdal.UseExceptions()
+        gdal.SetConfigOption("GDAL_FILENAME_IS_UTF8", "YES")
+    
+        # 创建一个gdb datasource
+        gdb_driver = ogr.GetDriverByName('FileGDB')
+        uuid_ = uuid.uuid1().__str__()
+        parent = os.path.dirname(os.path.dirname(os.path.realpath(__file__)))
+        gdb_path = os.path.join(parent, "file_tmp", uuid_+".gdb")
+        gdb_ds: DataSource = gdb_driver.CreateDataSource(gdb_path)
+    
+    
+        for table_name in table_names:
+    
+            layer: Layer = ds.GetLayerByName(table_name)
+            table = Table.query.filter_by(name=table_name, database_guid=database_guid).one_or_none()
+            feature_defn: FeatureDefn = layer.GetLayerDefn()
+    
+            for i in range(feature_defn.GetFieldCount()):
+                field_defn:FieldDefn = feature_defn.GetFieldDefn(i)
+                field_alias = Columns.query.filter_by(table_guid=table.guid,name=field_defn.GetName()).one_or_none().alias
+                field_defn.SetAlternativeName(field_alias)
+    
+            table_alias= table.alias
+    
+            # if is_chinese(table_name):
+            #     if not table_alias:
+            #         table_alias = table_name
+            #     table_name = "table{}".format(table_name.__hash__())
+    
+            gdb_ds.CopyLayer(layer, table_name,["LAYER_ALIAS={}".format(table_alias)])
+    
+        gdb_ds.Destroy()
+        ZipUtil.create_zip(gdb_path + ".zip", [gdb_path])
+        data.append({"name": ",".join(table_names), "download_url": "http://" + configure.deploy_ip_host + "/API/IO/Download/{}".format(uuid_+".gdb" + ".zip")})
+    
+    
+        return data
+    
+    
+    
+    api_doc={
+    "tags":["IO接口"],
+    "description":"下载数据",
+    "parameters":[
+        {"name": "table_name",
+         "in": "formData",
+         "type":"string","description":"支持多图层下载，以逗号相隔","required":"true"},
+        {"name": "encoding",
+         "in": "formData",
+         "type": "string",
+         "enum":["GBK","UTF-8"]},
+        {"name": "download_type",
+        "in": "formData",
+        "type": "string",
+        "enum": ["shp", "gdb"],"required":"true"
+        },
+        {"name": "database_guid",
+         "in": "formData",
+         "type": "string","required":"true"
+         }
+    ],
+    "responses":{
+        200:{
+            "schema":{
+                "properties":{
+                    "content":{
+                        "type": "string",
+                        "description": "The name of the user"
+                    }
+                }
+            }
+            }
+        }
 }
 }

-# coding=utf-8
-#author:        4N
-#createtime:    2021/1/27
-#email:         nheweijun@sina.com
-
-from osgeo.ogr import *
-import uuid
-
-import time
-from app.models import *
-import json
-import re
-from app.util.component.ApiTemplate import ApiTemplate
-from app.util.component.PGUtil import PGUtil
-
-
-
-class Api(ApiTemplate):
-
-    api_name = "通过meta入库"
-
-    def process(self):
-
-        #设置任务信息
-        self.para["task_guid"] = uuid.uuid1().__str__()
-        self.para["task_time"] = time.time()
-
-        #返回结果
-        res={}
-    
-        try:
-            #检测目录
-            if Catalog.query.filter_by(pguid=self.para.get("guid")).all():
-                raise Exception("目录非子目录，不可入库!")
-
-            # 图层重名检查
-            meta_list:list = json.loads(self.para.get("meta").__str__())
-            check_meta_only = int(self.para.get("check_meta_only",0))
-
-            res["data"] = {}
-            if check_meta_only:
-
-                database = Database.query.filter_by(guid=self.para.get("database_guid")).one_or_none()
-                if not database:
-                    raise Exception("数据库不存在！")
-                pg_ds: DataSource = PGUtil.open_pg_data_source(1, DES.decode(database.sqlalchemy_uri))
-
-                res["result"] = True
-
-                for meta in meta_list:
-                    layers:dict = meta.get("layer")
-                    for layer_name_origin in layers.keys():
-                        layer_name = layers.get(layer_name_origin)
-                        if pg_ds.GetLayerByName(layer_name) or InsertingLayerName.query.filter_by(name=layer_name).one_or_none():
-                            res["data"][layer_name_origin]=0
-                            res["result"] = False
-                        # 判断特殊字符
-                        elif re.search(r"\W",layer_name):
-                            res["data"][layer_name_origin]=-1
-                            res["result"] = False
-                        else :
-                            res["data"][layer_name_origin] = 1
-
-                if pg_ds:
-                    try:
-                        pg_ds.Destroy()
-                    except:
-                       print("关闭数据库失败！")
-                return res
-    
-            # 录入数据后台进程,录入主函数为entry
-            # 初始化task
-            task = Task(guid=self.para.get("task_guid"),
-                        name=self.para.get("task_name"),
-                        create_time=datetime.datetime.now(),
-                        state=0,
-                        creator=self.para.get("creator"),
-                        file_name=meta_list[0].get("filename"),
-                        database_guid=self.para.get("database_guid"),
-                        catalog_guid=self.para.get("catalog_guid"),
-                        process="等待入库",
-                        parameter=json.dumps(self.para))
-            db.session.add(task)
-            db.session.commit()
-    
-            res["result"] = True
-            res["msg"] = "数据录入提交成功！"
-            res["data"] = self.para["task_guid"]
-        except Exception as e:
-            raise e
-        return res
-
-
-    api_doc={
-    "tags":["IO接口"],
-    "parameters":[
-        {"name": "meta",
-         "in": "formData",
-         "type": "string",
-         "description": "数据meta"},
-        {"name": "encoding",
-         "in": "formData",
-         "type": "string",
-         "description": "原shp文件编码，非必要，优先使用cpg文件中编码，没有则默认GBK","enum":["UTF-8","GBK"]},
-        {"name": "overwrite",
-         "in": "formData",
-         "type": "string",
-         "description": "是否覆盖",
-         "enum":["yes","no"]},
-        {"name": "fid",
-         "in": "formData",
-         "type": "string",
-         "description": "fid列名"},
-        {"name": "geom_name",
-         "in": "formData",
-         "type": "string",
-         "description": "空间属性列名"},
-        {"name": "task_name",
-         "in": "formData",
-         "type": "string",
-         "description": "任务名",
-         "required":"true"},
-        {"name": "creator",
-         "in": "formData",
-         "type": "string",
-         "description": "创建人"},
-        {"name": "database_guid",
-         "in": "formData",
-         "type": "string",
-         "description": "数据库guid",
-         "required": "true"},
-        {"name": "catalog_guid",
-         "in": "formData",
-         "type": "string",
-         "description": "目录guid"},
-        {"name": "check_meta_only",
-         "in": "formData",
-         "type": "int",
-         "description": "是否只检查meta","enum":[0,1]}
-
-    ],
-    "responses":{
-        200:{
-            "schema":{
-                "properties":{
-                }
-            }
-            }
-        }
+# coding=utf-8
+#author:        4N
+#createtime:    2021/1/27
+#email:         nheweijun@sina.com
+
+from osgeo.ogr import *
+import uuid
+
+import time
+from app.models import *
+import json
+import re
+from app.util.component.ApiTemplate import ApiTemplate
+from app.util.component.PGUtil import PGUtil
+
+
+
+class Api(ApiTemplate):
+
+    api_name = "通过meta入库"
+
+    def process(self):
+
+        #设置任务信息
+        self.para["task_guid"] = uuid.uuid1().__str__()
+        self.para["task_time"] = time.time()
+
+        #返回结果
+        res={}
+    
+        try:
+            #检测目录
+            if Catalog.query.filter_by(pguid=self.para.get("guid")).all():
+                raise Exception("目录非子目录，不可入库!")
+
+            # 图层重名检查
+            meta_list:list = json.loads(self.para.get("meta").__str__())
+            check_meta_only = int(self.para.get("check_meta_only",0))
+
+            res["data"] = {}
+            if check_meta_only:
+
+                database = Database.query.filter_by(guid=self.para.get("database_guid")).one_or_none()
+                if not database:
+                    raise Exception("数据库不存在！")
+                pg_ds: DataSource = PGUtil.open_pg_data_source(1, DES.decode(database.sqlalchemy_uri))
+
+                res["result"] = True
+
+                for meta in meta_list:
+                    layers:dict = meta.get("layer")
+                    for layer_name_origin in layers.keys():
+                        layer_name = layers.get(layer_name_origin)
+                        if pg_ds.GetLayerByName(layer_name) or InsertingLayerName.query.filter_by(name=layer_name).one_or_none():
+                            res["data"][layer_name_origin]=0
+                            res["result"] = False
+                        # 判断特殊字符
+                        elif re.search(r"\W",layer_name):
+                            res["data"][layer_name_origin]=-1
+                            res["result"] = False
+                        else :
+                            res["data"][layer_name_origin] = 1
+
+                if pg_ds:
+                    try:
+                        pg_ds.Destroy()
+                    except:
+                       print("关闭数据库失败！")
+                return res
+    
+            # 录入数据后台进程,录入主函数为entry
+            # 初始化task
+            task = Task(guid=self.para.get("task_guid"),
+                        name=self.para.get("task_name"),
+                        create_time=datetime.datetime.now(),
+                        state=0,
+                        task_type=1,
+                        creator=self.para.get("creator"),
+                        file_name=meta_list[0].get("filename"),
+                        database_guid=self.para.get("database_guid"),
+                        catalog_guid=self.para.get("catalog_guid"),
+                        process="等待入库",
+                        parameter=json.dumps(self.para))
+            db.session.add(task)
+            db.session.commit()
+    
+            res["result"] = True
+            res["msg"] = "数据录入提交成功！"
+            res["data"] = self.para["task_guid"]
+        except Exception as e:
+            raise e
+        return res
+
+
+    api_doc={
+    "tags":["IO接口"],
+    "parameters":[
+        {"name": "meta",
+         "in": "formData",
+         "type": "string",
+         "description": "数据meta"},
+        {"name": "encoding",
+         "in": "formData",
+         "type": "string",
+         "description": "原shp文件编码，非必要，优先使用cpg文件中编码，没有则默认GBK","enum":["UTF-8","GBK"]},
+        {"name": "overwrite",
+         "in": "formData",
+         "type": "string",
+         "description": "是否覆盖",
+         "enum":["yes","no"]},
+        {"name": "fid",
+         "in": "formData",
+         "type": "string",
+         "description": "fid列名"},
+        {"name": "geom_name",
+         "in": "formData",
+         "type": "string",
+         "description": "空间属性列名"},
+        {"name": "task_name",
+         "in": "formData",
+         "type": "string",
+         "description": "任务名",
+         "required":"true"},
+        {"name": "creator",
+         "in": "formData",
+         "type": "string",
+         "description": "创建人"},
+        {"name": "database_guid",
+         "in": "formData",
+         "type": "string",
+         "description": "数据库guid",
+         "required": "true"},
+        {"name": "catalog_guid",
+         "in": "formData",
+         "type": "string",
+         "description": "目录guid"},
+        {"name": "check_meta_only",
+         "in": "formData",
+         "type": "int",
+         "description": "是否只检查meta","enum":[0,1]}
+
+    ],
+    "responses":{
+        200:{
+            "schema":{
+                "properties":{
+                }
+            }
+            }
+        }
     }
     }

-# coding=utf-8
-# author:        4N
-# createtime:    2020/9/4
-# email:         nheweijun@sina.com
-
-import traceback
-from osgeo.ogr import *
-from osgeo import ogr
-
-from flask import request
-import os
-import uuid
-
-import json
-from app.util.component.ApiTemplate import ApiTemplate
-from app.util.component.ZipUtil import ZipUtil
-from app.util.component.FileProcess import FileProcess
-import datetime
-import time
-class Api(ApiTemplate):
-    api_name = "本地数据list"
-    def process(self):
-        res = {}
-
-        try:
-            project_path = os.path.dirname(os.path.dirname(os.path.dirname(os.path.dirname(os.path.realpath(__file__)))))
-            base_path = os.path.join(project_path,"tmp")
-            if self.para.get("data_path"):
-                base_path = os.path.normpath(self.para.get("data_path"))
-            data_list:list = []
-            for f in os.listdir(base_path):
-
-                file_path = os.path.normpath(os.path.join(base_path, f))
-                file_size = FileProcess.get_file_size(file_path)
-
-                fctime = datetime.datetime.fromtimestamp(os.path.getctime(file_path)).strftime('%Y-%m-%d %H:%M:%S')
-
-                file_info ={"name":f,"path":file_path,"size":file_size,"create_time":fctime}
-
-                if file_path.endswith("shp"):
-                    file_info["type"]="shp"
-                    data_list.append(file_info)
-                elif file_path.endswith("gdb"):
-                    file_info["type"]="gdb"
-                    data_list.append(file_info)
-                elif file_path.endswith("zip"):
-                    file_info["type"]="zip"
-                    data_list.append(file_info)
-                elif os.path.isdir(file_path):
-                    bn = os.path.basename(file_path)
-                    if not len(bn.split("-"))==5:
-                        file_info["type"] = "dir"
-                        data_list.append(file_info)
-
-            data_list_sorted = sorted(data_list, key=lambda x: x["name"])
-            res["data"]=data_list_sorted
-            res["result"]=True
-        except Exception as e:
-            raise e
-        return res
-
-
-
-    api_doc={
-    "tags":["IO接口"],
-    "parameters":[
-        {"name": "data_path",
-         "in": "formData",
-         "type": "string",
-         "description": "数据文件路径"}
-    ],
-    "responses":{
-        200:{
-            "schema":{
-                "properties":{
-                }
-            }
-            }
-        }
+# coding=utf-8
+# author:        4N
+# createtime:    2020/9/4
+# email:         nheweijun@sina.com
+
+import traceback
+from osgeo.ogr import *
+from osgeo import ogr
+
+from flask import request
+import os
+import uuid
+
+import json
+from app.util.component.ApiTemplate import ApiTemplate
+from app.util.component.ZipUtil import ZipUtil
+from app.util.component.FileProcess import FileProcess
+import datetime
+import time
+class Api(ApiTemplate):
+    api_name = "本地数据list"
+    def process(self):
+        res = {}
+
+        try:
+            project_path = os.path.dirname(os.path.dirname(os.path.dirname(os.path.dirname(os.path.realpath(__file__)))))
+            base_path = os.path.join(project_path,"tmp")
+            if self.para.get("data_path"):
+                base_path = os.path.normpath(self.para.get("data_path"))
+            data_list:list = []
+            for f in os.listdir(base_path):
+
+                file_path = os.path.normpath(os.path.join(base_path, f))
+                file_size = FileProcess.get_file_size(file_path)
+
+                fctime = datetime.datetime.fromtimestamp(os.path.getctime(file_path)).strftime('%Y-%m-%d %H:%M:%S')
+
+                file_info ={"name":f,"path":file_path,"size":file_size,"create_time":fctime}
+
+                if file_path.endswith("shp"):
+                    file_info["type"]="shp"
+                    data_list.append(file_info)
+                elif file_path.endswith("gdb"):
+                    file_info["type"]="gdb"
+                    data_list.append(file_info)
+                elif file_path.endswith("zip"):
+                    file_info["type"]="zip"
+                    data_list.append(file_info)
+                elif os.path.isdir(file_path):
+                    bn = os.path.basename(file_path)
+                    if not len(bn.split("-"))==5:
+                        file_info["type"] = "dir"
+                        data_list.append(file_info)
+
+            data_list_sorted = sorted(data_list, key=lambda x: x["name"])
+            res["data"]=data_list_sorted
+            res["result"]=True
+        except Exception as e:
+            raise e
+        return res
+
+
+
+    api_doc={
+    "tags":["IO接口"],
+    "parameters":[
+        {"name": "data_path",
+         "in": "formData",
+         "type": "string",
+         "description": "数据文件路径"}
+    ],
+    "responses":{
+        200:{
+            "schema":{
+                "properties":{
+                }
+            }
+            }
+        }
 }
 }

-# coding=utf-8
-# author:        4N
-# createtime:    2020/9/4
-# email:         nheweijun@sina.com
-
-import traceback
-from osgeo.ogr import *
-from osgeo import ogr
-
-from flask import request
-import os
-import uuid
-
-import json
-from app.util.component.ApiTemplate import ApiTemplate
-from app.util.component.ZipUtil import ZipUtil
-from app.util.component.FileProcess import FileProcess
-
-
-class Api(ApiTemplate):
-    api_name = "获取meta"
-    def process(self):
-        res = {}
-
-        try:
-
-            spatial_files=[]
-            if self.para.get("data_path"):
-                filename = os.path.basename(self.para.get("data_path"))
-                #处理
-
-                if self.para.get("data_path").endswith("zip"):
-
-                    store_path = ZipUtil.unzip(self.para.get("data_path"),True)
-                    spatial_files = FileProcess.get_spatial_file(store_path)
-
-                elif  self.para.get("data_path").endswith("shp"):
-                    data_path=self.para.get("data_path")
-                    encoding_cpg_path = data_path.split(".shp")[0]+".cpg"
-                    with open(encoding_cpg_path) as fd:
-                        encoding_cpg = fd.readline().strip()
-                    if not os.path.exists(encoding_cpg_path):
-                        encoding_cpg=None
-                    spatial_files.append((data_path, encoding_cpg))
-                elif  self.para.get("data_path").endswith("gdb"):
-                    data_path=self.para.get("data_path")
-                    encoding_cpg=None
-                    spatial_files.append((data_path, encoding_cpg))
-                else:
-                    raise Exception("文件不符合规格！")
-
-            else:
-                # 保存文件
-                parent = os.path.dirname(os.path.dirname(os.path.realpath(__file__)))
-                dir_path, store_file = FileProcess.save(parent)
-                store_path = ZipUtil.unzip(store_file)
-
-                spatial_files = FileProcess.get_spatial_file(store_path)
-
-                file = request.files['file']
-                filename = file.filename.split('"')[0]
-
-            res["data"] =[]
-
-            for data_path,code in spatial_files:
-                one_data = self.get_meta(data_path)
-                one_data["encoding"]=code
-                one_data["filename"] = filename
-                res["data"].append(one_data)
-            res["result"] = True
-
-        except Exception as e:
-            raise e
-        return json.dumps(res,ensure_ascii=False)
-
-
-    def get_meta(self,data_path):
-        ds: DataSource = None
-        info = {}
-        layer_name = {}
-        info["data_path"] = os.path.normpath(data_path)
-        info["layer"] =layer_name
-        try:
-            # 分为shp和gdb 2种
-            if data_path.endswith("shp"):
-                info["type"]="shp"
-                driver: Driver = ogr.GetDriverByName("ESRI Shapefile")
-                ds: DataSource = driver.Open(data_path, 1)
-                if not ds:
-                    raise Exception("打开数据失败！")
-                layer: Layer = ds.GetLayer(0)
-                layer_name[layer.GetName().lower()] = layer.GetName().lower()
-
-            if data_path.endswith("gdb"):
-                info["type"] = "gdb"
-                driver: Driver = ogr.GetDriverByName("OpenFileGDB")
-                ds: DataSource = driver.Open(data_path, 0)
-                if not ds:
-                    raise Exception("打开数据失败！")
-                for i in range(ds.GetLayerCount()):
-                    layer: Layer = ds.GetLayer(i)
-                    layer_name[layer.GetName().lower()] = layer.GetName().lower()
-        except Exception as e :
-            print(traceback.format_exc())
-            info={}
-        finally:
-            if ds:
-                ds.Destroy()
-        return info
-
-
-    api_doc={
-    "tags":["IO接口"],
-    "parameters":[
-        {"name": "file",
-         "in": "formData",
-         "type":"file",
-         "description":"数据文件zip压缩包"},
-        {"name": "data_path",
-         "in": "formData",
-         "type": "string",
-         "description": "数据文件路径"}
-    ],
-    "responses":{
-        200:{
-            "schema":{
-                "properties":{
-                }
-            }
-            }
-        }
+# coding=utf-8
+# author:        4N
+# createtime:    2020/9/4
+# email:         nheweijun@sina.com
+
+import traceback
+from osgeo.ogr import *
+from osgeo import ogr
+
+from flask import request
+import os
+import uuid
+
+import json
+from app.util.component.ApiTemplate import ApiTemplate
+from app.util.component.ZipUtil import ZipUtil
+from app.util.component.FileProcess import FileProcess
+
+
+class Api(ApiTemplate):
+    api_name = "获取meta"
+    def process(self):
+        res = {}
+
+        try:
+
+            spatial_files=[]
+            if self.para.get("data_path"):
+                filename = os.path.basename(self.para.get("data_path"))
+                #处理
+
+                if self.para.get("data_path").endswith("zip"):
+
+                    store_path = ZipUtil.unzip(self.para.get("data_path"),True)
+                    spatial_files = FileProcess.get_spatial_file(store_path)
+
+                elif  self.para.get("data_path").endswith("shp"):
+                    data_path=self.para.get("data_path")
+                    encoding_cpg_path = data_path.split(".shp")[0]+".cpg"
+                    with open(encoding_cpg_path) as fd:
+                        encoding_cpg = fd.readline().strip()
+                    if not os.path.exists(encoding_cpg_path):
+                        encoding_cpg=None
+                    spatial_files.append((data_path, encoding_cpg))
+                elif  self.para.get("data_path").endswith("gdb"):
+                    data_path=self.para.get("data_path")
+                    encoding_cpg=None
+                    spatial_files.append((data_path, encoding_cpg))
+                else:
+                    raise Exception("文件不符合规格！")
+
+            else:
+                # 保存文件
+                parent = os.path.dirname(os.path.dirname(os.path.realpath(__file__)))
+                dir_path, store_file = FileProcess.save(parent)
+                store_path = ZipUtil.unzip(store_file)
+
+                spatial_files = FileProcess.get_spatial_file(store_path)
+
+                file = request.files['file']
+                filename = file.filename.split('"')[0]
+
+            res["data"] =[]
+
+            for data_path,code in spatial_files:
+                one_data = self.get_meta(data_path)
+                one_data["encoding"]=code
+                one_data["filename"] = filename
+                res["data"].append(one_data)
+            res["result"] = True
+
+        except Exception as e:
+            raise e
+        return json.dumps(res,ensure_ascii=False)
+
+
+    def get_meta(self,data_path):
+        ds: DataSource = None
+        info = {}
+        layer_name = {}
+        info["data_path"] = os.path.normpath(data_path)
+        info["layer"] =layer_name
+        try:
+            # 分为shp和gdb 2种
+            if data_path.endswith("shp"):
+                info["type"]="shp"
+                driver: Driver = ogr.GetDriverByName("ESRI Shapefile")
+                ds: DataSource = driver.Open(data_path, 1)
+                if not ds:
+                    raise Exception("打开数据失败！")
+                layer: Layer = ds.GetLayer(0)
+                layer_name[layer.GetName().lower()] = layer.GetName().lower()
+
+            if data_path.endswith("gdb"):
+                info["type"] = "gdb"
+                driver: Driver = ogr.GetDriverByName("OpenFileGDB")
+                ds: DataSource = driver.Open(data_path, 0)
+                if not ds:
+                    raise Exception("打开数据失败！")
+                for i in range(ds.GetLayerCount()):
+                    layer: Layer = ds.GetLayer(i)
+                    layer_name[layer.GetName().lower()] = layer.GetName().lower()
+        except Exception as e :
+            print(traceback.format_exc())
+            info={}
+        finally:
+            if ds:
+                ds.Destroy()
+        return info
+
+
+    api_doc={
+    "tags":["IO接口"],
+    "parameters":[
+        {"name": "file",
+         "in": "formData",
+         "type":"file",
+         "description":"数据文件zip压缩包"},
+        {"name": "data_path",
+         "in": "formData",
+         "type": "string",
+         "description": "数据文件路径"}
+    ],
+    "responses":{
+        200:{
+            "schema":{
+                "properties":{
+                }
+            }
+            }
+        }
 }
 }

-# coding=utf-8
-#author:        4N
-#createtime:    2020/11/30
-#email:         nheweijun@sina.com
-from app.util import *
-import configure
-from osgeo import ogr
-
-from configure import SQLALCHEMY_DATABASE_URI
-from sqlalchemy import create_engine
-from sqlalchemy.orm import sessionmaker, session
-
-
-
-
-
-
-
-
-
+# coding=utf-8
+#author:        4N
+#createtime:    2020/11/30
+#email:         nheweijun@sina.com
+from app.util import *
+import configure
+from osgeo import ogr
+
+from configure import SQLALCHEMY_DATABASE_URI
+from sqlalchemy import create_engine
+from sqlalchemy.orm import sessionmaker, session
+
+
+
+
+
+
+
+
+

-# coding=utf-8
-#author:        4N
-#createtime:    2021/3/1
-#email:         nheweijun@sina.com
-
-
-from flasgger import swag_from
-from flask import Blueprint
-from app.util import BlueprintApi
-
-from . import field_edit
-
-from . import table_list
-from . import field_list
-from . import table_edit
-from . import table_info
-from . import table_refresh
-from . import table_delete
-from . import table_view
-class DataManager(BlueprintApi):
-
-    bp = Blueprint("DataManager", __name__, url_prefix="/API/Manager")
-
-    @staticmethod
-    @bp.route('/FieldEdit', methods=['POST'])
-    @swag_from(field_edit.Api.api_doc)
-    def field_edit():
-        """
-        修改属性别名
-        """
-        return field_edit.Api().result
-
-    @staticmethod
-    @bp.route('/FieldList', methods=['POST'])
-    @swag_from(field_list.Api.api_doc)
-    def field_list():
-        """
-        属性列表
-        """
-        return field_list.Api().result
-
-    @staticmethod
-    @bp.route('/TableList', methods=['POST'])
-    @swag_from(table_list.Api.api_doc)
-    def table_list():
-        """
-        数据列表
-        """
-        return table_list.Api().result
-
-
-    @staticmethod
-    @bp.route('/TableEdit', methods=['POST'])
-    @swag_from(table_edit.Api.api_doc)
-    def table_edit():
-        """
-        修改数据
-        """
-        return table_edit.Api().result
-
-
-    @staticmethod
-    @bp.route('/TableDelete', methods=['POST'])
-    @swag_from(table_delete.Api.api_doc)
-    def table_delete():
-        """
-        删除数据
-        """
-        return table_delete.Api().result
-
-
-    @staticmethod
-    @bp.route('/TableInfo', methods=['POST'])
-    @swag_from(table_info.Api.api_doc)
-    def table_info():
-        """
-        数据信息
-        """
-        return table_info.Api().result
-
-
-    @staticmethod
-    @bp.route('/TableRefresh', methods=['POST'])
-    @swag_from(table_refresh.Api.api_doc)
-    def table_refresh():
-        """
-        刷新数据
-        """
-        return table_refresh.Api().result
-
-    @staticmethod
-    @bp.route('/TableView', methods=['POST'])
-    @swag_from(table_view.Api.api_doc)
-    def table_view():
-        """
-        数据浏览
-        """
-        return table_view.Api().result
+# coding=utf-8
+#author:        4N
+#createtime:    2021/3/1
+#email:         nheweijun@sina.com
+
+
+from flasgger import swag_from
+from flask import Blueprint
+from app.util import BlueprintApi
+
+from . import field_edit
+
+from . import table_list
+from . import field_list
+from . import table_edit
+from . import table_info
+from . import table_refresh
+from . import table_delete
+from . import table_view
+from . import table_vacuate
+class DataManager(BlueprintApi):
+
+    bp = Blueprint("DataManager", __name__, url_prefix="/API/Manager")
+
+    @staticmethod
+    @bp.route('/FieldEdit', methods=['POST'])
+    @swag_from(field_edit.Api.api_doc)
+    def field_edit():
+        """
+        修改属性别名
+        """
+        return field_edit.Api().result
+
+    @staticmethod
+    @bp.route('/FieldList', methods=['POST'])
+    @swag_from(field_list.Api.api_doc)
+    def field_list():
+        """
+        属性列表
+        """
+        return field_list.Api().result
+
+    @staticmethod
+    @bp.route('/TableList', methods=['POST'])
+    @swag_from(table_list.Api.api_doc)
+    def table_list():
+        """
+        数据列表
+        """
+        return table_list.Api().result
+
+
+    @staticmethod
+    @bp.route('/TableEdit', methods=['POST'])
+    @swag_from(table_edit.Api.api_doc)
+    def table_edit():
+        """
+        修改数据
+        """
+        return table_edit.Api().result
+
+
+    @staticmethod
+    @bp.route('/TableDelete', methods=['POST'])
+    @swag_from(table_delete.Api.api_doc)
+    def table_delete():
+        """
+        删除数据
+        """
+        return table_delete.Api().result
+
+
+    @staticmethod
+    @bp.route('/TableInfo', methods=['POST'])
+    @swag_from(table_info.Api.api_doc)
+    def table_info():
+        """
+        数据信息
+        """
+        return table_info.Api().result
+
+
+    @staticmethod
+    @bp.route('/TableRefresh', methods=['POST'])
+    @swag_from(table_refresh.Api.api_doc)
+    def table_refresh():
+        """
+        刷新数据
+        """
+        return table_refresh.Api().result
+
+    @staticmethod
+    @bp.route('/TableView', methods=['POST'])
+    @swag_from(table_view.Api.api_doc)
+    def table_view():
+        """
+        数据浏览
+        """
+        return table_view.Api().result
+
+
+    @staticmethod
+    @bp.route('/TableVacuate', methods=['POST'])
+    @swag_from(table_vacuate.Api.api_doc)
+    def table_vacuate():
+        """
+        数据抽稀
+        """
+        return table_vacuate.Api().result