[CLXR-479][Horizon] Module items offline mode

automation/espresso/src/main/kotlin/com/instructure/canvas/espresso/mockcanvas/fakes/FakeGetHorizonCourseManager.kt

@@ -20,6 +20,7 @@ import com.instructure.canvas.espresso.mockcanvas.MockCanvas
 import com.instructure.canvasapi2.GetCoursesQuery
 import com.instructure.canvasapi2.managers.graphql.horizon.CourseWithModuleItemDurations
 import com.instructure.canvasapi2.managers.graphql.horizon.CourseWithProgress
+import com.instructure.canvasapi2.managers.graphql.horizon.DashboardEnrollment
 import com.instructure.canvasapi2.managers.graphql.horizon.HorizonGetCoursesManager
 import com.instructure.canvasapi2.type.EnrollmentWorkflowState
 import com.instructure.canvasapi2.utils.DataResult
@@ -89,6 +90,33 @@ class FakeGetHorizonCourseManager(): HorizonGetCoursesManager {
         )
     }
 
+    override suspend fun getDashboardEnrollments(
+        userId: Long,
+        forceNetwork: Boolean
+    ): DataResult<List<DashboardEnrollment>> {
+        val enrollments = MockCanvas.data.enrollments.values.toList()
+        val courses = getCourses()
+        val dashboardEnrollments = courses.mapIndexedNotNull { index, course ->
+            val enrollmentId = enrollments.getOrNull(index)?.id ?: return@mapIndexedNotNull null
+            val state = when (index) {
+                1 -> DashboardEnrollment.STATE_COMPLETED
+                2 -> DashboardEnrollment.STATE_INVITED
+                else -> DashboardEnrollment.STATE_ACTIVE
+            }
+            DashboardEnrollment(
+                enrollmentId = enrollmentId,
+                enrollmentState = state,
+                courseId = course.courseId,
+                courseName = course.courseName,
+                courseImageUrl = course.courseImageUrl,
+                courseSyllabus = course.courseSyllabus,
+                institutionName = null,
+                completionPercentage = course.progress,
+            )
+        }
+        return DataResult.Success(dashboardEnrollments)
+    }
+
     override suspend fun getProgramCourses(
         courseId: Long,
         forceNetwork: Boolean
@@ -112,7 +140,7 @@ class FakeGetHorizonCourseManager(): HorizonGetCoursesManager {
                 courseName = courses[0].name,
                 courseImageUrl = null,
                 courseSyllabus = "Syllabus for Course 1",
-                progress = 0.25
+                progress = 25.0
             )
         } else { null }
         val completedCourse = if (courses.size > 1) {
@@ -121,7 +149,7 @@ class FakeGetHorizonCourseManager(): HorizonGetCoursesManager {
                 courseName = courses[1].name,
                 courseImageUrl = null,
                 courseSyllabus = "Syllabus for Course 2",
-                progress = 1.0
+                progress = 100.0
             )
         } else { null }
         val invitedCourse = if (courses.size > 2) {

libs/canvas-api-2/src/main/java/com/instructure/canvasapi2/managers/graphql/horizon/HorizonGetCoursesManager.kt

@@ -34,6 +34,8 @@ interface HorizonGetCoursesManager {
 
     suspend fun getEnrollments(userId: Long, forceNetwork: Boolean = false): DataResult<List<GetCoursesQuery.Enrollment>>
 
+    suspend fun getDashboardEnrollments(userId: Long, forceNetwork: Boolean = false): DataResult<List<DashboardEnrollment>>
+
     suspend fun getProgramCourses(courseId: Long, forceNetwork: Boolean = false): DataResult<CourseWithModuleItemDurations>
 }
 
@@ -101,6 +103,33 @@ class HorizonGetCoursesManagerImpl(private val apolloClient: ApolloClient): Hori
         }
     }
 
