Voici un article de blog qui intègre le script que vous avez fourni :

Supprimer des messages WhatsApp par lots à l'aide de Frappe

Gérer de grandes quantités de données dans n'importe quel système peut s'avérer difficile, en particulier lorsqu'il s'agit de supprimer efficacement des enregistrements. Dans Frappe, nous pouvons gérer ce scénario en personnalisant la vue de liste et en supprimant les enregistrements par lots pour éviter de surcharger le serveur.

Dans cet article, nous explorerons comment configurer la suppression par lots de documents « Message WhatsApp » à l'aide d'un code personnalisé dans Frappe.

Pourquoi la suppression par lots ?

Lorsque vous traitez des milliers d'enregistrements ou plus, essayer de les supprimer tous en même temps peut surcharger votre serveur, provoquant des délais d'attente ou un ralentissement des performances. Le traitement par lots nous permet de diviser la tâche en morceaux plus petits et gérables, réduisant ainsi la charge sur le serveur et garantissant une expérience utilisateur plus fluide.

Personnalisation de la vue Liste

Tout d'abord, nous allons modifier la vue liste du doctype "Message WhatsApp" pour ajouter un bouton de suppression par lots. Ce bouton déclenchera le processus de suppression de tous les messages WhatsApp par lots.

Voici le code pour personnaliser la vue liste :

frappe.listview_settings['WhatsApp Message'] = {
    onload: function(listview) {
        // Add a custom button in the list view
        // Uncomment this section to enable the button
         listview.page.add_inner_button(__('Delete All Docs'), function() {
            // Confirm before proceeding with the deletion
             frappe.confirm(
                 'Are you sure you want to delete all Whatsapp messages?',
                 function() {
                     Start the batch deletion process
                     delete_in_batches();
                 }
             );
         });
    }
};

La partie commentée du code ajoute un bouton intitulé "Supprimer tous les documents" à la vue liste. Une fois cliqué, il demande à l’utilisateur une confirmation avant de démarrer le processus de suppression. Vous pouvez décommenter cette partie du code pour activer le bouton dans votre environnement.

La fonction de suppression par lots

Le cœur de ce processus est la fonction delete_in_batches. Cette fonction récupère un lot de documents, les supprime un par un, puis passe au lot suivant avec un certain délai, garantissant que le serveur n'est pas submergé.

Voici le code complet pour la suppression par lots :

function delete_in_batches(batch_size = 2000) {
    // Step 1: Fetch a batch of documents to be deleted
    frappe.call({
        method: "frappe.client.get_list",
        args: {
            doctype: "WhatsApp Message",  // Your target doctype
            fields: ["name"],  // Fetch only the 'name' field (docnames)
            limit: batch_size  // Process in batches of 2000
        },
        callback: function(response) {
            let docs = response.message;

            if (docs && docs.length > 0) {
                // Step 2: Loop through each document in the batch and delete it
                docs.forEach(function(doc, index) {
                    frappe.call({
                        method: "frappe.client.delete",
                        args: {
                            doctype: "WhatsApp Message",  // Ensure this is correct
                            name: doc.name
                        },
                        callback: function(r) {
                            if (!r.exc) {
                                frappe.show_alert({
                                    message: `Document ${doc.name} deleted`,
                                    indicator: 'green'
                                });
                            }
                        }
                    });
                });

                // Step 3: Delay the next batch to prevent server overload
                setTimeout(function() {
                    delete_in_batches(batch_size);  // Recursive call to delete the next batch
                }, 2000);  // 2-second delay between batches
            } else {
                // No more documents to delete
                frappe.msgprint("All WhatsApp messages have been deleted.");
                frappe.listview.refresh();  // Refresh the list view once the process completes
            }
        }
    });
}

Comment ça marche :

1. Récupération de documents :
   
   La fonction commence par récupérer un lot de documents de message WhatsApp, la taille du lot étant contrôlée par le paramètre batch_size (la valeur par défaut est 2000).

2. Suppression de documents :
   
   Pour chaque document récupéré, le script appelle la méthode frappe.client.delete pour supprimer le document. Après chaque suppression réussie, une notification est affichée à l'utilisateur.

3. Mise en lots récursive :
   
   Une fois qu'un lot est traité, la fonction fait une pause de 2 secondes avant de récupérer et de supprimer le lot suivant. Ce délai permet d'éviter la surcharge du serveur.

4. Achèvement:
   
   Lorsqu'il n'y a plus de documents à supprimer, un message s'affiche à l'intention de l'utilisateur et la vue de liste est actualisée pour refléter les modifications.

Conclusion:

Ce script est une solution simple mais efficace pour supprimer par lots de grandes quantités de données dans Frappe. En divisant le processus de suppression en lots plus petits et gérables, nous évitons de surcharger le serveur et garantissons le bon déroulement de l'opération. Vous pouvez modifier la taille et le délai du lot en fonction de vos besoins, en fonction du volume de données et de la capacité du serveur.

N'hésitez pas à intégrer ce script dans votre propre application Frappe pour rationaliser la suppression des messages WhatsApp ou tout autre type de document.

Après avoir écrit le script client, écrivez cette logique dans le script du serveur, sélectionnez dans l'API du type de script de serveur et écrivez ce code dans le script

Voici une explication détaillée du code avec le code lui-même inclus :

import frappe

@frappe.whitelist()
def delete_all_docs(doctype):
    # Get all documents of the specified doctype
    docs = frappe.get_all(doctype)

    # Loop through each document in the list
    for doc in docs:
        # Delete the document using its name and the provided doctype
        frappe.delete_doc(doctype, doc.name, force=1)

    # Commit the changes to the database to make deletions permanent
    frappe.db.commit()

    # Return a confirmation message
    return f"All documents from {doctype} have been deleted."

Répartition du code :

1. import frappe : Ceci importe le module frappe, qui est le cœur du framework Frappe, vous permettant d'accéder aux fonctionnalités de la base de données et du serveur.

2. @frappe.whitelist() : Ce décorateur permet à la fonction delete_all_docs d'être accessible via l'API de Frappe et appelable depuis des applications ou des scripts externes.

3. def delete_all_docs(doctype): : La fonction est définie pour accepter un paramètre :

   • doctype : le type de document (par exemple, "Employé", "Client") à partir duquel tous les enregistrements seront supprimés.

4. docs = frappe.get_all(doctype) : ceci récupère tous les documents du type de document spécifié et les stocke dans la variable docs. Chaque document renvoyé comprendra le nom du document, qui est utilisé pour la suppression.

5. for doc in docs : : la fonction parcourt chaque document de la liste docs.

6. frappe.delete_doc(doctype, doc.name, force=1) : A l'intérieur de la boucle, chaque document est supprimé en précisant le doctype et le doc.name. L'argument force=1 garantit que le document est supprimé de force, en contournant les règles de validation et les vérifications si nécessaire.

7. frappe.db.commit() : Une fois tous les documents supprimés, les modifications de la base de données sont validées, rendant les suppressions permanentes.

8. return f"Tous les documents de {doctype} ont été supprimés." : une fois tous les documents supprimés, un message de réussite est renvoyé, indiquant que l'opération a réussi.

Cette fonction est utile lorsque vous devez supprimer tous les documents d'un doctype particulier dans une application Frappe.