@livepreso/api 6.42.1 → 6.45.0

package/src/collections/appointment-section-tags.js

@@ -0,0 +1,18 @@
+import "../models/appointment-section-tags.js";
+
+import { BaseCollection } from "./base.js";
+import { register } from "../state-register.js";
+
+/**
+ * @constructor
+ * @alias collections.AppointmentSectionTagsCollection
+ * @extends collections.BaseCollection
+ * @see models.AppointmentSectionTagsModel
+ */
+export const AppointmentSectionTagsCollection = BaseCollection.extend(
+	/** @lends collections.AppointmentSectionTagsCollection# */ {
+		model: "AppointmentSectionTagsModel",
+	}
+);
+
+register("AppointmentSectionTagsCollection", AppointmentSectionTagsCollection);

package/src/collections/appointment-slide-tags.js

@@ -0,0 +1,18 @@
+import "../models/appointment-slide-tags.js";
+
+import { BaseCollection } from "./base.js";
+import { register } from "../state-register.js";
+
+/**
+ * @constructor
+ * @alias collections.AppointmentSlideTagsCollection
+ * @extends collections.BaseCollection
+ * @see models.AppointmentSlideTagsModel
+ */
+export const AppointmentSlideTagsCollection = BaseCollection.extend(
+	/** @lends collections.AppointmentSlideTagsCollection# */ {
+		model: "AppointmentSlideTagsModel",
+	}
+);
+
+register("AppointmentSlideTagsCollection", AppointmentSlideTagsCollection);

package/src/collections/appointment-tags.js

@@ -0,0 +1,136 @@
+import { getState, register } from "../state-register.js";
+
+import { BaseCollection } from "./base.js";
+import _ from "lodash";
+
+/**
+ * @constructor
+ * @alias collections.AppointmentTagsCollection
+ * @extends collections.BaseCollection
+ * @see models.AppointmentTagsModel
+ */
+export const AppointmentTagsCollection = BaseCollection.extend(
+	/** @lends collections.AppointmentTagsCollection# */ {
+		model: "AppointmentTagsModel",
+
+		tagNameCollectionMapping: {
+			deckversion: "AppointmentDeckVersionTagsCollection",
+			section: "AppointmentSectionTagsCollection",
+			slide: "AppointmentSlideTagsCollection",
+			adjunct: "AppointmentAdjunctTagsCollection",
+		},
+
+		_mapResultsToModel(result) {
+			// Maps a model from a content specific tag to a more generic one.
+			// It's generally the same thing, except instead of something like:
+			//
+			//  slide: "/api/slides/1/"
+			//
+			// It becomes:
+			//
+			//  content_type: "slide",
+			//  content_url: "/api/slides/1/"
+			//
+			// So that we can return the list side by side.
+			const AppointmentTagsModel = getState("AppointmentTagsModel");
+			const resultType = Object.keys(result).find((key) => {
+				return Object.keys(this.tagNameCollectionMapping).includes(key);
+			});
+			if (!resultType) {
+				throw new Error("Unknown type of result found");
+			}
+			return new AppointmentTagsModel({
+				tags: result.tags,
+				content_type: resultType,
+				content_url: result[resultType],
+				appointment: result.appointment,
+				user: result.user,
+				url: result.url,
+			});
+		},
+
+		// These methods don't quite make sense right now, disable it for development.
+		async fetchSet() {
+			throw new Error("Not implemented");
+		},
+
+		async fetchModels() {
+			throw new Error("Not implemented");
+		},
+
+		async delete() {
+			throw new Error("Cannot delete using this collection");
+		},
+
+		async save() {
+			throw new Error("Not implemented");
+		},
+
+		async fetch(options) {
+			const AppointmentModel = getState("AppointmentModel");
+
+			let hasAppointment =
+				this._options?.appointment instanceof AppointmentModel ||
+				options?.appointment instanceof AppointmentModel;
+
+			if (!hasAppointment && this.parent instanceof AppointmentModel) {
+				options.appointment = this.parent;
+				hasAppointment = true;
+			}
+
+			if (!hasAppointment) {
+				throw new Error(
+					"Requires an appointment model in collection options to fetch."
+				);
+			}
+
+			const tagModels = Object.values(this.tagNameCollectionMapping);
+			// Fetch all the separate tag models and combine them into a single collection
+			const results = (
+				await Promise.all(
+					tagModels.map((tagModel) => {
+						const Collection = getState(tagModel);
+						const tags = new Collection({}, this._options);
+						return tags.fetch(options);
+					})
+				)
+			)
+				.flatMap((collection) => collection.results)
+				.map(this._mapResultsToModel.bind(this));
+
+			this.add(results);
+
+			return {
+				count: results.length,
+				next: null,
+				previous: null,
+				results: this.toJSON(),
+			};
+		},
+
+		// Used by Telepresenter to add the tags in the hostedpreso bundle to
+		// the appointment tags collection
+		addFromAppointment(appointment) {
+			const tagCollectionNames = [
+				"appointmentdeckversiontags_set",
+				"appointmentsectiontags_set",
+				"appointmentslidetags_set",
+				"appointmentadjuncttags_set",
+			];
+
+			// flatMap currently doesn't work in TelePresenter
+			const results = _.flatten(
+				tagCollectionNames.map((collectionName) => {
+					const collection = appointment[collectionName];
+					return collection?._data || [];
+				})
+			).map(this._mapResultsToModel.bind(this));
+
+			this.add(results);
+		},
+	}
+);
+
+AppointmentTagsCollection.canBeEmpty = true;
+
+register("AppointmentTagsCollection", AppointmentTagsCollection);

