@projectcaluma/ember-core 9.0.3 → 10.0.1

package/addon/-private/possible-types.js

@@ -7,7 +7,6 @@ export default {
     "WorkItem",
     "Flow",
     "DynamicOption",
-    "CalculatedFloatQuestion",
     "Option",
     "TextQuestion",
     "StringAnswer",
@@ -30,13 +29,14 @@ export default {
     "StaticQuestion",
     "FileAnswer",
     "File",
+    "CalculatedFloatQuestion",
+    "ActionButtonQuestion",
     "SimpleTask",
     "CompleteWorkflowFormTask",
     "CompleteTaskFormTask",
   ],
   Task: ["SimpleTask", "CompleteWorkflowFormTask", "CompleteTaskFormTask"],
   Question: [
-    "CalculatedFloatQuestion",
     "TextQuestion",
     "ChoiceQuestion",
     "MultipleChoiceQuestion",
@@ -50,6 +50,8 @@ export default {
     "FormQuestion",
     "FileQuestion",
     "StaticQuestion",
+    "CalculatedFloatQuestion",
+    "ActionButtonQuestion",
   ],
   Answer: [
     "StringAnswer",
@@ -60,4 +62,5 @@ export default {
     "TableAnswer",
     "FileAnswer",
   ],
+  DynamicQuestion: ["DynamicChoiceQuestion", "DynamicMultipleChoiceQuestion"],
 };

package/addon/caluma-query/queries/base.js

@@ -2,18 +2,19 @@ import { getOwner, setOwner } from "@ember/application";
 import { assert } from "@ember/debug";
 import { tracked } from "@glimmer/tracking";
 import { queryManager } from "ember-apollo-client";
-import gql from "graphql-tag";
+import {
+  enqueueTask,
+  lastValue,
+  restartableTask,
+  task,
+} from "ember-concurrency-decorators";
+import { gql } from "graphql-tag";
 
 export default class BaseQuery {
   @queryManager apollo;
 
   @tracked items = [];
 
-  @tracked totalCount = 0;
-  @tracked hasNextPage = true;
-
-  @tracked isLoading = true;
-
   constructor({
     pageSize = null,
     processNew = async (items) => items,
@@ -21,17 +22,13 @@ export default class BaseQuery {
     queryOptions = {},
   }) {
     this.pageSize = pageSize;
-    this.cursor = null;
-
     this.processNew = processNew;
     this.processAll = processAll;
     this.queryOptions = queryOptions;
   }
 
   get query() {
-    assert("`query` must be implemented on the model");
-
-    return "";
+    return assert("`query` must be implemented on the model");
   }
 
   get pagination() {
@@ -52,51 +49,20 @@ export default class BaseQuery {
     return factory.class;
   }
 
-  fetch({ filter = [], order = [], queryOptions = {} } = {}) {
-    this.items = [];
-    this.totalCount = 0;
-    this.hasNextPage = true;
-    this.cursor = null;
+  get isLoading() {
+    return this._fetch.isRunning || this._fetchMore.isRunning;
+  }
 
-    this.filter = filter;
-    this.order = order;
-    this.queryOptions = { ...(this.queryOptions ?? {}), ...queryOptions };
+  get totalCount() {
+    return this._data?.[this.dataKey].totalCount;
+  }
 
-    return this.fetchMore();
+  get hasNextPage() {
+    return this._data?.[this.dataKey].pageInfo.hasNextPage;
   }
 
-  async fetchMore() {
-    if (this.hasNextPage) {
-      this.isLoading = true;
-
-      const data = await this.apollo.query({
-        query: gql`
-          ${this.query}
-        `,
-        variables: {
-          filter: this.filter,
-          order: this.order,
-          pageSize: this.pageSize,
-          cursor: this.cursor,
-        },
-        fetchPolicy: "network-only",
-        ...this.queryOptions,
-      });
-
-      this.cursor = data[this.dataKey].pageInfo.endCursor;
-
-      this.hasNextPage = data[this.dataKey].pageInfo.hasNextPage;
-      this.totalCount = data[this.dataKey].totalCount;
-
-      const rawItems = data[this.dataKey].edges.map(({ node }) => node);
-
-      this.items = await this.processAll([
-        ...this.items,
-        ...(await this.processNew(rawItems)),
-      ]);
-
-      this.isLoading = false;
-    }
+  get cursor() {
+    return this._data?.[this.dataKey].pageInfo.endCursor;
   }
 
   get value() {
@@ -112,4 +78,59 @@ export default class BaseQuery {
       return instance;
     });
   }
+
+  fetch(...args) {
+    return this._fetch.perform(...args);
+  }
+
+  fetchMore(...args) {
+    return this._fetchMore.perform(...args);
+  }
+
+  @restartableTask
+  *_fetch({ filter = [], order = [], queryOptions = {} } = {}) {
+    yield this._fetchPage.cancelAll({ resetState: true });
+
+    this.items = [];
+
+    this.filter = filter;
+    this.order = order;
+    this.queryOptions = { ...(this.queryOptions ?? {}), ...queryOptions };
+
+    return yield this._fetchPage.linked().perform();
+  }
+
+  @enqueueTask
+  *_fetchMore() {
+    if (!this._data) return;
+
+    return yield this._fetchPage.linked().perform();
+  }
+
+  @lastValue("_fetchPage") _data;
+  @task
+  *_fetchPage() {
+    const data = yield this.apollo.query({
+      query: gql`
+        ${this.query}
+      `,
+      variables: {
+        filter: this.filter,
+        order: this.order,
+        pageSize: this.pageSize,
+        cursor: this.cursor,
+      },
+      fetchPolicy: "network-only",
+      ...this.queryOptions,
+    });
+
+    this.items = yield this.processAll([
+      ...this.items,
+      ...(yield this.processNew(
+        data[this.dataKey].edges.map(({ node }) => node)
+      )),
+    ]);
+
+    return data;
+  }
 }

package/addon/helpers/-resolver.js

@@ -0,0 +1,64 @@
+import Helper from "@ember/component/helper";
+import { assert } from "@ember/debug";
+import { run } from "@ember/runloop";
+import { inject as service } from "@ember/service";
+
+export default class PrivateResolver extends Helper {
+  @service("-scheduler") scheduler;
+  @service calumaOptions;
+
+  get resolverType() {
+    return assert("`resolverType` needs to be defined");
+  }
+
+  _identifier = null;
+  _value = null;
+  _settled = false;
+
+  compute([identifiers]) {
+    const identifier = Array.isArray(identifiers)
+      ? identifiers[0]
+      : identifiers;
+
+    if (!identifier) return null;
+
+    // The parameter for the helper changed so we need to recompute and store
+    // the new parameter to remember it at the next computation
+    if (identifier !== this._identifier) {
+      this._settled = false;
+      this._identifier = identifier;
+    }
+
+    // The value is resolved, return the passed property (default is defined as
+    // `{type}NameProperty` on the caluma options service) of the value. This
+    // happens after the `this.recompute()` call in `resolve`
+    if (this._settled) {
+      return this._value?.[
+        this.calumaOptions[`${this.resolverType}NameProperty`]
+      ];
+    }
+
+    // Schedule a resolve batch to only trigger the resolve method in the caluma
+    // options service once. We pass a resolve function to run after the
+    // possibly asynchronous resolve method.
+    this.scheduler.resolveOnce(identifier, this.resolverType, (value) =>
+      run(this, "resolve", value)
+    );
+
+    // Return the default value (`null`) if the value is not computed yet
+    return this._value;
+  }
+
+  /**
+   * Resolver method to set the value to the resolved value and mark the helper
+   * as settled and then recompute it to display that value.
+   *
+   * @method resolve
+   * @param {*} value The resolved group value
+   */
+  resolve(value) {
+    this._value = value;
+    this._settled = true;
+    this.recompute();
+  }
+}

package/addon/helpers/group-name.js

@@ -0,0 +1,5 @@
+import PrivateResolver from "@projectcaluma/ember-core/helpers/-resolver";
+
+export default class GroupName extends PrivateResolver {
+  resolverType = "group";
+}

package/addon/helpers/user-name.js

@@ -0,0 +1,5 @@
+import PrivateResolver from "@projectcaluma/ember-core/helpers/-resolver";
+
+export default class UserName extends PrivateResolver {
+  resolverType = "user";
+}

package/addon/services/-scheduler.js

@@ -0,0 +1,79 @@
+import { assert } from "@ember/debug";
+import { once } from "@ember/runloop";
+import Service, { inject as service } from "@ember/service";
+import { camelize } from "@ember/string";
+import { task } from "ember-concurrency";
+import { pluralize } from "ember-inflector";
+
+/**
+ * Decorator to define a type resolver in the scheduler service.
+ *
+ * @function typeResolver
+ * @param {"group"|"user"} type The type of the objects to resolve
+ * @returns {Function} The decorator function that returns an enqueued task to resolve the requested objects
+ */
+function typeResolver(type) {
+  return task(function* () {
+    const identifiers = [...this[type].identifiers];
+    const callbacks = [...this[type].callbacks];
+
+    this[type] = undefined;
+
+    if (!identifiers.length) return;
+
+    const methodName = camelize(`resolve-${pluralize(type)}`);
+    const result = yield this.calumaOptions[methodName]?.(identifiers);
+
+    yield Promise.all(callbacks.map((callback) => callback(result)));
+
+    return result;
+  }).enqueue();
+}
+
+export default class PrivateSchedulerService extends Service {
+  @service calumaOptions;
+
+  @typeResolver("group") resolveGroup;
+  @typeResolver("user") resolveUser;
+
+  /**
+   * Resolve a certain object of a type only once in the runloop.
+   *
+   * This method adds the given identifier to a set of already requested
+   * identifiers of a type and calls the resolve method of that type once in a
+   * single render loop and then passes the resolved object to a passed
+   * callback.
+   *
+   * @method resolveOnce
+   * @param {String} identifier The identifier used to find the resolved object
+   * @param {"group"|"user"} type The type of the object to resolve
+   * @param {Function} callback The callback function to call after the object is resolved
+   */
+  resolveOnce(identifier, type, callback) {
+    const _callback = (result) => {
+      callback(
+        result.find(
+          (obj) =>
+            String(obj[this.calumaOptions[`${type}IdentifierProperty`]]) ===
+            String(identifier)
+        )
+      );
+    };
+
+    if (!this[type]) {
+      this[type] = { identifiers: new Set(), callbacks: new Set() };
+    }
+
+    this[type].identifiers.add(identifier);
+    this[type].callbacks.add(_callback);
+
+    const typeResolverName = camelize(`resolve-${type}`);
+
+    assert(
+      `${typeResolverName} needs to be defined on the scheduler service`,
+      typeResolverName in this
+    );
+
+    once(this[typeResolverName], "perform");
+  }
+}

package/addon/services/caluma-options.js

@@ -88,4 +88,22 @@ export default class CalumaOptionsService extends Service {
   getComponentOverrides() {
     return Object.values(this._overrides);
   }
+
+  groupIdentifierProperty = "id";
+  groupNameProperty = "name";
+  resolveGroups(identifiers) {
+    return identifiers.map((identifier) => ({
+      [this.groupIdentifierProperty]: identifier,
+      [this.groupNameProperty]: identifier,
+    }));
+  }
+
+  userIdentifierProperty = "username";
+  userNameProperty = "fullName";
+  resolveUsers(identifiers) {
+    return identifiers.map((identifier) => ({
+      [this.userIdentifierProperty]: identifier,
+      [this.userNameProperty]: identifier,
+    }));
+  }
 }

package/app/helpers/group-name.js

@@ -0,0 +1 @@
+export { default } from "@projectcaluma/ember-core/helpers/group-name";

package/app/helpers/user-name.js

@@ -0,0 +1 @@
+export { default } from "@projectcaluma/ember-core/helpers/user-name";

package/app/services/-scheduler.js

@@ -0,0 +1 @@
+export { default } from "@projectcaluma/ember-core/services/-scheduler";

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@projectcaluma/ember-core",
-  "version": "9.0.3",
+  "version": "10.0.1",
   "description": "Ember core addon for working with Caluma.",
   "keywords": [
     "ember-addon"
@@ -15,31 +15,34 @@
   },
   "dependencies": {
     "@apollo/client": "^3.4.16",
+    "@glimmer/tracking": "^1.0.4",
     "ember-apollo-client": "^3.2.0",
-    "ember-auto-import": "^2.2.0",
+    "ember-auto-import": "^2.2.3",
     "ember-changeset-validations": "^3.16.0",
     "ember-cli-babel": "^7.26.6",
-    "ember-cli-htmlbars": "^5.7.1",
-    "ember-concurrency": "^2.1.2",
+    "ember-cli-htmlbars": "^6.0.0",
+    "ember-concurrency": "^2.2.0",
     "ember-concurrency-decorators": "^2.0.3",
     "ember-fetch": "^8.0.4",
     "ember-intl": "^5.7.0",
-    "graphql": "^15.6.0",
-    "graphql-tag": "^2.12.5",
+    "graphql": "^15.6.1",
+    "graphql-tag": "^2.12.6",
     "intersection-observer": "^0.12.0",
     "jexl": "^2.3.0",
     "lodash.clonedeep": "^4.5.0",
     "moment": "^2.29.1",
     "proxy-polyfill": "^0.3.2",
-    "slugify": "^1.6.1"
+    "slugify": "^1.6.2"
   },
   "devDependencies": {
     "@ember/optional-features": "2.0.0",
-    "@ember/test-helpers": "2.5.0",
-    "@embroider/test-setup": "0.45.0",
-    "@projectcaluma/ember-testing": "9.0.0",
+    "@ember/render-modifiers": "2.0.0",
+    "@ember/test-helpers": "2.6.0",
+    "@embroider/test-setup": "0.47.2",
+    "@glimmer/component": "1.0.4",
+    "@projectcaluma/ember-testing": "9.1.0",
     "broccoli-asset-rev": "3.0.0",
-    "ember-cli": "3.28.1",
+    "ember-cli": "3.28.4",
     "ember-cli-code-coverage": "1.0.3",
     "ember-cli-dependency-checker": "3.2.0",
     "ember-cli-inject-live-reload": "2.1.0",
@@ -50,20 +53,20 @@
     "ember-export-application-global": "2.0.1",
     "ember-load-initializers": "2.1.2",
     "ember-maybe-import-regenerator": "1.0.0",
-    "ember-qunit": "5.1.4",
+    "ember-qunit": "5.1.5",
     "ember-resolver": "8.0.3",
-    "ember-source": "3.28.1",
+    "ember-source": "3.28.6",
     "ember-source-channel-url": "3.0.0",
-    "ember-try": "1.4.0",
+    "ember-try": "2.0.0",
     "faker": "5.5.3",
     "loader.js": "4.7.0",
     "npm-run-all": "4.1.5",
     "qunit": "2.17.2",
     "qunit-dom": "2.0.0",
-    "webpack": "5.58.0"
+    "webpack": "5.64.1"
   },
   "engines": {
-    "node": "10.* || >= 12"
+    "node": "12.* || 14.* || >= 16"
   },
   "ember": {
     "edition": "octane"

package/translations/de.yaml

@@ -6,9 +6,10 @@ caluma:
         COMPLETED: "Erledigt"
         CANCELED: "Abgebrochen"
         SKIPPED: "Übersprungen"
-
+        SUSPENDED: "Pausiert"
     case:
       status:
         RUNNING: "In Bearbeitung"
         COMPLETED: "Abgeschlossen"
         CANCELED: "Abgebrochen"
+        SUSPENDED: "Pausiert"

package/translations/en.yaml

@@ -6,8 +6,10 @@ caluma:
         COMPLETED: "Completed"
         CANCELED: "Canceled"
         SKIPPED: "Skipped"
+        SUSPENDED: "Suspended"
     case:
       status:
         RUNNING: "Pending"
         COMPLETED: "Completed"
         CANCELED: "Canceled"
+        SUSPENDED: "Suspended"

package/translations/fr.yaml

@@ -6,9 +6,10 @@ caluma:
         COMPLETED: "Terminé"
         CANCELED: "Annulé"
         SKIPPED: "Sauté"
-
+        SUSPENDED: "En pause"
     case:
       status:
         RUNNING: "En cours"
         COMPLETED: "Terminé"
         CANCELED: "Annulé"
+        SUSPENDED: "En pause"