@glissandoo/lib 1.0.0

package/models/Evento/index.d.ts

@@ -0,0 +1,66 @@
+import { DocumentReference, DocumentSnapshot } from '@google-cloud/firestore';
+import { LanguagesTypes } from '../../lang';
+import EventoPromoter from './promoter';
+import { EventData, EventPlayerBasicData, EventStatusByTime } from './types';
+export default class Evento extends EventoPromoter<EventData> {
+    constructor(doc: DocumentSnapshot, lang?: LanguagesTypes);
+    get maxAttendance(): number | null;
+    get isCapacityCompleted(): boolean;
+    get location(): FirebaseFirestore.GeoPoint | null;
+    get videoURL(): string | null;
+    get coverURL(): string | null;
+    get description(): string | null;
+    get owner(): DocumentReference;
+    get relEvents(): string[];
+    get isASerie(): boolean;
+    get playerIds(): string[];
+    get players(): Record<string, EventPlayerBasicData>;
+    get playersCount(): number;
+    get repertory(): Record<string, import("../Repertory/types").ThemeBasicData>;
+    get repertoryIds(): string[];
+    get repertoryCount(): number;
+    get activeInvitationLink(): boolean;
+    get invitationLink(): string | null;
+    get shortDynamicLink(): string | null;
+    get deletedAt(): FirebaseFirestore.Timestamp | null;
+    get createdAt(): FirebaseFirestore.Timestamp;
+    get rollCalledAt(): FirebaseFirestore.Timestamp | null;
+    get rollCallReminderAt(): FirebaseFirestore.Timestamp | null;
+    get notifyAt(): FirebaseFirestore.Timestamp;
+    get isActive(): boolean;
+    get isDeleted(): boolean;
+    get statusByTime(): EventStatusByTime;
+    get repertoryList(): (import("../Repertory/types").ThemeBasicData & {
+        id: string;
+    })[];
+    get activePlayers(): string[];
+    get playersList(): (EventPlayerBasicData & {
+        id: string;
+    })[];
+    get confirmedPlayers(): string[];
+    get declinedPlayers(): string[];
+    get pendingPlayers(): string[];
+    get confirmedRollCallPlayers(): string[];
+    get declinedRollCallPlayers(): string[];
+    get isRollCalled(): boolean;
+    get isActiveRollCall(): boolean;
+    /** @deprecated  */
+    get viewers(): Record<string, import("./types").EventViewer>;
+    /** @deprecated  */
+    get listViewers(): (import("./types").EventViewer & {
+        id: string;
+    })[];
+    /** @deprecated  */
+    get totalViews(): number;
+    get templateId(): string | null;
+    get repeat(): import("./types").EventRepeatType | null;
+    get timezone(): string | null;
+    /** @deprecated  */
+    getViewer(userId: string): import("./types").EventViewer | null;
+    isPlayer: (userId: string) => boolean;
+    getPlayer: (userId: string) => EventPlayerBasicData | null;
+    isPlayerConfirmed(player: EventPlayerBasicData): boolean;
+    isPlayerDeclined(player: EventPlayerBasicData): boolean;
+    isPlayerRollCallConfirmed(player: EventPlayerBasicData): boolean;
+    isPlayerRollCallDeclined(player: EventPlayerBasicData): boolean;
+}

package/models/Evento/index.js

