@glissandoo/lib 1.123.2 → 1.124.0-dev.219.1

package/models/Group/Repertory/index.d.ts

@@ -0,0 +1,64 @@
+import { InstrumentId } from '../../../helpers/instruments';
+import { rateSteps } from '../../../helpers/rates';
+import { LanguagesTypes } from '../../../lang';
+import EventoTiny from '../../Evento/tiny';
+import { DocumentModel } from '../../Model';
+import Theme from '../../Repertory/basic';
+import { FileSectionId } from './File/Section/types';
+import { GroupRepertoireVisibility, GroupRepertoryData, SourceComposition, AcquisitionStatus } from './types';
+export default class GroupRepertory extends Theme<GroupRepertoryData> {
+    lang: LanguagesTypes;
+    constructor(doc: DocumentModel, lang?: LanguagesTypes);
+    get groupId(): string;
+    get tagsAlgolia(): import("./types").GroupRepertoryTagAlgoliaData[];
+    get files(): Record<string, import("./types").GroupRepertoireFile>;
+    get fileList(): (import("./types").GroupRepertoireFile & {
+        id: string;
+    })[];
+    get sectionIds(): FileSectionId[];
+    get filesPath(): Partial<Record<FileSectionId, ({
+        tag: string;
+    } & {
+        path: string;
+    })[]>>;
+    get filesPathList(): {
+        tag: string;
+        path: string;
+        sectionId: FileSectionId;
+    }[];
+    get visibility(): GroupRepertoireVisibility;
+    get votes(): Record<string, import("./types").VoteValue>;
+    get votesCount(): number;
+    get votesCountByValues(): Record<(typeof rateSteps)[number]["id"], number>;
+    voteByUserId(userId: string): import("./types").VoteValue;
+    get rating(): number;
+    get events(): string[];
+    get eventsTL(): Record<string, import("../../Evento/types").EventTinyData>;
+    get eventsList(): EventoTiny[];
+    get editedAt(): FirebaseFirestore.Timestamp | null;
+    get editedBy(): string | null;
+    get createdAt(): FirebaseFirestore.Timestamp;
+    get isActive(): boolean;
+    get thumbnailURL(): string | null;
+    get ownerId(): string;
+    get lastEventDatetime(): FirebaseFirestore.Timestamp | null;
+    get sourceComposition(): SourceComposition | null;
+    get acquisitionStatus(): AcquisitionStatus | null;
+    get isFromComposer(): boolean;
+    get claims(): Partial<Record<InstrumentId, Record<string, import("./types").GroupRepertoryClaimType>>>;
+    get claimsList(): {
+        createdAt: FirebaseFirestore.Timestamp;
+        notifiedAt: FirebaseFirestore.Timestamp | null;
+        userId: string;
+        instrumentId: InstrumentId;
+        hasFile: boolean;
+    }[];
+    hasInstrumentAFile(instrumentId: InstrumentId): boolean;
+    claimsByInstrument(instrumentId: InstrumentId): Record<string, import("./types").GroupRepertoryClaimType>;
+    getPlayersByInstrumentClaimed(instrumentId: InstrumentId, onlyNoNotified?: boolean): string[];
+    isInstrumentClaimed(instrumentId: string): boolean;
+    isInstrumentClaimedByPlayer(instrumentId: InstrumentId, userId: string): boolean;
+    getEventsByOrder(order?: 'asc' | 'desc'): EventoTiny[];
+    getNextEvents(endDay?: boolean): EventoTiny[];
+    getNextEvent(endDay?: boolean): EventoTiny | null;
+}

package/models/Group/Repertory/index.js

