@glissandoo/lib 1.0.0

package/models/Group/Repertory/index.js

@@ -0,0 +1,149 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const endOfDay_1 = __importDefault(require("date-fns/endOfDay"));
+const isFuture_1 = __importDefault(require("date-fns/isFuture"));
+const get_1 = __importDefault(require("lodash/get"));
+const orderBy_1 = __importDefault(require("lodash/orderBy"));
+const basic_1 = __importDefault(require("../../Repertory/basic"));
+class GroupRepertory extends basic_1.default {
+    constructor(doc) {
+        super(doc);
+    }
+    get groupId() {
+        return get_1.default(this.ref, 'parent.parent.id');
+    }
+    get tagsAlgolia() {
+        return this.data.tagsAlgolia || [];
+    }
+    get instruments() {
+        const instruments = this.data.instruments || [];
+        return instruments.map((instrument) => (Object.assign(Object.assign({}, instrument), { filesPath: instrument.filesPath })));
+    }
+    get mainFilePath() {
+        return this.data.mainFilePath;
+    }
+    get events() {
+        return this.data.events || [];
+    }
+    get eventsTL() {
+        return this.data.eventsTL || {};
+    }
+    get eventsList() {
+        return Object.keys(this.eventsTL).map((id) => Object.assign(this.eventsTL[id], { id }));
+    }
+    /** @deprecated use getNextEvents */
+    get nextEvents() {
+        return this.getEventsByOrder().filter((ev) => isFuture_1.default(ev.datetime.toDate()));
+    }
+    /** @deprecated use getNextEvent */
+    get nextEvent() {
+        if (this.nextEvents.length === 0) {
+            return null;
+        }
+        return this.nextEvents[this.nextEvents.length - 1];
+    }
+    get scoresByInstruments() {
+        return this.data.scoresByInstruments || false;
+    }
+    get editedAt() {
+        return this.data.editedAt;
+    }
+    get createdAt() {
+        return this.data.createdAt;
+    }
+    get audios() {
+        return this.data.audios || [];
+    }
+    get identifyAt() {
+        return this.data.identifyAt;
+    }
+    get isIdentify() {
+        return this.identifyAt !== null || this.identifyAt !== undefined;
+    }
+    get isActive() {
+        return this.exists;
+    }
+    get thumbnailURL() {
+        return this.data.thumbnailURL || null;
+    }
+    get ownerId() {
+        return this.data.owner.id;
+    }
+    /** @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 claims() {
+        return this.data.claims || {};
+    }
+    get claimsList() {
+        const list = [];
+        Object.keys(this.claims).map((instrumentId) => {
+            Object.keys(this.claims[instrumentId] || {}).map((userId) => {
+                list.push(Object.assign({ userId, instrumentId: instrumentId }, this.claims[instrumentId][userId]));
+            });
+        });
+        return list;
+    }
+    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];
+    }
+    /** @deprecated */
+    getViewer(userId) {
+        return userId in this.viewers ? this.viewers[userId] : null;
+    }
+    getInstrument(id) {
+        return this.instruments.find((i) => i.id === id);
+    }
+    getNextEvents(endDay = false) {
+        return this.getEventsByOrder().filter((ev) => {
+            if (endDay) {
+                return isFuture_1.default(endOfDay_1.default(ev.datetime.toDate()));
+            }
+            return isFuture_1.default(ev.datetime.toDate());
+        });
+    }
+    getNextEvent(endDay = false) {
+        const events = this.getNextEvents(endDay);
+        if (events.length === 0) {
+            return null;
+        }
+        return events[events.length - 1];
+    }
+    getEventsByOrder(order = 'desc') {
+        return orderBy_1.default(this.eventsList, (e) => e.datetime.toDate(), [order]);
+    }
+}
+exports.default = GroupRepertory;

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

