libanki: add notetype change methods and tests

From https://github.com/ankitects/anki/blob/630bdd31893d5113b81cd60612cef3ebf146d5b4/pylib/anki/models.py

Co-authored-by: David Allison <62114487+david-allison@users.noreply.github.com>

Author: 2 people

AnkiDroid/src/main/java/com/ichi2/anki/CardTemplateEditor.kt

@@ -101,7 +101,6 @@ import com.ichi2.libanki.Notetypes.Companion.NOT_FOUND_NOTE_TYPE
 import com.ichi2.libanki.exception.ConfirmModSchemaException
 import com.ichi2.libanki.getStockNotetype
 import com.ichi2.libanki.getStockNotetypeKinds
-import com.ichi2.libanki.restoreNotetypeToStock
 import com.ichi2.libanki.utils.append
 import com.ichi2.themes.Themes
 import com.ichi2.ui.FixedEditText
@@ -976,7 +975,7 @@ open class CardTemplateEditor :
         @NeedsTest("Notetype is restored to stock kind")
         private suspend fun restoreNotetypeToStock(kind: StockNotetype.Kind? = null) {
             val nid = notetypeId { ntid = tempModel.noteTypeId }
-            undoableOp { restoreNotetypeToStock(nid, kind) }
+            undoableOp { notetypes.restoreNotetypeToStock(nid, kind) }
             onModelSaved()
             showThemedToast(
                 requireContext(),

AnkiDroid/src/main/java/com/ichi2/libanki/Notetypes.kt

@@ -34,6 +34,8 @@ package com.ichi2.libanki
 import androidx.annotation.CheckResult
 import anki.collection.OpChanges
 import anki.collection.OpChangesWithId
+import anki.notetypes.ChangeNotetypeInfo
+import anki.notetypes.ChangeNotetypeRequest
 import anki.notetypes.Notetype
 import anki.notetypes.NotetypeId
 import anki.notetypes.NotetypeNameId
@@ -55,6 +57,7 @@ import com.ichi2.libanki.utils.insert
 import com.ichi2.libanki.utils.len
 import com.ichi2.libanki.utils.remove
 import net.ankiweb.rsdroid.RustCleanup
+import net.ankiweb.rsdroid.exceptions.BackendInvalidInputException
 import net.ankiweb.rsdroid.exceptions.BackendNotFoundException
 import org.intellij.lang.annotations.Language
 import org.json.JSONArray
@@ -527,6 +530,82 @@ class Notetypes(
         save(notetype)
     }
 
+    /*
+     * Changing notetypes of notes
+     * ***********************************************************
+     */
+
+    /**
+     * @return The ID of the single note type which all supplied notes are using; throws otherwise
+     *
+     * @throws BackendInvalidInputException notes from different note types were supplied
+     * @throws BackendInvalidInputException an empty list was supplied
+     * @throws BackendNotFoundException One of the provided IDs was invalid
+     */
+    @CheckResult
+    @LibAnkiAlias("get_single_notetype_of_notes")
+    fun getSingleNotetypeOfNotes(noteIds: List<NoteId>): NoteTypeId = col.backend.getSingleNotetypeOfNotes(noteIds)
+
+    @CheckResult
+    @LibAnkiAlias("change_notetype_info")
+    fun changeNotetypeInfo(
+        oldNoteTypeId: NoteTypeId,
+        newNoteTypeId: NoteTypeId,
+    ): ChangeNotetypeInfo =
+        this.col.backend.getChangeNotetypeInfo(
+            oldNotetypeId = oldNoteTypeId,
+            newNotetypeId = newNoteTypeId,
+        )
+
+    /**
+     * Assign a new notetype, optionally altering field/template order.
+     *
+     * To get defaults, use
+     *
+     * ```kotlin
+     * val info = col.models.change_notetype_info(...)
+     * val input = info.input
+     * input.note_ids.extend([...])
+     * ```
+     *
+     * The `newFields` and `newTemplates` lists are relative to the new notetype's
+     * field/template count.
+     *
+     * Each value represents the index in the previous notetype.
+     * -1 indicates the original value will be discarded.
+     */
+    @LibAnkiAlias("change_notetype_of_notes")
+    fun changeNotetypeOfNotes(input: ChangeNotetypeRequest): OpChanges {
+        val opBytes = this.col.backend.changeNotetypeRaw(input.toByteArray())
+        return OpChanges.parseFrom(opBytes)
+    }
+
+    /**
+     * Restores a notetype to its original stock kind.
+     *
+     * @param notetypeId id of the changed notetype
+     * @param forceKind optional stock kind to be forced instead of the original kind.
+     * Older notetypes did not store their original stock kind, so we allow the UI
+     * to pass in an override to use when missing, or for tests.
+     */
+    @CheckResult
+    @LibAnkiAlias("restore_notetype_to_stock")
+    fun restoreNotetypeToStock(
+        notetypeId: NotetypeId,
+        forceKind: StockNotetype.Kind? = null,
+    ): OpChanges {
+        val msg =
+            restoreNotetypeToStockRequest {
+                this.notetypeId = notetypeId
+                forceKind?.let { this.forceKind = forceKind }
+            }
+        return col.backend.restoreNotetypeToStock(msg).also {
+            // not in libAnki:
+            // Remove the specific notetype from cache to ensure consistency after restoration
+            removeFromCache(notetypeId.ntid)
+        }
+    }
+
     /*
     # Model changing
     ##########################################################################
@@ -741,29 +820,5 @@ fun Collection.addNotetypeLegacy(json: ByteString): OpChangesWithId {
 fun Collection.getStockNotetype(kind: StockNotetype.Kind): NotetypeJson =
     NotetypeJson(fromJsonBytes(backend.getStockNotetypeLegacy(kind = kind)))
 
-/**
- * Restores a notetype to its original stock kind.
- *
- * @param notetypeId id of the changed notetype
- * @param forceKind optional stock kind to be forced instead of the original kind.
- * Older notetypes did not store their original stock kind, so we allow the UI
- * to pass in an override to use when missing, or for tests.
- */
-@CheckResult
-fun Collection.restoreNotetypeToStock(
-    notetypeId: NotetypeId,
-    forceKind: StockNotetype.Kind? = null,
-): OpChanges {
-    val msg =
-        restoreNotetypeToStockRequest {
-            this.notetypeId = notetypeId
-            forceKind?.let { this.forceKind = forceKind }
-        }
-    val result = backend.restoreNotetypeToStock(msg)
-    // Remove the specific notetype from cache to ensure consistency after restoration
-    notetypes.removeFromCache(notetypeId.ntid)
-    return result
-}
-
 @NotInLibAnki
 fun getStockNotetypeKinds(): List<StockNotetype.Kind> = StockNotetype.Kind.entries.filter { it != StockNotetype.Kind.UNRECOGNIZED }

AnkiDroid/src/test/java/com/ichi2/libanki/NotetypesTest.kt

@@ -0,0 +1,79 @@
+/*
+ *  Copyright (c) 2025 David Allison <davidallisongithub@gmail.com>
+ *
+ *  This program is free software; you can redistribute it and/or modify it under
+ *  the terms of the GNU General Public License as published by the Free Software
+ *  Foundation; either version 3 of the License, or (at your option) any later
+ *  version.
+ *
+ *  This program is distributed in the hope that it will be useful, but WITHOUT ANY
+ *  WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A
+ *  PARTICULAR PURPOSE. See the GNU General Public License for more details.
+ *
+ *  You should have received a copy of the GNU General Public License along with
+ *  this program.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+package com.ichi2.libanki
+
+import androidx.test.espresso.matcher.ViewMatchers.assertThat
+import androidx.test.ext.junit.runners.AndroidJUnit4
+import com.ichi2.testutils.JvmTest
+import com.ichi2.testutils.common.assertThrows
+import net.ankiweb.rsdroid.exceptions.BackendInvalidInputException
+import net.ankiweb.rsdroid.exceptions.BackendNotFoundException
+import org.hamcrest.Matchers.equalTo
+import org.junit.Test
+import org.junit.runner.RunWith
+
+@RunWith(AndroidJUnit4::class)
+class NotetypesTest : JvmTest() {
+    @Test
+    fun `getSingleNotetypeOfNotes - multiple`() {
+        val notes = addNotes(2)
+        val result = col.notetypes.getSingleNotetypeOfNotes(notes.map { it.id })
+        assertThat(result, equalTo(notes.first().notetype.id))
+    }
+
+    @Test
+    fun `getSingleNotetypeOfNotes - valid`() {
+        val note = addNotes(1).single()
+        val result = col.notetypes.getSingleNotetypeOfNotes(listOf(note.id))
+        assertThat(result, equalTo(note.notetype.id))
+    }
+
+    @Test
+    fun `getSingleNotetypeOfNotes - no input`() {
+        val result = assertThrows<BackendInvalidInputException> { col.notetypes.getSingleNotetypeOfNotes(emptyList()) }
+        assertThat(result.message, equalTo("no note id provided"))
+    }
+
+    @Test
+    fun `getSingleNotetypeOfNotes - invalid input`() {
+        val noteIds = listOf<Long>(1)
+        val result = assertThrows<BackendNotFoundException> { col.notetypes.getSingleNotetypeOfNotes(noteIds) }
+        assertThat(
+            result.message,
+            equalTo("Your database appears to be in an inconsistent state. Please use the Check Database action. No such note: '1'"),
+        )
+    }
+
+    @Test
+    fun `getSingleNotetypeOfNotes - one invalid`() {
+        val noteIds = listOf(1, addNotes(1).single().id)
+        val result = assertThrows<BackendNotFoundException> { col.notetypes.getSingleNotetypeOfNotes(noteIds) }
+        assertThat(
+            result.message,
+            equalTo("Your database appears to be in an inconsistent state. Please use the Check Database action. No such note: '1'"),
+        )
+    }
+
+    @Test
+    fun `getSingleNotetypeOfNotes - mixed`() {
+        val basicNote = addNotes(1).single()
+        val clozeNote = addClozeNote("{{c1::aa}}")
+        val result =
+            assertThrows<BackendInvalidInputException> { col.notetypes.getSingleNotetypeOfNotes(listOf(basicNote.id, clozeNote.id)) }
+        assertThat(result.message, equalTo("Please select notes from only one note type."))
+    }
+}