init

+*.pyc
+app.db
+./tmp
+./build/*
+.idea
+env
+venv
+.venv/
+.venv
+*.sublime*
+tmp
+tmp/
+
+venv/
+whls/
+tmp/
+depoly/
+logs/
+*.pyc
+__pycache__/
+
+instance/
+
+.pytest_cache/
+.coverage
+htmlcov/
+kservice/tmp
+dist/
+build/
+*.egg-info/
+.git/

+
+

+import decimal
+
+from flask import Flask as _Flask
+from flask.json import JSONEncoder as _JSONEncoder
+from flask_cors import CORS
+import time
+import configure
+from app.util import BlueprintApi
+from app.util import find_class
+from app.models import db,Table,InsertingLayerName,Database,DES,Task
+
+from flasgger import Swagger
+# from rtree import index
+import logging
+from sqlalchemy.orm import Session
+import multiprocessing
+from app.util.component.EntryData import EntryData
+from app.util.component.EntryDataVacuate import EntryDataVacuate
+import json
+import threading
+import traceback
+from sqlalchemy import distinct
+import uuid
+from osgeo.ogr import DataSource
+import datetime
+from sqlalchemy import or_
+from app.util.component.StructuredPrint import StructurePrint
+from app.util.component.PGUtil import PGUtil
+import os
+
+"""
+因为decimal不能序列化，增加Flask对decimal类的解析 
+"""
+class JSONEncoder(_JSONEncoder):
+    def default(self, o):
+        if isinstance(o, decimal.Decimal):
+            return float(o)
+        super(JSONEncoder, self).default(o)
+
+class Flask(_Flask):
+    json_encoder = JSONEncoder
+
+
+# idx =None
+# url_json_list=None
+# sqlite3_connect= None
+def create_app():
+
+    # app基本设置
+    app = Flask(__name__)
+    app.config['SQLALCHEMY_DATABASE_URI'] = configure.SQLALCHEMY_DATABASE_URI
+    app.config['echo'] = True
+    app.config['SQLALCHEMY_TRACK_MODIFICATIONS'] = True
+    app.config['JSON_AS_ASCII'] = False
+    # app.config['SQLALCHEMY_ECHO'] = True
+
+    # 跨域设置
+    CORS(app)
+
+    #swagger设置
+    swagger_config = Swagger.DEFAULT_CONFIG
+    swagger_config.update(configure.swagger_configure)
+    Swagger(app, config=swagger_config)
+
+    # 创建数据库
+    db.init_app(app)
+    db.create_all(app=app)
+
+
+    # 日志
+    logging.basicConfig(level=logging.INFO)
+    log_file = os.path.join(os.path.dirname(os.path.dirname(os.path.realpath(__file__))),"logs","log.txt")
+    handler = logging.FileHandler(log_file, encoding='UTF-8')   # 设置日志字符集和存储路径名字
+    logging_format = logging.Formatter('[%(levelname)s] %(asctime)s %(message)s')
+    handler.setFormatter(logging_format)
+    app.logger.addHandler(handler)
+
+
+    # 注册blueprint，查找BlueprintApi的子类
+    for scan in configure.scan_module:
+        for api in find_class(scan, BlueprintApi):
+            app.register_blueprint(api.bp)
+
+
+    # 入库监测线程
+    @app.before_first_request
+    def data_entry_process():
+        StructurePrint.print("start listen")
+        process = threading.Thread(target=data_entry_center)
+        process.start()
+
+    return app
+
+
+
+
+def data_entry_center():
+    running_dict = {}
+    sys_session: Session = PGUtil.get_db_session(configure.SQLALCHEMY_DATABASE_URI)
+
+    while True:
+
+
+        try:
+            time.sleep(3)
+
+            # 已经结束的进程 从监测中删除
+            remove_process = []
+
+            # structured_print(running_dict.__len__().__str__())
+
+            for process,layer_names in running_dict.items():
+                if not process.is_alive():
+                    for l in layer_names:
+                        inserted = sys_session.query(InsertingLayerName).filter_by(name=l).one_or_none()
+                        if inserted:
+                            sys_session.delete(inserted)
+                    sys_session.commit()
+                    remove_process.append(process)
+            for process in remove_process:
+                running_dict.pop(process)
+
+            # StructurePrint.print("listening...")
+
+            # 入库进程少于阈值，开启入库进程
+
+            inter_size = sys_session.query(distinct(InsertingLayerName.task_guid)).count()
+
+            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()
+                if ready_task:
+
+                    try:
+                        parameter = json.loads(ready_task.parameter)
+                        StructurePrint.print("检测到入库任务")
+                        ready_task.state=2
+                        ready_task.process="入库中"
+                        sys_session.commit()
+
+                        metas: list = json.loads(parameter.get("meta").__str__())
+                        parameter["meta"] = metas
+
+
+                        database = sys_session.query(Database).filter_by(guid=ready_task.database_guid).one_or_none()
+                        pg_ds: DataSource = PGUtil.open_pg_data_source(1,DES.decode(database.sqlalchemy_uri))
+
+                        this_task_layer = []
+                        for meta in metas:
+                            overwrite = parameter.get("overwrite", "no")
+
+
+
+                            for layer_name_origin, layer_name in meta.get("layer").items():
+                                origin_name = layer_name
+                                no = 1
+
+                                while (overwrite.__eq__("no") and pg_ds.GetLayerByName(layer_name)) or sys_session.query(InsertingLayerName).filter_by(name=layer_name).one_or_none() :
+                                    layer_name = origin_name + "_{}".format(no)
+                                    no += 1
+
+                                # 添加到正在入库的列表中
+                                iln = InsertingLayerName(guid=uuid.uuid1().__str__(),
+                                                         task_guid=ready_task.guid,
+                                                         name=layer_name)
+
+                                sys_session.add(iln)
+                                sys_session.commit()
+                                this_task_layer.append(layer_name)
+                                # 修改表名
+                                meta["layer"][layer_name_origin] = layer_name
+
+                        pg_ds.Destroy()
+                        entry_data_process = multiprocessing.Process(target=EntryDataVacuate().entry,args=(parameter,))
+                        entry_data_process.start()
+                        running_dict[entry_data_process] = this_task_layer
+                    except Exception as e:
+                        sys_session.query(Task).filter_by(guid=ready_task.guid).update(
+                            {"state": -1, "process": "入库失败"})
+                        sys_session.commit()
+                        StructurePrint.print(e.__str__(), "error")
+                else:
+                    # 解表啊
+                    sys_session.commit()
+        except Exception as e:
+            sys_session.commit()
+            StructurePrint.print(e.__str__(),"error")

+# coding=utf-8
+import base64
+import os
+from flask_sqlalchemy import SQLAlchemy,Model
+import importlib
+from sqlalchemy import Column, Integer, String, ForeignKey, Text, DateTime, Time,Float
+from sqlalchemy.orm import relationship
+import base64
+from pyDes import *
+import datetime
+
+from app.util.component.PGUtil import PGUtil
+import glob
+
+class DES():
+    '''
+    DES密码加解密
+    '''
+    Des: des = des("Chinadci", ECB, "\0\0\0\0\0\0\0\0", pad=None, padmode=PAD_PKCS5)
+
+    @classmethod
+    def encode(cls, data):
+        return str(base64.b64encode(cls.Des.encrypt(data)), encoding="utf8")
+
+
+    @classmethod
+    def decode(cls, data):
+        if data:
+            return str(cls.Des.decrypt(base64.b64decode(data.encode("utf-8"))), encoding="utf8")
+
+        else:
+            return data
+
+db = SQLAlchemy()
+
+# 动态加载Model
+module_dir = "modules"
+model_pkg = "models"
+current_dir = os.path.abspath(os.path.dirname(__file__))
+for pkg in glob.glob('%s/%s/*/%s' % (current_dir,module_dir,model_pkg)) :
+    module  = os.path.basename(os.path.dirname(pkg))
+    base_name = os.path.basename(pkg).split('.')[0]
+    pkg_name = ".".join(["app.modules",module,base_name])
+    try:
+        __import__(pkg_name)
+    except:
+        pass
+
+
+
+class Table(db.Model):
+    '''
+    数据表元数据
+    '''
+    __tablename__ = 'dmdms_table'
+    guid = Column(String(256), primary_key=True)
+    # 数据源外键
+    database_guid = Column(String(256), ForeignKey('dmdms_database.guid'))
+
+    # 点线面123
+    table_type = Column(Integer)
+
+    name = Column(String(256))
+    alias = Column(Text)
+    create_time = Column(DateTime)
+    update_time = Column(DateTime)
+
+    feature_count = Column(Integer)
+
+    description = Column(Text)
+    extent = Column(Text)
+
+    #用户
+    creator = Column(Text)
+
+    # 目录外键
+    catalog_guid = Column(String(256), ForeignKey('dmdms_catalog.guid'))
+
+    relate_columns = relationship('Columns', backref='relate_table', lazy='dynamic')
+    relate_table_vacuates = relationship('TableVacuate', backref='relate_table', lazy='dynamic')
+
+
+class TableVacuate(db.Model):
+    '''
+    sub数据表元数据
+    '''
+    __tablename__ = 'dmdms_table_vacuate'
+    guid = Column(String(256), primary_key=True)
+    name = Column(String(256))
+    level = Column(Integer)
+    pixel_distance = Column(Float)
+    table_guid = Column(String(256), ForeignKey('dmdms_table.guid'))
+
+
+
+class Columns(db.Model):
+    '''
+    数据表的列
+    '''
+    __tablename__ = 'dmdms_column'
+    guid = Column(String(256), primary_key=True)
+    # 表外键
+    table_guid= Column(String(256), ForeignKey('dmdms_table.guid'))
+    name=Column(String(256))
+    alias = Column(String(256))
+    create_time = Column(DateTime)
+    update_time = Column(DateTime)
+
+class Task(db.Model):
+    '''
+    任务表
+    '''
+    __tablename__ = 'dmdms_task'
+    guid = Column(String(256), primary_key=True)
+    name = Column(Text)
+    process = Column(Text)
+    create_time = Column(DateTime)
+    update_time = Column(DateTime)
+    state = Column(Integer)
+    # 数据源外键
+    database_guid = Column(String(256), ForeignKey('dmdms_database.guid'))
+    # 目录外键
+    catalog_guid = Column(String(256), ForeignKey('dmdms_catalog.guid'))
+
+    creator = Column(Text)
+    file_name = Column(Text)
+
+    relate_processes = relationship('Process', backref='relate_task', lazy='dynamic')
+
+    # 入库参数
+    parameter= Column(Text)
+
+
+
+class Process(db.Model):
+    '''
+    过程信息表
+    '''
+    __tablename__ = 'dmdms_process'
+    guid = Column(String(256), primary_key=True)
+    # 任务外键
+    task_guid = Column(String(256), ForeignKey('dmdms_task.guid'))
+    time = Column(DateTime)
+    message = Column(Text)
+
+
+class Catalog(db.Model):
+    '''
+    目录表
+    '''
+    __tablename__ = 'dmdms_catalog'
+    guid = Column(String(256), primary_key=True)
+    database_guid = Column(String(256), ForeignKey('dmdms_database.guid'))
+    pguid = Column(String(256))
+    path = Column(Text)
+    name = Column(String(256))
+    sort = Column(Integer)
+    description = Column(Text)
+    relate_tables = relationship('Table', backref='relate_catalog', lazy='dynamic')
+    relate_tasks = relationship('Task', backref='relate_catalog', lazy='dynamic')
+
+class Database(db.Model):
+    '''
+    数据源表
+    '''
+    __tablename__ = 'dmdms_database'
+    guid = Column(String(256), primary_key=True)
+    name = Column(String(256))
+    alias = Column(String(256))
+    sqlalchemy_uri = Column(String(256))
+    description = Column(Text)
+    # 唯一性约束，不能注册相同连接的库
+    connectstr= Column(Text,unique=True)
+
+    creator = Column(String(256))
+
+    create_time = Column(DateTime)
+    update_time = Column(DateTime)
+
+    relate_catalogs = relationship('Catalog', backref='relate_database', lazy='dynamic')
+    relate_tables = relationship('Table', backref='relate_database', lazy='dynamic')
+    relate_tasks = relationship('Task', backref='relate_database', lazy='dynamic')
+
+
+
+class InsertingLayerName(db.Model):
+    '''
+    正在入库的数据
+    '''
+    __tablename__ = 'dmdms_iln'
+    guid = Column(String(256), primary_key=True)
+    task_guid = Column(String(256))
+    name = Column(String(256))
+

