137 lines
4.0 KiB
TypeScript
137 lines
4.0 KiB
TypeScript
import { useState } from 'react'
|
|
import { Logger, DDO, ComputeJob } from '@oceanprotocol/squid'
|
|
import { useOcean } from '../../providers'
|
|
import {
|
|
SearchQuery,
|
|
Aquarius,
|
|
QueryResult
|
|
} from '@oceanprotocol/squid/dist/node/aquarius/Aquarius'
|
|
import { ComputeItem } from './ComputeItem'
|
|
|
|
// TODO searchText,
|
|
interface UseSearch {
|
|
searchWithQuery: (query: SearchQuery) => Promise<QueryResult>
|
|
getPublishedList: (page: number, offset: number) => Promise<QueryResult>
|
|
getConsumedList: () => Promise<DDO[] | undefined>
|
|
getComputeItems: () => Promise<ComputeItem[] | undefined>
|
|
searchError?: string
|
|
}
|
|
|
|
function useSearch(): UseSearch {
|
|
// should we call the useOcean hook in useSearch or in each function?
|
|
const { ocean, account, config, accountId } = useOcean()
|
|
const [searchError, setSearchError] = useState<string | undefined>()
|
|
|
|
async function searchWithQuery(query: SearchQuery): Promise<QueryResult> {
|
|
if (!ocean || !account) return
|
|
|
|
setSearchError(undefined)
|
|
|
|
try {
|
|
const aquarius = new Aquarius(config.aquariusUri as string, Logger)
|
|
return await aquarius.queryMetadata(query)
|
|
} catch (error) {
|
|
setSearchError(error.message)
|
|
}
|
|
}
|
|
|
|
async function getPublishedList(
|
|
page: number,
|
|
offset: number
|
|
): Promise<QueryResult> {
|
|
if (!ocean || !accountId) return
|
|
|
|
setSearchError(undefined)
|
|
|
|
try {
|
|
const query = {
|
|
page,
|
|
offset,
|
|
query: {
|
|
'publicKey.owner': [accountId]
|
|
},
|
|
sort: {
|
|
created: -1
|
|
}
|
|
} as SearchQuery
|
|
|
|
return await searchWithQuery(query)
|
|
} catch (error) {
|
|
setSearchError(error.message)
|
|
}
|
|
}
|
|
|
|
async function getConsumedList(): Promise<DDO[] | undefined> {
|
|
const consumed = await ocean.assets.consumerAssets(accountId)
|
|
const consumedItems = await Promise.all(
|
|
consumed.map(async (did) => {
|
|
try {
|
|
const ddo = await ocean.assets.resolve(did)
|
|
if (ddo) {
|
|
// Since we are getting assets from chain there might be
|
|
// assets from other marketplaces. So return only those assets
|
|
// whose serviceEndpoint contains the configured Aquarius URI.
|
|
const { serviceEndpoint } = ddo.findServiceByType('metadata')
|
|
if (serviceEndpoint?.includes(config.aquariusUri)) return ddo
|
|
}
|
|
} catch (err) {
|
|
Logger.error(err)
|
|
}
|
|
})
|
|
)
|
|
const filteredConsumedItems = consumedItems.filter(
|
|
(value) => typeof value !== 'undefined'
|
|
)
|
|
return filteredConsumedItems
|
|
}
|
|
|
|
async function getComputeItems(): Promise<ComputeItem[] | undefined> {
|
|
if (!ocean || !account) return
|
|
const jobList = await ocean.compute.status(account)
|
|
const computeItems = await Promise.all(
|
|
jobList.map(async (job) => {
|
|
if (!job) return
|
|
try {
|
|
const { did } = await ocean.keeper.agreementStoreManager.getAgreement(
|
|
job.agreementId
|
|
)
|
|
if (
|
|
did ===
|
|
'0x0000000000000000000000000000000000000000000000000000000000000000'
|
|
)
|
|
return
|
|
|
|
const ddo = await ocean.assets.resolve(did)
|
|
|
|
if (ddo) {
|
|
// Since we are getting assets from chain there might be
|
|
// assets from other marketplaces. So return only those assets
|
|
// whose serviceEndpoint contains the configured Aquarius URI.
|
|
const { serviceEndpoint } = ddo.findServiceByType('metadata')
|
|
if (serviceEndpoint?.includes(config.aquariusUri)) {
|
|
return { job, ddo }
|
|
}
|
|
}
|
|
} catch (err) {
|
|
Logger.error(err)
|
|
}
|
|
})
|
|
)
|
|
const filteredComputeItems = computeItems.filter(
|
|
(value) => value !== undefined && typeof value.ddo !== 'undefined'
|
|
)
|
|
return filteredComputeItems
|
|
}
|
|
|
|
return {
|
|
searchWithQuery,
|
|
getPublishedList,
|
|
getConsumedList,
|
|
getComputeItems,
|
|
searchError
|
|
}
|
|
}
|
|
|
|
export { useSearch, UseSearch }
|
|
export default useSearch
|