HyperNet/Messaging
2
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

♻️ Move dealer to nexus

Browse Source
This commit is contained in:
LittleSheep
2024-11-02 13:23:27 +08:00
parent fce8669059
commit cef4764d8c
38 changed files with 454 additions and 550 deletions
Download Patch File Download Diff File Expand all files Collapse all files

1
pkg/internal/database/migrator.go
View File

@ -6,7 +6,6 @@ import (
)
var AutoMaintainRange = []any{
&models.Account{},
&models.Realm{},
&models.Channel{},
&models.ChannelMember{},

17
pkg/internal/database/source.go
View File

@ -1,28 +1,31 @@
package database
import (
"fmt"
"git.solsynth.dev/hydrogen/messaging/pkg/internal/gap"
"git.solsynth.dev/hypernet/nexus/pkg/nex/cruda"
"github.com/rs/zerolog/log"
"github.com/samber/lo"
"github.com/spf13/viper"
"gorm.io/driver/postgres"
"gorm.io/gorm"
"gorm.io/gorm/logger"
"gorm.io/gorm/schema"
)
var C *gorm.DB
func NewSource() error {
var err error
func NewGorm() error {
dsn, err := cruda.NewCrudaConn(gap.Nx).AllocDatabase("messaging")
if err != nil {
return fmt.Errorf("failed to alloc database from nexus: %v", err)
}
dialector := postgres.Open(viper.GetString("database.dsn"))
C, err = gorm.Open(dialector, &gorm.Config{NamingStrategy: schema.NamingStrategy{
TablePrefix: viper.GetString("database.prefix"),
}, Logger: logger.New(&log.Logger, logger.Config{
C, err = gorm.Open(postgres.Open(dsn), &gorm.Config{Logger: logger.New(&log.Logger, logger.Config{
Colorful: true,
IgnoreRecordNotFoundError: true,
LogLevel: lo.Ternary(viper.GetBool("debug.database"), logger.Info, logger.Silent),
})})
return err
}

15
pkg/internal/gap/net.go
View File

@ -1,15 +0,0 @@
package gap
import "net"
func GetOutboundIP() (net.IP, error) {
conn, err := net.Dial("udp", "1.1.1.1:80")
if err != nil {
return nil, err
} else {
defer conn.Close()
}
localAddr := conn.LocalAddr().(*net.UDPAddr)
return localAddr.IP, nil
}

27
pkg/internal/gap/server.go
View File

@ -2,42 +2,51 @@ package gap
import (
"fmt"
"git.solsynth.dev/hypernet/nexus/pkg/nex"
"git.solsynth.dev/hypernet/nexus/pkg/proto"
"git.solsynth.dev/hypernet/pusher/pkg/pushkit/pushcon"
"github.com/samber/lo"
"strings"
"git.solsynth.dev/hydrogen/dealer/pkg/hyper"
"git.solsynth.dev/hydrogen/dealer/pkg/proto"
"github.com/rs/zerolog/log"
"github.com/spf13/viper"
)
var H *hyper.HyperConn
var Nx *nex.Conn
var Px *pushcon.Conn
func RegisterService() error {
func InitializeToNexus() error {
grpcBind := strings.SplitN(viper.GetString("grpc_bind"), ":", 2)
httpBind := strings.SplitN(viper.GetString("bind"), ":", 2)
outboundIp, _ := GetOutboundIP()
outboundIp, _ := nex.GetOutboundIP()
grpcOutbound := fmt.Sprintf("%s:%s", outboundIp, grpcBind[1])
httpOutbound := fmt.Sprintf("%s:%s", outboundIp, httpBind[1])
var err error
H, err = hyper.NewHyperConn(viper.GetString("dealer.addr"), &proto.ServiceInfo{
Nx, err = nex.NewNexusConn(viper.GetString("nexus_addr"), &proto.ServiceInfo{
Id: viper.GetString("id"),
Type: hyper.ServiceTypeMessagingProvider,
Type: "im",
Label: "Messaging",
GrpcAddr: grpcOutbound,
HttpAddr: &httpOutbound,
HttpAddr: lo.ToPtr("http://" + httpOutbound + "/api"),
})
if err == nil {
go func() {
err := H.KeepRegisterService()
err := Nx.RunRegistering()
if err != nil {
log.Error().Err(err).Msg("An error occurred while registering service...")
}
}()
}
Px, err = pushcon.NewConn(Nx)
if err != nil {
return fmt.Errorf("error during initialize pushcon: %v", err)
}
return err
}

28
pkg/internal/grpc/server.go
View File

@ -3,7 +3,7 @@ package grpc
import (
"net"
"git.solsynth.dev/hydrogen/dealer/pkg/proto"
"git.solsynth.dev/hypernet/nexus/pkg/proto"
"github.com/spf13/viper"
"google.golang.org/grpc"
health "google.golang.org/grpc/health/grpc_health_v1"
@ -11,27 +11,31 @@ import (
)
type Server struct {
proto.UnimplementedStreamControllerServer
proto.UnimplementedServiceDirectoryServer
proto.UnimplementedStreamServiceServer
proto.UnimplementedDirectoryServiceServer
srv *grpc.Server
}
var S *grpc.Server
func NewGrpc() *Server {
server := &Server{
srv: grpc.NewServer(),
}
func NewGRPC() {
S = grpc.NewServer()
health.RegisterHealthServer(server.srv, server)
proto.RegisterStreamServiceServer(server.srv, server)
proto.RegisterDirectoryServiceServer(server.srv, server)
health.RegisterHealthServer(S, &Server{})
proto.RegisterStreamControllerServer(S, &Server{})
proto.RegisterServiceDirectoryServer(S, &Server{})
reflection.Register(server.srv)
reflection.Register(S)
return server
}
func ListenGRPC() error {
func (v *Server) Listen() error {
listener, err := net.Listen("tcp", viper.GetString("grpc_bind"))
if err != nil {
return err
}
return S.Serve(listener)
return v.srv.Serve(listener)
}

39
pkg/internal/grpc/services.go
View File

@ -2,28 +2,41 @@ package grpc
import (
"context"
"git.solsynth.dev/hypernet/nexus/pkg/nex"
"git.solsynth.dev/hypernet/nexus/pkg/proto"
"strconv"
"git.solsynth.dev/hydrogen/dealer/pkg/proto"
"git.solsynth.dev/hydrogen/messaging/pkg/internal/database"
"git.solsynth.dev/hydrogen/messaging/pkg/internal/models"
)
func (v *Server) BroadcastDeletion(ctx context.Context, request *proto.DeletionRequest) (*proto.DeletionResponse, error) {
switch request.GetResourceType() {
case "account":
numericId, err := strconv.Atoi(request.GetResourceId())
if err != nil {
func (v *Server) BroadcastEvent(ctx context.Context, in *proto.EventInfo) (*proto.EventResponse, error) {
switch in.GetEvent() {
case "deletion":
data := nex.DecodeMap(in.GetData())
resType, ok := data["type"].(string)
if !ok {
break
}
for _, model := range database.AutoMaintainRange {
switch model.(type) {
default:
database.C.Delete(model, "account_id = ?", numericId)
switch resType {
case "account":
id, ok := data["id"].(string)
if !ok {
break
}
numericId, err := strconv.Atoi(id)
if err != nil {
break
}
tx := database.C.Begin()
for _, model := range database.AutoMaintainRange {
switch model.(type) {
default:
tx.Delete(model, "account_id = ?", numericId)
}
}
tx.Commit()
}
database.C.Delete(&models.Account{}, "id = ?", numericId)
}
return &proto.DeletionResponse{}, nil
return &proto.EventResponse{}, nil
}

31
pkg/internal/grpc/stream.go
View File

@ -3,43 +3,48 @@ package grpc
import (
"context"
"fmt"
"git.solsynth.dev/hypernet/nexus/pkg/nex"
"git.solsynth.dev/hydrogen/dealer/pkg/hyper"
"git.solsynth.dev/hydrogen/dealer/pkg/proto"
"git.solsynth.dev/hydrogen/messaging/pkg/internal/gap"
"git.solsynth.dev/hydrogen/messaging/pkg/internal/server/exts"
"git.solsynth.dev/hydrogen/messaging/pkg/internal/http/exts"
"git.solsynth.dev/hydrogen/messaging/pkg/internal/services"
"git.solsynth.dev/hypernet/nexus/pkg/proto"
jsoniter "github.com/json-iterator/go"
)
func (v *Server) EmitStreamEvent(_ context.Context, in *proto.StreamEventRequest) (*proto.StreamEventResponse, error) {
sc := proto.NewStreamControllerClient(gap.H.GetDealerGrpcConn())
func (v *Server) PushStream(_ context.Context, request *proto.PushStreamRequest) (*proto.PushStreamResponse, error) {
sc := proto.NewStreamServiceClient(gap.Nx.GetNexusGrpcConn())
switch in.GetEvent() {
var in nex.WebSocketPackage
if err := jsoniter.Unmarshal(request.GetBody(), &in); err != nil {
return nil, err
}
switch in.Action {
case "status.typing":
var data struct {
ChannelID uint `json:"channel_id" validate:"required"`
}
err := jsoniter.Unmarshal(in.GetPayload(), &data)
err := jsoniter.Unmarshal(in.RawPayload(), &data)
if err == nil {
err = exts.ValidateStruct(data)
}
if err != nil {
_, _ = sc.PushStream(context.Background(), &proto.PushStreamRequest{
ClientId: &in.ClientId,
Body: hyper.NetworkPackage{
ClientId: request.ClientId,
Body: nex.WebSocketPackage{
Action: "error",
Message: fmt.Sprintf("unable parse payload: %v", err),
}.Marshal(),
})
}
err = services.SetTypingStatus(data.ChannelID, uint(in.GetUserId()))
err = services.SetTypingStatus(data.ChannelID, uint(request.GetUserId()))
if err != nil {
_, _ = sc.PushStream(context.Background(), &proto.PushStreamRequest{
ClientId: &in.ClientId,
Body: hyper.NetworkPackage{
ClientId: request.ClientId,
Body: nex.WebSocketPackage{
Action: "error",
Message: fmt.Sprintf("unable boardcast status: %v", err),
}.Marshal(),
@ -47,5 +52,5 @@ func (v *Server) EmitStreamEvent(_ context.Context, in *proto.StreamEventRequest
}
}
return &proto.StreamEventResponse{}, nil
return &proto.PushStreamResponse{}, nil
}

21
pkg/internal/server/api/calls_api.go → pkg/internal/http/api/calls_api.go
View File

@ -1,12 +1,13 @@
package api
import (
"git.solsynth.dev/hypernet/nexus/pkg/nex/sec"
authm "git.solsynth.dev/hypernet/passport/pkg/authkit/models"
"sync"
"git.solsynth.dev/hydrogen/messaging/pkg/internal/database"
"git.solsynth.dev/hydrogen/messaging/pkg/internal/gap"
"git.solsynth.dev/hydrogen/messaging/pkg/internal/http/exts"
"git.solsynth.dev/hydrogen/messaging/pkg/internal/models"
"git.solsynth.dev/hydrogen/messaging/pkg/internal/server/exts"
"git.solsynth.dev/hydrogen/messaging/pkg/internal/services"
"github.com/gofiber/fiber/v2"
"github.com/google/uuid"
@ -55,10 +56,10 @@ func getOngoingCall(c *fiber.Ctx) error {
}
func startCall(c *fiber.Ctx) error {
if err := gap.H.EnsureGrantedPerm(c, "CreateCalls", true); err != nil {
if err := sec.EnsureGrantedPerm(c, "CreateCalls", true); err != nil {
return err
}
user := c.Locals("user").(models.Account)
user := c.Locals("user").(authm.Account)
alias := c.Params("channel")
var channel models.Channel
@ -105,10 +106,10 @@ func startCall(c *fiber.Ctx) error {
}
func endCall(c *fiber.Ctx) error {
if err := gap.H.EnsureAuthenticated(c); err != nil {
if err := sec.EnsureAuthenticated(c); err != nil {
return err
}
user := c.Locals("user").(models.Account)
user := c.Locals("user").(authm.Account)
alias := c.Params("channel")
var channel models.Channel
@ -151,10 +152,10 @@ func endCall(c *fiber.Ctx) error {
}
func kickParticipantInCall(c *fiber.Ctx) error {
if err := gap.H.EnsureAuthenticated(c); err != nil {
if err := sec.EnsureAuthenticated(c); err != nil {
return err
}
user := c.Locals("user").(models.Account)
user := c.Locals("user").(authm.Account)
alias := c.Params("channel")
var data struct {
@ -193,10 +194,10 @@ func kickParticipantInCall(c *fiber.Ctx) error {
}
func exchangeCallToken(c *fiber.Ctx) error {
if err := gap.H.EnsureAuthenticated(c); err != nil {
if err := sec.EnsureAuthenticated(c); err != nil {
return err
}
user := c.Locals("user").(models.Account)
user := c.Locals("user").(authm.Account)
alias := c.Params("channel")
var channel models.Channel

38
pkg/internal/server/api/channel_members_api.go → pkg/internal/http/api/channel_members_api.go
View File

@ -2,10 +2,11 @@ package api
import (
"fmt"
"git.solsynth.dev/hypernet/nexus/pkg/nex/sec"
authm "git.solsynth.dev/hypernet/passport/pkg/authkit/models"
"git.solsynth.dev/hydrogen/dealer/pkg/hyper"
"git.solsynth.dev/hydrogen/messaging/pkg/internal/gap"
"git.solsynth.dev/hydrogen/messaging/pkg/internal/server/exts"
"git.solsynth.dev/hydrogen/messaging/pkg/internal/http/exts"
"git.solsynth.dev/hydrogen/messaging/pkg/internal/database"
"git.solsynth.dev/hydrogen/messaging/pkg/internal/models"
@ -36,10 +37,10 @@ func listChannelMembers(c *fiber.Ctx) error {
func getMyChannelMembership(c *fiber.Ctx) error {
alias := c.Params("channel")
if err := gap.H.EnsureAuthenticated(c); err != nil {
if err := sec.EnsureAuthenticated(c); err != nil {
return err
}
user := c.Locals("user").(models.Account)
user := c.Locals("user").(authm.Account)
var err error
var channel models.Channel
@ -60,10 +61,10 @@ func getMyChannelMembership(c *fiber.Ctx) error {
}
func addChannelMember(c *fiber.Ctx) error {
if err := gap.H.EnsureAuthenticated(c); err != nil {
if err := sec.EnsureAuthenticated(c); err != nil {
return err
}
user := c.Locals("user").(models.Account)
user := c.Locals("user").(authm.Account)
alias := c.Params("channel")
var data struct {
@ -89,7 +90,7 @@ func addChannelMember(c *fiber.Ctx) error {
return fiber.NewError(fiber.StatusForbidden, "you must be a moderator of a channel to add member into it")
}
var account models.Account
var account authm.Account
if err := database.C.Where(&hyper.BaseUser{
Name: data.Target,
}).First(&account).Error; err != nil {
@ -104,10 +105,10 @@ func addChannelMember(c *fiber.Ctx) error {
}
func removeChannelMember(c *fiber.Ctx) error {
if err := gap.H.EnsureAuthenticated(c); err != nil {
if err := sec.EnsureAuthenticated(c); err != nil {
return err
}
user := c.Locals("user").(models.Account)
user := c.Locals("user").(authm.Account)
alias := c.Params("channel")
var data struct {
@ -134,7 +135,7 @@ func removeChannelMember(c *fiber.Ctx) error {
return fiber.NewError(fiber.StatusForbidden, "you must be a moderator of a channel to remove member into it")
}
var account models.Account
var account authm.Account
if err := database.C.Where(&hyper.BaseUser{
Name: data.Target,
}).First(&account).Error; err != nil {
@ -149,10 +150,10 @@ func removeChannelMember(c *fiber.Ctx) error {
}
func editMyChannelMembership(c *fiber.Ctx) error {
if err := gap.H.EnsureAuthenticated(c); err != nil {
if err := sec.EnsureAuthenticated(c); err != nil {
return err
}
user := c.Locals("user").(models.Account)
user := c.Locals("user").(authm.Account)
alias := c.Params("channel")
var data struct {
@ -183,11 +184,12 @@ func editMyChannelMembership(c *fiber.Ctx) error {
return fiber.NewError(fiber.StatusNotFound, err.Error())
}
membership.Name = user.Name
membership.Notify = data.NotifyLevel
if len(data.Nick) > 0 {
membership.Nick = &data.Nick
membership.Nick = data.Nick
} else {
membership.Nick = nil
membership.Nick = user.Nick
}
if membership, err := services.EditChannelMember(membership); err != nil {
@ -198,10 +200,10 @@ func editMyChannelMembership(c *fiber.Ctx) error {
}
func joinChannel(c *fiber.Ctx) error {
if err := gap.H.EnsureAuthenticated(c); err != nil {
if err := sec.EnsureAuthenticated(c); err != nil {
return err
}
user := c.Locals("user").(models.Account)
user := c.Locals("user").(authm.Account)
alias := c.Params("channel")
var channel models.Channel
@ -231,10 +233,10 @@ func joinChannel(c *fiber.Ctx) error {
}
func leaveChannel(c *fiber.Ctx) error {
if err := gap.H.EnsureAuthenticated(c); err != nil {
if err := sec.EnsureAuthenticated(c); err != nil {
return err
}
user := c.Locals("user").(models.Account)
user := c.Locals("user").(authm.Account)
alias := c.Params("channel")
var channel models.Channel

35
pkg/internal/server/api/channels_api.go → pkg/internal/http/api/channels_api.go
View File

@ -2,10 +2,11 @@ package api
import (
"fmt"
"git.solsynth.dev/hypernet/nexus/pkg/nex/sec"
authm "git.solsynth.dev/hypernet/passport/pkg/authkit/models"
"git.solsynth.dev/hydrogen/dealer/pkg/hyper"
"git.solsynth.dev/hydrogen/messaging/pkg/internal/gap"
"git.solsynth.dev/hydrogen/messaging/pkg/internal/server/exts"
"git.solsynth.dev/hydrogen/messaging/pkg/internal/http/exts"
"git.solsynth.dev/hydrogen/messaging/pkg/internal/database"
"git.solsynth.dev/hydrogen/messaging/pkg/internal/models"
@ -32,10 +33,10 @@ func getChannel(c *fiber.Ctx) error {
}
func getChannelIdentity(c *fiber.Ctx) error {
if err := gap.H.EnsureAuthenticated(c); err != nil {
if err := sec.EnsureAuthenticated(c); err != nil {
return err
}
user := c.Locals("user").(models.Account)
user := c.Locals("user").(authm.Account)
alias := c.Params("channel")
var err error
@ -55,9 +56,9 @@ func getChannelIdentity(c *fiber.Ctx) error {
}
func listChannel(c *fiber.Ctx) error {
var user *models.Account
if err := gap.H.EnsureAuthenticated(c); err == nil {
user = lo.ToPtr(c.Locals("user").(models.Account))
var user *authm.Account
if err := sec.EnsureAuthenticated(c); err == nil {
user = lo.ToPtr(c.Locals("user").(authm.Account))
}
var err error
@ -75,10 +76,10 @@ func listChannel(c *fiber.Ctx) error {
}
func listOwnedChannel(c *fiber.Ctx) error {
if err := gap.H.EnsureAuthenticated(c); err != nil {
if err := sec.EnsureAuthenticated(c); err != nil {
return err
}
user := c.Locals("user").(models.Account)
user := c.Locals("user").(authm.Account)
var err error
var channels []models.Channel
@ -95,10 +96,10 @@ func listOwnedChannel(c *fiber.Ctx) error {
}
func listAvailableChannel(c *fiber.Ctx) error {
if err := gap.H.EnsureAuthenticated(c); err != nil {
if err := sec.EnsureAuthenticated(c); err != nil {
return err
}
user := c.Locals("user").(models.Account)
user := c.Locals("user").(authm.Account)
tx := database.C
isDirect := c.QueryBool("direct", false)
@ -123,10 +124,10 @@ func listAvailableChannel(c *fiber.Ctx) error {
}
func createChannel(c *fiber.Ctx) error {
if err := gap.H.EnsureGrantedPerm(c, "CreateChannels", true); err != nil {
if err := sec.EnsureGrantedPerm(c, "CreateChannels", true); err != nil {
return err
}
user := c.Locals("user").(models.Account)
user := c.Locals("user").(authm.Account)
var data struct {
Alias string `json:"alias" validate:"required,lowercase,min=4,max=32"`
@ -179,10 +180,10 @@ func createChannel(c *fiber.Ctx) error {
}
func editChannel(c *fiber.Ctx) error {
if err := gap.H.EnsureAuthenticated(c); err != nil {
if err := sec.EnsureAuthenticated(c); err != nil {
return err
}
user := c.Locals("user").(models.Account)
user := c.Locals("user").(authm.Account)
id, _ := c.ParamsInt("channelId", 0)
var data struct {
@ -233,10 +234,10 @@ func editChannel(c *fiber.Ctx) error {
}
func deleteChannel(c *fiber.Ctx) error {
if err := gap.H.EnsureAuthenticated(c); err != nil {
if err := sec.EnsureAuthenticated(c); err != nil {
return err
}
user := c.Locals("user").(models.Account)
user := c.Locals("user").(authm.Account)
id, _ := c.ParamsInt("channelId", 0)
tx := database.C.Where(&models.Channel{BaseModel: hyper.BaseModel{ID: uint(id)}})

11
pkg/internal/server/api/direct_channels_api.go → pkg/internal/http/api/direct_channels_api.go
View File

@ -2,9 +2,10 @@ package api
import (
"fmt"
"git.solsynth.dev/hypernet/nexus/pkg/nex/sec"
authm "git.solsynth.dev/hypernet/passport/pkg/authkit/models"
"git.solsynth.dev/hydrogen/messaging/pkg/internal/gap"
"git.solsynth.dev/hydrogen/messaging/pkg/internal/server/exts"
"git.solsynth.dev/hydrogen/messaging/pkg/internal/http/exts"
"git.solsynth.dev/hydrogen/messaging/pkg/internal/database"
"git.solsynth.dev/hydrogen/messaging/pkg/internal/models"
@ -13,10 +14,10 @@ import (
)
func createDirectChannel(c *fiber.Ctx) error {
if err := gap.H.EnsureAuthenticated(c); err != nil {
if err := sec.EnsureAuthenticated(c); err != nil {
return err
}
user := c.Locals("user").(models.Account)
user := c.Locals("user").(authm.Account)
var data struct {
Alias string `json:"alias" validate:"required,lowercase,min=4,max=32"`
@ -43,7 +44,7 @@ func createDirectChannel(c *fiber.Ctx) error {
}
}
var relatedUser models.Account
var relatedUser authm.Account
if err := database.C.
Where("external_id = ?", data.RelatedUser).
First(&relatedUser).Error; err != nil {

17
pkg/internal/server/api/events_api.go → pkg/internal/http/api/events_api.go
View File

@ -2,19 +2,20 @@ package api
import (
"fmt"
"git.solsynth.dev/hypernet/nexus/pkg/nex/sec"
authm "git.solsynth.dev/hypernet/passport/pkg/authkit/models"
"git.solsynth.dev/hydrogen/messaging/pkg/internal/gap"
"git.solsynth.dev/hydrogen/messaging/pkg/internal/http/exts"
"git.solsynth.dev/hydrogen/messaging/pkg/internal/models"
"git.solsynth.dev/hydrogen/messaging/pkg/internal/server/exts"
"git.solsynth.dev/hydrogen/messaging/pkg/internal/services"
"github.com/gofiber/fiber/v2"
)
func getEvent(c *fiber.Ctx) error {
if err := gap.H.EnsureAuthenticated(c); err != nil {
if err := sec.EnsureAuthenticated(c); err != nil {
return err
}
user := c.Locals("user").(models.Account)
user := c.Locals("user").(authm.Account)
alias := c.Params("channel")
id, _ := c.ParamsInt("eventId")
@ -40,10 +41,10 @@ func getEvent(c *fiber.Ctx) error {
}
func listEvent(c *fiber.Ctx) error {
if err := gap.H.EnsureAuthenticated(c); err != nil {
if err := sec.EnsureAuthenticated(c); err != nil {
return err
}
user := c.Locals("user").(models.Account)
user := c.Locals("user").(authm.Account)
take := c.QueryInt("take", 0)
offset := c.QueryInt("offset", 0)
alias := c.Params("channel")
@ -74,10 +75,10 @@ func listEvent(c *fiber.Ctx) error {
}
func newRawEvent(c *fiber.Ctx) error {
if err := gap.H.EnsureGrantedPerm(c, "CreateMessagingRawEvent", true); err != nil {
if err := sec.EnsureGrantedPerm(c, "CreateMessagingRawEvent", true); err != nil {
return err
}
user := c.Locals("user").(models.Account)
user := c.Locals("user").(authm.Account)
alias := c.Params("channel")
var data struct {

17
pkg/internal/server/api/events_message_api.go → pkg/internal/http/api/events_message_api.go
View File

@ -1,21 +1,22 @@
package api
import (
"git.solsynth.dev/hypernet/nexus/pkg/nex/sec"
authm "git.solsynth.dev/hypernet/passport/pkg/authkit/models"
"strings"
"git.solsynth.dev/hydrogen/messaging/pkg/internal/gap"
"git.solsynth.dev/hydrogen/messaging/pkg/internal/http/exts"
"git.solsynth.dev/hydrogen/messaging/pkg/internal/models"
"git.solsynth.dev/hydrogen/messaging/pkg/internal/server/exts"
"git.solsynth.dev/hydrogen/messaging/pkg/internal/services"
"github.com/gofiber/fiber/v2"
jsoniter "github.com/json-iterator/go"
)
func newMessageEvent(c *fiber.Ctx) error {
if err := gap.H.EnsureAuthenticated(c); err != nil {
if err := sec.EnsureAuthenticated(c); err != nil {
return err
}
user := c.Locals("user").(models.Account)
user := c.Locals("user").(authm.Account)
alias := c.Params("channel")
var data struct {
@ -73,10 +74,10 @@ func newMessageEvent(c *fiber.Ctx) error {
}
func editMessageEvent(c *fiber.Ctx) error {
if err := gap.H.EnsureAuthenticated(c); err != nil {
if err := sec.EnsureAuthenticated(c); err != nil {
return err
}
user := c.Locals("user").(models.Account)
user := c.Locals("user").(authm.Account)
alias := c.Params("channel")
messageId, _ := c.ParamsInt("messageId", 0)
@ -122,10 +123,10 @@ func editMessageEvent(c *fiber.Ctx) error {
}
func deleteMessageEvent(c *fiber.Ctx) error {
if err := gap.H.EnsureAuthenticated(c); err != nil {
if err := sec.EnsureAuthenticated(c); err != nil {
return err
}
user := c.Locals("user").(models.Account)
user := c.Locals("user").(authm.Account)
alias := c.Params("channel")
messageId, _ := c.ParamsInt("messageId", 0)

3
pkg/internal/server/api/index.go → pkg/internal/http/api/index.go
View File

@ -7,9 +7,6 @@ import (
func MapAPIs(app *fiber.App, baseURL string) {
api := app.Group(baseURL).Name("API")
{
api.Get("/users/me", getUserinfo)
api.Get("/users/:accountId", getOthersInfo)
channels := api.Group("/channels/:realm").Use(realmMiddleware).Name("Channels API")
{
channels.Get("/", listChannel)

0
pkg/internal/server/api/realms_api.go → pkg/internal/http/api/realms_api.go
View File

7
pkg/internal/server/api/whats_new_api.go → pkg/internal/http/api/whats_new_api.go
View File

@ -2,18 +2,19 @@ package api
import (
"fmt"
"git.solsynth.dev/hypernet/nexus/pkg/nex/sec"
authm "git.solsynth.dev/hypernet/passport/pkg/authkit/models"
"git.solsynth.dev/hydrogen/messaging/pkg/internal/database"
"git.solsynth.dev/hydrogen/messaging/pkg/internal/gap"
"git.solsynth.dev/hydrogen/messaging/pkg/internal/models"
"github.com/gofiber/fiber/v2"
)
func getWhatsNew(c *fiber.Ctx) error {
if err := gap.H.EnsureAuthenticated(c); err != nil {
if err := sec.EnsureAuthenticated(c); err != nil {
return err
}
user := c.Locals("user").(models.Account)
user := c.Locals("user").(authm.Account)
pivot := c.QueryInt("pivot", 0)
if pivot < 0 {

0
pkg/internal/server/exts/utils.go → pkg/internal/http/exts/utils.go
View File

50
pkg/internal/server/server.go → pkg/internal/http/server.go
View File

@ -1,14 +1,11 @@
package server
package http
import (
"git.solsynth.dev/hypernet/nexus/pkg/nex/sec"
"git.solsynth.dev/hypernet/passport/pkg/authkit"
"strings"
"git.solsynth.dev/hydrogen/dealer/pkg/hyper"
"git.solsynth.dev/hydrogen/messaging/pkg/internal/database"
"git.solsynth.dev/hydrogen/messaging/pkg/internal/gap"
"git.solsynth.dev/hydrogen/messaging/pkg/internal/models"
"git.solsynth.dev/hydrogen/messaging/pkg/internal/server/api"
"git.solsynth.dev/hydrogen/messaging/pkg/internal/http/api"
"github.com/gofiber/fiber/v2"
"github.com/gofiber/fiber/v2/middleware/cors"
"github.com/gofiber/fiber/v2/middleware/idempotency"
@ -18,14 +15,18 @@ import (
"github.com/spf13/viper"
)
var app *fiber.App
var IReader *sec.InternalTokenReader
func NewServer() {
app = fiber.New(fiber.Config{
type App struct {
app *fiber.App
}
func NewServer() *App {
app := fiber.New(fiber.Config{
DisableStartupMessage: true,
EnableIPValidation: true,
ServerHeader: "Hydrogen.Messaging",
AppName: "Hydrogen.Messaging",
ServerHeader: "Hypernet.Messaging",
AppName: "Hypernet.Messaging",
ProxyHeader: fiber.HeaderXForwardedFor,
JSONEncoder: jsoniter.ConfigCompatibleWithStandardLibrary.Marshal,
JSONDecoder: jsoniter.ConfigCompatibleWithStandardLibrary.Unmarshal,
@ -55,23 +56,18 @@ func NewServer() {
Output: log.Logger,
}))
tablePrefix := viper.GetString("database.prefix")
app.Use(gap.H.AuthMiddleware)
app.Use(hyper.LinkAccountMiddleware(
database.C,
tablePrefix+"accounts",
func(u hyper.BaseUser) models.Account {
return models.Account{
BaseUser: u,
}
},
))
app.Use(sec.ContextMiddleware(IReader))
app.Use(authkit.ParseAccountMiddleware)
api.MapAPIs(app, "/api")
}
func Listen() {
if err := app.Listen(viper.GetString("bind")); err != nil {
log.Fatal().Err(err).Msg("An error occurred when starting server...")
return &App{
app: app,
}
}
func (v *App) Listen() {
if err := v.app.Listen(viper.GetString("bind")); err != nil {
log.Fatal().Err(err).Msg("An error occurred when starting http...")
}
}

9
pkg/internal/models/accounts.go
View File

@ -1,9 +0,0 @@
package models
import "git.solsynth.dev/hydrogen/dealer/pkg/hyper"
type Account struct {
hyper.BaseUser
Channels []Channel `json:"channels"`
}

7
pkg/internal/models/channels.go
View File

@ -23,7 +23,6 @@ type Channel struct {
Messages []Event `json:"messages"`
Calls []Call `json:"calls"`
Type ChannelType `json:"type"`
Account Account `json:"account"`
AccountID uint `json:"account_id"`
IsPublic bool `json:"is_public"`
IsCommunity bool `json:"is_community"`
@ -53,11 +52,13 @@ const (
type ChannelMember struct {
hyper.BaseModel
Name string `json:"name"`
Nick string `json:"nick"`
Avatar *string `json:"avatar"`
ChannelID uint `json:"channel_id"`
AccountID uint `json:"account_id"`
Nick *string `json:"nick"`
Channel Channel `json:"channel"`
Account Account `json:"account"`
Notify NotifyLevel `json:"notify"`
PowerLevel int `json:"power_level"`

2
pkg/internal/models/realms.go
View File

@ -2,7 +2,7 @@ package models
import "git.solsynth.dev/hydrogen/dealer/pkg/hyper"
// Realm profiles basically fetched from Hydrogen.Passport
// Realm profiles basically fetched from Hypernet.Passport
// But cache at here for better usage and database relations
type Realm struct {
hyper.BaseRealm

21
pkg/internal/models/unified.go
View File

@ -1,21 +0,0 @@
package models
import jsoniter "github.com/json-iterator/go"
type UnifiedCommand struct {
Action string `json:"w"`
Message string `json:"m"`
Payload any `json:"p"`
}
func UnifiedCommandFromError(err error) UnifiedCommand {
return UnifiedCommand{
Action: "error",
Message: err.Error(),
}
}
func (v UnifiedCommand) Marshal() []byte {
data, _ := jsoniter.Marshal(v)
return data
}

38
pkg/internal/server/api/users_api.go
View File

@ -1,38 +0,0 @@
package api
import (
"git.solsynth.dev/hydrogen/dealer/pkg/hyper"
"git.solsynth.dev/hydrogen/messaging/pkg/internal/database"
"git.solsynth.dev/hydrogen/messaging/pkg/internal/gap"
"git.solsynth.dev/hydrogen/messaging/pkg/internal/models"
"github.com/gofiber/fiber/v2"
)
func getUserinfo(c *fiber.Ctx) error {
if err := gap.H.EnsureAuthenticated(c); err != nil {
return err
}
user := c.Locals("user").(models.Account)
var data models.Account
if err := database.C.
Where(&hyper.BaseModel{ID: user.ID}).
First(&data).Error; err != nil {
return fiber.NewError(fiber.StatusInternalServerError, err.Error())
}
return c.JSON(data)
}
func getOthersInfo(c *fiber.Ctx) error {
accountId := c.Params("accountId")
var data models.Account
if err := database.C.
Where(&hyper.BaseUser{Name: accountId}).
First(&data).Error; err != nil {
return fiber.NewError(fiber.StatusInternalServerError, err.Error())
}
return c.JSON(data)
}

64
pkg/internal/services/accounts.go
View File

@ -2,80 +2,26 @@ package services
import (
"context"
"fmt"
"git.solsynth.dev/hypernet/nexus/pkg/nex"
authm "git.solsynth.dev/hypernet/passport/pkg/authkit/models"
"time"
"git.solsynth.dev/hydrogen/dealer/pkg/hyper"
"git.solsynth.dev/hydrogen/messaging/pkg/internal/database"
"git.solsynth.dev/hydrogen/messaging/pkg/internal/gap"
jsoniter "github.com/json-iterator/go"
"github.com/samber/lo"
"git.solsynth.dev/hydrogen/dealer/pkg/proto"
"git.solsynth.dev/hydrogen/messaging/pkg/internal/models"
)
func CheckUserPerm(userId, otherId uint, key string, val any) error {
var user models.Account
if err := database.C.Where("id = ?", userId).First(&user).Error; err != nil {
return fmt.Errorf("account not found: %v", err)
}
var other models.Account
if err := database.C.Where("id = ?", otherId).First(&other).Error; err != nil {
return fmt.Errorf("other not found: %v", err)
}
func NotifyAccountMessagerBatch(users []authm.Account, notification *proto.NotifyRequest) error {
ctx, cancel := context.WithTimeout(context.Background(), time.Second*5)
defer cancel()
encodedData, _ := jsoniter.Marshal(val)
pc, err := gap.H.GetServiceGrpcConn(hyper.ServiceTypeAuthProvider)
if err != nil {
return err
}
out, err := proto.NewAuthClient(pc).EnsureUserPermGranted(ctx, &proto.CheckUserPermRequest{
UserId: uint64(user.ID),
OtherId: uint64(other.ID),
Key: key,
Value: encodedData,
})
if err != nil {
return err
} else if !out.IsValid {
return fmt.Errorf("missing permission: %v", key)
}
return nil
}
func NotifyAccountMessager(user models.Account, notification *proto.NotifyRequest) error {
ctx, cancel := context.WithTimeout(context.Background(), time.Second*5)
defer cancel()
pc, err := gap.H.GetServiceGrpcConn(hyper.ServiceTypeAuthProvider)
if err != nil {
return err
}
_, err = proto.NewNotifierClient(pc).NotifyUser(ctx, &proto.NotifyUserRequest{
UserId: uint64(user.ID),
Notify: notification,
})
return err
}
func NotifyAccountMessagerBatch(users []models.Account, notification *proto.NotifyRequest) error {
ctx, cancel := context.WithTimeout(context.Background(), time.Second*5)
defer cancel()
pc, err := gap.H.GetServiceGrpcConn(hyper.ServiceTypeAuthProvider)
pc, err := gap.Nx.GetClientGrpcConn(nex.ServiceTypeAuth)
if err != nil {
return err
}
_, err = proto.NewNotifierClient(pc).NotifyUserBatch(ctx, &proto.NotifyUserBatchRequest{
UserId: lo.Map(users, func(item models.Account, idx int) uint64 {
UserId: lo.Map(users, func(item authm.Account, idx int) uint64 {
return uint64(item.ID)
}),
Notify: notification,

42
pkg/internal/services/calls.go
View File

@ -4,10 +4,14 @@ import (
"context"
"errors"
"fmt"
"git.solsynth.dev/hydrogen/messaging/pkg/internal/gap"
"git.solsynth.dev/hypernet/nexus/pkg/nex"
"git.solsynth.dev/hypernet/passport/pkg/authkit"
authm "git.solsynth.dev/hypernet/passport/pkg/authkit/models"
"git.solsynth.dev/hypernet/pusher/pkg/pushkit"
"time"
"git.solsynth.dev/hydrogen/dealer/pkg/hyper"
"git.solsynth.dev/hydrogen/dealer/pkg/proto"
"git.solsynth.dev/hydrogen/messaging/pkg/internal/database"
"git.solsynth.dev/hydrogen/messaging/pkg/internal/models"
jsoniter "github.com/json-iterator/go"
@ -109,12 +113,12 @@ func NewCall(channel models.Channel, founder models.ChannelMember) (models.Call,
ChannelID: call.ChannelID,
}).Preload("Account").Find(&members).Error; err == nil {
call, _ = GetCall(call.Channel, call.ID)
var pendingUsers []models.Account
var pendingUsers []uint64
for _, member := range members {
if member.ID != call.Founder.ID {
pendingUsers = append(pendingUsers, member.Account)
pendingUsers = append(pendingUsers, uint64(member.AccountID))
}
PushCommand(member.Account.ID, models.UnifiedCommand{
PushCommand(member.AccountID, nex.WebSocketPackage{
Action: "calls.new",
Payload: call,
})
@ -122,21 +126,21 @@ func NewCall(channel models.Channel, founder models.ChannelMember) (models.Call,
channel, _ = GetChannel(channel.ID)
err = NotifyAccountMessagerBatch(
err = authkit.NotifyUserBatch(
gap.Nx,
pendingUsers,
&proto.NotifyRequest{
Topic: "messaging.callStart",
Title: fmt.Sprintf("Call in (%s)", channel.DisplayText()),
Body: fmt.Sprintf("%s is calling", call.Founder.Account.Name),
Avatar: &call.Founder.Account.Avatar,
Metadata: EncodeJSONBody(map[string]any{
"user_id": call.Founder.Account.ID,
"user_name": call.Founder.Account.Name,
"user_nick": call.Founder.Account.Nick,
pushkit.Notification{
Topic: "messaging.callStart",
Title: fmt.Sprintf("Call in (%s)", channel.DisplayText()),
Body: fmt.Sprintf("%s is calling", call.Founder.Name),
Metadata: map[string]any{
"avatar": call.Founder.Avatar,
"user_id": call.Founder.AccountID,
"user_name": call.Founder.Name,
"user_nick": call.Founder.Nick,
"channel_id": call.ChannelID,
}),
IsRealtime: false,
IsForcePush: true,
},
Priority: 5,
},
)
if err != nil {
@ -164,7 +168,7 @@ func EndCall(call models.Call) (models.Call, error) {
}).Preload("Account").Find(&members).Error; err == nil {
call, _ = GetCall(call.Channel, call.ID)
for _, member := range members {
PushCommand(member.Account.ID, models.UnifiedCommand{
PushCommand(member.AccountID, nex.WebSocketPackage{
Action: "calls.end",
Payload: call,
})
@ -182,7 +186,7 @@ func KickParticipantInCall(call models.Call, username string) error {
return err
}
func EncodeCallToken(user models.Account, call models.Call) (string, error) {
func EncodeCallToken(user authm.Account, call models.Call) (string, error) {
isAdmin := user.ID == call.FounderID || user.ID == call.Channel.AccountID
grant := &auth.VideoGrant{

15
pkg/internal/services/channel_members.go
View File

@ -4,6 +4,9 @@ import (
"context"
"fmt"
localCache "git.solsynth.dev/hydrogen/messaging/pkg/internal/cache"
"git.solsynth.dev/hydrogen/messaging/pkg/internal/gap"
"git.solsynth.dev/hypernet/passport/pkg/authkit"
authm "git.solsynth.dev/hypernet/passport/pkg/authkit/models"
"github.com/eko/gocache/lib/v4/cache"
"github.com/eko/gocache/lib/v4/marshaler"
"github.com/eko/gocache/lib/v4/store"
@ -25,7 +28,7 @@ func ListChannelMember(channelId uint) ([]models.ChannelMember, error) {
return members, nil
}
func GetChannelMember(user models.Account, channelId uint) (models.ChannelMember, error) {
func GetChannelMember(user authm.Account, channelId uint) (models.ChannelMember, error) {
var member models.ChannelMember
if err := database.C.
@ -37,9 +40,9 @@ func GetChannelMember(user models.Account, channelId uint) (models.ChannelMember
return member, nil
}
func AddChannelMemberWithCheck(user models.Account, target models.Channel) error {
if err := CheckUserPerm(user.ID, target.AccountID, "ChannelAdd", true); err != nil {
return fmt.Errorf("unable to add user into your channel")
func AddChannelMemberWithCheck(user authm.Account, target models.Channel) error {
if err := authkit.EnsureUserPermGranted(gap.Nx, user.ID, target.AccountID, "ChannelAdd", true); err != nil {
return fmt.Errorf("unable to add user into your channel due to access denied: %v", err)
}
member := models.ChannelMember{
@ -51,7 +54,7 @@ func AddChannelMemberWithCheck(user models.Account, target models.Channel) error
return err
}
func AddChannelMember(user models.Account, target models.Channel) error {
func AddChannelMember(user authm.Account, target models.Channel) error {
member := models.ChannelMember{
ChannelID: target.ID,
AccountID: user.ID,
@ -96,7 +99,7 @@ func EditChannelMember(membership models.ChannelMember) (models.ChannelMember, e
return membership, nil
}
func RemoveChannelMember(user models.Account, target models.Channel) error {
func RemoveChannelMember(user authm.Account, target models.Channel) error {
var member models.ChannelMember
if err := database.C.Where(&models.ChannelMember{

9
pkg/internal/services/channels.go
View File

@ -4,6 +4,7 @@ import (
"context"
"fmt"
localCache "git.solsynth.dev/hydrogen/messaging/pkg/internal/cache"
authm "git.solsynth.dev/hypernet/passport/pkg/authkit/models"
"github.com/eko/gocache/lib/v4/cache"
"github.com/eko/gocache/lib/v4/marshaler"
"github.com/eko/gocache/lib/v4/store"
@ -137,7 +138,7 @@ func GetAvailableChannelWithAlias(alias string, user uint, realmId ...uint) (mod
return channel, member, nil
}
func GetAvailableChannel(id uint, user models.Account) (models.Channel, models.ChannelMember, error) {
func GetAvailableChannel(id uint, user authm.Account) (models.Channel, models.ChannelMember, error) {
var err error
var member models.ChannelMember
var channel models.Channel
@ -167,7 +168,7 @@ func PreloadDirectChannelMembers(tx *gorm.DB) *gorm.DB {
}).Preload("Members.Account")
}
func ListChannel(user *models.Account, realmId ...uint) ([]models.Channel, error) {
func ListChannel(user *authm.Account, realmId ...uint) ([]models.Channel, error) {
var identities []models.ChannelMember
var idRange []uint
if user != nil {
@ -195,7 +196,7 @@ func ListChannel(user *models.Account, realmId ...uint) ([]models.Channel, error
return channels, nil
}
func ListChannelWithUser(user models.Account, realmId ...uint) ([]models.Channel, error) {
func ListChannelWithUser(user authm.Account, realmId ...uint) ([]models.Channel, error) {
var channels []models.Channel
tx := database.C.Where(&models.Channel{AccountID: user.ID}).Preload("Realm")
if len(realmId) > 0 {
@ -211,7 +212,7 @@ func ListChannelWithUser(user models.Account, realmId ...uint) ([]models.Channel
return channels, nil
}
func ListAvailableChannel(tx *gorm.DB, user models.Account, realmId ...uint) ([]models.Channel, error) {
func ListAvailableChannel(tx *gorm.DB, user authm.Account, realmId ...uint) ([]models.Channel, error) {
var channels []models.Channel
var members []models.ChannelMember
if err := database.C.Where(&models.ChannelMember{

8
pkg/internal/services/direct_channels.go
View File

@ -2,15 +2,15 @@ package services
import (
"fmt"
authm "git.solsynth.dev/hypernet/passport/pkg/authkit/models"
"git.solsynth.dev/hydrogen/messaging/pkg/internal/database"
"git.solsynth.dev/hydrogen/messaging/pkg/internal/models"
"github.com/spf13/viper"
)
func GetDirectChannelByUser(user models.Account, other models.Account) (models.Channel, error) {
memberTable := fmt.Sprintf("%schannel_members", viper.GetString("database.prefix"))
channelTable := fmt.Sprintf("%schannels", viper.GetString("database.prefix"))
func GetDirectChannelByUser(user authm.Account, other authm.Account) (models.Channel, error) {
memberTable := "channel_members"
channelTable := "channels"
var channel models.Channel
if err := database.C.Preload("Members").

77
pkg/internal/services/events.go
View File

@ -2,10 +2,13 @@ package services
import (
"fmt"
"git.solsynth.dev/hydrogen/messaging/pkg/internal/gap"
"git.solsynth.dev/hypernet/nexus/pkg/nex"
"git.solsynth.dev/hypernet/passport/pkg/authkit"
"git.solsynth.dev/hypernet/pusher/pkg/pushkit"
"strings"
"git.solsynth.dev/hydrogen/dealer/pkg/hyper"
"git.solsynth.dev/hydrogen/dealer/pkg/proto"
"git.solsynth.dev/hydrogen/messaging/pkg/internal/database"
"git.solsynth.dev/hydrogen/messaging/pkg/internal/models"
jsoniter "github.com/json-iterator/go"
@ -86,9 +89,9 @@ func NewEvent(event models.Event) (models.Event, error) {
event, _ = GetEvent(event.Channel, event.ID)
idxList := lo.Map(members, func(item models.ChannelMember, index int) uint64 {
return uint64(item.Account.ID)
return uint64(item.AccountID)
})
PushCommandBatch(idxList, models.UnifiedCommand{
PushCommandBatch(idxList, nex.WebSocketPackage{
Action: "events.new",
Payload: event,
})
@ -106,8 +109,8 @@ func NotifyMessageEvent(members []models.ChannelMember, event models.Event) {
raw, _ := jsoniter.Marshal(event.Body)
_ = jsoniter.Unmarshal(raw, &body)
var pendingUsers []models.Account
var mentionedUsers []models.Account
var pendingUsers []uint64
var mentionedUsers []uint64
for _, member := range members {
if member.ID != event.SenderID {
@ -115,31 +118,31 @@ func NotifyMessageEvent(members []models.ChannelMember, event models.Event) {
case models.NotifyLevelNone:
continue
case models.NotifyLevelMentioned:
if len(body.RelatedUsers) != 0 && lo.Contains(body.RelatedUsers, member.Account.ID) {
mentionedUsers = append(mentionedUsers, member.Account)
if len(body.RelatedUsers) != 0 && lo.Contains(body.RelatedUsers, member.AccountID) {
mentionedUsers = append(mentionedUsers, uint64(member.AccountID))
}
continue
default:
break
}
if lo.Contains(body.RelatedUsers, member.Account.ID) {
mentionedUsers = append(mentionedUsers, member.Account)
if lo.Contains(body.RelatedUsers, member.AccountID) {
mentionedUsers = append(mentionedUsers, uint64(member.AccountID))
} else {
pendingUsers = append(pendingUsers, member.Account)
pendingUsers = append(pendingUsers, uint64(member.AccountID))
}
}
}
var displayText string
var displaySubtitle *string
var displaySubtitle string
switch event.Type {
case models.EventMessageNew:
if body.Algorithm == "plain" {
displayText = body.Text
}
case models.EventMessageEdit:
displaySubtitle = lo.ToPtr("Edited a message")
displaySubtitle = "Edited a message"
if body.Algorithm == "plain" {
displayText = body.Text
}
@ -162,22 +165,22 @@ func NotifyMessageEvent(members []models.ChannelMember, event models.Event) {
}
if len(pendingUsers) > 0 {
err := NotifyAccountMessagerBatch(
err := authkit.NotifyUserBatch(
gap.Nx,
pendingUsers,
&proto.NotifyRequest{
pushkit.Notification{
Topic: "messaging.message",
Title: fmt.Sprintf("%s (%s)", event.Sender.Account.Nick, event.Channel.DisplayText()),
Title: fmt.Sprintf("%s (%s)", event.Sender.Nick, event.Channel.DisplayText()),
Subtitle: displaySubtitle,
Body: displayText,
Avatar: &event.Sender.Account.Avatar,
Metadata: EncodeJSONBody(map[string]any{
"user_id": event.Sender.Account.ID,
"user_name": event.Sender.Account.Name,
"user_nick": event.Sender.Account.Nick,
Metadata: map[string]any{
"avatar": event.Sender.Avatar,
"user_id": event.Sender.AccountID,
"user_name": event.Sender.Name,
"user_nick": event.Sender.Nick,
"channel_id": event.ChannelID,
}),
IsRealtime: true,
IsForcePush: false,
},
Priority: 5,
},
)
if err != nil {
@ -186,28 +189,28 @@ func NotifyMessageEvent(members []models.ChannelMember, event models.Event) {
}
if len(mentionedUsers) > 0 {
if displaySubtitle != nil && len(*displaySubtitle) > 0 {
*displaySubtitle += ", and metioned you"
if len(displaySubtitle) > 0 {
displaySubtitle += ", and mentioned you"
} else {
displaySubtitle = lo.ToPtr("Metioned you")
displaySubtitle = "Mentioned you"
}
err := NotifyAccountMessagerBatch(
err := authkit.NotifyUserBatch(
gap.Nx,
mentionedUsers,
&proto.NotifyRequest{
pushkit.Notification{
Topic: "messaging.message",
Title: fmt.Sprintf("%s (%s)", event.Sender.Account.Nick, event.Channel.DisplayText()),
Title: fmt.Sprintf("%s (%s)", event.Sender.Nick, event.Channel.DisplayText()),
Subtitle: displaySubtitle,
Body: displayText,
Avatar: &event.Sender.Account.Avatar,
Metadata: EncodeJSONBody(map[string]any{
"user_id": event.Sender.Account.ID,
"user_name": event.Sender.Account.Name,
"user_nick": event.Sender.Account.Nick,
Metadata: map[string]any{
"avatar": event.Sender.Avatar,
"user_id": event.Sender.AccountID,
"user_name": event.Sender.Name,
"user_nick": event.Sender.Nick,
"channel_id": event.ChannelID,
}),
IsRealtime: true,
IsForcePush: false,
},
Priority: 5,
},
)
if err != nil {

9
pkg/internal/services/realms.go
View File

@ -2,6 +2,7 @@ package services
import (
"context"
"git.solsynth.dev/hypernet/nexus/pkg/nex"
"git.solsynth.dev/hydrogen/dealer/pkg/hyper"
"git.solsynth.dev/hydrogen/dealer/pkg/proto"
@ -14,7 +15,7 @@ import (
func GetRealmWithExtID(id uint) (models.Realm, error) {
var realm models.Realm
pc, err := gap.H.GetServiceGrpcConn(hyper.ServiceTypeAuthProvider)
pc, err := gap.Nx.GetClientGrpcConn(nex.ServiceTypeAuth)
if err != nil {
return realm, err
}
@ -31,7 +32,7 @@ func GetRealmWithExtID(id uint) (models.Realm, error) {
func GetRealmWithAlias(alias string) (models.Realm, error) {
var realm models.Realm
pc, err := gap.H.GetServiceGrpcConn(hyper.ServiceTypeAuthProvider)
pc, err := gap.Nx.GetClientGrpcConn(nex.ServiceTypeAuth)
if err != nil {
return realm, err
}
@ -47,7 +48,7 @@ func GetRealmWithAlias(alias string) (models.Realm, error) {
}
func GetRealmMember(realmId uint, userId uint) (*proto.RealmMemberInfo, error) {
pc, err := gap.H.GetServiceGrpcConn(hyper.ServiceTypeAuthProvider)
pc, err := gap.Nx.GetClientGrpcConn(nex.ServiceTypeAuth)
if err != nil {
return nil, err
}
@ -63,7 +64,7 @@ func GetRealmMember(realmId uint, userId uint) (*proto.RealmMemberInfo, error) {
}
func ListRealmMember(realmId uint) ([]*proto.RealmMemberInfo, error) {
pc, err := gap.H.GetServiceGrpcConn(hyper.ServiceTypeAuthProvider)
pc, err := gap.Nx.GetClientGrpcConn(nex.ServiceTypeAuth)
if err != nil {
return nil, err
}

20
pkg/internal/services/status.go
View File

@ -3,7 +3,6 @@ package services
import (
"context"
"fmt"
"git.solsynth.dev/hydrogen/dealer/pkg/hyper"
"git.solsynth.dev/hydrogen/dealer/pkg/proto"
localCache "git.solsynth.dev/hydrogen/messaging/pkg/internal/cache"
@ -41,18 +40,11 @@ func SetTypingStatus(channelId uint, userId uint) error {
}
if !hitCache {
var account models.Account
if err := database.C.Where("external_id = ?", userId).First(&account).Error; err != nil {
return fmt.Errorf("account not found: %v", err)
}
var member models.ChannelMember
if err := database.C.
Where("account_id = ? AND channel_id = ?", account.ID, channelId).
Where("account_id = ? AND channel_id = ?", userId, channelId).
First(&member).Error; err != nil {
return fmt.Errorf("channel member not found: %v", err)
} else {
member.Account = account
}
var channel models.Channel
@ -65,7 +57,7 @@ func SetTypingStatus(channelId uint, userId uint) error {
}
for _, item := range channel.Members {
broadcastTarget = append(broadcastTarget, uint64(item.Account.ID))
broadcastTarget = append(broadcastTarget, uint64(item.AccountID))
}
data = map[string]any{
@ -77,11 +69,7 @@ func SetTypingStatus(channelId uint, userId uint) error {
}
// Cache queries
cacheManager := cache.New[any](localCache.S)
marshal := marshaler.New(cacheManager)
contx := context.Background()
marshal.Set(
_ = marshal.Set(
contx,
GetTypingStatusQueryCacheKey(channelId, userId),
statusQueryCacheEntry{broadcastTarget, data},
@ -89,7 +77,7 @@ func SetTypingStatus(channelId uint, userId uint) error {
)
}
sc := proto.NewStreamControllerClient(gap.H.GetDealerGrpcConn())
sc := proto.NewStreamControllerClient(gap.Nx.GetNexusGrpcConn())
_, err := sc.PushStreamBatch(context.Background(), &proto.PushStreamBatchRequest{
UserId: broadcastTarget,
Body: hyper.NetworkPackage{

10
pkg/internal/services/websocket.go
View File

@ -2,31 +2,31 @@ package services
import (
"context"
"git.solsynth.dev/hypernet/nexus/pkg/nex"
"time"
"github.com/samber/lo"
"git.solsynth.dev/hydrogen/dealer/pkg/proto"
"git.solsynth.dev/hydrogen/messaging/pkg/internal/gap"
"git.solsynth.dev/hydrogen/messaging/pkg/internal/models"
)
func PushCommand(userId uint, task models.UnifiedCommand) {
func PushCommand(userId uint, task nex.WebSocketPackage) {
ctx, cancel := context.WithTimeout(context.Background(), 5*time.Second)
defer cancel()
pc := gap.H.GetDealerGrpcConn()
pc := gap.Nx.GetNexusGrpcConn()
_, _ = proto.NewStreamControllerClient(pc).PushStream(ctx, &proto.PushStreamRequest{
UserId: lo.ToPtr(uint64(userId)),
Body: task.Marshal(),
})
}
func PushCommandBatch(userId []uint64, task models.UnifiedCommand) {
func PushCommandBatch(userId []uint64, task nex.WebSocketPackage) {
ctx, cancel := context.WithTimeout(context.Background(), 5*time.Second)
defer cancel()
pc := gap.H.GetDealerGrpcConn()
pc := gap.Nx.GetNexusGrpcConn()
_, _ = proto.NewStreamControllerClient(pc).PushStreamBatch(ctx, &proto.PushStreamBatchRequest{
UserId: userId,
Body: task.Marshal(),