user.go

package main

import (
	"bytes"
	_ "embed"
	"encoding/json"
	"fmt"
	"io"
	"net/http"
	"time"
)

//go:embed userinfo.gql
var userinfoQuery string

//go:embed users.gql
var usersQuery string

//go:embed groups.gql
var groupsQuery string

type UserInfo struct {
	ID                  int64       `json:"id"`
	Name                string      `json:"name"`
	FirstName           string      `json:"firstname"`
	Username            string      `json:"username"`
	Emails              []UserEmail `json:"emails"`
	Groups              []UserGroup `json:"groups"`
	Roles               []UserRole  `json:"roles"`
	AcceptedTOS         bool        `json:"accepted_tos"`
	SurveySubmittedTime *string     `json:"survey_submitted_time"`
}

type UserEmail struct {
	Email string `json:"email"`
}

type UserGroup struct {
	ID    int64            `json:"id"`
	Group UserGroupDetails `json:"group"`
}

type UserGroupDetails struct {
	Name    string `json:"name"`
	GroupID int64  `json:"group_id"`
}

type UserRole struct {
	Role UserRoleDetails `json:"role"`
}

type UserRoleDetails struct {
	Description string `json:"description"`
	ID          int64  `json:"id"`
	Name        string `json:"name"`
}

type UserInfoRequest struct {
	OperationName string                 `json:"operationName"`
	Query         string                 `json:"query"`
	Variables     map[string]interface{} `json:"variables"`
}

type UserInfoResponse struct {
	Data struct {
		Users []UserInfo `json:"users"`
	} `json:"data"`
	Errors []struct {
		Message string `json:"message"`
	} `json:"errors"`
}

func getUserInfo(server string) (*UserInfo, error) {
	token, err := ensureValidToken()
	if err != nil {
		return nil, fmt.Errorf("authentication required: %w", err)
	}

	query := userinfoQuery

	// Create GraphQL request
	graphqlReq := UserInfoRequest{
		OperationName: "UserInfo",
		Query:         query,
		Variables:     map[string]interface{}{},
	}

	jsonData, err := json.Marshal(graphqlReq)
	if err != nil {
		return nil, fmt.Errorf("failed to marshal GraphQL request: %w", err)
	}

	url := fmt.Sprintf("https://%s/v1/graphql", server)
	req, err := http.NewRequest("POST", url, bytes.NewBuffer(jsonData))
	if err != nil {
		return nil, fmt.Errorf("failed to create request: %w", err)
	}

	req.Header.Set("Authorization", fmt.Sprintf("Bearer %s", token.IDToken))
	req.Header.Set("Content-Type", "application/json")
	req.Header.Set("Accept", "application/json")
	req.Header.Set("X-Hasura-Role", "jhuser")

	client := &http.Client{Timeout: 30 * time.Second}
	resp, err := client.Do(req)
	if err != nil {
		return nil, fmt.Errorf("failed to make request: %w", err)
	}
	defer resp.Body.Close()

	if resp.StatusCode != http.StatusOK {
		body, _ := io.ReadAll(resp.Body)
		return nil, fmt.Errorf("GraphQL request failed (status %d): %s", resp.StatusCode, string(body))
	}

	body, err := io.ReadAll(resp.Body)
	if err != nil {
		return nil, fmt.Errorf("failed to read response: %w", err)
	}

	var response UserInfoResponse
	if err := json.Unmarshal(body, &response); err != nil {
		return nil, fmt.Errorf("failed to parse response: %w", err)
	}

	// Check for GraphQL errors
	if len(response.Errors) > 0 {
		return nil, fmt.Errorf("GraphQL errors: %v", response.Errors)
	}

	if len(response.Data.Users) == 0 {
		return nil, fmt.Errorf("no user information found")
	}

	return &response.Data.Users[0], nil
}

func showUserInfo(server string) error {
	userInfo, err := getUserInfo(server)
	if err != nil {
		return err
	}

	fmt.Printf("User Information:\n\n")
	fmt.Printf("ID: %d\n", userInfo.ID)
	fmt.Printf("Name: %s\n", userInfo.Name)
	fmt.Printf("First Name: %s\n", userInfo.FirstName)
	fmt.Printf("Username: %s\n", userInfo.Username)
	fmt.Printf("Accepted Terms of Service: %t\n", userInfo.AcceptedTOS)

	if userInfo.SurveySubmittedTime != nil {
		fmt.Printf("Survey Submitted: %s\n", *userInfo.SurveySubmittedTime)
	}

	// Show emails
	if len(userInfo.Emails) > 0 {
		fmt.Printf("\nEmails:\n")
		for _, email := range userInfo.Emails {
			fmt.Printf("  - %s\n", email.Email)
		}
	}

	// Show groups
	if len(userInfo.Groups) > 0 {
		fmt.Printf("\nGroups:\n")
		for _, group := range userInfo.Groups {
			fmt.Printf("  - %s (ID: %d)\n", group.Group.Name, group.Group.GroupID)
		}
	}

	// Show roles
	if len(userInfo.Roles) > 0 {
		fmt.Printf("\nRoles:\n")
		for _, role := range userInfo.Roles {
			fmt.Printf("  - %s: %s\n", role.Role.Name, role.Role.Description)
		}
	}

	return nil
}

