ebkTools/nhooyrioWebsocketAddons/nhooyrioWebsocketAddons.go

package nhooyrioWebsocketAddons

import (
	"context"
	"encoding/json"
	"fmt"

	"nhooyr.io/websocket"
	"nhooyr.io/websocket/wsjson"
)

// GosmContainerSection is the type for one single information segment
type GosmContainerSection struct {
	TagID     string `json:"tagid"`
	Attribute string `json:"attribute"` // might left empty
	Content   string `json:"content"`
	Upstream  bool   `json:"streamdirection"` // up = true / down = false
	Status    string `json:"status"`          // reserved for status message; type errors is out of bounds
}

// GosmContainer is an accumulation of information segments
type GosmContainer []GosmContainerSection

// GosmBuffer is the GosmContainer as byte-array
type GosmBuffer []byte

//GosmAdapter is the master type for sending and receiving data between websocket client and server
type GosmAdapter interface {
	Revalue(func(interface{}) interface{})
	Convert() (GosmAdapter, error)
	WsCommunicator(string, context.Context, *websocket.Conn, ...func(interface{}) interface{}) (GosmAdapter, error, websocket.MessageType)
	WsCommunicator(string, context.Context, *websocket.Conn, ...func(interface{}) interface{}) (error, websocket.MessageType)
}

//Convert method turns GosmContainer-Data to GosmBuffer and reverse
func (r *GosmContainer) Convert() (GosmAdapter, error) {
	buffer, err := json.Marshal(*r)
	/*	LÖSCHEN
		fmt.Println("Hier", *r)
		*r = GosmContainer{GosmContainerSection{"E", "FF", "GGG", true, "Hallo"}}
		fmt.Println("Hier2", *r)*/
	if err != nil {
		panic(err)
	}
	pbuffer := GosmBuffer(buffer)
	return &pbuffer, err
}

//Convert method turns GosmContainer-Data to GosmBuffer and reverse
func (r *GosmBuffer) Convert() (GosmAdapter, error) {
	var gosm GosmContainer

	err := json.Unmarshal(*r, &gosm)

	return &gosm, err
}

//Revalue alters data
func (r *GosmContainer) Revalue(dosth func(interface{}) interface{}) {
	*r = dosth(*r).(GosmContainer)
}

//Revalue alters data
func (r *GosmBuffer) Revalue(dosth func(interface{}) interface{}) {
	//*r = dosth(*r).([]byte)
	*r = dosth(*r).(GosmBuffer)
}

/*
func (r *GosmContainer) WsCommunicator(method string, ctx context.Context, conn *websocket.Conn, dosth ...func(interface{}) interface{}) (GosmAdapter, error, websocket.MessageType) {
	switch {
	case (method == "sendtext" || method == "sendbinary" || method == "send") && len(dosth) == 0:
		err, receiveval := WsjsonSend(ctx, conn, *r)
		return receiveval.(GosmAdapter), err, websocket.MessageText
	case method == "receive" && len(dosth) == 1:
		err, receiveval := WsjsonReceive(ctx, conn, dosth[0])
		return receiveval.(GosmAdapter), err, websocket.MessageText
	default:
		panic("Wrong communicator method or invalid number of dosth-functions")
	}
}
func (r *GosmBuffer) WsCommunicator(method string, ctx context.Context, conn *websocket.Conn, dosth ...func(interface{}) interface{}) (GosmAdapter, error, websocket.MessageType) {
	switch {
	case (method == "sendtext" || method == "send") && len(dosth) == 0:
		err, receiveval := WsSend(ctx, conn, *r, websocket.MessageText)
		pbuffer := GosmBuffer(receiveval)
		return &pbuffer, err, websocket.MessageText
	case method == "sendbinary" && len(dosth) == 0:
		err, receiveval := WsSend(ctx, conn, *r, websocket.MessageBinary)
		pbuffer := GosmBuffer(receiveval)
		return &pbuffer, err, websocket.MessageBinary
	case method == "receive" && len(dosth) == 1:
		err, receiveval, mtr := WsReceive(ctx, conn, dosth[0])
		pbuffer := GosmBuffer(receiveval)
		return &pbuffer, err, mtr
	default:
		panic("Wrong communicator method or invalid number of dosth-functions")
	}

}
*/

