Merge remote-tracking branch 'origin/feature/search' into feature/secret_store

# Conflicts:
#	src/models/Config.ts
#	src/ocean/Ocean.ts
#	test/config.ts
#	test/keeper/ContractBase.test.ts
#	test/keeper/ContractHandler.test.ts
#	test/keeper/Keeper.test.ts
#	test/ocean/Account.test.ts
#	test/ocean/Asset.test.ts
#	test/ocean/Ocean.test.ts
#	test/ocean/Order.test.ts

package-lock.json

@@ -1,6 +1,6 @@
 {
   "name": "@oceanprotocol/squid",
-  "version": "0.1.0-beta.16",
+  "version": "0.1.0-beta.17",
   "lockfileVersion": 1,
   "requires": true,
   "dependencies": {

package.json

@@ -1,6 +1,6 @@
 {
   "name": "@oceanprotocol/squid",
-  "version": "0.1.0-beta.16",
+  "version": "0.1.0-beta.17",
   "description": "JavaScript client library for Ocean Protocol",
   "main": "dist/squid.js",
   "scripts": {

src/ConfigProvider.ts

@@ -2,11 +2,11 @@ import Config from "./models/Config"
 
 export default class ConfigProvider {
 
-    public static getConfig() {
+    public static getConfig(): Config {
         return ConfigProvider.config
     }
 
-    public static configure(config: Config) {
+    public static setConfig(config: Config) {
 
         ConfigProvider.config = config
     }

src/aquarius/Aquarius.ts

@@ -1,16 +1,21 @@
-import fetch from "node-fetch"
+import Config from "../models/Config"
 import Logger from "../utils/Logger"
+import AquariusConnectorProvider from "./AquariusConnectorProvider"
 
 export default class Aquarius {
-    public static async getAccessUrl(accessToken: any, payload: any): Promise<string> {
 
-        const accessUrl = await fetch(`${accessToken.service_endpoint}/${accessToken.resource_id}`, {
-            method: "POST",
-            body: payload,
-            headers: {
-                "Content-type": "application/json",
-            },
-        })
+    private url: string
+
+    constructor(config: Config) {
+
+        this.url = config.aquariusUri
+    }
+
+    public async getAccessUrl(accessToken: any, payload: any): Promise<string> {
+
+        const accessUrl = await AquariusConnectorProvider.getConnector().post(
+            `${accessToken.service_endpoint}/${accessToken.resource_id}`,
+            payload)
             .then((response: any) => {
                 if (response.ok) {
                     return response.text()
@@ -27,4 +32,22 @@ export default class Aquarius {
 
         return accessUrl
     }
+
+    public async queryMetadata(query): Promise<any[]> {
+
+        const result = await AquariusConnectorProvider.getConnector().post(
+            this.url + "/api/v1/aquarius/assets/metadata/query",
+            JSON.stringify(query))
+            .then((response: any) => {
+                if (response.ok) {
+                    return response.json()
+                }
+                Logger.log("Failed: ", response.status, response.statusText)
+            })
+            .catch((error) => {
+                Logger.error("Error fetching querying metdata: ", error)
+            })
+
+        return result
+    }
 }

src/aquarius/AquariusConnector.ts

@@ -0,0 +1,14 @@
+import fetch from "node-fetch"
+
+export default class AquariusConnector {
+
+    public post(url, payload) {
+        return fetch(url, {
+            method: "POST",
+            body: payload,
+            headers: {
+                "Content-type": "application/json",
+            },
+        })
+    }
+}

src/aquarius/AquariusConnectorProvider.ts

@@ -0,0 +1,23 @@
+import Logger from "../utils/Logger"
+import AquariusConnector from "./AquariusConnector"
+
+export default class AquariusConnectorProvider {
+
+    public static setConnector(connector: AquariusConnector) {
+
+        Logger.log("setting", typeof connector.constructor.name)
+
+        AquariusConnectorProvider.connector = connector
+    }
+
+    public static getConnector() {
+
+        if (!AquariusConnectorProvider.connector) {
+            AquariusConnectorProvider.connector = new AquariusConnector()
+        }
+        Logger.log("getting", typeof AquariusConnectorProvider.connector.constructor.name)
+        return AquariusConnectorProvider.connector
+    }
+
+    private static connector: AquariusConnector = null
+}

src/aquarius/AquariusProvider.ts

@@ -1,14 +1,20 @@
+import ConfigProvider from "../ConfigProvider"
+import Aquarius from "./Aquarius"
+
 export default class AquariusProvider {
 
-    public static setAquarius(aquarius) {
+    public static setAquarius(aquarius: Aquarius) {
 
         AquariusProvider.aquarius = aquarius
     }
 
     public static getAquarius() {
 
+        if (!AquariusProvider.aquarius) {
+            AquariusProvider.aquarius = new Aquarius(ConfigProvider.getConfig())
+        }
         return AquariusProvider.aquarius
     }
 
-    private static aquarius
+    private static aquarius: Aquarius = null
 }

src/ocean/Ocean.ts

@@ -1,4 +1,3 @@
-import Aquarius from "../aquarius/Aquarius"
 import AquariusProvider from "../aquarius/AquariusProvider"
 import ConfigProvider from "../ConfigProvider"
 import Keeper from "../keeper/Keeper"
@@ -15,7 +14,7 @@ export default class Ocean {
     public static async getInstance(config: Config) {
 
         if (!Ocean.instance) {
-            ConfigProvider.configure(config)
+            ConfigProvider.setConfig(config)
             SecretStoreProvider.configure(config)
             AquariusProvider.setAquarius(Aquarius)
             Ocean.instance = new Ocean(await Keeper.getInstance())
@@ -106,4 +105,8 @@ export default class Ocean {
 
         return orders
     }
+
+    public async searchAssets(query): Promise<any[]> {
+        return AquariusProvider.getAquarius().queryMetadata(query)
+    }
 }

test/aquarius/Aquarius.test.ts

@@ -0,0 +1,33 @@
+import * as assert from "assert"
+import Aquarius from "../../src/aquarius/Aquarius"
+import AquariusConnectorProvider from "../../src/aquarius/AquariusConnectorProvider"
+import config from "../config"
+import AquariusConnectorMock from "../mocks/AquariusConnector.mock"
+
+before(() => {
+    AquariusConnectorProvider.setConnector(new AquariusConnectorMock())
+})
+
+describe("Aquarius", () => {
+
+    describe("#queryMetadata()", async () => {
+
+        const aquarius: Aquarius = new Aquarius(config)
+
+        const query = {
+            offset: 100,
+            page: 0,
+            query: {
+                value: 1,
+            },
+            sort: {
+                value: 1,
+            },
+            text: "Office",
+        }
+
+        const result: any[] = await aquarius.queryMetadata(query)
+        assert(result)
+    })
+
+})

test/config.ts

@@ -1,10 +1,12 @@
 import Config from "../src/models/Config"
 
 export default {
+    aquariusUri: "http://localhost:5000",
     nodeUri: "http://localhost:8545",
     parityUri: "http://localhost:9545",
     secretStoreUri: "https://secret-store.dev-ocean.com",
     threshold: 2,
     password: "unittest",
     address: "0xed243adfb84a6626eba46178ccb567481c6e655d",
+    web3Provider: null,
 } as Config

test/keeper/ContractBase.test.ts

@@ -5,10 +5,10 @@ import ContractBaseMock from "../mocks/ContractBase.Mock"
 
 const wrappedContract = new ContractBaseMock("OceanToken")
 
-describe("ContractBase", () => {
+describe("ContractWrapperBase", () => {
 
     before(async () => {
-        ConfigProvider.configure(config)
+        ConfigProvider.setConfig(config)
         await ContractHandler.deployContracts()
         wrappedContract.initMock()
     })

test/keeper/ContractHandler.test.ts

@@ -6,7 +6,7 @@ import config from "../config"
 describe("ContractHandler", () => {
 
     before(async () => {
-        ConfigProvider.configure(config)
+        ConfigProvider.setConfig(config)
         await ContractHandler.deployContracts()
     })
 

test/keeper/Keeper.test.ts

@@ -9,7 +9,7 @@ let keeper: Keeper
 describe("Keeper", () => {
 
     before(async () => {
-        ConfigProvider.configure(config)
+        ConfigProvider.setConfig(config)
         await ContractHandler.deployContracts()
         keeper = await Keeper.getInstance()
     })

test/mocks/Aquarius.mock.ts

@@ -2,7 +2,7 @@ import Aquarius from "../../src/aquarius/Aquarius"
 
 export default class AquariusMock extends Aquarius {
 
-    public static async getAccessUrl(accessToken: any, payload: any): Promise<string> {
+    public async getAccessUrl(accessToken: any, payload: any): Promise<string> {
         return "http://test/test"
     }
 }

test/mocks/AquariusConnector.mock.ts

@@ -0,0 +1,17 @@
+import AquariusConnector from "../../src/aquarius/AquariusConnector"
+
+export default class AquariusConnectorMock extends AquariusConnector {
+
+    public async post(url: string, payload: any) {
+
+        return {
+            ok: true,
+            json: () => {
+                return []
+            },
+            text: () => {
+                return ""
+            },
+        }
+    }
+}

test/ocean/Account.test.ts

@@ -12,7 +12,7 @@ let accounts: Account[]
 describe("Account", () => {
 
     before(async () => {
-        ConfigProvider.configure(config)
+        ConfigProvider.setConfig(config)
         await ContractHandler.deployContracts()
         ocean = await Ocean.getInstance(config)
 

test/ocean/Asset.test.ts

@@ -19,11 +19,11 @@ let testAsset: Asset
 let accounts: Account[]
 let testPublisher: Account
 
-describe("#purchase()", () => {
+describe("Asset", () => {
 
     before(async () => {
-        ConfigProvider.configure(config)
-        AquariusProvider.setAquarius(AquariusMock)
+        ConfigProvider.setConfig(config)
+        AquariusProvider.setAquarius(new AquariusMock(config))
 
         await ContractHandler.deployContracts()
         ocean = await Ocean.getInstance(config)
@@ -34,6 +34,8 @@ describe("#purchase()", () => {
         await ocean.register(testAsset)
     })
 
+    describe("#purchase()", () => {
+
         it("should purchase an asset", async () => {
 
         // todo

test/ocean/Ocean.test.ts

@@ -1,4 +1,5 @@
 import {assert} from "chai"
+import AquariusProvider from "../../src/aquarius/AquariusProvider"
 import ConfigProvider from "../../src/ConfigProvider"
 import ContractHandler from "../../src/keeper/ContractHandler"
 import Account from "../../src/ocean/Account"
@@ -6,6 +7,7 @@ import Asset from "../../src/ocean/Asset"
 import Ocean from "../../src/ocean/Ocean"
 import Order from "../../src/ocean/Order"
 import config from "../config"
+import AquariusMock from "../mocks/Aquarius.mock"
 
 let ocean: Ocean
 let accounts: Account[]
@@ -20,7 +22,8 @@ const timeout = 100000000
 describe("Ocean", () => {
 
     before(async () => {
-        ConfigProvider.configure(config)
+        ConfigProvider.setConfig(config)
+        AquariusProvider.setAquarius(new AquariusMock(config))
         await ContractHandler.deployContracts()
         ocean = await Ocean.getInstance(config)
         accounts = await ocean.getAccounts()
@@ -84,4 +87,26 @@ describe("Ocean", () => {
 
     })
 
+    describe("#searchAssets()", () => {
+
+        it("should search for assets", async () => {
+
+            const query = {
+                offset: 100,
+                page: 0,
+                query: {
+                    value: 1,
+                },
+                sort: {
+                    value: 1,
+                },
+                text: "Office",
+            }
+
+            const assets: any[] = await ocean.searchAssets(query)
+
+            assert(assets)
+        })
+
+    })
 })

test/ocean/Order.test.ts

@@ -1,4 +1,5 @@
 import {assert} from "chai"
+import AquariusProvider from "../../src/aquarius/AquariusProvider"
 import ConfigProvider from "../../src/ConfigProvider"
 import ContractHandler from "../../src/keeper/ContractHandler"
 import AccessStatus from "../../src/models/AccessStatus"
@@ -7,6 +8,7 @@ import Asset from "../../src/ocean/Asset"
 import Ocean from "../../src/ocean/Ocean"
 import Order from "../../src/ocean/Order"
 import config from "../config"
+import AquariusMock from "../mocks/Aquarius.mock"
 import * as AccessToken from "./AccessToken.json"
 
 const testName = "Order Test Asset"
@@ -23,7 +25,8 @@ let testConsumer: Account
 describe("Order", () => {
 
     before(async () => {
-        ConfigProvider.configure(config)
+        ConfigProvider.setConfig(config)
+        AquariusProvider.setAquarius(new AquariusMock(config))
         await ContractHandler.deployContracts()
         ocean = await Ocean.getInstance(config)
         accounts = await ocean.getAccounts()