Package de.svws_nrw.api.privileged

Klasse APIPrivilegedSchema

java.lang.Object
de.svws_nrw.api.privileged.APIPrivilegedSchema
@Path("") @Produces("application/json") @Consumes("application/json") public class APIPrivilegedSchema extends Object
Die Klasse spezifiziert die OpenAPI-Schnittstelle für den Zugriff auf Schemaoperationen mit Root-Rechten. Ein Zugriff erfolgt über den Pfad https://{Hostname}/db/{schema}/api/schema/root/...

  • Konstruktorübersicht

    Konstruktoren
    Konstruktor
    Beschreibung
    APIPrivilegedSchema()
    Leerer Standardkonstruktor.

  • Methodenübersicht

    Modifizierer und Typ
    Methode
    Beschreibung
    boolean
    checkDBPassword(BenutzerKennwort kennwort, jakarta.servlet.http.HttpServletRequest request)
    Die OpenAPI-Methode für das angegebene Password für einen Datenbankuser korrekt ist.
    jakarta.ws.rs.core.Response
    createSchema(String schemaname, long revision, BenutzerKennwort kennwort, jakarta.servlet.http.HttpServletRequest request)
    Die OpenAPI-Methode für das Anlegen eines Schemas mit angegebenem Namen und in der angegebenen Revision.
    jakarta.ws.rs.core.Response
    createSchemaCurrent(String schemaname, BenutzerKennwort kennwort, jakarta.servlet.http.HttpServletRequest request)
    Die OpenAPI-Methode für das Anlegen eines Schemas mit angegebenem Namen und in der aktuellen Revision.
    jakarta.ws.rs.core.Response
    createSchemaCurrentInto(String schemaname, jakarta.servlet.http.HttpServletRequest request)
    Die OpenAPI-Methode für das Anlegen eines SVWSM-Schemas in der aktuellen Revision in dem Schema mit angegebenem Namen.
    jakarta.ws.rs.core.Response
    createSchemaInto(String schemaname, long revision, jakarta.servlet.http.HttpServletRequest request)
    Die OpenAPI-Methode für das Anlegen eines SVWSM-Schemas in der angegebenen Revision in dem Schema mit angegebenem Namen.
    jakarta.ws.rs.core.Response
    deactivateSchema(String schemaname, int state, jakarta.servlet.http.HttpServletRequest request)
    Die OpenAPI-Methode für das Setzen des Flags, ob ein Schema deaktiviert wurde oder nicht.
    jakarta.ws.rs.core.Response
    destroySchema(String schemaname, jakarta.servlet.http.HttpServletRequest request)
    Die OpenAPI-Methode für das Löschen eines Schemas mit angegebenem Namen, wenn es existiert.
    jakarta.ws.rs.core.Response
    existsSchema(String schemaname, jakarta.servlet.http.HttpServletRequest request)
    Die OpenAPI-Methode für die Abfrage ob ein Datenbankschema mit bestimmtem Namen bereits existiert.
    jakarta.ws.rs.core.Response
    existsUser(String username, jakarta.servlet.http.HttpServletRequest request)
    Die OpenAPI-Methode für die Abfrage ob ein Datenbankuser mit bestimmtem Namen bereits existiert.
    jakarta.ws.rs.core.Response
    exportSQLiteFrom(String schemaname, jakarta.servlet.http.HttpServletRequest request)
    Die OpenAPI-Methode für den Export einer SQLite-Datenbank aus einem Schema.
    jakarta.ws.rs.core.Response
    getAllgemeinenKatalogSchulen(jakarta.servlet.http.HttpServletRequest request)
    Die OpenAPI-Methode für die Abfrage des Schulen-Kataloges.
    jakarta.ws.rs.core.Response
    getSchemaAdmins(String schemaname, jakarta.servlet.http.HttpServletRequest request)
    Die OpenAPI-Methode für die Abfrage der administrativen Benutzer in einem aktuellen SVWS-Schema.
    jakarta.ws.rs.core.Response
    getSchemaListe(jakarta.servlet.http.HttpServletRequest request)
    Die OpenAPI-Methode für die Abfrage der Liste aller Schemas im DBMS.
    jakarta.ws.rs.core.Response
    getSchuleInfo(String schemaname, jakarta.servlet.http.HttpServletRequest request)
    Die OpenAPI-Methode für die Abfrage der Informationen eines SVWS-Schema bezüglich der Schule.
    jakarta.ws.rs.core.Response
    getSVWSSchemaListe(jakarta.servlet.http.HttpServletRequest request)
    Die OpenAPI-Methode für die Abfrage der Liste aller SVWS-Schemata im DBMS.
    jakarta.ws.rs.core.Response
    importExistingSchema(String schema, BenutzerKennwort kennwort, jakarta.servlet.http.HttpServletRequest request)
    Die OpenAPI-Methode für das Hinzufügen eines bestehenden SVWS-Schemas zu der SVWS-Konfiguration.
    jakarta.ws.rs.core.Response
    importSQLite2Schema(String schemaname, DBMultipartBody multipart, jakarta.servlet.http.HttpServletRequest request)
    Die OpenAPI-Methode für den Import einer SQLite-Datenbank in ein Schema mit dem angegebenen Namen.
    jakarta.ws.rs.core.Response
    importSQLiteInto(String schemaname, DBMultipartBodyDataOnly multipart, jakarta.servlet.http.HttpServletRequest request)
    Die OpenAPI-Methode für den Import einer SQLite-Datenbank aus dem angegebenen Schema.
    jakarta.ws.rs.core.Response
    initSchemaMitSchule(String schema, int schulnummer, jakarta.servlet.http.HttpServletRequest request)
    Die OpenAPI-Methode für das Initialisieren des Schema mit einer Schulnummer.
    jakarta.ws.rs.core.Response
    migrateMariaDB2Schema(String schemaname, MigrateBody dbMigrationInfos, jakarta.servlet.http.HttpServletRequest request)
    Die OpenAPI-Methode für das Migrieren einer bestehenden MariaDB in ein Schema mit angegebenen Namen.
    jakarta.ws.rs.core.Response
    migrateMariaDB2SchemaSchulnummer(String schemaname, int schulnummer, MigrateBody dbMigrationInfos, jakarta.servlet.http.HttpServletRequest request)
    Die OpenAPI-Methode für das Migrieren aus einer Schild2-MariaDB-Datenbank in ein Schema mit angegebenen Namen, wobei nur Daten für die angegebene Schulnummer übertragen werden.
    jakarta.ws.rs.core.Response
    migrateMariaDBInto(String schemaname, DatenbankVerbindungsdaten verbindungsdaten, jakarta.servlet.http.HttpServletRequest request)
    Die OpenAPI-Methode für das Migrieren einer bestehenden MariaDB in ein Schema mit angegebenen Namen.
    jakarta.ws.rs.core.Response
    migrateMariaDBSchulnummerInto(String schemaname, int schulnummer, DatenbankVerbindungsdaten verbindungsdaten, jakarta.servlet.http.HttpServletRequest request)
    Die OpenAPI-Methode für das Migrieren einer bestehenden MariaDB in das angebenene Schema, wobei nur Daten für die angegebene Schulnummer übertragen werden.
    jakarta.ws.rs.core.Response
    migrateMDB2Schema(String schemaname, DBMultipartBody multipart, jakarta.servlet.http.HttpServletRequest request)
    Die OpenAPI-Methode für das Migrieren einer MDB in ein Schema mit angegebenen Namen.
    jakarta.ws.rs.core.Response
    migrateMDBInto(String schemaname, DBMultipartBodyDataOnly multipart, jakarta.servlet.http.HttpServletRequest request)
    Die OpenAPI-Methode für das Migrieren einer MDB in das angegebene Schema.
    jakarta.ws.rs.core.Response
    migrateMSSQL2Schema(String schemaname, MigrateBody dbMigrationInfos, jakarta.servlet.http.HttpServletRequest request)
    Die OpenAPI-Methode für das Migrieren einer bestehenden MSSQL in ein Schema mit angegebenen Namen.
    jakarta.ws.rs.core.Response
    migrateMSSQL2SchemaSchulnummer(String schemaname, int schulnummer, MigrateBody dbMigrationInfos, jakarta.servlet.http.HttpServletRequest request)
    Die OpenAPI-Methode für das Migrieren aus einer Schild2-MSSQL-Datenbank in ein Schema mit angegebenen Namen, wobei nur Daten für die angegebene Schulnummer übertragen werden.
    jakarta.ws.rs.core.Response
    migrateMsSqlServerInto(String schemaname, DatenbankVerbindungsdaten verbindungsdaten, jakarta.servlet.http.HttpServletRequest request)
    Die OpenAPI-Methode für das Migrieren einer bestehenden SQL-Server-Datenbank in das angegebene Schema.
    jakarta.ws.rs.core.Response
    migrateMsSqlServerSchulnummerInto(String schemaname, int schulnummer, DatenbankVerbindungsdaten verbindungsdaten, jakarta.servlet.http.HttpServletRequest request)
    Die OpenAPI-Methode für das Migrieren einer bestehenden SQL-Server-Datenbank in ein Schema mit angegebenen Namen, wobei nur Daten für die angegebene Schulnummer übertragen werden.
    jakarta.ws.rs.core.Response
    migrateMySQL2Schema(String schemaname, MigrateBody dbMigrationInfos, jakarta.servlet.http.HttpServletRequest request)
    Die OpenAPI-Methode für das Migrieren einer bestehenden MySQL in ein Schema mit angegebenen Namen.
    jakarta.ws.rs.core.Response
    migrateMySQL2SchemaSchulnummer(String schemaname, int schulnummer, MigrateBody dbMigrationInfos, jakarta.servlet.http.HttpServletRequest request)
    Die OpenAPI-Methode für das Migrieren aus einer Schild2-MySQL-Datenbank in ein Schema mit angegebenen Namen, wobei nur Daten für die angegebene Schulnummer übertragen werden.
    jakarta.ws.rs.core.Response
    migrateMySqlInto(String schemaname, DatenbankVerbindungsdaten verbindungsdaten, jakarta.servlet.http.HttpServletRequest request)
    Die OpenAPI-Methode für das Migrieren einer bestehenden MySQL-Datenbank in das angebenene Schema.
    jakarta.ws.rs.core.Response
    migrateMySqlSchulnummerInto(String schemaname, int schulnummer, DatenbankVerbindungsdaten verbindungsdaten, jakarta.servlet.http.HttpServletRequest request)
    Die OpenAPI-Methode für das Migrieren einer bestehenden MySQL-Datenbank in das angebene Schema, wobei nur Daten für die angegebene Schulnummer übertragen werden.
    jakarta.ws.rs.core.Response
    updateSchema(String schemaname, long revision, jakarta.servlet.http.HttpServletRequest request)
    Die OpenAPI-Methode um ein Datenbankschema auf eine bestimmte Revision upzudaten.
    jakarta.ws.rs.core.Response
    updateSchemaToCurrent(String schemaname, jakarta.servlet.http.HttpServletRequest request)
    Die OpenAPI-Methode um ein Datenbankschema auf die neueste Revision upzudaten.

    Von Klasse geerbte Methoden java.lang.Object

    clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait

  • Konstruktordetails

    • APIPrivilegedSchema

      public APIPrivilegedSchema()
      Leerer Standardkonstruktor.

  • Methodendetails

    • getSVWSSchemaListe

      @GET @Path("/api/schema/liste/svws") public jakarta.ws.rs.core.Response getSVWSSchemaListe(@Context jakarta.servlet.http.HttpServletRequest request)
      Die OpenAPI-Methode für die Abfrage der Liste aller SVWS-Schemata im DBMS.
      Parameter:
      request - die Informationen zur HTTP-Anfrage
      Gibt zurück:
      die Liste der vorhandenen SVWS-Schemata in der Datenbank

    • getSchemaListe

      @GET @Path("/api/schema/liste/alle") public jakarta.ws.rs.core.Response getSchemaListe(@Context jakarta.servlet.http.HttpServletRequest request)
      Die OpenAPI-Methode für die Abfrage der Liste aller Schemas im DBMS.
      Parameter:
      request - die Informationen zur HTTP-Anfrage
      Gibt zurück:
      die Liste der vorhandenen Schemas in der Datenbank

    • getAllgemeinenKatalogSchulen

      @GET @Path("/api/schema/liste/kataloge/schulen") public jakarta.ws.rs.core.Response getAllgemeinenKatalogSchulen(@Context jakarta.servlet.http.HttpServletRequest request)
      Die OpenAPI-Methode für die Abfrage des Schulen-Kataloges.
      Parameter:
      request - die Informationen zur HTTP-Anfrage
      Gibt zurück:
      die Liste der Schulen

    • getSchuleInfo

      @GET @Path("/api/schema/liste/info/{schema}/schule") public jakarta.ws.rs.core.Response getSchuleInfo(@PathParam("schema") String schemaname, @Context jakarta.servlet.http.HttpServletRequest request)
      Die OpenAPI-Methode für die Abfrage der Informationen eines SVWS-Schema bezüglich der Schule.
      Parameter:
      schemaname - der Name des SVWS-Schema
      request - die Informationen zur HTTP-Anfrage
      Gibt zurück:
      die Informationen zur Schule

    • getSchemaAdmins

      @GET @Path("/api/schema/liste/info/{schema}/admins") public jakarta.ws.rs.core.Response getSchemaAdmins(@PathParam("schema") String schemaname, @Context jakarta.servlet.http.HttpServletRequest request)
      Die OpenAPI-Methode für die Abfrage der administrativen Benutzer in einem aktuellen SVWS-Schema.
      Parameter:
      schemaname - der Name des SVWS-Schema
      request - die Informationen zur HTTP-Anfrage
      Gibt zurück:
      die Liste der administrativen Benutzer

    • existsSchema

      @GET @Path("/api/schema/root/exists/{schema}") public jakarta.ws.rs.core.Response existsSchema(@PathParam("schema") String schemaname, @Context jakarta.servlet.http.HttpServletRequest request)
      Die OpenAPI-Methode für die Abfrage ob ein Datenbankschema mit bestimmtem Namen bereits existiert.
      Parameter:
      schemaname - das Datenbankschema, auf das geprüft werden soll
      request - die Informationen zur HTTP-Anfrage
      Gibt zurück:
      Rückmeldung, ob das angegebene Schema existiert

    • existsUser

      @GET @Path("/api/schema/root/user/{user}/exists") public jakarta.ws.rs.core.Response existsUser(@PathParam("user") String username, @Context jakarta.servlet.http.HttpServletRequest request)
      Die OpenAPI-Methode für die Abfrage ob ein Datenbankuser mit bestimmtem Namen bereits existiert.
      Parameter:
      username - der Datenbankusername, auf den geprüft werden soll
      request - die Informationen zur HTTP-Anfrage
      Gibt zurück:
      Rückmeldung, ob der angegebene User existiert

    • checkDBPassword

      @POST @Path("/api/schema/root/user/checkpwd") public boolean checkDBPassword(BenutzerKennwort kennwort, @Context jakarta.servlet.http.HttpServletRequest request)
      Die OpenAPI-Methode für das angegebene Password für einen Datenbankuser korrekt ist.
      Parameter:
      kennwort - der Username und das Kennwort im json, das überprüft werden soll
      request - die Informationen zur HTTP-Anfrage
      Gibt zurück:
      Rückmeldung, ob das angegebene Kennwort korrekt ist

    • createSchema

      @POST @Path("/api/schema/root/create/{schema}/{revision : \\d+}") public jakarta.ws.rs.core.Response createSchema(@PathParam("schema") String schemaname, @PathParam("revision") long revision, BenutzerKennwort kennwort, @Context jakarta.servlet.http.HttpServletRequest request)
      Die OpenAPI-Methode für das Anlegen eines Schemas mit angegebenem Namen und in der angegebenen Revision.
      Parameter:
      schemaname - der Name des Schemas, das angelegt werden soll
      revision - die Revisionsnummer, auf die das Schema angehoben werden soll
      kennwort - Benutzername und Kennwort mit Root-Rechten
      request - die Informationen zur HTTP-Anfrage
      Gibt zurück:
      Rückmeldung, ob das angegebene Kennwort korrekt ist

    • createSchemaCurrent

      @POST @Path("/api/schema/root/create/{schema}") public jakarta.ws.rs.core.Response createSchemaCurrent(@PathParam("schema") String schemaname, BenutzerKennwort kennwort, @Context jakarta.servlet.http.HttpServletRequest request)
      Die OpenAPI-Methode für das Anlegen eines Schemas mit angegebenem Namen und in der aktuellen Revision.
      Parameter:
      schemaname - der Name des Schemas, das angelegt werden soll
      kennwort - Benutzername und Kennwort mit Root-Rechten
      request - die Informationen zur HTTP-Anfrage
      Gibt zurück:
      Rückmeldung, ob die Operation erfolgreich war

    • destroySchema

      @POST @Path("/api/schema/root/destroy/{schema}") public jakarta.ws.rs.core.Response destroySchema(@PathParam("schema") String schemaname, @Context jakarta.servlet.http.HttpServletRequest request)
      Die OpenAPI-Methode für das Löschen eines Schemas mit angegebenem Namen, wenn es existiert.
      Parameter:
      schemaname - der Name des Schemas, das gelöscht werden soll
      request - die Informationen zur HTTP-Anfrage
      Gibt zurück:
      Rückmeldung, ob die Operation erfolgreich war

    • deactivateSchema

      @POST @Path("/api/schema/root/schema/{schema}/deactivated/{state: [0-1]}") public jakarta.ws.rs.core.Response deactivateSchema(@PathParam("schema") String schemaname, @PathParam("state") int state, @Context jakarta.servlet.http.HttpServletRequest request)
      Die OpenAPI-Methode für das Setzen des Flags, ob ein Schema deaktiviert wurde oder nicht. Der angemeldete Datenbankbenutzer muss dafür priviligierte Rechte für die Bearbeitung der SVWS-Konfiguration haben.
      Parameter:
      schemaname - der Name des Schemas, dessen Flag angepasst werden soll
      state - der Status, auf den das Schema gesetzt werden soll (1=deaktiviert, 0=aktiv)
      request - die Informationen zur HTTP-Anfrage
      Gibt zurück:
      Rückmeldung, ob die Operation erfolgreich war

    • migrateMDB2Schema

      @POST @Consumes("multipart/form-data") @Path("/api/schema/root/migrate/mdb/{schema}") public jakarta.ws.rs.core.Response migrateMDB2Schema(@PathParam("schema") String schemaname, DBMultipartBody multipart, @Context jakarta.servlet.http.HttpServletRequest request)
      Die OpenAPI-Methode für das Migrieren einer MDB in ein Schema mit angegebenen Namen.
      Parameter:
      schemaname - Name des Schemas, in das hinein migriert werden soll
      multipart - Daten der MDB, MDB-Datenbankkennwort, DB-Username und Passwort
      request - die Informationen zur HTTP-Anfrage
      Gibt zurück:
      Rückmeldung, ob die Operation erfolgreich war

    • importSQLite2Schema

      @POST @Consumes("multipart/form-data") @Path("/api/schema/root/import/sqlite/{schema}") public jakarta.ws.rs.core.Response importSQLite2Schema(@PathParam("schema") String schemaname, DBMultipartBody multipart, @Context jakarta.servlet.http.HttpServletRequest request)
      Die OpenAPI-Methode für den Import einer SQLite-Datenbank in ein Schema mit dem angegebenen Namen.
      Parameter:
      schemaname - Name des Schemas, in das hinein migriert werden soll
      multipart - SQLite-Datenbank im Binärformat, DB-Username und Passwort für das neue Schema
      request - die Informationen zur HTTP-Anfrage
      Gibt zurück:
      Rückmeldung, ob die Operation erfolgreich war mit dem Log der Operation

    • migrateMariaDB2Schema

      @POST @Path("/api/schema/root/migrate/mariadb/{schema}") public jakarta.ws.rs.core.Response migrateMariaDB2Schema(@PathParam("schema") String schemaname, MigrateBody dbMigrationInfos, @Context jakarta.servlet.http.HttpServletRequest request)
      Die OpenAPI-Methode für das Migrieren einer bestehenden MariaDB in ein Schema mit angegebenen Namen.
      Parameter:
      schemaname - Name des Schemas, in das hinein migriert werden soll
      dbMigrationInfos - Zugangsdaten zur MariaDB, Name des Schema, das angelegt werden soll, Schmea-Username und Passwort
      request - die Informationen zur HTTP-Anfrage
      Gibt zurück:
      Rückmeldung, ob die Operation erfolgreich war

    • migrateMariaDB2SchemaSchulnummer

      @POST @Path("/api/schema/root/migrate/mariadb/{schema}/{schulnummer:\\d{6}}") public jakarta.ws.rs.core.Response migrateMariaDB2SchemaSchulnummer(@PathParam("schema") String schemaname, @PathParam("schulnummer") int schulnummer, MigrateBody dbMigrationInfos, @Context jakarta.servlet.http.HttpServletRequest request)
      Die OpenAPI-Methode für das Migrieren aus einer Schild2-MariaDB-Datenbank in ein Schema mit angegebenen Namen, wobei nur Daten für die angegebene Schulnummer übertragen werden.
      Parameter:
      schemaname - Name des Schemas, in das hinein migriert werden soll
      schulnummer - die Schulnummer, für die die Migration durchgeführt wird.
      dbMigrationInfos - Zugangsdaten zur MariaDB, Name des Schema, das angelegt werden soll, Schmea-Username und Passwort
      request - die Informationen zur HTTP-Anfrage
      Gibt zurück:
      Rückmeldung, ob die Operation erfolgreich war

    • migrateMySQL2Schema

      @POST @Path("/api/schema/root/migrate/mysql/{schema}") public jakarta.ws.rs.core.Response migrateMySQL2Schema(@PathParam("schema") String schemaname, MigrateBody dbMigrationInfos, @Context jakarta.servlet.http.HttpServletRequest request)
      Die OpenAPI-Methode für das Migrieren einer bestehenden MySQL in ein Schema mit angegebenen Namen.
      Parameter:
      schemaname - Name des Schemas, in das hinein migriert werden soll
      dbMigrationInfos - Zugangsdaten zur MySQL, Name des Schema, das angelegt werden soll, Schmea-Username und Passwort
      request - die Informationen zur HTTP-Anfrage
      Gibt zurück:
      Rückmeldung, ob die Operation erfolgreich war

    • migrateMySQL2SchemaSchulnummer

      @POST @Path("/api/schema/root/migrate/mysql/{schema}/{schulnummer:\\d{6}}") public jakarta.ws.rs.core.Response migrateMySQL2SchemaSchulnummer(@PathParam("schema") String schemaname, @PathParam("schulnummer") int schulnummer, MigrateBody dbMigrationInfos, @Context jakarta.servlet.http.HttpServletRequest request)
      Die OpenAPI-Methode für das Migrieren aus einer Schild2-MySQL-Datenbank in ein Schema mit angegebenen Namen, wobei nur Daten für die angegebene Schulnummer übertragen werden.
      Parameter:
      schemaname - Name des Schemas, in das hinein migriert werden soll
      schulnummer - die Schulnummer, für die die Migration durchgeführt wird.
      dbMigrationInfos - Zugangsdaten zur MySQL, Name des Schema, das angelegt werden soll, Schmea-Username und Passwort
      request - die Informationen zur HTTP-Anfrage
      Gibt zurück:
      Rückmeldung, ob die Operation erfolgreich war

    • migrateMSSQL2Schema

      @POST @Path("/api/schema/root/migrate/mssql/{schema}") public jakarta.ws.rs.core.Response migrateMSSQL2Schema(@PathParam("schema") String schemaname, MigrateBody dbMigrationInfos, @Context jakarta.servlet.http.HttpServletRequest request)
      Die OpenAPI-Methode für das Migrieren einer bestehenden MSSQL in ein Schema mit angegebenen Namen.
      Parameter:
      schemaname - Name des Schemas, in das hinein migriert werden soll
      dbMigrationInfos - Zugangsdaten zur MSSQL, Name des Schema, das angelegt werden soll, Schmea-Username und Passwort
      request - die Informationen zur HTTP-Anfrage
      Gibt zurück:
      Rückmeldung, ob die Operation erfolgreich war

    • migrateMSSQL2SchemaSchulnummer

      @POST @Path("/api/schema/root/migrate/mssql/{schema}/{schulnummer:\\d{6}}") public jakarta.ws.rs.core.Response migrateMSSQL2SchemaSchulnummer(@PathParam("schema") String schemaname, @PathParam("schulnummer") int schulnummer, MigrateBody dbMigrationInfos, @Context jakarta.servlet.http.HttpServletRequest request)
      Die OpenAPI-Methode für das Migrieren aus einer Schild2-MSSQL-Datenbank in ein Schema mit angegebenen Namen, wobei nur Daten für die angegebene Schulnummer übertragen werden.
      Parameter:
      schemaname - Name des Schemas, in das hinein migriert werden soll
      schulnummer - die Schulnummer, für die die Migration durchgeführt wird.
      dbMigrationInfos - Zugangsdaten zur MSSQL, Name des Schema, das angelegt werden soll, Schmea-Username und Passwort
      request - die Informationen zur HTTP-Anfrage
      Gibt zurück:
      Rückmeldung, ob die Operation erfolgreich war

    • exportSQLiteFrom

      @GET @Produces("application/vnd.sqlite3") @Path("/api/schema/export/{schema}/sqlite") public jakarta.ws.rs.core.Response exportSQLiteFrom(@PathParam("schema") String schemaname, @Context jakarta.servlet.http.HttpServletRequest request)
      Die OpenAPI-Methode für den Export einer SQLite-Datenbank aus einem Schema. Der Aufruf erfordert einen Datenbank-Benutzer mit den entsprechenden Rechten.
      Parameter:
      schemaname - Name des Schemas, welches exportiert werden soll.
      request - die Informationen zur HTTP-Anfrage
      Gibt zurück:
      Die SQLite-Datenbank

    • importSQLiteInto

      @POST @Consumes("multipart/form-data") @Path("/api/schema/import/{schema}/sqlite") public jakarta.ws.rs.core.Response importSQLiteInto(@PathParam("schema") String schemaname, DBMultipartBodyDataOnly multipart, @Context jakarta.servlet.http.HttpServletRequest request)
      Die OpenAPI-Methode für den Import einer SQLite-Datenbank aus dem angegebenen Schema. Der Aufruf erfordert einen Datenbank-Benutzer mit den entsprechenden Rechten. Die existierenden Daten in diesem Schema werden dabei entfernt und durch die Daten der SQLite-Datenbank ersetzt.
      Parameter:
      schemaname - Name des Schemas, auf welches die Abfrage ausgeführt wird und in das importiert werden soll
      multipart - Die SQLite-Datenbank
      request - die Informationen zur HTTP-Anfrage
      Gibt zurück:
      die Rückmeldung, ob die Operation erfolgreich war mit dem Log der Operation

    • migrateMDBInto

      @POST @Consumes("multipart/form-data") @Path("/api/schema/migrate/{schema}/mdb") public jakarta.ws.rs.core.Response migrateMDBInto(@PathParam("schema") String schemaname, DBMultipartBodyDataOnly multipart, @Context jakarta.servlet.http.HttpServletRequest request)
      Die OpenAPI-Methode für das Migrieren einer MDB in das angegebene Schema. Die existierenden Daten in diesem Schema werden dabei entfernt. Der Aufruf erfordert einen Datenbank-Benutzer mit den entsprechenden Rechten.
      Parameter:
      schemaname - Name des Schemas, auf welches die Abfrage ausgeführt wird und in das hinein migriert werden soll
      multipart - die Daten der MDB und das zugehörige Datenbankkennwort
      request - die Informationen zur HTTP-Anfrage
      Gibt zurück:
      die Rückmeldung, ob die Operation erfolgreich war mit dem Log der Operation

    • migrateMariaDBInto

      @POST @Path("/api/schema/migrate/{schema}/mariadb") public jakarta.ws.rs.core.Response migrateMariaDBInto(@PathParam("schema") String schemaname, DatenbankVerbindungsdaten verbindungsdaten, @Context jakarta.servlet.http.HttpServletRequest request)
      Die OpenAPI-Methode für das Migrieren einer bestehenden MariaDB in ein Schema mit angegebenen Namen. Die existierenden Daten in diesem Schema werden dabei entfernt. Der Aufruf erfordert einen Datenbank-Benutzer mit den entsprechenden Rechten.
      Parameter:
      schemaname - Name des Schemas, auf welches die Abfrage ausgeführt wird und in das hinein migriert werden soll
      verbindungsdaten - Die Verbindungsdaten zur MariaDB
      request - die Informationen zur HTTP-Anfrage
      Gibt zurück:
      die Rückmeldung, ob die Operation erfolgreich war mit dem Log der Operation

    • migrateMariaDBSchulnummerInto

      @POST @Path("/api/schema/migrate/{schema}/mariadb/{schulnummer:\\d{6}}") public jakarta.ws.rs.core.Response migrateMariaDBSchulnummerInto(@PathParam("schema") String schemaname, @PathParam("schulnummer") int schulnummer, DatenbankVerbindungsdaten verbindungsdaten, @Context jakarta.servlet.http.HttpServletRequest request)
      Die OpenAPI-Methode für das Migrieren einer bestehenden MariaDB in das angebenene Schema, wobei nur Daten für die angegebene Schulnummer übertragen werden. Die existierenden Daten in diesem Schema werden dabei entfernt. Der Aufruf erfordert einen Datenbank-Benutzer mit den entsprechenden Rechten.
      Parameter:
      schemaname - Name des Schemas, auf welches die Abfrage ausgeführt wird und in das hinein migriert werden soll
      schulnummer - die Schulnummer, für die die Migration durchgeführt wird.
      verbindungsdaten - Die Verbindungsdaten zur MariaDB
      request - die Informationen zur HTTP-Anfrage
      Gibt zurück:
      die Rückmeldung, ob die Operation erfolgreich war mit dem Log der Operation

    • migrateMySqlInto

      @POST @Path("/api/schema/migrate/{schema}/mysql") public jakarta.ws.rs.core.Response migrateMySqlInto(@PathParam("schema") String schemaname, DatenbankVerbindungsdaten verbindungsdaten, @Context jakarta.servlet.http.HttpServletRequest request)
      Die OpenAPI-Methode für das Migrieren einer bestehenden MySQL-Datenbank in das angebenene Schema. Die existierenden Daten in diesem Schema werden dabei entfernt. Der Aufruf erfordert einen Datenbank-Benutzer mit den entsprechenden Rechten.
      Parameter:
      schemaname - Name des Schemas, auf welches die Abfrage ausgeführt wird und in das hinein migriert werden soll
      verbindungsdaten - Die Verbindungsdaten zur MySQL-Datenbank
      request - die Informationen zur HTTP-Anfrage
      Gibt zurück:
      die Rückmeldung, ob die Operation erfolgreich war mit dem Log der Operation

    • migrateMySqlSchulnummerInto

      @POST @Path("/api/schema/migrate/{schema}/mysql/{schulnummer:\\d{6}}") public jakarta.ws.rs.core.Response migrateMySqlSchulnummerInto(@PathParam("schema") String schemaname, @PathParam("schulnummer") int schulnummer, DatenbankVerbindungsdaten verbindungsdaten, @Context jakarta.servlet.http.HttpServletRequest request)
      Die OpenAPI-Methode für das Migrieren einer bestehenden MySQL-Datenbank in das angebene Schema, wobei nur Daten für die angegebene Schulnummer übertragen werden. Die existierenden Daten in diesem Schema werden dabei entfernt. Der Aufruf erfordert einen Datenbank-Benutzer mit den entsprechenden Rechten.
      Parameter:
      schemaname - Name des Schemas, auf welches die Abfrage ausgeführt wird und in das hinein migriert werden soll
      schulnummer - die Schulnummer, für die die Migration durchgeführt wird.
      verbindungsdaten - Die Verbindungsdaten zur MySQL-Datenbank
      request - die Informationen zur HTTP-Anfrage
      Gibt zurück:
      die Rückmeldung, ob die Operation erfolgreich war mit dem Log der Operation

    • migrateMsSqlServerInto

      @POST @Path("/api/schema/migrate/{schema}/mssql") public jakarta.ws.rs.core.Response migrateMsSqlServerInto(@PathParam("schema") String schemaname, DatenbankVerbindungsdaten verbindungsdaten, @Context jakarta.servlet.http.HttpServletRequest request)
      Die OpenAPI-Methode für das Migrieren einer bestehenden SQL-Server-Datenbank in das angegebene Schema. Die existierenden Daten in diesem Schema werden dabei entfernt. Der Aufruf erfordert einen Datenbank-Benutzer mit den entsprechenden Rechten.
      Parameter:
      schemaname - Name des Schemas, auf welches die Abfrage ausgeführt wird und in das hinein migriert werden soll
      verbindungsdaten - Die Verbindungsdaten zur SQL-Server-Datenbank
      request - die Informationen zur HTTP-Anfrage
      Gibt zurück:
      die Rückmeldung, ob die Operation erfolgreich war mit dem Log der Operation

    • migrateMsSqlServerSchulnummerInto

      @POST @Path("/api/schema/migrate/{schema}/mssql/{schulnummer:\\d{6}}") public jakarta.ws.rs.core.Response migrateMsSqlServerSchulnummerInto(@PathParam("schema") String schemaname, @PathParam("schulnummer") int schulnummer, DatenbankVerbindungsdaten verbindungsdaten, @Context jakarta.servlet.http.HttpServletRequest request)
      Die OpenAPI-Methode für das Migrieren einer bestehenden SQL-Server-Datenbank in ein Schema mit angegebenen Namen, wobei nur Daten für die angegebene Schulnummer übertragen werden. Die existierenden Daten in diesem Schema werden dabei entfernt. Der Aufruf erfordert einen Datenbank-Benutzer mit den entsprechenden Rechten.
      Parameter:
      schemaname - Name des Schemas, auf welches die Abfrage ausgeführt wird und in das hinein migriert werden soll
      schulnummer - die Schulnummer, für die die Migration durchgeführt wird.
      verbindungsdaten - Die Verbindungsdaten zur SQL-Server-Datenbank
      request - die Informationen zur HTTP-Anfrage
      Gibt zurück:
      die Rückmeldung, ob die Operation erfolgreich war mit dem Log der Operation

    • createSchemaInto

      @POST @Path("/api/schema/create/{schema}/{revision : \\d+}") public jakarta.ws.rs.core.Response createSchemaInto(@PathParam("schema") String schemaname, @PathParam("revision") long revision, @Context jakarta.servlet.http.HttpServletRequest request)
      Die OpenAPI-Methode für das Anlegen eines SVWSM-Schemas in der angegebenen Revision in dem Schema mit angegebenem Namen. Der zur Authentifizierung verwendete Datenbank-Benutzer muss die nötigen Rechte haben.
      Parameter:
      schemaname - der Name des Schemas, das angelegt werden soll
      revision - die Revisionsnummer, auf die das Schema angehoben werden soll
      request - die Informationen zur HTTP-Anfrage
      Gibt zurück:
      die HTTP-Response

    • createSchemaCurrentInto

      @POST @Path("/api/schema/create/{schema}") public jakarta.ws.rs.core.Response createSchemaCurrentInto(@PathParam("schema") String schemaname, @Context jakarta.servlet.http.HttpServletRequest request)
      Die OpenAPI-Methode für das Anlegen eines SVWSM-Schemas in der aktuellen Revision in dem Schema mit angegebenem Namen. Der zur Authentifizierung verwendete Datenbank-Benutzer muss die nötigen Rechte haben.
      Parameter:
      schemaname - der Name des Schemas, das angelegt werden soll
      request - die Informationen zur HTTP-Anfrage
      Gibt zurück:
      die HTTP-Response

    • updateSchema

      @POST @Path("/api/schema/update/{schema}/{revision : \\d+}") public jakarta.ws.rs.core.Response updateSchema(@PathParam("schema") String schemaname, @PathParam("revision") long revision, @Context jakarta.servlet.http.HttpServletRequest request)
      Die OpenAPI-Methode um ein Datenbankschema auf eine bestimmte Revision upzudaten.
      Parameter:
      schemaname - das Datenbankschema, auf welches die Abfrage ausgeführt werden soll
      revision - die Revision, auf die angehoben werden soll
      request - die Informationen zur HTTP-Anfrage
      Gibt zurück:
      Logmeldung über den Updatevorgang

    • updateSchemaToCurrent

      @POST @Path("/api/schema/update/{schema}") public jakarta.ws.rs.core.Response updateSchemaToCurrent(@PathParam("schema") String schemaname, @Context jakarta.servlet.http.HttpServletRequest request)
      Die OpenAPI-Methode um ein Datenbankschema auf die neueste Revision upzudaten.
      Parameter:
      schemaname - das Datenbankschema, auf welches die Abfrage ausgeführt werden soll
      request - die Informationen zur HTTP-Anfrage
      Gibt zurück:
      Logmeldung über den Updatevorgang

    • initSchemaMitSchule

      @POST @Path("/api/schema/create/{schema}/init/{schulnummer : \\d+}") public jakarta.ws.rs.core.Response initSchemaMitSchule(@PathParam("schema") String schema, @PathParam("schulnummer") int schulnummer, @Context jakarta.servlet.http.HttpServletRequest request)
      Die OpenAPI-Methode für das Initialisieren des Schema mit einer Schulnummer. Es wird vorausgesetzt, dass bisher keine Schulnummer in dem Schema festgelegt wurde und dass es sich um ein SVWS-Schema handelt.
      Parameter:
      schema - das SVWS-Datenbankschema, in welchem die Schule angelegt wird
      schulnummer - die Schulnummer
      request - die Informationen zur HTTP-Anfrage
      Gibt zurück:
      die HTTP-Antwort mit den neuen Schulstammdaten

    • importExistingSchema

      @POST @Path("/api/schema/root/import/existing/{schema}") public jakarta.ws.rs.core.Response importExistingSchema(@PathParam("schema") String schema, BenutzerKennwort kennwort, @Context jakarta.servlet.http.HttpServletRequest request)
      Die OpenAPI-Methode für das Hinzufügen eines bestehenden SVWS-Schemas zu der SVWS-Konfiguration.
      Parameter:
      schema - das SVWS-Datenbankschema, welches hinzugefügt wird
      kennwort - Benutzername und Kennwort eines Benutzers mit vollen Rechten auf das Schema
      request - die Informationen zur HTTP-Anfrage
      Gibt zurück:
      die HTTP-Antwort