从3.0整合新功能

@@ -8,15 +8,17 @@ from app.models import Database,db,DES,Table,Columns,TableVacuate
 import uuid
 from . import database_test
 # from app.util import open_pg_data_source
-from osgeo.ogr import DataSource,Layer,FeatureDefn,FieldDefn,Feature
+from osgeo.ogr import DataSource,Layer,FeatureDefn,FieldDefn,Feature,Geometry
 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.SQLUtil import SQLUtil
 from app.util.component.GeometryAdapter import GeometryAdapter
+from app.util.component.StructuredPrint import StructurePrint
 class Api(ApiTemplate):
-    api_name = "数据库注册"
+    api_name = "注册数据库"
     def process(self):
         res ={}
         res["result"] = False
@@ -29,7 +31,7 @@ class Api(ApiTemplate):
             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)
     
@@ -87,26 +89,29 @@ class Api(ApiTemplate):
 
     def register_table(self,database):
         this_time = datetime.datetime.now()
+
         pg_ds: DataSource = PGUtil.open_pg_data_source(1, DES.decode(database.sqlalchemy_uri))
+        db_tuple = PGUtil.get_info_from_sqlachemy_uri(DES.decode(database.sqlalchemy_uri))
 
         # 注册空间表
-        spatial_table_name,tables = self.register_spatial_table(pg_ds, database, this_time)
+        spatial_table_name,tables = self.register_spatial_table(pg_ds, database, this_time,db_tuple)
 
         #注册抽稀表
-        self.regiser_vacuate_talbe(pg_ds,tables)
+        self.regiser_vacuate_table(pg_ds,tables,db_tuple)
 
         #注册普通表
-        self.register_common_table(this_time,database,spatial_table_name)
+        self.register_common_table(this_time,database,spatial_table_name,db_tuple)
 
         pg_ds.Destroy()
 
 
-    def register_spatial_table(self,pg_ds,database,this_time):
+    def register_spatial_table(self,pg_ds,database,this_time,db_tuple):
         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
@@ -116,9 +121,15 @@ class Api(ApiTemplate):
                 spatial_table_name.append(layer.GetName())
                 continue
 
+            # 没有权限的表跳过
+            if not PGUtil.check_table_privilege(l_name,"SELECT",db_tuple[0],pg_ds):
+                StructurePrint.print("用户{}对表{}没有select权限！".format(db_tuple[0],l_name),"warn")
+                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:
@@ -137,11 +148,13 @@ class Api(ApiTemplate):
 
             table_guid = uuid.uuid1().__str__()
 
+            geom_type = GeometryAdapter.get_geometry_type(layer)
+
             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(GeometryAdapter.get_geometry_type(layer)),
+                          table_type=GeometryAdapter.get_table_type(geom_type),
                           extent=extent,
                           feature_count=feature_count
                           )
@@ -164,19 +177,26 @@ class Api(ApiTemplate):
         return spatial_table_name,tables
 
 
-    def register_common_table(self,this_time,database,spatial_table_name):
+    def register_common_table(self,this_time,database,spatial_table_name,db_tuple):
         # 注册普通表
         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:
 
+                # 没有权限的表跳过
+                if not SQLUtil.check_table_privilege(table_name, "SELECT", db_tuple[0], db_session):
+                    StructurePrint.print("用户{}对表{}没有select权限！".format(db_tuple[0],table_name), "warn")
+                    continue
+
                 table_guid = uuid.uuid1().__str__()
-                count = db_session.execute('select count(*) from "{}"'.format(table_name)).fetchone()[0]
+
+                count = SQLUtil.get_table_count(table_name,db_session)
 
                 table = Table(guid=table_guid,
                               database_guid=database.guid,
@@ -209,15 +229,26 @@ class Api(ApiTemplate):
                     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.commit()
         db_session.close()
 
-    def regiser_vacuate_talbe(self,pg_ds,tables):
+
+    def regiser_vacuate_table(self,pg_ds,tables,db_tuple):
 
         # 注册抽稀表
         for i in range(pg_ds.GetLayerCount()):
             layer:Layer = pg_ds.GetLayer(i)
             l_name = layer.GetName()
+
+
+
             if l_name.__contains__("_vacuate_"):
+
+                # 没有权限的表跳过
+                if not PGUtil.check_table_privilege(l_name, "SELECT", db_tuple[0], pg_ds):
+                    StructurePrint.print("用户{}对表{}没有select权限！".format(db_tuple[0], l_name), "warn")
+                    continue
+
                 base_layer_name=l_name.split("_vacuate_")[0]
                 level = l_name.split("_")[-2]
                 pixel_distance_str: str ="0"
@@ -227,15 +258,17 @@ class Api(ApiTemplate):
                         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))
+                base_table = [table for table in tables if table.name.__eq__(base_layer_name)]
+                if base_table:
+                    base_table = base_table[0]
+                    table_vacuate = TableVacuate(guid=uuid.uuid1().__str__(),
+                                                 table_guid=base_table.guid,
+                                                 level=level,
+                                                 name=l_name,
+                                                 pixel_distance=float(pixel_distance_str))
 
-                Table.query.filter_by(guid=base_table.guid).update({"is_vacuate": 1})
-                db.session.add(table_vacuate)
+                    Table.query.filter_by(guid=base_table.guid).update({"is_vacuate":1})
+                    db.session.add(table_vacuate)
 
 
     
@@ -247,7 +280,6 @@ class Api(ApiTemplate):
             engine = create_engine(sqlachemy_uri)
             system_session = sessionmaker(bind=engine)()
             system_session.execute(test_sql).fetchone()
-
         except:
             check = False
         finally:
@@ -281,10 +313,6 @@ class Api(ApiTemplate):
         {"name": "alias",
          "in": "formData",
          "type": "string","description":"数据库别名","required": "true"},
-
-        {"name": "encryption",
-         "in": "formData",
-         "type": "integer", "description": "密码是否加密", "enum": [0,1]},
     ],
     "responses":{
         200:{

@@ -8,28 +8,28 @@ from app.models import *
 
 import traceback
 
-from osgeo.ogr import DataSource,Layer,FeatureDefn,FieldDefn
-from osgeo import gdal ,ogr
+from osgeo.ogr import DataSource,Layer,FeatureDefn,FieldDefn,Feature
+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={}
+        result={}
         #设置编码
         encoding = self.para.get("encoding")
         if encoding:
             gdal.SetConfigOption("SHAPE_ENCODING",encoding)
         else:
-            gdal.SetConfigOption("SHAPE_ENCODING", "GBK")
+            gdal.SetConfigOption("SHAPE_ENCODING", "UTF-8")
     
         ds:DataSource = None
         try:
@@ -38,6 +38,7 @@ class Api(ApiTemplate):
             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))
     
@@ -49,16 +50,16 @@ class Api(ApiTemplate):
             if download_type.__eq__("gdb"):
                 data = self.download_gdb(table_names, ds,database_guid)
     
-            res["data"] = data
-            res["result"] = True
+            result["data"] = data
+            result["state"] = 1
         except Exception as e:
             print(traceback.format_exc())
-            res["msg"]= e.__str__()
-            res["result"]=False
+            result["message"]= e.__str__()
+            result["state"]=-1
         finally:
             if ds:
                 ds.Destroy()
-        return res
+        return result
     
     
     def download_shp(self,table_names,ds):
@@ -77,9 +78,23 @@ class Api(ApiTemplate):
         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.CopyLayer(layer, table_name)
+
+
+        fid = layer.GetFIDColumn()
+        pg_layer: Layer = data_source.CreateLayer(table_name, layer.GetSpatialRef(), layer.GetGeomType())
+        schema = [sche for sche in layer.schema if not sche.name.__eq__(fid)]
+
+        pg_layer.CreateFields(schema)
+        layer.ResetReading()
+        for feature in layer:
+            pg_layer.CreateFeature(feature)
+
         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")
     
     
@@ -114,13 +129,32 @@ class Api(ApiTemplate):
             #     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)])
+
+            fid = layer.GetFIDColumn()
+            pg_layer: Layer = gdb_ds.CreateLayer(table_name, layer.GetSpatialRef(), layer.GetGeomType(),["LAYER_ALIAS={}".format(table_alias)])
+            schema = [sche for sche in layer.schema if not sche.name.__eq__(fid)]
+            # schema = layer.schema
+            pg_layer.CreateFields(schema)
+
+
+            # gdb 不支持fid=0的要素，所以识别到后要+1
+            offset = 0
+            f1:Feature =  layer.GetNextFeature()
+            if f1:
+                if f1.GetFID().__eq__(0):
+                    offset = 1
+            layer.ResetReading()
+            for feature in layer:
+                feature.SetFID(feature.GetFID()+offset)
+                pg_layer.CreateFeature(feature)
+
+
+            # 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
     

@@ -18,6 +18,10 @@ from . import table_refresh
 from . import table_delete
 from . import table_view
 from . import table_vacuate
+from . import table_vacuate_one
+from . import table_vacuate_info
+from . import table_vacuate_ref
+from . import table_vacuate_delete
 class DataManager(BlueprintApi):
 
     bp = Blueprint("DataManager", __name__, url_prefix="/API/Manager")
