Skip to content

Commit b69663f

Browse files
vicentepinto98vicentepinto98
authored
Fix multi-table pager display (#551)
* Fix multi-table pager display * Fix lint g
1 parent 66226f5 commit b69663f

7 files changed

Lines changed: 135 additions & 177 deletions

File tree

‎internal/cmd/beta/server/describe/describe.go‎

Lines changed: 9 additions & 8 deletions
Original file line numberDiff line numberDiff line change
@@ -125,6 +125,8 @@ func outputResult(p *print.Printer, model *inputModel, server *iaas.Server) erro
125125

126126
return nil
127127
default:
128+
content := []tables.Table{}
129+
128130
table := tables.NewTable()
129131
table.SetTitle("Server")
130132

@@ -182,10 +184,7 @@ func outputResult(p *print.Printer, model *inputModel, server *iaas.Server) erro
182184
table.AddSeparator()
183185
}
184186

185-
err := table.Display(p)
186-
if err != nil {
187-
return fmt.Errorf("render table: %w", err)
188-
}
187+
content = append(content, table)
189188

190189
if server.Nics != nil && len(*server.Nics) > 0 {
191190
nicsTable := tables.NewTable()
@@ -201,10 +200,12 @@ func outputResult(p *print.Printer, model *inputModel, server *iaas.Server) erro
201200
nicsTable.AddSeparator()
202201
}
203202

204-
err := nicsTable.Display(p)
205-
if err != nil {
206-
return fmt.Errorf("render table: %w", err)
207-
}
203+
content = append(content, nicsTable)
204+
}
205+
206+
err := tables.DisplayTables(p, content)
207+
if err != nil {
208+
return fmt.Errorf("render table: %w", err)
208209
}
209210

210211
return nil

‎internal/cmd/beta/sqlserverflex/options/options.go‎

Lines changed: 34 additions & 58 deletions
Original file line numberDiff line numberDiff line change
@@ -300,120 +300,96 @@ func outputResult(p *print.Printer, model *inputModel, flavors *sqlserverflex.Li
300300
}
301301

