603 lines
19 KiB
Go
603 lines
19 KiB
Go
package main
|
|
|
|
import (
|
|
"bytes"
|
|
"errors"
|
|
"github.com/go-chi/chi/v5"
|
|
"net/url"
|
|
"os"
|
|
"time"
|
|
|
|
"crypto/ed25519"
|
|
"database/sql"
|
|
"encoding/base64"
|
|
"encoding/json"
|
|
"html/template"
|
|
"io/fs"
|
|
"net/http"
|
|
"path/filepath"
|
|
|
|
library "git.ailur.dev/ailur/fg-library/v2"
|
|
authLibrary "git.ailur.dev/ailur/fg-nucleus-library"
|
|
"git.oreonproject.org/oreonproject/eternity/common"
|
|
"git.oreonproject.org/oreonproject/eternity/lib"
|
|
"github.com/go-git/go-git/v5"
|
|
"github.com/golang-jwt/jwt/v5"
|
|
"github.com/google/uuid"
|
|
)
|
|
|
|
var ServiceInformation = library.Service{
|
|
Name: "eternity",
|
|
Permissions: library.Permissions{
|
|
Authenticate: true, // This service does require authentication
|
|
Database: true, // This service does require database access
|
|
BlobStorage: false, // This service does not require blob storage
|
|
InterServiceCommunication: true, // This service does require inter-service communication
|
|
Resources: true, // This service does require its HTTP templates and static files
|
|
},
|
|
ServiceID: uuid.MustParse("0f31fa2d-43ca-410f-8148-239b298112b3"),
|
|
}
|
|
|
|
func logFunc(message string, messageType uint64, information library.ServiceInitializationInformation) {
|
|
// Log the message to the logger service
|
|
information.Outbox <- library.InterServiceMessage{
|
|
ServiceID: ServiceInformation.ServiceID,
|
|
ForServiceID: uuid.MustParse("00000000-0000-0000-0000-000000000002"), // Logger service
|
|
MessageType: messageType,
|
|
SentAt: time.Now(),
|
|
Message: message,
|
|
}
|
|
}
|
|
|
|
func renderTemplate(statusCode int, w http.ResponseWriter, data map[string]interface{}, templatePath string, information library.ServiceInitializationInformation) {
|
|
var err error
|
|
var requestedTemplate *template.Template
|
|
// Output ls of the resource directory
|
|
requestedTemplate, err = template.ParseFS(information.ResourceDir, "templates/"+templatePath)
|
|
if err != nil {
|
|
logFunc(err.Error(), 2, information)
|
|
renderString(500, w, "Sorry, something went wrong on our end. Error code: 01. Please report to the administrator.", information)
|
|
} else {
|
|
w.WriteHeader(statusCode)
|
|
err = requestedTemplate.Execute(w, data)
|
|
if err != nil {
|
|
logFunc(err.Error(), 2, information)
|
|
renderString(500, w, "Sorry, something went wrong on our end. Error code: 02. Please report to the administrator.", information)
|
|
}
|
|
}
|
|
}
|
|
|
|
func renderString(statusCode int, w http.ResponseWriter, data string, information library.ServiceInitializationInformation) {
|
|
w.WriteHeader(statusCode)
|
|
_, err := w.Write([]byte(data))
|
|
if err != nil {
|
|
logFunc(err.Error(), 2, information)
|
|
}
|
|
}
|
|
|
|
func renderJSON(statusCode int, w http.ResponseWriter, data map[string]interface{}, information library.ServiceInitializationInformation) {
|
|
w.WriteHeader(statusCode)
|
|
err := json.NewEncoder(w).Encode(data)
|
|
if err != nil {
|
|
logFunc(err.Error(), 2, information)
|
|
}
|
|
}
|
|
|
|
func verifySecret(secret string, conn library.Database) bool {
|
|
// Check if the secret is in the secrets table
|
|
var secretCheck string
|
|
err := conn.DB.QueryRow("SELECT secret FROM secrets WHERE secret = $1", secret).Scan(&secretCheck)
|
|
if err != nil || secretCheck != secret {
|
|
return false
|
|
}
|
|
|
|
return true
|
|
}
|
|
|
|
func verifyJwt(token string, publicKey ed25519.PublicKey, conn library.Database) (jwt.MapClaims, bool) {
|
|
parsedToken, err := jwt.Parse(token, func(token *jwt.Token) (interface{}, error) {
|
|
return publicKey, nil
|
|
})
|
|
if err != nil {
|
|
return nil, false
|
|
}
|
|
|
|
if !parsedToken.Valid {
|
|
return nil, false
|
|
}
|
|
|
|
claims, ok := parsedToken.Claims.(jwt.MapClaims)
|
|
if !ok {
|
|
return nil, false
|
|
}
|
|
|
|
// Check if the token expired
|
|
date, err := claims.GetExpirationTime()
|
|
if err != nil || date.Before(time.Now()) || claims["sub"] != nil || claims["isOpenID"] != nil || claims["isOAuth"].(bool) {
|
|
return claims, false
|
|
}
|
|
|
|
// Check if the token is in users
|
|
var idCheck []byte
|
|
err = conn.DB.QueryRow("SELECT id FROM users WHERE id = $1", claims["sub"]).Scan(&idCheck)
|
|
if err != nil || claims["sub"] != uuid.Must(uuid.FromBytes(idCheck)).String() {
|
|
return claims, false
|
|
}
|
|
|
|
return claims, true
|
|
}
|
|
|
|
func Main(information library.ServiceInitializationInformation) *chi.Mux {
|
|
var conn library.Database
|
|
gitDir := information.Configuration["gitDir"].(string)
|
|
outputDir := information.Configuration["outputDir"].(string)
|
|
hostName := information.Configuration["hostName"].(string)
|
|
|
|
// Initiate a connection to the database
|
|
// Call service ID 1 to get the database connection information
|
|
information.Outbox <- library.InterServiceMessage{
|
|
ServiceID: ServiceInformation.ServiceID,
|
|
ForServiceID: uuid.MustParse("00000000-0000-0000-0000-000000000001"), // Service initialization service
|
|
MessageType: 1, // Request connection information
|
|
SentAt: time.Now(),
|
|
Message: nil,
|
|
}
|
|
|
|
// Wait for the response
|
|
response := <-information.Inbox
|
|
if response.MessageType == 2 {
|
|
// This is the connection information
|
|
// Set up the database connection
|
|
conn = response.Message.(library.Database)
|
|
if conn.DBType == library.Sqlite {
|
|
// Create the packages table
|
|
_, err := conn.DB.Exec("CREATE TABLE IF NOT EXISTS packages (creator BLOB NOT NULL, name TEXT NOT NULL, path TEXT NOT NULL)")
|
|
if err != nil {
|
|
logFunc(err.Error(), 3, information)
|
|
}
|
|
// Create the secrets table
|
|
_, err = conn.DB.Exec("CREATE TABLE IF NOT EXISTS secrets (secret BLOB NOT NULL)")
|
|
if err != nil {
|
|
logFunc(err.Error(), 3, information)
|
|
}
|
|
// Create the users table
|
|
_, err = conn.DB.Exec("CREATE TABLE IF NOT EXISTS users (id BLOB NOT NULL)")
|
|
if err != nil {
|
|
logFunc(err.Error(), 3, information)
|
|
}
|
|
} else {
|
|
// Create the packages table
|
|
_, err := conn.DB.Exec("CREATE TABLE IF NOT EXISTS packages (creator BYTEA NOT NULL, name TEXT NOT NULL, path TEXT NOT NULL)")
|
|
if err != nil {
|
|
logFunc(err.Error(), 3, information)
|
|
}
|
|
// Create the secrets table
|
|
_, err = conn.DB.Exec("CREATE TABLE IF NOT EXISTS secrets (secret BYTEA NOT NULL)")
|
|
if err != nil {
|
|
logFunc(err.Error(), 3, information)
|
|
}
|
|
// Create the users table
|
|
_, err = conn.DB.Exec("CREATE TABLE IF NOT EXISTS users (id BYTEA NOT NULL)")
|
|
if err != nil {
|
|
logFunc(err.Error(), 3, information)
|
|
}
|
|
}
|
|
} else {
|
|
// This is an error message
|
|
// Log the error message to the logger service
|
|
logFunc(response.Message.(error).Error(), 3, information)
|
|
}
|
|
|
|
// Ask the authentication service for the public key
|
|
information.Outbox <- library.InterServiceMessage{
|
|
ServiceID: ServiceInformation.ServiceID,
|
|
ForServiceID: uuid.MustParse("00000000-0000-0000-0000-000000000004"), // Authentication service
|
|
MessageType: 2, // Request public key
|
|
SentAt: time.Now(),
|
|
Message: nil,
|
|
}
|
|
|
|
var publicKey ed25519.PublicKey = nil
|
|
|
|
// 3 second timeout
|
|
go func() {
|
|
time.Sleep(3 * time.Second)
|
|
if publicKey == nil {
|
|
logFunc("Timeout while waiting for the public key from the authentication service", 3, information)
|
|
}
|
|
}()
|
|
|
|
// Wait for the response
|
|
response = <-information.Inbox
|
|
if response.MessageType == 2 {
|
|
// This is the public key
|
|
publicKey = response.Message.(ed25519.PublicKey)
|
|
} else {
|
|
// This is an error message
|
|
// Log the error message to the logger service
|
|
logFunc(response.Message.(error).Error(), 3, information)
|
|
}
|
|
|
|
// Ask the authentication service to create a new OAuth2 client
|
|
urlPath, err := url.JoinPath(hostName, "/oauth")
|
|
if err != nil {
|
|
logFunc(err.Error(), 3, information)
|
|
}
|
|
|
|
information.Outbox <- library.InterServiceMessage{
|
|
ServiceID: ServiceInformation.ServiceID,
|
|
ForServiceID: uuid.MustParse("00000000-0000-0000-0000-000000000004"), // Authentication service
|
|
MessageType: 1, // Create OAuth2 client
|
|
SentAt: time.Now(),
|
|
Message: authLibrary.OAuthInformation{
|
|
Name: "Eternity Web",
|
|
RedirectUri: urlPath,
|
|
KeyShareUri: "",
|
|
Scopes: []string{"openid"},
|
|
},
|
|
}
|
|
|
|
oauthResponse := authLibrary.OAuthResponse{}
|
|
|
|
// 3 second timeout
|
|
go func() {
|
|
time.Sleep(3 * time.Second)
|
|
if oauthResponse == (authLibrary.OAuthResponse{}) {
|
|
logFunc("Timeout while waiting for the OAuth response from the authentication service", 3, information)
|
|
}
|
|
}()
|
|
|
|
// Wait for the response
|
|
response = <-information.Inbox
|
|
switch response.MessageType {
|
|
case 0:
|
|
// Success, set the OAuth response
|
|
oauthResponse = response.Message.(authLibrary.OAuthResponse)
|
|
logFunc("Initialized with App ID: "+oauthResponse.AppID, 0, information)
|
|
case 1:
|
|
// An error which is their fault
|
|
logFunc(response.Message.(error).Error(), 3, information)
|
|
case 2:
|
|
// An error which is our fault
|
|
logFunc(response.Message.(error).Error(), 3, information)
|
|
default:
|
|
// An unknown error
|
|
logFunc("Unknown error", 3, information)
|
|
}
|
|
|
|
// Set up the router
|
|
router := chi.NewRouter()
|
|
|
|
// Set up the static routes
|
|
staticDir, err := fs.Sub(information.ResourceDir, "static")
|
|
if err != nil {
|
|
logFunc(err.Error(), 3, information)
|
|
} else {
|
|
router.Handle("/static-eternity/*", http.StripPrefix("/static-eternity/", http.FileServerFS(staticDir)))
|
|
}
|
|
|
|
// Set up the API routes
|
|
router.Post("/api/packages/list", func(w http.ResponseWriter, r *http.Request) {
|
|
// Get the list of packages
|
|
rows, err := conn.DB.Query("SELECT name FROM packages")
|
|
if err != nil {
|
|
renderJSON(500, w, map[string]interface{}{"error": "Internal server error", "code": "01"}, information)
|
|
return
|
|
}
|
|
|
|
var packages []string
|
|
for rows.Next() {
|
|
var name string
|
|
err = rows.Scan(&name)
|
|
if err != nil {
|
|
renderJSON(500, w, map[string]interface{}{"error": "Internal server error", "code": "02"}, information)
|
|
return
|
|
}
|
|
packages = append(packages, name)
|
|
}
|
|
|
|
renderJSON(200, w, map[string]interface{}{
|
|
"packages": packages,
|
|
}, information)
|
|
})
|
|
|
|
router.Post("/api/packages/add", func(w http.ResponseWriter, r *http.Request) {
|
|
type packageData struct {
|
|
Name string `json:"name"`
|
|
RepositoryPath string `json:"repositoryPath"`
|
|
JwtToken string `json:"token"`
|
|
Secret string `json:"secret"`
|
|
}
|
|
var data packageData
|
|
err := json.NewDecoder(r.Body).Decode(&data)
|
|
if err != nil {
|
|
renderJSON(400, w, map[string]interface{}{"error": "Invalid JSON"}, information)
|
|
return
|
|
}
|
|
|
|
var claims jwt.MapClaims
|
|
if data.Secret != "" {
|
|
// Verify the secret
|
|
if !verifySecret(data.Secret, conn) {
|
|
renderJSON(400, w, map[string]interface{}{"error": "Invalid secret"}, information)
|
|
return
|
|
}
|
|
} else {
|
|
// Verify the JWT token
|
|
var ok bool
|
|
claims, ok = verifyJwt(data.JwtToken, publicKey, conn)
|
|
if !ok {
|
|
renderJSON(400, w, map[string]interface{}{"error": "Invalid JWT token"}, information)
|
|
return
|
|
}
|
|
}
|
|
|
|
// Fetch the Git repository
|
|
_, err = git.PlainClone(filepath.Join(gitDir, data.Name), false, &git.CloneOptions{
|
|
Depth: 1,
|
|
URL: data.RepositoryPath,
|
|
})
|
|
if err != nil {
|
|
renderJSON(400, w, map[string]interface{}{"error": "Invalid repository path"}, information)
|
|
return
|
|
}
|
|
|
|
// Add the package to the database
|
|
var userid []byte
|
|
if data.Secret != "" {
|
|
userid, err = uuid.MustParse("00000000-0000-0000-0000-000000000000").MarshalBinary()
|
|
if err != nil {
|
|
renderJSON(500, w, map[string]interface{}{"error": "Internal server error", "code": "03"}, information)
|
|
}
|
|
} else {
|
|
userid, err = uuid.MustParse(claims["sub"].(string)).MarshalBinary()
|
|
if err != nil {
|
|
renderJSON(500, w, map[string]interface{}{"error": "Internal server error", "code": "03"}, information)
|
|
}
|
|
}
|
|
|
|
_, err = conn.DB.Exec("INSERT INTO packages (creator, name, path) VALUES ($1, $2, $3)", userid, data.Name, data.RepositoryPath)
|
|
if err != nil {
|
|
renderJSON(500, w, map[string]interface{}{"error": "Internal server error", "code": "04"}, information)
|
|
return
|
|
}
|
|
|
|
renderJSON(200, w, map[string]interface{}{"success": true}, information)
|
|
})
|
|
|
|
router.Post("/api/packages/remove", func(w http.ResponseWriter, r *http.Request) {
|
|
type packageData struct {
|
|
Name string `json:"name"`
|
|
JwtToken string `json:"token"`
|
|
Secret string `json:"secret"`
|
|
}
|
|
var data packageData
|
|
err := json.NewDecoder(r.Body).Decode(&data)
|
|
if err != nil {
|
|
renderJSON(400, w, map[string]interface{}{"error": "Invalid JSON"}, information)
|
|
return
|
|
}
|
|
|
|
// Verify the JWT token
|
|
var claims jwt.MapClaims
|
|
if data.Secret != "" {
|
|
// Verify the secret
|
|
if !verifySecret(data.Secret, conn) {
|
|
renderJSON(400, w, map[string]interface{}{"error": "Invalid secret"}, information)
|
|
return
|
|
}
|
|
} else {
|
|
// Verify the JWT token
|
|
var ok bool
|
|
claims, ok = verifyJwt(data.JwtToken, publicKey, conn)
|
|
if !ok {
|
|
renderJSON(400, w, map[string]interface{}{"error": "Invalid JWT token"}, information)
|
|
return
|
|
}
|
|
}
|
|
|
|
// Remove the package from the database
|
|
var userid []byte
|
|
if data.Secret != "" {
|
|
userid, err = uuid.MustParse("00000000-0000-0000-0000-000000000000").MarshalBinary()
|
|
if err != nil {
|
|
renderJSON(500, w, map[string]interface{}{"error": "Internal server error", "code": "03"}, information)
|
|
}
|
|
} else {
|
|
userid, err = uuid.MustParse(claims["sub"].(string)).MarshalBinary()
|
|
if err != nil {
|
|
renderJSON(500, w, map[string]interface{}{"error": "Internal server error", "code": "03"}, information)
|
|
}
|
|
}
|
|
|
|
_, err = conn.DB.Exec("DELETE FROM packages WHERE creator = $1 AND name = $2", userid, data.Name)
|
|
if err != nil {
|
|
if errors.Is(err, sql.ErrNoRows) {
|
|
renderJSON(404, w, map[string]interface{}{"error": "Package not found"}, information)
|
|
return
|
|
} else {
|
|
renderJSON(500, w, map[string]interface{}{"error": "Internal server error", "code": "04"}, information)
|
|
return
|
|
}
|
|
}
|
|
|
|
// Remove the package from the filesystem
|
|
err = os.RemoveAll(filepath.Join(gitDir, data.Name))
|
|
if err != nil {
|
|
renderJSON(500, w, map[string]interface{}{"error": "Internal server error", "code": "05"}, information)
|
|
return
|
|
}
|
|
|
|
renderJSON(200, w, map[string]interface{}{"success": true}, information)
|
|
})
|
|
|
|
router.Post("/api/packages/get", func(w http.ResponseWriter, r *http.Request) {
|
|
type packageData struct {
|
|
Name string `json:"name"`
|
|
JwtToken string `json:"token"`
|
|
Secret string `json:"secret"`
|
|
}
|
|
var data packageData
|
|
err := json.NewDecoder(r.Body).Decode(&data)
|
|
if err != nil {
|
|
renderJSON(400, w, map[string]interface{}{"error": "Invalid JSON"}, information)
|
|
return
|
|
}
|
|
|
|
// Verify the JWT token
|
|
if data.Secret != "" {
|
|
// Verify the secret
|
|
if !verifySecret(data.Secret, conn) {
|
|
renderJSON(400, w, map[string]interface{}{"error": "Invalid secret"}, information)
|
|
return
|
|
}
|
|
} else {
|
|
// Verify the JWT token
|
|
var ok bool
|
|
_, ok = verifyJwt(data.JwtToken, publicKey, conn)
|
|
if !ok {
|
|
renderJSON(400, w, map[string]interface{}{"error": "Invalid JWT token"}, information)
|
|
return
|
|
}
|
|
}
|
|
|
|
var nameCheck string
|
|
err = conn.DB.QueryRow("SELECT name FROM packages WHERE name = $1", data.Name).Scan(&nameCheck)
|
|
if err != nil || nameCheck != data.Name {
|
|
if err != nil && errors.Is(err, sql.ErrNoRows) {
|
|
renderJSON(404, w, map[string]interface{}{"error": "Package not found"}, information)
|
|
return
|
|
} else {
|
|
renderJSON(500, w, map[string]interface{}{"error": "Internal server error", "code": "04"}, information)
|
|
return
|
|
}
|
|
}
|
|
|
|
// Get the package from the resource directory
|
|
packageEpk, err := os.ReadFile(filepath.Join(outputDir, "packages", data.Name+".epk"))
|
|
if err != nil {
|
|
renderJSON(500, w, map[string]interface{}{"error": "Internal server error", "code": "06"}, information)
|
|
return
|
|
}
|
|
|
|
w.Header().Set("Content-Type", "application/octet-stream")
|
|
w.WriteHeader(200)
|
|
_, err = w.Write(packageEpk)
|
|
if err != nil {
|
|
renderJSON(500, w, map[string]interface{}{"error": "Internal server error", "code": "07"}, information)
|
|
logFunc(err.Error(), 2, information)
|
|
}
|
|
})
|
|
|
|
router.Post("/api/packages/compile", func(w http.ResponseWriter, r *http.Request) {
|
|
type packageData struct {
|
|
Name string `json:"name"`
|
|
JwtToken string `json:"token"`
|
|
Secret string `json:"secret"`
|
|
PrivateKey string `json:"privateKey"`
|
|
}
|
|
var data packageData
|
|
err := json.NewDecoder(r.Body).Decode(&data)
|
|
if err != nil {
|
|
renderJSON(400, w, map[string]interface{}{"error": "Invalid JSON"}, information)
|
|
return
|
|
}
|
|
|
|
// Verify the JWT token
|
|
if data.Secret != "" {
|
|
// Verify the secret
|
|
if !verifySecret(data.Secret, conn) {
|
|
renderJSON(400, w, map[string]interface{}{"error": "Invalid secret"}, information)
|
|
return
|
|
}
|
|
} else {
|
|
// Verify the JWT token
|
|
var ok bool
|
|
_, ok = verifyJwt(data.JwtToken, publicKey, conn)
|
|
if !ok {
|
|
renderJSON(400, w, map[string]interface{}{"error": "Invalid JWT token"}, information)
|
|
return
|
|
}
|
|
}
|
|
|
|
// Fetch the package from the database
|
|
var nameCheck, path string
|
|
err = conn.DB.QueryRow("SELECT name, path FROM packages WHERE name = $1", data.Name).Scan(&nameCheck, &path)
|
|
if err != nil || nameCheck != data.Name {
|
|
if err != nil && errors.Is(err, sql.ErrNoRows) {
|
|
renderJSON(404, w, map[string]interface{}{"error": "Package not found"}, information)
|
|
return
|
|
} else {
|
|
renderJSON(500, w, map[string]interface{}{"error": "Internal server error", "code": "04"}, information)
|
|
return
|
|
}
|
|
}
|
|
|
|
// Decode the base64 private key
|
|
privateKeyBytes, err := base64.StdEncoding.DecodeString(data.PrivateKey)
|
|
if err != nil {
|
|
renderJSON(400, w, map[string]interface{}{"error": "Invalid private key"}, information)
|
|
return
|
|
}
|
|
|
|
// Compile the package
|
|
// I'm sure you all know how eternity works, so I'm not going to explain this
|
|
// If you don't, https://git.oreonproject.org/oreonproject/eternity, it's really cool!
|
|
err = os.Chdir(filepath.Join(gitDir, data.Name))
|
|
if err != nil {
|
|
renderJSON(500, w, map[string]interface{}{"error": "Internal server error", "code": "08"}, information)
|
|
return
|
|
}
|
|
|
|
var stdout bytes.Buffer
|
|
logger := &lib.Logger{
|
|
LogFunc: func(log lib.Log) string {
|
|
stdout.Write([]byte(log.Content))
|
|
if log.Level == "fatal" {
|
|
renderJSON(500, w, map[string]interface{}{"error": "Internal server error", "code": "09", "stdout": stdout.String()}, information)
|
|
}
|
|
return ""
|
|
},
|
|
PromptSupported: false,
|
|
StdoutSupported: true,
|
|
Stdout: &stdout,
|
|
}
|
|
|
|
config, err, vagueErr := lib.ParseConfig("eternity.json", logger)
|
|
if err != nil || vagueErr != nil {
|
|
common.EternityJsonHandleError(err, vagueErr, logger)
|
|
}
|
|
|
|
size, tempDir, err, vagueErr := lib.BuildEPK("./", false, config.Build, logger)
|
|
if err != nil || vagueErr != nil {
|
|
common.BuildEPKHandleError(tempDir, err, vagueErr, logger)
|
|
}
|
|
|
|
config.Metadata.DecompressedSize = size
|
|
|
|
err, vagueErr = lib.PackageEPK(config.Metadata, config.Build, tempDir, filepath.Join(outputDir, "packages", data.Name+".epk"), privateKeyBytes, logger)
|
|
if err != nil || vagueErr != nil {
|
|
common.PackageEPKHandleError(err, vagueErr, logger)
|
|
}
|
|
|
|
common.BuildEPKRemoveTemporaryDirectory(tempDir, logger)
|
|
renderJSON(200, w, map[string]interface{}{"success": true, "stdout": stdout.String()}, information)
|
|
})
|
|
|
|
// Set up the template routes
|
|
router.Get("/", func(w http.ResponseWriter, r *http.Request) {
|
|
renderTemplate(200, w, map[string]interface{}{}, "index.html", information)
|
|
})
|
|
|
|
router.Get("/packages", func(w http.ResponseWriter, r *http.Request) {
|
|
renderTemplate(200, w, map[string]interface{}{}, "packages.html", information)
|
|
})
|
|
|
|
router.Get("/oauth", func(w http.ResponseWriter, r *http.Request) {
|
|
renderTemplate(200, w, map[string]interface{}{
|
|
"ClientId": oauthResponse.AppID,
|
|
}, "oauth.html", information)
|
|
})
|
|
|
|
return router
|
|
}
|