142 lines
5.3 KiB
Go
142 lines
5.3 KiB
Go
package staterpc
|
|
|
|
import (
|
|
"context"
|
|
|
|
"google.golang.org/grpc/codes"
|
|
"google.golang.org/grpc/status"
|
|
|
|
pb "github.com/samcharles93/archie-core/internal/contracts/state/v1"
|
|
"github.com/samcharles93/archie-core/internal/domain/identity"
|
|
)
|
|
|
|
func authenticationProto(v identity.AuthenticationSettings) *pb.AuthenticationSettings {
|
|
return &pb.AuthenticationSettings{PublicUrl: v.PublicURL, OidcIssuer: v.OIDCIssuer, OidcAudience: v.OIDCAudience, OidcClientId: v.OIDCClientID}
|
|
}
|
|
|
|
func authenticationValue(v *pb.AuthenticationSettings) identity.AuthenticationSettings {
|
|
return identity.AuthenticationSettings{PublicURL: v.GetPublicUrl(), OIDCIssuer: v.GetOidcIssuer(), OIDCAudience: v.GetOidcAudience(), OIDCClientID: v.GetOidcClientId()}
|
|
}
|
|
|
|
func (s *server) GetAuthenticationSettings(ctx context.Context, _ *pb.GetAuthenticationSettingsRequest) (*pb.GetAuthenticationSettingsResponse, error) {
|
|
store, ok := s.deps.Accounts.(identity.AuthenticationSettingsStore)
|
|
if !ok {
|
|
return nil, status.Error(codes.Unavailable, "authentication settings unavailable")
|
|
}
|
|
value, err := store.AuthenticationSettings(ctx)
|
|
if err != nil {
|
|
return nil, accountStatus(err)
|
|
}
|
|
return &pb.GetAuthenticationSettingsResponse{Settings: authenticationProto(value)}, nil
|
|
}
|
|
|
|
func (s *server) SaveAuthenticationSettings(ctx context.Context, r *pb.SaveAuthenticationSettingsRequest) (*pb.SaveAuthenticationSettingsResponse, error) {
|
|
store, ok := s.deps.Accounts.(identity.AuthenticationSettingsStore)
|
|
if !ok {
|
|
return nil, status.Error(codes.Unavailable, "authentication settings unavailable")
|
|
}
|
|
return &pb.SaveAuthenticationSettingsResponse{}, accountStatus(store.SaveAuthenticationSettings(ctx, authenticationValue(r.Settings)))
|
|
}
|
|
|
|
func (c *Client) AuthenticationSettings(ctx context.Context) (identity.AuthenticationSettings, error) {
|
|
r, err := c.client.GetAuthenticationSettings(ctx, &pb.GetAuthenticationSettingsRequest{})
|
|
if err != nil {
|
|
return identity.AuthenticationSettings{}, accountClientError(err)
|
|
}
|
|
return authenticationValue(r.Settings), nil
|
|
}
|
|
|
|
func (c *Client) SaveAuthenticationSettings(ctx context.Context, v identity.AuthenticationSettings) error {
|
|
_, err := c.client.SaveAuthenticationSettings(ctx, &pb.SaveAuthenticationSettingsRequest{Settings: authenticationProto(v)})
|
|
return accountClientError(err)
|
|
}
|
|
|
|
func (s *server) passkeyStore() (identity.Passkeys, error) {
|
|
v, ok := s.deps.Accounts.(identity.Passkeys)
|
|
if !ok {
|
|
return nil, status.Error(codes.Unavailable, "passkeys unavailable")
|
|
}
|
|
return v, nil
|
|
}
|
|
|
|
func (s *server) BeginPasskey(ctx context.Context, r *pb.BeginPasskeyRequest) (*pb.BeginPasskeyResponse, error) {
|
|
store, err := s.passkeyStore()
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
value, err := store.BeginPasskey(ctx, r.Registration)
|
|
if err != nil {
|
|
return nil, accountStatus(err)
|
|
}
|
|
return &pb.BeginPasskeyResponse{Token: value.Token, Options: value.Options}, nil
|
|
}
|
|
|
|
func (s *server) FinishPasskey(ctx context.Context, r *pb.FinishPasskeyRequest) (*pb.FinishPasskeyResponse, error) {
|
|
store, err := s.passkeyStore()
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
value, err := store.FinishPasskey(ctx, r.Token, r.Credential, r.Registration, r.Name)
|
|
if err != nil {
|
|
return nil, accountStatus(err)
|
|
}
|
|
return &pb.FinishPasskeyResponse{Identity: identityProto(value.Identity), Token: value.Token, ExpiresAt: timestamp(value.Expires)}, nil
|
|
}
|
|
|
|
func (s *server) ListPasskeys(ctx context.Context, _ *pb.ListPasskeysRequest) (*pb.ListPasskeysResponse, error) {
|
|
store, err := s.passkeyStore()
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
values, err := store.ListPasskeys(ctx)
|
|
if err != nil {
|
|
return nil, accountStatus(err)
|
|
}
|
|
out := &pb.ListPasskeysResponse{}
|
|
for _, value := range values {
|
|
out.Passkeys = append(out.Passkeys, &pb.Passkey{Id: value.ID, Name: value.Name})
|
|
}
|
|
return out, nil
|
|
}
|
|
|
|
func (s *server) DeletePasskey(ctx context.Context, r *pb.DeletePasskeyRequest) (*pb.DeletePasskeyResponse, error) {
|
|
store, err := s.passkeyStore()
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
return &pb.DeletePasskeyResponse{}, accountStatus(store.DeletePasskey(ctx, r.Id))
|
|
}
|
|
|
|
func (c *Client) BeginPasskey(ctx context.Context, registration bool) (identity.PasskeyCeremony, error) {
|
|
r, err := c.client.BeginPasskey(ctx, &pb.BeginPasskeyRequest{Registration: registration})
|
|
if err != nil {
|
|
return identity.PasskeyCeremony{}, accountClientError(err)
|
|
}
|
|
return identity.PasskeyCeremony{Token: r.Token, Options: r.Options}, nil
|
|
}
|
|
|
|
func (c *Client) FinishPasskey(ctx context.Context, token string, credential []byte, registration bool, name string) (identity.AccountSession, error) {
|
|
r, err := c.client.FinishPasskey(ctx, &pb.FinishPasskeyRequest{Token: token, Credential: credential, Registration: registration, Name: name})
|
|
if err != nil {
|
|
return identity.AccountSession{}, accountClientError(err)
|
|
}
|
|
return identity.AccountSession{Identity: identityValue(r.Identity), Token: r.Token, Expires: timeValue(r.ExpiresAt)}, nil
|
|
}
|
|
|
|
func (c *Client) ListPasskeys(ctx context.Context) ([]identity.Passkey, error) {
|
|
r, err := c.client.ListPasskeys(ctx, &pb.ListPasskeysRequest{})
|
|
if err != nil {
|
|
return nil, accountClientError(err)
|
|
}
|
|
out := []identity.Passkey{}
|
|
for _, v := range r.Passkeys {
|
|
out = append(out, identity.Passkey{ID: v.Id, Name: v.Name})
|
|
}
|
|
return out, nil
|
|
}
|
|
|
|
func (c *Client) DeletePasskey(ctx context.Context, id string) error {
|
|
_, err := c.client.DeletePasskey(ctx, &pb.DeletePasskeyRequest{Id: id})
|
|
return accountClientError(err)
|
|
}
|