@glissandoo/lib 1.0.0

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

@@ -0,0 +1,15 @@
+import { DocumentSnapshot } from '@google-cloud/firestore';
+import { LanguagesTypes } from '../../../lang';
+import EventoBasic from '../../Evento/basic';
+import { GroupEventData } from './types';
+export default class GroupEvent extends EventoBasic<GroupEventData> {
+    constructor(doc: DocumentSnapshot, lang?: LanguagesTypes);
+    get rollCalledAt(): FirebaseFirestore.Timestamp | null;
+    get playersCount(): number;
+    get playersConfirmedCount(): number;
+    get playersDeclinedCount(): number;
+    get playersConfirmedRollCallCount(): number;
+    get playersDecliendRollCallCount(): number;
+    get repertoryCount(): number;
+    get isOutDate(): boolean;
+}

package/models/Group/Event/index.js

@@ -0,0 +1,38 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const isPast_1 = __importDefault(require("date-fns/isPast"));
+const lang_1 = require("../../../lang");
+const basic_1 = __importDefault(require("../../Evento/basic"));
+class GroupEvent extends basic_1.default {
+    constructor(doc, lang = lang_1.defaultLocale) {
+        super(doc, lang);
+    }
+    get rollCalledAt() {
+        return this.data.rollCalledAt || null;
+    }
+    get playersCount() {
+        return this.data.players_count || 0;
+    }
+    get playersConfirmedCount() {
+        return this.data.players_confirmed_count || 0;
+    }
+    get playersDeclinedCount() {
+        return this.data.players_declined_count || 0;
+    }
+    get playersConfirmedRollCallCount() {
+        return this.data.players_confirmed_rollcall_count || 0;
+    }
+    get playersDecliendRollCallCount() {
+        return this.data.players_declined_rollcall_count || 0;
+    }
+    get repertoryCount() {
+        return this.data.repertory_count || 0;
+    }
+    get isOutDate() {
+        return isPast_1.default(this.datetime.toDate());
+    }
+}
+exports.default = GroupEvent;

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

@@ -0,0 +1,11 @@
+import { Timestamp } from '@google-cloud/firestore';
+import { EventBasicData } from '../../Evento/types';
+export interface GroupEventData extends EventBasicData {
+    players_count: number;
+    players_confirmed_count: number;
+    players_declined_count: number;
+    rollCalledAt: Timestamp | null;
+    players_confirmed_rollcall_count: number;
+    players_declined_rollcall_count: number;
+    repertory_count: number;
+}

package/models/Group/Event/types.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/models/Group/Player/Event/index.d.ts

@@ -0,0 +1,17 @@
+import { DocumentSnapshot } from '@google-cloud/firestore';
+import { LanguagesTypes } from '../../../../lang';
+import EventoBasic from '../../../Evento/basic';
+import { EventPlayerStatus } from '../../../Evento/Player/types';
+import { GroupPlayerEventData } from './types';
+export default class GroupPlayerEvent extends EventoBasic<GroupPlayerEventData> {
+    constructor(doc: DocumentSnapshot, lang?: LanguagesTypes);
+    get playerId(): string;
+    get groupId(): string;
+    get status(): EventPlayerStatus | null;
+    get isConfirmed(): boolean;
+    get isDeclined(): boolean;
+    get rollcall(): EventPlayerStatus | null;
+    get isRollcallConfirmed(): boolean;
+    get isRollcallDeclined(): boolean;
+    get joinedAt(): FirebaseFirestore.Timestamp;
+}

package/models/Group/Player/Event/index.js

@@ -0,0 +1,42 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const get_1 = __importDefault(require("lodash/get"));
+const lang_1 = require("../../../../lang");
+const basic_1 = __importDefault(require("../../../Evento/basic"));
+const types_1 = require("../../../Evento/Player/types");
+class GroupPlayerEvent extends basic_1.default {
+    constructor(doc, lang = lang_1.defaultLocale) {
+        super(doc, lang);
+    }
+    get playerId() {
+        return get_1.default(this.ref, 'parent.parent.id');
+    }
+    get groupId() {
+        return get_1.default(this.ref, 'parent.parent.parent.parent.id');
+    }
+    get status() {
+        return this.data.status || null;
+    }
+    get isConfirmed() {
+        return this.status === types_1.EventPlayerStatus.Confirmed;
+    }
+    get isDeclined() {
+        return this.status === types_1.EventPlayerStatus.Declined;
+    }
+    get rollcall() {
+        return this.data.rollcall || null;
+    }
+    get isRollcallConfirmed() {
+        return this.rollcall === types_1.EventPlayerStatus.Confirmed;
+    }
+    get isRollcallDeclined() {
+        return this.rollcall === types_1.EventPlayerStatus.Declined;
+    }
+    get joinedAt() {
+        return this.data.joinedAt;
+    }
+}
+exports.default = GroupPlayerEvent;

