PenaSide/heruvym
3
0
Fork 0
Code Issues 2 Pull Requests Actions Packages Projects Releases Wiki Activity

-, need add sse and other cntrl methods and check

Browse Source
This commit is contained in:
Pavel 2024-09-30 19:17:17 +03:00
parent e3f08cac07
commit 7cc65c1cd8
8 changed files with 330 additions and 19 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

28
internal/app/app.go
View File

@ -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))

10
internal/controllers/other/other.go
View File

@ -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,
}
}

9
internal/controllers/tickets/route.go
View File

@ -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("/ticket", t.Subscribe) // sse
router.Get("/subscribe", tools.SseWrapper(t.GetList)) // sse todo
router.Get("/ticket", tools.SseWrapper(t.Subscribe)) // sse todo
router.Post("/send", t.PutMessage)
router.Post("/getTickets", t.GetTickets)
router.Post("/getMessages", t.GetMessages)

245
internal/controllers/tickets/tickets.go
View File

@ -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
}

2
internal/initialize/config.go
View File

@ -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) {

40
internal/initialize/controllers.go Normal file
View File

@ -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,
}),
}
}

10
internal/initialize/tg.go
View File

@ -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) {
newBot, err := tb.NewBot(tb.Settings{
func NewTgBot(cfg Config) (*telebot.Bot, error) {
newBot, err := telebot.NewBot(telebot.Settings{
Token: cfg.TgToken,
Verbose: false,
ParseMode: tb.ModeHTML,
Poller: &tb.LongPoller{
ParseMode: telebot.ModeHTML,
Poller: &telebot.LongPoller{
Timeout: time.Second,
},
})

5
service/service.go
View File

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