Heatzy - reconnu par Domoticz ?

[lost]

Je ne crois pas car cela fonctionne via l'appli Android.

Forcément ils peuvent ici maintenir les 2 côtés en phase! Enfin tant que la boite existe et paie l'hébergeur de ses serveurs.
Un pb qu'on n'a pas avec des dispositifs dont les api sont locales... et généralement stables.

[manuloup]

Je ne sais pas trop identifier le problème. Je peux éventuellement essayer de contacter le support si le pb vient de l'API.

[Redfirebrooks]

bonjour,
j'essaye de comprendre d'ou vient le problème en reprenant le script de Lordgun. Petite précision, je n'y connais vraiment pas grand chose donc fort probable que je fasse fausse route.

Tout d'abord le "heatzy-get-token.lua" ne pose pas de problème, il renouvelle toujours la variable utilisateur "heatzytoken". Donc j'ai un token à jour.

L'API semble donc fonctionner, pour m'en assurer, j'ai repris du script heatzy-get-status.lua la requête POST d'origine pour la tester dans un shell.

Dans le script d'origine on a :

Code : Tout sélectionner

--ligne de commande qui interoge les serveur heatzy pour le retour d'etat
 local config=assert(io.popen('curl -X GET --header \'Accept: application/json\' --header \'X-Gizwits-Application-Id: c70a66ff039d41b4a220e198b0fcc8b3\' \'https://euapi.gizwits.com/app/devdata/'..did..'/latest\''))
 

qui devient dans le shell

Code : Tout sélectionner

curl -X GET --header 'Accept: application/json' --header 'X-Gizwits-Application-Id: c70a66ff039d41b4a220e198b0fcc8b3' 'https://euapi.gizwits.com/app/devdata/MONDID/latest'

mais pour le coup on a une erreur:

Code : Tout sélectionner

{"error_code":9004,"detail_message":null,"error_message":"token invalid!"}%

Je rajoute dans la requête curl le token que le script heatzy-get-token.lua m'a donné:

Code : Tout sélectionner

--header 'X-Gizwits-User-token: MON TOKEN'

Et là tout l'état remonte dont notamment le "mode":"cft"

C'est tout de même étrange que la requête curl du script ne comporte pas le token non ? Donc, j'essaye de la rajouter dans la requête. Tout d'abord, je déclare une nouvelle variable montoken:

Code : Tout sélectionner

--variable a configurer
did = 'MON DID' 			--did que l'on a trouvé, on garde les ''
selectorheatzy = 'Heatzy - Salon'	--nom de votre inter selecteur qui pilote le heatzy on garde les ''
montoken = 'la valeur de mon token'

puis je rajoute un header token dans la requête curl ce qui donne :

Code : Tout sélectionner

--ligne de commande qui interoge les serveur heatzy pour le retour d'etat
 local config=assert(io.popen('curl -X GET --header \'Accept: application/json\' --header \'X-Gizwits-Application-Id: c70a66ff039d41b4a220e198b0fcc8b3\' --header \'X-Gizwits-User-token: '..montoken..'\' \'https://euapi.gizwits.com/app/devdata/'..did..'/latest\''))

Et là ça marche !!! Le statut remonte et le sélecteur est bien mis à jour.

Par contre et c'est là où je coince, comment déclarer montoken pour qu'il prenne la valeur de heatzytoken ?
J'ai bien essayé montoken = heatzytoken mais c'est une valeur nulle qui est attribuée à mon token.

EDIT

J'ai un peu cherché, je ne connais pas du tout lua, et endéclarant de cette manière cela fonctionne
montoken = uservariables['heatzytoken']
J'ai mis des print un peu partout pour que ca ressorte bien dans les logs et j'ai toute la remonté de la requête curl qui s'affiche.

[manuloup]

bonjour,

Je cherche une solution car je n'ai jamais réussi à piloter mon radiateur en dehors de l'appli android heatzy et c'est bien dommage. Il existe une solution alternative avec shelly mais c'est pas top.

[Guigui]

C'est noel alors je file mon code en bash pour heatzy.

Code : Tout sélectionner

HEATZY_LOGIN=
HEATZY_PASSWORD=
                
HEATZY_APPID=
ID_TOKEN=
    
    # Fonction pour la récupération du token d'authentification
fonction_get_auth_token() {

    while [ "$attempt_token" -le "$max_attempts_token" ]; do
        ID_TOKEN=$(curl --silent -X "POST" --header "Content-Type:application/json" \
            --header "Accept:application/json" \
            --header "X-Gizwits-Application-Id: ${HEATZY_APPID}" \
            -d '{"username":"'${HEATZY_LOGIN}'","password":"'${HEATZY_PASSWORD}'","lang":"fr"}' \
            "https://euapi.gizwits.com/app/login" | jq -r .token )

        # Vérifier si le token est récupéré avec succès et n'est pas "null"
        if [ -n "$ID_TOKEN" ] && [ "$ID_TOKEN" != "null" ]; then
            return 0
        fi

        # Si token est "null", loguer une erreur et sortir
        if [ "$ID_TOKEN" == "null" ]; then
            logger -p user.warn "Erreur: Échec de l'authentification. Le token est 'null'." --tag $NOM_SCRIPT
            exit 1
        fi

        # Sinon, attendre et réessayer
        logger -p user.warn "Aucun token valide reçu, attente de $sleep_time_token secondes avant la prochaine tentative..." --tag $NOM_SCRIPT
        sleep "$sleep_time_token"

        # Doubler la durée de sleep et incrémenter le compteur de tentatives
        sleep_time_token=$((sleep_time_token * 2))
        attempt_token=$((attempt_token + 1))
    done

    # Vérification finale après les tentatives
    if [ -z "$ID_TOKEN" ] || [ "$ID_TOKEN" == "null" ]; then
        echo "Erreur: Échec de l'authentification après $max_attempts_token tentatives."
        logger -p user.warn "Erreur: Échec de l'authentification après $max_attempts_token tentatives." --tag $NOM_SCRIPT
        exit 1
    fi
}

