Jamespot

Ce guide vous explique comment configurer l'authentification unique (SSO) entre SmartLink et Jamespot en utilisant SAML 2.0.

Prérequis

• Abonnement Jamespot Pro ou Enterprise
• Accès administrateur à Jamespot
• Domaine email vérifié
• Application configurée dans SmartLink avec SAML2

Note : Le SSO est disponible avec les offres Jamespot Pro et Enterprise.

Configuration dans SmartLink

1. Créer l'application

1. Connectez-vous à SmartLink en tant qu'administrateur
2. Allez dans Applications → Ajouter
3. Créez une nouvelle application :
   • Nom : Jamespot
   • URL : https://[votre-organisation].jamespot.com
   • Description : Digital workplace collaboratif français
   • Icône : Choisissez l'icône Jamespot

2. Configurer SAML2

1. Dans l'onglet Authentification
2. Sélectionnez SAML2
3. Configurez les paramètres suivants :
   • Entity ID : [appid]
   • ACS URL : https://[votre-organisation].jamespot.com/saml/acs
   • Format NameID : emailAddress
   • App ID : [appid] (identifiant unique généré automatiquement)

3. Récupérer les métadonnées

Notez les URLs suivantes :

• Métadonnées IdP : https://[votre-smartlink].link.vaultys.org/api/saml2/[appid]/metadata
• SSO URL : https://[votre-smartlink].link.vaultys.org/api/saml2/[appid]/sso
• SLO URL : https://[votre-smartlink].link.vaultys.org/api/saml2/[appid]/slo
• Entity ID : https://[votre-smartlink].link.vaultys.org/[appid]
• Certificat X.509 : Téléchargez depuis SmartLink

Configuration dans Jamespot

1. Accéder aux paramètres SSO

1. Connectez-vous à Jamespot en tant qu'administrateur
2. Allez dans Administration → Paramètres généraux → Authentification
3. Cliquez sur Configuration SSO SAML

2. Configuration du fournisseur d'identité

Configurez les paramètres SAML :

• IdP Entity ID : [appid]
• SSO Login URL : https://[votre-smartlink].link.vaultys.org/api/saml2/[appid]/sso
• SSO Logout URL : https://[votre-smartlink].link.vaultys.org/api/saml2/[appid]/slo
• Certificat public IdP : Collez le certificat X.509 depuis SmartLink
• Binding : HTTP-POST

3. Configuration des attributs

Attribut Jamespot	Attribut SAML	Obligatoire
Email	email	✅
Prénom	givenName	✅
Nom	surname	✅
Nom complet	displayName	❌
Service	department	❌
Fonction	jobTitle	❌
Téléphone	telephoneNumber	❌
Mobile	mobile	❌
Localisation	location	❌

Configuration des espaces et groupes

Structure des espaces

spaces:
  - name: "Espace Corporate"
    type: "organization"
    access: "all_users"
    features:
      - news_feed
      - corporate_directory
      - org_chart
      - announcements
    
  - name: "Espace Projets"
    type: "project"
    access: "members_only"
    features:
      - task_management
      - document_sharing
      - team_calendar
      - wikis
    
  - name: "Espace Innovation"
    type: "community"
    access: "open"
    features:
      - idea_box
      - innovation_challenges
      - polls
      - forums

Synchronisation des groupes

{
  "group_mapping": {
    "smartlink-admins": {
      "jamespot_role": "administrator",
      "permissions": ["manage_platform", "manage_users", "manage_content"]
    },
    "smartlink-managers": {
      "jamespot_role": "space_manager",
      "permissions": ["create_spaces", "manage_members", "moderate_content"]
    },
    "smartlink-employees": {
      "jamespot_role": "contributor",
      "permissions": ["create_content", "participate", "collaborate"]
    },
    "smartlink-external": {
      "jamespot_role": "guest",
      "permissions": ["view_public", "limited_interaction"]
    }
  }
}

Modules et fonctionnalités

Réseau social d'entreprise

social_features:
  wall:
    enabled: true
    moderation: automatic
    content_types:
      - posts
      - articles
      - events
      - polls
      - ideas
  
  interactions:
    likes: true
    comments: true
    shares: true
    mentions: true
    hashtags: true
  
  gamification:
    points: true
    badges: true
    leaderboard: true
    challenges: true

Gestion documentaire

{
  "document_management": {
    "storage_quota": "100GB",
    "version_control": true,
    "co_editing": {
      "enabled": true,
      "office_suite": "onlyoffice"
    },
    "permissions": {
      "folder_level": true,
      "file_level": true,
      "sharing_control": true
    },
    "search": {
      "full_text": true,
      "ocr": true,
      "metadata": true
    }
  }
}

Applications métiers

business_apps:
  - name: "Gestion de projets"
    features:
      - gantt_charts
      - kanban_boards
      - time_tracking
      - resource_planning
  
  - name: "Base de connaissances"
    features:
      - wikis
      - faqs
      - tutorials
      - best_practices
  
  - name: "Innovation"
    features:
      - idea_management
      - innovation_campaigns
      - voting_system
      - roi_tracking

API Jamespot

Client API avec SSO

const axios = require('axios');

class JamespotAPI {
  constructor(config) {
    this.baseUrl = `https://${config.domain}.jamespot.com/api/v3`;
    this.apiKey = config.apiKey;
    this.headers = {
      'Authorization': `Bearer ${this.apiKey}`,
      'Content-Type': 'application/json'
    };
  }
  
  async getUserBySSOEmail(email) {
    const response = await axios.get(`${this.baseUrl}/users`, {
      params: { email },
      headers: this.headers
    });
    return response.data;
  }
  
