def classified(self):
self._object_confirm = self.Object_Confirm_IUnKnown
self._object_name = None
current_path = self.file_info.file_name_with_full_path
metadata_file_name = CFile.join_file(current_path,
self.FileName_MetaData_Bus_21AT)
if CFile.file_or_path_exist(metadata_file_name):
self.__bus_metadata_xml_file_name__ = metadata_file_name
self.__metadata_xml_obj__ = CXml()
try:
self.__metadata_xml_obj__.load_file(metadata_file_name)
self.__classified_object_type = CXml.get_element_text(
self.__metadata_xml_obj__.xpath_one(
self.Path_21AT_MD_Content_ProductType))
if CUtils.equal_ignore_case(
self.__classified_object_type,
CUtils.dict_value_by_name(self.get_information(),
self.Plugins_Info_Type,
None)):
self._object_confirm = self.Object_Confirm_IKnown
self._object_name = CXml.get_element_text(
self.__metadata_xml_obj__.xpath_one(
self.Path_21AT_MD_Content_ProductName))
except:
self.__metadata_xml_obj__ = None
CLogger().warning('发现文件{0}符合二十一世纪业务数据集标准, 但该文件格式有误, 无法打开! ')
return self._object_confirm, self._object_name
def get_sync_dict_list(self, insert_or_updata) -> list:
"""
insert_or_updata 中 self.DB_True为insert，DB_False为updata
本方法的写法为强规则，调用add_value_to_sync_dict_list配置
第一个参数为list，第二个参数为字段名，第三个参数为字段值，第四个参数为特殊配置
"""
sync_dict_list = self.get_sync_predefined_dict_list(insert_or_updata)
object_table_id = self._obj_id
object_table_data = self._dataset
self.add_value_to_sync_dict_list(sync_dict_list, 'aprnwid',
object_table_id)
self.add_value_to_sync_dict_list(
sync_dict_list, 'datatype',
object_table_data.value_by_name(0, 'dsodatatype', ''))
dsometadataxml = object_table_data.value_by_name(
0, 'dsometadataxml_bus', '')
dsometadataxml_xml = CXml()
dsometadataxml_xml.load_xml(dsometadataxml) # 加载查询出来的xml
self.add_value_to_sync_dict_list(sync_dict_list, 'dsometadatajson',
dsometadataxml)
self.add_value_to_sync_dict_list(
sync_dict_list, 'sensors',
list([
dsometadataxml_xml.get_element_text_by_xpath_one(
'/root/MajorSource')
]), self.DataValueType_Array)
return sync_dict_list
def process_metadata_bus_dict(self):
dataset = self._dataset
class_plugins = self.get_class_plugins()
try:
dsometadataxml_xml = CXml()
dsometadataxml = dataset.value_by_name(0, 'dsometadataxml_bus', '')
dsometadataxml_xml.load_xml(dsometadataxml)
view_path = settings.application.xpath_one(
self.Path_Setting_MetaData_Dir_View, None)
browser_path = CFile.file_path(
dataset.value_by_name(0, 'dso_browser', None))
multiple_metadata_bus_filename_dict = \
class_plugins.get_multiple_metadata_bus_filename_with_path(
CFile.join_file(view_path, browser_path)
)
result, metadata_bus_dict = class_plugins.metadata_bus_xml_to_dict(
dsometadataxml_xml, multiple_metadata_bus_filename_dict)
self.set_metadata_bus_dict(metadata_bus_dict)
return result
except Exception as error:
return CResult.merge_result(
self.Failure,
'卫星数据的业务元数据的详细内容解析出错!原因为{0}'.format(error.__str__()))
def txt_to_xml(self, file_metadata_name_with_path: str):
"""
完成 王学谦 txt文件转xml,在函数外提前定义xml对象并获取父节点传入，函数会将通过父节点构造xml对象 by王学谦
:param file_metadata_name_with_path:查询的mat文件全名，带路径
:return xml_obj:将文件内容存储好的项目对象
"""
text_list = CFile.file_2_list(
file_metadata_name_with_path) # 获取mat文件作为列表
if (text_list is None) or len(text_list) == 0:
raise Exception('元数据文件无法读取，请检查') # 如果获取的文件内容为空，则抛出异常
xml_obj = CXml() # 建立xml对象
node_root = xml_obj.new_xml('root')
xml_obj.set_attr(node_root, self.Name_Type,
self.Transformer_TXT) # 设置root节点与属性
for row_text in text_list:
if not CUtils.equal_ignore_case(row_text, ''):
row_list = re.split(r'=',
row_text.strip()) # 利用正则表达式，根据一个或多个tab剪切字符
# item节点
node_item = xml_obj.create_element(node_root, 'item')
xml_obj.set_attr(node_item, self.Name_Name,
CUtils.any_2_str(row_list[0]).strip())
if len(row_list) > 1:
item_value = CUtils.any_2_str(row_list[1].strip())
if item_value.startswith('"') and item_value.endswith('"'):
item_value = item_value[1:-1]
xml_obj.set_element_text(node_item,
item_value) # 设置item节点与属性与内容
return xml_obj
def __init__(self):
self.__quality__ = CQuality()
self.__metadata_extract_result__ = self.Not_Support
self.__metadata_extract_memo__ = ''
self.__metadata_text__ = None
self.__metadata_xml__ = CXml()
self.__metadata_json__ = CJson()
self.__metadata_type__ = self.MetaDataFormat_Text
self.__metadata_bus_extract_result__ = self.Not_Support
self.__metadata_bus_extract_memo__ = ''
self.__metadata_bus_text__ = None
self.__metadata_bus_xml__ = CXml()
self.__metadata_bus_json__ = CJson()
self.__metadata_bus_type__ = self.MetaDataFormat_Text
self.__thumb_img_file_name__ = ''
self.__browse_img_file_name__ = ''
self.__metadata_view_extract_result__ = self.Not_Support
self.__metadata_view_extract_memo__ = ''
self.__time_information__ = CJson()
self.__metadata_time_extract_result__ = self.Not_Support
self.__metadata_time_extract_memo__ = ''
self.__metadata_spatial_extract_result__ = self.Not_Support
self.__metadata_spatial_extract_memo__ = ''
self.__metadata_spatial__ = CMDSpatial()
def xls_to_xml(self, file_metadata_name_with_path: str):
"""
完成 王学谦 xls/xlsx文件转xml,在函数外提前定义xml对象并获取父节点传入，函数会将通过父节点构造xml对象 by王学谦
:param file_metadata_name_with_path:查询的xls/xlsx文件全名，带路径
:return xml_obj:将文件内容存储好的项目对象
"""
all_data = xlrd.open_workbook(file_metadata_name_with_path) # 获取表格所有内容
table_data = all_data.sheets()[0] # 默认获取第一个表格
cols_num = table_data.ncols # 获取列数
rows_num = table_data.nrows # 获取行数
cols_index = 0 # 预定义列的index
if CUtils.equal_ignore_case(CUtils.any_2_str(cols_num),
CUtils.any_2_str(2)):
pass # 无序号列从1列开始
elif CUtils.equal_ignore_case(CUtils.any_2_str(cols_num),
CUtils.any_2_str(3)):
cols_index = 1 # 有序号列从2列开始
else:
raise Exception('xls格式异常，无法正常解析')
xml_obj = CXml() # 建立xml对象
node_root = xml_obj.new_xml('root')
xml_obj.set_attr(node_root, self.Name_Type,
self.transformer_type) # 设置root节点与属性
for row in range(0, rows_num):
node_item = xml_obj.create_element(node_root, 'item')
xml_obj.set_attr(
node_item, self.Name_Name,
CUtils.any_2_str(table_data.cell(row,
cols_index).value).lower())
xml_obj.set_element_text(
node_item,
table_data.cell(row, cols_index + 1).value) # 设置item节点与属性与内容
return xml_obj
def mat_to_xml(self, file_metadata_name_with_path: str):
"""
完成 王学谦 mat文件转xml,在函数外提前定义xml对象并获取父节点传入，函数会将通过父节点构造xml对象 by王学谦
:param file_metadata_name_with_path:查询的mat文件全名，带路径
:return xml_obj:将文件内容存储好的项目对象
"""
text_list = CFile.file_2_list(
file_metadata_name_with_path) # 获取mat文件作为列表
if (text_list is
None) or len(text_list) == 0 or CUtils.equal_ignore_case(
CUtils.any_2_str(text_list), ''):
raise # 如果获取的文件内容为空，则抛出异常
flag = False # 设置标志
xml_obj = CXml() # 建立xml对象
node_root = xml_obj.new_xml('root')
xml_obj.set_attr(node_root, self.Name_Type,
self.transformer_type) # 设置root节点与属性
for index, row_text in enumerate(text_list):
if row_text.startswith('1\t'): # 从开头为1+tab键的行开始录入
flag = True
row_list = re.split(r'\s+', row_text) # 利用正则表达式，根据一个或多个tab剪切字符
if flag:
node_item = xml_obj.create_element(node_root, 'item')
xml_obj.set_attr(node_item, self.Name_Name,
CUtils.any_2_str(row_list[1]).lower())
xml_obj.set_element_text(
node_item,
CUtils.any_2_str(row_list[2].strip())) # 设置item节点与属性与内容
if not flag:
raise Exception('文件内容异常，无法正常识别文件开头') # 如果未找到1+tab键开头，则抛出异常
return xml_obj
def a_xml_attribute(cls, audit_id, audit_title, audit_group, audit_result,
xml_obj: CXml, xpath: str, attr_name: str,
qa_items: dict) -> list:
result_dict = cls.__init_audit_dict__(audit_id, audit_title,
audit_group, audit_result)
if xml_obj is None:
result_dict[cls.Name_Message] = 'XML对象不合法, 节点[{0}]不存在'.format(
xpath)
return [result_dict]
element_obj = xml_obj.xpath_one(xpath)
if element_obj is not None:
if CXml.attr_exist(element_obj, attr_name):
attr_text = CXml.get_attr(element_obj, attr_name, '')
return cls.__a_check_value__(
result_dict, attr_text,
'属性[{0}]在XML节点[{1}.{2}]'.format(audit_title, xpath,
attr_name), qa_items)
else:
result_dict[
cls.
Name_Message] = '属性[{0}]在XML节点[{1}.{2}]未找到, 请检查修正!'.format(
audit_title, xpath, attr_name)
else:
result_dict[
cls.Name_Message] = '属性[{0}]在XML节点[{1}]未找到, 请检查修正!'.format(
audit_title, xpath)
return [result_dict]
def a_xml_element(cls, audit_id, audit_title, audit_group, audit_result,
xml_obj: CXml, xpath: str, qa_items: dict) -> list:
"""
判断一个xml元数据中, 指定的xpath, 对应的element, 满足 kargs参数中的检测项目
:param audit_id:
:param audit_title:
:param audit_group:
:param audit_result:
:param xml_obj:
:param xpath:
:param qa_items:
:return:
"""
result_dict = cls.__init_audit_dict__(audit_id, audit_title,
audit_group, audit_result)
if xml_obj is None:
result_dict[cls.Name_Message] = 'XML对象不合法, 节点[{0}]不存在'.format(
xpath)
return [result_dict]
element_obj = xml_obj.xpath_one(xpath)
if element_obj is not None:
element_text = CXml.get_element_text(element_obj)
return cls.__a_check_value__(result_dict, element_text,
'属性[{0}]'.format(audit_title),
qa_items)
else:
result_dict[cls.Name_Message] = 'XML对象的节点[{0}]不存在, 请检查修正!'.format(
xpath)
return [result_dict]
def test_new_xml(self):
"""
新建一个xml对象, 必须给定根节点名称
"""
root_element_name = "root"
xml = CXml()
xml.new_xml(root_element_name)
assert True
def metadata_bus_2_params(self, metadata_xml: CXml, params: dict):
metadata_list = metadata_xml.xpath('{0}/*'.format(
self.Path_MD_Bus_Root))
for metadata_item in metadata_list:
metadata_item_name = CXml.get_element_name(
metadata_item).lower().strip()
metadata_item_value = CXml.get_element_text(
metadata_item).lower().strip()
params[metadata_item_name] = metadata_item_value
def test_load_xml(self):
"""
通过给定的xml内容, 对xml对象进行初始化
"""
xml_content = '''
<root name="hello world"></root>
'''
xml = CXml()
xml.load_xml(xml_content)
assert True
def test_load_file(self):
"""
通过给定的xml文件名, 对xml对象进行初始化
"""
xml = CXml()
if CFile.file_or_path_exist(self.test_filename):
xml.load_file(self.test_filename)
assert True
else:
assert False
def test_to_xml(self):
"""
通过给定的xml内容, 对xml对象进行初始化
:return:
"""
xml = CXml()
xml_content = '''
<root><element>hello</element></root>
'''
xml.load_xml(xml_content)
xml_string = xml.to_xml()
assert xml_string == '<root><element>hello</element></root>'
def append_data_records_quality(self, record_index, audit_result: dict):
"""
设置数据的每一个记录的质量信息
:param record_index:
:param audit_result:
:return:
"""
temp_node = CXml.node_xpath_one(
self.__node_data_records,
'./{0}[@index="{1}"]'.format(self.Name_Record, record_index))
if temp_node is None:
temp_node = CXml.create_element(self.__node_data_records,
self.Name_Record)
self.__append_quality_info(temp_node, audit_result)
def set_value_from_file(self, file_name: str, file_format: str,
file_encoding: str):
"""
设置value为文件内容
. 根据文件格式, 可以加载文件内容
. 如果文件格式为二进制, 则value存储文件名
:param file_name:
:param file_format:
:param file_encoding:
:return:
"""
if CUtils.equal_ignore_case(file_format, CResource.FileFormat_TXT):
self._value = {
CResource.Name_Text: CFile.file_2_str(file_name),
CResource.Name_Type: CResource.DataValueType_SQL
}
elif CUtils.equal_ignore_case(file_format, CResource.FileFormat_XML):
self._value = {
CResource.Name_Text: CXml.file_2_str(file_name),
CResource.Name_Type: CResource.DataValueType_SQL
}
elif CUtils.equal_ignore_case(file_format, CResource.FileFormat_Json):
self._value = {
CResource.Name_Text: CJson.file_2_str(file_name),
CResource.Name_Type: CResource.DataValueType_SQL
}
else:
self._value = {
CResource.Name_Text: file_name,
CResource.Name_Type: CResource.DataValueType_File
}
def __plugins_classified_by_plugin_node_list__(
cls, file_info: CDMFilePathInfoEx,
plugin_node_list: list) -> CPlugins:
"""
根据外部给定的插件xml节点数组, 顺序进行识别, 返回第一个识别出文件的插件对象
:param file_info:
:param plugin_node_list:
:return:
"""
for plugin_node in plugin_node_list:
plugin_id = CXml.get_element_text(plugin_node)
class_classified_obj = cls.plugins(file_info, plugin_id)
if class_classified_obj is None:
continue
try:
object_confirm, object_name = class_classified_obj.classified()
if object_confirm != cls.Object_Confirm_IUnKnown:
CLogger().debug('{0} is classified as {1}.{2}'.format(
file_info.file_main_name,
class_classified_obj.get_information(),
class_classified_obj.get_id()))
return class_classified_obj
except:
CLogger().debug('插件[{0}]解析出现异常, 请检查!'.format(plugin_id))
continue
else:
return None
def get_information(self) -> dict:
information = super().get_information()
if self.__metadata_xml_obj__ is not None:
information[self.Plugins_Info_Title] = CXml.get_element_text(
self.__metadata_xml_obj__.xpath_one(
self.Path_21AT_MD_Content_ProductName))
information[self.Plugins_Info_Type_Code] = None # '110001'
information[
self.Plugins_Info_Group] = self.DataGroup_Industry_Land_DataSet
information[self.Plugins_Info_Group_Title] = self.data_group_title(
information[self.Plugins_Info_Group])
information[
self.Plugins_Info_Catalog] = self.DataCatalog_Land # 'land'
information[self.Plugins_Info_Catalog_Title] = self.data_catalog_title(
information[self.Plugins_Info_Catalog]) # '国土行业'
information[self.Plugins_Info_MetaDataEngine] = None
information[self.Plugins_Info_BusMetaDataEngine] = self.Engine_Custom
information[
self.Plugins_Info_DetailEngine] = self.DetailEngine_Busdataset
information[self.Plugins_Info_HasChildObj] = self.DB_True
information[self.Plugins_Info_Is_Spatial] = self.DB_False
information[self.Plugins_Info_Is_Dataset] = self.DB_True
information[self.Plugins_Info_Spatial_Qa] = self.DB_False
information[self.Plugins_Info_Time_Qa] = self.DB_True
information[self.Plugins_Info_Visual_Qa] = self.DB_False
return information
def set_metadata_bus(self, metadata_bus_extract_result: int,
metadata_bus_extract_memo: str,
metadata_bus_type: int, metadata_bus_text):
self.__metadata_bus_extract_result__ = metadata_bus_extract_result
self.__metadata_bus_extract_memo__ = metadata_bus_extract_memo
self.__metadata_bus_type__ = metadata_bus_type
if self.__metadata_bus_type__ == self.MetaDataFormat_Json:
self.__metadata_bus_text__ = ''
self.__metadata_bus_xml__ = CXml()
self.__metadata_bus_json__.load_json_text(metadata_bus_text)
elif self.__metadata_bus_type__ == self.MetaDataFormat_XML:
self.__metadata_bus_text__ = ''
self.__metadata_bus_xml__.load_xml(metadata_bus_text)
self.__metadata_bus_json__ = CJson()
else:
self.__metadata_bus_text__ = metadata_bus_text
self.__metadata_bus_xml__ = CXml()
self.__metadata_bus_json__ = CJson()
def set_metadata_bus_file(self, metadata_bus_extract_result: int,
metadata_bus_extract_memo: str,
metadata_type: int, file_name):
self.__metadata_bus_extract_result__ = metadata_bus_extract_result
self.__metadata_bus_extract_memo__ = metadata_bus_extract_memo
self.__metadata_bus_type__ = metadata_type
if self.__metadata_bus_type__ == self.MetaDataFormat_Json:
self.__metadata_bus_text__ = ''
self.__metadata_bus_xml__ = CXml()
self.__metadata_bus_json__.load_file(file_name)
elif self.__metadata_bus_type__ == self.MetaDataFormat_XML:
self.__metadata_bus_text__ = ''
self.__metadata_bus_xml__.load_file(file_name)
self.__metadata_bus_json__ = CJson()
else:
self.__metadata_bus_text__ = CFile.file_2_str(file_name)
self.__metadata_bus_xml__ = CXml()
self.__metadata_bus_json__ = CJson()
def test_set_attr(self):
"""
设置一个节点的属性
:return:
"""
xml_content = '''<root name="hello world"></root>'''
xml = CXml()
xml.load_xml(xml_content)
element = xml.xpath_one('/root')
CXml.set_attr(element, 'name', 'championing')
assert CXml.get_element_xml(element) == '<root name="championing"/>'
def test_set_element_text(self):
"""
设置一个节点的文本
:return:
"""
xml_content = '''<root name="hello world"></root>'''
xml = CXml()
xml.load_xml(xml_content)
element = xml.xpath('/root')[0]
CXml.set_element_text(element, 'hello')
assert CXml.get_element_xml(element) == '<root name="hello world"><![CDATA[hello]]></root>'
def access_check_dict(self) -> dict: # 预留的方法，sync写完后再调
object_name = self._obj_name
dsometadataxml_bus = self._dataset.value_by_name(
0, 'dsometadataxml_bus', '')
xml = CXml()
xml.load_xml(dsometadataxml_bus) # 初始化xml
dsometadataxml_bus_type = '{0}'.format(
xml.xpath_one("/root/@type")) # 查询业务元数据类别
if object_name is not None:
if dsometadataxml_bus_type is not None:
if CUtils.equal_ignore_case(dsometadataxml_bus_type, 'mdb'):
return self.access_check_dict_mdb()
elif CUtils.equal_ignore_case(dsometadataxml_bus_type, 'mat'):
return self.access_mdb_check_dict_mat()
elif CUtils.equal_ignore_case(dsometadataxml_bus_type, 'xls') \
or CUtils.equal_ignore_case(dsometadataxml_bus_type, 'xlsx'):
return self.access_mdb_check_dict_xls()
raise Exception("数据{0}业务元数据类型为'{1}'出现错误，没有可识别的类型".format(
object_name, dsometadataxml_bus_type))
def test_append(self):
"""
将一个子节点加入到指定节点下
:return:
"""
xml_content = '''<root name="hello world"></root>'''
xml = CXml()
xml.load_xml(xml_content)
child_element = etree.Element('train', name='wing')
element = xml.root_element()
CXml.append(element, child_element)
assert CXml.get_element_xml(element) == '<root name="hello world"><train name="wing"/></root>'
def test_creat_element(self):
"""
在一个节点下创建一个新节点
:return:
"""
xml_content = '''
<root name="hello world"><element name="hello"></element></root>
'''
xml = CXml()
xml.load_xml(xml_content)
element = xml.root_element()
CXml.create_element(element, "element1")
assert CXml.get_element_xml(element) == '<root name="hello world"><element name="hello"/><element1/></root>'
def test_clone(self):
"""
根据给定的xml节点, 深度克隆节点的全部内容, 创建一个新的节点
:return:
"""
xml = CXml()
xml_comment = '''<root name="hello world"><element>hello</element></root>'''
xml.load_xml(xml_comment)
element = CXml.clone(xml.root_element())
assert CXml.get_element_xml(element) == xml_comment
def test_get_tree_root(self):
"""
获取树对象的根节点
:return:
"""
xml_content = '''<root name="hello world"><parent><grandson>hello</grandson></parent></root>'''
xml = CXml()
xml.load_xml(xml_content)
tree = CXml.get_tree_root(xml.tree())
assert CXml.get_element_name(tree) == 'root'
def get_sync_dict_list(self, insert_or_updata) -> list:
"""
insert_or_updata 中 self.DB_True为insert，DB_False为updata
本方法的写法为强规则，调用add_value_to_sync_dict_list配置
第一个参数为list，第二个参数为字段名，第三个参数为字段值，第四个参数为特殊配置
"""
sync_dict = self.get_sync_predefined_dict_list(insert_or_updata)
object_table_id = self._obj_id
object_table_data = self._dataset
dsometadataxml = object_table_data.value_by_name(
0, 'dsometadataxml_bus', '')
dsometadataxml_xml = CXml()
dsometadataxml_xml.load_xml(dsometadataxml) # 加载查询出来的xml
self.add_value_to_sync_dict_list(sync_dict, 'aprpwid', object_table_id)
self.add_value_to_sync_dict_list(
sync_dict, 'dsname',
dsometadataxml_xml.get_element_text_by_xpath_one(
'/root/DSName')) # 配置字段值
self.add_value_to_sync_dict_list(
sync_dict, 'producttypechn',
dsometadataxml_xml.get_element_text_by_xpath_one(
'/root/ProductType'))
self.add_value_to_sync_dict_list(
sync_dict, 'dsometadatajson',
object_table_data.value_by_name(0, 'dsometadataxml_bus', ''))
return sync_dict
def get_sync_dict_list(self, insert_or_updata) -> list:
"""
insert_or_updata 中 self.DB_True为insert，DB_False为updata
本方法的写法为强规则，调用add_value_to_sync_dict_list配置
第一个参数为list，第二个参数为字段名，第三个参数为字段值，第四个参数为特殊配置
"""
sync_dict = self.get_sync_predefined_dict_list(insert_or_updata)
object_table_id = self._obj_id
object_table_data = self._dataset
# 业务元数据
dsometadataxml_bus = object_table_data.value_by_name(
0, 'dsometadataxml_bus', '')
xml = CXml()
xml.load_xml(dsometadataxml_bus)
# 下列字段名均待修改
self.add_value_to_sync_dict_list(sync_dict, 'aprmwid', object_table_id)
self.add_value_to_sync_dict_list(
sync_dict, 'mosaiclinefilename',
xml.get_element_text_by_xpath_one("//item[@name='ProductName']"))
self.add_value_to_sync_dict_list(
sync_dict, 'sensors',
xml.get_element_text_by_xpath_one("//item[@name='SatelliteID']"))
self.add_value_to_sync_dict_list(
sync_dict, 'dsometadatajson',
object_table_data.value_by_name(0, 'dsometadataxml_bus', ''))
self.add_value_to_sync_dict_list(
sync_dict, 'resolution',
xml.get_element_text_by_xpath_one("//item[@name='Resolution']"))
# self.add_value_to_sync_dict_list(sync_dict, 'regionname', xml.get_element_text_by_xpath_one(
# "//item[@name='GeographicName']"))
dso_prj_project = object_table_data.value_by_name(
0, 'dso_prj_project', '')
if CUtils.equal_ignore_case(dso_prj_project, 'tj2000'):
dso_prj_project = '2000天津城市坐标系'
if CUtils.equal_ignore_case(dso_prj_project, 'tj1990'):
dso_prj_project = '1990天津任意直角坐标系'
if CUtils.equal_ignore_case(dso_prj_project, 'cgcs2000'):
dso_prj_project = '2000国家标准坐标系'
else:
dataoptions = '其他国家标准坐标系'
self.add_value_to_sync_dict_list(sync_dict, 'dataoptions',
dso_prj_project)
# 备注
self.add_value_to_sync_dict_list(
sync_dict, 'remark',
xml.get_element_text_by_xpath_one("//item[@name='Description']"))
return sync_dict
def mdb_to_xml(self, file_metadata_name_with_path: str):
"""
TODO 王学谦 mdb文件转xml,在函数外提前定义xml对象并获取父节点传入，函数会将通过父节点构造xml对象 by王学谦
:param file_metadata_name_with_path:查询的mdb文件全名，带路径
:return xml_obj:将文件内容存储好的项目对象
"""
conn = None # 预定义连接与游标，方便释放
cur = None
try:
conn = self.get_mdb_connect(file_metadata_name_with_path)
cur = conn.cursor() # 游标
sql = "SELECT * FROM " + self.object_name
cur.execute(sql)
table_data = cur.fetchall()
# total_rows = len(alldata) # 行
# total_cols = len(alldata[0]) # 列
xml_obj = CXml() # 建立xml对象
node_root = xml_obj.new_xml('root')
xml_obj.set_attr(node_root, self.Name_Type,
self.transformer_type) # 设置root节点与属性
for field_index, row_obj in enumerate(cur.description):
row_name = row_obj[0] # 字段名称
row_type = row_obj[1] # 字段类型
if row_type is bytearray: # 跳过长二进制数组
continue
node_item = xml_obj.create_element(node_root, 'item')
xml_obj.set_attr(node_item, self.Name_Name,
CUtils.any_2_str(row_name).lower())
xml_obj.set_element_text(
node_item, table_data[0][field_index]) # 设置item节点与属性与内容
except Exception as error:
raise Exception(error.__str__())
finally:
if cur is not None:
cur.close()
if conn is not None:
conn.close()
return xml_obj
