Apply prettier 💄 (#80)

* Apply prettier

* applied prettier for similar-topics-validator

Co-authored-by: Faizaan Gagan <fzngagan@gmail.com>

assets/javascripts/discourse/components/custom-field-input.js.es6

@@ -2,118 +2,127 @@ import Component from "@ember/component";
 import discourseComputed, { observes } from "discourse-common/utils/decorators";
 import { or, alias } from "@ember/object/computed";
 
-const generateContent = function(array, type) {
+const generateContent = function (array, type) {
-  return array.map(key => ({
+  return array.map((key) => ({
     id: key,
-    name: I18n.t(`admin.wizard.custom_field.${type}.${key}`)
+    name: I18n.t(`admin.wizard.custom_field.${type}.${key}`),
   }));
-}
+};
 
 export default Component.extend({
-  tagName: 'tr',
+  tagName: "tr",
-  topicSerializers: ['topic_view', 'topic_list_item'],
+  topicSerializers: ["topic_view", "topic_list_item"],
-  postSerializers: ['post'],
+  postSerializers: ["post"],
-  groupSerializers: ['basic_group'],
+  groupSerializers: ["basic_group"],
-  categorySerializers: ['basic_category'],
+  categorySerializers: ["basic_category"],
-  klassContent: generateContent(['topic', 'post', 'group', 'category'], 'klass'),
+  klassContent: generateContent(
-  typeContent: generateContent(['string', 'boolean', 'integer', 'json'], 'type'),
+    ["topic", "post", "group", "category"],
-  showInputs: or('field.new', 'field.edit'),
+    "klass"
-  classNames: ['custom-field-input'],
+  ),
-  loading: or('saving', 'destroying'),
+  typeContent: generateContent(
-  destroyDisabled: alias('loading'),
+    ["string", "boolean", "integer", "json"],
-  closeDisabled: alias('loading'),
+    "type"
-  
+  ),
+  showInputs: or("field.new", "field.edit"),
+  classNames: ["custom-field-input"],
+  loading: or("saving", "destroying"),
+  destroyDisabled: alias("loading"),
+  closeDisabled: alias("loading"),
+
   didInsertElement() {
-    this.set('originalField', JSON.parse(JSON.stringify(this.field)));
+    this.set("originalField", JSON.parse(JSON.stringify(this.field)));
   },
-  
+
-  @discourseComputed('field.klass')
+  @discourseComputed("field.klass")
   serializerContent(klass, p2) {
     const serializers = this.get(`${klass}Serializers`);
-    
+
     if (serializers) {
-      return generateContent(serializers, 'serializers');
+      return generateContent(serializers, "serializers");
     } else {
       return [];
     }
   },
-  
+
-  @observes('field.klass')
+  @observes("field.klass")
   clearSerializersWhenClassChanges() {
-    this.set('field.serializers', null);
+    this.set("field.serializers", null);
   },
-  
+
   compareArrays(array1, array2) {
-    return array1.length === array2.length && array1.every((value, index) => {
+    return (
-      return value === array2[index];
+      array1.length === array2.length &&
-    });
+      array1.every((value, index) => {
+        return value === array2[index];
+      })
+    );
   },
-  
+
   @discourseComputed(
-    'saving',
+    "saving",
-    'field.name',
+    "field.name",
-    'field.klass',
+    "field.klass",
-    'field.type',
+    "field.type",
-    'field.serializers'
+    "field.serializers"
   )
   saveDisabled(saving) {
     if (saving) return true;
-    
+
     const originalField = this.originalField;
     if (!originalField) return false;
-        
+
-    return ['name', 'klass', 'type', 'serializers'].every(attr => {
+    return ["name", "klass", "type", "serializers"].every((attr) => {
       let current = this.get(attr);
       let original = originalField[attr];
-      
+
       if (!current) return false;
-      
+
-      if (attr == 'serializers') {
+      if (attr == "serializers") {
         return this.compareArrays(current, original);
       } else {
         return current == original;
       }
     });
   },
-  
+
   actions: {
     edit() {
-      this.set('field.edit', true);
+      this.set("field.edit", true);
     },
-    
+
     close() {
       if (this.field.edit) {
-        this.set('field.edit', false);
+        this.set("field.edit", false);
       }
     },
-    
+
     destroy() {
-      this.set('destroying', true);
+      this.set("destroying", true);
       this.removeField(this.field);
     },
-    
+
     save() {
-      this.set('saving', true);
+      this.set("saving", true);
-      
+
       const field = this.field;
-      
+
       let data = {
         id: field.id,
         klass: field.klass,
         type: field.type,
         serializers: field.serializers,
-        name: field.name
+        name: field.name,
-      }
+      };
-      
+
       this.saveField(data).then((result) => {
-        this.set('saving', false);
+        this.set("saving", false);
         if (result.success) {
-          this.set('field.edit', false);
+          this.set("field.edit", false);
         } else {
-          this.set('saveIcon', 'times');
+          this.set("saveIcon", "times");
         }
-        setTimeout(() => this.set('saveIcon', null), 10000);
+        setTimeout(() => this.set("saveIcon", null), 10000);
       });
-    }
+    },
-  }
+  },
-});
+});

assets/javascripts/discourse/components/wizard-advanced-toggle.js.es6

@@ -1,19 +1,19 @@
-import { default as discourseComputed } from 'discourse-common/utils/decorators';
+import { default as discourseComputed } from "discourse-common/utils/decorators";
-import Component from '@ember/component';
+import Component from "@ember/component";
 
 export default Component.extend({
-  classNames: 'wizard-advanced-toggle',
+  classNames: "wizard-advanced-toggle",
-  
+
-  @discourseComputed('showAdvanced')
+  @discourseComputed("showAdvanced")
   toggleClass(showAdvanced) {
-    let classes = 'btn'
+    let classes = "btn";
-    if (showAdvanced) classes += ' btn-primary';
+    if (showAdvanced) classes += " btn-primary";
     return classes;
   },
-  
+
   actions: {
     toggleAdvanced() {
-      this.toggleProperty('showAdvanced');
+      this.toggleProperty("showAdvanced");
-    }
+    },
-  }
+  },
-})
+});

assets/javascripts/discourse/components/wizard-custom-action.js.es6

@@ -1,89 +1,98 @@
-import { default as discourseComputed } from 'discourse-common/utils/decorators';
+import { default as discourseComputed } from "discourse-common/utils/decorators";
 import { equal, empty, or, and } from "@ember/object/computed";
-import { generateName, selectKitContent } from '../lib/wizard';
+import { generateName, selectKitContent } from "../lib/wizard";
 import { computed } from "@ember/object";
-import wizardSchema from '../lib/wizard-schema';
+import wizardSchema from "../lib/wizard-schema";
-import UndoChanges from '../mixins/undo-changes';
+import UndoChanges from "../mixins/undo-changes";
 import Component from "@ember/component";
-import { notificationLevels } from '../lib/wizard';
+import { notificationLevels } from "../lib/wizard";
 import I18n from "I18n";
 
 export default Component.extend(UndoChanges, {
-  componentType: 'action',
+  componentType: "action",
-  classNameBindings: [':wizard-custom-action', 'visible'],
+  classNameBindings: [":wizard-custom-action", "visible"],
-  visible: computed('currentActionId', function() { return this.action.id === this.currentActionId }),
+  visible: computed("currentActionId", function () {
-  createTopic: equal('action.type', 'create_topic'),
+    return this.action.id === this.currentActionId;
-  updateProfile: equal('action.type', 'update_profile'),
+  }),
-  watchCategories: equal('action.type', 'watch_categories'),
+  createTopic: equal("action.type", "create_topic"),
-  sendMessage: equal('action.type', 'send_message'),
+  updateProfile: equal("action.type", "update_profile"),
-  openComposer: equal('action.type', 'open_composer'),
+  watchCategories: equal("action.type", "watch_categories"),
-  sendToApi: equal('action.type', 'send_to_api'),
+  sendMessage: equal("action.type", "send_message"),
-  addToGroup: equal('action.type', 'add_to_group'),
+  openComposer: equal("action.type", "open_composer"),
-  routeTo: equal('action.type', 'route_to'),
+  sendToApi: equal("action.type", "send_to_api"),
-  createCategory: equal('action.type', 'create_category'),
+  addToGroup: equal("action.type", "add_to_group"),
-  createGroup: equal('action.type', 'create_group'),
+  routeTo: equal("action.type", "route_to"),
-  apiEmpty: empty('action.api'),
+  createCategory: equal("action.type", "create_category"),
-  groupPropertyTypes: selectKitContent(['id', 'name']),
+  createGroup: equal("action.type", "create_group"),
-  hasAdvanced: or('hasCustomFields', 'routeTo'),
+  apiEmpty: empty("action.api"),
-  showAdvanced: and('hasAdvanced', 'action.type'),
+  groupPropertyTypes: selectKitContent(["id", "name"]),
-  hasCustomFields: or('basicTopicFields', 'updateProfile', 'createGroup', 'createCategory'),
+  hasAdvanced: or("hasCustomFields", "routeTo"),
-  basicTopicFields: or('createTopic', 'sendMessage', 'openComposer'),
+  showAdvanced: and("hasAdvanced", "action.type"),
-  publicTopicFields: or('createTopic', 'openComposer'),
+  hasCustomFields: or(
-  showPostAdvanced: or('createTopic', 'sendMessage'),
+    "basicTopicFields",
-  actionTypes: Object.keys(wizardSchema.action.types).map(type => {
+    "updateProfile",
+    "createGroup",
+    "createCategory"
+  ),
+  basicTopicFields: or("createTopic", "sendMessage", "openComposer"),
+  publicTopicFields: or("createTopic", "openComposer"),
+  showPostAdvanced: or("createTopic", "sendMessage"),
+  actionTypes: Object.keys(wizardSchema.action.types).map((type) => {
     return {
       id: type,
-      name: I18n.t(`admin.wizard.action.${type}.label`)
+      name: I18n.t(`admin.wizard.action.${type}.label`),
     };
   }),
   availableNotificationLevels: notificationLevels.map((type, index) => {
     return {
       id: type,
-      name:  I18n.t(`admin.wizard.action.watch_categories.notification_level.${type}`)
+      name: I18n.t(
+        `admin.wizard.action.watch_categories.notification_level.${type}`
+      ),
     };
   }),
-  
+
-  messageUrl: 'https://thepavilion.io/t/2810',
+  messageUrl: "https://thepavilion.io/t/2810",
-  
+
-  @discourseComputed('action.type')
+  @discourseComputed("action.type")
   messageKey(type) {
-    let key = 'type';
+    let key = "type";
     if (type) {
-      key = 'edit';
+      key = "edit";
     }
     return key;
   },
-  
+
-  @discourseComputed('wizard.steps')
+  @discourseComputed("wizard.steps")
   runAfterContent(steps) {
-    let content = steps.map(function(step) {
+    let content = steps.map(function (step) {
       return {
         id: step.id,
-        name: step.title || step.id
+        name: step.title || step.id,
       };
     });
-    
+
     content.unshift({
-      id: 'wizard_completion',
+      id: "wizard_completion",
-      name: I18n.t('admin.wizard.action.run_after.wizard_completion')
+      name: I18n.t("admin.wizard.action.run_after.wizard_completion"),
     });
-        
+
     return content;
   },
 
-  @discourseComputed('apis')
+  @discourseComputed("apis")
   availableApis(apis) {
-    return apis.map(a => {
+    return apis.map((a) => {
       return {
         id: a.name,
-        name: a.title
+        name: a.title,
       };
     });
   },
 
-  @discourseComputed('apis', 'action.api')
+  @discourseComputed("apis", "action.api")
   availableEndpoints(apis, api) {
     if (!api) return [];
-    return apis.find(a => a.name === api).endpoints;
+    return apis.find((a) => a.name === api).endpoints;
-  }
+  },
 });

assets/javascripts/discourse/components/wizard-custom-field.js.es6

@@ -1,117 +1,119 @@
-import { default as discourseComputed } from 'discourse-common/utils/decorators';
+import { default as discourseComputed } from "discourse-common/utils/decorators";
 import { equal, or, alias } from "@ember/object/computed";
 import { computed } from "@ember/object";
-import { selectKitContent } from '../lib/wizard';
+import { selectKitContent } from "../lib/wizard";
-import UndoChanges from '../mixins/undo-changes';
+import UndoChanges from "../mixins/undo-changes";
 import Component from "@ember/component";
-import wizardSchema from '../lib/wizard-schema';
+import wizardSchema from "../lib/wizard-schema";
 
 export default Component.extend(UndoChanges, {
-  componentType: 'field',
+  componentType: "field",
-  classNameBindings: [':wizard-custom-field', 'visible'],
+  classNameBindings: [":wizard-custom-field", "visible"],
-  visible: computed('currentFieldId', function() { return this.field.id === this.currentFieldId }),
+  visible: computed("currentFieldId", function () {
-  isDropdown: equal('field.type', 'dropdown'),
+    return this.field.id === this.currentFieldId;
-  isUpload: equal('field.type', 'upload'),
+  }),
-  isCategory: equal('field.type', 'category'),
+  isDropdown: equal("field.type", "dropdown"),
-  isGroup: equal('field.type', 'group'),
+  isUpload: equal("field.type", "upload"),
-  isTag: equal('field.type', 'tag'),
+  isCategory: equal("field.type", "category"),
-  isText: equal('field.type', 'text'),
+  isGroup: equal("field.type", "group"),
-  isTextarea: equal('field.type', 'textarea'),
+  isTag: equal("field.type", "tag"),
-  isUrl: equal('field.type', 'url'),
+  isText: equal("field.type", "text"),
-  isComposer: equal('field.type', 'composer'),
+  isTextarea: equal("field.type", "textarea"),
-  showPrefill: or('isText', 'isCategory', 'isTag', 'isGroup', 'isDropdown'),
+  isUrl: equal("field.type", "url"),
-  showContent: or('isCategory', 'isTag', 'isGroup', 'isDropdown'),
+  isComposer: equal("field.type", "composer"),
-  showLimit: or('isCategory', 'isTag'),
+  showPrefill: or("isText", "isCategory", "isTag", "isGroup", "isDropdown"),
-  isTextType: or('isText', 'isTextarea', 'isComposer'),
+  showContent: or("isCategory", "isTag", "isGroup", "isDropdown"),
-  categoryPropertyTypes: selectKitContent(['id', 'slug']),
+  showLimit: or("isCategory", "isTag"),
-  showAdvanced: alias('field.type'),
+  isTextType: or("isText", "isTextarea", "isComposer"),
-  messageUrl: 'https://thepavilion.io/t/2809',
+  categoryPropertyTypes: selectKitContent(["id", "slug"]),
-  
+  showAdvanced: alias("field.type"),
-  @discourseComputed('field.type')
+  messageUrl: "https://thepavilion.io/t/2809",
+
+  @discourseComputed("field.type")
   validations(type) {
     const applicableToField = [];
-    
+
-    for(let validation in wizardSchema.field.validations) {
+    for (let validation in wizardSchema.field.validations) {
-      if ((wizardSchema.field.validations[validation]["types"]).includes(type)) {
+      if (wizardSchema.field.validations[validation]["types"].includes(type)) {
-        applicableToField.push(validation)
+        applicableToField.push(validation);
       }
     }
 
     return applicableToField;
   },
 
-  @discourseComputed('field.type')
+  @discourseComputed("field.type")
   isDateTime(type) {
-    return ['date_time', 'date', 'time'].indexOf(type) > -1;
+    return ["date_time", "date", "time"].indexOf(type) > -1;
   },
-  
+
-  @discourseComputed('field.type')
+  @discourseComputed("field.type")
   messageKey(type) {
-    let key = 'type';
+    let key = "type";
     if (type) {
-      key = 'edit';
+      key = "edit";
     }
     return key;
   },
-  
+
-  setupTypeOutput(fieldType, options) {    
+  setupTypeOutput(fieldType, options) {
     const selectionType = {
-      category: 'category',
+      category: "category",
-      tag: 'tag',
+      tag: "tag",
-      group: 'group'
+      group: "group",
     }[fieldType];
-    
+
     if (selectionType) {
-      options[`${selectionType}Selection`] = 'output';
+      options[`${selectionType}Selection`] = "output";
       options.outputDefaultSelection = selectionType;
     }
 
     return options;
   },
-  
+
-  @discourseComputed('field.type')
+  @discourseComputed("field.type")
   contentOptions(fieldType) {
     let options = {
       wizardFieldSelection: true,
-      textSelection: 'key,value',
+      textSelection: "key,value",
-      userFieldSelection: 'key,value',
+      userFieldSelection: "key,value",
-      context: 'field'
+      context: "field",
-    }
+    };
-    
+
     options = this.setupTypeOutput(fieldType, options);
-    
+
     if (this.isDropdown) {
-      options.wizardFieldSelection = 'key,value';
+      options.wizardFieldSelection = "key,value";
-      options.userFieldOptionsSelection = 'output';
+      options.userFieldOptionsSelection = "output";
-      options.textSelection = 'key,value,output';
+      options.textSelection = "key,value,output";
-      options.inputTypes = 'conditional,association,assignment';
+      options.inputTypes = "conditional,association,assignment";
-      options.pairConnector = 'association';
+      options.pairConnector = "association";
-      options.keyPlaceholder = 'admin.wizard.key';
+      options.keyPlaceholder = "admin.wizard.key";
-      options.valuePlaceholder = 'admin.wizard.value';
+      options.valuePlaceholder = "admin.wizard.value";
     }
-        
+
     return options;
   },
-  
+
-  @discourseComputed('field.type')
+  @discourseComputed("field.type")
   prefillOptions(fieldType) {
     let options = {
       wizardFieldSelection: true,
       textSelection: true,
-      userFieldSelection: 'key,value',
+      userFieldSelection: "key,value",
-      context: 'field'
+      context: "field",
-    }
+    };
 
     return this.setupTypeOutput(fieldType, options);
   },
-  
+
-  actions: {    
+  actions: {
     imageUploadDone(upload) {
       this.set("field.image", upload.url);
     },
-    
+
     imageUploadDeleted() {
       this.set("field.image", null);
-    }
+    },
-  }
+  },
 });

assets/javascripts/discourse/components/wizard-custom-step.js.es6

@@ -1,16 +1,16 @@
 import Component from "@ember/component";
-import { default as discourseComputed } from 'discourse-common/utils/decorators';
+import { default as discourseComputed } from "discourse-common/utils/decorators";
 
 export default Component.extend({
-  classNames: 'wizard-custom-step',
+  classNames: "wizard-custom-step",
-  
+
   actions: {
     bannerUploadDone(upload) {
       this.set("step.banner", upload.url);
     },
-    
+
     bannerUploadDeleted() {
       this.set("step.banner", null);
-    }
+    },
-  }
+  },
 });

assets/javascripts/discourse/components/wizard-links.js.es6

@@ -1,6 +1,13 @@
-import { default as discourseComputed, on, observes } from 'discourse-common/utils/decorators';
+import {
-import { generateName } from '../lib/wizard';
+  default as discourseComputed,
-import { default as wizardSchema, setWizardDefaults } from '../lib/wizard-schema';
+  on,
+  observes,
+} from "discourse-common/utils/decorators";
+import { generateName } from "../lib/wizard";
+import {
+  default as wizardSchema,
+  setWizardDefaults,
+} from "../lib/wizard-schema";
 import { notEmpty } from "@ember/object/computed";
 import { scheduleOnce, bind } from "@ember/runloop";
 import EmberObject from "@ember/object";
@@ -8,56 +15,63 @@ import Component from "@ember/component";
 import { A } from "@ember/array";
 
 export default Component.extend({
-  classNameBindings: [':wizard-links', 'itemType'],
+  classNameBindings: [":wizard-links", "itemType"],
   items: A(),
-  anyLinks: notEmpty('links'),
+  anyLinks: notEmpty("links"),
 
-  @on('didInsertElement')
+  @on("didInsertElement")
-  @observes('links.[]')
+  @observes("links.[]")
   setupSortable() {
-    scheduleOnce('afterRender', () => (this.applySortable()));
+    scheduleOnce("afterRender", () => this.applySortable());
   },
 
   applySortable() {
-    $(this.element).find(".link-list")
+    $(this.element)
-      .sortable({ tolerance: 'pointer' })
+      .find(".link-list")
-      .on('sortupdate', (e, ui) => {
+      .sortable({ tolerance: "pointer" })
-        this.updateItemOrder(ui.item.data('id'), ui.item.index());
+      .on("sortupdate", (e, ui) => {
+        this.updateItemOrder(ui.item.data("id"), ui.item.index());
       });
   },
 
   updateItemOrder(itemId, newIndex) {
     const items = this.items;
-    const item = items.findBy('id', itemId);
+    const item = items.findBy("id", itemId);
     items.removeObject(item);
     items.insertAt(newIndex, item);
-    scheduleOnce('afterRender', this, () => this.applySortable());
+    scheduleOnce("afterRender", this, () => this.applySortable());
   },
 
-  @discourseComputed('itemType')
+  @discourseComputed("itemType")
   header: (itemType) => `admin.wizard.${itemType}.header`,
 
-  @discourseComputed('current', 'items.@each.id', 'items.@each.type', 'items.@each.label', 'items.@each.title')
+  @discourseComputed(
+    "current",
+    "items.@each.id",
+    "items.@each.type",
+    "items.@each.label",
+    "items.@each.title"
+  )
   links(current, items) {
     if (!items) return;
 
     return items.map((item) => {
       if (item) {
         let link = {
-          id: item.id
+          id: item.id,
-        }
+        };
 
         let label = item.label || item.title || item.id;
         if (this.generateLabels && item.type) {
           label = generateName(item.type);
         }
-                
+
         link.label = `${label} (${item.id})`;
 
-        let classes = 'btn';
+        let classes = "btn";
         if (current && item.id === current.id) {
-          classes += ' btn-primary';
+          classes += " btn-primary";
-        };
+        }
 
         link.classes = classes;
 
@@ -68,69 +82,73 @@ export default Component.extend({
 
   actions: {
     add() {
-      const items = this.get('items');
+      const items = this.get("items");
       const itemType = this.itemType;
       let params = setWizardDefaults({}, itemType);
-      
+
       params.isNew = true;
-      
+
       let next = 1;
-            
+
       if (items.length) {
-        next = Math.max.apply(Math, items.map((i) => {
+        next =
-          let parts = i.id.split('_');
+          Math.max.apply(
-          let lastPart = parts[parts.length - 1];
+            Math,
-          return isNaN(lastPart) ? 0 : lastPart;
+            items.map((i) => {
-        })) + 1;
+              let parts = i.id.split("_");
+              let lastPart = parts[parts.length - 1];
+              return isNaN(lastPart) ? 0 : lastPart;
+            })
+          ) + 1;
       }
-            
+
       let id = `${itemType}_${next}`;
-      
+
-      if (itemType === 'field') {
+      if (itemType === "field") {
         id = `${this.parentId}_${id}`;
       }
-    
+
       params.id = id;
-      
+
       let objectArrays = wizardSchema[itemType].objectArrays;
       if (objectArrays) {
-        Object.keys(objectArrays).forEach(objectType => {
+        Object.keys(objectArrays).forEach((objectType) => {
           params[objectArrays[objectType].property] = A();
         });
-      };
+      }
-          
+
       const newItem = EmberObject.create(params);
       items.pushObject(newItem);
-      
+
-      this.set('current', newItem);
+      this.set("current", newItem);
     },
 
     change(itemId) {
-      this.set('current', this.items.findBy('id', itemId));
+      this.set("current", this.items.findBy("id", itemId));
     },
 
     remove(itemId) {
       const items = this.items;
       let item;
       let index;
-            
+
       items.forEach((it, ind) => {
         if (it.id === itemId) {
           item = it;
           index = ind;
         }
       });
-      
+
       let nextIndex;
       if (this.current.id === itemId) {
-        nextIndex = index < (items.length-2) ? (index+1) : (index-1);
+        nextIndex = index < items.length - 2 ? index + 1 : index - 1;
       }
-      
+
       items.removeObject(item);
-      
+
       if (nextIndex) {
-        this.set('current', items[nextIndex]);
+        this.set("current", items[nextIndex]);
       }
-    }
+    },
-  }
+  },
 });

assets/javascripts/discourse/components/wizard-mapper-connector.js.es6

@@ -1,35 +1,39 @@
 import Component from "@ember/component";
-import { gt } from '@ember/object/computed';
+import { gt } from "@ember/object/computed";
 import { computed } from "@ember/object";
-import { defaultConnector } from '../lib/wizard-mapper';
+import { defaultConnector } from "../lib/wizard-mapper";
 import { later } from "@ember/runloop";
 import { observes } from "discourse-common/utils/decorators";
 import I18n from "I18n";
 
 export default Component.extend({
-  classNameBindings: [':mapper-connector', ':mapper-block', 'hasMultiple::single'],
+  classNameBindings: [
-  hasMultiple: gt('connectors.length', 1),
+    ":mapper-connector",
-  connectorLabel: computed(function() {
+    ":mapper-block",
+    "hasMultiple::single",
+  ],
+  hasMultiple: gt("connectors.length", 1),
+  connectorLabel: computed(function () {
     let key = this.connector;
     let path = this.inputTypes ? `input.${key}.name` : `connector.${key}`;
     return I18n.t(`admin.wizard.${path}`);
   }),
-  
+
   didReceiveAttrs() {
     if (!this.connector) {
       later(() => {
         this.set(
-          'connector',
+          "connector",
           defaultConnector(this.connectorType, this.inputType, this.options)
         );
-      });  
+      });
     }
   },
-  
+
   actions: {
     changeConnector(value) {
-      this.set('connector', value);
+      this.set("connector", value);
-      this.onUpdate('connector', this.connectorType);
+      this.onUpdate("connector", this.connectorType);
-    }
+    },
-  }
+  },
-});
+});

assets/javascripts/discourse/components/wizard-mapper-input.js.es6

@@ -1,69 +1,78 @@
 import { computed, set } from "@ember/object";
 import { alias, equal, or, not } from "@ember/object/computed";
-import { newPair, connectorContent, inputTypesContent, defaultSelectionType, defaultConnector } from '../lib/wizard-mapper';
+import {
+  newPair,
+  connectorContent,
+  inputTypesContent,
+  defaultSelectionType,
+  defaultConnector,
+} from "../lib/wizard-mapper";
 import Component from "@ember/component";
 import { observes } from "discourse-common/utils/decorators";
 import { A } from "@ember/array";
 
 export default Component.extend({
-  classNameBindings: [':mapper-input', 'inputType'],
+  classNameBindings: [":mapper-input", "inputType"],
-  inputType: alias('input.type'),
+  inputType: alias("input.type"),
-  isConditional: equal('inputType', 'conditional'),
+  isConditional: equal("inputType", "conditional"),
-  isAssignment: equal('inputType', 'assignment'),
+  isAssignment: equal("inputType", "assignment"),
-  isAssociation: equal('inputType', 'association'),
+  isAssociation: equal("inputType", "association"),
-  isValidation: equal('inputType', 'validation'),
+  isValidation: equal("inputType", "validation"),
-  hasOutput: or('isConditional', 'isAssignment'),
+  hasOutput: or("isConditional", "isAssignment"),
-  hasPairs: or('isConditional', 'isAssociation', 'isValidation'),
+  hasPairs: or("isConditional", "isAssociation", "isValidation"),
-  canAddPair: not('isAssignment'),
+  canAddPair: not("isAssignment"),
-  connectors: computed(function() { return connectorContent('output', this.input.type, this.options) }),
+  connectors: computed(function () {
-  inputTypes: computed(function() { return inputTypesContent(this.options) }),
+    return connectorContent("output", this.input.type, this.options);
-  
+  }),
-  @observes('input.type')
+  inputTypes: computed(function () {
+    return inputTypesContent(this.options);
+  }),
+
+  @observes("input.type")
   setupType() {
     if (this.hasPairs && (!this.input.pairs || this.input.pairs.length < 1)) {
-      this.send('addPair');
+      this.send("addPair");
     }
-    
+
     if (this.hasOutput) {
-      this.set('input.output', null);
+      this.set("input.output", null);
-      
+
       if (!this.input.outputConnector) {
         const options = this.options;
-        this.set('input.output_type', defaultSelectionType('output', options));
+        this.set("input.output_type", defaultSelectionType("output", options));
-        this.set('input.output_connector', defaultConnector('output', this.inputType, options));
+        this.set(
+          "input.output_connector",
+          defaultConnector("output", this.inputType, options)
+        );
       }
     }
   },
-    
+
   actions: {
     addPair() {
       if (!this.input.pairs) {
-        this.set('input.pairs', A());
+        this.set("input.pairs", A());
       }
-      
+
       const pairs = this.input.pairs;
       const pairCount = pairs.length + 1;
-            
+
-      pairs.forEach(p => (set(p, 'pairCount', pairCount)));
+      pairs.forEach((p) => set(p, "pairCount", pairCount));
-      
+
       pairs.pushObject(
         newPair(
-          this.input.type, 
+          this.input.type,
-          Object.assign(
+          Object.assign({}, this.options, { index: pairs.length, pairCount })
-            {},
-            this.options,
-            { index: pairs.length, pairCount }
-          )
         )
       );
     },
-    
+
     removePair(pair) {
       const pairs = this.input.pairs;
       const pairCount = pairs.length - 1;
-      
+
-      pairs.forEach(p => (set(p, 'pairCount', pairCount)));
+      pairs.forEach((p) => set(p, "pairCount", pairCount));
       pairs.removeObject(pair);
-    }
+    },
-  }
+  },
 });

assets/javascripts/discourse/components/wizard-mapper-pair.js.es6

@@ -1,12 +1,16 @@
-import { connectorContent } from '../lib/wizard-mapper';
+import { connectorContent } from "../lib/wizard-mapper";
 import { gt, or, alias } from "@ember/object/computed";
-import { computed, observes } from "@ember/object"; 
+import { computed, observes } from "@ember/object";
 import Component from "@ember/component";
 
 export default Component.extend({
-  classNameBindings: [':mapper-pair', 'hasConnector::no-connector'],
+  classNameBindings: [":mapper-pair", "hasConnector::no-connector"],
-  firstPair: gt('pair.index', 0),
+  firstPair: gt("pair.index", 0),
-  showRemove: alias('firstPair'),
+  showRemove: alias("firstPair"),
-  showJoin: computed('pair.pairCount', function() { return this.pair.index < (this.pair.pairCount - 1) }),
+  showJoin: computed("pair.pairCount", function () {
-  connectors: computed(function() { return connectorContent('pair', this.inputType, this.options) })
+    return this.pair.index < this.pair.pairCount - 1;
-});
+  }),
+  connectors: computed(function () {
+    return connectorContent("pair", this.inputType, this.options);
+  }),
+});

assets/javascripts/discourse/components/wizard-mapper-selector-type.js.es6

@@ -1,14 +1,16 @@
-import discourseComputed from 'discourse-common/utils/decorators';
+import discourseComputed from "discourse-common/utils/decorators";
 import Component from "@ember/component";
 
 export default Component.extend({
-  tagName: 'a',
+  tagName: "a",
-  classNameBindings: ['active'],
+  classNameBindings: ["active"],
-  
+
-  @discourseComputed('item.type', 'activeType')
+  @discourseComputed("item.type", "activeType")
-  active(type, activeType) { return type === activeType },
+  active(type, activeType) {
-  
+    return type === activeType;
+  },
+
   click() {
-    this.toggle(this.item.type)
+    this.toggle(this.item.type);
-  }
+  },
-})
+});

