backend/services/connection_service.go

@@ -17,7 +17,6 @@ import (
 	"tinyrdm/backend/types"
 	maputil "tinyrdm/backend/utils/map"
 	redis2 "tinyrdm/backend/utils/redis"
-	strutil "tinyrdm/backend/utils/string"
 )
 
 type cmdHistoryItem struct {
@@ -477,7 +476,7 @@ func (c *connectionService) ScanKeys(connName string, db int, match, keyType str
 }
 
 // GetKeyValue get value by key
-func (c *connectionService) GetKeyValue(connName string, db int, key, viewAs string) (resp types.JSResp) {
+func (c *connectionService) GetKeyValue(connName string, db int, key string) (resp types.JSResp) {
 	rdb, ctx, err := c.getRedisClient(connName, db)
 	if err != nil {
 		resp.Msg = err.Error()
@@ -513,9 +512,7 @@ func (c *connectionService) GetKeyValue(connName string, db int, key, viewAs str
 	var cursor uint64
 	switch strings.ToLower(keyType) {
 	case "string":
-		var str string
+		value, err = rdb.Get(ctx, key).Result()
-		str, err = rdb.Get(ctx, key).Result()
-		value, viewAs = strutil.ConvertTo(str, viewAs)
 		size, _ = rdb.StrLen(ctx, key).Result()
 	case "list":
 		value, err = rdb.LRange(ctx, key, 0, -1).Result()
@@ -608,14 +605,13 @@ func (c *connectionService) GetKeyValue(connName string, db int, key, viewAs str
 		"ttl":   ttl,
 		"value": value,
 		"size":  size,
-		"viewAs": viewAs,
 	}
 	return
 }
 
 // SetKeyValue set value by key
 // @param ttl <= 0 means keep current ttl
-func (c *connectionService) SetKeyValue(connName string, db int, key, keyType string, value any, ttl int64, viewAs string) (resp types.JSResp) {
+func (c *connectionService) SetKeyValue(connName string, db int, key, keyType string, value any, ttl int64) (resp types.JSResp) {
 	rdb, ctx, err := c.getRedisClient(connName, db)
 	if err != nil {
 		resp.Msg = err.Error()
@@ -636,12 +632,7 @@ func (c *connectionService) SetKeyValue(connName string, db int, key, keyType st
 			resp.Msg = "invalid string value"
 			return
 		} else {
-			var saveStr string
+			_, err = rdb.Set(ctx, key, str, 0).Result()
-			if saveStr, err = strutil.SaveAs(str, viewAs); err != nil {
-				resp.Msg = fmt.Sprintf(`save to "%s" type fail: %s`, viewAs, err.Error())
-				return
-			}
-			_, err = rdb.Set(ctx, key, saveStr, 0).Result()
 			// set expiration lonely, not "keepttl"
 			if err == nil && expiration > 0 {
 				rdb.Expire(ctx, key, expiration)

backend/services/preferences_service.go

@@ -39,8 +39,8 @@ func (p *preferencesService) GetPreferences() (resp types.JSResp) {
 	return
 }
 
-func (p *preferencesService) SetPreferences(pf types.Preferences) (resp types.JSResp) {
+func (p *preferencesService) SetPreferences(values map[string]any) (resp types.JSResp) {
-	err := p.pref.SetPreferences(&pf)
+	err := p.pref.SetPreferencesN(values)
 	if err != nil {
 		resp.Msg = err.Error()
 		return
@@ -50,16 +50,6 @@ func (p *preferencesService) SetPreferences(pf types.Preferences) (resp types.JS
 	return
 }
 
-func (p *preferencesService) UpdatePreferences(value map[string]any) (resp types.JSResp) {
-	err := p.pref.UpdatePreferences(value)
-	if err != nil {
-		resp.Msg = err.Error()
-		return
-	}
-	resp.Success = true
-	return
-}
-
 func (p *preferencesService) RestorePreferences() (resp types.JSResp) {
 	defaultPref := p.pref.RestoreDefault()
 	resp.Data = map[string]any{
@@ -113,20 +103,23 @@ func (p *preferencesService) GetAppVersion() (resp types.JSResp) {
 }
 
 func (p *preferencesService) SaveWindowSize(width, height int) {
-	p.UpdatePreferences(map[string]any{
+	p.SetPreferences(map[string]any{
-		"behavior.windowWidth":  width,
+		"behavior": map[string]any{
-		"behavior.windowHeight": height,
+			"window_width":  width,
+			"window_height": height,
+		},
 	})
 }
 
 func (p *preferencesService) GetWindowSize() (width, height int) {
 	data := p.pref.GetPreferences()
-	width, height = data.Behavior.WindowWidth, data.Behavior.WindowHeight
+	w, h := data["behavior.window_width"], data["behavior.window_height"]
-	if width <= 0 {
+	var ok bool
-		width = consts.DEFAULT_WINDOW_WIDTH
+	if width, ok = w.(int); !ok {
+		return consts.DEFAULT_WINDOW_WIDTH, consts.DEFAULT_WINDOW_HEIGHT
 	}
-	if height <= 0 {
+	if height, ok = h.(int); !ok {
-		height = consts.DEFAULT_WINDOW_HEIGHT
+		return consts.DEFAULT_WINDOW_WIDTH, consts.DEFAULT_WINDOW_HEIGHT
 	}
 	return
 }

backend/storage/preferences.go

@@ -3,11 +3,9 @@ package storage
 import (
 	"fmt"
 	"gopkg.in/yaml.v3"
-	"log"
-	"reflect"
 	"strings"
 	"sync"
-	"tinyrdm/backend/types"
+	"tinyrdm/backend/consts"
 )
 
 type PreferencesStorage struct {
@@ -21,11 +19,30 @@ func NewPreferences() *PreferencesStorage {
 	}
 }
 
-func (p *PreferencesStorage) DefaultPreferences() types.Preferences {
+func (p *PreferencesStorage) DefaultPreferences() map[string]any {
-	return types.NewPreferences()
+	return map[string]any{
+		"behavior": map[string]any{
+			"aside_width":   consts.DEFAULT_ASIDE_WIDTH,
+			"window_width":  consts.DEFAULT_WINDOW_WIDTH,
+			"window_height": consts.DEFAULT_WINDOW_HEIGHT,
+		},
+		"general": map[string]any{
+			"language":           "auto",
+			"font":               "",
+			"font_size":          consts.DEFAULT_FONT_SIZE,
+			"use_sys_proxy":      false,
+			"use_sys_proxy_http": false,
+			"check_update":       true,
+			"skip_version":       "",
+		},
+		"editor": map[string]any{
+			"font":      "",
+			"font_size": 14,
+		},
+	}
 }
 
-func (p *PreferencesStorage) getPreferences() (ret types.Preferences) {
+func (p *PreferencesStorage) getPreferences() (ret map[string]any) {
 	b, err := p.storage.Load()
 	if err != nil {
 		ret = p.DefaultPreferences()
@@ -39,43 +56,79 @@ func (p *PreferencesStorage) getPreferences() (ret types.Preferences) {
 	return
 }
 
+func (p *PreferencesStorage) flatPreferences(data map[string]any, prefix string) map[string]any {
+	flattened := make(map[string]any)
+	for key, value := range data {
+		newKey := key
+		if prefix != "" {
+			newKey = prefix + "." + key
+		}
+
+		if nested, ok := value.(map[string]any); ok {
+			nestedFlattened := p.flatPreferences(nested, newKey)
+			for k, v := range nestedFlattened {
+				flattened[k] = v
+			}
+		} else {
+			flattened[newKey] = value
+		}
+	}
+	return flattened
+}
+
 // GetPreferences Get preferences from local
-func (p *PreferencesStorage) GetPreferences() (ret types.Preferences) {
+func (p *PreferencesStorage) GetPreferences() (ret map[string]any) {
 	p.mutex.Lock()
 	defer p.mutex.Unlock()
 
-	ret = p.getPreferences()
+	pref := p.getPreferences()
+	ret = p.flatPreferences(pref, "")
 	return
 }
 
-func (p *PreferencesStorage) setPreferences(pf *types.Preferences, key string, value any) error {
+func (p *PreferencesStorage) Value(keys ...string) any {
-	parts := strings.Split(key, ".")
+	kv := p.getPreferences()
-	if len(parts) > 0 {
+	var ok bool
-		var reflectValue reflect.Value
+	var a any
-		if reflect.TypeOf(pf).Kind() == reflect.Ptr {
+	total := len(keys)
-			reflectValue = reflect.ValueOf(pf).Elem()
+	for i, key := range keys {
-		} else {
+		if a, ok = kv[key]; !ok {
-			reflectValue = reflect.ValueOf(pf)
-		}
-		for i, part := range parts {
-			part = strings.ToUpper(part[:1]) + part[1:]
-			reflectValue = reflectValue.FieldByName(part)
-			if reflectValue.IsValid() {
-				if i == len(parts)-1 {
-					reflectValue.Set(reflect.ValueOf(value))
 			return nil
 		}
-			} else {
+		if i == total-1 {
-				break
+			// last key, return value
+			return a
+		}
+		if kv, ok = a.(map[string]any); !ok {
+			return nil
 		}
 	}
-	}
+	return nil
-
-	return fmt.Errorf("invalid key path(%s)", key)
 }
 
-func (p *PreferencesStorage) savePreferences(pf *types.Preferences) error {
+func (p *PreferencesStorage) setPreferences(pf map[string]any, key string, value any) error {
-	b, err := yaml.Marshal(pf)
+	keyPath := strings.Split(key, ".")
+	if len(keyPath) <= 0 {
+		return fmt.Errorf("invalid key path(%s)", key)
+	}
+	var node any = pf
+	for _, k := range keyPath[:len(keyPath)-1] {
+		if subNode, ok := node.(map[string]any); ok {
+			node = subNode[k]
+		} else {
+			return fmt.Errorf("invalid key path(%s)", key)
+		}
+	}
+
+	if subNode, ok := node.(map[string]any); ok {
+		subNode[keyPath[len(keyPath)-1]] = value
+	}
+
+	return nil
+}
+
+func (p *PreferencesStorage) savePreferences(pf map[string]any) error {
+	b, err := yaml.Marshal(&pf)
 	if err != nil {
 		return err
 	}
@@ -86,35 +139,35 @@ func (p *PreferencesStorage) savePreferences(pf *types.Preferences) error {
 	return nil
 }
 
-// SetPreferences replace preferences
+// SetPreferences assign value to key path, the key path use "." to indicate multiple level
-func (p *PreferencesStorage) SetPreferences(pf *types.Preferences) error {
+func (p *PreferencesStorage) SetPreferences(key string, value any) error {
 	p.mutex.Lock()
 	defer p.mutex.Unlock()
 
+	pf := p.getPreferences()
+	if err := p.setPreferences(pf, key, value); err != nil {
+		return err
+	}
 	return p.savePreferences(pf)
 }
 
-// UpdatePreferences update values by key paths, the key path use "." to indicate multiple level
+// SetPreferencesN set multiple key path and value
-func (p *PreferencesStorage) UpdatePreferences(values map[string]any) error {
+func (p *PreferencesStorage) SetPreferencesN(values map[string]any) error {
 	p.mutex.Lock()
 	defer p.mutex.Unlock()
 
 	pf := p.getPreferences()
 	for path, v := range values {
-		if err := p.setPreferences(&pf, path, v); err != nil {
+		if err := p.setPreferences(pf, path, v); err != nil {
 			return err
 		}
 	}
-	log.Println("after save", pf)
 
-	return p.savePreferences(&pf)
+	return p.savePreferences(pf)
 }
 
-func (p *PreferencesStorage) RestoreDefault() types.Preferences {
+func (p *PreferencesStorage) RestoreDefault() map[string]any {
-	p.mutex.Lock()
-	defer p.mutex.Unlock()
-
 	pf := p.DefaultPreferences()
-	p.savePreferences(&pf)
+	p.savePreferences(pf)
-	return pf
+	return p.flatPreferences(pf, "")
 }

backend/types/preferences.go

@@ -1,50 +0,0 @@
-package types
-
-import "tinyrdm/backend/consts"
-
-type Preferences struct {
-	Behavior PreferencesBehavior `json:"behavior" yaml:"behavior"`
-	General  PreferencesGeneral  `json:"general" yaml:"general"`
-	Editor   PreferencesEditor   `json:"editor" yaml:"editor"`
-}
-
-func NewPreferences() Preferences {
-	return Preferences{
-		Behavior: PreferencesBehavior{
-			AsideWidth:   consts.DEFAULT_ASIDE_WIDTH,
-			WindowWidth:  consts.DEFAULT_WINDOW_WIDTH,
-			WindowHeight: consts.DEFAULT_WINDOW_HEIGHT,
-		},
-		General: PreferencesGeneral{
-			Theme:       "auto",
-			Language:    "auto",
-			FontSize:    consts.DEFAULT_FONT_SIZE,
-			CheckUpdate: true,
-		},
-		Editor: PreferencesEditor{
-			FontSize: consts.DEFAULT_FONT_SIZE,
-		},
-	}
-}
-
-type PreferencesBehavior struct {
-	AsideWidth   int `json:"asideWidth" yaml:"aside_width"`
-	WindowWidth  int `json:"windowWidth" yaml:"window_width"`
-	WindowHeight int `json:"windowHeight" yaml:"window_height"`
-}
-
-type PreferencesGeneral struct {
-	Theme           string `json:"theme" yaml:"theme"`
-	Language        string `json:"language" yaml:"language"`
-	Font            string `json:"font" yaml:"font,omitempty"`
-	FontSize        int    `json:"fontSize" yaml:"font_size"`
-	UseSysProxy     bool   `json:"useSysProxy" yaml:"use_sys_proxy,omitempty"`
-	UseSysProxyHttp bool   `json:"useSysProxyHttp" yaml:"use_sys_proxy_http,omitempty"`
-	CheckUpdate     bool   `json:"checkUpdate" yaml:"check_update"`
-	SkipVersion     string `json:"skipVersion" yaml:"skip_version,omitempty"`
-}
-
-type PreferencesEditor struct {
-	Font     string `json:"font" yaml:"font,omitempty"`
-	FontSize int    `json:"fontSize" yaml:"font_size"`
-}

backend/types/view_type.go

@@ -1,11 +0,0 @@
-package types
-
-const PLAIN_TEXT = "Plain Text"
-const JSON = "JSON"
-const BASE64_TEXT = "Base64 Text"
-const BASE64_JSON = "Base64 JSON"
-const HEX = "Hex"
-const BINARY = "Binary"
-const GZIP = "GZip"
-const GZIP_JSON = "GZip JSON"
-const DEFLATE = "Deflate"

backend/utils/string/convert.go

@@ -1,275 +0,0 @@
-package strutil
-
-import (
-	"bytes"
-	"compress/flate"
-	"compress/gzip"
-	"encoding/base64"
-	"encoding/hex"
-	"encoding/json"
-	"errors"
-	"fmt"
-	"io"
-	"log"
-	"strings"
-	"tinyrdm/backend/types"
-)
-
-// ConvertTo convert string to specified type
-// @param targetType  empty string indicates automatic detection of the string type
-func ConvertTo(str, targetType string) (value, resultType string) {
-	if len(str) <= 0 {
-		// empty content
-		if len(targetType) <= 0 {
-			resultType = types.PLAIN_TEXT
-		} else {
-			resultType = targetType
-		}
-		return
-	}
-
-	switch targetType {
-	case types.PLAIN_TEXT:
-		value = str
-		resultType = targetType
-		return
-
-	case types.JSON:
-		value, _ = decodeJson(str)
-		resultType = targetType
-		return
-
-	case types.BASE64_TEXT, types.BASE64_JSON:
-		if base64Str, ok := decodeBase64(str); ok {
-			if targetType == types.BASE64_JSON {
-				value, _ = decodeJson(base64Str)
-			} else {
-				value = base64Str
-			}
-		} else {
-			value = str
-		}
-		resultType = targetType
-		return
-
-	case types.HEX:
-		if hexStr, ok := decodeHex(str); ok {
-			log.Print(hexStr)
-			value = hexStr
-		} else {
-			value = str
-		}
-		resultType = targetType
-		return
-
-	case types.BINARY:
-		var binary strings.Builder
-		for _, char := range str {
-			binary.WriteString(fmt.Sprintf("%08b", int(char)))
-		}
-		value = binary.String()
-		resultType = targetType
-		return
-
-	case types.GZIP, types.GZIP_JSON:
-		if gzipStr, ok := decodeGZip(str); ok {
-			if targetType == types.BASE64_JSON {
-				value, _ = decodeJson(gzipStr)
-			} else {
-				value = gzipStr
-			}
-		} else {
-			value = str
-		}
-		resultType = targetType
-		return
-
-	case types.DEFLATE:
-		value, _ = decodeDeflate(str)
-		resultType = targetType
-		return
-	}
-
-	// type isn't specified or unknown, try to automatically detect and return converted value
-	return autoToType(str)
-}
-
-// attempt automatic convert to possible types
-// if no conversion is possible, it will return the origin string value and "plain text" type
-func autoToType(str string) (value, resultType string) {
-	if len(str) > 0 {
-		var ok bool
-		if value, ok = decodeJson(str); ok {
-			resultType = types.JSON
-			return
-		}
-
-		if value, ok = decodeBase64(str); ok {
-			if value, ok = decodeJson(value); ok {
-				resultType = types.BASE64_JSON
-				return
-			}
-			resultType = types.BASE64_TEXT
-			return
-		}
-
-		if value, ok = decodeGZip(str); ok {
-			resultType = types.GZIP
-			return
-		}
-
-		if value, ok = decodeDeflate(str); ok {
-			resultType = types.DEFLATE
-			return
-		}
-	}
-
-	value = str
-	resultType = types.PLAIN_TEXT
-	return
-}
-
-func decodeJson(str string) (string, bool) {
-	var data any
-	if (strings.HasPrefix(str, "{") && strings.HasSuffix(str, "}")) ||
-		(strings.HasPrefix(str, "[") && strings.HasSuffix(str, "]")) {
-		if err := json.Unmarshal([]byte(str), &data); err == nil {
-			var jsonByte []byte
-			if jsonByte, err = json.MarshalIndent(data, "", "  "); err == nil {
-				return string(jsonByte), true
-			}
-		}
-	}
-	return str, false
-}
-
-func decodeBase64(str string) (string, bool) {
-	if decodedStr, err := base64.StdEncoding.DecodeString(str); err == nil {
-		return string(decodedStr), true
-	}
-	return str, false
-}
-
-func decodeHex(str string) (string, bool) {
-	encodeStr := hex.EncodeToString([]byte(str))
-	var resultStr strings.Builder
-	for i := 0; i < len(encodeStr); i += 2 {
-		resultStr.WriteString("\\x")
-		resultStr.WriteString(encodeStr[i : i+2])
-	}
-	return resultStr.String(), true
-}
-
-func decodeGZip(str string) (string, bool) {
-	if reader, err := gzip.NewReader(strings.NewReader(str)); err == nil {
-		defer reader.Close()
-		var decompressed []byte
-		if decompressed, err = io.ReadAll(reader); err == nil {
-			return string(decompressed), true
-		}
-	}
-	return str, false
-}
-
-func decodeDeflate(str string) (string, bool) {
-	reader := flate.NewReader(strings.NewReader(str))
-	defer reader.Close()
-	if decompressed, err := io.ReadAll(reader); err == nil {
-		return string(decompressed), true
-	}
-	return str, false
-}
-
-func SaveAs(str, targetType string) (value string, err error) {
-	switch targetType {
-	case types.PLAIN_TEXT:
-		return str, nil
-
-	case types.BASE64_TEXT:
-		base64Str, _ := encodeBase64(str)
-		return base64Str, nil
-
-	case types.JSON, types.BASE64_JSON, types.GZIP_JSON:
-		if jsonStr, ok := encodeJson(str); ok {
-			if targetType == types.BASE64_JSON {
-				base64Str, _ := encodeBase64(jsonStr)
-				return base64Str, nil
-			} else {
-				return jsonStr, nil
-			}
-		} else {
-			return str, errors.New("invalid json")
-		}
-
-	case types.GZIP:
-		if gzipStr, ok := encodeGZip(str); ok {
-			return gzipStr, nil
-		} else {
-			return str, errors.New("fail to build gzip data")
-		}
-
-	case types.DEFLATE:
-		if deflateStr, ok := encodeDeflate(str); ok {
-			return deflateStr, nil
-		} else {
-			return str, errors.New("fail to build deflate data")
-		}
-	}
-	return str, errors.New("fail to save with unknown error")
-}
-
-func encodeJson(str string) (string, bool) {
-	var data any
-	if (strings.HasPrefix(str, "{") && strings.HasSuffix(str, "}")) ||
-		(strings.HasPrefix(str, "[") && strings.HasSuffix(str, "]")) {
-		if err := json.Unmarshal([]byte(str), &data); err == nil {
-			var jsonByte []byte
-			if jsonByte, err = json.Marshal(data); err == nil {
-				return string(jsonByte), true
-			}
-		}
-	}
-	return str, false
-}
-
-func encodeBase64(str string) (string, bool) {
-	return base64.StdEncoding.EncodeToString([]byte(str)), true
-}
-
-func encodeGZip(str string) (string, bool) {
-	var compress = func(b []byte) (string, error) {
-		var buf bytes.Buffer
-		writer := gzip.NewWriter(&buf)
-		if _, err := writer.Write([]byte(str)); err != nil {
-			writer.Close()
-			return "", err
-		}
-		writer.Close()
-		return string(buf.Bytes()), nil
-	}
-
-	if gzipStr, err := compress([]byte(str)); err == nil {
-		return gzipStr, true
-	}
-	return str, false
-}
-
-func encodeDeflate(str string) (string, bool) {
-	var compress = func(b []byte) (string, error) {
-		var buf bytes.Buffer
-		writer, err := flate.NewWriter(&buf, flate.DefaultCompression)
-		if err != nil {
-			return "", err
-		}
-		if _, err = writer.Write([]byte(str)); err != nil {
-			writer.Close()
-			return "", err
-		}
-		writer.Close()
-		return string(buf.Bytes()), nil
-	}
-	if deflateStr, err := compress([]byte(str)); err == nil {
-		return deflateStr, true
-	}
-	return str, false
-}

frontend/src/components/content/ContentPane.vue

@@ -98,7 +98,6 @@ const tabContent = computed(() => {
         ttl: tab.ttl,
         value: tab.value,
         size: tab.size || 0,
-        viewAs: tab.viewAs,
     }
 })
 
@@ -123,7 +122,7 @@ const onReloadKey = async () => {
     if (tab == null || isEmpty(tab.key)) {
         return null
     }
-    await connectionStore.loadKeyValue(tab.name, tab.db, tab.key, tab.viewAs)
+    await connectionStore.loadKeyValue(tab.name, tab.db, tab.key)
 }
 </script>
 
@@ -154,8 +153,7 @@ const onReloadKey = async () => {
             :name="tabContent.name"
             :ttl="tabContent.ttl"
             :value="tabContent.value"
-            :size="tabContent.size"
+            :size="tabContent.size" />
-            :view-as="tabContent.viewAs" />
     </div>
 </template>
 

frontend/src/components/content_value/ContentValueString.vue

@@ -8,10 +8,12 @@ import { useThemeVars } from 'naive-ui'
 import { types } from '@/consts/value_view_type.js'
 import Close from '@/components/icons/Close.vue'
 import Edit from '@/components/icons/Edit.vue'
+import { IsJson } from '@/utils/check_string_format.js'
 import { types as redisTypes } from '@/consts/support_redis_type.js'
 import { ClipboardSetText } from 'wailsjs/runtime/runtime.js'
 import { map, toLower } from 'lodash'
 import useConnectionStore from 'stores/connections.js'
+import { fromBase64, fromBase64Json, toBinary, toHex, toJsonText } from '@/utils/string_convert.js'
 
 const i18n = useI18n()
 const themeVars = useThemeVars()
@@ -26,10 +28,6 @@ const props = defineProps({
     },
     value: String,
     size: Number,
-    viewAs: {
-        type: String,
-        default: types.PLAIN_TEXT,
-    },
 })
 
 const viewOption = computed(() =>
@@ -40,15 +38,15 @@ const viewOption = computed(() =>
         }
     }),
 )
-// const viewAs = ref(types.PLAIN_TEXT)
+const viewAs = ref(types.PLAIN_TEXT)
 
 const autoDetectFormat = () => {
     // auto check format when loaded
-    // if (IsJson(props.value)) {
+    if (IsJson(props.value)) {
-    //     viewAs.value = types.JSON
+        viewAs.value = types.JSON
-    // } else {
+    } else {
-    //     viewAs.value = types.PLAIN_TEXT
+        viewAs.value = types.PLAIN_TEXT
-    // }
+    }
 }
 
 onMounted(() => {
@@ -62,25 +60,44 @@ watch(
 )
 
 const keyType = redisTypes.STRING
-const viewLanguage = computed(() => {
+/**
-    switch (props.viewAs) {
+ * view value
+ * @type {ComputedRef<string>}
+ */
+const viewValue = computed(() => {
+    switch (viewAs.value) {
+        case types.PLAIN_TEXT:
+            return props.value
         case types.JSON:
-        case types.BASE64_JSON:
+            return toJsonText(props.value)
+        case types.BASE64_TO_TEXT:
+            return fromBase64(props.value)
+        case types.BASE64_TO_JSON:
+            return fromBase64Json(props.value)
+        case types.HEX:
+            return toHex(props.value)
+        case types.BINARY:
+            return toBinary(props.value)
+        default:
+            return props.value
+    }
+})
+
+const viewLanguage = computed(() => {
+    switch (viewAs.value) {
+        case types.JSON:
+        case types.BASE64_TO_JSON:
             return 'json'
         default:
             return 'plaintext'
     }
 })
 
-const onViewTypeUpdate = (viewType) => {
-    connectionStore.loadKeyValue(props.name, props.db, props.keyPath, viewType)
-}
-
 /**
  * Copy value
  */
 const onCopyValue = () => {
-    ClipboardSetText(props.value)
+    ClipboardSetText(viewValue.value)
         .then((succ) => {
             if (succ) {
                 $message.success(i18n.t('dialogue.copy_succ'))
@@ -94,7 +111,7 @@ const onCopyValue = () => {
 const editValue = ref('')
 const inEdit = ref(false)
 const onEditValue = () => {
-    editValue.value = props.value
+    editValue.value = viewValue.value
     inEdit.value = true
 }
 
@@ -117,7 +134,6 @@ const onSaveValue = async () => {
             toLower(keyType),
             editValue.value,
             -1,
-            props.viewAs,
         )
         if (success) {
             await connectionStore.loadKeyValue(props.name, props.db, props.keyPath)
@@ -139,11 +155,7 @@ const onSaveValue = async () => {
         <content-toolbar :db="props.db" :key-path="keyPath" :key-type="keyType" :server="props.name" :ttl="ttl" />
         <div class="tb2 flex-box-h">
             <n-text>{{ $t('interface.view_as') }}</n-text>
-            <n-select
+            <n-select v-model:value="viewAs" :options="viewOption" style="width: 200px" />
-                :value="props.viewAs"
-                :options="viewOption"
-                style="width: 200px"
-                @update:value="onViewTypeUpdate" />
             <div class="flex-item-expand"></div>
             <n-button-group v-if="!inEdit">
                 <n-button :focusable="false" @click="onCopyValue">
@@ -176,7 +188,7 @@ const onSaveValue = async () => {
         </div>
         <div class="value-wrapper flex-item-expand flex-box-v">
             <n-scrollbar v-if="!inEdit" class="flex-item-expand">
-                <n-code :code="props.value" :language="viewLanguage" show-line-numbers style="cursor: text" word-wrap />
+                <n-code :code="viewValue" :language="viewLanguage" show-line-numbers style="cursor: text" word-wrap />
             </n-scrollbar>
             <n-input
                 v-else

frontend/src/components/dialogs/NewKeyDialog.vue

@@ -1,7 +1,6 @@
 <script setup>
 import { computed, h, reactive, ref, watch } from 'vue'
 import { types, typesColor } from '@/consts/support_redis_type.js'
-import { types as viewTypes } from '@/consts/value_view_type.js'
 import useDialog from 'stores/dialog'
 import { isEmpty, keys, map } from 'lodash'
 import NewStringValue from '@/components/new_value/NewStringValue.vue'
@@ -117,15 +116,7 @@ const onAdd = async () => {
         if (value == null) {
             value = defaultValue[type]
         }
-        const { success, msg, nodeKey } = await connectionStore.setKey(
+        const { success, msg, nodeKey } = await connectionStore.setKey(server, db, key, type, value, ttl)
-            server,
-            db,
-            key,
-            type,
-            value,
-            ttl,
-            viewTypes.PLAIN_TEXT,
-        )
         if (success) {
             // select current key
             tabStore.setSelectedKeys(server, nodeKey)

frontend/src/consts/value_view_type.js

@@ -5,11 +5,8 @@
 export const types = {
     PLAIN_TEXT: 'Plain Text',
     JSON: 'JSON',
-    BASE64_TEXT: 'Base64 Text',
+    BASE64_TO_TEXT: 'Base64 To Text',
-    BASE64_JSON: 'Base64 JSON',
+    BASE64_TO_JSON: 'Base64 To JSON',
     HEX: 'Hex',
     BINARY: 'Binary',
-    GZIP: 'GZip',
-    GZIP_JSON: 'GZip JSON',
-    DEFLATE: 'Deflate',
 }

frontend/src/stores/connections.js

@@ -525,15 +525,14 @@ const useConnectionStore = defineStore('connections', {
          * @param {string} server
          * @param {number} db
          * @param {string} [key] when key is null or blank, update tab to display normal content (blank content or server status)
-         * @param {string} [viewType]
          */
-        async loadKeyValue(server, db, key, viewType) {
+        async loadKeyValue(server, db, key) {
             try {
                 const tab = useTabStore()
                 if (!isEmpty(key)) {
-                    const { data, success, msg } = await GetKeyValue(server, db, key, viewType)
+                    const { data, success, msg } = await GetKeyValue(server, db, key)
                     if (success) {
-                        const { type, ttl, value, size, viewAs } = data
+                        const { type, ttl, value, size } = data
                         tab.upsertTab({
                             server,
                             db,
@@ -542,16 +541,11 @@ const useConnectionStore = defineStore('connections', {
                             key,
                             value,
                             size,
-                            viewAs,
                         })
                         return
                     } else {
-                        if (!isEmpty(msg)) {
-                            $message.error('load key fail: ' + msg)
-                        }
                         // its danger to delete "non-exists" key, just remove from tree view
                         await this.deleteKey(server, db, key, true)
-                        // TODO: show key not found page?
                     }
                 }
 
@@ -858,12 +852,11 @@ const useConnectionStore = defineStore('connections', {
          * @param {string} keyType
          * @param {any} value
          * @param {number} ttl
-         * @param {string} [viewAs]
          * @returns {Promise<{[msg]: string, success: boolean, [nodeKey]: {string}}>}
          */
-        async setKey(connName, db, key, keyType, value, ttl, viewAs) {
+        async setKey(connName, db, key, keyType, value, ttl) {
             try {
-                const { data, success, msg } = await SetKeyValue(connName, db, key, keyType, value, ttl, viewAs)
+                const { data, success, msg } = await SetKeyValue(connName, db, key, keyType, value, ttl)
                 if (success) {
                     // update tree view data
                     const { newKey = 0 } = this._addKeyNodes(connName, db, [key], true)

frontend/src/stores/preferences.js

@@ -1,6 +1,6 @@
 import { defineStore } from 'pinia'
 import { lang } from '@/langs/index.js'
-import { clone, find, get, isEmpty, map, pick, set, split } from 'lodash'
+import { camelCase, clone, find, get, isEmpty, isObject, map, set, snakeCase, split } from 'lodash'
 import {
     CheckForUpdate,
     GetFontList,
@@ -38,7 +38,7 @@ const usePreferencesStore = defineStore('preferences', {
         },
         general: {
             theme: 'auto',
-            language: 'auto',
+            language: 'en',
             font: '',
             fontSize: 14,
             useSysProxy: false,
@@ -165,7 +165,8 @@ const usePreferencesStore = defineStore('preferences', {
     actions: {
         _applyPreferences(data) {
             for (const key in data) {
-                set(this, key, data[key])
+                const keys = map(split(key, '.'), camelCase)
+                set(this, keys, data[key])
             }
         },
 
@@ -202,13 +203,30 @@ const usePreferencesStore = defineStore('preferences', {
          * @returns {Promise<boolean>}
          */
         async savePreferences() {
-            const pf = pick(this, ['behavior', 'general', 'editor'])
+            const obj2Map = (prefix, obj) => {
+                const result = {}
+                for (const key in obj) {
+                    if (isObject(obj[key])) {
+                        const subResult = obj2Map(`${prefix}.${snakeCase(key)}`, obj[key])
+                        Object.assign(result, subResult)
+                    } else {
+                        result[`${prefix}.${snakeCase(key)}`] = obj[key]
+                    }
+                }
+                return result
+            }
+            const pf = Object.assign(
+                {},
+                obj2Map('behavior', this.behavior),
+                obj2Map('general', this.general),
+                obj2Map('editor', this.editor),
+            )
             const { success, msg } = await SetPreferences(pf)
             return success === true
         },
 
         /**
-         * reset to last-loaded preferences
+         * reset to last loaded preferences
          * @returns {Promise<void>}
          */
         async resetToLastPreferences() {

frontend/src/stores/tab.js

@@ -85,9 +85,8 @@ const useTabStore = defineStore('tab', {
          * @param {string} [key]
          * @param {number} [size]
          * @param {*} [value]
-         * @param {string} [viewAs]
          */
-        upsertTab({ server, db, type, ttl, key, size, value, viewAs }) {
+        upsertTab({ server, db, type, ttl, key, size, value }) {
             let tabIndex = findIndex(this.tabList, { name: server })
             if (tabIndex === -1) {
                 this.tabList.push({
@@ -99,7 +98,6 @@ const useTabStore = defineStore('tab', {
                     key,
                     size,
                     value,
-                    viewAs,
                 })
                 tabIndex = this.tabList.length - 1
             }
@@ -114,7 +112,6 @@ const useTabStore = defineStore('tab', {
             tab.key = key
             tab.size = size
             tab.value = value
-            tab.viewAs = viewAs
             this._setActivatedIndex(tabIndex, true)
             // this.activatedTab = tab.name
         },

frontend/src/utils/check_string_format.js

@@ -0,0 +1,25 @@
+import { endsWith, isEmpty, size, startsWith } from 'lodash'
+
+export const IsRedisKey = (str, separator) => {
+    if (isEmpty(separator)) {
+        separator = ':'
+    }
+}
+
+/**
+ * check string is json
+ * @param str
+ * @returns {boolean}
+ * @constructor
+ */
+export const IsJson = (str) => {
+    if (size(str) >= 2) {
+        if (startsWith(str, '{') && endsWith(str, '}')) {
+            return true
+        }
+        if (startsWith(str, '[') && endsWith(str, ']')) {
+            return true
+        }
+    }
+    return false
+}

frontend/src/utils/string_convert.js

@@ -0,0 +1,70 @@
+import { map, padStart } from 'lodash'
+
+/**
+ * convert string to json
+ * @param str
+ * @return {string}
+ */
+export const toJsonText = (str) => {
+    try {
+        const jsonObj = JSON.parse(str)
+        return JSON.stringify(jsonObj, null, 2)
+    } catch (e) {
+        return str
+    }
+}
+
+/**
+ * convert string from base64
+ * @param str
+ * @return {string}
+ */
+export const fromBase64 = (str) => {
+    try {
+        return atob(str)
+    } catch (e) {
+        return str
+    }
+}
+
+/**
+ * convert string from base64 to json
+ * @param str
+ * @return {string}
+ */
+export const fromBase64Json = (str) => {
+    try {
+        const text = atob(str)
+        const jsonObj = JSON.parse(text)
+        return JSON.stringify(jsonObj, null, 2)
+    } catch (e) {
+        return str
+    }
+}
+
+/**
+ * convert string to hex string
+ * @param str
+ * @return {string}
+ */
+export const toHex = (str) => {
+    const hexArr = map(str, (char) => {
+        const charCode = char.charCodeAt(0)
+        return charCode.toString(16)
+    })
+    return hexArr.join(' ')
+}
+
+/**
+ * convert string to binary string
+ * @param str
+ * @return {string}
+ */
+export const toBinary = (str) => {
+    const codeUnits = map(str, (char) => {
+        let code = char.charCodeAt(0).toString(2)
+        code = padStart(code, 8, '0')
+        return code
+    })
+    return codeUnits.join(' ')
+}

main.go

@@ -57,16 +57,6 @@ func main() {
 			app.startup(ctx)
 			connSvc.Start(ctx)
 		},
-		//OnBeforeClose: func(ctx context.Context) (prevent bool) {
-		//	// save current window size
-		//	width, height := runtime2.WindowGetSize(ctx)
-		//	if width > 0 && height > 0 {
-		//		if w, h := prefSvc.GetWindowSize(); w != width || h != height {
-		//			prefSvc.SaveWindowSize(width, height)
-		//		}
-		//	}
-		//	return false
-		//},
 		OnShutdown: func(ctx context.Context) {
 			// save current window size
 			width, height := runtime2.WindowGetSize(ctx)