TheArchive/zitadel
1
0
Fork 0
mirror of https://github.com/zitadel/zitadel.git synced 2025-01-12 10:53:39 +00:00
Code Issues Packages Projects Releases Wiki Activity

fix: refactor object-changes (#430)

Browse Source
This commit is contained in:
Silvan 2020-07-09 16:32:49 +02:00 committed by GitHub
parent 49a3339425
commit a1e8385714
No known key found for this signature in database
GPG Key ID: 4AEE18F83AFDEB23
3 changed files with 78 additions and 108 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

38
internal/org/repository/eventsourcing/eventstore.go
View File

@ -3,7 +3,6 @@ package eventsourcing
import (
"context"
"encoding/json"
"log"
"github.com/caos/zitadel/internal/config/systemdefaults"
@ -211,38 +210,35 @@ func (es *OrgEventstore) OrgChanges(ctx context.Context, id string, lastSequence
return nil, errors.ThrowNotFound(nil, "EVENT-FpQqK", "Errors.Changes.NotFound")
}
result := make([]*org_model.OrgChange, 0)
changes := make([]*org_model.OrgChange, len(events))
for _, u := range events {
creationDate, err := ptypes.TimestampProto(u.CreationDate)
for i, event := range events {
creationDate, err := ptypes.TimestampProto(event.CreationDate)
logging.Log("EVENT-qxIR7").OnError(err).Debug("unable to parse timestamp")
change := &org_model.OrgChange{
ChangeDate: creationDate,
EventType: u.Type.String(),
ModifierId: u.EditorUser,
Sequence: u.Sequence,
EventType: event.Type.String(),
ModifierId: event.EditorUser,
Sequence: event.Sequence,
}
orgDummy := model.Org{}
if u.Data != nil {
if err := json.Unmarshal(u.Data, &orgDummy); err != nil {
log.Println("Error getting data!", err.Error())
}
if event.Data != nil {
org := new(model.Org)
err := json.Unmarshal(event.Data, org)
logging.Log("EVENT-XCLEm").OnError(err).Debug("unable to unmarshal data")
change.Data = org
}
change.Data = orgDummy
result = append(result, change)
if lastSequence < u.Sequence {
lastSequence = u.Sequence
changes[i] = change
if lastSequence < event.Sequence {
lastSequence = event.Sequence
}
}
changes := &org_model.OrgChanges{
Changes: result,
return &org_model.OrgChanges{
Changes: changes,
LastSequence: lastSequence,
}
return changes, nil
}, nil
}
func ChangesQuery(orgID string, latestSequence, limit uint64, sortAscending bool) *es_models.SearchQuery {

112
internal/project/repository/eventsourcing/eventstore.go
View File

@ -3,7 +3,6 @@ package eventsourcing
import (
"context"
"encoding/json"
"log"
"strings"
"github.com/caos/logging"
@ -377,48 +376,40 @@ func (es *ProjectEventstore) ProjectChanges(ctx context.Context, id string, last
return nil, caos_errs.ThrowNotFound(nil, "EVENT-FpQqK", "Errors.Changes.NotFound")
}
result := make([]*proj_model.ProjectChange, 0)
changes := make([]*proj_model.ProjectChange, len(events))
for _, u := range events {
creationDate, err := ptypes.TimestampProto(u.CreationDate)
for i, event := range events {
creationDate, err := ptypes.TimestampProto(event.CreationDate)
logging.Log("EVENT-qxIR7").OnError(err).Debug("unable to parse timestamp")
change := &proj_model.ProjectChange{
ChangeDate: creationDate,
EventType: u.Type.String(),
ModifierId: u.EditorUser,
Sequence: u.Sequence,
EventType: event.Type.String(),
ModifierId: event.EditorUser,
Sequence: event.Sequence,
}
projectDummy := proj_model.Project{}
appDummy := model.Application{}
change.Data = projectDummy
if u.Data != nil {
if event.Data != nil {
var data interface{}
if strings.Contains(change.EventType, "application") {
if err := json.Unmarshal(u.Data, &appDummy); err != nil {
log.Println("Error getting data!", err.Error())
}
change.Data = appDummy
data = new(model.Application)
} else {
if err := json.Unmarshal(u.Data, &projectDummy); err != nil {
log.Println("Error getting data!", err.Error())
}
change.Data = projectDummy
data = new(model.Project)
}
err = json.Unmarshal(event.Data, data)
logging.Log("EVENT-NCkpN").OnError(err).Debug("unable to unmarshal data")
change.Data = data
}
result = append(result, change)
if lastSequence < u.Sequence {
lastSequence = u.Sequence
changes[i] = change
if lastSequence < event.Sequence {
lastSequence = event.Sequence
}
}
changes := &proj_model.ProjectChanges{
Changes: result,
return &proj_model.ProjectChanges{
Changes: changes,
LastSequence: lastSequence,
}
return changes, nil
}, nil
}
func ChangesQuery(projID string, latestSequence, limit uint64, sortAscending bool) *es_models.SearchQuery {
@ -543,10 +534,10 @@ func (es *ProjectEventstore) RemoveApplication(ctx context.Context, app *proj_mo
return nil
}
func (es *ProjectEventstore) ApplicationChanges(ctx context.Context, id string, secId string, lastSequence uint64, limit uint64, sortAscending bool) (*proj_model.ApplicationChanges, error) {
query := ChangesQuery(id, lastSequence, limit, sortAscending)
func (es *ProjectEventstore) ApplicationChanges(ctx context.Context, projectID string, appID string, lastSequence uint64, limit uint64, sortAscending bool) (*proj_model.ApplicationChanges, error) {
query := ChangesQuery(projectID, lastSequence, limit, sortAscending)
events, err := es.Eventstore.FilterEvents(context.Background(), query)
events, err := es.Eventstore.FilterEvents(ctx, query)
if err != nil {
logging.Log("EVENT-ZRffs").WithError(err).Warn("eventstore unavailable")
return nil, errors.ThrowInternal(err, "EVENT-sw6Ku", "Errors.Internal")
@ -556,50 +547,37 @@ func (es *ProjectEventstore) ApplicationChanges(ctx context.Context, id string,
}
result := make([]*proj_model.ApplicationChange, 0)
for _, event := range events {
if !strings.Contains(event.Type.String(), "application") || event.Data == nil {
continue
}
for _, u := range events {
creationDate, err := ptypes.TimestampProto(u.CreationDate)
app := new(model.Application)
err := json.Unmarshal(event.Data, app)
logging.Log("EVENT-GIiKD").OnError(err).Debug("unable to unmarshal data")
if app.AppID != appID {
continue
}
creationDate, err := ptypes.TimestampProto(event.CreationDate)
logging.Log("EVENT-MJzeN").OnError(err).Debug("unable to parse timestamp")
change := &proj_model.ApplicationChange{
result = append(result, &proj_model.ApplicationChange{
ChangeDate: creationDate,
EventType: u.Type.String(),
ModifierId: u.EditorUser,
Sequence: u.Sequence,
}
appendChanges := true
if change.EventType == model.ApplicationAdded.String() ||
change.EventType == model.ApplicationChanged.String() ||
change.EventType == model.OIDCConfigAdded.String() ||
change.EventType == model.OIDCConfigChanged.String() {
appDummy := model.Application{}
if u.Data != nil {
if err := json.Unmarshal(u.Data, &appDummy); err != nil {
log.Println("Error getting data!", err.Error())
}
}
change.Data = appDummy
if appDummy.AppID != secId {
appendChanges = false
}
} else {
appendChanges = false
}
if appendChanges {
result = append(result, change)
if lastSequence < u.Sequence {
lastSequence = u.Sequence
}
EventType: event.Type.String(),
ModifierId: event.EditorUser,
Sequence: event.Sequence,
Data: app,
})
if lastSequence < event.Sequence {
lastSequence = event.Sequence
}
}
changes := &proj_model.ApplicationChanges{
return &proj_model.ApplicationChanges{
Changes: result,
LastSequence: lastSequence,
}
return changes, nil
}, nil
}
func (es *ProjectEventstore) DeactivateApplication(ctx context.Context, projectID, appID string) (*proj_model.Application, error) {

36
internal/user/repository/eventsourcing/eventstore.go
View File

@ -3,7 +3,6 @@ package eventsourcing
import (
"context"
"encoding/json"
"log"
"github.com/caos/logging"
"github.com/caos/zitadel/internal/errors"
@ -291,38 +290,35 @@ func (es *UserEventstore) UserChanges(ctx context.Context, id string, lastSequen
return nil, caos_errs.ThrowNotFound(nil, "EVENT-6cAxe", "Errors.User.NoChanges")
}
result := make([]*usr_model.UserChange, 0)
result := make([]*usr_model.UserChange, len(events))
for _, u := range events {
creationDate, err := ptypes.TimestampProto(u.CreationDate)
for i, event := range events {
creationDate, err := ptypes.TimestampProto(event.CreationDate)
logging.Log("EVENT-8GTGS").OnError(err).Debug("unable to parse timestamp")
change := &usr_model.UserChange{
ChangeDate: creationDate,
EventType: u.Type.String(),
ModifierId: u.EditorUser,
Sequence: u.Sequence,
EventType: event.Type.String(),
ModifierId: event.EditorUser,
Sequence: event.Sequence,
}
userDummy := model.Profile{}
if u.Data != nil {
if err := json.Unmarshal(u.Data, &userDummy); err != nil {
log.Println("Error getting data!", err.Error())
}
if event.Data != nil {
user := new(model.Profile)
err := json.Unmarshal(event.Data, user)
logging.Log("EVENT-Rkg7X").OnError(err).Debug("unable to unmarshal data")
change.Data = user
}
change.Data = userDummy
result = append(result, change)
if lastSequence < u.Sequence {
lastSequence = u.Sequence
result[i] = change
if lastSequence < event.Sequence {
lastSequence = event.Sequence
}
}
changes := &usr_model.UserChanges{
return &usr_model.UserChanges{
Changes: result,
LastSequence: lastSequence,
}
return changes, nil
}, nil
}
func ChangesQuery(userID string, latestSequence, limit uint64, sortAscending bool) *es_models.SearchQuery {