@@ -0,0 +1,43 @@
+import { DocumentReference, Timestamp } from '@google-cloud/firestore';
+import { InstrumentId } from '../../../helpers/instruments';
+import { EventTinyData } from '../../Evento/types';
+import { ThemeBasicData } from '../../Repertory/types';
+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 GroupRepertoryData extends ThemeBasicData {
+    events: string[];
+    eventsTL: Record<string, EventTinyData>;
+    tagsAlgolia: GroupRepertoryTagAlgoliaData[];
+    mainFilePath: string | null;
+    scoresByInstruments: boolean;
+    instruments: GroupRepertoryInstrumentItemData[];
+    audios: string[];
+    thumbnailURL: string | null;
+    identifyAt: Timestamp | null;
+    editedAt: Timestamp | null;
+    /** @deprecated  */
+    viewers: Record<string, GroupRepertoryViewer>;
+    claims: Record<string, Record<string, GroupRepertoryClaimType>>;
+    readonly owner: DocumentReference;
+    readonly createdAt: Timestamp;
+}

package/models/Group/Repertory/types.js

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

package/models/Group/basic.d.ts

@@ -0,0 +1,17 @@
+import { DocumentSnapshot } from '@google-cloud/firestore';
+import { LanguagesTypes } from '../../lang';
+import Model from '../Model';
+import { GroupBasicData, GroupTinyData } from './types';
+export default class GroupBasic<D> extends Model<D & GroupBasicData> {
+    protected lang: LanguagesTypes;
+    constructor(doc: DocumentSnapshot, lang: LanguagesTypes);
+    get tinyInfo(): GroupTinyData;
+    get basicInfo(): GroupBasicData;
+    get displayName(): string;
+    get photoURL(): string;
+    get locality(): string;
+    get location(): FirebaseFirestore.GeoPoint;
+    get username(): string;
+    get musicStyle(): import("../../helpers/musicStyles").MusicStyleId;
+    get musicStyleString(): string;
+}

package/models/Group/basic.js

@@ -0,0 +1,51 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const lang_1 = require("../../lang");
+const Model_1 = __importDefault(require("../Model"));
+class GroupBasic extends Model_1.default {
+    constructor(doc, lang) {
+        super(doc);
+        this.lang = lang;
+    }
+    get tinyInfo() {
+        return {
+            displayName: this.displayName,
+            photoURL: this.photoURL,
+        };
+    }
+    get basicInfo() {
+        return {
+            displayName: this.displayName,
+            photoURL: this.photoURL,
+            username: this.username,
+            locality: this.locality,
+            location: this.location,
+            musicStyle: this.musicStyle,
+        };
+    }
+    get displayName() {
+        return this.data.displayName;
+    }
+    get photoURL() {
+        return this.data.photoURL;
+    }
+    get locality() {
+        return this.data.locality;
+    }
+    get location() {
+        return this.data.location;
+    }
+    get username() {
+        return this.data.username;
+    }
+    get musicStyle() {
+        return this.data.musicStyle;
+    }
+    get musicStyleString() {
+        return lang_1.getTranslation(`musicStyles.${this.musicStyle}`, this.lang);
+    }
+}
+exports.default = GroupBasic;

package/models/Group/index.d.ts