@@ -0,0 +1,178 @@
+"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 orders_1 = require("../../helpers/musicStyles/orders");
+const lang_1 = require("../../lang");
+const types_1 = require("./Player/types");
+const promoter_1 = __importDefault(require("./promoter"));
+const types_2 = require("./types");
+class Evento extends promoter_1.default {
+    constructor(doc, lang = lang_1.defaultLocale) {
+        super(doc, lang);
+        this.isPlayer = (userId) => {
+            return this.activePlayers.includes(userId);
+        };
+        this.getPlayer = (userId) => {
+            return userId in this.players ? this.players[userId] : null;
+        };
+    }
+    get maxAttendance() {
+        return this.data.maxAttendance;
+    }
+    get isCapacityCompleted() {
+        return lodash_1.isNumber(this.maxAttendance) && this.confirmedPlayers.length >= this.maxAttendance;
+    }
+    get location() {
+        return this.data.location;
+    }
+    get videoURL() {
+        return this.data.videoURL || null;
+    }
+    get coverURL() {
+        return this.data.coverURL || null;
+    }
+    get description() {
+        return this.data.description || null;
+    }
+    get owner() {
+        return this.data.owner;
+    }
+    get relEvents() {
+        return this.data.relEvents || [];
+    }
+    get isASerie() {
+        return this.relEvents.length > 1;
+    }
+    get playerIds() {
+        return this.data.playerIds || [];
+    }
+    get players() {
+        return this.data.players || {};
+    }
+    get playersCount() {
+        return this.data.playerIds.length;
+    }
+    get repertory() {
+        return this.data.repertory || {};
+    }
+    get repertoryIds() {
+        return this.data.repertoryIds || [];
+    }
+    get repertoryCount() {
+        return this.repertoryIds.length;
+    }
+    get activeInvitationLink() {
+        return this.data.activeInvitationLink || false;
+    }
+    get invitationLink() {
+        return this.data.invitationLink;
+    }
+    get shortDynamicLink() {
+        return this.data.shortDynamicLink;
+    }
+    get deletedAt() {
+        return this.data.deletedAt;
+    }
+    get createdAt() {
+        return this.data.createdAt;
+    }
+    get rollCalledAt() {
+        return this.data.rollCalledAt;
+    }
+    get rollCallReminderAt() {
+        return this.data.rollCallReminderAt;
+    }
+    get notifyAt() {
+        return this.data.notifyAt;
+    }
+    get isActive() {
+        return !this.isDeleted && !this.isOutDate;
+    }
+    get isDeleted() {
+        return !this.exists || !lodash_1.isNull(this.deletedAt);
+    }
+    get statusByTime() {
+        if (this.isOutDate) {
+            return types_2.EventStatusByTime.Past;
+        }
+        if (this.isHappening) {
+            return types_2.EventStatusByTime.Now;
+        }
+        return types_2.EventStatusByTime.Future;
+    }
+    get repertoryList() {
+        return Object.keys(this.repertory).map((themeId) => Object.assign({}, this.repertory[themeId], { id: themeId }));
+    }
+    get activePlayers() {
+        return Object.keys(this.players) || [];
+    }
+    get playersList() {
+        const players = this.activePlayers.map((playerId) => Object.assign({}, this.players[playerId], { id: playerId }));
+        return orders_1.orderByMusicStyle(players, 'mainInstrument', this.promoterInfo.musicStyle);
+    }
+    get confirmedPlayers() {
+        return this.activePlayers.filter((playerId) => this.isPlayerConfirmed(this.players[playerId]));
+    }
+    get declinedPlayers() {
+        return this.activePlayers.filter((playerId) => this.isPlayerDeclined(this.players[playerId]));
+    }
+    get pendingPlayers() {
+        return this.activePlayers.filter((playerId) => !this.players[playerId].status);
+    }
+    get confirmedRollCallPlayers() {
+        return this.activePlayers.filter((playerId) => this.isPlayerRollCallConfirmed(this.players[playerId]));
+    }
+    get declinedRollCallPlayers() {
+        return this.activePlayers.filter((playerId) => this.isPlayerRollCallDeclined(this.players[playerId]));
+    }
+    get isRollCalled() {
+        return this.rollCalledAt !== null;
+    }
+    get isActiveRollCall() {
+        return date_fns_1.isPast(date_fns_1.addHours(this.datetime.toDate(), -1));
+    }
+    /** @deprecated  */
+    get viewers() {
+        return this.data.viewers || {};
+    }
+    /** @deprecated  */
+    get listViewers() {
+        return Object.keys(this.viewers).map((userId) => Object.assign(this.viewers[userId], { id: userId }));
+    }
+    /** @deprecated  */
+    get totalViews() {
+        return this.listViewers
+            .map((viewer) => viewer.count || 0)
+            .reduce((acc, current) => acc + current);
+    }
+    get templateId() {
+        return this.data.templateId || null;
+    }
+    get repeat() {
+        return this.data.repeat || null;
+    }
+    get timezone() {
+        return this.data.timezone || null;
+    }
+    /** @deprecated  */
+    getViewer(userId) {
+        return userId in this.viewers ? this.viewers[userId] : null;
+    }
+    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;
+    }
+}
+exports.default = Evento;

