@glissandoo/lib 1.123.2 → 1.124.0-dev.219.1

package/models/Evento/types.d.ts

@@ -0,0 +1,177 @@
+import { DocumentReference, GeoPoint, Timestamp } from '@google-cloud/firestore';
+import { Descendant } from '../../helpers/slate';
+import { CreatedOn } from '../../helpers/types';
+import { EventoPayoutRuleEntry } from '../../types/payoutRule';
+import { StageTemplate } from '../Group/StageTemplate/types';
+import { GroupBasicData } from '../Group/types';
+import { PlayerBasicData } from '../Player/types';
+import { SourceComposition, ThemeBasicData } from '../Repertory/types';
+import { EventPlayerAnswers, EventPlayerReason, EventPlayerStatus } from './Player/types';
+export { EventHistoryAction } from '../supabase/EventHistory/types';
+export declare enum EventReminderOptions {
+    OneHours = "1-hours",
+    ThreeHours = "3-hours",
+    TwelveHours = "12-hours",
+    OneDay = "1-days",
+    ThreeDays = "3-days",
+    OneWeek = "1-weeks",
+    TwoWeeks = "2-weeks",
+    Custom = "custom"
+}
+export declare enum EventResponseDeadlineOptions {
+    BeforeEvent = "BeforeEvent",
+    OneHourBefore = "OneHourBefore",
+    OneDayBefore = "OneDayBefore",
+    OneWeekBefore = "OneWeekBefore",
+    Custom = "Custom"
+}
+export declare enum EventFiles {
+    StageThumbnail = "stageThumbnail.png",
+    StagePDF = "stage.pdf",
+    Cover = "cover.jpeg"
+}
+export declare enum EventType {
+    Practice = "practice",
+    Performance = "performance",
+    Other = "other"
+}
+export declare enum EventRepeatPeriod {
+    None = "none",
+    Weekly = "weekly",
+    Biweekly = "biweekly",
+    Monthly = "monthly"
+}
+export declare enum EventStatusByTime {
+    Future = "future",
+    Now = "now",
+    Past = "past"
+}
+export declare enum EventSelectionMode {
+    Open = "open",
+    Closed = "closed"
+}
+export interface EventRepeatType {
+    period: EventRepeatPeriod;
+    untilAt: Timestamp;
+}
+export interface EventViewer {
+    viewedAt: Timestamp;
+    lastViewedAt: Timestamp;
+    count: number;
+}
+export type EventStage = Pick<StageTemplate, 'boardMap' | 'boardSettings'>;
+export interface EventRollcallHistory {
+    changedAt: Timestamp;
+    changedBy: string;
+}
+export interface EventQuestions {
+    id: string;
+    title: string;
+    answers: {
+        id: string;
+        text: string;
+    }[];
+    allowNotes: boolean;
+    multiselect: boolean;
+    order: number;
+}
+export interface EventPlayerBasicData extends PlayerBasicData {
+    isGuest: boolean;
+    note?: string | null;
+    questions?: EventPlayerAnswers[];
+    status: EventPlayerStatus | null;
+    rollcall: EventPlayerStatus | null;
+    selected: boolean | null;
+    /** @deprecated use questions */
+    reason?: EventPlayerReason | null;
+    /** @deprecated use status */
+    interested: true | null;
+    paymentId?: string | null;
+}
+export interface AEventPlayerBasicData extends EventPlayerBasicData {
+    id: string;
+}
+export interface EventThemeBasicData extends ThemeBasicData {
+    order: number;
+    sourceComposition?: SourceComposition | null;
+}
+export interface AEventThemeBasicData extends EventThemeBasicData {
+    id: string;
+}
+export interface EventTinyData {
+    displayName: string | null;
+    datetime: Timestamp;
+    type: EventType;
+    timezone: string;
+}
+export interface EventBasicData extends EventTinyData {
+    locality: string | null;
+    online: boolean;
+    datetimeEnd: Timestamp;
+    responseDeadlineAt: Timestamp;
+    selectionMode: EventSelectionMode | null;
+}
+export interface EventPromoterData extends EventBasicData {
+    readonly promoter: DocumentReference;
+    promoterInfo: GroupBasicData;
+}
+export interface EventData extends EventPromoterData {
+    location: GeoPoint | null;
+    coverURL: string | null;
+    videoURL: string | null;
+    description: string | null;
+    descriptionSlate: Descendant[];
+    playerIds: string[];
+    players: Record<string, EventPlayerBasicData>;
+    repertoryIds: string[];
+    repertory: Record<string, EventThemeBasicData>;
+    relEvents: string[];
+    activeInvitationLink: boolean;
+    shortDynamicLink: string | null;
+    invitationLink: string | null;
+    notifyAt: Timestamp;
+    maxAttendance: number | null;
+    deletedAt: Timestamp | null;
+    deletedBy: string | null;
+    rollCalledAt: Timestamp | null;
+    rollCalledBy: string | null;
+    rollCallReminderAt: Timestamp | null;
+    rollCallHistory: EventRollcallHistory[];
+    templateId: string | null;
+    repeat: EventRepeatType | null;
+    stage: EventStage | null;
+    stageTemplateId: string | null;
+    responseDeadline: {
+        option: EventResponseDeadlineOptions;
+        customAt: Timestamp | null;
+    };
+    selectionModeClosedAt: Timestamp | null;
+    sites: boolean;
+    imagesPath: string[];
+    attachmentsPath: string[];
+    questions: Record<EventPlayerStatus, EventQuestions[]>;
+    reminders: EventReminderOptions[];
+    payout: EventPayoutConfig | null;
+    readonly owner: DocumentReference;
+    readonly createdAt: Timestamp;
+    readonly createdOn: CreatedOn;
+}
+export interface EventPayoutConfig {
+    /**
+     * Event budget. `null` means "to be determined" (an Income payment is still
+     * generated, with `totalAmount: null`). `0` means no budget (no Income
+     * payment is generated). `> 0` is a concrete amount.
+     */
+    grossAmount: number | null;
+    currency: string;
+    importByMember: number | null;
+    rules: EventoPayoutRuleEntry[];
+    expenses: string[];
+    /**
+     * Id of the auto-generated `Income` GroupPayment that materializes the
+     * event budget (`grossAmount`), assigned to the group itself. `null` when
+     * the budget is `0` or for legacy events created before incomes were
+     * tracked.
+     */
+    incomeId?: string | null;
+}