302302
func outputResultAsTable(p *print.Printer, model *inputModel, options *options) error {
303-
content := ""
304-
if model.Flavors {
305-
content += renderFlavors(*options.Flavors)
303+
content := []tables.Table{}
304+
if model.Flavors && len(*options.Flavors) != 0 {
305+
content = append(content, buildFlavorsTable(*options.Flavors))
306306
}
307-
if model.Versions {
308-
content += renderVersions(*options.Versions)
307+
if model.Versions && len(*options.Versions) != 0 {
308+
content = append(content, buildVersionsTable(*options.Versions))
309309
}
310-
if model.Storages {
311-
content += renderStorages(options.Storages.Storages)
310+
if model.Storages && options.Storages.Storages != nil && len(*options.Storages.Storages.StorageClasses) != 0 {
311+
content = append(content, buildStoragesTable(*options.Storages.Storages))
312312
}
313-
if model.UserRoles {
314-
content += renderUserRoles(options.UserRoles)
313+
if model.UserRoles && len(options.UserRoles.UserRoles) != 0 {
314+
content = append(content, buildUserRoles(options.UserRoles))
315315
}
316-
if model.DBCompatibilities {
317-
content += renderDBCompatibilities(options.DBCompatibilities)
316+
if model.DBCompatibilities && len(options.DBCompatibilities.DBCompatibilities) != 0 {
317+
content = append(content, buildDBCompatibilitiesTable(options.DBCompatibilities.DBCompatibilities))
318318
}
319319
// Rendered at last because table is very long
320-
if model.DBCollations {
321-
content += renderDBCollations(options.DBCollations)
320+
if model.DBCollations && len(options.DBCollations.DBCollations) != 0 {
321+
content = append(content, buildDBCollationsTable(options.DBCollations.DBCollations))
322322
}
323323

324-
err := p.PagerDisplay(content)
324+
err := tables.DisplayTables(p, content)
325325
if err != nil {
326326
return fmt.Errorf("display output: %w", err)
327327
}
328328

329329
return nil
330330
}
331331

332-
func renderFlavors(flavors []sqlserverflex.InstanceFlavorEntry) string {
333-
if len(flavors) == 0 {
334-
return ""
335-
}
336-
332+
func buildFlavorsTable(flavors []sqlserverflex.InstanceFlavorEntry) tables.Table {
337333
table := tables.NewTable()
338334
table.SetTitle("Flavors")
339335
table.SetHeader("ID", "CPU", "MEMORY", "DESCRIPTION", "VALID INSTANCE TYPES")
340336
for i := range flavors {
341337
f := flavors[i]
342338
table.AddRow(*f.Id, *f.Cpu, *f.Memory, *f.Description, *f.Categories)
343339
}
344-
return table.Render()
340+
return table
345341
}
346342

347-
func renderVersions(versions []string) string {
348-
if len(versions) == 0 {
349-
return ""
350-
}
351-
343+
func buildVersionsTable(versions []string) tables.Table {
352344
table := tables.NewTable()
353345
table.SetTitle("Versions")
354346
table.SetHeader("VERSION")
355347
for i := range versions {
356348
v := versions[i]
357349
table.AddRow(v)
358350
}
359-
return table.Render()
351+
return table
360352
}
361353

362-
func renderStorages(resp *sqlserverflex.ListStoragesResponse) string {
363-
if resp.StorageClasses == nil || len(*resp.StorageClasses) == 0 {
364-
return ""
365-
}
366-
storageClasses := *resp.StorageClasses
367-
354+
func buildStoragesTable(storagesResp sqlserverflex.ListStoragesResponse) tables.Table {
355+
storages := *storagesResp.StorageClasses
368356
table := tables.NewTable()
369357
table.SetTitle("Storages")
370358
table.SetHeader("MINIMUM", "MAXIMUM", "STORAGE CLASS")
371-
for i := range storageClasses {
372-
sc := storageClasses[i]
373-
table.AddRow(*resp.StorageRange.Min, *resp.StorageRange.Max, sc)
359+
for i := range storages {
360+
sc := storages[i]
361+
table.AddRow(*storagesResp.StorageRange.Min, *storagesResp.StorageRange.Max, sc)
374362
}
375363
table.EnableAutoMergeOnColumns(1, 2, 3)
376-
return table.Render()
364+
return table
377365
}
378366

379-
func renderUserRoles(roles *instanceUserRoles) string {
380-
if len(roles.UserRoles) == 0 {
381-
return ""
382-
}
383-
367+
func buildUserRoles(roles *instanceUserRoles) tables.Table {
384368
table := tables.NewTable()
385369
table.SetTitle("User Roles")
386370
table.SetHeader("ROLE")
387371
for i := range roles.UserRoles {
388372
table.AddRow(roles.UserRoles[i])
389373
}
390-
return table.Render()
374+
return table
391375
}
392376

393-
func renderDBCollations(dbCollations *instanceDBCollations) string {
394-
if len(dbCollations.DBCollations) == 0 {
395-
return ""
396-
}
397-
377+
func buildDBCollationsTable(dbCollations []sqlserverflex.MssqlDatabaseCollation) tables.Table {
398378
table := tables.NewTable()
399379
table.SetTitle("DB Collations")
400380
table.SetHeader("NAME", "DESCRIPTION")
401-
for i := range dbCollations.DBCollations {
402-
table.AddRow(*dbCollations.DBCollations[i].CollationName, *dbCollations.DBCollations[i].Description)
381+
for i := range dbCollations {
382+
table.AddRow(dbCollations[i].CollationName, dbCollations[i].Description)
403383
}
404-
return table.Render()
384+
return table
405385
}
406386

407-
func renderDBCompatibilities(dbCompatibilities *instanceDBCompatibilities) string {
408-
if len(dbCompatibilities.DBCompatibilities) == 0 {
409-
return ""
410-
}
411-
387+
func buildDBCompatibilitiesTable(dbCompatibilities []sqlserverflex.MssqlDatabaseCompatibility) tables.Table {
412388
table := tables.NewTable()
413389
table.SetTitle("DB Compatibilities")
414390
table.SetHeader("COMPATIBILITY LEVEL", "DESCRIPTION")
415-
for i := range dbCompatibilities.DBCompatibilities {
416-
table.AddRow(*dbCompatibilities.DBCompatibilities[i].CompatibilityLevel, *dbCompatibilities.DBCompatibilities[i].Description)
391+
for i := range dbCompatibilities {
392+
table.AddRow(dbCompatibilities[i].CompatibilityLevel, dbCompatibilities[i].Description)
417393
}
418-
return table.Render()
394+
return table
419395
}

‎internal/cmd/load-balancer/describe/describe.go‎

Lines changed: 12 additions & 10 deletions
Original file line numberDiff line numberDiff line change
@@ -121,25 +121,27 @@ func outputResult(p *print.Printer, outputFormat string, loadBalancer *loadbalan
121121
}
122122

123123
func outputResultAsTable(p *print.Printer, loadBalancer *loadbalancer.LoadBalancer) error {
124-
content := renderLoadBalancer(loadBalancer)
124+
content := []tables.Table{}
125+
126+
content = append(content, buildLoadBalancerTable(loadBalancer))
125127

126128
if loadBalancer.Listeners != nil {
127-
content += renderListeners(*loadBalancer.Listeners)
129+
content = append(content, buildListenersTable(*loadBalancer.Listeners))
128130
}
129131

130132
if loadBalancer.TargetPools != nil {
131-
content += renderTargetPools(*loadBalancer.TargetPools)
133+
content = append(content, buildTargetPoolsTable(*loadBalancer.TargetPools))
132134
}
133135

134-
err := p.PagerDisplay(content)
136+
err := tables.DisplayTables(p, content)
135137
if err != nil {
136138
return fmt.Errorf("display output: %w", err)
137139
}
138140

139141
return nil
140142
}
141143

142-
func renderLoadBalancer(loadBalancer *loadbalancer.LoadBalancer) string {
144+
func buildLoadBalancerTable(loadBalancer *loadbalancer.LoadBalancer) tables.Table {
143145
acl := []string{}
144146
privateAccessOnly := false
145147
if loadBalancer.Options != nil {
@@ -187,26 +189,26 @@ func renderLoadBalancer(loadBalancer *loadbalancer.LoadBalancer) string {
187189
table.AddRow("ATTACHED NETWORK ID", networkId)
188190
table.AddSeparator()
189191
table.AddRow("ACL", acl)
190-
return table.Render()
192+
return table
191193
}
192194

193-
func renderListeners(listeners []loadbalancer.Listener) string {
195+
func buildListenersTable(listeners []loadbalancer.Listener) tables.Table {
194196
table := tables.NewTable()
195197
table.SetTitle("Listeners")
196198
table.SetHeader("NAME", "PORT", "PROTOCOL", "TARGET POOL")
197199
for i := range listeners {
198200
listener := listeners[i]
199201
table.AddRow(*listener.Name, *listener.Port, *listener.Protocol, *listener.TargetPool)
200202
}
201-
return table.Render()
203+
return table
202204
}
203205

204-
func renderTargetPools(targetPools []loadbalancer.TargetPool) string {
206+
func buildTargetPoolsTable(targetPools []loadbalancer.TargetPool) tables.Table {
205207
table := tables.NewTable()
206208
table.SetTitle("Target Pools")
207209
table.SetHeader("NAME", "PORT", "TARGETS")
208210
for _, targetPool := range targetPools {
209211
table.AddRow(*targetPool.Name, *targetPool.TargetPort, len(*targetPool.Targets))
210212
}
211-
return table.Render()
213+
return table
212214
}

‎internal/cmd/mongodbflex/options/options.go‎

Lines changed: 18 additions & 30 deletions
Original file line numberDiff line numberDiff line change
@@ -206,68 +206,56 @@ func outputResult(p *print.Printer, model *inputModel, flavors *mongodbflex.List
206206
}
207207

208208
func outputResultAsTable(p *print.Printer, model *inputModel, options *options) error {
209-
content := ""
210-
if model.Flavors {
211-
content += renderFlavors(*options.Flavors)
209+
content := []tables.Table{}
210+
if model.Flavors && len(*options.Flavors) != 0 {
211+
content = append(content, buildFlavorsTable(*options.Flavors))
212212
}
213-
if model.Versions {
214-
content += renderVersions(*options.Versions)
213+
if model.Versions && len(*options.Versions) != 0 {
214+
content = append(content, buildVersionsTable(*options.Versions))
215215
}
216-
if model.Storages {
217-
content += renderStorages(options.Storages.Storages)
216+
if model.Storages && options.Storages.Storages != nil && len(*options.Storages.Storages.StorageClasses) == 0 {
217+
content = append(content, buildStoragesTable(*options.Storages.Storages))
218218
}
219219

220-
err := p.PagerDisplay(content)
220+
err := tables.DisplayTables(p, content)
221221
if err != nil {
222222
return fmt.Errorf("display output: %w", err)
223223
}
224224

225225
return nil
226226
}
227227

228-
func renderFlavors(flavors []mongodbflex.HandlersInfraFlavor) string {
229-
if len(flavors) == 0 {
230-
return ""
231-
}
232-
228+
func buildFlavorsTable(flavors []mongodbflex.HandlersInfraFlavor) tables.Table {
233229
table := tables.NewTable()
234230
table.SetTitle("Flavors")
235231
table.SetHeader("ID", "CPU", "MEMORY", "DESCRIPTION", "VALID INSTANCE TYPES")
236232
for i := range flavors {
237233
f := flavors[i]
238234
table.AddRow(*f.Id, *f.Cpu, *f.Memory, *f.Description, *f.Categories)
239235
}
240-
return table.Render()
236+
return table
241237
}
242238

243-
func renderVersions(versions []string) string {
244-
if len(versions) == 0 {
245-
return ""
246-
}
247-
239+
func buildVersionsTable(versions []string) tables.Table {
248240
table := tables.NewTable()
249241
table.SetTitle("Versions")
250242
table.SetHeader("VERSION")
251243
for i := range versions {
252244
v := versions[i]
253245
table.AddRow(v)
254246
}
255-
return table.Render()
247+
return table
256248
}
257249

258-
func renderStorages(resp *mongodbflex.ListStoragesResponse) string {
259-
if resp.StorageClasses == nil || len(*resp.StorageClasses) == 0 {
260-
return ""
261-
}
262-
storageClasses := *resp.StorageClasses
263-
250+
func buildStoragesTable(storagesResp mongodbflex.ListStoragesResponse) tables.Table {
251+
storages := *storagesResp.StorageClasses
264252
table := tables.NewTable()
265253
table.SetTitle("Storages")
266254
table.SetHeader("MINIMUM", "MAXIMUM", "STORAGE CLASS")
267-
for i := range storageClasses {
268-
sc := storageClasses[i]
269-
table.AddRow(*resp.StorageRange.Min, *resp.StorageRange.Max, sc)
255+
for i := range storages {
256+
sc := storages[i]
257+
table.AddRow(*storagesResp.StorageRange.Min, *storagesResp.StorageRange.Max, sc)
270258
}
271259
table.EnableAutoMergeOnColumns(1, 2, 3)
272-
return table.Render()
260+
return table
273261
}

0 commit comments

Comments
 (0)