live blog implemented

backend/src/modules/strapi.service.ts

@@ -3,8 +3,9 @@ import { ConfigService } from '@nestjs/config';
 import { HttpService } from '@nestjs/axios';
 import { lastValueFrom } from 'rxjs';
 import { ArticlesService } from './articles.service';
-import { CreateArticleDto } from './articles.dto';
-import { ArticleStatus } from './entities';
+import { LiveBlogService } from './live-blog.service';
+import { CreateArticleDto, CreateLiveBlogDto } from './articles.dto';
+import { ArticleStatus, LiveBlogStatus } from './entities';
 
 interface StrapiArticle {
   id: number;
@@ -18,6 +19,18 @@ interface StrapiArticle {
   updatedAt: string;
 }
 
+interface StrapiLiveBlog {
+  id: number;
+  documentId: string;
+  title: string;
+  description: string;
+  slug: string;
+  status: 'draft' | 'live' | 'ended' | 'archived';
+  publishedAt: string | null;
+  createdAt: string;
+  updatedAt: string;
+}
+
 interface StrapiResponse<T> {
   data: T;
   meta: {
@@ -40,6 +53,7 @@ export class StrapiService {
     private readonly configService: ConfigService,
     private readonly httpService: HttpService,
     private readonly articlesService: ArticlesService,
+    private readonly liveBlogService: LiveBlogService,
   ) {
     this.strapiUrl =
       this.configService.get<string>('STRAPI_URL') || 'http://localhost:1337';
@@ -140,17 +154,116 @@ export class StrapiService {
     }
   }
 
+  async syncLiveBlogs(): Promise<void> {
+    try {
+      this.logger.log('Starting live blogs sync from Strapi...');
+
+      const response = await lastValueFrom(
+        this.httpService.get<StrapiResponse<StrapiLiveBlog[]>>(
+          `${this.strapiUrl}/api/live-blogs`,
+          {
+            headers: this.getHeaders(),
+          },
+        ),
+      );
+
+      const strapiLiveBlogs = response.data.data;
+      let syncedCount = 0;
+
+      for (const strapiLiveBlog of strapiLiveBlogs) {
+        const liveBlogData: Partial<CreateLiveBlogDto> = {
+          title: strapiLiveBlog.title,
+          description: strapiLiveBlog.description,
+          slug: strapiLiveBlog.slug,
+          status: this.mapStrapiStatusToLiveBlogStatus(strapiLiveBlog.status),
+        };
+
+        await this.liveBlogService.syncFromStrapi(
+          strapiLiveBlog.documentId,
+          liveBlogData,
+        );
+        syncedCount++;
+      }
+
+      this.logger.log(
+        `Successfully synced ${syncedCount} live blogs from Strapi`,
+      );
+    } catch (error) {
+      this.logger.error('Failed to sync live blogs from Strapi', error);
+      throw error;
+    }
+  }
+
+  async syncSingleLiveBlog(strapiId: string): Promise<void> {
+    try {
+      this.logger.log(`Syncing single live blog from Strapi: ${strapiId}`);
+
+      const response = await lastValueFrom(
+        this.httpService.get<StrapiResponse<StrapiLiveBlog>>(
+          `${this.strapiUrl}/api/live-blogs/${strapiId}`,
+          {
+            headers: this.getHeaders(),
+          },
+        ),
+      );
+
+      const strapiLiveBlog = response.data.data;
+      const liveBlogData: Partial<CreateLiveBlogDto> = {
+        title: strapiLiveBlog.title,
+        description: strapiLiveBlog.description,
+        slug: strapiLiveBlog.slug,
+        status: this.mapStrapiStatusToLiveBlogStatus(strapiLiveBlog.status),
+      };
+
+      await this.liveBlogService.syncFromStrapi(
+        strapiLiveBlog.documentId,
+        liveBlogData,
+      );
+      this.logger.log(`Successfully synced live blog: ${strapiLiveBlog.title}`);
+    } catch (error) {
+      this.logger.error(
+        `Failed to sync live blog ${strapiId} from Strapi`,
+        error,
+      );
+      throw error;
+    }
+  }
+
+  private mapStrapiStatusToLiveBlogStatus(status: string): LiveBlogStatus {
+    switch (status) {
+      case 'live':
+        return LiveBlogStatus.LIVE;
+      case 'draft':
+        return LiveBlogStatus.DRAFT;
+      case 'ended':
+        return LiveBlogStatus.ENDED;
+      case 'archived':
+        return LiveBlogStatus.ARCHIVED;
+      default:
+        return LiveBlogStatus.DRAFT;
+    }
+  }
+
   async handleWebhook(
     event: 'entry.create' | 'entry.update' | 'entry.delete',
-    data: { documentId: string },
+    data: { documentId: string; model?: string },
   ): Promise<void> {
-    this.logger.log(`Received webhook event: ${event}`);
+    this.logger.log(
+      `Received webhook event: ${event} for model: ${data.model}`,
+    );
 
     if (event === 'entry.delete') {
       this.logger.log(`Handling delete for document: ${data.documentId}`);
       return;
     }
 
-    await this.syncSingleArticle(data.documentId);
+    // Route to appropriate sync method based on model
+    if (data.model === 'article') {
+      await this.syncSingleArticle(data.documentId);
+    } else if (data.model === 'live-blog') {
+      await this.syncSingleLiveBlog(data.documentId);
+    } else {
+      this.logger.warn(`Unknown model type in webhook: ${data.model}`);
+    }
   }
 }