@glissandoo/lib 1.52.3 → 1.53.1

package/helpers/firestore.d.ts

@@ -0,0 +1,11 @@
+import * as firestore from '../types/firestore';
+/** Create a DocumentSnapshot. */
+export declare function makeDocumentSnapshot(
+/** Key-value pairs representing data in the document, pass in `{}` to mock the snapshot of
+ * a document that doesn't exist.
+ */
+data: {
+    [key: string]: unknown;
+}, 
+/** Full path of the reference (e.g. 'users/alovelace') */
+refPath: string, project: string): firestore.DocumentSnapshot<firestore.DocumentData>;

package/helpers/firestore.js

@@ -0,0 +1,196 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.makeDocumentSnapshot = void 0;
+const lodash_1 = require("lodash");
+const firestore = __importStar(require("../types/firestore"));
+const firebase = __importStar(require("firebase-admin"));
+/** @internal */
+function testApp() {
+    if (typeof testApp.singleton === 'undefined') {
+        testApp.init();
+    }
+    return testApp.singleton;
+}
+/** @internal */
+(function (testApp) {
+    testApp.init = () => (testApp.singleton = new testApp.App());
+    class App {
+        constructor() {
+            return;
+        }
+        getApp() {
+            if (typeof this.appSingleton === 'undefined') {
+                const config = process.env.FIREBASE_CONFIG
+                    ? JSON.parse(process.env.FIREBASE_CONFIG)
+                    : {};
+                this.appSingleton = firebase.initializeApp(config, 
+                // Give this app a name so it does not conflict with apps that user initialized.
+                'firebase-functions-test');
+            }
+            return this.appSingleton;
+        }
+        deleteApp() {
+            if (this.appSingleton) {
+                void this.appSingleton.delete();
+                delete this.appSingleton;
+            }
+        }
+    }
+    testApp.App = App;
+})(testApp || (testApp = {}));
+/** @internal */
+function objectToValueProto(data) {
+    const encodeHelper = (val) => {
+        if (typeof val === 'string') {
+            return {
+                stringValue: val,
+            };
+        }
+        if (typeof val === 'boolean') {
+            return {
+                booleanValue: val,
+            };
+        }
+        if (typeof val === 'number') {
+            if (val % 1 === 0) {
+                return {
+                    integerValue: val,
+                };
+            }
+            return {
+                doubleValue: val,
+            };
+        }
+        if (val instanceof Date) {
+            return {
+                timestampValue: val.toISOString(),
+            };
+        }
+        if (val instanceof Array) {
+            const encodedElements = [];
+            for (const elem of val) {
+                const enc = encodeHelper(elem);
+                if (enc) {
+                    encodedElements.push(enc);
+                }
+            }
+            return {
+                arrayValue: {
+                    values: encodedElements,
+                },
+            };
+        }
+        if (val === null) {
+            // TODO: Look this up. This is a google.protobuf.NulLValue,
+            // and everything in google.protobuf has a customized JSON encoder.
+            // OTOH, Firestore's generated .d.ts files don't take this into
+            // account and have the default proto layout.
+            return {
+                nullValue: 'NULL_VALUE',
+            };
+        }
+        if (val instanceof Buffer || val instanceof Uint8Array) {
+            return {
+                bytesValue: val,
+            };
+        }
+        if (val instanceof firestore.DocumentReference) {
+            const projectId = (0, lodash_1.get)(val, '_referencePath.projectId');
+            const database = (0, lodash_1.get)(val, '_referencePath.databaseId');
+            const referenceValue = [
+                'projects',
+                projectId,
+                'databases',
+                database,
+                val.path,
+            ].join('/');
+            return { referenceValue };
+        }
+        if (val instanceof firestore.Timestamp) {
+            return {
+                timestampValue: val.toDate().toISOString(),
+            };
+        }
+        if (val instanceof firestore.GeoPoint) {
+            return {
+                geoPointValue: {
+                    latitude: val.latitude,
+                    longitude: val.longitude,
+                },
+            };
+        }
+        if ((0, lodash_1.isPlainObject)(val)) {
+            if (!val)
+                return;
+            return {
+                mapValue: {
+                    fields: objectToValueProto(val),
+                },
+            };
+        }
+        throw new Error('Cannot encode to a Firestore Value');
+    };
+    return (0, lodash_1.mapValues)(data, encodeHelper);
+}
+function dateToTimestampProto(timeString) {
+    if (typeof timeString === 'undefined') {
+        return;
+    }
+    const date = new Date(timeString);
+    const seconds = Math.floor(date.getTime() / 1000);
+    let nanos = 0;
+    if (timeString.length > 20) {
+        const nanoString = timeString.substring(20, timeString.length - 1);
+        const trailingZeroes = 9 - nanoString.length;
+        nanos = parseInt(nanoString, 10) * Math.pow(10, trailingZeroes);
+    }
+    return { seconds, nanos };
+}
+/** Create a DocumentSnapshot. */
+function makeDocumentSnapshot(
+/** Key-value pairs representing data in the document, pass in `{}` to mock the snapshot of
+ * a document that doesn't exist.
+ */
+data, 
+/** Full path of the reference (e.g. 'users/alovelace') */
+refPath, project) {
+    const firestoreService = firebase.firestore(testApp().getApp());
+    const resource = `projects/${project}/databases/(default)/documents/${refPath}`;
+    const proto = (0, lodash_1.isEmpty)(data)
+        ? resource
+        : {
+            fields: objectToValueProto(data),
+            createTime: dateToTimestampProto(new Date().toISOString()),
+            updateTime: dateToTimestampProto(new Date().toISOString()),
+            name: resource,
+        };
+    const readTimeProto = dateToTimestampProto(new Date().toISOString());
+    /* eslint-disable */
+    // @ts-ignore
+    return firestoreService.snapshot_(proto, readTimeProto, 'json');
+    /* eslint-enable */
+}
+exports.makeDocumentSnapshot = makeDocumentSnapshot;

