mirror of
https://github.com/andwati/zitadel.git
synced 2026-10-22 23:42:16 +00:00
f230cf0fb5
# Which Problems Are Solved Relational table's primary keys are part of the SQL table definition. However, by abstraction through the repository interfaces callers (service layer) have no clear understanding of the primary key definion. This might lead to confusion during implementation: - The repository makes a sanity check on required conditions before query execution and returns an error if the condition was not met. - When a Get method is executed, an error is returned if not exactly one row is found. Get replaces the legacy GetXxxByID methods we have on projections. However, a list of flexible conditions can be passed. - Operations like UPDATE and DELETE should often only affect a single row, identified by the primary key. If the primary key conditions are missing an error is returned. Because there is no "type safety" enforced here, the errors are returned during runtime. When all possible combinations of API arguments are not properly tested such errors are actually bugs in the experience of the end-user. (The API should do it's own input validation, but a programmer's error is easily made). # How the Problems Are Solved Add `PrimaryKeyColumns` and `PrimaryKeyCondition` to existing repository intefaces. # Additional Changes - Where reducers already used repositories, the PrimaryKeyConditions are used where possible. # Additional Context - Part of https://github.com/zitadel/zitadel/wiki/Decision-Log#expose-primary-key-definition-in-repository-interfaces --------- Co-authored-by: Marco A. <[email protected]>
654 lines
18 KiB
Go
654 lines
18 KiB
Go
package repository
|
|
|
|
import (
|
|
"context"
|
|
"encoding/json"
|
|
"time"
|
|
|
|
"github.com/zitadel/zitadel/backend/v3/domain"
|
|
"github.com/zitadel/zitadel/backend/v3/storage/database"
|
|
)
|
|
|
|
var _ domain.IDProviderRepository = (*idProvider)(nil)
|
|
|
|
type idProvider struct{}
|
|
|
|
func IDProviderRepository() domain.IDProviderRepository {
|
|
return new(idProvider)
|
|
}
|
|
|
|
const queryIDProviderStmt = `SELECT instance_id, org_id, id, state, name, type, auto_register, allow_creation, allow_auto_creation,` +
|
|
` allow_auto_update, allow_linking, auto_linking_field, styling_type, payload, created_at, updated_at` +
|
|
` FROM zitadel.identity_providers`
|
|
|
|
func (i *idProvider) Get(ctx context.Context, client database.QueryExecutor, id domain.IDPIdentifierCondition, instanceID string, orgID *string) (*domain.IdentityProvider, error) {
|
|
builder := database.StatementBuilder{}
|
|
|
|
builder.WriteString(queryIDProviderStmt)
|
|
|
|
conditions := []database.Condition{id, i.InstanceIDCondition(instanceID), i.OrgIDCondition(orgID)}
|
|
|
|
writeCondition(&builder, database.And(conditions...))
|
|
|
|
return scanIDProvider(ctx, client, &builder)
|
|
}
|
|
|
|
func (i *idProvider) List(ctx context.Context, client database.QueryExecutor, conditions ...database.Condition) ([]*domain.IdentityProvider, error) {
|
|
builder := database.StatementBuilder{}
|
|
|
|
builder.WriteString(queryIDProviderStmt)
|
|
|
|
if conditions != nil {
|
|
writeCondition(&builder, database.And(conditions...))
|
|
}
|
|
|
|
orderBy := database.OrderBy(i.CreatedAtColumn())
|
|
orderBy.Write(&builder)
|
|
|
|
return scanIDProviders(ctx, client, &builder)
|
|
}
|
|
|
|
const createIDProviderStmtStart = `INSERT INTO zitadel.identity_providers` +
|
|
` (instance_id, org_id, id, state, name, type, allow_creation, allow_auto_creation,` +
|
|
` allow_auto_update, allow_linking, styling_type, payload) VALUES (`
|
|
|
|
const createIDProviderStmtEnd = `) RETURNING created_at, updated_at`
|
|
|
|
func (i *idProvider) Create(ctx context.Context, client database.QueryExecutor, idp *domain.IdentityProvider) error {
|
|
builder := database.StatementBuilder{}
|
|
|
|
builder.WriteString(createIDProviderStmtStart)
|
|
|
|
builder.WriteArgs(
|
|
idp.InstanceID,
|
|
idp.OrgID,
|
|
idp.ID,
|
|
idp.State,
|
|
idp.Name,
|
|
idp.Type,
|
|
idp.AllowCreation,
|
|
idp.AllowAutoCreation,
|
|
idp.AllowAutoUpdate,
|
|
idp.AllowLinking,
|
|
idp.StylingType,
|
|
string(idp.Payload))
|
|
|
|
builder.WriteString(createIDProviderStmtEnd)
|
|
|
|
err := client.QueryRow(ctx, builder.String(), builder.Args()...).Scan(&idp.CreatedAt, &idp.UpdatedAt)
|
|
return err
|
|
}
|
|
|
|
func (i *idProvider) Update(ctx context.Context, client database.QueryExecutor, id domain.IDPIdentifierCondition, instanceID string, orgID *string, changes ...database.Change) (int64, error) {
|
|
if changes == nil {
|
|
return 0, database.ErrNoChanges
|
|
}
|
|
changes = append(changes, i.SetUpdatedAt(nil))
|
|
builder := database.StatementBuilder{}
|
|
builder.WriteString(`UPDATE zitadel.identity_providers SET `)
|
|
|
|
conditions := []database.Condition{
|
|
id,
|
|
i.InstanceIDCondition(instanceID),
|
|
i.OrgIDCondition(orgID),
|
|
}
|
|
database.Changes(changes).Write(&builder)
|
|
writeCondition(&builder, database.And(conditions...))
|
|
|
|
stmt := builder.String()
|
|
|
|
return client.Exec(ctx, stmt, builder.Args()...)
|
|
}
|
|
|
|
func (i *idProvider) Delete(ctx context.Context, client database.QueryExecutor, id domain.IDPIdentifierCondition, instanceID string, orgID *string) (int64, error) {
|
|
builder := database.StatementBuilder{}
|
|
|
|
builder.WriteString(`DELETE FROM zitadel.identity_providers`)
|
|
|
|
conditions := []database.Condition{
|
|
id,
|
|
i.InstanceIDCondition(instanceID),
|
|
i.OrgIDCondition(orgID),
|
|
}
|
|
writeCondition(&builder, database.And(conditions...))
|
|
|
|
return client.Exec(ctx, builder.String(), builder.Args()...)
|
|
}
|
|
|
|
func (i *idProvider) GetOIDC(ctx context.Context, client database.QueryExecutor, id domain.IDPIdentifierCondition, instanceID string, orgID *string) (*domain.IDPOIDC, error) {
|
|
idpOIDC := &domain.IDPOIDC{}
|
|
var err error
|
|
|
|
idpOIDC.IdentityProvider, err = i.Get(ctx, client, id, instanceID, orgID)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
|
|
var idpType domain.IDPType
|
|
if idpOIDC.Type != nil {
|
|
idpType = *idpOIDC.Type
|
|
}
|
|
|
|
if idpType != domain.IDPTypeOIDC {
|
|
return nil, domain.NewIDPWrongTypeError(domain.IDPTypeOIDC, idpType)
|
|
}
|
|
|
|
err = json.Unmarshal(idpOIDC.Payload, idpOIDC)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
|
|
return idpOIDC, nil
|
|
}
|
|
|
|
func (i *idProvider) GetJWT(ctx context.Context, client database.QueryExecutor, id domain.IDPIdentifierCondition, instanceID string, orgID *string) (*domain.IDPJWT, error) {
|
|
idpJWT := &domain.IDPJWT{}
|
|
var err error
|
|
|
|
idpJWT.IdentityProvider, err = i.Get(ctx, client, id, instanceID, orgID)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
|
|
var idpType domain.IDPType
|
|
if idpJWT.Type != nil {
|
|
idpType = *idpJWT.Type
|
|
}
|
|
|
|
if idpType != domain.IDPTypeJWT {
|
|
return nil, domain.NewIDPWrongTypeError(domain.IDPTypeJWT, idpType)
|
|
}
|
|
|
|
err = json.Unmarshal(idpJWT.Payload, idpJWT)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
|
|
return idpJWT, nil
|
|
}
|
|
|
|
func (i *idProvider) GetOAuth(ctx context.Context, client database.QueryExecutor, id domain.IDPIdentifierCondition, instanceID string, orgID *string) (*domain.IDPOAuth, error) {
|
|
idpOAuth := &domain.IDPOAuth{}
|
|
var err error
|
|
|
|
idpOAuth.IdentityProvider, err = i.Get(ctx, client, id, instanceID, orgID)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
|
|
var idpType domain.IDPType
|
|
if idpOAuth.Type != nil {
|
|
idpType = *idpOAuth.Type
|
|
}
|
|
|
|
if idpType != domain.IDPTypeOAuth {
|
|
return nil, domain.NewIDPWrongTypeError(domain.IDPTypeOAuth, idpType)
|
|
}
|
|
|
|
err = json.Unmarshal(idpOAuth.Payload, idpOAuth)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
|
|
return idpOAuth, nil
|
|
}
|
|
|
|
func (i *idProvider) GetAzureAD(ctx context.Context, client database.QueryExecutor, id domain.IDPIdentifierCondition, instanceID string, orgID *string) (*domain.IDPAzureAD, error) {
|
|
idpAzure := &domain.IDPAzureAD{}
|
|
var err error
|
|
|
|
idpAzure.IdentityProvider, err = i.Get(ctx, client, id, instanceID, orgID)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
|
|
var idpType domain.IDPType
|
|
if idpAzure.Type != nil {
|
|
idpType = *idpAzure.Type
|
|
}
|
|
|
|
if idpType != domain.IDPTypeAzure {
|
|
return nil, domain.NewIDPWrongTypeError(domain.IDPTypeAzure, idpType)
|
|
}
|
|
|
|
err = json.Unmarshal(idpAzure.Payload, idpAzure)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
|
|
return idpAzure, nil
|
|
}
|
|
|
|
func (i *idProvider) GetGoogle(ctx context.Context, client database.QueryExecutor, id domain.IDPIdentifierCondition, instanceID string, orgID *string) (*domain.IDPGoogle, error) {
|
|
idpGoogle := &domain.IDPGoogle{}
|
|
var err error
|
|
|
|
idpGoogle.IdentityProvider, err = i.Get(ctx, client, id, instanceID, orgID)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
|
|
var idpType domain.IDPType
|
|
if idpGoogle.Type != nil {
|
|
idpType = *idpGoogle.Type
|
|
}
|
|
|
|
if idpType != domain.IDPTypeGoogle {
|
|
return nil, domain.NewIDPWrongTypeError(domain.IDPTypeGoogle, idpType)
|
|
}
|
|
|
|
err = json.Unmarshal(idpGoogle.Payload, idpGoogle)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
|
|
return idpGoogle, nil
|
|
}
|
|
|
|
func (i *idProvider) GetGithub(ctx context.Context, client database.QueryExecutor, id domain.IDPIdentifierCondition, instanceID string, orgID *string) (*domain.IDPGithub, error) {
|
|
idpGithub := &domain.IDPGithub{}
|
|
var err error
|
|
|
|
idpGithub.IdentityProvider, err = i.Get(ctx, client, id, instanceID, orgID)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
|
|
var idpType domain.IDPType
|
|
if idpGithub.Type != nil {
|
|
idpType = *idpGithub.Type
|
|
}
|
|
|
|
if idpType != domain.IDPTypeGitHub {
|
|
return nil, domain.NewIDPWrongTypeError(domain.IDPTypeGitHub, idpType)
|
|
}
|
|
|
|
err = json.Unmarshal(idpGithub.Payload, idpGithub)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
|
|
return idpGithub, nil
|
|
}
|
|
|
|
func (i *idProvider) GetGithubEnterprise(ctx context.Context, client database.QueryExecutor, id domain.IDPIdentifierCondition, instanceID string, orgID *string) (*domain.IDPGithubEnterprise, error) {
|
|
idpGithubEnterprise := &domain.IDPGithubEnterprise{}
|
|
var err error
|
|
|
|
idpGithubEnterprise.IdentityProvider, err = i.Get(ctx, client, id, instanceID, orgID)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
|
|
var idpType domain.IDPType
|
|
if idpGithubEnterprise.Type != nil {
|
|
idpType = *idpGithubEnterprise.Type
|
|
}
|
|
|
|
if idpType != domain.IDPTypeGitHubEnterprise {
|
|
return nil, domain.NewIDPWrongTypeError(domain.IDPTypeGitHubEnterprise, idpType)
|
|
}
|
|
|
|
err = json.Unmarshal(idpGithubEnterprise.Payload, idpGithubEnterprise)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
|
|
return idpGithubEnterprise, nil
|
|
}
|
|
|
|
func (i *idProvider) GetGitlab(ctx context.Context, client database.QueryExecutor, id domain.IDPIdentifierCondition, instanceID string, orgID *string) (*domain.IDPGitlab, error) {
|
|
idpGitlab := &domain.IDPGitlab{}
|
|
var err error
|
|
|
|
idpGitlab.IdentityProvider, err = i.Get(ctx, client, id, instanceID, orgID)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
|
|
var idpType domain.IDPType
|
|
if idpGitlab.Type != nil {
|
|
idpType = *idpGitlab.Type
|
|
}
|
|
|
|
if idpType != domain.IDPTypeGitLab {
|
|
return nil, domain.NewIDPWrongTypeError(domain.IDPTypeGitLab, idpType)
|
|
}
|
|
|
|
err = json.Unmarshal(idpGitlab.Payload, idpGitlab)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
|
|
return idpGitlab, nil
|
|
}
|
|
|
|
func (i *idProvider) GetGitlabSelfHosting(ctx context.Context, client database.QueryExecutor, id domain.IDPIdentifierCondition, instanceID string, orgID *string) (*domain.IDPGitlabSelfHosting, error) {
|
|
idpGitlabSelfHosting := &domain.IDPGitlabSelfHosting{}
|
|
var err error
|
|
|
|
idpGitlabSelfHosting.IdentityProvider, err = i.Get(ctx, client, id, instanceID, orgID)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
|
|
var idpType domain.IDPType
|
|
if idpGitlabSelfHosting.Type != nil {
|
|
idpType = *idpGitlabSelfHosting.Type
|
|
}
|
|
|
|
if idpType != domain.IDPTypeGitLabSelfHosted {
|
|
return nil, domain.NewIDPWrongTypeError(domain.IDPTypeGitLabSelfHosted, idpType)
|
|
}
|
|
|
|
err = json.Unmarshal(idpGitlabSelfHosting.Payload, idpGitlabSelfHosting)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
|
|
return idpGitlabSelfHosting, nil
|
|
}
|
|
|
|
func (i *idProvider) GetLDAP(ctx context.Context, client database.QueryExecutor, id domain.IDPIdentifierCondition, instanceID string, orgID *string) (*domain.IDPLDAP, error) {
|
|
ldap := &domain.IDPLDAP{}
|
|
var err error
|
|
|
|
ldap.IdentityProvider, err = i.Get(ctx, client, id, instanceID, orgID)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
|
|
var idpType domain.IDPType
|
|
if ldap.Type != nil {
|
|
idpType = *ldap.Type
|
|
}
|
|
|
|
if idpType != domain.IDPTypeLDAP {
|
|
return nil, domain.NewIDPWrongTypeError(domain.IDPTypeLDAP, idpType)
|
|
}
|
|
|
|
err = json.Unmarshal(ldap.Payload, ldap)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
|
|
return ldap, nil
|
|
}
|
|
|
|
func (i *idProvider) GetApple(ctx context.Context, client database.QueryExecutor, id domain.IDPIdentifierCondition, instanceID string, orgID *string) (*domain.IDPApple, error) {
|
|
apple := &domain.IDPApple{}
|
|
var err error
|
|
|
|
apple.IdentityProvider, err = i.Get(ctx, client, id, instanceID, orgID)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
|
|
var idpType domain.IDPType
|
|
if apple.Type != nil {
|
|
idpType = *apple.Type
|
|
}
|
|
|
|
if idpType != domain.IDPTypeApple {
|
|
return nil, domain.NewIDPWrongTypeError(domain.IDPTypeApple, idpType)
|
|
}
|
|
|
|
err = json.Unmarshal(apple.Payload, apple)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
|
|
return apple, nil
|
|
}
|
|
|
|
func (i *idProvider) GetSAML(ctx context.Context, client database.QueryExecutor, id domain.IDPIdentifierCondition, instanceID string, orgID *string) (*domain.IDPSAML, error) {
|
|
saml := &domain.IDPSAML{}
|
|
var err error
|
|
|
|
saml.IdentityProvider, err = i.Get(ctx, client, id, instanceID, orgID)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
|
|
var idpType domain.IDPType
|
|
if saml.Type != nil {
|
|
idpType = *saml.Type
|
|
}
|
|
|
|
if idpType != domain.IDPTypeSAML {
|
|
return nil, domain.NewIDPWrongTypeError(domain.IDPTypeSAML, idpType)
|
|
}
|
|
|
|
err = json.Unmarshal(saml.Payload, saml)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
|
|
return saml, nil
|
|
}
|
|
|
|
// -------------------------------------------------------------
|
|
// columns
|
|
// -------------------------------------------------------------
|
|
|
|
// PrimaryKeyColumns implements [domain.Repository].
|
|
func (i idProvider) PrimaryKeyColumns() []database.Column {
|
|
return []database.Column{
|
|
i.InstanceIDColumn(),
|
|
i.IDColumn(),
|
|
}
|
|
}
|
|
|
|
func (idProvider) InstanceIDColumn() database.Column {
|
|
return database.NewColumn("identity_providers", "instance_id")
|
|
}
|
|
|
|
func (idProvider) OrgIDColumn() database.Column {
|
|
return database.NewColumn("identity_providers", "org_id")
|
|
}
|
|
|
|
func (idProvider) IDColumn() database.Column {
|
|
return database.NewColumn("identity_providers", "id")
|
|
}
|
|
|
|
func (idProvider) StateColumn() database.Column {
|
|
return database.NewColumn("identity_providers", "state")
|
|
}
|
|
|
|
func (idProvider) NameColumn() database.Column {
|
|
return database.NewColumn("identity_providers", "name")
|
|
}
|
|
|
|
func (idProvider) TypeColumn() database.Column {
|
|
return database.NewColumn("identity_providers", "type")
|
|
}
|
|
|
|
func (idProvider) AutoRegisterColumn() database.Column {
|
|
return database.NewColumn("identity_providers", "auto_register")
|
|
}
|
|
|
|
func (idProvider) AllowCreationColumn() database.Column {
|
|
return database.NewColumn("identity_providers", "allow_creation")
|
|
}
|
|
|
|
func (idProvider) AllowAutoCreationColumn() database.Column {
|
|
return database.NewColumn("identity_providers", "allow_auto_creation")
|
|
}
|
|
|
|
func (idProvider) AllowAutoUpdateColumn() database.Column {
|
|
return database.NewColumn("identity_providers", "allow_auto_update")
|
|
}
|
|
|
|
func (idProvider) AllowLinkingColumn() database.Column {
|
|
return database.NewColumn("identity_providers", "allow_linking")
|
|
}
|
|
|
|
func (idProvider) AllowAutoLinkingColumn() database.Column {
|
|
return database.NewColumn("identity_providers", "auto_linking_field")
|
|
}
|
|
|
|
func (idProvider) StylingTypeColumn() database.Column {
|
|
return database.NewColumn("identity_providers", "styling_type")
|
|
}
|
|
|
|
func (idProvider) PayloadColumn() database.Column {
|
|
return database.NewColumn("identity_providers", "payload")
|
|
}
|
|
|
|
func (idProvider) CreatedAtColumn() database.Column {
|
|
return database.NewColumn("identity_providers", "created_at")
|
|
}
|
|
|
|
func (idProvider) UpdatedAtColumn() database.Column {
|
|
return database.NewColumn("identity_providers", "updated_at")
|
|
}
|
|
|
|
// -------------------------------------------------------------
|
|
// conditions
|
|
// -------------------------------------------------------------
|
|
|
|
func (i idProvider) PrimaryKeyCondition(instanceID, id string) database.Condition {
|
|
return database.And(
|
|
i.InstanceIDCondition(instanceID),
|
|
i.IDCondition(id),
|
|
)
|
|
}
|
|
|
|
func (i idProvider) InstanceIDCondition(id string) database.Condition {
|
|
return database.NewTextCondition(i.InstanceIDColumn(), database.TextOperationEqual, id)
|
|
}
|
|
|
|
func (i idProvider) OrgIDCondition(id *string) database.Condition {
|
|
if id == nil {
|
|
return database.IsNull(i.OrgIDColumn())
|
|
}
|
|
return database.NewTextCondition(i.OrgIDColumn(), database.TextOperationEqual, *id)
|
|
}
|
|
|
|
func (i idProvider) IDCondition(id string) domain.IDPIdentifierCondition {
|
|
return database.NewTextCondition(i.IDColumn(), database.TextOperationEqual, id)
|
|
}
|
|
|
|
func (i idProvider) StateCondition(state domain.IDPState) database.Condition {
|
|
return database.NewTextCondition(i.StateColumn(), database.TextOperationEqual, state.String())
|
|
}
|
|
|
|
func (i idProvider) NameCondition(name string) domain.IDPIdentifierCondition {
|
|
return database.NewTextCondition(i.NameColumn(), database.TextOperationEqual, name)
|
|
}
|
|
|
|
func (i idProvider) TypeCondition(typ domain.IDPType) database.Condition {
|
|
return database.NewNumberCondition(i.TypeColumn(), database.NumberOperationEqual, typ)
|
|
}
|
|
|
|
func (i idProvider) AutoRegisterCondition(allow bool) database.Condition {
|
|
return database.NewBooleanCondition(i.AutoRegisterColumn(), allow)
|
|
}
|
|
|
|
func (i idProvider) AllowCreationCondition(allow bool) database.Condition {
|
|
return database.NewBooleanCondition(i.AllowCreationColumn(), allow)
|
|
}
|
|
|
|
func (i idProvider) AllowAutoCreationCondition(allow bool) database.Condition {
|
|
return database.NewBooleanCondition(i.AllowAutoCreationColumn(), allow)
|
|
}
|
|
|
|
func (i idProvider) AllowAutoUpdateCondition(allow bool) database.Condition {
|
|
return database.NewBooleanCondition(i.AllowAutoUpdateColumn(), allow)
|
|
}
|
|
|
|
func (i idProvider) AllowLinkingCondition(allow bool) database.Condition {
|
|
return database.NewBooleanCondition(i.AllowLinkingColumn(), allow)
|
|
}
|
|
|
|
func (i idProvider) AllowAutoLinkingCondition(linkingType domain.IDPAutoLinkingField) database.Condition {
|
|
return database.NewTextCondition(i.AllowAutoLinkingColumn(), database.TextOperationEqual, linkingType.String())
|
|
}
|
|
|
|
func (i idProvider) StylingTypeCondition(style int16) database.Condition {
|
|
return database.NewNumberCondition(i.StylingTypeColumn(), database.NumberOperationEqual, style)
|
|
}
|
|
|
|
func (i idProvider) PayloadCondition(payload string) database.Condition {
|
|
return database.NewTextCondition(i.PayloadColumn(), database.TextOperationEqual, payload)
|
|
}
|
|
|
|
// -------------------------------------------------------------
|
|
// changes
|
|
// -------------------------------------------------------------
|
|
|
|
func (i idProvider) SetName(name string) database.Change {
|
|
return database.NewChange(i.NameColumn(), name)
|
|
}
|
|
|
|
func (i idProvider) SetState(state domain.IDPState) database.Change {
|
|
return database.NewChange(i.StateColumn(), state)
|
|
}
|
|
|
|
func (i idProvider) SetAllowCreation(allow bool) database.Change {
|
|
return database.NewChange(i.AllowCreationColumn(), allow)
|
|
}
|
|
|
|
func (i idProvider) SetAutoRegister(allow bool) database.Change {
|
|
return database.NewChange(i.AutoRegisterColumn(), allow)
|
|
}
|
|
|
|
func (i idProvider) SetAllowAutoCreation(allow bool) database.Change {
|
|
return database.NewChange(i.AllowAutoCreationColumn(), allow)
|
|
}
|
|
|
|
func (i idProvider) SetAllowAutoUpdate(allow bool) database.Change {
|
|
return database.NewChange(i.AllowAutoUpdateColumn(), allow)
|
|
}
|
|
|
|
func (i idProvider) SetAllowLinking(allow bool) database.Change {
|
|
return database.NewChange(i.AllowLinkingColumn(), allow)
|
|
}
|
|
|
|
func (i idProvider) SetAutoAllowLinking(allow bool) database.Change {
|
|
return database.NewChange(i.AllowAutoLinkingColumn(), allow)
|
|
}
|
|
|
|
func (i idProvider) SetStylingType(stylingType int16) database.Change {
|
|
return database.NewChange(i.StylingTypeColumn(), stylingType)
|
|
}
|
|
|
|
func (i idProvider) SetPayload(payload string) database.Change {
|
|
return database.NewChange(i.PayloadColumn(), payload)
|
|
}
|
|
|
|
func (i idProvider) SetUpdatedAt(updatedAt *time.Time) database.Change {
|
|
return database.NewChangePtr(i.UpdatedAtColumn(), updatedAt)
|
|
}
|
|
|
|
func scanIDProvider(ctx context.Context, querier database.Querier, builder *database.StatementBuilder) (*domain.IdentityProvider, error) {
|
|
idp := &domain.IdentityProvider{}
|
|
rows, err := querier.Query(ctx, builder.String(), builder.Args()...)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
|
|
err = rows.(database.CollectableRows).CollectExactlyOneRow(idp)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
|
|
return idp, err
|
|
}
|
|
|
|
func scanIDProviders(ctx context.Context, querier database.Querier, builder *database.StatementBuilder) ([]*domain.IdentityProvider, error) {
|
|
idps := []*domain.IdentityProvider{}
|
|
|
|
rows, err := querier.Query(ctx, builder.String(), builder.Args()...)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
|
|
err = rows.(database.CollectableRows).Collect(&idps)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
|
|
return idps, nil
|
|
}
|