25/06/2024.

City-Zouitel · Jun 25, 2024 · ce5d5f4 · ce5d5f4
1 parent 35d9880
commit ce5d5f4
Show file tree

Hide file tree

Showing 94 changed files with 672 additions and 607 deletions.
diff --git a/.idea/deploymentTargetDropDown.xml b/.idea/deploymentTargetDropDown.xml
diff --git a/common/systemDesign/src/main/java/city/zouitel/systemDesign/CommonConstants.kt b/common/systemDesign/src/main/java/city/zouitel/systemDesign/CommonConstants.kt
@@ -1,7 +1,7 @@
 package city.zouitel.systemDesign
 
 object CommonConstants {
-    const val APP_VERSION = "5.7.2"
+    const val APP_VERSION = "5.7.3"
     const val APP_NAME = "JetNote"
     const val NONE = "unspecified"
 

diff --git a/core/database/src/main/java/city/zouitel/database/dao/DataDao.kt b/core/database/src/main/java/city/zouitel/database/dao/DataDao.kt
@@ -15,7 +15,7 @@ interface DataDao {
     @Delete
     suspend fun deleteNote(data: DataEntity)
 
-    // delete all trashed notes.
+    // delete all removed notes.
     @Query("DELETE FROM NOTES_TABLE WHERE REMOVED = 1")
     suspend fun deleteAllTrashedNotes()
 

diff --git a/core/database/src/main/java/city/zouitel/database/datasourceImpl/AudioDataSourceImpl.kt b/core/database/src/main/java/city/zouitel/database/datasourceImpl/AudioDataSourceImpl.kt
@@ -13,22 +13,18 @@ class AudioDataSourceImpl(
     private val mapper: AudioMapper
 ): AudioDataSource {
     override val getAllAudios: Flow<List<OutAudio>>
-        get() = dao.getAllAudios().map { list ->
-            list.map { audio ->
-                mapper.readOnly(audio)
-            }
-        }
+        get() = dao.getAllAudios().map { audios -> mapper.toRepo(audios) }
 
     override suspend fun addAudio(audio: OutAudio) {
-        dao.addAudio(mapper.toLocal(audio))
+        dao.addAudio(mapper.fromRepo(audio))
     }
 
     override suspend fun updateAudio(audio: Audio) {
-        dao.updateAudio(mapper.toLocal(audio))
+        dao.updateAudio(mapper.fromRepo(audio))
     }
 
     override suspend fun deleteAudio(audio: OutAudio) {
-        dao.deleteAudio(mapper.toLocal(audio))
+        dao.deleteAudio(mapper.fromRepo(audio))
     }
 
 }
diff --git a/core/database/src/main/java/city/zouitel/database/datasourceImpl/DataDataSourceImpl.kt b/core/database/src/main/java/city/zouitel/database/datasourceImpl/DataDataSourceImpl.kt
@@ -10,15 +10,15 @@ class DataDataSourceImpl(
     private val mapper: DataMapper
 ): DataDataSource {
     override suspend fun addData(data: OutData) {
-        dao.addNote(mapper.toLocal(data))
+        dao.addNote(mapper.fromRepo(data))
     }
 
     override suspend fun editData(data: OutData) {
-        dao.editNote(mapper.toLocal(data))
+        dao.editNote(mapper.fromRepo(data))
     }
 
     override suspend fun deleteData(data: OutData) {
-        dao.deleteNote(mapper.toLocal(data))
+        dao.deleteNote(mapper.fromRepo(data))
     }
 
     override suspend fun deleteAllTrashedData() {

diff --git a/core/database/src/main/java/city/zouitel/database/datasourceImpl/LinkDataSourceImpl.kt b/core/database/src/main/java/city/zouitel/database/datasourceImpl/LinkDataSourceImpl.kt
@@ -12,17 +12,13 @@ class LinkDataSourceImpl(
     private val mapper: LinkMapper
 ): LinkDataSource {
     override val getAllLinks: Flow<List<OutLink>>
-        get() = dao.getAllLinks().map { list ->
-            list.map { link ->
-                mapper.readOnly(link)
-            }
-        }
+        get() = dao.getAllLinks().map { links -> mapper.toRepo(links) }
 
     override suspend fun addLink(link: OutLink) {
-        dao.addLink(mapper.toLocal(link))
+        dao.addLink(mapper.fromRepo(link))
     }
 
     override suspend fun deleteLink(link: OutLink) {
-        dao.deleteLink(mapper.toLocal(link))
+        dao.deleteLink(mapper.fromRepo(link))
     }
 }
diff --git a/...database/src/main/java/city/zouitel/database/datasourceImpl/NoteAndAudioDataSourceImpl.kt b/...database/src/main/java/city/zouitel/database/datasourceImpl/NoteAndAudioDataSourceImpl.kt
@@ -13,21 +13,17 @@ class NoteAndAudioDataSourceImpl(
     private val mapper: NoteAndAudioMapper
 ): NoteAndAudioDataSource {
     override val getAllNotesAndAudio: Flow<List<OutNoteAndAudio>>
-        get() = dao.getAllNotesAndAudios().map { list ->
-            list.map { noteAndAudio ->
-                mapper.readOnly(noteAndAudio)
-            }
-        }
+        get() = dao.getAllNotesAndAudios().map { notesAndAudio -> mapper.toRepo(notesAndAudio) }
 
     override suspend fun addNoteAndAudio(noteAndAudio: OutNoteAndAudio) {
-        dao.addNoteAndAudio(mapper.toLocal(noteAndAudio))
+        dao.addNoteAndAudio(mapper.fromRepo(noteAndAudio))
     }
 
     override suspend fun updateNoteAndAudio(noteAndAudio: NoteAndAudio) {
-        dao.updateNoteAndAudio(mapper.toLocal(noteAndAudio))
+        dao.updateNoteAndAudio(mapper.fromRepo(noteAndAudio))
     }
 
     override suspend fun deleteNoteAndAudio(noteAndAudio: OutNoteAndAudio) {
-        dao.deleteNoteAndAudio(mapper.toLocal(noteAndAudio))
+        dao.deleteNoteAndAudio(mapper.fromRepo(noteAndAudio))
     }
 }
diff --git a/.../database/src/main/java/city/zouitel/database/datasourceImpl/NoteAndLinkDataSourceImpl.kt b/.../database/src/main/java/city/zouitel/database/datasourceImpl/NoteAndLinkDataSourceImpl.kt
@@ -12,17 +12,13 @@ class NoteAndLinkDataSourceImpl(
     private val  mapper: NoteAndLinkMapper
 ): NoteAndLinkDataSource {
     override val getAllNotesAndLinks: Flow<List<OutNoteAndLink>>
-        get() = dao.getAllNotesAndLinks().map { list ->
-            list.map { noteAndLink ->
-                mapper.readOnly(noteAndLink)
-            }
-        }
+        get() = dao.getAllNotesAndLinks().map { notesAndLink -> mapper.toRepo(notesAndLink) }
 
     override suspend fun addNoteAndLink(noteAndLink: OutNoteAndLink) {
-        dao.addNoteAndLink(mapper.toLocal(noteAndLink))
+        dao.addNoteAndLink(mapper.fromRepo(noteAndLink))
     }
 
     override suspend fun deleteNoteAndLink(noteAndLink: OutNoteAndLink) {
-        dao.deleteNoteAndLink(mapper.toLocal(noteAndLink))
+        dao.deleteNoteAndLink(mapper.fromRepo(noteAndLink))
     }
 }
diff --git a/core/database/src/main/java/city/zouitel/database/datasourceImpl/NoteAndTagDataSourceImpl.kt b/core/database/src/main/java/city/zouitel/database/datasourceImpl/NoteAndTagDataSourceImpl.kt
@@ -12,17 +12,13 @@ class NoteAndTagDataSourceImpl(
     private val mapper: NoteAndTagMapper
 ): NoteAndTagDataSource {
     override val getAllNotesAndTags: Flow<List<OutNoteAndTag>>
-        get() = dao.getAllNotesAndTags().map { list ->
-            list.map {
-                mapper.readOnly(it)
-            }
-        }
+        get() = dao.getAllNotesAndTags().map { notesAndTag -> mapper.toRepo(notesAndTag) }
 
     override suspend fun addNoteAndTag(noteAndTag: OutNoteAndTag) {
-        dao.addNoteAndTag(mapper.toLocal(noteAndTag))
+        dao.addNoteAndTag(mapper.fromRepo(noteAndTag))
     }
 
     override suspend fun deleteNoteAndTag(noteAndTag: OutNoteAndTag) {
-        dao.deleteNoteAndTag(mapper.toLocal(noteAndTag))
+        dao.deleteNoteAndTag(mapper.fromRepo(noteAndTag))
     }
 }
diff --git a/.../database/src/main/java/city/zouitel/database/datasourceImpl/NoteAndTaskDataSourceImpl.kt b/.../database/src/main/java/city/zouitel/database/datasourceImpl/NoteAndTaskDataSourceImpl.kt
@@ -12,17 +12,13 @@ class NoteAndTaskDataSourceImpl(
     private val mapper: NoteAndTaskMapper
 ): NoteAndTaskDataSource {
     override val getAllNotesAndTask: Flow<List<OutNoteAndTask>>
-        get() = dao.getAllNoteAndTasks().map { list ->
-            list.map {
-                mapper.readOnly(it)
-            }
-        }
+        get() = dao.getAllNoteAndTasks().map { notesAndTask -> mapper.toRepo(notesAndTask) }
 
     override suspend fun addNoteAndTask(noteAndTask: OutNoteAndTask) {
-        dao.addNoteAndTask(mapper.toLocal(noteAndTask))
+        dao.addNoteAndTask(mapper.fromRepo(noteAndTask))
     }
 
     override suspend fun deleteNoteAndTask(noteAndTask: OutNoteAndTask) {
-        dao.deleteNoteAndTask(mapper.toLocal(noteAndTask))
+        dao.deleteNoteAndTask(mapper.fromRepo(noteAndTask))
     }
 }
diff --git a/core/database/src/main/java/city/zouitel/database/datasourceImpl/NoteDataSourceImpl.kt b/core/database/src/main/java/city/zouitel/database/datasourceImpl/NoteDataSourceImpl.kt
@@ -13,51 +13,23 @@ class NoteDataSourceImpl(
 ): NoteDataSource {
 
     override val getAllNotesById: Flow<List<OutNote>>
-        get() = dao.getAllNotesById().map { list ->
-            list.map {
-                mapper.readOnly(it)
-            }
-        }
+        get() = dao.getAllNotesById().map { notes -> mapper.toRepo(notes) }
 
     override val getAllNotesByName: Flow<List<OutNote>>
-        get() = dao.getAllNotesByName().map { list ->
-            list.map {
-                mapper.readOnly(it)
-            }
-        }
+        get() = dao.getAllNotesByName().map { notes -> mapper.toRepo(notes) }
 
     override val getAllNotesByNewest: Flow<List<OutNote>>
-        get() = dao.getAllNotesByNewest().map { list ->
-            list.map {
-                mapper.readOnly(it)
-            }
-        }
+        get() = dao.getAllNotesByNewest().map { notes -> mapper.toRepo(notes) }
 
     override val getAllNotesByOldest: Flow<List<OutNote>>
-        get() = dao.getAllNotesByOldest().map { list ->
-            list.map {
-                mapper.readOnly(it)
-            }
-        }
+        get() = dao.getAllNotesByOldest().map { notes -> mapper.toRepo(notes) }
 
     override val getAllTrashedNotes: Flow<List<OutNote>>
-        get() = dao.getAllTrashedNotes().map { list ->
-            list.map {
-                mapper.readOnly(it)
-            }
-        }
+        get() = dao.getAllTrashedNotes().map { notes -> mapper.toRepo(notes) }
 
     override val allNotesByPriority: Flow<List<OutNote>>
-        get() = dao.getAllNotesByPriority().map { list ->
-            list.map {
-                mapper.readOnly(it)
-            }
-        }
+        get() = dao.getAllNotesByPriority().map { notes -> mapper.toRepo(notes) }
 
     override val getAllRemindingNotes: Flow<List<OutNote>>
-        get() = dao.getAllRemindingNotes().map { list ->
-            list.map {
-                mapper.readOnly(it)
-            }
-        }
+        get() = dao.getAllRemindingNotes().map { notes -> mapper.toRepo(notes) }
 }
diff --git a/core/database/src/main/java/city/zouitel/database/datasourceImpl/TagDataSourceImpl.kt b/core/database/src/main/java/city/zouitel/database/datasourceImpl/TagDataSourceImpl.kt
@@ -12,21 +12,17 @@ class TagDataSourceImpl(
     private val mapper: TagMapper
 ): TagDataSource {
     override val getAllLabels: Flow<List<OutTag>>
-        get() = dao.getAllTags().map { list ->
-            list.map {
-                mapper.readOnly(it)
-            }
-        }
+        get() = dao.getAllTags().map { tags -> mapper.toRepo(tags) }
 
     override suspend fun addTag(tag: OutTag) {
-        dao.addTag(mapper.toLocal(tag))
+        dao.addTag(mapper.fromRepo(tag))
     }
 
     override suspend fun updateTag(tag: OutTag) {
-        dao.updateTag(mapper.toLocal(tag))
+        dao.updateTag(mapper.fromRepo(tag))
     }
 
     override suspend fun deleteTag(tag: OutTag) {
-        dao.deleteTag(mapper.toLocal(tag))
+        dao.deleteTag(mapper.fromRepo(tag))
     }
 }
diff --git a/core/database/src/main/java/city/zouitel/database/datasourceImpl/TaskDataSourceImpl.kt b/core/database/src/main/java/city/zouitel/database/datasourceImpl/TaskDataSourceImpl.kt
@@ -12,21 +12,17 @@ class TaskDataSourceImpl(
     private val mapper: TaskMapper
 ): TaskDataSource {
     override val getAllTaskItems: Flow<List<OutTask>>
-        get() = dao.getAllTaskItems().map { list ->
-            list.map {
-                mapper.readOnly(it)
-            }
-        }
+        get() = dao.getAllTaskItems().map { tasks -> mapper.toRepo(tasks) }
 
     override suspend fun addTaskItem(task: OutTask) {
-        dao.addTaskItem(mapper.toLocal(task))
+        dao.addTaskItem(mapper.fromRepo(task))
     }
 
     override suspend fun updateTaskItem(task: OutTask) {
-        dao.updateTaskItem(mapper.toLocal(task))
+        dao.updateTaskItem(mapper.fromRepo(task))
     }
 
     override suspend fun deleteTaskItem(task: OutTask) {
-        dao.deleteTaskItem(mapper.toLocal(task))
+        dao.deleteTaskItem(mapper.fromRepo(task))
     }
 }
diff --git a/core/database/src/main/java/city/zouitel/database/datasourceImpl/WidgetDataSourceImpl.kt b/core/database/src/main/java/city/zouitel/database/datasourceImpl/WidgetDataSourceImpl.kt
@@ -12,9 +12,5 @@ class WidgetDataSourceImpl(
     private val mapper: WidgetMapper
 ): WidgetDataSource {
     override val getAllWidgetMainEntityById: Flow<List<OutNote>>
-        get() = dao.allWidgetEntitiesById().map { list ->
-            list.map { note ->
-                mapper.readOnly(note)
-            }
-        }
+        get() = dao.allWidgetEntitiesById().map { notes -> mapper.toRepo(notes) }
 }
diff --git a/core/database/src/main/java/city/zouitel/database/mapper/AudioMapper.kt b/core/database/src/main/java/city/zouitel/database/mapper/AudioMapper.kt
@@ -1,15 +1,27 @@
 package city.zouitel.database.mapper
 
-import city.zouitel.database.mapper.base.Mapper
 import city.zouitel.repository.model.Audio as OutAudio
 import city.zouitel.database.model.AudioEntity as InAudio
 
-class AudioMapper: Mapper.Base<InAudio, OutAudio> {
-    override fun toLocal(data: OutAudio): InAudio = with(data) {
-        InAudio(id, title, path, uri, size, duration)
-    }
+class  AudioMapper {
 
-    override fun readOnly(data: InAudio): OutAudio = with(data) {
-        OutAudio(id, title, path, uri, size, duration)
-    }
+    fun toRepo(audios: List<InAudio>) = audios.map { toRepo(it) }
+
+    fun toRepo(audio: InAudio) = OutAudio(
+        id = audio.id,
+        title = audio.title,
+        path = audio.path,
+        uri = audio.uri,
+        size = audio.size,
+        duration = audio.duration
+    )
+
+    fun fromRepo(audio: OutAudio) = InAudio(
+        id = audio.id,
+        title = audio.title,
+        path = audio.path,
+        uri = audio.uri,
+        size = audio.size,
+        duration = audio.duration
+    )
 }
diff --git a/core/database/src/main/java/city/zouitel/database/mapper/DataMapper.kt b/core/database/src/main/java/city/zouitel/database/mapper/DataMapper.kt
@@ -1,17 +1,32 @@
 package city.zouitel.database.mapper
 
-import city.zouitel.database.mapper.base.Mapper
+import city.zouitel.repository.model.Data
 import city.zouitel.database.model.DataEntity as InData
 import city.zouitel.repository.model.Data as OutData
 
-class DataMapper: Mapper.Base<InData, OutData> {
-    override fun toLocal(data: OutData): InData = with(data){
-        InData(uid, title, description, priority, color, textColor, date,
-            trashed, reminding)
-    }
+class DataMapper {
 
-    override fun readOnly(data: InData): OutData = with(data){
-        OutData(uid, title, description, priority, color, textColor, date,
-            removed, reminding)
-    }
+    fun toRepo(data: InData) = OutData(
+        uid = data.uid,
+        title = data.title,
+        description = data.description,
+        priority = data.priority,
+        color = data.color,
+        textColor = data.textColor,
+        date = data.date,
+        removed = data.removed,
+        reminding = data.reminding
+    )
+
+    fun fromRepo(data: OutData) = InData(
+        uid = data.uid,
+        title = data.title,
+        description = data.description,
+        priority = data.priority,
+        color = data.color,
+        textColor = data.textColor,
+        date = data.date,
+        removed = data.removed,
+        reminding = data.reminding
+    )
 }