@@ -0,0 +1,160 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const date_fns_1 = require("date-fns");
+const lodash_1 = require("lodash");
+const orderBy_1 = __importDefault(require("lodash/orderBy"));
+const objects_1 = require("../../../helpers/objects");
+const rates_1 = require("../../../helpers/rates");
+const ts_extras_1 = require("../../../helpers/ts-extras");
+const utils_1 = require("../../../helpers/utils");
+const lang_1 = require("../../../lang");
+const tiny_1 = __importDefault(require("../../Evento/tiny"));
+const basic_1 = __importDefault(require("../../Repertory/basic"));
+const types_1 = require("./File/Section/types");
+const types_2 = require("./types");
+class GroupRepertory extends basic_1.default {
+    constructor(doc, lang = lang_1.defaultLocale) {
+        super(doc);
+        this.lang = lang_1.defaultLocale;
+        this.lang = lang;
+    }
+    get groupId() {
+        return (0, utils_1.at)(this.ref.path.split('/'), 1) || '';
+    }
+    get tagsAlgolia() {
+        return this.data.tagsAlgolia || [];
+    }
+    get files() {
+        return this.data.files || {};
+    }
+    get fileList() {
+        return (0, objects_1.mapToArray)(this.files);
+    }
+    get sectionIds() {
+        return (0, lodash_1.uniq)(this.fileList.map((file) => Object.keys(file.sections)).flat());
+    }
+    get filesPath() {
+        return this.data.filesPath || {};
+    }
+    get filesPathList() {
+        return Object.entries(this.filesPath)
+            .map(([sectionId, files]) => (files || []).map((file) => ({ sectionId: sectionId, ...file })))
+            .flat();
+    }
+    get visibility() {
+        return this.data.visibility || types_2.GroupRepertoireVisibility.ByEvent;
+    }
+    get votes() {
+        return this.data.votes || {};
+    }
+    get votesCount() {
+        return Object.keys(this.votes).length;
+    }
+    get votesCountByValues() {
+        const existingCounts = (0, lodash_1.countBy)(Object.values(this.votes));
+        const allCountsEntries = rates_1.rateSteps.map(({ id, value }) => [id, existingCounts[`${value}`] || 0]);
+        return Object.fromEntries(allCountsEntries);
+    }
+    voteByUserId(userId) {
+        return this.votes[userId] || null;
+    }
+    get rating() {
+        const totalVotes = (0, lodash_1.sum)(Object.values(this.votes));
+        return totalVotes == 0 ? 0 : Math.round((totalVotes / this.votesCount) * 100) / 100;
+    }
+    get events() {
+        return this.data.events || [];
+    }
+    get eventsTL() {
+        return this.data.eventsTL || {};
+    }
+    get eventsList() {
+        return Object.keys(this.eventsTL).map((id) => new tiny_1.default(id, this.eventsTL[id], this.lang));
+    }
+    get editedAt() {
+        return this.data.editedAt || null;
+    }
+    get editedBy() {
+        return this.data.editedBy || null;
+    }
+    get createdAt() {
+        return this.data.createdAt;
+    }
+    get isActive() {
+        return this.exists;
+    }
+    get thumbnailURL() {
+        return this.data.thumbnailURL || null;
+    }
+    get ownerId() {
+        return this.data.owner.id;
+    }
+    get lastEventDatetime() {
+        return this.data.lastEventDatetime || null;
+    }
+    get sourceComposition() {
+        return this.data.sourceComposition || null;
+    }
+    get acquisitionStatus() {
+        return this.data.acquisitionStatus || null;
+    }
+    get isFromComposer() {
+        return !!this.data.sourceComposition;
+    }
+    get claims() {
+        return this.data.claims || {};
+    }
+    get claimsList() {
+        return (0, ts_extras_1.objectEntries)(this.claims)
+            .map(([iId, users]) => (0, ts_extras_1.objectEntries)(users || {}).map(([userId, claim]) => ({
+            userId,
+            instrumentId: iId,
+            hasFile: this.hasInstrumentAFile(iId),
+            ...(claim || {}),
+        })))
+            .flat();
+    }
+    hasInstrumentAFile(instrumentId) {
+        return (this.sectionIds.includes(types_1.FileSectionIdReserved.All) ||
+            this.sectionIds.includes(instrumentId));
+    }
+    claimsByInstrument(instrumentId) {
+        if (!this.isInstrumentClaimed(instrumentId)) {
+            return {};
+        }
+        return instrumentId in this.claims ? this.claims[instrumentId] || {} : {};
+    }
+    getPlayersByInstrumentClaimed(instrumentId, onlyNoNotified = false) {
+        const claimsByInstrument = this.claimsByInstrument(instrumentId);
+        if (!onlyNoNotified) {
+            return Object.keys(claimsByInstrument);
+        }
+        return Object.keys(claimsByInstrument).filter((userId) => !claimsByInstrument[userId].notifiedAt);
+    }
+    isInstrumentClaimed(instrumentId) {
+        return instrumentId in this.claims;
+    }
+    isInstrumentClaimedByPlayer(instrumentId, userId) {
+        if (!this.isInstrumentClaimed(instrumentId)) {
+            return false;
+        }
+        return userId in (this.claims[instrumentId] || {});
+    }
+    getEventsByOrder(order = 'desc') {
+        return (0, orderBy_1.default)(this.eventsList, (e) => e.datetime.toDate(), [order]);
+    }
+    getNextEvents(endDay = false) {
+        return this.getEventsByOrder().filter((ev) => endDay ? (0, date_fns_1.isFuture)((0, date_fns_1.endOfDay)(ev.datetime.toDate())) : (0, date_fns_1.isFuture)(ev.datetime.toDate()));
+    }
+    getNextEvent(endDay = false) {
+        const events = this.getNextEvents(endDay);
+        if (events.length === 0) {
+            return null;
+        }
+        return events[events.length - 1];
+    }
+}
+exports.default = GroupRepertory;

