/
version.go
124 lines (102 loc) · 2.73 KB
/
version.go
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
// Copyright 2023 VMware, Inc.
// SPDX-License-Identifier: BSD-2-Clause
package models
import (
"sort"
"strings"
"github.com/coreos/go-semver/semver"
)
type Version struct {
Number string `json:"versionnumber"`
Details string `json:"versiondetails"`
Status string `json:"status,omitempty"`
Instructions string `json:"versioninstruction"`
CreatedOn int32 `json:"createdon,omitempty"`
HasLimitedAccess bool `json:"haslimitedaccess,omitempty"`
Tag string `json:"tag,omitempty"`
IsNewVersion bool `json:"-"` // This is only for the CLI when adding a version
}
func (product *Product) NewVersion(number string) *Version {
if product.HasVersion(number) {
return product.GetVersion(number)
}
version := &Version{
Number: number,
IsNewVersion: true,
}
product.CurrentVersion = number
product.Versions = append(product.Versions, version)
return version
}
func (product *Product) GetVersion(version string) *Version {
if version == "" {
return product.GetLatestVersion()
}
for _, v := range product.AllVersions {
if v.Number == version {
return v
}
}
return nil
}
func (product *Product) GetLatestVersion() *Version {
if len(product.AllVersions) == 0 {
return nil
}
version, err := product.getLatestVersionSemver()
if err != nil {
version = product.getLatestVersionAlphanumeric()
}
return version
}
func (product *Product) getLatestVersionSemver() (*Version, error) {
latestVersion := product.AllVersions[0]
version, err := semver.NewVersion(latestVersion.Number)
if err != nil {
return nil, err
}
for _, v := range product.AllVersions {
otherVersion, err := semver.NewVersion(v.Number)
if err != nil {
return nil, err
}
if version.LessThan(*otherVersion) {
latestVersion = v
version = otherVersion
}
}
return latestVersion, nil
}
func (product *Product) getLatestVersionAlphanumeric() *Version {
latestVersion := product.AllVersions[0]
for _, v := range product.AllVersions {
if strings.Compare(latestVersion.Number, v.Number) < 0 {
latestVersion = v
}
}
return latestVersion
}
type Versions []*Version
func (v Versions) Len() int {
return len(v)
}
func (v Versions) Swap(i, j int) {
v[i], v[j] = v[j], v[i]
}
func (v Versions) Less(i, j int) bool {
return v[i].LessThan(*v[j])
}
func (a Version) LessThan(b Version) bool {
semverA, errA := semver.NewVersion(a.Number)
semverB, errB := semver.NewVersion(b.Number)
if errA != nil || errB != nil {
return strings.Compare(a.Number, b.Number) < 0
}
return semverA.LessThan(*semverB)
}
func Sort(versions []*Version) {
sort.Sort(sort.Reverse(Versions(versions)))
}
func (product *Product) HasVersion(version string) bool {
return product.GetVersion(version) != nil
}