@@ -0,0 +1,43 @@
+import { DocumentReference, DocumentSnapshot } from '@google-cloud/firestore';
+import { LanguagesTypes } from '../../lang';
+import GroupBasic from './basic';
+import { GroupData, SocialNetwork } from './types';
+export default class Group extends GroupBasic<GroupData> {
+    constructor(doc: DocumentSnapshot, 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 | null;
+    get shortDynamicLink(): string | null;
+    get admins(): string[];
+    get createdAt(): FirebaseFirestore.Timestamp;
+    get deletedAt(): FirebaseFirestore.Timestamp | null;
+    get activePlayers(): string[];
+    get playersList(): (import("../Player/types").PlayerBasicData & {
+        id: string;
+    })[];
+    get isActive(): boolean;
+    get isDeleted(): boolean;
+    get intercomId(): string | null;
+    get partnershipId(): string | null;
+    get socialNetworks(): Record<SocialNetwork, string | null>;
+    getSocialNetworkUrl(id: SocialNetwork): string | null;
+    get config(): Record<import("./types").GroupConfig, boolean>;
+    get templates(): Record<string, import("./types").GroupTemplateData>;
+    get status(): import("./types").GroupStatus;
+    get templatesList(): (import("./types").GroupTemplateData & {
+        id: string;
+    })[];
+    get satisfactionIndex(): {
+        current: number;
+        last: number;
+    };
+    getPlayer: (userId: string) => import("../Player/types").PlayerBasicData | null;
+    isAdmin: (userId: string) => boolean;
+    isPlayer: (userId: string) => boolean;
+}

package/models/Group/index.js

@@ -0,0 +1,115 @@
+"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 orders_1 = require("../../helpers/musicStyles/orders");
+const lang_1 = require("../../lang");
+const basic_1 = __importDefault(require("./basic"));
+const types_1 = require("./types");
+class Group extends basic_1.default {
+    constructor(doc, lang = lang_1.defaultLocale) {
+        super(doc, lang);
+        this.getPlayer = (userId) => {
+            return userId in this.players ? this.players[userId] : null;
+        };
+        this.isAdmin = (userId) => {
+            return this.admins.includes(userId);
+        };
+        this.isPlayer = (userId) => {
+            return this.playerIds.includes(userId);
+        };
+    }
+    get owner() {
+        return this.data.owner;
+    }
+    get playerIds() {
+        return this.data.playerIds || [];
+    }
+    get players() {
+        return this.data.players || {};
+    }
+    get playersCount() {
+        return this.playerIds.length;
+    }
+    get description() {
+        return this.data.description || null;
+    }
+    get addresses() {
+        return this.data.addresses || [];
+    }
+    get addressDefault() {
+        return this.addresses.find((a) => a.default === true);
+    }
+    get activeInvitationLink() {
+        return this.data.activeInvitationLink || false;
+    }
+    get invitationLink() {
+        return this.data.invitationLink;
+    }
+    get shortDynamicLink() {
+        return this.data.shortDynamicLink;
+    }
+    get admins() {
+        return this.data.administrators || [];
+    }
+    get createdAt() {
+        return this.data.createdAt;
+    }
+    get deletedAt() {
+        return this.data.deletedAt || null;
+    }
+    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.musicStyle);
+    }
+    get isActive() {
+        return this.exists && !this.deletedAt;
+    }
+    get isDeleted() {
+        return !this.exists || !lodash_1.isNull(this.deletedAt);
+    }
+    get intercomId() {
+        return this.data.intercom_id || null;
+    }
+    get partnershipId() {
+        return this.data.partnershipId || null;
+    }
+    get socialNetworks() {
+        if (this.data.socialNetworks) {
+            return this.data.socialNetworks;
+        }
+        return {
+            [types_1.SocialNetwork.Facebook]: null,
+            [types_1.SocialNetwork.Twitter]: null,
+            [types_1.SocialNetwork.Instagram]: null,
+            [types_1.SocialNetwork.YouTube]: null,
+        };
+    }
+    getSocialNetworkUrl(id) {
+        if (id in this.socialNetworks) {
+            return this.socialNetworks[id];
+        }
+        return null;
+    }
+    get config() {
+        return this.data.config || {};
+    }
+    get templates() {
+        return this.data.templates || {};
+    }
+    get status() {
+        return this.data.status;
+    }
+    get templatesList() {
+        return Object.keys(this.templates).map((templateId) => Object.assign({}, this.templates[templateId], { id: templateId }));
+    }
+    get satisfactionIndex() {
+        return this.data.satisfactionIndex || { current: 0, last: 0 };
+    }
+}
+exports.default = Group;

package/models/Group/types.d.ts

