robbyson-frontend-library 0.0.1 → 1.0.1

package/src/models/theme-base.ts

@@ -0,0 +1,403 @@
+class ThemeBaseColors {
+    primary1: string;
+    primary2: string;
+    secondary1: string;
+    secondary2: string;
+    secondary3: string;
+    secondary4: string;
+    brand1: string;
+    brand2: string;
+    hover1: string;
+    solidBackground: string;
+    gradientBackground: string;
+    levels: {
+        shade100: string;
+        shade75: string;
+        shade50: string;
+        shade25: string;
+        radialGradient: string;
+    }[];
+    neutral90: string;
+    neutral80: string;
+    neutral70: string;
+    neutral60: string;
+    neutral50: string;
+    neutral40: string;
+    neutral30: string;
+    neutral20: string;
+    neutral10: string;
+    neutral0: string;
+    successes: {
+        text: string;
+        hover: string;
+        dark: string;
+        default: string;
+        light: string;
+        background: string;
+    };
+    errors: {
+        text: string;
+        hover: string;
+        dark: string;
+        default: string;
+        light: string;
+        background: string;
+    };
+    warnings: {
+        text: string;
+        hover: string;
+        dark: string;
+        default: string;
+        light: string;
+        background: string;
+    };
+    itemsTags: {
+        experience: {
+            text: string;
+            background: string;
+        };
+        physical: {
+            text: string;
+            background: string;
+        };
+        auction: {
+            text: string;
+            background: string;
+        };
+        raffle: {
+            text: string;
+            background: string;
+        };
+        crowdfunding: {
+            text: string;
+            background: string;
+        };
+        voucher: {
+            text: string;
+            background: string;
+        };
+    };
+    complementary: {
+        agendaReminder: string;
+        angelGodson: string;
+        angelGodfather: string;
+    };
+}
+
+export const ICON_HANDLES = [
+    "active-bold",
+    "active-thin",
+    "avatar-login",
+    "add-challenge-bold",
+    "add-challenge-thin",
+    "add-notification-bold",
+    "add-notification-thin",
+    "add-quiz-bold",
+    "add-quiz-thin",
+    "angel-friend-add-bold",
+    "angel-friend-add-thin",
+    "angel-friend-bold",
+    "angel-friend-thin",
+    "attachment-bold",
+    "attachment-thin",
+    "auction-bold",
+    "auction-thin",
+    "available-bold",
+    "available-thin",
+    "broadcast-bold",
+    "broadcast-thin",
+    "calendar-bold",
+    "calendar-thin",
+    "camera-bold",
+    "camera-thin",
+    "cancel-bold",
+    "cancel-thin",
+    "challenge-bold",
+    "challenge-thin",
+    "chat-bold",
+    "chatbot-bold",
+    "chatbot-thin",
+    "chat-fil-bold",
+    "chat-fill-thin",
+    "chat-smile-bold",
+    "chat-smile-thin",
+    "chat-thin",
+    "check-bold",
+    "check-thin",
+    "chocolate-menu",
+    "chronometer-bold",
+    "chronometer-thin",
+    "clock-bold",
+    "clock-thin",
+    "close-bold",
+    "close-thin",
+    "cloud-bold",
+    "cloud-thin",
+    "coin-bold",
+    "coin-thin",
+    "column-view-active-bold",
+    "column-view-active-thin",
+    "column-view-bold",
+    "column-view-thin",
+    "contacts-bold",
+    "contacts-thin",
+    "delete-bold",
+    "delete-thin",
+    "documents-bold",
+    "documents-thin",
+    "down-arrow",
+    "download-bold",
+    "download-thin",
+    "downward-arrow-bold",
+    "downward-arrow-thin",
+    "duplicate-bold",
+    "duplicate-thin",
+    "eagle-bold",
+    "eagle-thin",
+    "edit-bold",
+    "edit-thin",
+    "emoji-bold",
+    "emoji-thin",
+    "family-bold",
+    "family-thin",
+    "filter-active-bold",
+    "filter-active-thin",
+    "filter-inactive-bold",
+    "filter-inactive-thin",
+    "filter",
+    "forward-bold",
+    "forward-thin",
+    "goal-bold",
+    "goal-thin",
+    "grid-view-active-bold",
+    "grid-view-active-thin",
+    "grid-view-bold",
+    "grid-view-thin",
+    "group-bold",
+    "group-brackets-bold",
+    "group-brackets-thin",
+    "group-fill-bold",
+    "group-fill-thin",
+    "group-thin",
+    "guide-bold",
+    "guide-thin",
+    "health-bold",
+    "health-thin",
+    "heart-bold",
+    "heart-fill-bold",
+    "heart-fill-thin",
+    "heart-thin",
+    "humor-bold",
+    "humor-thin",
+    "inactive-bold",
+    "inactive-thin",
+    "indicator-bold",
+    "indicator-thin",
+    "info-bold",
+    "info-thin",
+    "integration-bold",
+    "integration-thin",
+    "learning-bold",
+    "learning-thin",
+    "leave-bold",
+    "leave-thin",
+    "left-arrow-large",
+    "left-arrow-small",
+    "like-bold",
+    "like-fill-bold",
+    "like-fill-thin",
+    "like-thin",
+    "magnifying-glass-bold",
+    "magnifying-glass-thin",
+    "minus",
+    "more-vert",
+    "mountain-bold",
+    "mountain-thin",
+    "new-document-bold",
+    "new-document-thin",
+    "new-tip-thin-1",
+    "new-tip-thin",
+    "notification-bold",
+    "notification-thin",
+    "objetive-bold",
+    "objetive-thin",
+    "order-bold-1",
+    "order-bold",
+    "order-thin-1",
+    "order-thin",
+    "performance-bold",
+    "performance-thin",
+    "phone-bold",
+    "phone-thin",
+    "plus",
+    "quiz-bold",
+    "quiz-thin",
+    "raffle-bold",
+    "raffle-draw-bold",
+    "raffle-draw-thin",
+    "raffle-thin",
+    "relationship-bold",
+    "relationship-thin",
+    "reports-bold",
+    "reports-thin",
+    "right-arrow-large",
+    "right-arrow-small",
+    "send-bold",
+    "send-thin",
+    "settings-bold",
+    "settings-thin",
+    "star-bold",
+    "star-thin",
+    "store-bold",
+    "store-item-bold",
+    "store-item-thin",
+    "store-thin",
+    "tag-bold",
+    "tag-thin",
+    "test-bold",
+    "test-thin",
+    "tips-bold",
+    "tips-thin",
+    "tree-bold",
+    "tree-thin",
+    "trophy-bold",
+    "trophy-thin",
+    "up-arrow",
+    "upload-bold",
+    "upload-thin",
+    "upward-arrow-bold",
+    "upward-arrow-thin",
+    "user-bold",
+    "user-thin",
+    "variable-pay-bold",
+    "variable-pay-thin",
+    "view-bold",
+    "view-thin",
+    "not-view-thin",
+    "not-view-bold",
+    "work-bold",
+    "working",
+    "work-thin",
+    "no-results-found",
+    "not-found-bold",
+    "hamburger-menu",
+    "cloud-circle",
+    "mountain-circle",
+    "star-circle",
+    "expand-image-bold",
+    "camera-off-bold",
+    "minimize-image-bold",
+    "phone-call-bold",
+    "microphone-bold",
+    "microphone-off-bold",
+    "share-screen-bold",
+    "ead-play-button",
+    "tag-left-triangle",
+] as const;
+
+export type IconHandle = (typeof ICON_HANDLES)[number];
+
+class ThemeBaseRect {
+    top: string;
+    right: string;
+    bottom: string;
+    left: string;
+}
+
+class ThemeTypography {
+    fontFamily: string; // font-family
+    size: string; // size
+    textTransform: string; //text-transform
+    letterSpacing: string; //letter-spacing
+    lineHeight: string; //line-height
+    fontWeight: string; //font-weight
+    textDecoration: string; //text-decoration
+}
+
+class ThemeTransition {
+    transitionPrimary1: string;
+}
+
+class ThemeAssets {
+    src: string;
+    width: string;
+    height: string;
+}
+
+class Typography {
+    profile: ThemeTypography;
+    h1: ThemeTypography;
+    h2: ThemeTypography;
+    h2Bold: ThemeTypography;
+    h3: ThemeTypography;
+    h4: ThemeTypography;
+    h5: ThemeTypography;
+    h6: ThemeTypography;
+    h6Bold: ThemeTypography;
+    subtitle2: ThemeTypography;
+    subtitle1: ThemeTypography;
+    body1Medium: ThemeTypography;
+    body1Book: ThemeTypography;
+    body1BookItalic: ThemeTypography;
+    body1Link: ThemeTypography;
+    body2Medium: ThemeTypography;
+    body2Book: ThemeTypography;
+    body2BookStrikethrough: ThemeTypography;
+    body2BookItalic: ThemeTypography;
+    button: ThemeTypography;
+    chip: ThemeTypography;
+    chipMedium: ThemeTypography;
+    overline: ThemeTypography;
+    small: ThemeTypography;
+    smallMedium: ThemeTypography;
+    toolTip: ThemeTypography;
+}
+
+export class ThemeBase {
+    colors: ThemeBaseColors;
+    fonts: {
+        fontFamily: string; // font-family
+        fontWeight: string; // font-weight
+        fontStyle: string; // font-style
+        src: string; // src
+    }[];
+    transitions: ThemeTransition;
+    typography: Typography;
+    mobileTypography: Typography;
+    assets: {
+        logoText: ThemeAssets;
+        logoComplete: ThemeAssets;
+        logoIcon: ThemeAssets;
+        logoTextNegative: ThemeAssets;
+        logoCompleteNegative: ThemeAssets;
+        logoIconNegative: ThemeAssets;
+        backgroundLogo: ThemeAssets;
+        humorAvatar: ThemeAssets;
+        humorImGoodCircle: ThemeAssets;
+        humorImTopCircle: ThemeAssets;
+        humorImbadCircle: ThemeAssets;
+        logoMobile: ThemeAssets;
+        loginRobbysonAvatar: ThemeAssets;
+        quizThankYouAvatar: ThemeAssets;
+    };
+
+    constructor() {
+        this.colors = new ThemeBaseColors();
+        this.assets = {
+            logoText: new ThemeAssets(),
+            logoComplete: new ThemeAssets(),
+            logoIcon: new ThemeAssets(),
+            logoTextNegative: new ThemeAssets(),
+            logoCompleteNegative: new ThemeAssets(),
+            logoIconNegative: new ThemeAssets(),
+            backgroundLogo: new ThemeAssets(),
+            humorAvatar: new ThemeAssets(),
+            humorImGoodCircle: new ThemeAssets(),
+            humorImTopCircle: new ThemeAssets(),
+            humorImbadCircle: new ThemeAssets(),
+            logoMobile: new ThemeAssets(),
+            loginRobbysonAvatar: new ThemeAssets(),
+            quizThankYouAvatar: new ThemeAssets(),
+        };
+    }
+}

