Paramètres API

L'onglet API fournit les identifiants et la surveillance pour l'accès programmatique à votre projet GitScrum. Créez des intégrations personnalisées, automatisez les workflows et connectez des systèmes externes via l'API REST.

Aperçu de l'API

GitScrum fournit une API REST complète pour :

• Lire les données du projet (tâches, sprints, membres)
• Créer et mettre à jour des ressources
• Déclencher des actions par programmation
• Synchroniser avec des systèmes externes
• Créer des tableaux de bord personnalisés

Section Limites de taux

Comprendre les limites de taux

Les limites de taux préviennent les abus de l'API et garantissent un accès équitable pour tous les utilisateurs. Les limites s'appliquent par projet, par période.

Affichage des limites de taux

L'onglet API affiche trois métriques clés :

Niveaux de limites de taux

Réponse de limite de taux

Quand vous atteignez la limite :

• L'API retourne 429 Too Many Requests
• L'en-tête Retry-After indique le temps d'attente
• Le compteur disponible affiche 0

Timing de réinitialisation

Les limites de taux se réinitialisent sur une fenêtre glissante :

• La période affiche les heures de début et de fin
• Le compteur se reconstitue progressivement
• Réinitialisation complète à la fin de la période

Statistiques d'utilisation

Graphique des requêtes

Une visualisation montre l'utilisation de l'API dans le temps :

• Axe X : Temps (heures/jours)
• Axe Y : Nombre de requêtes
• Aide à identifier les patterns d'utilisation

Analyse d'utilisation

Ligne constante : Processus automatisés normaux Pics : Opérations manuelles ou travaux par lots Proche de la limite : Peut nécessiter d'optimiser ou upgrader

Tableau des requêtes récentes

Journal des requêtes

Le tableau montre les appels API récents :

Indicateurs de méthode

Les méthodes s'affichent avec un code couleur :

• GET : Bleu (opérations de lecture)
• POST : Vert (opérations de création)
• PUT/PATCH : Jaune (opérations de mise à jour)
• DELETE : Rouge (opérations de suppression)

Objectif du journal

Utilisez le journal des requêtes pour :

• Débugger les problèmes d'intégration
• Identifier l'utilisation inattendue de l'API
• Surveiller le comportement des automatisations
• Auditer l'accès API

Identifiants API

Obtenir les identifiants

Cliquez sur "Obtenir les identifiants" pour accéder à votre clé et secret API :

1. Le bouton déclenche la vérification d'authentification
2. Une fenêtre modale affiche les identifiants
3. Copiez pour utiliser dans vos applications

Composants des identifiants

Clé API : Identifiant public pour votre intégration

• Peut être inclus dans le code (pas vraiment secret)
• Utilisé dans les requêtes API pour l'identification

Secret API : Token d'authentification privé

• Ne jamais partager ou commiter dans des dépôts publics
• Utilisé pour signer les requêtes

Sécurité des identifiants

IMPORTANT :

• Stocker les secrets dans des variables d'environnement
• Ne jamais commiter dans le contrôle de version
• Régénérer si potentiellement exposé
• Utiliser des identifiants différents pour dev/prod

Régénérer les identifiants

Si les identifiants sont compromis :

1. Générer de nouveaux identifiants
2. Mettre à jour toutes les intégrations
3. Les anciens identifiants sont invalidés immédiatement

Attention : La régénération casse toutes les intégrations existantes jusqu'à mise à jour.

Effectuer des requêtes API

Authentification

Incluez les identifiants dans les en-têtes de requête :

Authorization: Bearer VOTRE_CLE_API
X-API-Secret: VOTRE_SECRET_API

Ou utilisez l'authentification HTTP Basic :

Authorization: Basic base64(CLE_API:SECRET_API)

URL de base

Toutes les requêtes API utilisent :

https://services.gitscrum.com/v1

Format de requête

En-têtes :

Content-Type: application/json
Accept: application/json
Authorization: Bearer VOTRE_CLE_API

Exemple de requête GET :

curl -X GET "https://services.gitscrum.com/v1/projects/SLUG_PROJET/tasks" \
  -H "Authorization: Bearer VOTRE_CLE_API" \
  -H "X-API-Secret: VOTRE_SECRET_API"

Exemple de requête POST :

curl -X POST "https://services.gitscrum.com/v1/projects/SLUG_PROJET/tasks" \
  -H "Authorization: Bearer VOTRE_CLE_API" \
  -H "X-API-Secret: VOTRE_SECRET_API" \
  -H "Content-Type: application/json" \
  -d '{"title": "Nouvelle tâche", "description": "Créée via API"}'

Endpoints courants

Tâches

Sprints

Entrées de temps

Membres

Format de réponse

Réponse réussie

{
    "data": {
        // Données de la ressource
    },
    "meta": {
        "current_page": 1,
        "total_pages": 5,
        "total_count": 47
    }
}

Réponse d'erreur

{
    "error": {
        "code": "validation_error",
        "message": "Le titre est requis",
        "details": {
            "title": ["Ce champ est requis"]
        }
    }
}

Codes de statut HTTP

Pagination

Les endpoints de liste retournent des résultats paginés :

Paramètres de requête

Exemple

GET /tasks?page=2&per_page=50

Filtrage

De nombreux endpoints supportent le filtrage :

Filtres de tâches

Filtres d'entrées de temps

Dépannage

401 Unauthorized

Causes :

• Clé API invalide
• Secret invalide ou manquant
• Identifiants régénérés

Solutions :

• Vérifier que les identifiants sont actuels
• Vérifier le format des en-têtes
• Recopier les identifiants depuis les paramètres

403 Forbidden

Causes :

• Le rôle n'a pas les permissions pour l'action
• La ressource appartient à un autre projet
• Action non autorisée pour l'état de la ressource

429 Rate Limited

Causes :

• Trop de requêtes dans la période
• Polling agressif
• Intégration inefficace

Solutions :

• Attendre la période de réinitialisation
• Implémenter un backoff exponentiel
• Mettre en cache les réponses si possible

Permissions

Les permissions API correspondent aux rôles utilisateur — l'API ne peut pas dépasser les permissions projet de l'utilisateur.

L'API étend les capacités de GitScrum à tout système ou workflow que vous pouvez imaginer. Commencez par lire les données, progressez vers la création de ressources, et construisez des intégrations personnalisées parfaitement adaptées aux besoins de votre équipe.

Paramètres du budget

L'onglet Budget transforme les données de suivi du temps en insights financiers. Suivez l'allocation des ressources, définissez des taux horaires personnalisés, configurez des alertes de coût et gérez les paramètres de budget du projet en un seul endroit.

Sous-onglets du budget

Les paramètres de budget s'organisent en quatre sections spécialisées :

Naviguez entre les sous-onglets en utilisant la barre latérale dans les paramètres de Budget.

Section Allocation

La vue Allocation montre comment les membres de l'équipe passent leur temps sur ce projet.

Tableau d'allocation

Chaque ligne représente un membre de l'équipe avec :

Lire les données d'allocation

Pourcentage facturable élevé : Membre de l'équipe concentré sur le travail livrable au client. L'objectif varie selon le rôle — les développeurs sont généralement plus élevés que les managers.

Pourcentage facturable bas : Plus de temps sur les tâches internes, réunions ou overhead. Pas intrinsèquement mauvais, mais à surveiller.

Distribution inégale : Un membre avec significativement plus d'heures peut indiquer un déséquilibre de charge de travail ou un goulot d'étranglement.

Métriques clés

La barre de filtre affiche des métriques agrégées :

• Total des membres de l'équipe : Nombre de personnes avec du temps enregistré
• Total des heures facturables : Somme pour tous les membres

Section Taux

