change main get account method

2026-04-22 02:06:39 +00:00 · 2025-10-17 11:53:58 +02:00
parent 4cab69a76c
commit 7e51803a58
1 changed files with 218 additions and 34 deletions
--- a/management/server/store/sql_store.go
+++ b/management/server/store/sql_store.go
@@ -2,6 +2,7 @@ package store

 import (
 	"context"
+	"database/sql"
 	"encoding/json"
 	"errors"
 	"fmt"
@@ -817,12 +818,43 @@ func (s *SqlStore) GetAccount(ctx context.Context, accountID string) (*types.Acc
 		keys, err := pgx.CollectRows(rows, func(row pgx.CollectableRow) (types.SetupKey, error) {
 			var sk types.SetupKey
 			var autoGroups []byte
-			err := row.Scan(&sk.Id, &sk.AccountID, &sk.Key, &sk.KeySecret, &sk.Name, &sk.Type, &sk.CreatedAt, &sk.ExpiresAt, &sk.UpdatedAt, &sk.Revoked, &sk.UsedTimes, &sk.LastUsed, &autoGroups, &sk.UsageLimit, &sk.Ephemeral, &sk.AllowExtraDNSLabels)
-			if err == nil && autoGroups != nil {
-				_ = json.Unmarshal(autoGroups, &sk.AutoGroups)
-			}
-			if sk.UpdatedAt.IsZero() {
-				sk.UpdatedAt = sk.CreatedAt
+			var expiresAt, updatedAt, lastUsed sql.NullTime
+			var revoked, ephemeral, allowExtraDNSLabels sql.NullBool
+			var usedTimes, usageLimit sql.NullInt64
+
+			err := row.Scan(&sk.Id, &sk.AccountID, &sk.Key, &sk.KeySecret, &sk.Name, &sk.Type, &sk.CreatedAt, &expiresAt, &updatedAt, &revoked, &usedTimes, &lastUsed, &autoGroups, &usageLimit, &ephemeral, &allowExtraDNSLabels)
+
+			if err == nil {
+				if expiresAt.Valid {
+					sk.ExpiresAt = &expiresAt.Time
+				}
+				if updatedAt.Valid {
+					sk.UpdatedAt = updatedAt.Time
+					if sk.UpdatedAt.IsZero() {
+						sk.UpdatedAt = sk.CreatedAt
+					}
+				}
+				if lastUsed.Valid {
+					sk.LastUsed = &lastUsed.Time
+				}
+				if revoked.Valid {
+					sk.Revoked = revoked.Bool
+				}
+				if usedTimes.Valid {
+					sk.UsedTimes = int(usedTimes.Int64)
+				}
+				if usageLimit.Valid {
+					sk.UsageLimit = int(usageLimit.Int64)
+				}
+				if ephemeral.Valid {
+					sk.Ephemeral = ephemeral.Bool
+				}
+				if allowExtraDNSLabels.Valid {
+					sk.AllowExtraDNSLabels = allowExtraDNSLabels.Bool
+				}
+				if autoGroups != nil {
+					_ = json.Unmarshal(autoGroups, &sk.AutoGroups)
+				}
 			}
 			return sk, err
 		})
@@ -846,9 +878,46 @@ func (s *SqlStore) GetAccount(ctx context.Context, accountID string) (*types.Acc
 		peers, err := pgx.CollectRows(rows, func(row pgx.CollectableRow) (nbpeer.Peer, error) {
 			var p nbpeer.Peer
 			p.Status = &nbpeer.PeerStatus{}
+			var lastLogin sql.NullTime
+			var sshEnabled, loginExpirationEnabled, inactivityExpirationEnabled, ephemeral, allowExtraDNSLabels sql.NullBool
+			var peerStatusLastSeen sql.NullTime
+			var peerStatusConnected, peerStatusLoginExpired, peerStatusRequiresApproval sql.NullBool
 			var ip, extraDNS, netAddr, env, flags, files, connIP []byte
-			err := row.Scan(&p.ID, &p.AccountID, &p.Key, &ip, &p.Name, &p.DNSLabel, &p.UserID, &p.SSHKey, &p.SSHEnabled, &p.LoginExpirationEnabled, &p.InactivityExpirationEnabled, &p.LastLogin, &p.CreatedAt, &p.Ephemeral, &extraDNS, &p.AllowExtraDNSLabels, &p.Meta.Hostname, &p.Meta.GoOS, &p.Meta.Kernel, &p.Meta.Core, &p.Meta.Platform, &p.Meta.OS, &p.Meta.OSVersion, &p.Meta.WtVersion, &p.Meta.UIVersion, &p.Meta.KernelVersion, &netAddr, &p.Meta.SystemSerialNumber, &p.Meta.SystemProductName, &p.Meta.SystemManufacturer, &env, &flags, &files, &p.Status.LastSeen, &p.Status.Connected, &p.Status.LoginExpired, &p.Status.RequiresApproval, &connIP, &p.Location.CountryCode, &p.Location.CityName, &p.Location.GeoNameID)
+
+			err := row.Scan(&p.ID, &p.AccountID, &p.Key, &ip, &p.Name, &p.DNSLabel, &p.UserID, &p.SSHKey, &sshEnabled, &loginExpirationEnabled, &inactivityExpirationEnabled, &lastLogin, &p.CreatedAt, &ephemeral, &extraDNS, &allowExtraDNSLabels, &p.Meta.Hostname, &p.Meta.GoOS, &p.Meta.Kernel, &p.Meta.Core, &p.Meta.Platform, &p.Meta.OS, &p.Meta.OSVersion, &p.Meta.WtVersion, &p.Meta.UIVersion, &p.Meta.KernelVersion, &netAddr, &p.Meta.SystemSerialNumber, &p.Meta.SystemProductName, &p.Meta.SystemManufacturer, &env, &flags, &files, &peerStatusLastSeen, &peerStatusConnected, &peerStatusLoginExpired, &peerStatusRequiresApproval, &connIP, &p.Location.CountryCode, &p.Location.CityName, &p.Location.GeoNameID)
+
 			if err == nil {
+				if lastLogin.Valid {
+					p.LastLogin = &lastLogin.Time
+				}
+				if sshEnabled.Valid {
+					p.SSHEnabled = sshEnabled.Bool
+				}
+				if loginExpirationEnabled.Valid {
+					p.LoginExpirationEnabled = loginExpirationEnabled.Bool
+				}
+				if inactivityExpirationEnabled.Valid {
+					p.InactivityExpirationEnabled = inactivityExpirationEnabled.Bool
+				}
+				if ephemeral.Valid {
+					p.Ephemeral = ephemeral.Bool
+				}
+				if allowExtraDNSLabels.Valid {
+					p.AllowExtraDNSLabels = allowExtraDNSLabels.Bool
+				}
+				if peerStatusLastSeen.Valid {
+					p.Status.LastSeen = peerStatusLastSeen.Time
+				}
+				if peerStatusConnected.Valid {
+					p.Status.Connected = peerStatusConnected.Bool
+				}
+				if peerStatusLoginExpired.Valid {
+					p.Status.LoginExpired = peerStatusLoginExpired.Bool
+				}
+				if peerStatusRequiresApproval.Valid {
+					p.Status.RequiresApproval = peerStatusRequiresApproval.Bool
+				}
+
 				if ip != nil {
 					_ = json.Unmarshal(ip, &p.IP)
 				}
@@ -892,9 +961,28 @@ func (s *SqlStore) GetAccount(ctx context.Context, accountID string) (*types.Acc
 		users, err := pgx.CollectRows(rows, func(row pgx.CollectableRow) (types.User, error) {
 			var u types.User
 			var autoGroups []byte
-			err := row.Scan(&u.Id, &u.AccountID, &u.Role, &u.IsServiceUser, &u.NonDeletable, &u.ServiceUserName, &autoGroups, &u.Blocked, &u.PendingApproval, &u.LastLogin, &u.CreatedAt, &u.Issued, &u.IntegrationReference.ID, &u.IntegrationReference.IntegrationType)
-			if err == nil && autoGroups != nil {
-				_ = json.Unmarshal(autoGroups, &u.AutoGroups)
+			var lastLogin sql.NullTime
+			var isServiceUser, nonDeletable, blocked, pendingApproval sql.NullBool
+			err := row.Scan(&u.Id, &u.AccountID, &u.Role, &isServiceUser, &nonDeletable, &u.ServiceUserName, &autoGroups, &blocked, &pendingApproval, &lastLogin, &u.CreatedAt, &u.Issued, &u.IntegrationReference.ID, &u.IntegrationReference.IntegrationType)
+			if err == nil {
+				if lastLogin.Valid {
+					u.LastLogin = &lastLogin.Time
+				}
+				if isServiceUser.Valid {
+					u.IsServiceUser = isServiceUser.Bool
+				}
+				if nonDeletable.Valid {
+					u.NonDeletable = nonDeletable.Bool
+				}
+				if blocked.Valid {
+					u.Blocked = blocked.Bool
+				}
+				if pendingApproval.Valid {
+					u.PendingApproval = pendingApproval.Bool
+				}
+				if autoGroups != nil {
+					_ = json.Unmarshal(autoGroups, &u.AutoGroups)
+				}
 			}
 			return u, err
 		})
@@ -917,9 +1005,19 @@ func (s *SqlStore) GetAccount(ctx context.Context, accountID string) (*types.Acc
 		groups, err := pgx.CollectRows(rows, func(row pgx.CollectableRow) (*types.Group, error) {
 			var g types.Group
 			var resources []byte
-			err := row.Scan(&g.ID, &g.AccountID, &g.Name, &g.Issued, &resources, &g.IntegrationReference.ID, &g.IntegrationReference.IntegrationType)
-			if err == nil && resources != nil {
-				_ = json.Unmarshal(resources, &g.Resources)
+			var refID sql.NullInt64
+			var refType sql.NullString
+			err := row.Scan(&g.ID, &g.AccountID, &g.Name, &g.Issued, &resources, &refID, &refType)
+			if err == nil {
+				if refID.Valid {
+					g.IntegrationReference.ID = int(refID.Int64)
+				}
+				if refType.Valid {
+					g.IntegrationReference.IntegrationType = refType.String
+				}
+				if resources != nil {
+					_ = json.Unmarshal(resources, &g.Resources)
+				}
 			}
 			return &g, err
 		})
@@ -942,9 +1040,15 @@ func (s *SqlStore) GetAccount(ctx context.Context, accountID string) (*types.Acc
 		policies, err := pgx.CollectRows(rows, func(row pgx.CollectableRow) (*types.Policy, error) {
 			var p types.Policy
 			var checks []byte
-			err := row.Scan(&p.ID, &p.AccountID, &p.Name, &p.Description, &p.Enabled, &checks)
-			if err == nil && checks != nil {
-				_ = json.Unmarshal(checks, &p.SourcePostureChecks)
+			var enabled sql.NullBool
+			err := row.Scan(&p.ID, &p.AccountID, &p.Name, &p.Description, &enabled, &checks)
+			if err == nil {
+				if enabled.Valid {
+					p.Enabled = enabled.Bool
+				}
+				if checks != nil {
+					_ = json.Unmarshal(checks, &p.SourcePostureChecks)
+				}
 			}
 			return &p, err
 		})
@@ -967,8 +1071,25 @@ func (s *SqlStore) GetAccount(ctx context.Context, accountID string) (*types.Acc
 		routes, err := pgx.CollectRows(rows, func(row pgx.CollectableRow) (route.Route, error) {
 			var r route.Route
 			var network, domains, peerGroups, groups, accessGroups []byte
-			err := row.Scan(&r.ID, &r.AccountID, &network, &domains, &r.KeepRoute, &r.NetID, &r.Description, &r.Peer, &peerGroups, &r.NetworkType, &r.Masquerade, &r.Metric, &r.Enabled, &groups, &accessGroups, &r.SkipAutoApply)
+			var keepRoute, masquerade, enabled, skipAutoApply sql.NullBool
+			var metric sql.NullInt64
+			err := row.Scan(&r.ID, &r.AccountID, &network, &domains, &keepRoute, &r.NetID, &r.Description, &r.Peer, &peerGroups, &r.NetworkType, &masquerade, &metric, &enabled, &groups, &accessGroups, &skipAutoApply)
 			if err == nil {
+				if keepRoute.Valid {
+					r.KeepRoute = keepRoute.Bool
+				}
+				if masquerade.Valid {
+					r.Masquerade = masquerade.Bool
+				}
+				if enabled.Valid {
+					r.Enabled = enabled.Bool
+				}
+				if skipAutoApply.Valid {
+					r.SkipAutoApply = skipAutoApply.Bool
+				}
+				if metric.Valid {
+					r.Metric = int(metric.Int64)
+				}
 				if network != nil {
 					_ = json.Unmarshal(network, &r.Network)
 				}
@@ -1006,8 +1127,18 @@ func (s *SqlStore) GetAccount(ctx context.Context, accountID string) (*types.Acc
 		nsgs, err := pgx.CollectRows(rows, func(row pgx.CollectableRow) (nbdns.NameServerGroup, error) {
 			var n nbdns.NameServerGroup
 			var ns, groups, domains []byte
-			err := row.Scan(&n.ID, &n.AccountID, &n.Name, &n.Description, &ns, &groups, &n.Primary, &domains, &n.Enabled, &n.SearchDomainsEnabled)
+			var primary, enabled, searchDomainsEnabled sql.NullBool
+			err := row.Scan(&n.ID, &n.AccountID, &n.Name, &n.Description, &ns, &groups, &primary, &domains, &enabled, &searchDomainsEnabled)
 			if err == nil {
+				if primary.Valid {
+					n.Primary = primary.Bool
+				}
+				if enabled.Valid {
+					n.Enabled = enabled.Bool
+				}
+				if searchDomainsEnabled.Valid {
+					n.SearchDomainsEnabled = searchDomainsEnabled.Bool
+				}
 				if ns != nil {
 					_ = json.Unmarshal(ns, &n.NameServers)
 				}
@@ -1081,20 +1212,36 @@ func (s *SqlStore) GetAccount(ctx context.Context, accountID string) (*types.Acc
 			errChan <- err
 			return
 		}
-		routers, err := pgx.CollectRows(rows, func(row pgx.CollectableRow) (*routerTypes.NetworkRouter, error) {
+		routers, err := pgx.CollectRows(rows, func(row pgx.CollectableRow) (routerTypes.NetworkRouter, error) {
 			var r routerTypes.NetworkRouter
 			var peerGroups []byte
-			err := row.Scan(&r.ID, &r.NetworkID, &r.AccountID, &r.Peer, &peerGroups, &r.Masquerade, &r.Metric, &r.Enabled)
-			if err == nil && peerGroups != nil {
-				_ = json.Unmarshal(peerGroups, &r.PeerGroups)
+			var masquerade, enabled sql.NullBool
+			var metric sql.NullInt64
+			err := row.Scan(&r.ID, &r.NetworkID, &r.AccountID, &r.Peer, &peerGroups, &masquerade, &metric, &enabled)
+			if err == nil {
+				if masquerade.Valid {
+					r.Masquerade = masquerade.Bool
+				}
+				if enabled.Valid {
+					r.Enabled = enabled.Bool
+				}
+				if metric.Valid {
+					r.Metric = int(metric.Int64)
+				}
+				if peerGroups != nil {
+					_ = json.Unmarshal(peerGroups, &r.PeerGroups)
+				}
 			}
-			return &r, err
+			return r, err
 		})
 		if err != nil {
 			errChan <- err
 			return
 		}
-		account.NetworkRouters = routers
+		account.NetworkRouters = make([]*routerTypes.NetworkRouter, len(routers))
+		for i := range routers {
+			account.NetworkRouters[i] = &routers[i]
+		}
 	}()

 	wg.Add(1)
@@ -1106,35 +1253,52 @@ func (s *SqlStore) GetAccount(ctx context.Context, accountID string) (*types.Acc
 			errChan <- err
 			return
 		}
-		resources, err := pgx.CollectRows(rows, func(row pgx.CollectableRow) (*resourceTypes.NetworkResource, error) {
+		resources, err := pgx.CollectRows(rows, func(row pgx.CollectableRow) (resourceTypes.NetworkResource, error) {
 			var r resourceTypes.NetworkResource
 			var prefix []byte
-			err := row.Scan(&r.ID, &r.NetworkID, &r.AccountID, &r.Name, &r.Description, &r.Type, &r.Domain, &prefix, &r.Enabled)
-			if err == nil && prefix != nil {
-				_ = json.Unmarshal(prefix, &r.Prefix)
+			var enabled sql.NullBool
+			err := row.Scan(&r.ID, &r.NetworkID, &r.AccountID, &r.Name, &r.Description, &r.Type, &r.Domain, &prefix, &enabled)
+			if err == nil {
+				if enabled.Valid {
+					r.Enabled = enabled.Bool
+				}
+				if prefix != nil {
+					_ = json.Unmarshal(prefix, &r.Prefix)
+				}
 			}
-			return &r, err
+			return r, err
 		})
 		if err != nil {
 			errChan <- err
 			return
 		}
-		account.NetworkResources = resources
+		account.NetworkResources = make([]*resourceTypes.NetworkResource, len(resources))
+		for i := range resources {
+			account.NetworkResources[i] = &resources[i]
+		}
 	}()

 	wg.Add(1)
 	go func() {
 		defer wg.Done()
 		const query = `SELECT account_id, onboarding_flow_pending, signup_form_pending, created_at, updated_at FROM account_onboardings WHERE account_id = $1`
+		var onboardingFlowPending, signupFormPending sql.NullBool
 		err := s.pool.QueryRow(ctx, query, accountID).Scan(
 			&account.Onboarding.AccountID,
-			&account.Onboarding.OnboardingFlowPending,
-			&account.Onboarding.SignupFormPending,
+			&onboardingFlowPending,
+			&signupFormPending,
 			&account.Onboarding.CreatedAt,
 			&account.Onboarding.UpdatedAt,
 		)
 		if err != nil && !errors.Is(err, pgx.ErrNoRows) {
 			errChan <- err
+			return
+		}
+		if onboardingFlowPending.Valid {
+			account.Onboarding.OnboardingFlowPending = onboardingFlowPending.Bool
+		}
+		if signupFormPending.Valid {
+			account.Onboarding.SignupFormPending = signupFormPending.Bool
 		}
 	}()

@@ -1174,7 +1338,20 @@ func (s *SqlStore) GetAccount(ctx context.Context, accountID string) (*types.Acc
 			errChan <- err
 			return
 		}
-		pats, err = pgx.CollectRows(rows, pgx.RowToStructByName[types.PersonalAccessToken])
+		pats, err = pgx.CollectRows(rows, func(row pgx.CollectableRow) (types.PersonalAccessToken, error) {
+			var pat types.PersonalAccessToken
+			var expirationDate, lastUsed sql.NullTime
+			err := row.Scan(&pat.ID, &pat.UserID, &pat.Name, &pat.HashedToken, &expirationDate, &pat.CreatedBy, &pat.CreatedAt, &lastUsed)
+			if err == nil {
+				if expirationDate.Valid {
+					pat.ExpirationDate = &expirationDate.Time
+				}
+				if lastUsed.Valid {
+					pat.LastUsed = &lastUsed.Time
+				}
+			}
+			return pat, err
+		})
 		if err != nil {
 			errChan <- err
 		}
@@ -1195,8 +1372,15 @@ func (s *SqlStore) GetAccount(ctx context.Context, accountID string) (*types.Acc
 		rules, err = pgx.CollectRows(rows, func(row pgx.CollectableRow) (*types.PolicyRule, error) {
 			var r types.PolicyRule
 			var dest, destRes, sources, sourceRes, ports, portRanges []byte
-			err := row.Scan(&r.ID, &r.PolicyID, &r.Name, &r.Description, &r.Enabled, &r.Action, &dest, &destRes, &sources, &sourceRes, &r.Bidirectional, &r.Protocol, &ports, &portRanges)
+			var enabled, bidirectional sql.NullBool
+			err := row.Scan(&r.ID, &r.PolicyID, &r.Name, &r.Description, &enabled, &r.Action, &dest, &destRes, &sources, &sourceRes, &bidirectional, &r.Protocol, &ports, &portRanges)
 			if err == nil {
+				if enabled.Valid {
+					r.Enabled = enabled.Bool
+				}
+				if bidirectional.Valid {
+					r.Bidirectional = bidirectional.Bool
+				}
 				if dest != nil {
 					_ = json.Unmarshal(dest, &r.Destinations)
 				}