feat: string http operation first version

core_string.go

@@ -0,0 +1,66 @@
+package nutshttp
+
+import "github.com/xujiajun/nutsdb"
+
+// Update handle insert and update operation
+func (c *core) Update(bucket string, key string, value string, ttl uint32) error {
+	err := c.db.Update(func(tx *nutsdb.Tx) error {
+		err := tx.Put(bucket, []byte(key), []byte(value), ttl)
+		return err
+	})
+	return err
+}
+
+// Delete handle delete operation
+func (c *core) Delete(bucket string, key string) error {
+	err := c.db.Update(func(tx *nutsdb.Tx) error {
+		err := tx.Delete(bucket, []byte(key))
+		return err
+	})
+	return err
+}
+
+// Get handle get key operation
+func (c *core) Get(bucket string, key string) (value string, err error) {
+	err = c.db.View(func(tx *nutsdb.Tx) error {
+		entry, err := tx.Get(bucket, []byte(key))
+		if err != nil {
+			return err
+		}
+		value = string(entry.Value)
+		return nil
+	})
+	return value, err
+}
+
+func (c *core) PrefixScan(bucket string, prefix string, offSet int, limNum int) (entries nutsdb.Entries, err error) {
+	err = c.db.View(func(tx *nutsdb.Tx) error {
+		entries, _, err = tx.PrefixScan(bucket, []byte(prefix), offSet, limNum)
+		return err
+	})
+	return entries, err
+}
+
+func (c *core) PrefixSearchScan(bucket, prefix string, reg string, offSet int, limNum int) (entries nutsdb.Entries, err error) {
+	err = c.db.View(func(tx *nutsdb.Tx) error {
+		entries, _, err = tx.PrefixSearchScan(bucket, []byte(prefix), reg, offSet, limNum)
+		return err
+	})
+	return entries, err
+}
+
+func (c *core) RangeScan(bucket string, start string, end string) (entries nutsdb.Entries, err error) {
+	err = c.db.View(func(tx *nutsdb.Tx) error {
+		entries, err = tx.RangeScan(bucket, []byte(start), []byte(end))
+		return err
+	})
+	return entries, err
+}
+
+func (c *core) GetAll(bucket string) (entries nutsdb.Entries, err error) {
+	err = c.db.View(func(tx *nutsdb.Tx) error {
+		entries, err = tx.GetAll(bucket)
+		return err
+	})
+	return entries, err
+}

response.go