package/models/Evento/types.js

@@ -0,0 +1,55 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.EventSelectionMode = exports.EventStatusByTime = exports.EventRepeatPeriod = exports.EventType = exports.EventFiles = exports.EventResponseDeadlineOptions = exports.EventReminderOptions = exports.EventHistoryAction = void 0;
+var types_1 = require("../supabase/EventHistory/types");
+Object.defineProperty(exports, "EventHistoryAction", { enumerable: true, get: function () { return types_1.EventHistoryAction; } });
+var EventReminderOptions;
+(function (EventReminderOptions) {
+    EventReminderOptions["OneHours"] = "1-hours";
+    EventReminderOptions["ThreeHours"] = "3-hours";
+    EventReminderOptions["TwelveHours"] = "12-hours";
+    EventReminderOptions["OneDay"] = "1-days";
+    EventReminderOptions["ThreeDays"] = "3-days";
+    EventReminderOptions["OneWeek"] = "1-weeks";
+    EventReminderOptions["TwoWeeks"] = "2-weeks";
+    EventReminderOptions["Custom"] = "custom";
+})(EventReminderOptions || (exports.EventReminderOptions = EventReminderOptions = {}));
+var EventResponseDeadlineOptions;
+(function (EventResponseDeadlineOptions) {
+    EventResponseDeadlineOptions["BeforeEvent"] = "BeforeEvent";
+    EventResponseDeadlineOptions["OneHourBefore"] = "OneHourBefore";
+    EventResponseDeadlineOptions["OneDayBefore"] = "OneDayBefore";
+    EventResponseDeadlineOptions["OneWeekBefore"] = "OneWeekBefore";
+    EventResponseDeadlineOptions["Custom"] = "Custom";
+})(EventResponseDeadlineOptions || (exports.EventResponseDeadlineOptions = EventResponseDeadlineOptions = {}));
+var EventFiles;
+(function (EventFiles) {
+    EventFiles["StageThumbnail"] = "stageThumbnail.png";
+    EventFiles["StagePDF"] = "stage.pdf";
+    EventFiles["Cover"] = "cover.jpeg";
+})(EventFiles || (exports.EventFiles = EventFiles = {}));
+var EventType;
+(function (EventType) {
+    EventType["Practice"] = "practice";
+    EventType["Performance"] = "performance";
+    EventType["Other"] = "other";
+})(EventType || (exports.EventType = EventType = {}));
+var EventRepeatPeriod;
+(function (EventRepeatPeriod) {
+    EventRepeatPeriod["None"] = "none";
+    EventRepeatPeriod["Weekly"] = "weekly";
+    EventRepeatPeriod["Biweekly"] = "biweekly";
+    EventRepeatPeriod["Monthly"] = "monthly";
+})(EventRepeatPeriod || (exports.EventRepeatPeriod = EventRepeatPeriod = {}));
+// Se usa en la cabecera de la vista de evento de la app
+var EventStatusByTime;
+(function (EventStatusByTime) {
+    EventStatusByTime["Future"] = "future";
+    EventStatusByTime["Now"] = "now";
+    EventStatusByTime["Past"] = "past";
+})(EventStatusByTime || (exports.EventStatusByTime = EventStatusByTime = {}));
+var EventSelectionMode;
+(function (EventSelectionMode) {
+    EventSelectionMode["Open"] = "open";
+    EventSelectionMode["Closed"] = "closed";
+})(EventSelectionMode || (exports.EventSelectionMode = EventSelectionMode = {}));

