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, 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 _generate_contact(self): try: self.db_cmd = SQLite.SQLiteCommand(self.db) if self.db_cmd is None: return self.db_cmd.CommandText = '''select distinct b.account_user, a.contact_user,a.contact_alias, a.contact_group, a.contact_remark, a.contact_phone, a.contact_birthday, a.contact_profession, a.contact_addr, a.contact_head_pic, a.contact_reg_date, a.contact_last_login, a.contact_last_modify, a.deleted from contact as a left join account as b on a.owner_account_id = b.account_id''' sr = self.db_cmd.ExecuteReader() while (sr.Read()): if canceller.IsCancellationRequested: break contact = Contact() contact.COLLECT_TARGET_ID = self.collect_target_id contact.MAIL_TOOL_TYPE = self.mail_tool_type contact.ACCOUNT = sr[0] contact.FRIEND_ACCOUNT = sr[1] contact.FRIEND_NICKNAME = sr[2] contact.FRIEND_GROUP = sr[3] contact.FRIEND_REMARK = sr[4] contact.FIXED_PHONE = sr[5] contact.BIRTHDAY = sr[6] contact.OCCUPATION_NAME = sr[7] contact.POSTAL_ADDRESS = sr[8] contact.USER_PHOTO = sr[9] contact.ACCOUNT_REG_DATE = sr[10] contact.LAST_LOGIN_TIME = sr[11] contact.LATEST_MOD_TIME = sr[12] contact.DELETE_STATUS = sr[13] self.mail.db_insert_table_contact(contact) self.mail.db_commit() except Exception as e: print(e)
def __prepare_contact(self): im_conn = unity_c37r.create_connection(self.cache + '.IM') cmd = sql.SQLiteCommand(im_conn) cmd.CommandText = ''' select account_id, nickname, photo from account ''' reader = cmd.ExecuteReader() while reader.Read(): o = O() o.uid = unity_c37r.c_sharp_get_string(reader, 0) o.nick = unity_c37r.c_sharp_get_string(reader, 1) o.photo = unity_c37r.c_sharp_get_string(reader, 2) self.contact[o.uid] = o reader.Close() #cmd.Dispose() cmd.CommandText = ''' select friend_id, nickname, photo from friend ''' reader = cmd.ExecuteReader() while reader.Read(): o = O() o.uid = unity_c37r.c_sharp_get_string(reader, 0) o.nick = unity_c37r.c_sharp_get_string(reader, 1) o.photo = unity_c37r.c_sharp_get_string(reader, 2) if self.contact.__contains__(o.uid): continue self.contact[o.uid] = o reader.Close() cmd.Dispose() im_conn.Close()
def generate_deal_bcp(self): conn = unity_c37r.create_connection(self.cache_db + '.IM') cmds = sql.SQLiteCommand(conn) cmds.CommandText = ''' select * from deal ''' reader = cmds.ExecuteReader() res = dict() while reader.Read(): deal = DealInfo() deal.set_value_with_idx(deal.colltection_target_id, self.colltection_target_id) deal.set_value_with_idx(deal.app_code, self.app_code) deal.set_value_with_idx(deal.deal_id, unity_c37r.c_sharp_get_string(reader, 0)) try: deal.set_value_with_idx(deal.money, unity_c37r.c_sharp_get_real(reader, 2)) except: deal.set_value_with_idx(deal.money, 0) deal.set_value_with_idx(deal.description, unity_c37r.c_sharp_get_string(reader, 3)) t = unity_c37r.c_sharp_get_long(reader, 6) if t != 0: deal.set_value_with_idx(deal.time, t) pass unity_c37r.execute_query(self.cmd, TBL_BCP_INSERT_DEAL, deal.get_values()) # status... not supported right now # type ... not suppoted right now reader.Close() cmds.Dispose() conn.Close()
def _generate_call_record(self): try: self.db_cmd = SQLite.SQLiteCommand(self.db) if self.db_cmd is None: return self.db_cmd.CommandText = '''select distinct * from records''' sr = self.db_cmd.ExecuteReader() while (sr.Read()): if canceller.IsCancellationRequested: break record = CallRecords() record.COLLECT_TARGET_ID = self.collect_target_id record.RELATIONSHIP_ACCOUNT = sr[1] record.RELATIONSHIP_NAME = sr[5] record.CALL_STATUS = CALL_STATUS_CONNECTD if sr[ 4] is 1 else CALL_STATUS_MISSED if sr[ 4] is 3 else CALL_STATUS_OTHER record.LOCAL_ACTION = LOCAL_ACTION_RECEIVE if sr[4] is 1 or sr[ 4] is 3 else LOCAL_ACTION_SEND if sr[ 4] is 2 else LOCAL_ACTION_OTHER record.START_TIME = sr[2] record.DUAL_TIME = sr[3] record.DELETE_STATUS = DELETE_STATUS_DELETED if sr[ 12] == 1 else DELETE_STATUS_INTACT self.basic.db_insert_table_call_record(record) self.basic.db_commit() self.db_cmd.Dispose() except Exception as e: pass
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) 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 CheckVersion(db_name, v_key, v_value): try: if not os.path.exists(db_name): return False conn = None cmd = None reader = None res = False conn = create_connection(db_name) cmd = sql.SQLiteCommand(conn) cmd.CommandText = ''' select v_val from tb_version where v_key = '{}' '''.format(v_key) reader = cmd.ExecuteReader() if reader.Read(): value = c_sharp_get_long(reader, 0) if value == v_value: res = True else: res = False reader.Close() cmd.Dispose() conn.Close() return res except: if reader is not None: reader.Close() if cmd is not None: cmd.Dispose() if conn is not None: conn.Close() return False
def _get_media_thumbnail(self, media_id): try: db_cmd = SQLite.SQLiteCommand(self.db) db_cmd.CommandText = '''select distinct * from thumbnails where media_id = {}'''.format(media_id) sr = db_cmd.ExecuteReader() while(sr.Read()): try: if canceller.IsCancellationRequested: break thumbnail = MediaFile.ThumbnailFile() filePath = self._db_reader_get_string_value(sr, 1) thumbnail.FileName = os.path.basename(filePath) thumbnail.Path = filePath thumbnail.Height = self._db_reader_get_int_value(sr, 4) thumbnail.Width = self._db_reader_get_int_value(sr, 3) addTime = self._db_reader_get_int_value(sr, 5) thumbnail.AddTime = self._get_timestamp(addTime) thumbnail.FileSuffix = self._db_reader_get_string_value(sr, 6) thumbnail.MimeType = self._db_reader_get_string_value(sr, 6) thumbnail.SourceFile = self._get_source_file(str(sr[7])) thumbnail.Deleted = self._convert_deleted_status(sr[8]) return thumbnail except: traceback.print_exc() except: pass
def _get_media_log(self, media_id): model = [] try: db_cmd = SQLite.SQLiteCommand(self.db) db_cmd.CommandText = '''select distinct * from media_log where media_id = {}'''.format(media_id) sr = db_cmd.ExecuteReader() while(sr.Read()): try: if canceller.IsCancellationRequested: break add_date = self.transtime(sr, 2) adj_date = self.transtime(sr, 3) cloudshare_date = self.transtime(sr, 4) create_date = self.transtime(sr, 5) faceadj_date = self.transtime(sr, 6) lastshare_date = self.transtime(sr, 7) modify_date = self.transtime(sr, 8) taken_date = self.transtime(sr, 9) trash_date = self.transtime(sr, 10) dates = {add_date:"添加", adj_date:"调整", cloudshare_date:"icloud分享", create_date:"创建", faceadj_date:"面部调整", lastshare_date:"分享", modify_date:"修改", taken_date:"拍摄", trash_date:"删除"} for date in sorted(dates.items(), key = lambda x:x[0], reverse=True): if date[0] is None: continue log = MediaFile.MediaLog() #log.FilePath = self._db_reader_get_string_value(sr, 14) log.Operating = date[1] log.OperatingTime = str(date[0]) model.append(log) except: pass except: return [] return model
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 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_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 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 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 try_get_avfs_message_dict(self): avfs_dir_node = self.node.GetByPath('Documents/AVFSStorage') if avfs_dir_node is None: return avfs_path = avfs_dir_node.PathWithMountPoint pl = os.listdir(avfs_path) for f in pl: avfs_sqlite_node = self.node.GetByPath( 'Documents/AVFSStorage/{}/avfs.sqlite'.format(f)) if avfs_sqlite_node is None: continue conn = unity_c37r.create_connection_tentatively(avfs_sqlite_node) cmd = sql.SQLiteCommand(conn) cmd.CommandText = ''' select tbl_name from sqlite_master where tbl_name = 'MPMProfileim_cc' and type = 'table' ''' reader = cmd.ExecuteReader() if not reader.Read(): reader.Close() cmd.Dispose() conn.Close() continue reader.Close() cmd.CommandText = ''' select targetId from MPMProfileim_cc where name is not null ''' reader = cmd.ExecuteReader() if reader.Read(): uid = unity_c37r.c_sharp_get_string(reader, 0) self.avfs_message_dict[uid] = avfs_sqlite_node reader.Close() cmd.Dispose() conn.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 prepare_message_dict(self): db_node = self.node.GetByPath('Library/Caches/YWDB') if db_node is None: return p_l = os.listdir(db_node.PathWithMountPoint) db_dirs = list() for p in p_l: res = re.search('WXOPENIMSDKDB(.*)', p, re.I | re.M) if res is not None: db_dirs.append(p) for d in db_dirs: message_node = self.node.GetByPath( 'Library/Caches/YWDB/%s/message.db' % d) if message_node is not None: path = unity_c37r.check_sqlite_maturity( message_node, self.cache) conn = unity_c37r.create_connection(path) cmd = sql.SQLiteCommand(conn) cmd.CommandText = ''' select ZUSER_ID from ZUSERINFO ''' reader = cmd.ExecuteReader() if reader.Read(): tb_id = unity_c37r.c_sharp_get_blob(reader, 0).decode( 'utf-8') #cntaobaotb5057305_11 tb_id = re.search('cntaobao(.*)', tb_id, re.I | re.M).group(1) self.message_dict[ tb_id] = unity_c37r.check_sqlite_maturity( message_node, self.cache) cmd.Dispose() conn.Close()
def _generate_calendar_info(self): try: self.db_cmd = SQLite.SQLiteCommand(self.db) if self.db_cmd is None: return self.db_cmd.CommandText = '''select distinct * from calendar''' sr = self.db_cmd.ExecuteReader() while (sr.Read()): if canceller.IsCancellationRequested: break calendar = CalendarInfo() calendar.COLLECT_TARGET_ID = self.collect_target_id if not IsDBNull(sr[1]): calendar.TITLE = sr[1] if not IsDBNull(sr[5]): calendar.START_TIME = self._get_timestamp(int(sr[5])) if not IsDBNull(sr[7]): calendar.END_TIME = self._get_timestamp(int(sr[7])) if not IsDBNull(sr[3]): calendar.DESCRIPTION = sr[3] if not IsDBNull(sr[12]): calendar.DELETE_STATUS = DELETE_STATUS_DELETED if sr[ 12] == 1 else DELETE_STATUS_INTACT self.basic.db_insert_table_calendar_info(calendar) self.basic.db_commit() self.db_cmd.Dispose() except Exception as e: pass
def parse_search(self, ac): db_node = self.node.GetByPath('Library/edge_compute.db') if db_node is None: return path = unity_c37r.check_sqlite_maturity(db_node, self.cache) conn = unity_c37r.create_connection(path) cmd = sql.SQLiteCommand(conn) cmd.CommandText = ''' select args,create_time from usertrack where owner_id = {} and page_name = 'Page_SearchItemList' '''.format(ac.uid) reader = cmd.ExecuteReader() while reader.Read(): if canceller.IsCancellationRequested: cmd.Dispose() conn.Close() self.im.db_close() raise IOError('E') s = model_im.Search() s.account_id = ac.uid m_str = unity_c37r.c_sharp_get_string(reader, 0) try: #s.key = re.search('keyword=(.*?),', m_str, re.I | re.M).group(1) match = re.search('keyword=(.*?),', m_str, re.I | re.M) if match is None: continue s.key = match.group(1) except: self.log.m_err('error string:{}'.format(m_str)) continue s.create_time = unity_c37r.c_sharp_get_long(reader, 1) / 1000 self.im.db_insert_table_search(s) self.im.db_commit() cmd.Dispose() conn.Close()
def generate_product_bcp(self): conn = unity_c37r.create_connection(self.cache_db) cmds = sql.SQLiteCommand(conn) cmds.CommandText = ''' select * from tb_product ''' reader = cmds.ExecuteReader() while reader.Read(): pdt = ProductInfo() pdt.set_value_with_idx(pdt.app_code, self.app_code) pdt.set_value_with_idx(pdt.colltection_target_id, self.colltection_target_id) pdt.set_value_with_idx(pdt.account_id, unity_c37r.c_sharp_get_string(reader, 0)) tp = unity_c37r.c_sharp_get_string(reader, 1) pdt.set_value_with_idx(pdt.source, '0%s' %tp) pdt.set_value_with_idx(pdt.product_id, unity_c37r.c_sharp_get_string(reader, 2)) pdt.set_value_with_idx(pdt.product_name, unity_c37r.c_sharp_get_string(reader, 3)) pdt.set_value_with_idx(pdt.price, unity_c37r.c_sharp_get_string(reader, 4)) t = unity_c37r.c_sharp_get_long(reader, 5) if t is not 0: pdt.set_value_with_idx(pdt.create_time, t) pdt.set_value_with_idx(pdt.description, unity_c37r.c_sharp_get_string(reader, 6)) pdt.set_value_with_idx(pdt.url, unity_c37r.c_sharp_get_string(reader, 7)) pdt.set_value_with_idx(pdt.shop_id, unity_c37r.c_sharp_get_string(reader, 8)) pdt.set_value_with_idx(pdt.delete_status, unity_c37r.c_sharp_get_long(reader, 9)) unity_c37r.execute_query(self.cmd, TBL_BCP_INSERT_PRODUCT, pdt.get_values()) reader.Close() cmds.Dispose() conn.Close()
def get_models(self): models = list() conn = unity_c37r.create_connection(self.cache_db, True) cmd = sql.SQLiteCommand(conn) cmd.CommandText = ''' select * from WA_MFORENSICS_120100 ''' reader = cmd.ExecuteReader() a = IMEAccount() while reader.Read(): am = Common.User() am.ID.Value = unity_c37r.c_sharp_get_string(reader, a.account) am.Name.Value = unity_c37r.c_sharp_get_string(reader, a.nick) photo = unity_c37r.c_sharp_get_string(reader, a.photo) photo = unity_c37r.get_c_sharp_uri(photo) am.PhotoUris.Add(photo) # reserved gender sex = unity_c37r.c_sharp_get_string(reader, a.gender_code) models.append(am) reader.Close() cmd.CommandText = ''' select * from WA_MFORENSICS_120200 ''' reader = cmd.ExecuteReader() b = IMEKeyword() while reader.Read(): kw = InputMethod.WordFrequency() kw.KeyWord.Value = unity_c37r.c_sharp_get_string( reader, b.key_word) kw.Count.Value = unity_c37r.c_sharp_get_long(reader, b.times) models.append(kw) reader.Close() cmd.Dispose() conn.Close() return models
def before_check(bcp_path, bcp_db): r_bcp_db = os.path.join(bcp_path, bcp_db) if not os.path.exists(r_bcp_db): return True try: conn = unity_c37r.create_connection(r_bcp_db) cmd = sql.SQLiteCommand(conn) cmd.CommandText = ''' select * from tb_version where vkey = '{}' '''.format(EB_VERSION_KEY) reader = cmd.ExecuteReader() if reader.Read(): value = unity_c37r.c_sharp_get_long(reader, 0) reader.Close() cmd.Dispose() conn.Close() if value != EB_VERSION_VALUE: return True else: return False else: reader.Close() cmd.Dispose() conn.Close() return True except: traceback.print_exc() reader.Close() cmd.Dispose() conn.Close() return False
def parse_sys_ver_1141(self): #if the sys ime does not contain zh.db if self.version & 0x1 == 0: return sql_node = self.node.GetByPath('DynamicPhraseLexicon_zh_Hans.db') db = unity_c37r.create_connection_tentatively(sql_node, True) cmd = sql.SQLiteCommand(db) cmd.CommandText = ''' select Reading, Surface, Seed from Words ''' reader = cmd.ExecuteReader() while reader.Read(): pharse = unity_c37r.c_sharp_get_blob(reader, 0) pharse = pharse.decode('utf_16_le', 'ignore') # => TODO:add pharse to sqlite bts = unity_c37r.c_sharp_get_blob(reader, 1) idx = 0 words = '' while idx < len(bts): m_string = r'\u%02x%02x' % (bts[idx + 1], bts[idx] ) # => note little ending try: m_string = m_string.decode('unicode_escape') except: idx += 2 continue words += m_string idx += 2 kw = IMEKeyword() kw.set_value_with_idx(kw.key_word, words) times = unity_c37r.c_sharp_get_long(reader, 2) kw.set_value_with_idx(kw.times, times) self.ime.db_insert_key(kw) self.ime.db_commit()
def _generate_attachment(self): try: self.db_cmd = SQLite.SQLiteCommand(self.db) if self.db_cmd is None: return self.db_cmd.CommandText = '''select distinct b.account_user, a.mail_id, a.attachment_name, a.attachment_save_dir, a.attachment_size, a.deleted from attachment as a left join account as b on a.owner_account_id = b.account_id''' sr = self.db_cmd.ExecuteReader() while (sr.Read()): if canceller.IsCancellationRequested: break attachment = Attachment() attachment.COLLECT_TARGET_ID = self.collect_target_id attachment.MAIL_TOOL_TYPE = self.mail_tool_type attachment.ACCOUNT = sr[0] attachment.SEQUENCE_NAME = sr[1] attachment.MATERIALS_NAME = sr[2] attachment.FILE_NAME = sr[3] attachment.FILE_SIZE = sr[4] attachment.DELETE_STATUS = sr[5] if not IsDBNull(sr[3]): self._copy_attachment(self.mountDir, sr[3]) print('拷贝成功') self.mail.db_insert_table_attachment(attachment) self.mail.db_commit() 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)