@@ -17,6 +17,12 @@ var (
 	ErrBadRequest          = APIMessage{Code: 400, Message: "Bad Request"}
 	ErrNotFound            = APIMessage{404, "Not Found"}
 	ErrInternalServerError = APIMessage{500, "Internal Server Error"}
+	ErrKeyNotFoundInBucket = APIMessage{40001, "Key Not Found In Bucket"}
+	ErrPrefixScan          = APIMessage{40002, "Prefix Scans Not Found"}
+	ErrPrefixSearchScan    = APIMessage{40003, "Prefix Search Scans Not Found"}
+	ErrRangeScan           = APIMessage{40004, "Range Scans Not Found"}
+	ErrBucketEmpty         = APIMessage{40005, "Bucket Empty"}
+	ErrUnknown             = APIMessage{40404, "UnKnown Err"}
 )
 
 type Response struct {
@@ -35,7 +41,7 @@ func WriteSucc(c *gin.Context, data interface{}) {
 }
 
 func WriteError(c *gin.Context, msg APIMessage) {
-	c.JSON(msg.Code, Response{
+	c.JSON(http.StatusOK, Response{
 		Code:  msg.Code,
 		Error: msg.Message,
 	})

router_string.go

@@ -0,0 +1,13 @@
+package nutshttp
+
+func (s *NutsHTTPServer) initStringRouter() {
+	sr := s.r.Group("/string")
+
+	sr.GET("get/:bucket/:key", s.Get)
+
+	sr.POST("update/:bucket/:key", s.Update)
+
+	sr.POST("delete/:bucket/:key", s.Delete)
+
+	sr.GET("scan/:bucket/:scanType", s.Scan)
+}

server.go

@@ -35,6 +35,8 @@ func (s *NutsHTTPServer) initRouter() {
 	s.initSetRouter()
 
 	s.initListRouter()
+
+	s.initStringRouter()
 }
 
 func (s *NutsHTTPServer) initListRouter() {

server_string.go

@@ -0,0 +1,243 @@
+package nutshttp
+
+import (
+	"github.com/gin-gonic/gin"
+	"github.com/xujiajun/nutsdb"
+)
+
+func (s *NutsHTTPServer) Get(c *gin.Context) {
+	var (
+		err     error
+		baseUri BaseUri
+	)
+
+	if err = c.ShouldBindUri(&baseUri); err != nil {
+		WriteError(c, APIMessage{
+			Message: err.Error(),
+		})
+		return
+	}
+
+	value, err := s.core.Get(baseUri.Bucket, baseUri.Key)
+	if err != nil {
+		switch err {
+		case nutsdb.ErrNotFoundKey:
+			WriteError(c, ErrKeyNotFoundInBucket)
+		default:
+			WriteError(c, ErrUnknown)
+		}
+		return
+	}
+
+	WriteSucc(c, value)
+
+}
+
+func (s *NutsHTTPServer) Update(c *gin.Context) {
+	type UpdateStringRequest struct {
+		Value string `json:"value" binding:"required"`
+		Ttl   uint32 `json:"ttl"`
+	}
+	var (
+		err                 error
+		baseUri             BaseUri
+		updateStringRequest UpdateStringRequest
+	)
+
+	if err = c.ShouldBindUri(&baseUri); err != nil {
+		WriteError(c, APIMessage{
+			Message: err.Error(),
+		})
+		return
+	}
+
+	if err = c.ShouldBindJSON(&updateStringRequest); err != nil {
+		WriteError(c, APIMessage{
+			Message: err.Error(),
+		})
+		return
+	}
+
+	err = s.core.Update(baseUri.Bucket, baseUri.Key, updateStringRequest.Value, updateStringRequest.Ttl)
+	if err != nil {
+		switch err {
+		case nutsdb.ErrNotFoundKey:
+			WriteError(c, ErrKeyNotFoundInBucket)
+		default:
+			WriteError(c, ErrUnknown)
+		}
+		return
+	}
+	WriteSucc(c, struct{}{})
+}
+
+func (s *NutsHTTPServer) Delete(c *gin.Context) {
+	var (
+		err     error
+		baseUri BaseUri
+	)
+
+	if err = c.ShouldBindUri(&baseUri); err != nil {
+		WriteError(c, APIMessage{
+			Message: err.Error(),
+		})
+		return
+	}
+
+	_, err = s.core.Get(baseUri.Bucket, baseUri.Key)
+	if err != nil {
+		switch err {
+		case nutsdb.ErrNotFoundKey:
+			WriteError(c, ErrKeyNotFoundInBucket)
+		default:
+			WriteError(c, ErrUnknown)
+		}
+		return
+	}
+
+	err = s.core.Delete(baseUri.Bucket, baseUri.Key)
+
+	if err != nil {
+		switch err {
+		case nutsdb.ErrKeyEmpty:
+			WriteError(c, ErrKeyNotFoundInBucket)
+		default:
+			WriteError(c, ErrUnknown)
+		}
+		return
+	}
+	WriteSucc(c, struct{}{})
+}
+
+func (s *NutsHTTPServer) Scan(c *gin.Context) {
+	const (
+		PrefixScan       = "prefixScan"
+		PrefixSearchScan = "prefixSearchScan"
+		RangeScan        = "rangeScan"
+		GetAll           = "getAll"
+	)
+
+	type ScanParam struct {
+		Bucket   string `uri:"bucket" binding:"required"`
+		ScanType string `uri:"scanType" binding:"required"`
+	}
+
+	var (
+		err       error
+		entries   nutsdb.Entries
+		scanParam ScanParam
+	)
+
+	if err = c.ShouldBindUri(&scanParam); err != nil {
+		WriteError(c, APIMessage{
+			Message: err.Error(),
+		})
+		return
+	}
+
+	switch scanParam.ScanType {
+	case PrefixScan:
+		type ScanRequest struct {
+			OffSet   *int    `json:"offSet"  binding:"required"`
+			LimitNum *int    `json:"limitNum"  binding:"required"`
+			Prefix   *string `json:"prefix" binding:"required"`
+		}
+
+		var scanReq ScanRequest
+		if err = c.ShouldBindJSON(&scanReq); err != nil {
+			WriteError(c, APIMessage{
+				Message: err.Error(),
+			})
+			return
+		}
+		entries, err = s.core.PrefixScan(scanParam.Bucket, *scanReq.Prefix, *scanReq.OffSet, *scanReq.LimitNum)
+		if err != nil {
+			switch err {
+			case nutsdb.ErrPrefixScan:
+				WriteError(c, ErrPrefixScan)
+			default:
+				WriteError(c, ErrUnknown)
+			}
+			return
+		}
+		var res = map[string]string{}
+		for _, e := range entries {
+			res[string(e.Key)] = string(e.Value)
+		}
+		WriteSucc(c, res)
+	case PrefixSearchScan:
+		type ScanSearchReq struct {
+			OffSet   *int    `json:"offSet"  binding:"required"`
+			LimitNum *int    `json:"limitNum"  binding:"required"`
+			Prefix   *string `json:"prefix" binding:"required"`
+			Reg      *string `json:"reg" binding:"required"`
+		}
+		var scanSearchReq ScanSearchReq
+		if err = c.ShouldBindJSON(&scanSearchReq); err != nil {
+			WriteError(c, APIMessage{
+				Message: err.Error(),
+			})
+			return
+		}
+		entries, err = s.core.PrefixSearchScan(scanParam.Bucket, *scanSearchReq.Prefix, *scanSearchReq.Reg, *scanSearchReq.OffSet, *scanSearchReq.LimitNum)
+		if err != nil {
+			switch err {
+			case nutsdb.ErrPrefixSearchScan:
+				WriteError(c, ErrPrefixSearchScan)
+			default:
+				WriteError(c, ErrUnknown)
+			}
+			return
+		}
+		var res = map[string]string{}
+		for _, e := range entries {
+			res[string(e.Key)] = string(e.Value)
+		}
+		WriteSucc(c, res)
+	case RangeScan:
+		type RangeScanReq struct {
+			Start *string `json:"start" binding:"required"`
+			End   *string `json:"end" binding:"required"`
+		}
+		var rangeScanReq RangeScanReq
+		if err = c.ShouldBindJSON(&rangeScanReq); err != nil {
+			WriteError(c, APIMessage{
+				Message: err.Error(),
+			})
+			return
+		}
+		entries, err = s.core.RangeScan(scanParam.Bucket, *rangeScanReq.Start, *rangeScanReq.End)
+		if err != nil {
+			switch err {
+			case nutsdb.ErrRangeScan:
+				WriteError(c, ErrRangeScan)
+			default:
+				WriteError(c, ErrUnknown)
+			}
+			return
+		}
+		var res = map[string]string{}
+		for _, e := range entries {
+			res[string(e.Key)] = string(e.Value)
+		}
+		WriteSucc(c, res)
+	case GetAll:
+		entries, err = s.core.GetAll(scanParam.Bucket)
+		if err != nil {
+			switch err {
+			case nutsdb.ErrBucketEmpty:
+				WriteError(c, ErrBucketEmpty)
+			default:
+				WriteError(c, ErrUnknown)
+			}
+			return
+		}
+		var res = map[string]string{}
+		for _, e := range entries {
+			res[string(e.Key)] = string(e.Value)
+		}
+		WriteSucc(c, res)
+	}
+
+	return
+}