/
parser.go
109 lines (89 loc) · 2.57 KB
/
parser.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
package util
import (
"encoding/json"
"fmt"
"strconv"
"github.com/Todorov99/sensorcli/pkg/logger"
"github.com/sirupsen/logrus"
yaml "gopkg.in/yaml.v2"
)
var utilLogger *logrus.Entry = logger.NewLogrus("./util")
const (
unitTypeFahrenheit string = "F"
unitTypeCelsius string = "C"
celsiusName string = "Celsius"
fahrenheitName string = "Fahrenheit"
gigaBytes string = "GigaBytes"
bytes string = "Bytes"
kiloBytes string = "KiloBytes"
megaBytes string = "MegaBytes"
jsonType string = "JSON"
yamlType string = "YAML"
)
// ParseTempAccordingToUnit returns correct parsed temperature.
func ParseTempAccordingToUnit(unit string, temperature string) (string, error) {
val, err := strconv.ParseFloat(temperature, 64)
if err != nil {
utilLogger.Error(err)
return "", err
}
switch unit {
case unitTypeFahrenheit:
utilLogger.Info("Parsing temperatur to fahrenheit unit")
return strconv.FormatFloat(fahrenheit(val), 'f', 1, 64), nil
case unitTypeCelsius:
utilLogger.Info("Parsing temperatur to celsius unit")
return strconv.FormatFloat(val, 'f', 1, 64), nil
}
return "", fmt.Errorf("invalid unit")
}
// ParseTempAccordingToUnit returns correct parsed temperature.
func ParseMemoryUsageAccordingToUnit(unit string, value string) (string, error) {
val, err := strconv.ParseFloat(value, 64)
if err != nil {
utilLogger.Error(err)
return "", err
}
switch unit {
case gigaBytes:
return strconv.FormatFloat(gigaByte(val), 'f', 1, 64), nil
case megaBytes:
return strconv.FormatFloat(megabytes(val), 'f', 1, 64), nil
case kiloBytes:
return strconv.FormatFloat(kilobytes(val), 'f', 1, 64), nil
case bytes:
return strconv.FormatFloat(val, 'f', 1, 64), nil
case "%":
return strconv.FormatFloat(val, 'f', 1, 64), nil
}
return "", fmt.Errorf("invalid unit")
}
// ParseDataAccordingToFormat returns corect parsed data.
func ParseDataAccordingToFormat(format string, data interface{}) string {
if format == yamlType {
utilLogger.Info("Parsing data to yaml")
return yamlParser(data)
}
utilLogger.Info("Parsing data to json")
return jsonParser(data)
}
func kilobytes(bytes float64) float64 {
return bytes / 1024
}
func megabytes(bytes float64) float64 {
return bytes / 1024 / 1024
}
func gigaByte(bytes float64) float64 {
return bytes / 1024 / 1024 / 1024
}
func fahrenheit(temperature float64) float64 {
return temperature*(9/5) + 32
}
func jsonParser(data interface{}) string {
jsonData, _ := json.Marshal(data)
return string(jsonData)
}
func yamlParser(data interface{}) string {
yamlData, _ := yaml.Marshal(data)
return string(yamlData)
}