@@ -0,0 +1,68 @@
+import { DocumentReference, GeoPoint, Timestamp } from '@google-cloud/firestore';
+import { MusicStyleId } from '../../helpers/musicStyles';
+import { PlayerBasicData } from '../Player/types';
+export declare enum GroupConfig {
+    IncludesMembersToEventsWhenJoined = "includesMembersToEventsWhenJoined"
+}
+export declare enum GroupStatus {
+    Premium = "premium",
+    Trial = "trial",
+    Inactive = "inactive",
+    Deleted = "deleted"
+}
+export declare enum SocialNetwork {
+    Facebook = "facebook",
+    Twitter = "twitter",
+    Instagram = "instagram",
+    YouTube = "youtube"
+}
+export interface GroupAddressData {
+    address: string;
+    location: GeoPoint | null;
+    default: boolean;
+}
+export interface GroupTemplateData {
+    title: string;
+    playerIds: string[];
+    createdAt: Timestamp;
+    owner: string;
+}
+export interface AGroupTemplateData extends GroupTemplateData {
+    id: string;
+}
+export interface AGroupBasicData extends GroupBasicData {
+    id: string;
+}
+export interface GroupTinyData {
+    displayName: string;
+    photoURL: string;
+}
+export interface GroupBasicData extends GroupTinyData {
+    username: string;
+    musicStyle: MusicStyleId;
+    locality: string;
+    location: GeoPoint;
+}
+export interface GroupData extends GroupBasicData {
+    owner: DocumentReference;
+    playerIds: string[];
+    players: Record<string, PlayerBasicData>;
+    templates: Record<string, GroupTemplateData>;
+    administrators: string[];
+    addresses: GroupAddressData[];
+    activeInvitationLink: boolean;
+    invitationLink: string | null;
+    shortDynamicLink: string | null;
+    intercom_id: string | null;
+    description: string | null;
+    createdAt: Timestamp;
+    deletedAt: Timestamp | null;
+    socialNetworks?: Record<SocialNetwork, string | null>;
+    config: Record<GroupConfig, boolean>;
+    satisfactionIndex: {
+        current: number;
+        last: number;
+    };
+    status: GroupStatus;
+    partnershipId: string | null;
+}

package/models/Group/types.js

@@ -0,0 +1,21 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SocialNetwork = exports.GroupStatus = exports.GroupConfig = void 0;
+var GroupConfig;
+(function (GroupConfig) {
+    GroupConfig["IncludesMembersToEventsWhenJoined"] = "includesMembersToEventsWhenJoined";
+})(GroupConfig = exports.GroupConfig || (exports.GroupConfig = {}));
+var GroupStatus;
+(function (GroupStatus) {
+    GroupStatus["Premium"] = "premium";
+    GroupStatus["Trial"] = "trial";
+    GroupStatus["Inactive"] = "inactive";
+    GroupStatus["Deleted"] = "deleted";
+})(GroupStatus = exports.GroupStatus || (exports.GroupStatus = {}));
+var SocialNetwork;
+(function (SocialNetwork) {
+    SocialNetwork["Facebook"] = "facebook";
+    SocialNetwork["Twitter"] = "twitter";
+    SocialNetwork["Instagram"] = "instagram";
+    SocialNetwork["YouTube"] = "youtube";
+})(SocialNetwork = exports.SocialNetwork || (exports.SocialNetwork = {}));

package/models/Instrument/index.d.ts

@@ -0,0 +1,9 @@
+import { InstrumentId } from '../../helpers/instruments';
+import { LanguagesTypes } from '../../lang';
+export default class Instrument {
+    id: InstrumentId;
+    private lang;
+    constructor(id: InstrumentId, lang?: LanguagesTypes);
+    get name(): string;
+    get icon(): string;
+}

package/models/Instrument/index.js

@@ -0,0 +1,17 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const instruments_1 = require("../../helpers/instruments");
+const lang_1 = require("../../lang");
+class Instrument {
+    constructor(id, lang = lang_1.defaultLocale) {
+        this.id = id;
+        this.lang = lang;
+    }
+    get name() {
+        return lang_1.getTranslation(`instruments.${this.id}`, this.lang);
+    }
+    get icon() {
+        return instruments_1.InstrumentIcons[this.id] || 'warning';
+    }
+}
+exports.default = Instrument;

package/models/Metrics/index.d.ts