// ManageUser represents a user from the /app/config/features/manage endpoint
type ManageUser struct {
	Email          string                 `json:"email"`
	Name           *string                `json:"name"`
	UUID           string                 `json:"uuid"`
	Features       json.RawMessage        `json:"features"` // Will be parsed from JSON string
	JuliaHubGroups string                 `json:"juliahub_groups"`
	SiteGroups     string                 `json:"site_groups"`
	ParsedFeatures map[string]interface{} `json:"-"` // Parsed features
}

// ManageUsersResponse represents the response from /app/config/features/manage
type ManageUsersResponse struct {
	Users    []ManageUser    `json:"users"`
	Features json.RawMessage `json:"features"`
}

type GroupsGQLResponse struct {
	Data struct {
		Groups []struct {
			Name    string `json:"name"`
			GroupID int64  `json:"group_id"`
		} `json:"groups"`
		Products []struct {
			Name            string `json:"name"`
			DisplayName     string `json:"display_name"`
			ID              int64  `json:"id"`
			ComputeTypeName string `json:"compute_type_name"`
		} `json:"products"`
	} `json:"data"`
	Errors []struct {
		Message string `json:"message"`
	} `json:"errors"`
}

type AdminGroup struct {
	Name string `json:"name"`
	ID   int64  `json:"id"`
}

func listGroups(server string) error {
	token, err := ensureValidToken()
	if err != nil {
		return fmt.Errorf("authentication required: %w", err)
	}

	url := fmt.Sprintf("https://%s/app/config/groups", server)
	req, err := http.NewRequest("GET", url, nil)
	if err != nil {
		return fmt.Errorf("failed to create request: %w", err)
	}
	req.Header.Set("Authorization", fmt.Sprintf("Bearer %s", token.IDToken))
	req.Header.Set("Accept", "application/json")

	client := &http.Client{Timeout: 30 * time.Second}
	resp, err := client.Do(req)
	if err != nil {
		return fmt.Errorf("failed to fetch groups: %w", err)
	}
	body, _ := io.ReadAll(resp.Body)
	resp.Body.Close()

	if resp.StatusCode != http.StatusOK {
		return fmt.Errorf("request failed (status %d): %s", resp.StatusCode, string(body))
	}

	var groups []AdminGroup
	if err := json.Unmarshal(body, &groups); err != nil {
		return fmt.Errorf("failed to parse groups: %w", err)
	}
	if len(groups) == 0 {
		fmt.Println("No groups found")
		return nil
	}
	for _, g := range groups {
		fmt.Println(g.Name)
	}
	return nil
}

func listGroupsGQL(server string) error {
	token, err := ensureValidToken()
	if err != nil {
		return fmt.Errorf("authentication required: %w", err)
	}

	gqlReq := UserInfoRequest{
		OperationName: "Groups",
		Query:         groupsQuery,
		Variables:     map[string]interface{}{"limit": 500},
	}
	jsonData, err := json.Marshal(gqlReq)
	if err != nil {
		return fmt.Errorf("failed to marshal groups request: %w", err)
	}
	req, err := http.NewRequest("POST", fmt.Sprintf("https://%s/v1/graphql", server), bytes.NewBuffer(jsonData))
	if err != nil {
		return fmt.Errorf("failed to create request: %w", err)
	}
	req.Header.Set("Authorization", fmt.Sprintf("Bearer %s", token.IDToken))
	req.Header.Set("Content-Type", "application/json")
	req.Header.Set("Accept", "application/json")
	req.Header.Set("X-Hasura-Role", "jhuser")
	req.Header.Set("X-Juliahub-Ensure-JS", "true")

	client := &http.Client{Timeout: 30 * time.Second}
	resp, err := client.Do(req)
	if err != nil {
		return fmt.Errorf("failed to fetch groups: %w", err)
	}
	body, _ := io.ReadAll(resp.Body)
	resp.Body.Close()

	var groupsResp GroupsGQLResponse
	if err := json.Unmarshal(body, &groupsResp); err != nil {
		return fmt.Errorf("failed to parse groups: %w", err)
	}
	if len(groupsResp.Errors) > 0 {
		return fmt.Errorf("GraphQL errors: %v", groupsResp.Errors)
	}
	if len(groupsResp.Data.Groups) == 0 {
		fmt.Println("No groups found")
		return nil
	}
	for _, g := range groupsResp.Data.Groups {
		fmt.Println(g.Name)
	}
	return nil
}

