Intégration Asana MakeAutomatiser Asana avec Make.

Tu obtiens un lot de tâches, filtré par espace de travail, projet, tag ou responsable, un bundle par tâche.

Un déclencheur ou une recherche ne te donne souvent que l'identifiant d'une tâche. Ce module lit la tâche entière à partir de cet identifiant, pour que la suite travaille avec du vrai contenu plutôt qu'avec un numéro.

Un e-mail client, une réponse de formulaire ou un devis signé devient du travail concret dans Asana, en tâche ou en sous-tâche.

Garde une tâche alignée sur ce qui se passe hors d'Asana, sans retouche manuelle.

Supprime une tâche pour de bon, pratique pour nettoyer les doublons qu'une automatisation a créés par erreur. Ton tableau reste propre sans chasse manuelle.

Copie une tâche modèle pour que le travail récurrent parte d'une version déjà prête. La personne qui la reprend trouve toujours la même formulation, et personne ne reconstruit la liste de mémoire.

Renvoie toutes les sous-tâches d'une tâche parente, un bundle chacune, pour vérifier l'avancement morceau par morceau sans ouvrir Asana.

Rattache une tâche à une autre, ce qui en fait une sous-tâche ou regroupe du travail éparpillé. Tout ce qui concerne un client se retrouve sous un seul toit.

Choisis qui reçoit les notifications d'une tâche, en ajoutant ou retirant des abonnés sans clic. Les bonnes personnes sont prévenues, les autres ne sont plus dérangées.

Une même tâche Asana peut vivre dans plusieurs projets : ce module te dit lesquels, un bundle par projet. La suite du scénario sait alors où l'envoyer.

Place une tâche existante dans un projet, et même dans une section précise, sans en créer de copie. C'est la même tâche, visible à un endroit de plus, et les mises à jour restent au même endroit.

Sort une tâche d'un projet, tout en la laissant vivre ailleurs. Le tableau d'accueil ne garde que ce qui reste à trier.

Montre les tâches qui doivent être finies avant que celle-ci puisse démarrer, un bundle par tâche bloquante. Tu sais ce qui retient le travail sans ouvrir Asana.

Inscrit dans Asana ce qu'une tâche attend, au lieu de laisser l'ordre des étapes dans la tête de quelqu'un. Chacun voit ce qui doit passer avant.

La vue inverse : toutes les tâches qui attendent celle-ci, un bundle chacune. Quand une étape glisse, tu sais tout de suite qui d'autre est touché.

Côté tâche bloquante, tu déclares celles qui ne peuvent pas avancer tant qu'elle n'est pas finie. Pratique quand la tâche qui retient tout est justement celle que ton scénario a en main.

Renvoie tes projets, un bundle chacun : la base de tout contrôle transversal. Tu passes chaque projet en revue sans en oublier un.

Lit le détail d'un projet à partir de son identifiant, pour que les modules suivants réutilisent ce qu'il renvoie. Tes messages nomment le projet au lieu d'afficher un code.

Ouvre un projet vierge à partir d'un événement extérieur, sans que personne passe par Asana. Le dossier existe dès que l'affaire est signée.

Modifie un projet quand quelque chose bouge dans un autre outil, pour qu'Asana reste aligné sur l'outil que ton équipe prend comme référence.

Efface un projet entier, tâches comprises. Pratique pour faire le ménage quand tes essais d'automatisation ont laissé des traces.

Clone un projet modèle pour que chaque nouvelle mission démarre avec les mêmes sections et tâches. Aucune étape oubliée, et chaque client a droit à la même mise en place.

Donne le nombre de tâches d'un projet, un indicateur rapide sans tout lister. Un module, un passage, un chiffre à glisser dans un rapport.

Renvoie les colonnes ou rubriques d'un projet, un bundle chacune. C'est ainsi que ton scénario apprend les identifiants dont il a besoin avant de ranger quoi que ce soit.

Lit une section précise dont tu connais déjà l'identifiant. Une vérification rapide qui évite de ranger des tâches dans une colonne renommée ou supprimée.