Définissez des taux horaires personnalisés pour les membres individuels de l'équipe. Les taux personnalisés remplacent le taux par défaut du projet.

Taux par défaut

Le taux horaire par défaut du projet s'applique à tout membre sans taux personnalisé. Définissez-le dans le sous-onglet Paramètres.

Tableau des taux personnalisés

Ajouter un taux personnalisé

1. Cliquez sur le bouton "Ajouter un taux"
2. Sélectionnez un membre de l'équipe dans le menu déroulant
3. Entrez le taux horaire
4. Cliquez sur Enregistrer

Cas d'utilisation pour les taux personnalisés :

• Ingénieurs seniors avec des taux de facturation plus élevés
• Membres juniors de l'équipe à des taux réduits
• Contractuels avec des taux négociés
• Consultants facturés à des taux premium

Modifier les taux

Cliquez sur l'icône de modification sur n'importe quelle ligne de taux pour modifier le montant. Les modifications s'appliquent aux calculs futurs — les coûts historiques ne sont pas recalculés rétroactivement.

Supprimer les taux personnalisés

Supprimez un taux personnalisé pour que ce membre revienne au taux par défaut. Encore une fois, cela n'affecte que les calculs futurs.

Affichage des taux

Les taux s'affichent dans la devise configurée de votre espace de travail. Le format suit les paramètres de locale (ex : 125,00 €, $125.00).

Section Alertes

Les alertes de budget vous notifient quand les coûts approchent ou dépassent les seuils. La notification proactive prévient les surprises budgétaires.

Types d'alertes

Alertes configurées

La liste des alertes montre tous les seuils de budget :

• Nom/description de l'alerte
• Montant ou pourcentage du seuil
• Statut actuel (OK, Avertissement, Critique)
• Horodatage du dernier déclenchement
• Statut d'acquittement

Comportement des alertes

Quand un seuil est atteint :

1. Le statut de l'alerte passe à Avertissement ou Critique
2. Une notification est envoyée (email, in-app)
3. L'alerte apparaît dans le tableau de bord
4. Reste jusqu'à acquittement ou résolution de la condition

Acquitter les alertes

Cliquez pour acquitter une alerte. Cela :