package/models/Evento/promoter.d.ts

@@ -0,0 +1,11 @@
+import { DocumentReference, DocumentSnapshot } from '@google-cloud/firestore';
+import { LanguagesTypes } from '../../lang';
+import EventoBasic from './basic';
+import { EventPromoterData } from './types';
+export default class EventoPromoter<D> extends EventoBasic<EventPromoterData & D> {
+    constructor(doc: DocumentSnapshot, lang: LanguagesTypes);
+    get promoter(): DocumentReference;
+    get groupId(): string;
+    get photoURL(): string;
+    get promoterInfo(): import("../Group/types").GroupBasicData;
+}

package/models/Evento/promoter.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 basic_1 = __importDefault(require("./basic"));
+class EventoPromoter extends basic_1.default {
+    constructor(doc, lang) {
+        super(doc, lang);
+    }
+    get promoter() {
+        return this.data.promoter;
+    }
+    get groupId() {
+        return this.promoter.id;
+    }
+    get photoURL() {
+        return this.promoterInfo.photoURL;
+    }
+    get promoterInfo() {
+        return this.data.promoterInfo;
+    }
+}
+exports.default = EventoPromoter;

package/models/Evento/tiny.d.ts

@@ -0,0 +1,13 @@
+import { LanguagesTypes } from '../../lang';
+import { EventTinyData, EventType } from './types';
+export default class EventoTiny {
+    protected lang: LanguagesTypes;
+    protected data: EventTinyData;
+    constructor(data: EventTinyData, lang: LanguagesTypes);
+    get displayName(): string | null;
+    get title(): string;
+    get type(): EventType;
+    get isPractice(): boolean;
+    get isPerformance(): boolean;
+    get datetime(): FirebaseFirestore.Timestamp;
+}

package/models/Evento/tiny.js

@@ -0,0 +1,32 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const lang_1 = require("../../lang");
+const types_1 = require("./types");
+class EventoTiny {
+    constructor(data, lang) {
+        this.lang = lang;
+        this.data = data;
+    }
+    get displayName() {
+        return this.data.displayName;
+    }
+    get title() {
+        if (this.displayName) {
+            return this.displayName;
+        }
+        return lang_1.getTranslation(this.type, this.lang) || lang_1.getTranslation('event', this.lang);
+    }
+    get type() {
+        return this.data.type;
+    }
+    get isPractice() {
+        return this.type === types_1.EventType.Practice;
+    }
+    get isPerformance() {
+        return this.type === types_1.EventType.Performance;
+    }
+    get datetime() {
+        return this.data.datetime;
+    }
+}
+exports.default = EventoTiny;

package/models/Evento/types.d.ts