+    override suspend fun getDashboardEnrollments(userId: Long, forceNetwork: Boolean): DataResult<List<DashboardEnrollment>> {
+        return try {
+            val query = GetCoursesQuery(userId.toString())
+            val result = apolloClient.enqueueQuery(query, forceNetwork).dataAssertNoErrors
+            val enrollments = result.legacyNode?.onUser?.enrollments.orEmpty().mapNotNull { enrollment ->
+                val course = enrollment.course ?: return@mapNotNull null
+                val courseId = course.id.toLongOrNull() ?: return@mapNotNull null
+                val enrollmentId = enrollment.id?.toLongOrNull() ?: return@mapNotNull null
+                val progress = course.usersConnection?.nodes?.firstOrNull()
+                    ?.courseProgression?.requirements?.completionPercentage ?: 0.0
+                DashboardEnrollment(
+                    enrollmentId = enrollmentId,
+                    enrollmentState = enrollment.state.rawValue,
+                    courseId = courseId,
+                    courseName = course.name,
+                    courseImageUrl = course.image_download_url,
+                    courseSyllabus = course.syllabus_body,
+                    institutionName = course.account?.name,
+                    completionPercentage = progress,
+                )
+            }
+            DataResult.Success(enrollments)
+        } catch (e: Exception) {
+            DataResult.Fail(Failure.Exception(e))
+        }
+    }
+
     override suspend fun getProgramCourses(courseId: Long, forceNetwork: Boolean): DataResult<CourseWithModuleItemDurations> {
         var hasNextPage = true
         var nextCursor: String? = null
@@ -137,6 +166,23 @@ class HorizonGetCoursesManagerImpl(private val apolloClient: ApolloClient): Hori
     }
 }
 
