@alba-cars/common-modules 1.7.8 → 1.8.0

package/dist/core/network/endpoint-config.d.ts

@@ -54,6 +54,7 @@ type APIEndpointType = {
     googleReview: BaseEndpoint;
     tickets: BaseEndpoint;
     user: BaseEndpoint;
+    faq: BaseEndpoint;
 };
 export declare const API_ENDPOINTS: APIEndpointType;
 export declare const UTIL_ENDPOINTS: {

package/dist/core/network/endpoint-config.js

@@ -203,6 +203,13 @@ exports.API_ENDPOINTS = {
         deleteOne: (id) => `/tickets/${id}`,
         updateOne: (id) => `/tickets/${id}`,
     },
+    faq: {
+        getAll: `/faqs`,
+        create: `/faqs`,
+        getOne: (id) => `/faqs/${id}`,
+        deleteOne: (id) => `/faqs/${id}`,
+        updateOne: (id) => `/faqs/${id}`,
+    }
 };
 exports.UTIL_ENDPOINTS = {
     media: {

package/dist/features/auth/data/dto/UserDTO.d.ts

@@ -51,6 +51,7 @@ export declare class UserFilterDTO {
     email?: string | string[];
     name?: string | string[];
     phone?: string | string[];
+    isPhoneNumberVerified?: boolean;
     roles?: Role[];
     isActive?: boolean;
     fromDate?: Date;

package/dist/features/auth/data/dto/UserDTO.js

@@ -165,6 +165,11 @@ __decorate([
     (0, class_validator_1.IsString)({ each: true }),
     __metadata("design:type", Object)
 ], UserFilterDTO.prototype, "phone", void 0);
+__decorate([
+    (0, class_validator_1.IsOptional)(),
+    (0, class_validator_1.IsBoolean)(),
+    __metadata("design:type", Boolean)
+], UserFilterDTO.prototype, "isPhoneNumberVerified", void 0);
 __decorate([
     (0, class_validator_1.IsOptional)(),
     (0, class_validator_1.IsArray)(),

package/dist/features/faq/data/dtos/FaqFetchDTO.d.ts

@@ -0,0 +1,101 @@
+import { FaqCategory } from "../enums";
+export declare class MultilingualContentFetch {
+    en: string;
+    ar: string;
+    ru: string;
+    zh: string;
+    toPlain(): {
+        en: string;
+        ar: string;
+        ru: string;
+        zh: string;
+    };
+    static fromPlain(plain: any): MultilingualContentFetch;
+}
+export declare class FaqFilterDTO {
+    search?: string;
+    searchLanguage?: 'en' | 'ar' | 'ru' | 'zh';
+    searchInAnswers?: boolean;
+    category?: FaqCategory;
+    isActive?: boolean;
+    constructor(init?: Partial<FaqFilterDTO>);
+    validate(shouldValidate?: boolean): string[];
+    static fromPlain(plain: any): FaqFilterDTO;
+    static toPlain(instance: FaqFilterDTO): Record<string, unknown>;
+}
+export declare class FaqOptionsDTO {
+    page: number;
+    limit: number;
+    sort?: {
+        field: string;
+        direction: 'asc' | 'desc';
+    };
+    constructor(init?: Partial<FaqOptionsDTO>);
+    validate(shouldValidate?: boolean): string[];
+    static toPlain(instance: FaqOptionsDTO): Record<string, any>;
+    static fromPlain(plain: any): FaqOptionsDTO;
+}
+export declare class FaqFetchDTO {
+    filter?: FaqFilterDTO;
+    options?: FaqOptionsDTO;
+    static fromPlain(plain: any): FaqFetchDTO;
+    constructor(init?: Partial<FaqFetchDTO>);
+    static toPlain(instance: FaqFetchDTO): Record<string, unknown>;
+}
+export declare class FaqResponseDTO {
+    id: string;
+    question: MultilingualContentFetch;
+    answer: MultilingualContentFetch;
+    category: string;
+    isActive: boolean;
+    order: number;
+    createdAt: string;
+    updatedAt: string;
+    toPlain(): {
+        id: string;
+        question: {
+            en: string;
+            ar: string;
+            ru: string;
+            zh: string;
+        };
+        answer: {
+            en: string;
+            ar: string;
+            ru: string;
+            zh: string;
+        };
+        category: string;
+        isActive: boolean;
+        order: number;
+        createdAt: string;
+        updatedAt: string;
+    };
+    static fromPlain(plain: Record<string, any>): FaqResponseDTO;
+    validate(): string[];
+}
+export interface FaqApiResponse {
+    success: boolean;
+    message?: string;
+    error?: {
+        message: string;
+        code?: string;
+        details?: Record<string, any>;
+    };
+    data?: FaqResponseDTO;
+}
+export interface FaqListApiResponse {
+    success: boolean;
+    message?: string;
+    error?: {
+        message: string;
+        code?: string;
+        details?: Record<string, any>;
+    };
+    data?: {
+        items: FaqResponseDTO[];
+        total: number;
+        page: number;
+        limit: number;
+    };
+}

package/dist/features/faq/data/dtos/FaqFetchDTO.js

@@ -0,0 +1,348 @@
+"use strict";
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var __metadata = (this && this.__metadata) || function (k, v) {
+    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FaqResponseDTO = exports.FaqFetchDTO = exports.FaqOptionsDTO = exports.FaqFilterDTO = exports.MultilingualContentFetch = void 0;
+const class_transformer_1 = require("class-transformer");
+const class_validator_1 = require("class-validator");
+const enums_1 = require("../enums");
+class MultilingualContentFetch {
+    toPlain() {
+        return {
+            en: this.en,
+            ar: this.ar,
+            ru: this.ru,
+            zh: this.zh
+        };
+    }
+    static fromPlain(plain) {
+        const content = new MultilingualContentFetch();
+        content.en = plain.en;
+        content.ar = plain.ar;
+        content.ru = plain.ru;
+        content.zh = plain.zh;
+        return content;
+    }
+}
+__decorate([
+    (0, class_validator_1.IsNotEmpty)(),
+    (0, class_validator_1.IsString)(),
+    __metadata("design:type", String)
+], MultilingualContentFetch.prototype, "en", void 0);
+__decorate([
+    (0, class_validator_1.IsNotEmpty)(),
+    (0, class_validator_1.IsString)(),
+    __metadata("design:type", String)
+], MultilingualContentFetch.prototype, "ar", void 0);
+__decorate([
+    (0, class_validator_1.IsNotEmpty)(),
+    (0, class_validator_1.IsString)(),
+    __metadata("design:type", String)
+], MultilingualContentFetch.prototype, "ru", void 0);
+__decorate([
+    (0, class_validator_1.IsNotEmpty)(),
+    (0, class_validator_1.IsString)(),
+    __metadata("design:type", String)
+], MultilingualContentFetch.prototype, "zh", void 0);
+exports.MultilingualContentFetch = MultilingualContentFetch;
+class FaqFilterDTO {
+    constructor(init) {
+        Object.assign(this, init);
+    }
+    validate(shouldValidate = true) {
+        const errors = [];
+        if (shouldValidate) {
+            if (this.category && !Object.values(enums_1.FaqCategory).includes(this.category)) {
+                errors.push(`Invalid category: ${this.category}. Valid categories are: ${Object.values(enums_1.FaqCategory).join(', ')}`);
+            }
+            if (this.searchLanguage && !['en', 'ar', 'ru', 'zh'].includes(this.searchLanguage)) {
+                errors.push(`Invalid search language: ${this.searchLanguage}. Valid languages are: en, ar, ru, zh`);
+            }
+        }
+        return errors;
+    }
+    static fromPlain(plain) {
+        const dto = new FaqFilterDTO();
+        if (plain) {
+            dto.search = plain.search;
+            dto.searchLanguage = plain.searchLanguage;
+            dto.searchInAnswers = plain.searchInAnswers;
+            // Handle category
+            if (plain.category) {
+                const categoryValue = plain.category.value || plain.category;
+                if (Object.values(enums_1.FaqCategory).includes(categoryValue)) {
+                    dto.category = categoryValue;
+                }
+            }
+            // Handle boolean conversions
+            if (typeof plain.isActive === 'string') {
+                dto.isActive = plain.isActive.toLowerCase() === 'true';
+            }
+            else {
+                dto.isActive = plain.isActive;
+            }
+            if (typeof plain.searchInAnswers === 'string') {
+                dto.searchInAnswers = plain.searchInAnswers.toLowerCase() === 'true';
+            }
+            else {
+                dto.searchInAnswers = plain.searchInAnswers;
+            }
+        }
+        return dto;
+    }
+    static toPlain(instance) {
+        return (0, class_transformer_1.instanceToPlain)(instance);
+    }
+}
+__decorate([
+    (0, class_validator_1.IsOptional)(),
+    (0, class_validator_1.IsString)(),
+    __metadata("design:type", String)
+], FaqFilterDTO.prototype, "search", void 0);
+__decorate([
+    (0, class_validator_1.IsOptional)(),
+    (0, class_validator_1.IsString)(),
+    __metadata("design:type", String)
+], FaqFilterDTO.prototype, "searchLanguage", void 0);
+__decorate([
+    (0, class_validator_1.IsOptional)(),
+    (0, class_validator_1.IsBoolean)(),
+    __metadata("design:type", Boolean)
+], FaqFilterDTO.prototype, "searchInAnswers", void 0);
+__decorate([
+    (0, class_validator_1.IsOptional)(),
+    (0, class_validator_1.IsEnum)(enums_1.FaqCategory, { message: 'Invalid category provided' }),
+    __metadata("design:type", String)
+], FaqFilterDTO.prototype, "category", void 0);
+__decorate([
+    (0, class_validator_1.IsOptional)(),
+    (0, class_validator_1.IsBoolean)(),
+    __metadata("design:type", Boolean)
+], FaqFilterDTO.prototype, "isActive", void 0);
+exports.FaqFilterDTO = FaqFilterDTO;
+class SortDTO {
+}
+__decorate([
+    (0, class_validator_1.IsString)(),
+    __metadata("design:type", String)
+], SortDTO.prototype, "field", void 0);
+__decorate([
+    (0, class_validator_1.IsString)(),
+    __metadata("design:type", String)
+], SortDTO.prototype, "direction", void 0);
+class FaqOptionsDTO {
+    constructor(init) {
+        this.page = 1;
+        this.limit = 10;
+        Object.assign(this, init);
+    }
+    validate(shouldValidate = true) {
+        const errors = [];
+        if (shouldValidate) {
+            // Validate page
+            if (this.page < 1) {
+                errors.push('Page must be greater than 0');
+            }
+            // Validate limit
+            if (this.limit < 1) {
+                errors.push('Limit must be greater than 0');
+            }
+            if (this.limit > 100) {
+                errors.push('Limit cannot exceed 100');
+            }
+            // Validate sort if present
+            if (this.sort) {
+                if (!this.sort.field) {
+                    errors.push('Sort field is required when sort is provided');
+                }
+                if (this.sort.direction && !['asc', 'desc'].includes(this.sort.direction.toLowerCase())) {
+                    errors.push('Sort direction must be either "asc" or "desc"');
+                }
+            }
+        }
+        return errors;
+    }
+    static toPlain(instance) {
+        return (0, class_transformer_1.instanceToPlain)(instance);
+    }
+    static fromPlain(plain) {
+        var _a;
+        const dto = new FaqOptionsDTO();
+        if (plain) {
+            // Convert and validate page
+            dto.page = plain.page ? Number(plain.page) : 1;
+            // Convert and validate limit
+            dto.limit = plain.limit ? Number(plain.limit) : 10;
+            // Handle sort if present
+            if (plain.sort) {
+                dto.sort = {
+                    field: plain.sort.field,
+                    direction: (_a = plain.sort.direction) === null || _a === void 0 ? void 0 : _a.toLowerCase()
+                };
+            }
+        }
+        return dto;
+    }
+}
+__decorate([
+    (0, class_validator_1.IsNumber)(),
+    (0, class_validator_1.Min)(1),
+    __metadata("design:type", Number)
+], FaqOptionsDTO.prototype, "page", void 0);
+__decorate([
+    (0, class_transformer_1.Type)(() => SortDTO),
+    (0, class_validator_1.IsNumber)(),
+    (0, class_validator_1.Min)(1),
+    (0, class_validator_1.Max)(100) // Optional: add max limit to prevent excessive requests
+    ,
+    __metadata("design:type", Number)
+], FaqOptionsDTO.prototype, "limit", void 0);
+__decorate([
+    (0, class_validator_1.IsOptional)(),
+    (0, class_validator_1.ValidateNested)(),
+    (0, class_transformer_1.Type)(() => SortDTO),
+    __metadata("design:type", Object)
+], FaqOptionsDTO.prototype, "sort", void 0);
+exports.FaqOptionsDTO = FaqOptionsDTO;
+class FaqFetchDTO {
+    static fromPlain(plain) {
+        return (0, class_transformer_1.plainToClass)(FaqFetchDTO, {
+            filter: plain.filter,
+            options: plain.options
+        });
+    }
+    constructor(init) {
+        Object.assign(this, init);
+    }
+    static toPlain(instance) {
+        return (0, class_transformer_1.instanceToPlain)(instance);
+    }
+}
+__decorate([
+    (0, class_transformer_1.Type)(() => FaqFilterDTO),
+    (0, class_validator_1.ValidateNested)(),
+    (0, class_validator_1.IsOptional)(),
+    __metadata("design:type", FaqFilterDTO)
+], FaqFetchDTO.prototype, "filter", void 0);
+__decorate([
+    (0, class_transformer_1.Type)(() => FaqOptionsDTO),
+    (0, class_validator_1.ValidateNested)(),
+    (0, class_validator_1.IsOptional)(),
+    __metadata("design:type", FaqOptionsDTO)
+], FaqFetchDTO.prototype, "options", void 0);
+exports.FaqFetchDTO = FaqFetchDTO;
+class FaqResponseDTO {
+    toPlain() {
+        return {
+            id: this.id,
+            question: this.question.toPlain(),
+            answer: this.answer.toPlain(),
+            category: this.category,
+            isActive: this.isActive,
+            order: this.order,
+            createdAt: this.createdAt,
+            updatedAt: this.updatedAt
+        };
+    }
+    static fromPlain(plain) {
+        if (!plain) {
+            throw new Error('Cannot create FaqResponseDTO from null or undefined');
+        }
+        const dto = new FaqResponseDTO();
+        try {
+            dto.id = plain.id;
+            dto.question = MultilingualContentFetch.fromPlain(plain.question);
+            dto.answer = MultilingualContentFetch.fromPlain(plain.answer);
+            dto.category = plain.category;
+            dto.isActive = Boolean(plain.isActive);
+            dto.order = Number(plain.order);
+            dto.createdAt = plain.createdAt;
+            dto.updatedAt = plain.updatedAt;
+            return dto;
+        }
+        catch (error) {
+            if (error instanceof Error) {
+                throw new Error(`Failed to create FaqResponseDTO: ${error.message}`);
+            }
+            else {
+                throw new Error('Failed to create FaqResponseDTO: Unknown error');
+            }
+        }
+    }
+    // Optional: Add a validate method if needed
+    validate() {
+        const errors = [];
+        if (!this.id)
+            errors.push('ID is required');
+        if (!this.question)
+            errors.push('Question is required');
+        if (!this.answer)
+            errors.push('Answer is required');
+        if (!this.category)
+            errors.push('Category is required');
+        if (this.isActive === undefined)
+            errors.push('isActive is required');
+        if (this.order === undefined)
+            errors.push('Order is required');
+        if (!this.createdAt)
+            errors.push('CreatedAt is required');
+        if (!this.updatedAt)
+            errors.push('UpdatedAt is required');
+        // Add any additional validation logic here
+        return errors;
+    }
+}
+__decorate([
+    (0, class_validator_1.IsString)(),
+    (0, class_validator_1.IsNotEmpty)(),
+    __metadata("design:type", String)
+], FaqResponseDTO.prototype, "id", void 0);
+__decorate([
+    (0, class_validator_1.ValidateNested)(),
+    (0, class_transformer_1.Type)(() => MultilingualContentFetch),
+    (0, class_validator_1.IsNotEmpty)(),
+    __metadata("design:type", MultilingualContentFetch)
+], FaqResponseDTO.prototype, "question", void 0);
+__decorate([
+    (0, class_validator_1.ValidateNested)(),
+    (0, class_transformer_1.Type)(() => MultilingualContentFetch),
+    (0, class_validator_1.IsNotEmpty)(),
+    __metadata("design:type", MultilingualContentFetch)
+], FaqResponseDTO.prototype, "answer", void 0);
+__decorate([
+    (0, class_validator_1.IsString)(),
+    (0, class_validator_1.IsNotEmpty)(),
+    (0, class_validator_1.IsEnum)(enums_1.FaqCategory) // Add enum validation if you have FaqCategory enum
+    ,
+    __metadata("design:type", String)
+], FaqResponseDTO.prototype, "category", void 0);
+__decorate([
+    (0, class_validator_1.IsBoolean)(),
+    (0, class_validator_1.IsNotEmpty)(),
+    __metadata("design:type", Boolean)
+], FaqResponseDTO.prototype, "isActive", void 0);
+__decorate([
+    (0, class_validator_1.IsNumber)(),
+    (0, class_validator_1.IsNotEmpty)(),
+    (0, class_validator_1.Min)(0) // Add minimum value validation
+    ,
+    __metadata("design:type", Number)
+], FaqResponseDTO.prototype, "order", void 0);
+__decorate([
+    (0, class_validator_1.IsString)(),
+    (0, class_validator_1.IsNotEmpty)(),
+    __metadata("design:type", String)
+], FaqResponseDTO.prototype, "createdAt", void 0);
+__decorate([
+    (0, class_validator_1.IsString)(),
+    (0, class_validator_1.IsNotEmpty)(),
+    __metadata("design:type", String)
+], FaqResponseDTO.prototype, "updatedAt", void 0);
+exports.FaqResponseDTO = FaqResponseDTO;

package/dist/features/faq/data/dtos/index.d.ts

@@ -1,2 +1,3 @@
 export * from "./CreateFaqDTO";
 export * from "./UpdateFaqDTO";
+export * from "./FaqFetchDTO";

package/dist/features/faq/data/dtos/index.js

@@ -16,3 +16,4 @@ var __exportStar = (this && this.__exportStar) || function(m, exports) {
 Object.defineProperty(exports, "__esModule", { value: true });
 __exportStar(require("./CreateFaqDTO"), exports);
 __exportStar(require("./UpdateFaqDTO"), exports);
+__exportStar(require("./FaqFetchDTO"), exports);

package/dist/features/finance-eligibilty-request/data/dto/FinanceEligibilityRequestDTO.d.ts

@@ -36,7 +36,6 @@ export declare class FinanceEligibilityRequestCreateDTO {
     employeeCount: EmployeeCount;
     isCompanyOlderThanOneYear: boolean;
     hasLandline: YesNo;
-    eligibility: EligibilityStatus;
     documents?: string[];
     static fromPlain(plain: Record<string, unknown>): FinanceEligibilityRequestCreateDTO;
     toPlain(): Record<string, unknown>;

package/dist/features/finance-eligibilty-request/data/dto/FinanceEligibilityRequestDTO.js

@@ -117,10 +117,6 @@ __decorate([
     (0, class_validator_1.IsEnum)(YesNo),
     __metadata("design:type", String)
 ], FinanceEligibilityRequestCreateDTO.prototype, "hasLandline", void 0);
-__decorate([
-    (0, class_validator_1.IsEnum)(EligibilityStatus),
-    __metadata("design:type", Number)
-], FinanceEligibilityRequestCreateDTO.prototype, "eligibility", void 0);
 __decorate([
     (0, class_validator_1.IsOptional)(),
     (0, class_validator_1.IsString)({ each: true }),

package/dist/features/models/User.d.ts

@@ -14,6 +14,7 @@ export interface User {
     lastLogin?: Date;
     createdAt: Date;
     updatedAt: Date;
+    isPhoneNumberVerified: boolean;
     vehicleFavorites?: UserFavoriteVehicle[];
     favoriteVehicles?: Vehicle[];
     deposits?: Deposit[];

package/package.json

@@ -3,7 +3,7 @@
   "publishConfig": {
     "access": "public"
   },
-  "version": "1.7.8",
+  "version": "1.8.0",
   "description": "A package containing DTOs, validation classes and common modules and interfaces for Alba Cars",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
@@ -33,6 +33,7 @@
     "url": "git+https://github.com/alba-cars/AlbaCarsCommonModules.git"
   },
   "dependencies": {
+    "@alba-cars/common-modules": "^1.7.4",
     "axios": "^1.7.9",
     "class-transformer": "^0.5.1",
     "class-validator": "^0.14.1",