package/models/Group/Player/Event/types.d.ts

@@ -0,0 +1,8 @@
+import { Timestamp } from '@google-cloud/firestore';
+import { EventPlayerStatus } from '../../../Evento/Player/types';
+import { EventBasicData } from '../../../Evento/types';
+export interface GroupPlayerEventData extends EventBasicData {
+    status: EventPlayerStatus | null;
+    rollcall: EventPlayerStatus | null;
+    joinedAt: Timestamp;
+}

package/models/Group/Player/Event/types.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/models/Group/Player/Log/index.d.ts

@@ -0,0 +1,12 @@
+import { DocumentSnapshot } from '@google-cloud/firestore';
+import Model from '../../../Model';
+import { LogData } from './types';
+export default class GroupPlayerLog extends Model<LogData> {
+    constructor(doc: DocumentSnapshot);
+    get type(): import("./types").LogTypes;
+    get values(): {
+        [key: string]: string;
+    };
+    get createdAt(): FirebaseFirestore.Timestamp;
+    get action(): import("./types").LogActions;
+}

package/models/Group/Player/Log/index.js

@@ -0,0 +1,24 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const Model_1 = __importDefault(require("../../../Model"));
+class GroupPlayerLog extends Model_1.default {
+    constructor(doc) {
+        super(doc);
+    }
+    get type() {
+        return this.data.type;
+    }
+    get values() {
+        return this.data.values || {};
+    }
+    get createdAt() {
+        return this.data.createdAt;
+    }
+    get action() {
+        return this.data.action;
+    }
+}
+exports.default = GroupPlayerLog;

package/models/Group/Player/Log/types.d.ts

@@ -0,0 +1,11 @@
+import { Timestamp } from '@google-cloud/firestore';
+export declare type LogTypes = 'event' | 'group' | 'user';
+export declare type LogActions = 'create' | 'leave' | 'add' | 'remove' | 'delete' | 'invite' | 'confirm' | 'decline' | 'undo' | 'addAdmin' | 'removeAdmin';
+export interface LogData {
+    type: LogTypes;
+    action: LogActions;
+    values: {
+        [key: string]: string;
+    };
+    createdAt: Timestamp;
+}

package/models/Group/Player/Log/types.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

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

@@ -0,0 +1,55 @@
+import * as firestore from '@google-cloud/firestore';
+import { BadgesTypes } from '../../../helpers/badges';
+import { LanguagesTypes } from '../../../lang';
+import { EventType } from '../../Evento/types';
+import PlayerBasic from '../../Player/basic';
+import { GroupPlayerData, GroupPlayerRole } from './types';
+export default class GroupPlayer extends PlayerBasic<GroupPlayerData> {
+    constructor(doc: firestore.DocumentSnapshot, lang?: LanguagesTypes);
+    get groupId(): string;
+    get instruments(): import("../../../helpers/instruments").InstrumentId[];
+    get role(): GroupPlayerRole;
+    get isAdmin(): boolean;
+    get joinedAt(): firestore.Timestamp;
+    get leavedAt(): firestore.Timestamp | null;
+    get isActive(): boolean;
+    get eventsInvited(): number;
+    get eventsAnswered(): number;
+    get eventsNoAnswered(): number;
+    get eventsConfirmed(): number;
+    get eventsDeclined(): number;
+    get performanceInvited(): number;
+    get performanceAnswered(): number;
+    get performanceNoAnswered(): number;
+    get performanceConfirmed(): number;
+    get performanceDeclined(): number;
+    get practiceInvited(): number;
+    get practiceAnswered(): number;
+    get practiceConfirmed(): number;
+    get practiceDeclined(): number;
+    get practiceRollCallConfirmedStrike(): number;
+    get eventsRollCall(): number;
+    get eventsRollCallConfirmed(): number;
+    get eventsRollCallDeclined(): number;
+    get performanceRollCall(): number;
+    get performanceRollCallConfirmed(): number;
+    get performanceRollCallDeclined(): number;
+    get practiceRollCall(): number;
+    get practiceRollCallConfirmed(): number;
+    get practiceRollCallDeclined(): number;
+    countStatus(type: EventType, action: 'invited' | 'answered' | 'confirmed' | 'declined'): number;
+    countRollcall(type: EventType, action?: 'confirmed' | 'declined'): number;
+    getBadgeLevel(field: BadgesTypes, level?: number): firestore.Timestamp | null;
+    getCurrentBadgeLevel(field: BadgesTypes): number | null;
+    getValueByBadgeType(field: BadgesTypes): number;
+    get badgeAccPractices(): import("./types").BadgeLevels | null;
+    get badgeAccPerformances(): import("./types").BadgeLevels | null;
+    get badgeStrikePractices(): import("./types").BadgeLevels | null;
+    get badgeAnswerEvents(): import("./types").BadgeLevels | null;
+    get badges(): {
+        id: BadgesTypes;
+        level: number | null;
+        obtainAt: Date | null;
+        currentValue: number;
+    }[];
+}

