V2 translate

app/api/i18n.v2/routes/routes.ts

@@ -0,0 +1,52 @@
+import { Application, Request } from 'express';
+import { needsAuthorization } from 'api/auth';
+import { validation } from 'api/utils';
+import translations from 'api/i18n';
+import { getTranslationsEntriesV2 } from 'api/i18n/v2_support';
+
+export default (app: Application) => {
+  app.get('/api/translationsV2', async (_req: Request, res) => {
+    const translationsV2 = await getTranslationsEntriesV2();
+    const translationList = await translationsV2.all();
+    res.json(translationList);
+  });
+
+  app.post(
+    '/api/translationsV2',
+    needsAuthorization(),
+    validation.validateRequest({
+      type: 'object',
+      properties: {
+        body: {
+          type: 'array',
+          items: {
+            type: 'object',
+            properties: {
+              _id: { type: 'string' },
+              language: { type: 'string' },
+              key: { type: 'string' },
+              value: { type: 'string' },
+              context: {
+                type: 'object',
+                properties: {
+                  id: { type: 'string' },
+                  label: { type: 'string' },
+                  type: { type: 'string' },
+                },
+                required: ['id', 'label', 'type'],
+              },
+            },
+            required: ['language', 'key', 'value', 'context'],
+          },
+        },
+      },
+      required: ['body'],
+    }),
+    async (req, res) => {
+      await translations.v2StructureSave(req.body);
+      req.sockets.emitToCurrentTenant('translationKeysChange', req.body);
+      res.status(200);
+      res.json({ success: true });
+    }
+  );
+};

app/api/i18n.v2/routes/specs/routes.spec.ts

@@ -0,0 +1,100 @@
+import 'isomorphic-fetch';
+import request from 'supertest';
+
+import { TranslationDBO } from 'api/i18n.v2/schemas/TranslationDBO';
+import i18nRoutes from 'api/i18n/routes';
+import { getFixturesFactory } from 'api/utils/fixturesFactory';
+import { testingEnvironment } from 'api/utils/testingEnvironment';
+import { TestEmitSources, iosocket, setUpApp } from 'api/utils/testingRoutes';
+import { UserRole } from 'shared/types/userSchema';
+
+describe('i18n translations V2 routes', () => {
+  const createTranslationDBO = getFixturesFactory().v2.database.translationDBO;
+  const app = setUpApp(i18nRoutes, (req, _res, next) => {
+    req.user = {
+      username: 'admin',
+      role: UserRole.ADMIN,
+      email: '[email protected]',
+    };
+    // @ts-ignore
+    req.file = { path: 'filder/filename.ext' };
+    next();
+  });
+
+  beforeEach(async () => {
+    const translationsV2: TranslationDBO[] = [
+      createTranslationDBO('Search', 'Buscar', 'es', {
+        id: 'System',
+        type: 'Entity',
+        label: 'User Interface',
+      }),
+      createTranslationDBO('Search', 'Search', 'en', {
+        id: 'System',
+        type: 'Uwazi UI',
+        label: 'User Interface',
+      }),
+    ];
+    await testingEnvironment.setUp(
+      {
+        settings: [
+          {
+            languages: [
+              { key: 'en', label: 'English', default: true },
+              { key: 'es', label: 'Spanish', default: false },
+            ],
+          },
+        ],
+        translationsV2,
+      },
+      'index_i18n_v2_routes'
+    );
+  });
+
+  afterEach(() => {
+    iosocket.emit.mockReset();
+  });
+
+  afterAll(async () => {
+    await testingEnvironment.tearDown();
+  });
+
+  describe('api/translationsV2', () => {
+    it('should update the translations and emit translationKeysChange event', async () => {
+      const response = await request(app)
+        .post('/api/translationsV2')
+        .send([
+          {
+            language: 'es',
+            key: 'Search',
+            value: 'Búsqueda',
+            context: {
+              id: 'System',
+              label: 'User Interface',
+              type: 'Uwazi UI',
+            },
+          },
+        ]);
+      expect(response.status).toEqual(200);
+      expect(iosocket.emit).toHaveBeenCalledWith(
+        'translationKeysChange',
+        TestEmitSources.currentTenant,
+        [
+          {
+            context: { id: 'System', label: 'User Interface', type: 'Uwazi UI' },
+            key: 'Search',
+            language: 'es',
+            value: 'Búsqueda',
+          },
+        ]
+      );
+    });
+
+    it('should handle invalid POST request payload', async () => {
+      const response = await request(app).post('/api/translationsV2').send({ invalidKey: 'value' }); // Invalid payload
+      expect(response.status).toBe(400);
+      expect(response.body).toEqual(
+        expect.objectContaining({ prettyMessage: 'validation failed' })
+      );
+    });
+  });
+});

app/api/i18n/routes.ts

@@ -1,3 +1,4 @@
+/* eslint-disable max-lines */
 import { createError, validation } from 'api/utils';
 import settings from 'api/settings';
 import entities from 'api/entities';
@@ -11,6 +12,7 @@ import { Application, Request } from 'express';
 import { UITranslationNotAvailable } from 'api/i18n/defaultTranslations';
 import needsAuthorization from '../auth/authMiddleware';
 import translations from './translations';