Ajoute une section à un projet, qui apparaît comme une colonne en vue tableau. Ta structure suit ton process sans que personne la monte à la main.

Renomme une section pour suivre l'évolution de ton process. Les tâches restent en place, seul l'intitulé que lit l'équipe change.

Réordonne les sections de la vue tableau, en plaçant l'une avant ou après une autre. La colonne utile du moment passe en premier, là où l'œil tombe.

Retire une section devenue inutile, pour que les anciennes phases n'encombrent plus le projet. Utile en fin de cycle, quand le tableau garde des colonnes que plus personne n'ouvre.

Récupère l'historique des points d'avancement publiés sur un projet, un bundle par statut. Tu vois comment le projet a évolué sans défiler dans Asana.

Lit un point d'avancement en entier à partir de son identifiant. Le texte écrit par le chef de projet peut alors sortir d'Asana tel quel.

Publie un point d'avancement construit avec des données venues d'ailleurs, pour que la page projet reste à jour. L'équipe lit l'avancement là où elle travaille, sans compilation à la main.

Supprime un point d'avancement d'un projet, pour que l'historique ne garde que des statuts justes.

Affiche chaque espace de travail accessible par ta connexion, un bundle chacun. C'est le point de départ quand un scénario doit couvrir plusieurs espaces.

Lit les informations d'un espace de travail à partir de son identifiant. Tes rapports et tes alertes affichent un nom que tout le monde reconnaît.

Renvoie les équipes d'une organisation, un bundle par équipe, pratique pour savoir qui porte quoi. Tu obtiens une liste à jour, pas un annuaire oublié.

Liste les personnes d'une organisation, un bundle par utilisateur. De quoi comparer qui a accès à Asana avec qui travaille vraiment chez toi.

Ajuste qui appartient à un espace de travail, en pilotant arrivées et départs depuis ta source de référence. Les accès suivent le dossier RH, pas la mémoire de quelqu'un.

Monte une nouvelle équipe dans l'organisation sans passer par l'administration. L'équipe existe dès que la décision est enregistrée dans un autre outil.

Lit la fiche d'une équipe à partir de son identifiant pour réutiliser son nom plus loin dans le scénario. Tes notifications se lisent comme si un collègue les avait écrites.

Tu récupères tous les membres d'une équipe Asana, un bundle par personne (un bundle, c'est un élément transmis au module suivant). De quoi alimenter un envoi ou un tableau sans recopier de noms.

Ta nouvelle recrue arrive directement dans la bonne équipe Asana, sans passage par l'administration, et voit tout de suite les projets de cette équipe.

Une personne qui change de poste ou quitte la boîte ne voit plus le travail de l'équipe, sans qu'il faille penser à retirer l'accès à la main.

De quoi obtenir les personnes connues de ton compte Asana, chacune dans son propre bundle, pour faire correspondre un email venu d'ailleurs à un utilisateur Asana.

Avec l'identifiant d'un utilisateur en main, tu obtiens le reste de son profil, le nom par exemple, pour qu'une notification parle d'une personne et pas d'un numéro.

À partir d'une seule personne, tu vois toutes les équipes Asana dont elle fait partie, un bundle par équipe : tu sais où vit son travail.

Tout l'historique d'une tâche remonte : les commentaires et les changements qu'Asana y consigne, chaque « story » dans son propre bundle.

Tu lis en entier un commentaire ou une entrée d'activité précise, pratique quand un déclencheur ne t'a donné que son identifiant.

Un commentaire apparaît sur la tâche comme si un collègue l'avait écrit : les nouvelles des autres outils arrivent là où l'équipe regarde déjà.

Un commentaire déjà posté se corrige sur place au lieu d'en empiler un second en dessous, et le fil reste lisible.

Le commentaire disparaît de la tâche : utile pour effacer les notes qu'une automatisation a laissées quand elles ne sont plus vraies.

Chaque fichier joint à une tâche remonte dans son propre bundle, pour les copier ou les archiver un par un.

