def password_recovery_request():
"""check login data and returns user data with token"""
req_data = request.get_json()
user_data = DB.get_object('users', req_data, create=False)
if not user_data or not user_data['email']:
return bad_request('Пользователь или email не зарегистрирован.\n' +\
'The username or email address is not registered.')
token = _create_token({
'login': req_data['login'],
'type': 'passwordRecovery',
'expires': time.time() + 60 * 60 * 60})
text = """Пройдите по ссылкe, чтобы сменить пароль на ONEADIF.com: """\
+ CONF.get('web', 'address')\
+ '/#/passwordRecovery?token=' + token + """
Если вы не запрашивали смену пароля на ONEADIF.com, просто игнорируйте это письмо.
Ссылка будет действительна в течение 1 часа.
Follow this link to change your ONEADIF.com password: """ \
+ CONF.get('web', 'address')\
+ '/#/passwordRecovery?token=' + token + """
Ignore this message if you did not request password change
Служба поддержки ONEADIF.com support"""
send_email.send_email(text=text,\
fr=CONF.get('email', 'address'),\
to=user_data['email'],\
subject="ONEADIF.com - password change")
return jsonify({'message':\
'На ваш почтовый адрес было отправлено письмо с инструкциями по ' +\
'сменен пароля.\n' +\
'The message with password change instrunctions was sent to your ' +\
'email address'})
def post_device_props(device_id):
"""saves updated device title/props to db"""
device_id = int(device_id)
req_data = request.get_json()
error = None
check_device = DB.execute("""
select login, devices_types.props as props_headers
from devices join devices_types
on devices.device_type_id = devices_types.id
where devices.id = %(id)s""", {'id': device_id},
keys=False)
if check_device:
if check_device['login'] == req_data['login']:
upd_params = {}
if 'delete' in req_data and req_data['delete']:
upd_params = {'login': None}
else:
upd_params = {'title': req_data['title'],\
'schedule_id': req_data['schedule_id']\
if 'schedule_id' in req_data else None,\
'mode': req_data['mode'] if 'mode' in req_data else None,\
'props': json.dumps(req_data['props'])}
DB.param_update('devices', {'id': device_id}, upd_params)
else:
error = 'Устройство зарегистрировано другим пользователем.'
else:
error = 'Устройство не найдено.'
if error:
return bad_request(error)
else:
return ok_response()
def post_switch_settings(device_id, switch_id):
"""updates switch title and other settings"""
device_id = int(device_id)
switch_id = int(switch_id)
req_data = request.get_json()
error = None
check_switch = DB.execute("""
select login
from devices join devices_switches
on devices.id = devices_switches.device_id
where devices.id = %(device_id)s and
devices_switches.device_type_switch_id = %(switch_id)s""",\
{'device_id': device_id, 'switch_id': switch_id}, keys=False)
if check_switch:
logging.debug('check_switch')
logging.debug(check_switch)
if check_switch == req_data['login']:
DB.param_update('devices_switches',\
{'device_id': device_id, 'device_type_switch_id': switch_id},\
{'title': req_data['title'],\
'enabled': req_data['enabled']})
else:
error = 'Датчик зарегистрирован другим пользователем.'
else:
error = 'Датчик не найден.'
if error:
return bad_request(error)
else:
return ok_response()
def post_sensor_settings(sensor_id):
"""updates sensor title and other settings"""
sensor_id = int(sensor_id)
req_data = request.get_json()
error = None
check_sensor = DB.execute("""
select login
from sensors join devices on sensors.device_id = devices.id
where sensors.id = %(id)s""", {'id': sensor_id},
keys=False)
if check_sensor:
if check_sensor == req_data['login']:
DB.param_update('sensors',\
{'id': sensor_id},\
{'title': req_data['title'],\
'enabled': req_data['enabled'],\
'correction': req_data['correction'],\
'is_master': req_data['is_master']})
else:
error = 'Датчик зарегистрирован другим пользователем.'
else:
error = 'Датчик не найден.'
if error:
return bad_request(error)
else:
return ok_response()
def delete_schedule(schedule_id):
"""deletes device schedule from db"""
error = None
req_data = request.get_json()
schedule_id = int(schedule_id)
check_schedule = DB.execute("""
select login
from device_schedules
where id = %(id)s""", {'id': schedule_id},
keys=False)
if check_schedule:
if check_schedule == req_data['login']:
DB.execute(
"""
delete from device_schedule_items
where schedule_id = %(schedule_id)s
""", {'schedule_id': schedule_id})
DB.param_delete('device_schedules', {'id': schedule_id})
else:
error = 'Шаблон зарегистрирован другим пользователем.'
else:
error = 'Шаблон не найден.'
if error:
return bad_request(error)
else:
return ok_response()
def post_sensors_data():
"""stores sensors data in db"""
req_data = request.get_json()
update_device_last_contact(req_data['device_id'])
device_sensors = DB.execute("""
select device_type_sensor_id as id, id as sensor_id
from sensors
where device_id = %(device_id)s
""",
req_data,
keys=True)
if device_sensors:
device_rtc = DB.execute(
"""
select rtc
from devices_types join devices
on devices.device_type_id = devices_types.id
where devices.id = %(device_id)s
""", req_data)
for item in req_data['data']:
if item['sensor_id'] in device_sensors.keys():
item['sensor_id'] = device_sensors[
item['sensor_id']]['sensor_id']
if not device_rtc:
del item['tstamp']
DB.get_object('sensors_data', item, create=True)
else:
return bad_request('Device sensors not found')
return ok_response()
def register_device():
"""binds device to user's account"""
req_data = request.get_json()
device_id = HASHIDS.decode(req_data['device_hash'])
error = None
if device_id:
check_device = DB.execute(
"""
select id, login
from devices
where id = %(device_id)s
""", {'device_id': device_id}, False)
if check_device:
if check_device['login']:
if check_device['login'] == req_data['login']:
error = 'Вы уже зарегистрировали это устройство.\n' +\
'You had already registered this device.'
else:
error = 'Устройство уже зарегистрировано дркгим пользователем.\n' +\
'Another user had already registered this device.'
else:
DB.param_update('devices', {'id': device_id},
{'login': req_data['login']})
else:
error = 'Устройство не найдено. Device not found.'
else:
error = 'Неверный код устройства. Invalid device code.'
if error:
return bad_request(error)
else:
return ok_response()
def create_device():
"""registers device and it's sensors data in db;
returns json {"device_id": _, "device_token": _}"""
req_data = request.get_json()
check_device_type = DB.execute(
"""
select id
from devices_types
where id = %(device_type_id)s
""", req_data)
if not check_device_type:
return bad_request('Неверный тип устройства. Invalid device type.')
else:
device_db_data = DB.get_object('devices',\
splice_request("login", "device_type_id"), create=True)
DB.execute(
"""insert into sensors (device_type_sensor_id, device_id)
select id, %(id)s
from device_type_sensors
where device_type_id = %(device_type_id)s""", device_db_data)
token = _create_token({'device_id': device_db_data['id']})
return jsonify({
'device_id': device_db_data['id'],
'device_token': token
})
def register_user():
"""registers user and returns user data with token"""
user_data = request.get_json()
user_exists = DB.get_object('users', {'login': user_data['login']}, create=False)
if user_exists:
return bad_request('Пользователь с этим именем уже зарегистрирован.\n' +\
'This username is already exists.')
return send_user_data(user_data, create=True)
def register_user():
"""registers user and returns user data with token"""
user_data = request.get_json()
user_exists = DB.get_object('users', {'login': user_data['login']},
create=False)
if user_exists:
return bad_request('Пользователь с этим именем уже зарегистрирован.')
user_data['public_id'] = _create_public_id()
return send_user_data(splice_params(user_data, 'login', 'public_id', 'password'),\
create=True)
def upload_cancel():
req_data = request.get_json()
if DB.execute("""select upload_id
from uploads join accounts on uploads.account_id = accounts.account_id
where upload_id = %(upload_id)s and login = %(login)s""", req_data):
with upload_client() as conn:
conn.send(('cancel', req_data['upload_id']))
rsp = conn.recv()
return jsonify(rsp)
else:
return bad_request('Загрузка не найдена.\n' +\
'Upload not found')
def send_user_data(user_data, create=False):
"""returns user data with auth token as json response"""
data = DB.get_object('users', user_data, create=create)
if data:
token = _create_token({'login': data['login'], 'type': 'auth'})
del data['password']
data['token'] = token
return jsonify(data)
else:
if create:
raise Exception("User creation failed")
else:
return bad_request('Неверное имя пользователя или пароль.\n' +\
'Wrong username or password')
def get_sensor_info(sensor_id):
"""returns sensor info json"""
sensor_id = int(sensor_id)
sensor_data = DB.execute("""
select sensors.title as sensor_title,
device_type_sensors.title as device_type_title,
sensor_type, correction
from sensors join device_type_sensors
on device_type_sensor_id = device_type_sensors.id
where sensors.id = %(sensor_id)s
""", {'sensor_id': sensor_id},
keys=False)
if not sensor_data:
return bad_request('Сенсор не найден. Sensor not found.')
return jsonify(sensor_data)
def get_schedule_data(schedule_id):
"""returns device schedule itesm (days) in json"""
schedule_id = int(schedule_id)
schedule_data = DB.execute("""
select device_schedules.id, device_type_id as device_type_id,
device_schedules.title, devices_types.title as device_type_title,
device_schedules.params
from device_schedules join devices_types
on device_type_id = devices_types.id
where device_schedules.id = %(schedule_id)s
""", {'schedule_id': schedule_id},
keys=False)
if not schedule_data:
return bad_request('Шаблон не найден.')
schedule_data['items'] = schedule_items(schedule_id)
return jsonify(schedule_data)
def post_schedule_data(schedule_id):
"""saves new/edited device schedule to db"""
error = None
req_data = request.get_json()
req_data['hash'] = hashlib.md5(
json.dumps(req_data, sort_keys=True).encode('utf-8')).hexdigest()
if schedule_id == 'new':
schedule = DB.get_object('device_schedules',\
splice_params(req_data, 'login', 'title', 'device_type_id', 'hash', 'params'),\
create=True)
if schedule:
schedule_id = schedule['id']
else:
raise Exception('Ошибка создания шаблона.')
else:
schedule_id = int(schedule_id)
check_schedule = DB.execute("""
select login
from device_schedules
where id = %(id)s""", {'id': schedule_id},
keys=False)
if check_schedule:
if check_schedule == req_data['login']:
DB.param_update('device_schedules',\
{'id': schedule_id},\
splice_params(req_data, 'title', 'device_type_id', 'hash', 'params'))
DB.execute(
"""
delete from device_schedule_items
where schedule_id = %(schedule_id)s
""", {'schedule_id': schedule_id})
else:
error = 'Шаблон зарегистрирован другим пользователем.'
else:
error = 'Шаблон не найдено.'
if error:
return bad_request(error)
else:
DB.execute("""
insert into device_schedule_items (schedule_id, day_no, params)
values (%(schedule_id)s, %(day_no)s, %(params)s)""",\
[{'schedule_id': schedule_id,\
'day_no': item['day_no'],\
'params': json.dumps(item['params'])}\
for item in req_data['items']])
return jsonify({'id': schedule_id})
def get_device_info(device_id):
"""returns device info json"""
device_id = int(device_id)
device_data = DB.execute("""
select device_type_id as device_type_id,
devices_types.title as device_type,
devices.title as title,
schedule_id, mode,
devices_types.props as props_titles,
devices.props as props_values
from devices join devices_types
on device_type_id = devices_types.id
where devices.id = %(device_id)s
""", {'device_id': device_id},
keys=False)
if not device_data:
return bad_request('Устройство не найдено. Device not found.')
timezone_ts, timezone_dev, _ = get_timezones(device_id=device_id)
device_data['hash'] = HASHIDS.encode(device_id)
device_data['sensors'] = DB.execute("""
select * from
(select sensors.id, sensors.is_master, sensor_type as type, device_type_sensor_id,
sensors.title as title, device_type_sensors.title as default_title,
sensors.enabled, sensors.correction, device_type_sensors.modes,
device_type_sensors.computed_expression,
device_type_sensors.sensors_group as group
from sensors join device_type_sensors on
device_type_sensors.id = sensors.device_type_sensor_id
where device_id = %(device_id)s) as sensors
left join lateral (select value,
to_char(tstamp::timestamp at time zone %(timezone_ts)s
at time zone %(timezone_dev)s, 'YYYY-MM-DD HH24:MI:SS') as tstamp
from sensors_data
where sensor_id = sensors.id
order by sensors_data.tstamp desc
limit 1) as last_data
on true
order by device_type_sensor_id
""", {'device_id': device_id, 'timezone_ts': timezone_ts, 'timezone_dev': timezone_dev},\
keys=False)
if device_data['sensors']:
for computed_sensor in device_data['sensors']:
if computed_sensor['computed_expression']:
sensors_group = [sensor for sensor in device_data['sensors']\
if not sensor['computed_expression'] and\
sensor['group'] == computed_sensor['group']]
if sensors_group:
sensors_group_values = {
'v' + str(idx): sensor['value']
for idx, sensor in enumerate(sensors_group)
}
try:
computed_sensor['value'] = round(eval(computed_sensor['computed_expression'],\
{}, sensors_group_values), 2)
computed_sensor['tstamp'] = sensors_group[0]['tstamp']
except Exception as exc:
logging.exception(exc)
logging.error('Error computing sensor value')
logging.error('Exxpression: %s',
computed_sensor['computed_expression'])
logging.error('Values:')
logging.error(sensors_group_values)
device_data['switches'] = DB.execute("""
select * from
(select device_type_switch_id as id,
devices_switches.title as title, device_type_switches.title as default_title,
enabled, device_type_switches.type, device_type_switches.modes
from devices_switches join device_type_switches on
device_type_switches.id = devices_switches.device_type_switch_id
where device_id = %(device_id)s) as switches
left join lateral (select state,
to_char(tstamp, 'YYYY-MM-DD HH24:MI:SS') as tstamp
from devices_switches_state
where devices_switches_state.device_id = %(device_id)s
and devices_switches_state.device_type_switch_id = switches.id
order by devices_switches_state.tstamp desc
limit 1) as last_data
on true
order by id
""", {'device_id': device_id},
keys=False)
timezone_dev_shift = tz_shift(timezone_dev)
for data_type in ('sensors', 'switches'):
if isinstance(device_data[data_type], dict):
device_data[data_type] = [
device_data[data_type],
]
if device_data[data_type]:
for row in device_data[data_type]:
if row['tstamp']:
row['tstamp'] += timezone_dev_shift
return jsonify(device_data)