package/models/Group/Player/index.js

@@ -0,0 +1,221 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const lodash_1 = require("lodash");
+const badges_1 = require("../../../helpers/badges");
+const lang_1 = require("../../../lang");
+const basic_1 = __importDefault(require("../../Player/basic"));
+const types_1 = require("./types");
+class GroupPlayer extends basic_1.default {
+    constructor(doc, lang = lang_1.defaultLocale) {
+        super(doc, lang);
+    }
+    get groupId() {
+        return lodash_1.get(this.ref, 'parent.parent.id');
+    }
+    get instruments() {
+        return this.data.instruments || [];
+    }
+    get role() {
+        return this.data.role;
+    }
+    get isAdmin() {
+        return this.role === types_1.GroupPlayerRole.Admin;
+    }
+    get joinedAt() {
+        return this.data.joinedAt;
+    }
+    get leavedAt() {
+        return this.data.leavedAt || null;
+    }
+    get isActive() {
+        return this.exists && lodash_1.isNull(this.leavedAt);
+    }
+    get eventsInvited() {
+        return this.data.events_invited_count || 0;
+    }
+    get eventsAnswered() {
+        return this.data.events_answered_count || 0;
+    }
+    get eventsNoAnswered() {
+        return this.eventsInvited - this.eventsAnswered;
+    }
+    get eventsConfirmed() {
+        return this.data.events_confirmed_count || 0;
+    }
+    get eventsDeclined() {
+        return this.data.events_declined_count || 0;
+    }
+    get performanceInvited() {
+        return this.data.performance_invited_count || 0;
+    }
+    get performanceAnswered() {
+        return this.data.performance_answered_count || 0;
+    }
+    get performanceNoAnswered() {
+        return this.performanceInvited - this.performanceAnswered;
+    }
+    get performanceConfirmed() {
+        return this.data.performance_confirmed_count || 0;
+    }
+    get performanceDeclined() {
+        return this.data.performance_declined_count || 0;
+    }
+    get practiceInvited() {
+        return this.data.practice_invited_count || 0;
+    }
+    get practiceAnswered() {
+        return this.data.practice_answered_count || 0;
+    }
+    get practiceConfirmed() {
+        return this.data.practice_confirmed_count || 0;
+    }
+    get practiceDeclined() {
+        return this.data.practice_declined_count || 0;
+    }
+    get practiceRollCallConfirmedStrike() {
+        return this.data.practice_rollcall_confirmed_strike || 0;
+    }
+    get eventsRollCall() {
+        return this.data.events_rollcall_count || 0;
+    }
+    get eventsRollCallConfirmed() {
+        return this.data.events_rollcall_confirmed_count || 0;
+    }
+    get eventsRollCallDeclined() {
+        return this.data.events_rollcall_declined_count || 0;
+    }
+    get performanceRollCall() {
+        return this.data.performance_rollcall_count || 0;
+    }
+    get performanceRollCallConfirmed() {
+        return this.data.performance_rollcall_confirmed_count || 0;
+    }
+    get performanceRollCallDeclined() {
+        return this.data.performance_rollcall_declined_count || 0;
+    }
+    get practiceRollCall() {
+        return this.data.practice_rollcall_count || 0;
+    }
+    get practiceRollCallConfirmed() {
+        return this.data.practice_rollcall_confirmed_count || 0;
+    }
+    get practiceRollCallDeclined() {
+        return this.data.practice_rollcall_declined_count || 0;
+    }
+    countStatus(type, action) {
+        const field = [type, action, 'count'].join('_');
+        return lodash_1.get(this.data, field) || 0;
+    }
+    countRollcall(type, action) {
+        const field = [type, 'rollcall', action, 'count'].join('_');
+        return lodash_1.get(this.data, field) || 0;
+    }
+    // public rollCallData(type?: EventType) {
+    // 	if (type) {
+    // 		const total = (this.get(`${type}_rollcall_count`) as number) || 0;
+    // 		const confirmed = (this.get(`${type}_rollcall_confirmed_count`) as number) || 0;
+    // 		const declined = (this.get(`${type}_rollcall_declined_count`) as number) || 0;
+    // 		return {
+    // 			total,
+    // 			confirmed,
+    // 			declined,
+    // 			nostatus: total - confirmed - declined,
+    // 		};
+    // 	}
+    // 	return {
+    // 		total: this.eventsRollCall,
+    // 		confirmed: this.eventsRollCallConfirmed,
+    // 		declined: this.eventsRollCallDeclined,
+    // 		nostatus:
+    // 			this.eventsRollCall - this.eventsRollCallConfirmed - this.eventsRollCallDeclined,
+    // 	};
+    // }
+    // public percPassEventsAnswered() {
+    // 	if (this.eventsPassed === 0) {
+    // 		return 0;
+    // 	}
+    // 	return Math.floor((this.eventsPassedAnswered * 100) / this.eventsPassed);
+    // }
+    // public answeredFreq() {
+    // 	const perc = this.percPassEventsAnswered();
+    // 	if (perc >= 0 && perc < 10) {
+    // 		return 'never';
+    // 	} else if (perc >= 10 && perc < 40) {
+    // 		return 'sometimes';
+    // 	} else if (perc >= 40 && perc < 70) {
+    // 		return 'often';
+    // 	} else if (perc >= 70 && perc < 90) {
+    // 		return 'usually';
+    // 	} else if (perc >= 90 && perc <= 100) {
+    // 		return 'always';
+    // 	}
+    // 	return null;
+    // }
+    getBadgeLevel(field, level) {
+        const _level = level || this.getCurrentBadgeLevel(field);
+        const badge = this[field];
+        if (!badge || !_level) {
+            return null;
+        }
+        const nameLevel = `level${_level}`;
+        if (!badge || !badge[nameLevel])
+            return null;
+        return badge[nameLevel];
+    }
+    getCurrentBadgeLevel(field) {
+        const levels = badges_1.getLevelsCountBadge(field);
+        if (!levels)
+            return null;
+        let level = levels.length;
+        while (level > 0) {
+            if (this.getBadgeLevel(field, level) !== null) {
+                return level;
+            }
+            level = level - 1;
+        }
+        return null;
+    }
+    getValueByBadgeType(field) {
+        switch (field) {
+            case badges_1.BadgesTypes.AccPractices:
+                return this.practiceRollCallConfirmed;
+            case badges_1.BadgesTypes.AccPerformances:
+                return this.performanceRollCallConfirmed;
+            case badges_1.BadgesTypes.AnswerEvents:
+                return this.eventsAnswered;
+            case badges_1.BadgesTypes.StrikePractices:
+                return this.practiceRollCallConfirmedStrike;
+            default:
+                return 0;
+        }
+    }
+    get badgeAccPractices() {
+        return this.data.badgeAccPractices || null;
+    }
+    get badgeAccPerformances() {
+        return this.data.badgeAccPerformances || null;
+    }
+    get badgeStrikePractices() {
+        return this.data.badgeStrikePractices || null;
+    }
+    get badgeAnswerEvents() {
+        return this.data.badgeAnswerEvents || null;
+    }
+    get badges() {
+        const badges = [];
+        for (const badge of Object.values(badges_1.BadgesTypes)) {
+            const obtainAt = this.getBadgeLevel(badge);
+            badges.push({
+                id: badge,
+                level: this.getCurrentBadgeLevel(badge),
+                obtainAt: obtainAt ? obtainAt.toDate() : null,
+                currentValue: this.getValueByBadgeType(badge),
+            });
+        }
+        return badges;
+    }
+}
+exports.default = GroupPlayer;

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