package/models/Federation/index.d.ts

@@ -0,0 +1,28 @@
+import { AdminItemStatus } from '../../helpers/types';
+import Model, { DocumentModel } from '../Model';
+import { FederationData } from './types';
+export default class Federation extends Model<FederationData> {
+    constructor(doc: DocumentModel);
+    get displayName(): string;
+    get email(): string | null;
+    get partnershipIds(): string[];
+    get adminIds(): string[];
+    get adminList(): import("../../helpers/types").AdminItem[];
+    get pendingAdmins(): import("../../helpers/types").AdminItem[];
+    get confirmedAdmins(): import("../../helpers/types").AdminItem[];
+    adminListByStatus(status: AdminItemStatus): import("../../helpers/types").AdminItem[];
+    isAdmin(userId: string): boolean;
+    get photoURL(): string;
+    get phone(): string | null;
+    get web(): string | null;
+    get address(): import("../../helpers/types").BasicAddressData | null;
+    get displayAddress(): string;
+    get partnershipConnectedIds(): string[];
+    get createdAt(): FirebaseFirestore.Timestamp;
+    get createdBy(): FirebaseFirestore.DocumentReference<FirebaseFirestore.DocumentData, FirebaseFirestore.DocumentData>;
+    get deletedAt(): FirebaseFirestore.Timestamp | null;
+    get deletedBy(): string | null;
+    get isActive(): boolean;
+    getGlissandooAdminUrl(adminHost: string): string;
+    get besm(): boolean;
+}

package/models/Federation/index.js

