Skip to content

armgit / fider

Public Imported from GitHub
0

Open platform to collect and prioritize feedback

3.4 KB
Raw Blame
package dbEntities

import (
	"context"
	"database/sql"
	"net/url"

	"github.com/getfider/fider/app"
	"github.com/getfider/fider/app/models/entity"
	"github.com/getfider/fider/app/models/enum"
	"github.com/getfider/fider/app/pkg/web"
)

// User is the database mapping for users table
type User struct {
	ID            sql.NullInt64  `db:"id"`
	Name          sql.NullString `db:"name"`
	Email         sql.NullString `db:"email"`
	Tenant        *Tenant        `db:"tenant"`
	Role          sql.NullInt64  `db:"role"`
	Status        sql.NullInt64  `db:"status"`
	AvatarType    sql.NullInt64  `db:"avatar_type"`
	AvatarBlobKey sql.NullString `db:"avatar_bkey"`
	IsTrusted     sql.NullBool   `db:"is_trusted"`
	SecurityStamp sql.NullString `db:"security_stamp"`
	Providers     []*UserProvider
}

type UserProvider struct {
	Name sql.NullString `db:"provider"`
	UID  sql.NullString `db:"provider_uid"`
}

type UserSetting struct {
	Key   string `db:"key"`
	Value string `db:"value"`
}

func (u *User) ToModel(ctx context.Context) *entity.User {
	if u == nil {
		return nil
	}

	// Bind the user to the tenant persisted on its own database row. The persisted
	// association is loaded into u.Tenant from the tenant_id column and is the user's
	// authorization identity — it MUST take precedence over the request-context tenant.
	// Deriving the tenant from context would let an authentication token minted on one
	// tenant be replayed on another subdomain and pass the downstream tenant-equality
	// check tautologically (cross-tenant privilege escalation).
	var tenant *entity.Tenant
	if u.Tenant != nil {
		tenant = u.Tenant.ToModel()
		// When the request is scoped to this same tenant, prefer the fully-populated
		// request tenant so presentation data (name, plan, settings) is preserved. The
		// authorization identity is unchanged because the IDs are equal.
		if ctxTenant, ok := ctx.Value(app.TenantCtxKey).(*entity.Tenant); ok && ctxTenant != nil && ctxTenant.ID == tenant.ID {
			tenant = ctxTenant
		}
	} else if ctxTenant, ok := ctx.Value(app.TenantCtxKey).(*entity.Tenant); ok {
		// No persisted association was loaded (e.g. a user struct not read through the
		// standard queries); fall back to the request tenant.
		tenant = ctxTenant
	}

	avatarType := enum.AvatarType(u.AvatarType.Int64)
	avatarURL := ""
	if u.AvatarType.Valid {
		avatarURL = buildAvatarURL(ctx, avatarType, int(u.ID.Int64), u.Name.String, u.AvatarBlobKey.String)
	}

	user := &entity.User{
		ID:            int(u.ID.Int64),
		Name:          u.Name.String,
		Email:         u.Email.String,
		Tenant:        tenant,
		Role:          enum.Role(u.Role.Int64),
		Status:        enum.UserStatus(u.Status.Int64),
		AvatarType:    avatarType,
		AvatarBlobKey: u.AvatarBlobKey.String,
		AvatarURL:     avatarURL,
		IsTrusted:     u.IsTrusted.Bool,
		SecurityStamp: u.SecurityStamp.String,
	}

	if u.Providers != nil {
		user.Providers = make([]*entity.UserProvider, len(u.Providers))
		for i, p := range u.Providers {
			user.Providers[i] = &entity.UserProvider{
				Name: p.Name.String,
				UID:  p.UID.String,
			}
		}
	}

	return user
}

func buildAvatarURL(ctx context.Context, avatarType enum.AvatarType, id int, name, avatarBlobKey string) string {
	if name == "" {
		name = "-"
	}

	if avatarType == enum.AvatarTypeCustom {
		return web.AssetsURL(ctx, "/static/images/%s", avatarBlobKey)
	}
	return web.AssetsURL(ctx, "/static/avatars/%s/%d/%s", avatarType.String(), id, url.PathEscape(name))
}