// Code generated by sqlc. DO NOT EDIT.
// versions:
//   sqlc v1.30.0
// source: space_member.sql

package repo

import (
	"context"

	"github.com/jackc/pgx/v5/pgtype"
)

const countUserSpaces = `-- name: CountUserSpaces :one
SELECT COUNT(1)
FROM space_member
WHERE user_id = $1
`

// 合计某个用户的空间数量
func (q *Queries) CountUserSpaces(ctx context.Context, userID int64) (int64, error) {
	row := q.db.QueryRow(ctx, countUserSpaces, userID)
	var count int64
	err := row.Scan(&count)
	return count, err
}

const getSpaceMember = `-- name: GetSpaceMember :one
SELECT id, space_id, user_id, role, is_default, sort_number, member_name, status, disabled_time, exit_time, join_time, update_time FROM space_member WHERE space_id = $1 AND user_id = $2
`

type GetSpaceMemberParams struct {
	SpaceID int64
	UserID  int64
}

func (q *Queries) GetSpaceMember(ctx context.Context, arg GetSpaceMemberParams) (SpaceMember, error) {
	row := q.db.QueryRow(ctx, getSpaceMember, arg.SpaceID, arg.UserID)
	var i SpaceMember
	err := row.Scan(
		&i.ID,
		&i.SpaceID,
		&i.UserID,
		&i.Role,
		&i.IsDefault,
		&i.SortNumber,
		&i.MemberName,
		&i.Status,
		&i.DisabledTime,
		&i.ExitTime,
		&i.JoinTime,
		&i.UpdateTime,
	)
	return i, err
}

const getSpaceMemberByDefault = `-- name: GetSpaceMemberByDefault :one
SELECT
    sm.id, sm.space_id, sm.user_id, sm.role, sm.is_default, sm.sort_number, sm.member_name, sm.status, sm.disabled_time, sm.exit_time, sm.join_time, sm.update_time
FROM space_member sm
         LEFT JOIN space s
                   ON sm.space_id = s.id
WHERE sm.status != 2
    AND s.status != 2
    AND sm.is_default = 1
    AND sm.user_id = $1
`

// 获取该用户的默认空间
func (q *Queries) GetSpaceMemberByDefault(ctx context.Context, userID int64) (SpaceMember, error) {
	row := q.db.QueryRow(ctx, getSpaceMemberByDefault, userID)
	var i SpaceMember
	err := row.Scan(
		&i.ID,
		&i.SpaceID,
		&i.UserID,
		&i.Role,
		&i.IsDefault,
		&i.SortNumber,
		&i.MemberName,
		&i.Status,
		&i.DisabledTime,
		&i.ExitTime,
		&i.JoinTime,
		&i.UpdateTime,
	)
	return i, err
}

const getUserSpaceRole = `-- name: GetUserSpaceRole :one
SELECT role
FROM space_member
WHERE user_id = $1
  AND space_id = $2
`

type GetUserSpaceRoleParams struct {
	UserID  int64
	SpaceID int64
}

// 获取用户在指定空间的角色
func (q *Queries) GetUserSpaceRole(ctx context.Context, arg GetUserSpaceRoleParams) (int16, error) {
	row := q.db.QueryRow(ctx, getUserSpaceRole, arg.UserID, arg.SpaceID)
	var role int16
	err := row.Scan(&role)
	return role, err
}

const insertSpaceMember = `-- name: InsertSpaceMember :exec
INSERT INTO space_member(id,space_id,user_id,role,is_default,member_name,sort_number,join_time,update_time)
VALUES ($1,$2,$3,$4,$5,$6,$7,NOW(),NOW())
`

type InsertSpaceMemberParams struct {
	ID         int64
	SpaceID    int64
	UserID     int64
	Role       int16
	IsDefault  int16
	MemberName string
	SortNumber int32
}

// 插入空间用户
func (q *Queries) InsertSpaceMember(ctx context.Context, arg InsertSpaceMemberParams) error {
	_, err := q.db.Exec(ctx, insertSpaceMember,
		arg.ID,
		arg.SpaceID,
		arg.UserID,
		arg.Role,
		arg.IsDefault,
		arg.MemberName,
		arg.SortNumber,
	)
	return err
}

const listSpaceMembers = `-- name: ListSpaceMembers :many
SELECT
    sm.space_id,
    sm.user_id,
    sm.role,
    sm.status AS member_status,
    sm.member_name,
    sm.update_time AS member_update_time,
    sm.join_time,

    u.avatar,
    u.status AS user_status,
    u.last_login_time
FROM space_member sm
         LEFT JOIN "user" u
                   ON sm.user_id = u.id
         LEFT JOIN space s
                   ON sm.space_id = s.id
WHERE sm.space_id = $1
  AND sm.status != 2
  AND s.status != 2
ORDER BY sm.role ASC, sm.join_time ASC
`