@@ -0,0 +1,85 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const collections_1 = require("../../helpers/collections");
+const externalUrls_1 = require("../../helpers/externalUrls");
+const types_1 = require("../../helpers/types");
+const Model_1 = __importDefault(require("../Model"));
+class Federation extends Model_1.default {
+    constructor(doc) {
+        super(doc);
+    }
+    get displayName() {
+        return this.data.displayName;
+    }
+    get email() {
+        return this.data.email || null;
+    }
+    get partnershipIds() {
+        return this.data.partnershipIds || [];
+    }
+    get adminIds() {
+        return this.data.adminIds || [];
+    }
+    get adminList() {
+        return this.data.adminList || [];
+    }
+    get pendingAdmins() {
+        return this.adminList.filter((item) => item.status === types_1.AdminItemStatus.Pending);
+    }
+    get confirmedAdmins() {
+        return this.adminList.filter((item) => item.status === types_1.AdminItemStatus.Accepted);
+    }
+    adminListByStatus(status) {
+        if (status === types_1.AdminItemStatus.Pending)
+            return this.pendingAdmins;
+        if (status === types_1.AdminItemStatus.Accepted)
+            return this.confirmedAdmins;
+        return this.adminList.filter((item) => item.status === status);
+    }
+    isAdmin(userId) {
+        return this.adminIds.includes(userId);
+    }
+    get photoURL() {
+        return this.data.photoURL;
+    }
+    get phone() {
+        return this.data.phone || null;
+    }
+    get web() {
+        return this.data.web || null;
+    }
+    get address() {
+        return this.data.address || null;
+    }
+    get displayAddress() {
+        return (0, types_1.displayBasicAddress)(this.address || {});
+    }
+    get partnershipConnectedIds() {
+        return this.data.partnershipConnectedIds || [];
+    }
+    get createdAt() {
+        return this.data.createdAt;
+    }
+    get createdBy() {
+        return this.data.createdBy;
+    }
+    get deletedAt() {
+        return this.data.deletedAt || null;
+    }
+    get deletedBy() {
+        return this.data.deletedBy || null;
+    }
+    get isActive() {
+        return !this.deletedAt && this.exists;
+    }
+    getGlissandooAdminUrl(adminHost) {
+        return (0, externalUrls_1.buildAdminEntityUrl)(adminHost, collections_1.CollectionNames.Federation, this.id);
+    }
+    get besm() {
+        return this.data.besm || false;
+    }
+}
+exports.default = Federation;

package/models/Group/Analytics/types.js

@@ -0,0 +1,13 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SatisfactionIndexElements = void 0;
+var SatisfactionIndexElements;
+(function (SatisfactionIndexElements) {
+    SatisfactionIndexElements["ADMIN_COUNT"] = "adminCount";
+    SatisfactionIndexElements["MEMBERS_COUNT"] = "memberCount";
+    SatisfactionIndexElements["EVENTS_PER_WEEK"] = "eventsPerWeek";
+    SatisfactionIndexElements["EVENTS_ROLLCALLED_RATIO"] = "eventsRollcalledRatio";
+    SatisfactionIndexElements["EVENTS_ATTENDANCE_PREVISION_RATIO"] = "eventsAttendancePrevisionRatio";
+    SatisfactionIndexElements["EVENTS_ANSWER_RATIO"] = "eventsAnswerRatio";
+    SatisfactionIndexElements["EVENTS_WITH_REPERTORY_RATIO"] = "eventsWithRepertoryRatio";
+})(SatisfactionIndexElements || (exports.SatisfactionIndexElements = SatisfactionIndexElements = {}));

package/models/Group/Payment/supabase.js

