aiden
/
synctv
mirror of https://github.com/synctv-org/synctv
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity

Opt: db handle not found func

Browse Source
pull/40/head
zijiren233 2 years ago
parent 71d1b96e69
commit b3f9733e35
10 changed files with 140 additions and 303 deletions
Show Stats Download Patch File Download Diff File

51
internal/bootstrap/db.go
Unescape Escape View File

@ -20,11 +20,35 @@ import (
)
func InitDatabase(ctx context.Context) (err error) {
var dialector gorm.Dialector
dialector, err := createDialector(conf.Conf.Database)
if err != nil {
log.Fatalf("failed to create dialector: %s", err.Error())
}
var opts []gorm.Option
opts = append(opts, &gorm.Config{
TranslateError: true,
Logger: newDBLogger(),
PrepareStmt: true,
})
d, err := gorm.Open(dialector, opts...)
if err != nil {
log.Fatalf("failed to connect database: %s", err.Error())
}
sqlDB, err := d.DB()
if err != nil {
log.Fatalf("failed to get sqlDB: %s", err.Error())
}
if conf.Conf.Database.Type != conf.DatabaseTypeSqlite3 {
initRawDB(sqlDB)
}
return db.Init(d, conf.Conf.Database.Type)
}
func createDialector(dbConf conf.DatabaseConfig) (dialector gorm.Dialector, err error) {
var dsn string
switch conf.Conf.Database.Type {
case conf.DatabaseTypeMysql:
var dsn string
if conf.Conf.Database.CustomDSN != "" {
dsn = conf.Conf.Database.CustomDSN
} else if conf.Conf.Database.Port == 0 {
@ -55,9 +79,7 @@ func InitDatabase(ctx context.Context) (err error) {
DontSupportRenameColumn: true,
SkipInitializeWithVersion: false,
})
// opts = append(opts, &gorm.Config{})
case conf.DatabaseTypeSqlite3:
var dsn string
if conf.Conf.Database.CustomDSN != "" {
dsn = conf.Conf.Database.CustomDSN
} else if conf.Conf.Database.DBName == "memory" || strings.HasPrefix(conf.Conf.Database.DBName, ":memory:") {
@ -75,9 +97,7 @@ func InitDatabase(ctx context.Context) (err error) {
log.Infof("sqlite3 database file: %s", conf.Conf.Database.DBName)
}
dialector = sqlite.Open(dsn)
// opts = append(opts, &gorm.Config{})
case conf.DatabaseTypePostgres:
var dsn string
if conf.Conf.Database.CustomDSN != "" {
dsn = conf.Conf.Database.CustomDSN
} else if conf.Conf.Database.Port == 0 {
@ -104,27 +124,10 @@ func InitDatabase(ctx context.Context) (err error) {
DSN: dsn,
PreferSimpleProtocol: true,
})
// opts = append(opts, &gorm.Config{})
default:
log.Fatalf("unknown database type: %s", conf.Conf.Database.Type)
}
opts = append(opts, &gorm.Config{
TranslateError: true,
Logger: newDBLogger(),
PrepareStmt: true,
})
d, err := gorm.Open(dialector, opts...)
if err != nil {
log.Fatalf("failed to connect database: %s", err.Error())
}
sqlDB, err := d.DB()
if err != nil {
log.Fatalf("failed to get sqlDB: %s", err.Error())
}
if conf.Conf.Database.Type != conf.DatabaseTypeSqlite3 {
initRawDB(sqlDB)
}
return db.Init(d, conf.Conf.Database.Type)
return
}
func newDBLogger() logger.Interface {

21
internal/db/db.go
Unescape Escape View File

@ -3,6 +3,7 @@ package db
import (
"errors"
"fmt"
"strings"
log "github.com/sirupsen/logrus"
"github.com/synctv-org/synctv/internal/conf"
@ -284,3 +285,23 @@ func WhereRoomUserStatus(status model.RoomUserStatus) func(db *gorm.DB) *gorm.DB
return db.Where("status = ?", status)
}
}
func HandleNotFound(err error, errMsg ...string) error {
if err != nil && errors.Is(err, gorm.ErrRecordNotFound) {
return fmt.Errorf("not found: %s", strings.Join(errMsg, " "))
}
return err
}
func Transactional(txFunc func(*gorm.DB) error) (err error) {
tx := db.Begin()
defer func() {
if err != nil {
tx.Rollback()
} else {
tx.Commit()
}
}()
err = txFunc(tx)
return
}

76
internal/db/movie.go
Unescape Escape View File

@ -1,9 +1,6 @@
package db
import (
"errors"
"fmt"
"github.com/synctv-org/synctv/internal/model"
"gorm.io/gorm"
"gorm.io/gorm/clause"
@ -25,86 +22,53 @@ func GetAllMoviesByRoomID(roomID string) []*model.Movie {
func DeleteMovieByID(roomID, id string) error {
err := db.Unscoped().Where("room_id = ? AND id = ?", roomID, id).Delete(&model.Movie{}).Error
if err != nil && errors.Is(err, gorm.ErrRecordNotFound) {
return errors.New("room or movie not found")
}
return err
return HandleNotFound(err, "room or movie")
}
func LoadAndDeleteMovieByID(roomID, id string, columns ...clause.Column) (*model.Movie, error) {
movie := &model.Movie{}
err := db.Unscoped().Clauses(clause.Returning{Columns: columns}).Where("room_id = ? AND id = ?", roomID, id).Delete(movie).Error
if err != nil && errors.Is(err, gorm.ErrRecordNotFound) {
return movie, errors.New("room or movie not found")
}
return movie, err
return movie, HandleNotFound(err, "room or movie")
}
func DeleteMoviesByRoomID(roomID string) error {
err := db.Unscoped().Where("room_id = ?", roomID).Delete(&model.Movie{}).Error
if err != nil && errors.Is(err, gorm.ErrRecordNotFound) {
return errors.New("room not found")
}
return err
return HandleNotFound(err, "room")
}
func LoadAndDeleteMoviesByRoomID(roomID string, columns ...clause.Column) ([]*model.Movie, error) {
movies := []*model.Movie{}
err := db.Unscoped().Clauses(clause.Returning{Columns: columns}).Where("room_id = ?", roomID).Delete(&movies).Error
if err != nil && errors.Is(err, gorm.ErrRecordNotFound) {
return nil, errors.New("room not found")
}
return movies, err
return movies, HandleNotFound(err, "room")
}
func UpdateMovie(movie *model.Movie, columns ...clause.Column) error {
err := db.Model(movie).Clauses(clause.Returning{Columns: columns}).Where("room_id = ? AND id = ?", movie.RoomID, movie.ID).Updates(movie).Error
if err != nil && errors.Is(err, gorm.ErrRecordNotFound) {
return errors.New("room or movie not found")
}
return err
return HandleNotFound(err, "room or movie")
}
func SaveMovie(movie *model.Movie, columns ...clause.Column) error {
err := db.Model(movie).Clauses(clause.Returning{Columns: columns}).Where("room_id = ? AND id = ?", movie.RoomID, movie.ID).Save(movie).Error
if err != nil && errors.Is(err, gorm.ErrRecordNotFound) {
return errors.New("room or movie not found")
}
return err
return HandleNotFound(err, "room or movie")
}
func SwapMoviePositions(roomID, movie1ID, movie2ID string) (err error) {
tx := db.Begin()
defer func() {
return Transactional(func(tx *gorm.DB) error {
movie1 := &model.Movie{}
movie2 := &model.Movie{}
err = tx.Where("room_id = ? AND id = ?", roomID, movie1ID).First(movie1).Error
if err != nil {
tx.Rollback()
} else {
tx.Commit()
return HandleNotFound(err, "movie1")
}
}()
movie1 := &model.Movie{}
movie2 := &model.Movie{}
err = tx.Select("position").Where("room_id = ? AND id = ?", roomID, movie1ID).First(movie1).Error
if err != nil {
if errors.Is(err, gorm.ErrRecordNotFound) {
err = fmt.Errorf("movie with id %s not found", movie1ID)
err = tx.Where("room_id = ? AND id = ?", roomID, movie2ID).First(movie2).Error
if err != nil {
return HandleNotFound(err, "movie2")
}
return
}
err = tx.Select("position").Where("room_id = ? AND id = ?", roomID, movie2ID).First(movie2).Error
if err != nil {
if errors.Is(err, gorm.ErrRecordNotFound) {
err = fmt.Errorf("movie with id %s not found", movie2ID)
movie1.Position, movie2.Position = movie2.Position, movie1.Position
err = tx.Save(movie1).Error
if err != nil {
return err
}
return
}
err = tx.Model(&model.Movie{}).Where("room_id = ? AND id = ?", roomID, movie1ID).Update("position", movie2.Position).Error
if err != nil {
return
}
err = tx.Model(&model.Movie{}).Where("room_id = ? AND id = ?", roomID, movie2ID).Update("position", movie1.Position).Error
if err != nil {
return
}
return
return tx.Save(movie2).Error
})
}

27
internal/db/relation.go
Unescape Escape View File

@ -1,8 +1,6 @@
package db
import (
"errors"
"github.com/synctv-org/synctv/internal/model"
"gorm.io/gorm"
)
@ -38,42 +36,27 @@ func FirstOrCreateRoomUserRelation(roomID, userID string, conf ...CreateRoomUser
func GetRoomUserRelation(roomID, userID string) (*model.RoomUserRelation, error) {
roomUserRelation := &model.RoomUserRelation{}
err := db.Where("room_id = ? AND user_id = ?", roomID, userID).First(roomUserRelation).Error
if err != nil && errors.Is(err, gorm.ErrRecordNotFound) {
return roomUserRelation, errors.New("room or user not found")
}
return roomUserRelation, err
return roomUserRelation, HandleNotFound(err, "room or user")
}
func SetRoomUserStatus(roomID string, userID string, status model.RoomUserStatus) error {
err := db.Model(&model.RoomUserRelation{}).Where("room_id = ? AND user_id = ?", roomID, userID).Update("status", status).Error
if err != nil && errors.Is(err, gorm.ErrRecordNotFound) {
return errors.New("room or user not found")
}
return err
return HandleNotFound(err, "room or user")
}
func SetUserPermission(roomID string, userID string, permission model.RoomUserPermission) error {
err := db.Model(&model.RoomUserRelation{}).Where("room_id = ? AND user_id = ?", roomID, userID).Update("permissions", permission).Error
if err != nil && errors.Is(err, gorm.ErrRecordNotFound) {
return errors.New("room or user not found")
}
return err
return HandleNotFound(err, "room or user")
}
func AddUserPermission(roomID string, userID string, permission model.RoomUserPermission) error {
err := db.Model(&model.RoomUserRelation{}).Where("room_id = ? AND user_id = ?", roomID, userID).Update("permissions", db.Raw("permissions | ?", permission)).Error
if err != nil && errors.Is(err, gorm.ErrRecordNotFound) {
return errors.New("room or user not found")
}
return err
return HandleNotFound(err, "room or user")
}
func RemoveUserPermission(roomID string, userID string, permission model.RoomUserPermission) error {
err := db.Model(&model.RoomUserRelation{}).Where("room_id = ? AND user_id = ?", roomID, userID).Update("permissions", db.Raw("permissions & ?", ^permission)).Error
if err != nil && errors.Is(err, gorm.ErrRecordNotFound) {
return errors.New("room or user not found")
}
return err
return HandleNotFound(err, "room or user")
}
func GetAllRoomUsersRelation(roomID string, scopes ...func(*gorm.DB) *gorm.DB) []*model.RoomUserRelation {

81
internal/db/room.go
Unescape Escape View File

@ -58,25 +58,23 @@ func CreateRoom(name, password string, maxCount int64, conf ...CreateRoomConfig)
}
}
tx := db.Begin()
if maxCount != 0 {
var count int64
tx.Model(&model.Room{}).Where("creator_id = ?", r.CreatorID).Count(&count)
if count >= maxCount {
tx.Rollback()
return nil, errors.New("room count is over limit")
return r, Transactional(func(tx *gorm.DB) error {
if maxCount != 0 {
var count int64
tx.Model(&model.Room{}).Where("creator_id = ?", r.CreatorID).Count(&count)
if count >= maxCount {
return errors.New("room count is over limit")
}
}
}
err := tx.Create(r).Error
if err != nil {
tx.Rollback()
if errors.Is(err, gorm.ErrDuplicatedKey) {
return r, errors.New("room already exists")
err := tx.Create(r).Error
if err != nil {
if errors.Is(err, gorm.ErrDuplicatedKey) {
return errors.New("room already exists")
}
return err
}
return r, err
}
tx.Commit()
return r, nil
return nil
})
}
func GetRoomByID(id string) (*model.Room, error) {
@ -85,50 +83,17 @@ func GetRoomByID(id string) (*model.Room, error) {
}
r := &model.Room{}
err := db.Where("id = ?", id).First(r).Error
if err != nil && errors.Is(err, gorm.ErrRecordNotFound) {
return r, errors.New("room not found")
}
return r, err
return r, HandleNotFound(err, "room")
}
func SaveRoomSettings(roomID string, setting model.RoomSettings) error {
err := db.Model(&model.Room{}).Where("id = ?", roomID).Update("setting", setting).Error
if err != nil && errors.Is(err, gorm.ErrRecordNotFound) {
return errors.New("room not found")
}
return err
return HandleNotFound(err, "room")
}
func DeleteRoomByID(roomID string) error {
err := db.Unscoped().Where("id = ?", roomID).Delete(&model.Room{}).Error
if err != nil && errors.Is(err, gorm.ErrRecordNotFound) {
return errors.New("room not found")
}
return err
}
func HasRoom(roomID string) (bool, error) {
r := &model.Room{}
err := db.Where("id = ?", roomID).First(r).Error
if err != nil {
if errors.Is(err, gorm.ErrRecordNotFound) {
err = nil
}
return false, err
}
return true, nil
}
func HasRoomByName(name string) (bool, error) {
r := &model.Room{}
err := db.Where("name = ?", name).First(r).Error
if err != nil {
if errors.Is(err, gorm.ErrRecordNotFound) {
err = nil
}
return false, err
}
return true, nil
return HandleNotFound(err, "room")
}
func SetRoomPassword(roomID, password string) error {
@ -145,10 +110,7 @@ func SetRoomPassword(roomID, password string) error {
func SetRoomHashedPassword(roomID string, hashedPassword []byte) error {
err := db.Model(&model.Room{}).Where("id = ?", roomID).Update("hashed_password", hashedPassword).Error
if err != nil && errors.Is(err, gorm.ErrRecordNotFound) {
return errors.New("room not found")
}
return err
return HandleNotFound(err, "room")
}
func GetAllRooms(scopes ...func(*gorm.DB) *gorm.DB) []*model.Room {
@ -177,10 +139,7 @@ func GetAllRoomsByUserID(userID string) []*model.Room {
func SetRoomStatus(roomID string, status model.RoomStatus) error {
err := db.Model(&model.Room{}).Where("id = ?", roomID).Update("status", status).Error
if err != nil && errors.Is(err, gorm.ErrRecordNotFound) {
return errors.New("room not found")
}
return err
return HandleNotFound(err, "room")
}
func SetRoomStatusByCreator(userID string, status model.RoomStatus) error {

120
internal/db/user.go
Unescape Escape View File

@ -143,26 +143,14 @@ func CreateOrLoadUserWithProvider(username, password string, p provider.OAuth2Pr
func GetUserByProvider(p provider.OAuth2Provider, puid string) (*model.User, error) {
var user model.User
if err := db.Where("id = (?)", db.Table("user_providers").Where("provider = ? AND provider_user_id = ?", p, puid).Select("user_id")).First(&user).Error; err != nil {
if errors.Is(err, gorm.ErrRecordNotFound) {
return &user, errors.New("user not found")
} else {
return &user, err
}
}
return &user, nil
err := db.Where("id = (?)", db.Table("user_providers").Where("provider = ? AND provider_user_id = ?", p, puid).Select("user_id")).First(&user).Error
return &user, HandleNotFound(err, "user")
}
func GetProviderUserID(p provider.OAuth2Provider, puid string) (string, error) {
var userProvider model.UserProvider
if err := db.Where("provider = ? AND provider_user_id = ?", p, puid).Select("user_id").First(&userProvider).Error; err != nil {
if errors.Is(err, gorm.ErrRecordNotFound) {
return "", errors.New("user not found")
} else {
return "", err
}
}
return userProvider.UserID, nil
err := db.Where("provider = ? AND provider_user_id = ?", p, puid).Select("user_id").First(&userProvider).Error
return userProvider.UserID, HandleNotFound(err, "user")
}
func BindProvider(uid string, p provider.OAuth2Provider, puid string) error {
@ -179,45 +167,31 @@ func BindProvider(uid string, p provider.OAuth2Provider, puid string) error {
// 当用户是通过provider注册的时候，则最少保留一个provider，否则禁止解除绑定
func UnBindProvider(uid string, p provider.OAuth2Provider) error {
tx := db.Begin()
user := model.User{}
if err := tx.Scopes(PreloadUserProviders()).Where("id = ?", uid).First(&user).Error; err != nil {
tx.Rollback()
if errors.Is(err, gorm.ErrRecordNotFound) {
return errors.New("user not found")
return Transactional(func(tx *gorm.DB) error {
user := model.User{}
if err := tx.Scopes(PreloadUserProviders()).Where("id = ?", uid).First(&user).Error; err != nil {
return HandleNotFound(err, "user")
}
return err
}
if user.RegisteredByProvider && len(user.UserProviders) == 1 {
tx.Rollback()
return errors.New("user must have at least one provider")
}
if err := tx.Where("user_id = ? AND provider = ?", uid, p).Delete(&model.UserProvider{}).Error; err != nil {
tx.Rollback()
if errors.Is(err, gorm.ErrRecordNotFound) {
return errors.New("user could not bind provider")
if user.RegisteredByProvider && len(user.UserProviders) == 1 {
return errors.New("user must have at least one provider")
}
return err
}
return tx.Commit().Error
if err := tx.Where("user_id = ? AND provider = ?", uid, p).Delete(&model.UserProvider{}).Error; err != nil {
return HandleNotFound(err, "provider")
}
return nil
})
}
func GetBindProviders(uid string) ([]*model.UserProvider, error) {
var providers []*model.UserProvider
err := db.Where("user_id = ?", uid).Find(&providers).Error
if errors.Is(err, gorm.ErrRecordNotFound) {
return providers, errors.New("user not found")
}
return providers, err
return providers, HandleNotFound(err, "user")
}
func GetUserByUsername(username string) (*model.User, error) {
u := &model.User{}
err := db.Where("username = ?", username).First(u).Error
if errors.Is(err, gorm.ErrRecordNotFound) {
return u, errors.New("user not found")
}
return u, err
return u, HandleNotFound(err, "user")
}
func GetUserByUsernameLike(username string, scopes ...func(*gorm.DB) *gorm.DB) []*model.User {
@ -241,10 +215,7 @@ func GerUsersIDByIDLike(id string, scopes ...func(*gorm.DB) *gorm.DB) []string {
func GetUserByIDOrUsernameLike(idOrUsername string, scopes ...func(*gorm.DB) *gorm.DB) ([]*model.User, error) {
var users []*model.User
err := db.Where("id = ? OR username LIKE ?", idOrUsername, fmt.Sprintf("%%%s%%", idOrUsername)).Scopes(scopes...).Find(&users).Error
if errors.Is(err, gorm.ErrRecordNotFound) {
return users, errors.New("user not found")
}
return users, err
return users, HandleNotFound(err, "user")
}
func GetUserByID(id string) (*model.User, error) {
@ -253,10 +224,7 @@ func GetUserByID(id string) (*model.User, error) {
}
u := &model.User{}
err := db.Where("id = ?", id).First(u).Error
if errors.Is(err, gorm.ErrRecordNotFound) {
return u, errors.New("user not found")
}
return u, err
return u, HandleNotFound(err, "user")
}
func BanUser(u *model.User) error {
@ -269,10 +237,7 @@ func BanUser(u *model.User) error {
func BanUserByID(userID string) error {
err := db.Model(&model.User{}).Where("id = ?", userID).Update("role", model.RoleBanned).Error
if errors.Is(err, gorm.ErrRecordNotFound) {
return errors.New("user not found")
}
return err
return HandleNotFound(err, "user")
}
func UnbanUser(u *model.User) error {
@ -285,18 +250,12 @@ func UnbanUser(u *model.User) error {
func UnbanUserByID(userID string) error {
err := db.Model(&model.User{}).Where("id = ?", userID).Update("role", model.RoleUser).Error
if errors.Is(err, gorm.ErrRecordNotFound) {
return errors.New("user not found")
}
return err
return HandleNotFound(err, "user")
}
func DeleteUserByID(userID string) error {
err := db.Unscoped().Where("id = ?", userID).Delete(&model.User{}).Error
if errors.Is(err, gorm.ErrRecordNotFound) {
return errors.New("user not found")
}
return err
return HandleNotFound(err, "user")
}
func LoadAndDeleteUserByID(userID string, columns ...clause.Column) (*model.User, error) {
@ -338,18 +297,12 @@ func GetAdmins() []*model.User {
func AddAdminByID(userID string) error {
err := db.Model(&model.User{}).Where("id = ?", userID).Update("role", model.RoleAdmin).Error
if errors.Is(err, gorm.ErrRecordNotFound) {
return errors.New("user not found")
}
return err
return HandleNotFound(err, "user")
}
func RemoveAdminByID(userID string) error {
err := db.Model(&model.User{}).Where("id = ?", userID).Update("role", model.RoleUser).Error
if errors.Is(err, gorm.ErrRecordNotFound) {
return errors.New("user not found")
}
return err
return HandleNotFound(err, "user")
}
func AddRoot(u *model.User) error {
@ -370,18 +323,12 @@ func RemoveRoot(u *model.User) error {
func AddRootByID(userID string) error {
err := db.Model(&model.User{}).Where("id = ?", userID).Update("role", model.RoleRoot).Error
if errors.Is(err, gorm.ErrRecordNotFound) {
return errors.New("user not found")
}
return err
return HandleNotFound(err, "user")
}
func RemoveRootByID(userID string) error {
err := db.Model(&model.User{}).Where("id = ?", userID).Update("role", model.RoleUser).Error
if errors.Is(err, gorm.ErrRecordNotFound) {
return errors.New("user not found")
}
return err
return HandleNotFound(err, "user")
}
func GetRoots() []*model.User {
@ -397,18 +344,12 @@ func SetRole(u *model.User, role model.Role) error {
func SetRoleByID(userID string, role model.Role) error {
err := db.Model(&model.User{}).Where("id = ?", userID).Update("role", role).Error
if errors.Is(err, gorm.ErrRecordNotFound) {
return errors.New("user not found")
}
return err
return HandleNotFound(err, "user")
}
func SetUsernameByID(userID string, username string) error {
err := db.Model(&model.User{}).Where("id = ?", userID).Update("username", username).Error
if errors.Is(err, gorm.ErrRecordNotFound) {
return errors.New("user not found")
}
return err
return HandleNotFound(err, "user")
}
func GetAllUserCount(scopes ...func(*gorm.DB) *gorm.DB) int64 {
@ -425,8 +366,5 @@ func GetAllUsers(scopes ...func(*gorm.DB) *gorm.DB) []*model.User {
func SetUserHashedPassword(id string, hashedPassword []byte) error {
err := db.Model(&model.User{}).Where("id = ?", id).Update("hashed_password", hashedPassword).Error
if err != nil && errors.Is(err, gorm.ErrRecordNotFound) {
return errors.New("user not found")
}
return err
return HandleNotFound(err, "user")
}

7
internal/db/vendor.go
Unescape Escape View File

@ -1,11 +1,9 @@
package db
import (
"errors"
"net/http"
"github.com/synctv-org/synctv/internal/model"
"gorm.io/gorm"
)
func GetVendorByUserID(userID string) ([]*model.StreamingVendorInfo, error) {
@ -20,10 +18,7 @@ func GetVendorByUserID(userID string) ([]*model.StreamingVendorInfo, error) {
func GetVendorByUserIDAndVendor(userID string, vendor model.StreamingVendor) (*model.StreamingVendorInfo, error) {
var vendorInfo model.StreamingVendorInfo
err := db.Where("user_id = ? AND vendor = ?", userID, vendor).First(&vendorInfo).Error
if err != nil && errors.Is(err, gorm.ErrRecordNotFound) {
return nil, errors.New("vendor not found")
}
return &vendorInfo, err
return &vendorInfo, HandleNotFound(err, "vendor")
}
type CreateVendorConfig func(*model.StreamingVendorInfo)

20
internal/op/rooms.go
Unescape Escape View File

@ -122,26 +122,6 @@ func PeopleNum(roomID string) int64 {
return 0
}
func HasRoom(roomID string) bool {
_, ok := roomCache.Load(roomID)
if ok {
return true
}
ok, err := db.HasRoom(roomID)
if err != nil {
return false
}
return ok
}
func HasRoomByName(name string) bool {
ok, err := db.HasRoomByName(name)
if err != nil {
return false
}
return ok
}
func GetAllRoomsInCacheWithNoNeedPassword() []*Room {
rooms := make([]*Room, 0)
roomCache.Range(func(key string, value *synccache.Entry[*Room]) bool {

32
server/static/static.go
Unescape Escape View File

@ -12,27 +12,25 @@ import (
)
func Init(e *gin.Engine) {
{
e.GET("/", func(ctx *gin.Context) {
ctx.Redirect(http.StatusMovedPermanently, "/web/")
})
e.GET("/", func(ctx *gin.Context) {
ctx.Redirect(http.StatusMovedPermanently, "/web/")
})
web := e.Group("/web")
web := e.Group("/web")
web.Use(middlewares.NewDistCacheControl("/web/"))
web.Use(middlewares.NewDistCacheControl("/web/"))
err := initFSRouter(web, public.Public.(fs.ReadDirFS), ".")
if err != nil {
panic(err)
}
e.NoRoute(func(ctx *gin.Context) {
if strings.HasPrefix(ctx.Request.URL.Path, "/web/") {
ctx.FileFromFS("", http.FS(public.Public))
return
}
})
err := initFSRouter(web, public.Public.(fs.ReadDirFS), ".")
if err != nil {
panic(err)
}
e.NoRoute(func(ctx *gin.Context) {
if strings.HasPrefix(ctx.Request.URL.Path, "/web/") {
ctx.FileFromFS("", http.FS(public.Public))
return
}
})
}
func initFSRouter(e *gin.RouterGroup, f fs.ReadDirFS, path string) error {

8
utils/utils.go
Unescape Escape View File

@ -92,12 +92,8 @@ func In[T comparable](items []T, item T) bool {
}
func Exists(name string) bool {
if _, err := os.Stat(name); err != nil {
if os.IsNotExist(err) {
return false
}
}
return true
_, err := os.Stat(name)
return !os.IsNotExist(err)
}
func WriteYaml(file string, module any) error {

Write Preview
Loading…
Cancel
Save