Activation du traitement de documents avec Azure Cognitive Services

2025-03-06

Utilisation d’Azure Cognitive Services

Azure Cognitive Services est un ensemble d’API cloud que vous pouvez utiliser dans les applications IA et les flux de données. Il fournit des modèles préentraînés qui sont prêts à être utilisés dans vos applications, sans aucune donnée ni formation de modèle de votre part. Elles peuvent être facilement intégrées aux applications via des interfaces REST HTTP.

Vous avez déjà appris à utiliser des webhooks avec l’application pour recevoir une notification chaque fois qu’un fichier existant est mis à jour ou qu’un nouveau fichier est chargé dans le didacticiel Utilisation de Webhooks. Ce tutoriel traite de sa connexion à Azure Cognitive Services pour extraire des données de factures.

Pour configurer le traitement automatique de l’IA avec votre application SharePoint actuelle lors d’une modification dans votre conteneur, vous devez suivre Utilisation de webhooks , puis :

Obtenez les modifications delta du conteneur. Vous pouvez actuellement recevoir la notification chaque fois qu’il y a une modification dans notre conteneur et obtenir les fichiers qui sont ajoutés ou mis à jour.
Appelez l’API du service Document Intelligence d’Azure Cognitive Services. Vous devez créer une ressource Azure AI pour utiliser l’API afin d’extraire les champs d’une image et d’obtenir les fichiers extraits. Vous pouvez les stocker comme indiqué dans ce tutoriel ou les traiter comme vous le souhaitez.

Conseil

Pour en savoir plus sur les API Microsoft Graph utilisées dans ce tutoriel, consultez Suivre les modifications apportées à un lecteur, Obtenir une ressource DriveItem et Charger ou remplacer le contenu d’un élément DriveItem.

Obtenir les modifications delta d’un conteneur

Ouvrez GraphProvider.ts et implémentez la méthode getDriveChanges pour obtenir la liste des éléments modifiés :

public static async getDriveChanges(driveId: string): Promise<any[]> {
  let changedItems: any[] = [];
  const driveDeltaBasePath: string = `/drives/${driveId}/items/root/delta`;
  let driveDeltaTokenParams: string = "";
  let hasMoreChanges: boolean = true;
  try{
    do {
      if (this.changeTokens.has(driveId)) {
        driveDeltaTokenParams = `?token=${this.changeTokens.get(driveId)}`
      }
      const response = await this.graphClient.api(driveDeltaBasePath + driveDeltaTokenParams).get();
      changedItems.push(...response.value);
      if (response['@odata.nextLink']) {
        const token = new URL(response['@odata.nextLink']).searchParams.get('token');
        this.changeTokens.set(driveId, token);
      } else {
        hasMoreChanges = false;
        const token = new URL(response['@odata.deltaLink']).searchParams.get('token');
        this.changeTokens.set(driveId, token);
      }
      console.log(this.changeTokens.get(driveId));
    } while (hasMoreChanges);
  }
  catch(err){
    console.log(err);
  }
  return changedItems;
}

Implémentez la méthode getDriveItem pour extraire un fichier d’un conteneur :

public static async getDriveItem(driveId: string, itemId: string): Promise<any> {
  return await this.graphClient.api(`/drives/${driveId}/items/${itemId}`).get();
}

Créez un fichier ReceiptProcessor.ts et implémentez une méthode processDrive:

export abstract class ReceiptProcessor {

  public static async processDrive(driveId: string): Promise<void> {
    const changedItems = await GraphProvider.getDriveChanges(driveId);
    for (const changedItem of changedItems) {
      try {
        const item = await GraphProvider.getDriveItem(driveId, changedItem.id);
        const extension = this.getFileExtension(item.name);
        if (this.SUPPORTED_FILE_EXTENSIONS.includes(extension.toLowerCase())) {
          console.log(item.name);
          const url = item["@microsoft.graph.downloadUrl"];
          const receipt = await this.analyzeReceiptStream(await this.getDriveItemStream(url));
          const receiptString = JSON.stringify(receipt, null, 2)
          const fileName = this.getFileDisplayName(item.name) + "-extracted-fields.json";
          const parentId = item.parentReference.id;
          await GraphProvider.addDriveItem(driveId, parentId, fileName, receiptString);
        }
      } catch (error) {
        console.log(error);
      }
    }
  }
}

