GrafanaSimpleJsonServer/jprocessor.py at main · Humminghead/GrafanaSimpleJsonServer · GitHub

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
import json
import time


class JsonDataProcessor:
    def flatJson(self, y):
        out = {}

        def flatten(x, name=''):
            if type(x) is dict:
                for a in x:
                    flatten(x[a], name + a + '_')
            elif type(x) is list:
                i = 0
                for a in x:
                    flatten(a, name + str(i) + '_')
                    i += 1
            else:
                out[name[:-1]] = x

        flatten(y)
        return out

    def listDataRecords(self, inData: list):
        if len(inData) > 0:
            flatJ = self.flatJson(inData)
            values = r'['
            for name in flatJ:
                values = values + "\""+name+"\","

            values = values[:-1] + "]"
            return json.loads(values.encode())
        return json.loads("[]")

    def getTagetData(self, inData: list, eventData: str):
        values = json.loads(eventData)
        targetString = r'['
        for val in values:
            targetString += "{\"target\": \""
            # targetString += "{'target': '"
            targetString += val.get('target') + "\", \"datapoints\": ["

            if(len(inData) == 0):
                targetString += r']},'
            else:
                for data in inData:
                    flatJ = self.flatJson(data.mJson)
                    valTarget = val.get('target')
                    jval = None
                    jtime = None

                    if(flatJ.__contains__(valTarget)):
                        jval = flatJ[valTarget]

                    if jval == None:
                        return (targetString + r"]}]")

                    if(flatJ.__contains__('@timestamp')):
                        jtime = flatJ['@timestamp']*1000
                    else:
                        jtime = data.mTime

                    if (type(jval) is float):
                        targetString += "[" + \
                            str(jval) + ", " + str(jtime) + "],"
                    else:
                        targetString += "[" + \
                            str(jval) + ".0, " + str(jtime) + "],"

                    # jval = str(flatJ[val.get('target')])
                    # jtime = flatJ['@timestamp']*1000
                    # targetString += "[" + jval + ".0, " + str(jtime) + "],"

                targetString = targetString[:-1] + r']},'
        return (targetString[:-1] + r']')

    def getDataPoints(self, inData: str, valueName: str):
        outStr = r'{"target": "'
        for data in inData:
            print(inData[valueName.encode()])