Initial

assets/js/admin.js

@@ -0,0 +1,171 @@
+document.addEventListener('DOMContentLoaded', function() {
+    // Initialize Sortable for rule containers
+    document.querySelectorAll('.lcp-rules-container').forEach(container => {
+        new Sortable(container, {
+            handle: '.dashicons-menu',
+            animation: 150
+        });
+    });
+
+    // Add new rule
+    document.addEventListener('click', function(e) {
+        if (e.target.matches('.add-rule')) {
+            const postType = e.target.dataset.postType;
+            const template = document.querySelector('.lcp-rule-template').innerHTML;
+            const container = e.target.closest('.lcp-post-type-rules').querySelector('.lcp-rules-container');
+            container.insertAdjacentHTML('beforeend', template);
+        }
+    });
+
+    // Delete rule
+    document.addEventListener('click', function(e) {
+        // Check if the click was on the delete button or its child icon
+        if (e.target.matches('.delete-rule') || e.target.closest('.delete-rule')) {
+            const ruleElement = e.target.closest('.lcp-rule');
+            if (ruleElement) {
+                ruleElement.remove();
+            }
+        }
+    });
+
+    // Update taxonomy and terms fields visibility
+    document.addEventListener('change', function(e) {
+        if (e.target.matches('.rule-value-type')) {
+            const ruleBody = e.target.closest('.rule-body');
+            if (!ruleBody) return; // Exit if rule-body not found
+
+            const taxonomySelect = ruleBody.querySelector('.rule-taxonomy');
+            const termSelect = ruleBody.querySelector('.rule-term');
+            
+            if (!taxonomySelect || !termSelect) return; // Exit if selects not found
+
+            if (e.target.value === 'taxonomy') {
+                taxonomySelect.style.display = 'inline-block';
+                termSelect.style.display = 'inline-block';
+            } else {
+                taxonomySelect.style.display = 'none';
+                termSelect.style.display = 'none';
+            }
+        }
+    });
+
+    // Update terms when taxonomy changes
+    document.addEventListener('change', function(e) {
+        if (e.target.matches('.rule-taxonomy')) {
+            const termSelect = e.target.nextElementSibling;
+            if (!termSelect) return; // Exit if term select not found
+
+            const taxonomy = e.target.value;
+
+            fetch(lcpPaywall.ajaxurl, {
+                method: 'POST',
+                headers: {
+                    'Content-Type': 'application/x-www-form-urlencoded',
+                },
+                body: new URLSearchParams({
+                    action: 'lcp_get_taxonomy_terms',
+                    nonce: lcpPaywall.nonce,
+                    taxonomy: taxonomy
+                })
+            })
+            .then(response => response.json())
+            .then(data => {
+                if (data.success) {
+                    termSelect.innerHTML = '';
+                    data.data.forEach(term => {
+                        const option = document.createElement('option');
+                        option.value = term.term_id;
+                        option.textContent = term.name;
+                        termSelect.appendChild(option);
+                    });
+                }
+            });
+        }
+    });
+
+    // Save individual post type rules
+    document.addEventListener('click', function(e) {
+        if (e.target.matches('.save-post-type-rules')) {
+            const postTypeSection = e.target.closest('.lcp-post-type-rules');
+            const postType = postTypeSection.dataset.postType;
+            
+            const rules = {
+                [postType]: {
+                    settings: {
+                        default_lock_status: postTypeSection.querySelector('.default-lock-status').value,
+                        is_metered: postTypeSection.querySelector('.is-metered').checked,
+                        metered_free_posts: parseInt(postTypeSection.querySelector('.metered-free-posts').value),
+                        metered_interval: parseInt(postTypeSection.querySelector('.metered-interval').value)
+                    },
+                    rules: []
+                }
+            };
+
+            postTypeSection.querySelectorAll('.lcp-rule').forEach(ruleElement => {
+                const rule = {
+                    action: ruleElement.querySelector('.rule-action').value,
+                    condition: ruleElement.querySelector('.rule-condition').value,
+                    operator: ruleElement.querySelector('.rule-operator').value,
+                    value_type: ruleElement.querySelector('.rule-value-type').value,
+                    taxonomy: ruleElement.querySelector('.rule-taxonomy')?.value || '',
+                    term: ruleElement.querySelector('.rule-term')?.value || ''
+                };
+                rules[postType].rules.push(rule);
+            });
+
+            fetch(lcpPaywall.ajaxurl, {
+                method: 'POST',
+                headers: {
+                    'Content-Type': 'application/x-www-form-urlencoded',
+                },
+                body: new URLSearchParams({
+                    action: 'lcp_save_rules',
+                    nonce: lcpPaywall.nonce,
+                    rules: JSON.stringify(rules)
+                })
+            })
+            .then(response => response.json())
+            .then(data => {
+                if (data.success) {
+                    alert(`Rules for ${postType} saved successfully!`);
+                } else {
+                    alert(`Failed to save rules for ${postType}. Please try again.`);
+                }
+            })
+            .catch(() => {
+                alert(`Failed to save rules for ${postType}. Please try again.`);
+            });
+        }
+    });
+
+    // Save settings
+    document.addEventListener('click', function(e) {
+        if (e.target.matches('#save-settings')) {
+            // Get the content from the WordPress editor
+            const content = wp.editor.getContent('lcp_nag_message');
+
+            fetch(lcpPaywall.ajaxurl, {
+                method: 'POST',
+                headers: {
+                    'Content-Type': 'application/x-www-form-urlencoded',
+                },
+                body: new URLSearchParams({
+                    action: 'lcp_save_settings',
+                    nonce: lcpPaywall.nonce,
+                    nag_message: content
+                })
+            })
+            .then(response => response.json())
+            .then(data => {
+                if (data.success) {
+                    alert('Settings saved successfully!');
+                } else {
+                    alert('Failed to save settings. Please try again.');
+                }
+            })
+            .catch(() => {
+                alert('Failed to save settings. Please try again.');
+            });
+        }
+    });
+});