@glissandoo/lib 1.0.0

package/lang/index.js

@@ -0,0 +1,101 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getTranslation = exports.getDateLang = exports.defaultLocale = exports.LanguagesTypes = void 0;
+const ca_1 = __importDefault(require("date-fns/locale/ca"));
+const de_1 = __importDefault(require("date-fns/locale/de"));
+const en_US_1 = __importDefault(require("date-fns/locale/en-US"));
+const es_1 = __importDefault(require("date-fns/locale/es"));
+const gl_1 = __importDefault(require("date-fns/locale/gl"));
+const get_1 = __importDefault(require("lodash/get"));
+const ca_json_1 = __importDefault(require("./ca.json"));
+const de_json_1 = __importDefault(require("./de.json"));
+const en_json_1 = __importDefault(require("./en.json"));
+const es_json_1 = __importDefault(require("./es.json"));
+const gl_json_1 = __importDefault(require("./gl.json"));
+var LanguagesTypes;
+(function (LanguagesTypes) {
+    LanguagesTypes["ES"] = "es";
+    LanguagesTypes["EN"] = "en";
+    LanguagesTypes["CA"] = "ca";
+    LanguagesTypes["GL"] = "gl";
+    LanguagesTypes["DE"] = "de";
+})(LanguagesTypes = exports.LanguagesTypes || (exports.LanguagesTypes = {}));
+const languageProvider = {
+    es: {
+        messages: es_json_1.default,
+        date: {
+            locale: es_1.default,
+            format: {
+                date: "iiii d 'de' MMMM",
+                datetime: "iiii d 'de' MMMM 'a las' HH:mm'h.'",
+                shortDate: 'dd/MM/yy',
+                time: "HH:mm'h.'",
+            },
+        },
+    },
+    en: {
+        messages: en_json_1.default,
+        date: {
+            locale: en_US_1.default,
+            format: {
+                date: "iiii',' MMMM d",
+                datetime: "iiii',' MMMM d 'at' h:mm aaaa",
+                shortDate: 'MM/dd/yy',
+                time: 'h:mm aaaa',
+            },
+        },
+    },
+    ca: {
+        messages: ca_json_1.default,
+        date: {
+            locale: ca_1.default,
+            format: {
+                date: "iiii d 'de' MMMM",
+                datetime: "iiii d 'de' MMMM 'a les' HH:mm'h.'",
+                shortDate: 'dd/MM/yy',
+                time: "HH:mm'h.'",
+            },
+        },
+    },
+    gl: {
+        messages: gl_json_1.default,
+        date: {
+            locale: gl_1.default,
+            format: {
+                date: "iiii d 'de' MMMM",
+                datetime: "iiii d 'de' MMMM 'a las' HH:mm'h.'",
+                shortDate: 'dd/MM/yy',
+                time: "HH:mm'h.'",
+            },
+        },
+    },
+    de: {
+        messages: de_json_1.default,
+        date: {
+            locale: de_1.default,
+            format: {
+                date: "iiii',' MMMM d",
+                datetime: "iiii',' MMMM d 'um' HH:mm 'Uhr'",
+                shortDate: 'MM/dd/yy',
+                time: "HH:mm 'Uhr'",
+            },
+        },
+    },
+};
+exports.defaultLocale = LanguagesTypes.ES;
+const getDateLang = (lang) => {
+    return languageProvider[lang].date;
+};
+exports.getDateLang = getDateLang;
+const getTranslation = (key, lang) => {
+    const translation = get_1.default(languageProvider, [lang, 'messages', key]);
+    if (!translation) {
+        return '';
+    }
+    return translation;
+};
+exports.getTranslation = getTranslation;
+exports.default = languageProvider;

package/models/Communication/index.d.ts

