Add region and timezone seeders

libs/common/src/seed/seeder.module.ts

@@ -15,6 +15,10 @@ import { UserRepository } from '../modules/user/repositories';
 import { UserRoleRepository } from '../modules/user-role/repositories';
 import { UserRoleRepositoryModule } from '../modules/user-role/user.role.repository.module';
 import { UserRepositoryModule } from '../modules/user/user.repository.module';
+import { RegionSeeder } from './services/regions.seeder';
+import { RegionRepository } from '../modules/region/repositories';
+import { TimeZoneSeeder } from './services/timezone.seeder';
+import { TimeZoneRepository } from '../modules/timezone/repositories';
 @Global()
 @Module({
   providers: [
@@ -28,6 +32,10 @@ import { UserRepositoryModule } from '../modules/user/user.repository.module';
     SuperAdminSeeder,
     UserRepository,
     UserRoleRepository,
+    RegionSeeder,
+    RegionRepository,
+    TimeZoneSeeder,
+    TimeZoneRepository,
   ],
   exports: [SeederService],
   controllers: [],

libs/common/src/seed/services/regions.seeder.ts

@@ -0,0 +1,40 @@
+import { RegionRepository } from '@app/common/modules/region/repositories';
+import { allCountries } from '@app/common/constants/regions';
+import { Injectable } from '@nestjs/common';
+
+@Injectable()
+export class RegionSeeder {
+  constructor(private readonly regionRepository: RegionRepository) {}
+
+  async addRegionDataIfNotFound(): Promise<void> {
+    try {
+      const existingRegions = await this.regionRepository.find();
+
+      const regionNames = existingRegions.map((region) => region.regionName);
+
+      const missingRegions = allCountries.filter(
+        (country) => !regionNames.includes(country),
+      );
+
+      if (missingRegions.length > 0) {
+        await this.addRegionData(missingRegions);
+      }
+    } catch (err) {
+      console.error('Error while checking region data:', err);
+      throw err;
+    }
+  }
+
+  private async addRegionData(regions: string[]): Promise<void> {
+    try {
+      const regionEntities = regions.map((regionName) => ({
+        regionName,
+      }));
+
+      await this.regionRepository.save(regionEntities);
+    } catch (err) {
+      console.error('Error while adding region data:', err);
+      throw err;
+    }
+  }
+}

libs/common/src/seed/services/seeder.service.ts

@@ -3,12 +3,16 @@ import { PermissionTypeSeeder } from './permission.type.seeder';
 import { RoleTypeSeeder } from './role.type.seeder';
 import { SpaceTypeSeeder } from './space.type.seeder';
 import { SuperAdminSeeder } from './supper.admin.seeder';
+import { RegionSeeder } from './regions.seeder';
+import { TimeZoneSeeder } from './timezone.seeder';
 @Injectable()
 export class SeederService {
   constructor(
     private readonly permissionTypeSeeder: PermissionTypeSeeder,
     private readonly roleTypeSeeder: RoleTypeSeeder,
     private readonly spaceTypeSeeder: SpaceTypeSeeder,
+    private readonly regionSeeder: RegionSeeder,
+    private readonly timeZoneSeeder: TimeZoneSeeder,
     private readonly superAdminSeeder: SuperAdminSeeder,
   ) {}
 
@@ -16,6 +20,8 @@ export class SeederService {
     await this.permissionTypeSeeder.addPermissionTypeDataIfNotFound();
     await this.roleTypeSeeder.addRoleTypeDataIfNotFound();
     await this.spaceTypeSeeder.addSpaceTypeDataIfNotFound();
+    await this.regionSeeder.addRegionDataIfNotFound();
+    await this.timeZoneSeeder.addTimeZoneDataIfNotFound();
     await this.superAdminSeeder.createSuperAdminIfNotFound();
   }
 }

libs/common/src/seed/services/timezone.seeder.ts

@@ -0,0 +1,42 @@
+import { TimeZoneRepository } from '@app/common/modules/timezone/repositories';
+import { allTimeZones } from '@app/common/constants/timezones';
+import { Injectable } from '@nestjs/common';
+
+@Injectable()
+export class TimeZoneSeeder {
+  constructor(private readonly timeZoneRepository: TimeZoneRepository) {}
+
+  async addTimeZoneDataIfNotFound(): Promise<void> {
+    try {
+      const existingTimeZones = await this.timeZoneRepository.find();
+      const timeZoneNames = existingTimeZones.map((tz) => tz.cityName);
+
+      const missingTimeZones = allTimeZones.filter(
+        (tz) => !timeZoneNames.includes(tz.name),
+      );
+
+      if (missingTimeZones.length > 0) {
+        await this.addTimeZoneData(missingTimeZones);
+      }
+    } catch (err) {
+      console.error('Error while checking time zone data:', err);
+      throw err;
+    }
+  }
+
+  private async addTimeZoneData(
+    timeZones: { name: string; offset: string }[],
+  ): Promise<void> {
+    try {
+      const timeZoneEntities = timeZones.map((tz) => ({
+        cityName: tz.name,
+        timeZoneOffset: tz.offset,
+      }));
+
+      await this.timeZoneRepository.save(timeZoneEntities);
+    } catch (err) {
+      console.error('Error while adding time zone data:', err);
+      throw err;
+    }
+  }
+}