...
|
...
|
@@ -7,40 +7,386 @@ from sqlalchemy import create_engine |
7
|
7
|
from sqlalchemy.orm import sessionmaker,Session
|
8
|
8
|
from osgeo import ogr
|
9
|
9
|
from osgeo.ogr import *
|
|
10
|
+import uuid
|
|
11
|
+import base64
|
|
12
|
+from pyDes import des, PAD_PKCS5, ECB
|
|
13
|
+import json
|
|
14
|
+
|
|
15
|
+class DES():
|
|
16
|
+ '''
|
|
17
|
+ DES密码加解密
|
|
18
|
+ '''
|
|
19
|
+ Des: des = des("Chinadci", ECB, "\0\0\0\0\0\0\0\0",
|
|
20
|
+ pad=None, padmode=PAD_PKCS5)
|
|
21
|
+
|
|
22
|
+ @classmethod
|
|
23
|
+ def encode(cls, data):
|
|
24
|
+ return str(base64.b64encode(cls.Des.encrypt(data)), encoding="utf8")
|
|
25
|
+
|
|
26
|
+ @classmethod
|
|
27
|
+ def decode(cls, data):
|
|
28
|
+ if data:
|
|
29
|
+ return str(cls.Des.decrypt(base64.b64decode(data.encode("utf-8"))), encoding="utf8")
|
|
30
|
+
|
|
31
|
+ else:
|
|
32
|
+ return data
|
10
|
33
|
|
11
|
34
|
class Migration():
|
12
|
35
|
|
13
|
|
- dmap_dms_ds = None
|
14
|
|
- dmap_server_ds = None
|
15
|
|
- dmap_manager_ds = None
|
|
36
|
+ # dmap_dms_ds = None
|
|
37
|
+ # dmap_dms_session = None
|
|
38
|
+ # dmap_server_ds = None
|
|
39
|
+ # dmap_manager_ds = None
|
|
40
|
+ # dmap_manager_session = None
|
16
|
41
|
|
17
|
|
- def __init__(self,dmap_dms_db,dmap_server_db,dmap_manager_db):
|
|
42
|
+ def __init__(self,dmap_dms_db,dmap_server_db,dmap_manager_db,dmap_engine):
|
18
|
43
|
|
19
|
44
|
self.dmap_dms_ds : DataSource = self.open_pg_data_source(dmap_dms_db)
|
|
45
|
+ self.dmap_dms_session : Session = self.get_db_session(dmap_dms_db)
|
|
46
|
+
|
20
|
47
|
self.dmap_server_ds: DataSource = self.open_pg_data_source(dmap_server_db)
|
21
|
|
- self.dmap_manager_ds: DataSource = self.open_pg_data_source(dmap_manager_db)
|
22
|
48
|
|
|
49
|
+ self.dmap_manager_ds: DataSource = self.open_pg_data_source(dmap_manager_db)
|
|
50
|
+ self.dmap_manager_session: Session = self.get_db_session(dmap_manager_db)
|
|
51
|
+ self.dmap_engine = dmap_engine
|
23
|
52
|
|
24
|
53
|
|
25
|
54
|
def process(self):
|
26
|
|
- self.dmap_dms_migration()
|
|
55
|
+ # self.dmap_dms_migration()
|
|
56
|
+ # self.dmap_migration()
|
27
|
57
|
self.dmap_server_migration()
|
28
|
58
|
|
29
|
59
|
|
30
|
60
|
|
31
|
61
|
def dmap_dms_migration(self):
|
32
|
62
|
|
33
|
|
- database:Layer = self.dmap_dms_ds.ExecuteSQL('select * from "dmdms_database" ')
|
|
63
|
+ #数据库表
|
|
64
|
+ self.migration_table("dmdms_database", "dmap_database")
|
|
65
|
+ #目录表
|
|
66
|
+ self.migration_table("dmdms_catalog", "dmap_catalog")
|
|
67
|
+ #table表
|
|
68
|
+ self.migration_table("dmdms_table","dmap_table")
|
|
69
|
+ #column表
|
|
70
|
+ self.migration_table("dmdms_column","dmap_column")
|
|
71
|
+
|
|
72
|
+
|
|
73
|
+
|
|
74
|
+
|
|
75
|
+ def dmap_migration(self):
|
|
76
|
+
|
|
77
|
+ dms_service: Layer = self.dmap_dms_ds.GetLayerByName("dmap_service")
|
|
78
|
+ dms_service_layer: Layer = self.dmap_dms_ds.GetLayerByName("dmap_service_layer")
|
|
79
|
+
|
|
80
|
+ dmapmanager_service : Layer = self.dmap_manager_ds.GetLayerByName("dmap_map_service")
|
|
81
|
+ dmapmanager_service_defn = dmapmanager_service.GetLayerDefn()
|
|
82
|
+
|
|
83
|
+ dmapmanager_service_all : Layer = self.dmap_manager_ds.GetLayerByName("dmap_service")
|
|
84
|
+ dmapmanager_service_all_defn = dmapmanager_service_all.GetLayerDefn()
|
|
85
|
+
|
|
86
|
+ dmapmanager_service_function : Layer = self.dmap_manager_ds.GetLayerByName("dmap_service_function")
|
|
87
|
+ dmapmanager_service_function_defn = dmapmanager_service_function.GetLayerDefn()
|
|
88
|
+
|
|
89
|
+ services = []
|
|
90
|
+ for feat in dms_service:
|
|
91
|
+ service_dict = {}
|
|
92
|
+ for indx in range(feat.GetFieldCount()):
|
|
93
|
+ name = dms_service.schema[indx].GetName()
|
|
94
|
+ value = feat.GetField(indx)
|
|
95
|
+ service_dict[name] = value
|
|
96
|
+ services.append(service_dict)
|
|
97
|
+
|
|
98
|
+ layers = []
|
|
99
|
+ for la in dms_service_layer:
|
|
100
|
+ la_dict ={}
|
|
101
|
+ for indx in range(la.GetFieldCount()):
|
|
102
|
+ la_name = dms_service_layer.schema[indx].GetName()
|
|
103
|
+ la_value = la.GetField(indx)
|
|
104
|
+ la_dict[la_name] = la_value
|
|
105
|
+ layers.append(la_dict)
|
|
106
|
+
|
|
107
|
+
|
|
108
|
+ for ser in services:
|
|
109
|
+
|
|
110
|
+ try:
|
|
111
|
+ ser["layer"] = []
|
|
112
|
+ for la in layers:
|
|
113
|
+ if ser["service"]==la["service"]:
|
|
114
|
+ ser["layer"].append(la)
|
|
115
|
+
|
|
116
|
+ ser["layer"] = sorted(ser["layer"],key=lambda x:x["layerindex"],reverse=True)
|
|
117
|
+
|
|
118
|
+ guid = uuid.uuid1().__str__()
|
|
119
|
+ service_guid = uuid.uuid1().__str__()
|
|
120
|
+
|
34
|
121
|
|
|
122
|
+ dmap_feat_all: Feature = ogr.Feature(dmapmanager_service_all_defn)
|
35
|
123
|
|
36
|
|
- self.dmap_manager_ds.CopyLayer(database,"dmap_database",["OVERWRITE=YES"])
|
|
124
|
+ dmap_feat_all.SetField("guid",service_guid)
|
|
125
|
+ dmap_feat_all.SetField("name", ser["service"])
|
|
126
|
+ dmap_feat_all.SetField("title", ser["title"])
|
|
127
|
+ dmap_feat_all.SetField("state", 1)
|
|
128
|
+ dmap_feat_all.SetField("creator", "admin")
|
|
129
|
+ dmap_feat_all.SetField("type", "矢量地图")
|
|
130
|
+ dmap_feat_all.SetField("node", 1)
|
|
131
|
+ dmap_feat_all.SetField("overview", "http://{}/DMap/Services/{}/mapserver/WmsService?REQUEST=GetThumbnail".format(self.dmap_engine,ser["service"]))
|
|
132
|
+ dmap_feat_all.SetField("create_time",ser["sctime"] )
|
|
133
|
+ dmap_feat_all.SetField("update_time",ser["updatetime"] )
|
|
134
|
+ dmap_feat_all.SetField("description", ser["abstract"])
|
|
135
|
+ dmapmanager_service_all.CreateFeature(dmap_feat_all)
|
37
|
136
|
|
|
137
|
+ dmap_feat: Feature = ogr.Feature(dmapmanager_service_defn)
|
|
138
|
+ project_file = self.create_projectfile(ser)
|
|
139
|
+ # print(project_file)
|
38
|
140
|
|
|
141
|
+ dmap_feat.SetField("guid",guid)
|
|
142
|
+ dmap_feat.SetField("name", ser["service"])
|
|
143
|
+ dmap_feat.SetField("title", ser["title"])
|
|
144
|
+ dmap_feat.SetField("type", "mapserver")
|
|
145
|
+ dmap_feat.SetField("capabilities", 2)
|
|
146
|
+ dmap_feat.SetField("service_guid", service_guid)
|
|
147
|
+ dmap_feat.SetField("project", project_file)
|
|
148
|
+ dmapmanager_service.CreateFeature(dmap_feat)
|
39
|
149
|
|
|
150
|
+ dmap_function_feat: Feature = ogr.Feature(dmapmanager_service_function_defn)
|
|
151
|
+
|
|
152
|
+ function_guid = uuid.uuid1().__str__()
|
|
153
|
+ dmap_function_feat.SetField("guid",function_guid)
|
|
154
|
+ dmap_function_feat.SetField("type", "WMS")
|
|
155
|
+ dmap_function_feat.SetField("service_guid", service_guid)
|
|
156
|
+ dmapmanager_service_function.CreateFeature(dmap_function_feat)
|
|
157
|
+
|
|
158
|
+ dmap_function_feat2: Feature = ogr.Feature(dmapmanager_service_function_defn)
|
|
159
|
+ function_guid2 = uuid.uuid1().__str__()
|
|
160
|
+ dmap_function_feat2.SetField("guid",function_guid2)
|
|
161
|
+ dmap_function_feat2.SetField("type", "WFS")
|
|
162
|
+ dmap_function_feat2.SetField("service_guid", service_guid)
|
|
163
|
+ dmapmanager_service_function.CreateFeature(dmap_function_feat2)
|
|
164
|
+ except:
|
|
165
|
+ print("{}迁移失败".format(ser["service"]))
|
|
166
|
+
|
|
167
|
+
|
|
168
|
+
|
|
169
|
+ def migration_table(self,source_table,target_table):
|
|
170
|
+ source_table:Layer = self.dmap_dms_ds.GetLayerByName(source_table)
|
|
171
|
+ target_table:Layer = self.dmap_manager_ds.GetLayerByName(target_table)
|
|
172
|
+ dmap_table_featdef:FeatureDefn = target_table.GetLayerDefn()
|
|
173
|
+ for feat in source_table:
|
|
174
|
+ dmdms_table_feat : Feature = feat
|
|
175
|
+ migration_feat = ogr.Feature(dmap_table_featdef)
|
|
176
|
+ for indx in range(dmdms_table_feat.GetFieldCount()):
|
|
177
|
+ name = source_table.schema[indx].GetName()
|
|
178
|
+ value = dmdms_table_feat.GetField(indx)
|
|
179
|
+ migration_feat.SetField(name,value)
|
|
180
|
+
|
|
181
|
+ try:
|
|
182
|
+ target_table.CreateFeature(migration_feat)
|
|
183
|
+ except:
|
|
184
|
+ pass
|
40
|
185
|
|
41
|
186
|
def dmap_server_migration(self):
|
42
|
187
|
|
43
|
|
- pass
|
|
188
|
+ tile_map: Layer = self.dmap_server_ds.GetLayerByName("TileMapItem")
|
|
189
|
+ tiles = []
|
|
190
|
+ for tm in tile_map:
|
|
191
|
+ tm_dict ={}
|
|
192
|
+ tm:Feature = tm
|
|
193
|
+ for indx in range(tm.GetFieldCount()):
|
|
194
|
+ tm_name = tile_map.schema[indx].GetName()
|
|
195
|
+ tm_value = tm.GetField(indx)
|
|
196
|
+ if tm_name == "TileInfo":
|
|
197
|
+ tm_value= tm.GetFieldAsBinary(indx).decode()
|
|
198
|
+ if tm_name == "LayerInfo":
|
|
199
|
+ tm_value= tm.GetFieldAsBinary(indx).decode()
|
|
200
|
+ tm_dict[tm_name] = tm_value
|
|
201
|
+ tiles.append(tm_dict)
|
|
202
|
+
|
|
203
|
+ dmap_tile_service : Layer = self.dmap_manager_ds.GetLayerByName("dmap_tile_service")
|
|
204
|
+ dmap_tile_service_defn = dmap_tile_service.GetLayerDefn()
|
|
205
|
+
|
|
206
|
+ dmapmanager_service_all : Layer = self.dmap_manager_ds.GetLayerByName("dmap_service")
|
|
207
|
+ dmapmanager_service_all_defn = dmapmanager_service_all.GetLayerDefn()
|
|
208
|
+
|
|
209
|
+ dmapmanager_service_function : Layer = self.dmap_manager_ds.GetLayerByName("dmap_service_function")
|
|
210
|
+ dmapmanager_service_function_defn = dmapmanager_service_function.GetLayerDefn()
|
|
211
|
+
|
|
212
|
+ for tl in tiles:
|
|
213
|
+ try:
|
|
214
|
+ if tl["Type"] == 1:
|
|
215
|
+ guid = uuid.uuid1().__str__()
|
|
216
|
+ service_guid = uuid.uuid1().__str__()
|
|
217
|
+ layer_json = json.loads(tl["LayerInfo"])
|
|
218
|
+ tile_json = json.loads(tl["TileInfo"])
|
|
219
|
+
|
|
220
|
+ scheme = {}
|
|
221
|
+ scheme["dpi"] = "96"
|
|
222
|
+ scheme["cols"] = "256"
|
|
223
|
+ scheme["rows"] = "256"
|
|
224
|
+ scheme["description"] = ""
|
|
225
|
+ scheme["crs"] = tl["SRS"]
|
|
226
|
+ scheme["name"] = tile_json["TileMatrixSets"][0]["Id"]
|
|
227
|
+ scheme["top_left"] = "{},{}".format(tile_json["TileMatrixSets"][0]["TileMatrixList"][0]["Left"],
|
|
228
|
+ tile_json["TileMatrixSets"][0]["TileMatrixList"][0]["Top"])
|
|
229
|
+
|
|
230
|
+ levels = []
|
|
231
|
+ for lev in tile_json["TileMatrixSets"][0]["TileMatrixList"]:
|
|
232
|
+ level = {}
|
|
233
|
+ level["level"] = int(lev["Level"])
|
|
234
|
+ level["resolution"] = lev["Resolution"]
|
|
235
|
+ level["scale"] = lev["ScaleDenominator"]
|
|
236
|
+ levels.append(level)
|
|
237
|
+
|
|
238
|
+ scheme["levels"] = json.dumps(levels)
|
|
239
|
+ # scheme["levels"] = levels
|
|
240
|
+
|
|
241
|
+ dmap_feat_all: Feature = ogr.Feature(dmapmanager_service_all_defn)
|
|
242
|
+
|
|
243
|
+ dmap_feat_all.SetField("guid",service_guid)
|
|
244
|
+ dmap_feat_all.SetField("name", tl["Name"])
|
|
245
|
+ dmap_feat_all.SetField("title", tl["Title"])
|
|
246
|
+ dmap_feat_all.SetField("state", 1)
|
|
247
|
+ dmap_feat_all.SetField("creator", "admin")
|
|
248
|
+ dmap_feat_all.SetField("type", "电子地图")
|
|
249
|
+ dmap_feat_all.SetField("node", 1)
|
|
250
|
+
|
|
251
|
+
|
|
252
|
+ dmap_feat_all.SetField("overview", "http://{}/DMap/Services/{}/tileserver/WmtsService?REQUEST=GetThumbnail".format(self.dmap_engine,tl["Name"]))
|
|
253
|
+ dmap_feat_all.SetField("create_time",tl["CreateDate"] )
|
|
254
|
+ dmap_feat_all.SetField("update_time",tl["CreateDate"] )
|
|
255
|
+ dmap_feat_all.SetField("description", tl["Abstract"])
|
|
256
|
+ dmapmanager_service_all.CreateFeature(dmap_feat_all)
|
|
257
|
+
|
|
258
|
+ tile_feat: Feature = ogr.Feature(dmap_tile_service_defn)
|
|
259
|
+
|
|
260
|
+ tile_feat.SetField("guid",guid)
|
|
261
|
+ tile_feat.SetField("name", tl["Name"])
|
|
262
|
+ tile_type = "WMTS" if tl["Type"] ==1 else "TMS"
|
|
263
|
+
|
|
264
|
+ tile_feat.SetField("tile_type", tile_type)
|
|
265
|
+ vendor= None
|
|
266
|
+ if tl["Vendor"] ==0:
|
|
267
|
+ vendor="ESRI_V0"
|
|
268
|
+ if tl["Vendor"] ==1:
|
|
269
|
+ vendor="ESRI_V1"
|
|
270
|
+ if tl["Vendor"] ==2:
|
|
271
|
+ vendor="ESRI_V2"
|
|
272
|
+ if tl["Vendor"] ==3:
|
|
273
|
+ vendor="QGIS"
|
|
274
|
+ tile_feat.SetField("vendor", vendor)
|
|
275
|
+ tile_feat.SetField("create_time", tl["CreateDate"])
|
|
276
|
+ tile_feat.SetField("crs", tl["SRS"])
|
|
277
|
+
|
|
278
|
+ datasource = tl["Path"]
|
|
279
|
+ datasource = "/usr/local/dmap4"+datasource.split("/tiles")[1]
|
|
280
|
+
|
|
281
|
+ tile_feat.SetField("datasource", datasource)
|
|
282
|
+
|
|
283
|
+
|
|
284
|
+ tile_feat.SetField("metadata_url", "http://{}/DMap/Services/{}/MapServer/WMTSServer".format(self.dmap_engine,tl["Name"]))
|
|
285
|
+ tile_feat.SetField("description", tl["Abstract"])
|
|
286
|
+
|
|
287
|
+ tile_feat.SetField("layer_name", layer_json["Id"])
|
|
288
|
+ tile_feat.SetField("layer_title", layer_json["Title"])
|
|
289
|
+ tile_feat.SetField("layer_alias", layer_json["Title"])
|
|
290
|
+ tile_feat.SetField("layer_style", layer_json["Style"])
|
|
291
|
+ tile_feat.SetField("layer_format", layer_json["Format"])
|
|
292
|
+
|
|
293
|
+ tile_feat.SetField("layer_extent", "{},{},{},{}".format(layer_json["Extent"]["XMin"],
|
|
294
|
+ layer_json["Extent"]["XMax"],
|
|
295
|
+ layer_json["Extent"]["YMin"],
|
|
296
|
+ layer_json["Extent"]["YMax"]))
|
|
297
|
+
|
|
298
|
+ tile_feat.SetField("scheme", json.dumps(scheme))
|
|
299
|
+
|
|
300
|
+ tile_feat.SetField("service_guid", service_guid)
|
|
301
|
+
|
|
302
|
+ dmap_tile_service.CreateFeature(tile_feat)
|
|
303
|
+
|
|
304
|
+
|
|
305
|
+
|
|
306
|
+ dmap_function_feat: Feature = ogr.Feature(dmapmanager_service_function_defn)
|
|
307
|
+
|
|
308
|
+ function_guid = uuid.uuid1().__str__()
|
|
309
|
+ dmap_function_feat.SetField("guid",function_guid)
|
|
310
|
+ dmap_function_feat.SetField("type", tile_type)
|
|
311
|
+ dmap_function_feat.SetField("service_guid", service_guid)
|
|
312
|
+ dmapmanager_service_function.CreateFeature(dmap_function_feat)
|
|
313
|
+ else:
|
|
314
|
+ guid = uuid.uuid1().__str__()
|
|
315
|
+ service_guid = uuid.uuid1().__str__()
|
|
316
|
+
|
|
317
|
+ dmap_feat_all: Feature = ogr.Feature(dmapmanager_service_all_defn)
|
|
318
|
+
|
|
319
|
+ dmap_feat_all.SetField("guid", service_guid)
|
|
320
|
+ dmap_feat_all.SetField("name", tl["Name"])
|
|
321
|
+ dmap_feat_all.SetField("title", tl["Title"])
|
|
322
|
+ dmap_feat_all.SetField("state", 1)
|
|
323
|
+ dmap_feat_all.SetField("creator", "admin")
|
|
324
|
+ dmap_feat_all.SetField("type", "电子地图")
|
|
325
|
+ dmap_feat_all.SetField("node", 1)
|
|
326
|
+
|
|
327
|
+ dmap_feat_all.SetField("overview",
|
|
328
|
+ "http://{}/DMap/Services/{}/tileserver/TMSService?REQUEST=GetThumbnail".format(
|
|
329
|
+ self.dmap_engine, tl["Name"]))
|
|
330
|
+ dmap_feat_all.SetField("create_time", tl["CreateDate"])
|
|
331
|
+ dmap_feat_all.SetField("update_time", tl["CreateDate"])
|
|
332
|
+ dmap_feat_all.SetField("description", tl["Abstract"])
|
|
333
|
+ dmapmanager_service_all.CreateFeature(dmap_feat_all)
|
|
334
|
+
|
|
335
|
+ tile_feat: Feature = ogr.Feature(dmap_tile_service_defn)
|
|
336
|
+
|
|
337
|
+ tile_feat.SetField("guid", guid)
|
|
338
|
+ tile_feat.SetField("name", tl["Name"])
|
|
339
|
+ tile_type = "WMTS" if tl["Type"] == 1 else "TMS"
|
|
340
|
+
|
|
341
|
+ tile_feat.SetField("tile_type", tile_type)
|
|
342
|
+ vendor = None
|
|
343
|
+ if tl["Vendor"] == 0:
|
|
344
|
+ vendor = "ESRI_V0"
|
|
345
|
+ if tl["Vendor"] == 1:
|
|
346
|
+ vendor = "ESRI_V1"
|
|
347
|
+ if tl["Vendor"] == 2:
|
|
348
|
+ vendor = "ESRI_V2"
|
|
349
|
+ if tl["Vendor"] == 3:
|
|
350
|
+ vendor = "QGIS"
|
|
351
|
+ tile_feat.SetField("vendor", vendor)
|
|
352
|
+ tile_feat.SetField("create_time", tl["CreateDate"])
|
|
353
|
+ tile_feat.SetField("crs", tl["SRS"])
|
|
354
|
+
|
|
355
|
+ datasource = tl["Path"]
|
|
356
|
+ datasource = "/usr/local/dmap4" + datasource.split("/tiles")[1]
|
|
357
|
+
|
|
358
|
+ tile_feat.SetField("datasource", datasource)
|
|
359
|
+
|
|
360
|
+ tile_feat.SetField("metadata_url",
|
|
361
|
+ "http://{}/DMap/Services/{}/MapServer/TMSServer".format(self.dmap_engine,
|
|
362
|
+ tl["Name"]))
|
|
363
|
+ tile_feat.SetField("description", tl["Abstract"])
|
|
364
|
+
|
|
365
|
+ tile_feat.SetField("layer_name", layer_json["Id"])
|
|
366
|
+ tile_feat.SetField("layer_title", layer_json["Title"])
|
|
367
|
+ tile_feat.SetField("layer_alias", layer_json["Title"])
|
|
368
|
+ tile_feat.SetField("layer_style", layer_json["Style"])
|
|
369
|
+ tile_feat.SetField("layer_format", layer_json["Format"])
|
|
370
|
+
|
|
371
|
+ tile_feat.SetField("layer_extent", "{},{},{},{}".format(layer_json["Extent"]["XMin"],
|
|
372
|
+ layer_json["Extent"]["XMax"],
|
|
373
|
+ layer_json["Extent"]["YMin"],
|
|
374
|
+ layer_json["Extent"]["YMax"]))
|
|
375
|
+
|
|
376
|
+ tile_feat.SetField("service_guid", service_guid)
|
|
377
|
+
|
|
378
|
+ dmap_tile_service.CreateFeature(tile_feat)
|
|
379
|
+
|
|
380
|
+ dmap_function_feat: Feature = ogr.Feature(dmapmanager_service_function_defn)
|
|
381
|
+
|
|
382
|
+ function_guid = uuid.uuid1().__str__()
|
|
383
|
+ dmap_function_feat.SetField("guid", function_guid)
|
|
384
|
+ dmap_function_feat.SetField("type", tile_type)
|
|
385
|
+ dmap_function_feat.SetField("service_guid", service_guid)
|
|
386
|
+ dmapmanager_service_function.CreateFeature(dmap_function_feat)
|
|
387
|
+ except:
|
|
388
|
+ print("{}迁移失败".format(tl["Name"]))
|
|
389
|
+
|
44
|
390
|
|
45
|
391
|
|
46
|
392
|
def end(self):
|
...
|
...
|
@@ -83,12 +429,120 @@ class Migration(): |
83
|
429
|
|
84
|
430
|
return user, password, host, port, database
|
85
|
431
|
|
|
432
|
+ def create_projectfile(self,service_info):
|
|
433
|
+
|
|
434
|
+ layers = service_info["layer"]
|
|
435
|
+ project_xml_format='''
|
|
436
|
+<dmap projectname="{service_name}" version="">
|
|
437
|
+ <projectCrs>
|
|
438
|
+ <spatialrefsys>
|
|
439
|
+ <wkt/>
|
|
440
|
+ <proj4/>
|
|
441
|
+ <srid>0</srid>
|
|
442
|
+ </spatialrefsys>
|
|
443
|
+ </projectCrs>
|
|
444
|
+ <projectlayers>
|
|
445
|
+ {layers}
|
|
446
|
+ </projectlayers>
|
|
447
|
+</dmap>
|
|
448
|
+ '''
|
|
449
|
+
|
|
450
|
+ maplayer_xml = ""
|
|
451
|
+
|
|
452
|
+ for layer_info in layers:
|
|
453
|
+ table_name = layer_info["layername"]
|
|
454
|
+ database_guid = layer_info["dbsource"]
|
|
455
|
+
|
|
456
|
+ table_query = self.dmap_dms_session.execute(
|
|
457
|
+ "select guid,feature_count,extent,table_type from dmdms_table where name='{}' and database_guid='{}'".format(table_name,database_guid)).fetchone()
|
|
458
|
+ table = table_query
|
|
459
|
+ table_guid = table[0]
|
|
460
|
+ table_feature_count = table[1]
|
|
461
|
+ extent = [float(x) for x in table[2].split(",")]
|
|
462
|
+ table_type = table[3]
|
|
463
|
+
|
|
464
|
+
|
|
465
|
+ database_query = self.dmap_dms_session.execute(
|
|
466
|
+ "select sqlalchemy_uri from dmdms_database where guid='{}'".format(database_guid)).fetchone()
|
|
467
|
+
|
|
468
|
+ database = database_query
|
|
469
|
+
|
|
470
|
+
|
|
471
|
+ speci_db_ds : DataSource = self.open_pg_data_source(DES.decode(database[0]))
|
|
472
|
+
|
|
473
|
+ gemetry_type = ["MULTIPOINT","MULTILINESTRING","MULTIPOLYGON"][table_type-1]
|
|
474
|
+
|
|
475
|
+ layer = speci_db_ds.GetLayerByName(table_name)
|
|
476
|
+ geom_column = layer.GetGeometryColumn()
|
|
477
|
+ srid = self.get_srid(speci_db_ds,table_name)
|
|
478
|
+
|
|
479
|
+ maplayer_xml_format_each='''
|
|
480
|
+ <maplayer alias="" alwaysShow="false" featurecount="{feature_count}" geometry="{gemetry_type}" geomfield="{geom_column}" id="{table_guid}" name="{table_name}" schema="public" srid="{srid}" tag="" type="1" visible="true" workspace="">
|
|
481
|
+ <extent>
|
|
482
|
+ <xmin>{xmin}</xmin>
|
|
483
|
+ <ymin>{ymin}</ymin>
|
|
484
|
+ <xmax>{xmax}</xmax>
|
|
485
|
+ <ymax>{ymax}</ymax>
|
|
486
|
+ </extent>
|
|
487
|
+ <datasource>{database_guid}</datasource>
|
|
488
|
+ <renderer>
|
|
489
|
+ {renderer}
|
|
490
|
+ </renderer>
|
|
491
|
+ </maplayer>
|
|
492
|
+
|
|
493
|
+ '''
|
|
494
|
+ maplayer_xml_each = maplayer_xml_format_each.format(
|
|
495
|
+ xmin = extent[0],
|
|
496
|
+ xmax = extent[1],
|
|
497
|
+ ymin = extent[2],
|
|
498
|
+ ymax = extent[3],
|
|
499
|
+ feature_count = table_feature_count,
|
|
500
|
+ database_guid = database_guid,
|
|
501
|
+ gemetry_type = gemetry_type,
|
|
502
|
+ geom_column = geom_column,
|
|
503
|
+ table_guid = table_guid,
|
|
504
|
+ table_name = table_name,
|
|
505
|
+ srid = srid,
|
|
506
|
+ renderer= layer_info["renderer"]
|
|
507
|
+ )
|
|
508
|
+
|
|
509
|
+ maplayer_xml = "{}{}".format(maplayer_xml,maplayer_xml_each)
|
|
510
|
+ speci_db_ds.Destroy()
|
|
511
|
+
|
|
512
|
+ project_xml = project_xml_format.format(service_name=service_info["service"],
|
|
513
|
+ layers=maplayer_xml).strip()
|
|
514
|
+
|
|
515
|
+ # print(project_xml)
|
|
516
|
+
|
|
517
|
+ return str(base64.b64encode(project_xml.encode('utf-8')), encoding="utf8")
|
|
518
|
+
|
|
519
|
+
|
|
520
|
+
|
|
521
|
+ def get_db_session(self,db_url, autocommit=False) -> Session:
|
|
522
|
+ engine = create_engine(db_url)
|
|
523
|
+ system_session :Session= sessionmaker(bind=engine, autocommit=autocommit)()
|
|
524
|
+ return system_session
|
|
525
|
+
|
|
526
|
+ def get_srid(self,pg_ds,table_name):
|
|
527
|
+ layer = pg_ds.GetLayerByName(table_name)
|
|
528
|
+ if not layer:
|
|
529
|
+ return None
|
|
530
|
+ srid_sql = '''select st_srid({}) from public."{}" limit 1'''.format(layer.GetGeometryColumn(), layer.GetName())
|
|
531
|
+ srid_layer = pg_ds.ExecuteSQL(srid_sql)
|
|
532
|
+ srid_feature = srid_layer.GetNextFeature()
|
|
533
|
+ if srid_feature:
|
|
534
|
+ if srid_feature.GetField(0):
|
|
535
|
+ return int(srid_feature.GetField(0))
|
|
536
|
+ else:
|
|
537
|
+ return None
|
|
538
|
+
|
86
|
539
|
if __name__ == '__main__':
|
87
|
540
|
|
88
|
541
|
dmap_dms_db = "postgresql://postgres:chinadci@172.26.60.100:5432/dmap_dms"
|
89
|
542
|
dmap_server_db = "postgresql://postgres:chinadci@172.26.60.100:5432/DmapServer"
|
90
|
543
|
dmap_manager_db = "postgresql://postgres:chinadci@172.26.60.100:5432/migration"
|
|
544
|
+ dmap_engine = "172.26.60.101:8822"
|
91
|
545
|
|
92
|
|
- migration = Migration(dmap_dms_db,dmap_server_db,dmap_manager_db)
|
|
546
|
+ migration = Migration(dmap_dms_db,dmap_server_db,dmap_manager_db,dmap_engine)
|
93
|
547
|
migration.process()
|
94
|
548
|
migration.end() |
|
|
\ No newline at end of file |
...
|
...
|
|