-, need add sse and other cntrl methods and check

internal/app/app.go

@@ -7,6 +7,7 @@ import (
 	"go.uber.org/zap"
 	"heruvym/app"
 	"heruvym/internal/initialize"
+	"heruvym/internal/server/http"
 	"heruvym/pkg/closer"
 	"strconv"
 	"time"
@@ -95,10 +96,33 @@ func Run(ctx context.Context, cfg initialize.Config, build Build) error {
 		return err
 	}
 
-	//shutdownGroup.Add(closer.CloserFunc(clientServer.Shutdown))
+	controllers := initialize.NewControllers(initialize.ControllersDeps{
+		Reps:        repositories,
+		RedisClient: redisClient,
+		Notifier:    tgBot,
+		TgChatID:    int64(cfg.TgChatID),
+		HLogger:     hlogger,
+		ZapLogger:   logger,
+	})
+
+	srv := http.NewServer(http.ServerConfig{
+		Logger:      logger,
+		Controllers: []http.Controller{controllers.Tickets, controllers.Other},
+		Hlogger:     hlogger,
+		//JWT:         jwtUtil,
+	})
+
+	go func() {
+		if err := srv.Start(cfg.HTTPHost + ":" + cfg.HTTPPort); err != nil {
+			logger.Error("Server startup error", zap.Error(err))
+			cancel()
+		}
+	}()
+
+	shutdownGroup.Add(closer.CloserFunc(srv.Shutdown))
 	//shutdownGroup.Add(closer.CloserFunc(adminServer.Shutdown))
 	//shutdownGroup.Add(closer.CloserFunc(grpcServer.Stop))
-	//shutdownGroup.Add(closer.CloserFunc(mdb.Client().Disconnect))
+	shutdownGroup.Add(closer.CloserFunc(mdb.Client().Disconnect))
 	//shutdownGroup.Add(closer.CloserFunc(recoveryWC.Stop))
 	//shutdownGroup.Add(closer.CloserFunc(purgeWC.Stop))
 

internal/controllers/other/other.go

@@ -1,21 +1,25 @@
 package other
 
 import (
+	"github.com/go-redis/redis/v8"
 	"github.com/gofiber/fiber/v2"
 	"heruvym/internal/repository/mongo"
 	"heruvym/internal/utils/jwt_adapter"
 )
 
 type Deps struct {
-	Dal *mongo.DAL
+	Dal         *mongo.DAL
+	RedisClient *redis.Client
 }
 type OtherController struct {
-	dal *mongo.DAL
+	dal         *mongo.DAL
+	redisClient *redis.Client
 }
 
 func NewOtherController(deps Deps) *OtherController {
 	return &OtherController{
-		dal: deps.Dal,
+		dal:         deps.Dal,
+		redisClient: deps.RedisClient,
 	}
 }
 

internal/controllers/tickets/route.go

@@ -1,11 +1,14 @@
 package tickets
 
-import "github.com/gofiber/fiber/v2"
+import (
+	"github.com/gofiber/fiber/v2"
+	"heruvym/tools"
+)
 
 func (t *TicketController) Register(router fiber.Router) {
 	router.Post("/create", t.CreateTicket)
-	router.Get("/subscribe", t.GetList) // sse
+	router.Get("/subscribe", tools.SseWrapper(t.GetList)) // sse todo
-	router.Get("/ticket", t.Subscribe)  // sse
+	router.Get("/ticket", tools.SseWrapper(t.Subscribe))  // sse todo
 	router.Post("/send", t.PutMessage)
 	router.Post("/getTickets", t.GetTickets)
 	router.Post("/getMessages", t.GetMessages)

internal/controllers/tickets/tickets.go

@@ -1,18 +1,20 @@
 package tickets
 
 import (
+	"context"
 	"encoding/json"
+	"errors"
 	"fmt"
 	"github.com/gofiber/fiber/v2"
 	"github.com/themakers/hlog"
 	"go.uber.org/zap"
 	"gopkg.in/telebot.v3"
-	tb "gopkg.in/tucnak/telebot.v2"
 	our_errors "heruvym/internal/controllers/errors"
 	"heruvym/internal/model"
 	"heruvym/internal/repository/mongo"
 	"heruvym/internal/utils/jwt_adapter"
 	"heruvym/internal/utils/middleware"
+	"heruvym/tools"
 )
 
 type Deps struct {
@@ -137,7 +139,7 @@ func (t *TicketController) CreateTicket(ctx *fiber.Ctx) error {
 					message := fmt.Sprintf("Вам пришло сообщение от %s сссылка на пользователя с %s, ccылка на чат - %s",
 						userLink, domain, supportLink)
 
-					if _, err := t.notifier.Send(tb.ChatID(t.tgChatID), message); err != nil {
+					if _, err := t.notifier.Send(telebot.ChatID(t.tgChatID), message); err != nil {
 						fmt.Println("CAN NOT NOTIFY", err)
 					}
 					return
@@ -218,7 +220,7 @@ func (t *TicketController) PutMessage(ctx *fiber.Ctx) error {
 				message := fmt.Sprintf("Вам пришло сообщение от %s сссылка на пользователя с %s, ссылка на чат - %s",
 					userLink, domain, supportLink)
 
-				if _, err := t.notifier.Send(tb.ChatID(t.tgChatID), message); err != nil {
+				if _, err := t.notifier.Send(telebot.ChatID(t.tgChatID), message); err != nil {
 					t.zapLogger.Error("CAN NOT NOTIFY", zap.Error(err))
 				}
 				return
@@ -398,3 +400,240 @@ func (t *TicketController) SetShown(ctx *fiber.Ctx) error {
 	}
 	return ctx.SendStatus(fiber.StatusOK)
 }
+
+// todo екнуть как работает
+var _ tools.DataEmitter = (&TicketController{}).GetList
+
+func (t *TicketController) GetList(ctx context.Context) chan interface{} {
+	fmt.Println("GetList")
+	defer func() {
+		if rec := recover(); rec != nil {
+			fmt.Println(rec)
+		}
+	}()
+	sess := jwt_adapter.Get(ctx)
+	fmt.Println("sess", sess)
+	if sess == nil {
+		return nil
+	}
+
+	output := make(chan interface{})
+
+	if sess.Id == "" {
+		go t.unauthorizedTickets(ctx, sess.Id, output)
+	} else {
+		role := jwt_adapter.GetRole(ctx)
+
+		fmt.Println("ALL TICKETS Sess ", sess.Id, role)
+		if role == "admin" || role == "manager" {
+			go t.allTickets(ctx, output)
+		} else {
+			go t.userTickets(ctx, sess.Id, output)
+		}
+	}
+
+	return output
+}
+
+func (t *TicketController) allTickets(ctx context.Context, output chan interface{}) {
+	defer func() {
+		if v := recover(); v != nil {
+			fmt.Println("AllTicketsRec", v)
+		}
+	}()
+
+	//data, count, err := h.dal.YieldTickets(ctx, 20)
+	//
+	//if err != nil {
+	//	output <- errors.New("cannot get tickets:" + err.Error())
+	//	return
+	//}
+	//
+	//if data != nil {
+	//	output <- GetTicketsResp{data, count}
+	//}
+
+	if err := t.dal.WatchAllTickets(ctx, func(ticket model.Ticket) error {
+		output <- ticket
+		return nil
+	}); err != nil {
+		output <- errors.New("cannot watch all tickets" + err.Error())
+	}
+}
+
+func (t *TicketController) userTickets(ctx context.Context, userID string, output chan interface{}) {
+
+	defer func() {
+		if v := recover(); v != nil {
+			fmt.Println("USERTICKS", v)
+		}
+	}()
+
+	data, count, err := t.dal.YieldUserTickets(ctx, userID, 20, 0)
+
+	if err != nil {
+		output <- errors.New("cannot get tickets:" + err.Error())
+		return
+	}
+
+	if data != nil {
+		output <- GetTicketsResp{data, count}
+	}
+
+	if err := t.dal.WatchTickets(ctx, userID, func(ticket model.Ticket) error {
+		output <- ticket
+		return nil
+	}); err != nil {
+		output <- errors.New("cannot watch tickets")
+		return
+	}
+}
+
+func (t *TicketController) unauthorizedTickets(ctx context.Context, sess string, output chan interface{}) {
+	//defer close(output)
+
+	tickets, count, err := t.dal.GetTickets4Sess(ctx, sess)
+
+	if err != nil {
+		output <- errors.New("no tickets for session")
+		return
+	}
+
+	if tickets != nil {
+		output <- GetTicketsResp{tickets, count}
+	}
+}
+
+var _ tools.DataEmitter = (&TicketController{}).Subscribe
+
+func (t *TicketController) Subscribe(ctx context.Context) chan interface{} {
+	sess := jwt_adapter.Get(ctx)
+	fmt.Println("SESS Subsc", sess)
+
+	ticketID := ctx.Value(tools.ContextURLKey).(string)
+
+	output := make(chan interface{})
+	if sess.Id == "" {
+		go func() {
+			ticket, err := t.dal.GetTicket4Sess(ctx, ticketID, sess.Id)
+			if err != nil || ticket == nil {
+				output <- errors.New("no tickets 4 session")
+				return
+			}
+
+			/*if err := h.dal.YieldMessages(ctx, ticketID, func(message model.Message) error {
+				output <- message
+				fmt.Println("OOOOOOLd")
+
+				//if err := h.dal.SetShown(ctx, message.ID, sess.Session); err != nil {
+				//
+				//	output <- errors.New("cannot show message " + err.Error())
+				//	return err
+				//}
+
+				return nil
+			}); err != nil {
+				output <- errors.New("cannot read messages " + err.Error())
+			}*/
+
+			if err := t.dal.WatchMessages(ctx, ticketID,
+				func(message model.Message) error {
+					output <- message
+
+					//if err := h.dal.SetShown(ctx, message.ID, sess.Session); err != nil {
+					//	fmt.Println("3", err)
+					//	output <- errors.New("cannot show watch message " + err.Error())
+					//	return err
+					//}
+
+					return nil
+				}); err != nil {
+				fmt.Println("4", err)
+				output <- errors.New("cannot watch messages " + err.Error())
+			}
+		}()
+	} else {
+		role := jwt_adapter.GetRole(ctx)
+
+		if role == "admin" || role == "manager" {
+			go func() {
+
+				if err := t.dal.YieldMessages(ctx, ticketID, func(message model.Message) error {
+					output <- message
+
+					//if err := h.dal.SetShown(ctx, message.ID, sess.User); err != nil {
+					//	fmt.Println("2", err)
+					//	output <- errors.New("cannot show message " + err.Error())
+					//	return err
+					//}
+
+					return nil
+				}); err != nil {
+					fmt.Println("1", err)
+					output <- errors.New("cannot read messages " + err.Error())
+				}
+
+				if err := t.dal.WatchMessages(ctx, ticketID,
+					func(message model.Message) error {
+						output <- message
+
+						//if err := h.dal.SetShown(ctx, message.ID, sess.Session); err != nil {
+						//	fmt.Println("3", err)
+						//	output <- errors.New("cannot show watch message " + err.Error())
+						//	return err
+						//}
+
+						return nil
+					}); err != nil {
+					fmt.Println("4", err)
+					output <- errors.New("cannot watch messages " + err.Error())
+				}
+			}()
+		} else {
+			go func() {
+				defer func() {
+					if v := recover(); v != nil {
+						fmt.Println("heryvym panic", v)
+					}
+				}()
+				ticket, err := t.dal.GetTicket4User(ctx, ticketID, sess.Id)
+				if err != nil || ticket == nil {
+					output <- errors.New("no tickets 4 user")
+				}
+
+				/*if err := h.dal.YieldMessages(ctx, ticketID, func(message model.Message) error {
+					output <- message
+
+					//if err := h.dal.SetShown(ctx, message.ID, sess.User); err != nil {
+					//	fmt.Println("2", err)
+					//	output <- errors.New("cannot show message " + err.Error())
+					//	return err
+					//}
+
+					return nil
+				}); err != nil {
+					fmt.Println("1", err)
+					output <- errors.New("cannot read messages " + err.Error())
+				}*/
+
+				if err := t.dal.WatchMessages(ctx, ticketID,
+					func(message model.Message) error {
+						output <- message
+
+						//if err := h.dal.SetShown(ctx, message.ID, sess.Session); err != nil {
+						//	fmt.Println("3", err)
+						//	output <- errors.New("cannot show watch message " + err.Error())
+						//	return err
+						//}
+
+						return nil
+					}); err != nil {
+					fmt.Println("4", err)
+					output <- errors.New("cannot watch messages " + err.Error())
+				}
+			}()
+		}
+	}
+
+	return output
+}

internal/initialize/config.go

@@ -29,6 +29,8 @@ type Config struct {
 	RedisPassword    string `env:"REDIS_PASSWORD" envDefault:""`
 	RedisDB          int    `env:"REDIS_DB" envDefault:"0"`
 	TgChatID         uint64 `env:"TELEGRAM_CHAT_ID" envDefault:"1001344671794"`
+	HTTPHost         string `env:"HTTP_HOST" envDefault:"localhost"`
+	HTTPPort         string `env:"HTTP_PORT" envDefault:"3000"`
 }
 
 func LoadConfig() (*Config, error) {

internal/initialize/controllers.go

@@ -0,0 +1,40 @@
+package initialize
+
+import (
+	"github.com/go-redis/redis/v8"
+	"github.com/themakers/hlog"
+	"go.uber.org/zap"
+	"gopkg.in/telebot.v3"
+	"heruvym/internal/controllers/other"
+	"heruvym/internal/controllers/tickets"
+)
+
+type ControllersDeps struct {
+	Reps        *Repositories
+	RedisClient *redis.Client
+	Notifier    *telebot.Bot
+	TgChatID    int64
+	HLogger     hlog.Logger
+	ZapLogger   *zap.Logger
+}
+
+type Controllers struct {
+	Tickets *tickets.TicketController
+	Other   *other.OtherController
+}
+
+func NewControllers(deps ControllersDeps) *Controllers {
+	return &Controllers{
+		Tickets: tickets.NewTicketController(tickets.Deps{
+			Dal:       deps.Reps.Mongo,
+			Notifier:  deps.Notifier,
+			TgChatID:  deps.TgChatID,
+			ZapLogger: deps.ZapLogger,
+			HLogger:   deps.HLogger,
+		}),
+		Other: other.NewOtherController(other.Deps{
+			Dal:         deps.Reps.Mongo,
+			RedisClient: deps.RedisClient,
+		}),
+	}
+}

internal/initialize/tg.go

@@ -1,16 +1,16 @@
 package initialize
 
 import (
-	tb "gopkg.in/tucnak/telebot.v2"
+	"gopkg.in/telebot.v3"
 	"time"
 )
 
-func NewTgBot(cfg Config) (*tb.Bot, error) {
+func NewTgBot(cfg Config) (*telebot.Bot, error) {
-	newBot, err := tb.NewBot(tb.Settings{
+	newBot, err := telebot.NewBot(telebot.Settings{
 		Token:     cfg.TgToken,
 		Verbose:   false,
-		ParseMode: tb.ModeHTML,
+		ParseMode: telebot.ModeHTML,
-		Poller: &tb.LongPoller{
+		Poller: &telebot.LongPoller{
 			Timeout: time.Second,
 		},
 	})

service/service.go

@@ -31,9 +31,8 @@ type Heruvym struct {
 	dal    *mongo.DAL
 	bs     *minio.BlobStore
 
-	notifier    *tb.Bot
+	notifier *tb.Bot
-	tgChatID    int64
+	tgChatID int64
-	redisClient *redis.Client
 }
 
 func New(