@@ -0,0 +1,43 @@
+import { Timestamp } from '@google-cloud/firestore';
+import { InstrumentId } from '../../../helpers/instruments';
+import { PlayerBasicData } from '../../Player/types';
+export declare enum GroupPlayerRole {
+    Admin = "admin",
+    Member = "member",
+    Guest = "guest"
+}
+export declare type BadgeLevels = {
+    [level: string]: Timestamp;
+};
+export interface GroupPlayerData extends PlayerBasicData {
+    instruments: InstrumentId[];
+    role: GroupPlayerRole;
+    joinedAt: Timestamp;
+    leavedAt: Timestamp | null;
+    badgeAccPractices?: BadgeLevels;
+    badgeAccPerformances?: BadgeLevels;
+    badgeStrikePractices?: BadgeLevels;
+    badgeAnswerEvents?: BadgeLevels;
+    events_invited_count?: number;
+    events_answered_count?: number;
+    events_confirmed_count?: number;
+    events_declined_count?: number;
+    events_rollcall_count?: number;
+    events_rollcall_confirmed_count?: number;
+    events_rollcall_declined_count?: number;
+    performance_invited_count?: number;
+    performance_answered_count?: number;
+    performance_confirmed_count?: number;
+    performance_declined_count?: number;
+    performance_rollcall_count?: number;
+    performance_rollcall_confirmed_count?: number;
+    performance_rollcall_declined_count?: number;
+    practice_invited_count?: number;
+    practice_answered_count?: number;
+    practice_confirmed_count?: number;
+    practice_declined_count?: number;
+    practice_rollcall_count?: number;
+    practice_rollcall_confirmed_count?: number;
+    practice_rollcall_declined_count?: number;
+    practice_rollcall_confirmed_strike?: number;
+}

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 || (exports.GroupPlayerRole = {}));

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

