34029 browser component

core-web/apps/mcp-server/.eslintrc.json

@@ -1,6 +1,6 @@
 {
     "extends": ["../../.eslintrc.base.json"],
-    "ignorePatterns": ["!**/*"],
+    "ignorePatterns": ["!**/*", "**/node_modules/**", "node_modules/**"],
     "overrides": [
         {
             "files": ["*.ts", "*.tsx", "*.js", "*.jsx"],

core-web/libs/data-access/jest.config.ts

@@ -21,7 +21,6 @@ export default {
         '^.+\\.(ts|mjs|js|html)$': [
             'jest-preset-angular',
             {
-                isolatedModules: true, // Prevent type checking in tests and deps
                 tsconfig: '<rootDir>/tsconfig.spec.json',
                 stringifyContentPathRegex: '\\.(html|svg)$'
             }

core-web/libs/data-access/src/lib/dot-contentlet/dot-contentlet-service.spec.ts

@@ -1,68 +1,44 @@
-import { createHttpFactory, HttpMethod, SpectatorHttp } from '@ngneat/spectator/jest';
-
-import { DotCMSContentlet, DotLanguage } from '@dotcms/dotcms-models';
+import {
+    createHttpFactory,
+    HttpMethod,
+    mockProvider,
+    SpectatorHttp,
+    SpyObject
+} from '@ngneat/spectator/jest';
+import { of } from 'rxjs';
+
+import { DotContentletCanLock } from '@dotcms/dotcms-models';
+import { createFakeContentlet, createFakeLanguage } from '@dotcms/utils-testing';
 
 import { DotContentletService } from './dot-contentlet.service';
 
-const mockContentletVersionsResponse = {
-    entity: {
-        versions: {
-            en: [{ content: 'one' }, { content: 'two' }] as unknown as DotCMSContentlet[]
-        }
-    }
-};
-
-const mockContentletByInodeResponse = {
-    entity: {
-        archived: false,
-        baseType: 'CONTENT',
-        caategory: [{ boys: 'Boys' }, { girls: 'Girls' }],
-        contentType: 'ContentType1',
-        date: 1639548000000,
-        dateTime: 1639612800000,
-        folder: 'SYSTEM_FOLDER',
-        hasLiveVersion: true,
-        hasTitleImage: false,
-        host: '48190c8c-42c4-46af-8d1a-0cd5db894797',
-        hostName: 'demo.dotcms.com',
-        identifier: '758cb37699eae8500d64acc16ebc468e',
-        inode: '18f707db-ebf3-45f8-9b5a-d8bf6a6f383a',
-        keyValue: { Colorado: 'snow', 'Costa Rica': 'summer' },
-        languageId: 1,
-        live: true,
-        locked: false,
-        modDate: 1639784363639,
-        modUser: 'dotcms.org.1',
-        modUserName: 'Admin User',
-        owner: 'dotcms.org.1',
-        publishDate: 1639784363639,
-        sortOrder: 0,
-        stInode: '0121c052881956cd95bfe5dde968ca07',
-        text: 'final value',
-        time: 104400000,
-        title: '758cb37699eae8500d64acc16ebc468e',
-        titleImage: 'TITLE_IMAGE_NOT_FOUND',
-        url: '/content.40e5d7cd-2117-47d5-b96d-3278b188deeb',
-        working: true
-    } as unknown as DotCMSContentlet
-};
-
-export const mockDotContentletCanLock = {
-    entity: {
-        canLock: true,
-        id: '1',
-        inode: '1',
-        locked: true
-    }
-};
+import { DotUploadFileService } from '../dot-upload-file/dot-upload-file.service';
 
 describe('DotContentletService', () => {
     let spectator: SpectatorHttp<DotContentletService>;
-    const createHttp = createHttpFactory(DotContentletService);
+    let dotUploadFileService: SpyObject<DotUploadFileService>;
+
+    const createHttp = createHttpFactory({
+        service: DotContentletService,
+        providers: [mockProvider(DotUploadFileService)]
+    });
 
-    beforeEach(() => (spectator = createHttp()));
+    beforeEach(() => {
+        spectator = createHttp();
+        dotUploadFileService = spectator.inject(DotUploadFileService);
+    });
 
     it('should bring the contentlet versions by language', () => {
+        const mockContentlet1 = createFakeContentlet({ content: 'one' });
+        const mockContentlet2 = createFakeContentlet({ content: 'two' });
+        const mockContentletVersionsResponse = {
+            entity: {
+                versions: {
+                    en: [mockContentlet1, mockContentlet2]
+                }
+            }
+        };
+
         spectator.service.getContentletVersions('123', 'en').subscribe((res) => {
             expect(res).toEqual(mockContentletVersionsResponse.entity.versions.en);
         });
@@ -75,59 +51,101 @@ describe('DotContentletService', () => {
     });
 
     it('should retrieve a contentlet by its inode', () => {
-        spectator.service
-            .getContentletByInode(mockContentletByInodeResponse.entity.inode)
-            .subscribe((res) => {
-                expect(res).toEqual(mockContentletByInodeResponse.entity);
-            });
+        const mockContentlet = createFakeContentlet({
+            inode: '18f707db-ebf3-45f8-9b5a-d8bf6a6f383a'
+        });
+        const mockResponse = {
+            entity: mockContentlet
+        };
 
-        const req = spectator.expectOne(
-            '/api/v1/content/' + mockContentletByInodeResponse.entity.inode,
-            HttpMethod.GET
-        );
-        req.flush(mockContentletByInodeResponse);
+        spectator.service.getContentletByInode(mockContentlet.inode).subscribe((res) => {
+            expect(res).toEqual(mockContentlet);
+        });
+
+        const req = spectator.expectOne(`/api/v1/content/${mockContentlet.inode}`, HttpMethod.GET);
+        req.flush(mockResponse);
+    });
+
+    it('should retrieve a contentlet by its inode with content', () => {
+        const mockContentlet = createFakeContentlet({
+            inode: '18f707db-ebf3-45f8-9b5a-d8bf6a6f383a'
+        });
+        const mockContentletWithContent = { ...mockContentlet, content: 'file content' };
+        const mockResponse = {
+            entity: mockContentlet
+        };
+
+        dotUploadFileService.addContent.mockReturnValue(of(mockContentletWithContent));
+
+        spectator.service.getContentletByInodeWithContent(mockContentlet.inode).subscribe((res) => {
+            expect(res).toEqual(mockContentletWithContent);
+            expect(dotUploadFileService.addContent).toHaveBeenCalledWith(mockContentlet);
+        });
+
+        const req = spectator.expectOne(`/api/v1/content/${mockContentlet.inode}`, HttpMethod.GET);
+        req.flush(mockResponse);
     });
 
     it('should retrieve available languages for a contentlet', () => {
+        const mockLanguage1 = createFakeLanguage({ id: 1, language: 'English' });
+        const mockLanguage2 = createFakeLanguage({ id: 2, language: 'Spanish' });
         const mockLanguagesResponse = {
-            entity: [
-                { languageId: 1, language: 'English' },
-                { languageId: 2, language: 'Spanish' }
-            ]
+            entity: [mockLanguage1, mockLanguage2]
         };
 
         spectator.service.getLanguages('1').subscribe((res) => {
-            expect(res).toEqual(mockLanguagesResponse.entity as unknown as DotLanguage[]);
+            expect(res).toEqual(mockLanguagesResponse.entity);
         });
 
         const req = spectator.expectOne('/api/v1/content/1/languages', HttpMethod.GET);
         req.flush(mockLanguagesResponse);
     });
 
     it('should lock a contentlet', () => {
+        const mockContentlet = createFakeContentlet({ inode: '1' });
+        const mockResponse = {
+            entity: mockContentlet
+        };
+
         spectator.service.lockContent('1').subscribe((res) => {
-            expect(res).toEqual(mockContentletByInodeResponse.entity);
+            expect(res).toEqual(mockContentlet);
         });
 
         const req = spectator.expectOne('/api/v1/content/_lock/1', HttpMethod.PUT);
-        req.flush(mockContentletByInodeResponse);
+        req.flush(mockResponse);
     });
 
     it('should unlock a contentlet', () => {
+        const mockContentlet = createFakeContentlet({ inode: '1' });
+        const mockResponse = {
+            entity: mockContentlet
+        };
+
         spectator.service.unlockContent('1').subscribe((res) => {
-            expect(res).toEqual(mockContentletByInodeResponse.entity);
+            expect(res).toEqual(mockContentlet);
         });
 
         const req = spectator.expectOne('/api/v1/content/_unlock/1', HttpMethod.PUT);
-        req.flush(mockContentletByInodeResponse);
+        req.flush(mockResponse);
     });
 
     it('should check if a contentlet can be locked', () => {
+        const mockDotContentletCanLock: DotContentletCanLock = {
+            canLock: true,
+            id: '1',
+            inode: '1',
+            locked: true,
+            lockedBy: 'user1'
+        };
+        const mockResponse = {
+            entity: mockDotContentletCanLock
+        };
+
         spectator.service.canLock('1').subscribe((res) => {
-            expect(res).toEqual(mockDotContentletCanLock.entity);
+            expect(res).toEqual(mockDotContentletCanLock);
         });
 
         const req = spectator.expectOne('/api/v1/content/_canlock/1', HttpMethod.GET);
-        req.flush(mockDotContentletCanLock);
+        req.flush(mockResponse);
     });
 });

core-web/libs/data-access/src/lib/dot-contentlet/dot-contentlet.service.ts

@@ -1,17 +1,25 @@
 import { Observable } from 'rxjs';
 
-import { HttpClient } from '@angular/common/http';
+import { HttpClient, HttpParams } from '@angular/common/http';
 import { Injectable, inject } from '@angular/core';
 
-import { pluck, take } from 'rxjs/operators';
+import { map, pluck, switchMap } from 'rxjs/operators';
 
-import { DotCMSContentlet, DotContentletCanLock, DotLanguage } from '@dotcms/dotcms-models';
+import {
+    DotCMSAPIResponse,
+    DotCMSContentlet,
+    DotContentletCanLock,
+    DotLanguage
+} from '@dotcms/dotcms-models';
+
+import { DotUploadFileService } from '../dot-upload-file/dot-upload-file.service';
 
 @Injectable({
     providedIn: 'root'
 })
 export class DotContentletService {
-    private http = inject(HttpClient);
+    readonly #http = inject(HttpClient);
+    readonly #dotUploadFileService = inject(DotUploadFileService);
 
     private readonly CONTENTLET_API_URL = '/api/v1/content/';
 
@@ -24,9 +32,11 @@ export class DotContentletService {
      * @memberof DotContentletService
      */
     getContentletVersions(identifier: string, language: string): Observable<DotCMSContentlet[]> {
-        return this.http
-            .get(`${this.CONTENTLET_API_URL}versions?identifier=${identifier}&groupByLang=1`)
-            .pipe(take(1), pluck('entity', 'versions', language));
+        return this.#http
+            .get<
+                DotCMSAPIResponse<DotCMSContentlet[]>
+            >(`${this.CONTENTLET_API_URL}versions?identifier=${identifier}&groupByLang=1`)
+            .pipe(pluck('entity', 'versions', language));
     }
 
     /**
@@ -36,8 +46,28 @@ export class DotContentletService {
      * @returns {Observable<DotCMSContentlet>} An observable emitting the contentlet.
      * @memberof DotContentletService
      */
-    getContentletByInode(inode: string): Observable<DotCMSContentlet> {
-        return this.http.get(`${this.CONTENTLET_API_URL}${inode}`).pipe(take(1), pluck('entity'));
+    getContentletByInode(inode: string, httpParams?: HttpParams): Observable<DotCMSContentlet> {
+        return this.#http
+            .get<
+                DotCMSAPIResponse<DotCMSContentlet>
+            >(`${this.CONTENTLET_API_URL}${inode}`, { params: httpParams })
+            .pipe(map((response) => response.entity));
+    }
+
+    /**
+     * Get the Contentlet by its inode and adds the content if it's a editable as text file.
+     *
+     * @param {string} inode - The inode of the contentlet.
+     * @returns {Observable<DotCMSContentlet>} An observable emitting the contentlet.
+     * @memberof DotContentletService
+     */
+    getContentletByInodeWithContent(
+        inode: string,
+        httpParams?: HttpParams
+    ): Observable<DotCMSContentlet> {
+        return this.getContentletByInode(inode, httpParams).pipe(
+            switchMap((contentlet) => this.#dotUploadFileService.addContent(contentlet))
+        );
     }
 
     /**
@@ -48,9 +78,11 @@ export class DotContentletService {
      * @memberof DotContentletService
      */
     getLanguages(identifier: string): Observable<DotLanguage[]> {
-        return this.http
-            .get(`${this.CONTENTLET_API_URL}${identifier}/languages`)
-            .pipe(take(1), pluck('entity'));
+        return this.#http
+            .get<
+                DotCMSAPIResponse<DotLanguage[]>
+            >(`${this.CONTENTLET_API_URL}${identifier}/languages`)
+            .pipe(map((response) => response.entity));
     }
 
     /**
@@ -61,9 +93,11 @@ export class DotContentletService {
      * @memberof DotContentletService
      */
     lockContent(inode: string): Observable<DotCMSContentlet> {
-        return this.http
-            .put(`${this.CONTENTLET_API_URL}_lock/${inode}`, {})
-            .pipe(take(1), pluck('entity'));
+        return this.#http
+            .put<
+                DotCMSAPIResponse<DotCMSContentlet>
+            >(`${this.CONTENTLET_API_URL}_lock/${inode}`, {})
+            .pipe(map((response) => response.entity));
     }
 
     /**
@@ -74,9 +108,11 @@ export class DotContentletService {
      * @memberof DotContentletService
      */
     unlockContent(inode: string): Observable<DotCMSContentlet> {
-        return this.http
-            .put(`${this.CONTENTLET_API_URL}_unlock/${inode}`, {})
-            .pipe(take(1), pluck('entity'));
+        return this.#http
+            .put<
+                DotCMSAPIResponse<DotCMSContentlet>
+            >(`${this.CONTENTLET_API_URL}_unlock/${inode}`, {})
+            .pipe(map((response) => response.entity));
     }
 
     /**
@@ -87,8 +123,10 @@ export class DotContentletService {
      * @memberof DotContentletService
      */
     canLock(inode: string): Observable<DotContentletCanLock> {
-        return this.http
-            .get(`${this.CONTENTLET_API_URL}_canlock/${inode}`)
-            .pipe(take(1), pluck('entity'));
+        return this.#http
+            .get<
+                DotCMSAPIResponse<DotContentletCanLock>
+            >(`${this.CONTENTLET_API_URL}_canlock/${inode}`)
+            .pipe(map((response) => response.entity));
     }
 }