type UsersGQLResponse struct {
	Data struct {
		Users []struct {
			Username string  `json:"username"`
			ID       int64   `json:"id"`
			Name     *string `json:"name"`
		} `json:"users"`
	} `json:"data"`
	Errors []struct {
		Message string `json:"message"`
	} `json:"errors"`
}

func listUsersGQL(server string) error {
	token, err := ensureValidToken()
	if err != nil {
		return fmt.Errorf("authentication required: %w", err)
	}

	gqlReq := UserInfoRequest{
		OperationName: "Users",
		Query:         usersQuery,
		Variables:     map[string]interface{}{"limit": 500},
	}
	jsonData, err := json.Marshal(gqlReq)
	if err != nil {
		return fmt.Errorf("failed to marshal users request: %w", err)
	}
	req, err := http.NewRequest("POST", fmt.Sprintf("https://%s/v1/graphql", server), bytes.NewBuffer(jsonData))
	if err != nil {
		return fmt.Errorf("failed to create request: %w", err)
	}
	req.Header.Set("Authorization", fmt.Sprintf("Bearer %s", token.IDToken))
	req.Header.Set("Content-Type", "application/json")
	req.Header.Set("Accept", "application/json")
	req.Header.Set("X-Hasura-Role", "jhuser")
	req.Header.Set("X-Juliahub-Ensure-JS", "true")

	client := &http.Client{Timeout: 30 * time.Second}
	resp, err := client.Do(req)
	if err != nil {
		return fmt.Errorf("failed to fetch users: %w", err)
	}
	body, _ := io.ReadAll(resp.Body)
	resp.Body.Close()

	var usersResp UsersGQLResponse
	if err := json.Unmarshal(body, &usersResp); err != nil {
		return fmt.Errorf("failed to parse users: %w", err)
	}
	if len(usersResp.Errors) > 0 {
		return fmt.Errorf("GraphQL errors: %v", usersResp.Errors)
	}
	if len(usersResp.Data.Users) == 0 {
		fmt.Println("No users found")
		return nil
	}
	for _, u := range usersResp.Data.Users {
		name := u.Username
		if u.Name != nil && *u.Name != "" {
			name = *u.Name
		}
		fmt.Printf("%s (%s)\n", name, u.Username)
	}
	return nil
}

func listUsers(server string, verbose bool) error {
	token, err := ensureValidToken()
	if err != nil {
		return fmt.Errorf("authentication required: %w", err)
	}

	url := fmt.Sprintf("https://%s/app/config/features/manage", server)
	req, err := http.NewRequest("GET", url, nil)
	if err != nil {
		return fmt.Errorf("failed to create request: %w", err)
	}

	req.Header.Set("Authorization", fmt.Sprintf("Bearer %s", token.IDToken))
	req.Header.Set("Accept", "application/json")

	client := &http.Client{Timeout: 30 * time.Second}
	resp, err := client.Do(req)
	if err != nil {
		return fmt.Errorf("failed to make request: %w", err)
	}
	defer resp.Body.Close()

	if resp.StatusCode != http.StatusOK {
		body, _ := io.ReadAll(resp.Body)
		return fmt.Errorf("request failed (status %d): %s", resp.StatusCode, string(body))
	}

	body, err := io.ReadAll(resp.Body)
	if err != nil {
		return fmt.Errorf("failed to read response: %w", err)
	}

	var response ManageUsersResponse
	if err := json.Unmarshal(body, &response); err != nil {
		return fmt.Errorf("failed to parse response: %w", err)
	}

	// Parse features JSON string for each user (only needed in verbose mode)
	if verbose {
		for i := range response.Users {
			var features map[string]interface{}
			if err := json.Unmarshal(response.Users[i].Features, &features); err == nil {
				response.Users[i].ParsedFeatures = features
			}
		}
	}

	if verbose {
		fmt.Printf("Users (%d total):\n\n", len(response.Users))
		// Verbose mode: show all details
		for _, user := range response.Users {
			fmt.Printf("UUID: %s\n", user.UUID)
			fmt.Printf("Email: %s\n", user.Email)
			if user.Name != nil {
				fmt.Printf("Name: %s\n", *user.Name)
			}
			if user.JuliaHubGroups != "" {
				fmt.Printf("JuliaHub Groups: %s\n", user.JuliaHubGroups)
			}
			if user.SiteGroups != "" {
				fmt.Printf("Site Groups: %s\n", user.SiteGroups)
			}
			if len(user.ParsedFeatures) > 0 {
				fmt.Printf("Features: %v\n", user.ParsedFeatures)
			}
			fmt.Println()
		}
	} else {
		for _, user := range response.Users {
			name := user.Email
			if user.Name != nil && *user.Name != "" {
				name = *user.Name
			}
			fmt.Printf("%s (%s)\n", name, user.Email)
		}
	}

	return nil
}