core/webapi/Shared Recent.go

/*
File Username:  Shared Recent.go
Copyright:  2021 Peernet Foundation s.r.o.
Author:     Peter Kleissner
*/
package webapi

import (
    "fmt"
    "time"

    "github.com/PeernetOfficial/core"
    "github.com/PeernetOfficial/core/blockchain"
)

// queryRecentShared returns recently shared files on the network from random peers until the limit is reached.
func (api *WebapiInstance) queryRecentShared(backend *core.Backend, fileType int, limitPeer, offsetTotal, limitTotal uint64, nodeID []byte, nodeIDState bool) (files []blockchain.BlockRecordFile) {
    if limitPeer == 0 {
        limitPeer = 1
    }
    // Assign peer list as an empty array
    var peerList []*core.PeerInfo

    // check if the NodeID is provided or not
    if len(nodeID) == 0 && !nodeIDState {
        // Use the peer list to know about active peers. Random order!
        peerList = api.Backend.PeerlistGet()
    } else {
        // Get peer information based on the NodeID provided
        _, peer, err := api.Backend.FindNode(nodeID, time.Second*5)
        if err != nil {
            return
        }
        peerList = append(peerList, peer)
    }

    // Files from peers exceeding the limit. It is used if from all peers the total limit is not reached.
    var filesSeconday []blockchain.BlockRecordFile

    for _, peer := range peerList {
        if peer.BlockchainHeight == 0 {
            continue
        }

        var filesFromPeer uint64
        var Name string

        ProfileNameFound := false

        // First iteration of the entire blockchain to search for the profile
        // image and Username of the user
        for blockN1 := peer.BlockchainHeight - 1; blockN1 > 0; blockN1-- {
            blockDecoded, _, found, _ := backend.ReadBlock(peer.PublicKey, peer.BlockchainVersion, blockN1)
            if !found {
                continue
            }
            // Adding profile image and Username to the output
            for raw := range blockDecoded.Block.RecordsRaw {
                if blockDecoded.Block.RecordsRaw[raw].Type == blockchain.ProfileName && !ProfileNameFound {
                    Name = string(blockDecoded.Block.RecordsRaw[raw].Data[:])
                    ProfileNameFound = true
                }
            }
        }

        // decode blocks from top down
    blockLoop:
        for blockN := peer.BlockchainHeight - 1; blockN > 0; blockN-- {
            blockDecoded, _, found, _ := backend.ReadBlock(peer.PublicKey, peer.BlockchainVersion, blockN)

            if !found {
                continue
            }

            for _, record := range blockDecoded.RecordsDecoded {
                if file, ok := record.(blockchain.BlockRecordFile); ok && isFileTypeMatchBlock(&file, fileType) {
                    // add the tags 'Shared By Count' and 'Shared By GeoIP'
                    file.Tags = append(file.Tags, blockchain.TagFromNumber(blockchain.TagSharedByCount, 1))
                    if latitude, longitude, valid := api.Peer2GeoIP(peer); valid {
                        sharedByGeoIP := fmt.Sprintf("%.4f", latitude) + "," + fmt.Sprintf("%.4f", longitude)
                        file.Tags = append(file.Tags, blockchain.TagFromText(blockchain.TagSharedByGeoIP, sharedByGeoIP))
                    }

                    file.Username = Name

                    // found a new file! append.
                    if filesFromPeer < limitPeer {
                        filesFromPeer++

                        if offsetTotal > 0 {
                            offsetTotal--
                            continue
                        }

                        files = append(files, file)

                        if uint64(len(files)) >= limitTotal {
                            return
                        }
                    } else if uint64(len(filesSeconday)) < limitTotal-uint64(len(files)) {
                        filesSeconday = append(filesSeconday, file)
                    } else {
                        break blockLoop
                    }
                }
            }
        }
    }

    files = append(files, filesSeconday...)

    return
}

// isFileTypeMatchBlock checks if the file type matches. -1 = accept any. -2 = core.TypeBinary, core.TypeCompressed, core.TypeContainer, core.TypeExecutable.
func isFileTypeMatchBlock(file *blockchain.BlockRecordFile, fileType int) bool {
    if fileType == -1 {
        return true
    } else if fileType == -2 {
        return file.Type == core.TypeBinary || file.Type == core.TypeCompressed || file.Type == core.TypeContainer || file.Type == core.TypeExecutable
    }

    return file.Type == uint8(fileType)
}