@@ -106,4 +110,41 @@ class DataManager(BlueprintApi):
         """
         数据抽稀
         """
-        return table_vacuate.Api().result
\ No newline at end of file
+        return table_vacuate.Api().result
+
+    @staticmethod
+    @bp.route('/TableVacuateOne', methods=['POST'])
+    @swag_from(table_vacuate_one.Api.api_doc)
+    def api_table_vacuate_one():
+        """
+        单独数据抽稀
+        """
+        return table_vacuate_one.Api().result
+
+
+    @staticmethod
+    @bp.route('/TableVacuateInfo', methods=['POST'])
+    @swag_from(table_vacuate_info.Api.api_doc)
+    def api_table_vacuate_info():
+        """
+        数据抽稀情况
+        """
+        return table_vacuate_info.Api().result
+
+    @staticmethod
+    @bp.route('/TableVacuateRef', methods=['POST'])
+    @swag_from(table_vacuate_ref.Api.api_doc)
+    def api_table_vacuate_ref():
+        """
+        数据抽稀参考
+        """
+        return table_vacuate_ref.Api().result
+
+    @staticmethod
+    @bp.route('/TableVacuateDelete', methods=['POST'])
+    @swag_from(table_vacuate_delete.Api.api_doc)
+    def api_table_vacuate_delete():
+        """
+        数据抽稀删除
+        """
+        return table_vacuate_delete.Api().result
\ No newline at end of file

@@ -40,6 +40,10 @@ class Api(ApiTemplate):
                 tables = Table.query.order_by(Table.update_time.desc(),Table.name)
             else:
                 tables = Table.query.order_by(Table.name)
+
+            #过滤spatial_ref_sys
+            tables = tables.filter(Table.name.notin_(["spatial_ref_sys"]))
+
             if database_guid:
                 tables = tables.filter_by(database_guid=database_guid)
             if catalog_guid:

@@ -13,7 +13,7 @@ import datetime
 import uuid
 
 from sqlalchemy.orm import Session
-
+from app.util.component.SQLUtil import SQLUtil
 from app.util.component.PGUtil import PGUtil
 from app.util.component.ModelVisitor import ModelVisitor
 from app.util.component.StructuredPrint import StructurePrint
@@ -70,6 +70,8 @@ class Api(ApiTemplate):
         data_session=None
         result = {}
         sys_session = None
+        db_tuple = PGUtil.get_info_from_sqlachemy_uri(DES.decode(database.sqlalchemy_uri))
+
         try:
             sys_session = PGUtil.get_db_session(configure.SQLALCHEMY_DATABASE_URI)
 
@@ -89,16 +91,16 @@ class Api(ApiTemplate):
 
             # 更新空间表
             # 增加表
-            db_tables_names = self.add_spatail_table(database, pg_ds, sys_session,spatial_tables_names, this_time)# 实体库中空间表名
+            db_tables_names = self.add_spatail_table(database, pg_ds, sys_session,spatial_tables_names, this_time,db_tuple)# 实体库中空间表名
 
             # 删除/修改表
-            self.edit_spatial_table(pg_ds, sys_session,spatial_tables, db_tables_names, this_time)
+            self.edit_spatial_table(pg_ds, sys_session,spatial_tables, db_tables_names, this_time,db_tuple)
 
             # 空间表处理完毕
             sys_session.commit()
 
             # 处理抽稀表
-            self.deal_vacuate_table(pg_ds,sys_session, database.guid)
+            self.deal_vacuate_table(pg_ds,sys_session, database.guid,db_tuple)
 
             # 空间表处理完毕
             sys_session.commit()
@@ -133,11 +135,11 @@ class Api(ApiTemplate):
             # 增加新普通表
 
             self.add_common_table(data_session, sys_session, database_guid, real_common_tables_name, origin_common_tables_name,
-                                  this_time)
+                                  this_time,db_tuple)
 
             # 删除、修改普通表
             self.edit_common_table(data_session,sys_session, database_guid, real_common_tables_name, origin_common_tables_name,
-                                   this_time)
+                                   this_time,db_tuple)
 
             sys_session.commit()
             result["data"] = "刷新数据成功！"
@@ -168,7 +170,7 @@ class Api(ApiTemplate):
                 sys_session.close()
         return result
 
