1
0
mirror of https://github.com/zitadel/zitadel.git synced 2024-12-14 20:08:02 +00:00
zitadel/internal/repository/org/idp.go
Livio Spring e57a9b57c8
feat(saml): allow setting nameid-format and alternative mapping for transient format ()
# Which Problems Are Solved

ZITADEL currently always uses
`urn:oasis:names:tc:SAML:2.0:nameid-format:persistent` in SAML requests,
relying on the IdP to respect that flag and always return a peristent
nameid in order to be able to map the external user with an existing
user (idp link) in ZITADEL.
In case the IdP however returns a
`urn:oasis:names:tc:SAML:2.0:nameid-format:transient` (transient)
nameid, the attribute will differ between each request and it will not
be possible to match existing users.

# How the Problems Are Solved

This PR adds the following two options on SAML IdP:
- **nameIDFormat**: allows to set the nameid-format used in the SAML
Request
- **transientMappingAttributeName**: allows to set an attribute name,
which will be used instead of the nameid itself in case the returned
nameid-format is transient

# Additional Changes

To reduce impact on current installations, the `idp_templates6_saml`
table is altered with the two added columns by a setup job. New
installations will automatically get the table with the two columns
directly.
All idp unit tests are updated to use `expectEventstore` instead of the
deprecated `eventstoreExpect`.

# Additional Context

Closes 
Closes 

---------

Co-authored-by: peintnermax <max@caos.ch>
Co-authored-by: Stefan Benz <46600784+stebenz@users.noreply.github.com>
2024-05-23 05:04:07 +00:00

1123 lines
24 KiB
Go