@@ -0,0 +1,47 @@
+import { DocumentReference, DocumentSnapshot } from '@google-cloud/firestore';
+import { LanguagesTypes } from '../../lang';
+import Model from '../Model';
+import { CommunicationData, CommunicationThumbnailType, CommunicationType } from './types';
+export default class Communication extends Model<CommunicationData> {
+    protected lang: LanguagesTypes;
+    constructor(doc: DocumentSnapshot, lang?: LanguagesTypes);
+    get title(): string;
+    get message(): import("slate").Node[];
+    get promoter(): DocumentReference;
+    get promoterInfo(): import("../Group/types").GroupTinyData;
+    get owner(): DocumentReference;
+    get ownerInfo(): import("../User/types").UserTinyData | import("../Group/types").GroupTinyData;
+    get allowAnswer(): boolean;
+    get recipients(): string[];
+    get recipientsInfo(): Record<string, import("./types").CommunicationRecipientData>;
+    get listRecipients(): (import("./types").CommunicationRecipientData & {
+        id: string;
+    })[];
+    get type(): CommunicationType;
+    get isPrivate(): boolean;
+    get isPublic(): boolean;
+    get attachmentsPath(): string[];
+    get imagesPath(): string[];
+    get deletedAt(): FirebaseFirestore.Timestamp | null;
+    get isDeleted(): boolean;
+    get isActive(): boolean;
+    get plainText(): string;
+    get createdAt(): FirebaseFirestore.Timestamp;
+    get createdToNow(): string;
+    get thumbnailType(): CommunicationThumbnailType | null;
+    get isThumbnailAvatar(): boolean;
+    get isThumbnailImage(): boolean;
+    get thumbnailURL(): string | null;
+    get avatar(): (import("../User/types").UserTinyData & {
+        id: string;
+    }) | null;
+    get thumbnail(): {
+        url: string;
+        alt: string;
+    };
+    get editedAt(): FirebaseFirestore.Timestamp | null;
+    get totalClaps(): number;
+    get totalViews(): number;
+    get isServer(): boolean;
+    getRecipient: (userId: string) => import("./types").CommunicationRecipientData | null;
+}

package/models/Communication/index.js