package/src/models/user-list.model.ts

@@ -0,0 +1,26 @@
+import { BaseRepositoryModel } from "./base.repository.model";
+
+export class UserListModel extends BaseRepositoryModel {
+    about: string;
+    accessed: boolean;
+    active: boolean;
+    birthDate: string;
+    email: string;
+    externalKey: string;
+    gender: string;
+    identification: string;
+    loginFailures: number;
+    name: string;
+    nickname: string;
+    passHash: string;
+    phone: string;
+    registered: boolean;
+    robbysonUser_id: number;
+    role_id: number | null;
+    systems: System[];
+    _id: number;
+}
+
+interface System {
+    _id: number;
+  }

package/src/models/user-mirror.model.ts

@@ -0,0 +1,10 @@
+import { BaseRepositoryModel } from "./base.repository.model";
+
+export class UserMirrorModel extends BaseRepositoryModel {
+    beginDate: Date;
+    endDate: Date;
+    identification: string;
+    name: string;
+    user_id: string;
+    _id: string;
+}

package/src/models/{user-session.model.tsx → user-session.model.ts}

@@ -1,4 +1,5 @@
 import { BaseRepositoryModel } from "./base.repository.model";
+import { UserMirrorModel } from "./user-mirror.model";
 
 export class UserSessionModel extends BaseRepositoryModel {
     _id: number;
@@ -97,5 +98,6 @@ export class UserSessionModel extends BaseRepositoryModel {
     login: string;
     system_id: number;
     mirror: boolean;
+    userMirror?: UserMirrorModel;
     SessionKey: string;
-}
+}

