import logging
import logging.config
from docker_secrets import getDocketSecrets
from check_service import checkService
import requests
logger = logging.getLogger()
session = requests.Session()
homeToken = getDocketSecrets("iotcloud_home_token")
url = "https://home.iotcloud.es"
@checkService("Home API")
def checkHome():
headers = {"Authorization": f"Bearer {homeToken}"}
requestId = "ff36a3cc-ec34-11e6-b1a0-64510650abcf"
payload = {
"requestId": requestId,
"inputs": [{
"intent": "action.devices.SYNC"
}],
}
response = session.post(url, json=payload, headers=headers)
decodedResponse = response.json()
assert decodedResponse["requestId"] == requestId
import logging
import json
import firebase_admin
from firebase_admin import messaging
from docker_secrets import getDocketSecrets
logger = logging.getLogger(__name__)
firebaseCredentials = {
"type": getDocketSecrets("type"),
"project_id": getDocketSecrets("project_id"),
"private_key_id": getDocketSecrets("private_key_id"),
"private_key": getDocketSecrets("private_key"),
"client_email": getDocketSecrets("client_email"),
"client_id": getDocketSecrets("client_id"),
"auth_uri": getDocketSecrets("auth_uri"),
"token_uri": getDocketSecrets("token_uri"),
"auth_provider_x509_cert_url": getDocketSecrets("auth_provider_x509_cert_url"),
"client_x509_cert_url": getDocketSecrets("client_x509_cert_url"),
}
cred = firebase_admin.credentials.Certificate(firebaseCredentials)
firebase_admin.initialize_app(cred)
def sendLocationNotification(
locationId,
notificationTitle,
notificationBody,
userToken,
from urllib3 import poolmanager
import time
from dateutil import tz
import datetime
from stations_list import stationsList
from location_list import locationsList
from geocodes_list import geocodesList
from cache import cache_disk
from docker_secrets import getDocketSecrets
import utils
logger = logging.getLogger(__name__)
googleApiKey = getDocketSecrets("googleApiKey")
aemetApiKey = getDocketSecrets("aemetApiKey")
measurements = {
"temperature": {
"observationMeasurementName": "ta",
"predictionMeasurementName": "temperatura",
},
"humidity": {
"observationMeasurementName": "hr",
"predictionMeasurementName": "humedadRelativa",
},
}
# Requiered to fix the AEMET cipher
class IotCloudApi:
iotcloudApiUrl = getDocketSecrets("api_url")
client_id = getDocketSecrets("api_client_id")
client_secret = getDocketSecrets("api_client_secret")
auth_url = getDocketSecrets("auth_url")
audience = getDocketSecrets("api_audience")
accessToken = ""
def __init__(self):
self.token = ""
self.session = requests.session()
def getAuthHeader(self):
headers = {"Authorization": "Bearer " + self.accessToken}
return headers
def authenticate(self):
data = {
"client_id": self.client_id,
"client_secret": self.client_secret,
"grant_type": "client_credentials",
"audience": self.audience,
}
result = requests.post(self.auth_url, json=data)
try:
decodedResult = result.json()
self.accessToken = decodedResult["access_token"]
except (KeyError, TypeError, ValueError):
logger.error(
"authenticate: User could NOT be successfully authenticated.")
return False
logger.info("authenticate: User authenticated successfully.")
return True
def validateResponse(self, response: requests.Response) -> dict:
assert response.status_code == 200
try:
result = response.json()
except ValueError:
logger.warning(
"validateResponse: the response could not be json decoded. Response: %s"
% response.text)
raise
try:
return result["data"]
except KeyError:
return {}
def get(self, url, auth=False) -> dict:
headers = self.getAuthHeader() if auth else None
# First we try to post de data without validating the token,
# if we get the unauthorized code then we ask for a new token,
# and if we are not able to get the token after 1 try we abandon
for numRetries in range(2):
r = self.session.get(self.iotcloudApiUrl + url,
headers=headers,
timeout=10)
if r.status_code != requests.codes.unauthorized:
break
# Get the auth token
authenticationResult = self.authenticate()
if numRetries == 1 or not authenticationResult:
raise Exception("Could not authenticate")
# Send again the data with the new token
headers = self.getAuthHeader()
return self.validateResponse(r)
def post(self, url, data, auth=False) -> dict:
headers = self.getAuthHeader() if auth else None
# First we try to post de data without validating the token,
# if we get the unauthorized code then we ask for a new token,
# and if we are not able to get the token after 1 try we abandon
for numRetries in range(2):
r = self.session.post(self.iotcloudApiUrl + url,
json=data,
headers=headers,
timeout=30)
if r.status_code != requests.codes.unauthorized:
break
# Get the auth token
authenticationResult = self.authenticate()
if numRetries == 1 or not authenticationResult:
raise Exception("Could not authenticate")
# Send again the data with the new token
headers = self.getAuthHeader()
return self.validateResponse(r)
def getSensor(self, locationId, deviceId, sensorId) -> dict:
sensor = self.get(
f"locations/{locationId}/devices/{deviceId}/sensors/{sensorId}",
auth=True)
return sensor
def getLocation(self, locationId):
location = self.get(f"locations/{locationId}/devices", auth=True)
return location
def getModulesLocations(self):
return self.get("locations/modulesEnabled", auth=True)
def getLocationSunSchedule(self, locationId):
sunSchedule = self.get(f"locations/{locationId}/sunschedule",
auth=True)
return sunSchedule
def notifyLocationOffline(self, locationId, locationName):
data = {
"notificationTitle": "locationOfflineTitle",
"notificationBody": "locationOfflineBody",
"notificationTitleArgs": [locationName],
"notificationBodyArgs": [locationName],
}
self.post(f"locations/{locationId}/locationnotification",
data=data,
auth=True)
import logging
import logging.config
from notifiers import get_notifier
from docker_secrets import getDocketSecrets
logger = logging.getLogger()
TELEGRAM_TOKEN = getDocketSecrets("telegram_token")
TELEGRAM_CHAT_ID = getDocketSecrets("telegram_chat_id")
telegram = get_notifier("telegram")
def sendNotification(message):
logger.info(message, exc_info=True)
telegram.notify(
message=f"[IotCloud]: {message}",
token=TELEGRAM_TOKEN,
chat_id=TELEGRAM_CHAT_ID,
parse_mode="markdown",
)
import logging
import requests
import threading
from docker_secrets import getDocketSecrets
import dbinterface
logger = logging.getLogger(__name__)
googleHomegraphKey = getDocketSecrets("google_homegraph_key")
def resync(db, userId, locationId):
locationUsers = dbinterface.getLocationUsers(db, locationId)
if not locationUsers:
threading.Thread(target=requestResync, args=(userId, )).start()
return
ownerUserId = None
for share in locationUsers:
threading.Thread(target=requestResync,
args=(share["sharedToUserId"], )).start()
ownerUserId = share["ownerUserId"]
threading.Thread(target=requestResync, args=(ownerUserId, )).start()
def requestResync(agentUserId):
logger.info("Requesting resync for the userId: %s" % agentUserId)
url = ("https://homegraph.googleapis.com/v1/devices:requestSync?key=%s" %
googleHomegraphKey)
try:
class Auth0Api:
domain = getDocketSecrets("auth0_domain")
non_interactive_client_id = getDocketSecrets("auth0_non_interactive_client_id")
application_client_id = getDocketSecrets("auth0_application_client_id")
non_interactive_client_secret = getDocketSecrets(
"auth0_non_interactive_client_secret"
)
interactive_client_secret = getDocketSecrets("auth0_interactive_client_secret")
audience = getDocketSecrets("auth0_audience")
connection = "Username-Password-Authentication"
def __init__(self):
self.initAuth0()
if not self.token:
raise ValueError("Could not get the auth token.")
def getToken(self):
token = self.tokenManager.client_credentials(
self.non_interactive_client_id,
self.non_interactive_client_secret,
"https://{}/api/v2/".format(self.domain),
)
mgmt_api_token = token["access_token"]
self.token = mgmt_api_token
def initAuth0(self):
self.tokenManager = GetToken(self.domain)
self.databaseManager = Database(self.domain)
self.getToken()
self.auth0 = Auth0(self.domain, self.token)
@autoAuthenticate
def addUser(self, username, name, password, verifyEmail=False):
userData = {
"connection": "Username-Password-Authentication",
"email": username,
"name": name,
"password": password,
"verify_email": verifyEmail,
}
result = self.auth0.users.create(userData)
try:
userId = result["user_id"]
except (KeyError, TypeError):
logger.error(
f"It was not possible to add the username: {username}.",
exc_info=True,
extra={"area": "users"},
)
return
logger.info(f"User added with id: {userId}",)
return userId
@autoAuthenticate
def deleteUser(self, userId):
logger.info(f"Deleted user with id: {userId}")
return self.auth0.users.delete(userId)
@autoAuthenticate
def updateUser(self, userId, updatedData):
"""
{
"blocked": false,
"email_verified": false,
"email": "*****@*****.**",
"verify_email": false,
"phone_number": "+199999999999999",
"phone_verified": false,
"verify_phone_number": false,
"password": "******",
"user_metadata": {},
"app_metadata": {},
"connection": "Initial-Connection",
"username": "******",
"client_id": "DaM8bokEXBWrTUFCiJjWn50jei6ardyX"
}
"""
result = self.auth0.users.update(userId, updatedData)
try:
assert result["user_id"]
except (KeyError, TypeError, AssertionError):
logger.error(
"It was not possible to update the user with id: %s." % userId,
exc_info=True,
extra={"area": "users"},
)
return
logger.info("Updated user with id: %s" % userId)
return result
@autoAuthenticate
def getUser(self, userId):
userData = self.auth0.users.get(userId)
return userData
def login(self, username, password):
token = self.tokenManager.login(
self.application_client_id,
self.interactive_client_secret,
username,
password,
"",
"",
self.audience,
"password",
)
auth_api_token = token["access_token"]
if username != "*****@*****.**":
logger.info(f"Loging from user: {username}")
return auth_api_token
def recoverPassword(self, username):
result = self.databaseManager.change_password(
self.application_client_id, username, self.connection
)
logger.info(f"User: {username} requests a new password")
return result
def changePassword(self, userId, password):
result = self.auth0.users.update(userId, {"password": password})
logger.info(f"User: {userId} requests to change the password")
return result
M2MLocationActionData,
M2MLocationDevicesStatusStats,
M2MLocationDeviceStatus,
M2MModulesLocations,
)
from mqtt import MqttAuth, MqttAcl, MqttSuperUser
from weather_api import Weather, SunSchedule
from bitcoin.bitcoin_api import BitcoinCurrent, BitcoinHistorical, BitcoinPrice
##############################################
# Configuration
##############################################
cfg = {
"alg": ["RS256"],
"audience": getDocketSecrets("auth0_audience"),
"domain": getDocketSecrets("auth0_full_domain"),
"jwks_uri": getDocketSecrets("auth0_jwks_uri"),
}
claims = {
"email_verified": "verified",
"email": "email",
"clientID": "id",
"updated_at": "updated",
"name": "name",
"picture": "avatar",
"user_id": "user_id",
"nickname": "profile_name",
"identities": "profiles",
"created_at": "created",
import logging
import logging.config
import time
from json.decoder import JSONDecodeError
from docker_secrets import getDocketSecrets
from check_service import checkService
import mqtt_client
import requests
logger = logging.getLogger()
session = requests.Session()
userId = getDocketSecrets("iotcloud_userId")
locationId = getDocketSecrets("iotcloud_locationId")
deviceId = getDocketSecrets("iotcloud_deviceId")
switchSensorId = "healthcheck_switch"
thermostatSensorId = "healthcheck_thermostat"
def updateSensorTimer(apiToken):
headers = {"Authorization": f"Bearer {apiToken}"}
# Turn of the switch for 5 seconds
now = int(time.time())
payload = {
"sensorMetadata": {
"timer": {
"initialTimestamp": now,
import logging
import logging.config
from json.decoder import JSONDecodeError
from docker_secrets import getDocketSecrets
from check_service import checkService
import requests
logger = logging.getLogger()
session = requests.Session()
userId = getDocketSecrets("iotcloud_userId")
@checkService("Weather")
def checkWeatherData(apiToken):
headers = {"Authorization": f"Bearer {apiToken}"}
payload = {
"postalCode": "44002",
"measurement": "temperature",
}
response = session.post(
f"https://api.iotcloud.es/api/v1/users/{userId}/weather",
json=payload,
headers=headers,
)
try:
decodedResponse = response.json()
def onConnect(mqttclient, userdata, flags, rc):
logger.info("Connected to the MQTT broker")
mqttclient.subscribe(updatedLocationTopic)
with locationsLock:
for location in locations.values():
location.subscribe(mqttclient)
logger.info("Starting...")
# IotHub api setup
api = IotCloudApi()
# Setup MQTT client
mqttclient = mqtt.Client(userdata={"api": api})
token = getDocketSecrets("mqtt_token")
mqttclient.username_pw_set(token, "_")
updatedLocationTopic = "v1/+/updatedLocation"
mqttclient.message_callback_add(updatedLocationTopic, onLocationUpdated)
mqttclient.on_connect = onConnect
# Get the locations
modulesLocations = api.getModulesLocations()
for locationData in modulesLocations:
locationId = locationData["_id"]
locations[locationId] = Location(locationId, locationData, mqttclient, api)
# Connect
mqttclient.connect("mosquitto")
mqttclient.loop_start()
import logging
import logging.config
import random
import ssl
import time
from docker_secrets import getDocketSecrets
import paho.mqtt.client as mqtt
from check_service import checkService
logger = logging.getLogger()
locationId = getDocketSecrets("iotcloud_locationId")
deviceId = getDocketSecrets("iotcloud_deviceId")
mqttToken = getDocketSecrets("iotcloud_mqtt_device_token")
analogSensorId = "healthcheck_analog"
switchSensorId = "healthcheck_switch"
url = "mqtt.iotcloud.es"
mqttHeader = f"v1/{locationId}/{deviceId}/"
switchState = False
def on_connect(client, userdata, flags, rc):
logger.info(f"Connected with result code: {rc}")
client.subscribe(mqttHeader + switchSensorId + "/setState")
client.publish(mqttHeader + "status", "online", retain=True)
def on_disconnect(client, userdata, rc):
logger.info(f"Disconnected result code: {rc}")
import logging
import time
import falcon
import jwt
import api_utils
from api_utils import Roles
import dbinterface
from docker_secrets import getDocketSecrets
logger = logging.getLogger(__name__)
secret = getDocketSecrets("mqtt_auth_secret")
class MqttActions:
ADDED = "added"
UPDATED = "updated"
DELETED = "deleted"
class MqttRoles:
user = "******"
device = "Device"
subdevice = "Subdevice"
admin = "Admin"
class ACL:
NO_ACCESS = 0
READ = 1
import logging
import logging.config
from docker_secrets import getDocketSecrets
from check_service import checkService
import requests
logger = logging.getLogger()
session = requests.Session()
iotcloudMail = getDocketSecrets("iotcloud_mail")
iotcloudPassword = getDocketSecrets("iotcloud_password")
iotcloudUserId = getDocketSecrets("iotcloud_userId")
url = "https://api.iotcloud.es/api/v1/login"
@checkService("API")
def login():
payload = {
"email": iotcloudMail,
"password": iotcloudPassword,
}
response = session.post(url, json=payload)
decodedResponse = response.json()
assert decodedResponse["data"]["userId"] == iotcloudUserId
token = decodedResponse["data"]["token"]
return token