@@ -0,0 +1,138 @@
+"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 utils_1 = require("../../helpers/utils");
+const lang_1 = require("../../lang");
+const Model_1 = __importDefault(require("../Model"));
+const types_1 = require("./types");
+class Communication extends Model_1.default {
+    constructor(doc, lang = lang_1.defaultLocale) {
+        super(doc);
+        this.getRecipient = (userId) => {
+            return userId in this.recipientsInfo ? this.recipientsInfo[userId] : null;
+        };
+        this.lang = lang;
+    }
+    get title() {
+        return this.data.title;
+    }
+    get message() {
+        return this.data.message || [];
+    }
+    get promoter() {
+        return this.data.promoter;
+    }
+    get promoterInfo() {
+        return this.data.promoterInfo;
+    }
+    get owner() {
+        return this.data.owner;
+    }
+    get ownerInfo() {
+        return this.data.ownerInfo;
+    }
+    get allowAnswer() {
+        return this.data.allowAnswers || false;
+    }
+    get recipients() {
+        return this.data.recipients || [];
+    }
+    get recipientsInfo() {
+        return this.data.recipientsInfo || {};
+    }
+    get listRecipients() {
+        return Object.keys(this.recipientsInfo).map((userId) => Object.assign(this.recipientsInfo[userId], { id: userId }));
+    }
+    get type() {
+        return this.data.type;
+    }
+    get isPrivate() {
+        return this.data.type === types_1.CommunicationType.Private;
+    }
+    get isPublic() {
+        return this.data.type === types_1.CommunicationType.Public;
+    }
+    get attachmentsPath() {
+        return this.data.attachmentsPath || [];
+    }
+    get imagesPath() {
+        return this.data.imagesPath || [];
+    }
+    get deletedAt() {
+        return this.data.deletedAt || null;
+    }
+    get isDeleted() {
+        return !this.exists || !lodash_1.isNull(this.deletedAt);
+    }
+    get isActive() {
+        return !this.isDeleted;
+    }
+    get plainText() {
+        return utils_1.serializeSlateBlock(this.message);
+    }
+    get createdAt() {
+        return this.data.createdAt;
+    }
+    get createdToNow() {
+        const dateLang = lang_1.getDateLang(this.lang);
+        // @ÑAPA
+        const text = date_fns_1.formatDistanceToNow(this.createdAt.toDate(), { locale: dateLang.locale })
+            .replace('alrededor de', 'hace')
+            .replace('arredor de', 'fa');
+        return text;
+    }
+    get thumbnailType() {
+        return this.data.thumbnailType || null;
+    }
+    get isThumbnailAvatar() {
+        return this.thumbnailType === types_1.CommunicationThumbnailType.Avatar;
+    }
+    get isThumbnailImage() {
+        return this.thumbnailType === types_1.CommunicationThumbnailType.Image;
+    }
+    get thumbnailURL() {
+        return this.data.thumbnailURL || null;
+    }
+    get avatar() {
+        return this.data.avatar || null;
+    }
+    get thumbnail() {
+        if (this.isThumbnailAvatar && this.avatar) {
+            return {
+                url: this.avatar.photoURL,
+                alt: this.avatar.displayName,
+            };
+        }
+        if (this.isThumbnailImage && this.thumbnailURL) {
+            return {
+                url: this.thumbnailURL,
+                alt: '',
+            };
+        }
+        return {
+            url: this.promoterInfo.photoURL,
+            alt: this.promoterInfo.displayName,
+        };
+    }
+    get editedAt() {
+        return this.data.editedAt || null;
+    }
+    get totalClaps() {
+        return this.listRecipients
+            .map((recipient) => recipient.claps || 0)
+            .reduce((acc, current) => acc + current, 0);
+    }
+    get totalViews() {
+        return this.listRecipients
+            .map((recipient) => recipient.countViews || 0)
+            .reduce((acc, current) => acc + current, 0);
+    }
+    get isServer() {
+        return this.data.server === true;
+    }
+}
+exports.default = Communication;

package/models/Communication/types.d.ts

@@ -0,0 +1,53 @@
+import { DocumentReference, Timestamp } from '@google-cloud/firestore';
+import { Node } from 'slate';
+import { GroupTinyData } from '../Group/types';
+import { UserTinyData } from '../User/types';
+export declare enum CommunicationType {
+    Private = "user",
+    Public = "group"
+}
+export declare enum CommunicationThumbnailType {
+    Avatar = "avatar",
+    Image = "image"
+}
+export interface RichTextChildren {
+    text: string;
+    bold?: boolean;
+    italic?: boolean;
+    underline?: boolean;
+}
+export interface RichText {
+    type: string;
+    url?: string;
+    children: RichTextChildren[] | RichText[];
+}
+export interface CommunicationRecipientData {
+    sendedAt: Timestamp;
+    claps: number;
+    viewedAt: Timestamp | null;
+    lastViewedAt: Timestamp | null;
+    countViews: number;
+}
+export interface CommunicationData {
+    title: string;
+    message: Node[];
+    promoter: DocumentReference;
+    promoterInfo: GroupTinyData;
+    type: CommunicationType;
+    owner: DocumentReference;
+    ownerInfo: GroupTinyData | UserTinyData;
+    allowAnswers: boolean;
+    attachmentsPath: string[];
+    imagesPath: string[];
+    recipients: string[];
+    recipientsInfo: Record<string, CommunicationRecipientData>;
+    thumbnailType: CommunicationThumbnailType | null;
+    thumbnailURL: string | null;
+    avatar: (UserTinyData & {
+        id: string;
+    }) | null;
+    deletedAt: Timestamp | null;
+    editedAt: Timestamp | null;
+    readonly server: boolean;
+    readonly createdAt: Timestamp;
+}

package/models/Communication/types.js