@@ -0,0 +1,46 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.GROUP_PAYMENT_HISTORY_TABLE = exports.GROUP_PAYMENT_TABLE = void 0;
+exports.rowToGroupPaymentData = rowToGroupPaymentData;
+exports.historyRowToItem = historyRowToItem;
+exports.GROUP_PAYMENT_TABLE = 'group_payment';
+exports.GROUP_PAYMENT_HISTORY_TABLE = 'group_payment_history';
+/**
+ * Convert a raw `group_payment` DB row into the canonical `GroupPaymentData`
+ * shape consumed by the `GroupPayment` model. `history` defaults to an empty
+ * array; hydrate it from the history table when needed.
+ */
+function rowToGroupPaymentData(row, history = []) {
+    return {
+        id: row.id,
+        groupId: row.groupId,
+        type: row.type,
+        eventId: row.eventId,
+        playerId: row.playerId,
+        concept: row.concept,
+        assignedTo: row.assignedTo,
+        totalAmount: row.totalAmount === null ? null : Number(row.totalAmount),
+        baseAmount: row.baseAmount === null ? null : Number(row.baseAmount),
+        appliedRules: row.appliedRules ?? [],
+        currency: row.currency,
+        status: row.status,
+        history,
+        paymentMethod: row.paymentMethod ?? null,
+        paidAt: row.paidAt,
+        paidBy: row.paidBy,
+        note: row.note,
+        createdAt: row.createdAt,
+        createdBy: row.createdBy,
+        editedAt: row.updatedAt,
+        editedBy: row.editedBy,
+    };
+}
+function historyRowToItem(row) {
+    return {
+        action: row.action,
+        oldValue: row.old_value,
+        newValue: row.new_value,
+        changedAt: row.changed_at,
+        changedBy: row.changed_by,
+    };
+}

package/models/Group/Payment/types.js

@@ -0,0 +1,38 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.EventPaymentStatus = exports.GroupPaymentHistoryAction = exports.GroupPaymentMethod = exports.GroupPaymentStatus = exports.GroupPaymentType = void 0;
+var GroupPaymentType;
+(function (GroupPaymentType) {
+    GroupPaymentType["Income"] = "income";
+    GroupPaymentType["Expense"] = "expense";
+})(GroupPaymentType || (exports.GroupPaymentType = GroupPaymentType = {}));
+var GroupPaymentStatus;
+(function (GroupPaymentStatus) {
+    GroupPaymentStatus["Pending"] = "pending";
+    GroupPaymentStatus["Paid"] = "paid";
+    GroupPaymentStatus["Cancelled"] = "cancelled";
+})(GroupPaymentStatus || (exports.GroupPaymentStatus = GroupPaymentStatus = {}));
+var GroupPaymentMethod;
+(function (GroupPaymentMethod) {
+    GroupPaymentMethod["Cash"] = "cash";
+    GroupPaymentMethod["Transfer"] = "transfer";
+})(GroupPaymentMethod || (exports.GroupPaymentMethod = GroupPaymentMethod = {}));
+var GroupPaymentHistoryAction;
+(function (GroupPaymentHistoryAction) {
+    GroupPaymentHistoryAction["Status"] = "status";
+    GroupPaymentHistoryAction["Amount"] = "amount";
+    GroupPaymentHistoryAction["Concept"] = "concept";
+    GroupPaymentHistoryAction["Method"] = "method";
+})(GroupPaymentHistoryAction || (exports.GroupPaymentHistoryAction = GroupPaymentHistoryAction = {}));
+/**
+ * Estados visibles en la lista unificada de pagos de un evento.
+ * Reutiliza los valores de `GroupPaymentStatus` y añade el sintético
+ * `forecast` para las filas de previsión (no persistidas en Postgres).
+ */
+var EventPaymentStatus;
+(function (EventPaymentStatus) {
+    EventPaymentStatus["Pending"] = "pending";
+    EventPaymentStatus["Paid"] = "paid";
+    EventPaymentStatus["Cancelled"] = "cancelled";
+    EventPaymentStatus["Forecast"] = "forecast";
+})(EventPaymentStatus || (exports.EventPaymentStatus = EventPaymentStatus = {}));

package/models/Group/Player/types.js

@@ -0,0 +1,9 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.GroupPlayerRole = void 0;
+var GroupPlayerRole;
+(function (GroupPlayerRole) {
+    GroupPlayerRole["Admin"] = "admin";
+    GroupPlayerRole["Member"] = "member";
+    GroupPlayerRole["Guest"] = "guest";
+})(GroupPlayerRole || (exports.GroupPlayerRole = GroupPlayerRole = {}));

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