package/src/collections/base.js

@@ -8,6 +8,10 @@ import qs from "qs";
 import { registeredStates } from "../state-register.js";
 import { sync } from "../sync.js";
 
+// Current hardcoded limit for maximum number of pages fetched
+// automatically by fetchAll
+const pageLimit = 20;
+
 /**
  * @constructor
  * @alias collections.BaseCollection
@@ -34,7 +38,8 @@ export const BaseCollection = Collection.extend(
 			per_page: 1000,
 		},
 
-		constructor(data = {}, opts = {}) {
+		constructor(_data = {}, opts = {}) {
+			let data = _data;
 			const options = _.defaults(opts, {
 				data: {},
 			});
@@ -220,8 +225,75 @@ export const BaseCollection = Collection.extend(
 			});
 		},
 
+		fetchAll(opts = {}) {
+			const options = _.cloneDeep(opts);
+
+			// Add default params to the fetch (ie ?per_page=1000)
+			options.data = _.extend({}, this.queryData, options.data || {});
+			this._options = _.extend({}, this._options, options);
+
+			this.queryData = { ...this._options.data };
+
+			if (this._options.url) {
+				this._url = options.url;
+			}
+
+			const checkPages = (response) => {
+				const notLastPage = response.total_pages > response.page;
+				const belowPageLimit = response.page < pageLimit;
+
+				if (notLastPage && belowPageLimit) {
+					const options = {
+						...this._options,
+						data: {
+							...this._options.data,
+							page: response.page + 1,
+						},
+					};
+
+					// Update the collection with the new data & page number
+					this._options = options;
+					this.queryData = { ...options.data };
+
+					return this.fetchPage().then((response) => {
+						return checkPages(response);
+					});
+				} else {
+					// The collection's models are replaced with the latest
+					// batch of models every time a new page is fetched.
+					// Here we add back all of the previously-fetched models.
+					this.add(this._data.results);
+					return this._data;
+				}
+			};
+
+			return this.fetchPage().then((response) => {
+				return checkPages(response);
+			});
+		},
+
+		fetchPage() {
+			return Collection.prototype.fetch
+				.call(this, this._options)
+				.then((response) => {
+					// Add the response data to this._data - if we're fetching
+					// multiple pages, this._data.results will contain all of the
+					// results fetched from all pages so far
+					if (this._data.results?.length) {
+						this._data = {
+							...response,
+							results: [...this._data.results, ...response.results],
+						};
+					} else {
+						this._data = response;
+					}
+
+					return response;
+				});
+		},
+
 		toServer() {
-			return this.map(function (model) {
+			return this.map((model) => {
 				if (model.toServer) {
 					return model.toServer();
 				} else if (model.serialize) {
@@ -235,6 +307,11 @@ export const BaseCollection = Collection.extend(
 			});
 		},
 
+		// Returns "true" if all child models have been fetched
+		areModelsFetched() {
+			return this.map((model) => model.isFetched()).every(Boolean);
+		},
+
 		isNew() {
 			return true;
 		},
@@ -292,7 +369,7 @@ export const BaseCollection = Collection.extend(
 				// can be passed to the model.
 				//
 				// TODO: Regex match for URLs
-				return results.map(function (attr) {
+				return results.map((attr) => {
 					return { url: attr };
 				});
 			}

package/src/collections/base.spec.js

@@ -1,6 +1,8 @@
+import AmpersandCollection from "ampersand-rest-collection";
 import { BaseCollection } from "./base.js";
 import { BaseModel } from "../models/base.js";
 import { G } from "sp-test/api";
+import Promise from "bluebird";
 import td from "testdouble";
 
 it("should parse an array of urls into models", () => {
@@ -12,7 +14,7 @@ it("should parse an array of urls into models", () => {
 	expect(collection.models).toHaveLength(2);
 });
 
-it("should fetch the individual models in the collection", async function () {
+it("should fetch the individual models in the collection", async () => {
 	G(BaseModel, "TestModel");
 	const Collection = G(BaseCollection).extend({ model: "TestModel" });
 	const collection = new Collection([{ id: 1 }, { id: 2 }]);
@@ -119,3 +121,108 @@ it("should be empty on initialize", () => {
 	const collection = new Collection();
 	expect(collection.length).toEqual(0);
 });
+
+it("should be not 'areModelsFetched' if all models are just a url or integer", () => {
+	const AppointmentCollection = G("AppointmentCollection");
+	// A string or an integer should be considered not fetched
+	const collection = new AppointmentCollection(["/api/appointments/1/", 2]);
+	expect(collection.areModelsFetched()).toBe(false);
+});
+
+it("should be 'areModelsFetched' if models are objects", () => {
+	G(BaseModel, "TestModel");
+	const Collection = G(BaseCollection.extend({ model: "TestModel" }));
+	const collection = new Collection([{ id: 1 }, { id: 2 }]);
+	expect(collection.areModelsFetched()).toBe(true);
+});
+
+const mockFetchResults = (dataFn) => {
+	jest
+		.spyOn(AmpersandCollection.prototype, "fetch")
+		.mockImplementation((opts) => {
+			const fetchResults = dataFn(opts);
+			return Promise.resolve(fetchResults);
+		});
+};
+
+describe("fetchAll", () => {
+	it("calls Collection.prototype.fetch", async () => {
+		mockFetchResults(() => {
+			return {
+				results: [{ id: 20 }, { id: 21 }, { id: 22 }],
+			};
+		});
+
+		G(BaseModel, "TestModel");
+		const Collection = G(BaseCollection.extend({ model: "TestModel" }));
+		const baseCollection = new Collection();
+
+		await baseCollection.fetchAll();
+
+		expect(baseCollection.length).toEqual(3);
+		expect(baseCollection.first().id).toEqual(20);
+	});
+
+	it("adds results to existing results", async () => {
+		mockFetchResults(() => {
+			return {
+				results: [{ id: 22 }],
+			};
+		});
+
+		G(BaseModel, "TestModel");
+		const Collection = G(BaseCollection.extend({ model: "TestModel" }));
+		const baseCollection = new Collection([{ id: 15 }]);
+
+		await baseCollection.fetchAll();
+
+		expect(baseCollection.length).toEqual(2);
+		// The models are sorted by ID
+		expect(baseCollection.first().id).toEqual(15);
+		expect(baseCollection.last().id).toEqual(22);
+	});
+
+	it("fetches multiple pages", async () => {
+		mockFetchResults((opts) => {
+			const page = opts.data.page || 1;
+			const fetchResults = {
+				total_pages: 5,
+				page,
+				results: [{ id: page + 10 }],
+			};
+			return Promise.resolve(fetchResults);
+		});
+
+		G(BaseModel, "TestModel");
+		const Collection = G(BaseCollection.extend({ model: "TestModel" }));
+		const baseCollection = new Collection();
+
+		await baseCollection.fetchAll();
+
+		expect(baseCollection.length).toEqual(5);
+		expect(baseCollection.first().id).toEqual(11);
+		expect(baseCollection.last().id).toEqual(15);
+	});
+
+	it("stops fetching pages at the hardcoded limit", async () => {
+		mockFetchResults((opts) => {
+			const page = opts.data.page || 1;
+			const fetchResults = {
+				total_pages: 50,
+				page,
+				results: [{ id: page + 10 }],
+			};
+			return Promise.resolve(fetchResults);
+		});
+
+		G(BaseModel, "TestModel");
+		const Collection = G(BaseCollection.extend({ model: "TestModel" }));
+		const baseCollection = new Collection();
+
+		await baseCollection.fetchAll();
+
+		expect(baseCollection.length).toEqual(20);
+		expect(baseCollection.first().id).toEqual(11);
+		expect(baseCollection.last().id).toEqual(30);
+	});
+});

package/src/collections/deck-version-screenshots.js

@@ -0,0 +1,48 @@
+import "../models/deck-version-screenshot.js";
+
+import Auth from "../auth.js";
+import { BaseCollection } from "./base.js";
+import { register } from "../state-register.js";
+
+/**
+ * @constructor
+ * @alias collections.DeckVersionScreenshotCollection
+ * @extends collections.BaseCollection
+ * @see models.DeckVersionScreenshotModel
+ */
+export const DeckVersionScreenshotCollection = BaseCollection.extend(
+	/** @lends collections.DeckVersionScreenshotCollection# */ {
+		model: "DeckVersionScreenshotModel",
+
+		fetch(opts = {}) {
+			const { user } = Auth;
+
+			if (!opts.data) {
+				opts.data = {};
+			}
+
+			// Let's only add this if it's not already being set, in case a global user
+			// DOES want to see a specific team.
+			if (user && !opts.data.team) {
+				//
+				// Filter all global autoadjuncts, and only query teams that
+				// the authorized user is a part of. This is mostly for the case where
+				// a 'global' temp slide admin could end up seeing autoadjuncts for
+				// many teams - which would be increadibly confusing.
+				opts.data.team = [null].concat(user.team_set.map((team) => team.id));
+			}
+
+			return BaseCollection.prototype.fetch.call(this, opts);
+		},
+
+		url() {
+			if (!this._url && this.parent) {
+				this._options.deckversion = this.parent;
+			}
+
+			return BaseCollection.prototype.url.call(this);
+		},
+	}
+);
+
+register("DeckVersionScreenshotCollection", DeckVersionScreenshotCollection);