package/models/Evento/Player/Basic.d.ts

@@ -0,0 +1,28 @@
+import { LanguagesTypes } from '../../../lang';
+import { AEventPlayerBasicData } from '../types';
+import { EventPlayerStatus } from './types';
+export default class EventoPlayerBasic {
+    eventId: string;
+    exists: boolean;
+    protected data: AEventPlayerBasicData;
+    protected lang: LanguagesTypes;
+    constructor(eventId: string, data: AEventPlayerBasicData | null, lang?: LanguagesTypes);
+    get id(): string;
+    get username(): string;
+    get displayName(): string;
+    get photoURL(): string;
+    get mainInstrument(): import("../../../helpers/instruments").InstrumentId;
+    get status(): EventPlayerStatus | null;
+    get reason(): import("./types").EventPlayerReason | null;
+    get note(): string | null;
+    get rollcall(): EventPlayerStatus | null;
+    get interested(): true | null;
+    get selected(): boolean | null;
+    get isActive(): boolean;
+    get isInterested(): boolean;
+    get isConfirmed(): boolean;
+    get isDeclined(): boolean;
+    get isPending(): boolean;
+    get isRollCallConfirmed(): boolean;
+    get isRollCallDeclined(): boolean;
+}

package/models/Evento/Player/Basic.js

@@ -0,0 +1,68 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const lodash_1 = require("lodash");
+const lang_1 = require("../../../lang");
+const types_1 = require("./types");
+class EventoPlayerBasic {
+    constructor(eventId, data, lang = lang_1.defaultLocale) {
+        this.eventId = eventId;
+        this.data = data || {};
+        this.exists = data !== null;
+        this.lang = lang;
+    }
+    get id() {
+        return this.data.id;
+    }
+    get username() {
+        return this.data.username;
+    }
+    get displayName() {
+        return this.data.displayName;
+    }
+    get photoURL() {
+        return this.data.photoURL;
+    }
+    get mainInstrument() {
+        return this.data.mainInstrument;
+    }
+    get status() {
+        return this.data.status;
+    }
+    get reason() {
+        return this.data.reason || null;
+    }
+    get note() {
+        return this.data.note || null;
+    }
+    get rollcall() {
+        return this.data.rollcall || null;
+    }
+    get interested() {
+        return this.data.interested || null;
+    }
+    get selected() {
+        return !(0, lodash_1.isUndefined)(this.data.selected) ? this.data.selected : null;
+    }
+    get isActive() {
+        return this.exists && this.selected !== false;
+    }
+    get isInterested() {
+        return this.interested === true;
+    }
+    get isConfirmed() {
+        return this.status === types_1.EventPlayerStatus.Confirmed;
+    }
+    get isDeclined() {
+        return this.status === types_1.EventPlayerStatus.Declined;
+    }
+    get isPending() {
+        return this.status === null;
+    }
+    get isRollCallConfirmed() {
+        return this.rollcall === types_1.EventPlayerStatus.Confirmed;
+    }
+    get isRollCallDeclined() {
+        return this.rollcall === types_1.EventPlayerStatus.Declined;
+    }
+}
+exports.default = EventoPlayerBasic;

package/models/Evento/index.d.ts