@@ -0,0 +1,12 @@
+import { InstrumentId } from '../../../../../helpers/instruments';
+import { LanguagesTypes } from '../../../../../lang';
+import { InstrumentsRecord } from '../../../../../helpers/instruments';
+import { FileSectionId } from './types';
+export default class GroupRepertoryFileSection {
+    id: FileSectionId;
+    groupInstruments: InstrumentsRecord;
+    private lang;
+    constructor(id: FileSectionId, instruments: InstrumentsRecord, lang?: LanguagesTypes);
+    get name(): string;
+    getOrder(instrumentsIds: InstrumentId[]): number;
+}

package/models/Group/Repertory/File/Section/index.js

@@ -0,0 +1,26 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const orders_1 = require("../../../../../helpers/fileSections/orders");
+const lang_1 = require("../../../../../lang");
+const fromRecord_1 = __importDefault(require("../../../../Instrument/fromRecord"));
+const types_1 = require("./types");
+class GroupRepertoryFileSection {
+    constructor(id, instruments, lang = lang_1.defaultLocale) {
+        this.id = id;
+        this.groupInstruments = instruments;
+        this.lang = lang;
+    }
+    get name() {
+        return ((this.id === types_1.FileSectionIdReserved.All
+            ? (0, lang_1.getTranslation)(`sections.all`, this.lang)
+            : new fromRecord_1.default(this.id, this.lang, this.groupInstruments).name) ||
+            this.id);
+    }
+    getOrder(instrumentsIds) {
+        return (0, orders_1.getFileSectionsOrder)(instrumentsIds).indexOf(this.id) + 1 || Infinity;
+    }
+}
+exports.default = GroupRepertoryFileSection;

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

@@ -0,0 +1,12 @@
+import { InstrumentId } from '../../../../../helpers/instruments';
+export declare enum FileSectionIdReserved {
+    All = "all"
+}
+export type FileSectionId = InstrumentId | FileSectionIdReserved;
+export type SectionRecord<T extends object = object> = Partial<Record<FileSectionId, T>>;
+export type SectionRecordByTags<T extends object = object> = SectionRecord<{
+    tag: string;
+} & T>;
+export type SectionArrayRecordByTags<T extends object = object> = SectionRecord<({
+    tag: string;
+} & T)[]>;

package/models/Group/Repertory/File/Section/types.js

@@ -0,0 +1,7 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FileSectionIdReserved = void 0;
+var FileSectionIdReserved;
+(function (FileSectionIdReserved) {
+    FileSectionIdReserved["All"] = "all";
+})(FileSectionIdReserved || (exports.FileSectionIdReserved = FileSectionIdReserved = {}));

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

@@ -0,0 +1,31 @@
+import { FileSectionId } from '../File/Section/types';
+import { GroupRepertoireFile } from '../types';
+import { RepertoireFileId } from '../../../Repertory/types';
+import { FileSectionItem } from './types';
+export default class ThemeFile {
+    id: RepertoireFileId;
+    private data;
+    constructor(id: string, data: GroupRepertoireFile);
+    get path(): string;
+    get filetype(): string;
+    get isAudio(): boolean;
+    get isPdf(): boolean;
+    get uploadedAt(): number;
+    get pageCount(): number | null;
+    get isEncrypted(): boolean;
+    get isFileByPages(): boolean;
+    get sections(): Partial<Record<FileSectionId, import("../types").GroupRepertoireFileSections>>;
+    get sectionIds(): FileSectionId[];
+    get sectionsList(): {
+        sectionId: FileSectionId;
+        tagsByFile: string[];
+        tagsByPages: FileSectionItem["tagsByPages"];
+    }[];
+    get sectionListByTags(): {
+        sectionId: FileSectionId;
+        tag: string;
+        pages: number[] | null;
+    }[];
+    get identifyAt(): number | null;
+    protected isNoTag(tags?: string[]): boolean;
+}

