@solidstarters/solid-core 1.2.93 → 1.2.96

package/src/services/view-metadata.service.ts

@@ -1,3 +1,4 @@
+import { Logger } from '@nestjs/common';
 import { BadRequestException, Injectable } from '@nestjs/common';
 import { ConfigService } from '@nestjs/config';
 import { DiscoveryService, ModuleRef } from "@nestjs/core";
@@ -18,6 +19,9 @@ import { ActionMetadataService } from './action-metadata.service';
 import { SolidIntrospectService } from './solid-introspect.service';
 import { BasicFilterDto } from 'src/dtos/basic-filters.dto';
 import { UserViewMetadataService } from './user-view-metadata.service';
+import { Locale } from 'src/entities/locale.entity';
+import { SolidRegistry } from 'src/helpers/solid-registry';
+import { classify } from '@angular-devkit/core/src/utils/strings';
 
 @Injectable()
 export class ViewMetadataService extends CRUDService<ViewMetadata> {
@@ -40,18 +44,81 @@ export class ViewMetadataService extends CRUDService<ViewMetadata> {
     @InjectRepository(ModelMetadata)
     private readonly modelMetadataRepo: Repository<ModelMetadata>,
     readonly moduleRef: ModuleRef
-
   ) {
     super(modelMetadataService, moduleMetadataService, configService, fileService, discoveryService, crudHelperService, entityManager, repo, 'viewMetadata', 'app-builder', moduleRef);
   }
 
+  private readonly logger = new Logger(ViewMetadataService.name);
+
+  //for locales 
+  private async getEntityRecordsInAllLocales(
+  modelName: string,
+  id: string,
+  defaultEntityLocaleIdFromQuery?: string
+): Promise<{ records: any[], defaultEntityLocaleId: string | null }> {
+  const solidRegistry = await this.moduleRef.get(SolidRegistry, { strict: false });
+  const currentEntityTarget = solidRegistry.getEntityTarget(this.entityManager, classify(modelName));
+  const currentEntityRepository = this.entityManager.getRepository(currentEntityTarget);
+
+  // Case 1: Creating a new record with no defaultEntityLocaleId to clone
+  if (id === 'new' && !defaultEntityLocaleIdFromQuery) {
+    this.logger.debug(`Creating new record without cloning from any defaultEntityLocaleId.`);
+    return { records: [], defaultEntityLocaleId: null };
+  }
+
+  // Case 2: Creating a new record and cloning from an existing defaultEntityLocaleId
+  if (id === 'new' && defaultEntityLocaleIdFromQuery) {
+    this.logger.debug(`Creating new record by cloning translations from defaultEntityLocaleId: ${defaultEntityLocaleIdFromQuery}`);
+
+    const records = await currentEntityRepository.find({
+      where: [
+        { defaultEntityLocaleId: defaultEntityLocaleIdFromQuery },
+        { id: defaultEntityLocaleIdFromQuery }
+      ]
+    });
+
+    this.logger.debug(`Found ${records.length} cloned records for new entity.`);
+    return { records, defaultEntityLocaleId: defaultEntityLocaleIdFromQuery };
+  }
+
+  // Case 3: Editing an existing entity
+  const entityRecord = await currentEntityRepository.findOne({ where: { id } });
+
+  if (!entityRecord) {
+    this.logger.warn(`No entity found for id ${id}`);
+    return { records: [], defaultEntityLocaleId: null };
+  }
+
+  const defaultLocale = await this.entityManager.getRepository(Locale).findOne({ where: { isDefault: true } });
+
+  let defaultEntityLocaleId: string;
+  if (entityRecord.localeName === defaultLocale?.locale) {
+    defaultEntityLocaleId = entityRecord.id;
+    this.logger.debug(`Editing default locale record with id ${defaultEntityLocaleId}`);
+  } else {
+    defaultEntityLocaleId = entityRecord.defaultEntityLocaleId;
+    this.logger.debug(`Editing non-default locale record. DefaultEntityLocaleId: ${defaultEntityLocaleId}`);
+  }
+
+  const records = await currentEntityRepository.find({
+    where: [
+      { defaultEntityLocaleId: defaultEntityLocaleId },
+      { id: defaultEntityLocaleId }
+    ]
+  });
+
+  this.logger.debug(`Found ${records.length} records in all locales for existing entity.`);
+
+  return { records, defaultEntityLocaleId };
+}
+
   // START: Custom Service Methods
   async getLayout(query, activeUser) {
-    let { modelName, moduleName, viewType, populate } = query;
+    let { modelName, moduleName, viewType, id, populate } = query;
 
     // modelName = camelize(modelName);
 
-    // Fetch the view based on module, model & view name.
+    // 1. Fetch the view based on module, model & view name.
     const entity = await this.repo.findOne({
       where: {
         model: { singularName: modelName },
@@ -60,7 +127,7 @@ export class ViewMetadataService extends CRUDService<ViewMetadata> {
       },
       relations: {
         model: {
-          userKeyField: true,  // Nested population of 'someOtherEntity' within 'model'
+          userKeyField: true,
         },
         module: true,
       }
@@ -69,19 +136,18 @@ export class ViewMetadataService extends CRUDService<ViewMetadata> {
     if (!entity) {
       throw new BadRequestException(`Unable to identify view for module: ${moduleName}, model: ${modelName} and viewType: ${viewType}`);
     }
-
     if (!activeUser?.sub) {
       throw new BadRequestException(`Unable to identify user for module: ${moduleName}, model: ${modelName} and viewType: ${viewType}`);
     }
 
+    // 2. See if we have a user specific layout for this view.
     const userLayout = await this.userViewMetadataService.repo.findOne({
       where: {
         user: { id: activeUser?.sub },
         viewMetadata: { id: entity.id },
       },
     });
-
-
+    // Based on where we found the layout we are converting it from string to json.
     if (userLayout) {
       entity.layout = JSON.parse(userLayout.layout);
     } else {
@@ -89,8 +155,7 @@ export class ViewMetadataService extends CRUDService<ViewMetadata> {
     }
 
 
-    // If view entity found then convert layout from "string" to "json".
-    //pass user id 
+    // 3. We are resolving the create & edit actions if specified in the layout.
     if (entity?.layout?.attrs?.createAction) {
       const actionName: string = entity.layout.attrs.createAction;
       entity.layout.attrs.createAction = await this.actionMetadataService.findOneByUserKey(actionName)
@@ -100,14 +165,14 @@ export class ViewMetadataService extends CRUDService<ViewMetadata> {
       entity.layout.attrs.editAction = await this.actionMetadataService.findOneByUserKey(actionName)
     }
 
-    // for form views, we need to check if "workflow" field is configured, if configured then return an extra metadata "solidFormViewWorkflowData"
+    // 4. For form views we need to fetch the workflow field metadata if specified.
     let workflowFieldName = null;
     let workflowField = null;
     if (viewType === 'form') {
       workflowFieldName = entity.layout?.attrs?.workflowField;
     }
 
-    // We also need to fetch a map of fields.
+    // 5. Create an easy to use map of field metadata, rather than sending an array of fields it becomes easier to use in the frontend.
     const fields = await this.loadFieldHierarchy(modelName);
     const fieldsMap = new Map<string, FieldMetadata>();
     for (let i = 0; i < fields.length; i++) {
@@ -139,6 +204,7 @@ export class ViewMetadataService extends CRUDService<ViewMetadata> {
       }
     }
 
+    // 6. Use the resolved workflowField to populate workflow specific metadata.
     // Check if we were able to resolve an actual workflowField.
     let solidFormViewWorkflowData = [];
     if (viewType === 'form' && workflowField) {
@@ -146,7 +212,7 @@ export class ViewMetadataService extends CRUDService<ViewMetadata> {
       // for workflowFields of type selectionStatic we simply return the key/values from field metadata AS-IS
       if (workflowField.type === 'selectionStatic') {
         solidFormViewWorkflowData = workflowField.selectionStaticValues.map(item => {
-          const [value,label] = item.split(":");
+          const [value, label] = item.split(":");
           return { label, value };
         });
       }
@@ -161,13 +227,112 @@ export class ViewMetadataService extends CRUDService<ViewMetadata> {
         // iterate over the comodel records extracting the label & value. 
         solidFormViewWorkflowData = records.map(item => ({ 'label': item[workflowFielUserkey], 'value': item['id'] }))
       }
+    }
 
+    // 7. If this model supports internationalisation, we need to load the locales applicable with the id of an actual record for each locale if present.
+    // This is the shape of locales that will be returned 
+    /**
+     * [
+     *    {locale: 'en', displayName: 'English', isDefault: 'yes', defaultEntityLocaleId: '', entityId: '1'}, 
+     *    {locale: 'en-IN', displayName: 'English (India)', isDefault: 'no', defaultEntityLocaleId: '1', entityId: '2'}, 
+     *    {locale: 'en-SG', displayName: 'English (Singapore)', isDefault: 'no', defaultEntityLocaleId: '', entityId: '3'}, 
+     *    {locale: 'fr', displayName: 'French', isDefault: 'no', defaultEntityLocaleId: '', entityId: ''}
+     * ]
+     */
+
+    const applicableLocales: any = []
+    // if (entity.model.internationalisation) {
+    //   const allLocales = await this.entityManager.getRepository(Locale).find({});
+
+    //   if (id === 'new') {
+    //     allLocales.forEach(locale => {
+    //       applicableLocales.push({
+    //         locale: locale.locale,
+    //         displayName: locale.displayName,
+    //         isDefault: locale.isDefault ? 'yes' : 'no',
+    //         defaultEntityLocaleId: null,
+    //         entityId: null
+    //       });
+    //     });
+    //   }
+    //   else {
+    //     const defaultLocale = allLocales.find(locale => locale.isDefault);
+    //     this.logger.debug(`Default locale is: ${defaultLocale.locale}`);
+
+    //     // Get hold of the repository for the current model
+    //     const solidRegistry = await this.moduleRef.get(SolidRegistry, { strict: false });
+    //     const currentEntityTarget = solidRegistry.getEntityTarget(this.entityManager, classify(modelName));
+    //     const currentEntityRepository = this.entityManager.getRepository(currentEntityTarget);
+
+    //     // We are in edit mode, the id that is being edited could be a record tagged with the default locale or it could be tagged with a non-default locale.
+    //     const entityRecord = await currentEntityRepository.findOne({
+    //       where: {
+    //         id: id,
+    //       }
+    //     });
+    //     if(entityRecord){
+    //     //  Resolve the default entity locale id....
+    //       let defaultEntityLocaleId = null;
+    //       if (entityRecord.localeName === defaultLocale.locale) {
+    //         defaultEntityLocaleId = entityRecord.id;
+    //         this.logger.debug(`You are editing a record tagged with the default locale: ${entityRecord.localeName}.`);
+    //       }
+    //       else {
+    //         defaultEntityLocaleId = entityRecord.defaultEntityLocaleId;
+    //         this.logger.debug(`You are editing a record tagged with the non-default locale: ${entityRecord.localeName}. `);
+    //       }
+    //       this.logger.debug(`Identified default Entity Locale Id: ${defaultEntityLocaleId}`);
+
+    //       // Now we query for all records in the same model matching the defaultEntityLocaleId
+    //       // Get all records mathcing the defaultEntityLocaleId or where the id is same as the defaultEntityLocaleId
+    //       const entityRecordsInAllLocales = await currentEntityRepository.find({
+    //         where: [
+    //           { defaultEntityLocaleId: defaultEntityLocaleId },
+    //           { id: defaultEntityLocaleId }
+    //         ],
+    //       });
+    //       this.logger.debug(`Found ${entityRecordsInAllLocales.length} records in all locales for the defaultEntityLocaleId: ${defaultEntityLocaleId}`);
+
+    //       // Loop over all locales and populate the applicableLocales array
+    //       for (const locale of allLocales) {
+    //         // Find the record in the entityRecordsInAllLocales that matches the current locale
+    //         const matchingRecord = entityRecordsInAllLocales.find(record => record.localeName === locale.locale);
+
+    //         applicableLocales.push({
+    //           locale: locale.locale,
+    //           displayName: locale.displayName,
+    //           isDefault: locale.isDefault ? 'yes' : 'no',
+    //           defaultEntityLocaleId: defaultEntityLocaleId,
+    //           entityId: (matchingRecord ? matchingRecord.id : null)
+    //         });
+    //       }
+    //     }else{
+    //       this.logger.warn(`No record found for id: ${id} in model: ${modelName}. Cannot determine applicable locales.`);
+    //     }
+    //   }
+    // }
+    if(entity.model.internationalisation){
+      const defaultEntityLocaleIdFromQuery = query?.defaultEntityLocaleId;
+      const { records: entityRecordsInAllLocales, defaultEntityLocaleId } =
+      await this.getEntityRecordsInAllLocales(modelName, id, defaultEntityLocaleIdFromQuery);
+      const allLocales = await this.entityManager.getRepository(Locale).find({});
+      for (const locale of allLocales) {
+        const matchingRecord = entityRecordsInAllLocales.find(record => record.localeName === locale.locale);
+        applicableLocales.push({
+          locale: locale.locale,
+          displayName: locale.displayName,
+          isDefault: locale.isDefault ? 'yes' : 'no',
+          defaultEntityLocaleId: defaultEntityLocaleId,
+          entityId: matchingRecord ? matchingRecord.id : null
+        });
+      }
     }
 
     const r = {
       'solidView': entity,
       'solidFieldsMetadata': Object.fromEntries(fieldsMap),
-      'solidFormViewWorkflowData': solidFormViewWorkflowData
+      'solidFormViewWorkflowData': solidFormViewWorkflowData,
+      'applicableLocales': applicableLocales
     }
 
     return r;
@@ -195,7 +360,7 @@ export class ViewMetadataService extends CRUDService<ViewMetadata> {
         fields.push(...model.parentModel.fields);
       }
     }
-    return fields;        
+    return fields;
   }
 
   async findOneByUserKey(name: string, relations = {}) {

package/src/solid-core.module.ts

@@ -160,6 +160,9 @@ import { ChatterMessageController } from './controllers/chatter-message.controll
 import { ChatterMessageDetails } from './entities/chatter-message-details.entity';
 import { ChatterMessageDetailsService } from './services/chatter-message-details.service';
 import { ChatterMessageDetailsController } from './controllers/chatter-message-details.controller';
+import { Locale } from './entities/locale.entity';
+import { LocaleService } from './services/locale.service';
+import { LocaleController } from './controllers/locale.controller';
 import { AuditSubscriber } from './subscribers/audit.subscriber';
 import { ExportTemplate } from './entities/export-template.entity';
 import { ExportTemplateService } from './services/export-template.service';
@@ -177,6 +180,7 @@ import { ImportTransactionController } from './controllers/import-transaction.co
 import { ImportTransactionErrorLog } from './entities/import-transaction-error-log.entity';
 import { ImportTransactionErrorLogService } from './services/import-transaction-error-log.service';
 import { ImportTransactionErrorLogController } from './controllers/import-transaction-error-log.controller';
+import { LocaleListSelectionProvider } from './services/selection-providers/locale-list-selection-provider.service';
 
 
 @Global()
@@ -228,6 +232,7 @@ import { ImportTransactionErrorLogController } from './controllers/import-transa
     TypeOrmModule.forFeature([ListOfValues]),
     TypeOrmModule.forFeature([ChatterMessage]),
     TypeOrmModule.forFeature([ChatterMessageDetails]),
+    TypeOrmModule.forFeature([Locale]),
     TypeOrmModule.forFeature([ExportTemplate]),
     TypeOrmModule.forFeature([ExportTransaction]),
     // TypeOrmModule.forFeature([User]),
@@ -268,6 +273,7 @@ import { ImportTransactionErrorLogController } from './controllers/import-transa
     ListOfValuesController,
     ChatterMessageController,
     ChatterMessageDetailsController,
+    LocaleController,
     ExportTemplateController,
     ExportTransactionController,
     ImportTransactionController,
@@ -343,6 +349,7 @@ import { ImportTransactionErrorLogController } from './controllers/import-transa
     PdfService,
     UuidExternalIdComputedFieldProvider,
     ListOfModelsSelectionProvider,
+    LocaleListSelectionProvider,
     SoftDeleteAwareEventSubscriber,
     AccessTokenGuard,
     AuthenticationService,
@@ -375,6 +382,7 @@ import { ImportTransactionErrorLogController } from './controllers/import-transa
     SavedFiltersService,
     ChatterMessageService,
     ChatterMessageDetailsService,
+    LocaleService,
     AuditSubscriber,
     ExportTemplateService,
     ExportTransactionService,

package/src/subscribers/model.subscriber.ts

@@ -66,6 +66,30 @@ export class ModelSubscriber implements EntitySubscriberInterface<ModelMetadata>
         isSystem: true,
         model: event.entity,
       },
+      {
+        name: "publishedAt",
+        displayName: "Published At",
+        type: "datetime",
+        ormType: "timestamp",
+        isSystem: true,
+        model: event.entity,
+      },
+      {
+        name: "localeName",
+        displayName: "Locale",
+        type: "shortText",
+        ormType: "varchar",
+        isSystem: true,
+        model: event.entity,
+      },
+      {
+        name: "defaultEntityLocaleId",
+        displayName: "Default Entity Locale Id",
+        type: "int",
+        ormType: "integer",
+        isSystem: true,
+        model: event.entity,
+      }
     ];
     await transactionManager.save(FieldMetadata, systemFieldsMetadata);
     // Save to the database.

package/src/transformers/datetime-transformer.ts

@@ -0,0 +1,12 @@
+import { TransformFnParams } from 'class-transformer';
+
+const datetimeTransformer = ({ value }: TransformFnParams): Date | null => {
+    console.log("date time transformer debug", value);
+
+    if (value === '' || value === undefined || value === null) return null;
+
+    const parsed = new Date(value);
+    return isNaN(parsed.getTime()) ? null : parsed;
+};
+
+export default datetimeTransformer;