@@ -0,0 +1,76 @@
+import { DocumentReference, GeoPoint, Timestamp } from '@google-cloud/firestore';
+import { GroupBasicData } from '../Group/types';
+import { PlayerBasicData } from '../Player/types';
+import { ThemeBasicData } from '../Repertory/types';
+import { EventPlayerStatus } from './Player/types';
+export declare enum EventType {
+    Practice = "practice",
+    Performance = "performance"
+}
+export declare enum EventRepeatPeriod {
+    None = "none",
+    Weekly = "weekly",
+    Biweekly = "biweekly",
+    Monthly = "monthly"
+}
+export declare enum EventStatusByTime {
+    Future = "future",
+    Now = "now",
+    Past = "past"
+}
+export interface EventRepeatType {
+    period: EventRepeatPeriod;
+    untilAt: Timestamp;
+}
+export interface EventViewer {
+    viewedAt: Timestamp;
+    lastViewedAt: Timestamp;
+    count: number;
+}
+export interface EventPlayerBasicData extends PlayerBasicData {
+    status: EventPlayerStatus | null;
+    rollcall: EventPlayerStatus | null;
+}
+export interface AEventPlayerBasicData extends EventPlayerBasicData {
+    id: string;
+}
+export interface EventTinyData {
+    displayName: string | null;
+    datetime: Timestamp;
+    type: EventType;
+}
+export interface EventBasicData extends EventTinyData {
+    locality: string | null;
+    online: boolean;
+    datetimeEnd: Timestamp;
+}
+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;
+    playerIds: string[];
+    players: Record<string, EventPlayerBasicData>;
+    repertoryIds: string[];
+    repertory: Record<string, ThemeBasicData>;
+    relEvents: string[];
+    activeInvitationLink: boolean;
+    shortDynamicLink: string | null;
+    invitationLink: string | null;
+    notifyAt: Timestamp;
+    maxAttendance: number | null;
+    deletedAt: Timestamp | null;
+    rollCalledAt: Timestamp | null;
+    rollCallReminderAt: Timestamp | null;
+    /** @deprecated  */
+    viewers: Record<string, EventViewer>;
+    templateId: string | null;
+    repeat: EventRepeatType | null;
+    timezone: string;
+    readonly owner: DocumentReference;
+    readonly createdAt: Timestamp;
+}

package/models/Evento/types.js

@@ -0,0 +1,22 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.EventStatusByTime = exports.EventRepeatPeriod = exports.EventType = void 0;
+var EventType;
+(function (EventType) {
+    EventType["Practice"] = "practice";
+    EventType["Performance"] = "performance";
+})(EventType = exports.EventType || (exports.EventType = {}));
+var EventRepeatPeriod;
+(function (EventRepeatPeriod) {
+    EventRepeatPeriod["None"] = "none";
+    EventRepeatPeriod["Weekly"] = "weekly";
+    EventRepeatPeriod["Biweekly"] = "biweekly";
+    EventRepeatPeriod["Monthly"] = "monthly";
+})(EventRepeatPeriod = exports.EventRepeatPeriod || (exports.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 || (exports.EventStatusByTime = {}));

package/models/Federation/Partnership/index.d.ts

@@ -0,0 +1,12 @@
+import { DocumentSnapshot } from '@google-cloud/firestore';
+import PartnershipBasic from '../../Partnership/basic';
+import { FederationPartnershipData } from './types';
+export default class FederationPartnership extends PartnershipBasic<FederationPartnershipData> {
+    constructor(doc: DocumentSnapshot);
+    get connectedAt(): FirebaseFirestore.Timestamp | null;
+    get federationId(): string;
+    get isConnected(): boolean;
+    get memberCount(): number;
+    get partnerCount(): number;
+    get token(): string | null;
+}

package/models/Federation/Partnership/index.js

@@ -0,0 +1,31 @@
+"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 basic_1 = __importDefault(require("../../Partnership/basic"));
+class FederationPartnership extends basic_1.default {
+    constructor(doc) {
+        super(doc);
+    }
+    get connectedAt() {
+        return this.data.connectedAt || null;
+    }
+    get federationId() {
+        return get_1.default(this.ref, 'parent.parent.id');
+    }
+    get isConnected() {
+        return this.connectedAt !== null;
+    }
+    get memberCount() {
+        return this.data.memberCount || 0;
+    }
+    get partnerCount() {
+        return this.data.partnerCount || 0;
+    }
+    get token() {
+        return this.data.token || null;
+    }
+}
+exports.default = FederationPartnership;

package/models/Federation/Partnership/types.d.ts

@@ -0,0 +1,8 @@
+import { Timestamp } from '@google-cloud/firestore';
+import { PartnershipBasicData } from '../../Partnership/types';
+export interface FederationPartnershipData extends PartnershipBasicData {
+    connectedAt: Timestamp | null;
+    memberCount: number;
+    partnerCount: number;
+    token: string | null;
+}

package/models/Federation/Partnership/types.js

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

package/models/Federation/index.d.ts

@@ -0,0 +1,20 @@
+import { DocumentSnapshot } from '@google-cloud/firestore';
+import Model from '../Model';
+import { FederationData } from './types';
+export default class Federation extends Model<FederationData> {
+    constructor(doc: DocumentSnapshot);
+    get displayName(): string;
+    get email(): string | null;
+    get partnershipIds(): string[];
+    get adminIds(): string[];
+    isAdmin(userId: string): boolean;
+    get photoURL(): string;
+    get phone(): string | null;
+    get web(): string | null;
+    get address(): import("../Partner/types").BasicAddressData | null;
+    get partnershipConnectedIds(): string[];
+    get createdAt(): FirebaseFirestore.Timestamp;
+    get createdBy(): FirebaseFirestore.DocumentReference<FirebaseFirestore.DocumentData>;
+    get deletedAt(): FirebaseFirestore.Timestamp | null;
+    get isActive(): boolean;
+}

package/models/Federation/index.js

@@ -0,0 +1,54 @@
+"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 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 || [];
+    }
+    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 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 isActive() {
+        return !this.deletedAt && this.exists;
+    }
+}
+exports.default = Federation;

