feat:环节&单元解锁逻辑

吴启风
1 parent 8df5fbf9
Showing 5 changed files with 126 additions and 28 deletions
.gitignore
lib/pages/section/bloc/section_bloc.dart
lib/pages/unit/bloc.dart
lib/pages/unit/view.dart
lib/utils/list_ext.dart
@@ -68,6 +68,7 @@
 **/ios/xcode_build_ipa_adh
 **/ios/xcode_build_ipa_aps
 **/ios/xcode_build_ipa_dev
+**/ios/build/
  
 # Exceptions to above rules.
 !**/ios/**/default.mode1v3
@@ -200,7 +200,7 @@ class SectionBloc extends Bloc&lt;SectionEvent, SectionState&gt; {
     final curCourseSectionEntity = findCourseSectionById(courseLessonId);
     if (curCourseSectionEntity != null) {
       final curCourseUnitDetail = _courseUnitEntity.courseUnitVOList
-          ?.firstWhere(
+          ?.firstWhereOrNull(
               (element) => element.id == curCourseSectionEntity.courseUnitId);
       return curCourseUnitDetail;
     }
@@ -213,39 +213,86 @@ class SectionBloc extends Bloc&lt;SectionEvent, SectionState&gt; {
     final curCourseSectionEntity = findCourseSectionById(courseLessonId);
     final curSectionSort = curCourseSectionEntity?.sortOrder ?? 0;
  
-    ///查找下一个section
-    final nextCourseSectionEntity = findCourseSectionBySort(curSectionSort + 1);
-    if (nextCourseSectionEntity != null) {
-      return nextCourseSectionEntity;
+    try {
+      ///查找当前unit的下一个section
+      CourseSectionEntity? nextCourseSectionEntity =
+          findCourseSectionBySort(curSectionSort + 1);
+      return checkCourseSectionLocked(courseLessonId, nextCourseSectionEntity, emitter);
+    } catch (e) {
+      if (e is ApiException) {
+        showToast(e.message.toString());
+      }
+      return null;
+    }
+  }
+
+  ///检查section是否锁定
+  Future<CourseSectionEntity?> checkCourseSectionLocked(int courseLessonId, CourseSectionEntity? courseSectionEntity,
+      Emitter<SectionState> emitter) async {
+    if (courseSectionEntity != null) {
+      if (courseSectionEntity.lock == false) {
+        ///如果section没锁，直接返回
+        return courseSectionEntity;
+      } else {
+        ///如果section锁了，请求当前unit下的section数据,查询解锁状态
+        int courseUnitId = courseSectionEntity.courseUnitId;
+        await loading(() async {
+          List<CourseSectionEntity>? tempSectionEntities =
+          await LessonDao.courseSection(courseUnitId: courseUnitId);
+          if (tempSectionEntities != null) {
+            _courseSectionDatasMap[courseUnitId] = tempSectionEntities;
+            emitter(LessonDataLoadState());
+          }
+          courseSectionEntity = tempSectionEntities?.firstWhereOrNull(
+                  (element) => element.id == courseSectionEntity?.id);
+          if (courseSectionEntity?.lock == false) {
+            ///刷新后的数据如果解锁了，直接返回
+            return courseSectionEntity;
+          } else {
+            ///请求失败或者锁定状态没变（没变就感觉状态异常了，理论上不应该进入这条分支），返回null
+            showToast('下个课程还没解锁哦');
+            return null;
+          }
+        });
+      }
     } else {
-      ///section为空说明当前unit学完了，找下一个unit。（跨unit选lesson）
+      ///section为空说明当前unit学完了，找下一个unit。（跨unit选section）
       ///先根据courseLessonId找出当前的unit
       final curCourseUnitDetail = findCourseUnitDetailById(courseLessonId);
       if (curCourseUnitDetail != null) {
-        ///再根据当前unit找出下一个unit
-        final nextCourseUnitDetail = _courseUnitEntity.courseUnitVOList
-            ?.firstWhere((element) =>
-                element.sortOrder == (curCourseUnitDetail.sortOrder! + 1));
+        ///再根据当前unit的sortOrder找出下一个unit
+        CourseUnitDetail? nextCourseUnitDetail =
+        _courseUnitEntity.courseUnitVOList?.firstWhereOrNull((element) =>
+          element.sortOrder == (curCourseUnitDetail.sortOrder! + 1));
+
         if (nextCourseUnitDetail != null) {
-          final courseUnitId = nextCourseUnitDetail.id!;
-          try {
+          if (nextCourseUnitDetail.lock == true) {
+            ///如果下一个unit是锁定状态，请求数据刷新查询解锁状态
             await loading(() async {
-              _courseSectionDatasMap[courseUnitId] =
-                  await LessonDao.courseSection(courseUnitId: courseUnitId);
-              emitter(LessonDataLoadState());
+              CourseUnitEntity? newCourseUnitEntity = await LessonDao.courseUnit(
+                  _courseUnitEntity.nowCourseModuleId);
+
+              ///拿到重新获取到的unit后，再次判断是否解锁
+              nextCourseUnitDetail = newCourseUnitEntity?.courseUnitVOList?.firstWhereOrNull(
+                      (element) => element.id == nextCourseUnitDetail?.id);
+              if (nextCourseUnitDetail?.lock == false) {
+                ///解锁状态从锁定到解锁，覆盖原unit数据并刷新ui
+                _courseUnitEntity = newCourseUnitEntity!;
+                emitter(LessonDataLoadState());
+
+                return checkCourseSectionLockedOfNextUnit(courseLessonId, nextCourseUnitDetail!.id!, emitter);
+              } else {
+                showToast('下个单元课程还没解锁哦');
+
+                ///如果还是锁定状态，返回null
+                return null;
+              }
             });
-            _pageController.nextPage(
-              duration: const Duration(milliseconds: 500),
-              curve: Curves.ease,
-            );
-            return _courseSectionDatasMap[courseUnitId]!.first;
-          } catch (e) {
-            if (e is ApiException) {
-              showToast(e.message.toString());
-            }
-            return null;
+          } else {
+            return checkCourseSectionLockedOfNextUnit(courseLessonId, nextCourseUnitDetail.id!, emitter);
           }
         } else {
+          showToast("恭喜你，本阶段学到顶啦");
           ///最后一个unit了
           return null;
         }
@@ -254,5 +301,45 @@ class SectionBloc extends Bloc&lt;SectionEvent, SectionState&gt; {
         return null;
       }
     }
+    return null;
+  }
+
+  ///检查下一个unit的（第一个）section
+  Future<CourseSectionEntity?> checkCourseSectionLockedOfNextUnit(int courseLessonId, int nextCourseUnitDetailId,
+      Emitter<SectionState> emitter) async {
+    CourseSectionEntity? firstSectionNextUnit = await getFirstSectionByUnitId(
+        nextCourseUnitDetailId, emitter);
+    if (firstSectionNextUnit != null) {
+      ///下个unit的第一个section如果不为空，再次检查是否锁定
+      CourseSectionEntity? courseSectionEntity = await checkCourseSectionLocked(courseLessonId, firstSectionNextUnit, emitter);
+      if (courseSectionEntity != null) {
+        ///只有是下一unit的第一个section并且解锁了，才跳转
+        _pageController.nextPage(
+          duration: const Duration(milliseconds: 250),
+          curve: Curves.ease,
+        );
+      }
+      return courseSectionEntity;
+    } else {
+      ///下个unit的第一个section如果为空，返回null
+      showToast('下个课程暂未找到');
+      return null;
+    }
+  }
+
+  ///根据unitId获取当前unit的第一个section
+  Future<CourseSectionEntity?> getFirstSectionByUnitId(
+      int courseUnitId, Emitter<SectionState> emitter) async {
+    List<CourseSectionEntity>? courseSectionEntity =
+        _courseSectionDatasMap[courseUnitId];
+    if (courseSectionEntity == null) {
+      ///如果没下载过，请求数据
+      await loading(() async {
+        _courseSectionDatasMap[courseUnitId] =
+            await LessonDao.courseSection(courseUnitId: courseUnitId);
+        emitter(LessonDataLoadState());
+      });
+    }
+    return _courseSectionDatasMap[courseUnitId]?.first;
   }
 }
@@ -23,10 +23,10 @@ class UnitBloc extends Bloc&lt;UnitEvent, UnitState&gt; {
  
  
   UnitBloc(CourseModuleEntity? courseEntity) : super(UnitState().init()) {
-    on<RequestUnitDataEvent>(_requestData);
+    on<RequestUnitDataEvent>(_requestUnitDatas);
   }
  
-  void _requestData(RequestUnitDataEvent event, Emitter<UnitState> emitter) async {
+  void _requestUnitDatas(RequestUnitDataEvent event, Emitter<UnitState> emitter) async {
     try {
       await loading(() async {
         _unitData = await LessonDao.courseUnit(event.moduleId);
@@ -57,7 +57,7 @@ class UnitPage extends StatelessWidget {
                             return GestureDetector(
                               onTap: () {
                                 if (data.lock == true) {
-                                  showToast('当前课程暂未解锁');
+                                  showToast('当前单元课程暂未解锁');
                                   return;
                                 }
  
@@ -8,4 +8,14 @@ extension ListExtension&lt;E&gt; on List&lt;E&gt; {
     }
     return null;
   }
+
+  /// 获取数组中第一个匹配元素，没有就返回null
+  E? firstWhereOrNull(bool Function(E element) test) {
+    for (E element in this) {
+      if (test(element)) {
+        return element;
+      }
+    }
+    return null;
+  }
 }