From 4d751c1875cc5e303ed3e420b3d5c8e4079a6900 Mon Sep 17 00:00:00 2001 From: Denis Arh Date: Tue, 26 May 2020 19:02:32 +0200 Subject: [PATCH] Improve actionlog err/message placeholder replacement --- codegen/v2/actionlog/actions.gen.go.tpl | 35 ++++- codegen/v2/actionlog/main.go | 14 +- system/service/access_control_actions.gen.go | 34 ++++- system/service/application_actions.gen.go | 76 ++++++++-- system/service/attachment_actions.gen.go | 68 ++++++--- system/service/auth_actions.gen.go | 78 +++++++--- system/service/reminder_actions.gen.go | 115 ++++++++++---- system/service/role_actions.gen.go | 151 ++++++++++++++----- system/service/sink_actions.gen.go | 48 ++++-- system/service/statistics_actions.gen.go | 4 +- system/service/user_actions.gen.go | 141 ++++++++++++----- 11 files changed, 580 insertions(+), 184 deletions(-) diff --git a/codegen/v2/actionlog/actions.gen.go.tpl b/codegen/v2/actionlog/actions.gen.go.tpl index 8f52b720f..3219b095a 100644 --- a/codegen/v2/actionlog/actions.gen.go.tpl +++ b/codegen/v2/actionlog/actions.gen.go.tpl @@ -113,7 +113,22 @@ func (p {{ $.Service }}ActionProps) serialize() actionlog.Meta { // This function is auto-generated. // func (p {{ $.Service }}ActionProps) tr(in string, err error) string { - var pairs = []string{"{err}"} + var ( + pairs = []string{"{err}"} + +{{- if $.Props }} + // first non-empty string + fns = func(ii ... interface{}) string { + for _, i:= range ii { + if s :=fmt.Sprintf("%v", i); len(s) > 0 { + return s + } + } + + return "" + } +{{- end }} + ) if err != nil { for { @@ -133,17 +148,23 @@ func (p {{ $.Service }}ActionProps) tr(in string, err error) string { {{- range $prop := $.Props }} {{- if $prop.Builtin }} - pairs = append(pairs, "{{"{"}}{{ $prop.Name }}}", fmt.Sprintf("%v", p.{{ $prop.Name }})) + pairs = append(pairs, "{{"{"}}{{ $prop.Name }}}", fns(p.{{ $prop.Name }})) {{- else }} if p.{{ $prop.Name }} != nil { - {{- if $prop.DefaultField }} - pairs = append(pairs, "{{"{"}}{{ $prop.Name }}}", fmt.Sprintf("%v", p.{{ $prop.Name }}.{{ camelCase " " $prop.DefaultField }})) - {{- end }} + // replacement for "{{"{"}}{{ $prop.Name }}}" (in order how fields are defined) + pairs = append( + pairs, + "{{"{"}}{{ $prop.Name }}}", + fns( + {{- range $f := $prop.Fields }} + p.{{ $prop.Name }}.{{ camelCase " " $f }}, + {{- end }} + ), + ) {{- range $f := $prop.Fields }} - pairs = append(pairs, "{{"{"}}{{ $prop.Name }}.{{ $f }}}", fmt.Sprintf("%v", p.{{ $prop.Name }}.{{ camelCase " " $f }})) - + pairs = append(pairs, "{{"{"}}{{ $prop.Name }}.{{ $f }}}", fns(p.{{ $prop.Name }}.{{ camelCase " " $f }})) {{- end }} } {{- end }} diff --git a/codegen/v2/actionlog/main.go b/codegen/v2/actionlog/main.go index 8090fc147..159b03812 100644 --- a/codegen/v2/actionlog/main.go +++ b/codegen/v2/actionlog/main.go @@ -23,11 +23,10 @@ type ( // List of event/log properties that can/will be captured // and injected into log or message string propsDef struct { - Name string - Type string - Fields []string - DefaultField string - Builtin bool + Name string + Type string + Fields []string + Builtin bool } actionDef struct { @@ -195,11 +194,6 @@ func procDef(path, output string) { knownProps[m.Name] = true - if len(m.Fields) > 0 { - m.DefaultField = m.Fields[0] - - } - for _, f := range m.Fields { knownProps[fmt.Sprintf("%s.%s", m.Name, f)] = true diff --git a/system/service/access_control_actions.gen.go b/system/service/access_control_actions.gen.go index 626d6ff22..bcd79a647 100644 --- a/system/service/access_control_actions.gen.go +++ b/system/service/access_control_actions.gen.go @@ -89,7 +89,19 @@ func (p accessControlActionProps) serialize() actionlog.Meta { // This function is auto-generated. // func (p accessControlActionProps) tr(in string, err error) string { - var pairs = []string{"{err}"} + var ( + pairs = []string{"{err}"} + // first non-empty string + fns = func(ii ...interface{}) string { + for _, i := range ii { + if s := fmt.Sprintf("%v", i); len(s) > 0 { + return s + } + } + + return "" + } + ) if err != nil { for { @@ -108,11 +120,21 @@ func (p accessControlActionProps) tr(in string, err error) string { } if p.rule != nil { - pairs = append(pairs, "{rule}", fmt.Sprintf("%v", p.rule.Operation)) - pairs = append(pairs, "{rule.operation}", fmt.Sprintf("%v", p.rule.Operation)) - pairs = append(pairs, "{rule.roleID}", fmt.Sprintf("%v", p.rule.RoleID)) - pairs = append(pairs, "{rule.access}", fmt.Sprintf("%v", p.rule.Access)) - pairs = append(pairs, "{rule.resource}", fmt.Sprintf("%v", p.rule.Resource)) + // replacement for "{rule}" (in order how fields are defined) + pairs = append( + pairs, + "{rule}", + fns( + p.rule.Operation, + p.rule.RoleID, + p.rule.Access, + p.rule.Resource, + ), + ) + pairs = append(pairs, "{rule.operation}", fns(p.rule.Operation)) + pairs = append(pairs, "{rule.roleID}", fns(p.rule.RoleID)) + pairs = append(pairs, "{rule.access}", fns(p.rule.Access)) + pairs = append(pairs, "{rule.resource}", fns(p.rule.Resource)) } return strings.NewReplacer(pairs...).Replace(in) } diff --git a/system/service/application_actions.gen.go b/system/service/application_actions.gen.go index 137b47545..c64659adb 100644 --- a/system/service/application_actions.gen.go +++ b/system/service/application_actions.gen.go @@ -137,7 +137,19 @@ func (p applicationActionProps) serialize() actionlog.Meta { // This function is auto-generated. // func (p applicationActionProps) tr(in string, err error) string { - var pairs = []string{"{err}"} + var ( + pairs = []string{"{err}"} + // first non-empty string + fns = func(ii ...interface{}) string { + for _, i := range ii { + if s := fmt.Sprintf("%v", i); len(s) > 0 { + return s + } + } + + return "" + } + ) if err != nil { for { @@ -156,29 +168,63 @@ func (p applicationActionProps) tr(in string, err error) string { } if p.application != nil { - pairs = append(pairs, "{application}", fmt.Sprintf("%v", p.application.Name)) - pairs = append(pairs, "{application.name}", fmt.Sprintf("%v", p.application.Name)) - pairs = append(pairs, "{application.ID}", fmt.Sprintf("%v", p.application.ID)) + // replacement for "{application}" (in order how fields are defined) + pairs = append( + pairs, + "{application}", + fns( + p.application.Name, + p.application.ID, + ), + ) + pairs = append(pairs, "{application.name}", fns(p.application.Name)) + pairs = append(pairs, "{application.ID}", fns(p.application.ID)) } if p.new != nil { - pairs = append(pairs, "{new}", fmt.Sprintf("%v", p.new.Name)) - pairs = append(pairs, "{new.name}", fmt.Sprintf("%v", p.new.Name)) - pairs = append(pairs, "{new.ID}", fmt.Sprintf("%v", p.new.ID)) + // replacement for "{new}" (in order how fields are defined) + pairs = append( + pairs, + "{new}", + fns( + p.new.Name, + p.new.ID, + ), + ) + pairs = append(pairs, "{new.name}", fns(p.new.Name)) + pairs = append(pairs, "{new.ID}", fns(p.new.ID)) } if p.update != nil { - pairs = append(pairs, "{update}", fmt.Sprintf("%v", p.update.Name)) - pairs = append(pairs, "{update.name}", fmt.Sprintf("%v", p.update.Name)) - pairs = append(pairs, "{update.ID}", fmt.Sprintf("%v", p.update.ID)) + // replacement for "{update}" (in order how fields are defined) + pairs = append( + pairs, + "{update}", + fns( + p.update.Name, + p.update.ID, + ), + ) + pairs = append(pairs, "{update.name}", fns(p.update.Name)) + pairs = append(pairs, "{update.ID}", fns(p.update.ID)) } if p.filter != nil { - pairs = append(pairs, "{filter}", fmt.Sprintf("%v", p.filter.Query)) - pairs = append(pairs, "{filter.query}", fmt.Sprintf("%v", p.filter.Query)) - pairs = append(pairs, "{filter.name}", fmt.Sprintf("%v", p.filter.Name)) - pairs = append(pairs, "{filter.deleted}", fmt.Sprintf("%v", p.filter.Deleted)) - pairs = append(pairs, "{filter.sort}", fmt.Sprintf("%v", p.filter.Sort)) + // replacement for "{filter}" (in order how fields are defined) + pairs = append( + pairs, + "{filter}", + fns( + p.filter.Query, + p.filter.Name, + p.filter.Deleted, + p.filter.Sort, + ), + ) + pairs = append(pairs, "{filter.query}", fns(p.filter.Query)) + pairs = append(pairs, "{filter.name}", fns(p.filter.Name)) + pairs = append(pairs, "{filter.deleted}", fns(p.filter.Deleted)) + pairs = append(pairs, "{filter.sort}", fns(p.filter.Sort)) } return strings.NewReplacer(pairs...).Replace(in) } diff --git a/system/service/attachment_actions.gen.go b/system/service/attachment_actions.gen.go index 185a175c2..bf2a4672c 100644 --- a/system/service/attachment_actions.gen.go +++ b/system/service/attachment_actions.gen.go @@ -161,7 +161,19 @@ func (p attachmentActionProps) serialize() actionlog.Meta { // This function is auto-generated. // func (p attachmentActionProps) tr(in string, err error) string { - var pairs = []string{"{err}"} + var ( + pairs = []string{"{err}"} + // first non-empty string + fns = func(ii ...interface{}) string { + for _, i := range ii { + if s := fmt.Sprintf("%v", i); len(s) > 0 { + return s + } + } + + return "" + } + ) if err != nil { for { @@ -178,27 +190,49 @@ func (p attachmentActionProps) tr(in string, err error) string { } else { pairs = append(pairs, "nil") } - pairs = append(pairs, "{size}", fmt.Sprintf("%v", p.size)) - pairs = append(pairs, "{name}", fmt.Sprintf("%v", p.name)) - pairs = append(pairs, "{mimetype}", fmt.Sprintf("%v", p.mimetype)) - pairs = append(pairs, "{url}", fmt.Sprintf("%v", p.url)) + pairs = append(pairs, "{size}", fns(p.size)) + pairs = append(pairs, "{name}", fns(p.name)) + pairs = append(pairs, "{mimetype}", fns(p.mimetype)) + pairs = append(pairs, "{url}", fns(p.url)) if p.attachment != nil { - pairs = append(pairs, "{attachment}", fmt.Sprintf("%v", p.attachment.Name)) - pairs = append(pairs, "{attachment.name}", fmt.Sprintf("%v", p.attachment.Name)) - pairs = append(pairs, "{attachment.kind}", fmt.Sprintf("%v", p.attachment.Kind)) - pairs = append(pairs, "{attachment.url}", fmt.Sprintf("%v", p.attachment.Url)) - pairs = append(pairs, "{attachment.previewUrl}", fmt.Sprintf("%v", p.attachment.PreviewUrl)) - pairs = append(pairs, "{attachment.meta}", fmt.Sprintf("%v", p.attachment.Meta)) - pairs = append(pairs, "{attachment.ownerID}", fmt.Sprintf("%v", p.attachment.OwnerID)) - pairs = append(pairs, "{attachment.ID}", fmt.Sprintf("%v", p.attachment.ID)) + // replacement for "{attachment}" (in order how fields are defined) + pairs = append( + pairs, + "{attachment}", + fns( + p.attachment.Name, + p.attachment.Kind, + p.attachment.Url, + p.attachment.PreviewUrl, + p.attachment.Meta, + p.attachment.OwnerID, + p.attachment.ID, + ), + ) + pairs = append(pairs, "{attachment.name}", fns(p.attachment.Name)) + pairs = append(pairs, "{attachment.kind}", fns(p.attachment.Kind)) + pairs = append(pairs, "{attachment.url}", fns(p.attachment.Url)) + pairs = append(pairs, "{attachment.previewUrl}", fns(p.attachment.PreviewUrl)) + pairs = append(pairs, "{attachment.meta}", fns(p.attachment.Meta)) + pairs = append(pairs, "{attachment.ownerID}", fns(p.attachment.OwnerID)) + pairs = append(pairs, "{attachment.ID}", fns(p.attachment.ID)) } if p.filter != nil { - pairs = append(pairs, "{filter}", fmt.Sprintf("%v", p.filter.Filter)) - pairs = append(pairs, "{filter.filter}", fmt.Sprintf("%v", p.filter.Filter)) - pairs = append(pairs, "{filter.kind}", fmt.Sprintf("%v", p.filter.Kind)) - pairs = append(pairs, "{filter.sort}", fmt.Sprintf("%v", p.filter.Sort)) + // replacement for "{filter}" (in order how fields are defined) + pairs = append( + pairs, + "{filter}", + fns( + p.filter.Filter, + p.filter.Kind, + p.filter.Sort, + ), + ) + pairs = append(pairs, "{filter.filter}", fns(p.filter.Filter)) + pairs = append(pairs, "{filter.kind}", fns(p.filter.Kind)) + pairs = append(pairs, "{filter.sort}", fns(p.filter.Sort)) } return strings.NewReplacer(pairs...).Replace(in) } diff --git a/system/service/auth_actions.gen.go b/system/service/auth_actions.gen.go index e1093720e..996cf1f30 100644 --- a/system/service/auth_actions.gen.go +++ b/system/service/auth_actions.gen.go @@ -151,7 +151,19 @@ func (p authActionProps) serialize() actionlog.Meta { // This function is auto-generated. // func (p authActionProps) tr(in string, err error) string { - var pairs = []string{"{err}"} + var ( + pairs = []string{"{err}"} + // first non-empty string + fns = func(ii ...interface{}) string { + for _, i := range ii { + if s := fmt.Sprintf("%v", i); len(s) > 0 { + return s + } + } + + return "" + } + ) if err != nil { for { @@ -168,31 +180,61 @@ func (p authActionProps) tr(in string, err error) string { } else { pairs = append(pairs, "nil") } - pairs = append(pairs, "{email}", fmt.Sprintf("%v", p.email)) - pairs = append(pairs, "{provider}", fmt.Sprintf("%v", p.provider)) + pairs = append(pairs, "{email}", fns(p.email)) + pairs = append(pairs, "{provider}", fns(p.provider)) if p.credentials != nil { - pairs = append(pairs, "{credentials}", fmt.Sprintf("%v", p.credentials.Kind)) - pairs = append(pairs, "{credentials.kind}", fmt.Sprintf("%v", p.credentials.Kind)) - pairs = append(pairs, "{credentials.label}", fmt.Sprintf("%v", p.credentials.Label)) - pairs = append(pairs, "{credentials.ID}", fmt.Sprintf("%v", p.credentials.ID)) + // replacement for "{credentials}" (in order how fields are defined) + pairs = append( + pairs, + "{credentials}", + fns( + p.credentials.Kind, + p.credentials.Label, + p.credentials.ID, + ), + ) + pairs = append(pairs, "{credentials.kind}", fns(p.credentials.Kind)) + pairs = append(pairs, "{credentials.label}", fns(p.credentials.Label)) + pairs = append(pairs, "{credentials.ID}", fns(p.credentials.ID)) } if p.role != nil { - pairs = append(pairs, "{role}", fmt.Sprintf("%v", p.role.Handle)) - pairs = append(pairs, "{role.handle}", fmt.Sprintf("%v", p.role.Handle)) - pairs = append(pairs, "{role.name}", fmt.Sprintf("%v", p.role.Name)) - pairs = append(pairs, "{role.ID}", fmt.Sprintf("%v", p.role.ID)) + // replacement for "{role}" (in order how fields are defined) + pairs = append( + pairs, + "{role}", + fns( + p.role.Handle, + p.role.Name, + p.role.ID, + ), + ) + pairs = append(pairs, "{role.handle}", fns(p.role.Handle)) + pairs = append(pairs, "{role.name}", fns(p.role.Name)) + pairs = append(pairs, "{role.ID}", fns(p.role.ID)) } if p.user != nil { - pairs = append(pairs, "{user}", fmt.Sprintf("%v", p.user.Handle)) - pairs = append(pairs, "{user.handle}", fmt.Sprintf("%v", p.user.Handle)) - pairs = append(pairs, "{user.name}", fmt.Sprintf("%v", p.user.Name)) - pairs = append(pairs, "{user.ID}", fmt.Sprintf("%v", p.user.ID)) - pairs = append(pairs, "{user.email}", fmt.Sprintf("%v", p.user.Email)) - pairs = append(pairs, "{user.suspendedAt}", fmt.Sprintf("%v", p.user.SuspendedAt)) - pairs = append(pairs, "{user.deletedAt}", fmt.Sprintf("%v", p.user.DeletedAt)) + // replacement for "{user}" (in order how fields are defined) + pairs = append( + pairs, + "{user}", + fns( + p.user.Handle, + p.user.Name, + p.user.ID, + p.user.Email, + p.user.SuspendedAt, + p.user.DeletedAt, + ), + ) + pairs = append(pairs, "{user.handle}", fns(p.user.Handle)) + pairs = append(pairs, "{user.name}", fns(p.user.Name)) + pairs = append(pairs, "{user.ID}", fns(p.user.ID)) + pairs = append(pairs, "{user.email}", fns(p.user.Email)) + pairs = append(pairs, "{user.suspendedAt}", fns(p.user.SuspendedAt)) + pairs = append(pairs, "{user.deletedAt}", fns(p.user.DeletedAt)) } return strings.NewReplacer(pairs...).Replace(in) } diff --git a/system/service/reminder_actions.gen.go b/system/service/reminder_actions.gen.go index 4e7c2afae..5d5a83f0b 100644 --- a/system/service/reminder_actions.gen.go +++ b/system/service/reminder_actions.gen.go @@ -150,7 +150,19 @@ func (p reminderActionProps) serialize() actionlog.Meta { // This function is auto-generated. // func (p reminderActionProps) tr(in string, err error) string { - var pairs = []string{"{err}"} + var ( + pairs = []string{"{err}"} + // first non-empty string + fns = func(ii ...interface{}) string { + for _, i := range ii { + if s := fmt.Sprintf("%v", i); len(s) > 0 { + return s + } + } + + return "" + } + ) if err != nil { for { @@ -169,42 +181,89 @@ func (p reminderActionProps) tr(in string, err error) string { } if p.reminder != nil { - pairs = append(pairs, "{reminder}", fmt.Sprintf("%v", p.reminder.Resource)) - pairs = append(pairs, "{reminder.resource}", fmt.Sprintf("%v", p.reminder.Resource)) - pairs = append(pairs, "{reminder.ID}", fmt.Sprintf("%v", p.reminder.ID)) - pairs = append(pairs, "{reminder.assignedTo}", fmt.Sprintf("%v", p.reminder.AssignedTo)) - pairs = append(pairs, "{reminder.assignedBy}", fmt.Sprintf("%v", p.reminder.AssignedBy)) - pairs = append(pairs, "{reminder.remindAt}", fmt.Sprintf("%v", p.reminder.RemindAt)) + // replacement for "{reminder}" (in order how fields are defined) + pairs = append( + pairs, + "{reminder}", + fns( + p.reminder.Resource, + p.reminder.ID, + p.reminder.AssignedTo, + p.reminder.AssignedBy, + p.reminder.RemindAt, + ), + ) + pairs = append(pairs, "{reminder.resource}", fns(p.reminder.Resource)) + pairs = append(pairs, "{reminder.ID}", fns(p.reminder.ID)) + pairs = append(pairs, "{reminder.assignedTo}", fns(p.reminder.AssignedTo)) + pairs = append(pairs, "{reminder.assignedBy}", fns(p.reminder.AssignedBy)) + pairs = append(pairs, "{reminder.remindAt}", fns(p.reminder.RemindAt)) } if p.new != nil { - pairs = append(pairs, "{new}", fmt.Sprintf("%v", p.new.Resource)) - pairs = append(pairs, "{new.resource}", fmt.Sprintf("%v", p.new.Resource)) - pairs = append(pairs, "{new.ID}", fmt.Sprintf("%v", p.new.ID)) - pairs = append(pairs, "{new.assignedTo}", fmt.Sprintf("%v", p.new.AssignedTo)) - pairs = append(pairs, "{new.assignedBy}", fmt.Sprintf("%v", p.new.AssignedBy)) - pairs = append(pairs, "{new.remindAt}", fmt.Sprintf("%v", p.new.RemindAt)) + // replacement for "{new}" (in order how fields are defined) + pairs = append( + pairs, + "{new}", + fns( + p.new.Resource, + p.new.ID, + p.new.AssignedTo, + p.new.AssignedBy, + p.new.RemindAt, + ), + ) + pairs = append(pairs, "{new.resource}", fns(p.new.Resource)) + pairs = append(pairs, "{new.ID}", fns(p.new.ID)) + pairs = append(pairs, "{new.assignedTo}", fns(p.new.AssignedTo)) + pairs = append(pairs, "{new.assignedBy}", fns(p.new.AssignedBy)) + pairs = append(pairs, "{new.remindAt}", fns(p.new.RemindAt)) } if p.updated != nil { - pairs = append(pairs, "{updated}", fmt.Sprintf("%v", p.updated.Resource)) - pairs = append(pairs, "{updated.resource}", fmt.Sprintf("%v", p.updated.Resource)) - pairs = append(pairs, "{updated.ID}", fmt.Sprintf("%v", p.updated.ID)) - pairs = append(pairs, "{updated.assignedTo}", fmt.Sprintf("%v", p.updated.AssignedTo)) - pairs = append(pairs, "{updated.assignedBy}", fmt.Sprintf("%v", p.updated.AssignedBy)) - pairs = append(pairs, "{updated.remindAt}", fmt.Sprintf("%v", p.updated.RemindAt)) + // replacement for "{updated}" (in order how fields are defined) + pairs = append( + pairs, + "{updated}", + fns( + p.updated.Resource, + p.updated.ID, + p.updated.AssignedTo, + p.updated.AssignedBy, + p.updated.RemindAt, + ), + ) + pairs = append(pairs, "{updated.resource}", fns(p.updated.Resource)) + pairs = append(pairs, "{updated.ID}", fns(p.updated.ID)) + pairs = append(pairs, "{updated.assignedTo}", fns(p.updated.AssignedTo)) + pairs = append(pairs, "{updated.assignedBy}", fns(p.updated.AssignedBy)) + pairs = append(pairs, "{updated.remindAt}", fns(p.updated.RemindAt)) } if p.filter != nil { - pairs = append(pairs, "{filter}", fmt.Sprintf("%v", p.filter.Resource)) - pairs = append(pairs, "{filter.resource}", fmt.Sprintf("%v", p.filter.Resource)) - pairs = append(pairs, "{filter.reminderID}", fmt.Sprintf("%v", p.filter.ReminderID)) - pairs = append(pairs, "{filter.assignedTo}", fmt.Sprintf("%v", p.filter.AssignedTo)) - pairs = append(pairs, "{filter.scheduledFrom}", fmt.Sprintf("%v", p.filter.ScheduledFrom)) - pairs = append(pairs, "{filter.scheduledUntil}", fmt.Sprintf("%v", p.filter.ScheduledUntil)) - pairs = append(pairs, "{filter.excludeDismissed}", fmt.Sprintf("%v", p.filter.ExcludeDismissed)) - pairs = append(pairs, "{filter.scheduledOnly}", fmt.Sprintf("%v", p.filter.ScheduledOnly)) - pairs = append(pairs, "{filter.sort}", fmt.Sprintf("%v", p.filter.Sort)) + // replacement for "{filter}" (in order how fields are defined) + pairs = append( + pairs, + "{filter}", + fns( + p.filter.Resource, + p.filter.ReminderID, + p.filter.AssignedTo, + p.filter.ScheduledFrom, + p.filter.ScheduledUntil, + p.filter.ExcludeDismissed, + p.filter.ScheduledOnly, + p.filter.Sort, + ), + ) + pairs = append(pairs, "{filter.resource}", fns(p.filter.Resource)) + pairs = append(pairs, "{filter.reminderID}", fns(p.filter.ReminderID)) + pairs = append(pairs, "{filter.assignedTo}", fns(p.filter.AssignedTo)) + pairs = append(pairs, "{filter.scheduledFrom}", fns(p.filter.ScheduledFrom)) + pairs = append(pairs, "{filter.scheduledUntil}", fns(p.filter.ScheduledUntil)) + pairs = append(pairs, "{filter.excludeDismissed}", fns(p.filter.ExcludeDismissed)) + pairs = append(pairs, "{filter.scheduledOnly}", fns(p.filter.ScheduledOnly)) + pairs = append(pairs, "{filter.sort}", fns(p.filter.Sort)) } return strings.NewReplacer(pairs...).Replace(in) } diff --git a/system/service/role_actions.gen.go b/system/service/role_actions.gen.go index c33e05c89..b34af2b4e 100644 --- a/system/service/role_actions.gen.go +++ b/system/service/role_actions.gen.go @@ -196,7 +196,19 @@ func (p roleActionProps) serialize() actionlog.Meta { // This function is auto-generated. // func (p roleActionProps) tr(in string, err error) string { - var pairs = []string{"{err}"} + var ( + pairs = []string{"{err}"} + // first non-empty string + fns = func(ii ...interface{}) string { + for _, i := range ii { + if s := fmt.Sprintf("%v", i); len(s) > 0 { + return s + } + } + + return "" + } + ) if err != nil { for { @@ -215,58 +227,127 @@ func (p roleActionProps) tr(in string, err error) string { } if p.member != nil { - pairs = append(pairs, "{member}", fmt.Sprintf("%v", p.member.Handle)) - pairs = append(pairs, "{member.handle}", fmt.Sprintf("%v", p.member.Handle)) - pairs = append(pairs, "{member.email}", fmt.Sprintf("%v", p.member.Email)) - pairs = append(pairs, "{member.name}", fmt.Sprintf("%v", p.member.Name)) - pairs = append(pairs, "{member.ID}", fmt.Sprintf("%v", p.member.ID)) + // replacement for "{member}" (in order how fields are defined) + pairs = append( + pairs, + "{member}", + fns( + p.member.Handle, + p.member.Email, + p.member.Name, + p.member.ID, + ), + ) + pairs = append(pairs, "{member.handle}", fns(p.member.Handle)) + pairs = append(pairs, "{member.email}", fns(p.member.Email)) + pairs = append(pairs, "{member.name}", fns(p.member.Name)) + pairs = append(pairs, "{member.ID}", fns(p.member.ID)) } if p.role != nil { - pairs = append(pairs, "{role}", fmt.Sprintf("%v", p.role.Handle)) - pairs = append(pairs, "{role.handle}", fmt.Sprintf("%v", p.role.Handle)) - pairs = append(pairs, "{role.name}", fmt.Sprintf("%v", p.role.Name)) - pairs = append(pairs, "{role.ID}", fmt.Sprintf("%v", p.role.ID)) + // replacement for "{role}" (in order how fields are defined) + pairs = append( + pairs, + "{role}", + fns( + p.role.Handle, + p.role.Name, + p.role.ID, + ), + ) + pairs = append(pairs, "{role.handle}", fns(p.role.Handle)) + pairs = append(pairs, "{role.name}", fns(p.role.Name)) + pairs = append(pairs, "{role.ID}", fns(p.role.ID)) } if p.new != nil { - pairs = append(pairs, "{new}", fmt.Sprintf("%v", p.new.Handle)) - pairs = append(pairs, "{new.handle}", fmt.Sprintf("%v", p.new.Handle)) - pairs = append(pairs, "{new.name}", fmt.Sprintf("%v", p.new.Name)) - pairs = append(pairs, "{new.ID}", fmt.Sprintf("%v", p.new.ID)) + // replacement for "{new}" (in order how fields are defined) + pairs = append( + pairs, + "{new}", + fns( + p.new.Handle, + p.new.Name, + p.new.ID, + ), + ) + pairs = append(pairs, "{new.handle}", fns(p.new.Handle)) + pairs = append(pairs, "{new.name}", fns(p.new.Name)) + pairs = append(pairs, "{new.ID}", fns(p.new.ID)) } if p.update != nil { - pairs = append(pairs, "{update}", fmt.Sprintf("%v", p.update.Handle)) - pairs = append(pairs, "{update.handle}", fmt.Sprintf("%v", p.update.Handle)) - pairs = append(pairs, "{update.name}", fmt.Sprintf("%v", p.update.Name)) - pairs = append(pairs, "{update.ID}", fmt.Sprintf("%v", p.update.ID)) + // replacement for "{update}" (in order how fields are defined) + pairs = append( + pairs, + "{update}", + fns( + p.update.Handle, + p.update.Name, + p.update.ID, + ), + ) + pairs = append(pairs, "{update.handle}", fns(p.update.Handle)) + pairs = append(pairs, "{update.name}", fns(p.update.Name)) + pairs = append(pairs, "{update.ID}", fns(p.update.ID)) } if p.existing != nil { - pairs = append(pairs, "{existing}", fmt.Sprintf("%v", p.existing.Handle)) - pairs = append(pairs, "{existing.handle}", fmt.Sprintf("%v", p.existing.Handle)) - pairs = append(pairs, "{existing.name}", fmt.Sprintf("%v", p.existing.Name)) - pairs = append(pairs, "{existing.ID}", fmt.Sprintf("%v", p.existing.ID)) + // replacement for "{existing}" (in order how fields are defined) + pairs = append( + pairs, + "{existing}", + fns( + p.existing.Handle, + p.existing.Name, + p.existing.ID, + ), + ) + pairs = append(pairs, "{existing.handle}", fns(p.existing.Handle)) + pairs = append(pairs, "{existing.name}", fns(p.existing.Name)) + pairs = append(pairs, "{existing.ID}", fns(p.existing.ID)) } if p.target != nil { - pairs = append(pairs, "{target}", fmt.Sprintf("%v", p.target.Handle)) - pairs = append(pairs, "{target.handle}", fmt.Sprintf("%v", p.target.Handle)) - pairs = append(pairs, "{target.name}", fmt.Sprintf("%v", p.target.Name)) - pairs = append(pairs, "{target.ID}", fmt.Sprintf("%v", p.target.ID)) + // replacement for "{target}" (in order how fields are defined) + pairs = append( + pairs, + "{target}", + fns( + p.target.Handle, + p.target.Name, + p.target.ID, + ), + ) + pairs = append(pairs, "{target.handle}", fns(p.target.Handle)) + pairs = append(pairs, "{target.name}", fns(p.target.Name)) + pairs = append(pairs, "{target.ID}", fns(p.target.ID)) } if p.filter != nil { - pairs = append(pairs, "{filter}", fmt.Sprintf("%v", p.filter.Query)) - pairs = append(pairs, "{filter.query}", fmt.Sprintf("%v", p.filter.Query)) - pairs = append(pairs, "{filter.roleID}", fmt.Sprintf("%v", p.filter.RoleID)) - pairs = append(pairs, "{filter.memberID}", fmt.Sprintf("%v", p.filter.MemberID)) - pairs = append(pairs, "{filter.handle}", fmt.Sprintf("%v", p.filter.Handle)) - pairs = append(pairs, "{filter.name}", fmt.Sprintf("%v", p.filter.Name)) - pairs = append(pairs, "{filter.deleted}", fmt.Sprintf("%v", p.filter.Deleted)) - pairs = append(pairs, "{filter.archived}", fmt.Sprintf("%v", p.filter.Archived)) - pairs = append(pairs, "{filter.sort}", fmt.Sprintf("%v", p.filter.Sort)) + // replacement for "{filter}" (in order how fields are defined) + pairs = append( + pairs, + "{filter}", + fns( + p.filter.Query, + p.filter.RoleID, + p.filter.MemberID, + p.filter.Handle, + p.filter.Name, + p.filter.Deleted, + p.filter.Archived, + p.filter.Sort, + ), + ) + pairs = append(pairs, "{filter.query}", fns(p.filter.Query)) + pairs = append(pairs, "{filter.roleID}", fns(p.filter.RoleID)) + pairs = append(pairs, "{filter.memberID}", fns(p.filter.MemberID)) + pairs = append(pairs, "{filter.handle}", fns(p.filter.Handle)) + pairs = append(pairs, "{filter.name}", fns(p.filter.Name)) + pairs = append(pairs, "{filter.deleted}", fns(p.filter.Deleted)) + pairs = append(pairs, "{filter.archived}", fns(p.filter.Archived)) + pairs = append(pairs, "{filter.sort}", fns(p.filter.Sort)) } return strings.NewReplacer(pairs...).Replace(in) } diff --git a/system/service/sink_actions.gen.go b/system/service/sink_actions.gen.go index 609c9daf2..750238078 100644 --- a/system/service/sink_actions.gen.go +++ b/system/service/sink_actions.gen.go @@ -146,7 +146,19 @@ func (p sinkActionProps) serialize() actionlog.Meta { // This function is auto-generated. // func (p sinkActionProps) tr(in string, err error) string { - var pairs = []string{"{err}"} + var ( + pairs = []string{"{err}"} + // first non-empty string + fns = func(ii ...interface{}) string { + for _, i := range ii { + if s := fmt.Sprintf("%v", i); len(s) > 0 { + return s + } + } + + return "" + } + ) if err != nil { for { @@ -163,19 +175,31 @@ func (p sinkActionProps) tr(in string, err error) string { } else { pairs = append(pairs, "nil") } - pairs = append(pairs, "{url}", fmt.Sprintf("%v", p.url)) - pairs = append(pairs, "{responseStatus}", fmt.Sprintf("%v", p.responseStatus)) - pairs = append(pairs, "{contentType}", fmt.Sprintf("%v", p.contentType)) - pairs = append(pairs, "{sinkParams}", fmt.Sprintf("%v", p.sinkParams)) + pairs = append(pairs, "{url}", fns(p.url)) + pairs = append(pairs, "{responseStatus}", fns(p.responseStatus)) + pairs = append(pairs, "{contentType}", fns(p.contentType)) + pairs = append(pairs, "{sinkParams}", fns(p.sinkParams)) if p.mailHeader != nil { - pairs = append(pairs, "{mailHeader}", fmt.Sprintf("%v", p.mailHeader.To)) - pairs = append(pairs, "{mailHeader.to}", fmt.Sprintf("%v", p.mailHeader.To)) - pairs = append(pairs, "{mailHeader.CC}", fmt.Sprintf("%v", p.mailHeader.CC)) - pairs = append(pairs, "{mailHeader.BCC}", fmt.Sprintf("%v", p.mailHeader.BCC)) - pairs = append(pairs, "{mailHeader.from}", fmt.Sprintf("%v", p.mailHeader.From)) - pairs = append(pairs, "{mailHeader.replyTo}", fmt.Sprintf("%v", p.mailHeader.ReplyTo)) - pairs = append(pairs, "{mailHeader.raw}", fmt.Sprintf("%v", p.mailHeader.Raw)) + // replacement for "{mailHeader}" (in order how fields are defined) + pairs = append( + pairs, + "{mailHeader}", + fns( + p.mailHeader.To, + p.mailHeader.CC, + p.mailHeader.BCC, + p.mailHeader.From, + p.mailHeader.ReplyTo, + p.mailHeader.Raw, + ), + ) + pairs = append(pairs, "{mailHeader.to}", fns(p.mailHeader.To)) + pairs = append(pairs, "{mailHeader.CC}", fns(p.mailHeader.CC)) + pairs = append(pairs, "{mailHeader.BCC}", fns(p.mailHeader.BCC)) + pairs = append(pairs, "{mailHeader.from}", fns(p.mailHeader.From)) + pairs = append(pairs, "{mailHeader.replyTo}", fns(p.mailHeader.ReplyTo)) + pairs = append(pairs, "{mailHeader.raw}", fns(p.mailHeader.Raw)) } return strings.NewReplacer(pairs...).Replace(in) } diff --git a/system/service/statistics_actions.gen.go b/system/service/statistics_actions.gen.go index c976a949e..44de24c97 100644 --- a/system/service/statistics_actions.gen.go +++ b/system/service/statistics_actions.gen.go @@ -70,7 +70,9 @@ func (p statisticsActionProps) serialize() actionlog.Meta { // This function is auto-generated. // func (p statisticsActionProps) tr(in string, err error) string { - var pairs = []string{"{err}"} + var ( + pairs = []string{"{err}"} + ) if err != nil { for { diff --git a/system/service/user_actions.gen.go b/system/service/user_actions.gen.go index 9136c8aba..12e01f486 100644 --- a/system/service/user_actions.gen.go +++ b/system/service/user_actions.gen.go @@ -170,7 +170,19 @@ func (p userActionProps) serialize() actionlog.Meta { // This function is auto-generated. // func (p userActionProps) tr(in string, err error) string { - var pairs = []string{"{err}"} + var ( + pairs = []string{"{err}"} + // first non-empty string + fns = func(ii ...interface{}) string { + for _, i := range ii { + if s := fmt.Sprintf("%v", i); len(s) > 0 { + return s + } + } + + return "" + } + ) if err != nil { for { @@ -189,52 +201,111 @@ func (p userActionProps) tr(in string, err error) string { } if p.user != nil { - pairs = append(pairs, "{user}", fmt.Sprintf("%v", p.user.Handle)) - pairs = append(pairs, "{user.handle}", fmt.Sprintf("%v", p.user.Handle)) - pairs = append(pairs, "{user.email}", fmt.Sprintf("%v", p.user.Email)) - pairs = append(pairs, "{user.name}", fmt.Sprintf("%v", p.user.Name)) - pairs = append(pairs, "{user.username}", fmt.Sprintf("%v", p.user.Username)) - pairs = append(pairs, "{user.ID}", fmt.Sprintf("%v", p.user.ID)) + // replacement for "{user}" (in order how fields are defined) + pairs = append( + pairs, + "{user}", + fns( + p.user.Handle, + p.user.Email, + p.user.Name, + p.user.Username, + p.user.ID, + ), + ) + pairs = append(pairs, "{user.handle}", fns(p.user.Handle)) + pairs = append(pairs, "{user.email}", fns(p.user.Email)) + pairs = append(pairs, "{user.name}", fns(p.user.Name)) + pairs = append(pairs, "{user.username}", fns(p.user.Username)) + pairs = append(pairs, "{user.ID}", fns(p.user.ID)) } if p.new != nil { - pairs = append(pairs, "{new}", fmt.Sprintf("%v", p.new.Handle)) - pairs = append(pairs, "{new.handle}", fmt.Sprintf("%v", p.new.Handle)) - pairs = append(pairs, "{new.email}", fmt.Sprintf("%v", p.new.Email)) - pairs = append(pairs, "{new.name}", fmt.Sprintf("%v", p.new.Name)) - pairs = append(pairs, "{new.username}", fmt.Sprintf("%v", p.new.Username)) - pairs = append(pairs, "{new.ID}", fmt.Sprintf("%v", p.new.ID)) + // replacement for "{new}" (in order how fields are defined) + pairs = append( + pairs, + "{new}", + fns( + p.new.Handle, + p.new.Email, + p.new.Name, + p.new.Username, + p.new.ID, + ), + ) + pairs = append(pairs, "{new.handle}", fns(p.new.Handle)) + pairs = append(pairs, "{new.email}", fns(p.new.Email)) + pairs = append(pairs, "{new.name}", fns(p.new.Name)) + pairs = append(pairs, "{new.username}", fns(p.new.Username)) + pairs = append(pairs, "{new.ID}", fns(p.new.ID)) } if p.update != nil { - pairs = append(pairs, "{update}", fmt.Sprintf("%v", p.update.Handle)) - pairs = append(pairs, "{update.handle}", fmt.Sprintf("%v", p.update.Handle)) - pairs = append(pairs, "{update.email}", fmt.Sprintf("%v", p.update.Email)) - pairs = append(pairs, "{update.name}", fmt.Sprintf("%v", p.update.Name)) - pairs = append(pairs, "{update.username}", fmt.Sprintf("%v", p.update.Username)) - pairs = append(pairs, "{update.ID}", fmt.Sprintf("%v", p.update.ID)) + // replacement for "{update}" (in order how fields are defined) + pairs = append( + pairs, + "{update}", + fns( + p.update.Handle, + p.update.Email, + p.update.Name, + p.update.Username, + p.update.ID, + ), + ) + pairs = append(pairs, "{update.handle}", fns(p.update.Handle)) + pairs = append(pairs, "{update.email}", fns(p.update.Email)) + pairs = append(pairs, "{update.name}", fns(p.update.Name)) + pairs = append(pairs, "{update.username}", fns(p.update.Username)) + pairs = append(pairs, "{update.ID}", fns(p.update.ID)) } if p.existing != nil { - pairs = append(pairs, "{existing}", fmt.Sprintf("%v", p.existing.Handle)) - pairs = append(pairs, "{existing.handle}", fmt.Sprintf("%v", p.existing.Handle)) - pairs = append(pairs, "{existing.email}", fmt.Sprintf("%v", p.existing.Email)) - pairs = append(pairs, "{existing.name}", fmt.Sprintf("%v", p.existing.Name)) - pairs = append(pairs, "{existing.username}", fmt.Sprintf("%v", p.existing.Username)) - pairs = append(pairs, "{existing.ID}", fmt.Sprintf("%v", p.existing.ID)) + // replacement for "{existing}" (in order how fields are defined) + pairs = append( + pairs, + "{existing}", + fns( + p.existing.Handle, + p.existing.Email, + p.existing.Name, + p.existing.Username, + p.existing.ID, + ), + ) + pairs = append(pairs, "{existing.handle}", fns(p.existing.Handle)) + pairs = append(pairs, "{existing.email}", fns(p.existing.Email)) + pairs = append(pairs, "{existing.name}", fns(p.existing.Name)) + pairs = append(pairs, "{existing.username}", fns(p.existing.Username)) + pairs = append(pairs, "{existing.ID}", fns(p.existing.ID)) } if p.filter != nil { - pairs = append(pairs, "{filter}", fmt.Sprintf("%v", p.filter.Query)) - pairs = append(pairs, "{filter.query}", fmt.Sprintf("%v", p.filter.Query)) - pairs = append(pairs, "{filter.userID}", fmt.Sprintf("%v", p.filter.UserID)) - pairs = append(pairs, "{filter.roleID}", fmt.Sprintf("%v", p.filter.RoleID)) - pairs = append(pairs, "{filter.handle}", fmt.Sprintf("%v", p.filter.Handle)) - pairs = append(pairs, "{filter.email}", fmt.Sprintf("%v", p.filter.Email)) - pairs = append(pairs, "{filter.username}", fmt.Sprintf("%v", p.filter.Username)) - pairs = append(pairs, "{filter.deleted}", fmt.Sprintf("%v", p.filter.Deleted)) - pairs = append(pairs, "{filter.suspended}", fmt.Sprintf("%v", p.filter.Suspended)) - pairs = append(pairs, "{filter.sort}", fmt.Sprintf("%v", p.filter.Sort)) + // replacement for "{filter}" (in order how fields are defined) + pairs = append( + pairs, + "{filter}", + fns( + p.filter.Query, + p.filter.UserID, + p.filter.RoleID, + p.filter.Handle, + p.filter.Email, + p.filter.Username, + p.filter.Deleted, + p.filter.Suspended, + p.filter.Sort, + ), + ) + pairs = append(pairs, "{filter.query}", fns(p.filter.Query)) + pairs = append(pairs, "{filter.userID}", fns(p.filter.UserID)) + pairs = append(pairs, "{filter.roleID}", fns(p.filter.RoleID)) + pairs = append(pairs, "{filter.handle}", fns(p.filter.Handle)) + pairs = append(pairs, "{filter.email}", fns(p.filter.Email)) + pairs = append(pairs, "{filter.username}", fns(p.filter.Username)) + pairs = append(pairs, "{filter.deleted}", fns(p.filter.Deleted)) + pairs = append(pairs, "{filter.suspended}", fns(p.filter.Suspended)) + pairs = append(pairs, "{filter.sort}", fns(p.filter.Sort)) } return strings.NewReplacer(pairs...).Replace(in) }