package/models/Federation/types.d.ts

@@ -0,0 +1,16 @@
+import { DocumentReference, Timestamp } from '@google-cloud/firestore';
+import { BasicAddressData } from '../Partner/types';
+export interface FederationData {
+    displayName: string;
+    photoURL: string;
+    email: string | null;
+    phone: string | null;
+    web: string | null;
+    address: BasicAddressData | null;
+    partnershipIds: string[];
+    partnershipConnectedIds: string[];
+    adminIds: string[];
+    deletedAt: Timestamp | null;
+    readonly createdAt: Timestamp;
+    readonly createdBy: DocumentReference;
+}

package/models/Federation/types.js

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

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

@@ -0,0 +1,11 @@
+import * as firestore from '@google-cloud/firestore';
+import Model from '../../Model';
+import { GroupAnalyticsData } from './types';
+export default class GroupAnalytics extends Model<GroupAnalyticsData> {
+    constructor(doc: firestore.DocumentSnapshot);
+    get groupId(): string;
+    get satisfactionIndex(): number;
+    get satisfactionIndexElements(): Record<import("./types").SatisfactionIndexElements, import("./types").SITypes>;
+    get createdAt(): firestore.Timestamp;
+    get weekDate(): Date;
+}

package/models/Group/Analytics/index.js

@@ -0,0 +1,29 @@
+"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 Model_1 = __importDefault(require("../../Model"));
+class GroupAnalytics extends Model_1.default {
+    constructor(doc) {
+        super(doc);
+    }
+    get groupId() {
+        return lodash_1.get(this.ref, 'parent.parent.id');
+    }
+    get satisfactionIndex() {
+        return this.data.satisfactionIndex || 0;
+    }
+    get satisfactionIndexElements() {
+        return this.data.satisfactionIndexElements || {};
+    }
+    get createdAt() {
+        return this.data.createdAt;
+    }
+    get weekDate() {
+        return date_fns_1.parse(this.id, 'yyyyMMdd', new Date());
+    }
+}
+exports.default = GroupAnalytics;

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

@@ -0,0 +1,20 @@
+import { Timestamp } from '@google-cloud/firestore';
+export declare enum SatisfactionIndexElements {
+    ADMIN_COUNT = "adminCount",
+    MEMBERS_COUNT = "memberCount",
+    EVENTS_PER_WEEK = "eventsPerWeek",
+    EVENTS_ROLLCALLED_RATIO = "eventsRollcalledRatio",
+    EVENTS_ATTENDANCE_PREVISION_RATIO = "eventsAttendancePrevisionRatio",
+    EVENTS_ANSWER_RATIO = "eventsAnswerRatio",
+    EVENTS_WITH_REPERTORY_RATIO = "eventsWithRepertoryRatio"
+}
+export interface SITypes {
+    value: number;
+    threshold: number;
+    result: number;
+}
+export interface GroupAnalyticsData {
+    satisfactionIndexElements: Record<SatisfactionIndexElements, SITypes>;
+    satisfactionIndex: number;
+    createdAt: Timestamp;
+}

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