From ab283f89c38534838b183834b4b13893dadd302e Mon Sep 17 00:00:00 2001 From: Vivek Patel Date: Wed, 18 Jan 2023 17:02:48 +0530 Subject: [PATCH] Fix saving issue with module discovery settings By Migrating discovery settings to support multi-language, and updated module discovery config struct to support multi lang result. --- server/discovery/types/resource_meta.go | 2 +- server/store/adapters/rdbms/upgrade_fixes.go | 185 ++++++++++++++++++- 2 files changed, 183 insertions(+), 4 deletions(-) diff --git a/server/discovery/types/resource_meta.go b/server/discovery/types/resource_meta.go index 517c2bf20..8090cbb80 100644 --- a/server/discovery/types/resource_meta.go +++ b/server/discovery/types/resource_meta.go @@ -46,7 +46,7 @@ type ( } AccessJson struct { - Result Result `json:"result"` + Result []Result `json:"result"` } Result struct { diff --git a/server/store/adapters/rdbms/upgrade_fixes.go b/server/store/adapters/rdbms/upgrade_fixes.go index d5fde5bc2..e75a32b55 100644 --- a/server/store/adapters/rdbms/upgrade_fixes.go +++ b/server/store/adapters/rdbms/upgrade_fixes.go @@ -7,6 +7,7 @@ import ( "fmt" "github.com/cortezaproject/corteza/server/compose/model" "github.com/cortezaproject/corteza/server/compose/types" + discovery "github.com/cortezaproject/corteza/server/discovery/types" "github.com/cortezaproject/corteza/server/pkg/dal" "github.com/cortezaproject/corteza/server/pkg/errors" "github.com/cortezaproject/corteza/server/pkg/filter" @@ -32,6 +33,7 @@ import ( var ( // all enabled fix function need to be listed here fixes = []func(context.Context, *Store) error{ + fix_2022_09_00_migrateComposeModuleDiscoveryConfigSettings, fix_2022_09_00_extendComposeModuleForPrivacyAndDAL, fix_2022_09_00_extendComposeModuleFieldsForPrivacyAndDAL, fix_2022_09_00_dropObsoleteComposeModuleFields, @@ -47,6 +49,183 @@ var ( } ) +func fix_2022_09_00_migrateComposeModuleDiscoveryConfigSettings(ctx context.Context, s *Store) (err error) { + type ( + oldS struct { + Discovery struct { + Public interface{} `json:"public"` + Private interface{} `json:"private"` + Protected interface{} `json:"protected"` + } `json:"discovery"` + + DAL interface{} `json:"dal"` + Privacy interface{} `json:"privacy"` + RecordRevisions interface{} `json:"recordRevisions"` + RecordDeDup interface{} `json:"recordDeDup"` + } + + result struct { + Result discovery.Result `json:"result"` + } + + updateModule struct { + ID uint64 `json:"id"` + Config []byte `json:"config"` + } + ) + + var ( + log = s.log(ctx) + query string + auxID uint64 + aux []byte + rows *sql.Rows + ss oldS + + uu []updateModule + + driver = s.DB.DriverName() + ) + + const ( + getModuleDiscoverySettings = ` + SELECT id, compose_module.config AS discovery + FROM compose_module` + + updateModuleDiscoverySettings = ` + UPDATE compose_module + SET config = CAST('%s' AS JSON) + WHERE id = %d` + + updatePSQLModuleDiscoverySettings = ` + UPDATE compose_module + SET config = '%s'::jsonb + WHERE id = %d` + ) + + // 1. Check if module has discovery settings + // 2. If yes, migrate them to new format from json to json slice for multiple lang support + // 3. Save module + + _, err = s.DataDefiner.TableLookup(ctx, model.Module.Ident) + if err != nil { + if errors.IsNotFound(err) { + log.Debug("skipping module config recordDeDup migration: compose_module table not found") + return nil + } + return err + } + + _ = s.Tx(ctx, func(ctx context.Context, s store.Storer) (err error) { + query = fmt.Sprintf(getModuleDiscoverySettings) + rows, err = s.(*Store).DB.QueryContext(ctx, query) + if err != nil { + return + } + + defer func() { + // assign error to return value... + err = rows.Close() + }() + + for rows.Next() { + if err = rows.Err(); err != nil { + return + } + + err = rows.Scan(&auxID, &aux) + if err != nil { + continue + } + + if aux == nil { + continue + } + + err = json.Unmarshal(aux, &ss) + if err != nil { + continue + } + + var ( + bb []byte + settings discovery.ModuleMeta + migrateSetting = func(input interface{}) (out result) { + var ( + ok bool + ii map[string]interface{} + rr []interface{} + res interface{} + ) + + if input != nil { + ii, ok = input.(map[string]interface{}) + if ok { + if ii["result"] != nil { + rr, ok = ii["result"].([]interface{}) + if !ok { + res, ok = ii["result"].(interface{}) + if ok { + rr = append(rr, res) + } + } + if ok { + for _, r := range rr { + out.Result.Lang = r.(map[string]interface{})["lang"].(string) + out.Result.Fields = []string{} + if _, ok = r.(map[string]interface{})["fields"].([]interface{}); ok { + for _, f := range r.(map[string]interface{})["fields"].([]interface{}) { + out.Result.Fields = append(out.Result.Fields, f.(string)) + } + } + } + } + } + } + } + return + } + ) + + settings.Public.Result = append(settings.Public.Result, migrateSetting(ss.Discovery.Public).Result) + settings.Private.Result = append(settings.Private.Result, migrateSetting(ss.Discovery.Private).Result) + settings.Protected.Result = append(settings.Protected.Result, migrateSetting(ss.Discovery.Protected).Result) + + ss.Discovery.Public = settings.Public + ss.Discovery.Private = settings.Private + ss.Discovery.Protected = settings.Protected + + bb, err = json.Marshal(ss) + if err != nil { + continue + } + + uu = append(uu, updateModule{ + ID: auxID, + Config: bb, + }) + } + + for _, u := range uu { + if driver == "postgres" || driver == "postgres+debug" { + query = fmt.Sprintf(updatePSQLModuleDiscoverySettings, u.Config, u.ID) + } else { + query = fmt.Sprintf(updateModuleDiscoverySettings, u.Config, u.ID) + } + log.Debug("saving migrated module.config.discovery settings", zap.Uint64("id", u.ID)) + _, err = s.(*Store).DB.ExecContext(ctx, query) + if err != nil { + log.Debug("error saving migrated module.config.discovery settings", zap.Uint64("id", u.ID)) + continue + } + } + + return + }) + + return +} + func fix_2022_09_00_extendComposeModuleForPrivacyAndDAL(ctx context.Context, s *Store) (err error) { return addColumn(ctx, s, "compose_module", @@ -514,7 +693,7 @@ func fix_2023_03_00_migrateComposeModuleConfigForRecordDeDup(ctx context.Context ) if err = s.Tx(ctx, func(ctx context.Context, s store.Storer) (err error) { - log.Info("collecting module.config.recordDeDup for module", zap.Uint64("id", m.ID)) + log.Debug("collecting module.config.recordDeDup for module", zap.Uint64("id", m.ID)) query = fmt.Sprintf(moduleConfigRecordDeDup, m.ID) rows, err = s.(*Store).DB.QueryContext(ctx, query) @@ -572,9 +751,9 @@ func fix_2023_03_00_migrateComposeModuleConfigForRecordDeDup(ctx context.Context if len(migratedRules) > 0 { m.Config.RecordDeDup.Rules = migratedRules - log.Info("saving migrated module.config.recordDeDup for module", zap.Uint64("id", m.ID)) + log.Debug("saving migrated module.config.recordDeDup for module", zap.Uint64("id", m.ID)) if err = s.UpdateComposeModule(ctx, m); err != nil { - log.Info("error saving migrated module.config.recordDeDup for module", zap.Uint64("id", m.ID)) + log.Debug("error saving migrated module.config.recordDeDup for module", zap.Uint64("id", m.ID)) return } }