discourse/app/assets/javascripts/select-kit/components/category-chooser.js.es6

import ComboBoxComponent from "select-kit/components/combo-box";
import { on } from "ember-addons/ember-computed-decorators";
import computed from "ember-addons/ember-computed-decorators";
import PermissionType from "discourse/models/permission-type";
import Category from "discourse/models/category";
import { categoryBadgeHTML } from "discourse/helpers/category-link";
const { get, isNone, isEmpty } = Ember;

export default ComboBoxComponent.extend({
  pluginApiIdentifiers: ["category-chooser"],
  classNames: "category-chooser",
  filterable: true,
  castInteger: true,
  allowUncategorized: false,
  rowComponent: "category-row",
  noneRowComponent: "none-category-row",
  allowSubCategories: true,
  permissionType: PermissionType.FULL,

  init() {
    this._super();

    this.get("rowComponentOptions").setProperties({
      allowUncategorized: this.get("allowUncategorized")
    });
  },

  filterComputedContent(computedContent, computedValue, filter) {
    if (isEmpty(filter)) {
      return computedContent;
    }

    const _matchFunction = (f, text) => {
      return this._normalize(text).indexOf(f) > -1;
    };

    return computedContent.filter(c => {
      const category = Category.findById(get(c, "value"));
      const text = get(c, "name");
      if (category && category.get("parentCategory")) {
        const categoryName = category.get("parentCategory.name");
        return (
          _matchFunction(filter, text) || _matchFunction(filter, categoryName)
        );
      } else {
        return _matchFunction(filter, text);
      }
    });
  },

  @computed("rootNone", "rootNoneLabel")
  none(rootNone, rootNoneLabel) {
    if (
      this.siteSettings.allow_uncategorized_topics ||
      this.get("allowUncategorized")
    ) {
      if (!isNone(rootNone)) {
        return rootNoneLabel || "category.none";
      } else {
        return Category.findUncategorized();
      }
    } else {
      return "category.choose";
    }
  },

  computeHeaderContent() {
    let content = this._super();

    if (this.get("hasSelection")) {
      const category = Category.findById(content.value);
      const parentCategoryId = category.get("parent_category_id");
      const hasParentCategory = Ember.isPresent(parentCategoryId);

      let badge = "";

      if (hasParentCategory) {
        const parentCategory = Category.findById(parentCategoryId);
        badge += categoryBadgeHTML(parentCategory, {
          link: false,
          allowUncategorized: true
        }).htmlSafe();
      }

      badge += categoryBadgeHTML(category, {
        link: false,
        hideParent: hasParentCategory ? true : false,
        allowUncategorized: true
      }).htmlSafe();

      content.label = badge;
    }

    return content;
  },

  @on("didRender")
  _bindComposerResizing() {
    this.appEvents.on("composer:resized", this, this.applyDirection);
  },

  @on("willDestroyElement")
  _unbindComposerResizing() {
    this.appEvents.off("composer:resized");
  },

  didSelect(computedContentItem) {
    if (this.attrs.onChooseCategory) {
      this.attrs.onChooseCategory(computedContentItem.originalContent);
    }
  },

  computeContent() {
    const categories = Discourse.SiteSettings.fixed_category_positions_on_create
      ? Category.list()
      : Category.listByActivity();

    let scopedCategoryId = this.get("scopedCategoryId");
    if (scopedCategoryId) {
      const scopedCat = Category.findById(scopedCategoryId);
      scopedCategoryId =
        scopedCat.get("parent_category_id") || scopedCat.get("id");
    }

    const excludeCategoryId = this.get("excludeCategoryId");

    return categories.filter(c => {
      const categoryId = this.valueForContentItem(c);

      if (
        scopedCategoryId &&
        categoryId !== scopedCategoryId &&
        get(c, "parent_category_id") !== scopedCategoryId
      ) {
        return false;
      }

      if (this.get("allowSubCategories") === false && c.get("parentCategory")) {
        return false;
      }

      if (
        (this.get("allowUncategorized") === false &&
          get(c, "isUncategorizedCategory")) ||
        excludeCategoryId === categoryId
      ) {
        return false;
      }

      if (this.get("permissionType")) {
        return this.get("permissionType") === get(c, "permission");
      }

      return true;
    });
  }
});