Add Sdk.init(student) call in all remote repositories (#764)

app/build.gradle

@@ -128,7 +128,7 @@ configurations.all {
 }
 
 dependencies {
-    implementation "io.github.wulkanowy:sdk:0.17.0"
+    implementation "io.github.wulkanowy:sdk:d842456"
 
     implementation "org.jetbrains.kotlin:kotlin-stdlib-jdk8:$kotlin_version"
     implementation "androidx.core:core-ktx:1.2.0"

app/src/androidTest/java/io/github/wulkanowy/data/repositories/TestEntityCreator.kt

@@ -0,0 +1,29 @@
+package io.github.wulkanowy.data.repositories
+
+import io.github.wulkanowy.data.db.entities.Student
+import org.threeten.bp.LocalDateTime
+
+fun getStudent(): Student {
+    return Student(
+        email = "test",
+        password = "test123",
+        schoolSymbol = "23",
+        scrapperBaseUrl = "fakelog.cf",
+        loginType = "AUTO",
+        isCurrent = true,
+        studentName = "",
+        schoolShortName = "",
+        schoolName = "",
+        studentId = 0,
+        classId = 1,
+        symbol = "",
+        registrationDate = LocalDateTime.now(),
+        className = "",
+        loginMode = "API",
+        certificateKey = "",
+        privateKey = "",
+        mobileBaseUrl = "",
+        userLoginId = 0,
+        isParent = false
+    )
+}

app/src/androidTest/java/io/github/wulkanowy/data/repositories/student/StudentLocalTest.kt

@@ -5,13 +5,11 @@ import androidx.room.Room
 import androidx.test.core.app.ApplicationProvider
 import androidx.test.ext.junit.runners.AndroidJUnit4
 import io.github.wulkanowy.data.db.AppDatabase
-import io.github.wulkanowy.data.db.SharedPrefProvider
+import io.github.wulkanowy.data.repositories.getStudent
-import io.github.wulkanowy.data.db.entities.Student
 import org.junit.After
 import org.junit.Before
 import org.junit.Test
 import org.junit.runner.RunWith
-import org.threeten.bp.LocalDateTime.now
 import kotlin.test.assertEquals
 
 @RunWith(AndroidJUnit4::class)
@@ -21,14 +19,13 @@ class StudentLocalTest {
 
     private lateinit var testDb: AppDatabase
 
-    private lateinit var sharedProvider: SharedPrefProvider
+    private val student = getStudent()
 
     @Before
     fun createDb() {
         val context = ApplicationProvider.getApplicationContext<Context>()
         testDb = Room.inMemoryDatabaseBuilder(context, AppDatabase::class.java)
             .build()
-        sharedProvider = SharedPrefProvider(context.getSharedPreferences("TEST", Context.MODE_PRIVATE))
         studentLocal = StudentLocal(testDb.studentDao, context)
     }
 
@@ -39,8 +36,7 @@ class StudentLocalTest {
 
     @Test
     fun saveAndReadTest() {
-        studentLocal.saveStudents(listOf(Student(email = "test", password = "test123", schoolSymbol = "23", scrapperBaseUrl = "fakelog.cf", loginType = "AUTO", isCurrent = true, studentName = "", schoolShortName = "", schoolName = "", studentId = 0, classId = 1, symbol = "", registrationDate = now(), className = "", loginMode = "API", certificateKey = "", privateKey = "", mobileBaseUrl = "", userLoginId = 0, isParent = false)))
+        studentLocal.saveStudents(listOf(student)).blockingGet()
-            .blockingGet()
 
         val student = studentLocal.getCurrentStudent(true).blockingGet()
         assertEquals("23", student.schoolSymbol)

app/src/androidTest/java/io/github/wulkanowy/data/repositories/timetable/TimetableRepositoryTest.kt

@@ -9,6 +9,7 @@ import com.github.pwittchen.reactivenetwork.library.rx2.internet.observing.Inter
 import io.github.wulkanowy.data.db.AppDatabase
 import io.github.wulkanowy.data.db.entities.Semester
 import io.github.wulkanowy.data.repositories.TestInternetObservingStrategy
+import io.github.wulkanowy.data.repositories.getStudent
 import io.github.wulkanowy.sdk.Sdk
 import io.mockk.MockKAnnotations
 import io.mockk.every
@@ -33,6 +34,8 @@ class TimetableRepositoryTest {
         .strategy(TestInternetObservingStrategy())
         .build()
 
+    private val student = getStudent()
+
     @MockK
     private lateinit var semesterMock: Semester
 
@@ -78,7 +81,7 @@ class TimetableRepositoryTest {
         ))
 
         val lessons = TimetableRepository(settings, timetableLocal, timetableRemote)
-            .getTimetable(semesterMock, LocalDate.of(2019, 3, 5), LocalDate.of(2019, 3, 5), true)
+            .getTimetable(student, semesterMock, LocalDate.of(2019, 3, 5), LocalDate.of(2019, 3, 5), true)
             .blockingGet()
 
         assertEquals(4, lessons.size)
@@ -124,7 +127,7 @@ class TimetableRepositoryTest {
         ))
 
         val lessons = TimetableRepository(settings, timetableLocal, timetableRemote)
-            .getTimetable(semesterMock, LocalDate.of(2019, 12, 23), LocalDate.of(2019, 12, 25), true)
+            .getTimetable(student, semesterMock, LocalDate.of(2019, 12, 23), LocalDate.of(2019, 12, 25), true)
             .blockingGet()
 
         assertEquals(12, lessons.size)

app/src/main/java/io/github/wulkanowy/data/SdkHelper.kt

@@ -1,30 +0,0 @@
-package io.github.wulkanowy.data
-
-import io.github.wulkanowy.data.db.entities.Student
-import io.github.wulkanowy.sdk.Sdk
-import javax.inject.Inject
-
-class SdkHelper @Inject constructor(private val sdk: Sdk) {
-
-    fun init(student: Student) {
-        sdk.apply {
-            email = student.email
-            password = student.password
-            symbol = student.symbol
-            schoolSymbol = student.schoolSymbol
-            studentId = student.studentId
-            classId = student.classId
-
-            if (Sdk.Mode.valueOf(student.loginMode) != Sdk.Mode.API) {
-                scrapperBaseUrl = student.scrapperBaseUrl
-                loginType = Sdk.ScrapperLoginType.valueOf(student.loginType)
-            }
-            loginId = student.userLoginId
-
-            mode = Sdk.Mode.valueOf(student.loginMode)
-            mobileBaseUrl = student.mobileBaseUrl
-            certKey = student.certificateKey
-            privateKey = student.privateKey
-        }
-    }
-}

app/src/main/java/io/github/wulkanowy/data/repositories/attendance/AttendanceRemote.kt

@@ -2,8 +2,10 @@ package io.github.wulkanowy.data.repositories.attendance
 
 import io.github.wulkanowy.data.db.entities.Attendance
 import io.github.wulkanowy.data.db.entities.Semester
+import io.github.wulkanowy.data.db.entities.Student
 import io.github.wulkanowy.sdk.Sdk
 import io.github.wulkanowy.sdk.pojo.Absent
+import io.github.wulkanowy.utils.init
 import io.reactivex.Single
 import org.threeten.bp.LocalDate
 import org.threeten.bp.LocalDateTime
@@ -14,8 +16,9 @@ import javax.inject.Singleton
 @Singleton
 class AttendanceRemote @Inject constructor(private val sdk: Sdk) {
 
-    fun getAttendance(semester: Semester, startDate: LocalDate, endDate: LocalDate): Single<List<Attendance>> {
+    fun getAttendance(student: Student, semester: Semester, startDate: LocalDate, endDate: LocalDate): Single<List<Attendance>> {
-        return sdk.switchDiary(semester.diaryId, semester.schoolYear).getAttendance(startDate, endDate, semester.semesterId)
+        return sdk.init(student).switchDiary(semester.diaryId, semester.schoolYear)
+            .getAttendance(startDate, endDate, semester.semesterId)
             .map { attendance ->
                 attendance.map {
                     Attendance(
@@ -39,8 +42,8 @@ class AttendanceRemote @Inject constructor(private val sdk: Sdk) {
             }
     }
 
-    fun excuseAbsence(semester: Semester, absenceList: List<Attendance>, reason: String?): Single<Boolean> {
+    fun excuseAbsence(student: Student, semester: Semester, absenceList: List<Attendance>, reason: String?): Single<Boolean> {
-        return sdk.switchDiary(semester.diaryId, semester.schoolYear).excuseForAbsence(absenceList.map { attendance ->
+        return sdk.init(student).switchDiary(semester.diaryId, semester.schoolYear).excuseForAbsence(absenceList.map { attendance ->
             Absent(
                 date = LocalDateTime.of(attendance.date, LocalTime.of(0, 0)),
                 timeId = attendance.timeId

app/src/main/java/io/github/wulkanowy/data/repositories/attendance/AttendanceRepository.kt

@@ -4,6 +4,7 @@ import com.github.pwittchen.reactivenetwork.library.rx2.ReactiveNetwork
 import com.github.pwittchen.reactivenetwork.library.rx2.internet.observing.InternetObservingSettings
 import io.github.wulkanowy.data.db.entities.Attendance
 import io.github.wulkanowy.data.db.entities.Semester
+import io.github.wulkanowy.data.db.entities.Student
 import io.github.wulkanowy.utils.friday
 import io.github.wulkanowy.utils.monday
 import io.github.wulkanowy.utils.uniqueSubtract
@@ -20,29 +21,25 @@ class AttendanceRepository @Inject constructor(
     private val remote: AttendanceRemote
 ) {
 
-    fun getAttendance(semester: Semester, startDate: LocalDate, endDate: LocalDate, forceRefresh: Boolean)
+    fun getAttendance(student: Student, semester: Semester, start: LocalDate, end: LocalDate, forceRefresh: Boolean): Single<List<Attendance>> {
-        : Single<List<Attendance>> {
+        return local.getAttendance(semester, start.monday, end.friday).filter { !forceRefresh }
-        return Single.fromCallable { startDate.monday to endDate.friday }
-            .flatMap { dates ->
-                local.getAttendance(semester, dates.first, dates.second).filter { !forceRefresh }
             .switchIfEmpty(ReactiveNetwork.checkInternetConnectivity(settings).flatMap {
-                        if (it) remote.getAttendance(semester, dates.first, dates.second)
+                if (it) remote.getAttendance(student, semester, start.monday, end.friday)
                 else Single.error(UnknownHostException())
             }.flatMap { newAttendance ->
-                        local.getAttendance(semester, dates.first, dates.second)
+                local.getAttendance(semester, start.monday, end.friday)
                     .toSingle(emptyList())
                     .doOnSuccess { oldAttendance ->
                         local.deleteAttendance(oldAttendance.uniqueSubtract(newAttendance))
                         local.saveAttendance(newAttendance.uniqueSubtract(oldAttendance))
                     }
             }.flatMap {
-                        local.getAttendance(semester, dates.first, dates.second)
+                local.getAttendance(semester, start.monday, end.friday)
                     .toSingle(emptyList())
-                    }).map { list -> list.filter { it.date in startDate..endDate } }
+            }).map { list -> list.filter { it.date in start..end } }
-            }
     }
 
-    fun excuseForAbsence(semester: Semester, attendanceList: List<Attendance>, reason: String? = null): Single<Boolean> {
+    fun excuseForAbsence(student: Student, semester: Semester, attendanceList: List<Attendance>, reason: String? = null): Single<Boolean> {
-        return remote.excuseAbsence(semester, attendanceList, reason)
+        return remote.excuseAbsence(student, semester, attendanceList, reason)
     }
 }

app/src/main/java/io/github/wulkanowy/data/repositories/attendancesummary/AttendanceSummaryRemote.kt

@@ -2,7 +2,9 @@ package io.github.wulkanowy.data.repositories.attendancesummary
 
 import io.github.wulkanowy.data.db.entities.AttendanceSummary
 import io.github.wulkanowy.data.db.entities.Semester
+import io.github.wulkanowy.data.db.entities.Student
 import io.github.wulkanowy.sdk.Sdk
+import io.github.wulkanowy.utils.init
 import io.reactivex.Single
 import javax.inject.Inject
 import javax.inject.Singleton
@@ -10,8 +12,9 @@ import javax.inject.Singleton
 @Singleton
 class AttendanceSummaryRemote @Inject constructor(private val sdk: Sdk) {
 
-    fun getAttendanceSummary(semester: Semester, subjectId: Int): Single<List<AttendanceSummary>> {
+    fun getAttendanceSummary(student: Student, semester: Semester, subjectId: Int): Single<List<AttendanceSummary>> {
-        return sdk.switchDiary(semester.diaryId, semester.schoolYear).getAttendanceSummary(subjectId)
+        return sdk.init(student).switchDiary(semester.diaryId, semester.schoolYear)
+            .getAttendanceSummary(subjectId)
             .map { attendance ->
                 attendance.map {
                     AttendanceSummary(

app/src/main/java/io/github/wulkanowy/data/repositories/attendancesummary/AttendanceSummaryRepository.kt

@@ -4,6 +4,7 @@ import com.github.pwittchen.reactivenetwork.library.rx2.ReactiveNetwork
 import com.github.pwittchen.reactivenetwork.library.rx2.internet.observing.InternetObservingSettings
 import io.github.wulkanowy.data.db.entities.AttendanceSummary
 import io.github.wulkanowy.data.db.entities.Semester
+import io.github.wulkanowy.data.db.entities.Student
 import io.github.wulkanowy.utils.uniqueSubtract
 import io.reactivex.Single
 import java.net.UnknownHostException
@@ -17,11 +18,11 @@ class AttendanceSummaryRepository @Inject constructor(
     private val remote: AttendanceSummaryRemote
 ) {
 
-    fun getAttendanceSummary(semester: Semester, subjectId: Int, forceRefresh: Boolean = false): Single<List<AttendanceSummary>> {
+    fun getAttendanceSummary(student: Student, semester: Semester, subjectId: Int, forceRefresh: Boolean = false): Single<List<AttendanceSummary>> {
         return local.getAttendanceSummary(semester, subjectId).filter { !forceRefresh }
             .switchIfEmpty(ReactiveNetwork.checkInternetConnectivity(settings)
                 .flatMap {
-                    if (it) remote.getAttendanceSummary(semester, subjectId)
+                    if (it) remote.getAttendanceSummary(student, semester, subjectId)
                     else Single.error(UnknownHostException())
                 }.flatMap { new ->
                     local.getAttendanceSummary(semester, subjectId).toSingle(emptyList())

app/src/main/java/io/github/wulkanowy/data/repositories/completedlessons/CompletedLessonsRemote.kt

@@ -2,7 +2,9 @@ package io.github.wulkanowy.data.repositories.completedlessons
 
 import io.github.wulkanowy.data.db.entities.CompletedLesson
 import io.github.wulkanowy.data.db.entities.Semester
+import io.github.wulkanowy.data.db.entities.Student
 import io.github.wulkanowy.sdk.Sdk
+import io.github.wulkanowy.utils.init
 import io.reactivex.Single
 import org.threeten.bp.LocalDate
 import javax.inject.Inject
@@ -11,8 +13,9 @@ import javax.inject.Singleton
 @Singleton
 class CompletedLessonsRemote @Inject constructor(private val sdk: Sdk) {
 
-    fun getCompletedLessons(semester: Semester, startDate: LocalDate, endDate: LocalDate): Single<List<CompletedLesson>> {
+    fun getCompletedLessons(student: Student, semester: Semester, startDate: LocalDate, endDate: LocalDate): Single<List<CompletedLesson>> {
-        return sdk.switchDiary(semester.diaryId, semester.schoolYear).getCompletedLessons(startDate, endDate)
+        return sdk.init(student).switchDiary(semester.diaryId, semester.schoolYear)
+            .getCompletedLessons(startDate, endDate)
             .map { lessons ->
                 lessons.map {
                     it.absence

app/src/main/java/io/github/wulkanowy/data/repositories/completedlessons/CompletedLessonsRepository.kt

@@ -4,6 +4,7 @@ import com.github.pwittchen.reactivenetwork.library.rx2.ReactiveNetwork
 import com.github.pwittchen.reactivenetwork.library.rx2.internet.observing.InternetObservingSettings
 import io.github.wulkanowy.data.db.entities.CompletedLesson
 import io.github.wulkanowy.data.db.entities.Semester
+import io.github.wulkanowy.data.db.entities.Student
 import io.github.wulkanowy.utils.friday
 import io.github.wulkanowy.utils.monday
 import io.github.wulkanowy.utils.uniqueSubtract
@@ -20,25 +21,22 @@ class CompletedLessonsRepository @Inject constructor(
     private val remote: CompletedLessonsRemote
 ) {
 
-    fun getCompletedLessons(semester: Semester, startDate: LocalDate, endDate: LocalDate, forceRefresh: Boolean = false): Single<List<CompletedLesson>> {
+    fun getCompletedLessons(student: Student, semester: Semester, start: LocalDate, end: LocalDate, forceRefresh: Boolean = false): Single<List<CompletedLesson>> {
-        return Single.fromCallable { startDate.monday to endDate.friday }
+        return local.getCompletedLessons(semester, start.monday, end.friday).filter { !forceRefresh }
-            .flatMap { dates ->
-                local.getCompletedLessons(semester, dates.first, dates.second).filter { !forceRefresh }
             .switchIfEmpty(ReactiveNetwork.checkInternetConnectivity(settings)
                 .flatMap {
-                            if (it) remote.getCompletedLessons(semester, dates.first, dates.second)
+                    if (it) remote.getCompletedLessons(student, semester, start.monday, end.friday)
                     else Single.error(UnknownHostException())
                 }.flatMap { new ->
-                            local.getCompletedLessons(semester, dates.first, dates.second)
+                    local.getCompletedLessons(semester, start.monday, end.friday)
                         .toSingle(emptyList())
                         .doOnSuccess { old ->
                             local.deleteCompleteLessons(old.uniqueSubtract(new))
                             local.saveCompletedLessons(new.uniqueSubtract(old))
                         }
                 }.flatMap {
-                            local.getCompletedLessons(semester, dates.first, dates.second)
+                    local.getCompletedLessons(semester, start.monday, end.friday)
                         .toSingle(emptyList())
-                        }).map { list -> list.filter { it.date in startDate..endDate } }
+                }).map { list -> list.filter { it.date in start..end } }
-            }
     }
 }

app/src/main/java/io/github/wulkanowy/data/repositories/exam/ExamRemote.kt

@@ -2,7 +2,9 @@ package io.github.wulkanowy.data.repositories.exam
 
 import io.github.wulkanowy.data.db.entities.Exam
 import io.github.wulkanowy.data.db.entities.Semester
+import io.github.wulkanowy.data.db.entities.Student
 import io.github.wulkanowy.sdk.Sdk
+import io.github.wulkanowy.utils.init
 import io.reactivex.Single
 import org.threeten.bp.LocalDate
 import javax.inject.Inject
@@ -11,8 +13,9 @@ import javax.inject.Singleton
 @Singleton
 class ExamRemote @Inject constructor(private val sdk: Sdk) {
 
-    fun getExams(semester: Semester, startDate: LocalDate, endDate: LocalDate): Single<List<Exam>> {
+    fun getExams(student: Student, semester: Semester, startDate: LocalDate, endDate: LocalDate): Single<List<Exam>> {
-        return sdk.switchDiary(semester.diaryId, semester.schoolYear).getExams(startDate, endDate, semester.semesterId)
+        return sdk.init(student).switchDiary(semester.diaryId, semester.schoolYear)
+            .getExams(startDate, endDate, semester.semesterId)
             .map { exams ->
                 exams.map {
                     Exam(

app/src/main/java/io/github/wulkanowy/data/repositories/exam/ExamRepository.kt

@@ -4,6 +4,7 @@ import com.github.pwittchen.reactivenetwork.library.rx2.ReactiveNetwork
 import com.github.pwittchen.reactivenetwork.library.rx2.internet.observing.InternetObservingSettings
 import io.github.wulkanowy.data.db.entities.Exam
 import io.github.wulkanowy.data.db.entities.Semester
+import io.github.wulkanowy.data.db.entities.Student
 import io.github.wulkanowy.utils.friday
 import io.github.wulkanowy.utils.monday
 import io.github.wulkanowy.utils.uniqueSubtract
@@ -20,25 +21,22 @@ class ExamRepository @Inject constructor(
     private val remote: ExamRemote
 ) {
 
-    fun getExams(semester: Semester, startDate: LocalDate, endDate: LocalDate, forceRefresh: Boolean = false): Single<List<Exam>> {
+    fun getExams(student: Student, semester: Semester, start: LocalDate, end: LocalDate, forceRefresh: Boolean = false): Single<List<Exam>> {
-        return Single.fromCallable { startDate.monday to endDate.friday }
+        return local.getExams(semester, start.monday, end.friday).filter { !forceRefresh }
-            .flatMap { dates ->
-                local.getExams(semester, dates.first, dates.second).filter { !forceRefresh }
             .switchIfEmpty(ReactiveNetwork.checkInternetConnectivity(settings)
                 .flatMap {
-                            if (it) remote.getExams(semester, dates.first, dates.second)
+                    if (it) remote.getExams(student, semester, start.monday, end.friday)
                     else Single.error(UnknownHostException())
                 }.flatMap { new ->
-                            local.getExams(semester, dates.first, dates.second)
+                    local.getExams(semester, start.monday, end.friday)
                         .toSingle(emptyList())
                         .doOnSuccess { old ->
                             local.deleteExams(old.uniqueSubtract(new))
                             local.saveExams(new.uniqueSubtract(old))
                         }
                 }.flatMap {
-                            local.getExams(semester, dates.first, dates.second)
+                    local.getExams(semester, start.monday, end.friday)
                         .toSingle(emptyList())
-                        }).map { list -> list.filter { it.date in startDate..endDate } }
+                }).map { list -> list.filter { it.date in start..end } }
-            }
     }
 }

app/src/main/java/io/github/wulkanowy/data/repositories/grade/GradeRemote.kt

@@ -2,7 +2,9 @@ package io.github.wulkanowy.data.repositories.grade
 
 import io.github.wulkanowy.data.db.entities.Grade
 import io.github.wulkanowy.data.db.entities.Semester
+import io.github.wulkanowy.data.db.entities.Student
 import io.github.wulkanowy.sdk.Sdk
+import io.github.wulkanowy.utils.init
 import io.reactivex.Single
 import javax.inject.Inject
 import javax.inject.Singleton
@@ -10,8 +12,9 @@ import javax.inject.Singleton
 @Singleton
 class GradeRemote @Inject constructor(private val sdk: Sdk) {
 
-    fun getGrades(semester: Semester): Single<List<Grade>> {
+    fun getGrades(student: Student, semester: Semester): Single<List<Grade>> {
-        return sdk.switchDiary(semester.diaryId, semester.schoolYear).getGrades(semester.semesterId)
+        return sdk.init(student).switchDiary(semester.diaryId, semester.schoolYear)
+            .getGrades(semester.semesterId)
             .map { grades ->
                 grades.map {
                     Grade(

app/src/main/java/io/github/wulkanowy/data/repositories/grade/GradeRepository.kt

@@ -23,7 +23,7 @@ class GradeRepository @Inject constructor(
         return local.getGrades(semester).filter { !forceRefresh }
             .switchIfEmpty(ReactiveNetwork.checkInternetConnectivity(settings)
                 .flatMap {
-                    if (it) remote.getGrades(semester)
+                    if (it) remote.getGrades(student, semester)
                     else Single.error(UnknownHostException())
                 }.flatMap { new ->
                     local.getGrades(semester).toSingle(emptyList())

app/src/main/java/io/github/wulkanowy/data/repositories/gradessummary/GradeSummaryRemote.kt

@@ -2,7 +2,9 @@ package io.github.wulkanowy.data.repositories.gradessummary
 
 import io.github.wulkanowy.data.db.entities.GradeSummary
 import io.github.wulkanowy.data.db.entities.Semester
+import io.github.wulkanowy.data.db.entities.Student
 import io.github.wulkanowy.sdk.Sdk
+import io.github.wulkanowy.utils.init
 import io.reactivex.Single
 import javax.inject.Inject
 import javax.inject.Singleton
@@ -10,8 +12,9 @@ import javax.inject.Singleton
 @Singleton
 class GradeSummaryRemote @Inject constructor(private val sdk: Sdk) {
 
-    fun getGradeSummary(semester: Semester): Single<List<GradeSummary>> {
+    fun getGradeSummary(student: Student, semester: Semester): Single<List<GradeSummary>> {
-        return sdk.switchDiary(semester.diaryId, semester.schoolYear).getGradesSummary(semester.semesterId)
+        return sdk.init(student).switchDiary(semester.diaryId, semester.schoolYear)
+            .getGradesSummary(semester.semesterId)
             .map { gradesSummary ->
                 gradesSummary.map {
                     GradeSummary(

app/src/main/java/io/github/wulkanowy/data/repositories/gradessummary/GradeSummaryRepository.kt

@@ -4,6 +4,7 @@ import com.github.pwittchen.reactivenetwork.library.rx2.ReactiveNetwork
 import com.github.pwittchen.reactivenetwork.library.rx2.internet.observing.InternetObservingSettings
 import io.github.wulkanowy.data.db.entities.GradeSummary
 import io.github.wulkanowy.data.db.entities.Semester
+import io.github.wulkanowy.data.db.entities.Student
 import io.github.wulkanowy.utils.uniqueSubtract
 import io.reactivex.Single
 import java.net.UnknownHostException
@@ -17,11 +18,11 @@ class GradeSummaryRepository @Inject constructor(
     private val remote: GradeSummaryRemote
 ) {
 
-    fun getGradesSummary(semester: Semester, forceRefresh: Boolean = false): Single<List<GradeSummary>> {
+    fun getGradesSummary(student: Student, semester: Semester, forceRefresh: Boolean = false): Single<List<GradeSummary>> {
         return local.getGradesSummary(semester).filter { !forceRefresh }
             .switchIfEmpty(ReactiveNetwork.checkInternetConnectivity(settings)
                 .flatMap {
-                    if (it) remote.getGradeSummary(semester)
+                    if (it) remote.getGradeSummary(student, semester)
                     else Single.error(UnknownHostException())
                 }.flatMap { new ->
                     local.getGradesSummary(semester).toSingle(emptyList())

app/src/main/java/io/github/wulkanowy/data/repositories/gradestatistics/GradeStatisticsRemote.kt

@@ -3,7 +3,9 @@ package io.github.wulkanowy.data.repositories.gradestatistics
 import io.github.wulkanowy.data.db.entities.GradePointsStatistics
 import io.github.wulkanowy.data.db.entities.GradeStatistics
 import io.github.wulkanowy.data.db.entities.Semester
+import io.github.wulkanowy.data.db.entities.Student
 import io.github.wulkanowy.sdk.Sdk
+import io.github.wulkanowy.utils.init
 import io.reactivex.Single
 import javax.inject.Inject
 import javax.inject.Singleton
@@ -11,8 +13,8 @@ import javax.inject.Singleton
 @Singleton
 class GradeStatisticsRemote @Inject constructor(private val sdk: Sdk) {
 
-    fun getGradeStatistics(semester: Semester, isSemester: Boolean): Single<List<GradeStatistics>> {
+    fun getGradeStatistics(student: Student, semester: Semester, isSemester: Boolean): Single<List<GradeStatistics>> {
-        return sdk.switchDiary(semester.diaryId, semester.schoolYear).let {
+        return sdk.init(student).switchDiary(semester.diaryId, semester.schoolYear).let {
             if (isSemester) it.getGradesAnnualStatistics(semester.semesterId)
             else it.getGradesPartialStatistics(semester.semesterId)
         }.map { gradeStatistics ->
@@ -29,8 +31,9 @@ class GradeStatisticsRemote @Inject constructor(private val sdk: Sdk) {
         }
     }
 
-    fun getGradePointsStatistics(semester: Semester): Single<List<GradePointsStatistics>> {
+    fun getGradePointsStatistics(student: Student, semester: Semester): Single<List<GradePointsStatistics>> {
-        return sdk.switchDiary(semester.diaryId, semester.schoolYear).getGradesPointsStatistics(semester.semesterId)
+        return sdk.init(student).switchDiary(semester.diaryId, semester.schoolYear)
+            .getGradesPointsStatistics(semester.semesterId)
             .map { gradePointsStatistics ->
                 gradePointsStatistics.map {
                     GradePointsStatistics(

app/src/main/java/io/github/wulkanowy/data/repositories/gradestatistics/GradeStatisticsRepository.kt

@@ -5,6 +5,7 @@ import com.github.pwittchen.reactivenetwork.library.rx2.internet.observing.Inter
 import io.github.wulkanowy.data.db.entities.GradePointsStatistics
 import io.github.wulkanowy.data.db.entities.GradeStatistics
 import io.github.wulkanowy.data.db.entities.Semester
+import io.github.wulkanowy.data.db.entities.Student
 import io.github.wulkanowy.data.pojos.GradeStatisticsItem
 import io.github.wulkanowy.ui.modules.grade.statistics.ViewType
 import io.github.wulkanowy.utils.uniqueSubtract
@@ -20,11 +21,11 @@ class GradeStatisticsRepository @Inject constructor(
     private val remote: GradeStatisticsRemote
 ) {
 
-    fun getGradesStatistics(semester: Semester, subjectName: String, isSemester: Boolean, forceRefresh: Boolean = false): Single<List<GradeStatisticsItem>> {
+    fun getGradesStatistics(student: Student, semester: Semester, subjectName: String, isSemester: Boolean, forceRefresh: Boolean = false): Single<List<GradeStatisticsItem>> {
         return local.getGradesStatistics(semester, isSemester, subjectName).map { it.mapToStatisticItems() }.filter { !forceRefresh }
             .switchIfEmpty(ReactiveNetwork.checkInternetConnectivity(settings)
                 .flatMap {
-                    if (it) remote.getGradeStatistics(semester, isSemester)
+                    if (it) remote.getGradeStatistics(student, semester, isSemester)
                     else Single.error(UnknownHostException())
                 }.flatMap { new ->
                     local.getGradesStatistics(semester, isSemester).toSingle(emptyList())
@@ -35,11 +36,11 @@ class GradeStatisticsRepository @Inject constructor(
                 }.flatMap { local.getGradesStatistics(semester, isSemester, subjectName).map { it.mapToStatisticItems() }.toSingle(emptyList()) })
     }
 
-    fun getGradesPointsStatistics(semester: Semester, subjectName: String, forceRefresh: Boolean): Single<List<GradeStatisticsItem>> {
+    fun getGradesPointsStatistics(student: Student, semester: Semester, subjectName: String, forceRefresh: Boolean): Single<List<GradeStatisticsItem>> {
         return local.getGradesPointsStatistics(semester, subjectName).map { it.mapToStatisticsItem() }.filter { !forceRefresh }
             .switchIfEmpty(ReactiveNetwork.checkInternetConnectivity(settings)
                 .flatMap {
-                    if (it) remote.getGradePointsStatistics(semester)
+                    if (it) remote.getGradePointsStatistics(student, semester)
                     else Single.error(UnknownHostException())
                 }.flatMap { new ->
                     local.getGradesPointsStatistics(semester).toSingle(emptyList())

app/src/main/java/io/github/wulkanowy/data/repositories/homework/HomeworkRemote.kt

@@ -2,7 +2,9 @@ package io.github.wulkanowy.data.repositories.homework
 
 import io.github.wulkanowy.data.db.entities.Homework
 import io.github.wulkanowy.data.db.entities.Semester
+import io.github.wulkanowy.data.db.entities.Student
 import io.github.wulkanowy.sdk.Sdk
+import io.github.wulkanowy.utils.init
 import io.reactivex.Single
 import org.threeten.bp.LocalDate
 import javax.inject.Inject
@@ -11,8 +13,9 @@ import javax.inject.Singleton
 @Singleton
 class HomeworkRemote @Inject constructor(private val sdk: Sdk) {
 
-    fun getHomework(semester: Semester, startDate: LocalDate, endDate: LocalDate): Single<List<Homework>> {
+    fun getHomework(student: Student, semester: Semester, startDate: LocalDate, endDate: LocalDate): Single<List<Homework>> {
-        return sdk.switchDiary(semester.diaryId, semester.schoolYear).getHomework(startDate, endDate)
+        return sdk.init(student).switchDiary(semester.diaryId, semester.schoolYear)
+            .getHomework(startDate, endDate)
             .map { homework ->
                 homework.map {
                     Homework(

app/src/main/java/io/github/wulkanowy/data/repositories/homework/HomeworkRepository.kt

@@ -4,6 +4,7 @@ import com.github.pwittchen.reactivenetwork.library.rx2.ReactiveNetwork
 import com.github.pwittchen.reactivenetwork.library.rx2.internet.observing.InternetObservingSettings
 import io.github.wulkanowy.data.db.entities.Homework
 import io.github.wulkanowy.data.db.entities.Semester
+import io.github.wulkanowy.data.db.entities.Student
 import io.github.wulkanowy.utils.friday
 import io.github.wulkanowy.utils.monday
 import io.github.wulkanowy.utils.uniqueSubtract
@@ -21,12 +22,12 @@ class HomeworkRepository @Inject constructor(
     private val remote: HomeworkRemote
 ) {
 
-    fun getHomework(semester: Semester, start: LocalDate, end: LocalDate, forceRefresh: Boolean = false): Single<List<Homework>> {
+    fun getHomework(student: Student, semester: Semester, start: LocalDate, end: LocalDate, forceRefresh: Boolean = false): Single<List<Homework>> {
         return Single.fromCallable { start.monday to end.friday }.flatMap { (monday, friday) ->
             local.getHomework(semester, monday, friday).filter { !forceRefresh }
                 .switchIfEmpty(ReactiveNetwork.checkInternetConnectivity(settings)
                     .flatMap {
-                        if (it) remote.getHomework(semester, monday, friday)
+                        if (it) remote.getHomework(student, semester, monday, friday)
                         else Single.error(UnknownHostException())
                     }.flatMap { new ->
                         local.getHomework(semester, monday, friday).toSingle(emptyList())

app/src/main/java/io/github/wulkanowy/data/repositories/luckynumber/LuckyNumberRemote.kt

@@ -3,6 +3,7 @@ package io.github.wulkanowy.data.repositories.luckynumber
 import io.github.wulkanowy.data.db.entities.LuckyNumber
 import io.github.wulkanowy.data.db.entities.Student
 import io.github.wulkanowy.sdk.Sdk
+import io.github.wulkanowy.utils.init
 import io.reactivex.Maybe
 import org.threeten.bp.LocalDate
 import javax.inject.Inject
@@ -12,7 +13,7 @@ import javax.inject.Singleton
 class LuckyNumberRemote @Inject constructor(private val sdk: Sdk) {
 
     fun getLuckyNumber(student: Student): Maybe<LuckyNumber> {
-        return sdk.getLuckyNumber(student.schoolShortName).map {
+        return sdk.init(student).getLuckyNumber(student.schoolShortName).map {
             LuckyNumber(
                 studentId = student.studentId,
                 date = LocalDate.now(),

app/src/main/java/io/github/wulkanowy/data/repositories/luckynumber/LuckyNumberRepository.kt

@@ -2,7 +2,6 @@ package io.github.wulkanowy.data.repositories.luckynumber
 
 import com.github.pwittchen.reactivenetwork.library.rx2.ReactiveNetwork
 import com.github.pwittchen.reactivenetwork.library.rx2.internet.observing.InternetObservingSettings
-import io.github.wulkanowy.data.SdkHelper
 import io.github.wulkanowy.data.db.entities.LuckyNumber
 import io.github.wulkanowy.data.db.entities.Student
 import io.reactivex.Completable
@@ -16,13 +15,11 @@ import javax.inject.Singleton
 class LuckyNumberRepository @Inject constructor(
     private val settings: InternetObservingSettings,
     private val local: LuckyNumberLocal,
-    private val remote: LuckyNumberRemote,
+    private val remote: LuckyNumberRemote
-    private val sdkHelper: SdkHelper
 ) {
 
     fun getLuckyNumber(student: Student, forceRefresh: Boolean = false, notify: Boolean = false): Maybe<LuckyNumber> {
-        return Maybe.just(sdkHelper.init(student)).flatMap {
+        return local.getLuckyNumber(student, LocalDate.now()).filter { !forceRefresh }
-            local.getLuckyNumber(student, LocalDate.now()).filter { !forceRefresh }
             .switchIfEmpty(ReactiveNetwork.checkInternetConnectivity(settings)
                 .flatMapMaybe {
                     if (it) remote.getLuckyNumber(student)
@@ -46,7 +43,6 @@ class LuckyNumberRepository @Inject constructor(
                     { local.getLuckyNumber(student, LocalDate.now()) })
             )
     }
-    }
 
     fun getNotNotifiedLuckyNumber(student: Student): Maybe<LuckyNumber> {
         return local.getLuckyNumber(student, LocalDate.now()).filter { !it.isNotified }

app/src/main/java/io/github/wulkanowy/data/repositories/message/MessageRemote.kt

@@ -8,6 +8,7 @@ import io.github.wulkanowy.data.db.entities.Student
 import io.github.wulkanowy.sdk.Sdk
 import io.github.wulkanowy.sdk.pojo.Folder
 import io.github.wulkanowy.sdk.pojo.SentMessage
+import io.github.wulkanowy.utils.init
 import io.reactivex.Single
 import org.threeten.bp.LocalDateTime.now
 import javax.inject.Inject
@@ -18,7 +19,7 @@ import io.github.wulkanowy.sdk.pojo.Recipient as SdkRecipient
 class MessageRemote @Inject constructor(private val sdk: Sdk) {
 
     fun getMessages(student: Student, semester: Semester, folder: MessageFolder): Single<List<Message>> {
-        return sdk.getMessages(Folder.valueOf(folder.name), semester.start.atStartOfDay(), semester.end.atStartOfDay()).map { messages ->
+        return sdk.init(student).getMessages(Folder.valueOf(folder.name), semester.start.atStartOfDay(), semester.end.atStartOfDay()).map { messages ->
             messages.map {
                 Message(
                     studentId = student.id.toInt(),
@@ -41,8 +42,8 @@ class MessageRemote @Inject constructor(private val sdk: Sdk) {
         }
     }
 
-    fun getMessagesContentDetails(message: Message, markAsRead: Boolean = false): Single<Pair<String, List<MessageAttachment>>> {
+    fun getMessagesContentDetails(student: Student, message: Message, markAsRead: Boolean = false): Single<Pair<String, List<MessageAttachment>>> {
-        return sdk.getMessageDetails(message.messageId, message.folderId, markAsRead, message.realId).map { details ->
+        return sdk.init(student).getMessageDetails(message.messageId, message.folderId, markAsRead, message.realId).map { details ->
             details.content to details.attachments.map {
                 MessageAttachment(
                     realId = it.id,
@@ -55,8 +56,8 @@ class MessageRemote @Inject constructor(private val sdk: Sdk) {
         }
     }
 
-    fun sendMessage(subject: String, content: String, recipients: List<Recipient>): Single<SentMessage> {
+    fun sendMessage(student: Student, subject: String, content: String, recipients: List<Recipient>): Single<SentMessage> {
-        return sdk.sendMessage(
+        return sdk.init(student).sendMessage(
             subject = subject,
             content = content,
             recipients = recipients.map {
@@ -73,7 +74,7 @@ class MessageRemote @Inject constructor(private val sdk: Sdk) {
         )
     }
 
-    fun deleteMessage(message: Message): Single<Boolean> {
+    fun deleteMessage(student: Student, message: Message): Single<Boolean> {
-        return sdk.deleteMessages(listOf(Pair(message.realId, message.folderId)))
+        return sdk.init(student).deleteMessages(listOf(Pair(message.realId, message.folderId)))
     }
 }

app/src/main/java/io/github/wulkanowy/data/repositories/message/MessageRepository.kt

@@ -2,7 +2,6 @@ package io.github.wulkanowy.data.repositories.message
 
 import com.github.pwittchen.reactivenetwork.library.rx2.ReactiveNetwork
 import com.github.pwittchen.reactivenetwork.library.rx2.internet.observing.InternetObservingSettings
-import io.github.wulkanowy.data.SdkHelper
 import io.github.wulkanowy.data.db.entities.Message
 import io.github.wulkanowy.data.db.entities.MessageWithAttachment
 import io.github.wulkanowy.data.db.entities.Recipient
@@ -22,14 +21,11 @@ import javax.inject.Singleton
 class MessageRepository @Inject constructor(
     private val settings: InternetObservingSettings,
     private val local: MessageLocal,
-    private val remote: MessageRemote,
+    private val remote: MessageRemote
-    private val sdkHelper: SdkHelper
 ) {
 
     fun getMessages(student: Student, semester: Semester, folder: MessageFolder, forceRefresh: Boolean = false, notify: Boolean = false): Single<List<Message>> {
-        return Single.just(sdkHelper.init(student))
+        return local.getMessages(student, folder).filter { !forceRefresh }
-            .flatMap { _ ->
-                local.getMessages(student, folder).filter { !forceRefresh }
             .switchIfEmpty(ReactiveNetwork.checkInternetConnectivity(settings)
                 .flatMap {
                     if (it) remote.getMessages(student, semester, folder)
@@ -46,12 +42,9 @@ class MessageRepository @Inject constructor(
                 }.flatMap { local.getMessages(student, folder).toSingle(emptyList()) }
             )
     }
-    }
 
     fun getMessage(student: Student, message: Message, markAsRead: Boolean = false): Single<MessageWithAttachment> {
-        return Single.just(sdkHelper.init(student))
+        return local.getMessageWithAttachment(student, message)
-            .flatMap { _ ->
-                local.getMessageWithAttachment(student, message)
             .filter {
                 it.message.content.isNotEmpty().also { status ->
                     Timber.d("Message content in db empty: ${!status}")
@@ -63,7 +56,7 @@ class MessageRepository @Inject constructor(
                     else Single.error(UnknownHostException())
                 }
                 .flatMap { dbMessage ->
-                            remote.getMessagesContentDetails(dbMessage.message, markAsRead).doOnSuccess { (downloadedMessage, attachments) ->
+                    remote.getMessagesContentDetails(student, dbMessage.message, markAsRead).doOnSuccess { (downloadedMessage, attachments) ->
                         local.updateMessages(listOf(dbMessage.message.copy(unread = !markAsRead).apply {
                             id = dbMessage.message.id
                             content = content.ifBlank { downloadedMessage }
@@ -76,7 +69,6 @@ class MessageRepository @Inject constructor(
                 }
             )
     }
-    }
 
     fun getNotNotifiedMessages(student: Student): Single<List<Message>> {
         return local.getMessages(student, RECEIVED)
@@ -88,18 +80,18 @@ class MessageRepository @Inject constructor(
         return Completable.fromCallable { local.updateMessages(messages) }
     }
 
-    fun sendMessage(subject: String, content: String, recipients: List<Recipient>): Single<SentMessage> {
+    fun sendMessage(student: Student, subject: String, content: String, recipients: List<Recipient>): Single<SentMessage> {
         return ReactiveNetwork.checkInternetConnectivity(settings)
             .flatMap {
-                if (it) remote.sendMessage(subject, content, recipients)
+                if (it) remote.sendMessage(student, subject, content, recipients)
                 else Single.error(UnknownHostException())
             }
     }
 
-    fun deleteMessage(message: Message): Single<Boolean> {
+    fun deleteMessage(student: Student, message: Message): Single<Boolean> {
         return ReactiveNetwork.checkInternetConnectivity(settings)
             .flatMap {
-                if (it) remote.deleteMessage(message)
+                if (it) remote.deleteMessage(student, message)
                 else Single.error(UnknownHostException())
             }
             .doOnSuccess {

app/src/main/java/io/github/wulkanowy/data/repositories/mobiledevice/MobileDeviceRemote.kt

@@ -2,8 +2,10 @@ package io.github.wulkanowy.data.repositories.mobiledevice
 
 import io.github.wulkanowy.data.db.entities.MobileDevice
 import io.github.wulkanowy.data.db.entities.Semester
+import io.github.wulkanowy.data.db.entities.Student
 import io.github.wulkanowy.data.pojos.MobileDeviceToken
 import io.github.wulkanowy.sdk.Sdk
+import io.github.wulkanowy.utils.init
 import io.reactivex.Single
 import javax.inject.Inject
 import javax.inject.Singleton
@@ -11,13 +13,14 @@ import javax.inject.Singleton
 @Singleton
 class MobileDeviceRemote @Inject constructor(private val sdk: Sdk) {
 
-    fun getDevices(semester: Semester): Single<List<MobileDevice>> {
+    fun getDevices(student: Student, semester: Semester): Single<List<MobileDevice>> {
-        return sdk.switchDiary(semester.diaryId, semester.schoolYear).getRegisteredDevices()
+        return sdk.init(student).switchDiary(semester.diaryId, semester.schoolYear)
+            .getRegisteredDevices()
             .map { devices ->
                 devices.map {
                     MobileDevice(
                         studentId = semester.studentId,
-                        date = it.date,
+                        date = it.createDate,
                         deviceId = it.id,
                         name = it.name
                     )
@@ -25,12 +28,14 @@ class MobileDeviceRemote @Inject constructor(private val sdk: Sdk) {
             }
     }
 
-    fun unregisterDevice(semester: Semester, device: MobileDevice): Single<Boolean> {
+    fun unregisterDevice(student: Student, semester: Semester, device: MobileDevice): Single<Boolean> {
-        return sdk.switchDiary(semester.diaryId, semester.schoolYear).unregisterDevice(device.deviceId)
+        return sdk.init(student).switchDiary(semester.diaryId, semester.schoolYear)
+            .unregisterDevice(device.deviceId)
     }
 
-    fun getToken(semester: Semester): Single<MobileDeviceToken> {
+    fun getToken(student: Student, semester: Semester): Single<MobileDeviceToken> {
-        return sdk.switchDiary(semester.diaryId, semester.schoolYear).getToken()
+        return sdk.init(student).switchDiary(semester.diaryId, semester.schoolYear)
+            .getToken()
             .map {
                 MobileDeviceToken(
                     token = it.token,

app/src/main/java/io/github/wulkanowy/data/repositories/mobiledevice/MobileDeviceRepository.kt

@@ -4,6 +4,7 @@ import com.github.pwittchen.reactivenetwork.library.rx2.ReactiveNetwork
 import com.github.pwittchen.reactivenetwork.library.rx2.internet.observing.InternetObservingSettings
 import io.github.wulkanowy.data.db.entities.MobileDevice
 import io.github.wulkanowy.data.db.entities.Semester
+import io.github.wulkanowy.data.db.entities.Student
 import io.github.wulkanowy.data.pojos.MobileDeviceToken
 import io.github.wulkanowy.utils.uniqueSubtract
 import io.reactivex.Single
@@ -18,11 +19,11 @@ class MobileDeviceRepository @Inject constructor(
     private val remote: MobileDeviceRemote
 ) {
 
-    fun getDevices(semester: Semester, forceRefresh: Boolean = false): Single<List<MobileDevice>> {
+    fun getDevices(student: Student, semester: Semester, forceRefresh: Boolean = false): Single<List<MobileDevice>> {
         return local.getDevices(semester).filter { !forceRefresh }
             .switchIfEmpty(ReactiveNetwork.checkInternetConnectivity(settings)
                 .flatMap {
-                    if (it) remote.getDevices(semester)
+                    if (it) remote.getDevices(student, semester)
                     else Single.error(UnknownHostException())
                 }.flatMap { new ->
                     local.getDevices(semester).toSingle(emptyList())
@@ -34,18 +35,18 @@ class MobileDeviceRepository @Inject constructor(
             ).flatMap { local.getDevices(semester).toSingle(emptyList()) }
     }
 
-    fun unregisterDevice(semester: Semester, device: MobileDevice): Single<Boolean> {
+    fun unregisterDevice(student: Student, semester: Semester, device: MobileDevice): Single<Boolean> {
         return ReactiveNetwork.checkInternetConnectivity(settings)
             .flatMap {
-                if (it) remote.unregisterDevice(semester, device)
+                if (it) remote.unregisterDevice(student, semester, device)
                 else Single.error(UnknownHostException())
             }
     }
 
-    fun getToken(semester: Semester): Single<MobileDeviceToken> {
+    fun getToken(student: Student, semester: Semester): Single<MobileDeviceToken> {
         return ReactiveNetwork.checkInternetConnectivity(settings)
             .flatMap {
-                if (it) remote.getToken(semester)
+                if (it) remote.getToken(student, semester)
                 else Single.error(UnknownHostException())
             }
     }

app/src/main/java/io/github/wulkanowy/data/repositories/note/NoteRemote.kt

@@ -2,7 +2,9 @@ package io.github.wulkanowy.data.repositories.note
 
 import io.github.wulkanowy.data.db.entities.Note
 import io.github.wulkanowy.data.db.entities.Semester
+import io.github.wulkanowy.data.db.entities.Student
 import io.github.wulkanowy.sdk.Sdk
+import io.github.wulkanowy.utils.init
 import io.reactivex.Single
 import javax.inject.Inject
 import javax.inject.Singleton
@@ -10,8 +12,9 @@ import javax.inject.Singleton
 @Singleton
 class NoteRemote @Inject constructor(private val sdk: Sdk) {
 
-    fun getNotes(semester: Semester): Single<List<Note>> {
+    fun getNotes(student: Student, semester: Semester): Single<List<Note>> {
-        return sdk.switchDiary(semester.diaryId, semester.schoolYear).getNotes(semester.semesterId)
+        return sdk.init(student).switchDiary(semester.diaryId, semester.schoolYear)
+            .getNotes(semester.semesterId)
             .map { notes ->
                 notes.map {
                     Note(

app/src/main/java/io/github/wulkanowy/data/repositories/note/NoteRepository.kt

@@ -23,7 +23,7 @@ class NoteRepository @Inject constructor(
         return local.getNotes(student).filter { !forceRefresh }
             .switchIfEmpty(ReactiveNetwork.checkInternetConnectivity(settings)
                 .flatMap {
-                    if (it) remote.getNotes(semester)
+                    if (it) remote.getNotes(student, semester)
                     else Single.error(UnknownHostException())
                 }.flatMap { new ->
                     local.getNotes(student).toSingle(emptyList())

app/src/main/java/io/github/wulkanowy/data/repositories/recipient/RecipientRemote.kt

@@ -3,7 +3,9 @@ package io.github.wulkanowy.data.repositories.recipient
 import io.github.wulkanowy.data.db.entities.Message
 import io.github.wulkanowy.data.db.entities.Recipient
 import io.github.wulkanowy.data.db.entities.ReportingUnit
+import io.github.wulkanowy.data.db.entities.Student
 import io.github.wulkanowy.sdk.Sdk
+import io.github.wulkanowy.utils.init
 import io.reactivex.Single
 import javax.inject.Inject
 import javax.inject.Singleton
@@ -12,15 +14,15 @@ import io.github.wulkanowy.sdk.pojo.Recipient as SdkRecipient
 @Singleton
 class RecipientRemote @Inject constructor(private val sdk: Sdk) {
 
-    fun getRecipients(role: Int, unit: ReportingUnit): Single<List<Recipient>> {
+    fun getRecipients(student: Student, role: Int, unit: ReportingUnit): Single<List<Recipient>> {
-        return sdk.getRecipients(unit.realId, role)
+        return sdk.init(student).getRecipients(unit.realId, role)
             .map { recipients ->
                 recipients.map { it.toRecipient() }
             }
     }
 
-    fun getMessageRecipients(message: Message): Single<List<Recipient>> {
+    fun getMessageRecipients(student: Student, message: Message): Single<List<Recipient>> {
-        return sdk.getMessageRecipients(message.messageId, message.senderId)
+        return sdk.init(student).getMessageRecipients(message.messageId, message.senderId)
             .map { recipients ->
                 recipients.map { it.toRecipient() }
             }

app/src/main/java/io/github/wulkanowy/data/repositories/recipient/RecipientRepository.kt

@@ -2,7 +2,6 @@ package io.github.wulkanowy.data.repositories.recipient
 
 import com.github.pwittchen.reactivenetwork.library.rx2.ReactiveNetwork
 import com.github.pwittchen.reactivenetwork.library.rx2.internet.observing.InternetObservingSettings
-import io.github.wulkanowy.data.SdkHelper
 import io.github.wulkanowy.data.db.entities.Message
 import io.github.wulkanowy.data.db.entities.Recipient
 import io.github.wulkanowy.data.db.entities.ReportingUnit
@@ -17,17 +16,14 @@ import javax.inject.Singleton
 class RecipientRepository @Inject constructor(
     private val settings: InternetObservingSettings,
     private val local: RecipientLocal,
-    private val remote: RecipientRemote,
+    private val remote: RecipientRemote
-    private val sdkHelper: SdkHelper
 ) {
 
     fun getRecipients(student: Student, role: Int, unit: ReportingUnit, forceRefresh: Boolean = false): Single<List<Recipient>> {
-        return Single.just(sdkHelper.init(student))
+        return local.getRecipients(student, role, unit).filter { !forceRefresh }
-            .flatMap { _ ->
-                local.getRecipients(student, role, unit).filter { !forceRefresh }
             .switchIfEmpty(ReactiveNetwork.checkInternetConnectivity(settings)
                 .flatMap {
-                            if (it) remote.getRecipients(role, unit)
+                    if (it) remote.getRecipients(student, role, unit)
                     else Single.error(UnknownHostException())
                 }.flatMap { new ->
                     local.getRecipients(student, role, unit).toSingle(emptyList())
@@ -40,13 +36,11 @@ class RecipientRepository @Inject constructor(
                 }
             )
     }
-    }
 
     fun getMessageRecipients(student: Student, message: Message): Single<List<Recipient>> {
-        return Single.just(sdkHelper.init(student))
+        return ReactiveNetwork.checkInternetConnectivity(settings)
-            .flatMap { ReactiveNetwork.checkInternetConnectivity(settings) }
             .flatMap {
-                if (it) remote.getMessageRecipients(message)
+                if (it) remote.getMessageRecipients(student, message)
                 else Single.error(UnknownHostException())
             }
     }

app/src/main/java/io/github/wulkanowy/data/repositories/reportingunit/ReportingUnitRemote.kt

@@ -1,7 +1,9 @@
 package io.github.wulkanowy.data.repositories.reportingunit
 
 import io.github.wulkanowy.data.db.entities.ReportingUnit
+import io.github.wulkanowy.data.db.entities.Student
 import io.github.wulkanowy.sdk.Sdk
+import io.github.wulkanowy.utils.init
 import io.reactivex.Single
 import javax.inject.Inject
 import javax.inject.Singleton
@@ -9,8 +11,8 @@ import javax.inject.Singleton
 @Singleton
 class ReportingUnitRemote @Inject constructor(private val sdk: Sdk) {
 
-    fun getReportingUnits(): Single<List<ReportingUnit>> {
+    fun getReportingUnits(student: Student): Single<List<ReportingUnit>> {
-        return sdk.getReportingUnits().map {
+        return sdk.init(student).getReportingUnits().map {
             it.map { unit ->
                 ReportingUnit(
                     studentId = sdk.studentId,

app/src/main/java/io/github/wulkanowy/data/repositories/reportingunit/ReportingUnitRepository.kt

@@ -2,7 +2,6 @@ package io.github.wulkanowy.data.repositories.reportingunit
 
 import com.github.pwittchen.reactivenetwork.library.rx2.ReactiveNetwork
 import com.github.pwittchen.reactivenetwork.library.rx2.internet.observing.InternetObservingSettings
-import io.github.wulkanowy.data.SdkHelper
 import io.github.wulkanowy.data.db.entities.ReportingUnit
 import io.github.wulkanowy.data.db.entities.Student
 import io.github.wulkanowy.utils.uniqueSubtract
@@ -16,17 +15,14 @@ import javax.inject.Singleton
 class ReportingUnitRepository @Inject constructor(
     private val settings: InternetObservingSettings,
     private val local: ReportingUnitLocal,
-    private val remote: ReportingUnitRemote,
+    private val remote: ReportingUnitRemote
-    private val sdkHelper: SdkHelper
 ) {
 
     fun getReportingUnits(student: Student, forceRefresh: Boolean = false): Single<List<ReportingUnit>> {
-        return Single.just(sdkHelper.init(student))
+        return local.getReportingUnits(student).filter { !forceRefresh }
-            .flatMap { _ ->
-                local.getReportingUnits(student).filter { !forceRefresh }
             .switchIfEmpty(ReactiveNetwork.checkInternetConnectivity(settings)
                 .flatMap {
-                            if (it) remote.getReportingUnits()
+                    if (it) remote.getReportingUnits(student)
                     else Single.error(UnknownHostException())
                 }.flatMap { new ->
                     local.getReportingUnits(student).toSingle(emptyList())
@@ -37,12 +33,9 @@ class ReportingUnitRepository @Inject constructor(
                 }.flatMap { local.getReportingUnits(student).toSingle(emptyList()) }
             )
     }
-    }
 
     fun getReportingUnit(student: Student, unitId: Int): Maybe<ReportingUnit> {
-        return Maybe.just(sdkHelper.init(student))
+        return local.getReportingUnit(student, unitId)
-            .flatMap { _ ->
-                local.getReportingUnit(student, unitId)
             .switchIfEmpty(ReactiveNetwork.checkInternetConnectivity(settings)
                 .flatMap {
                     if (it) getReportingUnits(student, true)
@@ -53,4 +46,3 @@ class ReportingUnitRepository @Inject constructor(
             )
     }
 }
-}

app/src/main/java/io/github/wulkanowy/data/repositories/school/SchoolRemote.kt

@@ -2,14 +2,17 @@ package io.github.wulkanowy.data.repositories.school
 
 import io.github.wulkanowy.data.db.entities.School
 import io.github.wulkanowy.data.db.entities.Semester
+import io.github.wulkanowy.data.db.entities.Student
 import io.github.wulkanowy.sdk.Sdk
+import io.github.wulkanowy.utils.init
 import io.reactivex.Single
 import javax.inject.Inject
 
 class SchoolRemote @Inject constructor(private val sdk: Sdk) {
 
-    fun getSchoolInfo(semester: Semester): Single<School> {
+    fun getSchoolInfo(student: Student, semester: Semester): Single<School> {
-        return sdk.switchDiary(semester.diaryId, semester.schoolYear).getSchool()
+        return sdk.init(student).switchDiary(semester.diaryId, semester.schoolYear)
+            .getSchool()
             .map {
                 School(
                     studentId = semester.studentId,

app/src/main/java/io/github/wulkanowy/data/repositories/school/SchoolRepository.kt

@@ -4,6 +4,7 @@ import com.github.pwittchen.reactivenetwork.library.rx2.ReactiveNetwork
 import com.github.pwittchen.reactivenetwork.library.rx2.internet.observing.InternetObservingSettings
 import io.github.wulkanowy.data.db.entities.School
 import io.github.wulkanowy.data.db.entities.Semester
+import io.github.wulkanowy.data.db.entities.Student
 import io.reactivex.Maybe
 import io.reactivex.Single
 import java.net.UnknownHostException
@@ -17,11 +18,11 @@ class SchoolRepository @Inject constructor(
     private val remote: SchoolRemote
 ) {
 
-    fun getSchoolInfo(semester: Semester, forceRefresh: Boolean = false): Maybe<School> {
+    fun getSchoolInfo(student: Student, semester: Semester, forceRefresh: Boolean = false): Maybe<School> {
         return local.getSchool(semester).filter { !forceRefresh }
             .switchIfEmpty(ReactiveNetwork.checkInternetConnectivity(settings)
                 .flatMap {
-                    if (it) remote.getSchoolInfo(semester)
+                    if (it) remote.getSchoolInfo(student, semester)
                     else Single.error(UnknownHostException())
                 }.flatMapMaybe { new ->
                     local.getSchool(semester)

app/src/main/java/io/github/wulkanowy/data/repositories/semester/SemesterRemote.kt

@@ -3,6 +3,7 @@ package io.github.wulkanowy.data.repositories.semester
 import io.github.wulkanowy.data.db.entities.Semester
 import io.github.wulkanowy.data.db.entities.Student
 import io.github.wulkanowy.sdk.Sdk
+import io.github.wulkanowy.utils.init
 import io.reactivex.Single
 import javax.inject.Inject
 import javax.inject.Singleton
@@ -11,7 +12,7 @@ import javax.inject.Singleton
 class SemesterRemote @Inject constructor(private val sdk: Sdk) {
 
     fun getSemesters(student: Student): Single<List<Semester>> {
-        return sdk.getSemesters().map { semesters ->
+        return sdk.init(student).getSemesters().map { semesters ->
             semesters.map {
                 Semester(
                     studentId = student.studentId,

app/src/main/java/io/github/wulkanowy/data/repositories/semester/SemesterRepository.kt

@@ -2,13 +2,11 @@ package io.github.wulkanowy.data.repositories.semester
 
 import com.github.pwittchen.reactivenetwork.library.rx2.ReactiveNetwork
 import com.github.pwittchen.reactivenetwork.library.rx2.internet.observing.InternetObservingSettings
-import io.github.wulkanowy.data.SdkHelper
 import io.github.wulkanowy.data.db.entities.Semester
 import io.github.wulkanowy.data.db.entities.Student
 import io.github.wulkanowy.utils.getCurrentOrLast
 import io.github.wulkanowy.utils.isCurrent
 import io.github.wulkanowy.utils.uniqueSubtract
-import io.reactivex.Maybe
 import io.reactivex.Single
 import java.net.UnknownHostException
 import javax.inject.Inject
@@ -18,20 +16,15 @@ import javax.inject.Singleton
 class SemesterRepository @Inject constructor(
     private val remote: SemesterRemote,
     private val local: SemesterLocal,
-    private val settings: InternetObservingSettings,
+    private val settings: InternetObservingSettings
-    private val sdkHelper: SdkHelper
 ) {
 
     fun getSemesters(student: Student, forceRefresh: Boolean = false, refreshOnNoCurrent: Boolean = false): Single<List<Semester>> {
-        return Maybe.just(sdkHelper.init(student))
+        return local.getSemesters(student).filter { !forceRefresh }.filter {
-            .flatMap {
-                local.getSemesters(student).filter { !forceRefresh }.filter {
             if (refreshOnNoCurrent) {
                 it.any { semester -> semester.isCurrent }
             } else true
-                }
+        }.switchIfEmpty(ReactiveNetwork.checkInternetConnectivity(settings)
-            }
-            .switchIfEmpty(ReactiveNetwork.checkInternetConnectivity(settings)
             .flatMap {
                 if (it) remote.getSemesters(student)
                 else Single.error(UnknownHostException())

app/src/main/java/io/github/wulkanowy/data/repositories/subject/SubjectLocal.kt

@@ -12,7 +12,7 @@ class SubjectLocal @Inject constructor(private val subjectDao: SubjectDao) {
 
     fun getSubjects(semester: Semester): Maybe<List<Subject>> {
         return subjectDao.loadAll(semester.diaryId, semester.studentId)
-            .filter { !it.isEmpty() }
+            .filter { it.isNotEmpty() }
     }
 
     fun saveSubjects(subjects: List<Subject>) {

app/src/main/java/io/github/wulkanowy/data/repositories/subject/SubjectRemote.kt

@@ -1,8 +1,10 @@
 package io.github.wulkanowy.data.repositories.subject
 
 import io.github.wulkanowy.data.db.entities.Semester
+import io.github.wulkanowy.data.db.entities.Student
 import io.github.wulkanowy.data.db.entities.Subject
 import io.github.wulkanowy.sdk.Sdk
+import io.github.wulkanowy.utils.init
 import io.reactivex.Single
 import javax.inject.Inject
 import javax.inject.Singleton
@@ -10,8 +12,9 @@ import javax.inject.Singleton
 @Singleton
 class SubjectRemote @Inject constructor(private val sdk: Sdk) {
 
-    fun getSubjects(semester: Semester): Single<List<Subject>> {
+    fun getSubjects(student: Student, semester: Semester): Single<List<Subject>> {
-        return sdk.switchDiary(semester.diaryId, semester.schoolYear).getSubjects()
+        return sdk.init(student).switchDiary(semester.diaryId, semester.schoolYear)
+            .getSubjects()
             .map { subjects ->
                 subjects.map {
                     Subject(

app/src/main/java/io/github/wulkanowy/data/repositories/subject/SubjectRepository.kt

@@ -3,6 +3,7 @@ package io.github.wulkanowy.data.repositories.subject
 import com.github.pwittchen.reactivenetwork.library.rx2.ReactiveNetwork
 import com.github.pwittchen.reactivenetwork.library.rx2.internet.observing.InternetObservingSettings
 import io.github.wulkanowy.data.db.entities.Semester
+import io.github.wulkanowy.data.db.entities.Student
 import io.github.wulkanowy.data.db.entities.Subject
 import io.github.wulkanowy.utils.uniqueSubtract
 import io.reactivex.Single
@@ -17,11 +18,11 @@ class SubjectRepository @Inject constructor(
     private val remote: SubjectRemote
 ) {
 
-    fun getSubjects(semester: Semester, forceRefresh: Boolean = false): Single<List<Subject>> {
+    fun getSubjects(student: Student, semester: Semester, forceRefresh: Boolean = false): Single<List<Subject>> {
         return local.getSubjects(semester).filter { !forceRefresh }
             .switchIfEmpty(ReactiveNetwork.checkInternetConnectivity(settings)
                 .flatMap {
-                    if (it) remote.getSubjects(semester)
+                    if (it) remote.getSubjects(student, semester)
                     else Single.error(UnknownHostException())
                 }.flatMap { new ->
                     local.getSubjects(semester)

app/src/main/java/io/github/wulkanowy/data/repositories/teacher/TeacherRemote.kt

@@ -1,8 +1,10 @@
 package io.github.wulkanowy.data.repositories.teacher
 
 import io.github.wulkanowy.data.db.entities.Semester
+import io.github.wulkanowy.data.db.entities.Student
 import io.github.wulkanowy.data.db.entities.Teacher
 import io.github.wulkanowy.sdk.Sdk
+import io.github.wulkanowy.utils.init
 import io.reactivex.Single
 import javax.inject.Inject
 import javax.inject.Singleton
@@ -10,8 +12,9 @@ import javax.inject.Singleton
 @Singleton
 class TeacherRemote @Inject constructor(private val sdk: Sdk) {
 
-    fun getTeachers(semester: Semester): Single<List<Teacher>> {
+    fun getTeachers(student: Student, semester: Semester): Single<List<Teacher>> {
-        return sdk.switchDiary(semester.diaryId, semester.schoolYear).getTeachers(semester.semesterId)
+        return sdk.init(student).switchDiary(semester.diaryId, semester.schoolYear)
+            .getTeachers(semester.semesterId)
             .map { teachers ->
                 teachers.map {
                     Teacher(

app/src/main/java/io/github/wulkanowy/data/repositories/teacher/TeacherRepository.kt

@@ -3,6 +3,7 @@ package io.github.wulkanowy.data.repositories.teacher
 import com.github.pwittchen.reactivenetwork.library.rx2.ReactiveNetwork
 import com.github.pwittchen.reactivenetwork.library.rx2.internet.observing.InternetObservingSettings
 import io.github.wulkanowy.data.db.entities.Semester
+import io.github.wulkanowy.data.db.entities.Student
 import io.github.wulkanowy.data.db.entities.Teacher
 import io.github.wulkanowy.utils.uniqueSubtract
 import io.reactivex.Single
@@ -17,11 +18,11 @@ class TeacherRepository @Inject constructor(
     private val remote: TeacherRemote
 ) {
 
-    fun getTeachers(semester: Semester, forceRefresh: Boolean = false): Single<List<Teacher>> {
+    fun getTeachers(student: Student, semester: Semester, forceRefresh: Boolean = false): Single<List<Teacher>> {
         return local.getTeachers(semester).filter { !forceRefresh }
             .switchIfEmpty(ReactiveNetwork.checkInternetConnectivity(settings)
                 .flatMap {
-                    if (it) remote.getTeachers(semester)
+                    if (it) remote.getTeachers(student, semester)
                     else Single.error(UnknownHostException())
                 }.flatMap { new ->
                     local.getTeachers(semester).toSingle(emptyList())

app/src/main/java/io/github/wulkanowy/data/repositories/timetable/TimetableRemote.kt

@@ -1,8 +1,10 @@
 package io.github.wulkanowy.data.repositories.timetable
 
 import io.github.wulkanowy.data.db.entities.Semester
+import io.github.wulkanowy.data.db.entities.Student
 import io.github.wulkanowy.data.db.entities.Timetable
 import io.github.wulkanowy.sdk.Sdk
+import io.github.wulkanowy.utils.init
 import io.reactivex.Single
 import org.threeten.bp.LocalDate
 import javax.inject.Inject
@@ -11,8 +13,9 @@ import javax.inject.Singleton
 @Singleton
 class TimetableRemote @Inject constructor(private val sdk: Sdk) {
 
-    fun getTimetable(semester: Semester, startDate: LocalDate, endDate: LocalDate): Single<List<Timetable>> {
+    fun getTimetable(student: Student, semester: Semester, startDate: LocalDate, endDate: LocalDate): Single<List<Timetable>> {
-        return sdk.switchDiary(semester.diaryId, semester.schoolYear).getTimetable(startDate, endDate)
+        return sdk.init(student).switchDiary(semester.diaryId, semester.schoolYear)
+            .getTimetable(startDate, endDate)
             .map { lessons ->
                 lessons.map {
                     Timetable(

app/src/main/java/io/github/wulkanowy/data/repositories/timetable/TimetableRepository.kt

@@ -3,6 +3,7 @@ package io.github.wulkanowy.data.repositories.timetable
 import com.github.pwittchen.reactivenetwork.library.rx2.ReactiveNetwork
 import com.github.pwittchen.reactivenetwork.library.rx2.internet.observing.InternetObservingSettings
 import io.github.wulkanowy.data.db.entities.Semester
+import io.github.wulkanowy.data.db.entities.Student
 import io.github.wulkanowy.data.db.entities.Timetable
 import io.github.wulkanowy.utils.friday
 import io.github.wulkanowy.utils.monday
@@ -20,11 +21,11 @@ class TimetableRepository @Inject constructor(
     private val remote: TimetableRemote
 ) {
 
-    fun getTimetable(semester: Semester, start: LocalDate, end: LocalDate, forceRefresh: Boolean = false): Single<List<Timetable>> {
+    fun getTimetable(student: Student, semester: Semester, start: LocalDate, end: LocalDate, forceRefresh: Boolean = false): Single<List<Timetable>> {
         return Single.fromCallable { start.monday to end.friday }.flatMap { (monday, friday) ->
             local.getTimetable(semester, monday, friday).filter { !forceRefresh }
                 .switchIfEmpty(ReactiveNetwork.checkInternetConnectivity(settings).flatMap {
-                    if (it) remote.getTimetable(semester, monday, friday)
+                    if (it) remote.getTimetable(student, semester, monday, friday)
                     else Single.error(UnknownHostException())
                 }.flatMap { new ->
                     local.getTimetable(semester, monday, friday)

app/src/main/java/io/github/wulkanowy/services/sync/works/AttendanceSummaryWork.kt

@@ -11,7 +11,7 @@ class AttendanceSummaryWork @Inject constructor(
 ) : Work {
 
     override fun create(student: Student, semester: Semester): Completable {
-        return attendanceSummaryRepository.getAttendanceSummary(semester, -1, true).ignoreElement()
+        return attendanceSummaryRepository.getAttendanceSummary(student, semester, -1, true).ignoreElement()
     }
 }
 

app/src/main/java/io/github/wulkanowy/services/sync/works/AttendanceWork.kt

@@ -12,7 +12,7 @@ import javax.inject.Inject
 class AttendanceWork @Inject constructor(private val attendanceRepository: AttendanceRepository) : Work {
 
     override fun create(student: Student, semester: Semester): Completable {
-        return attendanceRepository.getAttendance(semester, now().monday, now().friday, true)
+        return attendanceRepository.getAttendance(student, semester, now().monday, now().friday, true)
             .ignoreElement()
     }
 }

app/src/main/java/io/github/wulkanowy/services/sync/works/CompletedLessonWork.kt

@@ -14,7 +14,7 @@ class CompletedLessonWork @Inject constructor(
 ) : Work {
 
     override fun create(student: Student, semester: Semester): Completable {
-        return completedLessonsRepository.getCompletedLessons(semester, now().monday, now().friday, true)
+        return completedLessonsRepository.getCompletedLessons(student, semester, now().monday, now().friday, true)
             .ignoreElement()
     }
 }

app/src/main/java/io/github/wulkanowy/services/sync/works/ExamWork.kt

@@ -12,6 +12,6 @@ import javax.inject.Inject
 class ExamWork @Inject constructor(private val examRepository: ExamRepository) : Work {
 
     override fun create(student: Student, semester: Semester): Completable {
-        return examRepository.getExams(semester, now().monday, now().friday, true).ignoreElement()
+        return examRepository.getExams(student, semester, now().monday, now().friday, true).ignoreElement()
     }
 }

app/src/main/java/io/github/wulkanowy/services/sync/works/GradeStatisticsWork.kt

@@ -9,7 +9,7 @@ import javax.inject.Inject
 class GradeStatisticsWork @Inject constructor(private val gradeStatisticsRepository: GradeStatisticsRepository) : Work {
 
     override fun create(student: Student, semester: Semester): Completable {
-        return gradeStatisticsRepository.getGradesStatistics(semester, "Wszystkie", false, true)
+        return gradeStatisticsRepository.getGradesStatistics(student, semester, "Wszystkie", false, true)
             .ignoreElement()
     }
 }

app/src/main/java/io/github/wulkanowy/services/sync/works/GradeSummaryWork.kt

@@ -9,6 +9,6 @@ import javax.inject.Inject
 class GradeSummaryWork @Inject constructor(private val gradeSummaryRepository: GradeSummaryRepository) : Work {
 
     override fun create(student: Student, semester: Semester): Completable {
-        return gradeSummaryRepository.getGradesSummary(semester, true).ignoreElement()
+        return gradeSummaryRepository.getGradesSummary(student, semester, true).ignoreElement()
     }
 }

app/src/main/java/io/github/wulkanowy/services/sync/works/HomeworkWork.kt

@@ -12,6 +12,6 @@ import javax.inject.Inject
 class HomeworkWork @Inject constructor(private val homeworkRepository: HomeworkRepository) : Work {
 
     override fun create(student: Student, semester: Semester): Completable {
-        return homeworkRepository.getHomework(semester, now().monday, now().friday, true).ignoreElement()
+        return homeworkRepository.getHomework(student, semester, now().monday, now().friday, true).ignoreElement()
     }
 }

app/src/main/java/io/github/wulkanowy/services/sync/works/TeacherWork.kt

@@ -9,6 +9,6 @@ import javax.inject.Inject
 class TeacherWork @Inject constructor(private val teacherRepository: TeacherRepository) : Work {
 
     override fun create(student: Student, semester: Semester): Completable {
-        return teacherRepository.getTeachers(semester, true).ignoreElement()
+        return teacherRepository.getTeachers(student, semester, true).ignoreElement()
     }
 }

app/src/main/java/io/github/wulkanowy/services/sync/works/TimetableWork.kt

@@ -12,7 +12,7 @@ import javax.inject.Inject
 class TimetableWork @Inject constructor(private val timetableRepository: TimetableRepository) : Work {
 
     override fun create(student: Student, semester: Semester): Completable {
-        return timetableRepository.getTimetable(semester, now().monday, now().friday, true)
+        return timetableRepository.getTimetable(student, semester, now().monday, now().friday, true)
             .ignoreElement()
     }
 }

app/src/main/java/io/github/wulkanowy/ui/modules/attendance/AttendancePresenter.kt

@@ -188,13 +188,16 @@ class AttendancePresenter @Inject constructor(
         disposable.apply {
             clear()
             add(studentRepository.getCurrentStudent()
-                .delay(200, MILLISECONDS)
+                .flatMap { student ->
-                .flatMap { semesterRepository.getCurrentSemester(it) }
+                    semesterRepository.getCurrentSemester(student).flatMap { semester ->
-                .flatMap { attendanceRepository.getAttendance(it, date, date, forceRefresh) }
+                        attendanceRepository.getAttendance(student, semester, date, date, forceRefresh)
+                    }
+                }
                 .map { list ->
                     if (prefRepository.isShowPresent) list
                     else list.filter { !it.presence }
                 }
+                .delay(200, MILLISECONDS)
                 .map { items -> items.map { AttendanceItem(it) } }
                 .map { items -> items.sortedBy { it.attendance.number } }
                 .subscribeOn(schedulers.backgroundThread)
@@ -228,9 +231,12 @@ class AttendancePresenter @Inject constructor(
         Timber.i("Excusing absence started")
         disposable.apply {
             add(studentRepository.getCurrentStudent()
+                .flatMap { student ->
+                    semesterRepository.getCurrentSemester(student).flatMap { semester ->
+                        attendanceRepository.excuseForAbsence(student, semester, toExcuseList, reason)
+                    }
+                }
                 .delay(200, MILLISECONDS)
-                .flatMap { semesterRepository.getCurrentSemester(it) }
-                .flatMap { attendanceRepository.excuseForAbsence(it, toExcuseList, reason) }
                 .subscribeOn(schedulers.backgroundThread)
                 .observeOn(schedulers.mainThread)
                 .doOnSubscribe {

app/src/main/java/io/github/wulkanowy/ui/modules/attendance/summary/AttendanceSummaryPresenter.kt

@@ -83,10 +83,13 @@ class AttendanceSummaryPresenter @Inject constructor(
         disposable.apply {
             clear()
             add(studentRepository.getCurrentStudent()
-                .delay(200, MILLISECONDS)
+                .flatMap { student ->
-                .flatMap { semesterRepository.getCurrentSemester(it) }
+                    semesterRepository.getCurrentSemester(student).flatMap {
-                .flatMap { attendanceSummaryRepository.getAttendanceSummary(it, subjectId, forceRefresh) }
+                        attendanceSummaryRepository.getAttendanceSummary(student, it, subjectId, forceRefresh)
+                    }
+                }
                 .map { createAttendanceSummaryItems(it) to AttendanceSummaryScrollableHeader(formatPercentage(it.calculatePercentage())) }
+                .delay(200, MILLISECONDS)
                 .subscribeOn(schedulers.backgroundThread)
                 .observeOn(schedulers.mainThread)
                 .doFinally {
@@ -126,8 +129,11 @@ class AttendanceSummaryPresenter @Inject constructor(
     private fun loadSubjects() {
         Timber.i("Loading attendance summary subjects started")
         disposable.add(studentRepository.getCurrentStudent()
-            .flatMap { semesterRepository.getCurrentSemester(it) }
+            .flatMap { student ->
-            .flatMap { subjectRepository.getSubjects(it) }
+                semesterRepository.getCurrentSemester(student).flatMap { semester ->
+                    subjectRepository.getSubjects(student, semester)
+                }
+            }
             .doOnSuccess { subjects = it }
             .map { ArrayList(it.map { subject -> subject.name }) }
             .subscribeOn(schedulers.backgroundThread)

app/src/main/java/io/github/wulkanowy/ui/modules/exam/ExamPresenter.kt

@@ -112,9 +112,12 @@ class ExamPresenter @Inject constructor(
         disposable.apply {
             clear()
             add(studentRepository.getCurrentStudent()
+                .flatMap { student ->
+                    semesterRepository.getCurrentSemester(student).flatMap { semester ->
+                        examRepository.getExams(student, semester, currentDate.monday, currentDate.friday, forceRefresh)
+                    }
+                }
                 .delay(200, MILLISECONDS)
-                .flatMap { semesterRepository.getCurrentSemester(it) }
-                .flatMap { examRepository.getExams(it, currentDate.monday, currentDate.friday, forceRefresh) }
                 .map { it.groupBy { exam -> exam.date }.toSortedMap() }
                 .map { createExamItems(it) }
                 .subscribeOn(schedulers.backgroundThread)

app/src/main/java/io/github/wulkanowy/ui/modules/grade/GradeAverageProvider.kt

@@ -34,7 +34,7 @@ class GradeAverageProvider @Inject constructor(
         val selectedSemester = semesters.single { it.semesterId == semesterId }
         val firstSemester = semesters.single { it.diaryId == selectedSemester.diaryId && it.semesterName == 1 }
 
-        return getAverageFromGradeSummary(selectedSemester, forceRefresh)
+        return getAverageFromGradeSummary(student, selectedSemester, forceRefresh)
             .switchIfEmpty(gradeRepository.getGrades(student, selectedSemester, forceRefresh)
                 .flatMap { firstGrades ->
                     if (selectedSemester == firstSemester) Single.just(firstGrades)
@@ -52,7 +52,7 @@ class GradeAverageProvider @Inject constructor(
     private fun getOnlyOneSemesterAverage(student: Student, semesters: List<Semester>, semesterId: Int, forceRefresh: Boolean): Single<List<Triple<String, Double, String>>> {
         val selectedSemester = semesters.single { it.semesterId == semesterId }
 
-        return getAverageFromGradeSummary(selectedSemester, forceRefresh)
+        return getAverageFromGradeSummary(student, selectedSemester, forceRefresh)
             .switchIfEmpty(gradeRepository.getGrades(student, selectedSemester, forceRefresh)
                 .map { grades ->
                     grades.map { if (student.loginMode == Sdk.Mode.SCRAPPER.name) it.changeModifier(plusModifier, minusModifier) else it }
@@ -61,8 +61,8 @@ class GradeAverageProvider @Inject constructor(
                 })
     }
 
-    private fun getAverageFromGradeSummary(selectedSemester: Semester, forceRefresh: Boolean): Maybe<List<Triple<String, Double, String>>> {
+    private fun getAverageFromGradeSummary(student: Student, selectedSemester: Semester, forceRefresh: Boolean): Maybe<List<Triple<String, Double, String>>> {
-        return gradeSummaryRepository.getGradesSummary(selectedSemester, forceRefresh)
+        return gradeSummaryRepository.getGradesSummary(student, selectedSemester, forceRefresh)
             .toMaybe()
             .flatMap {
                 if (it.any { summary -> summary.average != .0 }) {

app/src/main/java/io/github/wulkanowy/ui/modules/grade/statistics/GradeStatisticsPresenter.kt

@@ -48,7 +48,6 @@ class GradeStatisticsPresenter @Inject constructor(
         loadDataByType(semesterId, currentSubjectName, currentType, forceRefresh)
     }
 
-
     fun onParentViewReselected() {
         view?.run {
             if (!isViewEmpty) resetView()
@@ -118,8 +117,11 @@ class GradeStatisticsPresenter @Inject constructor(
     private fun loadSubjects() {
         Timber.i("Loading grade stats subjects started")
         disposable.add(studentRepository.getCurrentStudent()
-            .flatMap { semesterRepository.getCurrentSemester(it) }
+            .flatMap { student ->
-            .flatMap { subjectRepository.getSubjects(it) }
+                semesterRepository.getCurrentSemester(student).flatMap { semester ->
+                    subjectRepository.getSubjects(student, semester)
+                }
+            }
             .doOnSuccess { subjects = it }
             .map { ArrayList(it.map { subject -> subject.name }) }
             .subscribeOn(schedulers.backgroundThread)
@@ -146,14 +148,15 @@ class GradeStatisticsPresenter @Inject constructor(
     private fun loadData(semesterId: Int, subjectName: String, type: ViewType, forceRefresh: Boolean) {
         Timber.i("Loading grade stats data started")
         disposable.add(studentRepository.getCurrentStudent()
-            .flatMap { semesterRepository.getSemesters(it) }
+            .flatMap { student ->
-            .flatMap {
+                semesterRepository.getSemesters(student).flatMap { semesters ->
-                val semester = it.first { item -> item.semesterId == semesterId }
+                    val semester = semesters.first { item -> item.semesterId == semesterId }
 
                     when (type) {
-                    ViewType.SEMESTER -> gradeStatisticsRepository.getGradesStatistics(semester, subjectName, true, forceRefresh)
+                        ViewType.SEMESTER -> gradeStatisticsRepository.getGradesStatistics(student, semester, subjectName, true, forceRefresh)
-                    ViewType.PARTIAL -> gradeStatisticsRepository.getGradesStatistics(semester, subjectName, false, forceRefresh)
+                        ViewType.PARTIAL -> gradeStatisticsRepository.getGradesStatistics(student, semester, subjectName, false, forceRefresh)
-                    ViewType.POINTS -> gradeStatisticsRepository.getGradesPointsStatistics(semester, subjectName, forceRefresh)
+                        ViewType.POINTS -> gradeStatisticsRepository.getGradesPointsStatistics(student, semester, subjectName, forceRefresh)
+                    }
                 }
             }
             .subscribeOn(schedulers.backgroundThread)

app/src/main/java/io/github/wulkanowy/ui/modules/grade/summary/GradeSummaryPresenter.kt

@@ -38,7 +38,7 @@ class GradeSummaryPresenter @Inject constructor(
         disposable.add(studentRepository.getCurrentStudent()
             .flatMap { semesterRepository.getSemesters(it).map { semesters -> it to semesters } }
             .flatMap { (student, semesters) ->
-                gradeSummaryRepository.getGradesSummary(semesters.first { it.semesterId == semesterId }, forceRefresh)
+                gradeSummaryRepository.getGradesSummary(student, semesters.first { it.semesterId == semesterId }, forceRefresh)
                     .map { it.sortedBy { subject -> subject.subject } }
                     .flatMap { gradesSummary ->
                         averageProvider.getGradeAverage(student, semesters, semesterId, forceRefresh)

app/src/main/java/io/github/wulkanowy/ui/modules/homework/HomeworkPresenter.kt

@@ -105,9 +105,12 @@ class HomeworkPresenter @Inject constructor(
         disposable.apply {
             clear()
             add(studentRepository.getCurrentStudent()
+                .flatMap { student ->
+                    semesterRepository.getCurrentSemester(student).flatMap { semester ->
+                        homeworkRepository.getHomework(student, semester, currentDate, currentDate, forceRefresh)
+                    }
+                }
                 .delay(200, TimeUnit.MILLISECONDS)
-                .flatMap { semesterRepository.getCurrentSemester(it) }
-                .flatMap { homeworkRepository.getHomework(it, currentDate, currentDate, forceRefresh) }
                 .map { it.groupBy { homework -> homework.date }.toSortedMap() }
                 .map { createHomeworkItem(it) }
                 .subscribeOn(schedulers.backgroundThread)

app/src/main/java/io/github/wulkanowy/ui/modules/message/preview/MessagePreviewPresenter.kt

@@ -85,7 +85,8 @@ class MessagePreviewPresenter @Inject constructor(
 
     private fun deleteMessage() {
         message?.let { message ->
-            disposable.add(messageRepository.deleteMessage(message)
+            disposable.add(studentRepository.getCurrentStudent()
+                .flatMap { messageRepository.deleteMessage(it, message) }
                 .subscribeOn(schedulers.backgroundThread)
                 .observeOn(schedulers.mainThread)
                 .doOnSubscribe {

app/src/main/java/io/github/wulkanowy/ui/modules/message/send/SendMessagePresenter.kt

@@ -148,7 +148,8 @@ class SendMessagePresenter @Inject constructor(
 
     private fun sendMessage(subject: String, content: String, recipients: List<Recipient>) {
         Timber.i("Sending message started")
-        disposable.add(messageRepository.sendMessage(subject, content, recipients)
+        disposable.add(studentRepository.getCurrentStudent()
+            .flatMap { messageRepository.sendMessage(it, subject, content, recipients) }
             .subscribeOn(schedulers.backgroundThread)
             .observeOn(schedulers.mainThread)
             .doOnSubscribe {

app/src/main/java/io/github/wulkanowy/ui/modules/mobiledevice/MobileDevicePresenter.kt

@@ -49,8 +49,11 @@ class MobileDevicePresenter @Inject constructor(
     private fun loadData(forceRefresh: Boolean = false) {
         Timber.i("Loading mobile devices data started")
         disposable.add(studentRepository.getCurrentStudent()
-            .flatMap { semesterRepository.getCurrentSemester(it) }
+            .flatMap { student ->
-            .flatMap { mobileDeviceRepository.getDevices(it, forceRefresh) }
+                semesterRepository.getCurrentSemester(student).flatMap { semester ->
+                    mobileDeviceRepository.getDevices(student, semester, forceRefresh)
+                }
+            }
             .map { items -> items.map { MobileDeviceItem(it) } }
             .subscribeOn(schedulers.backgroundThread)
             .observeOn(schedulers.mainThread)
@@ -107,10 +110,11 @@ class MobileDevicePresenter @Inject constructor(
     fun onUnregisterConfirmed(device: MobileDevice) {
         Timber.i("Unregister device started")
         disposable.add(studentRepository.getCurrentStudent()
-            .flatMap { semesterRepository.getCurrentSemester(it) }
+            .flatMap { student ->
-            .flatMap { semester ->
+                semesterRepository.getCurrentSemester(student).flatMap { semester ->
-                mobileDeviceRepository.unregisterDevice(semester, device)
+                    mobileDeviceRepository.unregisterDevice(student, semester, device)
-                    .flatMap { mobileDeviceRepository.getDevices(semester, it) }
+                        .flatMap { mobileDeviceRepository.getDevices(student, semester, it) }
+                }
             }
             .map { items -> items.map { MobileDeviceItem(it) } }
             .subscribeOn(schedulers.backgroundThread)

app/src/main/java/io/github/wulkanowy/ui/modules/mobiledevice/token/MobileDeviceTokenPresenter.kt

@@ -29,8 +29,11 @@ class MobileDeviceTokenPresenter @Inject constructor(
     private fun loadData() {
         Timber.i("Mobile device registration data started")
         disposable.add(studentRepository.getCurrentStudent()
-            .flatMap { semesterRepository.getCurrentSemester(it) }
+            .flatMap { student ->
-            .flatMap { mobileDeviceRepository.getToken(it) }
+                semesterRepository.getCurrentSemester(student).flatMap { semester ->
+                    mobileDeviceRepository.getToken(student, semester)
+                }
+            }
             .subscribeOn(schedulers.backgroundThread)
             .observeOn(schedulers.mainThread)
             .doFinally { view?.hideLoading() }

app/src/main/java/io/github/wulkanowy/ui/modules/schoolandteachers/school/SchoolPresenter.kt

@@ -64,8 +64,11 @@ class SchoolPresenter @Inject constructor(
     private fun loadData(forceRefresh: Boolean = false) {
         Timber.i("Loading school info started")
         disposable.add(studentRepository.getCurrentStudent()
-            .flatMap { semesterRepository.getCurrentSemester(it) }
+            .flatMapMaybe { student ->
-            .flatMapMaybe { schoolRepository.getSchoolInfo(it, forceRefresh) }
+                semesterRepository.getCurrentSemester(student).flatMapMaybe {
+                    schoolRepository.getSchoolInfo(student, it, forceRefresh)
+                }
+            }
             .subscribeOn(schedulers.backgroundThread)
             .observeOn(schedulers.mainThread)
             .doFinally {

app/src/main/java/io/github/wulkanowy/ui/modules/schoolandteachers/teacher/TeacherPresenter.kt

@@ -52,8 +52,11 @@ class TeacherPresenter @Inject constructor(
     private fun loadData(forceRefresh: Boolean = false) {
         Timber.i("Loading teachers data started")
         disposable.add(studentRepository.getCurrentStudent()
-            .flatMap { semesterRepository.getCurrentSemester(it) }
+            .flatMap { student ->
-            .flatMap { teacherRepository.getTeachers(it, forceRefresh) }
+                semesterRepository.getCurrentSemester(student).flatMap { semester ->
+                    teacherRepository.getTeachers(student, semester, forceRefresh)
+                }
+            }
             .map { it.filter { teacher -> teacher.name.isNotBlank() } }
             .map { items -> items.map { TeacherItem(it, view?.noSubjectString.orEmpty()) } }
             .subscribeOn(schedulers.backgroundThread)

app/src/main/java/io/github/wulkanowy/ui/modules/timetable/TimetablePresenter.kt

@@ -134,9 +134,12 @@ class TimetablePresenter @Inject constructor(
         disposable.apply {
             clear()
             add(studentRepository.getCurrentStudent()
-                .flatMap { semesterRepository.getCurrentSemester(it) }
+                .flatMap { student ->
+                    semesterRepository.getCurrentSemester(student).flatMap { semester ->
+                        timetableRepository.getTimetable(student, semester, currentDate, currentDate, forceRefresh)
+                    }
+                }
                 .delay(200, MILLISECONDS)
-                .flatMap { timetableRepository.getTimetable(it, currentDate, currentDate, forceRefresh) }
                 .map { createTimetableItems(it) }
                 .map { items -> items.sortedWith(compareBy({ it.lesson.number }, { !it.lesson.isStudentPlan })) }
                 .subscribeOn(schedulers.backgroundThread)

app/src/main/java/io/github/wulkanowy/ui/modules/timetable/completed/CompletedLessonsPresenter.kt

@@ -114,9 +114,12 @@ class CompletedLessonsPresenter @Inject constructor(
         disposable.apply {
             clear()
             add(studentRepository.getCurrentStudent()
-                .flatMap { semesterRepository.getCurrentSemester(it) }
+                .flatMap { student ->
+                    semesterRepository.getCurrentSemester(student).flatMap { semester ->
+                        completedLessonsRepository.getCompletedLessons(student, semester, currentDate, currentDate, forceRefresh)
+                    }
+                }
                 .delay(200, TimeUnit.MILLISECONDS)
-                .flatMap { completedLessonsRepository.getCompletedLessons(it, currentDate, currentDate, forceRefresh) }
                 .map { items -> items.map { CompletedLessonItem(it) } }
                 .map { items -> items.sortedBy { it.completedLesson.number } }
                 .subscribeOn(schedulers.backgroundThread)

app/src/main/java/io/github/wulkanowy/ui/modules/timetablewidget/TimetableWidgetFactory.kt

@@ -107,8 +107,11 @@ class TimetableWidgetFactory(
                     if (student != null) Maybe.just(student)
                     else Maybe.empty()
                 }
-                .flatMap { semesterRepository.getCurrentSemester(it).toMaybe() }
+                .flatMap { student ->
-                .flatMap { timetableRepository.getTimetable(it, date, date).toMaybe() }
+                    semesterRepository.getCurrentSemester(student).toMaybe().flatMap { semester ->
+                        timetableRepository.getTimetable(student, semester, date, date).toMaybe()
+                    }
+                }
                 .map { items -> items.sortedWith(compareBy({ it.number }, { !it.isStudentPlan })) }
                 .map { lessons -> lessons.filter { if (prefRepository.showWholeClassPlan == "no") it.isStudentPlan else true } }
                 .subscribeOn(schedulers.backgroundThread)

app/src/main/java/io/github/wulkanowy/utils/SdkExtension.kt

@@ -0,0 +1,29 @@
+package io.github.wulkanowy.utils
+
+import io.github.wulkanowy.data.db.entities.Student
+import io.github.wulkanowy.sdk.Sdk
+import timber.log.Timber
+
+fun Sdk.init(student: Student): Sdk {
+    email = student.email
+    password = student.password
+    symbol = student.symbol
+    schoolSymbol = student.schoolSymbol
+    studentId = student.studentId
+    classId = student.classId
+
+    if (Sdk.Mode.valueOf(student.loginMode) != Sdk.Mode.API) {
+        scrapperBaseUrl = student.scrapperBaseUrl
+        loginType = Sdk.ScrapperLoginType.valueOf(student.loginType)
+    }
+    loginId = student.userLoginId
+
+    mode = Sdk.Mode.valueOf(student.loginMode)
+    mobileBaseUrl = student.mobileBaseUrl
+    certKey = student.certificateKey
+    privateKey = student.privateKey
+
+    Timber.d("Sdk in ${student.loginMode} mode reinitialized")
+
+    return this
+}

app/src/test/java/io/github/wulkanowy/data/repositories/TestEnityCreator.kt

@@ -0,0 +1,47 @@
+package io.github.wulkanowy.data.repositories
+
+import io.github.wulkanowy.data.db.entities.Semester
+import io.github.wulkanowy.data.db.entities.Student
+import io.github.wulkanowy.sdk.Sdk
+import org.threeten.bp.LocalDate
+import org.threeten.bp.LocalDateTime.now
+
+fun createSemesterEntity(diaryId: Int, semesterId: Int, start: LocalDate, end: LocalDate, semesterName: Int = 1): Semester {
+    return Semester(
+        studentId = 1,
+        diaryId = diaryId,
+        semesterId = semesterId,
+        diaryName = "$semesterId",
+        schoolYear = 1970,
+        classId = 0,
+        semesterName = semesterName,
+        unitId = 1,
+        start = start,
+        end = end
+    )
+}
+
+fun getStudentEntity(mode: Sdk.Mode = Sdk.Mode.API): Student {
+    return Student(
+        scrapperBaseUrl = "http://fakelog.cf",
+        email = "jan@fakelog.cf",
+        certificateKey = "",
+        classId = 0,
+        className = "",
+        isCurrent = false,
+        isParent = false,
+        loginMode = mode.name,
+        loginType = "STANDARD",
+        mobileBaseUrl = "",
+        password = "",
+        privateKey = "",
+        registrationDate = now(),
+        schoolName = "",
+        schoolShortName = "test",
+        schoolSymbol = "",
+        studentId = 0,
+        studentName = "",
+        symbol = "",
+        userLoginId = 0
+    )
+}

app/src/test/java/io/github/wulkanowy/data/repositories/attendance/AttendanceRemoteTest.kt

@@ -1,11 +1,15 @@
 package io.github.wulkanowy.data.repositories.attendance
 
 import io.github.wulkanowy.data.db.entities.Semester
+import io.github.wulkanowy.data.db.entities.Student
+import io.github.wulkanowy.data.repositories.getStudentEntity
 import io.github.wulkanowy.sdk.Sdk
 import io.github.wulkanowy.sdk.pojo.Attendance
+import io.github.wulkanowy.utils.init
 import io.mockk.MockKAnnotations
 import io.mockk.every
 import io.mockk.impl.annotations.MockK
+import io.mockk.impl.annotations.SpyK
 import io.reactivex.Single
 import org.junit.Assert.assertEquals
 import org.junit.Before
@@ -15,12 +19,14 @@ import org.threeten.bp.LocalDate.of
 
 class AttendanceRemoteTest {
 
-    @MockK
+    @SpyK
-    private lateinit var mockSdk: Sdk
+    private var mockSdk = Sdk()
 
     @MockK
     private lateinit var semesterMock: Semester
 
+    private var student = getStudentEntity()
+
     @Before
     fun initApi() {
         MockKAnnotations.init(this)
@@ -28,6 +34,7 @@ class AttendanceRemoteTest {
 
     @Test
     fun getAttendanceTest() {
+        every { mockSdk.init(student) } returns mockSdk
         every {
             mockSdk.getAttendance(
                 of(2018, 9, 10),
@@ -45,7 +52,7 @@ class AttendanceRemoteTest {
         every { semesterMock.semesterId } returns 1
         every { mockSdk.switchDiary(any(), any()) } returns mockSdk
 
-        val attendance = AttendanceRemote(mockSdk).getAttendance(semesterMock,
+        val attendance = AttendanceRemote(mockSdk).getAttendance(student, semesterMock,
             of(2018, 9, 10),
             of(2018, 9, 15)
         ).blockingGet()

app/src/test/java/io/github/wulkanowy/data/repositories/completedlessons/CompletedLessonsRemoteTest.kt

@@ -1,11 +1,14 @@
 package io.github.wulkanowy.data.repositories.completedlessons
 
 import io.github.wulkanowy.data.db.entities.Semester
+import io.github.wulkanowy.data.repositories.getStudentEntity
 import io.github.wulkanowy.sdk.Sdk
 import io.github.wulkanowy.sdk.pojo.CompletedLesson
+import io.github.wulkanowy.utils.init
 import io.mockk.MockKAnnotations
 import io.mockk.every
 import io.mockk.impl.annotations.MockK
+import io.mockk.impl.annotations.SpyK
 import io.reactivex.Single
 import org.junit.Assert
 import org.junit.Before
@@ -15,12 +18,14 @@ import org.threeten.bp.LocalDate.of
 
 class CompletedLessonsRemoteTest {
 
-    @MockK
+    @SpyK
-    private lateinit var mockSdk: Sdk
+    private var mockSdk = Sdk()
 
     @MockK
     private lateinit var semesterMock: Semester
 
+    private val student = getStudentEntity()
+
     @Before
     fun initApi() {
         MockKAnnotations.init(this)
@@ -28,6 +33,7 @@ class CompletedLessonsRemoteTest {
 
     @Test
     fun getCompletedLessonsTest() {
+        every { mockSdk.init(student) } returns mockSdk
         every {
             mockSdk.getCompletedLessons(
                 of(2018, 9, 10),
@@ -44,7 +50,7 @@ class CompletedLessonsRemoteTest {
         every { semesterMock.semesterId } returns 1
         every { mockSdk.switchDiary(any(), any()) } returns mockSdk
 
-        val completed = CompletedLessonsRemote(mockSdk).getCompletedLessons(semesterMock,
+        val completed = CompletedLessonsRemote(mockSdk).getCompletedLessons(student, semesterMock,
             of(2018, 9, 10),
             of(2018, 9, 15)
         ).blockingGet()

app/src/test/java/io/github/wulkanowy/data/repositories/exam/ExamRemoteTest.kt

@@ -1,11 +1,14 @@
 package io.github.wulkanowy.data.repositories.exam
 
 import io.github.wulkanowy.data.db.entities.Semester
+import io.github.wulkanowy.data.repositories.getStudentEntity
 import io.github.wulkanowy.sdk.Sdk
 import io.github.wulkanowy.sdk.pojo.Exam
+import io.github.wulkanowy.utils.init
 import io.mockk.MockKAnnotations
 import io.mockk.every
 import io.mockk.impl.annotations.MockK
+import io.mockk.impl.annotations.SpyK
 import io.reactivex.Single
 import org.junit.Assert.assertEquals
 import org.junit.Before
@@ -15,19 +18,24 @@ import org.threeten.bp.LocalDate.of
 
 class ExamRemoteTest {
 
-    @MockK
+    @SpyK
-    private lateinit var mockSdk: Sdk
+    private var mockSdk = Sdk()
 
     @MockK
     private lateinit var semesterMock: Semester
 
+    private val student = getStudentEntity()
+
     @Before
-    fun initApi() {
+    fun setUp() {
         MockKAnnotations.init(this)
     }
 
     @Test
     fun getExamsTest() {
+        every { mockSdk.init(student) } returns mockSdk
+        every { mockSdk.switchDiary(1, 2019) } returns mockSdk
+
         every {
             mockSdk.getExams(
                 of(2018, 9, 10),
@@ -43,10 +51,8 @@ class ExamRemoteTest {
         every { semesterMock.diaryId } returns 1
         every { semesterMock.schoolYear } returns 2019
         every { semesterMock.semesterId } returns 1
-        every { mockSdk.switchDiary(any(), any()) } returns mockSdk
 
-        val exams = ExamRemote(mockSdk)
+        val exams = ExamRemote(mockSdk).getExams(student, semesterMock,
-            .getExams(semesterMock,
             of(2018, 9, 10),
             of(2018, 9, 15)
         ).blockingGet()

app/src/test/java/io/github/wulkanowy/data/repositories/gradestatistics/GradeStatisticsRemoteTest.kt

@@ -1,12 +1,15 @@
 package io.github.wulkanowy.data.repositories.gradestatistics
 
 import io.github.wulkanowy.data.db.entities.Semester
+import io.github.wulkanowy.data.repositories.getStudentEntity
 import io.github.wulkanowy.sdk.Sdk
 import io.github.wulkanowy.sdk.pojo.GradePointsStatistics
 import io.github.wulkanowy.sdk.pojo.GradeStatistics
+import io.github.wulkanowy.utils.init
 import io.mockk.MockKAnnotations
 import io.mockk.every
 import io.mockk.impl.annotations.MockK
+import io.mockk.impl.annotations.SpyK
 import io.reactivex.Single
 import org.junit.Assert.assertEquals
 import org.junit.Before
@@ -14,15 +17,18 @@ import org.junit.Test
 
 class GradeStatisticsRemoteTest {
 
-    @MockK
+    @SpyK
-    private lateinit var mockSdk: Sdk
+    private var mockSdk = Sdk()
 
     @MockK
     private lateinit var semesterMock: Semester
 
+    private val student = getStudentEntity()
+
     @Before
     fun initApi() {
         MockKAnnotations.init(this)
+        every { mockSdk.init(student) } returns mockSdk
     }
 
     @Test
@@ -38,7 +44,7 @@ class GradeStatisticsRemoteTest {
         every { semesterMock.semesterId } returns 1
         every { mockSdk.switchDiary(any(), any()) } returns mockSdk
 
-        val stats = GradeStatisticsRemote(mockSdk).getGradeStatistics(semesterMock, false).blockingGet()
+        val stats = GradeStatisticsRemote(mockSdk).getGradeStatistics(student, semesterMock, false).blockingGet()
         assertEquals(2, stats.size)
     }
 
@@ -55,7 +61,7 @@ class GradeStatisticsRemoteTest {
         every { semesterMock.semesterId } returns 1
         every { mockSdk.switchDiary(any(), any()) } returns mockSdk
 
-        val stats = GradeStatisticsRemote(mockSdk).getGradePointsStatistics(semesterMock).blockingGet()
+        val stats = GradeStatisticsRemote(mockSdk).getGradePointsStatistics(student, semesterMock).blockingGet()
         assertEquals(2, stats.size)
     }
 

app/src/test/java/io/github/wulkanowy/data/repositories/luckynumber/LuckyNumberRemoteTest.kt

@@ -1,10 +1,10 @@
 package io.github.wulkanowy.data.repositories.luckynumber
 
-import io.github.wulkanowy.data.db.entities.Student
+import io.github.wulkanowy.data.repositories.getStudentEntity
 import io.github.wulkanowy.sdk.Sdk
+import io.github.wulkanowy.utils.init
 import io.mockk.MockKAnnotations
 import io.mockk.every
-import io.mockk.impl.annotations.MockK
 import io.mockk.impl.annotations.SpyK
 import io.reactivex.Maybe
 import org.junit.Assert.assertEquals
@@ -17,28 +17,26 @@ class LuckyNumberRemoteTest {
     @SpyK
     private var mockSdk = Sdk()
 
-    @MockK
+    private val student = getStudentEntity(Sdk.Mode.SCRAPPER)
-    private lateinit var studentMock: Student
 
     @Before
-    fun initApi() {
+    fun setUp() {
         MockKAnnotations.init(this)
     }
 
     @Test
     fun getLuckyNumberTest() {
+        every { mockSdk.init(student) } returns mockSdk
         every { mockSdk.getLuckyNumber("test") } returns Maybe.just(14)
 
         every { mockSdk.diaryId } returns 1
-        every { studentMock.studentId } returns 1
-        every { studentMock.schoolShortName } returns "test"
 
         val luckyNumber = LuckyNumberRemote(mockSdk)
-            .getLuckyNumber(studentMock)
+            .getLuckyNumber(student)
             .blockingGet()
 
         assertEquals(14, luckyNumber.luckyNumber)
         assertEquals(LocalDate.now(), luckyNumber.date)
-        assertEquals(studentMock.studentId, luckyNumber.studentId)
+        assertEquals(student.studentId, luckyNumber.studentId)
     }
 }

app/src/test/java/io/github/wulkanowy/data/repositories/message/MessageRepositoryTest.kt

@@ -2,7 +2,6 @@ package io.github.wulkanowy.data.repositories.message
 
 import androidx.room.EmptyResultSetException
 import com.github.pwittchen.reactivenetwork.library.rx2.internet.observing.InternetObservingSettings
-import io.github.wulkanowy.data.SdkHelper
 import io.github.wulkanowy.data.db.entities.Message
 import io.github.wulkanowy.data.db.entities.MessageWithAttachment
 import io.github.wulkanowy.data.db.entities.Student
@@ -21,9 +20,6 @@ import java.net.UnknownHostException
 
 class MessageRepositoryTest {
 
-    @Mock
-    lateinit var sdk: SdkHelper
-
     @Mock
     lateinit var local: MessageLocal
 
@@ -43,7 +39,7 @@ class MessageRepositoryTest {
 
         repo = MessageRepository(InternetObservingSettings.builder()
             .strategy(testObservingStrategy)
-            .build(), local, remote, sdk)
+            .build(), local, remote)
     }
 
     @Test
@@ -80,7 +76,7 @@ class MessageRepositoryTest {
         `when`(local.getMessageWithAttachment(student, testMessage))
             .thenReturn(Single.just(mWa))
             .thenReturn(Single.just(mWaWithContent))
-        `when`(remote.getMessagesContentDetails(testMessageWithContent)).thenReturn(Single.just("Test" to emptyList()))
+        `when`(remote.getMessagesContentDetails(student, testMessageWithContent)).thenReturn(Single.just("Test" to emptyList()))
 
         val message = repo.getMessage(student, testMessage).blockingGet()
 

app/src/test/java/io/github/wulkanowy/data/repositories/mobiledevice/MobileDeviceRepositoryTest.kt

@@ -4,6 +4,7 @@ import com.github.pwittchen.reactivenetwork.library.rx2.internet.observing.Inter
 import io.github.wulkanowy.data.db.entities.MobileDevice
 import io.github.wulkanowy.data.db.entities.Semester
 import io.github.wulkanowy.data.repositories.UnitTestInternetObservingStrategy
+import io.github.wulkanowy.data.repositories.getStudentEntity
 import io.reactivex.Maybe
 import io.reactivex.Single
 import org.junit.Before
@@ -25,6 +26,8 @@ class MobileDeviceRepositoryTest {
     @Mock
     private lateinit var mobileDeviceLocal: MobileDeviceLocal
 
+    private val student = getStudentEntity()
+
     private lateinit var mobileDeviceRepository: MobileDeviceRepository
 
     private val settings = InternetObservingSettings.builder()
@@ -45,9 +48,9 @@ class MobileDeviceRepositoryTest {
         )
 
         doReturn(Maybe.empty<MobileDevice>()).`when`(mobileDeviceLocal).getDevices(semester)
-        doReturn(Single.just(devices)).`when`(mobileDeviceRemote).getDevices(semester)
+        doReturn(Single.just(devices)).`when`(mobileDeviceRemote).getDevices(student, semester)
 
-        mobileDeviceRepository.getDevices(semester).blockingGet()
+        mobileDeviceRepository.getDevices(student, semester).blockingGet()
 
         verify(mobileDeviceLocal).deleteDevices(emptyList())
         verify(mobileDeviceLocal).saveDevices(devices)

app/src/test/java/io/github/wulkanowy/data/repositories/semester/SemesterRepositoryTest.kt

@@ -1,17 +1,16 @@
 package io.github.wulkanowy.data.repositories.semester
 
 import com.github.pwittchen.reactivenetwork.library.rx2.internet.observing.InternetObservingSettings
-import io.github.wulkanowy.data.SdkHelper
 import io.github.wulkanowy.data.db.entities.Semester
 import io.github.wulkanowy.data.db.entities.Student
 import io.github.wulkanowy.data.repositories.UnitTestInternetObservingStrategy
+import io.github.wulkanowy.data.repositories.createSemesterEntity
 import io.reactivex.Maybe
 import io.reactivex.Single
 import org.junit.Assert.assertEquals
 import org.junit.Before
 import org.junit.Test
 import org.mockito.Mock
-import org.mockito.Mockito.doNothing
 import org.mockito.Mockito.doReturn
 import org.mockito.Mockito.verify
 import org.mockito.MockitoAnnotations
@@ -25,9 +24,6 @@ class SemesterRepositoryTest {
     @Mock
     private lateinit var semesterLocal: SemesterLocal
 
-    @Mock
-    private lateinit var sdkHelper: SdkHelper
-
     @Mock
     private lateinit var student: Student
 
@@ -40,7 +36,7 @@ class SemesterRepositoryTest {
     @Before
     fun initTest() {
         MockitoAnnotations.initMocks(this)
-        semesterRepository = SemesterRepository(semesterRemote, semesterLocal, settings, sdkHelper)
+        semesterRepository = SemesterRepository(semesterRemote, semesterLocal, settings)
     }
 
     @Test
@@ -50,7 +46,6 @@ class SemesterRepositoryTest {
             createSemesterEntity(0, 0, now().minusMonths(3), now())
         )
 
-        doNothing().`when`(sdkHelper).init(student)
         doReturn(Maybe.empty<Semester>()).`when`(semesterLocal).getSemesters(student)
         doReturn(Single.just(semesters)).`when`(semesterRemote).getSemesters(student)
 
@@ -67,7 +62,6 @@ class SemesterRepositoryTest {
             createSemesterEntity(0, 0, now().minusMonths(6), now().minusMonths(1))
         )
 
-        doNothing().`when`(sdkHelper).init(student)
         doReturn(Maybe.just(semesters)).`when`(semesterLocal).getSemesters(student)
 
         val items = semesterRepository.getSemesters(student).blockingGet()
@@ -81,7 +75,6 @@ class SemesterRepositoryTest {
             createSemesterEntity(0, 0, now().minusMonths(3), now())
         )
 
-        doNothing().`when`(sdkHelper).init(student)
         doReturn(Maybe.just(semesters)).`when`(semesterLocal).getSemesters(student)
 
         val items = semesterRepository.getSemesters(student).blockingGet()
@@ -95,7 +88,6 @@ class SemesterRepositoryTest {
             createSemesterEntity(0, 0, now(), now())
         )
 
-        doNothing().`when`(sdkHelper).init(student)
         doReturn(Maybe.just(semesters)).`when`(semesterLocal).getSemesters(student)
 
         val items = semesterRepository.getSemesters(student).blockingGet()
@@ -109,7 +101,6 @@ class SemesterRepositoryTest {
             createSemesterEntity(0, 0, now().minusMonths(3), now())
         )
 
-        doNothing().`when`(sdkHelper).init(student)
         doReturn(Maybe.empty<Semester>()).`when`(semesterLocal).getSemesters(student)
         doReturn(Single.just(semesters)).`when`(semesterRemote).getSemesters(student)
 
@@ -126,7 +117,6 @@ class SemesterRepositoryTest {
             createSemesterEntity(0, 0, now().minusMonths(6), now().minusMonths(1))
         )
 
-        doNothing().`when`(sdkHelper).init(student)
         doReturn(Maybe.just(semesters)).`when`(semesterLocal).getSemesters(student)
         doReturn(Single.just(semesters)).`when`(semesterRemote).getSemesters(student)
 
@@ -141,7 +131,6 @@ class SemesterRepositoryTest {
             createSemesterEntity(0, 0, now(), now())
         )
 
-        doNothing().`when`(sdkHelper).init(student)
         doReturn(Maybe.just(semesters)).`when`(semesterLocal).getSemesters(student)
 
         val items = semesterRepository.getSemesters(student, refreshOnNoCurrent = true).blockingGet()
@@ -155,7 +144,6 @@ class SemesterRepositoryTest {
             createSemesterEntity(0, 0, now(), now())
         )
 
-        doNothing().`when`(sdkHelper).init(student)
         doReturn(Maybe.just(semesters)).`when`(semesterLocal).getSemesters(student)
 
         semesterRepository.getCurrentSemester(student).blockingGet()
@@ -163,7 +151,6 @@ class SemesterRepositoryTest {
 
     @Test(expected = RuntimeException::class)
     fun getCurrentSemester_emptyList() {
-        doNothing().`when`(sdkHelper).init(student)
         doReturn(Maybe.just(emptyList<Semester>())).`when`(semesterLocal).getSemesters(student)
 
         semesterRepository.getCurrentSemester(student).blockingGet()

app/src/test/java/io/github/wulkanowy/data/repositories/semester/TestSemesterEnityCreator.kt

@@ -1,19 +0,0 @@
-package io.github.wulkanowy.data.repositories.semester
-
-import io.github.wulkanowy.data.db.entities.Semester
-import org.threeten.bp.LocalDate
-
-fun createSemesterEntity(diaryId: Int, semesterId: Int, start: LocalDate, end: LocalDate, semesterName: Int = 1): Semester {
-    return Semester(
-        studentId = 1,
-        diaryId = diaryId,
-        semesterId = semesterId,
-        diaryName = "$semesterId",
-        schoolYear = 1970,
-        classId = 0,
-        semesterName = semesterName,
-        unitId = 1,
-        start = start,
-        end = end
-    )
-}

app/src/test/java/io/github/wulkanowy/data/repositories/timetable/TimetableRemoteTest.kt

@@ -1,11 +1,13 @@
 package io.github.wulkanowy.data.repositories.timetable
 
 import io.github.wulkanowy.data.db.entities.Semester
+import io.github.wulkanowy.data.repositories.getStudentEntity
 import io.github.wulkanowy.sdk.Sdk
 import io.github.wulkanowy.sdk.pojo.Timetable
 import io.mockk.MockKAnnotations
 import io.mockk.every
 import io.mockk.impl.annotations.MockK
+import io.mockk.impl.annotations.SpyK
 import io.reactivex.Single
 import org.junit.Assert.assertEquals
 import org.junit.Before
@@ -16,12 +18,14 @@ import org.threeten.bp.LocalDateTime.now
 
 class TimetableRemoteTest {
 
-    @MockK
+    @SpyK
-    private lateinit var mockSdk: Sdk
+    private var mockSdk = Sdk()
 
     @MockK
     private lateinit var semesterMock: Semester
 
+    private val student = getStudentEntity()
+
     @Before
     fun initApi() {
         MockKAnnotations.init(this)
@@ -45,7 +49,7 @@ class TimetableRemoteTest {
         every { semesterMock.semesterId } returns 1
         every { mockSdk.switchDiary(any(), any()) } returns mockSdk
 
-        val timetable = TimetableRemote(mockSdk).getTimetable(semesterMock,
+        val timetable = TimetableRemote(mockSdk).getTimetable(student, semesterMock,
             of(2018, 9, 10),
             of(2018, 9, 15)
         ).blockingGet()

app/src/test/java/io/github/wulkanowy/ui/modules/grade/GradeAverageProviderTest.kt

@@ -6,7 +6,7 @@ import io.github.wulkanowy.data.db.entities.Student
 import io.github.wulkanowy.data.repositories.grade.GradeRepository
 import io.github.wulkanowy.data.repositories.gradessummary.GradeSummaryRepository
 import io.github.wulkanowy.data.repositories.preferences.PreferencesRepository
-import io.github.wulkanowy.data.repositories.semester.createSemesterEntity
+import io.github.wulkanowy.data.repositories.createSemesterEntity
 import io.github.wulkanowy.sdk.Sdk
 import io.reactivex.Single
 import org.junit.Assert.assertEquals
@@ -75,7 +75,7 @@ class GradeAverageProviderTest {
     @Test
     fun onlyOneSemesterTest() {
         doReturn("only_one_semester").`when`(preferencesRepository).gradeAverageMode
-        doReturn(Single.just(emptyList<GradeSummary>())).`when`(gradeSummaryRepository).getGradesSummary(semesters[2], true)
+        doReturn(Single.just(emptyList<GradeSummary>())).`when`(gradeSummaryRepository).getGradesSummary(student, semesters[2], true)
 
         val averages = gradeAverageProvider.getGradeAverage(student, semesters, semesters[2].semesterId, true)
             .blockingGet()
@@ -88,7 +88,7 @@ class GradeAverageProviderTest {
     @Test
     fun onlyOneSemester_gradesWithModifiers_default() {
         doReturn("only_one_semester").`when`(preferencesRepository).gradeAverageMode
-        doReturn(Single.just(emptyList<GradeSummary>())).`when`(gradeSummaryRepository).getGradesSummary(semesters[2], true)
+        doReturn(Single.just(emptyList<GradeSummary>())).`when`(gradeSummaryRepository).getGradesSummary(student, semesters[2], true)
         doReturn(Single.just(secondGradeWithModifier)).`when`(gradeRepository).getGrades(student, semesters[2], true)
 
         val averages = gradeAverageProvider.getGradeAverage(student, semesters, semesters[2].semesterId, true)
@@ -100,7 +100,7 @@ class GradeAverageProviderTest {
     @Test
     fun onlyOneSemester_gradesWithModifiers_api() {
         doReturn("only_one_semester").`when`(preferencesRepository).gradeAverageMode
-        doReturn(Single.just(emptyList<GradeSummary>())).`when`(gradeSummaryRepository).getGradesSummary(semesters[2], true)
+        doReturn(Single.just(emptyList<GradeSummary>())).`when`(gradeSummaryRepository).getGradesSummary(student.copy(loginMode = Sdk.Mode.API.name), semesters[2], true)
         doReturn(Single.just(secondGradeWithModifier)).`when`(gradeRepository).getGrades(student.copy(loginMode = Sdk.Mode.API.name), semesters[2], true)
 
         val averages = gradeAverageProvider.getGradeAverage(student.copy(loginMode = Sdk.Mode.API.name), semesters, semesters[2].semesterId, true)
@@ -112,7 +112,7 @@ class GradeAverageProviderTest {
     @Test
     fun onlyOneSemester_gradesWithModifiers_scrapper() {
         doReturn("only_one_semester").`when`(preferencesRepository).gradeAverageMode
-        doReturn(Single.just(emptyList<GradeSummary>())).`when`(gradeSummaryRepository).getGradesSummary(semesters[2], true)
+        doReturn(Single.just(emptyList<GradeSummary>())).`when`(gradeSummaryRepository).getGradesSummary(student, semesters[2], true)
         doReturn(Single.just(secondGradeWithModifier)).`when`(gradeRepository).getGrades(student.copy(loginMode = Sdk.Mode.SCRAPPER.name), semesters[2], true)
 
         val averages = gradeAverageProvider.getGradeAverage(student.copy(loginMode = Sdk.Mode.SCRAPPER.name), semesters, semesters[2].semesterId, true)
@@ -124,7 +124,7 @@ class GradeAverageProviderTest {
     @Test
     fun onlyOneSemester_gradesWithModifiers_hybrid() {
         doReturn("only_one_semester").`when`(preferencesRepository).gradeAverageMode
-        doReturn(Single.just(emptyList<GradeSummary>())).`when`(gradeSummaryRepository).getGradesSummary(semesters[2], true)
+        doReturn(Single.just(emptyList<GradeSummary>())).`when`(gradeSummaryRepository).getGradesSummary(student.copy(loginMode = Sdk.Mode.HYBRID.name), semesters[2], true)
         doReturn(Single.just(secondGradeWithModifier)).`when`(gradeRepository).getGrades(student.copy(loginMode = Sdk.Mode.HYBRID.name), semesters[2], true)
 
         val averages = gradeAverageProvider.getGradeAverage(student.copy(loginMode = Sdk.Mode.HYBRID.name), semesters, semesters[2].semesterId, true)
@@ -136,7 +136,7 @@ class GradeAverageProviderTest {
     @Test
     fun allYearFirstSemesterTest() {
         doReturn("all_year").`when`(preferencesRepository).gradeAverageMode
-        doReturn(Single.just(emptyList<GradeSummary>())).`when`(gradeSummaryRepository).getGradesSummary(semesters[1], true)
+        doReturn(Single.just(emptyList<GradeSummary>())).`when`(gradeSummaryRepository).getGradesSummary(student, semesters[1], true)
 
         val averages = gradeAverageProvider.getGradeAverage(student, semesters, semesters[1].semesterId, true)
             .blockingGet()
@@ -150,7 +150,7 @@ class GradeAverageProviderTest {
     fun allYearSecondSemesterTest() {
         doReturn("all_year").`when`(preferencesRepository).gradeAverageMode
         doReturn(Single.just(firstGrades)).`when`(gradeRepository).getGrades(student, semesters[1], false)
-        doReturn(Single.just(emptyList<GradeSummary>())).`when`(gradeSummaryRepository).getGradesSummary(semesters[2], true)
+        doReturn(Single.just(emptyList<GradeSummary>())).`when`(gradeSummaryRepository).getGradesSummary(student, semesters[2], true)
 
         val averages = gradeAverageProvider.getGradeAverage(student, semesters, semesters[2].semesterId, true)
             .blockingGet()
@@ -174,7 +174,7 @@ class GradeAverageProviderTest {
         doReturn(Single.just(listOf(
             getSummary(22, "Matematyka", 3.1),
             getSummary(22, "Fizyka", 3.26)
-        ))).`when`(gradeSummaryRepository).getGradesSummary(semesters[2], true)
+        ))).`when`(gradeSummaryRepository).getGradesSummary(student, semesters[2], true)
 
         val averages = gradeAverageProvider.getGradeAverage(student, semesters, semesters[2].semesterId, true)
             .blockingGet()
@@ -192,7 +192,7 @@ class GradeAverageProviderTest {
         doReturn(Single.just(listOf(
             getSummary(22, "Matematyka", 3.1),
             getSummary(22, "Fizyka", 3.26)
-        ))).`when`(gradeSummaryRepository).getGradesSummary(semesters[2], true)
+        ))).`when`(gradeSummaryRepository).getGradesSummary(student, semesters[2], true)
 
         val averages = gradeAverageProvider.getGradeAverage(student, semesters, semesters[2].semesterId, true)
             .blockingGet()