diff --git a/.github/workflows/builder.yml b/.github/workflows/builder.yml index 0025e75..914b23d 100644 --- a/.github/workflows/builder.yml +++ b/.github/workflows/builder.yml @@ -12,16 +12,17 @@ jobs: - name: Set up Go uses: actions/setup-go@v4 with: - go-version: '1.25.1' + go-version: '1.25.5' - name: Build run: go build -v ./... - name: Build Servers run: | - go build ./servers/bullion/main-server/main.go - go build ./servers/jwelly/mysql-to-surreal/main.go - go build ./servers/jwelly/main-server/main.go - go build ./servers/jwelly/mysql-backup/main.go - go build ./servers/jwelly/mysql-to-mysql/main.go - go build ./servers/link-shortner/main.go - go build ./servers/whatsapp-server/main.go + go build -v -ldflags "-s -w" ./servers/bullion/main-server/main.go + go build -v -ldflags "-s -w" ./servers/jwelly/mysql-to-surreal/main.go + go build -v -ldflags "-s -w" ./servers/jwelly/main-server/main.go + go build -v -ldflags "-s -w" ./servers/jwelly/mysql-backup/main.go + go build -v -ldflags "-s -w" ./servers/jwelly/mysql-to-mysql/main.go + go build -v -ldflags "-s -w" ./servers/link-shortner/main.go + go build -v -ldflags "-s -w" ./servers/whatsapp-server/main.go + go build -v -ldflags "-s -w" ./servers/http-dump/dump-server/main.go diff --git a/.vscode/launch.json b/.vscode/launch.json index 3be80da..e6cd453 100644 --- a/.vscode/launch.json +++ b/.vscode/launch.json @@ -12,6 +12,14 @@ "args": ["--dev"], "program": "${workspaceFolder}/servers/bullion/main-server/main.go" }, + { + "name": "Run Dump Server", + "type": "go", + "request": "launch", + "mode": "auto", + "args": ["--dev"], + "program": "${workspaceFolder}/servers/http-dump-server/main.go" + }, { "name": "Run Whatsapp Server", "type": "go", diff --git a/env/keys.go b/env/keys.go index 759293c..38ccb2b 100644 --- a/env/keys.go +++ b/env/keys.go @@ -11,6 +11,7 @@ const FIREBASE_DATABASE_URL_KEY = "FIREBASE_DATABASE_URL" const REDIS_DB_HOST_KEY = "REDIS_DB_HOST" const REDIS_DB_PORT_KEY = "REDIS_DB_PORT" const REDIS_DB_PASSWORD_KEY = "REDIS_DB_PASSWORD" +const REDIS_DB_USERNAME_KEY = "REDIS_DB_USERNAME" const REDIS_DB_DATABASE_KEY = "REDIS_DB_DATABASE" // SURREAL DB KEYS diff --git a/http-dump b/http-dump new file mode 100755 index 0000000..d98bb0e Binary files /dev/null and b/http-dump differ diff --git a/servers/bullion/main-server/main.go b/servers/bullion/main-server/main.go index 74aa7ac..92520aa 100644 --- a/servers/bullion/main-server/main.go +++ b/servers/bullion/main-server/main.go @@ -5,6 +5,8 @@ import ( "fmt" "time" + "github.com/gofiber/fiber/v2" + "github.com/gofiber/fiber/v2/middleware/logger" j "github.com/golang-jwt/jwt/v5" "github.com/rpsoftech/golang-servers/env" "github.com/rpsoftech/golang-servers/interfaces" @@ -15,9 +17,6 @@ import ( "github.com/rpsoftech/golang-servers/utility/jwt" "github.com/rpsoftech/golang-servers/utility/mongodb" "github.com/rpsoftech/golang-servers/utility/redis" - - "github.com/gofiber/fiber/v2" - "github.com/gofiber/fiber/v2/middleware/logger" ) func deferMainFunc() { diff --git a/servers/http-dump/dump-server/api/apis.go b/servers/http-dump/dump-server/api/apis.go new file mode 100644 index 0000000..10ca2ec --- /dev/null +++ b/servers/http-dump/dump-server/api/apis.go @@ -0,0 +1,12 @@ +package dump_server_apis + +import ( + "github.com/gofiber/fiber/v2" +) + +func AddApis(app fiber.Router) { + app.All("/dump/:id", DumpData) + // auth.AddAuthPackages(app.Group("/auth")) + // data.AddDataPackage(app.Group("/data")) + // order.AddOrderPackage(app.Group("/order")) +} diff --git a/servers/http-dump/dump-server/api/dump.go b/servers/http-dump/dump-server/api/dump.go new file mode 100644 index 0000000..443d23d --- /dev/null +++ b/servers/http-dump/dump-server/api/dump.go @@ -0,0 +1,34 @@ +package dump_server_apis + +import ( + "net/http" + + "github.com/gofiber/fiber/v2" + "github.com/rpsoftech/golang-servers/interfaces" + dump_server_services "github.com/rpsoftech/golang-servers/servers/http-dump/dump-server/services" +) + +func DumpData(c *fiber.Ctx) error { + id := c.Params("id") + if id == "" { + return &interfaces.RequestError{ + StatusCode: http.StatusBadRequest, + Code: interfaces.ERROR_INVALID_INPUT, + Message: "Please Pass Valid UUID Endpoint", + Name: "INVALID_INPUT", + } + } + + bodyBytes := c.Body() + + // Convert the byte slice to a string if needed + bodyString := string(bodyBytes) + + // You can then manually unmarshal it using the standard "encoding/json" package + // var data map[string]interface{} + // if err := json.Unmarshal(bodyBytes, &data); err != nil { + // return c.Status(fiber.StatusBadRequest).SendString(err.Error()) + // } + return dump_server_services.EndPointService.DumpData(id, bodyString) + +} diff --git a/servers/http-dump/dump-server/env/index.go b/servers/http-dump/dump-server/env/index.go new file mode 100644 index 0000000..9b304df --- /dev/null +++ b/servers/http-dump/dump-server/env/index.go @@ -0,0 +1,24 @@ +package dump_server_env + +import "github.com/rpsoftech/golang-servers/env" + +type dumpEnv struct { + DefaultEnv *env.DefaultEnvInterface + REDIS_DEFAULT_KEY string `json:"REDIS_DEFAULT_KEY" validate:"required,min=3"` + REDIS_DEFAULT_CHANNEL string `json:"REDIS_DEFAULT_CHANNEL" validate:"required,min=3"` +} + +var Env *dumpEnv + +func init() { + env.LoadEnv("http-dump-server.env") + println("Dump Server Env Initialized") + Env = &dumpEnv{ + DefaultEnv: env.Env, + REDIS_DEFAULT_KEY: env.Env.GetEnv("REDIS_DEFAULT_KEY"), + REDIS_DEFAULT_CHANNEL: env.Env.GetEnv("REDIS_DEFAULT_CHANNEL"), + // ACCESS_TOKEN_KEY: env.Env.GetEnv("ACCESS_TOKEN_KEY"), + // REFRESH_TOKEN_KEY: env.Env.GetEnv("REFRESH_TOKEN_KEY"), + } + env.ValidateEnv(Env) +} diff --git a/servers/http-dump/dump-server/env/redis.key-env.go b/servers/http-dump/dump-server/env/redis.key-env.go new file mode 100644 index 0000000..d3845f7 --- /dev/null +++ b/servers/http-dump/dump-server/env/redis.key-env.go @@ -0,0 +1,10 @@ +package dump_server_env + +import "fmt" + +func GetRedisKey(key string) string { + return fmt.Sprintf("%s%s", Env.REDIS_DEFAULT_KEY, key) +} +func GetRedisEventKey(key string) string { + return fmt.Sprintf("%s%s", Env.REDIS_DEFAULT_CHANNEL, key) +} diff --git a/servers/http-dump/dump-server/events/dump-base.event.go b/servers/http-dump/dump-server/events/dump-base.event.go new file mode 100644 index 0000000..c6dd109 --- /dev/null +++ b/servers/http-dump/dump-server/events/dump-base.event.go @@ -0,0 +1,25 @@ +package dump_server_events + +import ( + "encoding/json" + "fmt" + + "github.com/rpsoftech/golang-servers/events" + dump_server_env "github.com/rpsoftech/golang-servers/servers/http-dump/dump-server/env" +) + +type DumpServerBaseEvent struct { + *events.BaseEvent `bson:"inline"` + DumpId string `bson:"dumpId" json:"dumpId" validate:"required,uuid"` +} + +func (base *DumpServerBaseEvent) GetPayloadString() string { + if base.DataString != "" { + return base.DataString + } + payload, _ := json.Marshal(base) + return string(payload) +} +func (base *DumpServerBaseEvent) GetEventName() string { + return dump_server_env.GetRedisEventKey(fmt.Sprintf("event/%s/%s", base.DumpId, base.EventName)) +} diff --git a/servers/http-dump/dump-server/events/dump-details.event.go b/servers/http-dump/dump-server/events/dump-details.event.go new file mode 100644 index 0000000..65c8118 --- /dev/null +++ b/servers/http-dump/dump-server/events/dump-details.event.go @@ -0,0 +1,29 @@ +package dump_server_events + +import "github.com/rpsoftech/golang-servers/events" + +type dumpDataEvent struct { + *DumpServerBaseEvent `bson:"inline"` +} + +func (base *dumpDataEvent) Add() *dumpDataEvent { + base.ParentNames = []string{base.EventName, "BankDetailsEvent"} + base.DumpServerBaseEvent.CreateBaseEvent() + return base +} + +func CreateDumpEvent(id string, data string) *DumpServerBaseEvent { + event := &dumpDataEvent{ + DumpServerBaseEvent: &DumpServerBaseEvent{ + BaseEvent: &events.BaseEvent{ + KeyId: id, + Payload: data, + DataString: data, + EventName: "DumpDataEvent", + }, + DumpId: id, + }, + } + event.Add() + return event.DumpServerBaseEvent +} diff --git a/servers/http-dump/dump-server/interfaces/admin-user.entity.go b/servers/http-dump/dump-server/interfaces/admin-user.entity.go new file mode 100644 index 0000000..a70cc7f --- /dev/null +++ b/servers/http-dump/dump-server/interfaces/admin-user.entity.go @@ -0,0 +1,26 @@ +package dump_server_interfaces + +import "github.com/rpsoftech/golang-servers/interfaces" + +type EndPoint struct { + *interfaces.BaseEntity `bson:"inline"` + Name string `bson:"name" json:"name" validate:"required,min=3,max=100"` + Desc string `bson:"desc,omitempty" json:"desc,omitempty" validate:"required,min=3,max=100"` + CustomChanel string `bson:"customChanel" json:"customChanel" validate:"required,min=3,max=100"` +} + +func (endPoint *EndPoint) CreateNewEntity(Name string, Desc string, CustomChanel string) *EndPoint { + endPoint.BaseEntity = &interfaces.BaseEntity{} + endPoint.Desc = Desc + endPoint.Name = Name + endPoint.CustomChanel = CustomChanel + endPoint.CreateNewId() + return endPoint +} + +func (endPoint *EndPoint) GetChanel() string { + if endPoint.CustomChanel == "" { + endPoint.CustomChanel = endPoint.ID + } + return endPoint.CustomChanel +} diff --git a/servers/http-dump/dump-server/main.go b/servers/http-dump/dump-server/main.go new file mode 100644 index 0000000..6d0bca7 --- /dev/null +++ b/servers/http-dump/dump-server/main.go @@ -0,0 +1,57 @@ +package main + +import ( + "github.com/gofiber/fiber/v2" + "github.com/gofiber/fiber/v2/middleware/logger" + "github.com/rpsoftech/golang-servers/env" + "github.com/rpsoftech/golang-servers/interfaces" + dump_server_apis "github.com/rpsoftech/golang-servers/servers/http-dump/dump-server/api" + _ "github.com/rpsoftech/golang-servers/servers/http-dump/dump-server/env" + "github.com/rpsoftech/golang-servers/utility/mongodb" + "github.com/rpsoftech/golang-servers/utility/redis" +) + +func deferMainFunc() { + println("Closing...") + mongodb.DeferFunction() + redis.DeferFunction() +} + +func main() { + defer deferMainFunc() + // env.LoadEnv("http-dump-server.env") + println("Http Dump Server Env Initialized") + app := fiber.New(fiber.Config{ + ServerHeader: "Http Dump Server V1.0.0", + ErrorHandler: func(c *fiber.Ctx, err error) error { + mappedError, ok := err.(*interfaces.RequestError) + if !ok { + println(err.Error()) + return c.Status(500).JSON(interfaces.RequestError{ + Code: interfaces.ERROR_INTERNAL_SERVER, + Message: "Some Internal Error", + Name: "Global Error Handler Function", + }) + } + if mappedError.LogTheDetails { + //Todo: Store The Details Of the Error With Body And Other Extra Details Like AUTH KEY AND ETC + } + return c.Status(mappedError.StatusCode).JSON(mappedError) + }, + }) + app.Use(logger.New()) + dump_server_apis.AddApis(app.Group("/v1")) + app.Use(func(c *fiber.Ctx) error { + return c.Status(fiber.StatusNotFound).SendString("Sorry can't find that!") + }) + // entity := new(dump_server_interfaces.EndPoint) + // entity.CreateNewEntity("Testing", "TESTING LOCAL", "56397cab-7246-4d1c-ac14-c3446317e67b") + // entity.BaseEntity.ID = "56397cab-7246-4d1c-ac14-c3446317e67b" + // dump_server_repos.EndPointRepo.Save(entity) + hostAndPort := "" + if env.Env.APP_ENV == env.APP_ENV_LOCAL || env.Env.APP_ENV == env.APP_ENV_DEVELOPE { + hostAndPort = "127.0.0.1" + } + hostAndPort = hostAndPort + ":" + env.GetServerPort(env.PORT_KEY) + app.Listen(hostAndPort) +} diff --git a/servers/http-dump/dump-server/repos/end-point.repo.go b/servers/http-dump/dump-server/repos/end-point.repo.go new file mode 100644 index 0000000..4d0ec22 --- /dev/null +++ b/servers/http-dump/dump-server/repos/end-point.repo.go @@ -0,0 +1,126 @@ +package dump_server_repos + +import ( + "encoding/json" + "errors" + "fmt" + "net/http" + + "github.com/rpsoftech/golang-servers/env" + "github.com/rpsoftech/golang-servers/interfaces" + dump_server_env "github.com/rpsoftech/golang-servers/servers/http-dump/dump-server/env" + dump_server_interfaces "github.com/rpsoftech/golang-servers/servers/http-dump/dump-server/interfaces" + "github.com/rpsoftech/golang-servers/utility/mongodb" + "github.com/rpsoftech/golang-servers/utility/redis" + "go.mongodb.org/mongo-driver/bson" + "go.mongodb.org/mongo-driver/mongo" +) + +type EndPointRepoStruct struct { + collection *mongo.Collection + redis *redis.RedisClientStruct +} + +const endPointCollectionName = "EndPoint" + +var EndPointRepo *EndPointRepoStruct + +func init() { + if env.Env.APP_ENV == env.APP_ENV_DEVELOPE { + return + } + coll := mongodb.MongoDatabase.Collection(endPointCollectionName) + EndPointRepo = &EndPointRepoStruct{ + collection: coll, + redis: redis.InitRedisAndRedisClient(), + } + mongodb.AddUniqueIndexesToCollection([]string{"id"}, EndPointRepo.collection) + // mongodb.AddComboUniqueIndexesToCollection([]string{"userName", "bullionId"}, EndPointRepo.collection) +} +func (repo *EndPointRepoStruct) cacheDataToRedis(entity *dump_server_interfaces.EndPoint) { + go redis.CacheDataToRedis(repo.redis, &entity, dump_server_env.GetRedisKey(entity.ID), redis.TimeToLive_OneDay) +} + +func (repo *EndPointRepoStruct) Save(entity *dump_server_interfaces.EndPoint) (*dump_server_interfaces.EndPoint, error) { + var result dump_server_interfaces.EndPoint + err := repo.collection.FindOneAndUpdate(mongodb.MongoCtx, bson.D{{ + Key: "_id", Value: entity.ID, + }}, bson.D{{Key: "$set", Value: entity}}, mongodb.FindOneAndUpdateOptions).Decode(&result) + if err != nil { + if !errors.Is(err, mongo.ErrNoDocuments) { + err = &interfaces.RequestError{ + StatusCode: 500, + Code: interfaces.ERROR_INTERNAL_SERVER, + Message: fmt.Sprintf("Internal Server Error: %s", err.Error()), + Name: "INTERNAL_ERROR", + } + } else { + err = nil + } + } + repo.cacheDataToRedis(entity) + return &result, err +} + +func (repo *EndPointRepoStruct) FindOne(id string) (*dump_server_interfaces.EndPoint, error) { + result := new(dump_server_interfaces.EndPoint) + if redisData := repo.redis.GetStringData(dump_server_env.GetRedisKey(id)); redisData != "" { + if err := json.Unmarshal([]byte(redisData), result); err == nil { + result.RestoreTimeStamp() + return result, err + } + } + err := repo.collection.FindOne(mongodb.MongoCtx, bson.D{{ + Key: "id", Value: id, + }}).Decode(&result) + if err != nil { + if errors.Is(err, mongo.ErrNoDocuments) { + // This error means your query did not match any documents. + err = &interfaces.RequestError{ + StatusCode: http.StatusBadRequest, + Code: interfaces.ERROR_ENTITY_NOT_FOUND, + Message: fmt.Sprintf("GeneralUser Entity identified by id %s not found", id), + Name: "ENTITY_NOT_FOUND", + } + } else { + err = &interfaces.RequestError{ + StatusCode: 500, + Code: interfaces.ERROR_INTERNAL_SERVER, + Message: fmt.Sprintf("Internal Server Error: %s", err.Error()), + Name: "INTERNAL_ERROR", + } + } + return nil, err + } + repo.cacheDataToRedis(result) + return result, err +} + +// func (repo *EndPointRepoStruct) FindOneUserNameAndBullionId(uname string, bullionId string) (*dump_server_interfaces.EndPoint, error) { +// var result dump_server_interfaces.EndPoint +// err := repo.collection.FindOne(mongodb.MongoCtx, bson.D{{ +// Key: "userName", Value: uname, +// }, { +// Key: "bullionId", Value: bullionId, +// }}).Decode(&result) +// if err != nil { +// if errors.Is(err, mongo.ErrNoDocuments) { +// // This error means your query did not match any documents. +// err = &interfaces.RequestError{ +// StatusCode: http.StatusBadRequest, +// Code: interfaces.ERROR_ENTITY_NOT_FOUND, +// Message: fmt.Sprintf("GeneralUser Entity identified by uname %s and bullionId %s not found", uname, bullionId), +// Name: "ENTITY_NOT_FOUND", +// } +// } else { +// err = &interfaces.RequestError{ +// StatusCode: 500, +// Code: interfaces.ERROR_INTERNAL_SERVER, +// Message: fmt.Sprintf("Internal Server Error: %s", err.Error()), +// Name: "INTERNAL_ERROR", +// } +// } +// return nil, err +// } +// return &result, err +// } diff --git a/servers/http-dump/dump-server/repos/event.repo.go b/servers/http-dump/dump-server/repos/event.repo.go new file mode 100644 index 0000000..0789e39 --- /dev/null +++ b/servers/http-dump/dump-server/repos/event.repo.go @@ -0,0 +1,65 @@ +package dump_server_repos + +import ( + "errors" + "fmt" + + "github.com/rpsoftech/golang-servers/env" + "github.com/rpsoftech/golang-servers/interfaces" + dump_server_events "github.com/rpsoftech/golang-servers/servers/http-dump/dump-server/events" + "github.com/rpsoftech/golang-servers/utility/mongodb" + "go.mongodb.org/mongo-driver/mongo" +) + +type EventRepoStruct struct { + collection *mongo.Collection +} + +const eventsCollectionName = "Events" + +var EventRepo *EventRepoStruct + +func init() { + if env.Env.APP_ENV == env.APP_ENV_DEVELOPE { + return + } + coll := mongodb.MongoDatabase.Collection(eventsCollectionName) + EventRepo = &EventRepoStruct{ + collection: coll, + } + mongodb.AddUniqueIndexesToCollection([]string{"id"}, EventRepo.collection) + mongodb.AddIndexesToCollection([]string{"key", "occurredAt", "eventName", "parentNames"}, EventRepo.collection) +} + +func (repo *EventRepoStruct) Save(entity *dump_server_events.DumpServerBaseEvent) error { + _, err := repo.collection.InsertOne(mongodb.MongoCtx, entity) + if err != nil { + if !errors.Is(err, mongo.ErrNoDocuments) { + err = &interfaces.RequestError{ + StatusCode: 500, + Code: interfaces.ERROR_INTERNAL_SERVER, + Message: fmt.Sprintf("Internal Server Error: %s", err.Error()), + Name: "INTERNAL_ERROR", + } + } else { + err = nil + } + } + return err +} +func (repo *EventRepoStruct) SaveAll(entity *[]any) error { + _, err := repo.collection.InsertMany(mongodb.MongoCtx, *entity) + if err != nil { + if !errors.Is(err, mongo.ErrNoDocuments) { + err = &interfaces.RequestError{ + StatusCode: 500, + Code: interfaces.ERROR_INTERNAL_SERVER, + Message: fmt.Sprintf("Internal Server Error: %s", err.Error()), + Name: "INTERNAL_ERROR", + } + } else { + err = nil + } + } + return err +} diff --git a/servers/http-dump/dump-server/services/dump.service.go b/servers/http-dump/dump-server/services/dump.service.go new file mode 100644 index 0000000..7dc20b3 --- /dev/null +++ b/servers/http-dump/dump-server/services/dump.service.go @@ -0,0 +1,42 @@ +package dump_server_services + +import ( + "fmt" + "net/http" + + "github.com/rpsoftech/golang-servers/interfaces" + dump_server_events "github.com/rpsoftech/golang-servers/servers/http-dump/dump-server/events" + dump_server_repos "github.com/rpsoftech/golang-servers/servers/http-dump/dump-server/repos" +) + +type endPointService struct { + endPointRepo *dump_server_repos.EndPointRepoStruct + eventBus *eventBusService +} + +var EndPointService *endPointService + +func init() { + EndPointService = &endPointService{ + eventBus: getEventBusService(), + endPointRepo: dump_server_repos.EndPointRepo, + } + println("EndPoints Service Initialized") +} + +func (s *endPointService) DumpData(id string, dumpString string) error { + EndPoint, err := s.endPointRepo.FindOne(id) + if err != nil { + return &interfaces.RequestError{ + StatusCode: http.StatusUnauthorized, + Code: interfaces.ERROR_ENTITY_NOT_FOUND, + Message: "Entity Not Found For " + id, + Name: "Invalid Id For Entity", + Extra: err, + } + } + event := dump_server_events.CreateDumpEvent(id, dumpString) + s.eventBus.Publish(event) + s.eventBus.PunlishCustomDataToRedis(fmt.Sprintf("d/%s", EndPoint.GetChanel()), dumpString) + return nil +} diff --git a/servers/http-dump/dump-server/services/event-bus.service.go b/servers/http-dump/dump-server/services/event-bus.service.go new file mode 100644 index 0000000..19b7663 --- /dev/null +++ b/servers/http-dump/dump-server/services/event-bus.service.go @@ -0,0 +1,45 @@ +package dump_server_services + +import ( + dump_server_env "github.com/rpsoftech/golang-servers/servers/http-dump/dump-server/env" + dump_server_events "github.com/rpsoftech/golang-servers/servers/http-dump/dump-server/events" + dump_server_repos "github.com/rpsoftech/golang-servers/servers/http-dump/dump-server/repos" + "github.com/rpsoftech/golang-servers/utility/redis" +) + +type eventBusService struct { + eventsRepo *dump_server_repos.EventRepoStruct + redis *redis.RedisClientStruct +} + +var eventBus *eventBusService + +func getEventBusService() *eventBusService { + if eventBus == nil { + eventBus = &eventBusService{ + eventsRepo: dump_server_repos.EventRepo, + redis: redis.InitRedisAndRedisClient(), + } + println("EventBus Service Initialized") + } + return eventBus +} +func (service *eventBusService) Publish(event *dump_server_events.DumpServerBaseEvent) { + go service.saveToDb(event) +} +func (service *eventBusService) PublishAll(event *[]dump_server_events.DumpServerBaseEvent) { + go service.saveAllToDb(event) +} +func (service *eventBusService) saveAllToDb(events *[]dump_server_events.DumpServerBaseEvent) { + for _, event := range *events { + service.saveToDb(&event) + } +} +func (service *eventBusService) saveToDb(event *dump_server_events.DumpServerBaseEvent) { + service.redis.PublishEvent(event) + service.eventsRepo.Save(event) +} + +func (service *eventBusService) PunlishCustomDataToRedis(chanel string, data string) { + service.redis.PublishCustomEvent(dump_server_env.GetRedisEventKey(chanel), data) +} diff --git a/utility/functions/pdf-to-thumb.go b/servers/whatsapp-server/src/utility/pdf-to-thumb.go similarity index 98% rename from utility/functions/pdf-to-thumb.go rename to servers/whatsapp-server/src/utility/pdf-to-thumb.go index 3d5e457..c3bc032 100644 --- a/utility/functions/pdf-to-thumb.go +++ b/servers/whatsapp-server/src/utility/pdf-to-thumb.go @@ -1,6 +1,6 @@ //go:build !windows -package utility_functions +package whatsapp_utility import ( "bytes" diff --git a/utility/functions/pdf-to-thumb.win.go b/servers/whatsapp-server/src/utility/pdf-to-thumb.win.go similarity index 99% rename from utility/functions/pdf-to-thumb.win.go rename to servers/whatsapp-server/src/utility/pdf-to-thumb.win.go index 0acf2cd..136a4df 100644 --- a/utility/functions/pdf-to-thumb.win.go +++ b/servers/whatsapp-server/src/utility/pdf-to-thumb.win.go @@ -1,6 +1,6 @@ //go:build windows -package utility_functions +package whatsapp_utility import ( "bytes" diff --git a/servers/whatsapp-server/src/whatsapp/interfaces.go b/servers/whatsapp-server/src/whatsapp/interfaces.go index 7f45c03..4c5607e 100644 --- a/servers/whatsapp-server/src/whatsapp/interfaces.go +++ b/servers/whatsapp-server/src/whatsapp/interfaces.go @@ -13,6 +13,7 @@ import ( "github.com/rpsoftech/golang-servers/env" "github.com/rpsoftech/golang-servers/interfaces" whatsapp_config "github.com/rpsoftech/golang-servers/servers/whatsapp-server/src/config" + whatsapp_utility "github.com/rpsoftech/golang-servers/servers/whatsapp-server/src/utility" utility_functions "github.com/rpsoftech/golang-servers/utility/functions" "go.mau.fi/whatsmeow" "go.mau.fi/whatsmeow/proto/waE2E" @@ -305,7 +306,7 @@ func (connection *WhatsappConnection) sendMediaFile(to []string, fileByte []byte println("finished uploading") if strings.Contains(extensionName, "pdf") { println("PDF to thumb") - thumb, err := utility_functions.ExtractFirstPage(fileByte) + thumb, err := whatsapp_utility.ExtractFirstPage(fileByte) if err == nil && len(thumb) > 0 { docProto.DocumentMessage.JPEGThumbnail = thumb } else { diff --git a/utility/redis/index.go b/utility/redis/index.go index 851359d..8912311 100644 --- a/utility/redis/index.go +++ b/utility/redis/index.go @@ -17,6 +17,7 @@ type RedisClientConfig struct { REDIS_DB_HOST string `json:"REDIS_DB_HOST" validate:"required"` REDIS_DB_PORT int `json:"REDIS_DB_PORT" validate:"required,port"` REDIS_DB_PASSWORD string `json:"REDIS_DB_PASSWORD" validate:"required"` + REDIS_DB_USERNAME string `json:"REDIS_DB_USERNAME"` REDIS_DB_DATABASE int `json:"REDIS_DB_DATABASE" validate:"min=0,max=100"` } @@ -59,12 +60,14 @@ func InitRedisAndRedisClient() *RedisClientStruct { REDIS_DB_HOST: env.Env.GetEnv(env.REDIS_DB_HOST_KEY), REDIS_DB_PASSWORD: env.Env.GetEnv(env.REDIS_DB_PASSWORD_KEY), REDIS_DB_DATABASE: redis_DB_DATABASE, + REDIS_DB_USERNAME: env.Env.GetEnv(env.REDIS_DB_USERNAME_KEY), } env.ValidateEnv(config) client := redis.NewClient(&redis.Options{ Addr: fmt.Sprintf("%v:%d", config.REDIS_DB_HOST, config.REDIS_DB_PORT), Password: config.REDIS_DB_PASSWORD, // no password set - DB: config.REDIS_DB_DATABASE, // use default DB + DB: config.REDIS_DB_DATABASE, // use default DB, + Username: config.REDIS_DB_USERNAME, }) RedisClient = &RedisClientStruct{ @@ -103,6 +106,9 @@ func (r *RedisClientStruct) SubscribeToChannels(channels ...string) *redis.PubSu func (r *RedisClientStruct) PublishEvent(event events.BaseEventInterface) { r.redisClient.Publish(RedisCTX, event.GetEventName(), event.GetPayloadString()) } +func (r *RedisClientStruct) PublishCustomEvent(event string, payload string) { + r.redisClient.Publish(RedisCTX, event, payload) +} func (r *RedisClientStruct) GetHashValue(key string) map[string]string { return r.redisClient.HGetAll(RedisCTX, key).Val() }