Use the default vouchersResp

handlers/application/menuhandler.go

@@ -193,9 +193,8 @@ func (h *MenuHandlers) createAccountNoExist(ctx context.Context, sessionId strin
 	publicKey := r.PublicKey
 
 	data := map[storedb.DataTyp]string{
-		storedb.DATA_TRACKING_ID:   trackingId,
-		storedb.DATA_PUBLIC_KEY:    publicKey,
-		storedb.DATA_ACCOUNT_ALIAS: "",
+		storedb.DATA_TRACKING_ID: trackingId,
+		storedb.DATA_PUBLIC_KEY:  publicKey,
 	}
 	store := h.userdataStore
 	for key, value := range data {
@@ -1461,7 +1460,7 @@ func loadUserContent(ctx context.Context, activeSym string, balance string, alia
 	if alias != "" {
 		content = l.Get("%s balance: %s\n", alias, balStr)
 	} else {
-		content = l.Get("Balance: %s\n", balStr)
+		content = l.Get("balance: %s\n", balStr)
 	}
 	return content, nil
 }
@@ -1483,24 +1482,6 @@ func (h *MenuHandlers) CheckBalance(ctx context.Context, sym string, input []byt
 
 	store := h.userdataStore
 
-	// get the active sym and active balance
-	activeSym, err := store.ReadEntry(ctx, sessionId, storedb.DATA_ACTIVE_SYM)
-	if err != nil {
-		logg.InfoCtxf(ctx, "could not find the activeSym in checkBalance:", "err", err)
-		if !db.IsNotFound(err) {
-			logg.ErrorCtxf(ctx, "failed to read activeSym entry with", "key", storedb.DATA_ACTIVE_SYM, "error", err)
-			return res, err
-		}
-	}
-
-	activeBal, err := store.ReadEntry(ctx, sessionId, storedb.DATA_ACTIVE_BAL)
-	if err != nil {
-		if !db.IsNotFound(err) {
-			logg.ErrorCtxf(ctx, "failed to read activeBal entry with", "key", storedb.DATA_ACTIVE_BAL, "error", err)
-			return res, err
-		}
-	}
-
 	accAlias, err := store.ReadEntry(ctx, sessionId, storedb.DATA_ACCOUNT_ALIAS)
 	if err != nil {
 		if !db.IsNotFound(err) {
@@ -1511,6 +1492,27 @@ func (h *MenuHandlers) CheckBalance(ctx context.Context, sym string, input []byt
 		alias = strings.Split(string(accAlias), ".")[0]
 	}
 
+	// get the active sym and active balance
+	activeSym, err := store.ReadEntry(ctx, sessionId, storedb.DATA_ACTIVE_SYM)
+	if err != nil {
+		fmt.Println("could not find the activeSym in checkBalance:", err)
+		if !db.IsNotFound(err) {
+			fmt.Println("the err:", err)
+			logg.ErrorCtxf(ctx, "failed to read activeSym entry with", "key", storedb.DATA_ACTIVE_SYM, "error", err)
+			return res, err
+		}
+	}
+
+	fmt.Println("The active data in CheckBalance:", string(activeSym))
+
+	activeBal, err := store.ReadEntry(ctx, sessionId, storedb.DATA_ACTIVE_BAL)
+	if err != nil {
+		if !db.IsNotFound(err) {
+			logg.ErrorCtxf(ctx, "failed to read activeBal entry with", "key", storedb.DATA_ACTIVE_BAL, "error", err)
+			return res, err
+		}
+	}
+
 	content, err = loadUserContent(ctx, string(activeSym), string(activeBal), alias)
 	if err != nil {
 		return res, err
@@ -1940,8 +1942,12 @@ func (h *MenuHandlers) SetDefaultVoucher(ctx context.Context, sym string, input
 	flag_no_active_voucher, _ := h.flagManager.GetFlag("flag_no_active_voucher")
 
 	// check if the user has an active sym
-	_, err := userStore.ReadEntry(ctx, sessionId, storedb.DATA_ACTIVE_SYM)
+	activeSym, err := userStore.ReadEntry(ctx, sessionId, storedb.DATA_ACTIVE_SYM)
+	fmt.Println("The activeSym in SetDefaultVoucher:", string(activeSym))
 	if err != nil {
+		fmt.Println("The err", err)
+		fmt.Println("Checking the data as no activeSym", "DATA_ACTIVE_SYM", storedb.DATA_ACTIVE_SYM)
+
 		if db.IsNotFound(err) {
 			publicKey, err := userStore.ReadEntry(ctx, sessionId, storedb.DATA_PUBLIC_KEY)
 			if err != nil {
@@ -1952,12 +1958,25 @@ func (h *MenuHandlers) SetDefaultVoucher(ctx context.Context, sym string, input
 			// Fetch vouchers from the API using the public key
 			vouchersResp, err := h.accountService.FetchVouchers(ctx, string(publicKey))
 			if err != nil {
+				fmt.Println("setting the flag_no_active_voucher")
 				res.FlagSet = append(res.FlagSet, flag_no_active_voucher)
 				return res, nil
 			}
 
+			// vouchersResp := []dataserviceapi.TokenHoldings{
+			// 	{
+			// 		ContractAddress: "0xcB453B742Bc8BE1BAa03Ce1927e287788d0aF065",
+			// 		TokenSymbol:     "PES",
+			// 		TokenDecimals:   "6",
+			// 		Balance:         "10000000",
+			// 	},
+			// }
+
+			fmt.Println("fetched user vouchers in SetDefaultVoucher", "public_key", string(publicKey), "vouchers", vouchersResp)
+
 			// Return if there is no voucher
 			if len(vouchersResp) == 0 {
+				fmt.Println("setting the flag_no_active_voucher in SetDefaultVoucher")
 				res.FlagSet = append(res.FlagSet, flag_no_active_voucher)
 				return res, nil
 			}
@@ -1972,10 +1991,14 @@ func (h *MenuHandlers) SetDefaultVoucher(ctx context.Context, sym string, input
 			// Scale down the balance
 			scaledBalance := store.ScaleDownBalance(defaultBal, defaultDec)
 
+			fmt.Println("firstVoucher data", "defaultSym", defaultSym, "defaultBal", defaultBal, "defaultDec", defaultDec, "defaultAddr", defaultAddr)
+
 			// TODO: implement atomic transaction
 			// set the active symbol
 			err = userStore.WriteEntry(ctx, sessionId, storedb.DATA_ACTIVE_SYM, []byte(defaultSym))
 			if err != nil {
+				fmt.Println("got an error in writing DATA_ACTIVE_SYM", "defaultSym", defaultSym)
+
 				logg.ErrorCtxf(ctx, "failed to write defaultSym entry with", "key", storedb.DATA_ACTIVE_SYM, "value", defaultSym, "error", err)
 				return res, err
 			}
@@ -2001,7 +2024,7 @@ func (h *MenuHandlers) SetDefaultVoucher(ctx context.Context, sym string, input
 			return res, nil
 		}
 
-		logg.ErrorCtxf(ctx, "failed to read activeSym entry with", "key", storedb.DATA_ACTIVE_SYM, "error", err)
+		fmt.Println("failed to read activeSym entry with", "key", storedb.DATA_ACTIVE_SYM, "error", err)
 		return res, err
 	}
 
@@ -2032,7 +2055,16 @@ func (h *MenuHandlers) CheckVouchers(ctx context.Context, sym string, input []by
 		return res, nil
 	}
 
-	logg.InfoCtxf(ctx, "fetched user vouchers", "public_key", string(publicKey), "vouchers", vouchersResp)
+	// vouchersResp := []dataserviceapi.TokenHoldings{
+	// 	{
+	// 		ContractAddress: "0xcB453B742Bc8BE1BAa03Ce1927e287788d0aF065",
+	// 		TokenSymbol:     "PES",
+	// 		TokenDecimals:   "6",
+	// 		Balance:         "10000000",
+	// 	},
+	// }
+
+	fmt.Println("fetched user vouchers", "public_key", string(publicKey), "vouchers", vouchersResp)
 
 	// check the current active sym and update the data
 	activeSym, _ := userStore.ReadEntry(ctx, sessionId, storedb.DATA_ACTIVE_SYM)
@@ -2069,10 +2101,12 @@ func (h *MenuHandlers) CheckVouchers(ctx context.Context, sym string, input []by
 	activeBal, _ := userStore.ReadEntry(ctx, sessionId, storedb.DATA_ACTIVE_BAL)
 	activeAddr, _ := userStore.ReadEntry(ctx, sessionId, storedb.DATA_ACTIVE_ADDRESS)
 
-	logg.InfoCtxf(ctx, "The active data in CheckVouchers:", "activeSym", string(activeSym), string(activeBal), string(activeAddr))
+	fmt.Println(ctx, "The active data in CheckVouchers:", "activeSym", string(activeSym), string(activeBal), string(activeAddr))
 
 	data := store.ProcessVouchers(vouchersResp)
 
+	fmt.Println(ctx, "The data in CheckVouchers:", "data", data)
+
 	// Store all voucher data
 	dataMap := map[storedb.DataTyp]string{
 		storedb.DATA_VOUCHER_SYMBOLS:   data.Symbols,
@@ -2081,44 +2115,25 @@ func (h *MenuHandlers) CheckVouchers(ctx context.Context, sym string, input []by
 		storedb.DATA_VOUCHER_ADDRESSES: data.Addresses,
 	}
 
-	// Write data entries
 	for key, value := range dataMap {
-		if err := userStore.WriteEntry(ctx, sessionId, key, []byte(value)); err != nil {
-			logg.ErrorCtxf(ctx, "Failed to write data entry for sessionId: %s", sessionId, "key", key, "error", err)
-			continue
+		if err := h.prefixDb.Put(ctx, []byte(storedb.ToBytes(key)), []byte(value)); err != nil {
+			return res, nil
 		}
 	}
 
-	// for key, value := range dataMap {
-	// 	if err := h.prefixDb.Put(ctx, []byte(storedb.ToBytes(key)), []byte(value)); err != nil {
-	// 		return res, nil
-	// 	}
-	// }
-
 	return res, nil
 }
 
 // GetVoucherList fetches the list of vouchers and formats them.
 func (h *MenuHandlers) GetVoucherList(ctx context.Context, sym string, input []byte) (resource.Result, error) {
 	var res resource.Result
-	sessionId, ok := ctx.Value("SessionId").(string)
-	if !ok {
-		return res, fmt.Errorf("missing session")
-	}
-
-	userStore := h.userdataStore
 
 	// Read vouchers from the store
-	voucherData, err := userStore.ReadEntry(ctx, sessionId, storedb.DATA_VOUCHER_SYMBOLS)
+	voucherData, err := h.prefixDb.Get(ctx, storedb.ToBytes(storedb.DATA_VOUCHER_SYMBOLS))
 	if err != nil {
-		logg.ErrorCtxf(ctx, "failed to read voucherData entires with", "key", storedb.DATA_VOUCHER_SYMBOLS, "error", err)
+		logg.ErrorCtxf(ctx, "Failed to read the voucherData from prefixDb", "error", err)
 		return res, err
 	}
-	// voucherData, err := h.prefixDb.Get(ctx, storedb.ToBytes(storedb.DATA_VOUCHER_SYMBOLS))
-	// if err != nil {
-	// 	logg.ErrorCtxf(ctx, "Failed to read the voucherData from prefixDb", "error", err)
-	// 	return res, err
-	// }
 
 	formattedData := h.ReplaceSeparatorFunc(string(voucherData))
 
@@ -2148,7 +2163,7 @@ func (h *MenuHandlers) ViewVoucher(ctx context.Context, sym string, input []byte
 		return res, nil
 	}
 
-	metadata, err := store.GetVoucherData(ctx, h.userdataStore, sessionId, inputStr)
+	metadata, err := store.GetVoucherData(ctx, h.prefixDb, inputStr)
 	if err != nil {
 		return res, fmt.Errorf("failed to retrieve voucher data: %v", err)
 	}

handlers/application/menuhandler_test.go

@@ -1727,7 +1727,7 @@ func TestCheckBalance(t *testing.T) {
 			publicKey:      "0X98765432109",
 			activeSym:      "ETH",
 			activeBal:      "1.5",
-			expectedResult: resource.Result{Content: "Balance: 1.50 ETH\n"},
+			expectedResult: resource.Result{Content: "balance: 1.50 ETH\n"},
 			expectError:    false,
 		},
 	}

store/vouchers.go

@@ -68,7 +68,7 @@ func ScaleDownBalance(balance, decimals string) string {
 }
 
 // GetVoucherData retrieves and matches voucher data
-func GetVoucherData(ctx context.Context, store DataStore, sessionId string, input string) (*dataserviceapi.TokenHoldings, error) {
+func GetVoucherData(ctx context.Context, db storedb.PrefixDb, input string) (*dataserviceapi.TokenHoldings, error) {
 	keys := []storedb.DataTyp{
 		storedb.DATA_VOUCHER_SYMBOLS,
 		storedb.DATA_VOUCHER_BALANCES,
@@ -78,9 +78,9 @@ func GetVoucherData(ctx context.Context, store DataStore, sessionId string, inpu
 	data := make(map[storedb.DataTyp]string)
 
 	for _, key := range keys {
-		value, err := store.ReadEntry(ctx, sessionId, key)
+		value, err := db.Get(ctx, storedb.ToBytes(key))
 		if err != nil {
-			return nil, fmt.Errorf("failed to get data key %x: %v", key, err)
+			return nil, fmt.Errorf("failed to get prefix key %x: %v", storedb.ToBytes(key), err)
 		}
 		data[key] = string(value)
 	}