package/models/Group/Repertory/File/index.js

@@ -0,0 +1,81 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const lodash_1 = require("lodash");
+const objects_1 = require("../../../../helpers/objects");
+const types_1 = require("../../../../helpers/types");
+class ThemeFile {
+    constructor(id, data) {
+        this.id = id;
+        this.data = data;
+    }
+    get path() {
+        return this.data.path;
+    }
+    get filetype() {
+        return this.data.filetype;
+    }
+    get isAudio() {
+        return this.filetype.includes('audio');
+    }
+    get isPdf() {
+        return this.filetype === 'application/pdf';
+    }
+    get uploadedAt() {
+        return this.data.uploadedAt;
+    }
+    get pageCount() {
+        return this.data.pageCount || null;
+    }
+    get isEncrypted() {
+        return this.data.isEncrypted;
+    }
+    get isFileByPages() {
+        return this.isPdf && !this.isEncrypted;
+    }
+    get sections() {
+        return this.data.sections || {};
+    }
+    get sectionIds() {
+        return Object.keys(this.sections);
+    }
+    get sectionsList() {
+        const list = (0, objects_1.mapToArray)(this.sections);
+        return list.map((section) => {
+            const sectionId = section.id;
+            if (this.isFileByPages) {
+                const items = Object.entries(section.pages || {}).flatMap(([page, { tags }]) => this.isNoTag(tags)
+                    ? { page: Number(page), tag: types_1.RepertoireTagReserved.NoTag }
+                    : tags.map((tag) => ({ page: Number(page), tag })));
+                const tagsByPages = (0, lodash_1.mapValues)((0, lodash_1.groupBy)(items, 'tag'), (v) => v.map((t) => t.page));
+                return {
+                    sectionId,
+                    tagsByFile: [],
+                    tagsByPages,
+                };
+            }
+            return {
+                sectionId,
+                tagsByFile: this.isNoTag(section.tags) ? [types_1.RepertoireTagReserved.NoTag] : section.tags || [],
+                tagsByPages: {},
+            };
+        });
+    }
+    get sectionListByTags() {
+        const list = this.sectionsList;
+        return list.flatMap(({ tagsByFile, tagsByPages, sectionId }) => {
+            const tags = this.isFileByPages ? Object.keys(tagsByPages) : tagsByFile;
+            return tags.map((tag) => ({
+                sectionId,
+                tag,
+                pages: this.isFileByPages ? tagsByPages[tag] : null,
+            }));
+        });
+    }
+    get identifyAt() {
+        return this.data.identifyAt || null;
+    }
+    isNoTag(tags = []) {
+        return tags.length === 0 || tags.includes(types_1.RepertoireTagReserved.NoTag);
+    }
+}
+exports.default = ThemeFile;

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

@@ -0,0 +1,22 @@
+import path from 'path';
+import Group from '../../';
+import { InstrumentsRecord } from '../../../../helpers/instruments';
+import { LanguagesTypes } from '../../../../lang';
+import FileSection from '../File/Section';
+import { FileSectionId } from '../File/Section/types';
+import { GroupRepertoireFilePathItem } from '../types';
+export default class ThemeFilePath {
+    sectionId: FileSectionId;
+    protected data: GroupRepertoireFilePathItem;
+    protected lang: LanguagesTypes;
+    protected instruments: InstrumentsRecord;
+    constructor(sectionId: FileSectionId, data: GroupRepertoireFilePathItem, instruments: InstrumentsRecord, lang?: LanguagesTypes);
+    get path(): string;
+    get parsedPath(): path.ParsedPath;
+    get ext(): string;
+    get isPdf(): boolean;
+    get isAudio(): boolean;
+    get section(): FileSection;
+    get tag(): string;
+    getTagName(group: Group): string | null;
+}