chore: move the go code into a subfolder

This commit is contained in:
Florian Forster
2025-08-05 15:20:32 -07:00
parent 4ad22ba456
commit cd2921de26
2978 changed files with 373 additions and 300 deletions

View File

@@ -0,0 +1,142 @@
package model
import (
"github.com/zitadel/zitadel/internal/crypto"
"github.com/zitadel/zitadel/internal/eventstore"
es_models "github.com/zitadel/zitadel/internal/eventstore/v1/models"
"github.com/zitadel/zitadel/internal/org/model"
"github.com/zitadel/zitadel/internal/zerrors"
)
type OrgDomain struct {
es_models.ObjectRoot `json:"-"`
Domain string `json:"domain"`
Verified bool `json:"-"`
Primary bool `json:"-"`
ValidationType int32 `json:"validationType"`
ValidationCode *crypto.CryptoValue `json:"validationCode"`
}
func GetDomain(domains []*OrgDomain, domain string) (int, *OrgDomain) {
for i, d := range domains {
if d.Domain == domain {
return i, d
}
}
return -1, nil
}
func (o *Org) appendAddDomainEvent(event eventstore.Event) error {
domain := new(OrgDomain)
err := domain.SetData(event)
if err != nil {
return err
}
domain.ObjectRoot.CreationDate = event.CreatedAt()
o.Domains = append(o.Domains, domain)
return nil
}
func (o *Org) appendRemoveDomainEvent(event eventstore.Event) error {
domain := new(OrgDomain)
err := domain.SetData(event)
if err != nil {
return err
}
if i, r := GetDomain(o.Domains, domain.Domain); r != nil {
o.Domains[i] = o.Domains[len(o.Domains)-1]
o.Domains[len(o.Domains)-1] = nil
o.Domains = o.Domains[:len(o.Domains)-1]
}
return nil
}
func (o *Org) appendVerifyDomainEvent(event eventstore.Event) error {
domain := new(OrgDomain)
err := domain.SetData(event)
if err != nil {
return err
}
if i, d := GetDomain(o.Domains, domain.Domain); d != nil {
d.Verified = true
o.Domains[i] = d
}
return nil
}
func (o *Org) appendPrimaryDomainEvent(event eventstore.Event) error {
domain := new(OrgDomain)
err := domain.SetData(event)
if err != nil {
return err
}
for _, d := range o.Domains {
d.Primary = false
if d.Domain == domain.Domain {
d.Primary = true
}
}
return nil
}
func (o *Org) appendVerificationDomainEvent(event eventstore.Event) error {
domain := new(OrgDomain)
err := domain.SetData(event)
if err != nil {
return err
}
for _, d := range o.Domains {
if d.Domain == domain.Domain {
d.ValidationType = domain.ValidationType
d.ValidationCode = domain.ValidationCode
}
}
return nil
}
func (m *OrgDomain) SetData(event eventstore.Event) error {
err := event.Unmarshal(m)
if err != nil {
return zerrors.ThrowInternal(err, "EVENT-Hz7Mb", "unable to unmarshal data")
}
return nil
}
func OrgDomainsFromModel(domains []*model.OrgDomain) []*OrgDomain {
convertedDomainss := make([]*OrgDomain, len(domains))
for i, m := range domains {
convertedDomainss[i] = OrgDomainFromModel(m)
}
return convertedDomainss
}
func OrgDomainFromModel(domain *model.OrgDomain) *OrgDomain {
return &OrgDomain{
ObjectRoot: domain.ObjectRoot,
Domain: domain.Domain,
Verified: domain.Verified,
Primary: domain.Primary,
ValidationType: int32(domain.ValidationType),
ValidationCode: domain.ValidationCode,
}
}
func OrgDomainsToModel(domains []*OrgDomain) []*model.OrgDomain {
convertedDomains := make([]*model.OrgDomain, len(domains))
for i, m := range domains {
convertedDomains[i] = OrgDomainToModel(m)
}
return convertedDomains
}
func OrgDomainToModel(domain *OrgDomain) *model.OrgDomain {
return &model.OrgDomain{
ObjectRoot: domain.ObjectRoot,
Domain: domain.Domain,
Primary: domain.Primary,
Verified: domain.Verified,
ValidationType: model.OrgDomainValidationType(domain.ValidationType),
ValidationCode: domain.ValidationCode,
}
}

View File

