diff --git a/tangem-demo/src/main/java/com/tangem/tangemtest/ucase/variants/personalize/converter/IdToJsonValues.kt b/tangem-demo/src/main/java/com/tangem/tangemtest/ucase/variants/personalize/converter/IdToJsonValues.kt new file mode 100644 index 0000000000..686008ed97 --- /dev/null +++ b/tangem-demo/src/main/java/com/tangem/tangemtest/ucase/variants/personalize/converter/IdToJsonValues.kt @@ -0,0 +1,124 @@ +package com.tangem.tangemtest.ucase.variants.personalize.converter + +import com.tangem.tangemtest._arch.structure.* +import com.tangem.tangemtest._arch.structure.impl.KeyValue +import com.tangem.tangemtest.ucase.variants.personalize.dto.TestJsonDto +import ru.dev.gbixahue.eu4d.lib.kotlin.common.BaseTypedHolder + +/** +[REDACTED_AUTHOR] + */ +class Value( + val value: Any? = null, + val list: List? = mutableListOf() +) + +class IdToJsonValues : BaseTypedHolder() { + fun init(from: TestJsonDto) { + register(CardNumber.SERIES, Value(from.series)) + register(CardNumber.NUMBER, Value(from.startNumber)) + register(Common.CURVE, Value(from.curveID, Helper.listOfCurves())) + register(Common.BLOCKCHAIN, Value(from.blockchain.name, Helper.listOfBlockchain())) + register(Common.BLOCKCHAIN_CUSTOM, Value(from.blockchain.customName)) + register(Common.MAX_SIGNATURES, Value(from.MaxSignatures)) + register(Common.CREATE_WALLET, Value(from.createWalletB)) + register(SigningMethod.SIGN_TX, Value(from.SigningMethod0)) + register(SigningMethod.SIGN_TX_RAW, Value(from.SigningMethod1)) + register(SigningMethod.SIGN_VALIDATED_TX, Value(from.SigningMethod2)) + register(SigningMethod.SIGN_VALIDATED_TX_RAW, Value(from.SigningMethod3)) + register(SigningMethod.SIGN_VALIDATED_TX_ISSUER, Value(from.SigningMethod4)) + register(SigningMethod.SIGN_VALIDATED_TX_RAW_ISSUER, Value(from.SigningMethod5)) + register(SigningMethod.SIGN_EXTERNAL, Value(from.SigningMethod6)) + register(SignHashExProp.PIN_LESS_FLOOR_LIMIT, Value(from.pinLessFloorLimit)) + register(SignHashExProp.CRYPTO_EXTRACT_KEY, Value(from.hexCrExKey)) + register(SignHashExProp.REQUIRE_TERMINAL_CERT_SIG, Value(from.requireTerminalCertSignature)) + register(SignHashExProp.REQUIRE_TERMINAL_TX_SIG, Value(from.requireTerminalTxSignature)) + register(SignHashExProp.CHECK_PIN3, Value(from.checkPIN3onCard)) + register(Denomination.WRITE_ON_PERSONALIZE, Value(from.writeOnPersonalization)) + register(Denomination.DENOMINATION, Value(from.denomination)) + register(Token.ITS_TOKEN, Value(from.itsToken)) + register(Token.SYMBOL, Value(from.symbol)) + register(Token.CONTRACT_ADDRESS, Value(from.contractAddress)) + register(Token.DECIMAL, Value(from.decimal)) + register(ProductMask.NOTE, Value(from.cardData.product_note)) + register(ProductMask.TAG, Value(from.cardData.product_tag)) + register(ProductMask.ID_CARD, Value(from.cardData.product_id_card)) + register(SettingsMask.IS_REUSABLE, Value(from.isReusable)) + register(SettingsMask.NEED_ACTIVATION, Value(from.useActivation)) + register(SettingsMask.FORBID_PURGE, Value(from.forbidPurgeWallet)) + register(SettingsMask.ALLOW_SELECT_BLOCKCHAIN, Value(from.allowSelectBlockchain)) + register(SettingsMask.USE_BLOCK, Value(from.useBlock)) + register(SettingsMask.ONE_APDU, Value(from.useOneCommandAtTime)) + register(SettingsMask.USE_CVC, Value(from.useCVC)) + register(SettingsMask.ALLOW_SWAP_PIN, Value(from.allowSwapPIN)) + register(SettingsMask.ALLOW_SWAP_PIN2, Value(from.allowSwapPIN2)) + register(SettingsMask.FORBID_DEFAULT_PIN, Value(from.forbidDefaultPIN)) + register(SettingsMask.SMART_SECURITY_DELAY, Value(from.smartSecurityDelay)) + register(SettingsMask.PROTECT_ISSUER_DATA_AGAINST_REPLAY, Value(from.protectIssuerDataAgainstReplay)) + register(SettingsMask.SKIP_SECURITY_DELAY_IF_VALIDATED, Value(from.skipSecurityDelayIfValidatedByIssuer)) + register(SettingsMask.SKIP_PIN2_CVC_IF_VALIDATED, Value(from.skipCheckPIN2andCVCIfValidatedByIssuer)) + register(SettingsMask.SKIP_SECURITY_DELAY_ON_LINKED_TERMINAL, Value(from.skipSecurityDelayIfValidatedByLinkedTerminal)) + register(SettingsMask.RESTRICT_OVERWRITE_EXTRA_ISSUER_DATA, Value(from.restrictOverwriteIssuerDataEx)) + register(SettingsMaskProtocolEnc.ALLOW_UNENCRYPTED, Value(from.protocolAllowUnencrypted)) + register(SettingsMaskProtocolEnc.ALLOW_FAST_ENCRYPTION, Value(false)) + register(SettingsMaskNdef.USE_NDEF, Value(from.useNDEF)) + register(SettingsMaskNdef.DYNAMIC_NDEF, Value(from.useDynamicNDEF)) + register(SettingsMaskNdef.DISABLE_PRECOMPUTED_NDEF, Value(from.disablePrecomputedNDEF)) + register(SettingsMaskNdef.AAR, Value(from.NDEF[0].type, Helper.aarList())) + register(Pins.PIN, Value(from.PIN)) + register(Pins.PIN2, Value(from.PIN2)) + register(Pins.PIN3, Value(from.PIN3)) + register(Pins.CVC, Value(from.CVC)) + register(Pins.PAUSE_BEFORE_PIN2, Value(from.pauseBeforePIN2, Helper.pauseBeforePin())) + } +} + +internal class Helper { + companion object { + fun listOfCurves(): List { + return mutableListOf( + KeyValue("secp256k1", "secp256k1"), + KeyValue("ed25519", "ed25519") + ) + } + + fun listOfBlockchain(): List { + return mutableListOf( + KeyValue("--- CUSTOM ---", "BTC/test"), + KeyValue("BTC", "BTC"), + KeyValue("BTC/test", "BTC/test"), + KeyValue("ETH", "ETH"), + KeyValue("ETH/test", "ETH/test"), + KeyValue("BCH", "BCH"), + KeyValue("BCH/test", "BCH/test"), + KeyValue("LTC", "LTC"), + KeyValue("XLM", "XLM"), + KeyValue("XLM/test", "XLM/test"), + KeyValue("RSK", "RSK"), + KeyValue("XPR", "XPR"), + KeyValue("CARDANO", "CARDANO") + ) + } + + fun aarList(): List { + return mutableListOf( + KeyValue("--- CUSTOM ---", ""), + KeyValue("Release APP", "com.some.release"), + KeyValue("Debug APP", "com.some.debug"), + KeyValue("None", "") + ) + } + + fun pauseBeforePin(): List { + return mutableListOf( + KeyValue("immediately", 0), + KeyValue("2 seconds", 2000), + KeyValue("5 seconds", 5000), + KeyValue("15 seconds", 15000), + KeyValue("30 seconds", 30000), + KeyValue("1 minute", 60000), + KeyValue("2 minute", 120000) + ) + } + } +} \ No newline at end of file diff --git a/tangem-demo/src/main/java/com/tangem/tangemtest/ucase/variants/personalize/converter/JsonToBlockConverter.kt b/tangem-demo/src/main/java/com/tangem/tangemtest/ucase/variants/personalize/converter/JsonToBlockConverter.kt index 6fa1d98058..075b63602c 100644 --- a/tangem-demo/src/main/java/com/tangem/tangemtest/ucase/variants/personalize/converter/JsonToBlockConverter.kt +++ b/tangem-demo/src/main/java/com/tangem/tangemtest/ucase/variants/personalize/converter/JsonToBlockConverter.kt @@ -4,152 +4,166 @@ import com.tangem.tangemtest._arch.structure.* import com.tangem.tangemtest._arch.structure.abstraction.Block import com.tangem.tangemtest._arch.structure.abstraction.ListItemBlock import com.tangem.tangemtest._arch.structure.impl.* -import com.tangem.tangemtest.ucase.variants.personalize.dto.Ndef import com.tangem.tangemtest.ucase.variants.personalize.dto.TestJsonDto import ru.dev.gbixahue.eu4d.lib.kotlin.common.Converter -class JsonToBlockConverter : Converter> { +/** +[REDACTED_AUTHOR] + */ +class JsonToBlockConverter( + private val valuesHolder: IdToJsonValues +) : Converter> { override fun convert(from: TestJsonDto): List { + valuesHolder.init(from) val blocList = mutableListOf() - blocList.add(cardNumber(from)) - blocList.add(common(from)) - blocList.add(signingMethod(from)) - blocList.add(signHashExProperties(from)) - blocList.add(denomination(from)) - blocList.add(token(from)) - blocList.add(productMask(from)) - blocList.add(settingsMask(from)) - blocList.add(settingsMaskProtocolEnc(from)) - blocList.add(settingsMaskNdef(from)) - blocList.add(pins(from)) + blocList.add(cardNumber()) + blocList.add(common()) + blocList.add(signingMethod()) + blocList.add(signHashExProperties()) + blocList.add(denomination()) + blocList.add(token()) + blocList.add(productMask()) + blocList.add(settingsMask()) + blocList.add(settingsMaskProtocolEnc()) + blocList.add(settingsMaskNdef()) + blocList.add(pins()) val payloadBlock = ListItemBlock(Additional.JSON_TAILS) addPayload(payloadBlock, from) blocList.add(payloadBlock) return blocList } - private fun cardNumber(from: TestJsonDto): Block { - val block = ListItemBlock(BlockId.CARD_NUMBER) - block.addItem(TextItem(BlockId.CARD_NUMBER)) - block.addItem(EditTextItem(CardNumber.SERIES, from.series)) - block.addItem(NumberItem(CardNumber.NUMBER, from.startNumber)) + private fun cardNumber(): Block { + val block = createBlock(BlockId.CARD_NUMBER) + mutableListOf( + CardNumber.SERIES, + CardNumber.NUMBER + ).forEach { createItem(block, it as Id) } return block } - private fun common(from: TestJsonDto): Block { - val block = ListItemBlock(BlockId.COMMON) - block.addItem(TextItem(BlockId.COMMON)) - block.addItem(ListItem(Common.CURVE, Helper.listOfCurves(), from.curveID)) - block.addItem(ListItem(Common.BLOCKCHAIN, Helper.listOfBlockchain(), from.blockchain.name)) - block.addItem(EditTextItem(Common.BLOCKCHAIN_CUSTOM, from.blockchain.customName)) - block.addItem(NumberItem(Common.MAX_SIGNATURES, from.MaxSignatures)) - block.addItem(BoolItem(Common.CREATE_WALLET, from.createWalletB)) + private fun common(): Block { + val block = createBlock(BlockId.COMMON) + mutableListOf( + Common.CURVE, + Common.BLOCKCHAIN, + Common.BLOCKCHAIN_CUSTOM, + Common.MAX_SIGNATURES, + Common.CREATE_WALLET + ).forEach { createItem(block, it) } return block } - private fun signingMethod(from: TestJsonDto): Block { - val block = ListItemBlock(BlockId.SIGNING_METHOD) - block.addItem(TextItem(BlockId.SIGNING_METHOD)) - block.addItem(BoolItem(SigningMethod.SIGN_TX, from.SigningMethod0)) - block.addItem(BoolItem(SigningMethod.SIGN_TX_RAW, from.SigningMethod1)) - block.addItem(BoolItem(SigningMethod.SIGN_VALIDATED_TX, from.SigningMethod2)) - block.addItem(BoolItem(SigningMethod.SIGN_VALIDATED_TX_RAW, from.SigningMethod3)) - block.addItem(BoolItem(SigningMethod.SIGN_VALIDATED_TX_ISSUER, from.SigningMethod4)) - block.addItem(BoolItem(SigningMethod.SIGN_VALIDATED_TX_RAW_ISSUER, from.SigningMethod5)) - block.addItem(BoolItem(SigningMethod.SIGN_EXTERNAL, from.SigningMethod6)) + private fun signingMethod(): Block { + val block = createBlock(BlockId.SIGNING_METHOD) + mutableListOf( + SigningMethod.SIGN_TX, + SigningMethod.SIGN_TX_RAW, + SigningMethod.SIGN_VALIDATED_TX, + SigningMethod.SIGN_VALIDATED_TX_RAW, + SigningMethod.SIGN_VALIDATED_TX_ISSUER, + SigningMethod.SIGN_VALIDATED_TX_RAW_ISSUER, + SigningMethod.SIGN_EXTERNAL + ).forEach { createItem(block, it) } return block } - private fun signHashExProperties(from: TestJsonDto): Block { - val block = ListItemBlock(BlockId.SIGN_HASH_EX_PROP) - block.addItem(TextItem(BlockId.SIGN_HASH_EX_PROP)) - block.addItem(NumberItem(SignHashExProp.PIN_LESS_FLOOR_LIMIT, from.pinLessFloorLimit)) - block.addItem(EditTextItem(SignHashExProp.CRYPTO_EXTRACT_KEY, from.hexCrExKey)) - block.addItem(BoolItem(SignHashExProp.REQUIRE_TERMINAL_CERT_SIG, from.requireTerminalCertSignature)) - block.addItem(BoolItem(SignHashExProp.REQUIRE_TERMINAL_TX_SIG, from.requireTerminalTxSignature)) - block.addItem(BoolItem(SignHashExProp.CHECK_PIN3, from.checkPIN3onCard)) + private fun signHashExProperties(): Block { + val block = createBlock(BlockId.SIGN_HASH_EX_PROP) + mutableListOf( + SignHashExProp.PIN_LESS_FLOOR_LIMIT, + SignHashExProp.CRYPTO_EXTRACT_KEY, + SignHashExProp.REQUIRE_TERMINAL_CERT_SIG, + SignHashExProp.REQUIRE_TERMINAL_TX_SIG, + SignHashExProp.CHECK_PIN3 + ).forEach { createItem(block, it) } return block } - private fun denomination(from: TestJsonDto): Block { - val block = ListItemBlock(BlockId.DENOMINATION) - block.addItem(TextItem(BlockId.DENOMINATION)) - block.addItem(BoolItem(Denomination.WRITE_ON_PERSONALIZE, from.writeOnPersonalization)) - block.addItem(NumberItem(Denomination.DENOMINATION, from.denomination)) + private fun denomination(): Block { + val block = createBlock(BlockId.DENOMINATION) + mutableListOf( + Denomination.WRITE_ON_PERSONALIZE, + Denomination.DENOMINATION + ).forEach { createItem(block, it) } return block } - private fun token(from: TestJsonDto): Block { - val block = ListItemBlock(BlockId.TOKEN) - block.addItem(TextItem(BlockId.TOKEN)) - block.addItem(BoolItem(Token.ITS_TOKEN, from.itsToken)) - block.addItem(EditTextItem(Token.SYMBOL, from.symbol)) - block.addItem(EditTextItem(Token.CONTRACT_ADDRESS, from.contractAddress)) - block.addItem(NumberItem(Token.DECIMAL, from.decimal)) + private fun token(): Block { + val block = createBlock(BlockId.TOKEN) + mutableListOf( + Token.ITS_TOKEN, + Token.SYMBOL, + Token.CONTRACT_ADDRESS, + Token.DECIMAL + ).forEach { createItem(block, it) } return block } - private fun productMask(from: TestJsonDto): Block { - val block = ListItemBlock(BlockId.PROD_MASK) - block.addItem(TextItem(BlockId.PROD_MASK)) - block.addItem(BoolItem(ProductMask.NOTE, from.cardData.product_note)) - block.addItem(BoolItem(ProductMask.TAG, from.cardData.product_tag)) - block.addItem(BoolItem(ProductMask.ID_CARD, from.cardData.product_id_card)) + private fun productMask(): Block { + val block = createBlock(BlockId.PROD_MASK) + mutableListOf( + ProductMask.NOTE, + ProductMask.TAG, + ProductMask.ID_CARD + ).forEach { createItem(block, it) } return block } - private fun settingsMask(from: TestJsonDto): Block { - val block = ListItemBlock(BlockId.SETTINGS_MASK) - block.addItem(TextItem(BlockId.SETTINGS_MASK)) - block.addItem(BoolItem(SettingsMask.IS_REUSABLE, from.isReusable)) - block.addItem(BoolItem(SettingsMask.NEED_ACTIVATION, from.useActivation)) - block.addItem(BoolItem(SettingsMask.FORBID_PURGE, from.forbidPurgeWallet)) - block.addItem(BoolItem(SettingsMask.ALLOW_SELECT_BLOCKCHAIN, from.allowSelectBlockchain)) - block.addItem(BoolItem(SettingsMask.USE_BLOCK, from.useBlock)) - block.addItem(BoolItem(SettingsMask.ONE_APDU, from.useOneCommandAtTime)) - block.addItem(BoolItem(SettingsMask.USE_CVC, from.useCVC)) - block.addItem(BoolItem(SettingsMask.ALLOW_SWAP_PIN, from.allowSwapPIN)) - block.addItem(BoolItem(SettingsMask.ALLOW_SWAP_PIN2, from.allowSwapPIN2)) - block.addItem(BoolItem(SettingsMask.FORBID_DEFAULT_PIN, from.forbidDefaultPIN)) - block.addItem(BoolItem(SettingsMask.SMART_SECURITY_DELAY, from.smartSecurityDelay)) - block.addItem(BoolItem(SettingsMask.PROTECT_ISSUER_DATA_AGAINST_REPLAY, from.protectIssuerDataAgainstReplay)) - block.addItem(BoolItem(SettingsMask.SKIP_SECURITY_DELAY_IF_VALIDATED, from.skipSecurityDelayIfValidatedByIssuer)) - block.addItem(BoolItem(SettingsMask.SKIP_PIN2_CVC_IF_VALIDATED, from.skipCheckPIN2andCVCIfValidatedByIssuer)) - block.addItem(BoolItem(SettingsMask.SKIP_SECURITY_DELAY_ON_LINKED_TERMINAL, from.skipSecurityDelayIfValidatedByLinkedTerminal)) - block.addItem(BoolItem(SettingsMask.RESTRICT_OVERWRITE_EXTRA_ISSUER_DATA, from.restrictOverwriteIssuerDataEx)) + private fun settingsMask(): Block { + val block = createBlock(BlockId.SETTINGS_MASK) + mutableListOf( + SettingsMask.IS_REUSABLE, + SettingsMask.NEED_ACTIVATION, + SettingsMask.FORBID_PURGE, + SettingsMask.ALLOW_SELECT_BLOCKCHAIN, + SettingsMask.USE_BLOCK, + SettingsMask.ONE_APDU, + SettingsMask.USE_CVC, + SettingsMask.ALLOW_SWAP_PIN, + SettingsMask.ALLOW_SWAP_PIN2, + SettingsMask.FORBID_DEFAULT_PIN, + SettingsMask.SMART_SECURITY_DELAY, + SettingsMask.PROTECT_ISSUER_DATA_AGAINST_REPLAY, + SettingsMask.SKIP_SECURITY_DELAY_IF_VALIDATED, + SettingsMask.SKIP_PIN2_CVC_IF_VALIDATED, + SettingsMask.SKIP_SECURITY_DELAY_ON_LINKED_TERMINAL, + SettingsMask.RESTRICT_OVERWRITE_EXTRA_ISSUER_DATA + ).forEach { createItem(block, it) } return block } - private fun settingsMaskProtocolEnc(from: TestJsonDto): Block { - val block = ListItemBlock(BlockId.SETTINGS_MASK_PROTOCOL_ENC) - block.addItem(TextItem(BlockId.SETTINGS_MASK_PROTOCOL_ENC)) - block.addItem(BoolItem(SettingsMaskProtocolEnc.ALLOW_UNENCRYPTED, from.protocolAllowUnencrypted)) - block.addItem(BoolItem(SettingsMaskProtocolEnc.ALLOW_FAST_ENCRYPTION, false)) + private fun settingsMaskProtocolEnc(): Block { + val block = createBlock(BlockId.SETTINGS_MASK_PROTOCOL_ENC) + mutableListOf( + SettingsMaskProtocolEnc.ALLOW_UNENCRYPTED, + SettingsMaskProtocolEnc.ALLOW_FAST_ENCRYPTION).forEach { createItem(block, it) } return block } - private fun settingsMaskNdef(from: TestJsonDto): Block { - val block = ListItemBlock(BlockId.SETTINGS_MASK_NDEF) - block.addItem(TextItem(BlockId.SETTINGS_MASK_NDEF)) - block.addItem(BoolItem(SettingsMaskNdef.USE_NDEF, from.useNDEF)) - block.addItem(BoolItem(SettingsMaskNdef.DYNAMIC_NDEF, from.useDynamicNDEF)) - block.addItem(BoolItem(SettingsMaskNdef.DISABLE_PRECOMPUTED_NDEF, from.disablePrecomputedNDEF)) - block.addItem(ListItem(SettingsMaskNdef.AAR, Helper.aarList(), from.NDEF[0].type)) + private fun settingsMaskNdef(): Block { + val block = createBlock(BlockId.SETTINGS_MASK_NDEF) + mutableListOf( + SettingsMaskNdef.USE_NDEF, + SettingsMaskNdef.DYNAMIC_NDEF, + SettingsMaskNdef.DISABLE_PRECOMPUTED_NDEF, + SettingsMaskNdef.AAR + ).forEach { createItem(block, it) } return block } - private fun pins(from: TestJsonDto): Block { - val block = ListItemBlock(BlockId.PINS) - block.addItem(TextItem(BlockId.PINS)) - block.addItem(EditTextItem(Pins.PIN, from.PIN)) - block.addItem(EditTextItem(Pins.PIN2, from.PIN2)) - block.addItem(EditTextItem(Pins.PIN3, from.PIN3)) - block.addItem(EditTextItem(Pins.CVC, from.CVC)) - block.addItem(ListItem(Pins.PAUSE_BEFORE_PIN2, Helper.pauseBeforePin(), from.pauseBeforePIN2)) + private fun pins(): Block { + val block = createBlock(BlockId.PINS) + mutableListOf(Pins.PIN, Pins.PIN2, Pins.PIN3, Pins.CVC, Pins.PAUSE_BEFORE_PIN2) + .forEach { createItem(block, it) } return block } + private fun createBlock(id: Id): ListItemBlock { + return ListItemBlock(id).apply { createItem(this, id) } + } + private fun addPayload(block: Block, from: TestJsonDto) { block.payload[Additional.JSON_INCOMING.name] = from block.payload[Additional.JSON_TAILS.name] = JsonTails( @@ -160,6 +174,55 @@ class JsonToBlockConverter : Converter> { from.issuerName ) } + + private fun createItem(block: ListItemBlock, id: Id) { + val holder = valuesHolder.get(id) ?: return + val item = when { + IdItemHelper.blockIdList.contains(id) -> TextItem(id, holder.value as? String) + IdItemHelper.listItemList.contains(id) -> ListItem(id, holder.list as List, holder.value) + IdItemHelper.boolList.contains(id) -> BoolItem(id, holder.value as? Boolean) + IdItemHelper.editTextList.contains(id) -> EditTextItem(id, holder.value as? String) + IdItemHelper.numberList.contains(id) -> NumberItem(id, holder.value as? Number) + else -> ListItemBlock(Additional.UNDEFINED) + } + block.addItem(item) + } +} + +class IdItemHelper { + companion object { + val blockIdList = mutableListOf( + BlockId.CARD_NUMBER, BlockId.COMMON, BlockId.SIGNING_METHOD, BlockId.SIGN_HASH_EX_PROP, BlockId.DENOMINATION, + BlockId.TOKEN, BlockId.PROD_MASK, BlockId.SETTINGS_MASK, BlockId.SETTINGS_MASK_PROTOCOL_ENC, + BlockId.SETTINGS_MASK_NDEF, BlockId.PINS + ) + + val listItemList = mutableListOf(Common.CURVE, Common.BLOCKCHAIN, SettingsMaskNdef.AAR, Pins.PAUSE_BEFORE_PIN2) + + val boolList = mutableListOf( + Common.CREATE_WALLET, SigningMethod.SIGN_TX, SigningMethod.SIGN_TX_RAW, SigningMethod.SIGN_VALIDATED_TX, + SigningMethod.SIGN_VALIDATED_TX_RAW, SigningMethod.SIGN_VALIDATED_TX_ISSUER, + SigningMethod.SIGN_VALIDATED_TX_RAW_ISSUER, SigningMethod.SIGN_EXTERNAL, SignHashExProp.REQUIRE_TERMINAL_CERT_SIG, + SignHashExProp.REQUIRE_TERMINAL_TX_SIG, SignHashExProp.CHECK_PIN3, Denomination.WRITE_ON_PERSONALIZE, Token.ITS_TOKEN, + ProductMask.NOTE, ProductMask.TAG, ProductMask.ID_CARD, SettingsMask.IS_REUSABLE, SettingsMask.NEED_ACTIVATION, + SettingsMask.FORBID_PURGE, SettingsMask.ALLOW_SELECT_BLOCKCHAIN, SettingsMask.USE_BLOCK, SettingsMask.ONE_APDU, + SettingsMask.USE_CVC, SettingsMask.ALLOW_SWAP_PIN, SettingsMask.ALLOW_SWAP_PIN2, SettingsMask.FORBID_DEFAULT_PIN, + SettingsMask.SMART_SECURITY_DELAY, SettingsMask.PROTECT_ISSUER_DATA_AGAINST_REPLAY, + SettingsMask.SKIP_SECURITY_DELAY_IF_VALIDATED, SettingsMask.SKIP_PIN2_CVC_IF_VALIDATED, + SettingsMask.SKIP_SECURITY_DELAY_ON_LINKED_TERMINAL, SettingsMask.RESTRICT_OVERWRITE_EXTRA_ISSUER_DATA, + SettingsMaskProtocolEnc.ALLOW_UNENCRYPTED, SettingsMaskProtocolEnc.ALLOW_FAST_ENCRYPTION, + SettingsMaskNdef.USE_NDEF, SettingsMaskNdef.DYNAMIC_NDEF, SettingsMaskNdef.DISABLE_PRECOMPUTED_NDEF + ) + + val editTextList = mutableListOf( + CardNumber.SERIES, Common.BLOCKCHAIN_CUSTOM, SignHashExProp.CRYPTO_EXTRACT_KEY, Token.SYMBOL, + Token.CONTRACT_ADDRESS, Pins.PIN, Pins.PIN2, Pins.PIN3, Pins.CVC + ) + + val numberList = mutableListOf( + CardNumber.NUMBER, Common.MAX_SIGNATURES, SignHashExProp.PIN_LESS_FLOOR_LIMIT, Denomination.DENOMINATION, Token.DECIMAL + ) + } } class JsonTails( @@ -168,60 +231,4 @@ class JsonTails( val issuerData: Any?, val releaseVersion: Boolean, val issuerName: String -) - -internal class Helper { - companion object { - fun listOfCurves(): List { - return mutableListOf( - KeyValue("secp256k1", "secp256k1"), - KeyValue("ed25519", "ed25519") - ) - } - - fun listOfBlockchain(): List { - return mutableListOf( - KeyValue("--- CUSTOM ---", "BTC/test"), - KeyValue("BTC", "BTC"), - KeyValue("BTC/test", "BTC/test"), - KeyValue("ETH", "ETH"), - KeyValue("ETH/test", "ETH/test"), - KeyValue("BCH", "BCH"), - KeyValue("BCH/test", "BCH/test"), - KeyValue("LTC", "LTC"), - KeyValue("XLM", "XLM"), - KeyValue("XLM/test", "XLM/test"), - KeyValue("RSK", "RSK"), - KeyValue("XPR", "XPR"), - KeyValue("CARDANO", "CARDANO") - ) - } - - fun aarList(): List { - return mutableListOf( - KeyValue("--- CUSTOM ---", ""), - KeyValue("Release APP", "com.some.release"), - KeyValue("Debug APP", "com.some.debug"), - KeyValue("None", "") - ) - } - - fun pauseBeforePin(): List { - return mutableListOf( - KeyValue("immediately", 0), - KeyValue("2 seconds", 2000), - KeyValue("5 seconds", 5000), - KeyValue("15 seconds", 15000), - KeyValue("30 seconds", 30000), - KeyValue("1 minute", 60000), - KeyValue("2 minute", 120000) - ) - } - - fun ndef(ndef: MutableList): Map { - val map = mutableMapOf() - ndef.forEach { map[it.type] = it.value } - return map - } - } -} \ No newline at end of file +) \ No newline at end of file diff --git a/tangem-demo/src/main/java/com/tangem/tangemtest/ucase/variants/personalize/ui/PersonalizeViewModel.kt b/tangem-demo/src/main/java/com/tangem/tangemtest/ucase/variants/personalize/ui/PersonalizeViewModel.kt index a9abce2b64..fdb9557312 100644 --- a/tangem-demo/src/main/java/com/tangem/tangemtest/ucase/variants/personalize/ui/PersonalizeViewModel.kt +++ b/tangem-demo/src/main/java/com/tangem/tangemtest/ucase/variants/personalize/ui/PersonalizeViewModel.kt @@ -8,6 +8,7 @@ import com.google.gson.Gson import com.tangem.tangemtest._arch.structure.abstraction.BaseItem import com.tangem.tangemtest._arch.structure.abstraction.Block import com.tangem.tangemtest.ucase.variants.personalize.converter.BlockToJsonConverter +import com.tangem.tangemtest.ucase.variants.personalize.converter.IdToJsonValues import com.tangem.tangemtest.ucase.variants.personalize.converter.JsonBlockEnDe import com.tangem.tangemtest.ucase.variants.personalize.converter.JsonToBlockConverter import com.tangem.tangemtest.ucase.variants.personalize.dto.TestJsonDto @@ -24,7 +25,8 @@ class PersonalizeViewModel(private val jsonPersonalizeString: String) : ViewMode val ldBlockList: MutableLiveData> by lazy { MutableLiveData(readJson()) } private fun readJson(): List { - val enDe = JsonBlockEnDe(JsonToBlockConverter(), BlockToJsonConverter()) + val idToJsonValues = IdToJsonValues() + val enDe = JsonBlockEnDe(JsonToBlockConverter(idToJsonValues), BlockToJsonConverter()) val jsonDto = Gson().fromJson(jsonPersonalizeString, TestJsonDto::class.java) return enDe.decode(jsonDto) }