Preserve untouched example domains from query params

src/nginxconfig/templates/global_sections/security.vue

@@ -151,7 +151,7 @@ limitations under the License.
         computed: {
             ...computedFromDefaults(defaults, 'security'),          // Getters & setters for the delegated data
             hasWordPress() {
-                return this.$parent.$parent.$data.domains.some(d => d.php.wordPressRules.computed);
+                return this.$parent.$parent.$data.domains.some(d => d && d.php.wordPressRules.computed);
             },
             hasUnsafeEval() {
                 return this.$props.data.contentSecurityPolicy.computed.includes('\'unsafe-eval\'');

src/nginxconfig/util/backwards_compatibility.js

@@ -121,8 +121,8 @@ export default data => {
         // If not a global setting and if this is an integer
         // Then, this is probably an old domain, so we'll try to convert it as such
         if (!isNaN(parseInt(key))) {
-            data.domains = data.domains || [];
-            data.domains.push(data[key]);
+            data.domains = isObject(data.domains) ? data.domains : {};
+            data.domains[key] = data[key];
         }
     }
 
@@ -130,35 +130,35 @@ export default data => {
     data.global = {...(data.global || {}), ...mappedGlobal};
 
     // Handle converting domain settings
-    if ('domains' in data && (Array.isArray(data.domains) || isObject(data.domains))) {
-        // Ensure we're working with an array
-        const values = isObject(data.domains) ? Object.values(data.domains) : data.domains;
+    if ('domains' in data && isObject(data.domains)) {
+        for (const key in data.domains) {
+            // Don't include inherited props
+            if (!Object.prototype.hasOwnProperty.call(data.domains, key)) continue;
 
-        for (let i = 0; i < values.length; i++) {
             // Check this is an object
-            if (!isObject(values[i])) continue;
+            if (!isObject(data.domains[key])) continue;
 
             // Hold any mapped data
             const mappedData = {};
 
             // Handle converting old domain settings to new ones
-            for (const key in values[i]) {
-                if (!Object.prototype.hasOwnProperty.call(values[i], key)) continue;
-                if (isObject(values[i][key])) continue;
+            for (const key2 in data.domains[key]) {
+                // Don't include inherited props
+                if (!Object.prototype.hasOwnProperty.call(data.domains[key], key2)) continue;
+
+                // Don't convert objects
+                if (isObject(data.domains[key][key2])) continue;
 
                 // Map old settings to their new ones
-                if (key in domainMap) {
-                    const map = domainMap[key];
+                if (key2 in domainMap) {
+                    const map = domainMap[key2];
                     mappedData[map[0]] = mappedData[map[0]] || {};
-                    mappedData[map[0]][map[1]] = map.length < 3 ? values[i][key] : map[2](values[i][key]);
+                    mappedData[map[0]][map[1]] = map.length < 3 ? data.domains[key][key2] : map[2](data.domains[key][key2]);
                 }
             }
 
             // Overwrite mapped properties
-            values[i] = {...values[i], ...mappedData};
+            data.domains[key] = {...data.domains[key], ...mappedData};
         }
-
-        // Store the updated domain data
-        data.domains = values;
     }
 };

src/nginxconfig/util/import_data.js

@@ -54,6 +54,7 @@ export default (query, domains, global, nextTick) => {
     const data = qs.parse(query, {
         ignoreQueryPrefix: true,
         allowDots: true,
+        parseArrays: false,
         decoder(value) {
             value = decodeURIComponent(value);
 
@@ -78,25 +79,23 @@ export default (query, domains, global, nextTick) => {
     backwardsCompatibility(data);
 
     // Handle domains
-    if ('domains' in data) {
-        // Check its an array or object
-        if (Array.isArray(data.domains) || isObject(data.domains)) {
-            // Ensure we're working with an array
-            const values = isObject(data.domains) ? Object.values(data.domains) : data.domains;
-
-            // Work through each potential domain
-            for (const domainData of values) {
-                // Check this is an object
-                if (!isObject(domainData)) continue;
-
-                // Create a new domain (assume it has had custom user settings)
-                const domainImported = clone(Domain.delegated);
-                domainImported.hasUserInteraction = true;
-                domains.push(domainImported);
-
-                // Apply the initial values on the next Vue tick, once the watchers are ready
-                nextTick(() => applyCategories(domainData, domainImported));
+    if ('domains' in data && isObject(data.domains)) {
+        // Work through all valid integer keys in the object
+        const keys = Object.keys(data.domains).map(x => parseInt(x)).filter(x => !isNaN(x));
+        for (let i = 0; i < Math.max(...keys) + 1; i++) {
+            // If the key doesn't exist or this isn't a valid object, assume it was an untouched example domain
+            if (!keys.includes(i) || !isObject(data.domains[i])) {
+                domains.push(clone(Domain.delegated));
+                continue;
             }
+
+            // Create a new domain (assume it has had custom user settings)
+            const domainImported = clone(Domain.delegated);
+            domainImported.hasUserInteraction = true;
+            domains.push(domainImported);
+
+            // Apply the initial values on the next Vue tick, once the watchers are ready
+            nextTick(() => applyCategories(data.domains[i], domainImported));
         }
     } else {
         // If no configured domains, add a single default