Task/g50 account properties

e2e/infrastructure/AccountHttp.spec.ts

@@ -62,6 +62,23 @@ describe('AccountHttp', () => {
         });
     });
 
+    describe('getAccountProperty', () => {
+        it('should call getAccountProperty successfully', (done) => {
+            accountHttp.getAccountProperty(publicAccount).subscribe((accountProperty) => {
+                expect(accountProperty.accountProperties[0]!.address).to.be.equal(accountAddress);
+                done();
+            });
+        });
+    });
+
+    describe('getAccountProperties', () => {
+        it('should call getAccountProperties successfully', (done) => {
+            accountHttp.getAccountProperties([accountAddress]).subscribe((accountProperties) => {
+                expect(accountProperties[0]!.accountProperties[0]!.address).to.be.equal(accountAddress);
+                done();
+            });
+        });
+    });
     describe('getMultisigAccountGraphInfo', () => {
         it('should call getMultisigAccountGraphInfo successfully', (done) => {
             accountHttp.getMultisigAccountGraphInfo(multisigPublicAccount.address).subscribe((multisigAccountGraphInfo) => {

package.json

@@ -53,7 +53,7 @@
     "@types/crypto-js": "^3.1.43",
     "crypto-js": "^3.1.9-1",
     "js-joda": "^1.6.2",
-    "nem2-library": "^0.9.8",
+    "nem2-library": "^0.9.11",
     "request": "^2.83.0",
     "request-promise-native": "^1.0.5",
     "rxjs": "^6.2.1",

src/infrastructure/AccountHttp.ts

@@ -18,6 +18,8 @@ import {AccountRoutesApi} from 'nem2-library';
 import {from as observableFrom, Observable} from 'rxjs';
 import {map, mergeMap} from 'rxjs/operators';
 import {AccountInfo} from '../model/account/AccountInfo';
+import { AccountPropertiesInfo } from '../model/account/AccountPropertiesInfo';
+import { AccountProperty } from '../model/account/AccountProperty';
 import {Address} from '../model/account/Address';
 import {MultisigAccountGraphInfo} from '../model/account/MultisigAccountGraphInfo';
 import {MultisigAccountInfo} from '../model/account/MultisigAccountInfo';
@@ -79,6 +81,38 @@ export class AccountHttp extends Http implements AccountRepository {
         }));
     }
 
+    /**
+     * Gets Account property.
+     * @param publicAccount public account
+     * @returns Observable<AccountProperty>
+     */
+    public getAccountProperty(publicAccount: PublicAccount): Observable<AccountPropertiesInfo> {
+        return observableFrom(this.accountRoutesApi.getAccountProperties(publicAccount.publicKey)).pipe(map((accountProperties) => {
+                return new AccountPropertiesInfo(
+                    accountProperties.meta,
+                    accountProperties.accountProperties,
+                );
+            }));
+    }
+
+    /**
+     * Gets Account properties.
+     * @param address list of addresses
+     * @returns Observable<AccountProperty[]>
+     */
+    public getAccountProperties(addresses: Address[]): Observable<AccountPropertiesInfo[]> {
+        const accountIds = addresses.map((address) => address.plain());
+        return observableFrom(
+            this.accountRoutesApi.getAccountPropertiesFromAccounts(accountIds)).pipe(map((accountProperties) => {
+            return accountProperties.map((property) => {
+                return new AccountPropertiesInfo(
+                    property.meta,
+                    property.accountProperties,
+                );
+            });
+        }));
+    }
+
     /**
      * Gets AccountsInfo for different accounts.
      * @param addresses List of Address
@@ -160,8 +194,7 @@ export class AccountHttp extends Http implements AccountRepository {
      * @param queryParams - (Optional) Query params
      * @returns Observable<Transaction[]>
      */
-    public transactions(publicAccount: PublicAccount,
-                        queryParams?: QueryParams): Observable<Transaction[]> {
+    public transactions(publicAccount: PublicAccount, queryParams?: QueryParams): Observable<Transaction[]> {
         return observableFrom(
             this.accountRoutesApi.transactions(publicAccount.publicKey, queryParams != null ? queryParams : {})).pipe(
             map((transactionsDTO) => {
@@ -178,8 +211,7 @@ export class AccountHttp extends Http implements AccountRepository {
      * @param queryParams - (Optional) Query params
      * @returns Observable<Transaction[]>
      */
-    public incomingTransactions(publicAccount: PublicAccount,
-                                queryParams?: QueryParams): Observable<Transaction[]> {
+    public incomingTransactions(publicAccount: PublicAccount, queryParams?: QueryParams): Observable <Transaction[]> {
         return observableFrom(
             this.accountRoutesApi.incomingTransactions(publicAccount.publicKey, queryParams != null ? queryParams : {})).pipe(
             map((transactionsDTO) => {
@@ -196,8 +228,7 @@ export class AccountHttp extends Http implements AccountRepository {
      * @param queryParams - (Optional) Query params
      * @returns Observable<Transaction[]>
      */
-    public outgoingTransactions(publicAccount: PublicAccount,
-                                queryParams?: QueryParams): Observable<Transaction[]> {
+    public outgoingTransactions(publicAccount: PublicAccount, queryParams?: QueryParams): Observable <Transaction[]> {
         return observableFrom(
             this.accountRoutesApi.outgoingTransactions(publicAccount.publicKey, queryParams != null ? queryParams : {})).pipe(
             map((transactionsDTO) => {
@@ -215,8 +246,7 @@ export class AccountHttp extends Http implements AccountRepository {
      * @param queryParams - (Optional) Query params
      * @returns Observable<Transaction[]>
      */
-    public unconfirmedTransactions(publicAccount: PublicAccount,
-                                   queryParams?: QueryParams): Observable<Transaction[]> {
+    public unconfirmedTransactions(publicAccount: PublicAccount, queryParams?: QueryParams): Observable <Transaction[]> {
         return observableFrom(
             this.accountRoutesApi.unconfirmedTransactions(publicAccount.publicKey, queryParams != null ? queryParams : {})).pipe(
             map((transactionsDTO) => {
@@ -233,9 +263,7 @@ export class AccountHttp extends Http implements AccountRepository {
      * @param queryParams - (Optional) Query params
      * @returns Observable<AggregateTransaction[]>
      */
-    public aggregateBondedTransactions(publicAccount: PublicAccount,
-                                       queryParams?: QueryParams): Observable<AggregateTransaction[]> {
-
+    public aggregateBondedTransactions(publicAccount: PublicAccount, queryParams?: QueryParams): Observable <AggregateTransaction[]> {
         return observableFrom(
             this.accountRoutesApi.partialTransactions(publicAccount.publicKey, queryParams != null ? queryParams : {})).pipe(
             map((transactionsDTO) => {

src/infrastructure/transaction/CreateTransactionFromDTO.ts

@@ -17,6 +17,10 @@
 import {Address} from '../../model/account/Address';
 import {PublicAccount} from '../../model/account/PublicAccount';
 import {NetworkType} from '../../model/blockchain/NetworkType';
+import { AccountPropertyModification,
+    ModifyAccountPropertyAddressTransaction,
+    ModifyAccountPropertyEntityTypeTransaction,
+    ModifyAccountPropertyMosaicTransaction } from '../../model/model';
 import {Mosaic} from '../../model/mosaic/Mosaic';
 import {MosaicId} from '../../model/mosaic/MosaicId';
 import {MosaicProperties} from '../../model/mosaic/MosaicProperties';
@@ -254,6 +258,51 @@ const CreateStandaloneTransactionFromDTO = (transactionDTO, transactionInfo): Tr
             PublicAccount.createFromPublicKey(transactionDTO.signer, extractNetworkType(transactionDTO.version)),
             transactionInfo,
         );
+    } else if (transactionDTO.type === TransactionType.MODIFY_ACCOUNT_PROPERTY_ADDRESS) {
+        return new ModifyAccountPropertyAddressTransaction(
+            extractNetworkType(transactionDTO.version),
+            extractTransactionVersion(transactionDTO.version),
+            Deadline.createFromDTO(transactionDTO.deadline),
+            new UInt64(transactionDTO.fee),
+            transactionDTO.propertyType,
+            transactionDTO.modifications ? transactionDTO.modifications.map((modificationDTO) => new AccountPropertyModification(
+                modificationDTO.modificationType,
+                modificationDTO.value,
+            )) : [],
+            transactionDTO.signature,
+            PublicAccount.createFromPublicKey(transactionDTO.signer, extractNetworkType(transactionDTO.version)),
+            transactionInfo,
+        );
+    } else if (transactionDTO.type === TransactionType.MODIFY_ACCOUNT_PROPERTY_ENTITY_TYPE) {
+        return new ModifyAccountPropertyEntityTypeTransaction(
+            extractNetworkType(transactionDTO.version),
+            extractTransactionVersion(transactionDTO.version),
+            Deadline.createFromDTO(transactionDTO.deadline),
+            new UInt64(transactionDTO.fee),
+            transactionDTO.propertyType,
+            transactionDTO.modifications ? transactionDTO.modifications.map((modificationDTO) => new AccountPropertyModification(
+                modificationDTO.modificationType,
+                modificationDTO.value,
+            )) : [],
+            transactionDTO.signature,
+            PublicAccount.createFromPublicKey(transactionDTO.signer, extractNetworkType(transactionDTO.version)),
+            transactionInfo,
+        );
+    } else if (transactionDTO.type === TransactionType.MODIFY_ACCOUNT_PROPERTY_MOSAIC) {
+        return new ModifyAccountPropertyMosaicTransaction(
+            extractNetworkType(transactionDTO.version),
+            extractTransactionVersion(transactionDTO.version),
+            Deadline.createFromDTO(transactionDTO.deadline),
+            new UInt64(transactionDTO.fee),
+            transactionDTO.propertyType,
+            transactionDTO.modifications ? transactionDTO.modifications.map((modificationDTO) => new AccountPropertyModification(
+                modificationDTO.modificationType,
+                modificationDTO.value,
+            )) : [],
+            transactionDTO.signature,
+            PublicAccount.createFromPublicKey(transactionDTO.signer, extractNetworkType(transactionDTO.version)),
+            transactionInfo,
+        );
     }
 
     throw new Error('Unimplemented transaction with type ' + transactionDTO.type);

src/model/account/AccountProperties.ts

@@ -0,0 +1,39 @@
+/*
+ * Copyright 2019 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 { AccountProperty } from './AccountProperty';
+import { Address } from './Address';
+/**
+ * Account properties structure describes property information for an account.
+ */
+export class AccountProperties {
+
+    /**
+     * Constructor
+     * @param address
+     * @param properties
+     */
+    constructor(
+                /**
+                 * Account Address
+                 */
+                public readonly address: Address,
+                /**
+                 * Properties.
+                 */
+                public readonly properties: AccountProperty[]) {
+
+    }
+}

src/model/account/AccountPropertiesInfo.ts

@@ -0,0 +1,38 @@
+/*
+ * Copyright 2019 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 { AccountProperties } from './AccountProperties';
+/**
+ * Account properties structure describes property information for an account.
+ */
+export class AccountPropertiesInfo {
+
+    /**
+     * Constructor
+     * @param meta
+     * @param accountProperties
+     */
+    constructor(
+                /**
+                 * meta
+                 */
+                public readonly meta: any,
+                /**
+                 * Properties.
+                 */
+                public readonly accountProperties: AccountProperties[]) {
+
+    }
+}

src/model/account/AccountProperty.ts

@@ -0,0 +1,40 @@
+/*
+ * Copyright 2019 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 { PropertyType } from './PropertyType';
+/**
+ * Account property structure describes property information.
+ */
+export class AccountProperty {
+
+    /**
+     * Constructor
+     * @param propertyType
+     * @param values
+     */
+    constructor(
+            /**
+             * Account property type
+             */
+            public readonly propertyType: PropertyType,
+            /**
+             * Property values.
+             */
+            public readonly values: object[]) {
+
+    }
+
+}

src/model/account/PropertyModificationType.ts

@@ -0,0 +1,23 @@
+/*
+ * Copyright 2019 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.
+ */
+
+/**
+ * Account property modification type
+ */
+export enum PropertyModificationType {
+    Add = 0x00,
+    Remove = 0x01,
+}