def respond_with_json(
start_response: StartResponse,
json: str | bytes | Any,
*,
status: HTTPStatus = HTTPStatus.OK,
extra_headers: Sequence[Header] = [],
) -> Iterable[bytes]:
"""Prepare a JSON WSGI response.
>>> def handler(start_response, request):
... return respond_with_json(start_response, {"foo": "bar"})
The JSON text to return can be supplied as a string, as an UTF-8-encoded
bytestring, or as any object that can be serialized using json.dumps().
The default response status of "200 OK" can be overridden with the
"status" keyword argument.
"""
if isinstance(json, bytes):
encoded = json
elif isinstance(json, str):
encoded = json.encode("utf-8")
else:
encoded = dumps_json(json).encode("utf-8")
return respond_with_content(
start_response,
encoded,
status=status,
content_type="application/json; charset=utf-8",
extra_headers=extra_headers,
)
def store_alert(teamUUID, sensorUUID, mes_dict):
"""Pomocí HTTP příkazu post zašle mes_dict na Aimtec API jako Alert"""
url_alert = url_base + '/alerts'
headers_base_alert = {
'Content-Type': 'application/json',
'teamUUID': teamUUID
}
alert = dict_format_for_API_alert(mes_dict)
logging.info(alert)
body_alert = {
'createdOn': alert['created_on'],
'sensorUUID': sensorUUID,
'temperature': str(round(alert['temperature'], 1)),
'lowTemperature': alert['lowTemperature'],
'highTemperature': alert['highTemperature']
}
response = requests.post(url_alert,
data=dumps_json(body_alert),
headers=headers_base_alert)
logout = 'Storing alert to API for teamUUID = ' + teamUUID
logging.info(logout)
return response
def store_meas(teamUUID, sensorUUID, mes_dict):
"""Pomocí HTTP příkazu post zašle mes_dict na Aimtec API jako měření"""
url_measurement = url_base + '/measurements'
headers_base_measurement = {
'Content-Type': 'application/json',
'teamUUID': teamUUID
}
measurement = dict_format_for_API_meas(mes_dict)
logging.info(measurement)
body_measurement = {
'createdOn': measurement['created_on'],
'sensorUUID': sensorUUID,
'temperature': str(round(measurement['temperature'], 1)),
'status': 'TEST'
}
response = requests.post(url_measurement,
data=dumps_json(body_measurement),
headers=headers_base_measurement)
logout = 'Storing measurement to API for teamUUID = ' + teamUUID
logging.info(logout)
logging.info(response)
return response
async def request(method: str,
url: str,
params: dict = None,
data: Any = None,
json_body: bool = False,
timeout: int = 10,
**kwargs) -> AiohttpResp:
"""
原始网络请求封装。
Args:
method (str) : 请求方法。
url (str) : 请求 URL。
params (dict, optional) : 请求参数。
data (Any, optional) : 请求载荷。
json_body (bool, optional) : 载荷是否为 JSON
timeout (int, optional) : 超时时间
Returns:
返回 aiohttp 请求对象
"""
method = method.upper()
# 使用自定义 UA
DEFAULT_HEADERS = {
"user-agent": "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/76.0.3809.132 Safari/537.36"
}
headers = DEFAULT_HEADERS
if params is None:
params = {}
# 合并参数
config_ = {
"method": method,
"url": url,
"params": params,
"data": data,
"headers": headers,
}
# 支持自定义参数
config_.update(kwargs)
if json_body:
config_["headers"]["Content-Type"] = "application/json"
config_["data"] = dumps_json(config_["data"])
# 如果用户提供代理则设置代理
if not proxy_addr == '' and not proxy_port == '':
config_["proxy"] = f"socks5://{proxy_addr}:{proxy_port}"
elif not http_addr == '' and not http_port == '':
config_["proxy"] = f"http://{http_addr}:{http_port}"
session = aiohttp.ClientSession(timeout=aiohttp.ClientTimeout(total=timeout))
resp = await session.request(**config_)
# 返回请求
try:
resp_data = await resp.text()
except UnicodeDecodeError:
resp_data = await resp.read()
content = await resp.content.read()
status_code = resp.status
await session.close()
return AiohttpResp(resp_data, content, status_code)
def Load_last_data_from_DB(
teamname, status, day_avg, minimum, maximum
): #metoda nacte poslednich 10 hodnot pro dany tym a vraci dve struktury jednu se statusem offline druhou s predanym statusem
teamQuery = Query()
send = [0, 0]
ID = teams_send_dict[teamname]
last_data = []
time = []
for i in range(-10, 0):
last_data.append(
db.search(teamQuery.team == teamname)[i]['temperature'][:-11])
time.append(db.search(teamQuery.team == teamname)[i]['time'][11:-7])
slovnik_k_odeslani = {
"id": ID,
"status": status,
"data": last_data,
"times": time,
"max": maximum,
"min": minimum,
"avg": day_avg
} #vytvoreni struktury s predanym statusem
slovnik_k_odeslani = dumps_json(slovnik_k_odeslani)
slovnik_offline = {
"id": ID,
"status": 'offline',
"data": last_data,
"times": time,
"max": maximum,
"min": minimum,
"avg": day_avg
} #vytvoreni struktury se statusem offline
slovnik_offline = dumps_json(slovnik_offline)
send[0] = slovnik_k_odeslani
send[1] = slovnik_offline
return (send)
def login(body_login):
"""Přihlásí uživatele pomocí přihlašovacích údajů v body_login na AIMTEC API"""
url_login = url_base + '/login'
headers_base_login = {'Content-Type': 'application/json'}
login_data = loads_json(
requests.post(url_login,
data=dumps_json(body_login),
headers=headers_base_login).text)
logout = 'Logged in as ' + login_data['username']
logging.info(logout)
logout = 'teamUUID:', login_data['teamUUID']
logging.info(logout)
return login_data
def login():
"""Metoda vraci UUID tymu, a zaroven updatuje headers o dane teamUUID"""
url_login = url_base + '/login'
body_login = {'username': '******', 'password': '******'}
# login
login_data = loads_json(
requests.post(url_login,
data=dumps_json(body_login),
headers=headers_base).text)
print('\nLogin data:', login_data)
teamUUID = login_data['teamUUID']
print('\nteamUUID:', teamUUID)
headers_post.update({'teamUUID': teamUUID})
return (teamUUID)
def write_json_to_file(filepath: Path,
jsonstr: Dict[str, str],
indent: int = 4,
eof_line=True):
"""Dosyaya JSON yazar.
Dosya bulunamazsa ekrana raporlar hata fırlatmaz
Arguments:
filepath {Path} -- Okunacak dosyanın yolu
jsonstr {Dict[str, str]} -- JSON objesi
indent {int} -- JSON yazımı için varsayılan girinti uzunluğu
eof_line {bool} -- Dosyanın sonuna '\\n' koyar
Returns:
bool -- Yazma işlemi başarılı ise `True`
"""
jsonstr = dumps_json(jsonstr, indent=4)
jsonstr += "\n" if eof_line else ""
return write_to_file(filepath, jsonstr)
def store_measurement(temp):
'''
Sends the new measurement over the Aimtec REST API.
temp = currently measured temperature
'''
url_base = 'https://uvb1bb4153.execute-api.eu-central-1.amazonaws.com/Prod'
headers_base = {'Content-Type': 'application/json'}
# login
url_login = url_base + '/login'
body_login = {'username': '******', 'password': '******'}
login_data = loads_json(
requests.post(url_login,
data=dumps_json(body_login),
headers=headers_base).text)
teamUUID = login_data['teamUUID'] #saves team UUID
# get sensors
url_sensors = url_base + '/sensors'
headers_sensors = dict(headers_base)
headers_sensors.update({'teamUUID': teamUUID})
sensors_data = requests.get(url_sensors, headers=headers_sensors)
sensor_data_text = loads_json(sensors_data.text)
sensorUUID = sensor_data_text[0]['sensorUUID'] #saves sensor UUID
# create measurement
url_measurements = url_base + '/measurements'
headers_measurements = headers_sensors
now = datetime.now()
date_time = str(now).split(' ')
date_time[1] = date_time[1][:-3] + "+00:00"
createdOn = date_time[0] + 'T' + date_time[
1] #sets the time in the acceptable format
body_measurements = {
'createdOn': createdOn,
'sensorUUID': sensorUUID,
'temperature': str(temp),
'status': 'OK'
}
requests.post(url_measurements,
data=dumps_json(body_measurements),
headers=headers_measurements)
# create alert if the temperature steps out of the bounds
lowTemp = 0.0
highTemp = 25.0
if temp < lowTemp or temp > highTemp:
url_alerts = url_base + '/alerts'
headers_alerts = headers_sensors
now = datetime.now()
date_time = str(now).split(' ')
date_time[1] = date_time[1][:-3] + "+00:00"
createdOn = date_time[0] + 'T' + date_time[
1] #sets the time in the acceptable format
body_alerts = {
'createdOn': createdOn,
'sensorUUID': sensorUUID,
'temperature': str(temp),
'lowTemperature': str(lowTemp),
'highTemperature': str(highTemp)
}
requests.post(url_alerts,
data=dumps_json(body_alerts),
headers=headers_alerts)
def on_message(client, userdata, msg):
now = datetime.datetime.now()
if (msg.payload == 'Q'):
client.disconnect()
data = str(msg.payload)
team_name = re.search('(?<="team_name": ").+?(?=",)', data,
re.DOTALL).group().strip() #vyhledani jmena tymu
team_name = str(team_name)
created_on = re.search(
'(?<="created_on": ").+?(?=", "temperature")', data,
re.DOTALL).group().strip() #vyhledani kdy byla teplota nactena
temperature = re.search('(?<="temperature": ).+?(?=})', data,
re.DOTALL).group().strip()
data = {
"createdOn": created_on[:-3] + "+01:00",
"sensorUUID": sensor_UUID,
"temperature": temperature,
'status': 'TEST'
} #vytvoreni struktury dat k poslani
temperature_float = float(temperature)
global New_data
global hour_stats
global day_stats
global alert
global offline_data
status = "online"
if team_name == "green": #test zda se jedna o zeleny tym
b = requests.post(url_post,
data=dumps_json(data),
headers=headers_post)
if (
(temperature_float < minimum or temperature_float > maximum)
and alert == False
): #vyhodnoceni zda se teplota nachazi v danem rozmezi a zaroven jeste nebyl zaslan alert
dataalert = {
"createdOn": created_on[:-3] + "+01:00",
"sensorUUID": sensor_UUID,
"temperature": temperature,
"lowTemperature": minimum,
"highTemperature": maximum
}
url_alert = url_base + '/alerts'
b = requests.post(url_alert,
data=dumps_json(dataalert),
headers=headers_post)
alert = True
if (temperature_float > minimum and temperature_float < maximum
and alert): #zmena teploty zpet do standartnich hodnot
alert = False
if alert == True:
status = "alert"
#Vypocet statistickych dat
if day_stats.day != datetime.datetime.now(
).day: #pulnoc nulovani statistik
day_stats.midnight()
index_stats = teams_dict[team_name] #zjisteni indexu daneho tymu
Stats_update(temperature_float, team_name,
index_stats) #volani metody pro update statistik
db.insert({
'team': team_name,
'time': created_on,
'temperature': temperature
}) #vlozeni dat do databaze
load_data = Load_last_data_from_DB(
team_name, status, day_stats.avg[index_stats],
day_stats.min[index_stats],
day_stats.max[index_stats]) #nacteni dat do bufferu
Data_to_be_send[int(teams_dict[team_name])] = load_data[
0] #buffer dat k odeslani poslednich 10 hodnot daneho tymu
offline_data[int(teams_dict[team_name])] = load_data[
1] #poslednich 10 hodnot se statusem offline v pripade vypadku cidla
if hour_stats.hour != datetime.datetime.now().hour: #detekce zmeny hodiny
hour_stats.fullhour(
) #volani metody z tridy hour_stats pro ulozeni dat do databaze
New_data[teams_dict[
team_name]] = 1 #signalizace pro asynchroni metodu ze prisla nova teplota
print(a)
print(type(a))
adict = ast.literal_eval(a)
print(adict)
print(type(adict))
print(adict['source'])
teamUUID = 'f32c6941-bc2d-41b2-8bb3-cb6082427613' #blue
sensorUUIDblue = 'd384a529-6227-4133-afc9-4f5a16665f1f'
id = 0
#now = datetime.now()
tms = datetime.strptime(adict['created_on'], '%Y-%m-%dT%H:%M:%S.%f')
time = tms.strftime("%Y-%m-%d") + 'T' + tms.strftime("%H:%M:%S.") + str(
int(tms.strftime("%f")) // 1000) + '+' + '01:00'
url_base = 'https://uvb1bb4153.execute-api.eu-central-1.amazonaws.com/Prod'
url_measurement = url_base + '/measurements'
headers_base = {'Content-Type': 'application/json', 'teamUUID': teamUUID}
#body_measurement = {'id': id, 'createdOn': adict['created_on'], 'sensorUUID': sensorUUIDblue, 'temperature': adict['temperature'], 'status': adict['source'], 'modifiedOn': str(now), 'timestamp': now.timestamp()}
body_measurement = {
'createdOn': time,
'sensorUUID': sensorUUIDblue,
'temperature': str(round(adict['temperature'], 1)),
'status': 'TEST'
}
F = requests.post(url_measurement,
data=dumps_json(body_measurement),
headers=headers_base)
def get_json(self):
dic = copy(self.__dict__)
dic["header"] = self.header.hex()
dic["content"] = dumps_pickle(
self.content).hex() # Hay que serializarlo de algún modo
return dumps_json(dic)
#login
import requests
from json import dumps as dumps_json, loads as loads_json
url_base = 'https://uvb1bb4153.execute-api.eu-central-1.amazonaws.com/Prod'
headers_base = {'Content-Type': 'application/json'}
# login
url_login = url_base + '/login'
body_login = {'username': '******', 'password': '******'}
login_data = loads_json(
requests.post(url_login, data=dumps_json(body_login),
headers=headers_base).text)
print('\nLogin data:', login_data)
teamUUID = login_data['teamUUID']
print('\nteamUUID:', teamUUID)
# get sensors
url_sensors = url_base + '/sensors'
headers_sensors = dict(headers_base)
headers_sensors.update({'teamUUID': teamUUID})
sensors_data = requests.get(url_sensors, headers=headers_sensors)
print('\nSensors data:', loads_json(sensors_data.text))