@@ -0,0 +1,24 @@
package model
import (
"github.com/zitadel/zitadel/internal/eventstore"
iam_es_model "github.com/zitadel/zitadel/internal/iam/repository/eventsourcing/model"
)
func (o *Org) appendAddDomainPolicyEvent(event eventstore.Event) error {
o.DomainPolicy = new(iam_es_model.DomainPolicy)
err := o.DomainPolicy.SetData(event)
if err != nil {
return err
}
o.DomainPolicy.ObjectRoot.CreationDate = event.CreatedAt()
return nil
}
func (o *Org) appendChangeDomainPolicyEvent(event eventstore.Event) error {
return o.DomainPolicy.SetData(event)
}
func (o *Org) appendRemoveDomainPolicyEvent() {
o.DomainPolicy = nil
}

View File

@@ -0,0 +1,99 @@
package model
import (
"github.com/zitadel/zitadel/internal/eventstore"
es_models "github.com/zitadel/zitadel/internal/eventstore/v1/models"
iam_es_model "github.com/zitadel/zitadel/internal/iam/repository/eventsourcing/model"
org_model "github.com/zitadel/zitadel/internal/org/model"
"github.com/zitadel/zitadel/internal/repository/org"
"github.com/zitadel/zitadel/internal/zerrors"
)
type Org struct {
es_models.ObjectRoot `json:"-"`
Name string `json:"name,omitempty"`
State int32 `json:"-"`
Domains []*OrgDomain `json:"-"`
DomainPolicy *iam_es_model.DomainPolicy `json:"-"`
}
func OrgToModel(org *Org) *org_model.Org {
converted := &org_model.Org{
ObjectRoot: org.ObjectRoot,
Name: org.Name,
State: org_model.OrgState(org.State),
Domains: OrgDomainsToModel(org.Domains),
}
if org.DomainPolicy != nil {
converted.DomainPolicy = iam_es_model.DomainPolicyToModel(org.DomainPolicy)
}
return converted
}
func OrgFromEvents(org *Org, events ...eventstore.Event) (*Org, error) {
if org == nil {
org = new(Org)
}
return org, org.AppendEvents(events...)
}
func (o *Org) AppendEvents(events ...eventstore.Event) error {
for _, event := range events {
err := o.AppendEvent(event)
if err != nil {
return err
}
}
return nil
}
func (o *Org) AppendEvent(event eventstore.Event) (err error) {
switch event.Type() {
case org.OrgAddedEventType:
err = o.SetData(event)
if err != nil {
return err
}
case org.OrgChangedEventType:
err = o.SetData(event)
if err != nil {
return err
}
case org.OrgDeactivatedEventType:
o.State = int32(org_model.OrgStateInactive)
case org.OrgReactivatedEventType:
o.State = int32(org_model.OrgStateActive)
case org.OrgDomainAddedEventType:
err = o.appendAddDomainEvent(event)
case org.OrgDomainVerificationAddedEventType:
err = o.appendVerificationDomainEvent(event)
case org.OrgDomainVerifiedEventType:
err = o.appendVerifyDomainEvent(event)
case org.OrgDomainPrimarySetEventType:
err = o.appendPrimaryDomainEvent(event)
case org.OrgDomainRemovedEventType:
err = o.appendRemoveDomainEvent(event)
case org.DomainPolicyAddedEventType:
err = o.appendAddDomainPolicyEvent(event)
case org.DomainPolicyChangedEventType:
err = o.appendChangeDomainPolicyEvent(event)
case org.DomainPolicyRemovedEventType:
o.appendRemoveDomainPolicyEvent()
}
if err != nil {
return err
}
o.ObjectRoot.AppendEvent(event)
return nil
}
func (o *Org) SetData(event eventstore.Event) error {
err := event.Unmarshal(o)
if err != nil {
return zerrors.ThrowInternal(err, "EVENT-BpbQZ", "unable to unmarshal event")
}
return nil
}

View File