package/src/models/user.model.ts

@@ -0,0 +1,21 @@
+import { BaseRepositoryModel } from "./base.repository.model";
+
+export class UserModel extends BaseRepositoryModel {
+    hasAccessed: boolean
+    active: boolean
+    _id: number
+    gender: string
+    name: string
+    summary: string
+    robbyson_user_id: number
+    externalKey: string
+    systems: System[]
+    isRegistered: boolean
+    nickname: string
+    forceAvatarDisplay: boolean
+    phone: string
+}
+
+ interface System {
+    _id: number
+  }

package/src/repositories/agenda.repository.interface.ts

@@ -0,0 +1,26 @@
+import { AgendaModel } from "../models";
+import { AgendaDTO } from "../services";
+
+export interface IAgendaRepository {
+    getUserAppointments(params: {
+        start: string;
+        end: string;
+    }): Promise<AgendaModel[]>;
+
+    getAppointmentDetails(params: { id: string }): Promise<AgendaModel>;
+
+    confirmParticipation(
+        params: { id: string },
+        body: {
+            confirmation: AgendaModel["confirmation"];
+        }
+    ): Promise<void>;
+
+    cancelAppointment(params: { id: string }): Promise<void>;
+
+    insertAppointment(
+        params: AgendaDTO.IInsertAppointmentDTO
+    ): Promise<string>;
+
+    updateAppointment(params: AgendaDTO.IUpdateAppointmentDTO): Promise<void>;
+}

