robbyson-frontend-library 1.0.2 → 1.0.3

package/src/models/update-password.model.ts

@@ -0,0 +1,5 @@
+export class UpdatePasswordModel {
+    currentPassword: string;
+    newPassword: string;
+    confirmPassword: string;
+}

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

@@ -87,6 +87,7 @@ export class UserSessionModel extends BaseRepositoryModel {
         embeddedThirdPartyRv: boolean,
         chatSendFiles: boolean,
         chatMaxSizeFile?: number
+        enableVariableIncomes?: boolean,
     };
     UsuarioAceitouTermoUsoAtual: boolean;
     isAcceptedLastUseTerm: boolean;

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

@@ -1,4 +1,10 @@
-import { UserSessionModel, SendUserToAuthModel } from "../models";
+import {
+    UserSessionModel,
+    SendUserToAuthModel,
+    GetUserToRegisterModel,
+    SendUserToRegisterModel,
+    UpdatePasswordModel
+} from "../models";
 
 export interface IAuthenticationRepository {
     auth({
@@ -10,5 +16,12 @@ export interface IAuthenticationRepository {
     }: SendUserToAuthModel): Promise<UserSessionModel>;
 
     getRecaptchaWhiteListed(): Promise<boolean>;
-  
-}
+    getUserToRegister(params: {
+        identification: string;
+        birthDate: Date;
+        recaptcha: string;
+    }): Promise<GetUserToRegisterModel>;
+    sendUserToRegister(params: SendUserToRegisterModel): Promise<void>;
+
+    changePassword(data: UpdatePasswordModel): Promise<UserSessionModel>;
+}

package/src/repositories/base.repository.ts

@@ -1,17 +1,16 @@
-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';
+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 = "";
+    protected _apiURL: string = "";
     private static _source: any;
 
     private static _globalStore: IGlobalStore;
@@ -20,91 +19,125 @@ export class BaseRepository {
     public constructor() {
         this._axioInstance = axios.create({
             headers: {
-                Accept: 'application/json',
-                'Content-Type': 'application/json',
+                Accept: "application/json",
+                "Content-Type": "application/json",
             },
         });
         BaseRepository.updateGlobalState();
         this.configure();
+        this._apiURL = BaseRepository._globalState.Global.RootApp.apisUrls.private;
     }
 
     protected static updateGlobalState() {
         BaseRepository._globalStore = GlobalStore.Get();
-        BaseRepository._globalState = BaseRepository._globalStore.GetGlobalState();
+        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),
+                        url + JSON.stringify(config.params)
                     ).toString();
+                    const hasCache = await CacheControl.hasCache();
+                    if (hasCache) {
+                        const { expire, value }: Cache =
+                            (await CacheControl.getCache(key)) || {};
 
-                    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 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(
+                    const response = ResponseFactory.Create<T>(
+                        await this._axioInstance.get(url, config)
+                    );
+                    console.log("SENT REQUEST", url);
+                    await CacheControl.setCache(
                         key,
                         response,
-                        config.maxAge || [0, 'seconds'],
-                        config.type,
+                        config.maxAge || [0, "seconds"],
+                        config.type
                     );
                     return setTimeout(
                         () => resolve(response),
-                        config.delayOnCache || 0,
+                        config.delayOnCache || 0
                     );
                 } catch (error) {
-                    console.log('====================> ERROR CACHE', error);
+                    console.log("====================> ERROR CACHE", error);
                     reject(error);
                 }
             });
         }
-        return ResponseFactory.Create<T>(await this._axioInstance.get(url, config));
+        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 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 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 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));
+    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),
+            (error) => Promise.reject(error)
+        );
+        this._axioInstance.interceptors.response.use(
+            (res) => {
+                return res;
+            },
+            (err) => {
+                Promise.reject(ResponseFactory.Create<any>(err));
+            }
         );
-        this._axioInstance.interceptors.response.use((res) => {
-            return res
-        }, (err) => {
-            Promise.reject(ResponseFactory.Create<any>(err))
-        })
     }
 
     public axioConfigurationMiddleware(config: any) {
@@ -115,13 +148,14 @@ export class BaseRepository {
             config.cancelToken = BaseRepository._source.token;
         }
 
-        const sessionKey = BaseRepository._globalState.Global.RootApp.userSession?.SessionKey;
-        
+        const sessionKey =
+            BaseRepository._globalState.Global.RootApp.userSession?.SessionKey;
+
         if (sessionKey) {
             config.headers.SessionKey = sessionKey;
         }
 
-        config.headers['x-system-id'] = BaseRepository._systemId;
+        config.headers["x-system-id"] = BaseRepository._systemId;
 
         return config;
     }
@@ -136,4 +170,4 @@ export class BaseRepository {
             BaseRepository._source = null;
         }
     }
-}
+}

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

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

package/src/repositories/index.d.ts

@@ -13,3 +13,4 @@ export * from "./humor.repository.interface";
 export * from "./document.repository.interface";
 export * from "./quiz.repository.interface";
 export * from "./configuration.repository.interface";