À partir de l'identifiant d'une pièce jointe, tu obtiens ses détails pour faire voyager le fichier vers une autre app.

Un fichier produit ailleurs, un PDF ou un devis signé, se retrouve joint à la bonne tâche, là où l'équipe ira le chercher.

Le fichier disparaît de sa tâche, bien pratique quand une version périmée sème la confusion.

Tous les tags de ton compte Asana remontent, un bundle chacun : c'est le point de départ pour vérifier qu'une étiquette existe avant de t'en servir.

Les détails d'un tag à partir de son identifiant, pour qu'un module suivant affiche son nom et non une suite de chiffres.

Une nouvelle étiquette est prête dans Asana, et les tâches d'un nouveau client ou d'une campagne se regroupent dès le premier jour.

Les propriétés d'un tag changent à un seul endroit et toutes les tâches qui le portent suivent, sans rien réétiqueter.

Pour une tâche donnée, tu vois les étiquettes qu'elle porte, un bundle par tag, et un routeur peut l'envoyer sur la bonne branche.

Les étiquettes d'une tâche changent pour refléter ce qui vient de se passer ailleurs, et les vues filtrées d'Asana restent justes.

La doc de Make cite ce module sans le décrire : vois-le comme une porte vers les champs personnalisés d'Asana et lis ses réglages dans l'éditeur avant de t'y fier.

Tu obtiens l'inventaire des champs personnalisés d'un espace de travail, un bundle par champ, utile pour faire le point avant d'en ajouter.

La définition d'un champ, options comprises, pour que le module suivant sache quelles valeurs sont permises.

Un nouveau champ rejoint ton espace de travail, prêt à être ajouté aux projets et rempli sur les tâches.

La définition d'un champ change à un seul endroit, et son nouveau nom ou réglage s'affiche partout où il sert.

Un champ devenu inutile quitte l'espace de travail et désencombre tous les projets qui l'affichaient.

Une liste déroulante gagne un nouveau choix, et la valeur venue d'un autre outil trouve où se poser dans Asana.

Un choix de liste déroulante se renomme ou s'ajuste, et toutes les tâches qui l'utilisent déjà suivent.

Ici, tu sais quels champs personnalisés un projet utilise vraiment, un bundle par champ, avant que ton scénario tente d'y écrire.

La liste des champs personnalisés rattachés à un projet change, et un projet tout neuf reçoit les mêmes champs que ses voisins.

Tes objectifs Asana remontent sous forme de bundles, faciles à pousser dans un rapport ou un tableau de bord hors d'Asana.

Le détail d'un objectif à partir de son identifiant, pour qu'un message cite son nom et son état du moment.

Un nouveau portefeuille regroupe les projets liés à un client ou un programme, et la direction les voit côte à côte.

Les personnes choisies deviennent membres d'un portefeuille et suivent ses projets depuis là.

Les réglages d'un portefeuille s'alignent sur la réalité, son nom par exemple quand un programme est relancé.

Le détail d'un portefeuille récupéré par son identifiant, pour réutiliser son nom ou ses membres plus loin dans le scénario.

Chaque portefeuille accessible remonte dans son bundle : c'est ainsi que tu retrouves le bon par son nom.

Le portefeuille lui-même disparaît et la vue se range quand une relation client est terminée.

Les personnes indiquées ne sont plus membres du portefeuille, qui ne liste plus que celles encore impliquées.

Tu obtiens l'inventaire des webhooks enregistrés sur ton compte Asana, chacun sous forme de bundle (un élément transmis au module suivant). Un webhook, c'est le canal par lequel Asana prévient Make dès qu'un changement a lieu.

Il comble les trous du catalogue : quand aucun des 91 modules prêts à l'emploi ne fait ce que tu cherches, tu appelles directement n'importe quel point de l'API d'Asana, avec la connexion déjà en place (ton compte Asana relié à Make une fois pour toutes).

Résultat : le détail d'un seul champ personnalisé d'un projet donné, prêt à être lu par les modules suivants.