+data class DashboardEnrollment(
+    val enrollmentId: Long,
+    val enrollmentState: String,
+    val courseId: Long,
+    val courseName: String,
+    val courseImageUrl: String?,
+    val courseSyllabus: String?,
+    val institutionName: String?,
+    val completionPercentage: Double,
+) {
+    companion object {
+        const val STATE_ACTIVE = "active"
+        const val STATE_INVITED = "invited"
+        const val STATE_COMPLETED = "completed"
+    }
+}
+
 data class CourseWithProgress(
     val courseId: Long,
     val courseName: String,

libs/canvas-api-2/src/main/java/com/instructure/canvasapi2/models/journey/learninglibrary/CollectionItemType.kt

@@ -26,7 +26,11 @@ enum class CollectionItemType {
     EXTERNAL_URL,
     EXTERNAL_TOOL,
     FILE,
-    PROGRAM
+    PROGRAM;
+
+    companion object {
+        fun safeValueOf(name: String): CollectionItemType? = entries.find { it.name == name }
+    }
 }
 
 fun ApolloCollectionItemType.toModel(): CollectionItemType {

libs/horizon/build.gradle.kts

@@ -90,6 +90,12 @@ dependencies {
         isTransitive = true
     }
 
+    /* Room */
+    implementation(Libs.ROOM)
+    implementation(Libs.ROOM_COROUTINES)
+    ksp(Libs.ROOM_COMPILER)
+    testImplementation(Libs.ROOM_TEST)
+
     /* Android Test Dependencies */
     androidTestImplementation(project(":espresso"))
     androidTestImplementation(project(":dataseedingapi"))

libs/horizon/src/androidTest/java/com/instructure/horizon/espresso/HorizonOfflineTestModule.kt

@@ -0,0 +1,116 @@
+/*
+ * Copyright (C) 2026 - present Instructure, Inc.
+ *
+ *     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.
+ */
+package com.instructure.horizon.espresso
+
+import android.content.Context
+import androidx.room.Room
+import com.instructure.canvasapi2.utils.ApiPrefs
+import com.instructure.horizon.database.HorizonDatabase
+import com.instructure.horizon.database.dao.HorizonAssignmentCommentDao
+import com.instructure.horizon.database.dao.HorizonAssignmentDetailsDao
+import com.instructure.horizon.database.dao.HorizonCourseDao
+import com.instructure.horizon.database.dao.HorizonCourseModuleDao
+import com.instructure.horizon.database.dao.HorizonCourseScoreDao
+import com.instructure.horizon.database.dao.HorizonDashboardEnrollmentDao
+import com.instructure.horizon.database.dao.HorizonDashboardModuleItemDao
+import com.instructure.horizon.database.dao.HorizonFileFolderDao
+import com.instructure.horizon.database.dao.HorizonLearnCollectionDao
+import com.instructure.horizon.database.dao.HorizonLearnItemDao
+import com.instructure.horizon.database.dao.HorizonLearnSavedItemDao
+import com.instructure.horizon.database.dao.HorizonLocalFileDao
+import com.instructure.horizon.database.dao.HorizonPageDao
+import com.instructure.horizon.database.dao.HorizonProgramDao
+import com.instructure.horizon.database.dao.HorizonSubmissionDao
+import com.instructure.horizon.database.dao.HorizonSyncMetadataDao
+import com.instructure.horizon.di.HorizonHtmlParserQualifier
+import com.instructure.horizon.di.HorizonOfflineModule
+import com.instructure.horizon.offline.HorizonHtmlParserFileSource
+import com.instructure.pandautils.features.offline.sync.HtmlParser
+import dagger.Module
+import dagger.Provides
+import dagger.hilt.android.qualifiers.ApplicationContext
+import dagger.hilt.components.SingletonComponent
+import dagger.hilt.testing.TestInstallIn
+import javax.inject.Singleton
+
+@Module
+@TestInstallIn(components = [SingletonComponent::class], replaces = [HorizonOfflineModule::class])
+object HorizonOfflineTestModule {
+
+    @Provides
+    @Singleton
+    fun provideHorizonDatabase(@ApplicationContext context: Context): HorizonDatabase {
+        return Room.inMemoryDatabaseBuilder(context, HorizonDatabase::class.java)
+            .allowMainThreadQueries()
+            .build()
+    }
+
+    @Provides
+    fun provideHorizonDashboardEnrollmentDao(db: HorizonDatabase): HorizonDashboardEnrollmentDao = db.dashboardEnrollmentDao()
+
+    @Provides
+    fun provideHorizonProgramDao(db: HorizonDatabase): HorizonProgramDao = db.programDao()
+
+    @Provides
+    fun provideHorizonDashboardModuleItemDao(db: HorizonDatabase): HorizonDashboardModuleItemDao = db.dashboardModuleItemDao()
+
+    @Provides
+    fun provideHorizonSyncMetadataDao(db: HorizonDatabase): HorizonSyncMetadataDao = db.syncMetadataDao()
+
+    @Provides
+    fun provideHorizonLearnItemDao(db: HorizonDatabase): HorizonLearnItemDao = db.learnItemDao()
+
+    @Provides
+    fun provideHorizonLearnCollectionDao(db: HorizonDatabase): HorizonLearnCollectionDao = db.learnCollectionDao()
+
+    @Provides
+    fun provideHorizonLearnSavedItemDao(db: HorizonDatabase): HorizonLearnSavedItemDao = db.learnSavedItemDao()
+
+    @Provides
+    fun provideHorizonCourseDao(db: HorizonDatabase): HorizonCourseDao = db.courseDao()
+
+    @Provides
+    fun provideHorizonCourseModuleDao(db: HorizonDatabase): HorizonCourseModuleDao = db.courseModuleDao()
+
+    @Provides
+    fun provideHorizonCourseScoreDao(db: HorizonDatabase): HorizonCourseScoreDao = db.courseScoreDao()
+
+    @Provides
+    fun provideHorizonLocalFileDao(db: HorizonDatabase): HorizonLocalFileDao = db.localFileDao()
+
+    @Provides
+    fun provideHorizonFileFolderDao(db: HorizonDatabase): HorizonFileFolderDao = db.fileFolderDao()
+
+    @Provides
+    fun provideHorizonPageDao(db: HorizonDatabase): HorizonPageDao = db.pageDao()
+
+    @Provides
+    fun provideHorizonAssignmentDetailsDao(db: HorizonDatabase): HorizonAssignmentDetailsDao = db.assignmentDetailsDao()
+
+    @Provides
+    fun provideHorizonAssignmentCommentDao(db: HorizonDatabase): HorizonAssignmentCommentDao = db.assignmentCommentDao()
+
+    @Provides
+    fun provideHorizonSubmissionDao(db: HorizonDatabase): HorizonSubmissionDao = db.submissionDao()
+
+    @Provides
+    @HorizonHtmlParserQualifier
+    fun provideHorizonHtmlParser(
+        fileSource: HorizonHtmlParserFileSource,
+        apiPrefs: ApiPrefs,
+        @ApplicationContext context: Context,
+    ): HtmlParser = HtmlParser(fileSource, apiPrefs, context)
+}

libs/horizon/src/androidTest/java/com/instructure/horizon/espresso/TestModule.kt

@@ -1,8 +1,11 @@
 package com.instructure.horizon.espresso
 
+import android.content.Context
 import android.content.Intent
+import androidx.room.Room
 import com.instructure.canvasapi2.LoginRouter
 import com.instructure.canvasapi2.utils.pageview.PandataInfo
+import dagger.hilt.android.qualifiers.ApplicationContext
 import com.instructure.pandautils.features.about.AboutRepository
 import com.instructure.pandautils.features.assignments.details.AssignmentDetailsBehaviour
 import com.instructure.pandautils.features.assignments.details.AssignmentDetailsColorProvider
@@ -98,8 +101,11 @@ object HorizonTestModule {
     }
 
     @Provides
-    fun provideAppDatabase(): AppDatabase {
-        throw NotImplementedError("This is a test module. Implementation not required.")
+    @javax.inject.Singleton
+    fun provideAppDatabase(@ApplicationContext context: Context): AppDatabase {
+        return Room.inMemoryDatabaseBuilder(context, AppDatabase::class.java)
+            .allowMainThreadQueries()
+            .build()
     }
 
     @Provides

libs/horizon/src/main/java/com/instructure/horizon/data/datasource/AssignmentCommentsLocalDataSource.kt

@@ -0,0 +1,100 @@
+/*
+ * Copyright (C) 2026 - present Instructure, Inc.
+ *
+ *     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.
+ */
+package com.instructure.horizon.data.datasource
+
+import com.instructure.canvasapi2.managers.graphql.horizon.Comment
+import com.instructure.canvasapi2.managers.graphql.horizon.CommentAttachment
+import com.instructure.canvasapi2.managers.graphql.horizon.CommentsData
+import com.instructure.horizon.database.dao.HorizonAssignmentCommentDao
+import com.instructure.horizon.database.entity.HorizonAssignmentCommentAttachmentEntity
+import com.instructure.horizon.database.entity.HorizonAssignmentCommentEntity
+import java.util.Date
+import javax.inject.Inject
+
+class AssignmentCommentsLocalDataSource @Inject constructor(
+    private val commentDao: HorizonAssignmentCommentDao,
+) {
+
+    suspend fun getComments(assignmentId: Long, attempt: Int): CommentsData {
+        val commentEntities = commentDao.getComments(assignmentId, attempt)
+        val commentIds = commentEntities.map { it.id }
+        val attachmentEntities = if (commentIds.isNotEmpty()) {
+            commentDao.getAttachments(commentIds)
+        } else {
+            emptyList()
+        }
+        val attachmentsByCommentId = attachmentEntities.groupBy { it.commentId }
+        val comments = commentEntities.map { entity ->
+            entity.toComment(attachmentsByCommentId[entity.id] ?: emptyList())
+        }
+        return CommentsData(
+            comments = comments,
+            hasNextPage = false,
+            hasPreviousPage = false,
+        )
+    }
+
+    suspend fun saveComments(assignmentId: Long, attempt: Int, commentsData: CommentsData) {
+        val commentWithAttachments = commentsData.comments.map { comment ->
+            val commentEntity = HorizonAssignmentCommentEntity(
+                assignmentId = assignmentId,
+                attempt = attempt,
+                authorId = comment.authorId,
+                authorName = comment.authorName,
+                commentText = comment.commentText,
+                createdAtMs = comment.createdAt.time,
+                read = comment.read,
+            )
+            val attachmentEntities = comment.attachments.map { attachment ->
+                HorizonAssignmentCommentAttachmentEntity(
+                    attachmentId = attachment.attachmentId,
+                    commentId = 0,
+                    fileName = attachment.fileName,
+                    fileUrl = attachment.fileUrl,
+                    fileType = attachment.fileType,
+                )
+            }
+            commentEntity to attachmentEntities
+        }
+        commentDao.replaceCommentsForAttempt(assignmentId, attempt, commentWithAttachments)
+    }
+
+    suspend fun getUnreadCommentCount(assignmentId: Long): Int {
+        return commentDao.getUnreadCommentCount(assignmentId)
+    }
+
+    private fun HorizonAssignmentCommentEntity.toComment(
+        attachments: List<HorizonAssignmentCommentAttachmentEntity>,
+    ): Comment {
+        return Comment(
+            authorId = authorId,
+            authorName = authorName,
+            commentText = commentText,
+            createdAt = Date(createdAtMs),
+            attachments = attachments.map { it.toCommentAttachment() },
+            read = read,
+        )
+    }
+
+    private fun HorizonAssignmentCommentAttachmentEntity.toCommentAttachment(): CommentAttachment {
+        return CommentAttachment(
+            attachmentId = attachmentId,
+            fileName = fileName,
+            fileUrl = fileUrl,
+            fileType = fileType,
+        )
+    }
+}