@@ -0,0 +1,13 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CommunicationThumbnailType = exports.CommunicationType = void 0;
+var CommunicationType;
+(function (CommunicationType) {
+    CommunicationType["Private"] = "user";
+    CommunicationType["Public"] = "group";
+})(CommunicationType = exports.CommunicationType || (exports.CommunicationType = {}));
+var CommunicationThumbnailType;
+(function (CommunicationThumbnailType) {
+    CommunicationThumbnailType["Avatar"] = "avatar";
+    CommunicationThumbnailType["Image"] = "image";
+})(CommunicationThumbnailType = exports.CommunicationThumbnailType || (exports.CommunicationThumbnailType = {}));

package/models/Counters/index.d.ts

@@ -0,0 +1,7 @@
+import { DocumentSnapshot } from '@google-cloud/firestore';
+import Model from '../Model';
+import { CountersData } from './types';
+export default class Counters extends Model<CountersData> {
+    constructor(doc: DocumentSnapshot);
+    get count(): number;
+}

package/models/Counters/index.js

@@ -0,0 +1,15 @@
+"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 Counters extends Model_1.default {
+    constructor(doc) {
+        super(doc);
+    }
+    get count() {
+        return this.data.count || 0;
+    }
+}
+exports.default = Counters;

package/models/Counters/types.d.ts

@@ -0,0 +1,3 @@
+export interface CountersData {
+    count: number;
+}

package/models/Counters/types.js

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

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

@@ -0,0 +1,17 @@
+import * as firestore from '@google-cloud/firestore';
+import { LanguagesTypes } from '../../../lang';
+import PlayerBasic from '../../Player/basic';
+import { EventPlayerData, EventPlayerStatus } from './types';
+export default class EventoPlayer extends PlayerBasic<EventPlayerData> {
+    constructor(doc: firestore.DocumentSnapshot, lang?: LanguagesTypes);
+    get joinedAt(): firestore.Timestamp;
+    get eventId(): string;
+    get status(): EventPlayerStatus | null;
+    get isConfirmed(): boolean;
+    get isDeclined(): boolean;
+    get isPending(): boolean;
+    get rollcall(): EventPlayerStatus | null;
+    get isRollCallConfirmed(): boolean;
+    get isRollCallDeclined(): boolean;
+    get rollCalledAt(): firestore.Timestamp | null;
+}

package/models/Evento/Player/index.js

@@ -0,0 +1,45 @@
+"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("../../Player/basic"));
+const types_1 = require("./types");
+class EventoPlayer extends basic_1.default {
+    constructor(doc, lang = lang_1.defaultLocale) {
+        super(doc, lang);
+    }
+    get joinedAt() {
+        return this.data.joinedAt;
+    }
+    get eventId() {
+        return get_1.default(this.ref, 'parent.parent.id');
+    }
+    get status() {
+        return this.data.status;
+    }
+    get isConfirmed() {
+        return this.status === types_1.EventPlayerStatus.Confirmed;
+    }
+    get isDeclined() {
+        return this.status === types_1.EventPlayerStatus.Declined;
+    }
+    get isPending() {
+        return this.status === null;
+    }
+    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 rollCalledAt() {
+        return this.data.rollCalledAt || null;
+    }
+}
+exports.default = EventoPlayer;

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

@@ -0,0 +1,15 @@
+import { Timestamp } from '@google-cloud/firestore';
+import { EventPlayerBasicData } from '../types';
+export declare enum EventPlayerStatus {
+    Confirmed = "confirmed",
+    Declined = "declined"
+}
+export interface EventPlayerData extends EventPlayerBasicData {
+    joinedAt: Timestamp;
+    rollCalledAt: Timestamp | null;
+    /** @deprecated use rollcall */
+    rollCallStatus?: EventPlayerStatus;
+}
+export interface AEventPlayerData extends EventPlayerData {
+    id: string;
+}

package/models/Evento/Player/types.js

