def _get_chatroom(self):
conn = self.__get_con()
conn.Open()
cmd = System.Data.SQLite.SQLiteCommand(conn)
cmd.CommandText = """select uid,
name,
data
from chats"""
reader = cmd.ExecuteReader()
while reader.Read():
try:
chat_room = model_im.Chatroom()
chat_room.account_id = self.account
chat_room.chatroom_id = GetInt64(reader, 0)
chat_room.name = GetString(reader, 1)
chat_room.source = self.root.GetByPath(
self.account_db_path).PathWithMountPoint
# 没有找到解析chats表data的decoder类
self.model_col.db_insert_table_chatroom(chat_room)
except Exception as e:
print(e)
cmd.Dispose()
reader.Close()
conn.Close()
self.model_col.db_commit()
def parse_relation_recovery(self, db_node, account_id):
if db_node is None:
return
db = SQLiteParser.Database.FromNode(db_node)
ts = SQLiteParser.TableSignature('user')
sb = SQLiteParser.Tools.AddSignatureToTable(ts, "MOMOID", SQLiteParser.FieldType.Text, SQLiteParser.FieldConstraints.NotNull)
for rec in db.ReadTableDeletedRecords(ts, False):
friend = model_im.Friend()
friend.friend_id = str(unity_c37r.try_get_rec_value(rec, 'MOMOID', ''))
friend.nickname = str(unity_c37r.try_get_rec_value(rec, 'NAME', ""))
friend.signature = str(unity_c37r.try_get_rec_value(rec, 'SIGNATURE', ""))
friend.telephone = str(unity_c37r.try_get_rec_value(rec, 'PHONENUMBER', ''))
friend.photo = str(unity_c37r.try_get_rec_value(rec, 'PHOTOS', ''))
friend.account_id = account_id
friend.type = model_im.FRIEND_TYPE_FRIEND
friend.deleted = 1
self.im.db_insert_table_friend(friend)
ts = SQLiteParser.TableSignature('group')
SQLiteParser.Tools.AddSignatureToTable(ts, "GID", SQLiteParser.FieldType.Text, SQLiteParser.FieldConstraints.NotNull)
for rec in db.ReadTableDeletedRecords(ts, False):
cm = model_im.Chatroom()
cm.account_id = account_id
cm.chatroom_id = str(unity_c37r.try_get_rec_value(rec, 'GID', ""))
cm.name = str(unity_c37r.try_get_rec_value(rec, 'NAME', ''))
cm.owner_id = str(unity_c37r.try_get_rec_value(rec, 'NAME', ""))
cm.description = str(unity_c37r.try_get_rec_value(rec, 'SIGN', ''))
cm.photo = str(unity_c37r.try_get_rec_value(rec, 'PHOTOS', ''))
cm.deleted = 1
self.im.db_insert_table_chatroom(cm)
self.im.db_commit()
def decode_recover_chatroom(self):
node = self.root.GetByPath(self.account_db_path)
if node is None:
return
db = SQLiteParser.Database.FromNode(node, canceller)
if db is None:
return
table = 'chats'
ts = SQLiteParser.TableSignature(table)
for rec in db.ReadTableDeletedRecords(ts, False):
if canceller.IsCancellationRequested:
return
try:
chat_room = model_im.Chatroom()
chat_room.account_id = self.account
chat_room.source = self.root.GetByPath(
self.account_db_path).PathWithMountPoint
chat_room.chatroom_id = rec['uid'].Value
chat_room.name = rec['name'].Value
chat_room.deleted = 1
# 没有找到解析chats表data的decoder类
self.model_col.db_insert_table_chatroom(chat_room)
except Exception as e:
print("error happen", e)
self.model_col.db_commit()
def decode_recover_chatroom(self):
if not self.c_recover_helper.is_valid():
return
ts = self.c_recover_helper.fetch_table("groups", {
"group_id": "Int",
"name": "Text",
"ctime": "Int",
"create_uk": "Int",
"people_limit": "Int",
})
for rec in self.c_recover_helper.read_deleted_record(ts):
if canceller.IsCancellationRequested:
return
try:
chatroom = model_im.Chatroom()
chatroom.deleted = 1
chatroom.source = self.c_recover_helper.db_path
chatroom.account_id = self.using_account.account_id
chatroom.chatroom_id = rec['group_id'].Value
chatroom.name = rec['name'].Value
chatroom.creator_id = rec['create_uk'].Value
chatroom.create_time = rec['ctime'].Value
chatroom.max_member_count = rec['people_limit'].Value
self.model_im_col.db_insert_table_chatroom(chatroom)
except Exception as e:
pass
self.model_im_col.db_commit()
def decode_recover_chatroom(self):
table_name = self.table_name["conversations"]
if not self.recovering_helper.is_valid():
return
ts = self.recovering_helper.fetch_table(table_name, {
"nsp_data": "Text",
})
for rec in self.recovering_helper.read_deleted_record(ts):
if canceller.IsCancellationRequested:
return
try:
chatroom_info = json.loads(rec["nsp_data"].Value)
chatroom = model_im.Chatroom()
chatroom.deleted = 1
chatroom.source = self.checking_col.db_path
chatroom.account_id = self.using_account.account_id
chatroom.chatroom_id = chatroom_info["conv"]["id"].split(":", 1)[1]
if (not chatroom.chatroom_id.endswith("@thread.skype")) and (
not chatroom.chatroom_id.endswith("highlights.skype")):
continue
if chatroom_info["conv"].get("_convProps", None):
chatroom.create_time = self.__convert_timestamp(
chatroom_info["conv"]["_convProps"].get("created", None))
if chatroom_info["conv"].get("_threadProps", None):
chatroom.member_count = int(chatroom_info["conv"]["_threadProps"].get("membercount", 0))
chatroom.name = chatroom_info["conv"]["_threadProps"].get("topic", None)
if chatroom_info["conv"]["_threadProps"].get("creator", None):
chatroom.creator_id = chatroom_info["conv"]["_threadProps"].get("creator", "").split(":", 1)[1]
self.model_im_col.db_insert_table_chatroom(chatroom)
except Exception as e:
pass
self.model_im_col.db_commit()
def parse_chatroom(self, dbPath):
'''解析群组数据'''
db = SQLite.SQLiteConnection(
'Data Source = {}; ReadOnly = True'.format(dbPath))
db.Open()
db_cmd = SQLite.SQLiteCommand(db)
try:
if db is None:
return
db_cmd.CommandText = '''select a.discussionid, a.title, a.memberver, count(b.memberid) as member_count, a.deleted from bb_discussion_info as a
left join bb_discussion_member_info as b on a.discussionid = b.discussionid group by a.discussionid'''
sr = db_cmd.ExecuteReader()
while (sr.Read()):
try:
chatroom = model_im.Chatroom()
if canceller.IsCancellationRequested:
break
chatroom.account_id = self.account_id
chatroom.chatroom_id = self._db_reader_get_int_value(sr, 0)
chatroom.create_time = self._db_reader_get_int_value(sr, 2)
chatroom.deleted = self._db_reader_get_int_value(sr, 4)
chatroom.member_count = self._db_reader_get_int_value(
sr, 3)
chatroom.name = self._db_reader_get_string_value(sr, 1)
chatroom.source = self.node.AbsolutePath
self.db_insert_table_chatroom(chatroom)
except:
traceback.print_exc()
sr.Close()
self.db_commit()
db_cmd.Dispose()
db.Close()
except Exception as e:
print(e)
def parse_chatroom(self, dbPath):
'''解析群组数据'''
db = SQLite.SQLiteConnection(
'Data Source = {}; ReadOnly = True'.format(dbPath))
db.Open()
db_cmd = SQLite.SQLiteCommand(db)
try:
if db is None:
return
db_cmd.CommandText = '''select groupname, myuid, groupicon, groupId, deleted from DBTableNmae_GroupMsg'''
sr = db_cmd.ExecuteReader()
while (sr.Read()):
try:
chatroom = model_im.Chatroom()
if canceller.IsCancellationRequested:
break
chatroom.account_id = self.account_id
chatroom.chatroom_id = self._db_reader_get_int_value(sr, 3)
chatroom.photo = self._db_reader_get_string_value(sr, 2)
chatroom.deleted = self._db_reader_get_int_value(sr, 4)
chatroom.name = self._db_reader_get_string_value(sr, 0)
chatroom.source = self.node.AbsolutePath
self.db_insert_table_chatroom(chatroom)
except:
traceback.print_exc()
sr.Close()
self.db_commit()
db_cmd.Dispose()
db.Close()
except Exception as e:
print(e)
def decode_recover_chatroom(self):
if not self.cl_recover_helper.is_valid():
return
ts = self.cl_recover_helper.fetch_table("contact", {
"_rowid_": "Int",
"pid": "Text",
"isTemporary": "Int",
"displayName": "Text",
"groupId": "Int",
"userType": "Int"
})
for rec in self.cl_recover_helper.read_deleted_record(ts):
if canceller.IsCancellationRequested:
return
try:
if rec["groupId"].Value == 0 or rec["userType"].Value != 5:
continue
chatroom = model_im.Chatroom()
chatroom.source = self.cl_db_path
chatroom.account_id, _, chatroom.chatroom_id = rec["pid"].Value.split("|")
chatroom.name = rec["displayName"].Value
chatroom.deleted = 1
self.model_im_col.db_insert_table_chatroom(chatroom)
except Exception as e:
print("debug error", e)
self.model_im_col.db_commit()
def _get_chatroom_table(self):
with self.cl_db_col as db_col:
sql = """SELECT contact.pid,
contact.userType,
contact.isTemporary,
contact.displayName,
chat_info.chatDescription,
chat_info.chatParticipantsCount,
chat_info.rules,
chat_info.youRole
FROM contact left join chat_info on contact._rowid_ = chat_info.contactID
where chat_info.youRole != 0;"""
db_col.execute_sql(sql)
while db_col.has_rest():
try:
chatroom = model_im.Chatroom()
chatroom.source = self.cl_db_path
chatroom.account_id, _, chatroom.chatroom_id = db_col.get_string(0).split("|")
chatroom.name = db_col.get_string(3)
chatroom.description = db_col.get_string(4)
chatroom.member_count = db_col.get_int64(5)
chatroom.notice = db_col.get_string(6)
chatroom.type = model_im.CHATROOM_TYPE_NORMAL if db_col.get_int64(
2) == 0 else model_im.CHATROOM_TYPE_TEMP
self.model_im_col.db_insert_table_chatroom(chatroom)
except Exception as e:
print("debug error", e)
self.model_im_col.db_commit()
def parse_chatroom(self):
'''解析群组数据'''
try:
db = SQLiteParser.Database.FromNode(self.node, canceller)
if db is None:
return
ts = SQLiteParser.TableSignature('tb_group_history_order')
for rec in db.ReadTableRecords(ts, self.extractDeleted, True):
try:
if rec.IsDeleted == 1:
continue
chatroom = model_im.Chatroom()
if canceller.IsCancellationRequested:
break
chatroom.account_id = self.account_id
chatroom.chatroom_id = self._db_record_get_int_value(
rec, 'groupid')
chatroom.photo = self._db_record_get_string_value(
rec, 'groupicon')
chatroom.member_count = self.member_count[
chatroom.chatroom_id]
chatroom.deleted = rec.IsDeleted
chatroom.name = self._db_record_get_string_value(
rec, 'groupname')
chatroom.source = self.node.AbsolutePath
self.db_insert_table_chatroom(chatroom)
except:
pass
self.db_commit()
except Exception as e:
print(e)
def decode_recover_chatroom(self):
if not self.recover_helper.is_valid():
return
ts = self.recover_helper.fetch_table(
"ICQ_CONTACT_DATA", {
"PROFILE_ID": "Text",
"CONTACT_ID": "Text",
"NAME": "Text",
"CHAT_INFO_ID": "Int",
})
for rec in self.recover_helper.read_deleted_record(ts):
if canceller.IsCancellationRequested:
return
try:
name = rec["CONTACT_ID"].Value
if "@" in name:
chatroom = model_im.Chatroom()
chatroom.account_id = rec["PROFILE_ID"].Value
chatroom.name = name
chatroom.chatroom_id = rec["CONTACT_ID"].Value
chatroom.source = self.icq_data_path
chatroom.deleted = 1
chat_info_id = rec["CHAT_INFO_ID"].Value
if chat_info_id:
_, chatroom.description, chatroom.member_count = self.__query_chatroom_info(
chat_info_id)
self.model_im_col.db_insert_table_chatroom(chatroom)
except Exception as e:
print("error happen", e)
self.model_im_col.db_commit()
def get_groups_friends(self, node):
db = SQLiteParser.Database.FromNode(node, canceller)
if db is None:
return
if 'SessionModel' not in db.Tables:
return
tbs = SQLiteParser.TableSignature("SessionModel")
for rec in db.ReadTableRecords(tbs, self.extractDeleted, True):
try:
if canceller.IsCancellationRequested:
return
# 群
if "`sessionType`" in rec and rec["`sessionType`"].Value == 3:
group = model_im.Chatroom()
group.source = node.AbsolutePath
if rec.Deleted == DeletedState.Deleted:
group.deleted = 1
group.type = 1
if "`loadName`" in rec and (
not rec["`loadName`"].IsDBNull):
group.account_id = rec["`loadName`"].Value
if "`sessionAvatar`" in rec and (
not rec["`sessionAvatar`"].IsDBNull):
group.photo = rec["`sessionAvatar`"].Value
if "`sessionNickName`" in rec and (
not rec["`sessionNickName`"].IsDBNull):
group.name = rec["`sessionNickName`"].Value
if "`sessionId`" in rec and (
not rec["`sessionId`"].IsDBNull):
group.chatroom_id = rec["`sessionId`"].Value
if group.chatroom_id and group.name:
self.group_list[group.chatroom_id] = group.name
if group.account_id and group.chatroom_id:
self.blued.db_insert_table_chatroom(group)
# 好友
elif "`sessionType`" in rec and rec["`sessionType`"].Value == 2:
friend = model_im.Friend()
friend.source = node.AbsolutePath
friend.type = 1
if "`loadName`" in rec and (
not rec["`loadName`"].IsDBNull):
friend.account_id = rec["`loadName`"].Value
if "`sessionAvatar`" in rec and (
not rec["`sessionAvatar`"].IsDBNull):
friend.photo = rec["`sessionAvatar`"].Value
if "`sessionNickName`" in rec and (
not rec["`sessionNickName`"].IsDBNull):
friend.nickname = rec["`sessionNickName`"].Value
if "`sessionId`" in rec and (
not rec["`sessionId`"].IsDBNull):
friend.friend_id = rec["`sessionId`"].Value
if friend.friend_id and friend.nickname:
self.friend_list[friend.friend_id] = friend.nickname
if friend.account_id and friend.friend_id:
self.blued.db_insert_table_friend(friend)
except Exception as e:
traceback.print_exc()
self.blued.db_commit()
def get_contacts(self):
if self.user is None:
return
dbPath = self.root.GetByPath('../../../Documents/' + self.user +
'/msg2.db')
db = SQLiteParser.Database.FromNode(dbPath)
if db is None:
return
if 'msglog' in db.Tables:
ts = SQLiteParser.TableSignature('msglog')
SQLiteParser.Tools.AddSignatureToTable(
ts, "id", SQLiteParser.FieldType.Text,
SQLiteParser.FieldConstraints.NotNull)
for rec in db.ReadTableRecords(ts, self.extract_deleted):
if canceller.IsCancellationRequested:
return
contact = {'deleted': rec.Deleted, 'repeated': 0}
contactid = rec['id'].Value
type = rec['msg_type'].Value
if contactid in self.contacts:
continue
else:
self.contacts[contactid] = contact
if type == 1:
friend = model_im.Friend()
friend.deleted = 0 if rec.Deleted == DeletedState.Intact else 1
friend.repeated = contact.get('repeated', 0)
friend.source = dbPath.AbsolutePath
friend.account_id = self.user
friend.friend_id = contactid
friend.type = model_im.FRIEND_TYPE_FRIEND
self.csm.db_insert_table_friend(friend)
if type == 2:
chatroom = model_im.Chatroom()
chatroom.deleted = 0 if rec.Deleted == DeletedState.Intact else 1
chatroom.repeated = contact.get('repeated', 0)
chatroom.source = dbPath.AbsolutePath
chatroom.account_id = self.user
chatroom.chatroom_id = contactid
self.csm.db_insert_table_chatroom(chatroom)
if type == 6:
friend = model_im.Friend()
friend.deleted = 0 if rec.Deleted == DeletedState.Intact else 1
friend.repeated = contact.get('repeated', 0)
friend.source = dbPath.AbsolutePath
friend.account_id = self.user
friend.friend_id = contactid
friend.type = model_im.FRIEND_TYPE_SUBSCRIBE
self.csm.db_insert_table_friend(friend)
self.csm.db_commit()
def parse_chatroom(self, dbPath, deleteFlag):
'''解析群组数据'''
db = SQLite.SQLiteConnection('Data Source = {}; ReadOnly = True'.format(dbPath))
db.Open()
db_cmd = SQLite.SQLiteCommand(db)
if deleteFlag is 1:
self.db = SQLite.SQLiteConnection('Data Source = {}'.format(self.cachedb))
self.db.Open()
self.db_cmd = SQLite.SQLiteCommand(self.db)
try:
if db is None:
return
db_cmd.CommandText = '''select distinct _id, date, participant_id_1, participant_id_2, participant_id_3, participant_id_4, name from conversations where conversation_type = 1'''
sr = db_cmd.ExecuteReader()
dic = {}
while (sr.Read()):
try:
id = self._db_reader_get_int_value(sr, 0)
if id != 0:
if id not in dic.keys():
dic[id] = []
dic[id].append(deleteFlag)
elif deleteFlag in dic[id]:
continue
chatroom = model_im.Chatroom()
if canceller.IsCancellationRequested:
break
chatroom.account_id = self.account_id
chatroom.chatroom_id = self._db_reader_get_int_value(sr, 0)
chatroom.create_time = self._get_timestamp(sr[1]) if not IsDBNull(sr[1]) else 0
chatroom.deleted = deleteFlag
if sr[5] != 0:
count = 4
elif sr[4] != 0:
count = 3
elif sr[3] != 0:
count = 2
else:
count = 0
chatroom.member_count = count
chatroom.name = self._db_reader_get_string_value(sr, 6)
chatroom.source = self.node.AbsolutePath
self.db_insert_table_chatroom(chatroom)
except:
traceback.print_exc()
sr.Close()
if deleteFlag is 0:
self.db_commit()
db_cmd.Dispose()
db.Close()
except Exception as e:
print(e)
def parse_Chatroom(self, table_name):
''' REAL_GROUP 包含群成员
FieldName SQLType
_key STRING # chat_id
_val BLOB #
'''
CHATROOM_ID_NAME = {}
FRIEND_CHATROOMS = {}
for rec in self._read_table(table_name, deleted=False):
if self._is_empty(rec, '_key', '_val'):
continue
try:
pk_value = rec['_key'].Value
if pk_value[0] not in ('c', 'r') or self._is_duplicate(
rec, '_key'):
continue
except:
continue
CHATROOM_NAME, CHATROOM_MEMBERS = self._read_chatroom_hex(
rec['_val'].Value)
chatroom = model_im.Chatroom()
chatroom.account_id = self.cur_account_id
chatroom.chatroom_id = rec['_key'].Value
chatroom.name = CHATROOM_NAME if CHATROOM_NAME else None
chatroom.member_count = len(CHATROOM_MEMBERS)
chatroom.creator_id = CHATROOM_MEMBERS[
0] if CHATROOM_MEMBERS else None
# chatroom.create_time =
chatroom.deleted = 1 if rec.IsDeleted else 0
chatroom.source = self.cur_db_source
for friend_id in CHATROOM_MEMBERS:
if FRIEND_CHATROOMS.has_key(friend_id):
FRIEND_CHATROOMS[friend_id].add(chatroom.chatroom_id)
else:
chatrooms = set()
chatrooms.add(chatroom.chatroom_id)
FRIEND_CHATROOMS[friend_id] = chatrooms
try:
CHATROOM_ID_NAME[chatroom.chatroom_id] = chatroom.name
except:
exc()
try:
chatroom.insert_db(self.im)
except:
exc()
self.im.db_commit()
return CHATROOM_ID_NAME, FRIEND_CHATROOMS
def get_groups_friends(self, node, account_id):
db = SQLiteParser.Database.FromNode(node, canceller)
if db is None:
return
if 'sessionTable' not in db.Tables:
return
tbs = SQLiteParser.TableSignature("sessionTable")
for rec in db.ReadTableRecords(tbs, False):
try:
if canceller.IsCancellationRequested:
return
# 群
if "sessionType" in rec and rec["sessionType"].Value == 3:
group = model_im.Chatroom()
group.account_id = account_id
group.source = node.AbsolutePath
group.type = 1
if "sessionAvatar" in rec and (
not rec["sessionAvatar"].IsDBNull):
group.photo = rec["sessionAvatar"].Value
if "sessionName" in rec and (
not rec["sessionName"].IsDBNull):
group.name = rec["sessionName"].Value
if "sessionId" in rec and (not rec["sessionId"].IsDBNull):
group.chatroom_id = rec["sessionId"].Value
if group.chatroom_id and group.name:
self.group_list[group.chatroom_id] = group.name
if group.account_id and group.chatroom_id:
self.blued.db_insert_table_chatroom(group)
# 好友
elif "sessionType" in rec and rec["sessionType"].Value == 2:
friend = model_im.Friend()
friend.account_id = account_id
friend.source = node.AbsolutePath
friend.type = 1
if "sessionAvatar" in rec and (
not rec["sessionAvatar"].IsDBNull):
friend.photo = rec["sessionAvatar"].Value
if "sessionName" in rec and (
not rec["sessionName"].IsDBNull):
friend.nickname = rec["sessionName"].Value
if "sessionId" in rec and (not rec["sessionId"].IsDBNull):
friend.friend_id = rec["sessionId"].Value
if friend.friend_id and friend.nickname:
self.friend_list[friend.friend_id] = friend.nickname
if friend.account_id and friend.friend_id:
self.blued.db_insert_table_friend(friend)
except Exception as e:
pass
self.blued.db_commit()
def get_chatroom(self, account_id):
try:
for g_id, g_name in self.group_info.items():
chatroom = model_im.Chatroom()
chatroom.account_id = account_id
chatroom.chatroom_id = g_id
chatroom.name = g_name
chatroom.type = 1
try:
self.bulletMessage.db_insert_table_chatroom(chatroom)
except Exception as e:
pass
except Exception as e:
pass
self.bulletMessage.db_commit()
def parse_Chatroom(self, table_name, CHATROOM_MEMBER_COUNT):
''' TIMConversationCoreInfoORM
FieldName SQLType
belongingConversationIdentifier TEXT
infoVersion INTEGER
name TEXT
desc TEXT
icon TEXT
notice TEXT
ext TEXT
'''
CHATROOM_ID_NAME = {}
for rec in self._read_table(table_name):
try:
if (rec['belongingConversationIdentifier'].Value
not in CHATROOM_MEMBER_COUNT or self._is_empty(
rec, 'belongingConversationIdentifier', 'name')
or self._is_duplicate(
rec, 'belongingConversationIdentifier')):
continue
chatroom = model_im.Chatroom()
chatroom.account_id = self.cur_account_id
chatroom.chatroom_id = rec[
'belongingConversationIdentifier'].Value
chatroom.name = rec['name'].Value
chatroom.photo = rec['icon'].Value
try:
chatroom.creator_id = json.loads(
rec['ext'].Value).get('a:s_name_operator')
except:
pass
chatroom.member_count = CHATROOM_MEMBER_COUNT.get(
chatroom.chatroom_id, None)
chatroom.create_time = rec['infoVersion'].Value
chatroom.deleted = 1 if rec.IsDeleted else 0
chatroom.source = self.cur_db_source
try:
CHATROOM_ID_NAME[chatroom.chatroom_id] = chatroom.name
except:
exc()
chatroom.insert_db(self.csm)
except:
exc()
self.csm.db_commit()
return CHATROOM_ID_NAME
def get_groups(self, node, account_id):
groups_node = node.GetByPath("nim_cache.db")
if groups_node is None:
return
try:
conn = SqliteByCSharp(groups_node, self.cache)
with conn as cmd:
cmd.CommandText = '''
select id,name,creator,level,count,introduce,create_time,icon from team
'''
reader = cmd.ExecuteReader()
while reader.Read():
try:
chatroom_id = SqliteByCSharp.GetString(reader, 0)
name = SqliteByCSharp.GetString(reader, 1)
creator_id = SqliteByCSharp.GetString(reader, 2)
max_member_count = SqliteByCSharp.GetInt64(reader, 3)
member_count = SqliteByCSharp.GetInt64(reader, 4)
notice = SqliteByCSharp.GetString(reader, 5)
create_time = SqliteByCSharp.GetInt64(reader, 6)
photo = SqliteByCSharp.GetString(reader, 7)
self.group_list[chatroom_id] = name
chatroom = model_im.Chatroom()
chatroom.source = groups_node.AbsolutePath
chatroom.account_id = account_id
chatroom.chatroom_id = chatroom_id
chatroom.name = name
chatroom.creator_id = creator_id
chatroom.max_member_count = max_member_count
chatroom.member_count = member_count
chatroom.notice = notice
chatroom.photo = photo
chatroom.type = 1 # 普通群
if chatroom.account_id and chatroom.chatroom_id:
self.bulletMessage.db_insert_table_chatroom(
chatroom)
except Exception as e:
print(e)
except Exception as e:
print(e)
self.bulletMessage.db_commit()
def _get_chatroom_table(self):
chatroom_member = []
with self.checking_col as db_col:
sql = """SELECT nsp_data
FROM {};""".format(self.table_name["conversations"])
db_col.execute_sql(sql)
while db_col.has_rest():
try:
chatroom_info = json.loads(db_col.get_string(0))
chatroom = model_im.Chatroom()
chatroom.source = db_col.db_path
chatroom.account_id = self.using_account.account_id
chatroom.chatroom_id = chatroom_info["conv"]["id"].split(
":", 1)[1]
if not chatroom.chatroom_id.endswith("@thread.skype"):
continue
if chatroom_info["conv"].get("_convProps", None):
chatroom.create_time = self.__convert_timestamp(
chatroom_info["conv"]["_convProps"].get(
"created", None))
if chatroom_info["conv"].get("_threadProps", None):
chatroom.member_count = int(
chatroom_info["conv"]["_threadProps"].get(
"membercount", 0))
chatroom.name = chatroom_info["conv"][
"_threadProps"].get("topic", None)
if chatroom_info["conv"]["_threadProps"].get(
"creator", None):
chatroom.creator_id = \
chatroom_info["conv"]["_threadProps"].get("creator", "").split(":", 1)[1]
# 获取成员并return 出去方便拿到chatroom_member表
if chatroom_info["conv"].get("_threadMembers", None):
for member in chatroom_info["conv"]["_threadMembers"]:
member["id"] = member["id"].split(":", 1)[1]
member["chatroom_id"] = chatroom.chatroom_id
chatroom_member.append(member)
self.model_im_col.db_insert_table_chatroom(chatroom)
except Exception as e:
pass
self.model_im_col.db_commit()
return chatroom_member
def get_groups(self, node):
try:
results = []
db = SQLiteParser.Database.FromNode(node, canceller)
if db is None:
return
if 'QOCGroupDetail' not in db.Tables:
return
tbs = SQLiteParser.TableSignature("QOCGroupDetail")
for rec in db.ReadTableRecords(tbs, self.extractDeleted, True):
if canceller.IsCancellationRequested:
return
try:
groups = model_im.Chatroom()
groups.source = node.AbsolutePath
groups.type = 1
if rec.Deleted == DeletedState.Deleted:
groups.deleted = 1
if "owner_id" in rec and (not rec["owner_id"].IsDBNull):
groups.account_id = rec["owner_id"].Value
if "session_id" in rec and (
not rec["session_id"].IsDBNull):
groups.chatroom_id = rec["session_id"].Value
if "title" in rec and (not rec["title"].IsDBNull):
groups.name = rec["title"].Value
if "members_num" in rec and (
not rec["members_num"].IsDBNull):
groups.member_count = rec["members_num"].Value
if "img_url" in rec and (not rec["img_url"].IsDBNull):
groups.photo = rec["img_url"].Value
if groups.account_id and groups.chatroom_id:
self.qunar_db.db_insert_table_chatroom(groups)
# resluts.append(groups)
except Exception as e:
TraceService.Trace(TraceLevel.Info,
"qunar(ios) get_groups record failed")
# return results
except Exception as e:
TraceService.Trace(TraceLevel.Error,
"qunar(ios) get_groups failed")
# return []
self.qunar_db.db_commit()
def _get_chatroom_table(self):
with self.icq_db_col as db_col:
sql = """SELECT ICQ_CONTACT_DATA.PROFILE_ID,
ICQ_CONTACT_DATA.CONTACT_ID,
ICQ_CONTACT_DATA.NAME,
CHAT_INFO.ABOUT,
CHAT_INFO.MEMBERS_COUNT
FROM ICQ_CONTACT_DATA LEFT JOIN CHAT_INFO
on ICQ_CONTACT_DATA.CHAT_INFO_ID = CHAT_INFO._id
where ICQ_CONTACT_DATA.CONTACT_ID like '%@%';"""
db_col.execute_sql(sql)
while db_col.has_rest():
try:
chatroom = model_im.Chatroom()
chatroom.source = self.icq_data_path
chatroom.account_id = db_col.get_string(0)
chatroom.chatroom_id = db_col.get_string(1)
chatroom.name = db_col.get_string(2)
chatroom.description = db_col.get_string(3)
chatroom.member_count = db_col.get_int64(4)
self.model_im_col.db_insert_table_chatroom(chatroom)
except Exception as e:
print("debug error", e)
self.model_im_col.db_commit()
def _generate_chatroom_table(self):
with self.cloud_p2p_col as db_col:
sql = """SELECT v_groups_detail.name,
v_groups_detail.desc,
v_groups_detail.announce,
v_groups_detail.type,
v_groups_detail.ctime,
v_groups_detail.create_uk,
v_groups_detail.people_limit,
v_groups_detail.group_id,
v_groups_detail.is_banded,
count(v_groups_people.uk)
FROM v_groups_detail left join v_groups_people
on v_groups_detail.group_id = v_groups_people.group_id
group by v_groups_detail.group_id;"""
db_col.execute_sql(sql)
while db_col.has_rest():
try:
chatroom = model_im.Chatroom()
chatroom.chatroom_id = db_col.get_int64(7)
chatroom.account_id = self.using_account.account_id
chatroom.name = db_col.get_string(0)
chatroom.member_count = db_col.get_int64(9)
chatroom.max_member_count = db_col.get_int64(6)
chatroom.create_time = db_col.get_int64(4)
chatroom.creator_id = db_col.get_int64(5)
chatroom.source = db_col.db_path
chatroom.description = db_col.get_string(1)
chatroom.notice = db_col.get_string(2)
self.model_im_col.db_insert_table_chatroom(chatroom)
except Exception as e:
pass
self.model_im_col.db_commit()
def parse(self, aid):
files = self.cache + '/{}.db'.format(aid)
if not os.path.exists(self.cache + '/{}.db'.format(aid)):
self.m_print('no sql file,parse exit!')
return
conn = sql.SQLiteConnection(
'Data Source = {}; Readonly = True'.format(self.cache +
'/{}.db'.format(aid)))
conn.Open()
cmd = sql.SQLiteCommand(conn)
cmd.CommandText = '''
select iconMedia, nick, gender, city, mobile, real_name, dingtalkId, email, activeTime
from tbuser where uid = {}
'''.format(aid)
reader = cmd.ExecuteReader()
reader.Read()
a = model_im.Account()
a.account_id = aid
a.nickname = GetString(reader, 1)
if GetString(reader, 2) == 'F':
a.gender = model_im.GENDER_FEMALE
elif GetString(reader, 2) == 'M':
a.gender = model_im.GENDER_MALE
else:
a.gender = model_im.GENDER_OTHER
a.address = GetString(reader, 3)
a.telephone = GetString(reader, 4)
a.email = GetString(reader, 7)
a.photo = GetString(reader, 0)
self.im.db_insert_table_account(a)
cmd.Dispose()
cmd.CommandText = '''
select uid, iconMedia, nick, gender, city, mobile, email, extensation from tbuser
where uid != {}
'''.format(aid)
reader = cmd.ExecuteReader()
f_dict = dict()
while reader.Read():
f = model_im.Friend()
f.account_id = aid
f.friend_id = GetInt64(reader, 0)
f.photo = GetString(reader, 1)
gender = GetString(reader, 3)
if gender == 'F':
f.gender = model_im.GENDER_FEMALE
elif gender == 'M':
f.gender = model_im.GENDER_MALE
else:
f.gender = model_im.GENDER_OTHER
f.nickname = Getstring(reader, 2)
f.address = GetString(reader, 4)
f.telephone = GetString(reader, 5)
f.email = GetString(reader, 6)
f.source = files
ext = Getstring(reaser, 7)
js = json.loads(ext)
if js.get('ownness') is not None:
f.signature = js.get('ownness')[0].get('status')
#self.im.db_insert_table_friend(f)
f_dict[f.friend_id] = f
cmd.Dispose()
# 暂时未加入分组信息
cmd.CommandText = '''
select uid, empName, orgName, depName from tb_user_intimacy
'''
reader = cmd.ExecuteReader()
while reader.Read():
try:
#f = model_im.Friend()
f_dict[GetInt64(reader, 0)].remark = GetString(reader, 2)
except:
continue
for k in f_dict:
self.im.db_insert_table_friend(f_dict[k])
cmd.Dispose()
cmd.CommandText = '''
select tbdingcontent.content, tbdingcontent.dingId, tbdinglist.senderId,
tbdinglist.dingCreatedAt, tbdinglist.latestComments
from tbdingcontent,tbdinglist where tbdingcontent.dingId = tbdinglist.dingId
'''
reader = cmd.ExecuteReader()
while reader.Read():
feed = model_im.Feed()
feed.account_id = aid
feed.content = GetString(reader, 0)
feed.sender_id = GetInt64(reader, 2)
feed.send_time = GetInt64(reader, 3) / 1000
feed.source = files
string = GetString(reader, 4)
if string is not '':
js = json.loads(string)
for a in js:
feed.comments += '{},'.format(a.get('commentId'))
fcm = model_im.FeedComment()
fcm.comment_id = a.get('commentId')
fcm.content = a.get('commentContent').get('text')
fcm.sender_id = a.get('senderId')
fcm.sender_name = a.get('commenter')
fcm.create_time = a.get('createdAt') / 1000
fcm.source = files
self.im.db_insert_table_feed_comment(fcm)
self.im.db_insert_table_feed(feed)
cmd.Dispose()
conn.Close()
self.im.db_commit()
files = self.cache + '/{}_chat.db'.format(aid)
if not os.path.exists(files):
self.m_print('no chat sqlite file, parse exists!')
return
conn = sql.SQLiteConnection(
'Data Source = {}; ReadOnly = True'.format(files))
conn.Open()
cmd = sql.SQLiteCommand(conn)
cmd.CommandText('''
select cid, title , createAt, ownerId, groupIcon from tbconversation where type = 2
''')
reader = cmd.ExecuteReader()
while reader.Read():
g = model_im.Chatroom()
g.account_id = aid
g.chatroom_id = GetString(reader, 0)
g.name = GetString(reader, 1)
g.owner_id = GetInt64(reader, 3)
g.create_time = GetInt64(reader, 2) / 1000
g.source = files
self.im.db_insert_table_chatroom(g)
cmd.Dispose()
cmd.CommandText = '''
select tbl_name from sqlite_master where type = 'table' and tbl_name like 'tbmsg_%'
'''
reader = cmd.ExecuteReader()
tbl_list = list()
while reader.Read():
tbl_list.append(GetString(reade, 0))
cmd.Dispose()
for tbl in tbl_list:
cmd.CommandText = '''
select cid, mid, senderId, createdAt, contentType, content from {}
'''.format(tbl)
reader = cmd.ExecuteReader()
while reader.Read():
msg = model_im.Message()
msg.account_id = aid
msg.msg_id = GetInt64(reader, 1)
msg.talker_id = GetString(reader, 0)
# talker_name?
msg.sender_id = GetInt64(reader, 2)
msg.is_sender = 1 if msg.sender_id == aid else 0
msg.send_time = GetInt64(reader, 3) / 1000
tp = GetInt64(reader, 4)
string = GetString(reader, 5)
if tp == 1:
msg.type = model_im.MESSAGE_CONTENT_TYPE_TEXT
js = json.loads(string)
msg.content = js.get('txt')
elif tp == 2:
msg.type = model_im.MESSAGE_CONTENT_TYPE_IMAGE
js = json.loads(string)
msg.content = js.get('url')
elif tp == 501 or tp == 503 or tp == 502:
msg.type = model_im.MESSAGE_CONTENT_TYPE_ATTACHMENT
msg.content = js.get('ext').get('f_name')
elif tp == 901: # redpakcet
#msg.type = model_im.message_content_type_
# pass
js = json.loads(string)
amount = js.get('ext').get('amount')
title = js.get('ext').get('congrats')
size = js.get('ext').get('size')
elif tp == 203: # picture...
msg.type = model_im.MESSAGE_CONTENT_TYPE_ATTACHMENT
js = json.loads(string)
msg.content = js.get('f_name')
elif tp == 1200 or tp == 1203:
msg.type = model_im.MESSAGE_CONTENT_TYPE_TEXT
js = json.loads(string)
msg.content = js.get('markdown')
elif tp == 300:
msg.type = model_im.MESSAGE_CONTENT_TYPE_TEXT
js = json.loads(string)
ext = js.get('multi')[0].get('ext')
js = json.loads(ext)
msg.content = js.get('b_tl')
elif tp == 103:
msg.type = model_im.MESSAGE_CONTENT_TYPE_VIDEO
js = json.loads(string)
msg.content = js.get('url')
# msg.media_path = msg.content # ???
elif tp == 1101:
msg.type = model_im.MESSAGE_CONTENT_TYPE_TEXT
msg.content = string
elif tp == 3:
msg.type = model_im.MESSAGE_CONTENT_TYPE_VOICE
msg.content = json.loads(string).get('url')
elif tp == 1600:
msg.type = model_im.MESSAGE_CONTENT_TYPE_SYSTEM
msg.content = json.loads(string).get('dingContent')
else:
msg.type = model_im.MESSAGE_CONTENT_TYPE_TEXT
msg.content = string
self.im.db_insert_table_message(msg)
self.im.db_commit()
cmd.Dispose()
conn.Close()
def analyse_account(self, aid):
account_node = self.root_node.GetByPath(
'/Documents/{}/account'.format(aid))
##########################Friends#####################################
f_sql_node = account_node.GetByPath('/{}_Relation2.sqlite'.format(aid))
db = unity_c37r.create_connection(f_sql_node.PathWithMountPoint)
cmd = sql.SQLiteCommand(db)
friends = list()
cmd.CommandText = '''
select miliaoid, name, comments, icon, type, timestamp from MLRelation2Object
'''
reader = cmd.ExecuteReader()
while reader.Read():
if canceller.IsCancellationRequested:
self.im.db_close()
raise IOError("E")
f = model_im.Friend()
f.account_id = aid
f.friend_id = unity_c37r.c_sharp_get_string(reader, 0)
f.deleted = 0
f.nickname = unity_c37r.c_sharp_get_string(reader, 1)
f.remark = unity_c37r.c_sharp_get_string(reader, 2)
pic = unity_c37r.c_sharp_get_string(reader, 3)
f.icon = self.__get_media_path(pic, -1)
f.source = f_sql_node.AbsolutePath
f.type = model_im.FRIEND_TYPE_FRIEND
friends.append(f)
cmd.Dispose()
db.Close()
f_info_node = account_node.GetByPath(
'/{}_PersonalInfo2.sqlite'.format(aid))
db = unity_c37r.create_connection(f_info_node.PathWithMountPoint)
cmd = sql.SQLiteCommand(db)
for f in friends:
cmd.CommandText = '''
select info from MLPersonalInfo2Object where miliaoid = '{}'
'''.format(f.friend_id)
reader = cmd.ExecuteReader()
if not reader.Read():
cmd.Dispose()
continue
jstring = unity_c37r.c_sharp_get_string(reader, 0)
r = json.loads(jstring, encoding='utf-8')
f.address = r.get('city')
if r.get('sex') == u'男':
f.gender = 0
elif r.get('sex') == u'女':
f.gender = 1
else:
f.gender = 9
f.photo = self.__get_media_path(r.get('icon'), -1)
f.signature = r.get('signature')
self.im.db_insert_table_friend(f)
cmd.Dispose()
self.im.db_commit()
cmd.CommandText = '''
select info from MLPersonalInfo2Object where miliaoid = {}
'''.format(aid)
reader = cmd.ExecuteReader()
if not reader.Read():
module_print('no account record in the db, skipped', 1)
else:
a = model_im.Account()
a.account_id = aid
jstring = unity_c37r.c_sharp_get_string(reader, 0)
r = json.loads(jstring)
a.nickname = r.get('nickname')
a.address = r.get('city')
a.birthdat = r.get('birthday')
a.source = f_info_node.PathWithMountPoint
a.signature = r.get('signature')
icon_url = r.get('icon')
a.photo = self.__get_media_path(icon_url, -1)
a.source = f_info_node.AbsolutePath
self.im.db_insert_table_account(a)
##########################Groups#####################################
cmd.Dispose()
db.Close()
grp_sql_node = account_node.GetByPath('/{}_MUC2.sqlite'.format(aid))
if grp_sql_node is not None:
db = unity_c37r.create_connection(grp_sql_node.PathWithMountPoint)
cmd = sql.SQLiteCommand(db)
cmd.CommandText = '''
select creator_id, creator_name, group_id, group_name, create_time, group_member_limit, group_icon
from MLMUC2Object
'''
reader = cmd.ExecuteReader()
else:
reader = None
grp = dict()
while reader is not None and reader.Read():
if canceller.IsCancellationRequested:
self.im.db_close()
raise IOError("E")
g = model_im.Chatroom()
g.account_id = aid
g.chatroom_id = unity_c37r.c_sharp_get_string(reader, 2)
g.creator_id = unity_c37r.c_sharp_get_string(reader, 0)
g.create_time = unity_c37r.c_sharp_get_long(reader, 4)
g.owner_id = g.creator_id
g.name = unity_c37r.c_sharp_get_string(reader, 3)
g.max_member_count = unity_c37r.c_sharp_get_long(reader, 5)
g.deleted = 0
g.source = grp_sql_node.AbsolutePath
g.member_count = 0
pic = unity_c37r.c_sharp_get_string(reader, 6)
if pic is None:
pic = ""
res = re.search('\\[(.*)\\]', pic, re.I | re.M)
if res is not None:
g.photo = self.__get_media_path(
json.loads(res.group(1)).get('url'),
-1) if res.group(1) is not "" else None
grp[g.chatroom_id] = g
if reader is not None:
cmd.Dispose()
db.Close()
grp_mem_node = account_node.GetByPath(
'/{}_mucMember2.sqlite'.format(aid))
if grp_mem_node is not None:
#db = sqlite3.connect(grp_mem_node.PathWithMountPoint)
db = unity_c37r.create_connection(grp_mem_node.PathWithMountPoint)
#cur = db.cursor()
cmd = sql.SQLiteCommand(db)
cmd.CommandText = '''
select group_id, member_gender, member_icon, member_id, member_nick, join_time, last_send_msg, member_uptodate
from MLMUCMember2Object
'''
reader = cmd.ExecuteReader()
else:
reader = None
while reader is not None and reader.Read():
if canceller.IsCancellationRequested:
self.im.db_close()
raise IOError("E")
gid = unity_c37r.c_sharp_get_string(reader, 0)
if grp.__contains__(gid):
grp[gid].member_count += 1
m = model_im.ChatroomMember()
m.account_id = aid
m.member_id = unity_c37r.c_sharp_get_string(reader, 3)
m.display_name = unity_c37r.c_sharp_get_string(reader, 4)
# fix it later
#m.photo = md5()
pic = unity_c37r.c_sharp_get_string(reader, 2)
m.photo = self.__get_media_path(pic, -1) if pic is not "" else None
m.source = grp_mem_node.AbsolutePath
m.chatroom_id = unity_c37r.c_sharp_get_string(reader, 0)
#m.gender = # fix it later...
m.gender = 9
m.deleted = 0
self.im.db_insert_table_chatroom_member(m)
if reader is not None:
cmd.Dispose()
db.Close()
for k in grp:
self.im.db_insert_table_chatroom(grp[k])
self.im.db_commit()
self.__parse_message(account_node, aid)
def get_contacts(self):
if self.user is None:
return
subDbPath = self.root.GetByPath('/Documents/DB/' + self.user +
'/subscribed.sqlite')
subDb = SQLiteParser.Database.FromNode(subDbPath)
if subDb is None:
return
if 'r_h_c_public_account_object' in subDb.Tables:
ts = SQLiteParser.TableSignature('r_h_c_public_account_object')
SQLiteParser.Tools.AddSignatureToTable(
ts, "account_i_d", SQLiteParser.FieldType.Text,
SQLiteParser.FieldConstraints.NotNull)
for rec in subDb.ReadTableRecords(ts, self.extract_deleted):
if canceller.IsCancellationRequested:
return
friend = model_im.Friend()
friend.deleted = 0 if rec.Deleted == DeletedState.Intact else 1
friend.source = subDbPath.AbsolutePath
friend.account_id = self.user
friend.friend_id = str(rec['account_i_d'].Value)
friend.nickname = rec['account_name'].Value
friend.photo = rec['account_head_u_r_l'].Value
friend.type = model_im.FRIEND_TYPE_SUBSCRIBE
self.friends[friend.friend_id] = friend
self.im.db_insert_table_friend(friend)
infoDbPath = self.root.GetByPath('/Documents/DB/' + self.user +
'/info.sqlite')
infoDb = SQLiteParser.Database.FromNode(infoDbPath)
if infoDb is None:
return
if 'r_s_chat_room_persistence_object' in infoDb.Tables:
ts_1 = SQLiteParser.TableSignature(
'r_s_chat_room_persistence_object')
SQLiteParser.Tools.AddSignatureToTable(
ts_1, "room_id", SQLiteParser.FieldType.Text,
SQLiteParser.FieldConstraints.NotNull)
for rec in infoDb.ReadTableRecords(ts_1, self.extract_deleted):
if canceller.IsCancellationRequested:
return
chatroom = model_im.Chatroom()
chatroom.deleted = 0 if rec.Deleted == DeletedState.Intact else 1
chatroom.source = infoDbPath.AbsolutePath
chatroom.account_id = self.user
chatroom.chatroom_id = str(rec['room_id'].Value)
chatroom.name = rec['room_name'].Value
chatroom.photo = rec['head_url'].Value
if IsDBNull(chatroom.photo):
chatroom.photo = None
self.chatrooms[chatroom.chatroom_id] = chatroom
self.im.db_insert_table_chatroom(chatroom)
chatroom_members = []
if 'r_s_chat_member_persistence_object' in infoDb.Tables:
ts_2 = SQLiteParser.TableSignature(
'r_s_chat_member_persistence_object')
SQLiteParser.Tools.AddSignatureToTable(
ts_2, "user_id", SQLiteParser.FieldType.Text,
SQLiteParser.FieldConstraints.NotNull)
for rec in infoDb.ReadTableRecords(ts_2,
self.extract_deleted):
if canceller.IsCancellationRequested:
return
room_id = str(rec['room_id'].Value)
if room_id != chatroom.chatroom_id:
continue
chatroom_member = model_im.ChatroomMember()
chatroom_member.deleted = 0 if rec.Deleted == DeletedState.Intact else 1
chatroom_member.source = infoDbPath.AbsolutePath
chatroom_member.account_id = self.user
chatroom_member.chatroom_id = room_id
chatroom_member.member_id = rec['user_id'].Value
chatroom_member.display_name = rec['name'].Value
chatroom_member.photo = rec['head_url'].Value
chatroom_members.append(chatroom_member)
self.im.db_insert_table_chatroom_member(
chatroom_member)
self.chatroom_members[chatroom.chatroom_id] = chatroom_members
chatDbPath = self.root.GetByPath('/Documents/DB/' + self.user +
'/chat.sqlite')
chatDb = SQLiteParser.Database.FromNode(chatDbPath)
if chatDb is None:
return
if 'r_s_chat_session' in chatDb.Tables:
ts_1 = SQLiteParser.TableSignature('r_s_chat_session')
SQLiteParser.Tools.AddSignatureToTable(
ts_1, "target_user_id", SQLiteParser.FieldType.Text,
SQLiteParser.FieldConstraints.NotNull)
for rec in chatDb.ReadTableRecords(ts_1, self.extract_deleted):
if canceller.IsCancellationRequested:
return
friend = model_im.Friend()
friend.deleted = 0 if rec.Deleted == DeletedState.Intact else 1
friend.source = chatDbPath.AbsolutePath
friend.type = model_im.FRIEND_TYPE_FRIEND
friend.account_id = self.user
friend.friend_id = str(rec['target_user_id'].Value)
friend.nickname = rec['target_user_name'].Value
if 'r_n_chat_target_info' in infoDb.Tables:
ts_2 = SQLiteParser.TableSignature(
'r_n_chat_target_info')
SQLiteParser.Tools.AddSignatureToTable(
ts_2, "target_id", SQLiteParser.FieldType.Text,
SQLiteParser.FieldConstraints.NotNull)
for rec in infoDb.ReadTableRecords(
ts_2, self.extract_deleted):
id = str(rec['target_id'].Value)
if id != friend.friend_id:
continue
friend.photo = rec['target_head_url'].Value
if IsDBNull(friend.photo):
friend.photo = None
if friend.friend_id not in self.friends.keys(
) and friend.friend_id not in self.chatrooms.keys():
self.friends[friend.friend_id] = friend
self.im.db_insert_table_friend(friend)
self.im.db_commit()
def parse(self):
if self.account is None:
print('Get Account Id Failed, Parse Ret!')
return False
tg_node = self.root.GetByPath('Documents/tgdata.db')
conn = sql.SQLiteConnection('Data Source = {}; Readonly=True'.format(tg_node.PathWithMountPoint))
conn.Open()
cmd = sql.SQLiteCommand(conn)
cmd.CommandText = '''
select uid, first_name, last_name, phone_number, photo_small, photo_medium, photo_big, last_seen, username from users_v29
where uid = {}'''.format(self.account)
reader = cmd.ExecuteReader()
if reader.Read():
a = model_im.Account()
idx = 0
a.account_id = GetInt64(reader, 0)
a.nickname = GetString(reader, 2) + GetString(reader, 1)
a.telephone = GetString(reader, 3)
p = self.get_photo_from_id(GetString(reader, 6))
if p is "":
p = self.get_photo_from_id(GetString(reader, 5))
if p is "":
p = self.get_photo_from_id(GetString(reader, 4))
a.photo = p
a.username = GetString(reader, 8)
self.im.db_insert_table_account(a)
else:
self.im.db_close()
print("this is not the right group!")
return False
cmd.Dispose()
cmd.CommandText = '''
select uid, first_name, last_name, phone_number, photo_small, photo_medium, photo_big, username from users_v29
where uid != {}
'''.format(self.account)
reader = cmd.ExecuteReader()
while reader.Read():
f = model_im.Friend()
f.account_id = self.account
f.friend_id = GetInt64(reader, 0)
f.nickname = GetString(reader, 2) + GetString(reader, 1)
f.telephone = GetString(reader, 3)
p = self.get_photo_from_id(GetString(reader, 6))
if p is "":
p = self.get_photo_from_id(GetString(reader, 5))
if p is "":
p = self.get_photo_from_id(GetString(reader, 4))
f.photo = p
# user name?
f.account_id = self.account
self.im.db_insert_table_friend(f)
cmd.Dispose()
self.im.db_commit()
# channels...
cmd.CommandText = '''
select cid, data from channel_conversations_v29
'''
reader = cmd.ExecuteReader()
while reader.Read():
g = model_im.Chatroom()
g.account_id = self.account
g.chatroom_id = GetInt64(reader, 0)
blob = bytearray(GetBlob(reader, 1))
decoder = TeleBlobDecoder(blob)
decoder.decode_long_for_ckey('i') # cid
decoder.decode_long_for_ckey('ah') # acess hash
decoder.decode_int_for_ckey('dv')
decoder.decode_int_for_ckey('kind')
decoder.decode_int_for_ckey('pts')
decoder.decode_bytes_for_ckey('vsort', 9)
decoder.decode_bytes_for_ckey('isort', 9)
decoder.decode_bytes_for_ckey('usort', 9)
decoder.decode_int_for_ckey('mread')
decoder.decode_int_for_ckey('moutread')
decoder.decode_int_for_ckey('mknown')
decoder.decode_int_for_ckey('mlr')
decoder.decode_int_for_ckey('mrd')
decoder.decode_int_for_ckey('mrod')
about = decoder.decode_string_for_ckey('about')
g.description = about
decoder.decode_string_for_ckey('username')
decoder.decode_int_for_ckey('out')
decoder.decode_int_for_ckey('unr')
decoder.decode_int_for_ckey('der')
decoder.decode_int_for_ckey('ds')
decoder.decode_int_for_ckey('date')
decoder.decode_int_for_ckey('from')
decoder.decode_string_for_ckey('text')
decoder.decode_data_for_ckey('media') # note that...
decoder.decode_int_for_ckey('ucount')
decoder.decode_int_for_ckey('sucount')
g.name = decoder.decode_string_for_ckey('ct') # nick name
ps = self.get_photo_from_id(decoder.decode_string_for_ckey('cp.s')) # photo small
pm = self.get_photo_from_id(decoder.decode_string_for_ckey('cp.m')) # photo medium
pb = self.get_photo_from_id(decoder.decode_string_for_ckey('cp.l')) # photo big
if pb is not "":
g.photo = pb
elif pm is not "":
g.photo = pm
else:
g.photo = ps
decoder.decode_int_for_ckey('ver')
decoder.decode_int_for_ckey('adm')
decoder.decode_int_for_ckey('role')
decoder.decode_int_for_ckey('ro')
decoder.decode_long_for_ckey('flags')
decoder.decode_int_for_ckey('lef')
decoder.decode_int_for_ckey('kk')
decoder.decode_int_for_ckey('mtci')
decoder.decode_long_for_ckey('mtch')
decoder.decode_string_for_ckey('rr')
decoder.decode_int_for_ckey('pmi')
decoder.decode_int_for_ckey('ccd')
decoder.decode_int_for_ckey('pdt')
self.im.db_insert_table_chatroom(g)
cmd.Dispose()
# Friend messages
# 稳的一笔 C37R
cmd.CommandText = '''
select mid, cid, message, media, from_id, to_id, outgoing, date from messages_v29
'''
reader = cmd.ExecuteReader()
while reader.Read():
m = model_im.Message()
m.talker_type = model_im.CHAT_TYPE_FRIEND
m.account_id = self.account
m.msg_id = GetInt64(reader, 0)
m.is_sender = GetInt64(reader, 6)
m.content = GetString(reader, 2)
m.sender_id = GetInt64(reader, 4)
m.talker_id = GetInt64(reader, 5) if m.is_sender == 1 else m.sender_id
m.send_time = GetInt64(reader, 7)
# parse media.... excited.
try:
blob = bytearray(GetBlob(reader, 3))
if blob is None or len(blob) == 0:
pass
else:
self.parse_media_attachments(blob, m)
except Exception as e:
print(e)
if m.content == '' or m.content is None:
continue
self.im.db_insert_table_message(m)
self.im.db_commit()
cmd.Dispose()
cmd.CommandText = '''
select cid, data, mid from channel_messages_v29
'''
reader = cmd.ExecuteReader()
while reader.Read():
m = model_im.Message()
m.talker_type = model_im.CHAT_TYPE_GROUP
m.account_id = self.account
m.talker_id = GetInt64(reader, 0)
bts = GetBlob(reader, 1)
m.msg_id = GetInt64(reader, 2)
decoder = TeleBlobDecoder(bts)
decoder.decode_int_for_ckey('i')
decoder.decode_bytes_for_ckey('sk', 17)
decoder.decode_int_for_ckey('pts')
decoder.decode_int_for_ckey('unr')
decoder.decode_int_for_ckey('out')
decoder.decode_int_for_ckey('ds')
m.sender_id = decoder.decode_long_for_ckey('fi')
to_id = decoder.decode_long_for_ckey('ti')
cid = decoder.decode_long_for_ckey('ci')
m.content = decoder.decode_string_for_ckey('t')
m.send_time = decoder.decode_int_for_ckey('d')
medias = decoder.decode_data_for_ckey('md')
try:
if len(medias) == 0 or medias is None:
pass
else:
self.parse_media_attachments(medias, m)
except Exception as e:
print(e)
decoder.decode_int_for_ckey('rd')
decoder.decode_long_for_ckey('ri')
decoder.decode_int_for_ckey('lt')
decoder.decode_long_for_ckey('f')
decoder.decode_int_for_ckey('sqi')
decoder.decode_int_for_ckey('sqo')
if m.content is '' or m.content is None:
continue
self.im.db_insert_table_message(m)
self.im.db_commit()
return True
def get_groups(self):
if self.read_file_path():
conn = System.Data.SQLite.SQLiteConnection(
"Data Source = {0}; ReadOnly = True".format(
self.source_path.PathWithMountPoint))
else:
conn = System.Data.SQLite.SQLiteConnection(
"Data Source = {0}".format(self.dest_path))
try:
conn.Open()
cmd = System.Data.SQLite.SQLiteCommand(conn)
cmd.CommandText = '''
select key_remote_jid,count(jid) as count from chat_list left join group_participants
where chat_list.key_remote_jid = group_participants.gjid and subject is not null group by key_remote_jid
'''
reader = cmd.ExecuteReader()
dicts = {}
while reader.Read():
group_id = GetString(reader, 0)
group_count = GetInt64(reader, 1)
dicts[group_id] = group_count
cmd.Dispose()
cmd.CommandText = """
select key_remote_jid as group_id , subject as title, sort_timestamp as create_time, jid as member_id , admin from chat_list left join
group_participants where chat_list.key_remote_jid = group_participants.gjid and admin = 2
"""
reader = cmd.ExecuteReader()
while reader.Read():
if canceller.IsCancellationRequested:
return
chatroom = model_im.Chatroom()
chatroom.source = self.source_path.AbsolutePath
chatroom.account_id = self.account_id
chatroom.chatroom_id = GetString(reader, 0)
chatroom.name = GetString(reader, 1)
chatroom.create_time = int(str(GetInt64(reader, 2))[:-3])
create_person = GetString(reader, 0)[:13] + "@s.whatsapp.net"
chatroom.creator_id = create_person
if GetString(reader, 3):
chatroom.owner_id = GetString(reader, 3)
else:
chatroom.owner_id = self.account_id
chatroom.member_count = dicts.get(GetString(reader, 0))
chatroom.type = 1
try:
self.whatsapp.db_insert_table_chatroom(chatroom)
except Exception as e:
pass
cmd.Dispose()
# 找出创建失败的群
cmd.CommandText = '''
select key_remote_jid,sort_timestamp from chat_list where subject is null and last_read_message_table_id is null
'''
# chatroom_fail = model_im.Chatroom()
reader_fail = cmd.ExecuteReader()
while reader_fail.Read():
chatroom_fail = model_im.Chatroom()
chatroom_fail.source = self.source_path.AbsolutePath
chatroom_fail.chatroom_id = GetString(reader_fail, 0)
chatroom_fail.account_id = self.account_id
chatroom_fail.create_time = int(
str(GetInt64(reader_fail, 1))[:-3])
create_person_fail = GetString(reader_fail,
0)[:13] + "@s.whatsapp.net"
chatroom_fail.creator_id = create_person_fail
chatroom_fail.owner_id = create_person_fail
chatroom_fail.member_count = 1
chatroom_fail.type = 2 # 临时群
groups_id = GetString(reader_fail, 0)
start_index = groups_id.find("-")
end_index = groups_id.find("@")
name = groups_id[start_index + 1:end_index]
self.groups_dicts[groups_id] = name
chatroom_fail.name = name
try:
self.whatsapp.db_insert_table_chatroom(chatroom_fail)
except Exception as e:
pass
except Exception as e:
pass
if conn != None:
conn.Close()
self.whatsapp.db_commit()
def get_contacts(self):
dbPath = self.root.GetByPath(self.user_id + '/main.db')
db = SQLiteParser.Database.FromNode(dbPath)
if db is None:
return
if 'yixin_contact' in db.Tables:
ts = SQLiteParser.TableSignature('yixin_contact')
SQLiteParser.Tools.AddSignatureToTable(
ts, "uid", SQLiteParser.FieldType.Text,
SQLiteParser.FieldConstraints.NotNull)
for rec in db.ReadTableRecords(ts, self.extract_deleted):
_id = rec['uid'].Value
if _id in self.friends:
continue
friend = model_im.Friend()
friend.deleted = 0 if rec.Deleted == DeletedState.Intact else 1
friend.source = 'YiXin'
friend.account_id = self.user_id
friend.friend_id = _id
friend.nickname = rec['nickname'].Value
friend.photo = rec['photourl'].Value
friend.gender = 2 if rec['gender'].Value == 0 else 1
friend.signature = rec['signature'].Value
friend.email = rec['email'].Value
friend.address = rec['address'].Value
friend.type = model_im.FRIEND_TYPE_FRIEND
self.friends[_id] = friend
if 'buddylist' in db.Tables:
ts = SQLiteParser.TableSignature('buddylist')
SQLiteParser.Tools.AddSignatureToTable(
ts, "uid", SQLiteParser.FieldType.Text,
SQLiteParser.FieldConstraints.NotNull)
for rec in db.ReadTableRecords(ts, self.extract_deleted):
if friend.friend_id != rec['uid']:
continue
friend.remark = rec['alias'].Value
self.csm.db_insert_table_friend(friend)
if 'tinfo' in db.Tables:
ts = SQLiteParser.TableSignature('tinfo')
SQLiteParser.Tools.AddSignatureToTable(
ts, "tid", SQLiteParser.FieldType.Text,
SQLiteParser.FieldConstraints.NotNull)
for rec in db.ReadTableRecords(ts, self.extract_deleted):
_id = rec['tid'].Value
if _id in self.chatrooms:
continue
chatroom = model_im.Chatroom()
chatroom.deleted = 0 if rec.Deleted == DeletedState.Intact else 1
chatroom.source = 'YiXin'
chatroom.account_id = self.user_id
chatroom.chatroom_id = _id
chatroom.name = rec['defaultname'].Value
chatroom.creator_id = rec['creator'].Value
chatroom.photo = rec['photo'].Value
chatroom.member_count = rec['membercount'].Value
chatroom.type = model_im.CHATROOM_TYPE_NORMAL
self.chatrooms[_id] = chatroom
self.csm.db_insert_table_chatroom(chatroom)
if 'tuser' in db.Tables:
ts = SQLiteParser.TableSignature('tuser')
SQLiteParser.Tools.AddSignatureToTable(
ts, "tid", SQLiteParser.FieldType.Text,
SQLiteParser.FieldConstraints.NotNull)
for rec in db.ReadTableRecords(ts, self.extract_deleted):
room_id = rec['tid'].Value
if chatroom.chatroom_id != room_id:
continue
chatroom_member = model_im.ChatroomMember()
chatroom_member.deleted = 0 if rec.Deleted == DeletedState.Intact else 1
chatroom_member.source = 'YiXin'
chatroom_member.account_id = self.user_id
chatroom_member.chatroom_id = room_id
chatroom_member.member_id = rec['uid'].Value
friend = self.friends.get(chatroom_member.member_id)
if friend is not None:
chatroom_member.display_name = friend.nickname
chatroom_member.email = friend.email
chatroom_member.gender = friend.gender
chatroom_member.address = friend.address
chatroom_member.signature = friend.signature
chatroom_member.photo = friend.photo
self.csm.db_insert_table_chatroom_member(
chatroom_member)
if 'painfo' in db.Tables:
ts = SQLiteParser.TableSignature('painfo')
SQLiteParser.Tools.AddSignatureToTable(
ts, "uid", SQLiteParser.FieldType.Text,
SQLiteParser.FieldConstraints.NotNull)
for rec in db.ReadTableRecords(ts, self.extract_deleted):
_id = rec['uid'].Value
if _id in self.friends:
continue
friend = model_im.Friend()
friend.deleted = 0 if rec.Deleted == DeletedState.Intact else 1
friend.source = 'YiXin'
friend.account_id = self.user_id
friend.friend_id = _id
friend.nickname = rec['nickname'].Value
friend.photo = rec['photourl'].Value
friend.gender = rec['gender'].Value
friend.signature = rec['signature'].Value
friend.type = model_im.FRIEND_TYPE_FOLLOW
self.friends[friend.friend_id] = friend
self.csm.db_insert_table_friend(friend)
self.csm.db_commit()
def parse(self, account_id):
db_node = self.node.GetByPath('databases/momo_{}'.format(account_id))
if db_node is None:
return
conn = unity_c37r.create_connection_tentatively(db_node)
cmd = sql.SQLiteCommand(conn)
cmd.CommandText = '''
select NAME, SIGNATURE, PHONE_NUMBER, PHOTOS from user where MOMOID = {}
'''.format(account_id)
reader = cmd.ExecuteReader()
if reader.Read():
a = model_im.Account()
a.account_id = account_id
a.nickname = unity_c37r.c_sharp_get_string(reader, 0)
a.signature = unity_c37r.c_sharp_get_string(reader, 1)
a.photo = unity_c37r.c_sharp_get_string(reader, 3)
a.telephone = unity_c37r.c_sharp_get_string(reader, 2)
self.im.db_insert_table_account(a)
reader.Close()
cmd.CommandText = '''
select MOMOID, NAME, SIGNATURE, PHONE_NUMBER, PHOTOS from user where MOMOID != {}
'''.format(account_id)
reader = cmd.ExecuteReader()
while reader.Read():
f = model_im.Friend()
f.account_id = account_id
f.friend_id = unity_c37r.c_sharp_get_string(reader, 0)
f.nickname = unity_c37r.c_sharp_get_string(reader, 1)
f.signature = unity_c37r.c_sharp_get_string(reader, 2)
f.telephone = unity_c37r.c_sharp_get_string(reader, 3)
f.photo = unity_c37r.c_sharp_get_string(reader, 4)
f.type = model_im.FRIEND_TYPE_FRIEND
self.im.db_insert_table_friend(f)
self.f_dict[f.friend_id] = f
reader.Close()
self.im.db_commit()
cmd.CommandText = '''
select GID, NAME, CREATE_TIME, OWNER, SIGN, LOC_LAT, LOC_LNG, SITE_NAME, PHOTOS from 'group'
'''
reader = cmd.ExecuteReader()
grp_dict = dict()
while reader.Read():
grp = model_im.Chatroom()
grp.account_id = account_id
grp.chatroom_id = unity_c37r.c_sharp_get_string(reader, 0)
grp.name = unity_c37r.c_sharp_get_string(reader, 1)
grp.create_time = unity_c37r.c_sharp_try_get_time(reader, 2) / 1000
grp.owner_id = unity_c37r.c_sharp_get_string(reader, 3)
grp.description = unity_c37r.c_sharp_get_string(reader, 4)
grp.photo = unity_c37r.c_sharp_get_string(reader, 8)
self.im.db_insert_table_chatroom(grp)
grp_dict[grp.chatroom_id] = grp
self.im.db_commit()
reader.Close()
cmd.Dispose()
conn.Close()
chat_list = list()
db_node = self.node.GetByPath('databases/{}'.format(account_id))
if db_node is None:
pass
conn = unity_c37r.create_connection_tentatively(db_node)
cmd = sql.SQLiteCommand(conn)
cmd.CommandText = '''
select tbl_name from sqlite_master where tbl_name like 'Chat_%' and type = 'table'
'''
reader = cmd.ExecuteReader()
while reader.Read():
c = unity_c37r.c_sharp_get_string(reader, 0)
chat_list.append(c)
reader.Close()
idx = 0
chat_dict = dict()
while idx < len(chat_list):
v = chat_list[idx].split('_')[1]
v = processHexBytes(v)
v = processBytesAndString(v, "jarekTan")
#say hi 消息，之后再解析
if v.__contains__('momo'):
idx += 1
continue
v = v.split('_')[1]
chat_dict[v] = chat_list[idx]
idx += 1
for c in chat_dict:
tbl_name = chat_dict[c]
is_grp = grp_dict.__contains__(c) # 是否是GRP群组
if not is_grp:
cmd.CommandText = '''
select m_msgid, m_msginfo, m_time, m_receive, m_type from {}
'''.format(tbl_name)
else:
cmd.CommandText = '''
select m_msgid, m_msginfo, m_time, m_receive, m_type, m_remoteid from {}
'''.format(tbl_name)
reader = cmd.ExecuteReader()
while reader.Read():
m = model_im.Message()
m.account_id = account_id
m.msg_id = unity_c37r.c_sharp_get_string(reader, 0)
m.is_sender = 0 if unity_c37r.c_sharp_get_string(reader, 3) == '1' else 1
m.talker_id = c
tp = unity_c37r.c_sharp_get_long(reader, 4)
if not is_grp:
m.talker_name = self.f_dict[c].nickname
else:
m.talker_name = grp_dict[c].name
m.talker_type = model_im.CHAT_TYPE_FRIEND if not is_grp else model_im.CHAT_TYPE_GROUP
if m.is_sender:
m.sender_id = account_id
elif not is_grp:
m.sender_id = c
m.sender_name = m.talker_name
else: # 如果是群组
m.sender_id = unity_c37r.c_sharp_get_string(reader, 5)
m.send_time = int(unity_c37r.c_sharp_get_string(reader, 2))
content = unity_c37r.c_sharp_get_string(reader, 1)
js = json.loads(content)
#如果是群组
if is_grp:
m.sender_name = js.get('usertitle')
# 0 正常消息 5 撤回消息 7 入群通知
if tp == 0 or tp == 5 or tp == 7:
m.content = js.get('content')
m.type = model_im.MESSAGE_CONTENT_TYPE_TEXT
#暂时不知道怎么解析
elif tp == 1:
m.content = "暂不支持的内容"
m.type = model_im.MESSAGE_CONTENT_TYPE_TEXT
#???没内容
elif tp == 2:
m.content = "暂不支持的内容"
m.type = model_im.MESSAGE_CONTENT_TYPE_TEXT
#暂未分析
elif tp == 6:
m.content = "暂不支持的内容"
m.type = model_im.MESSAGE_CONTENT_TYPE_TEXT
#群成员的动态，没有feed连接，只有图片
#拆分成两条消息
elif tp == 20:
m.content = js.get('t17').get('title') + '\n' + js.get('t17').get('desc')
m.type = model_im.MESSAGE_CONTENT_TYPE_TEXT
self.im.db_insert_table_message(m)
m.media_path = js.get('t17').get('pic')
m.type = model_im.MESSAGE_CONTENT_TYPE_IMAGE
#分享
elif tp == 12:
m.content = js.get('content')
m.type = model_im.MESSAGE_CONTENT_TYPE_TEXT
else:
m.content = content
m.type = model_im.MESSAGE_CONTENT_TYPE_TEXT
self.im.db_insert_table_message(m)
reader.Close()
cmd.Dispose()
conn.Close()
self.im.db_commit()
self.parse_relation_recovery(self.node.GetByPath('databases/momo_{}'.format(account_id)), account_id)
self.parse_chat_recovery(self.node.GetByPath('databases/{}'.format(account_id)),account_id, chat_dict, self.f_dict, grp_dict)
self.parse_feed(account_id)