@@ -0,0 +1,67 @@
+import * as firestore from '@google-cloud/firestore';
+import { InstrumentId } from '../../../helpers/instruments';
+import Theme from '../../Repertory/basic';
+import { AGroupRepertoryClaim, GroupRepertoryData } from './types';
+export default class GroupRepertory extends Theme<GroupRepertoryData> {
+    constructor(doc: firestore.DocumentSnapshot);
+    get groupId(): string;
+    get tagsAlgolia(): import("./types").GroupRepertoryTagAlgoliaData[];
+    get instruments(): {
+        filesPath: string[] | undefined;
+        id: InstrumentId;
+        pages: number[];
+    }[];
+    get mainFilePath(): string | null;
+    get events(): string[];
+    get eventsTL(): Record<string, import("../../Evento/types").EventTinyData>;
+    get eventsList(): (import("../../Evento/types").EventTinyData & {
+        id: string;
+    })[];
+    /** @deprecated use getNextEvents */
+    get nextEvents(): (import("../../Evento/types").EventTinyData & {
+        id: string;
+    })[];
+    /** @deprecated use getNextEvent */
+    get nextEvent(): (import("../../Evento/types").EventTinyData & {
+        id: string;
+    }) | null;
+    get scoresByInstruments(): boolean;
+    get editedAt(): firestore.Timestamp | null;
+    get createdAt(): firestore.Timestamp;
+    get audios(): string[];
+    get identifyAt(): firestore.Timestamp | null;
+    get isIdentify(): boolean;
+    get isActive(): boolean;
+    get thumbnailURL(): string | null;
+    get ownerId(): string;
+    /** @deprecated  */
+    get viewers(): Record<string, import("./types").GroupRepertoryViewer>;
+    /** @deprecated  */
+    get listViewers(): (import("./types").GroupRepertoryViewer & {
+        id: string;
+    })[];
+    /** @deprecated */
+    get totalViews(): number;
+    get claims(): Record<string, Record<string, import("./types").GroupRepertoryClaimType>>;
+    get claimsList(): AGroupRepertoryClaim[];
+    claimsByInstrument(instrumentId: string): Record<string, import("./types").GroupRepertoryClaimType>;
+    getPlayersByInstrumentClaimed(instrumentId: string, onlyNoNotified?: boolean): string[];
+    isInstrumentClaimed(instrumentId: string): boolean;
+    isInstrumentClaimedByPlayer(instrumentId: InstrumentId, userId: string): boolean;
+    /** @deprecated */
+    getViewer(userId: string): import("./types").GroupRepertoryViewer | null;
+    getInstrument(id: string): {
+        filesPath: string[] | undefined;
+        id: InstrumentId;
+        pages: number[];
+    } | undefined;
+    getNextEvents(endDay?: boolean): (import("../../Evento/types").EventTinyData & {
+        id: string;
+    })[];
+    getNextEvent(endDay?: boolean): (import("../../Evento/types").EventTinyData & {
+        id: string;
+    }) | null;
+    getEventsByOrder(order?: 'asc' | 'desc'): (import("../../Evento/types").EventTinyData & {
+        id: string;
+    })[];
+}