+import { getTranslationsEntriesV2 } from './v2_support';
 
 const addLanguage = async (language: LanguageSchema) => {
   const newSettings = await settings.addLanguage(language);
@@ -59,6 +61,7 @@ async function deleteLanguage(key: LanguageISO6391, req: Request) {
 
 type TranslationsRequest = Request & { query: { context: string } };
 
+// eslint-disable-next-line max-statements
 export default (app: Application) => {
   app.get(
     '/api/translations',
@@ -81,6 +84,14 @@ export default (app: Application) => {
     }
   );
 
+  app.get('/api/translationsV2', async (_req: TranslationsRequest, res) => {
+    const translationsV2 = await getTranslationsEntriesV2();
+
+    const translationList = await translationsV2.all();
+
+    res.json(translationList);
+  });
+
   app.get('/api/languages', async (_req, res) => {
     res.json(await translations.availableLanguages());
   });
@@ -158,6 +169,45 @@ export default (app: Application) => {
     }
   );
 
+  app.post(
+    '/api/translationsV2',
+    needsAuthorization(),
+    validation.validateRequest({
+      type: 'object',
+      properties: {
+        body: {
+          type: 'array',
+          items: {
+            type: 'object',
+            properties: {
+              _id: { type: 'string' },
+              language: { type: 'string' },
+              key: { type: 'string' },
+              value: { type: 'string' },
+              context: {
+                type: 'object',
+                properties: {
+                  id: { type: 'string' },
+                  label: { type: 'string' },
+                  type: { type: 'string' },
+                },
+                required: ['id', 'label', 'type'],
+              },
+            },
+            required: ['language', 'key', 'value', 'context'],
+          },
+        },
+      },
+      required: ['body'],
+    }),
+    async (req, res) => {
+      await translations.v2StructureSave(req.body);
+      req.sockets.emitToCurrentTenant('translationKeysChange', req.body);
+      res.status(200);
+      res.json({ success: true });
+    }
+  );
+
   app.post(
     '/api/translations/populate',
     needsAuthorization(),

app/api/i18n/specs/fixtures.ts

@@ -199,6 +199,13 @@ const fixtures: DBFixture = {
     {
       _id: entityTemplateId,
       type: 'template',
+      properties: [
+        {
+          type: 'select',
+          name: 'Dictionary',
+          content: dictionaryId.toString(),
+        },
+      ],
     },
     {
       _id: documentTemplateId,
@@ -214,6 +221,21 @@ const fixtures: DBFixture = {
       published: false,
       metadata: {},
     },
+    {
+      language: 'es',
+      sharedId: 'entity1',
+      title: '1',
+      template: entityTemplateId,
+      published: false,
+      metadata: {
+        Dictionary: [
+          {
+            value: '1',
+            label: 'Password',
+          },
+        ],
+      },
+    },
   ],
   pages: [
     {

app/api/i18n/specs/translations.spec.ts

@@ -7,11 +7,13 @@ import thesauri from 'api/thesauri/thesauri.js';
 import { ContextType } from 'shared/translationSchema';
 // eslint-disable-next-line node/no-restricted-import
 import * as fs from 'fs';
+import { TranslationSyO } from 'api/i18n.v2/schemas/TranslationSyO';
 import { UITranslationNotAvailable } from '../defaultTranslations';
 import translations from '../translations';
 import fixtures, { dictionaryId } from './fixtures';
 import { sortByLocale } from './sortByLocale';
 import { addLanguage } from '../routes';
+import { getTranslationsV2ByContext } from '../v2_support';
 
 describe('translations', () => {
   beforeEach(async () => {
@@ -29,7 +31,7 @@ describe('translations', () => {
       expect(result).toMatchObject({
         contexts: [
           {
-            type: 'Thesaurus',
+            type: 'Thesaurus' as 'Thesaurus',
             values: {
               Account: 'Account',
               Age: 'Age',
@@ -56,6 +58,36 @@ describe('translations', () => {
     });
   });
 
+  describe('v2StructureSave', () => {
+    it('should save changed translations and propagate the changes', async () => {
+      const initialTranslations = await getTranslationsV2ByContext(dictionaryId.toString());
+      const initialEntity = (await entities.get({ language: 'es', sharedId: 'entity1' }))[0];
+      const translationsToSave = [
+        {
+          _id: '1',
+          language: initialTranslations[0].locale!,
+          key: 'Password',
+          value: 'Changed Password ES',
+          context: {
+            id: dictionaryId.toString(),
+            type: 'Thesaurus' as TranslationSyO['context']['type'],
+            label: '',
+          },
+        },
+      ];
+
+      await translations.v2StructureSave(translationsToSave);
+      const updatedTranslations = await getTranslationsV2ByContext(dictionaryId.toString());
+      initialTranslations![0]!.contexts![0]!.values!.find(v => v.key === 'Password')!.value =
+        'Changed Password ES';
+      expect(updatedTranslations).toEqual(initialTranslations);
+
+      const updatedEntity = (await entities.get({ language: 'es', sharedId: 'entity1' }))[0];
+      initialEntity.metadata.Dictionary[0].label = 'Changed Password ES';
+      expect(updatedEntity).toEqual(initialEntity);
+    });
+  });
+
   describe('save()', () => {
     it('should save the translation and return it', async () => {
       const result = await translations.save({ locale: 'fr' });