//WsCommunicator sends and receivs data to/from websocket partner
func (r *GosmContainer) WsCommunicator(method string, ctx context.Context, conn *websocket.Conn, dosth ...func(interface{}) interface{}) (error, websocket.MessageType) {
	fmt.Print("ICH BIN HIER UND HIER GEHT WAS SCHIEF 0")
	switch {
	case (method == "sendtext" || method == "sendbinary" || method == "send") && len(dosth) == 0:
		err, receiveval := WsjsonSend(ctx, conn, *r)
		*r = receiveval.(GosmContainer)
		return err, websocket.MessageText
	case method == "receive" && len(dosth) == 1:
		fmt.Print("ICH BIN HIER UND HIER GEHT WAS SCHIEF 1")
		err, receiveval := WsjsonReceive(ctx, conn, dosth[0])
		fmt.Print("ICH BIN HIER UND HIER GEHT WAS SCHIEF 2")
		//*r = receiveval.(GosmContainer)
		_ = receiveval
		return err, websocket.MessageText
	default:
		panic("Wrong communicator method or invalid number of dosth-functions")
	}
}

//WsCommunicator sends and receivs data to/from websocket partner
func (r *GosmBuffer) WsCommunicator(method string, ctx context.Context, conn *websocket.Conn, dosth ...func(interface{}) interface{}) (error, websocket.MessageType) {
	fmt.Print("ICH BIN HIER UND HIER GEHT WAS SCHIEF 10")
	switch {
	case (method == "sendtext" || method == "send") && len(dosth) == 0:
		err, receiveval := WsSend(ctx, conn, *r, websocket.MessageText)
		*r = GosmBuffer(receiveval)
		return err, websocket.MessageText
	case method == "sendbinary" && len(dosth) == 0:
		err, receiveval := WsSend(ctx, conn, *r, websocket.MessageBinary)
		*r = GosmBuffer(receiveval)
		return err, websocket.MessageBinary
	case method == "receive" && len(dosth) == 1:
		err, receiveval, mtr := WsReceive(ctx, conn, dosth[0]) //
		*r = GosmBuffer(receiveval)
		return err, mtr
	default:
		panic("Wrong communicator method or invalid number of dosth-functions")
	}

}

//WsjsonSend sends data to websocket partner in json text format
func WsjsonSend(ctx context.Context, conn *websocket.Conn, sendval interface{}) (err error, receiveval interface{}) {
	err = nil

	//Send
	err = wsjson.Write(ctx, conn, sendval)
	if err != nil {
		return err, nil
	}

	//Receive
	err = wsjson.Read(ctx, conn, &receiveval)
	if err != nil {
		return err, nil
	}

	return
}

//WsjsonReceive receives data from websocket partner in json text format
func WsjsonReceive(ctx context.Context, conn *websocket.Conn, dosth func(interface{}) interface{}) (err error, receiveval interface{}) {
	var sendval interface{}
	err = nil

	//Receive
	err = wsjson.Read(ctx, conn, &receiveval)
	if err != nil {
		return
	}
	if dosth != nil {
		sendval = dosth(receiveval)
	} else {
		sendval = "" //It doesn't make sense to return unprocess receiveval
	}

	//Send
	err = wsjson.Write(ctx, conn, sendval.(string))
	if err != nil {
		return
	}

	return
}

//WsSend sends data to websocket partner as byte array
func WsSend(ctx context.Context, conn *websocket.Conn, sendval []byte, mts websocket.MessageType) (err error, receiveval []byte) {
	var mtr websocket.MessageType
	err = nil

	//Send
	err = conn.Write(ctx, mts, sendval)
	if err != nil {
		return err, nil
	}

	//Receive
	mtr, receiveval, err = conn.Read(ctx)
	if err != nil {
		return err, nil
	}

	if mtr != mts { //Dürfte eigentlich niemals eintreten, denn MessageType mtr und mts sind identisch, sofern auf der anderen Seite WsReceive lauscht.
		panic("websocket.MessageType inconsistency")
	}

	return
}

//WsReceive receives data from websocket partner as byte array
func WsReceive(ctx context.Context, conn *websocket.Conn, dosth func(interface{}) interface{}) (err error, receiveval []byte, mtr websocket.MessageType) {
	var sendval []byte
	err = nil

	//Receive
	mtr, receiveval, err = conn.Read(ctx)
	if err != nil {
		return
	}
	if dosth != nil {
		sendval = dosth(receiveval).([]byte)
	} else {
		sendval = []byte{} //It doesn't make sense to return unprocess receiveval
	}

	//Send
	err = conn.Write(ctx, mtr, sendval)
	if err != nil {
		return
	}

	return
}