refactor(app/learn): use new request way

Author: ourai

src/app/creator/learn/[type]/[id]/StepThree.js

@@ -23,7 +23,6 @@ import { Button } from '@/components/Button';
 import { PlusIcon } from '@/components/icon/outlined';
 import { EditIcon, DeleteIcon, AddIcon } from '@/components/Icons';
 import { OEditor } from '@/components/MarkDown';
-// import { useCourseDetails } from '#/services/learn/hooks'
 import { Modal } from '@/components/Modal';
 import { Select } from '@/components/Select';
 import  { BASE_INPUT_STYLE } from '@/constants/config';

src/app/learn/NFTCertificates.js

@@ -15,7 +15,13 @@
  */
 
 import { PAGE_SIZE } from '@/constants/config';
-import { get } from '@/utils/request';
+import { pick } from '@/utils';
+
+import { fetchList as fetchChallengeList } from '#/domain/challenge/repository';
+import { fetchList as fetchCourseList } from '#/domain/course/repository';
+import { fetchList as fetchRoadmapList } from '#/domain/roadmap/repository';
+
+import type { ListValue, ResponseResult } from '@/types';
 
 import LearnListAdapter from './LearnListAdapter';
 
@@ -32,23 +38,41 @@ export async function Container({ type, searchParams }: { type: string; searchPa
   const body_type = searchParams?.body_type || '';
   const lang = searchParams?.lang || '';
 
-  let URL;
+  const params = {
+    skip: (page - 1) * PAGE_SIZE,
+    take: PAGE_SIZE,
+    sort: order,
+    labels,
+    search: query,
+  };
+
+  let req: Promise<ResponseResult> | undefined;
 
   if (type === 'courses' && lang) {
-    URL = `v1/learn/course/opencourse?&skip=${(page - 1) * PAGE_SIZE}&take=${PAGE_SIZE}&labels=${labels}&order=${order}&search=${query}&recommend_type=${featured}&body_type=${body_type}&lang=${lang}`;
+    req = fetchCourseList({
+      ...params,
+      recommend_type: featured,
+      body_type,
+      lang,
+    });
   } else if (type === 'challenges') {
-    URL = `v1/learn/course/challenges?&skip=${(page - 1) * PAGE_SIZE}&take=${PAGE_SIZE}&labels=${labels}&order=${order}&search=${query}&status=${status}&feeds=${feeds}&c_type=${c_type}`;
+    req = fetchChallengeList({
+      ...params,
+      status,
+      feeds,
+      c_type,
+    });
   } else if (type === 'career_path') {
-    URL = `/ts/v1/learn/general/course/grow_path?order=${order}`;
+    req = fetchRoadmapList(pick(params, ['sort']));
   }
 
-  let data;
+  let data: { list: ListValue; count: number };
 
-  if (URL) {
-    const res = await get(URL, { isServer: true });
+  if (req) {
+    const res = await req;
     data = res.data;
   } else {
-    data = await Promise.resolve({ count: 0 });
+    data = await Promise.resolve({ list: [], count: 0 });
   }
 
   return (

src/app/learn/[type]/Container.tsx

@@ -18,9 +18,8 @@
 
 import { revalidatePath } from 'next/cache';
 
-import { post } from '@/utils/request';
-
 import { enrollOne as enrollCourse } from '#/domain/course/repository';
+import { enrollOne as enrollRoadmap } from '#/domain/roadmap/repository';
 
 export async function enrollAction(id) {
   try {
@@ -37,13 +36,8 @@ export async function revalidatePathAction() {
 
 export async function growPathEnrollAction(id) {
   try {
-    const res = await post(`ts/v1/learn/general/course/grow_path/${id}/permission/enrool`, {}, { isServer: true });
-    console.log(res, 'res');
-    if (res.code === 200) {
-      return revalidatePath('/');
-    } else {
-      return res;
-    }
+    const res = await enrollRoadmap(id);
+    return res.success ? revalidatePath('/') : res;
   } catch (e) {
     return { message: 'Failed to request' };
   }

src/app/learn/[type]/[id]/actions.js

@@ -15,18 +15,18 @@
  */
 
 import { PreviewAlert } from '@/components/PreviewAlert';
-import { get } from '@/utils/request';
 
-import { fetchOneWithPermission as fetchChallengeWithPermission } from '#/domain/challenge/repository';
-import { fetchOneWithPermission as fetchCourseWithPermission } from '#/domain/course/repository';
+import { fetchOne as fetchChallenge, fetchOneWithPermission as fetchChallengeWithPermission, fetchRelatedCourse } from '#/domain/challenge/repository';
+import { fetchOne as fetchCourse, fetchOneWithPermission as fetchCourseWithPermission } from '#/domain/course/repository';
+import { fetchOneWithPermission as fetchRoadmapWithPermission } from '#/domain/roadmap/repository';
 
 import { enrollAction, revalidatePathAction } from './actions';
 import CourseDetailPageAdapter from './CourseDetailPageAdapter';
 import GrowPath from './GrowPath';
 
 export async function generateMetadata({ params }) {
-  // fetch data
-  const { data } = await get(`v1/learn/course/${params.type === 'courses' ? 'opencourse' : 'challenges'}/${params.id}`, {isServer: true});
+  const fetchOne = params.type === 'courses'? fetchCourse : fetchChallenge;
+  const { data } = await fetchOne(params.id);
   const previousImages = data?.base?.course_series_img ? `https://file-cdn.openbuild.xyz${data.base.course_series_img}` : '';
   return {
     title: data?.base?.course_series_title,
@@ -52,12 +52,9 @@ export default async function LearnDetailsPage({ params, searchParams }) {
   let data, permission;
 
   if (learnType === 'career_path') {
-    const datas = await Promise.all([
-      get(`ts/v1/learn/general/course/grow_path/${learnId}`, {isServer: true}),
-      get(`ts/v1/learn/general/course/grow_path/${learnId}/permission`, {isServer: true}),
-    ]);
-    data = datas[0].data;
-    permission = datas[1].data;
+    const roadmapRes = await fetchRoadmapWithPermission(learnId);
+    data = roadmapRes.data;
+    permission = (roadmapRes.data || {}).permission;
   } else {
     const fetchOneWithPermission = learnType === 'courses' ? fetchCourseWithPermission : fetchChallengeWithPermission;
     const res = await fetchOneWithPermission(learnId);
@@ -68,7 +65,7 @@ export default async function LearnDetailsPage({ params, searchParams }) {
   let related = null;
 
   if (learnType === 'challenges' && data?.challenges_extra?.course_challenges_extra_time_order === 0) {
-    const res = await get(`ts/v1/learn/general/course/challenges/${learnId}/link`, { isServer: true });
+    const res = await fetchRelatedCourse(learnId);
 
     if (res.data.link.toString() !== learnId) {
       related = res.data;

src/app/learn/[type]/[id]/page.js

@@ -14,15 +14,30 @@
  * limitations under the License.
  */
 
+import { PAGE_SIZE } from '@/constants/config';
 import { merge } from '@/utils';
 import httpClient, { legacyClient, mergeMultipleResponses } from '@/utils/http';
 
 import { fetchPermission, fetchLessonDetail } from '../course/repository';
 
+async function fetchList(params = {}) {
+  const { sort, ...others } = params;
+
+  return legacyClient.get('/learn/course/challenges', {
+    params: merge({ take: PAGE_SIZE }, others, {
+      order: sort || 'default',
+    }),
+  });
+}
+
 async function fetchOne(id) {
   return legacyClient.get(`/learn/course/challenges/${id}`);
 }
 
+async function enrollOne(id, data) {
+  return httpClient.post(`/learn/general/course/challenges/${id}/permission/enrool`, data);
+}
+
 async function fetchOneWithPermission(id) {
   return mergeMultipleResponses([fetchOne(id), fetchPermission(id)], ([{ data, ...others }, permission]) => ({
     ...others,
@@ -37,29 +52,30 @@ async function fetchLessonWithEntity({ id, entityId }) {
   }));
 }
 
-async function fetchPublishedChallengeList(params = {}) {
-  const { userId, sort, ...others } = params;
+async function fetchRelatedCourse(id) {
+  return httpClient.get(`/learn/general/course/challenges/${id}/link`);
+}
 
-  return legacyClient.get('/learn/course/challenges', {
-    params: merge({ take: 20 }, others, {
-      team_uid: userId,
-      order: sort || 'default',
-    }),
-  });
+async function fetchPublishedChallengeList(params = {}) {
+  return fetchList({ ...params, team_uid: params.userId });
 }
 
 async function fetchEnrolledChallengeList(params = {}) {
   const { userId, sort, ...others } = params;
 
   return legacyClient.get('/learn/dashboard/public/enrool/series', {
-    params: merge({ take: 20 }, others, {
+    params: merge({ take: PAGE_SIZE }, others, {
       id: userId,
       series_type: 'challenges',
       order: sort || 'default',
     }),
   });
 }
 
+async function updateTransaction(id, data) {
+  return httpClient.post(`/learn/general/course/challenges/${id}/permission/pay`, data);
+}
+
 async function updateMultipleApplicantStatus(id, { userIds, status }) {
   return httpClient.post(`/learn/creator/series/${id}/batch/enrool/status`, { uids: userIds, status });
 }
@@ -79,8 +95,9 @@ async function updateEmailTemplate(id, { title, body }) {
 }
 
 export {
-  fetchOne, fetchOneWithPermission, fetchLessonWithEntity,
+  fetchList, fetchOne, enrollOne,
+  fetchOneWithPermission, fetchLessonWithEntity, fetchRelatedCourse,
   fetchPublishedChallengeList, fetchEnrolledChallengeList,
-  updateMultipleApplicantStatus,
+  updateTransaction, updateMultipleApplicantStatus,
   fetchEmailTemplate, updateEmailTemplate,
 };

src/domain/challenge/repository.js

@@ -58,6 +58,10 @@ async function fetchLessonWithEntity({ id, entityId }) {
   }));
 }
 
+async function updateWatchProgress(lessonId) {
+  return httpClient.post(`/learn/general/course/single/${lessonId}/time`);
+}
+
 async function fetchPublishedCourseList(params = {}) {
   return fetchList({ ...params, team_uid: params.userId });
 }
@@ -77,6 +81,6 @@ async function fetchEnrolledCourseList(params = {}) {
 export {
   fetchList, fetchOne, enrollOne,
   fetchPermission, fetchOneWithPermission,
-  fetchLessonDetail, fetchLessonWithEntity,
+  fetchLessonDetail, fetchLessonWithEntity, updateWatchProgress,
   fetchPublishedCourseList, fetchEnrolledCourseList,
 };

src/domain/course/repository.js

@@ -0,0 +1,46 @@
+/**
+ * Copyright 2024 OpenBuild
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+import httpClient, { mergeMultipleResponses } from '@/utils/http';
+
+import type { EntityId } from '@/types';
+
+async function fetchList(params: { sort?: string; } = {}) {
+  const { sort: order, ...others } = params;
+
+  return httpClient.get('/learn/general/course/grow_path', { params: { ...others, order } });
+}
+
+async function fetchOne(id: EntityId) {
+  return httpClient.get(`/learn/general/course/grow_path/${id}`);
+}
+
+async function enrollOne(id: EntityId) {
+  return httpClient.post(`/learn/general/course/grow_path/${id}/permission/enrool`);
+}
+
+async function fetchPermission(id: EntityId) {
+  return httpClient.get(`/learn/general/course/grow_path/${id}/permission`);
+}
+
+async function fetchOneWithPermission(id: EntityId) {
+  return mergeMultipleResponses([fetchOne(id), fetchPermission(id)], ([{ data, ...others }, permission]) => ({
+    ...others,
+    data: { ...data, permission: permission.data },
+  }));
+}
+
+export { fetchList, fetchOne, enrollOne, fetchOneWithPermission };

src/domain/roadmap/repository.ts

@@ -14,13 +14,13 @@
  * limitations under the License.
  */
 
-import type { DataValue } from '@/types';
+import type { ListValue } from '@/types';
 import type { ClassValue } from 'clsx';
 import type { JSXElementConstructor, PropsWithChildren, ReactNode } from 'react';
 
 type ListProps = {
   className?: ClassValue;
-  data: Record<string, DataValue>[];
+  data: ListValue;
   total: number;
 };