123 lines
3.7 KiB
Go
123 lines
3.7 KiB
Go
package webui
|
|
|
|
import (
|
|
"context"
|
|
"crypto/rand"
|
|
"encoding/hex"
|
|
"errors"
|
|
"net/http"
|
|
"strings"
|
|
|
|
"github.com/samcharles93/archie-core/internal/domain/access"
|
|
"github.com/samcharles93/archie-core/internal/domain/identity"
|
|
"github.com/samcharles93/archie-core/internal/domain/org"
|
|
)
|
|
|
|
type identityRequest struct {
|
|
DisplayName string `json:"display_name"`
|
|
Kind identity.Kind `json:"kind"`
|
|
ExpectedVersion int64 `json:"expected_version"`
|
|
}
|
|
|
|
func (s *Server) handleIdentitiesList(w http.ResponseWriter, r *http.Request) {
|
|
if s.Identities == nil {
|
|
http.Error(w, "identity store unavailable", http.StatusServiceUnavailable)
|
|
return
|
|
}
|
|
values, err := s.Identities.List(r.Context())
|
|
if err != nil {
|
|
writeIdentityError(w, err)
|
|
return
|
|
}
|
|
if values == nil {
|
|
values = []identity.Identity{}
|
|
}
|
|
writeJSON(w, map[string]any{"identities": values})
|
|
}
|
|
|
|
func (s *Server) handleIdentityCreate(w http.ResponseWriter, r *http.Request) {
|
|
request, ok := decodeBody[identityRequest](w, r)
|
|
if !ok {
|
|
return
|
|
}
|
|
id, err := randomIdentityID()
|
|
if err != nil {
|
|
http.Error(w, "cannot create identity ID", http.StatusInternalServerError)
|
|
return
|
|
}
|
|
audit, err := webAudit(r.Context())
|
|
if err != nil {
|
|
http.Error(w, "cannot create request ID", http.StatusInternalServerError)
|
|
return
|
|
}
|
|
value, err := identity.New(id, request.Kind, request.DisplayName)
|
|
if err == nil {
|
|
value, err = s.Identities.Create(r.Context(), value, audit)
|
|
}
|
|
if err != nil {
|
|
writeIdentityError(w, err)
|
|
return
|
|
}
|
|
w.WriteHeader(http.StatusCreated)
|
|
writeJSON(w, value)
|
|
}
|
|
|
|
func (s *Server) handleIdentityCommand(w http.ResponseWriter, r *http.Request) {
|
|
request, ok := decodeBody[identityRequest](w, r)
|
|
if !ok {
|
|
return
|
|
}
|
|
audit, err := webAudit(r.Context())
|
|
if err != nil {
|
|
http.Error(w, "cannot create request ID", http.StatusInternalServerError)
|
|
return
|
|
}
|
|
command := identity.Command{Type: identity.CommandType(r.PathValue("command")), DisplayName: request.DisplayName}
|
|
value, err := s.Identities.Apply(r.Context(), identity.IdentityID(r.PathValue("id")), request.ExpectedVersion, command, audit)
|
|
if err != nil {
|
|
writeIdentityError(w, err)
|
|
return
|
|
}
|
|
writeJSON(w, value)
|
|
}
|
|
|
|
// webAudit attributes a dashboard write to the request's own principal: the
|
|
// person the dashboard acts as. Only a request with no principal at all falls
|
|
// back to the System identity, which is a real identity the repository
|
|
// resolves, never a name the request could claim for itself.
|
|
func webAudit(ctx context.Context) (identity.Audit, error) {
|
|
id, err := newControlPlaneRequestID()
|
|
if err != nil {
|
|
return identity.Audit{}, err
|
|
}
|
|
actor := identity.SystemID
|
|
if p, ok := access.PrincipalFromContext(ctx); ok && p.IdentityID != "" {
|
|
actor = p.IdentityID
|
|
}
|
|
return identity.Audit{ActorID: actor, Source: "archie-ui", RequestID: id}, nil
|
|
}
|
|
|
|
func randomIdentityID() (identity.IdentityID, error) {
|
|
var value [16]byte
|
|
if _, err := rand.Read(value[:]); err != nil {
|
|
return "", err
|
|
}
|
|
value[6] = value[6]&0x0f | 0x40
|
|
value[8] = value[8]&0x3f | 0x80
|
|
encoded := hex.EncodeToString(value[:])
|
|
return identity.IdentityID(encoded[:8] + "-" + encoded[8:12] + "-" + encoded[12:16] + "-" + encoded[16:20] + "-" + encoded[20:]), nil
|
|
}
|
|
|
|
func writeIdentityError(w http.ResponseWriter, err error) {
|
|
code := http.StatusInternalServerError
|
|
switch {
|
|
case errors.Is(err, identity.ErrNotFound):
|
|
code = http.StatusNotFound
|
|
case errors.Is(err, identity.ErrConflict), errors.Is(err, org.ErrLastOwner):
|
|
code = http.StatusConflict
|
|
case errors.Is(err, identity.ErrInvalid), errors.Is(err, identity.ErrIllegalTransition), errors.Is(err, identity.ErrSystemImmutable):
|
|
code = http.StatusBadRequest
|
|
}
|
|
http.Error(w, strings.TrimSpace(err.Error()), code)
|
|
}
|