package org
import (
"context"
"time"
"github.com/zitadel/zitadel/internal/crypto"
"github.com/zitadel/zitadel/internal/domain"
"github.com/zitadel/zitadel/internal/eventstore"
"github.com/zitadel/zitadel/internal/repository/idp"
)
const (
OAuthIDPAddedEventType eventstore.EventType = "org.idp.oauth.added"
OAuthIDPChangedEventType eventstore.EventType = "org.idp.oauth.changed"
OIDCIDPAddedEventType eventstore.EventType = "org.idp.oidc.added"
OIDCIDPChangedEventType eventstore.EventType = "org.idp.oidc.changed"
OIDCIDPMigratedAzureADEventType eventstore.EventType = "org.idp.oidc.migrated.azure"
OIDCIDPMigratedGoogleEventType eventstore.EventType = "org.idp.oidc.migrated.google"
JWTIDPAddedEventType eventstore.EventType = "org.idp.jwt.added"
JWTIDPChangedEventType eventstore.EventType = "org.idp.jwt.changed"
AzureADIDPAddedEventType eventstore.EventType = "org.idp.azure.added"
AzureADIDPChangedEventType eventstore.EventType = "org.idp.azure.changed"
GitHubIDPAddedEventType eventstore.EventType = "org.idp.github.added"
GitHubIDPChangedEventType eventstore.EventType = "org.idp.github.changed"
GitHubEnterpriseIDPAddedEventType eventstore.EventType = "org.idp.github_enterprise.added"
GitHubEnterpriseIDPChangedEventType eventstore.EventType = "org.idp.github_enterprise.changed"
GitLabIDPAddedEventType eventstore.EventType = "org.idp.gitlab.added"
GitLabIDPChangedEventType eventstore.EventType = "org.idp.gitlab.changed"
GitLabSelfHostedIDPAddedEventType eventstore.EventType = "org.idp.gitlab_self_hosted.added"
GitLabSelfHostedIDPChangedEventType eventstore.EventType = "org.idp.gitlab_self_hosted.changed"
GoogleIDPAddedEventType eventstore.EventType = "org.idp.google.added"
GoogleIDPChangedEventType eventstore.EventType = "org.idp.google.changed"
LDAPIDPAddedEventType eventstore.EventType = "org.idp.ldap.added"
LDAPIDPChangedEventType eventstore.EventType = "org.idp.ldap.changed"
AppleIDPAddedEventType eventstore.EventType = "org.idp.apple.added"
AppleIDPChangedEventType eventstore.EventType = "org.idp.apple.changed"
SAMLIDPAddedEventType eventstore.EventType = "org.idp.saml.added"
SAMLIDPChangedEventType eventstore.EventType = "org.idp.saml.changed"
IDPRemovedEventType eventstore.EventType = "org.idp.removed"
)
type OAuthIDPAddedEvent struct {
idp.OAuthIDPAddedEvent
}
func NewOAuthIDPAddedEvent(
ctx context.Context,
aggregate *eventstore.Aggregate,
id,
name,
clientID string,
clientSecret *crypto.CryptoValue,
authorizationEndpoint,
tokenEndpoint,
userEndpoint,
idAttribute string,
scopes []string,
options idp.Options,
) *OAuthIDPAddedEvent {
return &OAuthIDPAddedEvent{
OAuthIDPAddedEvent: *idp.NewOAuthIDPAddedEvent(
eventstore.NewBaseEventForPush(
ctx,
aggregate,
OAuthIDPAddedEventType,
),
id,
name,
clientID,
clientSecret,
authorizationEndpoint,
tokenEndpoint,
userEndpoint,
idAttribute,
scopes,
options,
),
}
}
func OAuthIDPAddedEventMapper(event eventstore.Event) (eventstore.Event, error) {
e, err := idp.OAuthIDPAddedEventMapper(event)
if err != nil {
return nil, err
}
return &OAuthIDPAddedEvent{OAuthIDPAddedEvent: *e.(*idp.OAuthIDPAddedEvent)}, nil
}
type OAuthIDPChangedEvent struct {
idp.OAuthIDPChangedEvent
}
func NewOAuthIDPChangedEvent(
ctx context.Context,
aggregate *eventstore.Aggregate,
id string,
changes []idp.OAuthIDPChanges,
) (*OAuthIDPChangedEvent, error) {
changedEvent, err := idp.NewOAuthIDPChangedEvent(
eventstore.NewBaseEventForPush(
ctx,
aggregate,
OAuthIDPChangedEventType,
),
id,
changes,
)
if err != nil {
return nil, err
}
return &OAuthIDPChangedEvent{OAuthIDPChangedEvent: *changedEvent}, nil
}
func OAuthIDPChangedEventMapper(event eventstore.Event) (eventstore.Event, error) {
e, err := idp.OAuthIDPChangedEventMapper(event)
if err != nil {
return nil, err
}
return &OAuthIDPChangedEvent{OAuthIDPChangedEvent: *e.(*idp.OAuthIDPChangedEvent)}, nil
}
type OIDCIDPAddedEvent struct {
idp.OIDCIDPAddedEvent
}
func NewOIDCIDPAddedEvent(
ctx context.Context,
aggregate *eventstore.Aggregate,
id,
name,
issuer,
clientID string,
clientSecret *crypto.CryptoValue,
scopes []string,
isIDTokenMapping bool,
options idp.Options,
) *OIDCIDPAddedEvent {
return &OIDCIDPAddedEvent{
OIDCIDPAddedEvent: *idp.NewOIDCIDPAddedEvent(
eventstore.NewBaseEventForPush(
ctx,
aggregate,
OIDCIDPAddedEventType,
),
id,
name,
issuer,
clientID,
clientSecret,
scopes,
isIDTokenMapping,
options,
),
}
}
func OIDCIDPAddedEventMapper(event eventstore.Event) (eventstore.Event, error) {
e, err := idp.OIDCIDPAddedEventMapper(event)
if err != nil {
return nil, err
}
return &OIDCIDPAddedEvent{OIDCIDPAddedEvent: *e.(*idp.OIDCIDPAddedEvent)}, nil
}
type OIDCIDPChangedEvent struct {
idp.OIDCIDPChangedEvent
}
func NewOIDCIDPChangedEvent(
ctx context.Context,
aggregate *eventstore.Aggregate,
id string,
changes []idp.OIDCIDPChanges,
) (*OIDCIDPChangedEvent, error) {
changedEvent, err := idp.NewOIDCIDPChangedEvent(
eventstore.NewBaseEventForPush(
ctx,
aggregate,
OIDCIDPChangedEventType,
),
id,
changes,
)
if err != nil {
return nil, err
}
return &OIDCIDPChangedEvent{OIDCIDPChangedEvent: *changedEvent}, nil
}
func OIDCIDPChangedEventMapper(event eventstore.Event) (eventstore.Event, error) {
e, err := idp.OIDCIDPChangedEventMapper(event)
if err != nil {
return nil, err
}
return &OIDCIDPChangedEvent{OIDCIDPChangedEvent: *e.(*idp.OIDCIDPChangedEvent)}, nil
}
type OIDCIDPMigratedAzureADEvent struct {
idp.OIDCIDPMigratedAzureADEvent
}
func NewOIDCIDPMigratedAzureADEvent(
ctx context.Context,
aggregate *eventstore.Aggregate,
id,
name,
clientID string,
clientSecret *crypto.CryptoValue,
scopes []string,
tenant string,
isEmailVerified bool,
options idp.Options,
) *OIDCIDPMigratedAzureADEvent {
return &OIDCIDPMigratedAzureADEvent{
OIDCIDPMigratedAzureADEvent: *idp.NewOIDCIDPMigratedAzureADEvent(
eventstore.NewBaseEventForPush(
ctx,
aggregate,
OIDCIDPMigratedAzureADEventType,
),
id,
name,
clientID,
clientSecret,
scopes,
tenant,
isEmailVerified,
options,
),
}
}
func OIDCIDPMigratedAzureADEventMapper(event eventstore.Event) (eventstore.Event, error) {
e, err := idp.OIDCIDPMigratedAzureADEventMapper(event)
if err != nil {
return nil, err
}
return &OIDCIDPMigratedAzureADEvent{OIDCIDPMigratedAzureADEvent: *e.(*idp.OIDCIDPMigratedAzureADEvent)}, nil
}
type OIDCIDPMigratedGoogleEvent struct {
idp.OIDCIDPMigratedGoogleEvent
}
func NewOIDCIDPMigratedGoogleEvent(
ctx context.Context,
aggregate *eventstore.Aggregate,
id,
name,
clientID string,
clientSecret *crypto.CryptoValue,
scopes []string,
options idp.Options,
) *OIDCIDPMigratedGoogleEvent {
return &OIDCIDPMigratedGoogleEvent{
OIDCIDPMigratedGoogleEvent: *idp.NewOIDCIDPMigratedGoogleEvent(
eventstore.NewBaseEventForPush(
ctx,
aggregate,
OIDCIDPMigratedGoogleEventType,
),
id,
name,
clientID,
clientSecret,
scopes,
options,
),
}
}
func OIDCIDPMigratedGoogleEventMapper(event eventstore.Event) (eventstore.Event, error) {
e, err := idp.OIDCIDPMigratedGoogleEventMapper(event)
if err != nil {
return nil, err
}
return &OIDCIDPMigratedGoogleEvent{OIDCIDPMigratedGoogleEvent: *e.(*idp.OIDCIDPMigratedGoogleEvent)}, nil
}
type JWTIDPAddedEvent struct {
idp.JWTIDPAddedEvent
}
func NewJWTIDPAddedEvent(
ctx context.Context,
aggregate *eventstore.Aggregate,
id,
name,
issuer,
jwtEndpoint,
keysEndpoint,
headerName string,
options idp.Options,
) *JWTIDPAddedEvent {
return &JWTIDPAddedEvent{
JWTIDPAddedEvent: *idp.NewJWTIDPAddedEvent(
eventstore.NewBaseEventForPush(
ctx,
aggregate,
JWTIDPAddedEventType,
),
id,
name,
issuer,
jwtEndpoint,
keysEndpoint,
headerName,
options,
),
}
}
func JWTIDPAddedEventMapper(event eventstore.Event) (eventstore.Event, error) {
e, err := idp.JWTIDPAddedEventMapper(event)
if err != nil {
return nil, err
}
return &JWTIDPAddedEvent{JWTIDPAddedEvent: *e.(*idp.JWTIDPAddedEvent)}, nil
}
type JWTIDPChangedEvent struct {
idp.JWTIDPChangedEvent
}
func NewJWTIDPChangedEvent(
ctx context.Context,
aggregate *eventstore.Aggregate,
id string,
changes []idp.JWTIDPChanges,
) (*JWTIDPChangedEvent, error) {
changedEvent, err := idp.NewJWTIDPChangedEvent(
eventstore.NewBaseEventForPush(
ctx,
aggregate,
JWTIDPChangedEventType,
),
id,
changes,
)
if err != nil {
return nil, err
}
return &JWTIDPChangedEvent{JWTIDPChangedEvent: *changedEvent}, nil
}
func JWTIDPChangedEventMapper(event eventstore.Event) (eventstore.Event, error) {
e, err := idp.JWTIDPChangedEventMapper(event)
if err != nil {
return nil, err
}
return &JWTIDPChangedEvent{JWTIDPChangedEvent: *e.(*idp.JWTIDPChangedEvent)}, nil
}
type AzureADIDPAddedEvent struct {
idp.AzureADIDPAddedEvent
}
func NewAzureADIDPAddedEvent(
ctx context.Context,
aggregate *eventstore.Aggregate,
id,
name,
clientID string,
clientSecret *crypto.CryptoValue,
scopes []string,
tenant string,
isEmailVerified bool,
options idp.Options,
) *AzureADIDPAddedEvent {
return &AzureADIDPAddedEvent{
AzureADIDPAddedEvent: *idp.NewAzureADIDPAddedEvent(
eventstore.NewBaseEventForPush(
ctx,
aggregate,
AzureADIDPAddedEventType,
),
id,
name,
clientID,
clientSecret,
scopes,
tenant,
isEmailVerified,
options,
),
}
}
func AzureADIDPAddedEventMapper(event eventstore.Event) (eventstore.Event, error) {
e, err := idp.AzureADIDPAddedEventMapper(event)
if err != nil {
return nil, err
}
return &AzureADIDPAddedEvent{AzureADIDPAddedEvent: *e.(*idp.AzureADIDPAddedEvent)}, nil
}
type AzureADIDPChangedEvent struct {
idp.AzureADIDPChangedEvent
}
func NewAzureADIDPChangedEvent(
ctx context.Context,
aggregate *eventstore.Aggregate,
id string,
changes []idp.AzureADIDPChanges,
) (*AzureADIDPChangedEvent, error) {
changedEvent, err := idp.NewAzureADIDPChangedEvent(
eventstore.NewBaseEventForPush(
ctx,
aggregate,
AzureADIDPChangedEventType,
),
id,
changes,
)
if err != nil {
return nil, err
}
return &AzureADIDPChangedEvent{AzureADIDPChangedEvent: *changedEvent}, nil
}
func AzureADIDPChangedEventMapper(event eventstore.Event) (eventstore.Event, error) {
e, err := idp.AzureADIDPChangedEventMapper(event)
if err != nil {
return nil, err
}
return &AzureADIDPChangedEvent{AzureADIDPChangedEvent: *e.(*idp.AzureADIDPChangedEvent)}, nil
}
type GitHubIDPAddedEvent struct {
idp.GitHubIDPAddedEvent
}
func NewGitHubIDPAddedEvent(
ctx context.Context,
aggregate *eventstore.Aggregate,
id,
name,
clientID string,
clientSecret *crypto.CryptoValue,
scopes []string,
options idp.Options,
) *GitHubIDPAddedEvent {
return &GitHubIDPAddedEvent{
GitHubIDPAddedEvent: *idp.NewGitHubIDPAddedEvent(
eventstore.NewBaseEventForPush(
ctx,
aggregate,
GitHubIDPAddedEventType,
),
id,
name,
clientID,
clientSecret,
scopes,
options,
),
}
}
func GitHubIDPAddedEventMapper(event eventstore.Event) (eventstore.Event, error) {
e, err := idp.GitHubIDPAddedEventMapper(event)
if err != nil {
return nil, err
}
return &GitHubIDPAddedEvent{GitHubIDPAddedEvent: *e.(*idp.GitHubIDPAddedEvent)}, nil
}
type GitHubIDPChangedEvent struct {
idp.GitHubIDPChangedEvent
}
func NewGitHubIDPChangedEvent(
ctx context.Context,
aggregate *eventstore.Aggregate,
id string,
changes []idp.GitHubIDPChanges,
) (*GitHubIDPChangedEvent, error) {
changedEvent, err := idp.NewGitHubIDPChangedEvent(
eventstore.NewBaseEventForPush(
ctx,
aggregate,
GitHubIDPChangedEventType,
),
id,
changes,
)
if err != nil {
return nil, err
}
return &GitHubIDPChangedEvent{GitHubIDPChangedEvent: *changedEvent}, nil
}
func GitHubIDPChangedEventMapper(event eventstore.Event) (eventstore.Event, error) {
e, err := idp.GitHubIDPChangedEventMapper(event)
if err != nil {
return nil, err
}
return &GitHubIDPChangedEvent{GitHubIDPChangedEvent: *e.(*idp.GitHubIDPChangedEvent)}, nil
}
type GitHubEnterpriseIDPAddedEvent struct {
idp.GitHubEnterpriseIDPAddedEvent
}
func NewGitHubEnterpriseIDPAddedEvent(
ctx context.Context,
aggregate *eventstore.Aggregate,
id,
name,
clientID string,
clientSecret *crypto.CryptoValue,
authorizationEndpoint,
tokenEndpoint,
userEndpoint string,
scopes []string,
options idp.Options,
) *GitHubEnterpriseIDPAddedEvent {
return &GitHubEnterpriseIDPAddedEvent{
GitHubEnterpriseIDPAddedEvent: *idp.NewGitHubEnterpriseIDPAddedEvent(
eventstore.NewBaseEventForPush(
ctx,
aggregate,
GitHubEnterpriseIDPAddedEventType,
),
id,
name,
clientID,
clientSecret,
authorizationEndpoint,
tokenEndpoint,
userEndpoint,
scopes,
options,
),
}
}
func GitHubEnterpriseIDPAddedEventMapper(event eventstore.Event) (eventstore.Event, error) {
e, err := idp.GitHubEnterpriseIDPAddedEventMapper(event)
if err != nil {
return nil, err
}
return &GitHubEnterpriseIDPAddedEvent{GitHubEnterpriseIDPAddedEvent: *e.(*idp.GitHubEnterpriseIDPAddedEvent)}, nil
}
type GitHubEnterpriseIDPChangedEvent struct {
idp.GitHubEnterpriseIDPChangedEvent
}
func NewGitHubEnterpriseIDPChangedEvent(
ctx context.Context,
aggregate *eventstore.Aggregate,
id string,
changes []idp.GitHubEnterpriseIDPChanges,
) (*GitHubEnterpriseIDPChangedEvent, error) {
changedEvent, err := idp.NewGitHubEnterpriseIDPChangedEvent(
eventstore.NewBaseEventForPush(
ctx,
aggregate,
GitHubEnterpriseIDPChangedEventType,
),
id,
changes,
)
if err != nil {
return nil, err
}
return &GitHubEnterpriseIDPChangedEvent{GitHubEnterpriseIDPChangedEvent: *changedEvent}, nil
}
func GitHubEnterpriseIDPChangedEventMapper(event eventstore.Event) (eventstore.Event, error) {
e, err := idp.GitHubEnterpriseIDPChangedEventMapper(event)
if err != nil {
return nil, err
}
return &GitHubEnterpriseIDPChangedEvent{GitHubEnterpriseIDPChangedEvent: *e.(*idp.GitHubEnterpriseIDPChangedEvent)}, nil
}
type GitLabIDPAddedEvent struct {
idp.GitLabIDPAddedEvent
}
func NewGitLabIDPAddedEvent(
ctx context.Context,
aggregate *eventstore.Aggregate,
id,
name,
clientID string,
clientSecret *crypto.CryptoValue,
scopes []string,
options idp.Options,
) *GitLabIDPAddedEvent {
return &GitLabIDPAddedEvent{
GitLabIDPAddedEvent: *idp.NewGitLabIDPAddedEvent(
eventstore.NewBaseEventForPush(
ctx,
aggregate,
GitLabIDPAddedEventType,
),
id,
name,
clientID,
clientSecret,
scopes,
options,
),
}
}
func GitLabIDPAddedEventMapper(event eventstore.Event) (eventstore.Event, error) {
e, err := idp.GitLabIDPAddedEventMapper(event)
if err != nil {
return nil, err
}
return &GitLabIDPAddedEvent{GitLabIDPAddedEvent: *e.(*idp.GitLabIDPAddedEvent)}, nil
}
type GitLabIDPChangedEvent struct {
idp.GitLabIDPChangedEvent
}
func NewGitLabIDPChangedEvent(
ctx context.Context,
aggregate *eventstore.Aggregate,
id string,
changes []idp.GitLabIDPChanges,
) (*GitLabIDPChangedEvent, error) {
changedEvent, err := idp.NewGitLabIDPChangedEvent(
eventstore.NewBaseEventForPush(
ctx,
aggregate,
GitLabIDPChangedEventType,
),
id,
changes,
)
if err != nil {
return nil, err
}
return &GitLabIDPChangedEvent{GitLabIDPChangedEvent: *changedEvent}, nil
}
func GitLabIDPChangedEventMapper(event eventstore.Event) (eventstore.Event, error) {
e, err := idp.GitLabIDPChangedEventMapper(event)
if err != nil {
return nil, err
}
return &GitLabIDPChangedEvent{GitLabIDPChangedEvent: *e.(*idp.GitLabIDPChangedEvent)}, nil
}
type GitLabSelfHostedIDPAddedEvent struct {
idp.GitLabSelfHostedIDPAddedEvent
}
func NewGitLabSelfHostedIDPAddedEvent(
ctx context.Context,
aggregate *eventstore.Aggregate,
id,
name,
issuer,
clientID string,
clientSecret *crypto.CryptoValue,
scopes []string,
options idp.Options,
) *GitLabSelfHostedIDPAddedEvent {
return &GitLabSelfHostedIDPAddedEvent{
GitLabSelfHostedIDPAddedEvent: *idp.NewGitLabSelfHostedIDPAddedEvent(
eventstore.NewBaseEventForPush(
ctx,
aggregate,
GitLabSelfHostedIDPAddedEventType,
),
id,
name,
issuer,
clientID,
clientSecret,
scopes,
options,
),
}
}
func GitLabSelfHostedIDPAddedEventMapper(event eventstore.Event) (eventstore.Event, error) {
e, err := idp.GitLabSelfHostedIDPAddedEventMapper(event)
if err != nil {
return nil, err
}
return &GitLabSelfHostedIDPAddedEvent{GitLabSelfHostedIDPAddedEvent: *e.(*idp.GitLabSelfHostedIDPAddedEvent)}, nil
}
type GitLabSelfHostedIDPChangedEvent struct {
idp.GitLabSelfHostedIDPChangedEvent
}
func NewGitLabSelfHostedIDPChangedEvent(
ctx context.Context,
aggregate *eventstore.Aggregate,
id string,
changes []idp.GitLabSelfHostedIDPChanges,
) (*GitLabSelfHostedIDPChangedEvent, error) {
changedEvent, err := idp.NewGitLabSelfHostedIDPChangedEvent(
eventstore.NewBaseEventForPush(
ctx,
aggregate,
GitLabSelfHostedIDPChangedEventType,
),
id,
changes,
)
if err != nil {
return nil, err
}
return &GitLabSelfHostedIDPChangedEvent{GitLabSelfHostedIDPChangedEvent: *changedEvent}, nil
}
func GitLabSelfHostedIDPChangedEventMapper(event eventstore.Event) (eventstore.Event, error) {
e, err := idp.GitLabSelfHostedIDPChangedEventMapper(event)
if err != nil {
return nil, err
}
return &GitLabSelfHostedIDPChangedEvent{GitLabSelfHostedIDPChangedEvent: *e.(*idp.GitLabSelfHostedIDPChangedEvent)}, nil
}
type GoogleIDPAddedEvent struct {
idp.GoogleIDPAddedEvent
}
func NewGoogleIDPAddedEvent(
ctx context.Context,
aggregate *eventstore.Aggregate,
id,
name,
clientID string,
clientSecret *crypto.CryptoValue,
scopes []string,
options idp.Options,
) *GoogleIDPAddedEvent {
return &GoogleIDPAddedEvent{
GoogleIDPAddedEvent: *idp.NewGoogleIDPAddedEvent(
eventstore.NewBaseEventForPush(
ctx,
aggregate,
GoogleIDPAddedEventType,
),
id,
name,
clientID,
clientSecret,
scopes,
options,
),
}
}
func GoogleIDPAddedEventMapper(event eventstore.Event) (eventstore.Event, error) {
e, err := idp.GoogleIDPAddedEventMapper(event)
if err != nil {
return nil, err
}
return &GoogleIDPAddedEvent{GoogleIDPAddedEvent: *e.(*idp.GoogleIDPAddedEvent)}, nil
}
type GoogleIDPChangedEvent struct {
idp.GoogleIDPChangedEvent
}
func NewGoogleIDPChangedEvent(
ctx context.Context,
aggregate *eventstore.Aggregate,
id string,
changes []idp.GoogleIDPChanges,
) (*GoogleIDPChangedEvent, error) {
changedEvent, err := idp.NewGoogleIDPChangedEvent(
eventstore.NewBaseEventForPush(
ctx,
aggregate,
GoogleIDPChangedEventType,
),
id,
changes,
)
if err != nil {
return nil, err
}
return &GoogleIDPChangedEvent{GoogleIDPChangedEvent: *changedEvent}, nil
}
func GoogleIDPChangedEventMapper(event eventstore.Event) (eventstore.Event, error) {
e, err := idp.GoogleIDPChangedEventMapper(event)
if err != nil {
return nil, err
}
return &GoogleIDPChangedEvent{GoogleIDPChangedEvent: *e.(*idp.GoogleIDPChangedEvent)}, nil
}
type LDAPIDPAddedEvent struct {
idp.LDAPIDPAddedEvent
}
func NewLDAPIDPAddedEvent(
ctx context.Context,
aggregate *eventstore.Aggregate,
id,
name string,
servers []string,
startTLS bool,
baseDN string,
bindDN string,
bindPassword *crypto.CryptoValue,
userBase string,
userObjectClasses []string,
userFilters []string,
timeout time.Duration,
attributes idp.LDAPAttributes,
options idp.Options,
) *LDAPIDPAddedEvent {
return &LDAPIDPAddedEvent{
LDAPIDPAddedEvent: *idp.NewLDAPIDPAddedEvent(
eventstore.NewBaseEventForPush(
ctx,
aggregate,
LDAPIDPAddedEventType,
),
id,
name,
servers,
startTLS,
baseDN,
bindDN,
bindPassword,
userBase,
userObjectClasses,
userFilters,
timeout,
attributes,
options,
),
}
}
func LDAPIDPAddedEventMapper(event eventstore.Event) (eventstore.Event, error) {
e, err := idp.LDAPIDPAddedEventMapper(event)
if err != nil {
return nil, err
}
return &LDAPIDPAddedEvent{LDAPIDPAddedEvent: *e.(*idp.LDAPIDPAddedEvent)}, nil
}
type LDAPIDPChangedEvent struct {
idp.LDAPIDPChangedEvent
}
func NewLDAPIDPChangedEvent(
ctx context.Context,
aggregate *eventstore.Aggregate,
id string,
changes []idp.LDAPIDPChanges,
) (*LDAPIDPChangedEvent, error) {
changedEvent, err := idp.NewLDAPIDPChangedEvent(
eventstore.NewBaseEventForPush(
ctx,
aggregate,
LDAPIDPChangedEventType,
),
id,
changes,
)
if err != nil {
return nil, err
}
return &LDAPIDPChangedEvent{LDAPIDPChangedEvent: *changedEvent}, nil
}
func LDAPIDPChangedEventMapper(event eventstore.Event) (eventstore.Event, error) {
e, err := idp.LDAPIDPChangedEventMapper(event)
if err != nil {
return nil, err
}
return &LDAPIDPChangedEvent{LDAPIDPChangedEvent: *e.(*idp.LDAPIDPChangedEvent)}, nil
}
type AppleIDPAddedEvent struct {
idp.AppleIDPAddedEvent
}
func NewAppleIDPAddedEvent(
ctx context.Context,
aggregate *eventstore.Aggregate,
id,
name,
clientID,
teamID,
keyID string,
privateKey *crypto.CryptoValue,
scopes []string,
options idp.Options,
) *AppleIDPAddedEvent {
return &AppleIDPAddedEvent{
AppleIDPAddedEvent: *idp.NewAppleIDPAddedEvent(
eventstore.NewBaseEventForPush(
ctx,
aggregate,
AppleIDPAddedEventType,
),
id,
name,
clientID,
teamID,
keyID,
privateKey,
scopes,
options,
),
}
}
func AppleIDPAddedEventMapper(event eventstore.Event) (eventstore.Event, error) {
e, err := idp.AppleIDPAddedEventMapper(event)
if err != nil {
return nil, err
}
return &AppleIDPAddedEvent{AppleIDPAddedEvent: *e.(*idp.AppleIDPAddedEvent)}, nil
}
type AppleIDPChangedEvent struct {
idp.AppleIDPChangedEvent
}
func NewAppleIDPChangedEvent(
ctx context.Context,
aggregate *eventstore.Aggregate,
id string,
changes []idp.AppleIDPChanges,
) (*AppleIDPChangedEvent, error) {
changedEvent, err := idp.NewAppleIDPChangedEvent(
eventstore.NewBaseEventForPush(
ctx,
aggregate,
AppleIDPChangedEventType,
),
id,
changes,
)
if err != nil {
return nil, err
}
return &AppleIDPChangedEvent{AppleIDPChangedEvent: *changedEvent}, nil
}
func AppleIDPChangedEventMapper(event eventstore.Event) (eventstore.Event, error) {
e, err := idp.AppleIDPChangedEventMapper(event)
if err != nil {
return nil, err
}
return &AppleIDPChangedEvent{AppleIDPChangedEvent: *e.(*idp.AppleIDPChangedEvent)}, nil
}
type SAMLIDPAddedEvent struct {
idp.SAMLIDPAddedEvent
}
func NewSAMLIDPAddedEvent(
ctx context.Context,
aggregate *eventstore.Aggregate,
id,
name string,
metadata []byte,
key *crypto.CryptoValue,
certificate []byte,
binding string,
withSignedRequest bool,
nameIDFormat *domain.SAMLNameIDFormat,
transientMappingAttributeName string,
options idp.Options,
) *SAMLIDPAddedEvent {
return &SAMLIDPAddedEvent{
SAMLIDPAddedEvent: *idp.NewSAMLIDPAddedEvent(
eventstore.NewBaseEventForPush(
ctx,
aggregate,
SAMLIDPAddedEventType,
),
id,
name,
metadata,
key,
certificate,
binding,
withSignedRequest,
nameIDFormat,
transientMappingAttributeName,
options,
),
}
}
func SAMLIDPAddedEventMapper(event eventstore.Event) (eventstore.Event, error) {
e, err := idp.SAMLIDPAddedEventMapper(event)
if err != nil {
return nil, err
}
return &SAMLIDPAddedEvent{SAMLIDPAddedEvent: *e.(*idp.SAMLIDPAddedEvent)}, nil
}
type SAMLIDPChangedEvent struct {
idp.SAMLIDPChangedEvent
}
func NewSAMLIDPChangedEvent(
ctx context.Context,
aggregate *eventstore.Aggregate,
id string,
changes []idp.SAMLIDPChanges,
) (*SAMLIDPChangedEvent, error) {
changedEvent, err := idp.NewSAMLIDPChangedEvent(
eventstore.NewBaseEventForPush(
ctx,
aggregate,
SAMLIDPChangedEventType,
),
id,
changes,
)
if err != nil {
return nil, err
}
return &SAMLIDPChangedEvent{SAMLIDPChangedEvent: *changedEvent}, nil
}
func SAMLIDPChangedEventMapper(event eventstore.Event) (eventstore.Event, error) {
e, err := idp.SAMLIDPChangedEventMapper(event)
if err != nil {
return nil, err
}
return &SAMLIDPChangedEvent{SAMLIDPChangedEvent: *e.(*idp.SAMLIDPChangedEvent)}, nil
}
type IDPRemovedEvent struct {
idp.RemovedEvent
}
func NewIDPRemovedEvent(
ctx context.Context,
aggregate *eventstore.Aggregate,
id string,
) *IDPRemovedEvent {
return &IDPRemovedEvent{
RemovedEvent: *idp.NewRemovedEvent(
eventstore.NewBaseEventForPush(
ctx,
aggregate,
IDPRemovedEventType,
),
id,
),
}
}
func (e *IDPRemovedEvent) Payload() interface{} {
return e
}
func IDPRemovedEventMapper(event eventstore.Event) (eventstore.Event, error) {
e, err := idp.RemovedEventMapper(event)
if err != nil {
return nil, err
}
return &IDPRemovedEvent{RemovedEvent: *e.(*idp.RemovedEvent)}, nil
}