@@ -0,0 +1,17 @@
+import * as firestore from '@google-cloud/firestore';
+import Model from '../Model';
+import { AllowCollections, EntityTypes, MetricsData } from './types';
+export default class Metrics extends Model<MetricsData> {
+    private defaultEntity;
+    constructor(doc: firestore.DocumentSnapshot);
+    getEntity: (entity: AllowCollections) => EntityTypes;
+    get users(): EntityTypes;
+    get groups(): EntityTypes;
+    get events(): EntityTypes;
+    get communications(): EntityTypes;
+    get repertory(): EntityTypes;
+    get partnerships(): EntityTypes;
+    get partners(): EntityTypes;
+    get date(): firestore.Timestamp;
+    get createdAt(): firestore.Timestamp;
+}

package/models/Metrics/index.js

@@ -0,0 +1,47 @@
+"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 Metrics extends Model_1.default {
+    constructor(doc) {
+        super(doc);
+        this.defaultEntity = {
+            acc: 0,
+            count: 0,
+            total: 0,
+        };
+        this.getEntity = (entity) => {
+            return this.data[entity] || this.defaultEntity;
+        };
+    }
+    get users() {
+        return this.data.user || this.defaultEntity;
+    }
+    get groups() {
+        return this.data.group || this.defaultEntity;
+    }
+    get events() {
+        return this.data.event || this.defaultEntity;
+    }
+    get communications() {
+        return this.data.communication || this.defaultEntity;
+    }
+    get repertory() {
+        return this.data.repertory || this.defaultEntity;
+    }
+    get partnerships() {
+        return this.data.partnership || this.defaultEntity;
+    }
+    get partners() {
+        return this.data.partner || this.defaultEntity;
+    }
+    get date() {
+        return this.data.date;
+    }
+    get createdAt() {
+        return this.data.createdAt;
+    }
+}
+exports.default = Metrics;

package/models/Metrics/types.d.ts

@@ -0,0 +1,12 @@
+import { Timestamp } from '@google-cloud/firestore';
+import { CollectionNames } from '../../helpers/collections';
+export declare type AllowCollections = CollectionNames.User | CollectionNames.Group | CollectionNames.Event | CollectionNames.Communication | CollectionNames.GroupRepertory | CollectionNames.Partner | CollectionNames.Partnership;
+export interface EntityTypes {
+    total: number;
+    acc: number;
+    count: number;
+}
+export interface MetricsData extends Record<AllowCollections, EntityTypes> {
+    date: Timestamp;
+    createdAt: Timestamp;
+}

package/models/Metrics/types.js

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

package/models/Model.d.ts

@@ -0,0 +1,10 @@
+import * as firestore from '@google-cloud/firestore';
+export default class Model<D> {
+    id: string;
+    ref: firestore.DocumentReference;
+    exists: boolean;
+    private _data;
+    constructor(doc: firestore.DocumentSnapshot);
+    get data(): D;
+    protected get(name: string): any;
+}

package/models/Model.js

@@ -0,0 +1,21 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+class Model {
+    constructor(doc) {
+        this.id = doc.id;
+        this._data = doc.data();
+        this.ref = doc.ref;
+        this.exists = doc.exists;
+    }
+    get data() {
+        return this._data;
+    }
+    get(name) {
+        if (!this._data || !this._data[name]) {
+            return null;
+        }
+        // eslint-disable-next-line @typescript-eslint/no-unsafe-return
+        return this._data[name];
+    }
+}
+exports.default = Model;

package/models/MusicStyle/index.d.ts

@@ -0,0 +1,8 @@
+import { MusicStyleId } from '../../helpers/musicStyles';
+import { LanguagesTypes } from '../../lang';
+export default class MusicStyle {
+    id: MusicStyleId;
+    private lang;
+    constructor(id: MusicStyleId, lang?: LanguagesTypes);
+    get name(): string;
+}

package/models/MusicStyle/index.js

@@ -0,0 +1,13 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const lang_1 = require("../../lang");
+class MusicStyle {
+    constructor(id, lang = lang_1.defaultLocale) {
+        this.id = id;
+        this.lang = lang;
+    }
+    get name() {
+        return lang_1.getTranslation(`musicStyles.${this.id}`, this.lang);
+    }
+}
+exports.default = MusicStyle;