TASKS-1823 WebManager module

apps/backend/app/base_modules/WebManager/controller/public_web_manager_controller.ts

@@ -0,0 +1,50 @@
+import type { HttpContext } from '@adonisjs/core/http'
+import WebManagerService from '#base_modules/WebManager/services/web_manager_service'
+import PreviewTokenService from '#base_modules/WebManager/services/preview_token_service'
+import {
+  previewRequestValidator,
+  publicBlogListValidator,
+  publicPageValidator,
+  publicSitemapValidator,
+} from '#base_modules/WebManager/validator/page_validator'
+import { settingsQueryValidator } from '#base_modules/WebManager/validator/settings_validator'
+
+export default class PublicWebManagerController {
+  private webManagerService = new WebManagerService()
+  private previewTokenService = new PreviewTokenService()
+
+  async blogList({ request }: HttpContext) {
+    const filters = await publicBlogListValidator.validate(request.qs())
+    return this.webManagerService.listPublicBlogPages(filters)
+  }
+
+  async sitemap({ request }: HttpContext) {
+    const filters = await publicSitemapValidator.validate(request.qs())
+    return this.webManagerService.listPublicSitemapPages(filters)
+  }
+
+  async resolve({ request, response }: HttpContext) {
+    const { locale, path } = await publicPageValidator.validate(request.qs())
+    const result = await this.webManagerService.resolvePublicPage(locale, path)
+    if (!result) return response.notFound({ message: 'Page not found' })
+    return response.ok(result)
+  }
+
+  async preview({ request, response }: HttpContext) {
+    const { token } = await previewRequestValidator.validate(request.qs())
+    const payload = this.previewTokenService.verify(token)
+    if (!payload) return response.notFound({ message: 'Preview token is invalid or expired' })
+
+    const result = await this.webManagerService.resolvePreviewPage(payload.pageId)
+    return response.ok(result)
+  }
+
+  async settings({ request, response }: HttpContext) {
+    const { locale } = await settingsQueryValidator.validate(request.qs())
+    if (!locale) return response.badRequest({ message: 'Locale is required' })
+
+    const settings = await this.webManagerService.getSettings(locale)
+    if (!settings) return response.notFound({ message: 'Settings not found' })
+    return response.ok({ settings })
+  }
+}

apps/backend/app/base_modules/WebManager/controller/web_manager_controller.ts

@@ -0,0 +1,98 @@
+import type { HttpContext } from '@adonisjs/core/http'
+import WebManagerPolicy from '#base_modules/WebManager/policy/web_manager_policy'
+import WebManagerService from '#base_modules/WebManager/services/web_manager_service'
+import PagePayloadService from '#base_modules/WebManager/services/page_payload_service'
+import PreviewTokenService from '#base_modules/WebManager/services/preview_token_service'
+import {
+  createPageValidator,
+  listPagesValidator,
+  previewTokenValidator,
+  saveDraftValidator,
+} from '#base_modules/WebManager/validator/page_validator'
+import {
+  saveSettingsValidator,
+  settingsQueryValidator,
+} from '#base_modules/WebManager/validator/settings_validator'
+
+export default class WebManagerController {
+  private webManagerService = new WebManagerService()
+  private pagePayloadService = new PagePayloadService()
+  private previewTokenService = new PreviewTokenService()
+
+  async index({ request, response, bouncer }: HttpContext) {
+    await bouncer.with(WebManagerPolicy).authorize('view')
+    const filters = await listPagesValidator.validate(request.qs())
+    const pages = await this.webManagerService.listPages(filters)
+    return response.ok(pages.serialize())
+  }
+
+  async groupKeys({ response, bouncer }: HttpContext) {
+    await bouncer.with(WebManagerPolicy).authorize('view')
+    const groupKeys = await this.webManagerService.listGroupKeys()
+    return response.ok({ data: groupKeys })
+  }
+
+  async store({ request, response, bouncer }: HttpContext) {
+    await bouncer.with(WebManagerPolicy).authorize('create')
+    const payload = this.pagePayloadService.parse(request)
+    const input = await createPageValidator.validate(payload)
+    const resolved = await this.pagePayloadService.resolveLocalFiles(request, input)
+    const page = await this.webManagerService.createDraft(resolved)
+    return response.created({ data: page })
+  }
+
+  async show({ params, response, bouncer }: HttpContext) {
+    await bouncer.with(WebManagerPolicy).authorize('view')
+    const page = await this.webManagerService.getPage(Number(params.id))
+    return response.ok({ data: page })
+  }
+
+  async saveDraft({ params, request, response, bouncer }: HttpContext) {
+    await bouncer.with(WebManagerPolicy).authorize('update')
+    const payload = this.pagePayloadService.parse(request)
+    const input = await saveDraftValidator.validate(payload)
+    const resolved = await this.pagePayloadService.resolveLocalFiles(request, input)
+    const page = await this.webManagerService.saveDraft(Number(params.id), resolved)
+    return response.ok({ data: page })
+  }
+
+  async publish({ params, response, bouncer }: HttpContext) {
+    await bouncer.with(WebManagerPolicy).authorize('publish')
+    const { page, revalidation } = await this.webManagerService.publish(Number(params.id))
+    return response.ok({ data: page, meta: { revalidation } })
+  }
+
+  async unpublish({ params, response, bouncer }: HttpContext) {
+    await bouncer.with(WebManagerPolicy).authorize('publish')
+    const { page, revalidation } = await this.webManagerService.unpublish(Number(params.id))
+    return response.ok({ data: page, meta: { revalidation } })
+  }
+
+  async destroy({ params, response, bouncer }: HttpContext) {
+    await bouncer.with(WebManagerPolicy).authorize('delete')
+    await this.webManagerService.discard(Number(params.id))
+    return response.noContent()
+  }
+
+  async createPreviewToken({ params, request, response, bouncer }: HttpContext) {
+    await bouncer.with(WebManagerPolicy).authorize('view')
+    await this.webManagerService.getPage(Number(params.id))
+    const { expiresIn } = await previewTokenValidator.validate(request.all())
+    const preview = this.previewTokenService.create(Number(params.id), expiresIn)
+    return response.created({ data: preview })
+  }
+
+  async getSettings({ request, response, bouncer }: HttpContext) {
+    await bouncer.with(WebManagerPolicy).authorize('view')
+    const { locale } = await settingsQueryValidator.validate(request.qs())
+    const settings = await this.webManagerService.getSettings(locale)
+    return response.ok({ data: settings })
+  }
+
+  async saveSettings({ request, response, bouncer }: HttpContext) {
+    await bouncer.with(WebManagerPolicy).authorize('manageSettings')
+    const input = await saveSettingsValidator.validate(request.all())
+    const { settings, revalidation } = await this.webManagerService.saveSettings(input)
+    return response.ok({ data: settings, meta: { revalidation } })
+  }
+}