assets/javascripts/discourse/components/wizard-mapper-selector.js.es6

@@ -1,51 +1,132 @@
 import { alias, or, gt } from "@ember/object/computed";
 import { computed } from "@ember/object";
-import { default as discourseComputed, observes, on } from "discourse-common/utils/decorators";
+import {
-import { getOwner } from 'discourse-common/lib/get-owner';
+  default as discourseComputed,
-import { defaultSelectionType, selectionTypes } from '../lib/wizard-mapper';
+  observes,
-import { snakeCase, generateName, userProperties } from '../lib/wizard';
+  on,
+} from "discourse-common/utils/decorators";
+import { getOwner } from "discourse-common/lib/get-owner";
+import { defaultSelectionType, selectionTypes } from "../lib/wizard-mapper";
+import { snakeCase, generateName, userProperties } from "../lib/wizard";
 import Component from "@ember/component";
 import { bind, later } from "@ember/runloop";
 import I18n from "I18n";
 
 export default Component.extend({
-  classNameBindings: [':mapper-selector', 'activeType'],
+  classNameBindings: [":mapper-selector", "activeType"],
-  
+
-  showText: computed('activeType', function() { return this.showInput('text') }),
+  showText: computed("activeType", function () {
-  showWizardField: computed('activeType', function() { return this.showInput('wizardField') }),
+    return this.showInput("text");
-  showWizardAction: computed('activeType', function() { return this.showInput('wizardAction') }),
+  }),
-  showUserField: computed('activeType', function() { return this.showInput('userField') }),
+  showWizardField: computed("activeType", function () {
-  showUserFieldOptions: computed('activeType', function() { return this.showInput('userFieldOptions') }),
+    return this.showInput("wizardField");
-  showCategory: computed('activeType', function() { return this.showInput('category') }),
+  }),
-  showTag: computed('activeType', function() { return this.showInput('tag') }),
+  showWizardAction: computed("activeType", function () {
-  showGroup: computed('activeType', function() { return this.showInput('group') }),
+    return this.showInput("wizardAction");
-  showUser: computed('activeType', function() { return this.showInput('user') }),
+  }),
-  showList: computed('activeType', function() { return this.showInput('list') }),
+  showUserField: computed("activeType", function () {
-  showCustomField: computed('activeType', function() { return this.showInput('customField') }),
+    return this.showInput("userField");
-  textEnabled: computed('options.textSelection', 'inputType', function() { return this.optionEnabled('textSelection') }),
+  }),
-  wizardFieldEnabled: computed('options.wizardFieldSelection', 'inputType', function() { return this.optionEnabled('wizardFieldSelection') }),
+  showUserFieldOptions: computed("activeType", function () {
-  wizardActionEnabled: computed('options.wizardActionSelection', 'inputType', function() { return this.optionEnabled('wizardActionSelection') }),
+    return this.showInput("userFieldOptions");
-  customFieldEnabled: computed('options.customFieldSelection', 'inputType', function() { return this.optionEnabled('customFieldSelection') }),
+  }),
-  userFieldEnabled: computed('options.userFieldSelection', 'inputType', function() { return this.optionEnabled('userFieldSelection') }),
+  showCategory: computed("activeType", function () {
-  userFieldOptionsEnabled: computed('options.userFieldOptionsSelection', 'inputType', function() { return this.optionEnabled('userFieldOptionsSelection') }),
+    return this.showInput("category");
-  categoryEnabled: computed('options.categorySelection', 'inputType', function() { return this.optionEnabled('categorySelection') }),
+  }),
-  tagEnabled: computed('options.tagSelection', 'inputType', function() { return this.optionEnabled('tagSelection') }),
+  showTag: computed("activeType", function () {
-  groupEnabled: computed('options.groupSelection', 'inputType', function() { return this.optionEnabled('groupSelection') }),
+    return this.showInput("tag");
-  userEnabled: computed('options.userSelection', 'inputType', function() { return this.optionEnabled('userSelection') }),
+  }),
-  listEnabled: computed('options.listSelection', 'inputType', function() { return this.optionEnabled('listSelection') }),
+  showGroup: computed("activeType", function () {
-  
+    return this.showInput("group");
-  groups: alias('site.groups'),
+  }),
-  categories: alias('site.categories'),
+  showUser: computed("activeType", function () {
-  showComboBox: or('showWizardField', 'showWizardAction', 'showUserField', 'showUserFieldOptions', 'showCustomField'),
+    return this.showInput("user");
-  showMultiSelect: or('showCategory', 'showGroup'),
+  }),
-  hasTypes: gt('selectorTypes.length', 1),
+  showList: computed("activeType", function () {
+    return this.showInput("list");
+  }),
+  showCustomField: computed("activeType", function () {
+    return this.showInput("customField");
+  }),
+  textEnabled: computed("options.textSelection", "inputType", function () {
+    return this.optionEnabled("textSelection");
+  }),
+  wizardFieldEnabled: computed(
+    "options.wizardFieldSelection",
+    "inputType",
+    function () {
+      return this.optionEnabled("wizardFieldSelection");
+    }
+  ),
+  wizardActionEnabled: computed(
+    "options.wizardActionSelection",
+    "inputType",
+    function () {
+      return this.optionEnabled("wizardActionSelection");
+    }
+  ),
+  customFieldEnabled: computed(
+    "options.customFieldSelection",
+    "inputType",
+    function () {
+      return this.optionEnabled("customFieldSelection");
+    }
+  ),
+  userFieldEnabled: computed(
+    "options.userFieldSelection",
+    "inputType",
+    function () {
+      return this.optionEnabled("userFieldSelection");
+    }
+  ),
+  userFieldOptionsEnabled: computed(
+    "options.userFieldOptionsSelection",
+    "inputType",
+    function () {
+      return this.optionEnabled("userFieldOptionsSelection");
+    }
+  ),
+  categoryEnabled: computed(
+    "options.categorySelection",
+    "inputType",
+    function () {
+      return this.optionEnabled("categorySelection");
+    }
+  ),
+  tagEnabled: computed("options.tagSelection", "inputType", function () {
+    return this.optionEnabled("tagSelection");
+  }),
+  groupEnabled: computed("options.groupSelection", "inputType", function () {
+    return this.optionEnabled("groupSelection");
+  }),
+  userEnabled: computed("options.userSelection", "inputType", function () {
+    return this.optionEnabled("userSelection");
+  }),
+  listEnabled: computed("options.listSelection", "inputType", function () {
+    return this.optionEnabled("listSelection");
+  }),
+
+  groups: alias("site.groups"),
+  categories: alias("site.categories"),
+  showComboBox: or(
+    "showWizardField",
+    "showWizardAction",
+    "showUserField",
+    "showUserFieldOptions",
+    "showCustomField"
+  ),
+  showMultiSelect: or("showCategory", "showGroup"),
+  hasTypes: gt("selectorTypes.length", 1),
   showTypes: false,
-  
+
   didInsertElement() {
-    if (!this.activeType || (this.activeType && !this[`${this.activeType}Enabled`])) {
+    if (
+      !this.activeType ||
+      (this.activeType && !this[`${this.activeType}Enabled`])
+    ) {
       later(() => this.resetActiveType());
     }
-    
+
     $(document).on("click", bind(this, this.documentClick));
   },
 
@@ -56,42 +137,45 @@ export default Component.extend({
   documentClick(e) {
     if (this._state == "destroying") return;
     let $target = $(e.target);
-        
+
-    if (!$target.parents('.type-selector').length && this.showTypes) {
+    if (!$target.parents(".type-selector").length && this.showTypes) {
-      this.set('showTypes', false);
+      this.set("showTypes", false);
     }
   },
-  
+
   @discourseComputed
   selectorTypes() {
-    return selectionTypes.filter(type => (this[`${type}Enabled`]))
+    return selectionTypes
-      .map(type => ({ type, label: this.typeLabel(type) }));
+      .filter((type) => this[`${type}Enabled`])
+      .map((type) => ({ type, label: this.typeLabel(type) }));
   },
-  
+
-  @discourseComputed('activeType')
+  @discourseComputed("activeType")
   activeTypeLabel(activeType) {
     return this.typeLabel(activeType);
   },
-  
+
   typeLabel(type) {
-    return type ? I18n.t(`admin.wizard.selector.label.${snakeCase(type)}`) : null;
+    return type
+      ? I18n.t(`admin.wizard.selector.label.${snakeCase(type)}`)
+      : null;
   },
-  
+
-  comboBoxAllowAny: or('showWizardField', 'showWizardAction'),
+  comboBoxAllowAny: or("showWizardField", "showWizardAction"),
-  
+
   @discourseComputed
   showController() {
-    return getOwner(this).lookup('controller:admin-wizards-wizard-show');
+    return getOwner(this).lookup("controller:admin-wizards-wizard-show");
   },
-  
+
   @discourseComputed(
-    'activeType',
+    "activeType",
-    'showController.wizardFields.[]',
+    "showController.wizardFields.[]",
-    'showController.wizard.actions.[]',
+    "showController.wizard.actions.[]",
-    'showController.userFields.[]',
+    "showController.userFields.[]",
-    'showController.currentField.id',
+    "showController.currentField.id",
-    'showController.currentAction.id',
+    "showController.currentAction.id",
-    'showController.customFields'
+    "showController.customFields"
   )
   comboBoxContent(
     activeType,
@@ -103,133 +187,144 @@ export default Component.extend({
     customFields
   ) {
     let content;
-    
+
-    if (activeType === 'wizardField') {
+    if (activeType === "wizardField") {
       content = wizardFields;
-      
+
-      if (this.options.context === 'field') {
+      if (this.options.context === "field") {
-        content = content.filter(field => field.id !== currentFieldId);
+        content = content.filter((field) => field.id !== currentFieldId);
       }
     }
-    
+
-    if (activeType === 'wizardAction') {
+    if (activeType === "wizardAction") {
-      content = wizardActions.map(a => ({
+      content = wizardActions.map((a) => ({
         id: a.id,
         label: `${generateName(a.type)} (${a.id})`,
-        type: a.type
+        type: a.type,
       }));
-            
+
-      if (this.options.context === 'action') {
+      if (this.options.context === "action") {
-        content = content.filter(a => a.id !== currentActionId);
+        content = content.filter((a) => a.id !== currentActionId);
       }
     }
-    
+
-    if (activeType === 'userField') {
+    if (activeType === "userField") {
-      content = userProperties.map((f) => ({
+      content = userProperties
-        id: f,
+        .map((f) => ({
-        name: generateName(f)
+          id: f,
-      })).concat((userFields || []));
+          name: generateName(f),
-      
+        }))
-      if (this.options.context === 'action' &&
+        .concat(userFields || []);
-          this.inputType === 'association' &&
+
-          this.selectorType === 'key') {
+      if (
-        
+        this.options.context === "action" &&
-        const excludedFields = ['username','email', 'trust_level'];
+        this.inputType === "association" &&
-        content = content.filter(userField => excludedFields.indexOf(userField.id) === -1);  
+        this.selectorType === "key"
+      ) {
+        const excludedFields = ["username", "email", "trust_level"];
+        content = content.filter(
+          (userField) => excludedFields.indexOf(userField.id) === -1
+        );
       }
     }
-    
+
-    if (activeType === 'userFieldOptions') {
+    if (activeType === "userFieldOptions") {
       content = userFields;
     }
-    
+
-    if (activeType === 'customField') {
+    if (activeType === "customField") {
       content = customFields;
     }
-    
+
     return content;
   },
-  
+
-  @discourseComputed('activeType')
+  @discourseComputed("activeType")
   multiSelectContent(activeType) {
     return {
       category: this.categories,
       group: this.groups,
-      list: ''
+      list: "",
     }[activeType];
   },
-  
+
-  @discourseComputed('activeType', 'inputType')
+  @discourseComputed("activeType", "inputType")
   placeholderKey(activeType, inputType) {
-    if (activeType === 'text' && this.options[`${this.selectorType}Placeholder`]) {
+    if (
+      activeType === "text" &&
+      this.options[`${this.selectorType}Placeholder`]
+    ) {
       return this.options[`${this.selectorType}Placeholder`];
     } else {
       return `admin.wizard.selector.placeholder.${snakeCase(activeType)}`;
-    }  
+    }
   },
-  
+
-  @discourseComputed('activeType')
+  @discourseComputed("activeType")
   multiSelectOptions(activeType) {
     let result = {
-      none: this.placeholderKey
+      none: this.placeholderKey,
     };
-    
+
-    if (activeType === 'list') {
+    if (activeType === "list") {
       result.allowAny = true;
     }
-    
+
     return result;
   },
-  
+
   optionEnabled(type) {
     const options = this.options;
     if (!options) return false;
-    
+
     const option = options[type];
     if (option === true) return true;
-    if (typeof option !== 'string') return false;
+    if (typeof option !== "string") return false;
-            
+
-    return option.split(',').filter(option => {
+    return option.split(",").filter((option) => {
       return [this.selectorType, this.inputType].indexOf(option) !== -1;
     }).length;
   },
-  
+
   showInput(type) {
     return this.activeType === type && this[`${type}Enabled`];
   },
-  
+
   changeValue(value) {
-    this.set('value', value);
+    this.set("value", value);
-    this.onUpdate('selector', this.activeType);
+    this.onUpdate("selector", this.activeType);
   },
-  
+
-  @observes('inputType')
+  @observes("inputType")
   resetActiveType() {
-    this.set('activeType', defaultSelectionType(this.selectorType, this.options));
+    this.set(
+      "activeType",
+      defaultSelectionType(this.selectorType, this.options)
+    );
   },
-  
+
   actions: {
     toggleType(type) {
-      this.set('activeType', type);
+      this.set("activeType", type);
-      this.set('showTypes', false);
+      this.set("showTypes", false);
-      this.set('value', null);
+      this.set("value", null);
-      this.onUpdate('selector');
+      this.onUpdate("selector");
     },
-    
+
     toggleTypes() {
-      this.toggleProperty('showTypes');
+      this.toggleProperty("showTypes");
     },
-    
+
     changeValue(value) {
       this.changeValue(value);
     },
-    
+
     changeInputValue(event) {
       this.changeValue(event.target.value);
     },
-    
+
     changeUserValue(previousValue, value) {
       this.changeValue(value);
-    }
+    },
-  }
+  },
-})
+});

assets/javascripts/discourse/components/wizard-mapper.js.es6

@@ -1,84 +1,90 @@
-import { getOwner } from 'discourse-common/lib/get-owner';
+import { getOwner } from "discourse-common/lib/get-owner";
-import { newInput, selectionTypes } from '../lib/wizard-mapper';
+import { newInput, selectionTypes } from "../lib/wizard-mapper";
-import { default as discourseComputed, observes, on } from 'discourse-common/utils/decorators';
+import {
+  default as discourseComputed,
+  observes,
+  on,
+} from "discourse-common/utils/decorators";
 import { later } from "@ember/runloop";
 import Component from "@ember/component";
 import { A } from "@ember/array";
 
 export default Component.extend({
-  classNames: 'wizard-mapper',
+  classNames: "wizard-mapper",
-  
+
   didReceiveAttrs() {
     if (this.inputs && this.inputs.constructor !== Array) {
-      later(() => this.set('inputs', null));
+      later(() => this.set("inputs", null));
     }
   },
-  
+
-  @discourseComputed('inputs.@each.type')
+  @discourseComputed("inputs.@each.type")
   canAdd(inputs) {
-    return !inputs ||
+    return (
-           inputs.constructor !== Array ||
+      !inputs ||
-           inputs.every(i => {
+      inputs.constructor !== Array ||
-             return ['assignment','association'].indexOf(i.type) === -1;
+      inputs.every((i) => {
-           });
+        return ["assignment", "association"].indexOf(i.type) === -1;
+      })
+    );
   },
-  
+
-  @discourseComputed('options.@each.inputType')
+  @discourseComputed("options.@each.inputType")
   inputOptions(options) {
     let result = {
-      inputTypes: options.inputTypes || 'assignment,conditional',
+      inputTypes: options.inputTypes || "assignment,conditional",
-      inputConnector: options.inputConnector || 'or',
+      inputConnector: options.inputConnector || "or",
       pairConnector: options.pairConnector || null,
       outputConnector: options.outputConnector || null,
-      context: options.context || null
+      context: options.context || null,
-    }
+    };
-        
+
-    let inputTypes = ['key', 'value', 'output'];
+    let inputTypes = ["key", "value", "output"];
-    inputTypes.forEach(type => {
+    inputTypes.forEach((type) => {
       result[`${type}Placeholder`] = options[`${type}Placeholder`] || null;
-      result[`${type}DefaultSelection`] = options[`${type}DefaultSelection`] || null;
+      result[`${type}DefaultSelection`] =
+        options[`${type}DefaultSelection`] || null;
     });
-    
+
-    selectionTypes.forEach(type => {
+    selectionTypes.forEach((type) => {
       if (options[`${type}Selection`] !== undefined) {
-        result[`${type}Selection`] = options[`${type}Selection`]
+        result[`${type}Selection`] = options[`${type}Selection`];
       } else {
-        result[`${type}Selection`] = type === 'text' ? true : false;
+        result[`${type}Selection`] = type === "text" ? true : false;
       }
     });
-                    
+
     return result;
   },
-  
+
-  onUpdate() {
+  onUpdate() {},
-  },
 
   actions: {
     add() {
-      if (!this.get('inputs')) {
+      if (!this.get("inputs")) {
-        this.set('inputs', A());
+        this.set("inputs", A());
       }
 
-      this.get('inputs').pushObject(
+      this.get("inputs").pushObject(
         newInput(this.inputOptions, this.inputs.length)
       );
-      
+
-      this.onUpdate(this.property, 'input');
+      this.onUpdate(this.property, "input");
     },
 
     remove(input) {
       const inputs = this.inputs;
       inputs.removeObject(input);
-            
+
       if (inputs.length) {
-        inputs[0].set('connector', null);
+        inputs[0].set("connector", null);
       }
-      
+
-      this.onUpdate(this.property, 'input');
+      this.onUpdate(this.property, "input");
     },
-    
+
     inputUpdated(component, type) {
       this.onUpdate(this.property, component, type);
-    }
+    },
-  }
+  },
 });

assets/javascripts/discourse/components/wizard-message.js.es6

@@ -1,32 +1,32 @@
-import { default as discourseComputed } from 'discourse-common/utils/decorators';
+import { default as discourseComputed } from "discourse-common/utils/decorators";
 import { not, notEmpty } from "@ember/object/computed";
 import Component from "@ember/component";
 import I18n from "I18n";
 
 const icons = {
-  error: 'times-circle',
+  error: "times-circle",
-  success: 'check-circle',
+  success: "check-circle",
-  info: 'info-circle'
+  info: "info-circle",
-}
+};
 
 export default Component.extend({
-  classNameBindings: [':wizard-message', 'type', 'loading'],
+  classNameBindings: [":wizard-message", "type", "loading"],
-  showDocumentation: not('loading'),
+  showDocumentation: not("loading"),
-  showIcon: not('loading'),
+  showIcon: not("loading"),
-  hasItems: notEmpty('items'),
+  hasItems: notEmpty("items"),
-  
+
-  @discourseComputed('type')
+  @discourseComputed("type")
   icon(type) {
-    return icons[type] || 'info-circle';
+    return icons[type] || "info-circle";
   },
-  
+
-  @discourseComputed('key', 'component', 'opts')
+  @discourseComputed("key", "component", "opts")
   message(key, component, opts) {
     return I18n.t(`admin.wizard.message.${component}.${key}`, opts || {});
   },
-  
+
-  @discourseComputed('component')
+  @discourseComputed("component")
   documentation(component) {
     return I18n.t(`admin.wizard.message.${component}.documentation`);
-  }
+  },
-})
+});

assets/javascripts/discourse/components/wizard-realtime-validations.js.es6

@@ -9,17 +9,12 @@ export default Component.extend({
   classNames: ["realtime-validations"],
   @discourseComputed
   timeUnits() {
-    return [
+    return ["days", "weeks", "months", "years"].map((unit) => {
-      "days",
+      return {
-      "weeks",
+        id: unit,
-      "months",
+        name: I18n.t(`admin.wizard.field.validations.time_units.${unit}`),
-      "years"
+      };
-    ].map((unit) => {
+    });
-        return {
-          id: unit,
-          name: I18n.t(`admin.wizard.field.validations.time_units.${unit}`)
-        }
-      });
   },
 
   init() {
@@ -28,7 +23,7 @@ export default Component.extend({
 
     if (!this.field.validations) {
       const validations = {};
-      
+
       this.validations.forEach((validation) => {
         validations[validation] = {};
       });

assets/javascripts/discourse/components/wizard-text-editor.js.es6

@@ -1,71 +1,75 @@
-import { default as discourseComputed, on } from 'discourse-common/utils/decorators';
+import {
+  default as discourseComputed,
+  on,
+} from "discourse-common/utils/decorators";
 import { notEmpty } from "@ember/object/computed";
-import { userProperties } from '../lib/wizard';
+import { userProperties } from "../lib/wizard";
 import { scheduleOnce } from "@ember/runloop";
 import Component from "@ember/component";
 import I18n from "I18n";
 
 const excludedUserProperties = [
-  'avatar',
+  "avatar",
-  'profile_background',
+  "profile_background",
-  'card_background'
+  "card_background",
 ];
 
 export default Component.extend({
-  classNames: 'wizard-text-editor',
+  classNames: "wizard-text-editor",
   barEnabled: true,
   previewEnabled: true,
   fieldsEnabled: true,
-  hasWizardFields: notEmpty('wizardFieldList'),
+  hasWizardFields: notEmpty("wizardFieldList"),
-  hasWizardActions: notEmpty('wizardActionList'),
+  hasWizardActions: notEmpty("wizardActionList"),
-  
+
   didReceiveAttrs() {
     this._super(...arguments);
-    
+
     if (!this.barEnabled) {
-      scheduleOnce('afterRender', () => {
+      scheduleOnce("afterRender", () => {
-        $(this.element).find('.d-editor-button-bar').addClass('hidden');
+        $(this.element).find(".d-editor-button-bar").addClass("hidden");
       });
     }
   },
-  
+
-  @discourseComputed('forcePreview')
+  @discourseComputed("forcePreview")
   previewLabel(forcePreview) {
     return I18n.t("admin.wizard.editor.preview", {
-      action: I18n.t(`admin.wizard.editor.${forcePreview ? 'hide' : 'show'}`)
+      action: I18n.t(`admin.wizard.editor.${forcePreview ? "hide" : "show"}`),
     });
   },
-  
+
-  @discourseComputed('showPopover')
+  @discourseComputed("showPopover")
   popoverLabel(showPopover) {
     return I18n.t("admin.wizard.editor.popover", {
-      action: I18n.t(`admin.wizard.editor.${showPopover ? 'hide' : 'show'}`)
+      action: I18n.t(`admin.wizard.editor.${showPopover ? "hide" : "show"}`),
     });
   },
-  
+
   @discourseComputed()
   userPropertyList() {
-    return userProperties.filter((f) => !excludedUserProperties.includes(f))
+    return userProperties
+      .filter((f) => !excludedUserProperties.includes(f))
       .map((f) => ` u{${f}}`);
   },
-  
+
-  @discourseComputed('wizardFields')
+  @discourseComputed("wizardFields")
   wizardFieldList(wizardFields) {
     return wizardFields.map((f) => ` w{${f.id}}`);
   },
-  
+
-  @discourseComputed('wizardActions')
+  @discourseComputed("wizardActions")
   wizardActionList(wizardActions) {
     return wizardActions.map((a) => ` w{${a.id}}`);
   },
-  
+
   actions: {
     togglePreview() {
-      this.toggleProperty('forcePreview');
+      this.toggleProperty("forcePreview");
     },
-    
+
     togglePopover() {
-      this.toggleProperty('showPopover');
+      this.toggleProperty("showPopover");
-    }
+    },
-  }
+  },
-});
+});

assets/javascripts/discourse/components/wizard-value-list.js.es6

@@ -1,4 +1,4 @@
-import ValueList from 'admin/components/value-list';
+import ValueList from "admin/components/value-list";
 
 export default ValueList.extend({
   _saveValues() {
@@ -8,5 +8,5 @@ export default ValueList.extend({
     }
 
     this.onChange(this.collection.join(this.inputDelimiter || "\n"));
-  }
+  },
-})
+});

assets/javascripts/discourse/connectors/top-notices/prompt-completion.js.es6

@@ -1,6 +1,7 @@
 export default {
   shouldRender(_, ctx) {
-    return ctx.siteSettings.custom_wizard_enabled && 
+    return (
-      ctx.site.complete_custom_wizard;
+      ctx.siteSettings.custom_wizard_enabled && ctx.site.complete_custom_wizard
-  }
+    );
-}
+  },
+};

assets/javascripts/discourse/controllers/admin-wizards-api-show.js.es6

@@ -1,93 +1,139 @@
-import { ajax } from 'discourse/lib/ajax';
+import { ajax } from "discourse/lib/ajax";
-import { popupAjaxError } from 'discourse/lib/ajax-error';
+import { popupAjaxError } from "discourse/lib/ajax-error";
-import CustomWizardApi from '../models/custom-wizard-api';
+import CustomWizardApi from "../models/custom-wizard-api";
-import { default as discourseComputed } from 'discourse-common/utils/decorators';
+import { default as discourseComputed } from "discourse-common/utils/decorators";
 import { not, and, equal } from "@ember/object/computed";
-import { selectKitContent } from '../lib/wizard';
+import { selectKitContent } from "../lib/wizard";
 import Controller from "@ember/controller";
 import I18n from "I18n";
 
 export default Controller.extend({
-  queryParams: ['refresh_list'],
+  queryParams: ["refresh_list"],
   loadingSubscriptions: false,
-  notAuthorized: not('api.authorized'),
+  notAuthorized: not("api.authorized"),
-  endpointMethods: selectKitContent(['GET', 'PUT', 'POST', 'PATCH', 'DELETE']),
+  endpointMethods: selectKitContent(["GET", "PUT", "POST", "PATCH", "DELETE"]),
-  showRemove: not('isNew'),
+  showRemove: not("isNew"),
-  showRedirectUri: and('threeLeggedOauth', 'api.name'),
+  showRedirectUri: and("threeLeggedOauth", "api.name"),
   responseIcon: null,
-  contentTypes: selectKitContent(['application/json', 'application/x-www-form-urlencoded']),
+  contentTypes: selectKitContent([
-  successCodes: selectKitContent([100, 101, 102, 200, 201, 202, 203, 204, 205, 206, 207, 208, 226, 300, 301, 302, 303, 303, 304, 305, 306, 307, 308]),
+    "application/json",
+    "application/x-www-form-urlencoded",
+  ]),
+  successCodes: selectKitContent([
+    100,
+    101,
+    102,
+    200,
+    201,
+    202,
+    203,
+    204,
+    205,
+    206,
+    207,
+    208,
+    226,
+    300,
+    301,
+    302,
+    303,
+    303,
+    304,
+    305,
+    306,
+    307,
+    308,
+  ]),
 
-  @discourseComputed('saveDisabled', 'api.authType', 'api.authUrl', 'api.tokenUrl', 'api.clientId', 'api.clientSecret', 'threeLeggedOauth')
+  @discourseComputed(
-  authDisabled(saveDisabled, authType, authUrl, tokenUrl, clientId, clientSecret, threeLeggedOauth) {
+    "saveDisabled",
-    if (saveDisabled || !authType || !tokenUrl || !clientId || !clientSecret) return true;
+    "api.authType",
+    "api.authUrl",
+    "api.tokenUrl",
+    "api.clientId",
+    "api.clientSecret",
+    "threeLeggedOauth"
+  )
+  authDisabled(
+    saveDisabled,
+    authType,
+    authUrl,
+    tokenUrl,
+    clientId,
+    clientSecret,
+    threeLeggedOauth
+  ) {
+    if (saveDisabled || !authType || !tokenUrl || !clientId || !clientSecret)
+      return true;
     if (threeLeggedOauth) return !authUrl;
     return false;
   },
 
-  @discourseComputed('api.name', 'api.authType')
+  @discourseComputed("api.name", "api.authType")
   saveDisabled(name, authType) {
     return !name || !authType;
   },
 
-  authorizationTypes: selectKitContent(['none', 'basic', 'oauth_2', 'oauth_3']),
+  authorizationTypes: selectKitContent(["none", "basic", "oauth_2", "oauth_3"]),
-  isBasicAuth: equal('api.authType', 'basic'),
+  isBasicAuth: equal("api.authType", "basic"),
 
-  @discourseComputed('api.authType')
+  @discourseComputed("api.authType")
   isOauth(authType) {
-    return authType && authType.indexOf('oauth') > -1;
+    return authType && authType.indexOf("oauth") > -1;
   },
 
-  twoLeggedOauth: equal('api.authType', 'oauth_2'),
+  twoLeggedOauth: equal("api.authType", "oauth_2"),
-  threeLeggedOauth: equal('api.authType', 'oauth_3'),
+  threeLeggedOauth: equal("api.authType", "oauth_3"),
 
   actions: {
     addParam() {
-      this.get('api.authParams').pushObject({});
+      this.get("api.authParams").pushObject({});
     },
 
     removeParam(param) {
-      this.get('api.authParams').removeObject(param);
+      this.get("api.authParams").removeObject(param);
     },
 
     addEndpoint() {
-      this.get('api.endpoints').pushObject({});
+      this.get("api.endpoints").pushObject({});
     },
 
     removeEndpoint(endpoint) {
-      this.get('api.endpoints').removeObject(endpoint);
+      this.get("api.endpoints").removeObject(endpoint);
     },
 
     authorize() {
-      const api = this.get('api');
+      const api = this.get("api");
       const { name, authType, authUrl, authParams } = api;
 
-      this.set('authErrorMessage', '');
+      this.set("authErrorMessage", "");
 
-      if (authType === 'oauth_2') {
+      if (authType === "oauth_2") {
-        this.set('authorizing', true);
+        this.set("authorizing", true);
-        ajax(`/admin/wizards/apis/${name.underscore()}/authorize`).catch(popupAjaxError)
+        ajax(`/admin/wizards/apis/${name.underscore()}/authorize`)
-          .then(result => {
+          .catch(popupAjaxError)
+          .then((result) => {
             if (result.success) {
-              this.set('api', CustomWizardApi.create(result.api));
+              this.set("api", CustomWizardApi.create(result.api));
             } else if (result.failed && result.message) {
-              this.set('authErrorMessage', result.message);
+              this.set("authErrorMessage", result.message);
             } else {
-              this.set('authErrorMessage', 'Authorization Failed');
+              this.set("authErrorMessage", "Authorization Failed");
             }
             setTimeout(() => {
-              this.set('authErrorMessage', '');
+              this.set("authErrorMessage", "");
             }, 6000);
-          }).finally(() => this.set('authorizing', false));
+          })
-      } else if (authType === 'oauth_3') {
+          .finally(() => this.set("authorizing", false));
-        let query = '?';
+      } else if (authType === "oauth_3") {
+        let query = "?";
 
         query += `client_id=${api.clientId}`;
         query += `&redirect_uri=${encodeURIComponent(api.redirectUri)}`;
         query += `&response_type=code`;
 
         if (authParams) {
-          authParams.forEach(p => {
+          authParams.forEach((p) => {
             query += `&${p.key}=${encodeURIComponent(p.value)}`;
           });
         }
@@ -97,7 +143,7 @@ export default Controller.extend({
     },
 
     save() {
-      const api = this.get('api');
+      const api = this.get("api");
       const name = api.name;
       const authType = api.authType;
       let refreshList = false;
@@ -106,35 +152,37 @@ export default Controller.extend({
       if (!name || !authType) return;
 
       let data = {
-        auth_type: authType
+        auth_type: authType,
       };
 
-      if (api.title) data['title'] = api.title;
+      if (api.title) data["title"] = api.title;
 
-      const originalTitle = this.get('api.originalTitle');
+      const originalTitle = this.get("api.originalTitle");
-      if (api.get('isNew') || (originalTitle && (api.title !== originalTitle))) {
+      if (api.get("isNew") || (originalTitle && api.title !== originalTitle)) {
         refreshList = true;
       }
 
-      if (api.get('isNew')) {
+      if (api.get("isNew")) {
-        data['new'] = true;
+        data["new"] = true;
-      };
+      }
 
       let requiredParams;
 
-      if (authType === 'basic') {
+      if (authType === "basic") {
-        requiredParams = ['username', 'password'];
+        requiredParams = ["username", "password"];
-      } else if (authType === 'oauth_2') {
+      } else if (authType === "oauth_2") {
-        requiredParams = ['tokenUrl', 'clientId', 'clientSecret'];
+        requiredParams = ["tokenUrl", "clientId", "clientSecret"];
-      } else if (authType === 'oauth_3') {
+      } else if (authType === "oauth_3") {
-        requiredParams = ['authUrl', 'tokenUrl', 'clientId', 'clientSecret'];
+        requiredParams = ["authUrl", "tokenUrl", "clientId", "clientSecret"];
       }
 
       if (requiredParams) {
         for (let rp of requiredParams) {
           if (!api[rp]) {
-            let key = rp.replace('auth', '');
+            let key = rp.replace("auth", "");
-            error = `${I18n.t(`admin.wizard.api.auth.${key.underscore()}`)} is required for ${authType}`;
+            error = `${I18n.t(
+              `admin.wizard.api.auth.${key.underscore()}`
+            )} is required for ${authType}`;
             break;
           }
           data[rp.underscore()] = api[rp];
@@ -143,73 +191,79 @@ export default Controller.extend({
 
       const params = api.authParams;
       if (params.length) {
-        data['auth_params'] = JSON.stringify(params);
+        data["auth_params"] = JSON.stringify(params);
       }
 
       const endpoints = api.endpoints;
       if (endpoints.length) {
         for (let e of endpoints) {
           if (!e.name) {
-            error = 'Every endpoint must have a name';
+            error = "Every endpoint must have a name";
             break;
           }
         }
-        data['endpoints'] = JSON.stringify(endpoints);
+        data["endpoints"] = JSON.stringify(endpoints);
       }
 
       if (error) {
-        this.set('error', error);
+        this.set("error", error);
         setTimeout(() => {
-          this.set('error', '');
+          this.set("error", "");
         }, 6000);
         return;
       }
 
-      this.set('updating', true);
+      this.set("updating", true);
 
       ajax(`/admin/wizards/api/${name.underscore()}`, {
-        type: 'PUT',
+        type: "PUT",
-        data
+        data,
-      }).catch(popupAjaxError)
+      })
-        .then(result => {
+        .catch(popupAjaxError)
+        .then((result) => {
           if (result.success) {
-            this.send('afterSave', result.api.name);
+            this.send("afterSave", result.api.name);
           } else {
-            this.set('responseIcon', 'times');
+            this.set("responseIcon", "times");
           }
-        }).finally(() => this.set('updating', false));
+        })
+        .finally(() => this.set("updating", false));
     },
 
     remove() {
-      const name = this.get('api.name');
+      const name = this.get("api.name");
       if (!name) return;
 
-      this.set('updating', true);
+      this.set("updating", true);
 
       ajax(`/admin/wizards/api/${name.underscore()}`, {
-        type: 'DELETE'
+        type: "DELETE",
-      }).catch(popupAjaxError)
+      })
-        .then(result => {
+        .catch(popupAjaxError)
+        .then((result) => {
           if (result.success) {
-            this.send('afterDestroy');
+            this.send("afterDestroy");
           }
-        }).finally(() => this.set('updating', false));
+        })
+        .finally(() => this.set("updating", false));
     },
 
     clearLogs() {
-      const name = this.get('api.name');
+      const name = this.get("api.name");
       if (!name) return;
 
       ajax(`/admin/wizards/api/${name.underscore()}/logs`, {
-        type: 'DELETE'
+        type: "DELETE",
-      }).catch(popupAjaxError)
+      })
-        .then(result => {
+        .catch(popupAjaxError)
+        .then((result) => {
           if (result.success) {
-            this.transitionToRoute('adminWizardsApis').then(() => {
+            this.transitionToRoute("adminWizardsApis").then(() => {
-              this.send('refreshModel');
+              this.send("refreshModel");
             });
           }
-        }).finally(() => this.set('updating', false));
+        })
-    }
+        .finally(() => this.set("updating", false));
-  }
+    },
+  },
 });

assets/javascripts/discourse/controllers/admin-wizards-custom-fields.js.es6

@@ -1,55 +1,57 @@
 import Controller from "@ember/controller";
-import EmberObject from '@ember/object';
+import EmberObject from "@ember/object";
-import { ajax } from 'discourse/lib/ajax';
+import { ajax } from "discourse/lib/ajax";
-import { popupAjaxError } from 'discourse/lib/ajax-error';
+import { popupAjaxError } from "discourse/lib/ajax-error";
 import CustomWizardCustomField from "../models/custom-wizard-custom-field";
-import { default as discourseComputed } from 'discourse-common/utils/decorators';
+import { default as discourseComputed } from "discourse-common/utils/decorators";
 
 export default Controller.extend({
-  messageKey: 'create',
+  messageKey: "create",
-  fieldKeys: ['klass', 'type', 'serializers', 'name'],
+  fieldKeys: ["klass", "type", "serializers", "name"],
   documentationUrl: "https://thepavilion.io/t/3572",
-  
+
   actions: {
     addField() {
-      this.get('customFields').pushObject(
+      this.get("customFields").pushObject(
         CustomWizardCustomField.create({ edit: true })
       );
     },
-    
+
     saveField(field) {
-      return CustomWizardCustomField.saveField(field)
+      return CustomWizardCustomField.saveField(field).then((result) => {
-        .then(result => {
+        if (result.success) {
-          if (result.success) {
+          this.setProperties({
+            messageKey: "saved",
+            messageType: "success",
+          });
+        } else {
+          if (result.messages) {
             this.setProperties({
-              messageKey: 'saved',
+              messageKey: "error",
-              messageType: 'success'
+              messageType: "error",
+              messageOpts: { messages: result.messages },
             });
-          } else {            
-            if (result.messages) {
-              this.setProperties({
-                messageKey: 'error',
-                messageType: 'error',
-                messageOpts: { messages: result.messages }
-              })
-            }
           }
-          
+        }
-          setTimeout(() => this.setProperties({
+
-            messageKey: 'create',
+        setTimeout(
-            messageType: null,
+          () =>
-            messageOpts: null
+            this.setProperties({
-          }), 10000);
+              messageKey: "create",
-          
+              messageType: null,
-          return result;
+              messageOpts: null,
-        });
+            }),
+          10000
+        );
+
+        return result;
+      });
     },
-    
+
     removeField(field) {
-      return CustomWizardCustomField.destroyField(field)
+      return CustomWizardCustomField.destroyField(field).then((result) => {
-        .then(result => {
+        this.get("customFields").removeObject(field);
-          this.get('customFields').removeObject(field);
+      });
-        });
+    },
-    }
+  },
-  }
+});
-});

assets/javascripts/discourse/controllers/admin-wizards-logs.js.es6

@@ -1,8 +1,8 @@
-import { default as computed } from 'discourse-common/utils/decorators';
+import { default as computed } from "discourse-common/utils/decorators";
-import { popupAjaxError } from 'discourse/lib/ajax-error';
+import { popupAjaxError } from "discourse/lib/ajax-error";
-import { ajax } from 'discourse/lib/ajax';
+import { ajax } from "discourse/lib/ajax";
 import { notEmpty } from "@ember/object/computed";
-import CustomWizardLogs from '../models/custom-wizard-logs';
+import CustomWizardLogs from "../models/custom-wizard-logs";
 import Controller from "@ember/controller";
 
 export default Controller.extend({
@@ -11,40 +11,40 @@ export default Controller.extend({
   page: 0,
   canLoadMore: true,
   logs: [],
-  
+
   loadLogs() {
     if (!this.canLoadMore) return;
 
     this.set("refreshing", true);
-        
+
     CustomWizardLogs.list()
-      .then(result => {
+      .then((result) => {
         if (!result || result.length === 0) {
-          this.set('canLoadMore', false);
+          this.set("canLoadMore", false);
         }
         this.set("logs", this.logs.concat(result));
       })
       .finally(() => this.set("refreshing", false));
   },
-  
+
-  @computed('hasLogs', 'refreshing')
+  @computed("hasLogs", "refreshing")
   noResults(hasLogs, refreshing) {
     return !hasLogs && !refreshing;
   },
-  
+
   actions: {
     loadMore() {
-      this.set('page', this.page += 1);
+      this.set("page", (this.page += 1));
       this.loadLogs();
     },
-    
+
     refresh() {
       this.setProperties({
         canLoadMore: true,
         page: 0,
-        logs: []
+        logs: [],
-      })
+      });
       this.loadLogs();
-    }
+    },
-  }
+  },
-});
+});

assets/javascripts/discourse/controllers/admin-wizards-manager.js.es6

@@ -1,76 +1,80 @@
 import Controller from "@ember/controller";
 import {
   default as discourseComputed,
-  observes
+  observes,
-} from 'discourse-common/utils/decorators';
+} from "discourse-common/utils/decorators";
 import { empty } from "@ember/object/computed";
-import CustomWizardManager from '../models/custom-wizard-manager';
+import CustomWizardManager from "../models/custom-wizard-manager";
 import { A } from "@ember/array";
 import I18n from "I18n";
 import { underscore } from "@ember/string";
 
 export default Controller.extend({
-  messageUrl: 'https://thepavilion.io/t/3652',
+  messageUrl: "https://thepavilion.io/t/3652",
-  messageKey: 'info',
+  messageKey: "info",
-  messageIcon: 'info-circle',
+  messageIcon: "info-circle",
-  messageClass: 'info',
+  messageClass: "info",
-  importDisabled: empty('file'),
+  importDisabled: empty("file"),
   exportWizards: A(),
   destroyWizards: A(),
-  exportDisabled: empty('exportWizards'),
+  exportDisabled: empty("exportWizards"),
-  destoryDisabled: empty('destroyWizards'),
+  destoryDisabled: empty("destroyWizards"),
 
-  setMessage(type, key, opts={}, items=[]) {
+  setMessage(type, key, opts = {}, items = []) {
     this.setProperties({
       messageKey: key,
       messageOpts: opts,
       messageType: type,
-      messageItems: items
+      messageItems: items,
     });
     setTimeout(() => {
       this.setProperties({
-        messageKey: 'info',
+        messageKey: "info",
         messageOpts: null,
         messageType: null,
-        messageItems: null
+        messageItems: null,
-      })
+      });
     }, 10000);
   },
-  
+
   buildWizardLink(wizard) {
     let html = `<a href='/admin/wizards/wizard/${wizard.id}'>${wizard.name}</a>`;
-    html += `<span class='action'>${I18n.t('admin.wizard.manager.imported')}</span>`;
+    html += `<span class='action'>${I18n.t(
+      "admin.wizard.manager.imported"
+    )}</span>`;
     return {
-      icon: 'check-circle',
+      icon: "check-circle",
-      html
+      html,
     };
   },
-  
+
   buildDestroyedItem(destroyed) {
     let html = `<span data-wizard-id="${destroyed.id}">${destroyed.name}</span>`;
-    html += `<span class='action'>${I18n.t('admin.wizard.manager.destroyed')}</span>`;
+    html += `<span class='action'>${I18n.t(
+      "admin.wizard.manager.destroyed"
+    )}</span>`;
     return {
-      icon: 'check-circle',
+      icon: "check-circle",
-      html
+      html,
     };
   },
-  
+
   buildFailureItem(failure) {
     return {
-      icon: 'times-circle',
+      icon: "times-circle",
-      html: `${failure.id}: ${failure.messages}`
+      html: `${failure.id}: ${failure.messages}`,
     };
   },
-  
+
   clearFile() {
     this.setProperties({
       file: null,
-      filename: null
+      filename: null,
     });
-    $('#file-upload').val('');
+    $("#file-upload").val("");
   },
-  
+
-  @observes('importing', 'destroying')
+  @observes("importing", "destroying")
   setLoadingMessages() {
     if (this.importing) {
       this.setMessage("loading", "importing");
@@ -82,47 +86,49 @@ export default Controller.extend({
 
   actions: {
     upload() {
-      $('#file-upload').click();
+      $("#file-upload").click();
     },
-    
+
     clearFile() {
       this.clearFile();
     },
-    
+
     setFile(event) {
       let maxFileSize = 512 * 1024;
       const file = event.target.files[0];
 
       if (file === undefined) {
-        this.set('file', null);
+        this.set("file", null);
         return;
       }
-      
+
       if (maxFileSize < file.size) {
         this.setMessage("error", "file_size_error");
         this.set("file", null);
-        $('#file-upload').val('');
+        $("#file-upload").val("");
       } else {
         this.setProperties({
           file,
-          filename: file.name
+          filename: file.name,
         });
       }
     },
-    
+
     selectWizard(event) {
-      const type = event.target.classList.contains('export') ? 'export' : 'destroy';
+      const type = event.target.classList.contains("export")
+        ? "export"
+        : "destroy";
       const wizards = this.get(`${type}Wizards`);
       const checked = event.target.checked;
-      
+
-      let wizardId = event.target.closest('tr').getAttribute('data-wizard-id');
+      let wizardId = event.target.closest("tr").getAttribute("data-wizard-id");
-      
+
       if (wizardId) {
         wizardId = underscore(wizardId);
       } else {
         return false;
       }
-      
+
       if (checked) {
         wizards.addObject(wizardId);
       } else {
@@ -131,99 +137,113 @@ export default Controller.extend({
     },
 
     import() {
-      const file = this.get('file');
+      const file = this.get("file");
-      
+
       if (!file) {
-        this.setMessage("error", 'no_file');
+        this.setMessage("error", "no_file");
         return;
       }
-      
+
       let $formData = new FormData();
-      $formData.append('file', file);
+      $formData.append("file", file);
-      
+
-      this.set('importing', true);
+      this.set("importing", true);
       this.setMessage("loading", "importing");
-      
+
-      CustomWizardManager.import($formData).then(result => {
+      CustomWizardManager.import($formData)
-        if (result.error) {
+        .then((result) => {
-          this.setMessage("error", "server_error", {
+          if (result.error) {
-            message: result.error
+            this.setMessage("error", "server_error", {
-          });
+              message: result.error,
-        } else {
+            });
-          this.setMessage("success", "import_complete", {},
+          } else {
-            result.imported.map(imported => {
+            this.setMessage(
-              return this.buildWizardLink(imported);
+              "success",
-            }).concat(
+              "import_complete",
-              result.failures.map(failure => {
+              {},
-                return this.buildFailureItem(failure);
+              result.imported
-              })
+                .map((imported) => {
-            )
+                  return this.buildWizardLink(imported);
-          );
+                })
-          
+                .concat(
-          if (result.imported.length) {
+                  result.failures.map((failure) => {
-            this.get('wizards').addObjects(result.imported);
+                    return this.buildFailureItem(failure);
+                  })
+                )
+            );
+
+            if (result.imported.length) {
+              this.get("wizards").addObjects(result.imported);
+            }
           }
-        }
+          this.clearFile();
-        this.clearFile();
+        })
-      }).finally(() => {
+        .finally(() => {
-        this.set('importing', false);
+          this.set("importing", false);
-      });
+        });
     },
 
     export() {
-      const exportWizards = this.get('exportWizards');
+      const exportWizards = this.get("exportWizards");
 
       if (!exportWizards.length) {
-        this.setMessage("error", 'none_selected');
+        this.setMessage("error", "none_selected");
       } else {
         CustomWizardManager.export(exportWizards);
         exportWizards.clear();
-        $('input.export').prop("checked", false);
+        $("input.export").prop("checked", false);
       }
     },
-    
+
     destroy() {
-      const destroyWizards = this.get('destroyWizards');
+      const destroyWizards = this.get("destroyWizards");
 
       if (!destroyWizards.length) {
-        this.setMessage("error", 'none_selected');
+        this.setMessage("error", "none_selected");
       } else {
-        this.set('destroying', true);
+        this.set("destroying", true);
-        
+
-        CustomWizardManager.destroy(destroyWizards).then((result) => {
+        CustomWizardManager.destroy(destroyWizards)
-          if (result.error) {
+          .then((result) => {
-            this.setMessage("error", "server_error", {
+            if (result.error) {
-              message: result.error
+              this.setMessage("error", "server_error", {
-            });
+                message: result.error,
-          } else {
+              });
-            this.setMessage("success", "destroy_complete", {},
+            } else {
-              result.destroyed.map(destroyed => {
+              this.setMessage(
-                return this.buildDestroyedItem(destroyed);
+                "success",
-              }).concat(
+                "destroy_complete",
-                result.failures.map(failure => {
+                {},
-                  return this.buildFailureItem(failure);
+                result.destroyed
-                })
+                  .map((destroyed) => {
-              )
+                    return this.buildDestroyedItem(destroyed);
-            );
+                  })
-            
+                  .concat(
-            if (result.destroyed.length) {
+                    result.failures.map((failure) => {
-              const destroyedIds = result.destroyed.map(d => d.id);
+                      return this.buildFailureItem(failure);
-              const destroyWizards = this.get('destroyWizards');
+                    })
-              const wizards = this.get('wizards');
+                  )
-              
-              wizards.removeObjects(
-                wizards.filter(w => {
-                  return destroyedIds.includes(w.id);
-                })
               );
-                            
+
-              destroyWizards.removeObjects(destroyedIds);
+              if (result.destroyed.length) {
+                const destroyedIds = result.destroyed.map((d) => d.id);
+                const destroyWizards = this.get("destroyWizards");
+                const wizards = this.get("wizards");
+
+                wizards.removeObjects(
+                  wizards.filter((w) => {
+                    return destroyedIds.includes(w.id);
+                  })
+                );
+
+                destroyWizards.removeObjects(destroyedIds);
+              }
             }
-          }
+          })
-        }).finally(() => {
+          .finally(() => {
-          this.set('destroying', false);
+            this.set("destroying", false);
-        });
+          });
       }
-    }
+    },
-  }
+  },
 });

assets/javascripts/discourse/controllers/admin-wizards-submissions-show.js.es6

@@ -2,5 +2,5 @@ import Controller from "@ember/controller";
 import { fmt } from "discourse/lib/computed";
 
 export default Controller.extend({
-  downloadUrl: fmt("wizard.id", "/admin/wizards/submissions/%@/download")
+  downloadUrl: fmt("wizard.id", "/admin/wizards/submissions/%@/download"),
-});
+});

assets/javascripts/discourse/controllers/admin-wizards-wizard-show.js.es6

@@ -1,123 +1,139 @@
-import { default as discourseComputed, observes, on } from 'discourse-common/utils/decorators';
+import {
+  default as discourseComputed,
+  observes,
+  on,
+} from "discourse-common/utils/decorators";
 import { notEmpty, alias } from "@ember/object/computed";
-import showModal from 'discourse/lib/show-modal';
+import showModal from "discourse/lib/show-modal";
-import { generateId, wizardFieldList } from '../lib/wizard';
+import { generateId, wizardFieldList } from "../lib/wizard";
-import { buildProperties } from '../lib/wizard-json';
+import { buildProperties } from "../lib/wizard-json";
 import { dasherize } from "@ember/string";
 import EmberObject from "@ember/object";
 import { scheduleOnce, later } from "@ember/runloop";
 import Controller from "@ember/controller";
 import copyText from "discourse/lib/copy-text";
-import CustomWizard from '../models/custom-wizard';
+import CustomWizard from "../models/custom-wizard";
 import I18n from "I18n";
 
 export default Controller.extend({
-  hasName: notEmpty('wizard.name'),
+  hasName: notEmpty("wizard.name"),
-  
+
-  @observes('currentStep')
+  @observes("currentStep")
   resetCurrentObjects() {
     const currentStep = this.currentStep;
-    
+
     if (currentStep) {
       const fields = currentStep.fields;
-      this.set('currentField', fields && fields.length ? fields[0] : null)
+      this.set("currentField", fields && fields.length ? fields[0] : null);
     }
-    
+
-    scheduleOnce('afterRender', () => ($("body").addClass('admin-wizard')));
+    scheduleOnce("afterRender", () => $("body").addClass("admin-wizard"));
-  },
-    
-  @observes('wizard.name')
-  setId() {
-    const wizard = this.wizard;    
-    if (wizard && !wizard.existingId) {      
-      this.set('wizard.id', generateId(wizard.name));
-    }
-  },
-  
-  @discourseComputed('wizard.id')
-  wizardUrl(wizardId) {
-    return window.location.origin + '/w/' + dasherize(wizardId);
   },
 
-  @discourseComputed('wizard.after_time_scheduled')
+  @observes("wizard.name")
-  nextSessionScheduledLabel(scheduled) {
+  setId() {
-    return scheduled ?
+    const wizard = this.wizard;
-      moment(scheduled).format('MMMM Do, HH:mm') :
+    if (wizard && !wizard.existingId) {
-      I18n.t('admin.wizard.after_time_time_label');
+      this.set("wizard.id", generateId(wizard.name));
+    }
   },
-  
+
-  @discourseComputed('currentStep.id', 'wizard.save_submissions', 'currentStep.fields.@each.label')
+  @discourseComputed("wizard.id")
+  wizardUrl(wizardId) {
+    return window.location.origin + "/w/" + dasherize(wizardId);
+  },
+
+  @discourseComputed("wizard.after_time_scheduled")
+  nextSessionScheduledLabel(scheduled) {
+    return scheduled
+      ? moment(scheduled).format("MMMM Do, HH:mm")
+      : I18n.t("admin.wizard.after_time_time_label");
+  },
+
+  @discourseComputed(
+    "currentStep.id",
+    "wizard.save_submissions",
+    "currentStep.fields.@each.label"
+  )
   wizardFields(currentStepId, saveSubmissions) {
     let steps = this.wizard.steps;
     if (!saveSubmissions) {
-      steps = [steps.findBy('id', currentStepId)];
+      steps = [steps.findBy("id", currentStepId)];
     }
     return wizardFieldList(steps);
   },
 
-  actions: {    
+  actions: {
     save() {
       this.setProperties({
         saving: true,
-        error: null
+        error: null,
       });
-      
+
       const wizard = this.wizard;
       const creating = this.creating;
       let opts = {};
-      
+
       if (creating) {
         opts.create = true;
       }
-      
+
-      wizard.save(opts).then((result) => {
+      wizard
-        this.send('afterSave', result.wizard_id);
+        .save(opts)
-      }).catch((result) => {                
+        .then((result) => {
-        let errorType = 'failed';
+          this.send("afterSave", result.wizard_id);
-        let errorParams = {};
+        })
-        
+        .catch((result) => {
-        if (result.error) {
+          let errorType = "failed";
-          errorType = result.error.type;
+          let errorParams = {};
-          errorParams = result.error.params;
+
-        }
+          if (result.error) {
-        
+            errorType = result.error.type;
-        this.set('error', I18n.t(`admin.wizard.error.${errorType}`, errorParams));
+            errorParams = result.error.params;
-        
+          }
-        later(() => this.set('error', null), 10000);
+
-      }).finally(() => this.set('saving', false));
+          this.set(
+            "error",
+            I18n.t(`admin.wizard.error.${errorType}`, errorParams)
+          );
+
+          later(() => this.set("error", null), 10000);
+        })
+        .finally(() => this.set("saving", false));
     },
 
     remove() {
-      this.wizard.remove().then(() => this.send('afterDestroy'));
+      this.wizard.remove().then(() => this.send("afterDestroy"));
     },
 
     setNextSessionScheduled() {
-      let controller = showModal('next-session-scheduled', {
+      let controller = showModal("next-session-scheduled", {
         model: {
           dateTime: this.wizard.after_time_scheduled,
-          update: (dateTime) => this.set('wizard.after_time_scheduled', dateTime)
+          update: (dateTime) =>
-        }
+            this.set("wizard.after_time_scheduled", dateTime),
+        },
       });
 
       controller.setup();
     },
-    
+
     toggleAdvanced() {
-      this.toggleProperty('wizard.showAdvanced');
+      this.toggleProperty("wizard.showAdvanced");
     },
-    
+
     copyUrl() {
       const $copyRange = $('<p id="copy-range"></p>');
       $copyRange.html(this.wizardUrl);
-      
+
       $(document.body).append($copyRange);
-      
+
       if (copyText(this.wizardUrl, $copyRange[0])) {
         this.set("copiedUrl", true);
         later(() => this.set("copiedUrl", false), 2000);
       }
-      
+
       $copyRange.remove();
-    }
+    },
-  }
+  },
 });

assets/javascripts/discourse/controllers/admin-wizards-wizard.js.es6

@@ -1,25 +1,25 @@
 import Controller from "@ember/controller";
-import { default as discourseComputed } from 'discourse-common/utils/decorators';
+import { default as discourseComputed } from "discourse-common/utils/decorators";
-import { equal } from '@ember/object/computed';
+import { equal } from "@ember/object/computed";
 
 export default Controller.extend({
-  creating: equal('wizardId', 'create'),
+  creating: equal("wizardId", "create"),
-  
+
-  @discourseComputed('creating', 'wizardId')
+  @discourseComputed("creating", "wizardId")
   wizardListVal(creating, wizardId) {
     return creating ? null : wizardId;
   },
-  
+
-  @discourseComputed('creating', 'wizardId')
+  @discourseComputed("creating", "wizardId")
   messageKey(creating, wizardId) {
-    let key = 'select';
+    let key = "select";
     if (creating) {
-      key = 'create';
+      key = "create";
     } else if (wizardId) {
-      key = 'edit';
+      key = "edit";
     }
-    return key;  
+    return key;
   },
-  
+
-  messageUrl: "https://thepavilion.io/c/knowledge/discourse/custom-wizard"
+  messageUrl: "https://thepavilion.io/c/knowledge/discourse/custom-wizard",
-});
+});

assets/javascripts/discourse/controllers/next-session-scheduled.js.es6

@@ -1,27 +1,27 @@
-import { default as discourseComputed } from 'discourse-common/utils/decorators';
+import { default as discourseComputed } from "discourse-common/utils/decorators";
 import Controller from "@ember/controller";
 
 export default Controller.extend({
-  title: 'admin.wizard.after_time_modal.title',
+  title: "admin.wizard.after_time_modal.title",
 
   setup() {
-    this.set('bufferedDateTime', moment(this.model.dateTime));
+    this.set("bufferedDateTime", moment(this.model.dateTime));
   },
 
-  @discourseComputed('bufferedDateTime')
+  @discourseComputed("bufferedDateTime")
   submitDisabled(dateTime) {
     return moment().isAfter(dateTime);
   },
 
   actions: {
     submit() {
-      const dateTime = this.get('bufferedDateTime');
+      const dateTime = this.get("bufferedDateTime");
-      this.get('model.update')(moment(dateTime).utc().toISOString());
+      this.get("model.update")(moment(dateTime).utc().toISOString());
       this.send("closeModal");
     },
-    
+
     dateTimeChanged(dateTime) {
-      this.set('bufferedDateTime', dateTime);
+      this.set("bufferedDateTime", dateTime);
-    }
+    },
-  }
+  },
 });

assets/javascripts/discourse/custom-wizard-admin-route-map.js.es6

@@ -1,25 +1,55 @@
 export default {
-  resource: 'admin',
+  resource: "admin",
   map() {
-    this.route('adminWizards', { path: '/wizards', resetNamespace: true }, function() {
+    this.route(
-      
+      "adminWizards",
-      this.route('adminWizardsWizard', { path: '/wizard/', resetNamespace: true }, function() {
+      { path: "/wizards", resetNamespace: true },
-        this.route('adminWizardsWizardShow', { path: '/:wizardId/', resetNamespace: true });
+      function () {
-      });
+        this.route(
-      
+          "adminWizardsWizard",
-      this.route('adminWizardsCustomFields', { path: '/custom-fields', resetNamespace: true });
+          { path: "/wizard/", resetNamespace: true },
-      
+          function () {
-      this.route('adminWizardsSubmissions', { path: '/submissions', resetNamespace: true }, function() {
+            this.route("adminWizardsWizardShow", {
-        this.route('adminWizardsSubmissionsShow', { path: '/:wizardId/', resetNamespace: true });
+              path: "/:wizardId/",
-      })
+              resetNamespace: true,
-      
+            });
-      this.route('adminWizardsApi', { path: '/api', resetNamespace: true }, function() {
+          }
-        this.route('adminWizardsApiShow', { path: '/:name', resetNamespace: true });
+        );
-      });
-      
-      this.route('adminWizardsLogs', { path: '/logs', resetNamespace: true });
 
-      this.route('adminWizardsManager', { path: '/manager', resetNamespace: true });
+        this.route("adminWizardsCustomFields", {
-    });
+          path: "/custom-fields",
-  }
+          resetNamespace: true,
+        });
+
+        this.route(
+          "adminWizardsSubmissions",
+          { path: "/submissions", resetNamespace: true },
+          function () {
+            this.route("adminWizardsSubmissionsShow", {
+              path: "/:wizardId/",
+              resetNamespace: true,
+            });
+          }
+        );
+
+        this.route(
+          "adminWizardsApi",
+          { path: "/api", resetNamespace: true },
+          function () {
+            this.route("adminWizardsApiShow", {
+              path: "/:name",
+              resetNamespace: true,
+            });
+          }
+        );
+
+        this.route("adminWizardsLogs", { path: "/logs", resetNamespace: true });
+
+        this.route("adminWizardsManager", {
+          path: "/manager",
+          resetNamespace: true,
+        });
+      }
+    );
+  },
 };

assets/javascripts/discourse/helpers/custom-wizard.js.es6

@@ -1,6 +1,6 @@
-import { registerUnbound } from 'discourse-common/lib/helpers';
+import { registerUnbound } from "discourse-common/lib/helpers";
 import { dasherize } from "@ember/string";
 
-registerUnbound('dasherize', function(string) {
+registerUnbound("dasherize", function (string) {
   return dasherize(string);
 });

assets/javascripts/discourse/initializers/custom-wizard-edits.js.es6

@@ -1,19 +1,19 @@
-import { withPluginApi } from 'discourse/lib/plugin-api';
+import { withPluginApi } from "discourse/lib/plugin-api";
-import DiscourseURL from 'discourse/lib/url';
+import DiscourseURL from "discourse/lib/url";
 
 export default {
-  name: 'custom-wizard-edits',
+  name: "custom-wizard-edits",
   initialize(container) {
-    const siteSettings = container.lookup('site-settings:main');
+    const siteSettings = container.lookup("site-settings:main");
-    
+
     if (!siteSettings.custom_wizard_enabled) return;
 
     const existing = DiscourseURL.routeTo;
-    DiscourseURL.routeTo = function(path, opts) {
+    DiscourseURL.routeTo = function (path, opts) {
-      if (path && path.indexOf('/w/') > -1) {
+      if (path && path.indexOf("/w/") > -1) {
-        return window.location = path;
+        return (window.location = path);
       }
       return existing.apply(this, [path, opts]);
     };
-  }
+  },
 };

assets/javascripts/discourse/initializers/custom-wizard-redirect.js.es6

@@ -1,36 +1,42 @@
-import ApplicationRoute from 'discourse/routes/application';
+import ApplicationRoute from "discourse/routes/application";
 
 export default {
   name: "custom-wizard-redirect",
   after: "message-bus",
 
   initialize: function (container) {
-    const messageBus = container.lookup('message-bus:main');
+    const messageBus = container.lookup("message-bus:main");
-    const siteSettings = container.lookup('site-settings:main');
+    const siteSettings = container.lookup("site-settings:main");
-    
+
     if (!siteSettings.custom_wizard_enabled || !messageBus) return;
 
     messageBus.subscribe("/redirect_to_wizard", function (wizardId) {
-      const wizardUrl = window.location.origin + '/w/' + wizardId;
+      const wizardUrl = window.location.origin + "/w/" + wizardId;
       window.location.href = wizardUrl;
     });
 
     ApplicationRoute.reopen({
       actions: {
         willTransition(transition) {
-          const redirectToWizard = this.get('currentUser.redirect_to_wizard');
+          const redirectToWizard = this.get("currentUser.redirect_to_wizard");
-          const excludedPaths = Discourse.SiteSettings.wizard_redirect_exclude_paths.split('|').concat(['loading']);
+          const excludedPaths = Discourse.SiteSettings.wizard_redirect_exclude_paths
+            .split("|")
+            .concat(["loading"]);
 
-          if (redirectToWizard && (!transition.intent.name || !excludedPaths.find((p) => {
+          if (
-            return transition.intent.name.indexOf(p) > -1;
+            redirectToWizard &&
-          }))) {
+            (!transition.intent.name ||
+              !excludedPaths.find((p) => {
+                return transition.intent.name.indexOf(p) > -1;
+              }))
+          ) {
             transition.abort();
-            window.location = '/w/' + redirectToWizard.dasherize();
+            window.location = "/w/" + redirectToWizard.dasherize();
           }
 
           return this._super(transition);
-        }
+        },
-      }
+      },
-    })
+    });
-  }
+  },
 };

assets/javascripts/discourse/lib/wizard-json.js.es6

@@ -1,14 +1,14 @@
-import { listProperties, camelCase, snakeCase } from '../lib/wizard';
+import { listProperties, camelCase, snakeCase } from "../lib/wizard";
-import wizardSchema from '../lib/wizard-schema';
+import wizardSchema from "../lib/wizard-schema";
-import EmberObject from '@ember/object';
+import EmberObject from "@ember/object";
 import { A } from "@ember/array";
 
 function present(val) {
   if (val === null || val === undefined) {
     return false;
-  } else if (typeof val === 'object') {
+  } else if (typeof val === "object") {
     return Object.keys(val).length !== 0;
-  } else if (typeof val === 'string' || val.constructor === Array) {
+  } else if (typeof val === "string" || val.constructor === Array) {
     return val && val.length;
   } else {
     return false;
@@ -20,51 +20,44 @@ function mapped(property, type) {
 }
 
 function castCase(property, value) {
-  return property.indexOf('_type') > -1 ? camelCase(value) : value;
+  return property.indexOf("_type") > -1 ? camelCase(value) : value;
 }
 
 function buildProperty(json, property, type) {
   let value = json[property];
-  
+
-  if (mapped(property, type) &&
+  if (mapped(property, type) && present(value) && value.constructor === Array) {
-      present(value) &&
-      value.constructor === Array) {
-    
     let inputs = [];
-        
+
-    value.forEach(inputJson => {
+    value.forEach((inputJson) => {
-      let input = {}
+      let input = {};
-      
+
-      Object.keys(inputJson).forEach(inputKey => {
+      Object.keys(inputJson).forEach((inputKey) => {
-        if (inputKey === 'pairs') {
+        if (inputKey === "pairs") {
           let pairs = [];
           let pairCount = inputJson.pairs.length;
-          
+
-          inputJson.pairs.forEach(pairJson => {
+          inputJson.pairs.forEach((pairJson) => {
             let pair = {};
-            
+
-            Object.keys(pairJson).forEach(pairKey => {
+            Object.keys(pairJson).forEach((pairKey) => {
-              pair[pairKey] = castCase(pairKey,  pairJson[pairKey]);
+              pair[pairKey] = castCase(pairKey, pairJson[pairKey]);
             });
-            
+
             pair.pairCount = pairCount;
-            
+
-            pairs.push(
+            pairs.push(EmberObject.create(pair));
-              EmberObject.create(pair)
-            );
           });
-          
+
           input.pairs = pairs;
         } else {
-          input[inputKey] = castCase(inputKey,  inputJson[inputKey]);
+          input[inputKey] = castCase(inputKey, inputJson[inputKey]);
         }
       });
-      
+
-      inputs.push(
+      inputs.push(EmberObject.create(input));
-        EmberObject.create(input)
-      );
     });
-    
+
     return A(inputs);
   } else {
     return value;
@@ -73,48 +66,48 @@ function buildProperty(json, property, type) {
 
 function buildObject(json, type) {
   let props = {
-    isNew: false
+    isNew: false,
-  }
+  };
-  
+
-  Object.keys(json).forEach(prop => {
+  Object.keys(json).forEach((prop) => {
-    props[prop] = buildProperty(json, prop, type)
+    props[prop] = buildProperty(json, prop, type);
   });
-    
+
   return EmberObject.create(props);
 }
 
 function buildObjectArray(json, type) {
   let array = A();
-  
+
   if (present(json)) {
     json.forEach((objJson) => {
       let object = buildObject(objJson, type);
-      
+
       if (hasAdvancedProperties(object, type)) {
-        object.set('showAdvanced', true);
+        object.set("showAdvanced", true);
       }
-      
+
       array.pushObject(object);
     });
   }
-  
+
   return array;
 }
 
 function buildBasicProperties(json, type, props) {
   listProperties(type).forEach((p) => {
     props[p] = buildProperty(json, p, type);
-    
+
     if (hasAdvancedProperties(json, type)) {
       props.showAdvanced = true;
     }
   });
-  
+
   return props;
 }
 
 function hasAdvancedProperties(object, type) {
-  return Object.keys(object).some(p => {
+  return Object.keys(object).some((p) => {
     return wizardSchema[type].advanced.indexOf(p) > -1 && present(object[p]);
   });
 }
@@ -122,59 +115,55 @@ function hasAdvancedProperties(object, type) {
 /// to be removed: necessary due to action array being moved from step to wizard
 function actionPatch(json) {
   let actions = json.actions || [];
-  
+
-  json.steps.forEach(step => {
+  json.steps.forEach((step) => {
     if (step.actions && step.actions.length) {
-      step.actions.forEach(action => {
+      step.actions.forEach((action) => {
-        action.run_after = 'wizard_completion';
+        action.run_after = "wizard_completion";
         actions.push(action);
       });
     }
   });
-  
+
   json.actions = actions;
-  
+
   return json;
 }
 ///
 
 function buildProperties(json) {
-  let props = { 
+  let props = {
     steps: A(),
-    actions: A()
+    actions: A(),
   };
-        
+
   if (present(json)) {
     props.existingId = true;
-    props = buildBasicProperties(json, 'wizard', props);
+    props = buildBasicProperties(json, "wizard", props);
-    
+
     if (present(json.steps)) {
       json.steps.forEach((stepJson) => {
         let stepProps = {
-          isNew: false
+          isNew: false,
         };
-  
+
-        stepProps = buildBasicProperties(stepJson, 'step', stepProps);
+        stepProps = buildBasicProperties(stepJson, "step", stepProps);
-        stepProps.fields = buildObjectArray(stepJson.fields, 'field');
+        stepProps.fields = buildObjectArray(stepJson.fields, "field");
-        
+
         props.steps.pushObject(EmberObject.create(stepProps));
       });
-    };
+    }
 
     json = actionPatch(json); // to be removed - see above
-    
+
-    props.actions = buildObjectArray(json.actions, 'action');
+    props.actions = buildObjectArray(json.actions, "action");
   } else {
-    listProperties('wizard').forEach(prop => {
+    listProperties("wizard").forEach((prop) => {
       props[prop] = wizardSchema.wizard.basic[prop];
     });
   }
-    
+
   return props;
 }
 
-export {
+export { buildProperties, present, mapped };
-  buildProperties,
-  present,
-  mapped
-}

assets/javascripts/discourse/lib/wizard-mapper.js.es6

@@ -5,71 +5,71 @@ import I18n from "I18n";
 // Inputs
 
 function defaultInputType(options = {}) {
-  return options.inputTypes.split(',')[0];
+  return options.inputTypes.split(",")[0];
 }
 
 function mapInputTypes(types) {
-  return types.map(function(type) {
+  return types.map(function (type) {
     return {
-      id: type, 
+      id: type,
-      name: I18n.t(`admin.wizard.input.${type}.name`) 
+      name: I18n.t(`admin.wizard.input.${type}.name`),
     };
   });
 }
 
 function inputTypesContent(options = {}) {
-  return options.inputTypes ?
+  return options.inputTypes
-    mapInputTypes(options.inputTypes.split(',')) :
+    ? mapInputTypes(options.inputTypes.split(","))
-    mapInputTypes(selectableInputTypes);
+    : mapInputTypes(selectableInputTypes);
 }
 
 // connectorTypes
 
 const connectors = {
   pair: [
-    'equal',
+    "equal",
-    'greater',
+    "greater",
-    'less',
+    "less",
-    'greater_or_equal',
+    "greater_or_equal",
-    'less_or_equal',
+    "less_or_equal",
-    'regex',
+    "regex",
-    'is'
+    "is",
   ],
-  output: [
+  output: ["then", "set"],
-    'then',
+};
-    'set',
-  ],
-}
 
-function defaultConnector(connectorType, inputType, options={}) {
+function defaultConnector(connectorType, inputType, options = {}) {
-  if (connectorType === 'input') {
+  if (connectorType === "input") {
     return defaultInputType(options);
   }
-  if (connectorType === 'pair') {
+  if (connectorType === "pair") {
-    if (inputType === 'conditional') return 'equal';
+    if (inputType === "conditional") return "equal";
-    if (inputType === 'association') return 'association';
+    if (inputType === "association") return "association";
-    if (inputType === 'validation') return 'equal';
+    if (inputType === "validation") return "equal";
   }
-  if (connectorType === 'output') {
+  if (connectorType === "output") {
-    if (inputType === 'conditional') return 'then';
+    if (inputType === "conditional") return "then";
-    if (inputType === 'assignment') return 'set';
+    if (inputType === "assignment") return "set";
   }
-  return 'equal';
+  return "equal";
 }
 
 function connectorContent(connectorType, inputType, opts) {
   let connector = opts[`${connectorType}Connector`];
-  
+
-  if ((!connector && connectorType === 'output') || inputType === 'association') {
+  if (
+    (!connector && connectorType === "output") ||
+    inputType === "association"
+  ) {
     connector = defaultConnector(connectorType, inputType);
   }
-  
+
   let content = connector ? [connector] : connectors[connectorType];
-  
+
-  return content.map(function(item) {
+  return content.map(function (item) {
     return {
-      id: item, 
+      id: item,
-      name: I18n.t(`admin.wizard.connector.${item}`) 
+      name: I18n.t(`admin.wizard.connector.${item}`),
     };
   });
 }
@@ -77,38 +77,39 @@ function connectorContent(connectorType, inputType, opts) {
 // Selectors
 
 const selectionTypes = [
-  'text',
+  "text",
-  'list',
+  "list",
-  'wizardField',
+  "wizardField",
-  'wizardAction',
+  "wizardAction",
-  'userField',
+  "userField",
-  'userFieldOptions',
+  "userFieldOptions",
-  'group',
+  "group",
-  'category',
+  "category",
-  'tag',
+  "tag",
-  'user',
+  "user",
-  'customField'
+  "customField",
-]
+];
 
 function defaultSelectionType(inputType, options = {}) {
   if (options[`${inputType}DefaultSelection`]) {
     return options[`${inputType}DefaultSelection`];
   }
-    
+
   let type = selectionTypes[0];
-  
+
   for (let t of selectionTypes) {
     let inputTypes = options[`${t}Selection`];
-                
+
-    if (inputTypes === true || 
+    if (
-        ((typeof inputTypes === 'string') &&
+      inputTypes === true ||
-         inputTypes.split(',').indexOf(inputType) > -1)) {
+      (typeof inputTypes === "string" &&
-      
+        inputTypes.split(",").indexOf(inputType) > -1)
+    ) {
       type = t;
       break;
     }
   }
-    
+
   return type;
 }
 
@@ -118,46 +119,42 @@ function newPair(inputType, options = {}) {
   let params = {
     index: options.index,
     pairCount: options.pairCount,
-    key: '',
+    key: "",
-    key_type: defaultSelectionType('key', options),
+    key_type: defaultSelectionType("key", options),
-    value: '',
+    value: "",
-    value_type: defaultSelectionType('value', options),
+    value_type: defaultSelectionType("value", options),
-    connector: defaultConnector('pair', inputType, options)
+    connector: defaultConnector("pair", inputType, options),
-  }
+  };
-    
+
   return EmberObject.create(params);
 }
 
 function newInput(options = {}, count) {
   const inputType = defaultInputType(options);
-      
+
   let params = {
     type: inputType,
-    pairs: A(
+    pairs: A([
-      [
+      newPair(
-        newPair(
+        inputType,
-          inputType,
+        Object.assign({}, options, { index: 0, pairCount: 1 })
-          Object.assign({},
+      ),
-            options,
+    ]),
-            { index: 0, pairCount: 1 }
+  };
-          )
+
-        )
-      ]
-    )
-  }
-    
   if (count > 0) {
     params.connector = options.inputConnector;
   }
-  
+
-  if (['conditional', 'assignment'].indexOf(inputType) > -1 ||
+  if (
-      options.outputDefaultSelection ||
+    ["conditional", "assignment"].indexOf(inputType) > -1 ||
-      options.outputConnector) {
+    options.outputDefaultSelection ||
-    
+    options.outputConnector
-    params['output_type'] = defaultSelectionType('output', options);
+  ) {
-    params['output_connector'] = defaultConnector('output', inputType, options);
+    params["output_type"] = defaultSelectionType("output", options);
+    params["output_connector"] = defaultConnector("output", inputType, options);
   }
-    
+
   return EmberObject.create(params);
 }
 
@@ -169,5 +166,5 @@ export {
   inputTypesContent,
   selectionTypes,
   newInput,
-  newPair
+  newPair,
-}
+};

assets/javascripts/discourse/lib/wizard-schema.js.es6

@@ -14,30 +14,24 @@ const wizard = {
     prompt_completion: null,
     restart_on_revisit: null,
     theme_id: null,
-    permitted: null
+    permitted: null,
   },
-  mapped: [
+  mapped: ["permitted"],
-    'permitted'
+  advanced: ["restart_on_revisit"],
-  ],
+  required: ["id"],
-  advanced: [
-    'restart_on_revisit',
-  ],
-  required: [
-    'id',
-  ],
   dependent: {
-    after_time: 'after_time_scheduled'
+    after_time: "after_time_scheduled",
   },
   objectArrays: {
     step: {
-      property: 'steps',
+      property: "steps",
-      required: false
+      required: false,
     },
     action: {
-      property: 'actions',
+      property: "actions",
-      required: false
+      required: false,
-    }
+    },
-  }
+  },
 };
 
 const step = {
@@ -49,28 +43,19 @@ const step = {
     raw_description: null,
     required_data: null,
     required_data_message: null,
-    permitted_params: null
+    permitted_params: null,
-  },
-  mapped: [
-    'required_data',
-    'permitted_params'
-  ],
-  advanced: [
-    'required_data',
-    'permitted_params'
-  ],
-  required: [
-    'id'
-  ],
-  dependent: {
   },
+  mapped: ["required_data", "permitted_params"],
+  advanced: ["required_data", "permitted_params"],
+  required: ["id"],
+  dependent: {},
   objectArrays: {
     field: {
-      property: 'fields',
+      property: "fields",
-      required: false
+      required: false,
-    }
+    },
-  }
+  },
-}
+};
 
 const field = {
   basic: {
@@ -80,32 +65,21 @@ const field = {
     description: null,
     required: null,
     key: null,
-    type: null
+    type: null,
   },
   types: {},
-  mapped: [
+  mapped: ["prefill", "content"],
-    'prefill',
+  advanced: ["property", "key"],
-    'content'
+  required: ["id", "type"],
-  ],
+  dependent: {},
-  advanced: [
+  objectArrays: {},
-    'property',
+};
-    'key'
-  ],
-  required: [
-    'id',
-    'type'
-  ],
-  dependent: {
-  },
-  objectArrays: {
-  }
-}
 
 const action = {
   basic: {
     id: null,
-    run_after: 'wizard_completion',
+    run_after: "wizard_completion",
-    type: null
+    type: null,
   },
   types: {
     create_topic: {
@@ -129,7 +103,7 @@ const action = {
       custom_fields: null,
       required: null,
       recipient: null,
-      suppress_notifications: null
+      suppress_notifications: null,
     },
     open_composer: {
       title: null,
@@ -138,30 +112,30 @@ const action = {
       post_template: null,
       category: null,
       tags: null,
-      custom_fields: null
+      custom_fields: null,
     },
     update_profile: {
       profile_updates: null,
-      custom_fields: null
+      custom_fields: null,
     },
     watch_categories: {
       categories: null,
       notification_level: null,
       mute_remainder: null,
       wizard_user: true,
-      usernames: null
+      usernames: null,
     },
     send_to_api: {
       api: null,
       api_endpoint: null,
-      api_body: null
+      api_body: null,
     },
     add_to_group: {
-      group: null
+      group: null,
     },
     route_to: {
       url: null,
-      code: null
+      code: null,
     },
     create_category: {
       name: null,
@@ -170,7 +144,7 @@ const action = {
       text_color: "FFFFFF",
       parent_category_id: null,
       permissions: null,
-      custom_fields: null
+      custom_fields: null,
     },
     create_group: {
       name: null,
@@ -184,61 +158,56 @@ const action = {
       messageable_level: null,
       visibility_level: null,
       members_visibility_level: null,
-      custom_fields: null
+      custom_fields: null,
-    }
+    },
   },
   mapped: [
-    'title',
+    "title",
-    'category',
+    "category",
-    'tags',
+    "tags",
-    'visible',
+    "visible",
-    'custom_fields',
+    "custom_fields",
-    'required',
+    "required",
-    'recipient',
+    "recipient",
-    'profile_updates',
+    "profile_updates",
-    'group',
+    "group",
-    'url',
+    "url",
-    'categories',
+    "categories",
-    'mute_remainder',
+    "mute_remainder",
-    'name',
+    "name",
-    'slug',
+    "slug",
-    'color',
+    "color",
-    'text_color',
+    "text_color",
-    'parent_category_id',
+    "parent_category_id",
-    'permissions',
+    "permissions",
-    'full_name',
+    "full_name",
-    'bio_raw',
+    "bio_raw",
-    'owner_usernames',
+    "owner_usernames",
-    'usernames',
+    "usernames",
-    'grant_trust_level',
+    "grant_trust_level",
-    'mentionable_level',
+    "mentionable_level",
-    'messageable_level',
+    "messageable_level",
-    'visibility_level',
+    "visibility_level",
-    'members_visibility_level'
+    "members_visibility_level",
   ],
   advanced: [
-    'code',
+    "code",
-    'custom_fields',
+    "custom_fields",
-    'skip_redirect',
+    "skip_redirect",
-    'suppress_notifications',
+    "suppress_notifications",
-    'required'
+    "required",
   ],
-  required: [
+  required: ["id", "type"],
-    'id',
+  dependent: {},
-    'type'
+  objectArrays: {},
-  ],
+};
-  dependent: {
-  },
-  objectArrays: {
-  }
-}
 
 const wizardSchema = {
   wizard,
   step,
   field,
-  action
+  action,
-}
+};
 
 export function buildFieldTypes(types) {
   wizardSchema.field.types = types;
@@ -252,34 +221,34 @@ if (Discourse.SiteSettings.wizard_apis_enabled) {
   wizardSchema.action.types.send_to_api = {
     api: null,
     api_endpoint: null,
-    api_body: null
+    api_body: null,
-  }
+  };
 }
 
-export function setWizardDefaults(obj, itemType, opts={}) {
+export function setWizardDefaults(obj, itemType, opts = {}) {
   const objSchema = wizardSchema[itemType];
   const basicDefaults = objSchema.basic;
-  
+
-  Object.keys(basicDefaults).forEach(property => {
+  Object.keys(basicDefaults).forEach((property) => {
     let defaultValue = get(basicDefaults, property);
     if (defaultValue) {
       set(obj, property, defaultValue);
     }
   });
-  
+
   if (objSchema.types) {
     const typeDefaults = objSchema.types[obj.type];
-    
+
     if (typeDefaults) {
-      Object.keys(typeDefaults).forEach(property => {
+      Object.keys(typeDefaults).forEach((property) => {
         if (typeDefaults.hasOwnProperty(property)) {
           set(obj, property, get(typeDefaults, property));
-        }        
+        }
       });
     }
   }
-  
+
   return obj;
 }
 
-export default wizardSchema;
+export default wizardSchema;

assets/javascripts/discourse/lib/wizard.js.es6

@@ -1,110 +1,111 @@
 import EmberObject from "@ember/object";
-import wizardSchema from './wizard-schema';
+import wizardSchema from "./wizard-schema";
 
 function selectKitContent(content) {
-  return content.map(i => ({id: i, name: i}));
+  return content.map((i) => ({ id: i, name: i }));
 }
 
 function generateName(id) {
-  return id ? sentenceCase(id) : '';
+  return id ? sentenceCase(id) : "";
 }
 
-function generateId(name, opts={}) {
+function generateId(name, opts = {}) {
-  return name ? snakeCase(name) : '';
+  return name ? snakeCase(name) : "";
 }
 
 function sentenceCase(string) {
-  return string.replace(/[_\-]+/g, ' ')
+  return string
+    .replace(/[_\-]+/g, " ")
     .toLowerCase()
     .replace(/(^\w|\b\w)/g, (m) => m.toUpperCase());
 }
 
 function snakeCase(string) {
-  return string.match(/[A-Z]{2,}(?=[A-Z][a-z]+[0-9]*|\b)|[A-Z]?[a-z]+[0-9]*|[A-Z]|[0-9]+/g)
+  return string
-    .map(x => x.toLowerCase())
+    .match(/[A-Z]{2,}(?=[A-Z][a-z]+[0-9]*|\b)|[A-Z]?[a-z]+[0-9]*|[A-Z]|[0-9]+/g)
-    .join('_');
+    .map((x) => x.toLowerCase())
+    .join("_");
 }
 
 function camelCase(string) {
-  return string.replace(/([-_][a-z])/ig, ($1) => {
+  return string.replace(/([-_][a-z])/gi, ($1) => {
-    return $1.toUpperCase()
+    return $1.toUpperCase().replace("-", "").replace("_", "");
-      .replace('-', '')
-      .replace('_', '');
   });
 }
 
 const userProperties = [
-  'name',
+  "name",
-  'username',
+  "username",
-  'email',
+  "email",
-  'avatar',
+  "avatar",
-  'date_of_birth',
+  "date_of_birth",
-  'title',
+  "title",
-  'profile_background',
+  "profile_background",
-  'card_background',
+  "card_background",
-  'locale',
+  "locale",
-  'location',
+  "location",
-  'website',
+  "website",
-  'bio_raw',
+  "bio_raw",
-  'trust_level',
+  "trust_level",
-  'email_level',
+  "email_level",
-  'email_messages_level',
+  "email_messages_level",
-  'email_digests'
+  "email_digests",
 ];
 
 const notificationLevels = [
-  'regular',
+  "regular",
-  'watching',
+  "watching",
-  'tracking',
+  "tracking",
-  'watching_first_post',
+  "watching_first_post",
-  'muted'
+  "muted",
 ];
 
-function listProperties(type, opts={}) {
+function listProperties(type, opts = {}) {
   let properties = Object.keys(wizardSchema[type].basic);
-  
+
   const types = wizardSchema[type].types;
-  
+
   if (types) {
     let typeProperties = [];
-    
+
     if (opts.allTypes) {
-      Object.keys(types).forEach(type => {
+      Object.keys(types).forEach((type) => {
         typeProperties = typeProperties.concat(Object.keys(types[type]));
       });
     } else if (opts.objectType && types[opts.objectType]) {
       typeProperties = Object.keys(types[opts.objectType]);
     }
-    
+
     properties = properties.concat(typeProperties);
   }
-    
+
   return properties;
 }
 
 function wizardFieldList(steps = [], opts = {}) {
   let upToIndex = null;
-  
+
   if (opts.upTo) {
-    upToIndex = steps.map((s) => (s.id)).indexOf(opts.upTo);
+    upToIndex = steps.map((s) => s.id).indexOf(opts.upTo);
   }
-     
+
   return steps.reduce((result, step, index) => {
     let fields = step.fields;
-  
+
     if (fields && fields.length > 0) {
-            
       if (upToIndex === null || index < upToIndex) {
-        result.push(...fields.map((field) => {
+        result.push(
-          return EmberObject.create({
+          ...fields.map((field) => {
-            id: field.id,
+            return EmberObject.create({
-            label: `${field.label} (${field.id})`,
+              id: field.id,
-            type: field.type
+              label: `${field.label} (${field.id})`,
-          });
+              type: field.type,
-        }));
+            });
+          })
+        );
       }
     }
-    
+
     return result;
   }, []);
 }
@@ -118,5 +119,5 @@ export {
   userProperties,
   listProperties,
   notificationLevels,
-  wizardFieldList
+  wizardFieldList,
 };

assets/javascripts/discourse/mixins/undo-changes.js.es6

@@ -1,9 +1,9 @@
-import { listProperties } from '../lib/wizard';
+import { listProperties } from "../lib/wizard";
-import { default as wizardSchema } from '../lib/wizard-schema';
+import { default as wizardSchema } from "../lib/wizard-schema";
 import { set, get } from "@ember/object";
 import Mixin from "@ember/object/mixin";
-import { observes } from 'discourse-common/utils/decorators';
+import { observes } from "discourse-common/utils/decorators";
-import { deepEqual } from 'discourse-common/lib/object';
+import { deepEqual } from "discourse-common/lib/object";
 
 export default Mixin.create({
   didInsertElement() {
@@ -14,9 +14,9 @@ export default Mixin.create({
 
     this.setProperties({
       originalObject: JSON.parse(JSON.stringify(obj)),
-      undoIcon: obj.isNew ? 'times' : 'undo',
+      undoIcon: obj.isNew ? "times" : "undo",
-      undoKey: `admin.wizard.${obj.isNew ? 'clear' : 'undo'}`
+      undoKey: `admin.wizard.${obj.isNew ? "clear" : "undo"}`,
-    })
+    });
   },
 
   willDestroyElement() {
@@ -24,33 +24,33 @@ export default Mixin.create({
     this.removeObservers();
   },
 
-  removeObservers(objType=null) {
+  removeObservers(objType = null) {
     const componentType = this.componentType;
     const obj = this.get(componentType);
 
     let opts = {
-      objectType: objType || obj.type
+      objectType: objType || obj.type,
-    }
+    };
 
-    listProperties(componentType, opts).forEach(property => {
+    listProperties(componentType, opts).forEach((property) => {
       obj.removeObserver(property, this, this.toggleUndo);
     });
   },
 
-  setupObservers(objType=null) {
+  setupObservers(objType = null) {
     const componentType = this.componentType;
     const obj = this.get(componentType);
 
     let opts = {
-      objectType: objType || obj.type
+      objectType: objType || obj.type,
-    }
+    };
 
-    listProperties(componentType, opts).forEach(property => {
+    listProperties(componentType, opts).forEach((property) => {
       obj.addObserver(property, this, this.toggleUndo);
     });
   },
 
-  revertToOriginal(revertBasic=false) {
+  revertToOriginal(revertBasic = false) {
     const original = JSON.parse(JSON.stringify(this.originalObject));
     const componentType = this.componentType;
     const obj = this.get(componentType);
@@ -58,7 +58,7 @@ export default Mixin.create({
     const basicDefaults = objSchema.basic;
 
     if (revertBasic) {
-      Object.keys(basicDefaults).forEach(property => {
+      Object.keys(basicDefaults).forEach((property) => {
         let value;
 
         if (original.hasOwnProperty(property)) {
@@ -74,7 +74,7 @@ export default Mixin.create({
     if (objSchema.types && obj.type) {
       let typeDefaults = objSchema.types[obj.type];
 
-      Object.keys(typeDefaults).forEach(property => {
+      Object.keys(typeDefaults).forEach((property) => {
         let value;
 
         if (original.type === obj.type && original.hasOwnProperty(property)) {
@@ -91,36 +91,36 @@ export default Mixin.create({
   toggleUndo() {
     const current = this.get(this.componentType);
     const original = this.originalObject;
-    this.set('showUndo', !deepEqual(current, original));
+    this.set("showUndo", !deepEqual(current, original));
   },
 
   actions: {
     undoChanges() {
       const componentType = this.componentType;
-      const original = this.get('originalObject');
+      const original = this.get("originalObject");
       const obj = this.get(componentType);
 
       this.removeObservers(obj.type);
       this.revertToOriginal(true);
-      this.set('showUndo', false);
+      this.set("showUndo", false);
       this.setupObservers(this.get(componentType).type);
     },
 
     changeType(type) {
       const componentType = this.componentType;
-      const original = this.get('originalObject');
+      const original = this.get("originalObject");
       const obj = this.get(componentType);
 
       this.removeObservers(obj.type);
-      obj.set('type', type);
+      obj.set("type", type);
       this.revertToOriginal();
-      this.set('showUndo', type !== original.type);
+      this.set("showUndo", type !== original.type);
       this.setupObservers(type);
     },
 
     mappedFieldUpdated(property, mappedComponent, type) {
       const obj = this.get(this.componentType);
       obj.notifyPropertyChange(property);
-    }
+    },
-  }
+  },
-})
+});

assets/javascripts/discourse/models/custom-wizard-api.js.es6

@@ -1,15 +1,19 @@
-import { ajax } from 'discourse/lib/ajax';
+import { ajax } from "discourse/lib/ajax";
-import { default as discourseComputed } from 'discourse-common/utils/decorators';
+import { default as discourseComputed } from "discourse-common/utils/decorators";
 import EmberObject from "@ember/object";
 import { A } from "@ember/array";
 
 const CustomWizardApi = EmberObject.extend({
-  @discourseComputed('name')
+  @discourseComputed("name")
   redirectUri(name) {
     let nameParam = name.toString().dasherize();
-    const baseUrl = location.protocol+'//'+location.hostname+(location.port ? ':'+location.port: '');
+    const baseUrl =
+      location.protocol +
+      "//" +
+      location.hostname +
+      (location.port ? ":" + location.port : "");
     return baseUrl + `/admin/wizards/apis/${nameParam}/redirect`;
-  }
+  },
 });
 
 CustomWizardApi.reopenClass({
@@ -38,7 +42,7 @@ CustomWizardApi.reopenClass({
       tokenRefreshAt: authorization.token_refresh_at,
       endpoints: A(endpoints),
       isNew: params.isNew,
-      log: params.log
+      log: params.log,
     });
 
     return api;
@@ -46,19 +50,19 @@ CustomWizardApi.reopenClass({
 
   find(name) {
     return ajax(`/admin/wizards/api/${name}`, {
-      type: 'GET'
+      type: "GET",
-    }).then(result => {
+    }).then((result) => {
       return CustomWizardApi.create(result);
     });
   },
 
   list() {
     return ajax("/admin/wizards/api", {
-      type: 'GET'
+      type: "GET",
-    }).then(result => {
+    }).then((result) => {
       return result;
     });
-  }
+  },
 });
 
 export default CustomWizardApi;

assets/javascripts/discourse/models/custom-wizard-custom-field.js.es6

@@ -1,33 +1,33 @@
-import { ajax } from 'discourse/lib/ajax';
+import { ajax } from "discourse/lib/ajax";
-import { popupAjaxError } from 'discourse/lib/ajax-error';
+import { popupAjaxError } from "discourse/lib/ajax-error";
 import EmberObject from "@ember/object";
 import { isEmpty } from "@ember/utils";
 
 const CustomWizardCustomField = EmberObject.extend({
-  isNew: isEmpty('id')
+  isNew: isEmpty("id"),
 });
 
-const basePath = '/admin/wizards/custom-fields';
+const basePath = "/admin/wizards/custom-fields";
 
 CustomWizardCustomField.reopenClass({
   listFields() {
     return ajax(basePath).catch(popupAjaxError);
   },
-  
+
   saveField(customField) {
     return ajax(basePath, {
-      type: 'PUT',
+      type: "PUT",
       data: {
-        custom_field: customField
+        custom_field: customField,
-      }
+      },
     }).catch(popupAjaxError);
   },
-  
+
   destroyField(field) {
     return ajax(`${basePath}/${field.name}`, {
-      type: 'DELETE'
+      type: "DELETE",
     }).catch(popupAjaxError);
-  }
+  },
 });
 
-export default CustomWizardCustomField;
+export default CustomWizardCustomField;

assets/javascripts/discourse/models/custom-wizard-logs.js.es6

@@ -1,17 +1,17 @@
-import { ajax } from 'discourse/lib/ajax';
+import { ajax } from "discourse/lib/ajax";
-import { popupAjaxError } from 'discourse/lib/ajax-error';
+import { popupAjaxError } from "discourse/lib/ajax-error";
 import EmberObject from "@ember/object";
 
 const CustomWizardLogs = EmberObject.extend();
 
 CustomWizardLogs.reopenClass({
   list(page = 0) {
-    return ajax('/admin/wizards/logs', {
+    return ajax("/admin/wizards/logs", {
       data: {
-        page
+        page,
-      }
+      },
     }).catch(popupAjaxError);
-  }
+  },
 });
 
-export default CustomWizardLogs;
+export default CustomWizardLogs;

assets/javascripts/discourse/models/custom-wizard-manager.js.es6

@@ -1,5 +1,5 @@
-import { ajax } from 'discourse/lib/ajax';
+import { ajax } from "discourse/lib/ajax";
-import { popupAjaxError } from 'discourse/lib/ajax-error';
+import { popupAjaxError } from "discourse/lib/ajax-error";
 import EmberObject from "@ember/object";
 
 const CustomWizardManager = EmberObject.extend();
@@ -9,35 +9,35 @@ const basePath = "admin/wizards/manager";
 CustomWizardManager.reopenClass({
   import($formData) {
     return ajax(`/${basePath}/import`, {
-      type: 'POST',
+      type: "POST",
       data: $formData,
       processData: false,
       contentType: false,
     }).catch(popupAjaxError);
   },
-  
+
   export(wizardIds) {
     let url = `${Discourse.BaseUrl}/${basePath}/export?`;
-    
+
     wizardIds.forEach((wizardId, index) => {
-      let step = 'wizard_ids[]=' + wizardId;
+      let step = "wizard_ids[]=" + wizardId;
       if (index !== wizardIds[wizardIds.length - 1]) {
-        step += '&';
+        step += "&";
       }
       url += step;
     });
 
     location.href = url;
   },
-  
+
   destroy(wizardIds) {
     return ajax(`/${basePath}/destroy`, {
       type: "DELETE",
       data: {
-        wizard_ids: wizardIds
+        wizard_ids: wizardIds,
-      }
+      },
     }).catch(popupAjaxError);
-  }
+  },
 });
 
-export default CustomWizardManager;
+export default CustomWizardManager;

assets/javascripts/discourse/models/custom-wizard.js.es6

@@ -1,32 +1,32 @@
-import { ajax } from 'discourse/lib/ajax';
+import { ajax } from "discourse/lib/ajax";
 import EmberObject from "@ember/object";
-import { buildProperties, present, mapped } from '../lib/wizard-json';
+import { buildProperties, present, mapped } from "../lib/wizard-json";
-import { listProperties, camelCase, snakeCase } from '../lib/wizard';
+import { listProperties, camelCase, snakeCase } from "../lib/wizard";
-import wizardSchema from '../lib/wizard-schema';
+import wizardSchema from "../lib/wizard-schema";
 import { Promise } from "rsvp";
-import { popupAjaxError } from 'discourse/lib/ajax-error';
+import { popupAjaxError } from "discourse/lib/ajax-error";
 
 const CustomWizard = EmberObject.extend({
   save(opts) {
-    return new Promise((resolve, reject) => {      
+    return new Promise((resolve, reject) => {
-      let wizard = this.buildJson(this, 'wizard');
+      let wizard = this.buildJson(this, "wizard");
-      
+
       if (wizard.error) {
         reject(wizard);
       }
-      
+
       let data = {
-        wizard
+        wizard,
       };
-      
+
       if (opts.create) {
         data.create = true;
       }
-            
+
       ajax(`/admin/wizards/wizard/${wizard.id}`, {
-        type: 'PUT',
+        type: "PUT",
         contentType: "application/json",
-        data: JSON.stringify(data)
+        data: JSON.stringify(data),
       }).then((result) => {
         if (result.error) {
           reject(result);
@@ -39,53 +39,55 @@ const CustomWizard = EmberObject.extend({
 
   buildJson(object, type, result = {}) {
     let objectType = object.type || null;
-    
+
     if (wizardSchema[type].types) {
       if (!objectType) {
         result.error = {
-          type: 'required',
+          type: "required",
-          params: { type, property: 'type' }
+          params: { type, property: "type" },
-        }
+        };
         return result;
       }
     }
-            
+
     for (let property of listProperties(type, { objectType })) {
       let value = object.get(property);
-      
+
       result = this.validateValue(property, value, object, type, result);
-      
+
       if (result.error) {
         break;
       }
-        
+
       if (mapped(property, type)) {
         value = this.buildMappedJson(value);
       }
-            
+
       if (value !== undefined && value !== null) {
         result[property] = value;
       }
-    };
+    }
-    
+
     if (!result.error) {
-      for (let arrayObjectType of Object.keys(wizardSchema[type].objectArrays)) {
+      for (let arrayObjectType of Object.keys(
+        wizardSchema[type].objectArrays
+      )) {
         let arraySchema = wizardSchema[type].objectArrays[arrayObjectType];
         let objectArray = object.get(arraySchema.property);
-                
+
         if (arraySchema.required && !present(objectArray)) {
           result.error = {
-            type: 'required',
+            type: "required",
-            params: { type, property: arraySchema.property }
+            params: { type, property: arraySchema.property },
-          }
+          };
           break;
         }
 
         result[arraySchema.property] = [];
-                
+
         for (let item of objectArray) {
           let itemProps = this.buildJson(item, arrayObjectType);
-                    
+
           if (itemProps.error) {
             result.error = itemProps.error;
             break;
@@ -93,115 +95,119 @@ const CustomWizard = EmberObject.extend({
             result[arraySchema.property].push(itemProps);
           }
         }
-      };
+      }
     }
-          
+
     return result;
   },
-  
+
   validateValue(property, value, object, type, result) {
     if (wizardSchema[type].required.indexOf(property) > -1 && !value) {
       result.error = {
-        type: 'required',
+        type: "required",
-        params: { type, property }
+        params: { type, property },
-      }
+      };
     }
-    
+
     let dependent = wizardSchema[type].dependent[property];
     if (dependent && value && !object[dependent]) {
       result.error = {
-        type: 'dependent',
+        type: "dependent",
-        params: { property, dependent }
+        params: { property, dependent },
-      }
+      };
     }
-    
+
-    if (property === 'api_body') {
+    if (property === "api_body") {
       try {
         value = JSON.parse(value);
       } catch (e) {
         result.error = {
-          type: 'invalid',
+          type: "invalid",
-          params: { type, property }
+          params: { type, property },
-        }
+        };
       }
     }
-    
+
     return result;
   },
 
   buildMappedJson(inputs) {
     if (!inputs || !inputs.length) return false;
-    
+
     let result = [];
-      
+
-    inputs.forEach(inpt => {
+    inputs.forEach((inpt) => {
       let input = {
         type: inpt.type,
       };
-      
+
       if (inpt.connector) {
         input.connector = inpt.connector;
       }
-          
+
       if (present(inpt.output)) {
         input.output = inpt.output;
         input.output_type = snakeCase(inpt.output_type);
         input.output_connector = inpt.output_connector;
       }
-      
+
       if (present(inpt.pairs)) {
         input.pairs = [];
-        
+
-        inpt.pairs.forEach(pr => {                
+        inpt.pairs.forEach((pr) => {
           if (present(pr.key) && present(pr.value)) {
-            
             let pairParams = {
               index: pr.index,
               key: pr.key,
               key_type: snakeCase(pr.key_type),
               value: pr.value,
               value_type: snakeCase(pr.value_type),
-              connector: pr.connector
+              connector: pr.connector,
-            }
+            };
-                      
+
             input.pairs.push(pairParams);
           }
         });
       }
-          
+
-      if ((input.type === 'assignment' && present(input.output)) ||
+      if (
-          present(input.pairs)) {
+        (input.type === "assignment" && present(input.output)) ||
-        
+        present(input.pairs)
+      ) {
         result.push(input);
       }
     });
-    
+
     if (!result.length) {
       result = false;
     }
-      
+
     return result;
   },
 
   remove() {
     return ajax(`/admin/wizards/wizard/${this.id}`, {
-      type: 'DELETE'
+      type: "DELETE",
-    }).then(() => this.destroy()).catch(popupAjaxError);
+    })
-  }
+      .then(() => this.destroy())
+      .catch(popupAjaxError);
+  },
 });
 
 CustomWizard.reopenClass({
   all() {
     return ajax("/admin/wizards/wizard", {
-      type: 'GET'
+      type: "GET",
-    }).then(result => {
+    })
-      return result.wizard_list;
+      .then((result) => {
-    }).catch(popupAjaxError);
+        return result.wizard_list;
+      })
+      .catch(popupAjaxError);
   },
 
   submissions(wizardId) {
     return ajax(`/admin/wizards/submissions/${wizardId}`, {
-      type: "GET"
+      type: "GET",
     }).catch(popupAjaxError);
   },
 
@@ -209,7 +215,7 @@ CustomWizard.reopenClass({
     const wizard = this._super.apply(this);
     wizard.setProperties(buildProperties(wizardJson));
     return wizard;
-  }
+  },
 });
 
 export default CustomWizard;

assets/javascripts/discourse/routes/admin-wizards-api-show.js.es6

@@ -1,16 +1,16 @@
-import CustomWizardApi from '../models/custom-wizard-api';
+import CustomWizardApi from "../models/custom-wizard-api";
 import DiscourseRoute from "discourse/routes/discourse";
 
 export default DiscourseRoute.extend({
   model(params) {
-    if (params.name === 'create') {
+    if (params.name === "create") {
       return CustomWizardApi.create({ isNew: true });
     } else {
       return CustomWizardApi.find(params.name);
     }
   },
 
-  setupController(controller, model){
+  setupController(controller, model) {
     controller.set("api", model);
-  }
+  },
 });

assets/javascripts/discourse/routes/admin-wizards-api.js.es6

@@ -1,45 +1,44 @@
 import DiscourseRoute from "discourse/routes/discourse";
-import CustomWizardApi from '../models/custom-wizard-api';
+import CustomWizardApi from "../models/custom-wizard-api";
 
 export default DiscourseRoute.extend({
   model() {
     return CustomWizardApi.list();
   },
-  
+
   setupController(controller, model) {
-    const showParams = this.paramsFor('adminWizardsApiShow');
+    const showParams = this.paramsFor("adminWizardsApiShow");
-    const apiName = showParams.name == 'create' ? null : showParams.name;
+    const apiName = showParams.name == "create" ? null : showParams.name;
-    const apiList = (model || []).map(api => {
+    const apiList = (model || []).map((api) => {
       return {
         id: api.name,
-        name: api.title
+        name: api.title,
-      }
+      };
     });
-        
+
     controller.setProperties({
       apiName,
-      apiList
+      apiList,
-    })
+    });
   },
-  
+
   actions: {
     changeApi(apiName) {
-      this.controllerFor('adminWizardsApi').set('apiName', apiName);
+      this.controllerFor("adminWizardsApi").set("apiName", apiName);
-      this.transitionTo('adminWizardsApiShow', apiName);
+      this.transitionTo("adminWizardsApiShow", apiName);
     },
-    
+
     afterDestroy() {
-      this.transitionTo('adminWizardsApi').then(() => this.refresh());
+      this.transitionTo("adminWizardsApi").then(() => this.refresh());
     },
-    
+
     afterSave(apiName) {
-      this.refresh().then(() => this.send('changeApi', apiName));
+      this.refresh().then(() => this.send("changeApi", apiName));
     },
-    
+
     createApi() {
-      this.controllerFor('adminWizardsApi').set('apiName', 'create');
+      this.controllerFor("adminWizardsApi").set("apiName", "create");
-      this.transitionTo('adminWizardsApiShow', 'create');
+      this.transitionTo("adminWizardsApiShow", "create");
-    }
+    },
-  }
+  },
-  
+});
-});

assets/javascripts/discourse/routes/admin-wizards-custom-fields.js.es6

@@ -6,9 +6,9 @@ export default DiscourseRoute.extend({
   model() {
     return CustomWizardCustomField.listFields();
   },
-  
+
   setupController(controller, model) {
     const customFields = A(model || []);
-    controller.set('customFields', customFields);
+    controller.set("customFields", customFields);
-  }
+  },
-});
+});

assets/javascripts/discourse/routes/admin-wizards-logs.js.es6

@@ -1,4 +1,4 @@
-import CustomWizardLogs from '../models/custom-wizard-logs';
+import CustomWizardLogs from "../models/custom-wizard-logs";
 import DiscourseRoute from "discourse/routes/discourse";
 
 export default DiscourseRoute.extend({
@@ -7,6 +7,6 @@ export default DiscourseRoute.extend({
   },
 
   setupController(controller, model) {
-    controller.set('logs', model);
+    controller.set("logs", model);
-  }
+  },
-})
+});

assets/javascripts/discourse/routes/admin-wizards-manager.js.es6

@@ -1,12 +1,12 @@
-import CustomWizard from '../models/custom-wizard';
+import CustomWizard from "../models/custom-wizard";
 import DiscourseRoute from "discourse/routes/discourse";
 
 export default DiscourseRoute.extend({
   model() {
     return CustomWizard.all();
   },
-  
+
   setupController(controller, model) {
-    controller.set('wizards', model)
+    controller.set("wizards", model);
-  }
+  },
 });

assets/javascripts/discourse/routes/admin-wizards-submissions-show.js.es6

@@ -1,4 +1,4 @@
-import CustomWizard from '../models/custom-wizard';
+import CustomWizard from "../models/custom-wizard";
 import DiscourseRoute from "discourse/routes/discourse";
 
 export default DiscourseRoute.extend({
@@ -25,12 +25,12 @@ export default DiscourseRoute.extend({
         });
         submissions.push(submission);
       });
-      
+
       controller.setProperties({
         wizard: model.wizard,
         submissions,
-        fields
+        fields,
       });
     }
-  }
+  },
 });

assets/javascripts/discourse/routes/admin-wizards-submissions.js.es6

@@ -1,24 +1,24 @@
 import DiscourseRoute from "discourse/routes/discourse";
-import { ajax } from 'discourse/lib/ajax';
+import { ajax } from "discourse/lib/ajax";
 
 export default DiscourseRoute.extend({
   model() {
     return ajax(`/admin/wizards/wizard`);
   },
-  
+
   setupController(controller, model) {
-    const showParams = this.paramsFor('adminWizardsSubmissionsShow');
+    const showParams = this.paramsFor("adminWizardsSubmissionsShow");
-        
+
     controller.setProperties({
       wizardId: showParams.wizardId,
-      wizardList: model.wizard_list
+      wizardList: model.wizard_list,
-    })
+    });
   },
-  
+
   actions: {
     changeWizard(wizardId) {
-      this.controllerFor('adminWizardsSubmissions').set('wizardId', wizardId);
+      this.controllerFor("adminWizardsSubmissions").set("wizardId", wizardId);
-      this.transitionTo('adminWizardsSubmissionsShow', wizardId);
+      this.transitionTo("adminWizardsSubmissionsShow", wizardId);
-    }
+    },
-  }
+  },
-});
+});

assets/javascripts/discourse/routes/admin-wizards-wizard-show.js.es6

@@ -1,47 +1,49 @@
-import CustomWizard from '../models/custom-wizard';
+import CustomWizard from "../models/custom-wizard";
-import { ajax } from 'discourse/lib/ajax';
+import { ajax } from "discourse/lib/ajax";
 import DiscourseRoute from "discourse/routes/discourse";
 import I18n from "I18n";
-import { selectKitContent } from '../lib/wizard';
+import { selectKitContent } from "../lib/wizard";
 
 export default DiscourseRoute.extend({
   model(params) {
-    if (params.wizardId === 'create') {
+    if (params.wizardId === "create") {
       return { create: true };
     } else {
       return ajax(`/admin/wizards/wizard/${params.wizardId}`);
     }
   },
-  
+
   afterModel(model) {
     if (model.none) {
-      return this.transitionTo('adminWizardsWizard');
+      return this.transitionTo("adminWizardsWizard");
     }
   },
 
   setupController(controller, model) {
-    const parentModel = this.modelFor('adminWizardsWizard');
+    const parentModel = this.modelFor("adminWizardsWizard");
-    const wizard = CustomWizard.create((!model || model.create) ? {} : model);
+    const wizard = CustomWizard.create(!model || model.create ? {} : model);
-    const fieldTypes = Object.keys(parentModel.field_types).map(type => {
+    const fieldTypes = Object.keys(parentModel.field_types).map((type) => {
       return {
         id: type,
-        name: I18n.t(`admin.wizard.field.type.${type}`)
+        name: I18n.t(`admin.wizard.field.type.${type}`),
       };
-    })
+    });
-              
+
     let props = {
       wizardList: parentModel.wizard_list,
       fieldTypes,
       userFields: parentModel.userFields,
-      customFields: selectKitContent(parentModel.custom_fields.map(f => f.name)),
+      customFields: selectKitContent(
+        parentModel.custom_fields.map((f) => f.name)
+      ),
       apis: parentModel.apis,
       themes: parentModel.themes,
       wizard,
       currentStep: wizard.steps[0],
       currentAction: wizard.actions[0],
-      creating: model.create
+      creating: model.create,
     };
-    
+
     controller.setProperties(props);
-  }
+  },
 });

assets/javascripts/discourse/routes/admin-wizards-wizard.js.es6

@@ -1,15 +1,15 @@
 import DiscourseRoute from "discourse/routes/discourse";
-import { buildFieldTypes, buildFieldValidations } from '../lib/wizard-schema';
+import { buildFieldTypes, buildFieldValidations } from "../lib/wizard-schema";
 import EmberObject, { set } from "@ember/object";
 import { A } from "@ember/array";
 import { all } from "rsvp";
-import { ajax } from 'discourse/lib/ajax';
+import { ajax } from "discourse/lib/ajax";
 
-export default DiscourseRoute.extend({  
+export default DiscourseRoute.extend({
   model() {
     return ajax("/admin/wizards/wizard");
   },
-  
+
   afterModel(model) {
     buildFieldTypes(model.field_types);
     buildFieldValidations(model.realtime_validations);
@@ -17,80 +17,86 @@ export default DiscourseRoute.extend({
     return all([
       this._getThemes(model),
       this._getApis(model),
-      this._getUserFields(model)
+      this._getUserFields(model),
     ]);
   },
-  
+
   _getThemes(model) {
-    return ajax('/admin/themes')
+    return ajax("/admin/themes").then((result) => {
-      .then((result) => {
+      set(
-        set(model, 'themes', result.themes.map(t => {
+        model,
+        "themes",
+        result.themes.map((t) => {
           return {
             id: t.id,
-            name: t.name
+            name: t.name,
-          }
+          };
-        }));
+        })
-      });
+      );
+    });
   },
 
   _getApis(model) {
-    return ajax('/admin/wizards/api')
+    return ajax("/admin/wizards/api").then((result) =>
-      .then((result) => set(model, 'apis', result));
+      set(model, "apis", result)
+    );
   },
-  
+
   _getUserFields(model) {
-    return this.store.findAll('user-field').then((result) => {
+    return this.store.findAll("user-field").then((result) => {
       if (result && result.content) {
-        set(model, 'userFields', 
+        set(
+          model,
+          "userFields",
           result.content.map((f) => ({
             id: `user_field_${f.id}`,
-            name: f.name
+            name: f.name,
           }))
         );
       }
     });
   },
-  
+
   currentWizard() {
-    const params = this.paramsFor('adminWizardsWizardShow');    
+    const params = this.paramsFor("adminWizardsWizardShow");
-    
+
     if (params && params.wizardId) {
       return params.wizardId;
     } else {
       return null;
     }
   },
-  
+
   setupController(controller, model) {
     controller.setProperties({
       wizardList: model.wizard_list,
       wizardId: this.currentWizard(),
-      custom_fields: A(model.custom_fields.map(f => EmberObject.create(f)))
+      custom_fields: A(model.custom_fields.map((f) => EmberObject.create(f))),
     });
   },
-  
+
   actions: {
     changeWizard(wizardId) {
-      this.controllerFor('adminWizardsWizard').set('wizardId', wizardId);
+      this.controllerFor("adminWizardsWizard").set("wizardId", wizardId);
-      
+
       if (wizardId) {
-        this.transitionTo('adminWizardsWizardShow', wizardId);
+        this.transitionTo("adminWizardsWizardShow", wizardId);
       } else {
-        this.transitionTo('adminWizardsWizard');
+        this.transitionTo("adminWizardsWizard");
       }
     },
-    
+
     afterDestroy() {
-      this.transitionTo('adminWizardsWizard').then(() => this.refresh());
+      this.transitionTo("adminWizardsWizard").then(() => this.refresh());
     },
-    
+
     afterSave(wizardId) {
-      this.refresh().then(() => this.send('changeWizard', wizardId));
+      this.refresh().then(() => this.send("changeWizard", wizardId));
     },
-    
+
     createWizard() {
-      this.controllerFor('adminWizardsWizard').set('wizardId', 'create');
+      this.controllerFor("adminWizardsWizard").set("wizardId", "create");
-      this.transitionTo('adminWizardsWizardShow', 'create');
+      this.transitionTo("adminWizardsWizardShow", "create");
-    }
+    },
-  }
+  },
-});
+});

assets/javascripts/discourse/routes/admin-wizards.js.es6

@@ -3,7 +3,7 @@ import DiscourseRoute from "discourse/routes/discourse";
 export default DiscourseRoute.extend({
   beforeModel(transition) {
     if (transition.targetName === "adminWizards.index") {
-      this.transitionTo('adminWizardsWizard');
+      this.transitionTo("adminWizardsWizard");
     }
   },
-});
+});

assets/javascripts/wizard/components/custom-user-selector.js.es6

@@ -1,9 +1,12 @@
-import { default as computed, observes } from 'discourse-common/utils/decorators';
+import {
-import { renderAvatar } from 'discourse/helpers/user-avatar';
+  default as computed,
-import userSearch from '../lib/user-search';
+  observes,
+} from "discourse-common/utils/decorators";
+import { renderAvatar } from "discourse/helpers/user-avatar";
+import userSearch from "../lib/user-search";
 import WizardI18n from "../lib/wizard-i18n";
 
-const template = function(params) {
+const template = function (params) {
   const options = params.options;
   let html = "<div class='autocomplete'>";
 
@@ -11,7 +14,7 @@ const template = function(params) {
     html += "<ul>";
     options.users.forEach((u) => {
       html += `<li><a href title="${u.name}">`;
-      html += renderAvatar(u, { imageSize: 'tiny' });
+      html += renderAvatar(u, { imageSize: "tiny" });
       html += `<span class='username'>${u.username}</span>`;
       if (u.name) {
         html += `<span class='name'>${u.name}</span>`;
@@ -19,7 +22,7 @@ const template = function(params) {
       html += `</a></li>`;
     });
     html += "</ul>";
-  };
+  }
 
   html += "</div>";
 
@@ -27,10 +30,10 @@ const template = function(params) {
 };
 
 export default Ember.TextField.extend({
-  attributeBindings: ['autofocus', 'maxLength'],
+  attributeBindings: ["autofocus", "maxLength"],
   autocorrect: false,
   autocapitalize: false,
-  name: 'user-selector',
+  name: "user-selector",
   id: "custom-member-selector",
 
   @computed("placeholderKey")
@@ -38,101 +41,107 @@ export default Ember.TextField.extend({
     return placeholderKey ? WizardI18n(placeholderKey) : "";
   },
 
-  @observes('usernames')
+  @observes("usernames")
   _update() {
-    if (this.get('canReceiveUpdates') === 'true')
+    if (this.get("canReceiveUpdates") === "true")
-      this.didInsertElement({updateData: true});
+      this.didInsertElement({ updateData: true });
   },
 
   didInsertElement(opts) {
     this._super();
     var self = this,
-        selected = [],
+      selected = [],
-        groups = [],
+      groups = [],
-        currentUser = this.currentUser,
+      currentUser = this.currentUser,
-        includeMentionableGroups = this.get('includeMentionableGroups') === 'true',
+      includeMentionableGroups =
-        includeMessageableGroups = this.get('includeMessageableGroups') === 'true',
+        this.get("includeMentionableGroups") === "true",
-        includeGroups = this.get('includeGroups') === 'true',
+      includeMessageableGroups =
-        allowedUsers = this.get('allowedUsers') === 'true';
+        this.get("includeMessageableGroups") === "true",
+      includeGroups = this.get("includeGroups") === "true",
+      allowedUsers = this.get("allowedUsers") === "true";
 
     function excludedUsernames() {
       // hack works around some issues with allowAny eventing
-      const usernames = self.get('single') ? [] : selected;
+      const usernames = self.get("single") ? [] : selected;
 
-      if (currentUser && self.get('excludeCurrentUser')) {
+      if (currentUser && self.get("excludeCurrentUser")) {
-        return usernames.concat([currentUser.get('username')]);
+        return usernames.concat([currentUser.get("username")]);
       }
       return usernames;
     }
 
-    $(this.element).val(this.get('usernames')).autocomplete({
+    $(this.element)
-      template,
+      .val(this.get("usernames"))
-      disabled: this.get('disabled'),
+      .autocomplete({
-      single: this.get('single'),
+        template,
-      allowAny: this.get('allowAny'),
+        disabled: this.get("disabled"),
-      updateData: (opts && opts.updateData) ? opts.updateData : false,
+        single: this.get("single"),
+        allowAny: this.get("allowAny"),
+        updateData: opts && opts.updateData ? opts.updateData : false,
 
-      dataSource(term) {
+        dataSource(term) {
-        const termRegex = /[^a-zA-Z0-9_\-\.@\+]/;
+          const termRegex = /[^a-zA-Z0-9_\-\.@\+]/;
 
-        var results = userSearch({
+          var results = userSearch({
-          term: term.replace(termRegex, ''),
+            term: term.replace(termRegex, ""),
-          topicId: self.get('topicId'),
+            topicId: self.get("topicId"),
-          exclude: excludedUsernames(),
+            exclude: excludedUsernames(),
-          includeGroups,
+            includeGroups,
-          allowedUsers,
+            allowedUsers,
-          includeMentionableGroups,
+            includeMentionableGroups,
-          includeMessageableGroups
+            includeMessageableGroups,
-        });
-
-        return results;
-      },
-
-      transformComplete(v) {
-        if (v.username || v.name) {
-          if (!v.username) { groups.push(v.name); }
-          return v.username || v.name;
-        } else {
-          var excludes = excludedUsernames();
-          return v.usernames.filter(function(item){
-            return excludes.indexOf(item) === -1;
           });
-        }
-      },
 
-      onChangeItems(items) {
+          return results;
-        var hasGroups = false;
+        },
-        items = items.map(function(i) {
-          if (groups.indexOf(i) > -1) { hasGroups = true; }
-          return i.username ? i.username : i;
-        });
-        self.set('usernames', items.join(","));
-        self.set('hasGroups', hasGroups);
 
-        selected = items;
+        transformComplete(v) {
-        if (self.get('onChangeCallback')) self.sendAction('onChangeCallback');
+          if (v.username || v.name) {
-      },
+            if (!v.username) {
+              groups.push(v.name);
+            }
+            return v.username || v.name;
+          } else {
+            var excludes = excludedUsernames();
+            return v.usernames.filter(function (item) {
+              return excludes.indexOf(item) === -1;
+            });
+          }
+        },
 
-      reverseTransform(i) {
+        onChangeItems(items) {
-        return { username: i };
+          var hasGroups = false;
-      }
+          items = items.map(function (i) {
+            if (groups.indexOf(i) > -1) {
+              hasGroups = true;
+            }
+            return i.username ? i.username : i;
+          });
+          self.set("usernames", items.join(","));
+          self.set("hasGroups", hasGroups);
 
-    });
+          selected = items;
+          if (self.get("onChangeCallback")) self.sendAction("onChangeCallback");
+        },
+
+        reverseTransform(i) {
+          return { username: i };
+        },
+      });
   },
 
   willDestroyElement() {
     this._super();
-    $(this.element).autocomplete('destroy');
+    $(this.element).autocomplete("destroy");
   },
 
   // THIS IS A HUGE HACK TO SUPPORT CLEARING THE INPUT
-  @observes('usernames')
+  @observes("usernames")
-  _clearInput: function() {
+  _clearInput: function () {
     if (arguments.length > 1) {
       if (Em.isEmpty(this.get("usernames"))) {
         $(this.element).parent().find("a").click();
       }
     }
-  }
+  },
-
 });

assets/javascripts/wizard/components/similar-topics-validator.js.es6

@@ -10,44 +10,48 @@ import { categoryBadgeHTML } from "discourse/helpers/category-link";
 import { dasherize } from "@ember/string";
 
 export default WizardFieldValidator.extend({
-  classNames: ['similar-topics-validator'],
+  classNames: ["similar-topics-validator"],
   similarTopics: null,
-  hasInput: notEmpty('field.value'),
+  hasInput: notEmpty("field.value"),
-  hasSimilarTopics: notEmpty('similarTopics'),
+  hasSimilarTopics: notEmpty("similarTopics"),
-  hasNotSearched: equal('similarTopics', null),
+  hasNotSearched: equal("similarTopics", null),
-  noSimilarTopics: computed('similarTopics', function() {
+  noSimilarTopics: computed("similarTopics", function () {
     return this.similarTopics !== null && this.similarTopics.length == 0;
   }),
-  showSimilarTopics: computed('typing', 'hasSimilarTopics', function() {
+  showSimilarTopics: computed("typing", "hasSimilarTopics", function () {
     return this.hasSimilarTopics && !this.typing;
   }),
-  showNoSimilarTopics: computed('typing', 'noSimilarTopics', function() {
+  showNoSimilarTopics: computed("typing", "noSimilarTopics", function () {
     return this.noSimilarTopics && !this.typing;
   }),
-  hasValidationCategories: notEmpty('validationCategories'),
+  hasValidationCategories: notEmpty("validationCategories"),
-  insufficientCharacters: computed('typing', 'field.value', function() {
+  insufficientCharacters: computed("typing", "field.value", function () {
     return this.hasInput && this.field.value.length < 5 && !this.typing;
   }),
-  insufficientCharactersCategories: and('insufficientCharacters', 'hasValidationCategories'),
+  insufficientCharactersCategories: and(
-  
+    "insufficientCharacters",
-  @discourseComputed('validation.categories')
+    "hasValidationCategories"
+  ),
+
+  @discourseComputed("validation.categories")
   validationCategories(categoryIds) {
-    if (categoryIds) return categoryIds.map(id => this.site.categoriesById[id]);
+    if (categoryIds)
+      return categoryIds.map((id) => this.site.categoriesById[id]);
 
     return A();
   },
-  
+
-  @discourseComputed('validationCategories')
+  @discourseComputed("validationCategories")
   catLinks(categories) {
-    return categories.map(category => categoryBadgeHTML(category)).join("");
+    return categories.map((category) => categoryBadgeHTML(category)).join("");
   },
 
   @discourseComputed(
-    'loading',
+    "loading",
-    'showSimilarTopics',
+    "showSimilarTopics",
-    'showNoSimilarTopics',
+    "showNoSimilarTopics",
-    'insufficientCharacters',
+    "insufficientCharacters",
-    'insufficientCharactersCategories'
+    "insufficientCharactersCategories"
   )
   currentState(
     loading,
@@ -58,30 +62,31 @@ export default WizardFieldValidator.extend({
   ) {
     switch (true) {
       case loading:
-        return 'loading';
+        return "loading";
       case showSimilarTopics:
-        return 'results';
+        return "results";
       case showNoSimilarTopics:
-        return 'no_results';
+        return "no_results";
       case insufficientCharactersCategories:
-        return 'insufficient_characters_categories';
+        return "insufficient_characters_categories";
       case insufficientCharacters:
-        return 'insufficient_characters';
+        return "insufficient_characters";
       default:
         return false;
     }
   },
 
-  @discourseComputed('currentState')
+  @discourseComputed("currentState")
-  currentStateClass (currentState) {
+  currentStateClass(currentState) {
     if (currentState) return `similar-topics-${dasherize(currentState)}`;
 
     return "similar-topics";
   },
 
-  @discourseComputed('currentState')
+  @discourseComputed("currentState")
-  currentStateKey (currentState) {
+  currentStateKey(currentState) {
-    if (currentState) return `realtime_validations.similar_topics.${currentState}`;
+    if (currentState)
+      return `realtime_validations.similar_topics.${currentState}`;
 
     return false;
   },
@@ -91,15 +96,15 @@ export default WizardFieldValidator.extend({
   @observes("field.value")
   customValidate() {
     const field = this.field;
-    
+
     if (!field.value) {
-      this.set('similarTopics', null);
+      this.set("similarTopics", null);
       return;
     }
     const value = field.value;
-    
+
     this.set("typing", true);
-    
+
     const lastKeyUp = new Date();
     this._lastKeyUp = lastKeyUp;
 
@@ -113,7 +118,7 @@ export default WizardFieldValidator.extend({
       this.set("typing", false);
 
       if (value && value.length < 5) {
-        this.set('similarTopics', null);
+        this.set("similarTopics", null);
         return;
       }
 
@@ -122,23 +127,25 @@ export default WizardFieldValidator.extend({
   },
 
   updateSimilarTopics() {
-    this.set('updating', true);
+    this.set("updating", true);
-    
+
     this.backendValidate({
       title: this.get("field.value"),
       categories: this.get("validation.categories"),
       time_unit: this.get("validation.time_unit"),
-      time_n_value: this.get("validation.time_n_value")
+      time_n_value: this.get("validation.time_n_value"),
-    }).then((result) => {
+    })
-      const similarTopics = A(
+      .then((result) => {
-        deepMerge(result["topics"], result["similar_topics"])
+        const similarTopics = A(
-      );
+          deepMerge(result["topics"], result["similar_topics"])
-      similarTopics.forEach(function (topic, index) {
+        );
-        similarTopics[index] = EmberObject.create(topic);
+        similarTopics.forEach(function (topic, index) {
-      });
+          similarTopics[index] = EmberObject.create(topic);
+        });
 
-      this.set("similarTopics", similarTopics);
+        this.set("similarTopics", similarTopics);
-    }).finally(() => this.set('updating', false));
+      })
+      .finally(() => this.set("updating", false));
   },
 
   actions: {

assets/javascripts/wizard/components/validator.js.es6

@@ -4,14 +4,14 @@ import { ajax } from "discourse/lib/ajax";
 import { getToken } from "wizard/lib/ajax";
 
 export default Component.extend({
-  classNames: ['validator'],
+  classNames: ["validator"],
   classNameBindings: ["isValid", "isInvalid"],
   validMessageKey: null,
   invalidMessageKey: null,
   isValid: null,
   isInvalid: equal("isValid", false),
   layoutName: "components/validator", // useful for sharing the template with extending components
-  
+
   init() {
     this._super(...arguments);
 

assets/javascripts/wizard/components/wizard-category-selector.js.es6

@@ -1,12 +1,17 @@
-import CategorySelector from 'select-kit/components/category-selector';
+import CategorySelector from "select-kit/components/category-selector";
 import { computed } from "@ember/object";
 import { makeArray } from "discourse-common/lib/helpers";
 
 export default CategorySelector.extend({
-  content: computed("categories.[]", "blacklist.[]", "whitelist.[]", function() {
+  content: computed(
-    return this._super().filter(category => {
+    "categories.[]",
-      const whitelist = makeArray(this.whitelist);
+    "blacklist.[]",
-      return !whitelist.length || whitelist.indexOf(category.id) > -1;
+    "whitelist.[]",
-    });
+    function () {
-  })
+      return this._super().filter((category) => {
-})
+        const whitelist = makeArray(this.whitelist);
+        return !whitelist.length || whitelist.indexOf(category.id) > -1;
+      });
+    }
+  ),
+});

assets/javascripts/wizard/components/wizard-composer-editor.js.es6

@@ -20,7 +20,7 @@ import {
 import { cacheShortUploadUrl } from "pretty-text/upload-short-url";
 import { alias } from "@ember/object/computed";
 import { uploadIcon } from "discourse/lib/uploads";
-import WizardI18n from '../lib/wizard-i18n';
+import WizardI18n from "../lib/wizard-i18n";
 
 const uploadMarkdownResolvers = [];
 

assets/javascripts/wizard/components/wizard-composer-hyperlink.js.es6

@@ -1,15 +1,15 @@
 import Component from "@ember/component";
 
 export default Component.extend({
-  classNames: ['wizard-composer-hyperlink'],
+  classNames: ["wizard-composer-hyperlink"],
-  
+
   actions: {
     addLink() {
       this.addLink(this.linkName, this.linkUrl);
     },
-    
+
     hideBox() {
       this.hideBox();
-    }
+    },
   },
 });

assets/javascripts/wizard/components/wizard-date-input.js.es6

@@ -1,3 +1,3 @@
 import DateInput from "discourse/components/date-input";
 
-export default DateInput.extend();
+export default DateInput.extend();

assets/javascripts/wizard/components/wizard-date-time-input.js.es6

@@ -1,14 +1,14 @@
 import DateTimeInput from "discourse/components/date-time-input";
-import discourseComputed from 'discourse-common/utils/decorators';
+import discourseComputed from "discourse-common/utils/decorators";
 
 export default DateTimeInput.extend({
-  @discourseComputed('timeFirst', 'tabindex')
+  @discourseComputed("timeFirst", "tabindex")
   timeTabindex(timeFirst, tabindex) {
     return timeFirst ? tabindex : tabindex + 1;
   },
-  
+
-  @discourseComputed('timeFirst', 'tabindex')
+  @discourseComputed("timeFirst", "tabindex")
   dateTabindex(timeFirst, tabindex) {
     return timeFirst ? tabindex + 1 : tabindex;
-  }
+  },
-});
+});

assets/javascripts/wizard/components/wizard-field-category.js.es6

@@ -1,32 +1,39 @@
-import { observes } from 'discourse-common/utils/decorators';
+import { observes } from "discourse-common/utils/decorators";
-import Category from 'discourse/models/category';
+import Category from "discourse/models/category";
 
 export default Ember.Component.extend({
   didInsertElement() {
-    const property = this.field.property || 'id';
+    const property = this.field.property || "id";
     const value = this.field.value;
-    
+
     if (value) {
-      this.set('categories', [...value].reduce((result, v) => {
+      this.set(
-        let val = property === 'id' ? Category.findById(v) : Category.findBySlug(v);
+        "categories",
-        if (val) result.push(val);
+        [...value].reduce((result, v) => {
-        return result;
+          let val =
-      }, []));
+            property === "id" ? Category.findById(v) : Category.findBySlug(v);
+          if (val) result.push(val);
+          return result;
+        }, [])
+      );
     }
   },
-  
+
-  @observes('categories')
+  @observes("categories")
   setValue() {
-    const categories = (this.categories || []).filter(c => !!c);
+    const categories = (this.categories || []).filter((c) => !!c);
-    const property = this.field.property || 'id';
+    const property = this.field.property || "id";
-    
+
-    if (categories.length) {            
+    if (categories.length) {
-      this.set('field.value', categories.reduce((result, c) => {
+      this.set(
-        if (c && c[property]) {
+        "field.value",
-          result.push(c[property])
+        categories.reduce((result, c) => {
-        }
+          if (c && c[property]) {
-        return result;
+            result.push(c[property]);
-      }, []));
+          }
+          return result;
+        }, [])
+      );
     }
-  }
+  },
-});
+});

assets/javascripts/wizard/components/wizard-field-composer.js.es6

@@ -1,41 +1,47 @@
-import { default as computed, observes } from 'discourse-common/utils/decorators';
+import {
+  default as computed,
+  observes,
+} from "discourse-common/utils/decorators";
 import EmberObject from "@ember/object";
 
 export default Ember.Component.extend({
   showPreview: false,
-  classNameBindings: [":wizard-field-composer", "showPreview:show-preview:hide-preview"],
+  classNameBindings: [
-  
+    ":wizard-field-composer",
+    "showPreview:show-preview:hide-preview",
+  ],
+
   didInsertElement() {
-    this.set('composer', EmberObject.create({
+    this.set(
-      loading: false,
+      "composer",
-      reply: this.get('field.value')
+      EmberObject.create({
-    }))
+        loading: false,
+        reply: this.get("field.value"),
+      })
+    );
   },
-  
+
-  @observes('composer.reply')
+  @observes("composer.reply")
   setField() {
-    this.set('field.value', this.get('composer.reply'));
+    this.set("field.value", this.get("composer.reply"));
   },
-  
+
-  @computed('showPreview')
+  @computed("showPreview")
   togglePreviewLabel(showPreview) {
-    return showPreview ? 'wizard_composer.hide_preview' : 'wizard_composer.show_preview';
+    return showPreview
+      ? "wizard_composer.hide_preview"
+      : "wizard_composer.show_preview";
   },
 
   actions: {
     togglePreview() {
-      this.toggleProperty('showPreview');
+      this.toggleProperty("showPreview");
     },
-    
+
-    groupsMentioned() {
+    groupsMentioned() {},
-    },
+    afterRefresh() {},
-    afterRefresh() {
+    cannotSeeMention() {},
-    },               
+    importQuote() {},
-    cannotSeeMention() {
+    showUploadSelector() {},
-    },
+  },
-    importQuote() {
-    },
-    showUploadSelector() {
-    }
-  }
 });

assets/javascripts/wizard/components/wizard-field-date-time.js.es6

@@ -1,15 +1,15 @@
 import Component from "@ember/component";
-import { observes } from 'discourse-common/utils/decorators';
+import { observes } from "discourse-common/utils/decorators";
 
 export default Component.extend({
-  @observes('dateTime')
+  @observes("dateTime")
   setValue() {
-    this.set('field.value', this.dateTime.format(this.field.format));
+    this.set("field.value", this.dateTime.format(this.field.format));
   },
-  
+
   actions: {
     onChange(value) {
-      this.set('dateTime', moment(value));
+      this.set("dateTime", moment(value));
-    }
+    },
-  }
+  },
-});
+});

assets/javascripts/wizard/components/wizard-field-date.js.es6

@@ -1,15 +1,15 @@
 import Component from "@ember/component";
-import { observes } from 'discourse-common/utils/decorators';
+import { observes } from "discourse-common/utils/decorators";
 
 export default Component.extend({
-  @observes('date')
+  @observes("date")
   setValue() {
-    this.set('field.value', this.date.format(this.field.format));
+    this.set("field.value", this.date.format(this.field.format));
   },
-  
+
   actions: {
     onChange(value) {
-      this.set('date', moment(value));
+      this.set("date", moment(value));
-    }
+    },
-  }
+  },
-});
+});

assets/javascripts/wizard/components/wizard-field-time.js.es6

@@ -1,20 +1,21 @@
 import Component from "@ember/component";
-import { observes } from 'discourse-common/utils/decorators';
+import { observes } from "discourse-common/utils/decorators";
 
 export default Component.extend({
-  @observes('time')
+  @observes("time")
   setValue() {
-    this.set('field.value', this.time.format(this.field.format));
+    this.set("field.value", this.time.format(this.field.format));
   },
-  
+
   actions: {
     onChange(value) {
-      this.set('time',
+      this.set(
+        "time",
         moment({
           hours: value.hours,
-          minutes: value.minutes
+          minutes: value.minutes,
         })
-      )
+      );
-    }
+    },
-  }
+  },
-});
+});

assets/javascripts/wizard/components/wizard-field-upload.js.es6

@@ -20,10 +20,10 @@ export default Ember.Component.extend({
       formData: {
         synchronous: true,
         type: `wizard_${id}`,
-        authenticity_token: getToken()
+        authenticity_token: getToken(),
       },
       dataType: "json",
-      dropZone: $upload
+      dropZone: $upload,
     });
 
     $upload.on("fileuploadsubmit", () => this.set("uploading", true));
@@ -31,12 +31,16 @@ export default Ember.Component.extend({
     $upload.on("fileuploaddone", (e, response) => {
       this.setProperties({
         "field.value": response.result,
-        "uploading": false
+        uploading: false,
       });
-      if ( Discourse.SiteSettings.wizard_recognised_image_upload_formats.split('|').includes(response.result.extension)) {
+      if (
+        Discourse.SiteSettings.wizard_recognised_image_upload_formats
+          .split("|")
+          .includes(response.result.extension)
+      ) {
         this.setProperties({
-          "isImage": true
+          isImage: true,
-        })
+        });
       }
     });
 
@@ -51,9 +55,9 @@ export default Ember.Component.extend({
         title: "",
         text: message,
         type: "warning",
-        confirmButtonColor: "#6699ff"
+        confirmButtonColor: "#6699ff",
       });
       this.set("uploading", false);
     });
-  }
+  },
 });

assets/javascripts/wizard/components/wizard-group-selector.js.es6

@@ -1,17 +1,19 @@
-import ComboBox from 'select-kit/components/combo-box';
+import ComboBox from "select-kit/components/combo-box";
 import { computed } from "@ember/object";
 import { makeArray } from "discourse-common/lib/helpers";
 
-export default ComboBox.extend({  
+export default ComboBox.extend({
-  content: computed("groups.[]", "field.content.[]", function() {
+  content: computed("groups.[]", "field.content.[]", function () {
     const whitelist = makeArray(this.field.content);
-    return this.groups.filter(group => {
+    return this.groups
-      return !whitelist.length || whitelist.indexOf(group.id) > -1;
+      .filter((group) => {
-    }).map(g => {
+        return !whitelist.length || whitelist.indexOf(group.id) > -1;
-      return {
+      })
-        id: g.id,
+      .map((g) => {
-        name: g.full_name ? g.full_name : g.name
+        return {
-      }
+          id: g.id,
-    });
+          name: g.full_name ? g.full_name : g.name,
-  })
+        };
-})
+      });
+  }),
+});

assets/javascripts/wizard/components/wizard-no-access.js.es6

@@ -1,13 +1,13 @@
-import CustomWizard from '../models/custom';
+import CustomWizard from "../models/custom";
 
 export default Ember.Component.extend({
-  siteName: function() {
+  siteName: function () {
     return Wizard.SiteSettings.title;
   }.property(),
 
   actions: {
     skip() {
-      CustomWizard.skip(this.get('wizardId'));
+      CustomWizard.skip(this.get("wizardId"));
-    }
+    },
-  }
+  },
 });

assets/javascripts/wizard/components/wizard-similar-topics.js.es6

@@ -2,10 +2,10 @@ import Component from "@ember/component";
 import { bind } from "@ember/runloop";
 import { observes } from "discourse-common/utils/decorators";
 
-export default Component.extend({ 
+export default Component.extend({
-  classNames: ['wizard-similar-topics'],
+  classNames: ["wizard-similar-topics"],
   showTopics: true,
-  
+
   didInsertElement() {
     $(document).on("click", bind(this, this.documentClick));
   },
@@ -18,19 +18,19 @@ export default Component.extend({
     if (this._state == "destroying") return;
     let $target = $(e.target);
 
-    if (!$target.hasClass('show-topics')) {
+    if (!$target.hasClass("show-topics")) {
-      this.set('showTopics', false);
+      this.set("showTopics", false);
     }
   },
-  
+
-  @observes('topics')
+  @observes("topics")
   toggleShowWhenTopicsChange() {
-    this.set('showTopics', true);
+    this.set("showTopics", true);
   },
-  
+
   actions: {
     toggleShowTopics() {
-      this.set('showTopics', true);
+      this.set("showTopics", true);
-    }
+    },
-  }
+  },
-})
+});

assets/javascripts/wizard/components/wizard-tag-selector.js.es6

@@ -1,4 +1,4 @@
-import TagChooser from 'select-kit/components/tag-chooser';
+import TagChooser from "select-kit/components/tag-chooser";
 import { makeArray } from "discourse-common/lib/helpers";
 
 export default TagChooser.extend({
@@ -7,5 +7,5 @@ export default TagChooser.extend({
       const whitelist = makeArray(context.whitelist);
       return !whitelist.length || whitelist.indexOf(tag.id) > 1;
     });
-  }
+  },
-})
+});

assets/javascripts/wizard/components/wizard-text-field.js.es6

@@ -5,14 +5,20 @@ import { siteDir, isRTL, isLTR } from "discourse/lib/text-direction";
 import WizardI18n from "../lib/wizard-i18n";
 
 export default Ember.TextField.extend({
-  attributeBindings: ['autocorrect', 'autocapitalize', 'autofocus', 'maxLength', 'dir'],
+  attributeBindings: [
+    "autocorrect",
+    "autocapitalize",
+    "autofocus",
+    "maxLength",
+    "dir",
+  ],
 
   @computed
   dir() {
     if (Wizard.SiteSettings.support_mixed_text_direction) {
       let val = this.value;
       if (val) {
-        return isRTL(val) ? 'rtl' : 'ltr';
+        return isRTL(val) ? "rtl" : "ltr";
       } else {
         return siteDir();
       }
@@ -23,11 +29,11 @@ export default Ember.TextField.extend({
     if (Wizard.SiteSettings.support_mixed_text_direction) {
       let val = this.value;
       if (isRTL(val)) {
-        this.set('dir', 'rtl');
+        this.set("dir", "rtl");
       } else if (isLTR(val)) {
-        this.set('dir', 'ltr');
+        this.set("dir", "ltr");
       } else {
-        this.set('dir', siteDir());
+        this.set("dir", siteDir());
       }
     }
   },
@@ -35,5 +41,5 @@ export default Ember.TextField.extend({
   @computed("placeholderKey")
   placeholder(placeholderKey) {
     return placeholderKey ? WizardI18n(placeholderKey) : "";
-  }
+  },
 });

assets/javascripts/wizard/components/wizard-time-input.js.es6

@@ -1,3 +1,3 @@
 import TimeInput from "discourse/components/time-input";
 
-export default TimeInput.extend();
+export default TimeInput.extend();

assets/javascripts/wizard/controllers/custom-step.js.es6

@@ -1,32 +1,32 @@
-import StepController from 'wizard/controllers/step';
+import StepController from "wizard/controllers/step";
-import getUrl from 'discourse-common/lib/get-url';
+import getUrl from "discourse-common/lib/get-url";
 
 export default StepController.extend({
   actions: {
     goNext(response) {
-      const next = this.get('step.next');
+      const next = this.get("step.next");
       if (response.redirect_on_next) {
         window.location.href = response.redirect_on_next;
       } else if (response.refresh_required) {
-        const id = this.get('wizard.id');
+        const id = this.get("wizard.id");
         window.location.href = getUrl(`/w/${id}/steps/${next}`);
       } else {
-        this.transitionToRoute('custom.step', next);
+        this.transitionToRoute("custom.step", next);
       }
     },
 
     goBack() {
-      this.transitionToRoute('custom.step', this.get('step.previous'));
+      this.transitionToRoute("custom.step", this.get("step.previous"));
     },
 
     showMessage(message) {
-      this.set('stepMessage', message);
+      this.set("stepMessage", message);
     },
 
     resetWizard() {
-      const id = this.get('wizard.id');
+      const id = this.get("wizard.id");
-      const stepId = this.get('step.id');
+      const stepId = this.get("step.id");
       window.location.href = getUrl(`/w/${id}/steps/${stepId}?reset=true`);
-    }
+    },
-  }
+  },
 });

assets/javascripts/wizard/controllers/custom.js.es6

@@ -1,3 +1,3 @@
 export default Ember.Controller.extend({
-  queryParams: ['reset']
+  queryParams: ["reset"],
 });

assets/javascripts/wizard/custom-wizard.js.es6

@@ -1,7 +1,7 @@
 import { buildResolver } from "discourse-common/resolver";
 
 export default Ember.Application.extend({
-  rootElement: '#custom-wizard-main',
+  rootElement: "#custom-wizard-main",
   Resolver: buildResolver("wizard"),
 
   start() {
@@ -11,7 +11,7 @@ export default Ember.Application.extend({
         if (!module) {
           throw new Error(key + " must export an initializer.");
         }
-        
+
         const init = module.default;
         const oldInitialize = init.initialize;
         init.initialize = () => {
@@ -21,8 +21,8 @@ export default Ember.Application.extend({
         this.initializer(init);
       }
     });
-    
+
-    Object.keys(requirejs._eak_seen).forEach(key => {
+    Object.keys(requirejs._eak_seen).forEach((key) => {
       if (/\/initializers\//.test(key)) {
         const module = requirejs(key, null, null, true);
         if (!module) {
@@ -31,5 +31,5 @@ export default Ember.Application.extend({
         this.initializer(module.default);
       }
     });
-  }
+  },
 });

assets/javascripts/wizard/helpers/char-counter.js.es6

@@ -1,16 +1,21 @@
 import { registerUnbound } from "discourse-common/lib/helpers";
 import I18n from "I18n";
 
-export default registerUnbound("char-counter", function(body, maxLength) {
+export default registerUnbound("char-counter", function (body, maxLength) {
-    let bodyLength = body ? body.length : 0; 
+  let bodyLength = body ? body.length : 0;
-    let finalString;
+  let finalString;
 
-    if (maxLength) {
+  if (maxLength) {
-       let isOverMax = bodyLength > maxLength ? "true" : "false";
+    let isOverMax = bodyLength > maxLength ? "true" : "false";
-       finalString = `<div class="body-length" data-length=${bodyLength} data-over-max=${isOverMax}>${bodyLength} / ${I18n.t('wizard.x_characters', { count: parseInt(maxLength) })}</div>`;
+    finalString = `<div class="body-length" data-length=${bodyLength} data-over-max=${isOverMax}>${bodyLength} / ${I18n.t(
-    } else {
+      "wizard.x_characters",
-       finalString = `<div class="body-length">${I18n.t('wizard.x_characters', { count: parseInt(bodyLength) })}</div>`;
+      { count: parseInt(maxLength) }
-    }
+    )}</div>`;
+  } else {
+    finalString = `<div class="body-length">${I18n.t("wizard.x_characters", {
+      count: parseInt(bodyLength),
+    })}</div>`;
+  }
 
   return new Handlebars.SafeString(finalString);
 });

assets/javascripts/wizard/helpers/dir-span.js.es6

@@ -1,5 +1,5 @@
 import { registerUnbound } from "discourse-common/lib/helpers";
 
-export default registerUnbound("dir-span", function(str) {
+export default registerUnbound("dir-span", function (str) {
   return new Handlebars.SafeString(str);
-});
+});

assets/javascripts/wizard/helpers/plugin-outlet.js.es6

@@ -1,5 +1,5 @@
 import { registerUnbound } from "discourse-common/lib/helpers";
 
-export default registerUnbound("plugin-outlet", function(attrs) {
+export default registerUnbound("plugin-outlet", function (attrs) {
-  return new Handlebars.SafeString('');
+  return new Handlebars.SafeString("");
-});
+});

assets/javascripts/wizard/helpers/wizard-i18n.js.es6

@@ -1,6 +1,6 @@
-import { registerUnbound } from 'discourse-common/lib/helpers';
+import { registerUnbound } from "discourse-common/lib/helpers";
-import WizardI18n from '../lib/wizard-i18n';
+import WizardI18n from "../lib/wizard-i18n";
 
 export default registerUnbound("wizard-i18n", (key, params) => {
   return WizardI18n(key, params);
-});
+});

assets/javascripts/wizard/initializers/custom-wizard-field.js.es6

@@ -5,20 +5,22 @@ export default {
   name: "custom-wizard-field",
   initialize(app) {
     if (window.location.pathname.indexOf("/w/") < 0) return;
-    
+
     const FieldComponent = requirejs("wizard/components/wizard-field").default;
     const FieldModel = requirejs("wizard/models/wizard-field").default;
-    const { cook } = requirejs("discourse/plugins/discourse-custom-wizard/wizard/lib/text-lite");
+    const { cook } = requirejs(
+      "discourse/plugins/discourse-custom-wizard/wizard/lib/text-lite"
+    );
     const DEditor = requirejs("discourse/components/d-editor").default;
     const { clipboardHelpers } = requirejs("discourse/lib/utilities");
     const { toMarkdown } = requirejs("discourse/lib/to-markdown");
-    
+
     FieldComponent.reopen({
       classNameBindings: ["field.id"],
 
       @discourseComputed("field.type")
       textType(fieldType) {
-        return ['text', 'textarea'].includes(fieldType);
+        return ["text", "textarea"].includes(fieldType);
       },
 
       cookedDescription: function () {
@@ -81,35 +83,43 @@ export default {
         return valid;
       },
     });
-    
+
     const isInside = (text, regex) => {
       const matches = text.match(regex);
       return matches && matches.length % 2;
     };
-    
+
     DEditor.reopen({
       isComposer: true,
-      
+
       didInsertElement() {
         this._super();
         if (this.wizardComposerEvents) {
-          this.appEvents.on("wizard-editor:insert-text", this, "_wizardInsertText");
+          this.appEvents.on(
-          this.appEvents.on("wizard-editor:replace-text", this, "_wizardReplaceText");
+            "wizard-editor:insert-text",
+            this,
+            "_wizardInsertText"
+          );
+          this.appEvents.on(
+            "wizard-editor:replace-text",
+            this,
+            "_wizardReplaceText"
+          );
         }
       },
-      
+
       _wizardInsertText(args = {}) {
         if (args.fieldId === this.fieldId) {
           this._insertText(args.text, args.options);
         }
       },
-      
+
       _wizardReplaceText(args = {}) {
         if (args.fieldId === this.fieldId) {
-          this._replaceText(args.oldVal, args.newVal, args.opts = {});
+          this._replaceText(args.oldVal, args.newVal, (args.opts = {}));
         }
       },
-      
+
       paste(e) {
         if (!$(".d-editor-input").is(":focus")) {
           return;
@@ -140,7 +150,7 @@ export default {
           if (table) {
             this.appEvents.trigger("wizard-editor:insert-text", {
               fieldId: this.fieldId,
-              text: table
+              text: table,
             });
             handled = true;
           }
@@ -169,7 +179,7 @@ export default {
 
             this.appEvents.trigger("composer:insert-text", {
               fieldId: this.fieldId,
-              text: markdown
+              text: markdown,
             });
             handled = true;
           }
@@ -180,5 +190,5 @@ export default {
         }
       },
     });
-  }
+  },
-}
+};

assets/javascripts/wizard/initializers/custom-wizard-step.js.es6

@@ -2,16 +2,21 @@ export default {
   name: "custom-wizard-step",
   initialize(app) {
     if (window.location.pathname.indexOf("/w/") < 0) return;
-    
+
-    const CustomWizard = requirejs("discourse/plugins/discourse-custom-wizard/wizard/models/custom").default;
+    const CustomWizard = requirejs(
+      "discourse/plugins/discourse-custom-wizard/wizard/models/custom"
+    ).default;
     const StepModel = requirejs("wizard/models/step").default;
     const StepComponent = requirejs("wizard/components/wizard-step").default;
     const ajax = requirejs("wizard/lib/ajax").ajax;
     const getUrl = requirejs("discourse-common/lib/get-url").default;
-    const discourseComputed = requirejs("discourse-common/utils/decorators").default;
+    const discourseComputed = requirejs("discourse-common/utils/decorators")
-    const cook = requirejs("discourse/plugins/discourse-custom-wizard/wizard/lib/text-lite").cook;
+      .default;
+    const cook = requirejs(
+      "discourse/plugins/discourse-custom-wizard/wizard/lib/text-lite"
+    ).cook;
     const { schedule } = requirejs("@ember/runloop");
-    
+
     StepModel.reopen({
       save() {
         const wizardId = this.get("wizardId");
@@ -69,10 +74,10 @@ export default {
         Ember.run.later(() => this.set("message", null), 6000);
       },
     });
-    
+
     StepComponent.reopen({
       classNameBindings: ["step.id"],
-      
+
       autoFocus() {
         schedule("afterRender", () => {
           const $invalid = $(
@@ -82,14 +87,16 @@ export default {
           if ($invalid.length) {
             return $invalid.focus();
           }
-          
+
           $(".wizard-focusable:first").focus();
         });
       },
 
       animateInvalidFields() {
         schedule("afterRender", () => {
-          let $element = $(".invalid input[type=text],.invalid textarea,.invalid input[type=checkbox],.invalid .select-kit");
+          let $element = $(
+            ".invalid input[type=text],.invalid textarea,.invalid input[type=checkbox],.invalid .select-kit"
+          );
 
           if ($element.length) {
             $([document.documentElement, document.body]).animate(
@@ -128,13 +135,13 @@ export default {
         if (!src) return;
         return getUrl(src);
       }.property("step.banner"),
-      
+
-      @discourseComputed('step.fields.[]')
+      @discourseComputed("step.fields.[]")
       primaryButtonIndex(fields) {
         return fields.length + 1;
       },
-      
+
-      @discourseComputed('step.fields.[]')
+      @discourseComputed("step.fields.[]")
       secondaryButtonIndex(fields) {
         return fields.length + 2;
       },
@@ -176,5 +183,5 @@ export default {
         },
       },
     });
-  }
+  },
-}
+};

assets/javascripts/wizard/initializers/custom-wizard.js.es6

@@ -6,18 +6,27 @@ export default {
     const EmberObject = requirejs("@ember/object").default;
     const Router = requirejs("wizard/router").default;
     const ApplicationRoute = requirejs("wizard/routes/application").default;
-    const CustomWizard = requirejs("discourse/plugins/discourse-custom-wizard/wizard/models/custom").default;
+    const CustomWizard = requirejs(
+      "discourse/plugins/discourse-custom-wizard/wizard/models/custom"
+    ).default;
     const getUrl = requirejs("discourse-common/lib/get-url").default;
     const Store = requirejs("discourse/models/store").default;
-    const registerRawHelpers = requirejs("discourse-common/lib/raw-handlebars-helpers").registerRawHelpers;
+    const registerRawHelpers = requirejs(
-    const createHelperContext = requirejs("discourse-common/lib/helpers").createHelperContext;
+      "discourse-common/lib/raw-handlebars-helpers"
-    const RawHandlebars = requirejs("discourse-common/lib/raw-handlebars").default;
+    ).registerRawHelpers;
-    const Site = requirejs("discourse/plugins/discourse-custom-wizard/wizard/models/site").default;
+    const createHelperContext = requirejs("discourse-common/lib/helpers")
+      .createHelperContext;
+    const RawHandlebars = requirejs("discourse-common/lib/raw-handlebars")
+      .default;
+    const Site = requirejs(
+      "discourse/plugins/discourse-custom-wizard/wizard/models/site"
+    ).default;
     const RestAdapter = requirejs("discourse/adapters/rest").default;
     const Session = requirejs("discourse/models/session").default;
-    const setDefaultOwner = requirejs("discourse-common/lib/get-owner").setDefaultOwner;
+    const setDefaultOwner = requirejs("discourse-common/lib/get-owner")
+      .setDefaultOwner;
     const messageBus = requirejs("message-bus-client").default;
-    
+
     const container = app.__container__;
     Discourse.Model = EmberObject.extend();
     Discourse.__container__ = container;
@@ -66,7 +75,7 @@ export default {
     site.set("can_create_tag", false);
     app.register("session:main", Session.current(), { instantiate: false });
     targets.forEach((t) => app.inject(t, "session", "session:main"));
-    
+
     createHelperContext({
       siteSettings: container.lookup("site-settings:main"),
       currentUser: container.lookup("current-user:main"),
@@ -74,13 +83,13 @@ export default {
       session: container.lookup("session:main"),
       capabilities: container.lookup("capabilities:main"),
     });
-    
+
     const session = container.lookup("session:main");
     const setupData = document.getElementById("data-discourse-setup").dataset;
     session.set("highlightJsPath", setupData.highlightJsPath);
-    
+
     Router.reopen({
-      rootURL: getUrl("/w/")
+      rootURL: getUrl("/w/"),
     });
 
     Router.map(function () {

assets/javascripts/wizard/lib/load-script.js.es6

@@ -1,23 +1,28 @@
-import { ajax } from 'wizard/lib/ajax';
+import { ajax } from "wizard/lib/ajax";
 import getURL from "discourse-common/lib/get-url";
 
 const _loaded = {};
 const _loading = {};
 
 function loadWithTag(path, cb) {
-  const head = document.getElementsByTagName('head')[0];
+  const head = document.getElementsByTagName("head")[0];
 
   let finished = false;
-  let s = document.createElement('script');
+  let s = document.createElement("script");
   s.src = path;
   if (Ember.Test) {
     Ember.Test.registerWaiter(() => finished);
   }
   head.appendChild(s);
 
-  s.onload = s.onreadystatechange = function(_, abort) {
+  s.onload = s.onreadystatechange = function (_, abort) {
     finished = true;
-    if (abort || !s.readyState || s.readyState === "loaded" || s.readyState === "complete") {
+    if (
+      abort ||
+      !s.readyState ||
+      s.readyState === "loaded" ||
+      s.readyState === "complete"
+    ) {
       s = s.onload = s.onreadystatechange = null;
       if (!abort) {
         Ember.run(null, cb);
@@ -31,38 +36,42 @@ export function loadCSS(url) {
 }
 
 export default function loadScript(url, opts) {
-
   // TODO: Remove this once plugins have been updated not to use it:
-  if (url === "defer/html-sanitizer-bundle") { return Ember.RSVP.Promise.resolve(); }
+  if (url === "defer/html-sanitizer-bundle") {
+    return Ember.RSVP.Promise.resolve();
+  }
 
   opts = opts || {};
 
-  $('script').each((i, tag) => {
+  $("script").each((i, tag) => {
-    const src = tag.getAttribute('src');
+    const src = tag.getAttribute("src");
 
     if (src && (opts.scriptTag || src !== url)) {
-      _loaded[tag.getAttribute('src')] = true;
+      _loaded[tag.getAttribute("src")] = true;
     }
   });
 
-
+  return new Ember.RSVP.Promise(function (resolve) {
-  return new Ember.RSVP.Promise(function(resolve) {
     url = getURL(url);
 
     // If we already loaded this url
-    if (_loaded[url]) { return resolve(); }
+    if (_loaded[url]) {
-    if (_loading[url]) { return _loading[url].then(resolve);}
+      return resolve();
+    }
+    if (_loading[url]) {
+      return _loading[url].then(resolve);
+    }
 
     let done;
-    _loading[url] = new Ember.RSVP.Promise(function(_done){
+    _loading[url] = new Ember.RSVP.Promise(function (_done) {
       done = _done;
     });
 
-    _loading[url].then(function(){
+    _loading[url].then(function () {
       delete _loading[url];
     });
 
-    const cb = function(data) {
+    const cb = function (data) {
       if (opts && opts.css) {
         $("head").append("<style>" + data + "</style>");
       }
@@ -76,7 +85,7 @@ export default function loadScript(url, opts) {
     // Scripts should always load from CDN
     // CSS is type text, to accept it from a CDN we would need to handle CORS
     if (!opts.css && Discourse.CDN && url[0] === "/" && url[1] !== "/") {
-      cdnUrl = Discourse.CDN.replace(/\/$/,"") + url;
+      cdnUrl = Discourse.CDN.replace(/\/$/, "") + url;
     }
 
     // Some javascript depends on the path of where it is loaded (ace editor)
@@ -88,7 +97,11 @@ export default function loadScript(url, opts) {
       }
       loadWithTag(cdnUrl, cb);
     } else {
-      ajax({url: cdnUrl, dataType: opts.css ? "text": "script", cache: true}).then(cb);
+      ajax({
+        url: cdnUrl,
+        dataType: opts.css ? "text" : "script",
+        cache: true,
+      }).then(cb);
     }
   });
 }

assets/javascripts/wizard/lib/text-lite.js.es6

@@ -1,5 +1,5 @@
-import loadScript from './load-script';
+import loadScript from "./load-script";
-import { default as PrettyText } from 'pretty-text/pretty-text';
+import { default as PrettyText } from "pretty-text/pretty-text";
 
 export function cook(text, options) {
   return new Handlebars.SafeString(new PrettyText(options).cook(text));
@@ -10,8 +10,8 @@ export function cook(text, options) {
 export function cookAsync(text, options) {
   if (Discourse.MarkdownItURL) {
     return loadScript(Discourse.MarkdownItURL)
-      .then(()=>cook(text, options))
+      .then(() => cook(text, options))
-      .catch(e => Ember.Logger.error(e));
+      .catch((e) => Ember.Logger.error(e));
   } else {
     return Ember.RSVP.Promise.resolve(cook(text));
   }

assets/javascripts/wizard/lib/user-search.js.es6

@@ -1,14 +1,23 @@
-import { CANCELLED_STATUS } from 'discourse/lib/autocomplete';
+import { CANCELLED_STATUS } from "discourse/lib/autocomplete";
 import { debounce } from "@ember/runloop";
-import getUrl from 'discourse-common/lib/get-url';
+import getUrl from "discourse-common/lib/get-url";
 
 var cache = {},
-    cacheTopicId,
+  cacheTopicId,
-    cacheTime,
+  cacheTime,
-    currentTerm,
+  currentTerm,
-    oldSearch;
+  oldSearch;
 
-function performSearch(term, topicId, includeGroups, includeMentionableGroups, includeMessageableGroups, allowedUsers, group, resultsFn) {
+function performSearch(
+  term,
+  topicId,
+  includeGroups,
+  includeMentionableGroups,
+  includeMessageableGroups,
+  allowedUsers,
+  group,
+  resultsFn
+) {
   var cached = cache[term];
   if (cached) {
     resultsFn(cached);
@@ -16,42 +25,49 @@ function performSearch(term, topicId, includeGroups, includeMentionableGroups, i
   }
 
   // need to be able to cancel this
-  oldSearch = $.ajax(getUrl('/u/search/users'), {
+  oldSearch = $.ajax(getUrl("/u/search/users"), {
-    data: { term: term,
+    data: {
-            topic_id: topicId,
+      term: term,
-            include_groups: includeGroups,
+      topic_id: topicId,
-            include_mentionable_groups: includeMentionableGroups,
+      include_groups: includeGroups,
-            include_messageable_groups: includeMessageableGroups,
+      include_mentionable_groups: includeMentionableGroups,
-            group: group,
+      include_messageable_groups: includeMessageableGroups,
-            topic_allowed_users: allowedUsers }
+      group: group,
+      topic_allowed_users: allowedUsers,
+    },
   });
 
   var returnVal = CANCELLED_STATUS;
 
-  oldSearch.then(function (r) {
+  oldSearch
-    cache[term] = r;
+    .then(function (r) {
-    cacheTime = new Date();
+      cache[term] = r;
-    // If there is a newer search term, return null
+      cacheTime = new Date();
-    if (term === currentTerm) { returnVal = r; }
+      // If there is a newer search term, return null
-
+      if (term === currentTerm) {
-  }).always(function(){
+        returnVal = r;
-    oldSearch = null;
+      }
-    resultsFn(returnVal);
+    })
-  });
+    .always(function () {
+      oldSearch = null;
+      resultsFn(returnVal);
+    });
 }
 
 function organizeResults(r, options) {
-  if (r === CANCELLED_STATUS) { return r; }
+  if (r === CANCELLED_STATUS) {
+    return r;
+  }
 
   var exclude = options.exclude || [],
-      limit = options.limit || 5,
+    limit = options.limit || 5,
-      users = [],
+    users = [],
-      emails = [],
+    emails = [],
-      groups = [],
+    groups = [],
-      results = [];
+    results = [];
 
   if (r.users) {
-    r.users.every(function(u) {
+    r.users.every(function (u) {
       if (exclude.indexOf(u.username) === -1) {
         users.push(u);
         results.push(u);
@@ -62,13 +78,17 @@ function organizeResults(r, options) {
 
   if (options.term.match(/@/)) {
     let e = { username: options.term };
-    emails = [ e ];
+    emails = [e];
     results.push(e);
   }
 
   if (r.groups) {
-    r.groups.every(function(g) {
+    r.groups.every(function (g) {
-      if (results.length > limit && options.term.toLowerCase() !== g.name.toLowerCase()) return false;
+      if (
+        results.length > limit &&
+        options.term.toLowerCase() !== g.name.toLowerCase()
+      )
+        return false;
       if (exclude.indexOf(g.name) === -1) {
         groups.push(g);
         results.push(g);
@@ -83,16 +103,14 @@ function organizeResults(r, options) {
   return results;
 }
 
-
 export default function userSearch(options) {
   var term = options.term || "",
-      includeGroups = options.includeGroups,
+    includeGroups = options.includeGroups,
-      includeMentionableGroups = options.includeMentionableGroups,
+    includeMentionableGroups = options.includeMentionableGroups,
-      includeMessageableGroups = options.includeMessageableGroups,
+    includeMessageableGroups = options.includeMessageableGroups,
-      allowedUsers = options.allowedUsers,
+    allowedUsers = options.allowedUsers,
-      topicId = options.topicId,
+    topicId = options.topicId,
-      group = options.group;
+    group = options.group;
-
 
   if (oldSearch) {
     oldSearch.abort();
@@ -101,26 +119,26 @@ export default function userSearch(options) {
 
   currentTerm = term;
 
-  return new Ember.RSVP.Promise(function(resolve) {
+  return new Ember.RSVP.Promise(function (resolve) {
     // TODO site setting for allowed regex in username
     if (term.match(/[^\w_\-\.@\+]/)) {
       resolve([]);
       return;
     }
-    if (((new Date() - cacheTime) > 30000) || (cacheTopicId !== topicId)) {
+    if (new Date() - cacheTime > 30000 || cacheTopicId !== topicId) {
       cache = {};
     }
 
     cacheTopicId = topicId;
 
-    var clearPromise = setTimeout(function(){
+    var clearPromise = setTimeout(function () {
       resolve(CANCELLED_STATUS);
     }, 5000);
 
     // TODO: Use discouseDebounce after it is available on stable.
     debounce(
       this,
-      function() {
+      function () {
         performSearch(
           term,
           topicId,
@@ -129,13 +147,13 @@ export default function userSearch(options) {
           includeMessageableGroups,
           allowedUsers,
           group,
-          function(r) {
+          function (r) {
             clearTimeout(clearPromise);
             resolve(organizeResults(r, options));
           }
-        )
+        );
       },
       300
-    )
+    );
   });
 }

assets/javascripts/wizard/lib/utilities-lite.js.es6

@@ -1,7 +1,12 @@
 // lite version of discourse/lib/utilities
 
-export function determinePostReplaceSelection({ selection, needle, replacement }) {
+export function determinePostReplaceSelection({
-  const diff = (replacement.end - replacement.start) - (needle.end - needle.start);
+  selection,
+  needle,
+  replacement,
+}) {
+  const diff =
+    replacement.end - replacement.start - (needle.end - needle.start);
 
   if (selection.end <= needle.start) {
     // Selection ends (and starts) before needle.
@@ -30,7 +35,7 @@ export function determinePostReplaceSelection({ selection, needle, replacement }
   }
 }
 
-const toArray = items => {
+const toArray = (items) => {
   items = items || [];
 
   if (!Array.isArray(items)) {
@@ -41,20 +46,26 @@ const toArray = items => {
 };
 
 export function clipboardData(e, canUpload) {
-  const clipboard = e.clipboardData ||
+  const clipboard =
-                      e.originalEvent.clipboardData ||
+    e.clipboardData ||
-                      e.delegatedEvent.originalEvent.clipboardData;
+    e.originalEvent.clipboardData ||
+    e.delegatedEvent.originalEvent.clipboardData;
 
   const types = toArray(clipboard.types);
   let files = toArray(clipboard.files);
 
-  if (types.includes("Files") && files.length === 0) { // for IE
+  if (types.includes("Files") && files.length === 0) {
-    files = toArray(clipboard.items).filter(i => i.kind === "file");
+    // for IE
+    files = toArray(clipboard.items).filter((i) => i.kind === "file");
   }
 
   canUpload = files && canUpload && !types.includes("text/plain");
-  const canUploadImage = canUpload && files.filter(f => f.type.match('^image/'))[0];
+  const canUploadImage =
-  const canPasteHtml = Discourse.SiteSettings.enable_rich_text_paste && types.includes("text/html") && !canUploadImage;
+    canUpload && files.filter((f) => f.type.match("^image/"))[0];
+  const canPasteHtml =
+    Discourse.SiteSettings.enable_rich_text_paste &&
+    types.includes("text/html") &&
+    !canUploadImage;
 
   return { clipboard, types, canUpload, canPasteHtml };
 }

assets/javascripts/wizard/lib/wizard-i18n.js.es6

@@ -2,30 +2,32 @@ import I18n from "I18n";
 
 const getThemeId = () => {
   let themeId = parseInt($("meta[name=discourse_theme_ids]")[0].content, 10);
-  
+
   if (!isNaN(themeId)) {
     return themeId.toString();
   } else {
     return null;
   }
-}
+};
 
 const translationExists = (key) => {
-  return I18n.findTranslation(key, { locale: I18n.locale }) ||
+  return (
-    I18n.findTranslation(key, { locale: I18n.defaultLocale });
+    I18n.findTranslation(key, { locale: I18n.locale }) ||
-} 
+    I18n.findTranslation(key, { locale: I18n.defaultLocale })
+  );
+};
 
-const WizardI18n = (key, params={}) => {
+const WizardI18n = (key, params = {}) => {
   const themeId = getThemeId();
   if (!themeId) return I18n.t(key, params);
-  
+
   const themeKey = `theme_translations.${themeId}.${key}`;
-    
+
   if (translationExists(themeKey)) {
     return I18n.t(themeKey, params);
   } else {
     return I18n.t(key, params);
   }
-}
+};
 
-export default WizardI18n; 
+export default WizardI18n;

assets/javascripts/wizard/models/custom.js.es6

@@ -1,23 +1,23 @@
-import { default as computed } from 'discourse-common/utils/decorators';
+import { default as computed } from "discourse-common/utils/decorators";
-import getUrl from 'discourse-common/lib/get-url';
+import getUrl from "discourse-common/lib/get-url";
-import WizardField from 'wizard/models/wizard-field';
+import WizardField from "wizard/models/wizard-field";
-import { ajax } from 'wizard/lib/ajax';
+import { ajax } from "wizard/lib/ajax";
-import Step from 'wizard/models/step';
+import Step from "wizard/models/step";
 import EmberObject from "@ember/object";
 
 const CustomWizard = EmberObject.extend({
-  @computed('steps.length')
+  @computed("steps.length")
-  totalSteps: length => length,
+  totalSteps: (length) => length,
 
   skip() {
-    if (this.required && (!this.completed && this.permitted)) return;
+    if (this.required && !this.completed && this.permitted) return;
     CustomWizard.skip(this.id);
   },
 });
 
 CustomWizard.reopenClass({
   skip(wizardId) {
-    ajax({ url: `/w/${wizardId}/skip`, type: 'PUT' }).then((result) => {
+    ajax({ url: `/w/${wizardId}/skip`, type: "PUT" }).then((result) => {
       CustomWizard.finished(result);
     });
   },
@@ -28,52 +28,52 @@ CustomWizard.reopenClass({
       url = result.redirect_on_complete;
     }
     window.location.href = getUrl(url);
-  }
+  },
 });
 
 export function findCustomWizard(wizardId, params = {}) {
   let url = `/w/${wizardId}`;
 
-  let paramKeys = Object.keys(params).filter(k => {
+  let paramKeys = Object.keys(params).filter((k) => {
-    if (k === 'wizard_id') return false;
+    if (k === "wizard_id") return false;
     return !!params[k];
   });
 
   if (paramKeys.length) {
-    url += '?';
+    url += "?";
-    paramKeys.forEach((k,i) => {
+    paramKeys.forEach((k, i) => {
       if (i > 0) {
-        url += '&';
+        url += "&";
       }
       url += `${k}=${params[k]}`;
     });
   }
 
-  return ajax({ url, cache: false, dataType: 'json' }).then(result => {
+  return ajax({ url, cache: false, dataType: "json" }).then((result) => {
     const wizard = result;
     if (!wizard) return null;
 
     if (!wizard.completed) {
-      wizard.steps = wizard.steps.map(step => {
+      wizard.steps = wizard.steps.map((step) => {
         const stepObj = Step.create(step);
-        
+
         stepObj.fields.sort((a, b) => {
           return parseFloat(a.number) - parseFloat(b.number);
         });
-        
+
         let tabindex = 1;
         stepObj.fields.forEach((f, i) => {
           f.tabindex = tabindex;
-          
+
-          if (['date_time'].includes(f.type)) {
+          if (["date_time"].includes(f.type)) {
             tabindex = tabindex + 2;
           } else {
             tabindex++;
           }
         });
-        
+
-        stepObj.fields = stepObj.fields.map(f => WizardField.create(f));
+        stepObj.fields = stepObj.fields.map((f) => WizardField.create(f));
-        
+
         return stepObj;
       });
     }
@@ -81,7 +81,7 @@ export function findCustomWizard(wizardId, params = {}) {
     if (wizard.categories) {
       let subcatMap = {};
       let categoriesById = {};
-      let categories = wizard.categories.map(c => {
+      let categories = wizard.categories.map((c) => {
         if (c.parent_category_id) {
           subcatMap[c.parent_category_id] =
             subcatMap[c.parent_category_id] || [];
@@ -91,25 +91,31 @@ export function findCustomWizard(wizardId, params = {}) {
       });
 
       // Associate the categories with their parents
-      categories.forEach(c => {
+      categories.forEach((c) => {
         let subcategoryIds = subcatMap[c.get("id")];
         if (subcategoryIds) {
-          c.set("subcategories", subcategoryIds.map(id => categoriesById[id]));
+          c.set(
+            "subcategories",
+            subcategoryIds.map((id) => categoriesById[id])
+          );
         }
         if (c.get("parent_category_id")) {
           c.set("parentCategory", categoriesById[c.get("parent_category_id")]);
         }
       });
 
-      Discourse.Site.currentProp('categoriesList', categories);
+      Discourse.Site.currentProp("categoriesList", categories);
-      Discourse.Site.currentProp('sortedCategories', categories);
+      Discourse.Site.currentProp("sortedCategories", categories);
-      Discourse.Site.currentProp('listByActivity', categories);
+      Discourse.Site.currentProp("listByActivity", categories);
-      Discourse.Site.currentProp('categoriesById', categoriesById);
+      Discourse.Site.currentProp("categoriesById", categoriesById);
-      Discourse.Site.currentProp('uncategorized_category_id', wizard.uncategorized_category_id);
+      Discourse.Site.currentProp(
+        "uncategorized_category_id",
+        wizard.uncategorized_category_id
+      );
     }
 
     return CustomWizard.create(wizard);
   });
-};
+}
 
 export default CustomWizard;

assets/javascripts/wizard/models/site.js.es6

@@ -7,4 +7,4 @@ export default Site.reopenClass({
     const store = Discourse.__container__.lookup("service:store");
     return store.createRecord("site", {});
   },
-})
+});

assets/javascripts/wizard/routes/custom-index.js.es6

@@ -1,22 +1,27 @@
 export default Ember.Route.extend({
   beforeModel() {
-    const appModel = this.modelFor('custom');
+    const appModel = this.modelFor("custom");
-    if (appModel && appModel.permitted && !appModel.completed && appModel.start) {
+    if (
-      this.replaceWith('custom.step', appModel.start);
+      appModel &&
+      appModel.permitted &&
+      !appModel.completed &&
+      appModel.start
+    ) {
+      this.replaceWith("custom.step", appModel.start);
     }
   },
 
   model() {
-    return this.modelFor('custom');
+    return this.modelFor("custom");
   },
 
   setupController(controller, model) {
     if (model) {
-      const completed = model.get('completed');
+      const completed = model.get("completed");
-      const permitted = model.get('permitted');
+      const permitted = model.get("permitted");
-      const wizardId = model.get('id');
+      const wizardId = model.get("id");
-      const user = model.get('user');
+      const user = model.get("user");
-      const name = model.get('name');
+      const name = model.get("name");
 
       controller.setProperties({
         requiresLogin: !user,
@@ -24,10 +29,10 @@ export default Ember.Route.extend({
         name,
         completed,
         notPermitted: !permitted,
-        wizardId
+        wizardId,
       });
     } else {
-      controller.set('noWizard', true);
+      controller.set("noWizard", true);
     }
-  }
+  },
 });

assets/javascripts/wizard/routes/custom-step.js.es6

@@ -2,37 +2,38 @@ import WizardI18n from "../lib/wizard-i18n";
 
 export default Ember.Route.extend({
   model(params) {
-    const appModel = this.modelFor('custom');
+    const appModel = this.modelFor("custom");
     const allSteps = appModel.steps;
     if (allSteps) {
-      const step = allSteps.findBy('id', params.step_id);
+      const step = allSteps.findBy("id", params.step_id);
       return step ? step : allSteps[0];
-    };
+    }
 
     return appModel;
   },
 
   afterModel(model) {
-    if (model.completed) return this.transitionTo('index');
+    if (model.completed) return this.transitionTo("index");
-    return model.set("wizardId", this.modelFor('custom').id);
+    return model.set("wizardId", this.modelFor("custom").id);
   },
 
   setupController(controller, model) {
     let props = {
       step: model,
-      wizard: this.modelFor('custom')
+      wizard: this.modelFor("custom"),
     };
 
     if (!model.permitted) {
-      props['stepMessage'] = {
+      props["stepMessage"] = {
-        state: 'not-permitted',
+        state: "not-permitted",
-        text: model.permitted_message || WizardI18n('wizard.step_not_permitted')
+        text:
+          model.permitted_message || WizardI18n("wizard.step_not_permitted"),
       };
       if (model.index > 0) {
-        props['showReset'] = true;
+        props["showReset"] = true;
       }
     }
 
     controller.setProperties(props);
-  }
+  },
 });

assets/javascripts/wizard/routes/custom-steps.js.es6

@@ -1,5 +1,5 @@
 export default Ember.Route.extend({
   redirect() {
-    this.transitionTo('custom.index');
+    this.transitionTo("custom.index");
-  }
+  },
 });

assets/javascripts/wizard/routes/custom.js.es6

@@ -1,39 +1,39 @@
 /* eslint no-undef: 0 */
 
-import { findCustomWizard } from '../models/custom';
+import { findCustomWizard } from "../models/custom";
-import { ajax } from 'wizard/lib/ajax';
+import { ajax } from "wizard/lib/ajax";
 
 export default Ember.Route.extend({
   beforeModel(transition) {
-    this.set('queryParams', transition.intent.queryParams);
+    this.set("queryParams", transition.intent.queryParams);
   },
 
   model(params) {
-    return findCustomWizard(params.wizard_id, this.get('queryParams'));
+    return findCustomWizard(params.wizard_id, this.get("queryParams"));
   },
 
   afterModel() {
     return ajax({
       url: `/site/settings`,
-      type: 'GET',
+      type: "GET",
     }).then((result) => {
       $.extend(Wizard.SiteSettings, result);
     });
   },
 
   setupController(controller, model) {
-    const background = model ? model.get('background') : 'AliceBlue';
+    const background = model ? model.get("background") : "AliceBlue";
-    Ember.run.scheduleOnce('afterRender', this, function(){
+    Ember.run.scheduleOnce("afterRender", this, function () {
-      $('body.custom-wizard').css('background', background);
+      $("body.custom-wizard").css("background", background);
       if (model) {
-        $('#custom-wizard-main').addClass(model.get('id').dasherize());
+        $("#custom-wizard-main").addClass(model.get("id").dasherize());
       }
     });
 
     controller.setProperties({
       customWizard: true,
       logoUrl: Wizard.SiteSettings.logo_small,
-      reset: null
+      reset: null,
     });
-  }
+  },
 });