यहां एक ब्लॉग पोस्ट है जिसमें आपके द्वारा प्रदान की गई स्क्रिप्ट शामिल है:

फ्रैपे का उपयोग करके व्हाट्सएप संदेशों को बैचों में हटाना

किसी भी सिस्टम में बड़ी मात्रा में डेटा को प्रबंधित करना चुनौतीपूर्ण हो सकता है, खासकर जब रिकॉर्ड को कुशलतापूर्वक हटाने की बात आती है। फ्रैपे में, हम सर्वर पर ओवरलोडिंग से बचने के लिए सूची दृश्य को अनुकूलित करके और बैचों में रिकॉर्ड हटाकर इस परिदृश्य को संभाल सकते हैं।

इस पोस्ट में, हम यह पता लगाएंगे कि फ्रैपे के भीतर कस्टम कोड का उपयोग करके "व्हाट्सएप संदेश" दस्तावेज़ों का बैच विलोपन कैसे सेट किया जाए।

बैच विलोपन क्यों?

हजारों या अधिक रिकॉर्ड के साथ काम करते समय, उन सभी को एक साथ हटाने का प्रयास आपके सर्वर पर दबाव डाल सकता है, जिससे टाइमआउट या धीमा प्रदर्शन हो सकता है। बैच प्रोसेसिंग हमें कार्य को छोटे, प्रबंधनीय भागों में विभाजित करने, सर्वर पर लोड को कम करने और एक सहज उपयोगकर्ता अनुभव सुनिश्चित करने की अनुमति देती है।

सूची दृश्य को अनुकूलित करना

सबसे पहले, हम बैच हटाने के लिए एक बटन जोड़ने के लिए "व्हाट्सएप संदेश" सिद्धांत के सूची दृश्य को संशोधित करेंगे। यह बटन बैचों में सभी व्हाट्सएप संदेशों को हटाने की प्रक्रिया को ट्रिगर करेगा।

सूची दृश्य को अनुकूलित करने के लिए यहां कोड है:

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();
                 }
             );
         });
    }
};

कोड का टिप्पणी वाला भाग सूची दृश्य में "सभी दस्तावेज़ हटाएं" लेबल वाला एक बटन जोड़ता है। एक बार क्लिक करने पर, यह उपयोगकर्ता को हटाने की प्रक्रिया शुरू करने से पहले पुष्टि के लिए संकेत देता है। आप अपने परिवेश में बटन को सक्षम करने के लिए कोड के इस भाग पर टिप्पणी हटा सकते हैं।

बैच विलोपन फ़ंक्शन

इस प्रक्रिया का मूल delete_in_batches फ़ंक्शन है। यह फ़ंक्शन दस्तावेज़ों का एक बैच लाता है, उन्हें एक-एक करके हटाता है, और फिर देरी से अगले बैच की ओर बढ़ता है, यह सुनिश्चित करते हुए कि सर्वर अभिभूत नहीं है।

बैच हटाने के लिए पूरा कोड यहां दिया गया है:

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
            }
        }
    });
}

यह काम किस प्रकार करता है:

1. दस्तावेज़ लाया जा रहा है:
   
   फ़ंक्शन व्हाट्सएप संदेश दस्तावेज़ों के एक बैच को लाने से शुरू होता है, बैच के आकार को बैच_साइज़ पैरामीटर द्वारा नियंत्रित किया जाता है (डिफ़ॉल्ट 2000 है)।

2. दस्तावेज़ हटाना:
   
   लाए गए प्रत्येक दस्तावेज़ के लिए, स्क्रिप्ट दस्तावेज़ को हटाने के लिए frappe.client.delete विधि को कॉल करती है। प्रत्येक सफल विलोपन के बाद, उपयोगकर्ता को एक अधिसूचना दिखाई जाती है।

3. पुनरावर्ती बैचिंग:
   
   एक बार एक बैच संसाधित हो जाने पर, फ़ंक्शन अगले बैच को लाने और हटाने से पहले 2 सेकंड के लिए रुक जाता है। यह विलंब सर्वर ओवरलोड को रोकने में मदद करता है।