type ListSpaceMembersRow struct {
	SpaceID          int64
	UserID           int64
	Role             int16
	MemberStatus     int16
	MemberName       string
	MemberUpdateTime pgtype.Timestamptz
	JoinTime         pgtype.Timestamptz
	Avatar           pgtype.Text
	UserStatus       pgtype.Int2
	LastLoginTime    pgtype.Timestamptz
}

// 获取空间下的成员列表
func (q *Queries) ListSpaceMembers(ctx context.Context, spaceID int64) ([]ListSpaceMembersRow, error) {
	rows, err := q.db.Query(ctx, listSpaceMembers, spaceID)
	if err != nil {
		return nil, err
	}
	defer rows.Close()
	var items []ListSpaceMembersRow
	for rows.Next() {
		var i ListSpaceMembersRow
		if err := rows.Scan(
			&i.SpaceID,
			&i.UserID,
			&i.Role,
			&i.MemberStatus,
			&i.MemberName,
			&i.MemberUpdateTime,
			&i.JoinTime,
			&i.Avatar,
			&i.UserStatus,
			&i.LastLoginTime,
		); err != nil {
			return nil, err
		}
		items = append(items, i)
	}
	if err := rows.Err(); err != nil {
		return nil, err
	}
	return items, nil
}

const updateOtherSpacesIsDefault = `-- name: UpdateOtherSpacesIsDefault :exec
UPDATE space_member
SET is_default = $1
WHERE user_id = $2
  AND space_id != $3
`

type UpdateOtherSpacesIsDefaultParams struct {
	IsDefault int16
	UserID    int64
	SpaceID   int64
}

// 将用户的其它空间更新为非默认
func (q *Queries) UpdateOtherSpacesIsDefault(ctx context.Context, arg UpdateOtherSpacesIsDefaultParams) error {
	_, err := q.db.Exec(ctx, updateOtherSpacesIsDefault, arg.IsDefault, arg.UserID, arg.SpaceID)
	return err
}

const updateSpaceIsDefault = `-- name: UpdateSpaceIsDefault :exec
UPDATE space_member SET is_default = $1
WHERE space_id = $2 AND user_id = $3
`

type UpdateSpaceIsDefaultParams struct {
	IsDefault int16
	SpaceID   int64
	UserID    int64
}

// 更新空间是否为默认
func (q *Queries) UpdateSpaceIsDefault(ctx context.Context, arg UpdateSpaceIsDefaultParams) error {
	_, err := q.db.Exec(ctx, updateSpaceIsDefault, arg.IsDefault, arg.SpaceID, arg.UserID)
	return err
}

const updateSpaceMemberExit = `-- name: UpdateSpaceMemberExit :exec
UPDATE space_member
SET status = 2,
    exit_time = NOW()
WHERE space_id = $1
  AND user_id = $2
`

type UpdateSpaceMemberExitParams struct {
	SpaceID int64
	UserID  int64
}

// 退出空间
func (q *Queries) UpdateSpaceMemberExit(ctx context.Context, arg UpdateSpaceMemberExitParams) error {
	_, err := q.db.Exec(ctx, updateSpaceMemberExit, arg.SpaceID, arg.UserID)
	return err
}

const updateSpaceMemberJoin = `-- name: UpdateSpaceMemberJoin :exec
UPDATE space_member
SET status = 0,
    join_time = NOW()
WHERE space_id = $1
  AND user_id = $2
`

type UpdateSpaceMemberJoinParams struct {
	SpaceID int64
	UserID  int64
}

func (q *Queries) UpdateSpaceMemberJoin(ctx context.Context, arg UpdateSpaceMemberJoinParams) error {
	_, err := q.db.Exec(ctx, updateSpaceMemberJoin, arg.SpaceID, arg.UserID)
	return err
}

const updateSpaceMemberName = `-- name: UpdateSpaceMemberName :exec
UPDATE space_member SET member_name = $1
WHERE space_id = $2 AND user_id = $3
`

type UpdateSpaceMemberNameParams struct {
	MemberName string
	SpaceID    int64
	UserID     int64
}

// 更新用户在空间内的名称
func (q *Queries) UpdateSpaceMemberName(ctx context.Context, arg UpdateSpaceMemberNameParams) error {
	_, err := q.db.Exec(ctx, updateSpaceMemberName, arg.MemberName, arg.SpaceID, arg.UserID)
	return err
}

const updateSpaceMemberRole = `-- name: UpdateSpaceMemberRole :exec
UPDATE space_member SET role = $1,update_time = NOW() WHERE space_id = $2 AND user_id = $3
`

type UpdateSpaceMemberRoleParams struct {
	Role    int16
	SpaceID int64
	UserID  int64
}

// 修改角色
func (q *Queries) UpdateSpaceMemberRole(ctx context.Context, arg UpdateSpaceMemberRoleParams) error {
	_, err := q.db.Exec(ctx, updateSpaceMemberRole, arg.Role, arg.SpaceID, arg.UserID)
	return err
}