package/src/repositories/angel-friend.repository.interface.ts

@@ -0,0 +1,5 @@
+import { AngelFriendStatusModel } from "../models";
+
+export interface IAngelFriendRepository {
+    getAngelFriendStatus(_id: number): Promise<AngelFriendStatusModel>;
+}

package/src/repositories/authentication.repository.interface.ts

@@ -0,0 +1,14 @@
+import { UserSessionModel, SendUserToAuthModel } from "../models";
+
+export interface IAuthenticationRepository {
+    auth({
+        login,
+        password,
+        system_id,
+        recaptchaResponse,
+        timeZone,
+    }: SendUserToAuthModel): Promise<UserSessionModel>;
+
+    getRecaptchaWhiteListed(): Promise<boolean>;
+  
+}

package/src/repositories/base.repository.ts

@@ -0,0 +1,139 @@
+import axios, { AxiosInstance, AxiosRequestConfig } from 'axios';
+import moment from 'moment';
+import { CacheConfig, CacheControl, Cache } from '../utils';
+import sha1 from 'crypto-js/sha1';
+import { GlobalStore, IGlobalStore } from 'redux-micro-frontend';
+import { IPlatformState } from '../states';
+import { ResponseFactory } from '../factories';
+
+export class BaseRepository {
+
+    protected _axioInstance: AxiosInstance;
+    private static _sessionKey: string = "";
+    private static _systemId: number = 1;
+    private static _baseURL: string = "";
+    private static _source: any;
+
+    private static _globalStore: IGlobalStore;
+    private static _globalState: IPlatformState;
+
+    public constructor() {
+        this._axioInstance = axios.create({
+            headers: {
+                Accept: 'application/json',
+                'Content-Type': 'application/json',
+            },
+        });
+        BaseRepository.updateGlobalState();
+        this.configure();
+    }
+
+    protected static updateGlobalState() {
+        BaseRepository._globalStore = GlobalStore.Get();
+        BaseRepository._globalState = BaseRepository._globalStore.GetGlobalState();
+    }
+
+    protected async get<T>(url: string, config?: CacheConfig): Promise<T> {
+        if (config && config.cache) {
+            return new Promise(async (resolve, reject) => {
+                try {
+
+                    const key: string = sha1(
+                        url + JSON.stringify(config.params),
+                    ).toString();
+
+                    const { expire, value }: Cache =
+                        (await CacheControl.getCache(key)) || {};
+
+                    const isExpired: boolean = moment().isSameOrAfter(
+                        moment(expire),
+                    );
+
+                    if (value && !isExpired) {
+                        console.log('RECOVERED FROM CACHE', url);
+                        return setTimeout(
+                            () => resolve(value),
+                            config.delayOnCache || 0,
+                        );
+                    }
+
+                    const response = ResponseFactory.Create<T>(await this._axioInstance.get(url, config));
+                    console.log('SENT REQUEST', url);
+                    CacheControl.setCache(
+                        key,
+                        response,
+                        config.maxAge || [0, 'seconds'],
+                        config.type,
+                    );
+                    return setTimeout(
+                        () => resolve(response),
+                        config.delayOnCache || 0,
+                    );
+                } catch (error) {
+                    console.log('====================> ERROR CACHE', error);
+                    reject(error);
+                }
+            });
+        }
+        return ResponseFactory.Create<T>(await this._axioInstance.get(url, config));
+    }
+
+    protected async post<T>(url: string, data: any, config?: AxiosRequestConfig): Promise<T> {
+        return ResponseFactory.Create<T>( await this._axioInstance.post(url, data, config));
+    }
+
+    protected async delete<T>(url: string, data: any, config?: AxiosRequestConfig): Promise<T> {
+        return ResponseFactory.Create<T>(await this._axioInstance.delete(url, config));
+    }
+
+    protected async put<T>(url: string, data: any, config?: AxiosRequestConfig): Promise<T> {
+        return ResponseFactory.Create<T>(await this._axioInstance.put(url, data, config));
+    }
+
+    protected async patch<T>(url: string, data: any, config?: AxiosRequestConfig): Promise<T> {
+        return ResponseFactory.Create<T>(await this._axioInstance.patch(url, data, config));
+    }
+
+    public configure() {
+        this._axioInstance.interceptors.request.clear();
+        this._axioInstance.interceptors.request.use(
+            this.axioConfigurationMiddleware,
+            error => Promise.reject(error),
+        );
+        this._axioInstance.interceptors.response.use((res) => {
+            return res
+        }, (err) => {
+            Promise.reject(ResponseFactory.Create<any>(err))
+        })
+    }
+
+    public axioConfigurationMiddleware(config: any) {
+        BaseRepository.updateGlobalState();
+
+        config.url = `${BaseRepository._globalState.Global.RootApp.apisUrls.private}${config.url}`;
+        if (BaseRepository._source && BaseRepository._source.token) {
+            config.cancelToken = BaseRepository._source.token;
+        }
+
+        const sessionKey = BaseRepository._globalState.Global.RootApp.userSession?.SessionKey;
+        
+        if (sessionKey) {
+            config.headers.SessionKey = sessionKey;
+        }
+
+        config.headers['x-system-id'] = BaseRepository._systemId;
+
+        return config;
+    }
+
+    protected createAxiosCancelationContext(): void {
+        BaseRepository._source = axios.CancelToken.source();
+    }
+
+    protected cancelAxiosRequest(): void {
+        if (BaseRepository._source) {
+            BaseRepository._source.cancel();
+            BaseRepository._source = null;
+        }
+    }
+}

