implement new json_data model

dbm/db.go

@@ -0,0 +1,25 @@
+package dbm
+
+import (
+	"fmt"
+	"net/http"
+	"time"
+
+	"github.com/gin-gonic/gin"
+	json_dataModels "github.com/tecamino/tecamino-json_data/models"
+)
+
+func (d *DBMHandler) SaveData(c *gin.Context) {
+	s := time.Now()
+	if err := d.SaveDb(); err != nil {
+		r := json_dataModels.NewResponse()
+		r.SendError(err.Error())
+		c.JSON(http.StatusBadRequest, r)
+
+		return
+	}
+
+	r := json_dataModels.NewResponse()
+	r.SendMessage(fmt.Sprintf("DBM %ddatapints saved in: %v", d.GetNumbersOfDatapoints(), time.Since(s)))
+	c.JSON(http.StatusOK, r)
+}

dbm/dbmHandler.go

@@ -2,24 +2,23 @@ package dbm
 
 import (
 	"bufio"
-	"context"
 	"encoding/json"
 	"fmt"
 	"os"
-	"runtime"
 	"sync"
 	"time"
 
+	"github.com/tecamino/tecamino-dbm/args"
+	"github.com/tecamino/tecamino-dbm/models"
+	serverModels "github.com/tecamino/tecamino-dbm/server/models"
+	json_dataModels "github.com/tecamino/tecamino-json_data/models"
 	"github.com/tecamino/tecamino-logger/logging"
-	"github.com/zuadi/tecamino-dbm/args"
-	"github.com/zuadi/tecamino-dbm/models"
-	serverModels "github.com/zuadi/tecamino-dbm/server/models"
 )
 
 type DBMHandler struct {
 	filePath string
 	DB       models.Datapoint
-	Clients  serverModels.Clients
+	Conns    *serverModels.Connections
 	sync.RWMutex
 	Log *logging.Logger
 	arg *args.Args
@@ -40,14 +39,14 @@ func NewDbmHandler(a *args.Args) (*DBMHandler, error) {
 	if err != nil {
 		return nil, err
 	}
-	logger.Info("main", "start dma")
+	logger.Info("main", "start dma handler")
 
 	// Initialize dtabase manager handler
 	dmaHandler := DBMHandler{
 		arg:      a,
 		filePath: fmt.Sprintf("%s/%s.dma", a.RootDir, a.DMAFile),
 		Log:      logger,
-		Clients:  serverModels.NewClients(),
+		Conns:    serverModels.NewConnections(),
 	}
 
 	// initialize system datapoint and periodically update it
@@ -56,6 +55,7 @@ func NewDbmHandler(a *args.Args) (*DBMHandler, error) {
 	}
 
 	// check if dtabase file exists to load data
+	s := time.Now()
 	if _, err := os.Stat(dmaHandler.filePath); err == nil {
 
 		f, err := os.Open(dmaHandler.filePath)
@@ -69,14 +69,13 @@ func NewDbmHandler(a *args.Args) (*DBMHandler, error) {
 
 		for scanner.Scan() {
 			dp := models.Datapoint{}
-			err = json.Unmarshal(scanner.Bytes(), &dp)
+			if err = json.Unmarshal(scanner.Bytes(), &dp); err != nil {
-			if err != nil {
 				return nil, err
 			}
-			dmaHandler.ImportDatapoints(&dp)
+			dmaHandler.ImportDatapoints(dp)
 		}
 	}
-
+	dmaHandler.Log.Info("dmbHandler.NewDmbHandler", fmt.Sprintf("%d datapoint imported in %v", dmaHandler.GetNumbersOfDatapoints(), time.Since(s)))
 	return &dmaHandler, nil
 }
 
@@ -105,18 +104,30 @@ func (d *DBMHandler) SaveDb() (err error) {
 	return
 }
 
-func (d *DBMHandler) CreateDatapoint(typ models.Type, value any, right models.Rights, path string) error {
+func (d *DBMHandler) CreateDatapoints(sets ...json_dataModels.Set) ([]json_dataModels.Set, error) {
-	if err := d.DB.CreateDatapoint(typ, value, right, path); err != nil {
+	if len(sets) == 0 {
-		return err
+		return nil, nil
+	}
+
+	dps, err := d.DB.CreateDatapoints(d.Conns, sets...)
+	if err != nil {
+		return nil, err
+	}
+
+	var ndp uint64
+	for _, dp := range dps {
+		if !dp.Updated {
+			ndp++
+		}
 	}
 	dp := d.QueryDatapoints(1, "System:Datapoints")
-	d.UpdateDatapointValue("System:Datapoints", dp[0].GetValueUint64()+1)
+	d.UpdateDatapointValue("System:Datapoints", dp[0].GetValueUint64()+ndp)
-	return nil
+	return dps, nil
 }
 
-func (d *DBMHandler) ImportDatapoints(dps ...*models.Datapoint) error {
+func (d *DBMHandler) ImportDatapoints(dps ...models.Datapoint) error {
 	for _, dp := range dps {
-		err := d.DB.ImportDatapoint(dp, dp.Path)
+		err := d.DB.ImportDatapoint(d.Conns, dp, dp.Path)
 		if err != nil {
 			return err
 		}
@@ -127,71 +138,24 @@ func (d *DBMHandler) ImportDatapoints(dps ...*models.Datapoint) error {
 }
 
 func (d *DBMHandler) UpdateDatapointValue(path string, value any) error {
-	return d.DB.UpdateDatapointValue(value, path)
+	return d.DB.UpdateDatapointValue(d.Conns, value, path)
 }
 
-func (d *DBMHandler) RemoveDatapoint(path string) error {
+func (d *DBMHandler) RemoveDatapoint(sets ...json_dataModels.Set) ([]json_dataModels.Set, error) {
-	if err := d.DB.RemoveDatapoint(path); err != nil {
+	var lsRemoved []json_dataModels.Set
-		return err
+	for _, set := range sets {
+		removed, err := d.DB.RemoveDatapoint(d.Conns, set)
+		if err != nil {
+			return lsRemoved, err
 		}
+		lsRemoved = append(lsRemoved, removed)
 		dp := d.QueryDatapoints(1, "System:Datapoints")
-	d.UpdateDatapointValue("System:Datapoints", dp[0].GetValueUint64()+1)
+		d.UpdateDatapointValue("System:Datapoints", dp[0].GetValueUint64()-1)
-	return nil
+	}
+
+	return lsRemoved, nil
 }
 
-func (d *DBMHandler) QueryDatapoints(depth int, key string) []*models.Datapoint {
+func (d *DBMHandler) QueryDatapoints(depth uint, key string) []*models.Datapoint {
 	return d.DB.QueryDatapoints(depth, key)
 }
-
-func (d *DBMHandler) AddSystemDps() (err error) {
-	tim := "System:Time"
-	memory := "System:UsedMemory"
-	var m runtime.MemStats
-	var mOld uint64
-	var tOld int64
-
-	err = d.DB.CreateDatapoint(models.LOU, 0, models.Read, "System:Datapoints")
-	if err != nil {
-		d.Log.Error("dmb.Handler.AddSystemDps.CreateDatapoint", err.Error())
-		return
-	}
-
-	err = d.DB.CreateDatapoint(models.STR, nil, models.Read, tim)
-	if err != nil {
-		d.Log.Error("dmb.Handler.AddSystemDps.CreateDatapoint", err.Error())
-		return
-	}
-	err = d.DB.CreateDatapoint(models.STR, nil, models.Read, memory)
-	if err != nil {
-		d.Log.Error("dmb.Handler.AddSystemDps.CreateDatapoint", err.Error())
-		return
-	}
-
-	go func() {
-
-		ctx, cancel := context.WithTimeout(context.Background(), 10*time.Minute)
-		defer cancel()
-
-		for {
-			t := time.Now().UnixMilli()
-			if tOld != t {
-				if er := d.DB.UpdateDatapointValue(t, tim); er != nil {
-					d.Log.Error("dmb.Handler.AddSystemDps.UpdateDatapointValue", er.Error())
-				}
-				d.Publish(ctx, OnChange, tim, t)
-				tOld = t
-			}
-			runtime.ReadMemStats(&m)
-			if m.Sys != mOld {
-				mem := fmt.Sprintf("%.2f MB", float64(m.Sys)/1024/1024)
-				if er := d.DB.UpdateDatapointValue(mem, memory); er != nil {
-					d.Log.Error("dmb.Handler.AddSystemDps.UpdateDatapointValue", er.Error())
-				}
-				d.Publish(ctx, OnChange, memory, mem)
-				mOld = m.Sys
-			}
-			time.Sleep(1 * time.Second)
-		}
-	}()
-	return
-}

dbm/json_data.go

@@ -0,0 +1,82 @@
+package dbm
+
+import (
+	"net/http"
+
+	"github.com/gin-gonic/gin"
+	json_data "github.com/tecamino/tecamino-json_data"
+	json_dataModels "github.com/tecamino/tecamino-json_data/models"
+)
+
+func (d *DBMHandler) Json_Data(c *gin.Context) {
+	var err error
+	payload, err := json_data.ParseRequest(c.Request.Body)
+	if err != nil {
+		r := json_data.NewResponse()
+		r.SendError(err.Error())
+		c.JSON(http.StatusBadRequest, r)
+		return
+	}
+
+	respond := json_dataModels.NewResponse()
+
+	if payload.Get != nil {
+		var depth uint = 1
+		for _, get := range payload.Get {
+			if get.Query != nil {
+				depth = get.Query.Depth
+			}
+
+			for _, res := range d.QueryDatapoints(depth, get.Path) {
+				respond.AddGet(json_dataModels.Get{
+					Uuid:    res.Uuid,
+					Path:    res.Path,
+					Type:    res.Type,
+					Value:   res.Value,
+					Rights:  res.ReadWrite,
+					Drivers: &res.Drivers,
+				})
+			}
+		}
+
+	}
+	if payload.Set != nil {
+		respond.Set, err = d.CreateDatapoints(payload.Set...)
+		if err != nil {
+			r := json_data.NewResponse()
+			r.SendError(err.Error())
+			c.JSON(http.StatusBadRequest, r)
+			return
+		}
+	}
+
+	c.JSON(200, respond)
+	return
+}
+
+func (d *DBMHandler) Delete(c *gin.Context) {
+	var err error
+	payload, err := json_data.ParseRequest(c.Request.Body)
+	if err != nil {
+		r := json_data.NewResponse()
+		r.SendError(err.Error())
+		c.JSON(http.StatusBadRequest, r)
+		return
+	}
+
+	response := json_data.NewResponse()
+
+	if payload.Set != nil {
+
+		response.Set, err = d.RemoveDatapoint(payload.Set...)
+		if err != nil {
+			r := json_data.NewResponse()
+			r.SendError(err.Error())
+			c.JSON(http.StatusBadRequest, r)
+			return
+		}
+	}
+
+	c.JSON(200, response)
+	return
+}

dbm/publish.go

@@ -1,34 +0,0 @@
-package dbm
-
-import (
-	"context"
-
-	"github.com/coder/websocket/wsjson"
-	"github.com/zuadi/tecamino-dbm/models"
-)
-
-func (d *DBMHandler) Publish(ctx context.Context, eventType, path string, value any) error {
-	d.RLock()
-	defer d.RUnlock()
-
-	for _, dp := range d.DB.QueryDatapoints(1, path) {
-		for id, pub := range dp.Subscribtions {
-			if client, ok := d.Clients[id]; !ok {
-				delete(dp.Subscribtions, id)
-			} else {
-				if pub.OnChange {
-					err := wsjson.Write(ctx, client.Conn, models.JsonResponse{
-						Event: OnChange,
-						Path:  dp.Path,
-						Value: value,
-					})
-					if err != nil {
-						d.Log.Error("publish.Publish", err.Error())
-						return err
-					}
-				}
-			}
-		}
-	}
-	return nil
-}

dbm/subscribe.go

@@ -2,45 +2,74 @@ package dbm
 
 import (
 	"github.com/coder/websocket/wsjson"
-	"github.com/zuadi/tecamino-dbm/models"
+	json_dataModels "github.com/tecamino/tecamino-json_data/models"
-	"golang.org/x/net/context"
 )
 
-func (d *DBMHandler) Subscribe(ctx context.Context, sub *models.Subscribe, id string) {
+func (d *DBMHandler) Subscribe(subs []json_dataModels.Subscribe, id string) {
+	if subs == nil {
+		return
+	}
 	d.RLock()
 	defer d.RUnlock()
 
+	client, ok := d.Conns.Clients[id]
+	if !ok {
+		d.Log.Error("subscribe.Subscribe", "client not found for id "+id)
+		return
+	}
+
+	response := json_dataModels.NewResponse()
+
+	for _, sub := range subs {
 		for _, dp := range d.DB.QueryDatapoints(sub.Depth, sub.Path) {
-		if sub.Driver != nil {
+			if sub.Driver != "" {
-			if dp.Drivers == nil {
+				if dp.Drivers == nil || dp.Drivers[sub.Driver] == nil {
-				continue
-			} else if _, ok := dp.Drivers[*sub.Driver]; !ok {
 					continue
 				}
 			}
-
 			dp.AddSubscribtion(id, sub)
-
+			response.AddSubscription(json_dataModels.Subscribe{
-		err := wsjson.Write(ctx, d.Clients[id].Conn, models.JsonResponse{
+				Uuid:    dp.Uuid,
-			Event: OnCreate,
 				Path:    dp.Path,
 				Value:   dp.Value,
+				Driver:  sub.Driver,
+				Drivers: &dp.Drivers,
 			})
-		if err != nil {
-			d.Log.Error("subscribe.Subscribe", err.Error())
 		}
 	}
+	if err := wsjson.Write(client.Ctx, client.Conn, response); err != nil {
+		d.Log.Error("subscribe.Subscribe", err.Error())
+	}
 }
 
-func (d *DBMHandler) Unsubscribe(ctx context.Context, sub *models.Subscribe, id string) error {
+func (d *DBMHandler) Unsubscribe(subs []json_dataModels.Subscribe, id string) {
+	if subs == nil {
+		return
+	}
 	d.RLock()
 	defer d.RUnlock()
 
+	client, ok := d.Conns.Clients[id]
+	if !ok {
+		d.Log.Error("subscribe.Subscribe", "client not found for id "+id)
+		return
+	}
+
+	response := json_dataModels.NewResponse()
+
+	for _, sub := range subs {
 		for _, dp := range d.DB.QueryDatapoints(sub.Depth, sub.Path) {
-		if _, ok := dp.Subscribtions[id]; !ok {
+			if _, ok := dp.Subscriptions[id]; !ok {
 				continue
 			}
 			dp.RemoveSubscribtion(id)
+			response.AddUnsubscription(json_dataModels.Subscribe{
+				Uuid: dp.Uuid,
+				Path: dp.Path,
+			})
+		}
+	}
+	if err := wsjson.Write(client.Ctx, client.Conn, response); err != nil {
+		d.Log.Error("subscribe.Subscribe", err.Error())
 	}
-	return nil
 }

dbm/system.go

@@ -0,0 +1,97 @@
+package dbm
+
+import (
+	"fmt"
+	"runtime"
+	"time"
+
+	"github.com/tecamino/tecamino-dbm/utils"
+	json_dataModels "github.com/tecamino/tecamino-json_data/models"
+)
+
+func (d *DBMHandler) AddSystemDps() (err error) {
+	path := "System:Datapoints"
+
+	typ := json_dataModels.LOU
+	rights := json_dataModels.Read
+	_, err = d.DB.CreateDatapoints(d.Conns, json_dataModels.Set{Path: path, Value: 0, Type: typ, Rights: rights})
+	if err != nil {
+		d.Log.Error("dmb.Handler.AddSystemDps", err.Error())
+		return err
+	}
+	dp := d.QueryDatapoints(1, path)
+	d.UpdateDatapointValue(path, dp[0].GetValueUint64()+1)
+
+	if err = d.GoSystemTime(); err != nil {
+		return err
+	}
+
+	if err = d.GoSystemMemory(); err != nil {
+		return err
+	}
+	return
+}
+
+func (d *DBMHandler) GetNumbersOfDatapoints() uint64 {
+	return utils.Uint64From(d.DB.Datapoints["System"].Datapoints["Datapoints"].Value)
+}
+
+func (d *DBMHandler) GoSystemTime() error {
+	path := "System:Time"
+	var tOld int64
+
+	typ := json_dataModels.STR
+	rights := json_dataModels.Read
+	_, err := d.DB.CreateDatapoints(d.Conns, json_dataModels.Set{Path: path, Type: typ, Rights: rights})
+	if err != nil {
+		d.Log.Error("system.GoSystemTime", err.Error())
+		return err
+	}
+	dp := d.QueryDatapoints(1, "System:Datapoints")
+	d.UpdateDatapointValue("System:Datapoints", dp[0].GetValueUint64()+1)
+
+	go func() {
+		for {
+			t := time.Now().UnixMilli()
+			if tOld != t {
+				if er := d.DB.UpdateDatapointValue(d.Conns, t, path); er != nil {
+					d.Log.Error("dmb.Handler.AddSystemDps.UpdateDatapointValue", er.Error())
+				}
+				tOld = t
+			}
+			time.Sleep(time.Second)
+		}
+	}()
+	return nil
+}
+
+func (d *DBMHandler) GoSystemMemory() error {
+	path := "System:UsedMemory"
+	var m runtime.MemStats
+	var mOld uint64
+
+	typ := json_dataModels.STR
+	rights := json_dataModels.Read
+	_, err := d.DB.CreateDatapoints(d.Conns, json_dataModels.Set{Path: path, Type: typ, Rights: rights})
+	if err != nil {
+		d.Log.Error("system.GoSystemMemory", err.Error())
+		return err
+	}
+	dp := d.QueryDatapoints(1, "System:Datapoints")
+	d.UpdateDatapointValue("System:Datapoints", dp[0].GetValueUint64()+1)
+
+	go func() {
+		for {
+			runtime.ReadMemStats(&m)
+			if m.Sys != mOld {
+				mem := fmt.Sprintf("%.2f MB", float64(m.Sys)/1024/1024)
+				if er := d.DB.UpdateDatapointValue(d.Conns, mem, path); er != nil {
+					d.Log.Error("dmb.Handler.AddSystemDps.UpdateDatapointValue", er.Error())
+				}
+				mOld = m.Sys
+			}
+			time.Sleep(time.Second)
+		}
+	}()
+	return nil
+}

dbm/webSocket.go

@@ -1,13 +1,14 @@
 package dbm
 
 import (
-	"context"
+	"errors"
 	"fmt"
 
 	"github.com/coder/websocket"
 	"github.com/coder/websocket/wsjson"
 	"github.com/gin-gonic/gin"
-	"github.com/zuadi/tecamino-dbm/models"
+	"github.com/tecamino/tecamino-dbm/auth"
+	json_dataModels "github.com/tecamino/tecamino-json_data/models"
 )
 
 const (
@@ -17,62 +18,45 @@ const (
 )
 
 func (d *DBMHandler) WebSocket(c *gin.Context) {
-	// id, err := auth.GetIDFromAuth(c)
+	id, err := auth.GetIDFromQuery(c)
-	// if err != nil {
+	if err != nil {
-	// 	d.Log.Error("dbmHandler.webSocket.Websocket", "error GetIDFromAuth: "+err.Error())
+		d.Log.Error("dbmHandler.webSocket.Websocket", "error GetIDFromQuery: "+err.Error())
-	// 	return
+		return
-	// }
+	}
-	id := "test"
-
 	d.Log.Debug("dbmHandler.webSocket.Websocket", "authorization id token: "+id)
 
-	ctx, cancel := context.WithCancel(c.Request.Context())
+	err = d.Conns.ConnectRecievingWsConnection(id, c)
-	defer cancel()
+	defer d.Conns.RemoveClient(id)
-	err := d.Clients.ConnectRecievingWsConnection(id, c)
-	defer d.Clients.RemoveClient(id)
 	if err != nil {
 		d.Log.Error("dbmHandler.webSocket.Websocket", "error connecting recieving websocket conection: "+err.Error())
 		return
 	}
-	defer d.Clients.DisconnectWsConnection(id, websocket.StatusInternalError, "Internal error")
+	defer d.Conns.DisconnectWsConnection(id, websocket.StatusInternalError, "Internal error")
 
 	//Read loop
 	for {
-		request, err := d.readJsonData(ctx, id)
+		request, err := d.readJsonData(id)
 		if err != nil {
 			break
 		}
 
 		// Subscribe
-
+		go d.Subscribe(request.Subscribe, id)
-		if request.Subscribe != nil {
-			go func() {
-				for _, sub := range *request.Subscribe {
-					d.Subscribe(ctx, &sub, id)
-				}
-			}()
-		}
 
 		// Unsubscribe
-		if request.Unsubscribe != nil {
+		go d.Unsubscribe(request.Unsubscribe, id)
-			for _, unsub := range *request.Unsubscribe {
-				err = d.Unsubscribe(ctx, &unsub, id)
-				if err != nil {
-					d.Log.Error("dbmHandler.WebSocket unsubscribe", err)
-					break
-				}
-			}
-		}
 
-		if err != nil {
-			break
-		}
 	}
 }
 
-func (d *DBMHandler) readJsonData(ctx context.Context, id string) (*models.JsonData, error) {
+func (d *DBMHandler) readJsonData(id string) (request json_dataModels.Request, err error) {
-	var request models.JsonData
+
-	err := wsjson.Read(ctx, d.Clients[id].Conn, &request)
+	client, ok := d.Conns.Clients[id]
+	if !ok {
+		return request, errors.New("client id not found")
+	}
+
+	err = wsjson.Read(client.Ctx, client.Conn, &request)
 	if err != nil {
 		code := websocket.CloseStatus(err)
 
@@ -81,11 +65,11 @@ func (d *DBMHandler) readJsonData(ctx context.Context, id string) (*models.JsonD
 			websocket.StatusGoingAway,
 			websocket.StatusNoStatusRcvd:
 			d.Log.Info("webSocket.readJsonData", fmt.Sprintf("WebSocket closed: %v (code: %v)\n", err, code))
-			return nil, err
+			return
 		default:
 			d.Log.Error("webSocket.readJsonData", fmt.Sprintf("WebSocket read error: %v (code: %v)\n", err, code))
-			return nil, err
+			return
 		}
 	}
-	return &request, nil
+	return
 }

go.mod

@@ -1,12 +1,13 @@
-module github.com/zuadi/tecamino-dbm
+module github.com/tecamino/tecamino-dbm
 
 go 1.24.0
 
 require (
 	github.com/coder/websocket v1.8.13
 	github.com/gin-gonic/gin v1.10.0
+	github.com/google/uuid v1.6.0
+	github.com/tecamino/tecamino-json_data v0.0.10
 	github.com/tecamino/tecamino-logger v0.2.0
-	golang.org/x/net v0.25.0
 )
 
 require (
@@ -33,6 +34,7 @@ require (
 	go.uber.org/zap v1.27.0 // indirect
 	golang.org/x/arch v0.8.0 // indirect
 	golang.org/x/crypto v0.23.0 // indirect
+	golang.org/x/net v0.25.0 // indirect
 	golang.org/x/sys v0.20.0 // indirect
 	golang.org/x/text v0.15.0 // indirect
 	google.golang.org/protobuf v1.34.1 // indirect

go.sum

@@ -30,6 +30,8 @@ github.com/goccy/go-json v0.10.2/go.mod h1:6MelG93GURQebXPDq3khkgXZkazVtN9CRI+MG
 github.com/google/go-cmp v0.5.5 h1:Khx7svrCpmxxtHBq5j2mp/xVjsi8hQMfNLvJFAlrGgU=
 github.com/google/go-cmp v0.5.5/go.mod h1:v8dTdLbMG2kIc/vJvl+f65V22dbkXbowE6jgT/gNBxE=
 github.com/google/gofuzz v1.0.0/go.mod h1:dBl0BpW6vV/+mYPU4Po3pmUjxk6FQPldtuIdl/M65Eg=
+github.com/google/uuid v1.6.0 h1:NIvaJDMOsjHA8n1jAhLSgzrAzy1Hgr+hNrb57e+94F0=
+github.com/google/uuid v1.6.0/go.mod h1:TIyPZe4MgqvfeYDBFedMoGGpEw/LqOeaOT+nhxU+yHo=
 github.com/json-iterator/go v1.1.12 h1:PV8peI4a0ysnczrg+LtxykD8LfKY9ML6u2jnxaEnrnM=
 github.com/json-iterator/go v1.1.12/go.mod h1:e30LSqwooZae/UwlEbR2852Gd8hjQvJoHmT4TnhNGBo=
 github.com/klauspost/cpuid/v2 v2.0.9/go.mod h1:FInQzS24/EEf25PyTYn52gqo7WaD8xa0213Md/qVLRg=
@@ -61,6 +63,8 @@ github.com/stretchr/testify v1.8.1/go.mod h1:w2LPCIKwWwSfY2zedu0+kehJoqGctiVI29o
 github.com/stretchr/testify v1.8.4/go.mod h1:sz/lmYIOXD/1dqDmKjjqLyZ2RngseejIcXlSw2iwfAo=
 github.com/stretchr/testify v1.9.0 h1:HtqpIVDClZ4nwg75+f6Lvsy/wHu+3BoSGCbBAcpTsTg=
 github.com/stretchr/testify v1.9.0/go.mod h1:r2ic/lqez/lEtzL7wO/rwa5dbSLXVDPFyf8C91i36aY=
+github.com/tecamino/tecamino-json_data v0.0.10 h1:I5xvJ8eRxX0QbMTuSHlAA16FQ8uE49OiCSsQ7Xjircc=
+github.com/tecamino/tecamino-json_data v0.0.10/go.mod h1:LLlyD7Wwqplb2BP4PeO86EokEcTRidlW5MwgPd1T2JY=
 github.com/tecamino/tecamino-logger v0.2.0 h1:NPH/Gg9qRhmVoW8b39i1eXu/LEftHc74nyISpcRG+XU=
 github.com/tecamino/tecamino-logger v0.2.0/go.mod h1:0M1E9Uei/qw3e3WA1x3lBo1eP3H5oeYE7GjYrMahnj8=
 github.com/twitchyliquid64/golang-asm v0.15.1 h1:SU5vSMR7hnwNxj24w34ZyCi/FmDZTkS4MhqMhdFk5YI=

main.go

@@ -4,9 +4,9 @@ import (
 	"fmt"
 
 	"github.com/gin-gonic/gin"
-	"github.com/zuadi/tecamino-dbm/args"
+	"github.com/tecamino/tecamino-dbm/args"
-	"github.com/zuadi/tecamino-dbm/dbm"
+	"github.com/tecamino/tecamino-dbm/dbm"
-	"github.com/zuadi/tecamino-dbm/server"
+	"github.com/tecamino/tecamino-dbm/server"
 )
 
 func main() {
@@ -26,7 +26,9 @@ func main() {
 	//set routes
 	dbmHandler.Log.Debug("main", "setting routes")
 	s.Routes.GET("/ws", dbmHandler.WebSocket)
-	s.Routes.POST("/json_data", s.JsonRequest)
+	s.Routes.GET("/saveData", dbmHandler.SaveData)
+	s.Routes.POST("/json_data", dbmHandler.Json_Data)
+	s.Routes.DELETE("/json_data", dbmHandler.Delete)
 
 	s.Routes.GET("/", func(c *gin.Context) {
 		c.String(200, "DBM WebSocket Server is running!")

models/datapoints.go

@@ -1,28 +1,99 @@
 package models
 
 import (
+	"errors"
 	"fmt"
 	"regexp"
 	"strings"
 	"time"
 
-	"github.com/zuadi/tecamino-dbm/utils"
+	"github.com/coder/websocket/wsjson"
+	"github.com/google/uuid"
+	serverModels "github.com/tecamino/tecamino-dbm/server/models"
+	"github.com/tecamino/tecamino-dbm/utils"
+	json_data "github.com/tecamino/tecamino-json_data"
+	json_dataModels "github.com/tecamino/tecamino-json_data/models"
+)
+
+const (
+	OnCreate = "onCreate"
+	OnChange = "onChange"
+	OnDelete = "onDelete"
 )
 
 type Datapoint struct {
 	Datapoints     map[string]*Datapoint   `json:"-"`
+	Uuid           uuid.UUID               `json:"uuid"`
 	Path           string                  `json:"path"`
 	Value          any                     `json:"value,omitempty"`
 	CreateDateTime int64                   `json:"createDateTime,omitempty"`
 	UpdateDateTime int64                   `json:"updateDateTime,omitempty"`
-	Type           Type                  `json:"type"`
+	Type           json_dataModels.Type    `json:"type"`
-	ReadWrite      Rights                `json:"readWrite"`
+	ReadWrite      json_dataModels.Rights  `json:"readWrite"`
-	Drivers        map[string]*Driver    `json:"-"`
+	Drivers        json_dataModels.Drivers `json:"drivers,omitempty"`
-	Subscribtions  Subscribtions         `json:"-"`
+	Subscriptions  Subscriptions           `json:"-"`
 }
 
-func (d *Datapoint) CreateDatapoint(typ Type, value any, rights Rights, path string) error {
+func (d *Datapoint) Set(path string, set json_dataModels.Set) (bool, error) {
-	parts := regexp.MustCompile(`[:]+`).Split(path, -1)
+	var changed bool
+	if path != "" {
+		changed = true
+		d.Path = path
+	}
+
+	if set.Type != "" {
+		changed = true
+		d.Type = set.Type
+	}
+
+	if d.Type != "" {
+		if d.Value == nil && set.Value == nil {
+			changed = true
+			d.Value = d.Type.DefaultValue()
+		} else if d.Value != d.Type.ConvertValue(set.Value) {
+			changed = true
+			d.Value = d.Type.ConvertValue(set.Value)
+		}
+
+	}
+	if set.Rights != "" {
+		changed = true
+		d.ReadWrite = set.Rights.GetRights()
+	}
+
+	if changed {
+		d.UpdateDateTime = time.Now().UnixMilli()
+	}
+
+	if set.Driver == nil {
+		return changed, nil
+	}
+	if set.Driver.Type == "" {
+		return changed, errors.New("driver type missing")
+	}
+	if set.Driver.Bus == "" {
+		return changed, errors.New("driver bus name missing")
+	}
+
+	if d.Drivers == nil {
+		d.Drivers = json_dataModels.NewDrivers()
+	}
+	d.Drivers.AddDriver(set.Driver.Type, set.Driver.Bus, set.Driver.Address)
+	d.UpdateDateTime = time.Now().UnixMilli()
+
+	return changed, nil
+}
+
+func (d *Datapoint) GetValueUint64() uint64 {
+	return utils.Uint64From(d.Value)
+}
+
+func (d *Datapoint) CreateDatapoints(conns *serverModels.Connections, sets ...json_dataModels.Set) (created []json_dataModels.Set, err error) {
+	if len(sets) == 0 {
+		return
+	}
+	for _, dp := range sets {
+		parts := strings.Split(dp.Path, ":")
 
 		current := d
 		for i, part := range parts {
@@ -33,24 +104,46 @@ func (d *Datapoint) CreateDatapoint(typ Type, value any, rights Rights, path str
 			if i == len(parts)-1 {
 				// Leaf node: create or update datapoint
 				if existing, ok := current.Datapoints[part]; ok {
-				// Update existing
+					publish, err := existing.Set("", dp)
-				existing.Type = typ
+					if err != nil {
-				existing.ReadWrite = rights.GetRights()
+						return nil, err
-				existing.Value = typ.ConvertValue(value)
+					}
-				existing.UpdateDateTime = time.Now().UnixMilli()
+					created = append(created, json_dataModels.Set{
+						Uuid:    existing.Uuid,
+						Path:    existing.Path,
+						Type:    existing.Type,
+						Value:   existing.Value,
+						Rights:  existing.ReadWrite,
+						Drivers: &existing.Drivers,
+						Updated: true,
+					})
+
+					if publish {
+						existing.Publish(conns, OnChange)
+					}
 				} else {
 					// Create new
 					current.Datapoints[part] = &Datapoint{
-					Path:           strings.Join(parts, ":"),
+						Uuid:           uuid.New(),
-					Type:           typ,
-					Value:          typ.ConvertValue(value),
-					ReadWrite:      rights.GetRights(),
 						CreateDateTime: time.Now().UnixMilli(),
-					UpdateDateTime: time.Now().UnixMilli(),
+						Subscriptions:  InitSubscribtion(),
-					Subscribtions:  InitSubscribtion(),
+					}
+					publish, err := current.Datapoints[part].Set(strings.Join(parts, ":"), dp)
+					if err != nil {
+						return nil, err
+					}
+					created = append(created, json_dataModels.Set{
+						Uuid:   current.Uuid,
+						Path:   current.Path,
+						Type:   current.Type,
+						Value:  current.Value,
+						Rights: current.ReadWrite,
+						Driver: dp.Driver,
+					})
+					if publish {
+						current.Publish(conns, OnChange)
 					}
 				}
-			return nil
 			}
 
 			// Traverse or create intermediate datapoints
@@ -58,22 +151,36 @@ func (d *Datapoint) CreateDatapoint(typ Type, value any, rights Rights, path str
 				current = next
 			} else {
 				newDp := &Datapoint{
+					Uuid:           uuid.New(),
 					Path:           strings.Join(parts[:i+1], ":"),
-				Type:           NONE,
+					Type:           json_dataModels.NONE,
-				ReadWrite:      rights.GetRights(),
 					CreateDateTime: time.Now().UnixMilli(),
 					UpdateDateTime: time.Now().UnixMilli(),
-				Subscribtions:  InitSubscribtion(),
+					Subscriptions:  InitSubscribtion(),
 				}
+
+				created = append(created, json_dataModels.Set{
+					Uuid:   newDp.Uuid,
+					Path:   newDp.Path,
+					Type:   newDp.Type,
+					Value:  newDp.Value,
+					Rights: newDp.ReadWrite,
+				})
+
+				if dp.Rights != "" {
+					newDp.ReadWrite = dp.Rights.GetRights()
+				}
+
 				current.Datapoints[part] = newDp
 				current = newDp
 			}
 		}
-	return nil
+	}
+	return
 }
 
-func (d *Datapoint) ImportDatapoint(dp *Datapoint, path string) error {
+func (d *Datapoint) ImportDatapoint(conns *serverModels.Connections, dp Datapoint, path string) error {
-	parts := regexp.MustCompile(`[:]+`).Split(path, -1)
+	parts := strings.Split(dp.Path, ":")
 
 	current := d
 	for i, part := range parts {
@@ -88,12 +195,14 @@ func (d *Datapoint) ImportDatapoint(dp *Datapoint, path string) error {
 				existing.Value = current.Type.ConvertValue(dp.Value)
 				existing.ReadWrite = dp.ReadWrite.GetRights()
 				existing.UpdateDateTime = time.Now().UnixMilli()
+				dp.Publish(conns, OnChange)
 			} else {
 				dp.Path = strings.Join(parts, ":")
 				dp.ReadWrite = dp.ReadWrite.GetRights()
 				dp.UpdateDateTime = time.Now().UnixMilli()
-				dp.Subscribtions = InitSubscribtion()
+				dp.Subscriptions = InitSubscribtion()
-				current.Datapoints[part] = dp
+				current.Datapoints[part] = &dp
+				dp.Publish(conns, OnChange)
 			}
 			return nil
 		}
@@ -104,7 +213,7 @@ func (d *Datapoint) ImportDatapoint(dp *Datapoint, path string) error {
 		} else {
 			newDp := &Datapoint{
 				Path:           strings.Join(parts[:i+1], ":"),
-				Type:           NONE,
+				Type:           json_dataModels.NONE,
 				ReadWrite:      dp.ReadWrite.GetRights(),
 				UpdateDateTime: time.Now().UnixMilli(),
 			}
@@ -116,9 +225,9 @@ func (d *Datapoint) ImportDatapoint(dp *Datapoint, path string) error {
 	return nil
 }
 
-func (d *Datapoint) UpdateDatapointValue(value any, path string) error {
+func (d *Datapoint) UpdateDatapointValue(conns *serverModels.Connections, value any, path string) error {
 
-	paths := regexp.MustCompile(`[:]+`).Split(path, -1)
+	paths := strings.Split(path, ":")
 
 	current := d
 	for i, part := range paths {
@@ -129,6 +238,7 @@ func (d *Datapoint) UpdateDatapointValue(value any, path string) error {
 		if i == len(paths)-1 {
 			dp.Value = dp.Type.ConvertValue(value)
 			dp.UpdateDateTime = time.Now().UnixMilli()
+			dp.Publish(conns, OnChange)
 			return nil
 		}
 		current = dp
@@ -136,40 +246,38 @@ func (d *Datapoint) UpdateDatapointValue(value any, path string) error {
 	return nil
 }
 
-func (d *Datapoint) RemoveDatapoint(path string) error {
+func (d *Datapoint) RemoveDatapoint(conns *serverModels.Connections, set json_dataModels.Set) (json_dataModels.Set, error) {
-	parts := regexp.MustCompile(`[:]+`).Split(path, -1)
+	parts := strings.Split(set.Path, ":")
 
 	if len(parts) < 1 {
-		return fmt.Errorf("invalid path: '%s'", path)
+		return json_dataModels.Set{}, fmt.Errorf("invalid path: '%s'", set.Path)
 	}
 
 	current := d
 	for i := range len(parts) - 1 {
 		next, ok := current.Datapoints[parts[i]]
 		if !ok {
-			return fmt.Errorf("path not found: '%s'", strings.Join(parts[:i+1], ":"))
+			return json_dataModels.Set{}, fmt.Errorf("path not found: '%s'", strings.Join(parts[:i+1], ":"))
 		}
 		current = next
 	}
 
 	toDelete := parts[len(parts)-1]
-	if _, ok := current.Datapoints[toDelete]; ok {
+	if dp, ok := current.Datapoints[toDelete]; ok {
+		dp.Publish(conns, OnDelete)
 		delete(current.Datapoints, toDelete)
-		fmt.Println("Removed datapoint:", path)
+		return json_dataModels.Set{
-		return nil
+			Uuid: set.Uuid,
+			Path: set.Path,
+		}, nil
 	}
-
+	return json_dataModels.Set{}, fmt.Errorf("datapoint '%s' not found", set.Path)
-	return fmt.Errorf("datapoint '%s' not found", path)
 }
 
-func (d *Datapoint) GetAllDatapoints(depth int) (dps []*Datapoint) {
+func (d *Datapoint) GetAllDatapoints(depth uint) (dps []*Datapoint) {
-
-	var dfs func(dp *Datapoint, currentDepth int)
-	dfs = func(dp *Datapoint, currentDepth int) {
-		if currentDepth == 0 {
-			dps = append(dps, dp)
-		}
 
+	var dfs func(dp *Datapoint, currentDepth uint)
+	dfs = func(dp *Datapoint, currentDepth uint) {
 		if depth == 1 {
 			return
 		} else if depth == 0 {
@@ -186,15 +294,16 @@ func (d *Datapoint) GetAllDatapoints(depth int) (dps []*Datapoint) {
 		}
 
 		for _, child := range dp.Datapoints {
+			dps = append(dps, child)
 			dfs(child, currentDepth+1)
 		}
 	}
-
+	dps = append(dps, d)
 	dfs(d, 0)
 	return
 }
 
-func (d *Datapoint) QueryDatapoints(depth int, path string) (dps []*Datapoint) {
+func (d *Datapoint) QueryDatapoints(depth uint, path string) (dps []*Datapoint) {
 	parts := strings.Split(path, ":")
 
 	var dfs func(current *Datapoint, index int)
@@ -222,17 +331,17 @@ func (d *Datapoint) QueryDatapoints(depth int, path string) (dps []*Datapoint) {
 	return
 }
 
-func (d *Datapoint) AddSubscribtion(id string, sub *Subscribe) {
+func (d *Datapoint) AddSubscribtion(id string, sub json_dataModels.Subscribe) {
-	if d.Subscribtions == nil {
+	if d.Subscriptions == nil {
 		return
 	}
 
-	if s, ok := d.Subscribtions[id]; ok {
+	if s, ok := d.Subscriptions[id]; ok {
 		s.OnCreate = sub.OnCreate
 		s.OnChange = sub.OnChange
 		s.OnDelete = sub.OnDelete
 	} else {
-		d.Subscribtions[id] = &Subscribtion{
+		d.Subscriptions[id] = &Subscription{
 			OnCreate: sub.OnCreate,
 			OnChange: sub.OnChange,
 			OnDelete: sub.OnDelete,
@@ -241,37 +350,35 @@ func (d *Datapoint) AddSubscribtion(id string, sub *Subscribe) {
 }
 
 func (d *Datapoint) RemoveSubscribtion(id string) {
-	if _, ok := d.Subscribtions[id]; !ok {
+	if _, ok := d.Subscriptions[id]; !ok {
 		return
 	}
-	delete(d.Subscribtions, id)
+	delete(d.Subscriptions, id)
 }
 
-func (d *Datapoint) AddDriver(driver, bus string, adr int) {
+func (d *Datapoint) Publish(conns *serverModels.Connections, eventType string) error {
-	if d.Drivers == nil {
+	if conns.Clients == nil {
-		d.Drivers = make(map[string]*Driver)
+		return nil
 	}
+	conns.RLock()
+	defer conns.RUnlock()
 
-	d.Drivers[driver] = &Driver{
+	for id := range d.Subscriptions {
-		Bus:     bus,
+		if client, ok := conns.Clients[id]; !ok {
-		Address: adr,
+			delete(d.Subscriptions, id)
-	}
-}
-
-func (d *Datapoint) AddDriverSubscribtion(id string, sub *Subscribe) {
-	if s, ok := d.Subscribtions[id]; ok {
-		s.OnCreate = sub.OnCreate
-		s.OnChange = sub.OnChange
-		s.OnDelete = sub.OnDelete
 		} else {
-		d.Subscribtions[id] = &Subscribtion{
+			r := json_data.NewResponse()
-			OnCreate: sub.OnCreate,
+			r.AddUPublish(json_dataModels.Publish{
-			OnChange: sub.OnChange,
+				Event: eventType,
-			OnDelete: sub.OnDelete,
+				Uuid:  d.Uuid,
+				Path:  d.Path,
+				Value: d.Value,
+			})
+			err := wsjson.Write(client.Ctx, client.Conn, r)
+			if err != nil {
+				return err
 			}
 		}
-}
+	}
-
+	return nil
-func (d *Datapoint) GetValueUint64() uint64 {
-	return utils.Uint64From(d.Value)
 }

models/driver.go

@@ -1,6 +0,0 @@
-package models
-
-type Driver struct {
-	Bus     string
-	Address int
-}

models/get.go

@@ -1,6 +0,0 @@
-package models
-
-type Get struct {
-	Path  string `json:"path"`
-	Query *Query `json:"query,omitempty"`
-}

models/jsonData.go

@@ -1,35 +0,0 @@
-package models
-
-type JsonData struct {
-	Get         *[]Get       `json:"get,omitempty"`
-	Set         *[]Set       `json:"set,omitempty"`
-	Subscribe   *[]Subscribe `json:"subscribe,omitempty"`
-	Unsubscribe *[]Subscribe `json:"unsubscribe,omitempty"`
-}
-
-func NewRequest() *JsonData {
-	return &JsonData{}
-
-}
-
-func (r *JsonData) AddGet(path string, query Query) {
-	if r.Get == nil {
-		r.Get = &[]Get{}
-	}
-
-	*r.Get = append(*r.Get, Get{
-		Path:  path,
-		Query: &query,
-	})
-}
-
-func (r *JsonData) AddSet(path string, value any, create bool) {
-	if r.Set == nil {
-		r.Set = &[]Set{}
-	}
-
-	*r.Set = append(*r.Set, Set{
-		Path:  path,
-		Value: value,
-	})
-}

models/jsonResponse.go

@@ -1,10 +0,0 @@
-package models
-
-type JsonResponse struct {
-	Error   *bool  `json:"error,omitempty"`
-	Message string `json:"message,omitempty"`
-	Data    string `json:"data,omitempty"`
-	Event   string `json:"event,omitempty"`
-	Path    string `json:"path,omitempty"`
-	Value   any    `json:"value,omitempty"`
-}

models/query.go

@@ -1,6 +0,0 @@
-package models
-
-type Query struct {
-	Depth  int    `json:"depth,omitempty"`
-	RegExp string `json:"regExp,omitempty"`
-}

models/rights.go

@@ -1,18 +0,0 @@
-package models
-
-type Rights string
-
-const (
-	Read      Rights = "R"
-	Write     Rights = "W"
-	ReadWrite Rights = "RW"
-)
-
-func (r *Rights) GetRights() Rights {
-	if r == nil {
-		return ReadWrite
-	} else if *r == "" {
-		return ReadWrite
-	}
-	return *r
-}

models/set.go

@@ -1,8 +0,0 @@
-package models
-
-type Set struct {
-	Path   string  `json:"path"`
-	Driver *Driver `json:"driver,omitempty"`
-	Value  any     `json:"value,omitempty"`
-	Create bool    `json:"create,omitempty"`
-}

models/subscribe.go

@@ -1,10 +0,0 @@
-package models
-
-type Subscribe struct {
-	Path     string  `json:"path"`
-	Depth    int     `json:"depth"`
-	Driver   *string `json:"driver,omitempty"`
-	OnCreate bool    `json:"onCreate"`
-	OnDelete bool    `json:"onDelete"`
-	OnChange bool    `json:"onChange"`
-}

models/subscribtion.go

@@ -1,13 +1,13 @@
 package models
 
-type Subscribtions map[string]*Subscribtion
+type Subscriptions map[string]*Subscription
 
-type Subscribtion struct {
+type Subscription struct {
 	OnCreate bool
 	OnDelete bool
 	OnChange bool
 }
 
-func InitSubscribtion() Subscribtions {
+func InitSubscribtion() Subscriptions {
-	return make(Subscribtions)
+	return make(Subscriptions)
 }

models/type.go

@@ -1,67 +0,0 @@
-package models
-
-import (
-	"fmt"
-
-	"github.com/zuadi/tecamino-dbm/utils"
-)
-
-const (
-	NONE Type = "NONE"
-	BIT  Type = "BIT"
-	BYU  Type = "BYU"    // UINT8
-	BYS  Type = "BYS"    // INT8
-	WOS  Type = "WOS"    // INT16
-	WOU  Type = "WOU"    // UINT16
-	DWS  Type = "DWS"    // INT32
-	DWU  Type = "DWU"    // UINT32
-	LOS  Type = "LOS"    // INT64
-	LOU  Type = "LOU"    // UINT64
-	F32  Type = "F32"    // FLOAT32
-	F64  Type = "F64"    // FLOAT64
-	STR  Type = "STRING" // STRING
-)
-
-type Type string
-
-func (t *Type) DefaultValue(v any) any {
-	switch *t {
-	case BIT:
-		return false
-	case BYS, BYU, WOS, WOU, DWS, DWU, LOS, LOU, F32, F64:
-		return 0
-	case STR:
-		return ""
-	}
-	return nil
-}
-
-func (t *Type) ConvertValue(v any) any {
-	switch *t {
-	case BIT:
-		return utils.BoolFrom(v)
-	case BYS:
-		return utils.Int8From(v)
-	case BYU:
-		return utils.Uint8From(v)
-	case WOS:
-		return utils.Int16From(v)
-	case WOU:
-		return utils.Uint16From(v)
-	case DWS:
-		return utils.Int32From(v)
-	case DWU:
-		return utils.Uint32From(v)
-	case LOS:
-		return utils.Int64From(v)
-	case LOU:
-		return utils.Uint64From(v)
-	case F32:
-		return utils.Float32From(v)
-	case F64:
-		return utils.Float64From(v)
-	case STR:
-		return fmt.Sprintf("%v", v)
-	}
-	return nil
-}

server/jsonRequest.go

@@ -1,27 +0,0 @@
-package server
-
-import (
-	"net/http"
-
-	"github.com/gin-gonic/gin"
-	"github.com/zuadi/tecamino-dbm/models"
-)
-
-func (s *Server) JsonRequest(c *gin.Context) {
-	var payload models.JsonData
-
-	if err := c.BindJSON(&payload); err != nil {
-		c.JSON(http.StatusBadRequest, gin.H{"error": err.Error()})
-		return
-	}
-
-	if payload.Set != nil {
-
-	}
-
-	c.JSON(200, gin.H{
-		"name": payload,
-	})
-	return
-
-}

server/models/clients.go

@@ -3,7 +3,7 @@ package models
 import (
 	"context"
 	"fmt"
-	"net/http"
+	"time"
 
 	"github.com/coder/websocket"
 	"github.com/gin-gonic/gin"
@@ -14,7 +14,9 @@ var Origins []string = []string{"*"}
 type Clients map[string]*Client
 
 type Client struct {
-	Connected *bool           `json:"connected"`
+	Ctx       context.Context    `json:"-"`
+	Cancel    context.CancelFunc `json:"-"`
+	Connected bool               `json:"connected"`
 	Conn      *websocket.Conn    `json:"-"`
 }
 
@@ -23,60 +25,35 @@ func NewClients() Clients {
 }
 
 // Connect a recieving websocket connection
-func (c *Clients) ConnectRecievingWsConnection(id string, ctx *gin.Context) error {
+func (cl *Clients) ConnectRecievingWsConnection(id string, c *gin.Context) error {
-	if _, exists := (*c)[id]; exists {
+	if _, exists := (*cl)[id]; exists {
 		return nil
 	}
 
-	conn, err := websocket.Accept(ctx.Writer, ctx.Request, &websocket.AcceptOptions{
+	conn, err := websocket.Accept(c.Writer, c.Request, &websocket.AcceptOptions{
 		OriginPatterns: Origins,
 	})
 
 	if err != nil {
 		return fmt.Errorf("error accept websocket client: %s", err)
 	}
+	ctx, cancel := context.WithTimeout(context.Background(), 3*time.Minute)
 
-	b := true
+	(*cl)[id] = &Client{
-	(*c)[id] = &Client{
+		Connected: true,
-		Connected: &b,
+		Ctx:       ctx,
+		Cancel:    cancel,
 		Conn:      conn,
 	}
 	return nil
 }
 
-// Connect a recieving websocket connection
-func (c *Clients) ConnectSendingWsConnection(id, url string) (*websocket.Conn, error) {
-	if _, exists := (*c)[id]; exists {
-		return (*c)[id].Conn, nil
-	}
-
-	header := http.Header{}
-	header.Set("Authorization", "Bearer "+id)
-
-	conn, _, err := websocket.Dial(context.Background(), url, &websocket.DialOptions{
-		HTTPHeader: header,
-	})
-	if err != nil {
-		return nil, err
-	}
-
-	b := true
-	(*c)[id] = &Client{
-		Connected: &b,
-		Conn:      conn,
-	}
-	return conn, nil
-}
-
 func (c *Clients) RemoveClient(id string) {
 	delete(*c, id)
 }
 
-func (c *Clients) GetClientPointer(id string) *bool {
-	return (*c)[id].Connected
-}
-
 func (c *Clients) DisconnectWsConnection(id string, code websocket.StatusCode, reason string) {
-	*(*c)[id].Connected = false
+	(*c)[id].Connected = false
 	(*c)[id].Conn.Close(code, reason)
+	(*c)[id].Cancel()
 }

server/models/connections.go

@@ -0,0 +1,32 @@
+package models
+
+import (
+	"sync"
+
+	"github.com/coder/websocket"
+	"github.com/gin-gonic/gin"
+)
+
+type Connections struct {
+	sync.RWMutex
+	Clients Clients
+}
+
+func NewConnections() *Connections {
+	return &Connections{
+		Clients: NewClients(),
+	}
+}
+
+// Connect a recieving websocket connection
+func (c *Connections) ConnectRecievingWsConnection(id string, ctx *gin.Context) error {
+	return c.Clients.ConnectRecievingWsConnection(id, ctx)
+}
+
+func (c *Connections) RemoveClient(id string) {
+	c.Clients.RemoveClient(id)
+}
+
+func (c *Connections) DisconnectWsConnection(id string, code websocket.StatusCode, reason string) {
+	c.Clients.DisconnectWsConnection(id, code, reason)
+}

test/helper.go

@@ -1,41 +0,0 @@
-package test
-
-import (
-	"math/rand"
-
-	"github.com/zuadi/tecamino-dbm/models"
-)
-
-func RandomType() models.Type {
-	n := rand.Intn(11) + 1
-
-	switch n {
-	case 1:
-		return "BIT"
-	case 2:
-		return "BYU"
-	case 3:
-		return "BYS"
-	case 4:
-		return "WOS"
-	case 5:
-		return "WOU"
-	case 6:
-		return "DWS"
-	case 7:
-		return "DWU"
-	case 8:
-		return "LOS"
-	case 9:
-		return "LOU"
-	case 10:
-		return "F32"
-	case 11:
-		return "F64"
-	case 12:
-		return "STRING"
-	default:
-		return "NONE"
-	}
-
-}