  async createSpace(spaceData) {
    const response = await axios.post(`${this.baseUrl}/spaces`, {
      name: spaceData.name,
      type: spaceData.type,
      description: spaceData.description,
      members: spaceData.members,
      settings: {
        visibility: spaceData.visibility || 'private',
        moderation: spaceData.moderation || true
      }
    }, { headers: this.headers });
    return response.data;
  }
  
  async publishContent(spaceId, content) {
    const response = await axios.post(`${this.baseUrl}/spaces/${spaceId}/posts`, {
      title: content.title,
      body: content.body,
      type: content.type,
      tags: content.tags,
      attachments: content.attachments
    }, { headers: this.headers });
    return response.data;
  }
}

Webhooks

// Endpoint pour les webhooks Jamespot
app.post('/webhook/jamespot', async (req, res) => {
  const { event, payload } = req.body;
  const signature = req.headers['x-jamespot-signature'];
  
  // Vérifier la signature
  if (!verifySignature(signature, req.body, process.env.JAMESPOT_WEBHOOK_SECRET)) {
    return res.status(401).json({ error: 'Invalid signature' });
  }
  
  switch(event) {
    case 'user.login':
      await trackUserLogin(payload);
      break;
    
    case 'content.created':
      await processNewContent(payload);
      break;
    
    case 'space.member.added':
      await notifyNewMember(payload);
      break;
    
    case 'task.completed':
      await updateProjectStatus(payload);
      break;
  }
  
  res.status(200).json({ received: true });
});

Test de la configuration

1. Test de connexion

1. Déconnectez-vous de Jamespot
2. Allez sur https://[votre-organisation].jamespot.com
3. Cliquez sur Se connecter avec SSO
4. Authentifiez-vous via SmartLink
5. Vérifiez l'accès à vos espaces

2. Test API

# Récupérer les informations utilisateur
curl -X GET "https://[votre-organisation].jamespot.com/api/v3/me" \
  -H "Authorization: Bearer YOUR_API_KEY"

3. Test mobile

Applications Jamespot disponibles :

• Jamespot Mobile (iOS/Android)
• Support complet du SSO
• Notifications push

Dépannage

Erreur "SAML response is not valid"

Problème : La réponse SAML est rejetée

Solution :

1. Vérifiez que l'Entity ID est [appid]
2. Vérifiez le certificat X.509 (format PEM)
3. Assurez-vous que l'ACS URL est correcte
4. Consultez les logs : Administration → Logs système

Les groupes ne sont pas synchronisés

Problème : Les rôles Jamespot ne correspondent pas aux groupes SmartLink

Solution :

<!-- Assertion SAML pour les groupes -->
<saml:Attribute Name="memberOf">
  <saml:AttributeValue>CN=jamespot-admins,OU=Groups,DC=exemple,DC=com</saml:AttributeValue>
  <saml:AttributeValue>CN=jamespot-users,OU=Groups,DC=exemple,DC=com</saml:AttributeValue>
</saml:Attribute>

Problème de session

Problème : La session expire trop rapidement

Solution :

1. Augmentez la durée de session dans Jamespot
2. Vérifiez la configuration de session dans SmartLink
3. Alignez les paramètres de timeout des deux côtés

Sécurité

Configuration recommandée

{
  "security_settings": {
    "enforce_sso": true,
    "session_timeout": "8h",
    "concurrent_sessions": false,
    "ip_restrictions": {
      "enabled": false,
      "whitelist": []
    },
    "content_security": {
      "moderation": "ai_assisted",
      "dlp": true,
      "watermarking": false
    },
    "audit": {
      "enabled": true,
      "retention": "2y",
      "export_format": "csv"
    }
  }
}

Conformité RGPD

Jamespot est conforme RGPD avec :

• Hébergement des données en France
• Droit à l'effacement
• Portabilité des données
• Registre des traitements
• DPO désigné

Migration des utilisateurs

Script de migration

import csv
import requests
from datetime import datetime

class JamespotMigration:
    def __init__(self, domain, api_key):
        self.domain = domain
        self.api_key = api_key
        self.base_url = f"https://{domain}.jamespot.com/api/v3"
        
    def migrate_to_sso(self, users_csv):
        """Migre les utilisateurs vers SSO"""
        results = []
        
        with open(users_csv, 'r', encoding='utf-8') as file:
            reader = csv.DictReader(file)
            
            for user in reader:
                try:
                    # Activer SSO pour l'utilisateur
                    response = requests.patch(
                        f"{self.base_url}/users/{user['id']}",
                        headers={'Authorization': f'Bearer {self.api_key}'},
                        json={
                            'authentication_method': 'sso',
                            'sso_email': user['email']
                        }
                    )
                    
                    if response.status_code == 200:
                        results.append({
                            'email': user['email'],
                            'status': 'success',
                            'timestamp': datetime.now()
                        })
                        
                        # Envoyer email de notification
                        self.send_notification(user['email'])
                    else:
                        results.append({
                            'email': user['email'],
                            'status': 'failed',
                            'error': response.text
                        })
                        
                except Exception as e:
                    results.append({
                        'email': user['email'],
                        'status': 'error',
                        'error': str(e)
                    })
        
        return results
    
    def send_notification(self, email):
        """Envoie un email de notification pour la migration SSO"""
        # Implémenter l'envoi d'email
        pass

Ressources

• Documentation Jamespot
• API Jamespot
• Support Jamespot
• Configuration SAML SmartLink
• Blog Jamespot