package/src/repositories/chat.repository.interface.ts

@@ -0,0 +1,10 @@
+import { ChatModel } from "../models";
+import { ChatDTO, UserDTO } from "../services";
+
+export interface IChatRepository {
+    getConversations(params: ChatDTO.IGetConversationDTO): Promise<ChatModel[]>;
+    createConversation(params: ChatDTO.ICreateConversationDTO): Promise<ChatModel>;
+    addUsersToConversation(conversationId: string, users: UserDTO.GetUserDTO[]): Promise<void>;
+    deleteConversation(conversationId: string): Promise<void>;
+    removeUserFromConversation(conversationId: string, robbysonUserId: number): Promise<void>;
+}

package/src/repositories/configuration.repository.interface.ts

@@ -0,0 +1,5 @@
+export interface IConfigurationRepository {
+    getResizableImageURL(imageName: string, dimension: number): string;
+    getOriginalImageURL(imageName: string): string;
+    getBaseURL(): string;
+}

package/src/repositories/document.repository.interface.ts

@@ -0,0 +1,17 @@
+import { DocumentModel } from "../models";
+
+export interface IDocumentRepository {
+    getUnansweredDocuments(): Promise<{
+        items: Array<DocumentModel>;
+        numTotalItems: number;
+    }>;
+    updateDocument(
+        id: string,
+        data: {
+            answered?: boolean;
+            accepted?: boolean;
+            observation?: string;
+            viewed?: boolean;
+        }
+    ): Promise<void>;
+}