Example #1
0
    def get_spcific_distance(self):
        models = []
        if self.root is None:
            return
        try:
            conn = SqliteByCSharp(self.root, self.cache)
            with conn as cmd:

                cmd.CommandText = """
                    select (samples.start_date+978336000) as "Start Date",(samples.end_date+978336000) as "End Date", samples.data_id,data_type,
                        quantity,original_quantity,unit_strings.unit_string,data_provenances.origin_product_type,data_provenances.origin_build,data_provenances.local_product_type,data_provenances.local_build 
                        from samples 
                            left outer join quantity_samples on samples.data_id = quantity_samples.data_id 
                            left outer join unit_strings on quantity_samples.original_unit = unit_strings.RowID 
                            left outer join objects on samples.data_id = objects.data_id 
                            left outer join data_provenances on objects.provenance = data_provenances.RowID 
                            where data_type = 8
                """
                reader = cmd.ExecuteReader()
                while reader.Read():
                    try:
                        cache_time = SqliteByCSharp.GetFloat(reader, 1)
                        distance = SqliteByCSharp.GetFloat(reader, 4)

                        spcific_distance = Health.System.DistanceRecord()
                        spcific_distance.Time = TimeStamp.FromUnixTime(
                            cache_time, False)
                        spcific_distance.Distance = float(distance)

                        models.append(spcific_distance)
                    except Exception as e:
                        print(e)
        except Exception as e:
            pass
        return models
    def get_groups_member(self, node, account_id):
        g_node = node.GetByPath("nim_cache.db")
        if g_node is None:
            return
        try:
            conn = SqliteByCSharp(g_node, self.cache)
            with conn as cmd:

                cmd.CommandText = '''
                    select tid, account, nick, join_time from tuser
                    '''
                reader = cmd.ExecuteReader()
                while reader.Read():
                    try:
                        chatroom_id = SqliteByCSharp.GetString(reader, 0)
                        memeber_id = SqliteByCSharp.GetString(reader, 1)
                        display_name = SqliteByCSharp.GetString(reader, 2)

                        member = model_im.ChatroomMember()
                        member.source = g_node.AbsolutePath
                        member.account_id = account_id
                        member.chatroom_id = chatroom_id
                        member.member_id = memeber_id
                        member.display_name = display_name

                        if member.account_id and member.chatroom_id and member.member_id:
                            self.bulletMessage.db_insert_table_chatroom_member(
                                member)
                    except Exception as e:
                        pass
        except Exception as e:
            pass
        self.bulletMessage.db_commit()
    def get_all_sendname(self, node):
        s_node = node.GetByPath("msg.db")
        if s_node is None:
            return
        try:
            conn = SqliteByCSharp(s_node, self.cache)
            with conn as cmd:

                cmd.CommandText = '''
                    select account, nick from sender_nick
                    '''
                reader = cmd.ExecuteReader()
                while reader.Read():
                    try:
                        self.all_send_nick_name[SqliteByCSharp.GetString(
                            reader, 0)] = SqliteByCSharp.GetString(reader, 1)
                    except Exception as e:
                        pass
        except Exception as e:
            pass
    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_friend(self, node, account_id):
        f_node = node.GetByPath("nim_cache.db")
        if f_node is None:
            return
        try:
            conn = SqliteByCSharp(f_node, self.cache)
            with conn as cmd:

                cmd.CommandText = '''
                    select uinfo.account,uinfo.name,uinfo.icon,uinfo.sign,uinfo.gender,uinfo.email,
                    uinfo.mobile from uinfo,friend where uinfo.account = friend.account
                    '''
                reader = cmd.ExecuteReader()
                while reader.Read():
                    try:
                        friend_id = SqliteByCSharp.GetString(reader, 0)
                        nickname = SqliteByCSharp.GetString(reader, 1)
                        avtar = SqliteByCSharp.GetString(reader, 2)
                        sign = SqliteByCSharp.GetString(reader, 3)
                        gender = SqliteByCSharp.GetInt64(reader, 4)
                        email = SqliteByCSharp.GetString(reader, 5)
                        phone = SqliteByCSharp.GetString(reader, 6)

                        self.friend_list[friend_id] = nickname

                        friend = model_im.Friend()
                        friend.source = f_node.AbsolutePath
                        friend.account_id = account_id
                        friend.friend_id = friend_id
                        friend.nickname = nickname
                        friend.photo = avtar
                        friend.telephone = phone
                        friend.signature = sign
                        friend.email = email
                        friend.type = model_im.FRIEND_TYPE_FRIEND

                        if friend.account_id and friend.friend_id:
                            self.bulletMessage.db_insert_table_friend(friend)
                    except Exception as e:
                        print(e)
        except Exception as e:
            print(e)
        self.bulletMessage.db_commit()
