Merge pull request #390 from urnetwork/api-key

adds api key support

Author: stuartwk

api/handlers/account_api_handlers.go

@@ -0,0 +1,21 @@
+package handlers
+
+import (
+	"net/http"
+
+	"github.com/urnetwork/server/controller"
+	"github.com/urnetwork/server/model"
+	"github.com/urnetwork/server/router"
+)
+
+func CreateApiKey(w http.ResponseWriter, r *http.Request) {
+	router.WrapWithInputRequireAuth(model.CreateApiKey, w, r)
+}
+
+func GetApiKeys(w http.ResponseWriter, r *http.Request) {
+	router.WrapRequireAuth(controller.GetApiKeys, w, r)
+}
+
+func DeleteApiKey(w http.ResponseWriter, r *http.Request) {
+	router.WrapWithInputRequireAuth(controller.DeleteApiKey, w, r)
+}

api/main.go

@@ -164,6 +164,9 @@ Options:
 		router.NewRoute("POST", "/device/set-provide", handlers.DeviceSetProvide),
 		router.NewRoute("POST", "/connect/control", handlers.ConnectControl),
 		router.NewRoute("GET", "/hello", handlers.Hello),
+		router.NewRoute("POST", "/account/api-key", handlers.CreateApiKey),
+		router.NewRoute("POST", "/account/api-key/remove", handlers.DeleteApiKey),
+		router.NewRoute("GET", "/account/api-keys", handlers.GetApiKeys),
 		router.NewRoute("POST", "/account/payout-wallet", handlers.SetPayoutWallet),
 		router.NewRoute("GET", "/account/payout-wallet", handlers.GetPayoutWallet),
 		router.NewRoute("POST", "/account/circle-wallet", handlers.CircleWebhook),

apikey/apikey.go

@@ -0,0 +1,108 @@
+package apikey
+
+import (
+	"context"
+	"crypto/rand"
+	"encoding/base32"
+	"fmt"
+
+	"github.com/urnetwork/server"
+)
+
+type NetworkByApiKey struct {
+	NetworkId   server.Id
+	UserId      server.Id
+	NetworkName string
+}
+
+func GetNetworkByApiKey(apiKey string, ctx context.Context) *NetworkByApiKey {
+	var result *NetworkByApiKey
+
+	server.Db(ctx, func(conn server.PgConn) {
+		rows, err := conn.Query(
+			ctx,
+			`
+				SELECT
+					network.network_id,
+					network.admin_user_id,
+					network.network_name
+				FROM account_api_key
+				JOIN network ON network.network_id = account_api_key.network_id
+				WHERE account_api_key.api_key = $1
+			`,
+			apiKey,
+		)
+
+		server.WithPgResult(rows, err, func() {
+			if rows.Next() {
+				var r NetworkByApiKey
+				server.RaisePgResult(rows.Scan(
+					&r.NetworkId,
+					&r.UserId,
+					&r.NetworkName,
+				), err)
+				result = &r
+			}
+		})
+	})
+
+	return result
+}
+
+type CreateApiKeyResult struct {
+	Id     server.Id `json:"id,omitempty"`
+	ApiKey string    `json:"api_key,omitempty"`
+}
+
+func Testing_CreateApiKey(networkId server.Id, ctx context.Context) (result *CreateApiKeyResult, err error) {
+	var apiKeyId server.Id
+	var apiKey string
+
+	server.Tx(ctx, func(tx server.PgTx) {
+		apiKeyId = server.NewId()
+
+		var keyErr error
+		apiKey, keyErr = generateApiKey()
+		if keyErr != nil {
+			err = keyErr
+			return
+		}
+
+		_, err = tx.Exec(
+			ctx,
+			`
+				INSERT INTO account_api_key
+				(
+					api_key_id,
+					network_id,
+					api_key,
+					name
+				)
+				VALUES ($1, $2, $3, $4)
+			`,
+			apiKeyId,
+			networkId,
+			apiKey,
+			"testkey",
+		)
+	})
+
+	if err != nil {
+		return nil, err
+	}
+
+	return &CreateApiKeyResult{
+		Id:     apiKeyId,
+		ApiKey: apiKey,
+	}, nil
+}
+
+// for testing
+func generateApiKey() (string, error) {
+	b := make([]byte, 32)
+	if _, err := rand.Read(b); err != nil {
+		return "", err
+	}
+	e := base32.HexEncoding.WithPadding(base32.NoPadding)
+	return fmt.Sprintf("urn_%s", e.EncodeToString(b)), nil
+}

apikey/apikey_test.go

