Fix: room user permission

build.sh

@@ -12,6 +12,7 @@ function Help() {
     echo "-h get help"
     echo "-v set build version (default: dev)"
     echo "-w set web version (default: latest releases)"
+    echo "-s sekp init dep (default: false)"
     echo "-m set build mode (default: pie)"
     echo "-l set ldflags (default: -s -w --extldflags \"-static -fpic -Wl,-z,relro,-z,now\")"
     echo "-p set platform (default: host platform, support: all, linux, darwin, windows)"
@@ -35,12 +36,13 @@ function Init() {
     LDFLAGS='-s -w --extldflags "-static -fpic -Wl,-z,relro,-z,now"'
     PLATFORM=""
     TRIM_PATH=""
+    SKIP_INIT_DEP=""
     BUILD_DIR="build"
     TAGS="jsoniter"
 }
 
 function ParseArgs() {
-    while getopts "hv:w:m:l:p:Pb:T:" arg; do
+    while getopts "hsv:w:m:l:p:Pb:T:" arg; do
         case $arg in
         h)
             Help
@@ -49,6 +51,9 @@ function ParseArgs() {
         v)
             VERSION="$(echo "$OPTARG" | sed 's/ //g' | sed 's/"//g' | sed 's/\n//g')"
             ;;
+        s)
+            SKIP_INIT_DEP="true"
+            ;;
         w)
             WEB_VERSION="$OPTARG"
             ;;