-    def add_spatail_table(self,database,pg_ds,sys_session,spatial_tables_names,this_time):
+    def add_spatail_table(self,database,pg_ds,sys_session,spatial_tables_names,this_time,db_tuple):
         '''
         注册新增空间表
         :param database:
@@ -196,10 +198,17 @@ class Api(ApiTemplate):
                 if layer.GetName().__contains__("_vacuate_"):
                     continue
 
+                # 没有权限的表跳过
+                if not PGUtil.check_table_privilege(l_name, "SELECT", db_tuple[0], pg_ds):
+                    StructurePrint.print("用户{}对表{}没有select权限！".format(db_tuple[0], l_name), "warn")
+                    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:
@@ -218,12 +227,14 @@ class Api(ApiTemplate):
 
                 StructurePrint.print("空间表增加！")
 
+                geom_type = GeometryAdapter.get_geometry_type(layer)
+
                 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(GeometryAdapter.get_geometry_type(layer)),
+                              table_type=GeometryAdapter.get_table_type(geom_type),
                               extent=extent,
                               feature_count=feature_count
                               )
@@ -240,7 +251,7 @@ class Api(ApiTemplate):
                     sys_session.add(column)
         return db_tables_names
 
-    def deal_vacuate_table(self,pg_ds,sys_session,database_guid):
+    def deal_vacuate_table(self,pg_ds,sys_session,database_guid,db_tuple):
 
 
         for i in range(pg_ds.GetLayerCount()):
@@ -255,6 +266,10 @@ class Api(ApiTemplate):
             if layer.GetName().__contains__("_vacuate_"):
                 l_name = layer.GetName()
 
+                # 没有权限的表跳过
+                if not PGUtil.check_table_privilege(l_name, "SELECT", db_tuple[0], pg_ds):
+                    StructurePrint.print("用户{}对表{}没有select权限！".format(db_tuple[0], l_name), "warn")
+                    continue
 
                 base_layer_name = l_name.split("_vacuate_")[0]
                 level = l_name.split("_")[-2]
@@ -283,7 +298,9 @@ class Api(ApiTemplate):
 
 
 
-    def edit_spatial_table(self,pg_ds,sys_session,spatial_tables,db_tables_names,this_time):
+    def edit_spatial_table(self,pg_ds,sys_session,spatial_tables,db_tables_names,this_time,db_tuple):
+
+
 
         for table in spatial_tables:
 
@@ -303,6 +320,12 @@ class Api(ApiTemplate):
                 if layer.GetName().__contains__("_vacuate_"):
                     continue
 
+                # 没有权限的表跳过
+                if not PGUtil.check_table_privilege(l_name, "SELECT", db_tuple[0], pg_ds):
+                    StructurePrint.print("用户{}对表{}没有select权限！".format(db_tuple[0], l_name), "warn")
+                    sys_session.delete(table)
+                    continue
+
                 columns = table.relate_columns
                 columns_names = [column.name for column in columns]
                 feature_defn: FeatureDefn = layer.GetLayerDefn()
@@ -357,11 +380,18 @@ class Api(ApiTemplate):
                                                                    "extent": extent})
 
 
-    def add_common_table(self,data_session,sys_session,database_guid,real_common_tables_name,origin_common_tables_name,this_time):
+    def add_common_table(self,data_session,sys_session,database_guid,real_common_tables_name,origin_common_tables_name,this_time,db_tuple):
         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__()
+
+
+                # 没有权限的表跳过
+                if not SQLUtil.check_table_privilege(table_name, "SELECT", db_tuple[0], data_session):
+                    StructurePrint.print("用户{}对表{}没有select权限！".format(db_tuple[0], table_name), "warn")
+                    continue
+
                 count = data_session.execute('select count(*) from "{}"'.format(table_name)).fetchone()[0]
 
                 table = Table(guid=table_guid,
@@ -402,7 +432,7 @@ class Api(ApiTemplate):
                         for table in tables:
                             sys_session.delete(table)
 
-    def edit_common_table(self,data_session,sys_session,database_guid,real_common_tables_name,origin_common_tables_name,this_time):
+    def edit_common_table(self,data_session,sys_session,database_guid,real_common_tables_name,origin_common_tables_name,this_time,db_tuple):
         for table_name in origin_common_tables_name:
             tables = sys_session.query(Table).filter_by(name=table_name).filter_by(database_guid=database_guid).all()
             for table in tables:
@@ -411,6 +441,13 @@ class Api(ApiTemplate):
                     sys_session.delete(table)
                 # 修改表
                 else:
+
+                    # 没有权限的表删除
+                    if not SQLUtil.check_table_privilege(table_name, "SELECT", db_tuple[0], data_session):
+                        StructurePrint.print("用户{}对表{}没有select权限！".format(db_tuple[0], table_name), "warn")
+                        sys_session.delete(table)
+                        continue
+
                     columns = table.relate_columns
                     columns_names = [column.name for column in columns]
 
@@ -448,15 +485,15 @@ class Api(ApiTemplate):
                             sys_session.delete(column)
 
                     # 修改要素量
-                    sql = 'select count(*) from "{}"'.format(table_name)
+                    # sql = 'select count(*) from "{}"'.format(table_name)
+                    # count = data_session.execute(sql).fetchone()[0]
+
+                    count = SQLUtil.get_table_count(table_name,data_session)
 
-                    count = data_session.execute(sql).fetchone()[0]
                     if not table.feature_count.__eq__(count):
                         StructurePrint.print("{}表要素变化！".format(table_name))
                         sys_session.query(Table).filter_by(guid=table.guid).update({"feature_count": count})
 
-
-    
     
     api_doc={
     "tags":["管理接口"],

@@ -5,19 +5,23 @@
 
 import datetime
 import traceback
-from app.models import Table, Database, DES,Task,db
+from app.models import Table, Database, DES,Task,db,TableVacuate
 
 from sqlalchemy.engine import ResultProxy
 from app.util.component.ApiTemplate import ApiTemplate
 from app.util.component.PGUtil import PGUtil
 from app.util.component.EntryDataVacuate import VacuateProcess,ThisTask,Process
+from app.util.component.StructuredPrint import StructurePrint
+from app.util.component.PGUtil import PGUtil
 import multiprocessing
 import uuid
 import configure
-from osgeo.ogr import DataSource
+from osgeo.ogr import DataSource,Layer
 
-class Api(ApiTemplate):
+from .table_vacuate_ref import Api as RefApi
 
+class Api(ApiTemplate):
+    api_name = "数据抽稀"
     def process(self):
 
         res = {}
@@ -26,15 +30,21 @@ class Api(ApiTemplate):
         try:
             table_guid = self.para.get("guid")
             table: Table = Table.query.filter_by(guid=table_guid).one_or_none()
+
             if not table:
                 raise Exception("数据不存在！")
 
-            # 判断图层是否存在
-
             pg_ds :DataSource= PGUtil.open_pg_data_source(0,DES.decode(table.relate_database.sqlalchemy_uri))
             layer = pg_ds.GetLayerByName(table.name)
+            # 判断图层是否存在
             if not layer:
                 raise Exception("图层不存在！")
+
+            # 判断用户权限
+            db_tuple = PGUtil.get_info_from_sqlachemy_uri(DES.decode(table.relate_database.sqlalchemy_uri))
+            if not PGUtil.check_table_privilege(table.name,"SELECT",db_tuple[0],pg_ds):
+                raise  Exception("用户{}对表{}没有select权限！".format(db_tuple[0],table.name))
+
             if pg_ds:
                 pg_ds.Destroy()
 
@@ -46,17 +56,22 @@ class Api(ApiTemplate):
                 res["result"] = False
                 res["msg"] = "非空间表！"
                 return res
+
             # if table.is_vacuate==1:
             #     res["state"] = -1
             #     res["message"] = "已精化！"
             #     return res
 
 
+
             # 初始化task
             task_guid = uuid.uuid1().__str__()
             vacuate_process = multiprocessing.Process(target=self.task,args=(table,task_guid))
             vacuate_process.start()
 
+            ref_api = RefApi()
+            ref_api.para["guid"] = table_guid
+            ref_grids = ref_api.process()["data"]
 
             task = Task(guid=task_guid,
                         name="{}精化".format(table.name),
@@ -67,12 +82,15 @@ class Api(ApiTemplate):
                         creator=self.para.get("creator"),
                         file_name=None,
                         database_guid=table.database_guid,
-                        process="精化中")
+                        process="精化中",
+                        parameter=",".join([str(x) for x in ref_grids]))
+
             db.session.add(task)
             db.session.commit()
             res["msg"] = "图层抽稀已提交！"
-            res["data"] = table_guid
+            res["data"] = task_guid
             res["result"] = True
+
         except Exception as e:
             raise e
         finally:
@@ -87,23 +105,34 @@ class Api(ApiTemplate):
         pg_ds = None
         vacuate_process = None
         try:
-
-            sys_session= PGUtil.get_db_session(configure.SQLALCHEMY_DATABASE_URI)
-
+            sys_session = PGUtil.get_db_session(configure.SQLALCHEMY_DATABASE_URI)
             sys_session.query(Table).filter_by(guid=table.guid).update(
                 {"is_vacuate": 2, "update_time": datetime.datetime.now()})
             sys_session.commit()
 
+
             database = sys_session.query(Database).filter_by(guid=table.database_guid).one_or_none()
             pg_session = PGUtil.get_db_session(DES.decode(database.sqlalchemy_uri))
 
             pg_ds :DataSource= PGUtil.open_pg_data_source(0,DES.decode(database.sqlalchemy_uri))
 
+
+            #删除原有数据
+            tvs = sys_session.query(TableVacuate).filter_by(table_guid=table.guid).all()
+            for tv in tvs :
+                sys_session.delete(tv)
+                # try:
+                #     pg_ds.DeleteLayer(tv.name)
+                # except Exception as e :
+                #     StructurePrint.print("抽稀图层不存在！","warn")
+
             # 创建抽稀过程
             options = ["OVERWRITE=yes", "GEOMETRY_NAME={}".format(PGUtil.get_geo_column(table.name,pg_session)),
                        "PRECISION=NO"]
+
             layer = pg_ds.GetLayerByName(table.name)
-            vacuate_process = VacuateProcess(layer, table.name, options,database.sqlalchemy_uri)
+
+            vacuate_process:VacuateProcess = VacuateProcess(layer, table.name, options,database.sqlalchemy_uri)
 
 
             for feature in layer:
@@ -112,14 +141,28 @@ class Api(ApiTemplate):
                 if geo is not None:
                     vacuate_process.vacuate(geo)
 
-            sys_session.query(Task).filter_by(guid=task_guid).update({"state":1,"update_time":datetime.datetime.now()})
+
+            #新增
+            for l in range(vacuate_process.max_level):
+                lev = vacuate_process.t_grid_size.index(vacuate_process.this_gridsize[l])
+
+                table_vacuate = TableVacuate(guid=uuid.uuid1().__str__(),
+                                             table_guid=table.guid,
+                                             level=lev,
+                                             name=vacuate_process.vacuate_layers[l].GetName(),
+                                             pixel_distance=vacuate_process.this_gridsize[l])
+                sys_session.add(table_vacuate)
+
+            sys_session.query(Task).filter_by(guid=task_guid).update({"state":1,"update_time":datetime.datetime.now(),
+                                                                      "process": "精化完成"})
             sys_session.query(Table).filter_by(guid=table.guid).update(
                 {"is_vacuate": 1, "update_time": datetime.datetime.now()})
             sys_session.commit()
 
         except Exception as e:
             try:
-                sys_session.query(Task).filter_by(guid=task_guid).update({"state": -1,"update_time":datetime.datetime.now()})
+                sys_session.query(Task).filter_by(guid=task_guid).update({"state": -1,"update_time":datetime.datetime.now(),
+                                                                          "process": "精化失败"})
                 sys_session.query(Table).filter_by(guid=table.guid).update(
                     {"is_vacuate": 0, "update_time": datetime.datetime.now()})
 
@@ -129,7 +172,8 @@ class Api(ApiTemplate):
                                        task_guid=task_guid)
                 sys_session.add(task_process)
                 sys_session.commit()
-                vacuate_process.rollback()
+                if vacuate_process:
+                    vacuate_process.rollback()
 
                 print(traceback.format_exc())
             except Exception as ee:

+# author:        4N
+# createtime:    2021/1/27
+# email:         nheweijun@sina.com
+
+
+import datetime
+import traceback
+from app.models import Table, Database, DES,Task,db,TableVacuate
+
+from sqlalchemy.engine import ResultProxy
+from app.util.component.ApiTemplate import ApiTemplate
+from app.util.component.PGUtil import PGUtil
+from app.util.component.EntryDataVacuate import Process
+from app.util.component.GeometryAdapter import GeometryAdapter
+from app.util.component.StructuredPrint import StructurePrint
+import multiprocessing
+import uuid
+import configure
+from osgeo.ogr import DataSource,Layer,Geometry
+from osgeo import ogr
+
+class Api(ApiTemplate):
+    api_name = "删除抽稀表"
+    def process(self):
+
+        res = {}
+        res["data"] = {}
+        pg_ds = None
+        try:
+            table_guid = self.para.get("guid")
+            table: Table = Table.query.filter_by(guid=table_guid).one_or_none()
+            grid = None
+            if not self.para.get("grid"):
+                raise Exception("请输入grids参数！")
+            else:
+                grid = float(self.para.get("grid"))
+
+            if not table:
+                raise Exception("数据不存在！")
+
+            # 判断图层是否存在
+            pg_ds :DataSource= PGUtil.open_pg_data_source(0,DES.decode(table.relate_database.sqlalchemy_uri))
+            layer = pg_ds.GetLayerByName(table.name)
+
+            # 判断用户权限
+            # user, pw, host, port, database = PGUtil.get_info_from_sqlachemy_uri(DES.decode(table.relate_database.sqlalchemy_uri))
+            # query_role:Layer = pg_ds.ExecuteSQL("SELECT rolcreatedb FROM pg_roles WHERE rolname='{}'".format(user))
+            # if not query_role.GetFeature(0).GetField("rolcreatedb"):
+            #     raise Exception("用户不具备建表权限！")
+
+            if not layer:
+                raise Exception("图层不存在！")
+
+            #删除数据
+            tvs = db.session.query(TableVacuate).filter_by(pixel_distance=grid, table_guid=table.guid).all()
+            if not tvs:
+                raise Exception("数据不存在！")
+            for tv in tvs :
+                db.session.delete(tv)
+                try:
+                    pg_ds.DeleteLayer(tv.name)
+                except Exception as e :
+                    StructurePrint.print("抽稀图层不存在！","warn")
+            db.session.commit()
+            res["result"] = True
+
+        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"},
+            {"name": "grid",
+             "in": "formData",
+             "type": "string",
+             "description": "网格大小", "required": "true"}
+        ],
+        "responses": {
+            200: {
+                "schema": {
+                    "properties": {
+                    }
+                }
+            }
+        }
+    }

+# author:        4N
+# createtime:    2021/1/27
+# email:         nheweijun@sina.com
+
+
+from app.models import Table,TableVacuate,Task
+from app.util.component.ApiTemplate import ApiTemplate
+from app.util.component.VacuateConf import VacuateConf
+import collections
+import json
+
+import copy
+class Api(ApiTemplate):
+    api_name = "抽稀info"
+    def process(self):
+
+        res = {}
+        try:
+
+            lonlat_gridsize = VacuateConf.lonlat_gridsize
+            project_gridsize = VacuateConf.project_gridsize
+            table_guid = self.para.get("guid")
+
+            table: Table = Table.query.filter_by(guid=table_guid).one_or_none()
+            if not table:
+                raise Exception("数据不存在！")
+            tvs = TableVacuate.query.filter_by(table_guid=table_guid).all()
+            dat = collections.OrderedDict()
+            if float(table.extent.split(",")[0])<180:
+                grid_size = copy.copy(lonlat_gridsize)
+            else:
+                grid_size = copy.copy(project_gridsize)
+
+            now_grid = [tv.pixel_distance for tv in tvs]
+
+            grid_size.reverse()
+
+            # 正在精华的任务
+            task_running = Task.query.filter_by(task_type=2,table_guid=table_guid,state=0).all()
+            grid_running = []
+            
+            for t in task_running:
+                grid_running.extend(t.parameter.split(","))
+
+            for grid in grid_size:
+                if grid in now_grid:
+                    dat[str(grid)] = 1
+                else:
+                    dat[str(grid)] = 0
+                if str(grid) in grid_running:
+                    dat[str(grid)] = 2
+
+            res["data"] = json.dumps(dat)
+            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": {
+                    }
+                }
+            }
+        }
+    }
\ No newline at end of file

+# author:        4N
+# createtime:    2021/1/27
+# email:         nheweijun@sina.com
+
+
+import datetime
+import traceback
+from app.models import Table, Database, DES,Task,db,TableVacuate
+from app.util.component.ApiTemplate import ApiTemplate
+from app.util.component.PGUtil import PGUtil
+from app.util.component.EntryDataVacuate import Process
+import multiprocessing
+import uuid
+import configure
+from osgeo.ogr import DataSource,Layer,Geometry
+from osgeo import ogr
+from app.util.component.StructuredPrint import StructurePrint
+from app.util.component.VacuateConf import VacuateConf
+
+class Api(ApiTemplate):
+    api_name = "单独抽稀"
+    def process(self):
+
+        res = {}
+        res["data"] = {}
+        db_session = None
+        try:
+            table_guid = self.para.get("guid")
+            grids = []
+            if not self.para.get("grids"):
+                raise Exception("请输入grids参数！")
+            else:
+                grids = [float(x) for x in self.para.get("grids").split(",")]
+                grids.sort()
+
+            table: Table = Table.query.filter_by(guid=table_guid).one_or_none()
+
+            if not table:
+                raise Exception("数据不存在！")
+
+            # 判断图层是否存在
+
+            pg_ds :DataSource= PGUtil.open_pg_data_source(0,DES.decode(table.relate_database.sqlalchemy_uri))
+            layer = pg_ds.GetLayerByName(table.name)
+
+            # 判断用户权限
+            db_tuple = PGUtil.get_info_from_sqlachemy_uri(DES.decode(table.relate_database.sqlalchemy_uri))
+            if not PGUtil.check_table_privilege(table.name,"SELECT",db_tuple[0],pg_ds):
+                raise  Exception("用户{}对表{}没有select权限！".format(db_tuple[0],table.name))
+
+            if not layer:
+                raise Exception("图层不存在！")
+            if pg_ds:
+                pg_ds.Destroy()
+
+
+
+            if Task.query.filter_by(table_guid=table_guid,state=0).one_or_none():
+                res["result"] = False
+                res["msg"] = "数据精化中！"
+                return res
+            if table.table_type==0:
+                res["result"] = False
+                res["msg"] = "非空间表！"
+                return res
+
+            # if table.is_vacuate==1:
+            #     res["state"] = -1
+            #     res["message"] = "已精化！"
+            #     return res
+
+            # 初始化task
+            task_guid = uuid.uuid1().__str__()
+
+            vacuate_process = multiprocessing.Process(target=self.task,args=(table,task_guid,grids))
+            vacuate_process.start()
+
+
+            task = Task(guid=task_guid,
+                        name="{}精化,网格大小:{}".format(table.name,self.para.get("grids")),
+                        table_guid=table_guid,
+                        create_time=datetime.datetime.now(),
+                        state=0,
+                        task_type=2,
+                        creator=self.para.get("creator"),
+                        file_name=None,
+                        database_guid=table.database_guid,
+                        process="精化中",
+                        parameter=self.para.get("grids"))
+
+            db.session.add(task)
+            db.session.commit()
+            res["msg"] = "图层抽稀已提交！"
+            res["data"] = task_guid
+            res["result"] = True
+
+        except Exception as e:
+            raise e
+        finally:
+            if db_session:
+                db_session.close()
+        return res
+
+    def task(self,table,task_guid,grids):
+
+        sys_session = None
+        pg_session = None
+        pg_ds = None
+        vacuate_process = None
+        origin_vacuate = table.is_vacuate
+
+        try:
+            sys_session = PGUtil.get_db_session(configure.SQLALCHEMY_DATABASE_URI)
+            sys_session.query(Table).filter_by(guid=table.guid).update(
+                {"is_vacuate": 2, "update_time": datetime.datetime.now()})
+            sys_session.commit()
+
+
+            database = sys_session.query(Database).filter_by(guid=table.database_guid).one_or_none()
+            pg_session = PGUtil.get_db_session(DES.decode(database.sqlalchemy_uri))
+
+            pg_ds :DataSource= PGUtil.open_pg_data_source(1,DES.decode(database.sqlalchemy_uri))
+
+            # 创建抽稀过程
+            options = ["OVERWRITE=yes", "GEOMETRY_NAME={}".format(PGUtil.get_geo_column(table.name,pg_session)),
+                       "PRECISION=NO"]
+
+            layer = pg_ds.GetLayerByName(table.name)
+
+            vacuate_process:VacuateProcess = VacuateProcess(layer, table.name, options,database.sqlalchemy_uri,grids)
+
+
+            for feature in layer:
+                geo = feature.GetGeometryRef()
+                #插入抽稀图层
+                if geo is not None:
+                    vacuate_process.vacuate(geo)
+
+            #删除原有数据
+            for grid in grids:
+                tvs = sys_session.query(TableVacuate).filter_by(pixel_distance=grid,table_guid=table.guid).all()
+                for tv in tvs :
+                    sys_session.delete(tv)
+
+
+            #新增
+            for l in range(vacuate_process.max_level):
+                layer_name = vacuate_process.vacuate_layers[l].GetName()
+                lev = layer_name.split("_")[-2]
+
+                table_vacuate = TableVacuate(guid=uuid.uuid1().__str__(),
+                                             table_guid=table.guid,
+                                             level=int(lev),
+                                             name=layer_name,
+                                             pixel_distance=vacuate_process.this_gridsize[l])
+                sys_session.add(table_vacuate)
+
+            sys_session.query(Task).filter_by(guid=task_guid).update({"state":1,"update_time":datetime.datetime.now(),
+                                                                      "process" : "精化完成"})
+            sys_session.query(Table).filter_by(guid=table.guid).update(
+                {"is_vacuate": 1, "update_time": datetime.datetime.now()})
+            sys_session.commit()
+
+        except Exception as e:
+            try:
+                sys_session.query(Task).filter_by(guid=task_guid).update({"state": -1,"update_time":datetime.datetime.now(),
+                                                                          "process": "精化失败"})
+                sys_session.query(Table).filter_by(guid=table.guid).update(
+                    {"is_vacuate": origin_vacuate, "update_time": datetime.datetime.now()})
+
+                message = "{} {}".format(datetime.datetime.now().strftime('%Y-%m-%d %H:%M:%S'), e.__str__())
+                task_process_guid = uuid.uuid1().__str__()
+                task_process = Process(guid=task_process_guid, message=message, time=datetime.datetime.now(),
+                                       task_guid=task_guid)
+                sys_session.add(task_process)
+                sys_session.commit()
+                if vacuate_process:
+                    vacuate_process.rollback()
+
+                print(traceback.format_exc())
+            except Exception as ee:
+                print(traceback.format_exc())
+        finally:
+            try:
+                if vacuate_process:
+                    vacuate_process.end()
+                if sys_session:
+                    sys_session.close()
+                if pg_session:
+                    pg_session.close()
+                if pg_ds:
+                    pg_ds.Destroy()
+            except:
+                print(traceback.format_exc())
+
+    api_doc = {
+        "tags": ["管理接口"],
+        "parameters": [
+            {"name": "guid",
+             "in": "formData",
+             "type": "string",
+             "description": "表guid", "required": "true"},
+            {"name": "grids",
+             "in": "formData",
+             "type": "string",
+             "description": "需要抽稀的网格大小，以逗号相隔", "required": "true"}
+        ],
+        "responses": {
+            200: {
+                "schema": {
+                    "properties": {
+                    }
+                }
+            }
+        }
+    }
+
+
+class VacuateProcess:
+    '''
+    抽稀类
+    '''
+
+    max_level=0
+    fill_dict={}
+    vacuate_layers={}
+    vacuate_layers_gridsize={}
+    pg_ds_dict = {}
+    #被抽吸图层的范围
+    extent=[]
+    is_spatial=False
+    #该抽稀过程的抽稀网格
+    this_gridsize=[]
+
+
+    def __init__(self,layer:Layer,new_layer_name, options,sqlalchemy_uri,grids):
+
+        #是空间图层才初始化
+        if layer.GetExtent()[0] > 0 or layer.GetExtent()[0] < 0:
+
+            self.is_spatial=True
+
+            # 判断需要抽稀多少级
+
+            extent = layer.GetExtent()
+            self.extent=extent
+
+            layer.SetSpatialFilter(None)
+            layer.ResetReading()
+
+            self.this_gridsize = grids
+            self.max_level = len(grids)
+
+
+            # 创建抽稀ds
+            for l in range(self.max_level):
+                pg_ds_l: DataSource = PGUtil.open_pg_data_source(1, DES.decode(sqlalchemy_uri))
+                pg_ds_l.StartTransaction()
+                self.pg_ds_dict[l] = pg_ds_l
+
+            # 生成抽稀图层
+            options = options[1:]
+            options.append("OVERWRITE=yes")
+            options.append("LAUNDER=no")
+            for l in range(self.max_level):
+                this_grid_len = self.this_gridsize[l]
+
+                self.vacuate_layers_gridsize[l] = this_grid_len
+
+                pg = self.pg_ds_dict[l]
+
+                if this_grid_len<1:
+                    grid_name = str(this_grid_len).split(".")[-1]
+                    if this_grid_len.__eq__(0.000075):
+                        grid_name = "000075"
+                else:
+                    grid_name = str(int(this_grid_len))
+
+                # 抽稀图层是点面混合的
+                # 抽稀表有固定的命名规则
+                # 抽稀表一定要覆盖
+
+                this_grid_szie = VacuateConf.project_gridsize if VacuateConf.project_gridsize.__contains__(this_grid_len) else  VacuateConf.lonlat_gridsize
+
+                lev = this_grid_szie.index(this_grid_len)
+                print("{}:{}".format(grid_name, lev))
+                vl = pg.CreateLayer("{}_vacuate_{}_{}".format(new_layer_name, lev, grid_name), layer.GetSpatialRef(),
+                                    ogr.wkbUnknown, options)
+                # 抽稀表不需要属性
+                # vl.CreateFields(schema)
+                self.vacuate_layers[l] = vl
+
+        else:
+            pass
+
+
+    def vacuate(self,g):
+
+        if self.is_spatial:
+
+            # 插入到所有抽稀图层中
+            for level in range(self.max_level):
+
+                center: Geometry = g.Centroid()
+
+                extent = g.GetEnvelope()
+                long_extent= extent[1]-extent[0]
+                lat_extent = extent[3]-extent[2]
+
+                this_grid_len =self.vacuate_layers_gridsize[level]
+
+                row = int((center.GetY() - self.extent[2]) / this_grid_len)
+                col = int((center.GetX() - self.extent[0]) / this_grid_len)
+                key = "{}.{}.{}".format(level, row, col)
+
+                if not self.fill_dict.get(key):
+                    self.fill_dict[key] = 0
+                if self.fill_dict[key] == 0:
+
+                    vacuate_layer: Layer = self.vacuate_layers.get(level)
+                    feat = ogr.Feature(vacuate_layer.GetLayerDefn())
+                    # 如果图形比网格小，直接存储其中心点
+                    if this_grid_len>long_extent and this_grid_len>lat_extent:
+                        feat.SetGeometry(center)
+                    else:
+                        feat.SetGeometry(g)
+                    vacuate_layer.CreateFeature(feat)
+                self.fill_dict[key] += 1
+
+    def end(self):
+        for pg in self.pg_ds_dict.values():
+            pg.Destroy()
+
+    def rollback(self):
+        for pg in self.pg_ds_dict.values():
+            pg.RollbackTransaction()
\ No newline at end of file

+# author:        4N
+# createtime:    2021/1/27
+# email:         nheweijun@sina.com
+
+
+import datetime
+import traceback
+from app.models import Table, Database, DES,Task,db,TableVacuate
+
+from sqlalchemy.engine import ResultProxy
+from app.util.component.ApiTemplate import ApiTemplate
+from app.util.component.PGUtil import PGUtil
+from app.util.component.EntryDataVacuate import Process
+from app.util.component.GeometryAdapter import GeometryAdapter
+from app.util.component.StructuredPrint import StructurePrint
+import multiprocessing
+import uuid
+import configure
+from osgeo.ogr import DataSource,Layer,Geometry
+from osgeo import ogr
+from app.util.component.VacuateConf import VacuateConf
+import copy
+class Api(ApiTemplate):
+    api_name = "推荐抽稀"
+    def process(self):
+
+        res = {}
+        res["data"] = {}
+        pg_ds = None
+        try:
+            table_guid = self.para.get("guid")
+
+
+            table: Table = Table.query.filter_by(guid=table_guid).one_or_none()
+
+
+            if not table:
+                raise Exception("数据不存在！")
+
+            # 判断图层是否存在
+
+            pg_ds :DataSource= PGUtil.open_pg_data_source(0,DES.decode(table.relate_database.sqlalchemy_uri))
+            layer = pg_ds.GetLayerByName(table.name)
+
+            # 判断用户权限
+            user, pw, host, port, database = PGUtil.get_info_from_sqlachemy_uri(DES.decode(table.relate_database.sqlalchemy_uri))
+            query_role:Layer = pg_ds.ExecuteSQL("SELECT rolcreatedb FROM pg_roles WHERE rolname='{}'".format(user))
+            if not query_role.GetFeature(0).GetField("rolcreatedb"):
+                raise Exception("用户不具备建表权限！")
+
+            if not layer:
+                raise Exception("图层不存在！")
+
+
+            lonlat_gridsize = copy.deepcopy(VacuateConf.lonlat_gridsize)
+            project_gridsize = copy.deepcopy(VacuateConf.project_gridsize)
+            least_vacuate_count = copy.deepcopy(VacuateConf.least_vacuate_count)
+
+            this_gridsize = []
+            max_level = 0
+            # 是空间图层才初始化
+            if layer.GetExtent()[0] > 0 or layer.GetExtent()[0] < 0:
+
+
+                # 判断需要抽稀多少级
+                lc = layer.GetFeatureCount()
+                extent = layer.GetExtent()
+
+                # 判断疏密程度
+                p_x = (extent[1] - extent[0]) / 10.0
+                p_y = (extent[3] - extent[2]) / 10.0
+                fill_precent = 0
+                StructurePrint.print("判断疏密")
+                for ix in range(10):
+                    for iy in range(10):
+                        grid_extent = [extent[0] + ix * p_x, extent[0] + ix * p_x + p_x, extent[2] + iy * p_y,
+                                       extent[2] + iy * p_y + p_y]
+                        poly = GeometryAdapter.envelop_2_polygon(grid_extent)
+
+                        layer.SetSpatialFilter(None)
+                        layer.SetSpatialFilter(poly)
+                        layer.ResetReading()
+                        if layer.GetNextFeature():
+                            fill_precent += 1
+
+                print(fill_precent)
+                StructurePrint.print("判断疏密结束")
+
+                layer.SetSpatialFilter(None)
+                layer.ResetReading()
+                # 固有疏密程度
+                original_density = 8
+
+                if extent[0] > 180:
+                    t_grid_size = project_gridsize
+                else:
+                    t_grid_size = lonlat_gridsize
+                for grid_size in t_grid_size:
+                    # 最少抽稀个数
+                    if lc > least_vacuate_count:
+                        # 网格数至少大于
+                        if ((extent[1] - extent[0]) * (extent[3] - extent[2])) / (
+                                grid_size ** 2) > least_vacuate_count:
+                            # 要素数量大于网格数量
+                            # 要考虑图层的疏密程度，original_density*(100.0/fill_precent) 为疏密指数
+                            if lc * original_density * (100.0 / fill_precent) > (
+                                    (extent[1] - extent[0]) * (extent[3] - extent[2])) / (grid_size ** 2):
+                                this_gridsize.append(grid_size)
+                                max_level += 1
+
+            res["data"] = this_gridsize
+            res["result"] = True
+
+
+        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": {
+                    }
+                }
+            }
+        }
+    }

@@ -16,6 +16,7 @@ from functools import lru_cache
 import traceback
 import copy
 from app.util.component.GeometryAdapter import GeometryAdapter
+from app.util.component.VacuateConf import VacuateConf
 class EntryDataVacuate:
 
     def entry(self,parameter):
@@ -317,13 +318,15 @@ class ThisTask:
         else:
             ext = [round(e, 2) for e in ext]
 
+        geom_type = GeometryAdapter.get_geometry_type(layer)
+
         extent = "{},{},{},{}".format(ext[0], ext[1], ext[2], ext[3])
         table_guid = uuid.uuid1().__str__()
         table = Table(guid=table_guid,
                       database_guid=self.database.guid,
                       creator=creator,
                       name=new_layer_name, create_time=this_time, update_time=this_time,
-                      catalog_guid=self.catalog_guid, table_type=GeometryAdapter.get_table_type(GeometryAdapter.get_geometry_type(layer)),
+                      catalog_guid=self.catalog_guid, table_type=GeometryAdapter.get_table_type(geom_type),
                       extent=extent,
                       feature_count=layer.GetFeatureCount(),
                       is_vacuate=is_vacuate
@@ -353,13 +356,16 @@ class ThisTask:
         # 抽稀表有固定的命名规则
         for level,layer in vacuate_layers.items():
             pixel_distance_str:str=layer.GetName().split("_")[-1]
+            lev = layer.GetName().split("_")[-2]
+
             if pixel_distance_str.startswith("0"):
                 pixel_distance_str="0.{}".format(pixel_distance_str)
 
             pixel_distance = float(pixel_distance_str)
+
             table_vacuate = TableVacuate(guid=uuid.uuid1().__str__(),
                                          table_guid=table_guid,
-                                         level=level,
+                                         level=int(lev),
                                          name=layer.GetName(),
                                          pixel_distance=pixel_distance)
             self.sys_session.add(table_vacuate)
@@ -398,14 +404,18 @@ class VacuateProcess:
     vacuate_layers_gridsize={}
     pg_ds_dict = {}
     # 图层要素大于5W才抽稀
-    least_vacuate_count = 20000
+    least_vacuate_count = VacuateConf.least_vacuate_count
 
     extent=[]
     is_spatial=False
-    # 网格大小是固定的，根据图层的信息滑动选取需要抽稀的等级
-    lonlat_gridsize=[0.000075,0.00015,0.0003,0.0006,0.0012,0.0024,0.0048,0.0096,0.0192,0.0384,0.0768]
-    project_gridsize=[15,30,60,120,240,480,960,1920,3840,7680]
 
+    lonlat_gridsize = VacuateConf.lonlat_gridsize
+    project_gridsize = VacuateConf.project_gridsize
+
+    # 该抽稀过程使用的grid_size
+    t_grid_size = []
+
+    # 该抽稀过程的抽稀网格
     this_gridsize=[]
 
 
@@ -453,17 +463,17 @@ class VacuateProcess:
             ######
 
             if extent[0]>180:
-                t_grid_size=self.project_gridsize
+                self.t_grid_size=self.project_gridsize
             else:
-                t_grid_size = self.lonlat_gridsize
-            for grid_size in t_grid_size:
+                self.t_grid_size = self.lonlat_gridsize
+            for grid_size in self.t_grid_size:
                 # 最少抽稀个数
-                if lc>self.least_vacuate_count:
+                if lc > self.least_vacuate_count:
                     # 网格数至少大于
-                    if ((extent[1] - extent[0])*(extent[3] - extent[2]))/(grid_size**2)>self.least_vacuate_count:
+                    if ((extent[1] - extent[0]) * (extent[3] - extent[2])) / (grid_size**2)>self.least_vacuate_count:
                         # 要素数量大于网格数量
                         # 要考虑图层的疏密程度，original_density*(100.0/fill_precent) 为疏密指数
-                        if lc*original_density*(100.0/fill_precent)>((extent[1] - extent[0])*(extent[3] - extent[2]))/(grid_size**2) :
+                        if lc * original_density * (100.0/fill_precent)>((extent[1] - extent[0])*(extent[3] - extent[2]))/(grid_size**2) :
                             print(grid_size)
                             self.this_gridsize.append(grid_size)
                             self.max_level += 1
@@ -479,6 +489,7 @@ class VacuateProcess:
             # 生成抽稀图层
             options = options[1:]
             options.append("OVERWRITE=yes")
+            options.append("LAUNDER=no")
             for l in range(self.max_level):
                 this_grid_len = self.this_gridsize[l]
 
@@ -496,7 +507,8 @@ class VacuateProcess:
                 # 抽稀表有固定的命名规则
                 # 抽稀表一定要覆盖
 
-                vl = pg.CreateLayer("{}_vacuate_{}_{}".format(new_layer_name, l, grid_name), layer.GetSpatialRef(),
+
+                vl = pg.CreateLayer("{}_vacuate_{}_{}".format(new_layer_name, self.t_grid_size.index(this_grid_len), grid_name), layer.GetSpatialRef(),
                                     ogr.wkbUnknown, options)
                 # 抽稀表不需要属性
                 # vl.CreateFields(schema)

@@ -5,8 +5,6 @@
 from osgeo import ogr
 from sqlalchemy import create_engine
 from sqlalchemy.orm import sessionmaker,Session
-from sqlalchemy.engine import ResultProxy
-
 class PGUtil:
 
     @classmethod
@@ -27,11 +25,6 @@ class PGUtil:
 
     @classmethod
     def get_info_from_sqlachemy_uri(cls,uri):
-        '''
-        解析sqlachemy_uri
-        :param uri:
-        :return:
-        '''
         parts = uri.split(":")
         user = parts[1][2:]
 
@@ -56,12 +49,7 @@ class PGUtil:
 
     @classmethod
     def get_geo_column(cls,table_name,db_session):
-        '''
         # 判断空间列