• Marque l'alerte comme vue
• Arrête les notifications répétées (jusqu'au prochain déclenchement)
• Enregistre qui a acquitté et quand

L'acquittement ne résout pas le problème de budget sous-jacent — il confirme simplement la prise de conscience.

Configuration des alertes

Créez des alertes dans le sous-onglet Paramètres. Seuils d'alerte courants :

• 75% du budget consommé (avertissement)
• 90% du budget consommé (critique)
• 100% du budget dépassé (critique)

Sous-onglet Paramètres

Configuration de base du budget pour le projet.

Budget du projet

Budget total : Le budget global du projet dans votre devise. C'est le nombre avec lequel les alertes sont comparées.

Définir un budget active :

• Le suivi de progression du budget
• Les alertes basées sur le pourcentage
• Les rapports coût vs budget

Laissez vide si le projet n'a pas de budget fixe.

Taux horaire par défaut

Le taux appliqué aux membres de l'équipe sans taux personnalisé. Recommandations :

Modèle agence : Utilisez votre taux de facturation client standard Projets internes : Utilisez le coût chargé (salaire ÷ heures de travail + overhead) Projets à prix fixe : Peut être moins pertinent — suivez pour l'analyse des coûts internes

Configuration des alertes

Créez et gérez les alertes de budget :

Ajouter une alerte :

1. Cliquez sur "Ajouter une alerte"
2. Définissez le seuil (montant ou pourcentage)
3. Choisissez le type d'alerte (avertissement/critique)
4. Configurez les destinataires des notifications
5. Enregistrez

Modifier une alerte : Cliquez sur n'importe quelle alerte pour modifier le seuil, le type ou les destinataires.

Supprimer une alerte : Supprimez les alertes qui ne sont plus nécessaires.

Facturable par défaut

Basculez si les nouvelles entrées de temps sont par défaut facturables. Les membres de l'équipe peuvent modifier par entrée, mais cela définit l'état initial.

Facturable par défaut ACTIVÉ : La plupart du temps est facturable au client Facturable par défaut DÉSACTIVÉ : La plupart du temps est interne/overhead

Enregistrer les paramètres

Cliquez sur "Enregistrer" pour persister les modifications. Les modifications des taux et budgets affectent immédiatement les calculs futurs.

Calculs des coûts

Comprendre comment les coûts sont calculés aide à interpréter correctement les données.

Formule de base

Coût = Heures × Taux

Heures : Des entrées de suivi du temps Taux : Taux personnalisé si défini, sinon taux par défaut

Facturable vs Non-facturable

Seules les heures facturables sont prises en compte dans les rapports de facturation. Toutes les heures (facturables + non-facturables) sont prises en compte dans les calculs de coût.

Priorité des taux

1. Taux personnalisé de l'utilisateur (si défini)
2. Taux par défaut du projet (si défini)
3. Zéro (si aucun taux configuré)

Devise

Toutes les valeurs monétaires utilisent la devise configurée de l'espace de travail. La devise ne peut pas différer par projet — c'est au niveau de l'espace de travail.

Données historiques

Les modifications de taux ne recalculent pas rétroactivement les coûts historiques. Le coût au moment de l'entrée persiste.

Rapports et analyse

Les données de budget alimentent le système de reporting de GitScrum :

Rapports disponibles

Coût par membre de l'équipe : Qui consomme le budget Coût par tâche : Quelles tâches sont coûteuses Coût dans le temps : Tendances du taux de consommation du budget Facturable vs Non-facturable : Analyse de l'utilisation

Export des données

Exportez les données de budget en CSV ou Excel pour une analyse externe ou la facturation client.

Bonnes pratiques

Planification du budget

Définissez des budgets réalistes : Incluez une marge pour les changements de périmètre et le travail inattendu.

Révisez mensuellement : N'attendez pas les alertes — vérifiez proactivement le statut du budget.

Communiquez avec les parties prenantes : Partagez le statut du budget dans les mises à jour du projet.

Gestion des taux

Documentez la logique des taux : Notez pourquoi les taux diffèrent entre les membres de l'équipe.

Révisez annuellement : Les taux doivent refléter les coûts actuels et les réalités de facturation.

Considérez les coûts chargés : Pour les projets internes, incluez l'overhead dans les calculs.

Stratégie d'alertes

Plusieurs seuils : Utilisez avertissement à 75%, critique à 90%.

Bons destinataires : Alertez les personnes qui peuvent agir.

N'ignorez pas les alertes : Acquitté n'est pas la même chose que traité.

Discipline du suivi du temps

La précision du budget dépend de la précision du suivi du temps :

• Enregistrez le temps quotidiennement
• Utilisez les bons indicateurs de facturation
• Associez le temps aux bonnes tâches

Permissions

Les membres réguliers de l'équipe voient leur propre allocation mais pas les taux de l'équipe ou la configuration des alertes.

Dépannage

Coûts affichant 0 € : Vérifiez que le taux par défaut est défini et que des entrées de temps existent.

Alertes ne se déclenchant pas : Vérifiez que l'alerte est activée et que le seuil n'a pas été acquitté.

Mauvaise devise : La devise est au niveau de l'espace de travail — contactez l'admin de l'espace de travail pour changer.

Taux ne s'appliquant pas : Les nouveaux taux s'appliquent aux entrées futures uniquement. Vérifiez l'horodatage de l'entrée vs l'horodatage du changement de taux.

Membres de l'équipe manquants dans l'allocation : Les membres doivent avoir enregistré du temps pour apparaître.

Les paramètres de budget transforment les données de temps en insights financiers actionnables. Configurez une fois, surveillez régulièrement, et anticipez les problèmes de budget avant qu'ils ne deviennent des problèmes.

Paramètres des détails du projet

L'onglet Détails contrôle l'identité fondamentale de votre projet et la disponibilité des fonctionnalités. C'est ici que vous configurez le nom de votre projet, ce qu'il fait et quelles capacités GitScrum il utilise.

Section Informations de base

Nom du projet

L'identifiant principal de votre projet dans tout GitScrum. Ce nom apparaît dans :

• Navigation de la barre latérale
• En-têtes et fil d'Ariane du projet
• Notifications et emails
• Rapports et exports
• Résultats de recherche

Bonnes pratiques :

• Gardez-le concis (2-4 mots)
• Rendez-le reconnaissable par votre équipe
• Évitez les noms génériques comme "Projet 1"
• Envisagez des préfixes pour les projets liés (Client-Web, Client-Mobile)

Limite de caractères : 255 caractères maximum

Description du projet

Texte explicatif optionnel sur l'objectif, la portée ou le focus actuel du projet. Utile pour :

• Intégrer les nouveaux membres de l'équipe
• Distinguer les projets similaires
• Documenter la phase ou les objectifs du projet

La description s'affiche sur l'aperçu du projet et dans les listes de projets.

Catégorie

Les catégories organisent les projets au niveau de l'espace de travail. Sélectionnez parmi les catégories existantes ou laissez non catégorisé.

Avantages des catégories :

• Filtrer les listes de projets par catégorie
• Regrouper les projets liés dans les rapports
• Organiser le tableau de bord de l'espace de travail

Les catégories sont gérées au niveau de l'espace de travail — vous sélectionnez parmi les options disponibles ici, vous n'en créez pas de nouvelles.

Section Fonctionnalités du projet

Activez ou désactivez individuellement les fonctionnalités GitScrum pour ce projet. Chaque interrupteur contrôle la visibilité de cette fonctionnalité dans la barre latérale du projet et dans toute l'interface.

Fonctionnalités disponibles

Comportement des interrupteurs de fonctionnalités

Quand désactivé :

• La fonctionnalité disparaît de la barre latérale du projet
• Les éléments de menu associés sont masqués
• Les données existantes restent préservées
• Les liens vers cette fonctionnalité retournent des erreurs

Quand réactivé :

• La fonctionnalité réapparaît immédiatement
• Toutes les données historiques sont restaurées
• Aucune donnée n'est jamais supprimée par la désactivation

Pourquoi désactiver des fonctionnalités ?

Tous les projets n'ont pas besoin de toutes les fonctionnalités. Un projet de documentation pourrait n'avoir besoin que du Wiki et des Documents. Un simple tracker de tâches pourrait n'avoir besoin que du tableau Kanban (qui est toujours activé).

Avantages de désactiver les fonctionnalités inutilisées :

• Navigation de barre latérale plus propre
• Charge cognitive réduite pour l'équipe
• Intégration plus rapide pour les nouveaux membres
• Workflow concentré sans distractions

État par défaut

Les nouveaux projets ont toutes les fonctionnalités activées par défaut. Ajustez pendant la configuration initiale ou à tout moment du cycle de vie du projet.

Section Branding

Personnalisez l'identité visuelle de votre projet avec un logo personnalisé.

Télécharger le logo du projet

Formats supportés : PNG, JPG, GIF Taille recommandée : 256×256 pixels (carré) Taille maximale du fichier : 2 Mo

Méthodes de téléchargement :

1. Glisser-déposer : Faites glisser un fichier image sur la zone de téléchargement
2. Cliquer pour parcourir : Cliquez sur la zone de téléchargement pour ouvrir le sélecteur de fichiers

Emplacements d'affichage du logo

Votre logo téléchargé apparaît dans :

• Barre latérale du projet (petite icône)
• En-tête du projet
• Listes de sélection de projet
• Notifications (certains clients email)

Progression du téléchargement

Un indicateur de progression s'affiche pendant le téléchargement. Les fichiers volumineux ou les connexions lentes peuvent prendre quelques secondes.

Supprimer le logo

Cliquez sur le bouton supprimer/effacer pour revenir à l'icône de projet par défaut (un carré coloré avec les initiales du projet).

Conseils pour le logo

• Utilisez des arrière-plans transparents : PNG avec transparence est le plus propre
• Les icônes simples fonctionnent mieux : Les images détaillées deviennent méconnaissables en petite taille
• Branding cohérent : Correspondez à l'identité visuelle de votre organisation
• Testez en mode sombre : Assurez la visibilité sur les arrière-plans sombres

Section Zone de danger

Actions irréversibles qui impactent significativement le projet. Ces contrôles nécessitent une confirmation explicite pour prévenir l'activation accidentelle.

Supprimer le projet

Supprime définitivement le projet et toutes les données associées :

Ce qui est supprimé :

• Toutes les tâches (ouvertes, fermées, archivées)
• Tous les sprints et l'historique des sprints
• Toutes les entrées de temps
• Toutes les pages wiki et révisions
• Tous les documents et dossiers
• Tous les canaux de discussion et messages
• Toutes les user stories et epics
• Tous les paramètres du projet
• Toutes les configurations d'intégration
• Tous les paramètres de webhook
• Tous les journaux d'accès API

Ce qui est préservé :

• Paramètres de l'espace de travail (non affectés)
• Comptes utilisateurs (non affectés)
• Autres projets (non affectés)
• Historique de facturation (si le projet avait des factures associées)

Confirmation de suppression

Le dialogue de confirmation nécessite de taper le nom exact du projet :

1. Le dialogue affiche un avertissement sur la suppression permanente
2. Le champ de texte nécessite une correspondance exacte du nom du projet
3. Sensible à la casse : "Mon Projet" ≠ "mon projet"
4. Le bouton Supprimer ne s'active que lorsque le nom correspond

Qui peut supprimer

Seuls les utilisateurs avec le rôle Agency Owner peuvent supprimer des projets. Les Managers et les membres réguliers voient la Zone de danger mais ne peuvent pas activer la suppression.

Avant de supprimer

Considérez les alternatives :

• Archiver : Masquer le projet des listes actives tout en préservant les données
• Exporter : Télécharger les données du projet avant la suppression
• Transférer : Remettre à un autre propriétaire d'espace de travail

Vérifiez avec les parties prenantes :

• Confirmez avec les parties prenantes du projet
• Assurez-vous qu'aucune donnée critique ne nécessite de préservation
• Vérifiez si des intégrations dépendent de ce projet

Après la suppression

• Le projet disparaît immédiatement de toutes les vues
• Les membres perdent l'accès instantanément
• Tout rapport planifié pour ce projet échoue
• Les webhooks cessent de se déclencher
• Les appels API retournent 404

Récupération : La suppression ne peut pas être annulée. Il n'y a pas de corbeille ou de mécanisme de restauration. Les données sont définitivement supprimées des serveurs GitScrum.

Enregistrer les modifications

Bouton Enregistrer

L'en-tête contient un bouton Enregistrer qui devient actif lorsque des modifications sont détectées :

États du bouton :

• Enregistrer : Modifications détectées, prêt à enregistrer
• Enregistrement... : Enregistrement en cours (avec spinner)
• Enregistré : Enregistré avec succès (s'affiche brièvement avant réinitialisation)

Détection automatique

Le formulaire suit les modifications automatiquement :

• Champs de texte modifiés
• Fonctionnalités basculées
• Logo téléchargé/supprimé

Naviguer ailleurs avec des modifications non enregistrées affiche un dialogue de confirmation.

Erreurs d'enregistrement

Si l'enregistrement échoue :

• Un message d'erreur s'affiche
• Les modifications restent dans le formulaire
• Réessayez l'enregistrement après avoir vérifié la connexion réseau

Causes courantes :

• Déconnexion réseau
• Session expirée (reconnexion requise)
• Changements de permission (rôle modifié par un admin)

Validation du formulaire

Validation du nom du projet

• Requis : Ne peut pas être vide
• Unique : Doit être unique dans l'espace de travail
• Longueur : Maximum 255 caractères
• Caractères : Tous les caractères Unicode autorisés

Validation de la description

• Optionnel : Peut être vide
• Longueur : Maximum 1000 caractères
• Formatage : Texte brut uniquement (pas de markdown)

Raccourcis clavier

Les Détails du projet établissent les fondations de l'identité et des capacités de votre projet. Configurez soigneusement à la création du projet, puis ajustez au fur et à mesure de l'évolution de votre projet.

Paramètres des intégrations

L'onglet Intégrations connecte GitScrum aux outils que votre équipe utilise déjà. Envoyez des notifications aux plateformes de chat, liez les systèmes de contrôle de version et automatisez les workflows via des services tiers.

Catégories d'intégrations

Les intégrations GitScrum se divisent en deux groupes :

Intégrations natives

Intégrées directement dans GitScrum avec des fonctionnalités approfondies :

• Slack : Messagerie d'équipe
• Microsoft Teams : Communication d'entreprise
• Discord : Chat orienté communauté
• GitHub : Contrôle de version (Pro)
• GitLab : Contrôle de version (Pro)
• Bitbucket : Contrôle de version (Pro)

Intégrations externes

Connexion via des plateformes tierces :

• Zapier : 5 000+ connexions d'applications
• Make (Integromat) : Automatisation de workflows avancée

Interface des intégrations

Disposition de la barre latérale

La barre latérale de gauche liste toutes les intégrations disponibles :

• Icône et nom de l'intégration
• Indicateur de statut de connexion
• Badge Pro pour les fonctionnalités premium

Cliquez sur n'importe quelle intégration pour voir son panneau de configuration à droite.

Indicateurs de statut

Compte actif

L'en-tête affiche le total des intégrations actives, donnant une visibilité rapide sur le niveau de connexion de votre projet.

Intégrations de communication

Slack

Connectez Slack pour recevoir les notifications du projet dans les canaux de votre espace de travail.

Processus de configuration :

1. Cliquez sur Slack dans la barre latérale
2. Cliquez sur "Connecter à Slack"
3. Autorisez GitScrum dans le flux OAuth de Slack
4. Sélectionnez l'espace de travail à connecter
5. Choisissez le canal de notification par défaut
6. Enregistrez la configuration

Options de configuration :

• Canal : Quel canal Slack reçoit les notifications
• Événements : Sélectionnez quels événements déclenchent des notifications
• Format : Format de message enrichi ou simple

Événements de notification :

• Tâche créée, mise à jour, complétée
• Sprint démarré, complété
• Membre d'équipe ajouté/supprimé
• Commentaires et mentions
• Entrées de temps enregistrées

Test : Cliquez sur "Envoyer un message test" pour vérifier que la connexion fonctionne. Une notification exemple apparaît dans votre canal configuré.

Déconnexion : Cliquez sur "Déconnecter" pour supprimer l'intégration Slack. Les notifications s'arrêtent immédiatement. Les messages historiques dans Slack restent.

Microsoft Teams

L'intégration Teams reflète les fonctionnalités Slack pour les environnements Microsoft 365.

Processus de configuration :

1. Cliquez sur Microsoft Teams dans la barre latérale
2. Cliquez sur "Connecter à Teams"
3. Connectez-vous avec un compte Microsoft
4. Accordez les permissions à GitScrum
5. Sélectionnez l'équipe et le canal
6. Configurez les préférences de notification

Option Webhook : Alternativement, utilisez un webhook entrant :

1. Créez un webhook entrant dans Teams
2. Copiez l'URL du webhook
3. Collez l'URL dans la configuration GitScrum
4. Sélectionnez les événements à envoyer

Les événements et le formatage correspondent aux capacités de Slack.

Discord

Connectez Discord pour les notifications d'équipe ou de communauté.

Processus de configuration :

1. Cliquez sur Discord dans la barre latérale
2. Choisissez la méthode de connexion :

• OAuth (recommandé)
• URL Webhook (plus simple)

1. Pour OAuth : Autorisez et sélectionnez serveur/canal
2. Pour Webhook : Collez l'URL du webhook Discord
3. Configurez les événements

Options spécifiques à Discord :

• Embeds enrichis avec détails des tâches
• Mentions @role pour les événements critiques
• Nom et avatar de bot personnalisés

Note : Les webhooks Discord ne supportent pas toutes les options de formatage que OAuth fournit.

Intégrations de contrôle de version (Pro)

Liez les dépôts Git pour connecter les commits, branches et pull requests avec les tâches GitScrum.

GitHub

Prérequis :

• Abonnement Pro
• Compte GitHub avec accès aux dépôts
• Dépôts d'organisation ou personnels

Processus de configuration :

1. Cliquez sur GitHub dans la barre latérale
2. Cliquez sur "Connecter le compte GitHub"
3. Authentifiez-vous via GitHub OAuth
4. Accordez les permissions d'accès aux dépôts
5. Sélectionnez les dépôts à lier

Configuration :

• Dépôts : Choisissez quels repos connecter à ce projet
• Auto-linking : Activez l'analyse intelligente des messages de commit
• Statut Pull Request : Affichez le statut PR sur les tâches

Liaison de commits : Incluez les identifiants de tâches dans les messages de commit :

git commit -m "Ajouter validation login [GS-123]"

GitScrum lie automatiquement le commit à la tâche GS-123.

Identifiants supportés :

• [GS-123] ou GS-123
• #123 (si configuré)
• UUID de tâche (pour les intégrations API)

Intégration Pull Request :

• La création de PR notifie sur les tâches liées
• Le statut PR s'affiche dans la vue de tâche
• La fusion ferme les tâches liées (si configuré)

GitLab

Fonctionnalités identiques à GitHub pour les utilisateurs GitLab.

Processus de configuration :

1. Cliquez sur GitLab dans la barre latérale
2. Cliquez sur "Connecter le compte GitLab"
3. Authentifiez-vous via GitLab OAuth
4. Sélectionnez les projets/dépôts
5. Configurez les préférences de liaison

GitLab auto-hébergé : Les utilisateurs Enterprise peuvent connecter des instances GitLab auto-hébergées :

1. Entrez l'URL de l'instance GitLab
2. Créez un token d'accès personnel
3. Configurez les permissions
4. Complétez la connexion

Bitbucket

Les utilisateurs Atlassian peuvent connecter les dépôts Bitbucket.

Processus de configuration :

1. Cliquez sur Bitbucket dans la barre latérale
2. Authentifiez-vous via Bitbucket OAuth
3. Sélectionnez les dépôts
4. Configurez la liaison de commits

Spécifique à Bitbucket :

• Supporte Cloud et Server
• Fonctionne avec Bitbucket Pipelines
• S'intègre avec les migrations Jira

Plateformes d'intégration externes

Zapier

Connectez GitScrum à 5 000+ applications via la plateforme d'automatisation Zapier.

Ce que Zapier permet :

• Créer des tâches depuis des soumissions de formulaire
• Synchroniser avec les systèmes CRM
• Notifier par SMS ou email
• Mettre à jour des feuilles de calcul depuis les données de tâche
• Déclencher des actions dans toute application supportée par Zapier

Pour commencer :

1. Cliquez sur Zapier dans la barre latérale
2. Ouvre la page d'intégration GitScrum de Zapier
3. Créez un compte ou connectez-vous
4. Construisez des "Zaps" connectant GitScrum à d'autres apps

Zaps populaires :

• Gmail → GitScrum : Email crée une tâche
• Google Sheets → GitScrum : Ligne crée une tâche
• GitScrum → Google Calendar : Date limite de tâche crée un événement
• Typeform → GitScrum : Soumission de formulaire crée une tâche

Authentification : Zapier se connecte via l'API GitScrum. Vous entrerez les identifiants API lors de la configuration du Zap.

Make (Integromat)

Automatisation plus avancée avec un constructeur de workflow visuel.

Ce que Make permet :

• Scénarios multi-étapes complexes
• Logique conditionnelle et branchement
• Transformation de données entre applications
• Workflows planifiés et déclenchés

Pour commencer :

1. Cliquez sur Make dans la barre latérale
2. Ouvre la page du module GitScrum de Make
3. Créez des scénarios connectant GitScrum

Make vs. Zapier :

• Make : Plus puissant, courbe d'apprentissage plus raide
• Zapier : Plus simple, plus cher à grande échelle

Référence des événements

Événements de tâche

Événements de sprint

Événements d'entrée de temps

Événements de projet

Dépannage

Slack ne se connecte pas

Erreurs OAuth :

• Assurez-vous d'avoir les permissions admin de l'espace de travail Slack
• Vérifiez que le navigateur autorise les popups pour le flux OAuth
• Essayez de déconnecter et reconnecter

Messages n'apparaissant pas :

• Vérifiez que le bon canal est sélectionné
• Vérifiez les permissions de l'app Slack
• Envoyez un message test pour confirmer

GitHub ne lie pas les commits

Commits ne s'affichant pas :

• Vérifiez que le dépôt est connecté
• Vérifiez que le message de commit inclut l'ID de tâche
• Assurez-vous que le pusher a un compte GitScrum lié

Mauvaise tâche liée :

• Le format de l'ID de tâche compte : [GS-123] pas GS 123
• Plusieurs IDs ? La première correspondance gagne

Intégration déconnectée

Causes de déconnexion automatique :

• Token expiré (ré-authentifiez)
• Permissions révoquées dans le service externe
• Mot de passe changé sur le compte externe

Correction : Déconnectez puis reconnectez l'intégration pour rafraîchir les tokens.

Bonnes pratiques

Gestion des notifications

Ne pas sur-notifier :

• Choisissez uniquement les événements critiques
• Utilisez des canaux séparés pour différents types d'événements
• Considérez les notifications digest vs temps réel

Contrôle de version

Standards de message de commit :

• Établissez une convention d'équipe pour les références de tâches
• Documentez le format attendu
• Utilisez des hooks de commit pour appliquer si nécessaire

Sécurité

Identifiants API :

• Ne partagez pas les clés API dans les canaux publics
• Faites tourner les clés périodiquement
• Utilisez les permissions minimum requises

Permissions

Fonctionnalités Pro

Les intégrations GitHub, GitLab et Bitbucket nécessitent un abonnement Pro. Le panneau d'intégration affiche un badge "PRO" à côté de ces options.

Ce que Pro ajoute :

• Intégration complète du contrôle de version
• Liaison des commits et PR
• Synchronisation des dépôts
• Suivi du statut des branches

Les utilisateurs non-Pro voient les options mais ne peuvent pas compléter la configuration.

Les intégrations connectent GitScrum à votre workflow existant. Commencez par les notifications de communication, ajoutez le contrôle de version si vous utilisez Git, et explorez les plateformes d'automatisation pour les workflows avancés.

Paramètres des membres

L'onglet Membres contrôle qui a accès à votre projet. Assignez des équipes entières ou ajoutez des membres individuels pour garantir que les bonnes personnes peuvent collaborer tout en maintenant le contrôle d'accès.

Modèle d'accès

GitScrum utilise un modèle d'accès en couches :

1. Appartenance à l'espace de travail : L'utilisateur doit appartenir à l'espace de travail
2. Affectation équipe ou individuelle : L'utilisateur obtient l'accès au projet via l'équipe ou l'affectation directe
3. Permissions de rôle : Le rôle de l'espace de travail de l'utilisateur détermine les capacités

L'accès au projet ne remplace pas les rôles de l'espace de travail — les permissions viennent de l'attribution de rôle au niveau de l'espace de travail.

Interface des membres

Barre de filtre

L'en-tête affiche :

• Titre de la vue actuelle
• Nombre d'affectations d'équipe
• Nombre de membres individuels
• Champ de recherche pour filtrer

Recherche

Tapez pour filtrer par :

• Nom de l'équipe
• Nom du membre
• Adresse email

Les résultats se mettent à jour en temps réel pendant la saisie.

Bouton Ajouter des membres

Cliquez pour ouvrir le dialogue d'affectation membre/équipe. Disponible pour les Agency Owners et Managers avec les permissions appropriées.

Section Affectations d'équipe

Section extensible

Cliquez sur l'en-tête "Affectations d'équipe" pour développer/réduire. Affiche le nombre entre parenthèses.

Tableau des équipes

Une fois développé, un tableau affiche les équipes assignées :

Expansion des lignes d'équipe

Cliquez sur une ligne d'équipe pour développer et voir les membres individuels de cette équipe :

• Avatar et nom du membre
• Email du membre
• Rôle dans l'équipe
• Date d'arrivée

Assigner des équipes

1. Cliquez sur "Ajouter des membres"
2. Sélectionnez l'onglet "Équipes"
3. Choisissez la ou les équipes à ajouter
4. Confirmez l'affectation

Tous les membres de l'équipe obtiennent immédiatement l'accès au projet.

Comportement de l'accès équipe

Quand une équipe est assignée :

• Membres actuels : Obtiennent un accès immédiat
• Ajouts futurs : Obtiennent automatiquement l'accès quand ils sont ajoutés à l'équipe
• Membres retirés : Perdent l'accès quand ils sont retirés de l'équipe

Cela rend l'affectation d'équipe auto-maintenue.

Supprimer l'affectation d'équipe

Cliquez sur le bouton de suppression sur une ligne d'équipe :

1. Un dialogue de confirmation apparaît
2. Confirmez pour supprimer
3. Tous les membres de l'équipe perdent l'accès immédiatement

Note : Les membres avec une affectation individuelle conservent l'accès même si leur équipe est supprimée.

Section Membres individuels

Section extensible

Cliquez sur l'en-tête "Membres individuels" pour développer/réduire. Affiche le nombre entre parenthèses.

Tableau des membres

Les affectations individuelles affichent :

Ajouter des membres individuels

1. Cliquez sur "Ajouter des membres"
2. Sélectionnez l'onglet "Membres"
3. Recherchez ou parcourez les membres disponibles
4. Sélectionnez le ou les membres à ajouter
5. Confirmez

Affectation individuelle vs équipe

Quand utiliser individuel :

• Contributeur temporaire au projet
• Collaborateur transversal
• Cas d'accès spéciaux

Quand utiliser équipe :

• Équipe permanente du projet
• Accès basé sur le rôle (tous les développeurs)
• Accès auto-maintenu

Supprimer des membres individuels

Cliquez sur le bouton de suppression sur la ligne du membre :

1. Dialogue de confirmation
2. Confirmez la suppression
3. Le membre perd l'accès immédiatement

Exception : Si l'équipe du membre est également assignée, il conserve l'accès via l'appartenance à l'équipe.

Dialogue Ajouter des membres

Structure du dialogue

Interface à deux onglets :

• Équipes : Équipes disponibles à assigner
• Membres : Membres individuels de l'espace de travail

Onglet Équipes

Affiche les équipes de l'espace de travail non encore assignées :

• Nom et couleur de l'équipe
• Nombre de membres
• Capacité de multi-sélection

Onglet Membres

Affiche les membres de l'espace de travail non assignés individuellement :

• Recherche par nom ou email
• Affichage avatar et nom
• Indicateur de rôle
• Capacité de multi-sélection

Sélection en masse

Sélectionnez plusieurs équipes ou membres avant de confirmer. Utile lors de la configuration de nouveaux projets ou de grands changements d'accès.

Exigences de permissions

Qui peut voir

Tous les membres du projet peuvent voir :

• Affectations d'équipe
• Liste des membres individuels
• Leur propre type d'accès

Qui peut gérer

Les Managers peuvent ajouter des individus mais ne peuvent généralement pas gérer les affectations d'équipe.

Auto-suppression

Les utilisateurs ne peuvent pas se retirer eux-mêmes d'un projet. Cela prévient le verrouillage accidentel. Demandez à un autre utilisateur autorisé de supprimer votre accès si nécessaire.

Implications de l'accès

Ce que l'accès fournit

Les membres du projet peuvent :

• Voir le projet dans la barre latérale
• Accéder aux fonctionnalités activées (Kanban, Wiki, etc.)
• Voir les tâches et données du projet
• Interagir selon les permissions de rôle

Ce que l'accès ne fournit pas

• Permissions élevées au-delà du rôle de l'espace de travail
• Accès aux autres projets (affectation séparée)
• Capacités administratives (sauf si le rôle le permet)

Capacités des rôles

Accès + Rôle détermine les permissions réelles :

Scénarios courants

Configuration d'un nouveau projet

1. Ajoutez l'équipe principale du projet
2. Ajoutez les parties prenantes individuelles
3. Vérifiez que tous les membres attendus apparaissent

Changements de membres d'équipe

Nouvelle recrue rejoint une équipe existante :

• Obtient automatiquement l'accès aux projets de l'équipe
• Aucune action nécessaire

Engagement de consultant :

• Ajoutez individuellement aux projets spécifiques
• Supprimez à la fin de l'engagement

Changement de phase du projet

Transition vers la maintenance :

• Supprimez l'équipe de développement
• Ajoutez l'équipe de support
• Gardez les individus clés

Audit d'accès

Révisez périodiquement :

• Toutes les équipes assignées ont-elles encore besoin d'accès ?
• Les affectations individuelles sont-elles encore pertinentes ?
• Quelqu'un manque-t-il qui devrait avoir accès ?

Dépannage

Le membre ne peut pas accéder au projet

Vérifiez :

1. Le membre existe dans l'espace de travail
2. Le membre est assigné (équipe ou individuel)
3. Le rôle du membre permet l'accès au projet
4. Le projet est actif (non archivé)

L'affectation d'équipe n'affiche aucun membre

Causes possibles :

• L'équipe elle-même est vide
• Chargement encore en cours
• Les permissions empêchent de voir les détails de l'équipe

Impossible d'ajouter certains membres

Causes possibles :

• Déjà assigné (individuellement ou via équipe)
• Utilisateur pas dans l'espace de travail
• Permissions insuffisantes pour ajouter

Le membre supprimé a toujours accès

Vérifiez :

• Est-il assigné via une équipe qui n'a pas été supprimée ?
• La suppression a-t-elle été enregistrée avec succès ?
• A-t-il rafraîchi sa session ?

Bonnes pratiques

Utilisez les équipes quand possible

Avantages :

• Accès auto-maintenu
• Audit plus facile
• Organisation basée sur les rôles
• Cohérent entre les projets

Individuel pour les exceptions

Utilisez pour :

• Collaborations ponctuelles
• Contributeurs inter-équipes
• Accès temporaire

Audits réguliers

Révision mensuelle :

• Supprimez l'accès pour les membres partis
• Ajoutez l'accès pour les nouveaux membres de l'équipe
• Vérifiez que les affectations d'équipe sont à jour

Les paramètres des membres garantissent que les bonnes personnes ont accès pour collaborer sur votre projet. Utilisez les équipes pour un accès systématique, les individus pour les exceptions, et auditez régulièrement pour garder l'accès aligné avec la réalité.

Paramètres du planning de travail

L'onglet Planning de travail définit quand le travail a lieu sur ce projet. Configurez les jours ouvrés, les heures quotidiennes et les jours fériés pour garantir que les calculs de capacité, la planification des sprints et le suivi du temps reflètent la réalité.

Hiérarchie des plannings

GitScrum utilise une hiérarchie pour les plannings de travail :

1. Défaut de l'espace de travail : S'applique à tous les projets sauf si remplacé
2. Remplacement du projet : Ce projet utilise un planning personnalisé

L'interrupteur "Remplacer le planning de l'espace de travail" contrôle lequel s'applique.

Remplacer le planning de l'espace de travail

Quand désactivé (par défaut)

Le projet utilise les paramètres de planning au niveau de l'espace de travail. Un encadré d'information affiche :

• Jours ouvrés actuels de l'espace de travail
• Heures par jour depuis les paramètres de l'espace de travail

Tout changement de planning nécessite un accès admin à l'espace de travail.

Quand activé

Le projet utilise son propre planning personnalisé. Les options de configuration complètes apparaissent :

• Grille des jours ouvrés
• Curseur des heures par jour
• Jours fériés spécifiques au projet

Configuration des jours ouvrés

Grille de sélection des jours

Sept boutons représentent chaque jour de la semaine :

Sélectionner les jours ouvrés

Cliquez sur un jour pour basculer :

• Actif (surligné) : Jour de travail
• Inactif (atténué) : Jour non travaillé

La plupart des organisations utilisent lundi-vendredi. Certains scénarios nécessitent des configurations différentes :

• Couverture week-end : Inclure Sam/Dim
• Observance religieuse : Exclure des jours spécifiques
• Semaine compressée : Quatre jours de 10 heures

Nombre de jours ouvrés

Sous la grille, un résumé affiche : "X jours ouvrés par semaine"

Cela affecte :

• Calculs de capacité hebdomadaire
• Comptages de jours de sprint
• Prévision de disponibilité des ressources

Heures par jour

Définir les heures quotidiennes

Un curseur ou champ de saisie contrôle les heures travaillées par jour :

• Plage : 1-24 heures (plage pratique : 4-12)
• Par défaut : 8 heures
• Incréments : 0,5 heures

Capacité hebdomadaire

La configuration affiche la capacité hebdomadaire calculée :

Heures par jour × Jours ouvrés = Capacité hebdomadaire
8 heures × 5 jours = 40 heures/semaine

Impact sur la planification

Les heures par jour affectent :

• Capacité du sprint : Total d'heures disponibles
• Conversion effort-heures : Ratio story points vers heures
• Attentes de suivi du temps : Ce qui compte comme une "journée complète"
• Calculs de burndown : Progression quotidienne attendue

Jours fériés du projet

Liste des jours fériés

Consultez et gérez les jours fériés spécifiques au projet qui excluent des jours du temps de travail.

Ajouter des jours fériés

1. Cliquez sur "Ajouter un jour férié"
2. Sélectionnez la date dans le sélecteur de date
3. Cliquez sur "Ajouter" pour confirmer

Les jours fériés apparaissent dans une liste chronologique :

• Date affichée au format local
• Bouton de suppression pour retirer

Supprimer des jours fériés

Cliquez sur l'icône de suppression à côté de n'importe quel jour férié. Il est supprimé immédiatement.

Impact des jours fériés

Les jours fériés affectent :

• Planification du sprint : Jour exclu de la durée du sprint
• Calculs de capacité : Heures disponibles réduites
• Vues calendrier : Jour marqué comme non travaillé
• Calculs d'échéances : Tiennent compte des jours fériés

Jours fériés courants à ajouter

Envisagez d'ajouter :

• Jours fériés nationaux/publics
• Jours de fermeture de l'entreprise
• Événements hors site de l'équipe
• Congés prolongés (période des fêtes)

Gestion en masse des jours fériés

Pour de nombreux jours fériés, envisagez :

1. Gérer au niveau de l'espace de travail (s'applique à tous les projets)
2. Utiliser le niveau projet uniquement pour les fermetures spécifiques au projet

Enregistrer les modifications

Bouton Enregistrer

Cliquez sur "Enregistrer" dans l'en-tête pour persister les modifications. Le bouton affiche :

• Enregistrer les modifications : Modifications détectées
• Enregistrement... : Enregistrement en cours
• L'enregistrement réussi revient à l'état normal

Quand enregistrer

Les modifications nécessitent un enregistrement explicite :

• Jours ouvrés modifiés
• Heures par jour changées
• Jours fériés ajoutés ou supprimés
• Paramètre de remplacement basculé

Naviguer ailleurs avec des modifications non enregistrées affiche une confirmation.

Indicateur de source du planning

L'en-tête affiche la source actuelle du planning :

• "Utilise le planning de l'espace de travail" : Le projet hérite des paramètres de l'espace de travail
• "Utilise le planning du projet" : Le remplacement est actif

Cela aide à identifier rapidement quelle configuration s'applique.

Visualisation de l'impact

Aperçu de la capacité

Lors de la planification des sprints, le planning affecte :

Exemple de calcul :

• Jours ouvrés : Lun-Ven (5 jours)
• Heures par jour : 8 heures
• Durée du sprint : 2 semaines
• Jours fériés dans le sprint : 1 jour

Jours disponibles : (5 jours × 2 semaines) - 1 jour férié = 9 jours
Capacité totale : 9 jours × 8 heures = 72 heures

Contexte du suivi du temps

Le planning affecte comment le temps enregistré s'affiche :

• Totaux quotidiens comparés aux heures par jour
• Totaux hebdomadaires comparés à la capacité hebdomadaire
• Heures supplémentaires calculées quand le planning est dépassé

Configurations courantes

Semaine de travail standard

Jours : Lun, Mar, Mer, Jeu, Ven
Heures : 8 par jour
Capacité hebdomadaire : 40 heures

Semaine de travail compressée

Jours : Lun, Mar, Mer, Jeu
Heures : 10 par jour
Capacité hebdomadaire : 40 heures

Semaine de six jours

Jours : Lun, Mar, Mer, Jeu, Ven, Sam
Heures : 7 par jour
Capacité hebdomadaire : 42 heures

Projet à temps partiel

Jours : Lun, Mar, Mer
Heures : 6 par jour
Capacité hebdomadaire : 18 heures

Bonnes pratiques

Précision plutôt qu'optimisme

Définissez des heures réalistes : Si l'équipe travaille réellement 6 heures productives, ne mettez pas 8.

Incluez les jours fériés tôt : Ajoutez les jours fériés connus au début du projet.

Révisez périodiquement : Ajustez quand les habitudes de l'équipe changent.

Cohérence

Correspondre à la réalité : Le planning doit refléter comment le travail se passe réellement.

Sensibilisation de l'équipe : Assurez-vous que l'équipe connaît le planning configuré.

Mettre à jour rapidement : Ajustez quand les circonstances changent.

Remplacer avec sagesse

Utilisez les défauts de l'espace de travail quand les projets suivent le planning standard.

Remplacez uniquement si nécessaire :

• Client dans un fuseau horaire/région différent
• Projet avec des exigences uniques
• Planning temporairement différent

Permissions

Les membres réguliers voient le planning mais ne peuvent pas le modifier.

Dépannage

Calculs de capacité incorrects

Vérifiez :

• Jours ouvrés correctement définis
• Heures par jour précises
• Jours fériés correctement saisis
• Interrupteur de remplacement dans l'état attendu

Le planning ne s'applique pas

Si utilisant le planning de l'espace de travail :

• Vérifiez que le remplacement est désactivé
• Vérifiez les paramètres de l'espace de travail pour les valeurs correctes

Si utilisant le planning du projet :

• Confirmez que le remplacement est activé
• Enregistrez après avoir fait des modifications

Les jours fériés ne sont pas exclus

• Vérifiez que le jour férié est dans le bon format de date
• Vérifiez que le jour férié tombe dans la période concernée
• Assurez-vous que le jour férié a été enregistré (pas juste ajouté)

Décalage de capacité du sprint

La capacité du sprint combine :

• Paramètres du planning de travail
• Disponibilité des membres de l'équipe
• Congés individuels

Les trois facteurs entrent dans la capacité finale. Vérifiez chacun si les nombres semblent incorrects.

Notes techniques

Gestion des fuseaux horaires

Les jours fériés et les jours ouvrés utilisent le fuseau horaire du projet. Assurez-vous que le fuseau horaire du projet est correctement configuré pour une gestion précise des dates.

Format de date

Les dates des jours fériés s'affichent au format de votre locale. Le système stocke les dates au format ISO (AAAA-MM-JJ) quel que soit l'affichage.

Accès API

Le planning de travail est accessible via l'API :

GET /projects/{slug}/settings/schedule
PUT /projects/{slug}/settings/schedule

Utile pour la gestion programmatique du planning.

Le Planning de travail garantit que les fonctionnalités de planification et de suivi de GitScrum reflètent comment votre équipe travaille réellement. Configurez avec précision, maintenez avec diligence, et votre planification de capacité reste ancrée dans la réalité.

Paramètres des webhooks

Les webhooks envoient des requêtes HTTP POST à vos endpoints quand des événements se produisent dans GitScrum. Créez des intégrations personnalisées, déclenchez des workflows externes et gardez les systèmes externes synchronisés avec l'activité du projet.

Fondamentaux des webhooks

Ce que font les webhooks

Quand un événement configuré se produit :

1. GitScrum détecte l'événement
2. Construit un payload JSON avec les données de l'événement
3. Envoie un HTTP POST à l'URL de votre endpoint
4. Enregistre la réponse pour le débogage

Cas d'utilisation

• Notifications personnalisées : Envoyer vers des systèmes de chat propriétaires
• Synchronisation de données : Mettre à jour des bases de données externes
• Déclencheurs de workflow : Démarrer des pipelines CI/CD
• Journalisation d'audit : Enregistrement externe des événements
• Intégrations tierces : Connecter des services non supportés

Interface des webhooks

Disposition du tableau

Les webhooks s'organisent par catégorie d'événement dans un tableau extensible :

Catégories d'événements

Cliquez sur les en-têtes de catégorie pour développer/réduire :

Tâches : Événements du cycle de vie des tâches Sprints : Événements de gestion des sprints Entrées de temps : Événements de suivi du temps Projets : Événements de configuration du projet

Affichage des statistiques

L'en-tête affiche les métriques des webhooks :

• Total des webhooks configurés
• Nombre de webhooks actifs

Configurer les webhooks

Ajouter un endpoint

1. Trouvez le type d'événement que vous voulez surveiller
2. Entrez l'URL de votre endpoint dans le champ de saisie
3. Appuyez sur Entrée ou cliquez ailleurs pour enregistrer

Exigences de l'URL :

• Doit être une URL HTTP ou HTTPS valide
• Doit être accessible publiquement (ou dans votre réseau)
• Doit retourner un statut 2xx pour confirmer la réception

Format de l'endpoint

https://votre-domaine.com/webhooks/gitscrum
https://api.votreservice.com/hooks/incoming
https://hooks.slack.com/services/T00/B00/xxx (pour Slack)

Validation de l'URL

Les URLs invalides affichent un état d'erreur :

• Bordure rouge sur le champ
• Message de validation apparaît
• Enregistrement bloqué jusqu'à correction

Supprimer un endpoint

Videz le champ URL et enregistrez. Le webhook se désactive immédiatement.

Référence des événements

Événements de tâche

Événements de sprint

Événements d'entrée de temps

Événements de projet

Structure du payload

Tous les webhooks envoient des payloads JSON avec une structure cohérente :

{
  "event": "task.created",
  "timestamp": "2024-01-15T14:30:00Z",
  "project": {
    "uuid": "proj-uuid-123",
    "name": "Nom du projet",
    "slug": "nom-du-projet"
  },
  "data": {
    // Données spécifiques à l'événement
  },
  "triggered_by": {
    "uuid": "user-uuid-456",
    "name": "Jean Dupont",
    "email": "jean@exemple.com"
  }
}

Exemple de payload de tâche

{
  "event": "task.created",
  "timestamp": "2024-01-15T14:30:00Z",
  "project": {
    "uuid": "proj-abc123",
    "name": "Développement Web",
    "slug": "developpement-web"
  },
  "data": {
    "uuid": "task-xyz789",
    "title": "Implémenter l'authentification utilisateur",
    "description": "Ajouter connexion et inscription",
    "status": {
      "name": "À faire",
      "slug": "a-faire"
    },
    "priority": "high",
    "assignee": {
      "uuid": "user-456",
      "name": "Marie Martin"
    },
    "due_date": "2024-01-20",
    "effort": 5,
    "labels": ["fonctionnalité", "sécurité"]
  },
  "triggered_by": {
    "uuid": "user-123",
    "name": "Jean Dupont"
  }
}

Exemple de payload de sprint

{
  "event": "sprint.started",
  "timestamp": "2024-01-15T09:00:00Z",
  "project": {
    "uuid": "proj-abc123",
    "name": "Développement Web"
  },
  "data": {
    "uuid": "sprint-def456",
    "name": "Sprint 5",
    "goal": "Compléter le module d'authentification",
    "start_date": "2024-01-15",
    "end_date": "2024-01-29",
    "task_count": 12,
    "total_effort": 45
  },
  "triggered_by": {
    "uuid": "user-123",
    "name": "Jean Dupont"
  }
}

Tester les webhooks

Bouton de test

Chaque webhook configuré a un bouton de test. Cliquez pour envoyer un payload exemple :

1. GitScrum envoie un payload de test à votre endpoint
2. La réponse s'affiche en ligne :

• Succès (2xx) : Confirmation verte
• Échec : Message d'erreur avec code de statut

Payload de test

Les payloads de test s'identifient clairement comme tests :

{
  "event": "webhook.test",
  "timestamp": "2024-01-15T14:30:00Z",
  "test": true,
  "message": "Ceci est un webhook de test de GitScrum"
}

Tester tout

Le bouton "Tester tout" dans l'en-tête envoie des payloads de test à tous les webhooks configurés simultanément. Utile pour vérifier toute la configuration des webhooks d'un coup.

Gestion des réponses

Réponse attendue

Votre endpoint doit retourner :

• Statut 2xx : Webhook reçu avec succès
• Temps de réponse : Moins de 30 secondes

Timeout

GitScrum expire après 30 secondes. Les processus longs doivent :

1. Retourner 202 Accepted immédiatement
2. Traiter de manière asynchrone

Logique de retry

Les webhooks échoués réessaient automatiquement :

• 1er retry : 1 minute après l'échec
• 2e retry : 5 minutes après le 1er retry
• 3e retry : 30 minutes après le 2e retry
• Dernier retry : 2 heures après le 3e retry

Après tous les échecs de retry, le webhook est enregistré comme échoué.

Codes de statut

Sécurité

Sécurité de l'endpoint

HTTPS recommandé : Utilisez toujours des endpoints HTTPS en production.

Liste blanche d'IP : Les webhooks GitScrum proviennent de plages d'IP documentées. Contactez le support pour la liste actuelle.

Vérification de signature : Fonctionnalité à venir — signera les payloads pour vérification.

Sécuriser votre endpoint

1. Tokens secrets : Ajoutez un paramètre de requête ou en-tête pour vérification

`` https://votresite.com/webhooks?token=secret123 ``

1. Restriction d'IP : Acceptez uniquement depuis les IPs GitScrum

1. Limitation de débit : Protégez contre les attaques par rejeu

1. Validation d'entrée : Validez toujours la structure du payload

Intégrations courantes

Webhook entrant Slack

1. Créez un Webhook entrant dans Slack
2. Copiez l'URL du webhook
3. Collez comme endpoint pour les événements désirés

Note : L'intégration native Slack fournit un formatage plus riche.

Webhook Discord

1. Créez un webhook dans les paramètres du canal Discord
2. Utilisez l'URL du webhook directement
3. Discord accepte les payloads JSON standard

Serveur personnalisé

Exemple d'endpoint Node.js :

app.post('/webhooks/gitscrum', (req, res) => {
  const { event, data } = req.body;
  
  // Traiter selon le type d'événement
  switch(event) {
    case 'task.created':
      handleNewTask(data);
      break;
    case 'sprint.completed':
      handleSprintComplete(data);
      break;
  }
  
  res.status(200).send('OK');
});

Dépannage

Les webhooks ne se déclenchent pas

Checklist :

1. L'URL de l'endpoint est-elle enregistrée (pas vide) ?
2. L'URL est-elle accessible depuis l'internet public ?
3. L'endpoint retourne-t-il un statut 2xx ?
4. Vérifiez les logs du serveur de l'endpoint

Mauvaises données reçues

Vérifiez :

• Type d'événement correct configuré
• Structure du payload correspond à l'attendu
• Pas de middleware transformant la requête

Événements en double

Causes possibles :

• Retry après timeout (mais endpoint a traité)
• Plusieurs webhooks pour le même type d'événement

Solution : Implémentez l'idempotence en utilisant l'UUID de l'événement ou le timestamp.

Connexion refusée

Causes courantes :

• Pare-feu bloquant les IPs GitScrum
• Endpoint n'écoute pas sur le port spécifié
• Problèmes de certificat SSL (pour HTTPS)

Débogage :

1. Testez l'endpoint depuis une source externe
2. Vérifiez les règles du pare-feu
3. Vérifiez la validité du certificat SSL

Bonnes pratiques

Conception de l'endpoint

Retournez rapidement : Accusez réception, traitez en async Gérez les échecs gracieusement : Ne plantez pas sur des payloads malformés Loggez tout : Aide au débogage et à l'audit

Sélection des événements

Soyez spécifique : Abonnez-vous uniquement aux événements nécessaires Évitez la redondance : task.completed inclut les infos de task.updated Considérez le volume : Les projets très actifs génèrent beaucoup d'événements

Maintenance

Surveillez la santé de l'endpoint : Alertez sur les échecs Testez après les changements : Re-vérifiez après les mises à jour de l'endpoint Documentez les intégrations : Enregistrez pourquoi chaque webhook existe

Permissions

Les membres réguliers du projet ne peuvent pas accéder à la configuration des webhooks.

Limites de débit

Les webhooks partagent les limites de débit API du projet :

• Standard : 1000 requêtes/heure
• Pro : 5000 requêtes/heure

Les événements à haut volume peuvent atteindre les limites. Envisagez le batching ou des événements sélectifs.

Les webhooks étendent la portée de GitScrum à tout système pouvant recevoir des requêtes HTTP. Configurez soigneusement, testez minutieusement, et construisez les intégrations personnalisées que votre workflow nécessite.