package/models/Group/Repertory/types.d.ts

@@ -0,0 +1,80 @@
+import { DocumentReference, Timestamp } from '@google-cloud/firestore';
+import { InstrumentId } from '../../../helpers/instruments';
+import { EventTinyData } from '../../Evento/types';
+import { BaseRepertoireFile, RepertoireFileId, SourceComposition, ThemeBasicData } from '../../Repertory/types';
+import { FileSectionId, SectionArrayRecordByTags, SectionRecord } from './File/Section/types';
+import { UserId } from '../../User/types';
+export type { SourceComposition } from '../../Repertory/types';
+export declare enum GroupRepertoireVisibility {
+    Always = "always",
+    ByEvent = "byEvent"
+}
+export interface AGroupRepertoryClaim extends GroupRepertoryClaimType {
+    userId: string;
+    instrumentId: InstrumentId;
+}
+export interface GroupRepertoryViewer {
+    viewedAt: Timestamp;
+    lastViewedAt: Timestamp;
+    count: number;
+}
+export interface GroupRepertoryClaimType {
+    createdAt: Timestamp;
+    notifiedAt: Timestamp | null;
+}
+export interface GroupRepertoryTagAlgoliaData {
+    query: string;
+    objectID: string | null;
+}
+export interface GroupRepertoryInstrumentItemData {
+    id: InstrumentId;
+    pages: number[];
+    filesPath?: string[];
+}
+export interface GroupRepertoireScoreFilePage {
+    tags: string[];
+}
+export interface AGroupRepertoireScoreFilePage extends GroupRepertoireScoreFilePage {
+    id: FileSectionId;
+}
+export type RepertoirePageNumber = string;
+export interface GroupRepertoireFileSections {
+    tags?: string[];
+    pages?: Record<RepertoirePageNumber, GroupRepertoireScoreFilePage>;
+}
+export interface GroupRepertoireFile extends BaseRepertoireFile {
+    readonly pageCount: number | null;
+    readonly isEncrypted: boolean;
+    identifyAt: number | null;
+    sections: SectionRecord<GroupRepertoireFileSections>;
+}
+export type GroupRepertoireFilePath = SectionArrayRecordByTags<{
+    path: string;
+}>;
+export type GroupRepertoireFilePathItem = NonNullable<GroupRepertoireFilePath[keyof GroupRepertoireFilePath]>[number];
+export type VoteValue = 1 | 2 | 3 | 4;
+export type { AcquiredProduct, AcquiredProductsMap, } from '../../supabase/Composer/Composition/Acquisition/types';
+export declare enum AcquisitionStatus {
+    Preparing = "preparing",
+    ActionsNeeded = "actionsNeeded",
+    Ready = "ready"
+}
+export interface GroupRepertoryData extends ThemeBasicData {
+    events: string[];
+    eventsTL: Record<string, EventTinyData>;
+    tagsAlgolia: GroupRepertoryTagAlgoliaData[];
+    files: Record<RepertoireFileId, GroupRepertoireFile>;
+    filesPath: GroupRepertoireFilePath;
+    votes: Record<string, VoteValue>;
+    thumbnailURL: string | null;
+    editedAt: Timestamp | null;
+    editedBy: string | null;
+    visibility: GroupRepertoireVisibility;
+    lastEventDatetime: Timestamp | null;
+    claims: Partial<Record<InstrumentId, Record<UserId, GroupRepertoryClaimType>>>;
+    clonedFrom: DocumentReference | null;
+    sourceComposition?: SourceComposition | null;
+    acquisitionStatus?: AcquisitionStatus | null;
+    readonly owner: DocumentReference;
+    readonly createdAt: Timestamp;
+}

