def parse_ding(root, extract_deleted, extract_source):
try:
root = judge_node(root)
if root is None:
raise IOError('e')
d = Ding(root, extract_deleted, extract_source)
if d.need_parse:
d.search_account()
d.parse()
d.im.db_insert_table_version(model_im.VERSION_KEY_APP, APP_V)
d.im.db_insert_table_version(model_im.VERSION_KEY_DB,
model_im.VERSION_VALUE_DB)
d.im.db_commit()
models = model_im.GenerateModel(d.cache_res,
root.MountPoint).get_models()
mlm = ModelListMerger()
pr = ParserResults()
pr.Categories = DescripCategories.QQ
pr.Models.AddRange(list(mlm.GetUnique(models)))
nameValues.SafeAddValue('1030162', d.cache_res)
pr.Build('钉钉')
except Exception as e:
traceback.print_exc()
pr = ParserResults()
return pr
def parse(self):
"""解析的主函数"""
if self.has_data is False:
return
for account in self._generate_account_table():
self.cloud_p2p_col, self.file_list_col = self.__fetch_cols(account)
self.c_recover_helper, self.f_recover_helper = self.__fetch_recover_helper(account)
self._generate_friend_table()
self._generate_message_table()
self._generate_chatroom_table()
self._generate_chatroom_member_table()
self._generate_file_list_table()
self._generate_download_task_table()
self._generate_share_file_table()
self.decode_recover_chatroom()
self.decode_recover_chatroom_member()
self.decode_recover_groups_messages()
self.decode_recover_people_messages()
self.decode_recover_file_list()
self.decode_recover_download_task()
self.decode_recover_share_file()
generate = model_nd.NDModel(self.cache_db)
nd_results = generate.generate_models()
generate = model_im.GenerateModel(self.cache_db + ".IM")
im_results = generate.get_models()
return nd_results + im_results
def parse(self):
if not os.path.exists(self.root.PathWithMountPoint +
"/databases/msgstore.db"):
return
db_path = md5(self.cache, self.root.AbsolutePath)
if self.whatsapp.need_parse(db_path, VERSION_APP_VALUE):
self.whatsapp.db_create(db_path)
self.get_account()
self.get_friends()
self.get_groups()
self.get_group_member()
self.get_friend_messages()
self.get_group_messages()
self.get_feeds()
self.whatsapp.db_close()
if not canceller.IsCancellationRequested:
self.whatsapp.db_insert_table_version(
model_im.VERSION_KEY_DB, model_im.VERSION_VALUE_DB)
self.whatsapp.db_insert_table_version(model_im.VERSION_KEY_APP,
VERSION_APP_VALUE)
tmp_dir = ds.OpenCachePath("tmp")
PA_runtime.save_cache_path(bcp_im.CONTACT_ACCOUNT_TYPE_IM_WHATSAPP,
db_path, tmp_dir)
generate = model_im.GenerateModel(db_path)
results = generate.get_models()
return results
def analyse_twitter(root, extract_deleted, extract_source):
node = judge_node(root)
try:
if node is None:
raise IOError('E')
t = TIphone(node, extract_deleted, extract_source)
if t.need_parse:
t.parse_account()
t.parse_recovery()
t.im.db_insert_table_version(model_im.VERSION_KEY_DB,
model_im.VERSION_VALUE_DB)
t.im.db_insert_table_version(model_im.VERSION_KEY_APP,
VERSION_APP_VALUE)
t.im.db_commit()
t.im.db_close()
nameValues.SafeAddValue('1330005', t.cache + "/{}".format(t.hash))
models = model_im.GenerateModel(t.cache +
"/{}".format(t.hash)).get_models()
mlm = ModelListMerger()
pr = ParserResults()
pr.Categories = DescripCategories.QQ
pr.Models.AddRange(list(mlm.GetUnique(models)))
pr.Build('Twitter')
except:
traceback.print_exc()
pr = ParserResults()
return pr
def parse_mm(root, extract_source, extract_deleted):
try:
node = judge_node(root)
if node is None:
raise IOError('E')
m = momo(node, extract_deleted, extract_source)
if m.need_parse:
m.search()
for id in m.accounts:
m.parse(id)
m.im.db_insert_table_version(model_im.VERSION_KEY_DB, model_im.VERSION_VALUE_DB)
m.im.db_insert_table_version(model_im.VERSION_KEY_APP, MM_PARSER_VERSION)
m.im.db_commit()
m.im.db_close()
pr = ParserResults()
models = model_im.GenerateModel(m.cache_db).get_models()
mlm = ModelListMerger()
pr = ParserResults()
pr.Categories = DescripCategories.QQ
pr.Models.AddRange(list(mlm.GetUnique(models)))
pr.Build('陌陌')
except:
traceback.print_exc()
pr = ParserResults()
return pr
def _generate_nd_models(self):
"""网盘类应用 => 从中间数据库返回models给C#那边"""
generate = model_nd.NDModel(self.cache_db)
nd_results = generate.generate_models()
generate = model_im.GenerateModel(self.cache_db + ".IM")
im_results = generate.get_models()
return nd_results + im_results
def get_models(self):
models = []
models.extend(self.__get_product_models())
models.extend(self.__get_log_models())
models.extend(self.__get_shop_models())
models.extend(self.__get_trading_models())
models.extend(model_im.GenerateModel(self.im_cache).get_models())
self.ccmd.Dispose()
self.ebc.Close() #====>释放对数据库的占用
return models
def parse(self):
if DEBUG or self.csm.need_parse(self.cache_db, self.app_version):
self.csm.db_create(self.cache_db)
self._main()
if not canceller.IsCancellationRequested:
self.csm.db_insert_table_version(model_ticketing.VERSION_KEY_DB, model_ticketing.VERSION_VALUE_DB)
self.csm.db_insert_table_version(model_ticketing.VERSION_KEY_APP, self.app_version)
self.csm.db_commit()
self.csm.db_close()
models = model_im.GenerateModel(self.cache_db).get_models() + model_map.Genetate(self.cache_db).get_models()
return models
def parse(self):
db_path = model_map.md5(self.cache, self.root.AbsolutePath)
self.blued.db_create(db_path)
self.main()
self.blued.db_close()
im_models = model_im.GenerateModel(db_path).get_models()
# map_models = model_map.Genetate(db_path).get_models()
results = []
results.extend(im_models)
# results.extend(map_models)
return results
def parse(self):
"""程序入口"""
if DEBUG or self.model_nd_col.need_parse:
self._main()
self._db_update_finished_info()
generate = model_nd.NDModel(self.cache_db)
nd_results = generate.generate_models()
generate = model_im.GenerateModel(self.cache_db + ".IM")
im_results = generate.get_models()
return nd_results + im_results
def parse(self):
db_path = model_map.md5(self.cache, self.root.AbsolutePath)
self.qunar_db.db_create(db_path)
self.main()
self.qunar_db.db_close()
tmp_dir = ds.OpenCachePath("tmp")
PA_runtime.save_cache_path("05005", db_path, tmp_dir)
im_models = model_im.GenerateModel(db_path).get_models()
map_models = model_map.Genetate(db_path).get_models()
results = []
results.extend(im_models)
results.extend(map_models)
return results
def parse_xy(root, extract_deleted, extract_source):
try:
node = judge_node(root)
if node is None:
raise IOError('E')
x = xianyu(node, extract_deleted, extract_deleted)
x.search()
x.parse()
models = model_im.GenerateModel(x.cache + '/{}'.format(x.hash)).get_models()
mlm = ModelListMerger()
pr = ParserResults()
pr.Categories = DescripCategories.QQ
pr.Models.AddRange(list(mlm.GetUnique(models)))
pr.Build('闲鱼')
except:
return ParserResults()
return pr
def parse(self):
"""解析的主函数"""
# 获取缓存数据
self._get_account_table()
self._get_friend_table()
self._get_message_table()
self._get_chatroom_table()
self._get_chatroom_member_table()
self.decode_recover_friend()
self.decode_recover_message()
self.decode_recover_chatroom()
generate = model_im.GenerateModel(self.cache_db)
results = generate.get_models()
PA_runtime.save_cache_path(bcp_im.CONTACT_ACCOUNT_TYPE_IM_ICQ, self.cache_db, ds.OpenCachePath("tmp"))
return results
def parse(self):
if DEBUG or self.im.need_parse(self.cache_db, VERSION_APP_VALUE):
self.im.db_create(self.cache_db)
self.parse_main()
if not canceller.IsCancellationRequested:
self.im.db_insert_table_version(model_im.VERSION_KEY_DB,
model_im.VERSION_VALUE_DB)
self.im.db_insert_table_version(model_im.VERSION_KEY_APP,
VERSION_APP_VALUE)
self.im.db_commit()
self.im.db_close()
tmp_dir = ds.OpenCachePath('tmp')
save_cache_path(bcp_im.CONTACT_ACCOUNT_TYPE_IM_LINE, self.cache_db,
tmp_dir)
models = model_im.GenerateModel(self.cache_db).get_models()
return models
def parse(self):
db_path = model_map.md5(self.cache, self.root.AbsolutePath)
self.bulletMessage.db_create(db_path)
self.get_user_friends()
self.get_messages()
self.get_feeds()
self.bulletMessage.db_close()
tmp_dir = ds.OpenCachePath("tmp")
# PA_runtime.save_cache_path("05005", db_path, tmp_dir)
im_models = model_im.GenerateModel(db_path).get_models()
# map_models = model_map.Genetate(db_path).get_models()
results = []
results.extend(im_models)
# results.extend(map_models)
return results
def parse_potato(root, extract_deleted, extract_source):
node = judge_node(root)
container_node = node.Parent.Parent.Parent
container_node = container_node.GetByPath('Data/Application')
try:
if container_node is None:
print('lost container node')
raise IOError('E')
nodes = container_node.Search(
'Library/Preferences/org.potatochat.PotatoEnterprise.plist$')
if len(nodes) > 1:
print('multi target hitted,parser exits')
raise IOError('E')
container_node = nodes[0].Parent.Parent.Parent
if node is None:
print('''can't find group node''')
raise IOError('E')
res = []
try:
t = apple_telegram.Telegram(node, container_node, False, False, 1)
if t.need_parse:
result = t.parse()
t.im.db_insert_table_version(model_im.VERSION_KEY_DB,
model_im.VERSION_VALUE_DB)
t.im.db_insert_table_version(model_im.VERSION_KEY_APP, 1)
t.im.db_commit()
t.im.db_close()
models = model_im.GenerateModel(
t.cache + '/{}.C37R'.format(t.hash_code)).get_models()
nameValues.SafeAddValue('1030063',
t.cache + '/{}.C37R'.format(t.hash_code))
res.extend(models)
except:
traceback.print_exc()
if canceller.IsCancellationRequested:
raise IOError('E')
mlm = ModelListMerger()
pr = ParserResults()
pr.Categories = DescripCategories.Potato
pr.Models.AddRange(list(mlm.GetUnique(res)))
pr.Build('Potato')
except Exception as e:
print(e)
pr = ParserResults()
return pr
def parse(self):
if self.need_parse(self.cachedb, VERSION_APP_VALUE):
if os.path.exists(self.cachepath):
shutil.rmtree(self.cachepath)
os.mkdir(self.cachepath)
self.db_create(self.cachedb)
#self._copytocache(self.node.Parent.PathWithMountPoint)
self.analyze_data()
self.db_insert_table_version(model_im.VERSION_KEY_DB,
model_im.VERSION_VALUE_DB)
self.db_insert_table_version(model_im.VERSION_KEY_APP,
VERSION_APP_VALUE)
self.db_commit()
self.db_close()
models = []
models_im = model_im.GenerateModel(self.cachedb).get_models()
models.extend(models_im)
return models
def parse(self):
try:
self.db_create(self.db_cache)
cache_dir = self.dir + r'\Documents\RequestCache'
db_dir = self.dir + r'\Library\Application Support\聚星众赢\AntHouseModel.sqlite'
self.parse_db(db_dir)
#设置一个未知好友作为不知道消息发送对象时的好友
friend = model_im.Friend()
friend.account_id = self.uid
friend.friend_id = 2
friend.nickname = '未知好友'
friend.fullname = '未知好友'
self.db_insert_table_friend(friend)
self.parse_cache(cache_dir)
models = model_im.GenerateModel(self.db_cache).get_models()
return models
except:
traceback.print_exc()
def parse(self):
"""解析的主函数"""
for _ in self.__change_db_config():
# 因为查询的表的名字里面有版本号，所以做一些处理，挂载一个表名字的状态
self.table_name = self.__query_table_names()
self._generate_account_table()
self._generate_friend_table()
self._generate_message_table()
chatroom_members = self._generate_chatroom_table()
self._generate_chatroom_member_table(chatroom_members)
self.decode_recover_friend()
self.decode_recover_message()
self.decode_recover_chatroom()
generate = model_im.GenerateModel(self.cache_db)
results = generate.get_models()
PA_runtime.save_cache_path(bcp_im.CONTACT_ACCOUNT_TYPE_IM_SKYPE, self.cache_db, ds.OpenCachePath("tmp"))
return results
def parse(self):
if self.need_parse(self.cachedb, VERSION_APP_VALUE):
if os.path.exists(self.cachepath):
shutil.rmtree(self.cachepath)
os.mkdir(self.cachepath)
self.db_create(self.cachedb)
self.analyze_data()
self.db_insert_table_version(model_im.VERSION_KEY_DB,
model_im.VERSION_VALUE_DB)
self.db_insert_table_version(model_im.VERSION_KEY_APP,
VERSION_APP_VALUE)
self.db_commit()
self.db_close()
models = []
models_im = model_im.GenerateModel(self.cachedb).get_models()
models.extend(models_im)
print(len(models))
models_record = model_callrecord.Generate(self.cachedb).get_models()
models.extend(models_record)
return models
def parse(self):
"""解析的主函数"""
for _ in self.__change_account_config():
account = self._get_account()
if account:
self._get_friends()
self._get_messages()
self._get_chatroom()
self._get_chatroom_member()
self.decode_recover_chatroom()
self.decode_recover_chatroom_member()
self.decode_recover_friends()
self.decode_recover_messages()
try:
self._add_unknown_resource()
except Exception as e:
print("error happen", e)
generate = model_im.GenerateModel(self.cache_db)
results = generate.get_models()
return results
def parse_telegram(root, extract_deleted, extract_source):
group_container_nodes = ds.GroupContainers.ToArray()
r_nodes = try_to_get_telegram_group(group_container_nodes)
root = root.Parent.Parent.Parent
try:
if len(r_nodes) is 0:
print('''can't find group node''')
raise IOError('E')
res = []
for r in r_nodes:
try:
t = Telegram(r, root, False, False)
if t.need_parse:
result = t.parse()
if not result:
continue
t.im.db_insert_table_version(model_im.VERSION_KEY_DB, model_im.VERSION_VALUE_DB)
t.im.db_insert_table_version(model_im.VERSION_KEY_APP, 1)
t.im.db_commit()
t.im.db_close()
models = model_im.GenerateModel(t.cache + '/{}.C37R'.format(t.hash_code)).get_models()
nameValues.SafeAddValue('1030063', t.cache + '/{}.C37R'.format(t.hash_code))
res.extend(models)
except:
traceback.print_exc()
if canceller.IsCancellationRequested:
raise IOError('E')
else:
continue
mlm = ModelListMerger()
pr = ParserResults()
pr.Categories = DescripCategories.Telegram
pr.Models.AddRange(list(mlm.GetUnique(res)))
pr.Build('Telegram')
except Exception as e:
print(e)
pr = ParserResults()
return pr
def parse_android_twr(node, es, ed):
t = Twitter(node, es, ed)
try:
if t.need_parse:
t.search()
for aid in t.account_list:
t.parse(aid)
t.im.db_insert_table_version(model_im.VERSION_KEY_DB,
model_im.VERSION_VALUE_DB)
t.im.db_insert_table_version(model_im.VERSION_KEY_APP,
AND_TWR_VERSION)
t.im.db_commit()
t.im.db_close()
models = model_im.GenerateModel(t.cache_db).get_models()
mlm = ModelListMerger()
pr = ParserResults()
pr.Categories = DescripCategories.Twitter
pr.Models.AddRange(list(mlm.GetUnique(models)))
pr.Build("Twitter")
except:
pr = ParserResults()
return pr
def parse(self):
"""解析的主函数"""
if not all(
(self.account_info_path, self.user_info_path, self.icq_data_path)):
return
# 获取缓存数据
self._get_account_table()
self._get_friend_table()
self._get_message_table()
self._get_chatroom_table()
self._get_search_table()
self.decode_recover_friend()
self.decode_recover_message()
self.decode_recover_search()
self.decode_recover_chatroom()
generate = model_im.GenerateModel(self.cache_db)
results = generate.get_models()
PA_runtime.save_cache_path(bcp_im.CONTACT_ACCOUNT_TYPE_IM_ICQ,
self.cache_db, ds.OpenCachePath("tmp"))
return results
def parse(self):
db_path = md5(self.cache, self.root.AbsolutePath)
if self.facebook_db.need_parse(db_path, VERSION_APP_VALUE):
self.facebook_db.db_create(db_path)
self.get_account_id()
self.get_friends()
self.get_friends_chat()
self.get_groups_chat()
self.get_recover_friends_chat()
self.get_recover_groups_chat()
self.facebook_db.db_close()
if not canceller.IsCancellationRequested:
self.facebook_db.db_insert_table_version(
model_im.VERSION_KEY_DB, model_im.VERSION_VALUE_DB)
self.facebook_db.db_insert_table_version(
model_im.VERSION_KEY_APP, VERSION_APP_VALUE)
generate = model_im.GenerateModel(db_path)
results = generate.get_models()
tmp_dir = ds.OpenCachePath("tmp")
PA_runtime.save_cache_path(bcp_im.CONTACT_ACCOUNT_TYPE_IM_FACEBOOK,
db_path, tmp_dir)
return results
def other_parse(self):
db_path = model_map.md5(self.cache, self.root.AbsolutePath)
self.blued.db_create(db_path)
self.get_account(self.root)
node_lists = self.root.Parent.Children
if len(node_lists) == 0:
return
for node in node_lists:
if node.Name.endswith("DB.sqlite"):
account_id = node.Name.replace("DB.sqlite", "")
self.get_groups_friends(node, account_id)
self.get_messages(node, account_id)
self.blued.db_close()
tmp_dir = ds.OpenCachePath("tmp")
PA_runtime.save_cache_path("05005", db_path, tmp_dir)
im_models = model_im.GenerateModel(db_path).get_models()
# map_models = model_map.Genetate(db_path).get_models()
results = []
if results:
results.extend(im_models)
# results.extend(map_models)
return results
def parse_miliao(root, extract_deleted, extract_source):
try:
ml = MiLiao(root, extract_deleted, extract_source)
if ml.need_parse:
ml.search_account()
for aid in ml.account:
ml.analyse_account(aid)
ml.im.db_insert_table_version(model_im.VERSION_KEY_DB,
model_im.VERSION_VALUE_DB)
ml.im.db_insert_table_version(model_im.VERSION_KEY_APP,
VERSION_APP_VALUE)
ml.im.db_commit()
ml.im.db_close()
models = model_im.GenerateModel(ml.cache +
'/{}'.format(ml.hash)).get_models()
mlm = ModelListMerger()
pr = ParserResults()
pr.Categories = DescripCategories.MiLiao
pr.Models.AddRange(list(mlm.GetUnique(models)))
pr.Build('米聊')
except Exception as e:
traceback.print_exc()
pr = ParserResults()
return pr
def parse(self):
db_path = self.md5(self.cache, self.root.AbsolutePath)
self.ctrip.db_create(db_path)
self.get_account()
self.get_groups_member()
self.get_groups()
self.get_messages()
self.get_order_ticket_method_two()
self.get_order_data()
self.get_order_ticket()
self.get_pageview_cache()
self.ctrip.db_close()
tmp_dir = ds.OpenCachePath("tmp")
PA_runtime.save_cache_path(bcp_gis.NETWORK_APP_TICKET_CTRIP, db_path,
tmp_dir)
models = []
im_results = model_im.GenerateModel(db_path).get_models()
ticket_results = model_map.Genetate(db_path).get_models()
models.extend(im_results)
models.extend(ticket_results)
return models
def get_models_from_cache_db(self):
models = model_im.GenerateModel(self.cache_db).get_models()
return models
def _generate_im_models(self):
generate = model_im.GenerateModel(self.cache_db)
results = generate.get_models()
return results
