Added transaction filter param in accontHttp

rg911 · rg911 · commit 2808eb89a291 · 2020-02-18T21:34:00.000Z
diff --git a/e2e/infrastructure/AccountHttp.spec.ts b/e2e/infrastructure/AccountHttp.spec.ts
@@ -16,8 +16,10 @@
 
 import { expect } from 'chai';
 import { AccountRepository } from '../../src/infrastructure/AccountRepository';
+import { TransactionFilter } from '../../src/infrastructure/infrastructure';
 import { MultisigRepository } from '../../src/infrastructure/MultisigRepository';
 import { NamespaceRepository } from '../../src/infrastructure/NamespaceRepository';
+import { QueryParams } from '../../src/infrastructure/QueryParams';
 import { Account } from '../../src/model/account/Account';
 import { Address } from '../../src/model/account/Address';
 import { PublicAccount } from '../../src/model/account/PublicAccount';
@@ -35,7 +37,6 @@ import { TransactionType } from '../../src/model/transaction/TransactionType';
 import { TransferTransaction } from '../../src/model/transaction/TransferTransaction';
 import { UInt64 } from '../../src/model/UInt64';
 import { IntegrationTestHelper } from './IntegrationTestHelper';
-import { QueryParams } from '../../src/infrastructure/QueryParams';
 
 describe('AccountHttp', () => {
     const helper = new IntegrationTestHelper();
@@ -227,7 +228,7 @@ describe('AccountHttp', () => {
     describe('transactions', () => {
         it('should call transactions successfully by type', async () => {
             const transactions = await accountRepository.getAccountTransactions(
-                publicAccount.address, new QueryParams().setType([TransactionType.TRANSFER])).toPromise();
+                publicAccount.address, new QueryParams(), new TransactionFilter().setType([TransactionType.TRANSFER])).toPromise();
             expect(transactions.length).to.be.greaterThan(0);
             transactions.forEach((t) => {
                 expect(t.type).to.be.eq(TransactionType.TRANSFER);
diff --git a/src/infrastructure/AccountHttp.ts b/src/infrastructure/AccountHttp.ts
@@ -29,6 +29,7 @@ import { AccountRepository } from './AccountRepository';
 import { Http } from './Http';
 import { QueryParams } from './QueryParams';
 import { CreateTransactionFromDTO } from './transaction/CreateTransactionFromDTO';
+import { TransactionFilter } from './TransactionFilter';
 
 /**
  * Account http repository.
@@ -115,15 +116,18 @@ export class AccountHttp extends Http implements AccountRepository {
      * Gets an array of confirmed transactions for which an account is signer or receiver.
      * @param address - * Address can be created rawAddress or publicKey
      * @param queryParams - (Optional) Query params
+     * @param transactionFilter - (Optional) Transaction filter
      * @returns Observable<Transaction[]>
      */
-    public getAccountTransactions(address: Address, queryParams?: QueryParams): Observable<Transaction[]> {
+    public getAccountTransactions(address: Address,
+                                  queryParams?: QueryParams,
+                                  transactionFilter?: TransactionFilter): Observable<Transaction[]> {
         return observableFrom(
             this.accountRoutesApi.getAccountConfirmedTransactions(address.plain(),
                 this.queryParams(queryParams).pageSize,
                 this.queryParams(queryParams).id,
                 this.queryParams(queryParams).ordering,
-                this.queryParams(queryParams).type)).pipe(
+                this.transactionFilter(transactionFilter).type)).pipe(
                     map(({body}) => body.map((transactionDTO) => {
                             return CreateTransactionFromDTO(transactionDTO);
                         })),
@@ -136,15 +140,18 @@ export class AccountHttp extends Http implements AccountRepository {
      * A transaction is said to be incoming with respect to an account if the account is the recipient of a transaction.
      * @param address - * Address can be created rawAddress or publicKey
      * @param queryParams - (Optional) Query params
+     * @param transactionFilter - (Optional) Transaction filter
      * @returns Observable<Transaction[]>
      */
-    public getAccountIncomingTransactions(address: Address, queryParams?: QueryParams): Observable <Transaction[]> {
+    public getAccountIncomingTransactions(address: Address,
+                                          queryParams?: QueryParams,
+                                          transactionFilter?: TransactionFilter): Observable <Transaction[]> {
         return observableFrom(
             this.accountRoutesApi.getAccountIncomingTransactions(address.plain(),
                 this.queryParams(queryParams).pageSize,
                 this.queryParams(queryParams).id,
                 this.queryParams(queryParams).ordering),
-                this.queryParams(queryParams).type).pipe(
+                this.transactionFilter(transactionFilter).type).pipe(
                     map(({body}) => body.map((transactionDTO) => {
                             return CreateTransactionFromDTO(transactionDTO);
                         })),
@@ -157,15 +164,18 @@ export class AccountHttp extends Http implements AccountRepository {
      * A transaction is said to be outgoing with respect to an account if the account is the sender of a transaction.
      * @param address - * Address can be created rawAddress or publicKey
      * @param queryParams - (Optional) Query params
+     * @param transactionFilter - (Optional) Transaction filter
      * @returns Observable<Transaction[]>
      */
-    public getAccountOutgoingTransactions(address: Address, queryParams?: QueryParams): Observable <Transaction[]> {
+    public getAccountOutgoingTransactions(address: Address,
+                                          queryParams?: QueryParams,
+                                          transactionFilter?: TransactionFilter): Observable <Transaction[]> {
         return observableFrom(
             this.accountRoutesApi.getAccountOutgoingTransactions(address.plain(),
                 this.queryParams(queryParams).pageSize,
                 this.queryParams(queryParams).id,
                 this.queryParams(queryParams).ordering),
-                this.queryParams(queryParams).type).pipe(
+                this.transactionFilter(transactionFilter).type).pipe(
                     map(({body}) => body.map((transactionDTO) => {
                             return CreateTransactionFromDTO(transactionDTO);
                         })),
@@ -179,15 +189,18 @@ export class AccountHttp extends Http implements AccountRepository {
      * Unconfirmed transactions are not guaranteed to be included in any block.
      * @param address - * Address can be created rawAddress or publicKey
      * @param queryParams - (Optional) Query params
+     * @param transactionFilter - (Optional) Transaction filter
      * @returns Observable<Transaction[]>
      */
-    public getAccountUnconfirmedTransactions(address: Address, queryParams?: QueryParams): Observable <Transaction[]> {
+    public getAccountUnconfirmedTransactions(address: Address,
+                                             queryParams?: QueryParams,
+                                             transactionFilter?: TransactionFilter): Observable <Transaction[]> {
         return observableFrom(
             this.accountRoutesApi.getAccountUnconfirmedTransactions(address.plain(),
                 this.queryParams(queryParams).pageSize,
                 this.queryParams(queryParams).id,
                 this.queryParams(queryParams).ordering),
-                this.queryParams(queryParams).type).pipe(
+                this.transactionFilter(transactionFilter).type).pipe(
                     map(({body}) => body.map((transactionDTO) => {
                             return CreateTransactionFromDTO(transactionDTO);
                         })),
@@ -200,15 +213,18 @@ export class AccountHttp extends Http implements AccountRepository {
      * A transaction is said to be aggregate bonded with respect to an account if there are missing signatures.
      * @param address - * Address can be created rawAddress or publicKey
      * @param queryParams - (Optional) Query params
+     * @param transactionFilter - (Optional) Transaction filter
      * @returns Observable<AggregateTransaction[]>
      */
-    public getAccountPartialTransactions(address: Address, queryParams?: QueryParams): Observable <AggregateTransaction[]> {
+    public getAccountPartialTransactions(address: Address,
+                                         queryParams?: QueryParams,
+                                         transactionFilter?: TransactionFilter): Observable <AggregateTransaction[]> {
         return observableFrom(
             this.accountRoutesApi.getAccountPartialTransactions(address.plain(),
                 this.queryParams(queryParams).pageSize,
                 this.queryParams(queryParams).id,
                 this.queryParams(queryParams).ordering),
-                this.queryParams(queryParams).type).pipe(
+                this.transactionFilter(transactionFilter).type).pipe(
                     map(({body}) => body.map((transactionDTO) => {
                             return CreateTransactionFromDTO(transactionDTO) as AggregateTransaction;
                         })),
diff --git a/src/infrastructure/AccountRepository.ts b/src/infrastructure/AccountRepository.ts
@@ -20,6 +20,7 @@ import {Address} from '../model/account/Address';
 import {AggregateTransaction} from '../model/transaction/AggregateTransaction';
 import {Transaction} from '../model/transaction/Transaction';
 import { QueryParams } from './QueryParams';
+import { TransactionFilter } from './TransactionFilter';
 
 /**
  * Account interface repository.
@@ -46,44 +47,53 @@ export interface AccountRepository {
      * Gets an array of confirmed transactions for which an account is signer or receiver.
      * @param address - * Address can be created rawAddress or publicKey
      * @param queryParams - (Optional) Query params
+     * @param transactionFilter - (Optional) Transaction fitler
      * @returns Observable<Transaction[]>
      */
-    getAccountTransactions(address: Address, queryParams?: QueryParams): Observable<Transaction[]>;
+    getAccountTransactions(address: Address, queryParams?: QueryParams, transactionFilter?: TransactionFilter): Observable<Transaction[]>;
 
     /**
      * Gets an array of transactions for which an account is the recipient of a transaction.
      * A transaction is said to be incoming with respect to an account if the account is the recipient of a transaction.
      * @param address - * Address can be created rawAddress or publicKey
      * @param queryParams - (Optional) Query params
+     * @param transactionFilter - (Optional) Transaction fitler
      * @returns Observable<Transaction[]>
      */
-    getAccountIncomingTransactions(address: Address, queryParams?: QueryParams): Observable<Transaction[]>;
+    getAccountIncomingTransactions(
+        address: Address, queryParams?: QueryParams, transactionFilter?: TransactionFilter): Observable<Transaction[]>;
 
     /**
      * Gets an array of transactions for which an account is the sender a transaction.
      * A transaction is said to be outgoing with respect to an account if the account is the sender of a transaction.
      * @param address - * Address can be created rawAddress or publicKey
      * @param queryParams - (Optional) Query params
+     * @param transactionFilter - (Optional) Transaction fitler
      * @returns Observable<Transaction[]>
      */
-    getAccountOutgoingTransactions(address: Address, queryParams?: QueryParams): Observable<Transaction[]>;
+    getAccountOutgoingTransactions(
+        address: Address, queryParams?: QueryParams, transactionFilter?: TransactionFilter): Observable<Transaction[]>;
 
     /**
      * Gets the array of transactions for which an account is the sender or receiver and which have not yet been included in a block.
      * Unconfirmed transactions are those transactions that have not yet been included in a block.
      * Unconfirmed transactions are not guaranteed to be included in any block.
      * @param address - * Address can be created rawAddress or publicKey
      * @param queryParams - (Optional) Query params
+     * @param transactionFilter - (Optional) Transaction fitler
      * @returns Observable<Transaction[]>
      */
-    getAccountUnconfirmedTransactions(address: Address, queryParams?: QueryParams): Observable<Transaction[]>;
+    getAccountUnconfirmedTransactions(
+        address: Address, queryParams?: QueryParams, transactionFilter?: TransactionFilter): Observable<Transaction[]>;
 
     /**
      * Gets an array of transactions for which an account is the sender or has sign the transaction.
      * A transaction is said to be aggregate bonded with respect to an account if there are missing signatures.
      * @param address - * Address can be created rawAddress or publicKey
      * @param queryParams - (Optional) Query params
+     * @param transactionFilter - (Optional) Transaction fitler
      * @returns Observable<AggregateTransaction[]>
      */
-    getAccountPartialTransactions(address: Address, queryParams?: QueryParams): Observable<AggregateTransaction[]>;
+    getAccountPartialTransactions(
+        address: Address, queryParams?: QueryParams, transactionFilter?: TransactionFilter): Observable<AggregateTransaction[]>;
 }
diff --git a/src/infrastructure/Http.ts b/src/infrastructure/Http.ts
@@ -20,6 +20,7 @@ import { from as observableFrom, Observable, of as observableOf, throwError } fr
 import { catchError, map, shareReplay } from 'rxjs/operators';
 import { NetworkType } from '../model/blockchain/NetworkType';
 import { QueryParams } from './QueryParams';
+import { TransactionFilter } from './TransactionFilter';
 
 /**
  * Http extended by all http services
@@ -56,12 +57,9 @@ export abstract class Http {
         };
     }
 
-    transactionSearchCriteria(queryParams?: QueryParams): any {
+    transactionFilter(filter?: TransactionFilter): any {
         return {
-            pageSize: queryParams ? queryParams.pageSize : undefined,
-            id: queryParams ? queryParams.id : undefined,
-            ordering: queryParams ? queryParams.order : undefined,
-            type: queryParams ? queryParams.convertCSV(queryParams.type) : undefined,
+            type: filter ? filter.convertCSV(filter.type) : undefined,
         };
     }
 
diff --git a/src/infrastructure/QueryParams.ts b/src/infrastructure/QueryParams.ts
@@ -1,5 +1,3 @@
-import { TransactionType } from '../model/transaction/TransactionType';
-
 /*
  * Copyright 2018 NEM
  *
@@ -16,6 +14,8 @@ import { TransactionType } from '../model/transaction/TransactionType';
  * limitations under the License.
  */
 
+import { TransactionType } from '../model/transaction/TransactionType';
+
  /**
   * @since 0.11.3
   */
@@ -45,10 +45,6 @@ export class QueryParams {
      */
     public order: Order = Order.DESC;
 
-    /**
-     * Transaction type list
-     */
-    public type?: TransactionType[];
     /**
      * Constructor
      */
@@ -69,21 +65,4 @@ export class QueryParams {
         this.order = order;
         return this;
     }
-
-    public setType(type?: TransactionType[]): QueryParams {
-        this.type = type;
-        return this;
-    }
-
-    /**
-     * Return comma seperated list
-     * @param type Transaction type list
-     */
-    public convertCSV(type?: TransactionType[]): string | undefined {
-        if (!type || type.length === 0) {
-            return undefined;
-        } else {
-            return type.map((t) => t.valueOf().toString()).join(',');
-        }
-    }
 }
diff --git a/src/infrastructure/TransactionFilter.ts b/src/infrastructure/TransactionFilter.ts
@@ -0,0 +1,50 @@
+/*
+ * Copyright 2020 NEM
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+import { TransactionType } from '../model/transaction/TransactionType';
+import { QueryParams } from './QueryParams';
+
+/**
+ * The Transaction filter class
+ */
+export class TransactionFilter {
+    /**
+     * Transaction type list
+     */
+    public type?: TransactionType[];
+    /**
+     * Constructor
+     */
+    constructor() {
+    }
+
+    public setType(type?: TransactionType[]): TransactionFilter {
+        this.type = type;
+        return this;
+    }
+
+    /**
+     * Return comma seperated list
+     * @param type Transaction type list
+     */
+    public convertCSV(type?: TransactionType[]): string | undefined {
+        if (!type || type.length === 0) {
+            return undefined;
+        } else {
+            return type.map((t) => t.valueOf().toString()).join(',');
+        }
+    }
+}
diff --git a/src/infrastructure/infrastructure.ts b/src/infrastructure/infrastructure.ts
@@ -47,3 +47,4 @@ export * from './RepositoryFactory';
 export * from './RestrictionAccountRepository';
 export * from './RestrictionMosaicRepository';
 export * from './TransactionRepository';
+export * from './TransactionFilter';
diff --git a/test/infrastructure/TransactionFilter.spec.ts b/test/infrastructure/TransactionFilter.spec.ts
@@ -15,19 +15,14 @@
  */
 
 import { expect } from 'chai';
-import { Order, QueryParams } from '../../src/infrastructure/QueryParams';
+import { TransactionFilter } from '../../src/infrastructure/TransactionFilter';
 import { TransactionType } from '../../src/model/transaction/TransactionType';
 
-describe('QueryParams', () => {
+describe('TransactionFilter', () => {
     it('should return correct query param', () => {
-        const param = new QueryParams().setId('0')
-            .setOrder(Order.ASC)
-            .setPageSize(10)
+        const param = new TransactionFilter()
             .setType([TransactionType.TRANSFER, TransactionType.ACCOUNT_LINK]);
 
-        expect(param.id).to.be.equal('0');
-        expect(param.order.valueOf()).to.be.equal(Order.ASC.valueOf());
-        expect(param.pageSize).to.be.equal(10);
         expect(param.convertCSV(param.type)).to.be.equal('16724,16716');
     });
 });
diff --git a/test/service/BlockService.spec.ts b/test/service/BlockService.spec.ts
@@ -28,6 +28,7 @@ import { NetworkType } from '../../src/model/blockchain/NetworkType';
 import { UInt64 } from '../../src/model/UInt64';
 import { BlockService } from '../../src/service/BlockService';
 import { TestingAccount } from '../conf/conf.spec';
+import { PositionEnum } from 'nem2-sdk-openapi-typescript-node-client';
 
 describe('BlockService', () => {
 
@@ -100,11 +101,11 @@ describe('BlockService', () => {
     function mockMerklePath(): MerkleProofInfo {
         return new MerkleProofInfo(
             [
-                new MerklePathItem(1, 'CDE45D740536E5361F392025A44B26546A138958E69CD6F18D22908F8F11ECF2'),
-                new MerklePathItem(2, '4EF55DAB8FEF9711B23DA71D2ACC58EFFF3969C3D572E06ACB898F99BED4827A'),
-                new MerklePathItem(1, '1BB95470065ED69D184948A0175EDC2EAB9E86A0CEB47B648A58A02A5445AF66'),
-                new MerklePathItem(2, 'D96B03809B8B198EFA5824191A979F7B85C0E9B7A6623DAFF38D4B2927EFDFB5'),
-                new MerklePathItem(2, '9981EBDBCA8E36BA4D4D4A450072026AC8C85BA6497666219E0E049BE3362E51'),
+                new MerklePathItem(PositionEnum.Left, 'CDE45D740536E5361F392025A44B26546A138958E69CD6F18D22908F8F11ECF2'),
+                new MerklePathItem(PositionEnum.Right, '4EF55DAB8FEF9711B23DA71D2ACC58EFFF3969C3D572E06ACB898F99BED4827A'),
+                new MerklePathItem(PositionEnum.Left, '1BB95470065ED69D184948A0175EDC2EAB9E86A0CEB47B648A58A02A5445AF66'),
+                new MerklePathItem(PositionEnum.Right, 'D96B03809B8B198EFA5824191A979F7B85C0E9B7A6623DAFF38D4B2927EFDFB5'),
+                new MerklePathItem(PositionEnum.Right, '9981EBDBCA8E36BA4D4D4A450072026AC8C85BA6497666219E0E049BE3362E51'),
             ],
         );
     }