# Fonction pour la récupération des données
fonction_get_data() {
    # Variables de la boucle pour la récupération des données

    while [ "$attempt_data" -le "$max_attempts_data" ]; do

        # Récupérer les données
        DATA_CLOUD_HEATZY=$(curl --silent --location --request "GET" "https://euapi.gizwits.com/app/bindings?limit=20&skip=0" \
            --header "X-Gizwits-Application-Id: ${HEATZY_APPID}" \
            --header "X-Gizwits-User-token: ${ID_TOKEN}")

        # Vérifier si les données sont présentes
        if [ -n "$DATA_CLOUD_HEATZY" ]; then
            # Vérifier s'il y a un champ "error_message" dans la réponse
            if echo "$DATA_CLOUD_HEATZY" | jq -e '.error_message' >/dev/null 2>&1; then
                # Extraire le message d'erreur et l'afficher
                local error_message=$(echo "$DATA_CLOUD_HEATZY" | jq -r '.error_message')
                echo "Erreur dans la réponse de l'API : $error_message"
                return 1
            else
                return 0
            fi
        else

            # Si données vides, attendre et réessayer
            logger -p user.warn "Aucune donnée reçue, attente de $sleep_time_data secondes avant la prochaine tentative..." --tag $NOM_SCRIPT
            sleep "$sleep_time_data"

            # Doubler la durée de sleep et incrémenter le compteur de tentatives
            sleep_time_data=$((sleep_time_data * 2))
            attempt_data=$((attempt_data + 1))
        fi
    done

    # Vérification finale pour les données après les tentatives
    if [ -z "$DATA_CLOUD_HEATZY" ]; then
        echo "Erreur: échec de la récupération des données après $max_attempts_data tentatives."
        logger -p user.warn "Erreur: Échec de la récupération des données HEATZY après $max_attempts_data tentatives." --tag $NOM_SCRIPT
        exit 1
    fi
}

# Fonction pour vérifier si le convecteur est en ligne
fonction_is_device_online() {
    local device_data="$1"
    local device_id="$2"

    # Récupérer la disponibilité du convecteur en ligne ou hors ligne
    local online_status=$(echo -e "$device_data" | jq '.devices[] | {dev_alias},{is_online},{did}' | \
                          egrep 'dev_alias|is_online|did' | cut -d\: -f2 | cut -d\  -f2 | tr -d \" | \
                          grep -B 2 "$device_id" | tail -n 2 | head -1)

    # Vérifier si l'appareil est en ligne
    if [ "$online_status" == "true" ]; then
        return 0  # Succès
    else
        logger -p user.warn "Erreur: Le convecteur $DATA_NOM $device_id est hors ligne." --tag $NOM_SCRIPT
        return 1  # Échec
    fi
}

# Fonction pour définir le mode du convecteur (si nécessaire seulement grace a un controle de l'état)
fonction_set_device_mode() {
    local device_id="$1"
    local target_mode="$2"

    # Récupérer l'état actuel du convecteur
    local current_mode=$(curl --silent --location --request "GET" \
                         "https://euapi.gizwits.com/app/devdata/$device_id/latest" \
                         --header "X-Gizwits-Application-Id: ${HEATZY_APPID}" \
                         --header "X-Gizwits-User-token: ${ID_TOKEN}" | jq -r .attr.mode)

    # Traduire l'état actuel en un format numérique pour la comparaison
    case $current_mode in
        "cft") current_mode="0" ;;
        "eco") current_mode="1" ;;
        "fro") current_mode="2" ;;
        "off") current_mode="3" ;;
        "stop") current_mode="3" ;;
        *)
            logger -p user.warn "Erreur: État inconnu du convecteur $device_id: $current_mode" --tag $NOM_SCRIPT
            return 1  # État non valide
            ;;
    esac

    # Comparer l'état actuel avec le mode cible
    if [ "$current_mode" != "$target_mode" ]; then
        # Si les modes sont différents, envoyer la commande pour changer le mode
        local response=$(curl --silent --location --request "POST" \
            "https://euapi.gizwits.com/app/control/$device_id" \
            --header "X-Gizwits-Application-Id: ${HEATZY_APPID}" \
            --header "X-Gizwits-User-token: ${ID_TOKEN}" \
            --header "Content-Type: text/plain" \
            --data-raw "{\"attrs\":{\"mode\":$target_mode}}")

        # Vérifier si la réponse contient une erreur
        if [ -z "$response" ] || echo "$response" | jq -e '.error_code' &>/dev/null; then
            local error_message=$(echo "$response" | jq -r .error_message)
            local error_code=$(echo "$response" | jq -r .error_code)
            logger -p user.warn "Erreur lors de la mise à jour du mode du convecteur $device_id : $error_message (Code erreur: $error_code)" --tag $NOM_SCRIPT
            return 1  # Indiquer une erreur
        fi
    fi
}

Bien sûr il faudra instancier les variables.





Bonne exploitation.