+# 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():
+        """
+        删除目录
+        """
+        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
+
+
+
+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
+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()
+            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():
+        """
+        数据源信息
+        """
+        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:    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 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
+
+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:    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接口
+        """
+        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/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:    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

+# 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:    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:    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/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

+#author:        4N
+#createtime:    2021/1/27
+#email:         nheweijun@sina.com
+
+from app.models import Columns
+import datetime
+
+
+from app.models import db
+from app.util.component.ApiTemplate import ApiTemplate
+
+
+class Api(ApiTemplate):
+    api_name = "修改属性"
+    def process(self):
+
+        #返回结果
+        res={}
+
+        column_guid = self.para.get("column_guid")
+        try:
+            Columns.query.filter_by(guid = column_guid).update({"alias":self.para.get("column_alias"),"update_time":datetime.datetime.now()})
+            db.session.commit()
+            res["result"] = True
+            res["msg"] = "属性别名修改成功！"
+
+        except Exception as e:
+            raise e
+
+        return res
+
+    api_doc={
+    "tags":["管理接口"],
+    "parameters":[
+        {"name": "column_guid",
+         "in": "formData",
+         "type": "string",
+         "description": "属性guid","required":"true"},
+        {"name": "column_alias",
+         "in": "formData",
+         "type": "string",
+         "description": "属性别名","required":"true"},
+
+    ],
+    "responses":{
+        200:{
+            "schema":{
+                "properties":{
+                }
+            }
+            }
+        }
+    }

+#author:        4N
+#createtime:    2021/1/27
+#email:         nheweijun@sina.com
+
+
+import traceback
+from app.models import Table
+from app.util.component.ApiTemplate import ApiTemplate
+from app.util.component.ModelVisitor import ModelVisitor
+
+class Api(ApiTemplate):
+    api_name = "属性列表"
+    def process(self):
+
+        #返回结果
+        dir_path = None
+        res={}
+    
+        try:
+            table_guid = self.para.get("guid")
+            table:Table = Table.query.filter_by(guid=table_guid).one_or_none()
+            if table:
+                res["result"]=True
+                res["data"] = ModelVisitor.objects_to_jsonarray(table.relate_columns)
+            else:
+                res["result"]=False
+                res["msg"] = "数据表不存在！"
+        except Exception as e:
+            print(traceback.format_exc())
+            raise e
+
+        return res
+
+    api_doc={
+    "tags":["管理接口"],
+    "parameters":[
+        {"name": "guid",
+         "in": "formData",
+         "type": "string",
+         "description": "表guid"},
+    
+    ],
+    "responses":{
+        200:{
+            "schema":{
+                "properties":{
+                }
+            }
+            }
+        }
+    }

+#author:        4N
+#createtime:    2021/1/27
+#email:         nheweijun@sina.com
+
+
+
+import traceback
+from app.models import Table,Database,DES
+
+from osgeo.ogr import DataSource
+
+
+from app.models import db
+from app.util.component.ApiTemplate import ApiTemplate
+
+from app.util.component.PGUtil import PGUtil
+class Api(ApiTemplate):
+    api_name = "删除表"
+    def process(self):
+
+        res = {}
+        pg_ds = None
+        try:
+
+            table_guid = self.para.get("guid")
+    
+            table = Table.query.filter_by(guid=table_guid)
+    
+            if not table.one_or_none():
+                res["result"]=False
+                res["msg"]= "数据不存在！"
+                return res
+
+    
+            table = table.one_or_none()
+    
+
+    
+            # 删除真实数据
+            database = Database.query.filter_by(guid=table.database_guid).one_or_none()
+            if not database:
+                res["result"]=False
+                res["msg"]= "数据库不存在!"
+                return res
+
+    
+            pg_ds: DataSource = PGUtil.open_pg_data_source(1, DES.decode(database.sqlalchemy_uri))
+
+
+            #删除抽稀表
+            vacuate_tables=table.relate_table_vacuates.all()
+            for vt in vacuate_tables:
+                pg_ds.DeleteLayer(vt.name)
+
+            pg_ds.DeleteLayer(table.name)
+
+            # 删除元数据
+
+            db.session.delete(table)
+            db.session.commit()
+            res["result"] = True
+            res["msg"] ="删除成功！"
+        except Exception as e:
+            raise e
+        finally:
+            if pg_ds:
+                pg_ds.Destroy()
+        return res
+
+    api_doc={
+    "tags":["管理接口"],
+    "parameters":[
+        {"name": "guid",
+         "in": "formData",
+         "type": "string",
+         "description": "表guid","required":"true"},
+    ],
+    "responses":{
+        200:{
+            "schema":{
+                "properties":{
+                }
+            }
+            }
+        }
+    }

+#author:        4N
+#createtime:    2021/1/27
+#email:         nheweijun@sina.com
+
+
+
+from app.models import Table,Catalog,Database,DES
+
+from app.models import db,Columns
+import json
+
+from sqlalchemy.orm import Session
+import datetime
+from app.util.component.ApiTemplate import ApiTemplate
+from app.util.component.PGUtil import PGUtil
+
+class Api(ApiTemplate):
+    api_name = "修改表信息"
+    def process(self):
+
+        res = {}
+        try:
+        
+            table_guid = self.para.get("guid")
+            table_alias = self.para.get("alias")
+            catalog_guid = self.para.get("catalog_guid")
+            description = self.para.get("description")
+            name = self.para.get("name")
+            columns_edit = self.para.get("columns_edit")
+    
+    
+            table = Table.query.filter_by(guid=table_guid)
+            if not table.one_or_none():
+                res["result"]=False
+                res["msg"]= "数据不存在！"
+                return res
+
+    
+            if self.para.__contains__("catalog_guid"):
+                if catalog_guid is None:
+                    table.update({"catalog_guid": None})
+    
+                else:
+                    # 检测目录的有效性
+    
+                    if not Catalog.query.filter_by(guid=catalog_guid).one_or_none():
+                        raise Exception("目录不存在！")
+    
+                    if not table.one_or_none().database_guid.__eq__(
+                        Catalog.query.filter_by(guid=catalog_guid).one_or_none().database_guid
+                    ):
+                        raise Exception("该目录不属于表所在的数据库！")
+                    table.update({"catalog_guid": catalog_guid})
+    
+    
+            if self.para.__contains__("alias"):
+                table.update({"alias":table_alias})
+    
+            if self.para.__contains__("description"):
+                table.update({"description":description})
+    
+            if columns_edit:
+                columns_edit_list = json.loads(columns_edit)
+                for ce in columns_edit_list:
+                    Columns.query.filter_by(guid=ce["guid"]).update({"alias": ce.get("alias")})
+    
+            if name:
+                sys_session=None
+                try:
+                    this_table = table.one_or_none()
+                    database:Database= this_table.relate_database
+                    sys_session: Session = PGUtil.get_db_session(DES.decode(database.sqlalchemy_uri))
+                    rename_sql = 'alter table "{}" rename to "{}"'.format(this_table.name,name)
+                    sys_session.execute(rename_sql)
+                    sys_session.commit()
+                    print(rename_sql)
+                    # 更新所有相关业务表
+                    same_databases = Database.query.filter_by(sqlalchemy_uri=this_table.relate_database.sqlalchemy_uri).all()
+                    same_databases_database_guid = [d.guid for d in same_databases]
+                    re_tables = Table.query.filter(Table.name==this_table.name).filter(Table.database_guid.in_(same_databases_database_guid))
+                    re_tables.update({"name": name},synchronize_session=False)
+                except:
+                    raise Exception("表名更新失败，表名已存在!")
+                finally:
+                    if sys_session:
+                        sys_session.close()
+            db.session.commit()
+
+            if catalog_guid or table_alias or name or columns_edit:
+                Table.query.filter_by(guid=table_guid).update({"update_time":datetime.datetime.now()})
+                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",
+         "description": "表guid","required":"true"},
+        {"name": "alias",
+         "in": "formData",
+         "type": "string",
+         "description": "表别名"},
+        {"name": "name",
+         "in": "formData",
+         "type": "string",
+         "description": "表名"},
+        {"name": "description",
+         "in": "formData",
+         "type": "string",
+         "description": "表描述"},
+        {"name": "catalog_guid",
+         "in": "formData",
+         "type": "string",
+         "description": "目录guid,如果要撤销挂载目录，传None"},
+        {"name": "columns_edit",
+         "in": "formData",
+         "type": "string",
+         "description": '需要修改的属性的列表，如 [{"guid":"1fda","alias":"测试"}]'},
+    
+    ],
+    "responses":{
+        200:{
+            "schema":{
+                "properties":{
+                }
+            }
+            }
+        }
+    }

+#author:        4N
+#createtime:    2021/1/27
+#email:         nheweijun@sina.com
+
+from app.models import Table,Columns
+
+from app.util.component.ApiTemplate import ApiTemplate
+from app.util.component.ModelVisitor import ModelVisitor
+
+class Api(ApiTemplate):
+    api_name = "表信息"
+    def process(self):
+        res = {}
+        try:
+            table_guid = self.para.get("guid")
+            table = Table.query.filter_by(guid=table_guid)
+            if not table.one_or_none():
+                raise Exception("数据不存在！")
+            table = table.one_or_none()
+            columns = table.relate_columns.order_by(Columns.name).all()
+            res["data"]=ModelVisitor.table_to_json(table)
+            res["data"]["columns"] = ModelVisitor.objects_to_jsonarray(columns)
+            res["result"] = True
+    
+        except Exception as e:
+            raise e
+        return res
+    
+    api_doc={
+    "tags":["管理接口"],
+    "parameters":[
+        {"name": "guid",
+         "in": "formData",
+         "type": "string",
+         "description": "表guid","required":"true"},
+    ],
+    "responses":{
+        200:{
+            "schema":{
+                "properties":{
+                }
+            }
+            }
+        }
+    }

+#author:        4N
+#createtime:    2021/1/27
+#email:         nheweijun@sina.com
+
+
+from app.models import Table,Catalog,Database,DES,Columns,db
+
+from sqlalchemy import or_,and_
+
+from app.util.component.ApiTemplate import ApiTemplate
+
+from app.util.component.ModelVisitor import ModelVisitor
+class Api(ApiTemplate):
+    api_name = "表列表"
+    def process(self):
+    
+        res = {}
+        try:
+
+            page_index = int(self.para.get("page_index", "0"))
+            page_size = int(self.para.get("page_size", "10"))
+    
+            alias = self.para.get("alias")
+            name = self.para.get("name")
+    
+    
+            database_guid = self.para.get("database_guid")
+            catalog_guid = self.para.get("catalog_guid")
+            table_type = self.para.get("table_type")
+    
+            start_time = self.para.get("start_time")
+            end_time =  self.para.get("end_time")
+    
+    
+    
+            recursion = int(self.para.get("recursion","0"))
+    
+            sort = int(self.para.get("sort","1"))
+            if sort.__eq__(1):
+                tables = Table.query.order_by(Table.update_time.desc())
+            else:
+                tables = Table.query.order_by(Table.name)
+    
+            if database_guid:
+                tables = tables.filter_by(database_guid=database_guid)
+            if catalog_guid:
+    
+                if recursion.__eq__(0):
+                    tables = tables.filter_by(catalog_guid=catalog_guid)
+                else:
+                    #所有子目录id
+                    catalog_guids = [c.guid for c in  Catalog.query.filter(Catalog.path.like("%" + catalog_guid + "%")).all()]
+                    tables = tables.filter(Table.catalog_guid.in_(catalog_guids))
+    
+            if table_type:
+                tables = tables.filter_by(table_type=table_type)
+            if start_time and end_time:
+                tables = tables.filter(Table.create_time.between(start_time, end_time))
+    
+            # 并集
+            if alias and name:
+                tables = tables.filter(or_(Table.alias.like("%" + alias + "%") , Table.name.like("%" + name + "%")))
+            else:
+                if alias:
+                    tables = tables.filter(Table.alias.like("%" + alias + "%"))
+                if name:
+                    tables = tables.filter(Table.name.like("%" + name + "%"))
+            res["data"]={}
+            res["data"]["count"] = tables.count()
+            tables = tables.limit(page_size).offset(page_index * page_size).all()
+            res["data"]["list"]=[]
+
+            for t in tables:
+                res["data"]["list"].append(ModelVisitor.table_to_json(t))
+
+            res["result"] = True
+        except Exception as e:
+            raise e
+        return res
+    
+    
+    
+    
+    
+    api_doc={
+    "tags":["管理接口"],
+    "parameters":[
+        {"name": "page_index",
+         "in": "formData",
+         "type": "int",
+         "description": "页"},
+        {"name": "page_size",
+         "in": "formData",
+         "type": "int",
+         "description": "页大小"},
+        {"name": "alias",
+         "in": "formData",
+         "type": "string",
+         "description": "表别名"},
+        {"name": "name",
+         "in": "formData",
+         "type": "string",
+         "description": "表名"},
+        {"name": "table_type",
+         "in": "formData",
+         "type": "int",
+         "description": "点线面123","enum":[1,2,3]},
+        {"name": "database_guid",
+         "in": "formData",
+         "type": "string",
+         "description": "数据库guid"},
+        {"name": "catalog_guid",
+         "in": "formData",
+         "type": "string",
+         "description": "目录guid"},
+        {"name": "recursion",
+         "in": "formData",
+         "type": "int",
+         "description": "是否递归目录,0不递归，1递归","enum":[0,1]},
+        {"name": "start_time",
+         "in": "formData",
+         "type": "string",
+         "description": "开始时间 2020-12-12 00:00:00"},
+        {"name": "end_time",
+         "in": "formData",
+         "type": "string",
+         "description": "结束时间"},
+        {"name": "sort",
+         "in": "formData",
+         "type": "int",
+         "description": "排序","enum":[1,2]},
+    ],
+    "responses":{
+        200:{
+            "schema":{
+                "properties":{
+                }
+            }
+            }
+        }
+    }

+#author:        4N
+#createtime:    2021/1/27
+#email:         nheweijun@sina.com
+
+
+
+import traceback
+from app.models import Table,Database,DES,Columns,db,TableVacuate
+
+from osgeo.ogr import DataSource,FeatureDefn,FieldDefn,Layer
+
+import datetime
+import uuid
+
+from sqlalchemy.orm import Session
+
+from app.util.component.PGUtil import PGUtil
+from app.util.component.ModelVisitor import ModelVisitor
+from app.util.component.StructuredPrint import StructurePrint
+from app.util.component.ApiTemplate import ApiTemplate
+from app.util.component.GeometryAdapter import GeometryAdapter
+
+class Api(ApiTemplate):
+    api_name = "数据刷新"
+    def process(self):
+
+        res = {}
+        pg_ds =None
+        data_session=None
+        this_time = datetime.datetime.now()
+        try:
+            
+            database_guid = self.para.get("database_guid")
+            database = Database.query.filter_by(guid=database_guid).one_or_none()
+    
+            if not database:
+                raise Exception("数据库不存在!")
+            spatial_tables = Table.query.order_by(Table.create_time.desc()).filter_by(database_guid=database_guid).filter(Table.table_type!=0).all()
+            spatial_tables_names = [table.name for table in spatial_tables]
+            db_tables_names = []
+    
+
+            pg_ds: DataSource = PGUtil.open_pg_data_source(1, DES.decode(database.sqlalchemy_uri))
+            # 更新空间表
+            # 增加表
+            self.add_spatail_table(database, pg_ds, spatial_tables_names, db_tables_names, this_time)
+    
+            # 删除/修改表
+            self.edit_spatial_table(pg_ds, spatial_tables, db_tables_names, this_time)
+
+            # 处理抽稀表
+            self.deal_vacuate_table(pg_ds,database.guid)
+
+
+            # 空间表处理完毕
+            db.session.commit()
+
+    
+            # 注册普通表
+            # 实体库连接
+            data_session: Session = PGUtil.get_db_session(DES.decode(database.sqlalchemy_uri))
+    
+            # 空间表
+            spatial_tables = Table.query.order_by(Table.create_time.desc()).filter_by(database_guid=database_guid).filter(Table.table_type!=0).all()
+            spatial_tables_names = [table.name for table in spatial_tables]
+    
+    
+            #原有普通表
+            common_tables = Table.query.order_by(Table.create_time.desc()).filter_by(database_guid=database_guid).filter(Table.table_type==0).all()
+            origin_common_tables_name = [table.name for table in common_tables]
+    
+    
+            # 现有普通表
+            real_common_tables_name =[]
+            # 只注册public中的表
+            common_result = data_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 common_result:
+                table_name = re[0]
+                if table_name not in spatial_tables_names and (not table_name.__contains__("_vacuate_")):
+                    real_common_tables_name.append(table_name)
+    
+            # 增加新普通表
+
+            self.add_common_table(data_session, database_guid, real_common_tables_name, origin_common_tables_name,
+                            this_time)
+
+    
+            #删除、修改普通表
+            self.edit_common_table(data_session, database_guid, real_common_tables_name, origin_common_tables_name,
+                              this_time)
+
+            db.session.commit()
+            res["msg"] = "刷新数据成功！"
+            res["result"] = True
+
+        except Exception as e:
+            raise e
+    
+        finally:
+            if pg_ds:
+                pg_ds.Destroy()
+            if data_session:
+                data_session.close()
+    
+        return res
+    
+
+    def add_spatail_table(self,database,pg_ds,spatial_tables_names,db_tables_names,this_time):
+        # 更新空间表
+        # 增加表
+
+        for i in range(pg_ds.GetLayerCount()):
+            layer: Layer = pg_ds.GetLayer(i)
+            geom_column = layer.GetGeometryColumn()
+            db_tables_names.append(layer.GetName())
+            if not geom_column:
+                continue
+            if layer.GetName() not in spatial_tables_names:
+                l_name = layer.GetName()
+
+                # 只注册public的空间表,其他表空间的表名会有.
+                if layer.GetName().__contains__("."):
+                    continue
+
+                if layer.GetName().__contains__("_vacuate_"):
+                    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])
+
+                StructurePrint.print("空间表增加！")
+
+                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)
+
+                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)
+
+    def deal_vacuate_table(self,pg_ds,database_guid):
+
+
+        for i in range(pg_ds.GetLayerCount()):
+            layer: Layer = pg_ds.GetLayer(i)
+            geom_column = layer.GetGeometryColumn()
+
+            if not geom_column:
+                continue
+
+
+
+            if layer.GetName().__contains__("_vacuate_"):
+                l_name = layer.GetName()
+
+
+                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.query.filter_by(name=base_layer_name,database_guid=database_guid).one_or_none()
+                if base_table:
+                    if not TableVacuate.query.filter_by(table_guid=base_table.guid,name=l_name).one_or_none():
+                        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)
+                else:
+                    kk=1
+
+
+
+
+    def edit_spatial_table(self,pg_ds,spatial_tables,db_tables_names,this_time):
+
+        for table in spatial_tables:
+
+            # 删除表
+            if table.name not in db_tables_names:
+                StructurePrint.print("空间表减少！")
+                db.session.delete(table)
+            # 修改表
+            else:
+                layer: Layer = pg_ds.GetLayerByName(table.name)
+                l_name = layer.GetName()
+
+                # 只注册public的空间表,其他表空间的表名会有.
+                if layer.GetName().__contains__("."):
+                    continue
+
+                if layer.GetName().__contains__("_vacuate_"):
+                    continue
+
+                columns = table.relate_columns
+                columns_names = [column.name for column in columns]
+                feature_defn: FeatureDefn = layer.GetLayerDefn()
+                db_columns_names = []
+
+                # 增加列
+                for i in range(feature_defn.GetFieldCount()):
+                    field_defn: FieldDefn = feature_defn.GetFieldDefn(i)
+                    field_name = field_defn.GetName().lower()
+                    db_columns_names.append(field_name)
+
+                    if field_name not in columns_names:
+                        StructurePrint.print("{}空间表属性增加！".format(table.name))
+                        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)
+
+                # 删除列
+                for column in columns:
+                    if column.name not in db_columns_names:
+                        StructurePrint.print("{}空间表属性减少！".format(table.name))
+                        db.session.delete(column)
+
+
+
+                # 范围统计和数量统计以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])
+
+                # 修改要素量
+                if not table.feature_count.__eq__(feature_count):
+                    StructurePrint.print("{}空间表要素！".format(table.name))
+                    Table.query.filter_by(guid=table.guid).update({"feature_count": feature_count,
+                                                                   "extent": extent})
+
+
+    def add_common_table(self,data_session,database_guid,real_common_tables_name,origin_common_tables_name,this_time):
+        for table_name in real_common_tables_name:
+            if table_name not in origin_common_tables_name:
+                StructurePrint.print("{}非空间表增加！".format(table_name))
+                table_guid = uuid.uuid1().__str__()
+                count = data_session.execute('select count(*) from "{}"'.format(table_name)).fetchone()[0]
+
+                table = Table(guid=table_guid,
+                              database_guid=database_guid,
+                              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 = data_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)
+
+                # 删除不存在的表
+                for n in origin_common_tables_name:
+                    if n not in real_common_tables_name:
+                        table = Table.query.filter_by(name=n).filter_by(database_guid=database_guid).one_or_none()
+                        if table:
+                            db.session.delete(table)
+
+    def edit_common_table(self,data_session,database_guid,real_common_tables_name,origin_common_tables_name,this_time):
+        for table_name in origin_common_tables_name:
+            table = Table.query.filter_by(name=table_name).filter_by(database_guid=database_guid).one_or_none()
+            if table:
+                if table_name not in real_common_tables_name:
+                    StructurePrint.print("{}非空间表减少！".format(table_name))
+                    db.session.delete(table)
+                # 修改表
+                else:
+                    columns = table.relate_columns
+                    columns_names = [column.name for column in columns]
+
+                    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 = data_session.execute(sql).fetchall()
+                    real_cols_name = [col[1] for col in cols]
+
+                    # 属性增加
+                    for col in real_cols_name:
+                        if col not in columns_names:
+                            StructurePrint.print("{}表要素属性增加！".format(table_name))
+                            column = Columns(guid=uuid.uuid1().__str__(), table_guid=table.guid,
+                                             name=col, create_time=this_time, update_time=this_time)
+                            db.session.add(column)
+
+                    # 属性减少
+                    for column in columns:
+                        if column.name not in real_cols_name:
+                            StructurePrint.print("{}表要素属性减少！".format(table_name))
+                            db.session.delete(column)
+
+                    # 修改要素量
+                    sql = 'select count(*) from "{}"'.format(table_name)
+
+                    count = data_session.execute(sql).fetchone()[0]
+                    if not table.feature_count.__eq__(count):
+                        StructurePrint.print("{}表要素变化！".format(table_name))
+                        Table.query.filter_by(guid=table.guid).update({"feature_count": count})
+
+
+    
+    
+    api_doc={
+    "tags":["管理接口"],
+    "parameters":[
+        {"name": "database_guid",
+         "in": "formData",
+         "type": "string",
+         "description": "数据库guid",
+         "required":"true"},
+        {"name": "user",
+         "in": "formData",
+         "type": "string",
+         "description": "用户"}
+
+    ],
+    "responses":{
+        200:{
+            "schema":{
+                "properties":{
+                }
+            }
+            }
+        }
+}

+#author:        4N
+#createtime:    2021/1/27
+#email:         nheweijun@sina.com
+
+
+import datetime
+import traceback
+from app.models import Table,Database,DES
+
+from sqlalchemy.engine import ResultProxy
+from app.util.component.ApiTemplate import ApiTemplate
+from app.util.component.PGUtil import PGUtil
+
+class Api(ApiTemplate):
+    api_name = "数据浏览"
+    def process(self):
+
+        res = {}
+        res["data"] = {}
+        db_session=None
+        try:  
+            table_guid = self.para.get("guid")
+            limit = int(self.para.get("limit",50))
+            offset = int(self.para.get("offset", 0))
+            table :Table= Table.query.filter_by(guid=table_guid).one_or_none()
+    
+            if not table:
+                raise Exception("数据不存在！")
+    
+            database:Database = table.relate_database
+    
+            db_session = PGUtil.get_db_session(DES.decode(database.sqlalchemy_uri))
+
+            geom_col = PGUtil.get_geo_column(table.name,db_session)
+
+            query_result : ResultProxy = db_session.execute('select * from "{}" limit {} offset {}'.format(table.name,limit,offset))
+
+            res["data"]["count"]=PGUtil.get_table_count(table.name,db_session)
+
+            res["data"]["list"]=[]
+            for row_proxy in query_result:
+                d = {}
+                for column, value in row_proxy.items():
+                    #跳过空间列
+                    if geom_col:
+                        if column.__eq__(geom_col):
+                            continue
+                    #格式化时间列
+                    if isinstance(value, datetime.datetime):
+                        d[column] = value.strftime('%Y-%m-%d %H:%M:%S')
+                    else:
+                        d[column]=value
+                res["data"]["list"].append(d)
+            res["result"]=True
+        except Exception as e:
+            raise Exception("数据库连接失败！")
+        finally:
+            if db_session:
+                db_session.close()
+        return res
+    
+    api_doc={
+    "tags":["管理接口"],
+    "parameters":[
+        {"name": "guid",
+         "in": "formData",
+         "type": "string",
+         "description": "表guid","required":"true"},
+        {"name": "limit",
+         "in": "formData",
+         "type": "int"
+         },
+        {"name": "offset",
+         "in": "formData",
+         "type": "int"},
+    ],
+    "responses":{
+        200:{
+            "schema":{
+                "properties":{
+                }
+            }
+            }
+        }
+    }

+# coding=utf-8
+#author:        4N
+#createtime:    2021/5/18
+#email:         nheweijun@sina.com
+
+
+from flasgger import swag_from
+from flask import Blueprint
+from app.util import BlueprintApi
+
+from . import monitor_info
+class DataManager():
+
+    bp = Blueprint("Monitor", __name__, url_prefix="/API/Monitor")
+
+    @staticmethod
+    @bp.route('/Info', methods=['GET'])
+    @swag_from(monitor_info.Api.api_doc)
+    def monitor_info():
+        """
+        性能监控
+        """
+        return monitor_info.Api().result

+# coding=utf-8
+#author:        4N
+#createtime:    2021/6/11
+#email:         nheweijun@sina.com
+
+
+from sqlalchemy import Column, Integer, String, ForeignKey, Text, DateTime, Time
+from app.models import db
+
+class TestModel(db.Model):
+    '''
+    数据表元数据
+    '''
+    __tablename__ = 'test_model'
+    guid = Column(String(256), primary_key=True)

+# coding=utf-8
+#author:        4N
+#createtime:    2021/7/9
+#email:         nheweijun@sina.com
+
+from app.models import *
+
+from app.util.component.ApiTemplate import ApiTemplate
+from app.util.component.ModelVisitor import ModelVisitor
+import psutil
+
+class Api(ApiTemplate):
+    api_name = "监控"
+
+    def process(self):
+
+        # 返回结果
+        res = {}
+        res["data"] = {}
+        try:
+            # 业务逻辑
+            cpu_count = psutil.cpu_count(False)
+            cpu_per = int(psutil.cpu_percent())
+            res["data"]["cpu"] ={"count":cpu_count,"percent":"{}%".format(cpu_per)}
+
+
+            mem_total = int(psutil.virtual_memory()[0])
+            mem_used = int(psutil.virtual_memory()[3])
+            mem_per = int(psutil.virtual_memory()[2])
+
+            res["data"]["memory"] = {
+                'total': self.format_value(mem_total),
+                'used': self.format_value(mem_used),
+                'percent': "{}%".format(mem_per)
+            }
+
+
+
+            network_sent = int(psutil.net_io_counters()[0] / 8 )  # 每秒接受的kb
+            network_recv = int(psutil.net_io_counters()[1] / 8 )
+
+            res["data"]["network"] = {
+                'sent': self.format_value(network_sent),
+                'recv': self.format_value(network_recv)
+            }
+
+
+            res["result"] = True
+        except Exception as e:
+            raise e
+        return res
+
+    api_doc = {
+
+        "tags": ["监控接口"],
+        "parameters": [
+        ],
+        "responses": {
+            200: {
+                "schema": {
+                    "properties": {
+                    }
+                }
+            }
+        }
+    }
+
+    def format_value(self,value):
+        if value>1024**3:
+            value = "{}GB".format(format(value/1024.0**3,'.1f'))
+        elif value>1024**2:
+            value = "{}MB".format(format(value / 1024.0 ** 2, '.1f'))
+        elif value>1024:
+            value = "{}KB".format(format(value / 1024.0, '.1f'))
+        else:
+            value = "{}B".format(format(value, '.1f'))
+        return value
+
+if __name__ == '__main__':
+    api = Api()
+    api.process()

+# coding=utf-8
+#author:        4N
+#createtime:    2021/3/1
+#email:         nheweijun@sina.com
+
+from app.util import BlueprintApi
+from flasgger import swag_from
+from flask import Blueprint
+from . import task_list
+from . import task_detail
+from . import task_delete
+from . import task_count
+
+class DataManager(BlueprintApi):
+
+    bp = Blueprint("Task", __name__, url_prefix="/API/Task")
+
+
+    @staticmethod
+    @bp.route('/List', methods=['POST'])
+    @swag_from(task_list.Api.api_doc)
+    def api_task_list():
+        """
+        任务列表
+        """
+        return task_list.Api().result
+
+    @staticmethod
+    @bp.route('/Detail', methods=['POST'])
+    @swag_from(task_detail.Api.api_doc)
+    def api_task_detail():
+        """
+        任务详情
+        """
+        return task_detail.Api().result
+
+    @staticmethod
+    @bp.route('/Delete', methods=['POST'])
+    @swag_from(task_delete.Api.api_doc)
+    def task_delete():
+        """
+        删除任务
+        """
+        return task_delete.Api().result
+
+    @staticmethod
+    @bp.route('/Count', methods=['POST'])
+    @swag_from(task_count.Api.api_doc)
+    def task_count():
+        """
+        任务统计
+        """
+        return task_count.Api().result
+
+

+# coding=utf-8
+#author:        4N
+#createtime:    2021/6/15
+#email:         nheweijun@sina.com

+# coding=utf-8
+# author:        4N
+# createtime:    2020/9/4
+# email:         nheweijun@sina.com
+
+from app.models import db,Task
+
+from sqlalchemy import func
+from app.util.component.ApiTemplate import ApiTemplate
+
+
+class Api(ApiTemplate):
+    api_name = "任务统计"
+    def process(self):
+        res= {}
+        try:
+            tasks = db.session.query(func.count(Task.state), Task.state)
+            creator = self.para.get("creator")
+
+            if creator:
+                tasks = tasks.filter_by(creator=creator)
+
+            tasks = tasks.group_by(Task.state).all()
+            res["data"] = {}
+            for task in tasks:
+                res["data"][task[1].__str__()] = task[0]
+
+            for status in ["-1", "0", "1", "2"]:
+                if not res["data"].get(status):
+                    res["data"][status] = 0
+
+            res["result"] = True
+        except Exception as e:
+            raise e
+        return res
+
+
+
+    api_doc = {
+        "tags": ["任务接口"],
+        "parameters": [
+            {"name": "creator",
+             "in": "formData",
+             "type": "string"}
+        ],
+        "responses": {
+            200: {
+                "schema": {
+                    "properties": {
+                    }
+                }
+            }
+        }
+    }

+# coding=utf-8
+#author:        4N
+#createtime:    2020/9/4
+#email:         nheweijun@sina.com
+
+from app.models import db,Task
+
+
+from app.util.component.ApiTemplate import ApiTemplate
+
+
+class Api(ApiTemplate):
+    api_name = "删除任务"
+    def para_check(self):
+        pass
+
+    def process(self):
+        res = {}
+        try:
+            task_guid = self.para.get("task_guid")
+            state = self.para.get("state")
+            creator = self.para.get("creator")
+
+            tasks = Task.query
+            if task_guid:
+                tasks = tasks.filter_by(guid=task_guid)
+            if state:
+                state = int(state)
+                tasks = tasks.filter_by(state=state)
+            if creator:
+                tasks = tasks.filter_by(creator=creator)
+            tasks = tasks.all()
+
+            if not tasks:
+                res["result"] = False
+                res["msg"] = "数据不存在！"
+                return res
+            else:
+                for task in tasks:
+                    db.session.delete(task)
+                db.session.commit()
+                res["msg"] = "删除成功！"
+                res["result"] = True
+        except Exception as e:
+            db.session.rollback()
+            raise e
+        return res
+
+
+    api_doc = {
+        "tags": ["任务接口"],
+        "parameters": [
+            {"name": "task_guid",
+             "in": "formData",
+             "type": "string"},
+            {"name": "state",
+             "in": "formData",
+             "type": "string"},
+            {"name": "creator",
+             "in": "formData",
+             "type": "string"},
+
+        ],
+        "responses": {
+            200: {
+                "schema": {
+                    "properties": {
+                    }
+                }
+            }
+        }
+    }

+# coding=utf-8
+#author:        4N
+#createtime:    2020/9/4
+#email:         nheweijun@sina.com
+
+from app.models import db,Task,Process
+from app.util.component.ApiTemplate import ApiTemplate
+from app.util.component.ModelVisitor import ModelVisitor
+class Api(ApiTemplate):
+    api_name = "任务详情"
+    def para_check(self):
+        if not self.para.get("task_guid"):
+            raise Exception("缺乏task_guid参数。")
+
+    def process(self):
+
+        res = {}
+        try:
+            task_guid = self.para.get("task_guid")
+            task:Task = Task.query.filter_by(guid=task_guid).one_or_none()
+
+            if not task :
+                raise Exception("任务不存在！")
+            else:
+                task_processes = task.relate_processes.order_by(Process.time).all()
+                res["data"] = ModelVisitor.objects_to_jsonarray(task_processes)
+
+                res["result"] = True
+        except Exception as e:
+            raise e
+        return res
+
+    api_doc={
+    "tags":["任务接口"],
+    "parameters":[
+        {"name": "task_guid",
+         "in": "formData",
+         "type": "string"},
+
+    ],
+    "responses":{
+        200:{
+            "schema":{
+                "properties":{
+                }
+            }
+            }
+        }
+    }

+# coding=utf-8
+# author:        4N
+# createtime:    2020/9/4
+# email:         nheweijun@sina.com
+import datetime
+
+
+
+from app.models import Task
+from app.util.component.ApiTemplate import ApiTemplate
+from app.util.component.ModelVisitor import ModelVisitor
+class Api(ApiTemplate):
+    api_name = "任务列表"
+    def para_check(self):
+        pass
+
+    def process(self):
+
+        res = {}
+        res["data"] = {}
+        try:
+            parameter = self.para
+            page_index = int(parameter.get("page_index", "0"))
+            page_size = int(parameter.get("page_size", "10"))
+            name = parameter.get("name")
+            tasks = Task.query.order_by(Task.create_time.desc())
+            start_time = parameter.get("start_time")
+            end_time = parameter.get("end_time")
+            creator = parameter.get("creator")
+
+            state = parameter.get("state")
+
+            if creator:
+                tasks = tasks.filter_by(creator=creator)
+            if start_time and end_time:
+                tasks = tasks.filter(Task.create_time.between(start_time, end_time))
+            if name:
+                tasks = tasks.filter(Task.name.like("%" + name + "%"))
+            if state is not None:
+                state_list = state.split(",")
+                state_list =[int(x) for x in state_list]
+
+                tasks = tasks.filter(Task.state.in_(state_list))
+
+            res["data"]["count"] = tasks.count()
+
+            tasks = tasks.limit(page_size).offset(page_index * page_size).all()
+
+            res["data"]["list"] = [ModelVisitor.task_to_json(task) for task in tasks]
+            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": "start_time",
+         "in": "formData",
+         "type": "string"},
+        {"name": "end_time",
+         "in": "formData",
+         "type": "string"},
+        {"name": "name",
+         "in": "formData",
+         "type": "string"},
+        {"name": "creator",
+         "in": "formData",
+         "type": "string"},
+        {"name": "state",
+         "in": "formData",
+         "type": "string"}
+    ],
+    "responses":{
+        200:{
+            "schema":{
+                "properties":{
+                }
+            }
+            }
+        }
+    }

+# coding=utf-8
+#author:        4N
+#createtime:    2020/8/27
+#email:         nheweijun@sina.com
+
+from flask import Blueprint,request
+from app.util import BlueprintApi
+from . import sample
+from flasgger import swag_from
+
+class Template(BlueprintApi):
+
+    bp = Blueprint("Template", __name__, url_prefix="/API/Template")
+
+    @staticmethod
+    @bp.route('/Sample', methods=['GET'])
+    @swag_from(sample.Api.api_doc)
+    def api_sample():
+        """
+        测试接口
+        """
+        return sample.Api().result
+

+# coding=utf-8
+#author:        4N
+#createtime:    2020/8/27
+#email:         nheweijun@sina.com
+
+
+from flask import current_app
+import os
+
+from app.util.component.ApiTemplate import ApiTemplate
+from app.util.component.StructuredPrint import StructurePrint
+
+from flask import current_app
+class Api(ApiTemplate):
+
+    def para_check(self):
+        if self.para.get("content") is None:
+            raise Exception("缺乏content参数")
+
+    def log(self):
+        current_app.logger.info('info log')
+
+    def process(self):
+
+        result=dict()
+        result.update(self.para)
+        result["root_path"] = os.path.dirname(current_app.instance_path)
+        return result
+
+
+    api_doc= {
+        "tags": ["测试接口"],
+        "description": "测试接口",
+        "parameters": [
+            {"name": "content",
+             "in": "query"}
+        ],
+        "responses": {
+            200: {
+                "schema": {
+                    "properties": {
+                        "content": {
+                            "type": "string",
+                            "description": "The name of the user"
+                        }
+                    }
+                }
+            }
+        }
+    }
+
+

+.mapboxgl-map {
+    font: 12px/20px 'Helvetica Neue', Arial, Helvetica, sans-serif;
+    overflow: hidden;
+    position: relative;
+    -webkit-tap-highlight-color: rgba(0,0,0,0);
+}
+
+.mapboxgl-canvas-container.mapboxgl-interactive,
+.mapboxgl-ctrl-nav-compass {
+    cursor: -webkit-grab;
+    cursor: -moz-grab;
+    cursor: grab;
+}
+.mapboxgl-canvas-container.mapboxgl-interactive:active,
+.mapboxgl-ctrl-nav-compass:active {
+    cursor: -webkit-grabbing;
+    cursor: -moz-grabbing;
+    cursor: grabbing;
+}
+
+.mapboxgl-canvas-container.mapboxgl-touch-zoom-rotate {
+    -ms-touch-action: pan-x pan-y;
+    touch-action: pan-x pan-y;
+}
+.mapboxgl-canvas-container.mapboxgl-touch-drag-pan {
+    -ms-touch-action: pinch-zoom;
+}
+.mapboxgl-canvas-container.mapboxgl-touch-zoom-rotate.mapboxgl-touch-drag-pan {
+    -ms-touch-action: none;
+    touch-action: none;
+}
+.mapboxgl-ctrl-top-left,
+.mapboxgl-ctrl-top-right,
+.mapboxgl-ctrl-bottom-left,
+.mapboxgl-ctrl-bottom-right  { position:absolute; pointer-events:none; z-index:2; }
+.mapboxgl-ctrl-top-left      { top:0; left:0; }
+.mapboxgl-ctrl-top-right     { top:0; right:0; }
+.mapboxgl-ctrl-bottom-left   { bottom:0; left:0; }
+.mapboxgl-ctrl-bottom-right  { right:0; bottom:0; }
+
+.mapboxgl-ctrl { clear:both; pointer-events:auto }
+.mapboxgl-ctrl-top-left .mapboxgl-ctrl { margin:10px 0 0 10px; float:left; }
+.mapboxgl-ctrl-top-right .mapboxgl-ctrl{ margin:10px 10px 0 0; float:right; }
+.mapboxgl-ctrl-bottom-left .mapboxgl-ctrl { margin:0 0 10px 10px; float:left; }
+.mapboxgl-ctrl-bottom-right .mapboxgl-ctrl { margin:0 10px 10px 0; float:right; }
+
+.mapboxgl-ctrl-group {
+    border-radius: 4px;
+    -moz-box-shadow: 0px 0px 2px rgba(0,0,0,0.1);
+    -webkit-box-shadow: 0px 0px 2px rgba(0,0,0,0.1);
+    box-shadow: 0px 0px 0px 2px rgba(0,0,0,0.1);
+    overflow: hidden;
+    background: #fff;
+}
+.mapboxgl-ctrl-group > button {
+    width: 30px;
+    height: 30px;
+    display: block;
+    padding: 0;
+    outline: none;
+    border: none;
+    border-bottom: 1px solid #ddd;
+    box-sizing: border-box;
+    background-color: rgba(0,0,0,0);
+    cursor: pointer;
+}
+/* https://bugzilla.mozilla.org/show_bug.cgi?id=140562 */
+.mapboxgl-ctrl > button::-moz-focus-inner {
+    border: 0;
+    padding: 0;
+}
+.mapboxgl-ctrl > button:last-child {
+    border-bottom: 0;
+}
+.mapboxgl-ctrl > button:hover {
+    background-color: rgba(0,0,0,0.05);
+}
+.mapboxgl-ctrl-icon,
+.mapboxgl-ctrl-icon > .mapboxgl-ctrl-compass-arrow {
+    speak: none;
+    -webkit-font-smoothing: antialiased;
+    -moz-osx-font-smoothing: grayscale;
+}
+.mapboxgl-ctrl-icon {
+    padding: 5px;
+}
+.mapboxgl-ctrl-icon.mapboxgl-ctrl-zoom-out {
+    background-image: url("data:image/svg+xml;charset=utf8,%3Csvg%20viewBox%3D%270%200%2020%2020%27%20xmlns%3D%27http%3A%2F%2Fwww.w3.org%2F2000%2Fsvg%27%3E%0A%20%20%3Cpath%20style%3D%27fill%3A%23333333%3B%27%20d%3D%27m%207%2C9%20c%20-0.554%2C0%20-1%2C0.446%20-1%2C1%200%2C0.554%200.446%2C1%201%2C1%20l%206%2C0%20c%200.554%2C0%201%2C-0.446%201%2C-1%200%2C-0.554%20-0.446%2C-1%20-1%2C-1%20z%27%20%2F%3E%0A%3C%2Fsvg%3E%0A");
+}
+.mapboxgl-ctrl-icon.mapboxgl-ctrl-zoom-in {
+    background-image: url("data:image/svg+xml;charset=utf8,%3Csvg%20viewBox%3D%270%200%2020%2020%27%20xmlns%3D%27http%3A%2F%2Fwww.w3.org%2F2000%2Fsvg%27%3E%0A%20%20%3Cpath%20style%3D%27fill%3A%23333333%3B%27%20d%3D%27M%2010%206%20C%209.446%206%209%206.4459904%209%207%20L%209%209%20L%207%209%20C%206.446%209%206%209.446%206%2010%20C%206%2010.554%206.446%2011%207%2011%20L%209%2011%20L%209%2013%20C%209%2013.55401%209.446%2014%2010%2014%20C%2010.554%2014%2011%2013.55401%2011%2013%20L%2011%2011%20L%2013%2011%20C%2013.554%2011%2014%2010.554%2014%2010%20C%2014%209.446%2013.554%209%2013%209%20L%2011%209%20L%2011%207%20C%2011%206.4459904%2010.554%206%2010%206%20z%27%20%2F%3E%0A%3C%2Fsvg%3E%0A");
+}
+.mapboxgl-ctrl-icon.mapboxgl-ctrl-geolocate  {
+    background-image: url("data:image/svg+xml;charset=utf-8,%3Csvg%20viewBox%3D%270%200%2020%2020%27%20xmlns%3D%27http%3A%2F%2Fwww.w3.org%2F2000%2Fsvg%27%3E%0D%0A%20%20%3Cpath%20style%3D%27fill%3A%23333%3B%27%20d%3D%27M10%204C9%204%209%205%209%205L9%205.1A5%205%200%200%200%205.1%209L5%209C5%209%204%209%204%2010%204%2011%205%2011%205%2011L5.1%2011A5%205%200%200%200%209%2014.9L9%2015C9%2015%209%2016%2010%2016%2011%2016%2011%2015%2011%2015L11%2014.9A5%205%200%200%200%2014.9%2011L15%2011C15%2011%2016%2011%2016%2010%2016%209%2015%209%2015%209L14.9%209A5%205%200%200%200%2011%205.1L11%205C11%205%2011%204%2010%204zM10%206.5A3.5%203.5%200%200%201%2013.5%2010%203.5%203.5%200%200%201%2010%2013.5%203.5%203.5%200%200%201%206.5%2010%203.5%203.5%200%200%201%2010%206.5zM10%208.3A1.8%201.8%200%200%200%208.3%2010%201.8%201.8%200%200%200%2010%2011.8%201.8%201.8%200%200%200%2011.8%2010%201.8%201.8%200%200%200%2010%208.3z%27%20%2F%3E%0D%0A%3C%2Fsvg%3E");
+}
+.mapboxgl-ctrl-icon.mapboxgl-ctrl-geolocate.mapboxgl-watching  {
+    background-image: url("data:image/svg+xml;charset=utf-8,%3Csvg%20viewBox%3D%270%200%2020%2020%27%20xmlns%3D%27http%3A%2F%2Fwww.w3.org%2F2000%2Fsvg%27%3E%0D%0A%20%20%3Cpath%20style%3D%27fill%3A%2300f%3B%27%20d%3D%27M10%204C9%204%209%205%209%205L9%205.1A5%205%200%200%200%205.1%209L5%209C5%209%204%209%204%2010%204%2011%205%2011%205%2011L5.1%2011A5%205%200%200%200%209%2014.9L9%2015C9%2015%209%2016%2010%2016%2011%2016%2011%2015%2011%2015L11%2014.9A5%205%200%200%200%2014.9%2011L15%2011C15%2011%2016%2011%2016%2010%2016%209%2015%209%2015%209L14.9%209A5%205%200%200%200%2011%205.1L11%205C11%205%2011%204%2010%204zM10%206.5A3.5%203.5%200%200%201%2013.5%2010%203.5%203.5%200%200%201%2010%2013.5%203.5%203.5%200%200%201%206.5%2010%203.5%203.5%200%200%201%2010%206.5zM10%208.3A1.8%201.8%200%200%200%208.3%2010%201.8%201.8%200%200%200%2010%2011.8%201.8%201.8%200%200%200%2011.8%2010%201.8%201.8%200%200%200%2010%208.3z%27%20%2F%3E%0D%0A%3C%2Fsvg%3E");
+}
+.mapboxgl-ctrl-icon.mapboxgl-ctrl-fullscreen  {
+    background-image: url("data:image/svg+xml;base64,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");
+}
+.mapboxgl-ctrl-icon.mapboxgl-ctrl-shrink  {
+    background-image: url("data:image/svg+xml;base64,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");
+}
+.mapboxgl-ctrl-icon.mapboxgl-ctrl-compass > .mapboxgl-ctrl-compass-arrow {
+    width: 20px;
+    height: 20px;
+    margin: 5px;
+    background-image: url("data:image/svg+xml;charset=utf8,%3Csvg%20xmlns%3D%27http%3A%2F%2Fwww.w3.org%2F2000%2Fsvg%27%20viewBox%3D%270%200%2020%2020%27%3E%0A%09%3Cpolygon%20fill%3D%27%23333333%27%20points%3D%276%2C9%2010%2C1%2014%2C9%27%2F%3E%0A%09%3Cpolygon%20fill%3D%27%23CCCCCC%27%20points%3D%276%2C11%2010%2C19%2014%2C11%20%27%2F%3E%0A%3C%2Fsvg%3E");
+    background-repeat: no-repeat;
+    display: inline-block;
+}
+
+a.mapboxgl-ctrl-logo {
+    width: 85px;
+    height: 21px;
+    margin: 0 0 -3px -3px;
+    display: block;
+    background-repeat: no-repeat;
+    cursor: pointer;
+    background-image: url(data:image/svg+xml;base64,<?xml version="1.0" encoding="utf-8"?><svg version="1.1" id="Layer_1" xmlns="http://www.w3.org/2000/svg" xmlns:xlink="http://www.w3.org/1999/xlink" x="0px" y="0px"   viewBox="0 0 84.49 21" style="enable-background:new 0 0 84.49 21;" xml:space="preserve"><g>  <path class="st0" style="opacity:0.9; fill: #FFFFFF; enable-background: new;" d="M83.25,14.26c0,0.12-0.09,0.21-0.21,0.21h-1.61c-0.13,0-0.24-0.06-0.3-0.17l-1.44-2.39l-1.44,2.39    c-0.06,0.11-0.18,0.17-0.3,0.17h-1.61c-0.04,0-0.08-0.01-0.12-0.03c-0.09-0.06-0.13-0.19-0.06-0.28l0,0l2.43-3.68L76.2,6.84    c-0.02-0.03-0.03-0.07-0.03-0.12c0-0.12,0.09-0.21,0.21-0.21h1.61c0.13,0,0.24,0.06,0.3,0.17l1.41,2.36l1.4-2.35    c0.06-0.11,0.18-0.17,0.3-0.17H83c0.04,0,0.08,0.01,0.12,0.03c0.09,0.06,0.13,0.19,0.06,0.28l0,0l-2.37,3.63l2.43,3.67    C83.24,14.18,83.25,14.22,83.25,14.26z"/>  <path class="st0" style="opacity:0.9; fill: #FFFFFF; enable-background: new;" d="M66.24,9.59c-0.39-1.88-1.96-3.28-3.84-3.28c-1.03,0-2.03,0.42-2.73,1.18V3.51c0-0.13-0.1-0.23-0.23-0.23h-1.4    c-0.13,0-0.23,0.11-0.23,0.23v10.72c0,0.13,0.1,0.23,0.23,0.23h1.4c0.13,0,0.23-0.11,0.23-0.23V13.5c0.71,0.75,1.7,1.18,2.73,1.18    c1.88,0,3.45-1.41,3.84-3.29C66.37,10.79,66.37,10.18,66.24,9.59L66.24,9.59z M62.08,13c-1.32,0-2.39-1.11-2.41-2.48v-0.06    c0.02-1.38,1.09-2.48,2.41-2.48s2.42,1.12,2.42,2.51S63.41,13,62.08,13z"/>  <path class="st0" style="opacity:0.9; fill: #FFFFFF; enable-background: new;" d="M71.67,6.32c-1.98-0.01-3.72,1.35-4.16,3.29c-0.13,0.59-0.13,1.19,0,1.77c0.44,1.94,2.17,3.32,4.17,3.3    c2.35,0,4.26-1.87,4.26-4.19S74.04,6.32,71.67,6.32z M71.65,13.01c-1.33,0-2.42-1.12-2.42-2.51s1.08-2.52,2.42-2.52    c1.33,0,2.42,1.12,2.42,2.51S72.99,13,71.65,13.01L71.65,13.01z"/>  <path class="st1" style="opacity:0.35; enable-background:new;" d="M62.08,7.98c-1.32,0-2.39,1.11-2.41,2.48v0.06C59.68,11.9,60.75,13,62.08,13s2.42-1.12,2.42-2.51    S63.41,7.98,62.08,7.98z M62.08,11.76c-0.63,0-1.14-0.56-1.17-1.25v-0.04c0.01-0.69,0.54-1.25,1.17-1.25    c0.63,0,1.17,0.57,1.17,1.27C63.24,11.2,62.73,11.76,62.08,11.76z"/>  <path class="st1" style="opacity:0.35; enable-background:new;" d="M71.65,7.98c-1.33,0-2.42,1.12-2.42,2.51S70.32,13,71.65,13s2.42-1.12,2.42-2.51S72.99,7.98,71.65,7.98z     M71.65,11.76c-0.64,0-1.17-0.57-1.17-1.27c0-0.7,0.53-1.26,1.17-1.26s1.17,0.57,1.17,1.27C72.82,11.21,72.29,11.76,71.65,11.76z"    />  <path class="st0" style="opacity:0.9; fill: #FFFFFF; enable-background: new;" d="M45.74,6.53h-1.4c-0.13,0-0.23,0.11-0.23,0.23v0.73c-0.71-0.75-1.7-1.18-2.73-1.18    c-2.17,0-3.94,1.87-3.94,4.19s1.77,4.19,3.94,4.19c1.04,0,2.03-0.43,2.73-1.19v0.73c0,0.13,0.1,0.23,0.23,0.23h1.4    c0.13,0,0.23-0.11,0.23-0.23V6.74c0-0.12-0.09-0.22-0.22-0.22C45.75,6.53,45.75,6.53,45.74,6.53z M44.12,10.53    C44.11,11.9,43.03,13,41.71,13s-2.42-1.12-2.42-2.51s1.08-2.52,2.4-2.52c1.33,0,2.39,1.11,2.41,2.48L44.12,10.53z"/>  <path class="st1" style="opacity:0.35; enable-background:new;" d="M41.71,7.98c-1.33,0-2.42,1.12-2.42,2.51S40.37,13,41.71,13s2.39-1.11,2.41-2.48v-0.06    C44.1,9.09,43.03,7.98,41.71,7.98z M40.55,10.49c0-0.7,0.52-1.27,1.17-1.27c0.64,0,1.14,0.56,1.17,1.25v0.04    c-0.01,0.68-0.53,1.24-1.17,1.24C41.08,11.75,40.55,11.19,40.55,10.49z"/>  <path class="st0" style="opacity:0.9; fill: #FFFFFF; enable-background: new;" d="M52.41,6.32c-1.03,0-2.03,0.42-2.73,1.18V6.75c0-0.13-0.1-0.23-0.23-0.23h-1.4c-0.13,0-0.23,0.11-0.23,0.23    v10.72c0,0.13,0.1,0.23,0.23,0.23h1.4c0.13,0,0.23-0.1,0.23-0.23V13.5c0.71,0.75,1.7,1.18,2.74,1.18c2.17,0,3.94-1.87,3.94-4.19    S54.58,6.32,52.41,6.32z M52.08,13.01c-1.32,0-2.39-1.11-2.42-2.48v-0.07c0.02-1.38,1.09-2.49,2.4-2.49c1.32,0,2.41,1.12,2.41,2.51    S53.4,13,52.08,13.01L52.08,13.01z"/>  <path class="st1" style="opacity:0.35; enable-background:new;" d="M52.08,7.98c-1.32,0-2.39,1.11-2.42,2.48v0.06c0.03,1.38,1.1,2.48,2.42,2.48s2.41-1.12,2.41-2.51    S53.4,7.98,52.08,7.98z M52.08,11.76c-0.63,0-1.14-0.56-1.17-1.25v-0.04c0.01-0.69,0.54-1.25,1.17-1.25c0.63,0,1.17,0.58,1.17,1.27    S52.72,11.76,52.08,11.76z"/>  <path class="st0" style="opacity:0.9; fill: #FFFFFF; enable-background: new;" d="M36.08,14.24c0,0.13-0.1,0.23-0.23,0.23h-1.41c-0.13,0-0.23-0.11-0.23-0.23V9.68c0-0.98-0.74-1.71-1.62-1.71    c-0.8,0-1.46,0.7-1.59,1.62l0.01,4.66c0,0.13-0.11,0.23-0.23,0.23h-1.41c-0.13,0-0.23-0.11-0.23-0.23V9.68    c0-0.98-0.74-1.71-1.62-1.71c-0.85,0-1.54,0.79-1.6,1.8v4.48c0,0.13-0.1,0.23-0.23,0.23h-1.4c-0.13,0-0.23-0.11-0.23-0.23V6.74    c0.01-0.13,0.1-0.22,0.23-0.22h1.4c0.13,0,0.22,0.11,0.23,0.22V7.4c0.5-0.68,1.3-1.09,2.16-1.1h0.03c1.09,0,2.09,0.6,2.6,1.55    c0.45-0.95,1.4-1.55,2.44-1.56c1.62,0,2.93,1.25,2.9,2.78L36.08,14.24z"/>  <path class="st1" style="opacity:0.35; enable-background:new;" d="M84.34,13.59l-0.07-0.13l-1.96-2.99l1.94-2.95c0.44-0.67,0.26-1.56-0.41-2.02c-0.02,0-0.03,0-0.04-0.01    c-0.23-0.15-0.5-0.22-0.78-0.22h-1.61c-0.56,0-1.08,0.29-1.37,0.78L79.72,6.6l-0.34-0.56C79.09,5.56,78.57,5.27,78,5.27h-1.6    c-0.6,0-1.13,0.37-1.35,0.92c-2.19-1.66-5.28-1.47-7.26,0.45c-0.35,0.34-0.65,0.72-0.89,1.14c-0.9-1.62-2.58-2.72-4.5-2.72    c-0.5,0-1.01,0.07-1.48,0.23V3.51c0-0.82-0.66-1.48-1.47-1.48h-1.4c-0.81,0-1.47,0.66-1.47,1.47v3.75    c-0.95-1.36-2.5-2.18-4.17-2.19c-0.74,0-1.46,0.16-2.12,0.47c-0.24-0.17-0.54-0.26-0.84-0.26h-1.4c-0.45,0-0.87,0.21-1.15,0.56    c-0.02-0.03-0.04-0.05-0.07-0.08c-0.28-0.3-0.68-0.47-1.09-0.47h-1.39c-0.3,0-0.6,0.09-0.84,0.26c-0.67-0.3-1.39-0.46-2.12-0.46    c-1.83,0-3.43,1-4.37,2.5c-0.2-0.46-0.48-0.89-0.83-1.25c-0.8-0.81-1.89-1.25-3.02-1.25h-0.01c-0.89,0.01-1.75,0.33-2.46,0.88    c-0.74-0.57-1.64-0.88-2.57-0.88H28.1c-0.29,0-0.58,0.03-0.86,0.11c-0.28,0.06-0.56,0.16-0.82,0.28c-0.21-0.12-0.45-0.18-0.7-0.18    h-1.4c-0.82,0-1.47,0.66-1.47,1.47v7.5c0,0.82,0.66,1.47,1.47,1.47h1.4c0.82,0,1.48-0.66,1.48-1.48l0,0V9.79    c0.03-0.36,0.23-0.59,0.36-0.59c0.18,0,0.38,0.18,0.38,0.47v4.57c0,0.82,0.66,1.47,1.47,1.47h1.41c0.82,0,1.47-0.66,1.47-1.47    l-0.01-4.57c0.06-0.32,0.25-0.47,0.35-0.47c0.18,0,0.38,0.18,0.38,0.47v4.57c0,0.82,0.66,1.47,1.47,1.47h1.41    c0.82,0,1.47-0.66,1.47-1.47v-0.38c0.96,1.29,2.46,2.06,4.06,2.06c0.74,0,1.46-0.16,2.12-0.47c0.24,0.17,0.54,0.26,0.84,0.26h1.39    c0.3,0,0.6-0.09,0.84-0.26v2.01c0,0.82,0.66,1.47,1.47,1.47h1.4c0.82,0,1.47-0.66,1.47-1.47v-1.77c0.48,0.15,0.99,0.23,1.49,0.22    c1.7,0,3.22-0.87,4.17-2.2v0.52c0,0.82,0.66,1.47,1.47,1.47h1.4c0.3,0,0.6-0.09,0.84-0.26c0.66,0.31,1.39,0.47,2.12,0.47    c1.92,0,3.6-1.1,4.49-2.73c1.54,2.65,4.95,3.53,7.58,1.98c0.18-0.11,0.36-0.22,0.53-0.36c0.22,0.55,0.76,0.91,1.35,0.9H78    c0.56,0,1.08-0.29,1.37-0.78l0.37-0.61l0.37,0.61c0.29,0.48,0.81,0.78,1.38,0.78h1.6c0.81,0,1.46-0.66,1.45-1.46    C84.49,14.02,84.44,13.8,84.34,13.59L84.34,13.59z M35.86,14.47h-1.41c-0.13,0-0.23-0.11-0.23-0.23V9.68    c0-0.98-0.74-1.71-1.62-1.71c-0.8,0-1.46,0.7-1.59,1.62l0.01,4.66c0,0.13-0.1,0.23-0.23,0.23h-1.41c-0.13,0-0.23-0.11-0.23-0.23    V9.68c0-0.98-0.74-1.71-1.62-1.71c-0.85,0-1.54,0.79-1.6,1.8v4.48c0,0.13-0.1,0.23-0.23,0.23h-1.4c-0.13,0-0.23-0.11-0.23-0.23    V6.74c0.01-0.13,0.11-0.22,0.23-0.22h1.4c0.13,0,0.22,0.11,0.23,0.22V7.4c0.5-0.68,1.3-1.09,2.16-1.1h0.03    c1.09,0,2.09,0.6,2.6,1.55c0.45-0.95,1.4-1.55,2.44-1.56c1.62,0,2.93,1.25,2.9,2.78l0.01,5.16C36.09,14.36,35.98,14.46,35.86,14.47    L35.86,14.47z M45.97,14.24c0,0.13-0.1,0.23-0.23,0.23h-1.4c-0.13,0-0.23-0.11-0.23-0.23V13.5c-0.7,0.76-1.69,1.18-2.72,1.18    c-2.17,0-3.94-1.87-3.94-4.19s1.77-4.19,3.94-4.19c1.03,0,2.02,0.43,2.73,1.18V6.74c0-0.13,0.1-0.23,0.23-0.23h1.4    c0.12-0.01,0.22,0.08,0.23,0.21c0,0.01,0,0.01,0,0.02v7.51h-0.01V14.24z M52.41,14.67c-1.03,0-2.02-0.43-2.73-1.18v3.97    c0,0.13-0.1,0.23-0.23,0.23h-1.4c-0.13,0-0.23-0.1-0.23-0.23V6.75c0-0.13,0.1-0.22,0.23-0.22h1.4c0.13,0,0.23,0.11,0.23,0.23v0.73    c0.71-0.76,1.7-1.18,2.73-1.18c2.17,0,3.94,1.86,3.94,4.18S54.58,14.67,52.41,14.67z M66.24,11.39c-0.39,1.87-1.96,3.29-3.84,3.29    c-1.03,0-2.02-0.43-2.73-1.18v0.73c0,0.13-0.1,0.23-0.23,0.23h-1.4c-0.13,0-0.23-0.11-0.23-0.23V3.51c0-0.13,0.1-0.23,0.23-0.23    h1.4c0.13,0,0.23,0.11,0.23,0.23v3.97c0.71-0.75,1.7-1.18,2.73-1.17c1.88,0,3.45,1.4,3.84,3.28C66.37,10.19,66.37,10.8,66.24,11.39    L66.24,11.39L66.24,11.39z M71.67,14.68c-2,0.01-3.73-1.35-4.17-3.3c-0.13-0.59-0.13-1.19,0-1.77c0.44-1.94,2.17-3.31,4.17-3.3    c2.36,0,4.26,1.87,4.26,4.19S74.03,14.68,71.67,14.68L71.67,14.68z M83.04,14.47h-1.61c-0.13,0-0.24-0.06-0.3-0.17l-1.44-2.39    l-1.44,2.39c-0.06,0.11-0.18,0.17-0.3,0.17h-1.61c-0.04,0-0.08-0.01-0.12-0.03c-0.09-0.06-0.13-0.19-0.06-0.28l0,0l2.43-3.68    L76.2,6.84c-0.02-0.03-0.03-0.07-0.03-0.12c0-0.12,0.09-0.21,0.21-0.21h1.61c0.13,0,0.24,0.06,0.3,0.17l1.41,2.36l1.41-2.36    c0.06-0.11,0.18-0.17,0.3-0.17h1.61c0.04,0,0.08,0.01,0.12,0.03c0.09,0.06,0.13,0.19,0.06,0.28l0,0l-2.38,3.64l2.43,3.67    c0.02,0.03,0.03,0.07,0.03,0.12C83.25,14.38,83.16,14.47,83.04,14.47L83.04,14.47L83.04,14.47z"/>  <path class="st0" style="opacity:0.9; fill: #FFFFFF; enable-background: new;" d="M10.5,1.24c-5.11,0-9.25,4.15-9.25,9.25s4.15,9.25,9.25,9.25s9.25-4.15,9.25-9.25    C19.75,5.38,15.61,1.24,10.5,1.24z M14.89,12.77c-1.93,1.93-4.78,2.31-6.7,2.31c-0.7,0-1.41-0.05-2.1-0.16c0,0-1.02-5.64,2.14-8.81    c0.83-0.83,1.95-1.28,3.13-1.28c1.27,0,2.49,0.51,3.39,1.42C16.59,8.09,16.64,11,14.89,12.77z"/>  <path class="st1" style="opacity:0.35; enable-background:new;" d="M10.5-0.01C4.7-0.01,0,4.7,0,10.49s4.7,10.5,10.5,10.5S21,16.29,21,10.49C20.99,4.7,16.3-0.01,10.5-0.01z     M10.5,19.74c-5.11,0-9.25-4.15-9.25-9.25s4.14-9.26,9.25-9.26s9.25,4.15,9.25,9.25C19.75,15.61,15.61,19.74,10.5,19.74z"/>  <path class="st1" style="opacity:0.35; enable-background:new;" d="M14.74,6.25C12.9,4.41,9.98,4.35,8.23,6.1c-3.16,3.17-2.14,8.81-2.14,8.81s5.64,1.02,8.81-2.14    C16.64,11,16.59,8.09,14.74,6.25z M12.47,10.34l-0.91,1.87l-0.9-1.87L8.8,9.43l1.86-0.9l0.9-1.87l0.91,1.87l1.86,0.9L12.47,10.34z"    />  <polygon class="st0" style="opacity:0.9; fill: #FFFFFF; enable-background: new;" points="14.33,9.43 12.47,10.34 11.56,12.21 10.66,10.34 8.8,9.43 10.66,8.53 11.56,6.66 12.47,8.53   "/></g></svg>);
+}
+
+.mapboxgl-ctrl.mapboxgl-ctrl-attrib {
+    padding: 0 5px;
+    background-color: rgba(255, 255, 255, .5);
+    margin: 0;
+}
+.mapboxgl-ctrl-attrib.mapboxgl-compact {
+    padding-top: 2px;
+    padding-bottom: 2px;
+    margin: 0 10px 10px 10px;
+    position: relative;
+    padding-right: 24px;
+    background-color: #fff;
+    border-radius: 3px 12px 12px 3px;
+    visibility: hidden;
+}
+.mapboxgl-ctrl-attrib.mapboxgl-compact:hover {
+    visibility: visible;
+}
+.mapboxgl-ctrl-attrib.mapboxgl-compact:after {
+    content: '';
+    cursor: pointer;
+    position: absolute;
+    bottom: 0;
+    right: 0;
+    background-image: url("data:image/svg+xml;charset=utf-8,%3Csvg%20viewBox%3D%270%200%2020%2020%27%20xmlns%3D%27http%3A%2F%2Fwww.w3.org%2F2000%2Fsvg%27%3E%0D%0A%09%3Cpath%20fill%3D%27%23333333%27%20fill-rule%3D%27evenodd%27%20d%3D%27M4%2C10a6%2C6%200%201%2C0%2012%2C0a6%2C6%200%201%2C0%20-12%2C0%20M9%2C7a1%2C1%200%201%2C0%202%2C0a1%2C1%200%201%2C0%20-2%2C0%20M9%2C10a1%2C1%200%201%2C1%202%2C0l0%2C3a1%2C1%200%201%2C1%20-2%2C0%27%20%2F%3E%0D%0A%3C%2Fsvg%3E");
+    background-color: rgba(255, 255, 255, .5);
+    width: 24px;
+    height: 24px;
+    box-sizing: border-box;
+    visibility: visible;
+    border-radius: 12px;
+}
+.mapboxgl-ctrl-attrib a {
+    color: rgba(0,0,0,0.75);
+    text-decoration: none;
+}
+.mapboxgl-ctrl-attrib a:hover {
+    color: inherit;
+    text-decoration: underline;
+}
+/* stylelint-disable */
+.mapboxgl-ctrl-attrib .mapbox-improve-map {
+    font-weight: bold;
+    margin-left: 2px;
+}
+/*stylelint-enable*/
+.mapboxgl-ctrl-scale {
+    background-color: rgba(255,255,255,0.75);
+    font-size: 10px;
+    border-width: medium 2px 2px;
+    border-style: none solid solid;
+    border-color: #333;
+    padding: 0 5px;
+    color: #333;
+}
+
+.mapboxgl-popup {
+    position: absolute;
+    top: 0;
+    left: 0;
+    display: -webkit-flex;
+    display: flex;
+    will-change: transform;
+    pointer-events: none;
+}
+.mapboxgl-popup-anchor-top,
+.mapboxgl-popup-anchor-top-left,
+.mapboxgl-popup-anchor-top-right {
+    -webkit-flex-direction: column;
+    flex-direction: column;
+}
+.mapboxgl-popup-anchor-bottom,
+.mapboxgl-popup-anchor-bottom-left,
+.mapboxgl-popup-anchor-bottom-right {
+    -webkit-flex-direction: column-reverse;
+    flex-direction: column-reverse;
+}
+.mapboxgl-popup-anchor-left {
+    -webkit-flex-direction: row;
+    flex-direction: row;
+}
+.mapboxgl-popup-anchor-right {
+    -webkit-flex-direction: row-reverse;
+    flex-direction: row-reverse;
+}
+.mapboxgl-popup-tip {
+    width: 0;
+    height: 0;
+    border: 10px solid transparent;
+    z-index: 1;
+}
+.mapboxgl-popup-anchor-top .mapboxgl-popup-tip {
+    -webkit-align-self: center;
+    align-self: center;
+    border-top: none;
+    border-bottom-color: #fff;
+}
+.mapboxgl-popup-anchor-top-left .mapboxgl-popup-tip {
+    -webkit-align-self: flex-start;
+    align-self: flex-start;
+    border-top: none;
+    border-left: none;
+    border-bottom-color: #fff;
+}
+.mapboxgl-popup-anchor-top-right .mapboxgl-popup-tip {
+    -webkit-align-self: flex-end;
+    align-self: flex-end;
+    border-top: none;
+    border-right: none;
+    border-bottom-color: #fff;
+}
+.mapboxgl-popup-anchor-bottom .mapboxgl-popup-tip {
+    -webkit-align-self: center;
+    align-self: center;
+    border-bottom: none;
+    border-top-color: #fff;
+}
+.mapboxgl-popup-anchor-bottom-left .mapboxgl-popup-tip {
+    -webkit-align-self: flex-start;
+    align-self: flex-start;
+    border-bottom: none;
+    border-left: none;
+    border-top-color: #fff;
+}
+.mapboxgl-popup-anchor-bottom-right .mapboxgl-popup-tip {
+    -webkit-align-self: flex-end;
+    align-self: flex-end;
+    border-bottom: none;
+    border-right: none;
+    border-top-color: #fff;
+}
+.mapboxgl-popup-anchor-left .mapboxgl-popup-tip {
+    -webkit-align-self: center;
+    align-self: center;
+    border-left: none;
+    border-right-color: #fff;
+}
+.mapboxgl-popup-anchor-right .mapboxgl-popup-tip {
+    -webkit-align-self: center;
+    align-self: center;
+    border-right: none;
+    border-left-color: #fff;
+}
+.mapboxgl-popup-close-button {
+    position: absolute;
+    right: 0;
+    top: 0;
+    border: none;
+    border-radius: 0 3px 0 0;
+    cursor: pointer;
+    background-color: rgba(0,0,0,0);
+}
+.mapboxgl-popup-close-button:hover {
+    background-color: rgba(0,0,0,0.05);
+}
+.mapboxgl-popup-content {
+    position: relative;
+    background: #fff;
+    border-radius: 3px;
+    box-shadow: 0 1px 2px rgba(0,0,0,0.10);
+    padding: 10px 10px 15px;
+    pointer-events: auto;
+}
+.mapboxgl-popup-anchor-top-left .mapboxgl-popup-content {
+    border-top-left-radius: 0;
+}
+.mapboxgl-popup-anchor-top-right .mapboxgl-popup-content {
+    border-top-right-radius: 0;
+}
+.mapboxgl-popup-anchor-bottom-left .mapboxgl-popup-content {
+    border-bottom-left-radius: 0;
+}
+.mapboxgl-popup-anchor-bottom-right .mapboxgl-popup-content {
+    border-bottom-right-radius: 0;
+}
+
+.mapboxgl-marker {
+    position: absolute;
+    top: 0;
+    left: 0;
+    will-change: transform;
+}
+
+.mapboxgl-crosshair,
+.mapboxgl-crosshair .mapboxgl-interactive,
+.mapboxgl-crosshair .mapboxgl-interactive:active {
+    cursor: crosshair;
+}
+.mapboxgl-boxzoom {
+    position: absolute;
+    top: 0;
+    left: 0;
+    width: 0;
+    height: 0;
+    background: #fff;
+    border: 2px dotted #202020;
+    opacity: 0.5;
+}
+
+@media print {
+/* stylelint-disable */
+    .mapbox-improve-map {
+        display:none;
+    }
+/* stylelint-enable */
+}