Example #6
0
    def get_fitness_record(self):
        models = []
        if self.root is None:
            return
        try:
            conn = SqliteByCSharp(self.root, self.cache)
            with conn as cmd:

                cmd.CommandText = """
                    select (energy_burned_goal_date+978336000) as "Energy Burned Goal Date", 
                        (cache_index+978336000) as "cache_index", 
                        energy_burned,energy_burned_goal,active_hours,active_hours_goal,brisk_minutes,brisk_minutes_goal,
                        steps,walk_distance from activity_caches
                """
                reader = cmd.ExecuteReader()
                while reader.Read():
                    try:
                        cache_time = SqliteByCSharp.GetFloat(reader, 1)
                        energy_burned = SqliteByCSharp.GetFloat(reader, 2)
                        # energy_burned_goal = SqliteByCSharp.GetFloat(reader, 3)
                        active_hours = SqliteByCSharp.GetFloat(reader, 4)
                        # active_hours_goal = SqliteByCSharp.GetFloat(reader, 5)
                        brisk_minutes = SqliteByCSharp.GetFloat(reader, 6)
                        # brisk_minutes_goal = SqliteByCSharp.GetFloat(reader, 7)
                        step = SqliteByCSharp.GetFloat(reader, 8)
                        walk_distance = SqliteByCSharp.GetFloat(reader, 9)

                        fitness_record = Health.System.FitnessRecord()
                        fitness_record.Activity = energy_burned
                        fitness_record.Workout = brisk_minutes
                        fitness_record.Standing = active_hours
                        fitness_record.StepNumber = step
                        fitness_record.Distance = walk_distance
                        fitness_record.Time = TimeStamp.FromUnixTime(
                            cache_time, False)

                        models.append(fitness_record)
                    except Exception as e:
                        print(e)
        except Exception as e:
            pass
        return models
    def get_account(self, node, account_id):
        a_node = node.GetByPath("nim_cache.db")
        if a_node is None:
            return
        try:
            conn = SqliteByCSharp(a_node, self.cache)
            with conn as cmd:

                cmd.CommandText = 'select account, name, icon, sign, gender, mobile from uinfo where account = {0}'.format(
                    account_id)
                reader = cmd.ExecuteReader()
                while reader.Read():
                    try:
                        a_id = SqliteByCSharp.GetString(reader, 0)
                        nickname = SqliteByCSharp.GetString(reader, 1)
                        avtar = SqliteByCSharp.GetString(reader, 2)
                        sign = SqliteByCSharp.GetString(reader, 3)
                        gender = SqliteByCSharp.GetInt64(reader, 4)
                        phone = SqliteByCSharp.GetString(reader, 5)

                        account = model_im.Account()
                        account.source = a_node.AbsolutePath
                        account.account_id = a_id
                        account.nickname = nickname
                        account.photo = avtar
                        account.gender = gender
                        account.signature = sign
                        account.telephone = phone

                        if account.account_id:
                            self.bulletMessage.db_insert_table_account(account)
                    except Exception as e:
                        pass
        except Exception as e:
            pass
        self.bulletMessage.db_commit()