À ce stade, si vous redémarrez l’application avec le tunneling et l’abonnement, vous devez voir les fichiers récemment ajoutés/mis à jour répertoriés dans la console.

Appeler l’API du service Document Intelligence d’Azure Cognitive Services

Pour utiliser les API Document Intelligence d’Azure Cognitive Services, vous devez créer une ressource multiservice ou Document Intelligence pour Azure AI Service. Reportez-vous aux didacticiels suivants pour créer la ressource :

Après cette étape, vous devez disposer d’un point de terminaison et d’une clé prête à l’emploi.

Ouvrez maintenant ReceiptProcessor.ts pour créer une méthode dac pour stocker les informations d’identification Azure Cognitive Services :

private static dac = new DocumentAnalysisClient(
  `${process.env["DAC_RESOURCE_ENDPOINT"]}`,
  new AzureKeyCredential(`${process.env["DAC_RESOURCE_KEY"]}`)
);

Create, méthode getDriveItemStream.

private static async getDriveItemStream(url: string): Promise<Readable> {
  const token = GraphProvider.graphAccessToken;
  const config: AxiosRequestConfig = {
    method: "get",
    url: url,
    headers: {
      "Authorization": `Bearer ${token}`
    },
    responseType: 'stream'
  };
  const response = await axios.get<Readable>(url, config);
  return response.data;
}

Créez une méthode analyzeReceiptStream pour obtenir les champs OCR via le traitement Azure Cognitive Services. Ici, nous prenons le prebuilt-invoice modèle, mais d’autres modèles peuvent être choisis :

private static async analyzeReceiptStream(stream: Readable): Promise<any> {
  const poller = await this.dac.beginAnalyzeDocument("prebuilt-invoice", stream, {
    onProgress: ({ status }) => {
      console.log(`status: ${status}`);
    },
  });

  const {
    documents: [result] = [],
  } = await poller.pollUntilDone();

  const fields = result?.fields;
  this.removeUnwantedFields(fields);
  return fields;
}

Créez une méthode removeUnwantedFields pour supprimer les champs indésirables dans la réponse d’Azure Cognitive Services :

private static removeUnwantedFields(fields: any) {
  for (const prop in fields) {
    if (prop === 'boundingRegions' || prop === 'content' || prop === 'spans') {
      delete fields[prop];
    }
    if (typeof fields[prop] === 'object') {
      this.removeUnwantedFields(fields[prop]);
    }
  }
}

Enfin, ouvrez GraphProvider.ts pour ajouter la addDriveItem méthode à la fin de la GraphProvider classe.

public static async addDriveItem(driveId: string, parentId: any, fileName: string, receiptString: string) {
  await this.graphClient.api(`/drives/${driveId}/items/${parentId}:/${fileName}:/content`).put(receiptString);
}

À présent, redémarrez l’application de démonstration et configurez à nouveau le tunneling à l’aide de ngrok et de l’abonnement delta change sur le conteneur.

Si vous ajoutez/mettez à jour un fichier (formats pris en charge : JPEG, JPG, PNG, BMP, TIFF, PDF) dans ce conteneur, vous devez voir un nouveau fichier JSON créé et contenant les champs extraits du fichier.

Partager via

Activation du traitement de documents avec Azure Cognitive Services

Utilisation d’Azure Cognitive Services

Obtenir les modifications delta d’un conteneur

Appeler l’API du service Document Intelligence d’Azure Cognitive Services

Ressources supplémentaires