def putFlowOptions(country, lobName, flowName):
body = request.get_json()
flow = MediationConfig.getLobWithCountry(country,
lobName)["flows"][flowName]
res = MediationConfig.getCollection().update_one(
MEDIATION_DOCUMENT, {"$set": {
"lobs." + flow["dataPath"]: body
}})
return jsonify(
MediationConfig.getLobWithCountry(
country, lobName)["flows"][flowName]["options"])
def enableFlow(country, lobName, flowName):
body = request.get_json()
enable = body["enable"]
flow = MediationConfig.getLobWithCountry(country,
lobName)["flows"][flowName]
MediationConfig.getCollection().update_one(
MEDIATION_DOCUMENT,
{"$set": {
"lobs." + flow["dataPath"] + ".enabled": enable
}})
return jsonify(
MediationConfig.getLobWithCountry(
country, lobName)["flows"][flowName]["options"])
def deleteLob(country, lobName):
lob = MediationConfig.getLobWithCountry(country, lobName)
if lob is not None:
MediationConfig.deleteLob(lob)
else:
raise StatusException("lob does not exists", 400)
return getCountry(country)
def flowGET(country, lobName, flowName):
flow = MediationConfig.getLobWithCountry(country,
lobName)["flows"][flowName]
if shouldIncludeStatus():
status = FlowStatusManager().getLobDetailWithCountry(country,
lobName)[flowName]
flow["status"] = status
return jsonify(flow)
def getLobDetailWithCountry(self, country, lobName):
lob = MediationConfig.getLobWithCountry(country, lobName)
allStatuses = self.getAll(lob["country"])
lobFlowStatuses = {}
for flowName, flow in lob["flows"].items():
lobFlowStatuses[flowName] = allStatuses[flow["gName"]]
return lobFlowStatuses
def enableLob(country, lobName):
enable = request.get_json()["enable"]
optionsPath = "lobs." + country + "." + lobName + ".options.enabled"
MediationConfig.getCollection().update_one(MEDIATION_DOCUMENT,
{"$set": {
optionsPath: enable
}})
return jsonify(
MediationConfig.getLobWithCountry(country, lobName)["options"])
def lobOptionsPUT(country, lobName):
body = request.get_json()
optionsPath = "lobs." + country + "." + lobName + ".options"
MediationConfig.getCollection().update_one(MEDIATION_DOCUMENT,
{"$set": {
optionsPath: body
}})
return jsonify(
MediationConfig.getLobWithCountry(country, lobName)["options"])
def addLob():
"""put under /lobs"""
addLobRequest = request.get_json()
country = addLobRequest["country"]
lobName = addLobRequest["lobName"]
if MediationConfig.getLobWithCountry(country, lobName) is not None:
raise StatusException("Lob already exists", 400)
MediationConfig.addLob(country, lobName)
return getCountry(country)
def getLob(country, lobName):
res = MediationConfig.getLobWithCountry(country, lobName)
if shouldIncludeStatus():
status = FlowStatusManager().getLobDetailWithCountry(country, lobName)
for k, v in status.items():
type = res["flows"][k]["type"]
res[type][k]["status"] = v
del res["flows"]
return jsonify(res)
def addFlow(country, lobName):
lob = MediationConfig.getLobWithCountry(country, lobName)
addFlowRequest = request.get_json()
name = addFlowRequest["name"]
type = addFlowRequest["type"]
if name in lob["flows"]:
raise StatusException("Flow already exists", 400)
flow = {"country": country, "lobName": lobName, "type": type, "name": name}
MediationConfig.addFlow(flow)
return getLob(country, lobName)
latestClosedIntervalTime = time - datetime.timedelta(minutes=minutesOverInterval + granularity)
latestClosedIntervalTime = latestClosedIntervalTime.replace(second=0, microsecond=0)
return util.getTicTime(latestClosedIntervalTime.astimezone(AppConfig.getTimezone()), granularity)
else:
naiveTime = time.replace(tzinfo=None)
latestClosedIntervalNaiveTime = naiveTime - datetime.timedelta(minutes=minutesOverInterval + granularity)
latestClosedIntervalNaiveTime = latestClosedIntervalNaiveTime.replace(second=0, microsecond=0)
localized = AppConfig.getTimezone().localize(latestClosedIntervalNaiveTime).astimezone(AppConfig.getTimezone())
return util.getTicTime(localized, granularity)
def getResult(self):
"""
returns result. It's up to caller to save it to db!
:return:
"""
return self.status, self.difference
def setPrecomputedData(self, precomputedData):
self.precomputedData = precomputedData
self.outageDetector.setPrecomputedData(self.precomputedData)
if __name__ == "__main__":
logging.basicConfig(format='%(levelname)s [%(module)s]: %(message)s', level=logging.DEBUG)
gsm = MediationConfig.getLobWithCountry("CZ", "TIT")
analyzer = FlowAnalyzer(gsm["flows"]["CLH"])
analyzer.run(util.stringToTime("17.01.2017 15:00:00"))
isOutage, traffic = analyzer.getResult()
print(isOutage)
print(traffic)
def dataQueryV2():
"""
Endpoint for getting traffic data.
POST body:
{
"from":"01.02.2017",
"to":"15.02.2017",
"country":"CZ",
"lobName":"ACI",
"flowName":["GSM"],
"forwards":[],
"granularity":0
}
Response:
{
"data": [
{
"GSM": 188385532,
"_id": "2017-02-01T00:00:00+01:00",
"dayAverage": 1162595297.6666667,
"dayDifference": 1.023,
"expected": 161627916,
"status": "OK",
"tickDifference": 1.166
},
...
],
"metadata": {
"flowName": "GSM",
"granularity": 480,
"metrics": {
"GSM": {
"type": "traffic"
},
"dayAverage": {
"type": "traffic"
},
"dayDifference": {
"type": "difference"
},
"expected": {
"type": "traffic"
},
"status": {
"type": "other"
},
"tickDifference": {
"type": "difference"
}
}
}
"""
searchParam = request.get_json()
fromDate = util.stringToDate(searchParam["from"])
toDate = util.stringToDate(searchParam["to"])
country = searchParam["country"]
lobName = searchParam["lobName"]
lobConfig = MediationConfig.getLobWithCountry(country, lobName)
flows = []
granularity = searchParam.get("granularity", 0)
flows.append(lobConfig["flows"][searchParam["flowName"]])
response = {}
# Query the traffic data and add to metric list
mongoQuery = data_query.DateRangeGroupQuery(fromDate,
toDate,
flows,
granularity=granularity)
data = mongoQuery.execute()
metrics = {}
metricsList = []
flowName = mongoQuery.metrics[0]
metricsList.append(flowName)
metadata = mongoQuery.metadata
if len(flows) == 1:
# Run outage detection analysis
metric = metricsList[0]
flowLevelQuery = data_query.FlowLevelDateRangeQuery(
fromDate, toDate, flows, metadata["granularity"], data)
flowLevelData = flowLevelQuery.execute()
data = util.merge2DateLists(flowLevelData, None, data, None)
metricsList.extend(flowLevelQuery.metrics)
outageQuery = data_query.OutageDateRangeQuery(fromDate, toDate,
flows[0],
metadata["granularity"])
outageQuery.setPrecomputedData(data, metric)
outageList = outageQuery.execute()
data = util.merge2DateLists(outageList, [outageQuery.metric], data,
None)
metricsList.append(outageQuery.metric)
# Create metadata infor
for metric in metricsList:
if metric == flowName or metric == "dayAverage" or metric == "expected":
type = "traffic"
elif "Difference" in metric:
type = "difference"
else:
type = "other"
metrics[metric] = {"type": type}
response["data"] = data
response["metadata"] = {
**{
"metrics": metrics
},
**metadata, "flowName": flowName
}
return jsonify(response)
dataTicks = []
dataTickPos = []
for i in range(0, len(dates)):
if True:
dataTicks.append(dates[i])
dataTickPos.append(i)
return data1, expected, dataTicks, dataTickPos
fromDate = util.stringToDate("30.01.2017")
toDate = util.stringToDate("12.02.2017")
# lobName = "ICG"
# flowName = "CENTREX01"
lobName = "GSM"
flowName = "MSSBRN1B"
lob = MediationConfig.getLobWithCountry("CZ", lobName)
flow = lob["flows"][flowName]
flows = [flow]
granularity = 240
data = []
expected = []
ticks = []
pos = []
d, e, t, p = getData(flows, util.stringToDate("28.09.2016"),
util.stringToDate("29.09.2016"))
data += d
expected += e
ticks += t
posLen = len(pos)
pos += [i + posLen for i in p]
windowData = data[start:i + 1]
weights = [1 + x * x for x in range(0, len(windowData))]
s = 0
for x, y in zip(windowData, weights):
s += x * y
average = s / sum(weights)
output.append(average)
return output
fromDate = util.stringToTime("02.03.2017 00:00:00")
toDate = util.stringToTime("03.03.2017 00:00:00")
granularity = 15
q = DateRangeGroupQuery(
fromDate, toDate,
[MediationConfig.getLobWithCountry("CZ", "GSM")["flows"]["MSSBRN1A"]],
granularity)
# q = DateRangeGroupQuery(fromDate, toDate, [MediationConfig.getLobWithCountry("CZ","ACI")["flows"]["GSM"]], granularity)
lob1Data = util.dateDataListToList(q.execute(), "MSSBRN1A")
lob1Data.append(0)
lob1Data.append(0)
lob1Data.append(0)
lob1Data.append(0)
dates = list(
map(
lambda x: util.dateToTimeString(x).split("+")[0].split("T")[1].split(
":")[0], util.dateDataListToList(q.execute(), "_id")))
dataTicks = []
dataTickPos = []
for i in range(0, len(dates)):
if i % 4 == 0:
def deleteFlow(country, lobName, flowName):
lob = MediationConfig.getLobWithCountry(country, lobName)
if flowName in lob["flows"]:
MediationConfig.deleteFlow(lob["flows"][flowName])
return getLob(country, lobName)
def getFlowOptions(country, lobName, flowName):
lobConfig = MediationConfig.getLobWithCountry(country, lobName)
flowConfig = lobConfig["flows"][flowName]
return jsonify(flowConfig)
for i in range(0, len(data)):
start = max(0, i - window_size)
windowData = data[start:i + 1]
weights = [1 + x * x for x in range(0, len(windowData))]
s = 0
for x, y in zip(windowData, weights):
s += x * y
average = s / sum(weights)
output.append(average)
return output
fromDate = util.stringToTime("02.03.2017 00:00:00")
toDate = util.stringToTime("03.03.2017 00:00:00")
granularity = 60
x = MediationConfig.getLobWithCountry("CZ", "GSM")
q = DateRangeGroupQuery(
fromDate, toDate,
[MediationConfig.getLobWithCountry("CZ", "DAR")["flows"]["DARE2FEE"]],
granularity)
# q = DateRangeGroupQuery(fromDate, toDate, [MediationConfig.getLobWithCountry("CZ","ACI")["flows"]["GSM"]], granularity)
lob1Data = util.dateDataListToList(q.execute(), "DARE2FEE")
dates = list(
map(
lambda x: util.dateToTimeString(x).split("+")[0].split("T")[1].split(
":")[0], util.dateDataListToList(q.execute(), "_id")))
dataTicks = []
dataTickPos = []
for i in range(0, len(dates)):
if i % 4 == 0:
dataTicks.append(dates[i])