package/models/Group/Repertory/types.js

@@ -0,0 +1,14 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AcquisitionStatus = exports.GroupRepertoireVisibility = void 0;
+var GroupRepertoireVisibility;
+(function (GroupRepertoireVisibility) {
+    GroupRepertoireVisibility["Always"] = "always";
+    GroupRepertoireVisibility["ByEvent"] = "byEvent";
+})(GroupRepertoireVisibility || (exports.GroupRepertoireVisibility = GroupRepertoireVisibility = {}));
+var AcquisitionStatus;
+(function (AcquisitionStatus) {
+    AcquisitionStatus["Preparing"] = "preparing";
+    AcquisitionStatus["ActionsNeeded"] = "actionsNeeded";
+    AcquisitionStatus["Ready"] = "ready";
+})(AcquisitionStatus || (exports.AcquisitionStatus = AcquisitionStatus = {}));

package/models/Group/index.d.ts

@@ -0,0 +1,145 @@
+import { DocumentReference } from '@google-cloud/firestore';
+import { CustomInstrumentId } from '../../helpers/instruments';
+import { PlansGroup } from '../../helpers/plans';
+import { LanguagesTypes } from '../../lang';
+import { GroupPayoutRuleEntry } from '../../types/payoutRule';
+import { EventPlayerStatus } from '../Evento/Player/types';
+import { DocumentModel } from '../Model';
+import GroupBasic from './basic';
+import { AGroupCustomField, AGroupInstrument, AdminPermissions, CustomGroupInstrument, GroupConfigShowAttendanceToMembers, GroupData, GroupModuleData, GroupModuleId, GroupModules, GroupStatus, SocialNetwork } from './types';
+export default class Group extends GroupBasic<GroupData> {
+    constructor(doc: DocumentModel, lang?: LanguagesTypes);
+    get owner(): DocumentReference;
+    get playerIds(): string[];
+    get players(): Record<string, import("../Player/types").PlayerBasicData>;
+    get playersCount(): number;
+    get description(): string | null;
+    get addresses(): import("./types").GroupAddressData[];
+    get addressDefault(): import("./types").GroupAddressData | undefined;
+    get activeInvitationLink(): boolean;
+    get invitationLink(): string;
+    getInvitationLink(landingHost: string): string;
+    get invitationEmails(): string[];
+    get shortDynamicLink(): string;
+    getShortDynamicLink(appHost: string): string;
+    get admins(): string[];
+    get adminPermissions(): Record<string, AdminPermissions[]>;
+    permissionsByAdmin(userId: string): AdminPermissions[];
+    adminsByPermissions(permission: AdminPermissions): string[];
+    get createdAt(): FirebaseFirestore.Timestamp;
+    get deletedAt(): FirebaseFirestore.Timestamp | null;
+    get deletedBy(): string | null;
+    get repertoryCount(): number;
+    get eventCount(): Record<import("../Evento/types").EventType, number>;
+    get performanceCount(): number;
+    get practiceCount(): number;
+    get eventTotalCount(): number;
+    get communicationCount(): number;
+    get country(): string;
+    get currency(): string;
+    get currencySymbol(): string;
+    get activePlayers(): string[];
+    get playersList(): {
+        id: string;
+        mainInstrument: import("../../helpers/instruments").InstrumentId;
+        username: string;
+        name: string;
+        lastname: string;
+        displayName: string;
+        photoURL: string;
+    }[];
+    get isActive(): boolean;
+    get isDeleted(): boolean;
+    get intercomId(): string | null;
+    get partnershipId(): string | null;
+    get customerId(): string | null;
+    get socialNetworks(): Record<SocialNetwork, string | null>;
+    getSocialNetworkUrl(id: SocialNetwork): string | null;
+    get config(): {
+        includesMembersToEventsWhenJoined: boolean;
+        allowEditInstruments: boolean;
+        showAttendanceToMembers: GroupConfigShowAttendanceToMembers;
+        allowVerifyGeoLoc: boolean;
+    };
+    get configSites(): {
+        active: boolean;
+        showEvents: boolean;
+        showMembers: boolean;
+    };
+    get status(): GroupStatus;
+    get planId(): PlansGroup;
+    get templates(): Record<string, import("./types").GroupTemplateData>;
+    get templatesList(): (import("./types").GroupTemplateData & {
+        id: string;
+    })[];
+    get satisfactionIndex(): {
+        current: number;
+        last: number;
+    };
+    get metadata(): Record<string, string>;
+    getPlayer: (userId: string) => import("../Player/types").PlayerBasicData | null;
+    isAdmin: (userId: string) => boolean;
+    isPlayer: (userId: string) => boolean;
+    /** @deprecated use isUpgradeRequired */
+    get isExpiredTrial(): boolean;
+    get isOutOfMembersLimit(): boolean;
+    get isUpgradePlanRequired(): boolean;
+    get firstAnswerAt(): FirebaseFirestore.Timestamp | null;
+    get repertoireTags(): Record<string, import("./types").GroupRepertoireTag>;
+    get repertoireTagsList(): (import("./types").GroupRepertoireTag & {
+        id: string;
+    })[];
+    getRepertoireTagName(id: string): string | null;
+    get trialEndAt(): Date;
+    get glissandooAdminUrl(): string;
+    getGlissandooAdminUrl(adminHost: string): string;
+    get createdOn(): import("../../helpers/types").CreatedOn;
+    get instruments(): import("./types").GroupInstruments;
+    get instrumentsList(): AGroupInstrument[];
+    get instrumentsIds(): (import("../../helpers/instruments").DefaultInstrumentId | `customInstrument-${string}`)[];
+    get customInstruments(): Record<CustomInstrumentId, CustomGroupInstrument>;
+    get customInstrumentsList(): Pick<CustomGroupInstrument & {
+        id: `customInstrument-${string}`;
+    }, "id" | "name" | "icon" | "basedOnInstrument">[];
+    get customInstrumentsIds(): `customInstrument-${string}`[];
+    get visitedDashboardAt(): Record<string, FirebaseFirestore.Timestamp>;
+    get onboardingMessages(): import("./types").GroupOnboardingMessage[];
+    get rollcallLink(): string;
+    getRollcallLink(landingHost: string): string;
+    get subscriptionId(): string | null;
+    get questions(): Record<string, import("./types").GroupEventQuestion>;
+    get questionsList(): {
+        updatedBy: string;
+        title: string;
+        status: EventPlayerStatus;
+        isDefault: boolean;
+        answers: {
+            id: string;
+            text: string;
+        }[];
+        allowNotes: boolean;
+        multiselect: boolean;
+        id: string;
+    }[];
+    getDefaultQuestion(status: EventPlayerStatus): {
+        updatedBy: string;
+        title: string;
+        status: EventPlayerStatus;
+        isDefault: boolean;
+        answers: {
+            id: string;
+            text: string;
+        }[];
+        allowNotes: boolean;
+        multiselect: boolean;
+        id: string;
+    } | undefined;
+    get customFields(): Record<string, import("./types").GroupCustomField>;
+    get customFieldsList(): AGroupCustomField[];
+    get inventoryId(): string;
+    get coverURL(): string | null;
+    get modules(): GroupModules;
+    getModule(id: GroupModuleId): GroupModuleData | null;
+    isModuleEnabled(id: GroupModuleId): boolean;
+    get payoutRules(): GroupPayoutRuleEntry[];
+}