def temperature_task():
global is_temperature_limit, is_humidity_limit
logger.info('start temperature collect!')
is_temperature_limit = True
is_humidity_limit = True
try:
# Print the values to the serial port
temperature_c = dht_device.temperature
temperature_f = temperature_c * (9 / 5) + 32
humidity = dht_device.humidity
logger.info("Temp: {:.1f} F / {:.1f} C Humidity: {}% ".format(
temperature_f, temperature_c, humidity))
data['temperature'] = "{:.1f}".format(temperature_c)
data['humidity'] = "{}".format(humidity)
if float(data['temperature']) > float(data['temperature_limit']):
is_temperature_limit = False
if float(data['humidity']) > float(data['humidity_limit']):
is_temperature_limit = False
except RuntimeError as error:
# Errors happen fairly often, DHT's are hard to read, just keep going
logger.error(error.args[0])
except Exception as error:
dht_device.exit()
logger.error(error)
def getDailySensorData():
uuid = request.args.get('uuid', None)
logger.info(uuid)
if uuid is None:
raise ContentEmptyException()
return response_success('success', get_sensor_data_hourly(uuid))
def insert_sensor_data(temperature: str, humidity: str, uuid: str, fire: bool,
illumination: bool, solid: bool):
logger.info('insert_sensor_data')
return MysqlOp().op_sql(
'INSERT INTO sensor_data (hardware_uuid, temperature, humidity, is_fire, is_dry, is_illum) VALUES (%s, %s, %s, %s, %s, %s)',
(uuid, temperature, humidity, int(fire), int(solid),
int(illumination)))
def get(self):
logger.info('start /account/fetch-users/ request')
user_list = AccountLoonUserModel.get_all_user()
if user_list is None:
return api_response('', 400)
return api_response({"msg": "", "code": 0, "data": user_list}, 200)
def get_sensor_pagination(page, size, ordered, where_sql, *args):
logger.info('get_sensor_pagination')
return MysqlOp().select_all(
f"SELECT sensor_data.id, hardware_uuid, temperature, humidity, is_fire, is_dry, is_illum, record_time, `name` "
f"FROM sensor_data LEFT JOIN hardware ON sensor_data.hardware_uuid = hardware.uuid "
f" {where_sql} ORDER BY {ordered} ASC LIMIT %s OFFSET %s",
(*args, size, (page - 1) * size))
def count_total_user_hardware(where_sql, *args):
logger.info('count_total_user_hardware')
return MysqlOp().select_one(
f'SELECT COUNT(`user_id`) as len from user_hardware '
f'LEFT JOIN `user` ON `user`.id = user_hardware.user_id '
f'LEFT JOIN hardware ON hardware.uuid = user_hardware.hardware_uuid '
f'{where_sql}', (*args, ))
def patch(self, ticket_id):
logger.info(f'start patch /service/tickets/{ticket_id} request')
username = get_request_username()
if not ticket_id:
return api_response("请输入工单id", 400)
ins = WorkFlowAPiRequest(username)
request_data = json.loads(request.data)
request_data['username'] = username
status, resp = ins.getdata(
parameters={},
method='patch',
url='/api/v1.0/tickets/{}'.format(ticket_id),
data=request_data)
if resp['code'] == 0:
return api_response(
{
'code': resp['code'],
'data': resp['data'],
'msg': resp['msg']
}, 200)
else:
return api_response(
{
'code': resp['code'],
'data': None,
'msg': resp['msg']
}, 400)
def get(self, ticket_id):
logger.info(f'start get /service/tickets/{ticket_id} request')
username = get_request_username()
if not ticket_id:
return api_response("请输入工单id", 400)
ins = WorkFlowAPiRequest(username)
status, resp = ins.getdata(
dict(per_page=10, name=''),
method='get',
url='/api/v1.0/tickets/{}?username={}'.format(ticket_id, username))
if resp['code'] == 0:
return api_response(
{
'code': resp['code'],
'data': resp['data'],
'msg': resp['msg']
}, 200)
else:
return api_response(
{
'code': resp['code'],
'data': None,
'msg': resp['msg']
}, 400)
def get(self, params):
logger.info('start /service/tickets/ request')
username = get_request_username()
category = params['category']
page = params['page'] or 1
url = '/api/v1.0/tickets?username={}'.format(username)
if category:
url += '&category={}'.format(category)
ins = WorkFlowAPiRequest(username)
status, resp = ins.getdata(dict(per_page=10, name='', page=page),
method='get',
url=url)
if resp['code'] == 0:
return api_response(
{
'code': resp['code'],
'data': resp['data'],
'msg': resp['msg']
}, 200)
else:
return api_response(
{
'code': resp['code'],
'data': None,
'msg': resp['msg']
}, 400)
def get(self, params):
logger.info('start /service/ueditor/ request')
action = params['action']
if action == 'config':
return api_response(UEDITER_SETTING, 200)
return api_response("禁用其他参数相关功能", 400)
def get_user_pagination(page, size, where_sql, *args):
logger.info('get_user_pagination')
return MysqlOp().select_all(
f"SELECT `user`.id, username, role.`name` FROM `user` "
f"LEFT JOIN user_roles ON `user`.id = user_roles.user_id "
f"LEFT JOIN role ON user_roles.role_id = role.id "
f"{where_sql} LIMIT %s OFFSET %s", (*args, size, (page - 1) * size))
def solid_task():
global solid_regular
logger.info('start solid check!')
solid_regular = True
if GPIO.input(solid_pin) == 1:
logger.info(f'需要进行灌溉！')
solid_regular = False
data['solid'] = not solid_regular
def fire_task():
global fire_regular
logger.info('start fire check!')
fire_regular = True
if GPIO.input(fire_pin) == 0:
logger.info(f'fire!fire!fire!')
fire_regular = False
data['fire'] = not fire_regular
def handle_mqtt_connect(client, userdata, flags, rc):
if rc == 0:
logger.info('Connected to mqtt broker!')
else:
logger.info('Failed to connect to mqtt broker!')
client.subscribe(setup_threshold_topic)
client.on_message = handle_mqtt_message
def get_rfid_pagination(page, size, ordered, where_sql, *args):
logger.info('get_sensor_pagination')
return MysqlOp().select_all(
f"SELECT username, log_time, hardware_uuid, `name` FROM RFID_log "
f"LEFT JOIN `user` ON RFID_log.user_id = `user`.id "
f"LEFT JOIN hardware ON RFID_log.hardware_uuid = hardware.uuid "
f"{where_sql} ORDER BY {ordered} ASC LIMIT %s OFFSET %s",
(*args, size, (page - 1) * size))
def get_hardware_pagination_by_username(username, page, size, ordered,
where_sql, *args):
logger.info('get_hardware_pagination_by_username')
return MysqlOp().select_all(
f'SELECT * FROM hardware WHERE uuid IN '
f'(SELECT hardware_uuid FROM user_hardware WHERE user_id = (SELECT id FROM `user` WHERE username = %s)) {where_sql} '
f'ORDER BY {ordered} ASC LIMIT %s OFFSET %s',
(username, *args, size, (page - 1) * size))
def get_sensor_pagination_by_username(username, page, size, ordered, where_sql, *args):
logger.info('get_hardware_pagination_by_username')
return MysqlOp().select_all(
f'SELECT sensor_data.id, hardware_uuid, temperature, humidity, is_fire, is_dry, is_illum, record_time, `name` '
f'FROM sensor_data LEFT JOIN hardware ON sensor_data.hardware_uuid = hardware.uuid'
f' WHERE hardware_uuid IN (SELECT hardware_uuid FROM user_hardware '
f'WHERE user_id = (SELECT id FROM `user` WHERE username = %s)) {where_sql} '
f'ORDER BY {ordered} ASC LIMIT %s OFFSET %s',
(username, *args, size, (page - 1) * size))
def handle_mqtt_message(client, userdata, message):
logger.info(f'topic: {message.topic}, message: {message.payload.decode()}')
if message.topic == sensor_data_topic:
data = json.loads(message.payload)
insert_sensor_data(data['temperature'], data['humidity'], data['uuid'],
data['fire'], data['illumination'], data['solid'])
elif message.topic == rfid_topic:
data = json.loads(message.payload)
insert_rfid_log(match(r'(\d+)', data['text']).group(1), data['uuid'])
def post(self, params):
logger.info('start /account/obtain_token/ request')
# todo:注意用户名只能是英文，否则前端报错，在导入用户数据时 注意校验
username = params['username']
user = AccountLoonUserModel.get_user_obj(username)
if user is None:
return api_response('', 400)
return api_response({'token': f'{user.id}.{user.username}'}, 200)
def warpper(*args, **kw):
rel_key = key + str(args) + str(kw)
# 判断缓存是否存在
logger.info('check key: %s' % rel_key)
cache_msg = redis.get(rel_key)
if cache_msg is None:
# 若不存在则执行获取数据的方法
# 注意返回数据的类型(字符串，数字，字典，列表均可)
cache_msg = dumps(func(*args, **kw), cls=ComplexEncoder)
redis.set(rel_key, cache_msg, ex=timeout)
return loads(cache_msg)
def get_rfid_pagination_by_username(username, page, size, ordered, where_sql,
*args):
logger.info('get_hardware_pagination_by_username')
return MysqlOp().select_all(
f'SELECT username, log_time, hardware_uuid, `name` FROM RFID_log '
f'LEFT JOIN `user` ON RFID_log.user_id = `user`.id '
f'LEFT JOIN hardware ON RFID_log.hardware_uuid = hardware.uuid '
f'WHERE hardware_uuid IN (SELECT hardware_uuid '
f'FROM user_hardware WHERE user_id = (SELECT id FROM `user` WHERE username = %s)) {where_sql} '
f'ORDER BY {ordered} ASC LIMIT %s OFFSET %s',
(username, *args, size, (page - 1) * size))
def warpper(*args, **kw):
# 判断缓存是否存在
logger.info('check key: %s' % key)
cache_msg = redis.get(key)
if cache_msg is None:
# 若不存在则执行获取数据的方法
# 注意返回数据的类型(字符串，数字，字典，列表均可)
cache_msg = func(*args, **kw)
redis.set(key, dumps(cache_msg), ex=timeout)
else:
cache_msg = loads(cache_msg)
return cache_msg
def handle_mqtt_message(client, userdata, message):
logger.info(
f'topic: {message.topic}, message: {message.payload.decode()}')
if message.topic == setup_threshold_topic:
msg = json.loads(message.payload)
data['temperature_limit'] = msg['temperature_limit']
data['humidity_limit'] = msg['humidity_limit']
f = open('./c.json', 'w', encoding='utf-8')
f.write(
json.dumps({
'uuid': data['uuid'],
'temperature_limit': data['temperature_limit'],
'humidity_limit': data['humidity_limit']
}))
f.close()
def select_all(self, query, params=None):
'''
查询数据表的单条数据
:param query:包含%s的sql字符串，当params=None的时候，不包含%s
:param params:一个元祖，默认为None
:return:如果执行未crash，并以包含dict的列表的方式返回select的结果，否则返回错误代码001
'''
try:
self.cur.execute(query, params)
# self.cur.scroll(0, "absolute") # 光标回到初始位置，感觉这里得这句有点多余
return self.cur.fetchall()
except BaseException as e:
logger.info("[sql_query] - %s" % query)
logger.info("[sql_params] - %s" % params)
logger.exception(e)
return None # 错误代码001
def insert_many(self, query, params):
'''
向数据表中插入多条数据
:param query:包含%s的sql字符串，当params=None的时候，不包含%s
:param params:一个内容为元祖的列表
:return:如果执行过程没有crash，返回True，反之返回False
'''
try:
self.cur.executemany(query, params)
self.conn.commit()
return True
except BaseException as e:
self.conn.rollback()
logger.info("[sql_query] - %s" % query)
logger.info("[sql_params] - %s" % params)
logger.exception(e)
return False
def op_sql(self, query, params=None):
'''
单条数据的操作，insert，update，delete
:param query:包含%s的sql字符串，当params=None的时候，不包含%s
:param params:一个元祖，默认为None
:return:如果执行过程没有crash，返回True，反之返回False
'''
try:
self.cur.execute(query, params)
self.conn.commit()
return True
except BaseException as e:
self.conn.rollback() # 如果这里是执行的执行存储过程的sql命令，那么可能会存在rollback的情况，所以这里应该考虑到
logger.info("[sql_query] - %s" % query)
logger.info("[sql_params] - %s" % (params,))
logger.exception(e)
return False
def regular_task():
global is_init
if fire_regular and solid_regular and illumination_regular and is_temperature_limit and is_humidity_limit:
if not is_init:
# change to green
pwm_r.ChangeDutyCycle(0)
pwm_g.ChangeDutyCycle(100)
pwm_b.ChangeDutyCycle(100)
else:
pwm_r.ChangeDutyCycle(100)
pwm_g.ChangeDutyCycle(0)
pwm_b.ChangeDutyCycle(100)
is_init = False
logger.info(
f"{fire_regular}/{solid_regular}/{illumination_regular}/{is_temperature_limit}/{is_humidity_limit}"
)
def get(self):
logger.info('start /service/workflows/ request')
ins = WorkFlowAPiRequest(get_request_username())
status, resp = ins.getdata(dict(per_page=10, name=''),
method='get',
url='/api/v1.0/workflows')
if resp['code'] == 0:
return api_response(
{
'code': resp['code'],
'data': resp['data'],
'msg': resp['msg']
}, 200)
else:
return api_response(
{
'code': resp['code'],
'data': None,
'msg': resp['msg']
}, 400)
def illumination_task():
global illumination_regular, is_shine, first_illum_not_enough
logger.info('start illumination check')
illumination_regular = True
if GPIO.input(illumination_pin) == 1:
logger.info('需要光照！')
illumination_regular = False
if is_shine == False:
GPIO.output(light_pin, True)
is_shine = True
first_illum_not_enough += 1
else:
first_illum_not_enough = 0
if is_shine == True:
GPIO.output(light_pin, False)
is_shine = False
if first_illum_not_enough == 2:
data['illumination'] = True
else:
data['illumination'] = False
def after_request(response):
# 获取响应数据
try:
response_data = json.loads(response.data)
except Exception:
response_data = response.data
log_info = {
"host": request.host_url,
"path": request.path,
"method": request.method,
"response": {
"header": dict(response.headers),
# 日志响应结果保留 5000个字符
"params": str(response_data)[:5000] or "UnKnown Response Data",
}
}
logger.info(log_info)
return response