package/src/collections/tags.js

@@ -0,0 +1,18 @@
+import "../models/tag.js";
+
+import { BaseCollection } from "./base.js";
+import { register } from "../state-register.js";
+
+/**
+ * @constructor
+ * @alias collections.TagCollection
+ * @extends collections.BaseCollection
+ * @see models.TagModel
+ */
+export const TagCollection = BaseCollection.extend(
+	/** @lends collections.TagCollection# */ {
+		model: "TagModel",
+	}
+);
+
+register("TagCollection", TagCollection);

package/src/collections.js

@@ -14,6 +14,7 @@ export * from "./collections/contacts";
 export * from "./collections/created-assets";
 export * from "./collections/customers";
 export * from "./collections/deck-versions";
+export * from "./collections/deck-version-screenshots";
 export * from "./collections/decks";
 export * from "./collections/deleted-assets";
 export * from "./collections/dispatches";
@@ -36,5 +37,11 @@ export * from "./collections/users";
 export * from "./collections/uploads";
 export * from "./collections/appointment-editors.js";
 export * from "./collections/appointment-duplicates.js";
+export * from "./collections/tags.js";
 export * from "./collections/teams.js";
 export * from "./collections/templates.js";
+export * from "./collections/appointment-tags.js";
+export * from "./collections/appointment-deckversion-tags.js";
+export * from "./collections/appointment-section-tags.js";
+export * from "./collections/appointment-slide-tags.js";
+export * from "./collections/appointment-adjunct-tags.js";