@@ -0,0 +1,53 @@
+package apikey_test
+
+import (
+	"context"
+	"testing"
+
+	"github.com/go-playground/assert/v2"
+	"github.com/urnetwork/server"
+	"github.com/urnetwork/server/apikey"
+	"github.com/urnetwork/server/jwt"
+	"github.com/urnetwork/server/model"
+	"github.com/urnetwork/server/session"
+)
+
+func TestFetchNetworkByApiKey(t *testing.T) {
+	server.DefaultTestEnv().Run(func() {
+		server.DefaultTestEnv().Run(func() {
+
+			ctx := context.Background()
+
+			networkId := server.NewId()
+			userId := server.NewId()
+			networkName := "testnetwork"
+
+			model.Testing_CreateNetwork(ctx, networkId, networkName, userId)
+
+			clientId := server.NewId()
+			userSession := session.Testing_CreateClientSession(ctx, &jwt.ByJwt{
+				NetworkId: networkId,
+				ClientId:  &clientId,
+			})
+
+			// create some api keys
+			key, err := apikey.Testing_CreateApiKey(networkId, ctx)
+			assert.Equal(t, err, nil)
+
+			// fetch api key
+			network := apikey.GetNetworkByApiKey(key.ApiKey, ctx)
+			assert.NotEqual(t, network, nil)
+			assert.Equal(t, network.NetworkId, networkId)
+			assert.Equal(t, network.UserId, userId)
+			// assert.Equal(t, key1.ApiKeyId, key1Result.Id)
+
+			err = model.DeleteApiKey(&key.Id, userSession)
+			assert.Equal(t, err, nil)
+
+			// attempt fetch deleted api key
+			keyDeleted := apikey.GetNetworkByApiKey(key.ApiKey, ctx)
+			assert.Equal(t, keyDeleted, nil)
+
+		})
+	})
+}

controller/account_api_key_controller.go

@@ -0,0 +1,60 @@
+package controller
+
+import (
+	"github.com/urnetwork/glog"
+	"github.com/urnetwork/server"
+	"github.com/urnetwork/server/model"
+	"github.com/urnetwork/server/session"
+)
+
+type GetApiKeysError struct {
+	Message string `json:"message"`
+}
+
+type GetApiKeysResult struct {
+	ApiKeys []*model.PublicAccountApiKey `json:"api_keys"`
+	Error   *GetApiKeysError             `json:"error,omitempty"`
+}
+
+func GetApiKeys(session *session.ClientSession) (result *GetApiKeysResult, err error) {
+
+	keys, err := model.GetAccountApiKeys(session)
+	if err != nil {
+		glog.Info("Error getting account api keys", "error", err)
+		return &GetApiKeysResult{
+			Error: &GetApiKeysError{
+				Message: "Error getting account api keys",
+			},
+		}, nil
+	}
+
+	return &GetApiKeysResult{
+		ApiKeys: keys,
+	}, nil
+
+}
+
+type DeleteApiKeyError struct {
+	Message string `json:"message"`
+}
+
+type DeleteApiKeyResult struct {
+	Error *DeleteApiKeyError `json:"error,omitempty"`
+}
+
+type DeleteApiKeyArgs struct {
+	Id *server.Id `json:"id"`
+}
+
+func DeleteApiKey(deleteApiKey *DeleteApiKeyArgs, session *session.ClientSession) (*DeleteApiKeyResult, error) {
+	err := model.DeleteApiKey(deleteApiKey.Id, session)
+	if err != nil {
+		glog.Info("Error deleting api key: %s", err.Error())
+		return &DeleteApiKeyResult{
+			Error: &DeleteApiKeyError{
+				Message: "Error deleting api key",
+			},
+		}, nil
+	}
+	return &DeleteApiKeyResult{}, nil
+}

db_migrations.go

@@ -2722,7 +2722,7 @@ var migrations = []any{
             block varchar(128) NOT NULL,
             change_id bigint GENERATED ALWAYS AS IDENTITY,
             proxy_id uuid NOT NULL,
-            
+
             PRIMARY KEY (proxy_host, block, change_id)
         )
     `),
@@ -2731,7 +2731,7 @@ var migrations = []any{
         CREATE TABLE proxy_client_ipv4 (
             sequence_id bigint NOT NULL,
             client_ipv4 bigint NOT NULL,
-            
+
             PRIMARY KEY (sequence_id, client_ipv4)
         )
     `),
@@ -2759,4 +2759,20 @@ var migrations = []any{
 	newSqlMigration(`
         CREATE INDEX IF NOT EXISTS transfer_contract_payer_network_id ON transfer_contract (payer_network_id, open, contract_id)
     `),
+
+	newSqlMigration(`
+        CREATE TABLE account_api_key (
+            api_key_id uuid NOT NULL DEFAULT gen_random_uuid(),
+            network_id uuid NOT NULL,
+            api_key varchar(128) NOT NULL,
+            name varchar(128) NOT NULL DEFAULT '',
+            create_time timestamp NOT NULL DEFAULT now(),
+
+            PRIMARY KEY (api_key_id),
+            UNIQUE (api_key)
+        )
+    `),
+	newSqlMigration(`
+        CREATE INDEX account_api_key_network_id ON account_api_key (network_id, api_key_id)
+    `),
 }