@@ -126,6 +131,10 @@ function FixArgs() {
 }
 
 function InitDep() {
+    if [ "$SKIP_INIT_DEP" ]; then
+        echo "skip init dep"
+        return
+    fi
     rm -rf public/dist/*
     echo "download: https://github.com/synctv-org/synctv-web/releases/download/${WEB_VERSION}/dist.tar.gz"
     curl -sL "https://github.com/synctv-org/synctv-web/releases/download/${WEB_VERSION}/dist.tar.gz" | tar --strip-components 1 -C "public/dist" -z -x -v -f -

internal/db/db.go

@@ -236,3 +236,9 @@ func WhereIDLike(id string) func(db *gorm.DB) *gorm.DB {
 		}
 	}
 }
+
+func WhereRoomUserStatus(status model.RoomUserStatus) func(db *gorm.DB) *gorm.DB {
+	return func(db *gorm.DB) *gorm.DB {
+		return db.Where("status = ?", status)
+	}
+}

internal/db/relation.go

@@ -75,3 +75,9 @@ func RemoveUserPermission(roomID string, userID string, permission model.RoomUse
 	}
 	return err
 }
+
+func GetAllRoomUsersRelation(roomID string, scopes ...func(*gorm.DB) *gorm.DB) []*model.RoomUserRelation {
+	var roomUserRelations []*model.RoomUserRelation
+	db.Where("room_id = ?", roomID).Scopes(scopes...).Find(&roomUserRelations)
+	return roomUserRelations
+}

internal/db/room.go

@@ -23,7 +23,7 @@ func WithCreator(creator *model.User) CreateRoomConfig {
 		r.GroupUserRelations = []model.RoomUserRelation{
 			{
 				UserID:      creator.ID,
-				Status:      model.RoomRoleActive,
+				Status:      model.RoomUserStatusActive,
 				Permissions: model.PermissionAll,
 			},
 		}

internal/model/relation.go

@@ -8,18 +8,18 @@ import (
 type RoomUserStatus uint
 
 const (
-	RoomRoleBanned RoomUserStatus = iota + 1
-	RoomRolePending
-	RoomRoleActive
+	RoomUserStatusBanned RoomUserStatus = iota + 1
+	RoomUserStatusPending
+	RoomUserStatusActive
 )
 
 func (r RoomUserStatus) String() string {
 	switch r {
-	case RoomRoleBanned:
+	case RoomUserStatusBanned:
 		return "banned"
-	case RoomRolePending:
+	case RoomUserStatusPending:
 		return "pending"
-	case RoomRoleActive:
+	case RoomUserStatusActive:
 		return "active"
 	default:
 		return "unknown"
@@ -58,7 +58,7 @@ var ErrNoPermission = errors.New("no permission")
 
 func (r *RoomUserRelation) HasPermission(permission RoomUserPermission) bool {
 	switch r.Status {
-	case RoomRoleActive:
+	case RoomUserStatusActive:
 		return r.Permissions.Has(permission)
 	default:
 		return false

internal/op/room.go

@@ -101,9 +101,9 @@ func (r *Room) HasPermission(userID string, permission model.RoomUserPermission)
 func (r *Room) LoadOrCreateRoomUserRelation(userID string) (*model.RoomUserRelation, error) {
 	var conf []db.CreateRoomUserRelationConfig
 	if r.Settings.JoinNeedReview {
-		conf = []db.CreateRoomUserRelationConfig{db.WithRoomUserRelationStatus(model.RoomRolePending)}
+		conf = []db.CreateRoomUserRelationConfig{db.WithRoomUserRelationStatus(model.RoomUserStatusPending)}
 	} else {
-		conf = []db.CreateRoomUserRelationConfig{db.WithRoomUserRelationStatus(model.RoomRoleActive)}
+		conf = []db.CreateRoomUserRelationConfig{db.WithRoomUserRelationStatus(model.RoomUserStatusActive)}
 	}
 	if r.Settings.UserDefaultPermissions != 0 {
 		conf = append(conf, db.WithRoomUserRelationPermissions(r.Settings.UserDefaultPermissions))
@@ -180,12 +180,12 @@ func (r *Room) Current() *Current {
 	return &c
 }
 
-func (r *Room) ChangeCurrentMovie(id string, play bool) error {
+func (r *Room) SetCurrentMovieByID(id string, play bool) error {
 	m, err := r.movies.GetMovieByID(id)
 	if err != nil {
 		return err
 	}
-	r.current.SetMovie(*m.Movie, play)
+	r.SetCurrentMovie(m.Movie, play)
 	return nil
 }
 

internal/op/user.go

@@ -123,3 +123,55 @@ func (u *User) SetRoomSetting(room *Room, setting model.RoomSettings) error {
 	}
 	return room.SetSettings(setting)
 }
+
+func (u *User) DeleteMovieByID(room *Room, movieID string) error {
+	m, err := room.GetMovieByID(movieID)
+	if err != nil {
+		return err
+	}
+	if m.CreatorID != u.ID && !u.HasRoomPermission(room, model.PermissionEditUser) {
+		return model.ErrNoPermission
+	}
+	return room.DeleteMovieByID(movieID)
+}
+
+func (u *User) DeleteMoviesByID(room *Room, movieIDs []string) error {
+	for _, id := range movieIDs {
+		m, err := room.GetMovieByID(id)
+		if err != nil {
+			return err
+		}
+		if m.CreatorID != u.ID && !u.HasRoomPermission(room, model.PermissionEditUser) {
+			return model.ErrNoPermission
+		}
+	}
+	for _, v := range movieIDs {
+		if err := room.DeleteMovieByID(v); err != nil {
+			return err
+		}
+	}
+	return nil
+}
+
+func (u *User) ClearMovies(room *Room) error {
+	if !u.HasRoomPermission(room, model.PermissionEditUser) {
+		return model.ErrNoPermission
+	}
+	return room.ClearMovies()
+}
+
+func (u *User) SetCurrentMovie(room *Room, movie *model.Movie, play bool) error {
+	if !u.HasRoomPermission(room, model.PermissionEditCurrent) {
+		return model.ErrNoPermission
+	}
+	room.SetCurrentMovie(movie, play)
+	return nil
+}
+
+func (u *User) SetCurrentMovieByID(room *Room, movieID string, play bool) error {
+	m, err := room.GetMovieByID(movieID)
+	if err != nil {
+		return err
+	}
+	return u.SetCurrentMovie(room, m.Movie, play)
+}

server/handlers/admin.go

@@ -111,12 +111,11 @@ func Users(ctx *gin.Context) {
 
 	ctx.JSON(http.StatusOK, model.NewApiDataResp(gin.H{
 		"total": db.GetAllUserCount(scopes...),
-		"list":  genUserListResp(append(scopes, db.Paginate(page, pageSize))...),
+		"list":  genUserListResp(db.GetAllUsers(append(scopes, db.Paginate(page, pageSize))...)),
 	}))
 }
 
-func genUserListResp(scopes ...func(db *gorm.DB) *gorm.DB) []*model.UserInfoResp {
-	us := db.GetAllUsers(scopes...)
+func genUserListResp(us []*dbModel.User) []*model.UserInfoResp {
 	resp := make([]*model.UserInfoResp, len(us))
 	for i, v := range us {
 		resp[i] = &model.UserInfoResp{

server/handlers/init.go

@@ -78,6 +78,8 @@ func Init(e *gin.Engine) {
 			needAuthRoom.GET("/settings", RoomSetting)
 
 			needAuthRoom.POST("/settings", SetRoomSetting)
+
+			// needAuthRoom.GET("/users", RoomUsers)
 		}
 
 		{

server/handlers/movie.go

@@ -319,12 +319,10 @@ func DelMovie(ctx *gin.Context) {
 		return
 	}
 
-	for _, id := range req.Ids {
-		err := room.DeleteMovieByID(id)
-		if err != nil {
-			ctx.AbortWithStatusJSON(http.StatusBadRequest, model.NewApiErrorResp(err))
-			return
-		}
+	err := user.DeleteMoviesByID(room, req.Ids)
+	if err != nil {
+		ctx.AbortWithStatusJSON(http.StatusBadRequest, model.NewApiErrorResp(err))
+		return
 	}
 
 	if err := room.Broadcast(&op.ElementMessage{
@@ -344,7 +342,7 @@ func ClearMovies(ctx *gin.Context) {
 	room := ctx.MustGet("room").(*op.Room)
 	user := ctx.MustGet("user").(*op.User)
 
-	if err := room.ClearMovies(); err != nil {
+	if err := user.ClearMovies(room); err != nil {
 		ctx.AbortWithStatusJSON(http.StatusBadRequest, model.NewApiErrorResp(err))
 		return
 	}
@@ -401,8 +399,12 @@ func ChangeCurrentMovie(ctx *gin.Context) {
 	}
 
 	if req.Id == "" {
-		room.SetCurrentMovie(&dbModel.Movie{}, false)
-	} else if err := room.ChangeCurrentMovie(req.Id, true); err != nil {
+		err := user.SetCurrentMovie(room, &dbModel.Movie{}, false)
+		if err != nil {
+			ctx.AbortWithStatusJSON(http.StatusBadRequest, model.NewApiErrorResp(err))
+			return
+		}
+	} else if err := user.SetCurrentMovieByID(room, req.Id, true); err != nil {
 		ctx.AbortWithStatusJSON(http.StatusBadRequest, model.NewApiErrorResp(err))
 		return
 	}

server/handlers/room.go

@@ -261,3 +261,64 @@ func SetRoomSetting(ctx *gin.Context) {
 
 	ctx.Status(http.StatusNoContent)
 }
+
+// func RoomUsers(ctx *gin.Context) {
+// 	room := ctx.MustGet("room").(*op.Room)
+// 	page, pageSize, err := GetPageAndPageSize(ctx)
+// 	if err != nil {
+// 		ctx.AbortWithStatusJSON(http.StatusBadRequest, model.NewApiErrorResp(err))
+// 		return
+// 	}
+
+// 	var desc = ctx.DefaultQuery("sort", "desc") == "desc"
+
+// 	scopes := []func(db *gorm.DB) *gorm.DB{}
+// 	roomUserRelationScopes := []func(db *gorm.DB) *gorm.DB{}
+
+// 	switch ctx.DefaultQuery("status", "active") {
+// 	case "pending":
+// 		roomUserRelationScopes = append(roomUserRelationScopes, db.WhereRoomUserStatus(dbModel.RoomUserStatusPending))
+// 	case "banned":
+// 		roomUserRelationScopes = append(roomUserRelationScopes, db.WhereRoomUserStatus(dbModel.RoomUserStatusBanned))
+// 	case "active":
+// 		roomUserRelationScopes = append(roomUserRelationScopes, db.WhereRoomUserStatus(dbModel.RoomUserStatusActive))
+// 	default:
+// 		ctx.AbortWithStatusJSON(http.StatusBadRequest, model.NewApiErrorStringResp("not support role"))
+// 		return
+// 	}
+
+// 	switch ctx.DefaultQuery("order", "name") {
+// 	case "join":
+// 		if desc {
+// 			roomUserRelationScopes = append(roomUserRelationScopes, db.OrderByCreatedAtDesc)
+// 		} else {
+// 			roomUserRelationScopes = append(roomUserRelationScopes, db.OrderByCreatedAtAsc)
+// 		}
+// 	case "name":
+// 		if desc {
+// 			scopes = append(scopes, db.OrderByDesc("username"))
+// 		} else {
+// 			scopes = append(scopes, db.OrderByAsc("username"))
+// 		}
+// 	default:
+// 		ctx.AbortWithStatusJSON(http.StatusBadRequest, model.NewApiErrorStringResp("not support order"))
+// 		return
+// 	}
+
+// 	if keyword := ctx.Query("keyword"); keyword != "" {
+// 		// search mode, all, name, id
+// 		switch ctx.DefaultQuery("search", "all") {
+// 		case "all":
+// 			scopes = append(scopes, db.WhereUsernameLikeOrIDIn(keyword, db.GerUsersIDByIDLike(keyword)))
+// 		case "name":
+// 			scopes = append(scopes, db.WhereUsernameLike(keyword))
+// 		case "id":
+// 			scopes = append(scopes, db.WhereIDIn(db.GerUsersIDByIDLike(keyword)))
+// 		}
+// 	}
+
+// 	ctx.JSON(http.StatusOK, model.NewApiDataResp(gin.H{
+// 		"total": db.GetAllRoomUsersCount(room.ID, roomUserRelationScopes, scopes...),
+// 		"list":  genUserListResp(db.GetAllRoomUsers(room.ID, roomUserRelationScopes, append(scopes, db.Paginate(page, pageSize))...)),
+// 	}))
+// }

server/model/user.go

@@ -91,3 +91,11 @@ func (u *UserIDReq) Validate() error {
 	}
 	return nil
 }
+
+type RoomUserInfoResp struct {
+	ID         string                     `json:"id"`
+	Username   string                     `json:"username"`
+	JoinedAt   int64                      `json:"joinedAt"`
+	Status     string                     `json:"status"`
+	Permission dbModel.RoomUserPermission `json:"permission"`
+}