@@ -0,0 +1,118 @@
package model
import (
"encoding/json"
"testing"
"github.com/zitadel/zitadel/internal/eventstore"
es_models "github.com/zitadel/zitadel/internal/eventstore/v1/models"
"github.com/zitadel/zitadel/internal/org/model"
"github.com/zitadel/zitadel/internal/repository/org"
)
func TestOrgFromEvents(t *testing.T) {
type args struct {
event []eventstore.Event
org *Org
}
tests := []struct {
name string
args args
result *Org
}{
{
name: "org from events, ok",
args: args{
event: []eventstore.Event{
&es_models.Event{AggregateID: "ID", Seq: 1, Typ: org.OrgAddedEventType},
},
org: &Org{Name: "OrgName"},
},
result: &Org{ObjectRoot: es_models.ObjectRoot{AggregateID: "ID"}, State: int32(model.OrgStateActive), Name: "OrgName"},
},
{
name: "org from events, nil org",
args: args{
event: []eventstore.Event{
&es_models.Event{AggregateID: "ID", Seq: 1, Typ: org.OrgAddedEventType},
},
org: nil,
},
result: &Org{ObjectRoot: es_models.ObjectRoot{AggregateID: "ID"}, State: int32(model.OrgStateActive)},
},
}
for _, tt := range tests {
t.Run(tt.name, func(t *testing.T) {
if tt.args.org != nil {
data, _ := json.Marshal(tt.args.org)
tt.args.event[0].(*es_models.Event).Data = data
}
result, _ := OrgFromEvents(tt.args.org, tt.args.event...)
if result.Name != tt.result.Name {
t.Errorf("got wrong result name: expected: %v, actual: %v ", tt.result.Name, result.Name)
}
})
}
}
func TestAppendEvent(t *testing.T) {
type args struct {
event *es_models.Event
org *Org
}
tests := []struct {
name string
args args
result *Org
}{
{
name: "append added event",
args: args{
event: &es_models.Event{AggregateID: "ID", Seq: 1, Typ: org.OrgAddedEventType},
org: &Org{Name: "OrgName"},
},
result: &Org{ObjectRoot: es_models.ObjectRoot{AggregateID: "ID"}, State: int32(model.OrgStateActive), Name: "OrgName"},
},
{
name: "append change event",
args: args{
event: &es_models.Event{AggregateID: "ID", Seq: 1, Typ: org.OrgChangedEventType, Data: []byte(`{"name": "OrgName}`)},
org: &Org{Name: "OrgNameChanged"},
},
result: &Org{ObjectRoot: es_models.ObjectRoot{AggregateID: "ID"}, State: int32(model.OrgStateActive), Name: "OrgNameChanged"},
},
{
name: "append deactivate event",
args: args{
event: &es_models.Event{AggregateID: "ID", Seq: 1, Typ: org.OrgDeactivatedEventType},
},
result: &Org{ObjectRoot: es_models.ObjectRoot{AggregateID: "ID"}, State: int32(model.OrgStateInactive)},
},
{
name: "append reactivate event",
args: args{
event: &es_models.Event{AggregateID: "ID", Seq: 1, Typ: org.OrgReactivatedEventType},
},
result: &Org{ObjectRoot: es_models.ObjectRoot{AggregateID: "ID"}, State: int32(model.OrgStateActive)},
},
}
for _, tt := range tests {
t.Run(tt.name, func(t *testing.T) {
if tt.args.org != nil {
data, _ := json.Marshal(tt.args.org)
tt.args.event.Data = data
}
result := &Org{}
result.AppendEvent(tt.args.event)
if result.State != tt.result.State {
t.Errorf("got wrong result state: expected: %v, actual: %v ", tt.result.State, result.State)
}
if result.Name != tt.result.Name {
t.Errorf("got wrong result name: expected: %v, actual: %v ", tt.result.Name, result.Name)
}
if result.ObjectRoot.AggregateID != tt.result.ObjectRoot.AggregateID {
t.Errorf("got wrong result id: expected: %v, actual: %v ", tt.result.ObjectRoot.AggregateID, result.ObjectRoot.AggregateID)
}
})
}
}

View File

@@ -0,0 +1,35 @@
package view
import (
"github.com/zitadel/zitadel/internal/eventstore"
"github.com/zitadel/zitadel/internal/repository/org"
"github.com/zitadel/zitadel/internal/zerrors"
)
func OrgByIDQuery(id, instanceID string, latestSequence uint64) (*eventstore.SearchQueryBuilder, error) {
if id == "" {
return nil, zerrors.ThrowPreconditionFailed(nil, "EVENT-dke74", "id should be filled")
}
return eventstore.NewSearchQueryBuilder(eventstore.ColumnsEvent).
InstanceID(instanceID).
AwaitOpenTransactions().
SequenceGreater(latestSequence).
AddQuery().
AggregateTypes(org.AggregateType).
AggregateIDs(id).
EventTypes(
org.OrgAddedEventType,
org.OrgChangedEventType,
org.OrgDeactivatedEventType,
org.OrgReactivatedEventType,
org.OrgDomainAddedEventType,
org.OrgDomainVerificationAddedEventType,
org.OrgDomainVerifiedEventType,
org.OrgDomainPrimarySetEventType,
org.OrgDomainRemovedEventType,
org.DomainPolicyAddedEventType,
org.DomainPolicyChangedEventType,
org.DomainPolicyRemovedEventType,
).
Builder(), nil
}