erp-platform/ui/src/services/blog.service.ts

import apiService from '@/services/api.service'

export interface BlogPost {
  id: string
  title: string
  slug: string
  content?: string
  summary: string
  coverImage?: string
  author: {
    id: string
    name: string
    avatar?: string
  }
  category: {
    id: string
    name: string
    slug: string
  }
  tags: string[]
  viewCount: number
  likeCount: number
  commentCount: number
  isPublished: boolean
  publishedAt?: string
  createdAt: string
  updatedAt: string
}

export interface BlogCategory {
  id: string
  name: string
  slug: string
  description?: string
  postCount: number
  isActive: boolean
  icon: string
  displayOrder: number
}

export interface BlogComment {
  id: string
  postId: string
  content: string
  author: {
    id: string
    name: string
    avatar?: string
  }
  parentId?: string
  replies?: BlogComment[]
  likeCount: number
  isLiked?: boolean
  createdAt: string
  updatedAt: string
}

export interface CreateUpdateBlogPostDto {
  title: string
  slug: string
  content: string
  summary: string
  categoryId: string
  tags: string[]
  coverImage?: string
  isPublished: boolean
}

export interface CreateUpdateBlogCategoryDto {
  name: string
  slug: string
  description: string
  icon?: string
  displayOrder: number
  isActive: boolean
}

export interface CreateCommentDto {
  postId: string
  content: string
  parentId?: string
}

export interface BlogListParams {
  page?: number
  pageSize?: number
  categoryId?: string
  tag?: string
  search?: string
  authorId?: string
  sortBy?: 'latest' | 'popular' | 'trending'
}

export interface PaginatedResponse<T> {
  items: T[]
  totalCount: number
  pageNumber: number
  pageSize: number
  totalPages: number
}

class BlogService {
  async getPosts(params: BlogListParams = {}): Promise<PaginatedResponse<BlogPost>> {
    const response = await apiService.fetchData<PaginatedResponse<BlogPost>>({
      url: '/api/app/blog/posts',
      method: 'GET',
      params,
    })
    return response.data
  }

  async getPostBySlug(slug: string): Promise<BlogPost> {
    const response = await apiService.fetchData<BlogPost>({
      url : `/api/app/blog/posts/post-by-slug/${slug}`,
      method: 'GET',
    })
    return response.data;
  }

  async getPost(idOrSlug: string): Promise<BlogPost> {
    const response = await apiService.fetchData<BlogPost>({
      url: `/api/app/blog/posts/${idOrSlug}`,
      method: 'GET',
    })
    return response.data
  }

  async createPost(data: CreateUpdateBlogPostDto): Promise<BlogPost> {
    const response = await apiService.fetchData<BlogPost>({
      url: '/api/app/blog/post',
      method: 'POST',
      data: data as any,
    })
    return response.data
  }

  async updatePost(id: string, data: CreateUpdateBlogPostDto): Promise<BlogPost> {
    const response = await apiService.fetchData<BlogPost>({
      url: `/api/app/blog/${id}/post`,
      method: 'PUT',
      data: data as any,
    })
    return response.data
  }

  async deletePost(id: string): Promise<void> {
    await apiService.fetchData({
      url: `/api/app/blog/${id}/post`,
      method: 'DELETE',
    })
  }

  async publishPost(id: string): Promise<BlogPost> {
    const response = await apiService.fetchData<BlogPost>({
      url: `/api/app/blog/${id}/publish-post`,
      method: 'POST',
    })
    return response.data
  }

  async unpublishPost(id: string): Promise<BlogPost> {
    const response = await apiService.fetchData<BlogPost>({
      url: `/api/app/blog/${id}/unpublish-post`,
      method: 'POST',
    })
    return response.data
  }

  async getCategories(): Promise<BlogCategory[]> {
    const response = await apiService.fetchData<BlogCategory[]>({
      url: '/api/app/blog/categories',
      method: 'GET',
    })
    return response.data
  }

  async getComments(postId: string): Promise<BlogComment[]> {
    const response = await apiService.fetchData<BlogComment[]>({
      url: `/api/app/blog/posts/${postId}/comments`,
      method: 'GET',
    })
    return response.data
  }

  async createComment(data: CreateCommentDto): Promise<BlogComment> {
    const response = await apiService.fetchData<BlogComment>({
      url: '/api/app/blog/comments',
      method: 'POST',
      data: data as any,
    })
    return response.data
  }

  async deleteComment(id: string): Promise<void> {
    await apiService.fetchData({
      url: `/api/app/blog/comments/${id}`,
      method: 'DELETE',
    })
  }

  async likePost(postId: string): Promise<void> {
    await apiService.fetchData({
      url: `/api/app/blog/${postId}/like-post`,
      method: 'POST',
    })
  }

  async unlikePost(postId: string): Promise<void> {
    await apiService.fetchData({
      url: `/api/app/blog/${postId}/unlike-post`,
      method: 'DELETE',
    })
  }

  async likeComment(commentId: string): Promise<void> {
    await apiService.fetchData({
      url: `/api/app/blog/comments/${commentId}/like`,
      method: 'POST',
    })
  }

  async unlikeComment(commentId: string): Promise<void> {
    await apiService.fetchData({
      url: `/api/app/blog/comments/${commentId}/like`,
      method: 'DELETE',
    })
  }

  async getTags(): Promise<string[]> {
    const response = await apiService.fetchData<string[]>({
      url: '/api/app/blog/tags',
      method: 'GET',
    })
    return response.data
  }

  // Category methods
  async getCategory(id: string): Promise<BlogCategory> {
    const response = await apiService.fetchData<BlogCategory>({
      url: `/api/app/blog/${id}/category`,
      method: 'GET',
    })
    return response.data
  }

  async createCategory(data: CreateUpdateBlogCategoryDto): Promise<BlogCategory> {
    const response = await apiService.fetchData<BlogCategory>({
      url: '/api/app/blog/category',
      method: 'POST',
      data: data as any,
    })
    return response.data
  }

  async updateCategory(id: string, data: CreateUpdateBlogCategoryDto): Promise<BlogCategory> {
    const response = await apiService.fetchData<BlogCategory>({
      url: `/api/app/blog/${id}/category`,
      method: 'PUT',
      data: data as any,
    })
    return response.data
  }

  async deleteCategory(id: string): Promise<void> {
    await apiService.fetchData({
      url: `/api/app/blog/${id}/category`,
      method: 'DELETE',
    })
  }
}

export const blogService = new BlogService()