Exemple de script TLS d'importation (Cintoo Connect CLI)

Cet article contient un exemple de script Python avec des commentaires permettant de tirer parti des fonctionnalités de Cintoo Connect CLI pour importer des données de numérisation terrestre.

Un exemple de script est fourni en pièce jointe.

Ce script est un exemple de la façon d'automatiser l'importation d'un balayage vers une zone de travail spécifique. Il n'a pas besoin d'une URI, mais certains IDs doivent être spécifiés.
Il appelle la commande import-static dans la fonction "import_file", ouverte à toutes modifications si nécessaire.

Vous trouverez ci-dessous le script avec des commentaires sur chaque partie.

from pathlib import Path
from typing import Final

import json
import logging
import os
import sys
import subprocess
import requests

TIMEOUT: Final[int] = 10

TOKEN: Final[str] = ""
GLOBAL_HEADERS: Final[dict] = {"Authorization": f"Bearer {TOKEN}"}

Importation des bibliothèques. Obtention du jeton et des en-têtes. Pour plus de détails : Guidance API Cintoo Connect CLI.

<WORKZONE_ID>/data
ACCOUNT_ID: Final[str] = ""
PROJECT_ID: Final[str] = ""
WORKZONE_ID: Final[str] = ""

ID de compte pour le compte hébergeant le projet ciblé
ID de projet correspondant au projet cible où se trouve la zone de travail ciblée
ID de zone de travail correspondant à la zone de travail cible

Ils pourraient être récupérés avec des requêtes HTTPS ou à partir de l'URL de l'application Web à l'intérieur d'une zone de travail.

https://aec.cintoo.com/accounts/<ACCOUNT_ID>/projects/<PROJECT_ID>/workzones/

Guidage détaillé : Guidage API Cintoo Connect CLI.

DEFAULT_URL: Final[str] = "https://aec.cintoo.com"

L'URL par défaut peut être soit aec.cintoo.com soit us.cintoo.com ou [company].cintoo.com si l'organisation a un domaine dédié selon la configuration.

def get_cintoo_cli_exe() -> str:
    path = Path(os.environ['LOCALAPPDATA']) / "Programs" / "Cintoo"
    if not path.exists():
        path = Path(os.environ['ProgramFiles']) / "Cintoo"
    if not path.exists():
        raise RuntimeError("Impossible de trouver l'installation de Cintoo Connect.")
                           "\nSi vous ne l'avez pas installée dans le chemin par défaut,"
                           " veuillez définir cette variable de chemin sur le bon chemin")
    cli = path / "cintooconnect-cli.exe"
    if not cli.exists():
        raise RuntimeError("Impossible de trouver cintooconnect-cli.exe."
                           " Veuillez installer la dernière version de Cintoo Connect : "
                           "https://aec.cintoo.com/download/cintooconnect-setup-latest.exe")
    return cli.as_posix()


CINTOO_CLI_EXE: Final[str] = get_cintoo_cli_exe()

Recherche et exécution de l'exécutable Cintoo Connect CLI. L'exécutable est au même endroit où Cintoo Connect est installé. Par défaut, il devrait être dans :

Utilisateurs/"VotreNomUtilisateur"/AppData/Local /Programs/Cintoo
ProgramFiles/Cintoo si installé avec les droits administrateur

def post_and_check_request(url: str,
                           headers: dict) -> dict:
    logging.info(f"Requête : url={url}, en-têtes={headers}")
    try:
        reply = requests.post(url, headers=headers, timeout=TIMEOUT)
        reply.raise_for_status()
        return reply.json()
    except json.JSONDecodeError as exception:
        message = f"Exception lors du décodage du JSON en utilisant le jeton : {exception}"
    except requests.exceptions.RequestException as exception:
        message = f"Exception lors de la validation du jeton : {exception}"
    except Exception as exception:
        message = f"Exception : {exception}"
    logging.error(message)
    raise RuntimeError(message)

Envoi d'informations à un serveur et obtention d'une vérification de la réponse du serveur.

def validate_login():
    url = f"{DEFAULT_URL}/api/isLogged"
    response = post_and_check_request(url, GLOBAL_HEADERS)
    if not response.get("success"):
        raise ValueError("Connexion requise : impossible de vérifier votre statut de connexion.\n"
                         f"Détails : {response}.\n"
                         "Veuillez vous connecter en suivant les instructions ici :\n"
                         "https://aec.cintoo.com/api/#section/API-Specification/Authentication")

Validation de connexion.

def get_cintoo_uri(account_id: str,
                   project_id: str,
                   workzone_id: str):
    url = 
'{DEFAULT_URL}/api/accounts/{account_id}/projects/{project_id}/workzones/{workzone_id}/imports'
    response = post_and_check_request(url, GLOBAL_HEADERS)
    cintoo_uri = response.get("url")
    if not cintoo_uri:
        raise KeyError(f"Impossible de trouver l'url dans la réponse : {response}")
    return cintoo_uri

Obtention de l'URI Cintoo à partir des composants de compte, projet et zone de travail définis précédemment.

def import_file(cintoo_uri: str,
                file_path: str):
    return subprocess.call([CINTOO_CLI_EXE, "import-static",
                            f"--cintoo-uri={cintoo_uri}",
                            f"--file-ref={file_path}"])

Exécution du processus d'importation avec l'exécutable Cintoo Connect CLI.

def import_files_in_dir(cintoo_uri: str,
                        root_dir_path: str):
    for (dirpath, _, filenames) in os.walk(root_dir_path):
        for filename in filenames:
            file_path = os.path.join(dirpath, filename)
            import_file(cintoo_uri, file_path)

Importation de tous les fichiers dans le répertoire défini.

def main(path: str):
    assert TOKEN, "Le jeton doit être spécifié"
    assert ACCOUNT_ID and PROJECT_ID and WORKZONE_ID, "Les ID doivent être spécifiés"
    validate_login()
    cintoo_uri = get_cintoo_uri(ACCOUNT_ID, PROJECT_ID, WORKZONE_ID)
    if os.path.isfile(path):
        import_file(cintoo_uri, path)
    elif os.path.isdir(path):
        import_files_in_dir(cintoo_uri, path)

if __name__ == "__main__":
    arguments = sys.argv
    if len(arguments) != 2:
        raise RuntimeError("Vous devez passer le chemin vers le répertoire ou le fichier à importer")
    main(arguments[1])

Exécution de la fonction principale.