-        :param table_name:
-        :param db_session:
-        :return:
-        '''
         geom_col_sql = '''
         SELECT a.attname AS field,t.typname AS type
         FROM
@@ -75,7 +63,7 @@ class PGUtil:
         and a.atttypid = t.oid
         '''.format(table_name)
         geom_col = None
-        geom_result: ResultProxy = db_session.execute(geom_col_sql)
+        geom_result = db_session.execute(geom_col_sql)
         for row_proxy in geom_result:
             if row_proxy[1].__eq__("geometry"):
                 geom_col = row_proxy[0]
@@ -84,39 +72,39 @@ class PGUtil:
 
     @classmethod
     def get_table_count(cls,table_name,db_session):
-        '''
-        获取图层数量
-        :param table_name:
-        :param db_session:
-        :return:
-        '''
         count_result = db_session.execute('''SELECT reltuples::bigint AS ec FROM pg_class WHERE  oid = 'public."{}"'::regclass'''.format(
             table_name)).fetchone()
         count = count_result[0]
         if count< 1000000:
-            count_result: ResultProxy = db_session.execute('select count(*) from "{}"'.format(table_name)).fetchone()
+            count_result = db_session.execute('select count(*) from "{}"'.format(table_name)).fetchone()
             count=count_result[0]
         return count
 
     @classmethod
-    def check_space(cls, sqlachemy_uri):
+    def check_table_privilege(cls,table_name,pri_type,user,pg_ds):
         '''