package/src/models/activity-item.js

@@ -38,6 +38,8 @@ export const ActivityItemModel = BaseModel.extend(
 			notyours: "boolean",
 			onshare: "boolean",
 			view_type: "string",
+			is_muted: "boolean",
+			appointment_is_deleted: "boolean",
 		},
 
 		children: {

package/src/models/appointment-adjunct-tags.js

@@ -0,0 +1,41 @@
+import "./appointment.js";
+import "./user.js";
+import "./adjunct.js";
+
+import { BaseModel } from "./base.js";
+import { register } from "../state-register.js";
+
+/**
+ * @constructor
+ * @alias models.AppointmentAdjunctTagsModel
+ * @extends models.BaseModel
+ */
+export const AppointmentAdjunctTagsModel = BaseModel.extend(
+	/** @lends models.AppointmentAdjunctTagsModel# */ {
+		modelName: "appointment-adjunct-tags",
+
+		urlMatchKeys: {
+			"appointment.id": "number",
+		},
+
+		/**
+		 * @property {string[]} tags
+		 */
+		props: {
+			tags: "array",
+		},
+
+		/**
+		 * @property {models.AppointmentModel} appointment
+		 * @property {models.AdjunctModel} adjunct
+		 * @property {models.UserModel} user
+		 */
+		children: {
+			appointment: "AppointmentModel",
+			adjunct: "AdjunctModel",
+			user: "UserModel",
+		},
+	}
+);
+
+register("AppointmentAdjunctTagsModel", AppointmentAdjunctTagsModel);

package/src/models/appointment-deckversion-tags.js

@@ -0,0 +1,41 @@
+import "./appointment.js";
+import "./user.js";
+import "./deck-version.js";
+
+import { BaseModel } from "./base.js";
+import { register } from "../state-register.js";
+
+/**
+ * @constructor
+ * @alias models.AppointmentDeckVersionTagsModel
+ * @extends models.BaseModel
+ */
+export const AppointmentDeckVersionTagsModel = BaseModel.extend(
+	/** @lends models.AppointmentDeckVersionTagsModel# */ {
+		modelName: "appointment-deckversion-tags",
+
+		urlMatchKeys: {
+			"appointment.id": "number",
+		},
+
+		/**
+		 * @property {string[]} tags
+		 */
+		props: {
+			tags: "array",
+		},
+
+		/**
+		 * @property {models.AppointmentModel} appointment
+		 * @property {models.DeckVersionModel} deckversion
+		 * @property {models.UserModel} user
+		 */
+		children: {
+			appointment: "AppointmentModel",
+			deckversion: "DeckVersionModel",
+			user: "UserModel",
+		},
+	}
+);
+
+register("AppointmentDeckVersionTagsModel", AppointmentDeckVersionTagsModel);

package/src/models/appointment-section-tags.js

@@ -0,0 +1,41 @@
+import "./appointment.js";
+import "./user.js";
+import "./slide.js";
+
+import { BaseModel } from "./base.js";
+import { register } from "../state-register.js";
+
+/**
+ * @constructor
+ * @alias models.AppointmentSectionTagsModel
+ * @extends models.BaseModel
+ */
+export const AppointmentSectionTagsModel = BaseModel.extend(
+	/** @lends models.AppointmentSectionTagsModel# */ {
+		modelName: "appointment-section-tags",
+
+		urlMatchKeys: {
+			"appointment.id": "number",
+		},
+
+		/**
+		 * @property {string[]} tags
+		 */
+		props: {
+			tags: "array",
+		},
+
+		/**
+		 * @property {models.AppointmentModel} appointment
+		 * @property {models.SectionModel} slide
+		 * @property {models.UserModel} user
+		 */
+		children: {
+			appointment: "AppointmentModel",
+			section: "SectionModel",
+			user: "UserModel",
+		},
+	}
+);
+
+register("AppointmentSectionTagsModel", AppointmentSectionTagsModel);

package/src/models/appointment-slide-tags.js

@@ -0,0 +1,41 @@
+import "./appointment.js";
+import "./user.js";
+import "./slide.js";
+
+import { BaseModel } from "./base.js";
+import { register } from "../state-register.js";
+
+/**
+ * @constructor
+ * @alias models.AppointmentSlideTagsModel
+ * @extends models.BaseModel
+ */
+export const AppointmentSlideTagsModel = BaseModel.extend(
+	/** @lends models.AppointmentSlideTagsModel# */ {
+		modelName: "appointment-slide-tags",
+
+		urlMatchKeys: {
+			"appointment.id": "number",
+		},
+
+		/**
+		 * @property {string[]} tags
+		 */
+		props: {
+			tags: "array",
+		},
+
+		/**
+		 * @property {models.AppointmentModel} appointment
+		 * @property {models.SlideModel} slide
+		 * @property {models.UserModel} user
+		 */
+		children: {
+			appointment: "AppointmentModel",
+			slide: "SlideModel",
+			user: "UserModel",
+		},
+	}
+);
+
+register("AppointmentSlideTagsModel", AppointmentSlideTagsModel);