@@ -0,0 +1,8 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.EventPlayerStatus = void 0;
+var EventPlayerStatus;
+(function (EventPlayerStatus) {
+    EventPlayerStatus["Confirmed"] = "confirmed";
+    EventPlayerStatus["Declined"] = "declined";
+})(EventPlayerStatus = exports.EventPlayerStatus || (exports.EventPlayerStatus = {}));

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

@@ -0,0 +1,9 @@
+import * as firestore from '@google-cloud/firestore';
+import Theme from '../../Repertory/basic';
+import { EventRepertoryData } from './types';
+export default class EventoRepertory extends Theme<EventRepertoryData> {
+    constructor(doc: firestore.DocumentSnapshot);
+    get createdAt(): firestore.Timestamp;
+    get eventId(): string;
+    get isActive(): boolean;
+}

package/models/Evento/Repertory/index.js

@@ -0,0 +1,22 @@
+"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("../../Repertory/basic"));
+class EventoRepertory extends basic_1.default {
+    constructor(doc) {
+        super(doc);
+    }
+    get createdAt() {
+        return this.data.createdAt;
+    }
+    get eventId() {
+        return get_1.default(this.ref, 'parent.parent.id');
+    }
+    get isActive() {
+        return this.exists;
+    }
+}
+exports.default = EventoRepertory;

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

@@ -0,0 +1,5 @@
+import { Timestamp } from '@google-cloud/firestore';
+import { ThemeBasicData } from '../../Repertory/types';
+export interface EventRepertoryData extends ThemeBasicData {
+    createdAt: Timestamp;
+}

package/models/Evento/Repertory/types.js

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

package/models/Evento/basic.d.ts

@@ -0,0 +1,22 @@
+import { DocumentSnapshot } from '@google-cloud/firestore';
+import { LanguagesTypes } from '../../lang';
+import Model from '../Model';
+import { EventBasicData, EventTinyData, EventType } from './types';
+export default class EventoBasic<D> extends Model<EventBasicData & D> {
+    protected lang: LanguagesTypes;
+    constructor(doc: DocumentSnapshot, lang: LanguagesTypes);
+    get tinyInfo(): EventTinyData;
+    get basicInfo(): EventBasicData;
+    get displayName(): string | null;
+    get title(): string;
+    get type(): EventType;
+    get isPractice(): boolean;
+    get isPerformance(): boolean;
+    get locality(): string | null;
+    get online(): boolean;
+    get datetime(): FirebaseFirestore.Timestamp;
+    get datetimeEnd(): FirebaseFirestore.Timestamp;
+    get duration(): number;
+    get isOutDate(): boolean;
+    get isHappening(): boolean;
+}

package/models/Evento/basic.js

@@ -0,0 +1,72 @@
+"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 lang_1 = require("../../lang");
+const Model_1 = __importDefault(require("../Model"));
+const types_1 = require("./types");
+class EventoBasic extends Model_1.default {
+    constructor(doc, lang) {
+        super(doc);
+        this.lang = lang;
+    }
+    get tinyInfo() {
+        return {
+            displayName: this.displayName,
+            datetime: this.datetime,
+            type: this.type,
+        };
+    }
+    get basicInfo() {
+        return {
+            displayName: this.displayName,
+            locality: this.locality,
+            online: this.online,
+            datetime: this.datetime,
+            datetimeEnd: this.datetimeEnd,
+            type: this.type,
+        };
+    }
+    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 locality() {
+        return this.data.locality;
+    }
+    get online() {
+        return this.data.online || false;
+    }
+    get datetime() {
+        return this.data.datetime;
+    }
+    get datetimeEnd() {
+        return this.data.datetimeEnd;
+    }
+    get duration() {
+        return this.datetimeEnd.seconds - this.datetime.seconds;
+    }
+    get isOutDate() {
+        return date_fns_1.isPast(this.datetimeEnd.toDate());
+    }
+    get isHappening() {
+        return date_fns_1.isPast(this.datetime.toDate()) && date_fns_1.isFuture(this.datetimeEnd.toDate());
+    }
+}
+exports.default = EventoBasic;