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 analyze_account(self, mailPath, deleteFlag):
'''保存账户数据到中间数据库'''
self.db = SQLite.SQLiteConnection(
'Data Source = {}; ReadOnly = True'.format(mailPath))
self.db.Open()
self.db_cmd = SQLite.SQLiteCommand(self.db)
try:
if self.db is None:
return
self.db_cmd.CommandText = SQL_ASSOCIATE_TABLE_ACCOUNT
sr = self.db_cmd.ExecuteReader()
while (sr.Read()):
account = Account()
if canceller.IsCancellationRequested:
break
account.account_id = sr[0]
account.account_user = sr[1]
account.account_alias = sr[2]
account.account_email = sr[1]
account.source = self.node.AbsolutePath
account.deleted = deleteFlag
self.mm.db_insert_table_account(account)
self.mm.db_commit()
self.db_cmd.Dispose()
self.db.Close()
except Exception as e:
print(e)
def analyze_account(self):
'''保存账户数据到中间数据库'''
self.db = SQLite.SQLiteConnection('Data Source = {}'.format(
self.recoverDB))
self.db.Open()
self.db_cmd = SQLite.SQLiteCommand(self.db)
try:
if self.db is None:
return
self.db_cmd.CommandText = SQL_ASSOCIATE_TABLE_ACCOUNT
sr = self.db_cmd.ExecuteReader()
while (sr.Read()):
try:
account = Account()
if canceller.IsCancellationRequested:
break
account.account_id = self._db_reader_get_int_value(sr, 0)
account.account_user = self._db_reader_get_string_value(
sr, 1)
account.account_alias = self._db_reader_get_string_value(
sr, 2)
account.account_email = self._db_reader_get_string_value(
sr, 1)
account.account_passwd = self._db_reader_get_string_value(
sr, 3)
account.source = self.node.AbsolutePath
account.deleted = self._db_reader_get_int_value(sr, 4)
self.mm.db_insert_table_account(account)
except:
traceback.print_exc()
self.mm.db_commit()
self.db_cmd.Dispose()
self.db.Close()
except Exception as e:
print(e)
def read_deleted_records(self):
'''获取删除数据保存至删除数据库'''
self.create_deleted_db()
self.rdb = SQLite.SQLiteConnection('Data Source = {}'.format(
self.recoverDB))
self.rdb.Open()
self.rdb_cmd = SQLite.SQLiteCommand(self.rdb)
dbid = re.findall('\d+', os.path.basename(self.node.AbsolutePath))[0]
fs = self.node.FileSystem
nodes = fs.Search('buzz_' + dbid + '.db$')
for node in nodes:
self.fnode = node
break
self.rdb_trans = self.rdb.BeginTransaction()
self.read_deleted_table_account()
self.read_deleted_table_contact()
self.read_deleted_table_group_user_id()
self.read_deleted_table_group()
self.read_deleted_table_group_user()
self.read_deleted_table_message()
self.read_deleted_table_group_chat()
self.read_deleted_table_feed()
self.read_deleted_table_feed_comments()
self.rdb_trans.Commit()
self.rdb_cmd.Dispose()
self.rdb.Close()
def create_deleted_db(self):
'''创建恢复数据库'''
if os.path.exists(self.recoverDB):
os.remove(self.recoverDB)
self.db = SQLite.SQLiteConnection('Data Source = {}'.format(
self.recoverDB))
self.db.Open()
self.db_cmd = SQLite.SQLiteCommand(self.db)
if self.db_cmd is not None:
self.db_cmd.CommandText = SQL_CREATE_TABLE_RECOVER_MAILACCOUNT
self.db_cmd.ExecuteNonQuery()
self.db_cmd.CommandText = SQL_CREATE_TABLE_RECOVER_MAILATTACH
self.db_cmd.ExecuteNonQuery()
self.db_cmd.CommandText = SQL_CREATE_TABLE_RECOVER_MAILCONTACT
self.db_cmd.ExecuteNonQuery()
self.db_cmd.CommandText = SQL_CREATE_TABLE_RECOVER_MAILCONTACTGROUP
self.db_cmd.ExecuteNonQuery()
self.db_cmd.CommandText = SQL_CREATE_TABLE_RECOVER_MAILCONTACTITEM
self.db_cmd.ExecuteNonQuery()
self.db_cmd.CommandText = SQL_CREATE_TABLE_RECOVER_MAILCONTENT
self.db_cmd.ExecuteNonQuery()
self.db_cmd.CommandText = SQL_CREATE_TABLE_RECOVER_MAILFOLDER
self.db_cmd.ExecuteNonQuery()
self.db_cmd.CommandText = SQL_CREATE_TABLE_RECOVER_MAILINFO
self.db_cmd.ExecuteNonQuery()
self.db_cmd.Dispose()
self.db.Close()
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 analyze_logic_calendar(self):
try:
db_source = self.node.PathWithMountPoint
self.db = SQLite.SQLiteConnection(
'Data Source = {}'.format(db_source))
self.db.Open()
self.db_cmd = SQLite.SQLiteCommand(self.db)
if self.db is None:
return
self.db_cmd.CommandText = '''select distinct * from Calendar'''
sr = self.db_cmd.ExecuteReader()
while (sr.Read()):
calendar = Calendar()
if canceller.IsCancellationRequested:
break
try:
calendar.calendar_id = sr[0]
calendar.title = sr[1]
calendar.description = sr[3]
calendar.dtstart = sr[5]
calendar.dtend = sr[6]
calendar.rrule = self._extractData(sr[4], 'FREQ')
calendar.interval = self._extractData(sr[4], 'INTERVAL')
calendar.until = self._extractData(sr[4], 'UNTIL')
calendar.source = self.node.AbsolutePath
self.mc.db_insert_calendar(calendar)
except:
pass
self.mc.db_commit()
sr.Close()
self.db.Close()
except:
pass
def read_deleted_table_mailaccount(self):
self.db = SQLite.SQLiteConnection('Data Source = {}'.format(
self.recoverDB))
self.db.Open()
self.db_cmd = SQLite.SQLiteCommand(self.db)
try:
node = self.node
if node is None:
return
db = SQLiteParser.Database.FromNode(node, canceller)
if db is None:
return
ts = SQLiteParser.TableSignature('FM_Account_Setting')
for rec in db.ReadTableDeletedRecords(ts, False):
if canceller.IsCancellationRequested:
break
param = ()
param = param + (rec['id'].Value, )
param = param + (rec['name'].Value, )
param = param + (rec['nickname'].Value, )
self.db_insert_table(SQL_INSERT_TABLE_RECOVER_MAILACCOUNT,
param)
self.db_cmd.Dispose()
self.db.Close()
except Exception as e:
print(e)
def read_deleted_table_mailcontactgroup(self):
self.db = SQLite.SQLiteConnection('Data Source = {}'.format(
self.recoverDB))
self.db.Open()
self.db_cmd = SQLite.SQLiteCommand(self.db)
try:
node = self.node.Parent.GetByPath("/FMContact.db")
if node is None:
return
db = SQLiteParser.Database.FromNode(node, canceller)
if db is None:
return
ts = SQLiteParser.TableSignature('FMContactGroup')
for rec in db.ReadTableDeletedRecords(ts, False):
if canceller.IsCancellationRequested:
break
param = ()
param = param + (rec['groupid'].Value, )
param = param + (rec['name'].Value, )
self.db_insert_table(SQL_INSERT_TABLE_RECOVER_MAILCONTACTGROUP,
param)
self.db_cmd.Dispose()
self.db.Close()
except Exception as e:
print(e)
def create_deleted_db(self):
'''创建删除数据库'''
if os.path.exists(self.recoverDB):
os.remove(self.recoverDB)
db = SQLite.SQLiteConnection('Data Source = {}'.format(self.recoverDB))
db.Open()
db_cmd = SQLite.SQLiteCommand(db)
if db_cmd is not None:
db_cmd.CommandText = '''create table if not exists cfurl_cache_receiver_data
(entry_ID INTEGER, IsDataOnFS INTEGER, receiver_data BLOB, deleted INTEGER)'''
db_cmd.ExecuteNonQuery()
db_cmd.CommandText = '''create table if not exists DBTableName_UserRelation
(otheruid INTEGER, icon TEXT, relation INTEGER, nickname TEXT, myuid INTEGER, gender INTEGER, sign TEXT, deleted INTEGER)'''
db_cmd.ExecuteNonQuery()
db_cmd.CommandText = '''create table if not exists DBTableNmae_GroupMsg
(groupname TEXT, myuid INTEGER, groupicon TEXT, groupId INTEGER, deleted INTEGER)'''
db_cmd.ExecuteNonQuery()
db_cmd.CommandText = '''create table if not exists DBTableName_P2PMsg
(time INTEGER, otheruid INTEGER, msgid INTEGER, msgstate INTEGER, attachment TEXT, distance INTEGER, myuid INTEGER, content TEXT, msgtype INTEGER, deleted INTEGER)'''
db_cmd.ExecuteNonQuery()
db_cmd.CommandText = '''create table if not exists DBTableName_MySendDynamic
(address TEXT, userid INTEGER, sendTime INTEGER, nickname TEXT, icon TEXT, myuid INTEGER, likecount INTEGER, datetime INTEGER, reviewcount INTEGER, gender INTEGER, dynamicid INTEGER, sendPhotos BLOB, content TEXT, deleted INTEGER)'''
db_cmd.ExecuteNonQuery()
db_cmd.Dispose()
db.Close()
def parse_feed_comment(self, dbPath):
'''解析评论点赞数据'''
db = SQLite.SQLiteConnection(
'Data Source = {}; ReadOnly = True'.format(dbPath))
db.Open()
db_cmd = SQLite.SQLiteCommand(db)
fs = self.node.FileSystem
try:
if self.db is None:
return
db_cmd.CommandText = ''''''
sr = db_cmd.ExecuteReader()
while (sr.Read()):
try:
feed_like = model_im.FeedLike()
feed_comment = model_im.FeedComment()
if canceller.IsCancellationRequested:
break
pass
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 create_deleted_db(self):
'''创建删除数据库'''
if os.path.exists(self.recoverDB):
os.remove(self.recoverDB)
db = SQLite.SQLiteConnection('Data Source = {}'.format(self.recoverDB))
db.Open()
db_cmd = SQLite.SQLiteCommand(db)
if db_cmd is not None:
db_cmd.CommandText = '''create table if not exists participants_info
(_id INTEGER, display_name TEXT, number TEXT)'''
db_cmd.ExecuteNonQuery()
db_cmd.CommandText = '''create table if not exists phonebookcontact
(_id INTEGER, native_id INTEGER, display_name TEXT)'''
db_cmd.ExecuteNonQuery()
db_cmd.CommandText = '''create table if not exists phonebookdata
(contact_id INTEGER, data2 TEXT)'''
db_cmd.ExecuteNonQuery()
db_cmd.CommandText = '''create table if not exists conversations
(conversation_type INTEGER, _id INTEGER, date INTEGER, participant_id_1 INTEGER, participant_id_2 INTEGER, participant_id_3 INTEGER, participant_id_4 INTEGER, name TEXT)'''
db_cmd.ExecuteNonQuery()
db_cmd.CommandText = '''create table if not exists messages
(body TEXT, send_type INTEGER, extra_uri TEXT, _id INTEGER, msg_date INTEGER, participant_id INTEGER, conversation_type INTEGER, conversation_id INTEGER, extra_mime INTEGER, description TEXT, msg_info TEXT)'''
db_cmd.ExecuteNonQuery()
db_cmd.CommandText = '''create table if not exists messages_calls
(_id INTEGER, date INTEGER, duration INTEGER, type INTEGER, canonized_number TEXT)'''
db_cmd.ExecuteNonQuery()
db_cmd.Dispose()
db.Close()
def read_deleted_table_mailattach(self):
self.db = SQLite.SQLiteConnection('Data Source = {}'.format(
self.recoverDB))
self.db.Open()
self.db_cmd = SQLite.SQLiteCommand(self.db)
try:
node = self.node
if node is None:
return
db = SQLiteParser.Database.FromNode(node, canceller)
if db is None:
return
ts = SQLiteParser.TableSignature('FM_Mail_Attach')
for rec in db.ReadTableDeletedRecords(ts, False):
if canceller.IsCancellationRequested:
break
if IsDBNull(
rec['attachId'].Value) or rec['attachId'].Value == 0:
continue
param = ()
param = param + (rec['attachId'].Value, )
param = param + (rec['accountId'].Value, )
param = param + (rec['mailId'].Value, )
param = param + (rec['name'].Value, )
param = param + (rec['downloadSize'].Value, )
param = param + (rec['downloadUtc'].Value, )
self.db_insert_table(SQL_INSERT_TABLE_RECOVER_MAILATTACH,
param)
self.db_cmd.Dispose()
self.db.Close()
except Exception as e:
print(e)
def parse_call_record(self, dbPath, deleteFlag):
'''解析通话记录数据'''
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._id, a.date, a.duration, a.type, a.canonized_number, b.display_name
from messages_calls as a left join participants_info as b on a.canonized_number = b.number'''
sr = db_cmd.ExecuteReader()
while (sr.Read()):
try:
record = model_callrecord.Records()
if canceller.IsCancellationRequested:
break
record.date = self._get_timestamp(sr[1]) if not IsDBNull(sr[1]) else 0
record.deleted = deleteFlag
record.duration = self._db_reader_get_int_value(sr, 2)
record.id = self._db_reader_get_int_value(sr, 0)
record.name = self._db_reader_get_string_value(sr, 5)
record.phone_number = self._db_reader_get_string_value(sr, 4)
record.local_number = self.local_number
record.source = self.node.AbsolutePath
record.type = self._db_reader_get_int_value(sr, 3)
self.db_insert_table_call_records(record)
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 analyze_contact(self, contactPath, deleteFlag):
"""保存联系人数据到中间数据库"""
self.db = SQLite.SQLiteConnection(
'Data Source = {}; ReadOnly = True'.format(contactPath))
self.db.Open()
self.db_cmd = SQLite.SQLiteCommand(self.db)
try:
if self.db is None:
return
self.db_cmd.CommandText = SQL_ASSOCIATE_TABLE_CONTACT
sr = self.db_cmd.ExecuteReader()
while sr.Read():
contact = Contact()
if canceller.IsCancellationRequested:
break
contact.contact_id = sr[0]
contact.owner_account_id = sr[1]
contact.contact_user = sr[2]
contact.contact_email = sr[2]
contact.contact_alias = sr[3]
contact.contact_group = sr[4]
contact.contact_remark = sr[5]
contact.contact_phone = sr[6]
contact.source = self.node.AbsolutePath
contact.deleted = deleteFlag
self.mm.db_insert_table_contact(contact)
self.mm.db_commit()
self.db_cmd.Dispose()
self.db.Close()
except Exception as e:
print(e)
def db_create(self):
self.conn = sql.SQLiteConnection("DataSource = {}".format(self.cache))
self.conn.Open()
self.cmd = sql.SQLiteCommand(self.conn)
self.event = None
self.im.db_create(self.cache + '.im')
self.db_create_table()
self.db_begin_transaction()
def parse_chatroom_member(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)
fs = self.node.FileSystem
try:
if self.db is None:
return
db_cmd.CommandText = '''select distinct a._id, a.date, a.participant_id_1, b.number, b.display_name, a.participant_id_2, c.number, c.display_name,
a.participant_id_3, d.number, d.display_name, a.participant_id_4, e.number, e.display_name, a.name from conversations as a
left join participants_info as b on a.participant_id_1 = b._id left join participants_info as c on a.participant_id_2 = c._id
left join participants_info as d on a.participant_id_3 = d._id left join participants_info as e on a.participant_id_4 = e._id where conversation_type = 1'''
sr = db_cmd.ExecuteReader()
while (sr.Read()):
try:
if canceller.IsCancellationRequested:
break
tags = [2, 5, 8, 11]
for tag in tags:
if IsDBNull(sr[tag]) or sr[tag] == 0:
break
chatroom_member = model_im.ChatroomMember()
chatroom_member.account_id = self.account_id
chatroom_member.chatroom_id = self._db_reader_get_int_value(sr, 0)
chatroom_member.deleted = deleteFlag
chatroom_member.display_name = self._db_reader_get_string_value(sr, tag+2)
chatroom_member.member_id = self._db_reader_get_int_value(sr, tag)
chatroom_member.source = self.node.AbsolutePath
chatroom_member.telephone = self._db_reader_get_string_value(sr, tag+1)
self.db_insert_table_chatroom_member(chatroom_member)
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 get_models(self):
models = []
self.db = SQLite.SQLiteConnection('Data Source = {}'.format(self.db_cache))
self.db.Open()
self.db_cmd = SQLite.SQLiteCommand(self.db)
models.extend(self._get_model_media())
models.extend(self._get_model_thumbnail())
models.extend(self._get_model_media_log())
self.db.Close()
self.db = None
return models
def create_connection_tentatively(db_node, read_only=True):
cmd = 'DataSource = {}; ReadOnly = {}'
cmd = cmd.format(db_node.PathWithMountPoint,
'True' if read_only else 'False')
try:
conn = None
dcmd = None
reader = None
conn = sql.SQLiteConnection(cmd)
conn.Open()
dcmd = sql.SQLiteCommand(conn)
dcmd.CommandText = '''
select * from sqlite_master limit 1 offset 0
'''
reader = dcmd.ExecuteReader()
reader.Read()
reader.Close()
dcmd.Dispose()
return conn
except:
traceback.print_exc()
if reader is not None:
reader.Close()
if dcmd is not None:
dcmd.Dispose()
if conn is not None:
conn.Close()
data = db_node.Data
sz = db_node.Size
cache = ds.OpenCachePath('C37R')
if not os.path.exists(cache):
os.mkdir(cache)
cache_db = cache + '/' + md5(db_node.PathWithMountPoint)
f = open(cache_db, 'wb+')
f.write(data.read(sz))
f.close()
cmd = 'DataSource = {}; ReadOnly = {}'.format(
cache_db, 'True' if read_only else 'False')
conn = sql.SQLiteConnection(cmd)
conn.Open()
return conn
def db_create(self, db_path):
try:
if os.path.exists(db_path):
os.remove(db_path)
except Exception as e:
print("bcp_mail db_create() remove %s error:%s" % (db_path, e))
self.db = SQLite.SQLiteConnection('Data Source = {}'.format(db_path))
self.db.Open()
self.db_cmd = SQLite.SQLiteCommand(self.db)
self.db_trans = self.db.BeginTransaction()
self.db_create_table()
self.db_commit()
def analyze_deleted_data(self):
'''分析删除数据'''
self.read_deleted_records()
self.db = SQLite.SQLiteConnection('Data Source = {}'.format(self.cachedb))
self.db.Open()
self.db_cmd = SQLite.SQLiteCommand(self.db)
if self.recoverDB is not None:
self.parse_friend(self.node, self.recoverDB, 1)
self.parse_chatroom(self.recoverDB, 1)
self.parse_chatroom_member(self.recoverDB, 1)
self.parse_call_record(self.recoverDB, 1)
self.parse_message(self.recoverDB, 1)
def get_models(self):
models = []
self.db = SQLite.SQLiteConnection('Data Source = {}'.format(self.cache_db))
self.db.Open()
self.db_cmd = SQLite.SQLiteCommand(self.db)
models.extend(self._get_charge_models())
models.extend(self._get_blacklist_models())
models.extend(self._get_blockedsms_models())
models.extend(self._get_callrecord_models())
models.extend(self._get_wifi_signal_models())
self.db.Close()
return models
def parse_feed_comment(self, dbPath):
'''解析评论点赞数据'''
db = SQLite.SQLiteConnection(
'Data Source = {}; ReadOnly = True'.format(dbPath))
db.Open()
db_cmd = SQLite.SQLiteCommand(db)
try:
if self.db is None:
return
db_cmd.CommandText = '''select action, comment, commend_id, item_id, timestamp, user_id, deleted from bb_dl_comment_info'''
sr = db_cmd.ExecuteReader()
while (sr.Read()):
try:
feed_like = model_im.FeedLike()
feed_comment = model_im.FeedComment()
if canceller.IsCancellationRequested:
break
if sr[0] == 'like':
feed_like.like_id = self._db_reader_get_int_value(
sr, 2)
feed_like.sender_id = self._db_reader_get_int_value(
sr, 5)
feed_like.sender_name = 'BeeTalkUser'
feed_like.create_time = self._db_reader_get_int_value(
sr, 4)
feed_like.deleted = self._db_reader_get_int_value(
sr, 6)
feed_like.source = self.node.AbsolutePath
self.db_insert_table_feed_like(feed_like)
elif not IsDBNull(sr[4]):
feed_comment.comment_id = self._db_reader_get_int_value(
sr, 2)
feed_comment.sender_id = self._db_reader_get_int_value(
sr, 5)
feed_comment.sender_name = 'BeeTalkUser'
feed_comment.content = self._db_reader_get_string_value(
sr, 1)
feed_comment.create_time = self._db_reader_get_int_value(
sr, 4)
feed_comment.deleted = self._db_reader_get_int_value(
sr, 6)
feed_comment.source = self.node.AbsolutePath
self.db_insert_table_feed_comment(feed_comment)
except:
traceback.print_exc()
sr.Close()
self.db_commit()
db_cmd.Dispose()
db.Close()
except Exception as e:
print(e)