-        判断数据库是否为空间库
-        :param sqlachemy_uri:
+        通过pg_ds来判断用户是否对表具有权限
+        :param table_name:
+        :param pri_type:
+        :param user:
+        :param pg_ds:
         :return:
         '''
-        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
 
+        pri = pg_ds.ExecuteSQL("select * from information_schema.table_privileges "
+                               "where grantee='{}' and table_name='{}' and privilege_type='{}' "
+                               .format(user,table_name,pri_type))
+
+        if pri.GetNextFeature():
+            return True
+        else:
+            return False
+
+
+    @classmethod
+    def check_database_privilege(cls,table_name,pri_type,user,session):
+        pass
+
+    @classmethod
+    def check_database_privilege(cls,table_name,pri_type,user,session):
+        pass
\ No newline at end of file

@@ -8,11 +8,45 @@ class SQLUtil:
 
 
     @classmethod
-    def get_count(cls,session,table_name):
-        count = session.execute('select count(*) from "{}"'.format(table_name)).fetchone()[0]
+    def get_table_count(cls,table_name,db_session):
+        count_result = db_session.execute('''SELECT reltuples::bigint AS ec FROM pg_class WHERE  oid = 'public."{}"'::regclass'''.format(
+            table_name)).fetchone()
+        count = count_result[0]
+        if count< 1000000:
+            count_result = db_session.execute('select count(*) from "{}"'.format(table_name)).fetchone()
+            count=count_result[0]
         return count
 
     @classmethod
     def rename(cls,session,origin,after_name):
         rename_sql = 'alter table "{}" rename to "{}"'.format(origin, after_name)
         session.execute(rename_sql)
+        session.commit()
+
+    @classmethod
+    def check_table_privilege(cls,table_name,pri_type,user,session):
+        '''
+        判断用户是否对表具有权限
+        :param table_name:
+        :param pri_type:
+        :param user:
+        :param pg_ds:
+        :return:
+        '''
+        pri = session.execute("select * from information_schema.table_privileges "
+                              "where grantee='{}' and table_name='{}' and privilege_type='{}' "
+                              .format(user,table_name,pri_type)).fetchall()
+        if len(pri) == 1:
+            return True
+        else:
+            return False
+
+
+
+    @classmethod
+    def check_database_privilege(cls,table_name,pri_type,user,session):
+        pass
+
+    @classmethod
+    def check_database_privilege_pg(cls,table_name,pri_type,user,session):
+        pass
\ No newline at end of file

+# coding=utf-8
+#author:        4N
+#createtime:    2021/8/25
+#email:         nheweijun@sina.com
+
+
+class VacuateConf:
+    least_vacuate_count = 20000
+    lonlat_gridsize = [0.00008, 0.00016, 0.00032, 0.00064, 0.00128, 0.00256, 0.00512, 0.01024, 0.02048,0.04096, 0.08192]
+    project_gridsize = [8,16, 32, 64, 128, 256, 512, 1024, 2048, 4096, 8192]
\ No newline at end of file

-LoadModule wsgi_module "/usr/lib/apache2/modules/mod_wsgi-py39.cpython-39-x86_64-linux-gnu.so"
- "/usr"
-
- conf.d/*.conf
-<VirtualHost *>
-    ServerName dampmanager
-    WSGIDaemonProcess yourapplication user=chinadci group=chinadci threads=5
-    WSGIScriptAlias /DMapManager /usr/src/DMapManager/run.wsgi
-    <Directory /usr/src/>
-        WSGIProcessGroup yourapplication
-        WSGIApplicationGroup %{GLOBAL}
-        Require all granted
-    </Directory>
-</VirtualHost>
-
-<virtualhost *:80>
-    ServerName dampmanager
-    WSGIDaemonProcess mlfans threads=5
-    WSGIScriptAlias / /var/www/mlfans/app.wsgi
-
-    <directory /var/www/mlfans>
-        WSGIProcessGroup mlfans
-        WSGIApplicationGroup %{GLOBAL}
-        WSGIScriptReloading On
-        Order deny,allow
-        Allow from all
-    </directory>
-</virtualhost>
-
-
-
-
-LoadModule wsgi_module "/usr/lib/apache2/modules/mod_wsgi-py39.cpython-39-x86_64-linux-gnu.so"
-WSGIPythonHome "/usr"
-
-WSGIScriptAlias /DMapManager /usr/DMapManager/run.wsgi
-<Directory /usr/>
-  Require all granted
-</Directory>
\ No newline at end of file
+#
+# This is the main Apache HTTP server configuration file.  It contains the
+# configuration directives that give the server its instructions.
+# See <URL:http://httpd.apache.org/docs/2.4/> for detailed information.
+# In particular, see 
+# <URL:http://httpd.apache.org/docs/2.4/mod/directives.html>
+# for a discussion of each configuration directive.
+#
+# Do NOT simply read the instructions in here without understanding
+# what they do.  They're here only as hints or reminders.  If you are unsure
+# consult the online docs. You have been warned.  
+#
+# Configuration and logfile names: If the filenames you specify for many
+# of the server's control files begin with "/" (or "drive:/" for Win32), the
+# server will use that explicit path.  If the filenames do *not* begin
+# with "/", the value of ServerRoot is prepended -- so 'log/access_log'
+# with ServerRoot set to '/www' will be interpreted by the
+# server as '/www/log/access_log', where as '/log/access_log' will be
+# interpreted as '/log/access_log'.
+
+#
+# ServerRoot: The top of the directory tree under which the server's
+# configuration, error, and log files are kept.
+#
+# Do not add a slash at the end of the directory path.  If you point
+# ServerRoot at a non-local disk, be sure to specify a local disk on the
+# Mutex directive, if file-based mutexes are used.  If you wish to share the
+# same ServerRoot for multiple httpd daemons, you will need to change at
+# least PidFile.
+#
+ServerRoot "/etc/httpd"
+
+#
+# Listen: Allows you to bind Apache to specific IP addresses and/or
+# ports, instead of the default. See also the <VirtualHost>
+# directive.
+#
+# Change this to Listen on specific IP addresses as shown below to 
+# prevent Apache from glomming onto all bound IP addresses.
+#
+#Listen 12.34.56.78:80
+Listen 80
+
+#
+# Dynamic Shared Object (DSO) Support
+#
+# To be able to use the functionality of a module which was built as a DSO you
+# have to place corresponding `LoadModule' lines at this location so the
+# directives contained in it are actually available _before_ they are used.
+# Statically compiled modules (those listed by `httpd -l') do not need
+# to be loaded here.
+#
+# Example:
+# LoadModule foo_module modules/mod_foo.so
+#
+Include conf.modules.d/*.conf
+
+#
+# If you wish httpd to run as a different user or group, you must run
+# httpd as root initially and it will switch.  
+#
+# User/Group: The name (or #number) of the user/group to run httpd as.
+# It is usually good practice to create a dedicated user and group for
+# running httpd, as with most system services.
+#
+User apache
+Group apache
+
+# 'Main' server configuration
+#
+# The directives in this section set up the values used by the 'main'
+# server, which responds to any requests that aren't handled by a
+# <VirtualHost> definition.  These values also provide defaults for
+# any <VirtualHost> containers you may define later in the file.
+#
+# All of these directives may appear inside <VirtualHost> containers,
+# in which case these default settings will be overridden for the
+# virtual host being defined.
+#
+
+#
+# ServerAdmin: Your address, where problems with the server should be
+# e-mailed.  This address appears on some server-generated pages, such
+# as error documents.  e.g. admin@your-domain.com
+#
+ServerAdmin root@localhost
+
+#
+# ServerName gives the name and port that the server uses to identify itself.
+# This can often be determined automatically, but we recommend you specify
+# it explicitly to prevent problems during startup.
+#
+# If your host doesn't have a registered DNS name, enter its IP address here.
+#
+#ServerName www.example.com:80
+
+#
+# Deny access to the entirety of your server's filesystem. You must
+# explicitly permit access to web content directories in other 
+# <Directory> blocks below.
+#
+<Directory />
+    AllowOverride none
+    Require all denied
+</Directory>
+
+#
+# Note that from this point forward you must specifically allow
+# particular features to be enabled - so if something's not working as
+# you might expect, make sure that you have specifically enabled it
+# below.
+#
+
+#
+# DocumentRoot: The directory out of which you will serve your
+# documents. By default, all requests are taken from this directory, but
+# symbolic links and aliases may be used to point to other locations.
+#
+DocumentRoot "/var/www/html"
+
+#
+# Relax access to content within /var/www.
+#
+<Directory "/var/www">
+    AllowOverride None
+    # Allow open access:
+    Require all granted
+</Directory>
+
+# Further relax access to the default document root:
+<Directory "/var/www/html">
+    #
+    # Possible values for the Options directive are "None", "All",
+    # or any combination of:
+    #   Indexes Includes FollowSymLinks SymLinksifOwnerMatch ExecCGI MultiViews
+    #
+    # Note that "MultiViews" must be named *explicitly* --- "Options All"
+    # doesn't give it to you.
+    #
+    # The Options directive is both complicated and important.  Please see
+    # http://httpd.apache.org/docs/2.4/mod/core.html#options
+    # for more information.
+    #
+    Options Indexes FollowSymLinks
+
+    #
+    # AllowOverride controls what directives may be placed in .htaccess files.
+    # It can be "All", "None", or any combination of the keywords:
+    #   Options FileInfo AuthConfig Limit
+    #
+    AllowOverride None
+
+    #
+    # Controls who can get stuff from this server.
+    #
+    Require all granted
+</Directory>
+
+#
+# DirectoryIndex: sets the file that Apache will serve if a directory
+# is requested.
+#
+<IfModule dir_module>
+    DirectoryIndex index.html
+</IfModule>
+
+#
+# The following lines prevent .htaccess and .htpasswd files from being 
+# viewed by Web clients. 
+#
+<Files ".ht*">
+    Require all denied
+</Files>
+
+#
+# ErrorLog: The location of the error log file.
+# If you do not specify an ErrorLog directive within a <VirtualHost>
+# container, error messages relating to that virtual host will be
+# logged here.  If you *do* define an error logfile for a <VirtualHost>
+# container, that host's errors will be logged there and not here.
+#
+ErrorLog "logs/error_log"
+
+#
+# LogLevel: Control the number of messages logged to the error_log.
+# Possible values include: debug, info, notice, warn, error, crit,
+# alert, emerg.
+#
+LogLevel warn
+
+<IfModule log_config_module>
+    #
+    # The following directives define some format nicknames for use with
+    # a CustomLog directive (see below).
+    #
+    LogFormat "%h %l %u %t \"%r\" %>s %b \"%{Referer}i\" \"%{User-Agent}i\"" combined
+    LogFormat "%h %l %u %t \"%r\" %>s %b" common
+
+    <IfModule logio_module>
+      # You need to enable mod_logio.c to use %I and %O
+      LogFormat "%h %l %u %t \"%r\" %>s %b \"%{Referer}i\" \"%{User-Agent}i\" %I %O" combinedio
+    </IfModule>
+
+    #
+    # The location and format of the access logfile (Common Logfile Format).
+    # If you do not define any access logfiles within a <VirtualHost>
+    # container, they will be logged here.  Contrariwise, if you *do*
+    # define per-<VirtualHost> access logfiles, transactions will be
+    # logged therein and *not* in this file.
+    #
+    #CustomLog "logs/access_log" common
+
+    #
+    # If you prefer a logfile with access, agent, and referer information
+    # (Combined Logfile Format) you can use the following directive.
+    #
+    CustomLog "logs/access_log" combined
+</IfModule>
+
+<IfModule alias_module>
+    #
+    # Redirect: Allows you to tell clients about documents that used to 
+    # exist in your server's namespace, but do not anymore. The client 
+    # will make a new request for the document at its new location.
+    # Example:
+    # Redirect permanent /foo http://www.example.com/bar
+
+    #
+    # Alias: Maps web paths into filesystem paths and is used to
+    # access content that does not live under the DocumentRoot.
+    # Example:
+    # Alias /webpath /full/filesystem/path
+    #
+    # If you include a trailing / on /webpath then the server will
+    # require it to be present in the URL.  You will also likely
+    # need to provide a <Directory> section to allow access to
+    # the filesystem path.
+
+    #
+    # ScriptAlias: This controls which directories contain server scripts. 
+    # ScriptAliases are essentially the same as Aliases, except that
+    # documents in the target directory are treated as applications and
+    # run by the server when requested rather than as documents sent to the
+    # client.  The same rules about trailing "/" apply to ScriptAlias
+    # directives as to Alias.
+    #
+    ScriptAlias /cgi-bin/ "/var/www/cgi-bin/"
+
+</IfModule>
+
+#
+# "/var/www/cgi-bin" should be changed to whatever your ScriptAliased
+# CGI directory exists, if you have that configured.
+#
+<Directory "/var/www/cgi-bin">
+    AllowOverride None
+    Options None
+    Require all granted
+</Directory>
+
+<IfModule mime_module>
+    #
+    # TypesConfig points to the file containing the list of mappings from
+    # filename extension to MIME-type.
+    #
+    TypesConfig /etc/mime.types
+
+    #
+    # AddType allows you to add to or override the MIME configuration
+    # file specified in TypesConfig for specific file types.
+    #
+    #AddType application/x-gzip .tgz
+    #
+    # AddEncoding allows you to have certain browsers uncompress
+    # information on the fly. Note: Not all browsers support this.
+    #
+    #AddEncoding x-compress .Z
+    #AddEncoding x-gzip .gz .tgz
+    #
+    # If the AddEncoding directives above are commented-out, then you
+    # probably should define those extensions to indicate media types:
+    #
+    AddType application/x-compress .Z
+    AddType application/x-gzip .gz .tgz
+
+    #
+    # AddHandler allows you to map certain file extensions to "handlers":
+    # actions unrelated to filetype. These can be either built into the server
+    # or added with the Action directive (see below)
+    #
+    # To use CGI scripts outside of ScriptAliased directories:
+    # (You will also need to add "ExecCGI" to the "Options" directive.)
+    #
+    #AddHandler cgi-script .cgi
+
+    # For type maps (negotiated resources):
+    #AddHandler type-map var
+
+    #
+    # Filters allow you to process content before it is sent to the client.
+    #
+    # To parse .shtml files for server-side includes (SSI):
+    # (You will also need to add "Includes" to the "Options" directive.)
+    #
+    AddType text/html .shtml
+    AddOutputFilter INCLUDES .shtml
+</IfModule>
+
+#
+# Specify a default charset for all content served; this enables
+# interpretation of all content as UTF-8 by default.  To use the 
+# default browser choice (ISO-8859-1), or to allow the META tags
+# in HTML content to override this choice, comment out this
+# directive:
+#
+AddDefaultCharset UTF-8
+
+<IfModule mime_magic_module>
+    #
+    # The mod_mime_magic module allows the server to use various hints from the
+    # contents of the file itself to determine its type.  The MIMEMagicFile
+    # directive tells the module where the hint definitions are located.
+    #
+     conf/magic
+</IfModule>
+
+#
+# Customizable error responses come in three flavors:
+# 1) plain text 2) local redirects 3) external redirects
+#
+# Some examples:
+#ErrorDocument 500 "The server made a boo boo."
+#ErrorDocument 404 /missing.html
+#ErrorDocument 404 "/cgi-bin/missing_handler.pl"
+#ErrorDocument 402 http://www.example.com/subscription_info.html
+#
+
+#
+# EnableMMAP and EnableSendfile: On systems that support it, 
+# memory-mapping or the sendfile syscall may be used to deliver
+# files.  This usually improves server performance, but must
+# be turned off when serving from networked-mounted 
+# filesystems or if support for these functions is otherwise
+# broken on your system.
+# Defaults if commented: EnableMMAP On, EnableSendfile Off
+#
+#EnableMMAP off
+EnableSendfile on
+
+# Supplemental configuration
+#
+# Load config files in the "/etc/httpd/conf.d" directory, if any.
+ conf.d/*.conf
+
+LoadModule wsgi_module "/usr/lib64/httpd/modules/mod_wsgi-py37.cpython-37m-x86_64-linux-gnu.so"
+ "/var/gdal"
+
+ / /usr/src/app/run.wsgi
+<Directory /usr/>
+  Require all granted
+</Directory>

+#! /bin/sh
+
+#停止容器
+echo "正在关闭容器..."
+docker stop dmapmanager
+docker rm dmapmanager
+
+curPath=$(readlink -f $(dirname $0))
+
+
+#设置日志权限
+chmod -R 777 $curPath/logs/*
+
+#设置端口
+port=""
+if [ ! -n "$1" ] ;then
+port="8840"
+echo "未设置端口，使用默认8840端口..."
+else
+port=$1
+echo "端口设置为$1 ..."
+fi
+
+#启动容器和apache
+echo "正在启动容器..."
+set="--privileged=true -e TZ="Asia/Shanghai" --restart=always -e ALLOW_IP_RANGE=0.0.0.0/0"
+docker run -d --name dmapmanager $set -p $port:80 -v $curPath:/usr/src/app -v $curPath/httpd.conf:/etc/httpd/conf/httpd.conf dci/dmapdms:4.0 /usr/sbin/init
+docker exec -d dmapmanager systemctl start httpd
+sleep 5
+curl localhost:$port/release

-#! /bin/sh
-
-#停止容器
-echo "正在关闭容器..."
-docker stop apache
-docker rm apache
-
-curPath=$(readlink -f $(dirname $0))
-
-#寻找模块
-echo "在modules下寻找模块..."
-map=""
-for mod in $(ls $curPath/modules)
-do
-  map="$map -v $curPath/modules/$mod:/usr/src/$mod"
-done
-
-#设置日志权限
-for mod in $(ls $curPath/modules)
-do
-  chmod -R 777 $curPath/modules/$mod/logs/*
-done
-
-
-#设置端口
-port=""
-if [ ! -n "$1" ] ;then
-  port="8888"
-  echo "未设置端口，使用默认8888端口..."
-else
-  port=$1
-  echo "端口设置为$1 ..."
-fi
-
-#修改httpd.conf
-echo "正在修改httpd.conf..."
-rm $curPath/httpd.conf
-cp $curPath/httpd.conf.sample $curPath/httpd.conf
-echo "<VirtualHost *>" >> $curPath/httpd.conf
-echo "    ServerName apacheflask">>$curPath/httpd.conf
-echo "    WSGIDaemonProcess yourapplication user=chinadci group=chinadci threads=5">>$curPath/httpd.conf
-
-for mod in $(ls $curPath/modules)
-do
-  echo "    WSGIScriptAlias /$mod /usr/src/$mod/run.wsgi">>$curPath/httpd.conf
-done
-
-echo "    <Directory /usr/src/app>">>$curPath/httpd.conf
-echo "        WSGIProcessGroup yourapplication">>$curPath/httpd.conf
-echo "        WSGIApplicationGroup %{GLOBAL}">>$curPath/httpd.conf
-echo "        Require all granted">>$curPath/httpd.conf
-echo "    </Directory>">>$curPath/httpd.conf
-echo "</VirtualHost>">>$curPath/httpd.conf
-
-#启动容器和apache
-echo "正在启动容器..."
-set="--privileged=true -e TZ="Asia/Shanghai" --restart=always -e ALLOW_IP_RANGE=0.0.0.0/0"
-docker run -d --name apache $set -p $port:80 $map -v $curPath/httpd.conf:/etc/httpd/conf/httpd.conf dci/apache:1.0 /usr/sbin/init
-docker exec -d apache systemctl start httpd
-