+export * from './profile.repository.interface'

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

@@ -0,0 +1,7 @@
+import { ProfileImageModel } from "../models";
+import { ProfileDTO } from "../services";
+export interface IProfileRepository {
+    getProfileImage(
+        getProfileImageDto: ProfileDTO.IGetProfileImageDTO
+    ): Promise<ProfileImageModel>;
+}

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

@@ -1,21 +1,21 @@
-import { UserDTO } from "../services";
+import { UserDTO, ProfileDTO } from "../services";
 import { UserListModel, UserMirrorModel, UserModel } from "../models";
 
 export interface IUserRepository {
-
     getUser(id: number): Promise<UserModel>;
-    
+
     getUsers(body: {
         filter: {
-            robbyson_user_id: number[],
-        },
+            robbyson_user_id: number[];
+        };
         pagination: {
-            limit: number,
-        },
+            limit: number;
+        };
     }): Promise<any>;
 
     getUserMirror(id: number): Promise<UserMirrorModel>;
 
     getUserList(params: UserDTO.IGetUserListDTO): Promise<UserListModel[]>;
-    
-}
+
+    updateProfile(data: ProfileDTO.IUpdateProfileDTO): Promise<UserModel>;
+}

package/src/services/authentication.service.interface.ts

@@ -1,5 +1,4 @@
-import { SendUserToAuthModel, UserSessionModel } from "../models";
-
+import { SendUserToAuthModel, UserSessionModel, SendUserToRegisterModel, GetUserToRegisterModel, UpdatePasswordModel } from "../models";
 export interface IAuthenticationService {
     auth({
         login,
@@ -10,10 +9,14 @@ export interface IAuthenticationService {
 
     getLoggedUser(): UserSessionModel;
     checkSession(): boolean;
-    getUserSession(): UserSessionModel | undefined
+    getUserSession(): UserSessionModel | undefined;
     clearSession(): void;
     ipWhiteList(): boolean;
     clearIpWhiteList(): void;
     logout(): void;
     getRecaptchaWhiteListed(): Promise<void>;
-}
+    getUserToRegister(params: {identification: string, birthDate: Date, recaptcha: string}): Promise<GetUserToRegisterModel>;
+    sendUserToRegister(params: SendUserToRegisterModel): Promise<void>;
+    changePassword(data: UpdatePasswordModel): Promise<UserSessionModel>;
+    userHasRV(): boolean;
+}

package/src/services/dtos/index.ts

@@ -4,3 +4,4 @@ export * as AgendaDTO from "./agenda.dto";
 export * as ChatDTO from "./chat.dto";
 export * as UserDTO from "./user.dto";
 export * as FriendshipDTO from "./friendship.dto";
+export * as ProfileDTO from "./profile.dto";

package/src/services/dtos/profile.dto.ts

@@ -0,0 +1,9 @@
+export interface IUpdateProfileDTO {
+    nickname?: string;
+    about?: string;
+}
+
+export interface IGetProfileImageDTO {
+    user_id: number;
+    identification: string;
+}

package/src/services/index.d.ts

@@ -14,4 +14,6 @@ export * from "./dtos";
 export * from "./agenda.service.interface";
 export * from "./chat.service.interface";
 export * from "./friendship.service.interface";
+export * from "./profile.service.interface";
 export * from "./tree.service.interface";
+export * from "./upload.service.interface";

package/src/services/profile.service.interface.ts

@@ -0,0 +1,8 @@
+import { ProfileImageModel } from "../models";
+import { ProfileDTO } from "./dtos";
+
+export interface IProfileService {
+    getProfileImage(
+        getProfileImageDto: ProfileDTO.IGetProfileImageDTO
+    ): Promise<ProfileImageModel>;
+}

package/src/services/upload.service.interface.ts

@@ -0,0 +1,12 @@
+import { UploadConstants } from "../constants";
+    
+export interface IUploadService {
+    getResizableImageURL(
+        imageName: string,
+        mode?: UploadConstants.EImageMode,
+        anchor?: UploadConstants.EImageAnchor,
+        width?: number,
+        height?: number
+    ): string;
+    getRawFileUrl(imageName: string): string;
+}

package/src/services/user.service.interface.ts

@@ -1,5 +1,5 @@
 import { UserListModel, UserMirrorModel, UserModel } from "../models";
-import { UserDTO } from "./dtos";
+import { UserDTO, ProfileDTO } from "./dtos";
 
 export interface IUserService {
     getUser(id: number): Promise<UserModel>;
@@ -16,4 +16,6 @@ export interface IUserService {
     getUserMirror(_id: number): Promise<UserMirrorModel>;
 
     getUserList(params: UserDTO.IGetUserListDTO): Promise<UserListModel[]>;
+
+    updateProfile(data: ProfileDTO.IUpdateProfileDTO): Promise<UserModel>;
 }

package/src/utils/{cache-control.tsx → cache-control.ts}

@@ -1,5 +1,5 @@
 import { AxiosRequestConfig } from 'axios';
-import { LOCALSTORAGE, config, createInstance } from 'localforage';
+import localforage from 'localforage';
 import moment, { DurationInputArg1, DurationInputArg2 } from 'moment';
 
 export type MaxAge = [DurationInputArg1, DurationInputArg2];
@@ -12,7 +12,7 @@ export interface CacheConfig extends AxiosRequestConfig {
 export type Cache = {
     expire: string;
     value: any
-};
+};          
 
 export class CacheControl {
 
@@ -20,17 +20,16 @@ export class CacheControl {
 
     static getDbInstance(): LocalForage {
         if (!CacheControl.dbInstance) {
-            config({
-                driver: LOCALSTORAGE,
+            localforage.config({
+                driver: localforage.LOCALSTORAGE,
                 name: 'Robbyson',
                 version: 1,
                 storeName: 'CacheControl',
             });
             const userAuth = JSON.parse(sessionStorage.getItem('persist:auth') || '{}').data;
             const user = JSON.parse(userAuth || '{}');
-
-            CacheControl.dbInstance = createInstance({
-                name: `cache-${user._id.toString()}`,
+            CacheControl.dbInstance = localforage.createInstance({
+                name: `cache-${user._id}`,
             });
         }
         return CacheControl.dbInstance;
@@ -41,7 +40,7 @@ export class CacheControl {
         return this.getDbInstance().getItem(key);
     }
 
-    static setCache(key: string, value: any, maxAge: MaxAge, type = ''): void {
+    static async setCache(key: string, value: any, maxAge: MaxAge, type = ''): Promise<void> {
         const now = moment();
         const data: any = {
             value,
@@ -52,7 +51,7 @@ export class CacheControl {
                 .toDate()
                 .toISOString(),
         };
-        this.getDbInstance().setItem(key, data);
+        await this.getDbInstance().setItem(key, data);
     }
 
     static async hasCache(): Promise<number> {

package/src/utils/index.ts

@@ -1,8 +1,9 @@
-export * from './build-error/buildError.util.interface';
-export * from './build-error/buildError.util';
-export * from './query-params'
-export * from './cache-control'
+export * from "./build-error/buildError.util.interface";
+export * from "./build-error/buildError.util";
+export * from "./query-params";
+export * from "./cache-control";
 export * from "./robbyson-navigate";
 export * from "./layout.utils";
 export * from "./date.utils";
+export * from "./resize-image";
 export * from "./timer.utils";

package/src/utils/resize-image.ts

@@ -0,0 +1,74 @@
+function createImage(url: string): Promise<HTMLImageElement> {
+    return new Promise(function (resolve, reject) {
+        const image = new Image();
+        image.addEventListener("load", function () {
+            resolve(image);
+        });
+        image.addEventListener("error", function (error) {
+            reject(error);
+        });
+        image.setAttribute("crossOrigin", "anonymous");
+        image.src = url;
+    });
+}
+
+export async function getCroppedImg(
+    imageSrc: string,
+    pixelCrop: { x: number; y: number; width: number; height: number },
+    flip: { horizontal: boolean; vertical: boolean } = {
+        horizontal: false,
+        vertical: false,
+    },
+    type: string = "base64"
+): Promise<string | null> {
+    const image = await createImage(imageSrc);
+    const canvas = document.createElement("canvas");
+    const ctx = canvas.getContext("2d");
+
+    if (!ctx) {
+        return null;
+    }
+
+    canvas.width = image.width;
+    canvas.height = image.height;
+
+    ctx.translate(image.width / 2, image.height / 2);
+    ctx.scale(flip.horizontal ? -1 : 1, flip.vertical ? -1 : 1);
+    ctx.translate(-image.width / 2, -image.height / 2);
+    ctx.drawImage(image, 0, 0);
+
+    const croppedCanvas = document.createElement("canvas");
+    const croppedCtx = croppedCanvas.getContext("2d");
+
+    if (!croppedCtx) {
+        return null;
+    }
+
+    croppedCanvas.width = pixelCrop.width;
+    croppedCanvas.height = pixelCrop.height;
+    croppedCtx.drawImage(
+        canvas,
+        pixelCrop.x,
+        pixelCrop.y,
+        pixelCrop.width,
+        pixelCrop.height,
+        0,
+        0,
+        pixelCrop.width,
+        pixelCrop.height
+    );
+
+    if (type === "blob") {
+        return new Promise(function (resolve, reject) {
+            croppedCanvas.toBlob(function (file) {
+                if (file) {
+                    resolve(URL.createObjectURL(file));
+                } else {
+                    reject(new Error("Blob generation failed"));
+                }
+            }, "image/png");
+        });
+    }
+
+    return croppedCanvas.toDataURL("image/png");
+}

package/typedoc.json

@@ -0,0 +1,6 @@
+{
+    "out": "./docs",
+    "entryPoints": [
+        "./src/**/*.ts"
+    ],
+}