@@ -1,9 +1,9 @@
 import { InstrumentId } from '../../helpers/instruments';
 import { LanguagesTypes } from '../../lang';
 import { DocumentReference, DocumentSnapshot } from '../../types/firestore';
-import { EventPlayerStatus } from './Player/types';
 import EventoPromoter from './promoter';
-import { EventData, EventPlayerBasicData, EventResponseDeadlineOptions, EventStatusByTime } from './types';
+import { EventData, EventResponseDeadlineOptions, EventStatusByTime } from './types';
+import EventoPlayerBasic from './Player/Basic';
 export default class Evento extends EventoPromoter<EventData> {
     constructor(doc: DocumentSnapshot, lang?: LanguagesTypes);
     get maxAttendance(): number | null;
@@ -17,7 +17,9 @@ export default class Evento extends EventoPromoter<EventData> {
     get relEvents(): string[];
     get isASerie(): boolean;
     get playerIds(): string[];
-    get players(): Record<string, EventPlayerBasicData>;
+    get players(): {
+        [x: string]: EventoPlayerBasic;
+    };
     get playersCount(): number;
     get repertory(): Record<string, import("./types").EventThemeBasicData>;
     get repertoryIds(): string[];
@@ -49,19 +51,7 @@ export default class Evento extends EventoPromoter<EventData> {
     playersList({ showAll, order }?: {
         showAll?: boolean;
         order?: InstrumentId[];
-    }): {
-        note?: string | null | undefined;
-        reason?: import("./Player/types").EventPlayerReason | null | undefined;
-        status: EventPlayerStatus | null;
-        rollcall: EventPlayerStatus | null;
-        interested: true | null;
-        selected: boolean | null;
-        mainInstrument: InstrumentId;
-        username: string;
-        displayName: string;
-        photoURL: string;
-        id: string;
-    }[];
+    }): EventoPlayerBasic[];
     get interestedPlayers(): string[];
     get confirmedPlayers(): string[];
     get declinedPlayers(): string[];
@@ -73,13 +63,7 @@ export default class Evento extends EventoPromoter<EventData> {
     get templateId(): string | null;
     get repeat(): import("./types").EventRepeatType | null;
     isPlayer: (userId: string) => boolean;
-    isPlayerActive: (userId: string) => boolean;
-    getPlayer: (userId: string) => EventPlayerBasicData | null;
-    isPlayerInterested(player: EventPlayerBasicData): boolean;
-    isPlayerConfirmed(player: EventPlayerBasicData): boolean;
-    isPlayerDeclined(player: EventPlayerBasicData): boolean;
-    isPlayerRollCallConfirmed(player: EventPlayerBasicData): boolean;
-    isPlayerRollCallDeclined(player: EventPlayerBasicData): boolean;
+    getPlayer: (userId: string) => EventoPlayerBasic | null;
     get responseDeadline(): {
         option: EventResponseDeadlineOptions;
         customAt: import("../../types/firestore").Timestamp | null;

package/models/Evento/index.js

@@ -8,19 +8,15 @@ const lodash_1 = require("lodash");
 const orders_1 = require("../../helpers/musicStyles/orders");
 const utils_1 = require("../../helpers/utils");
 const lang_1 = require("../../lang");
-const types_1 = require("./Player/types");
 const promoter_1 = __importDefault(require("./promoter"));
-const types_2 = require("./types");
+const types_1 = require("./types");
+const Basic_1 = __importDefault(require("./Player/Basic"));
 class Evento extends promoter_1.default {
     constructor(doc, lang = lang_1.defaultLocale) {
         super(doc, lang);
         this.isPlayer = (userId) => {
             return this.playerIds.includes(userId);
         };
-        this.isPlayerActive = (userId) => {
-            const player = this.getPlayer(userId);
-            return player !== null && player.selected !== false;
-        };
         this.getPlayer = (userId) => {
             return userId in this.players ? this.players[userId] : null;
         };
@@ -59,7 +55,7 @@ class Evento extends promoter_1.default {
         return this.data.playerIds || [];
     }
     get players() {
-        return this.data.players || {};
+        return (0, lodash_1.mapValues)(this.data.players || {}, (player, id) => new Basic_1.default(this.id, { id, ...player }, this.lang));
     }
     get playersCount() {
         return this.data.playerIds.length;
@@ -121,12 +117,12 @@ class Evento extends promoter_1.default {
     }
     get statusByTime() {
         if (this.isOutDate) {
-            return types_2.EventStatusByTime.Past;
+            return types_1.EventStatusByTime.Past;
         }
         if (this.isHappening) {
-            return types_2.EventStatusByTime.Now;
+            return types_1.EventStatusByTime.Now;
         }
-        return types_2.EventStatusByTime.Future;
+        return types_1.EventStatusByTime.Future;
     }
     get repertoryList() {
         const repertory = Object.keys(this.repertory).map((themeId) => ({
@@ -136,34 +132,31 @@ class Evento extends promoter_1.default {
         return (0, lodash_1.orderBy)(repertory, 'order', 'asc');
     }
     playersList({ showAll, order } = {}) {
-        const players = this.playerIds.map((playerId) => ({
-            id: playerId,
-            ...this.players[playerId],
-        }));
+        const players = Object.values(this.players);
         const orderedPlayers = order
             ? (0, utils_1.sortByMatch)(players, 'mainInstrument', order)
             : (0, orders_1.orderByMusicStyle)(players, 'mainInstrument', this.promoterInfo.musicStyle);
         if (showAll)
             return orderedPlayers;
-        return orderedPlayers.filter((player) => this.isPlayerActive(player.id));
+        return orderedPlayers.filter((player) => player.isActive);
     }
     get interestedPlayers() {
-        return this.playerIds.filter((playerId) => this.isPlayerInterested(this.players[playerId]));
+        return this.playerIds.filter((playerId) => this.players[playerId].isInterested);
     }
     get confirmedPlayers() {
-        return this.playerIds.filter((playerId) => this.isPlayerConfirmed(this.players[playerId]));
+        return this.playerIds.filter((playerId) => this.players[playerId].isConfirmed);
     }
     get declinedPlayers() {
-        return this.playerIds.filter((playerId) => this.isPlayerDeclined(this.players[playerId]));
+        return this.playerIds.filter((playerId) => this.players[playerId].isDeclined);
     }
     get pendingPlayers() {
-        return this.playerIds.filter((playerId) => !this.players[playerId].status);
+        return this.playerIds.filter((playerId) => this.players[playerId].isPending);
     }
     get confirmedRollCallPlayers() {
-        return this.playerIds.filter((playerId) => this.isPlayerRollCallConfirmed(this.players[playerId]));
+        return this.playerIds.filter((playerId) => this.players[playerId].isRollCallConfirmed);
     }
     get declinedRollCallPlayers() {
-        return this.playerIds.filter((playerId) => this.isPlayerRollCallDeclined(this.players[playerId]));
+        return this.playerIds.filter((playerId) => this.players[playerId].isRollCallDeclined);
     }
     get isRollCalled() {
         return this.rollCalledAt !== null;
@@ -177,24 +170,9 @@ class Evento extends promoter_1.default {
     get repeat() {
         return this.data.repeat || null;
     }
-    isPlayerInterested(player) {
-        return player.interested === true;
-    }
-    isPlayerConfirmed(player) {
-        return player.status === types_1.EventPlayerStatus.Confirmed;
-    }
-    isPlayerDeclined(player) {
-        return player.status === types_1.EventPlayerStatus.Declined;
-    }
-    isPlayerRollCallConfirmed(player) {
-        return player.rollcall === types_1.EventPlayerStatus.Confirmed;
-    }
-    isPlayerRollCallDeclined(player) {
-        return player.rollcall === types_1.EventPlayerStatus.Declined;
-    }
     get responseDeadline() {
         return (this.data.responseDeadline || {
-            option: types_2.EventResponseDeadlineOptions.BeforeEvent,
+            option: types_1.EventResponseDeadlineOptions.BeforeEvent,
             customAt: null,
         });
     }
@@ -205,10 +183,10 @@ class Evento extends promoter_1.default {
         return this.data.selectionModeClosedAt || null;
     }
     get isSelectionModeClose() {
-        return (!(0, lodash_1.isNull)(this.selectionModeClosedAt) && this.selectionMode === types_2.EventSelectionMode.Closed);
+        return (!(0, lodash_1.isNull)(this.selectionModeClosedAt) && this.selectionMode === types_1.EventSelectionMode.Closed);
     }
     get isSelectionModeOpen() {
-        return (0, lodash_1.isNull)(this.selectionModeClosedAt) && this.selectionMode === types_2.EventSelectionMode.Open;
+        return (0, lodash_1.isNull)(this.selectionModeClosedAt) && this.selectionMode === types_1.EventSelectionMode.Open;
     }
 }
 exports.default = Evento;

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@glissandoo/lib",
-	"version": "1.52.3",
+	"version": "1.53.1",
 	"description": "Glissandoo library js",
 	"main": "./index.js",
 	"types": "./index.d.ts",