overleaf-registration-be/overleaf.go

package main

import (
	"bytes"
	"fmt"
	"io"
	"log"
	"net/http"
	"net/http/cookiejar"
	"net/url"
	"strings"

	"github.com/PuerkitoBio/goquery"
)

type Overleaf struct {
	BaseURL string
	Client  *http.Client
	CSRF    string
}

// NewOverleaf initializes a new Overleaf instance with a cookie jar
func NewOverleaf(baseURL string) *Overleaf {
	jar, _ := cookiejar.New(nil) // Initialize cookie jar
	client := &http.Client{
		Jar: jar, // Attach cookie jar to client
	}

	return &Overleaf{
		BaseURL: strings.TrimSuffix(baseURL, "/"),
		Client:  client,
	}
}

// logCookies logs cookies stored in the client's cookie jar for a given endpoint
func logCookies(client *http.Client, endpoint string) {
	u, _ := url.Parse(endpoint)
	cookies := client.Jar.Cookies(u)
	for _, cookie := range cookies {
		log.Printf("Cookie for %s: %s=%s", endpoint, cookie.Name, cookie.Value)
	}
}

// get performs a GET request
func (o *Overleaf) get(endpoint string) (*http.Response, error) {
	url := fmt.Sprintf("%s%s", o.BaseURL, endpoint)
	resp, err := o.Client.Get(url)
	if err == nil {
		logCookies(o.Client, url) // Log cookies after GET request
	}
	return resp, err
}

// post performs a POST request
func (o *Overleaf) post(endpoint string, data map[string]string) (*http.Response, error) {
	url := fmt.Sprintf("%s%s", o.BaseURL, endpoint)
	data["_csrf"] = o.CSRF
	formData := encodeFormData(data)

	req, err := http.NewRequest("POST", url, bytes.NewBufferString(formData))
	if err != nil {
		return nil, fmt.Errorf("failed to create POST request: %v", err)
	}
	req.Header.Set("Content-Type", "application/x-www-form-urlencoded")

	resp, err := o.Client.Do(req)
	if err == nil {
		logCookies(o.Client, url) // Log cookies after POST request
	}
	return resp, err
}

// obtainCSRF retrieves the CSRF token
func (o *Overleaf) obtainCSRF() error {
	resp, err := o.get("/login")
	if err != nil {
		return fmt.Errorf("failed to load login page: %v", err)
	}
	defer resp.Body.Close()

	doc, err := goquery.NewDocumentFromReader(resp.Body)
	if err != nil {
		return fmt.Errorf("failed to parse login page HTML: %v", err)
	}

	csrf, exists := doc.Find(`meta[name="ol-csrfToken"]`).Attr("content")
	if !exists {
		return fmt.Errorf("CSRF token not found in login page")
	}

	o.CSRF = csrf
	log.Printf("Obtained CSRF token: %s", o.CSRF)
	return nil
}

// Login authenticates as admin
func (o *Overleaf) Login(email, password string) error {
	if err := o.obtainCSRF(); err != nil {
		return fmt.Errorf("failed to obtain CSRF token: %v", err)
	}

	resp, err := o.post("/login", map[string]string{
		"email":    email,
		"password": password,
	})
	if err != nil {
		return fmt.Errorf("failed to send login request: %v", err)
	}
	defer resp.Body.Close()

	if resp.StatusCode != http.StatusOK {
		body, _ := io.ReadAll(resp.Body)
		log.Printf("Login response: %s", string(body))
		return fmt.Errorf("admin login returned status %d: %s", resp.StatusCode, string(body))
	}

	log.Println("Admin login successful.")
	return nil
}

// RegisterUser registers a new user
func (o *Overleaf) RegisterUser(email string) error {
	log.Printf("Attempting to register user with email: %s", email)
	log.Printf("Using CSRF token: %s", o.CSRF)

	resp, err := o.post("/admin/register", map[string]string{
		"email": email,
	})
	if err != nil {
		return fmt.Errorf("failed to send register request: %v", err)
	}
	defer resp.Body.Close()

	// Log response for debugging
	body, _ := io.ReadAll(resp.Body)
	log.Printf("Register user response: %s", string(body))

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

	log.Println("User registered successfully.")
	return nil
}

// encodeFormData encodes a map into x-www-form-urlencoded format
func encodeFormData(data map[string]string) string {
	var formData []string
	for key, value := range data {
		formData = append(formData, fmt.Sprintf("%s=%s", key, value))
	}
	return strings.Join(formData, "&")
}