4. समापन:
   
   जब हटाने के लिए कोई और दस्तावेज़ नहीं होता है, तो उपयोगकर्ता को एक संदेश प्रदर्शित किया जाता है, और परिवर्तनों को प्रतिबिंबित करने के लिए सूची दृश्य ताज़ा किया जाता है।

निष्कर्ष:

यह स्क्रिप्ट फ्रैपे में बड़ी मात्रा में डेटा को बैच-डिलीट करने के लिए एक सरल लेकिन प्रभावी समाधान है। हटाने की प्रक्रिया को छोटे, प्रबंधनीय बैचों में तोड़कर, हम सर्वर पर ओवरलोडिंग से बचते हैं और यह सुनिश्चित करते हैं कि ऑपरेशन सुचारू रूप से चले। आप डेटा की मात्रा और सर्वर क्षमता के आधार पर, अपनी आवश्यकताओं के अनुरूप बैच आकार और विलंब को संशोधित कर सकते हैं।

व्हाट्सएप संदेशों या किसी अन्य दस्तावेज़ प्रकार को हटाने को सुव्यवस्थित करने के लिए इस स्क्रिप्ट को अपने फ्रैपे एप्लिकेशन में एकीकृत करने के लिए स्वतंत्र महसूस करें।

क्लाइंट स्क्रिप्ट लिखने के बाद इस लॉजिक को सर्वर स्क्रिप्ट में लिखें, सेवर स्क्रिप्ट टाइप एपीआई में चुनें और इस कोड को स्क्रिप्ट में लिखें

यहां कोड के साथ कोड का विस्तृत विवरण दिया गया है:

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."

कोड ब्रेकडाउन:

1. आयात फ्रैपे: यह फ्रैपे मॉड्यूल को आयात करता है, जो फ्रैपे ढांचे का मूल है, जो आपको डेटाबेस और सर्वर कार्यात्मकताओं तक पहुंचने की अनुमति देता है।

2. @frappe.whitelist(): यह डेकोरेटर फ़ंक्शन delete_all_docs को फ्रैपे के एपीआई के माध्यम से पहुंच योग्य और बाहरी अनुप्रयोगों या स्क्रिप्ट से कॉल करने योग्य बनाता है।

3. def delete_all_docs(doctype):: फ़ंक्शन को एक पैरामीटर स्वीकार करने के लिए परिभाषित किया गया है:

   • doctype: दस्तावेज़ का प्रकार (उदाहरण के लिए, "कर्मचारी", "ग्राहक") जिससे सभी रिकॉर्ड हटा दिए जाएंगे।

4. docs = frappe.get_all(doctype): यह निर्दिष्ट doctype के सभी दस्तावेज़ लाता है और उन्हें दस्तावेज़ चर में संग्रहीत करता है। लौटाए गए प्रत्येक दस्तावेज़ में दस्तावेज़ का नाम शामिल होगा, जिसका उपयोग हटाने के लिए किया जाता है।

5. docs में doc के लिए:: फ़ंक्शन सूची docs में प्रत्येक दस्तावेज़ के माध्यम से लूप करता है।

6. frappe.delete_doc(doctype, doc.name, Force=1): लूप के अंदर, प्रत्येक दस्तावेज़ को doctype और doc.name निर्दिष्ट करके हटा दिया जाता है। Force=1 तर्क यह सुनिश्चित करता है कि दस्तावेज़ को बलपूर्वक हटा दिया गया है, यदि आवश्यक हो तो सत्यापन नियमों और जाँचों को दरकिनार कर दिया जाए।

7. frappe.db.commit(): एक बार सभी दस्तावेज़ हटा दिए जाने के बाद, डेटाबेस में परिवर्तन किए जाते हैं, जिससे विलोपन स्थायी हो जाता है।

8. रिटर्न f"{doctype} से सभी दस्तावेज़ हटा दिए गए हैं।": सभी दस्तावेज़ हटा दिए जाने के बाद, एक सफलता संदेश लौटाया जाता है, जो दर्शाता है कि ऑपरेशन सफल रहा।

यह फ़ंक्शन तब उपयोगी होता है जब आपको फ्रैपे एप्लिकेशन में किसी विशेष सिद्धांत से सभी दस्तावेज़ों को हटाने की आवश्यकता होती है।