GS-2555

alex

10 hours ago a82027a51a3056e574b9c6c8941a7a16f5841126

 lib/db.js

@@ -58,8 +58,8 @@

   setStatus,

   getCourseAdmins,
   getCoursesWithNoAdmins,
   getCourseAdminRoles,
   getCourseWithoutAdminRoles,
}

/////////////////////////////////////////////////////////////////////////
@@ -421,81 +421,6 @@
      return data
   }

   // const teilnehmer = await getKursTeilnehmer(ref_id)
   // const tnUnter = await getKursUnterobjektLp(obj_id)
   // console.table(teilnehmer)
   // console.table(tnUnter)
   //
   // /**
   //  * Die beiden Datensätze mergen
   //  * NEIN - es reicht der
   //  *
   //  */
   //
   // const idx = _.groupBy(tnUnter, "usr_id")
   // for (const tn of teilnehmer) {
   //     delete tn.parent_id
   //     delete tn.type
   //     delete tn.active
   //
   //     /** @type Array */
   //     const unter = idx[tn.usr_id]
   //     if (!unter) continue
   //
   //     /**
   //      * wenn unter.status_changed neuer, wird unter tn.status_changed vorgezogen
   //      * wenn unter.status neuer, überscheibt es tn.status
   //      * tn.passed muss zurückgesetzt werden wenn tn.status überschrieben wird
   //      */
   //     tn.status_overwrite = false
   //
   //     // max unter status_changed finden
   //     const unterStatusChanged = _.max(unter.map(u => u.status_changed))
   //
   //     // es muss nur überschrieben werden wenn das Unterdatum größer ist
   //     if (unterStatusChanged > tn.status_changed) {
   //         // unter Status auswerten
   //         // 0 = noch nicht bearbeitet
   //         // 1 = in Bearbeitung
   //         // 2 = bestanden
   //         // 3 = nicht bestanden
   //
   //         /** @type Array */
   //         const unterStatusse = unter.map(u => u.status)
   //         let newStatus = tn.status
   //         const allSame = function () {
   //             if (!unterStatusse.length) return false
   //             const first = unterStatusse[0]
   //             return unterStatusse.every(it => it === first)
   //         }()
   //         console.log({unterStatusse})
   //         // Fall 1: keine Unterstatussse vorhanden -> status vom Kurs
   //         if (!unterStatusse.length) {
   //             newStatus = tn.status
   //         }
   //         // Fall 2: eines nicht bestanden -> nicht bestanden // 0,1,2,3 -> 3
   //         if (unterStatusse.some(u => u === 3)) {
   //             newStatus = 3
   //         }
   //         // Fall 3: alle statusse gleich -> status // 0,0,0 1,1,1 2,2,2 3,3,3
   //         else if (allSame) {
   //             newStatus = unterStatusse[0]
   //         }
   //         // Fall 4: wenn eines in Bearbeitung -> in Bearbeitung // 0,1,0 2,1,2
   //         else if (unterStatusse.some(u => u === 1)) {
   //             newStatus = 1
   //         }
   //         // Fall 5: sonst in Bearbeitung
   //         else {
   //             // newStatus = Math.max.apply(this, unterStatusse)
   //             newStatus = 1
   //         }
   //         tn.status_changed = unterStatusChanged
   //         tn.status = newStatus
   //         tn.status_overwrite = true
   //     }
   // }
   // return teilnehmer
}

async function getKursUnterobjektLp(obj_id) {
@@ -680,50 +605,87 @@

/////// ADMINS ////////////////////////////////////////////////////////////////

async function getCourseAdmins() {

async function getCourseAdminRoles() {
   const pool = await poolP
   const q = `SELECT om.obj_id as kurs_obj_id,
                     t.ref_id  as kurs_ref_id,
                     om.usr_id,
                     ud.login,
                     om.admin,
                     ud.firstname,
                     ud.lastname,
                     od2.title
              FROM ${database}.obj_members om
                       INNER JOIN ${database}.usr_data ud ON ud.usr_id = om.usr_id
                       INNER JOIN ${database}.object_data od2 ON od2.obj_id = om.obj_id
                       INNER JOIN ${database}.object_reference t ON t.obj_id = om.obj_id
              WHERE om.admin = 1
   const q = `
       SELECT od.obj_id as crs_obj_id, t.ref_id as crs_ref_id, od.title as crs_title, rf.rol_id, od2.title as role
       FROM ${database}.object_data od
                INNER JOIN ${database}.object_reference t ON t.obj_id = od.obj_id
                INNER JOIN ${database}.rbac_fa rf ON rf.parent = t.ref_id
                INNER JOIN ${database}.object_data od2 ON od2.obj_id = rf.rol_id
       WHERE od.\`type\` = "crs"
         AND od2.title LIKE "%admin%"
         AND t.deleted is NULL
   `
   const [results] = await pool.query(q)
   return results
}

/**
 * Liefert die Kurse ohne Admins
 * Admins hier definiert als Einträge in obj_members wo admin==1
 * Darüber hinaus gibt es offenbar noch einen anderen Mechanismus über die Rolle.
 * Denn ein Kurs ohne Admin (z.B. lokal Fliesenratgeber ref_id=88) hat in ILIAS
 * trotzdem einen Admin im Screen "Members".
 * Dort wird wohl über die Rolle zugeordnet.
 *
 * Die Frage ist wo der Fehler GS-2333 auftritt.
 * Bei obj_members oder bei fehlender Rolle.
 * @return {Promise<*>}
 */
async function getCoursesWithNoAdmins() {
async function getCourseWithoutAdminRoles() {
   const pool = await poolP
   const q = `
       SELECT asdf.obj_id, t.ref_id, asdf.numTn, asdf.title
       FROM (SELECT om.obj_id, COUNT(*) as numTn, od.title, MAX(om.admin) as maxAdmin
             FROM ${database}.obj_members om
                      INNER JOIN ${database}.object_data od ON od.obj_id = om.obj_id
             GROUP by om.obj_id
             ORDER BY numTn DESC) asdf
                INNER JOIN ${database}.object_reference t ON t.obj_id = asdf.obj_id
       WHERE asdf.maxAdmin = 0
       SELECT adminRoles.crs_obj_id, adminRoles.crs_ref_id, adminRoles.crs_title, adminRoles.rol_id, adminRoles.role
       FROM (SELECT od.obj_id as crs_obj_id, t.ref_id as crs_ref_id, od.title as crs_title, rf.rol_id, od2.title as role
             FROM ${database}.object_data od
                      INNER JOIN ${database}.object_reference t ON t.obj_id = od.obj_id
                      INNER JOIN ${database}.rbac_fa rf ON rf.parent = t.ref_id
                      INNER JOIN ${database}.object_data od2 ON od2.obj_id = rf.rol_id
             WHERE od.\`type\` = "crs"
               AND od2.title LIKE "%admin%"
               AND t.deleted is NULL) adminRoles
       WHERE adminRoles.rol_id NOT IN (SELECT ru2.rol_id
                                       FROM ${database}.rbac_ua ru2)
   `
   const [results] = await pool.query(q)
   return results
}

// !! wird nicht gebraucht - Admin Erkennung in ILIAS läuft anders ab - über die Rolle
// async function getCourseAdmins() {
//    const pool = await poolP
//    const q = `SELECT om.obj_id as kurs_obj_id,
//                      t.ref_id  as kurs_ref_id,
//                      om.usr_id,
//                      ud.login,
//                      om.admin,
//                      ud.firstname,
//                      ud.lastname,
//                      od2.title
//               FROM ${database}.obj_members om
//                        INNER JOIN ${database}.usr_data ud ON ud.usr_id = om.usr_id
//                        INNER JOIN ${database}.object_data od2 ON od2.obj_id = om.obj_id
//                        INNER JOIN ${database}.object_reference t ON t.obj_id = om.obj_id
//               WHERE om.admin = 1
//    `
//    const [results] = await pool.query(q)
//    return results
// }
//
// /**
//  * Liefert die Kurse ohne Admins
//  * Admins hier definiert als Einträge in obj_members wo admin==1
//  * Darüber hinaus gibt es offenbar noch einen anderen Mechanismus über die Rolle.
//  * Denn ein Kurs ohne Admin (z.B. lokal Fliesenratgeber ref_id=88) hat in ILIAS
//  * trotzdem einen Admin im Screen "Members".
//  * Dort wird wohl über die Rolle zugeordnet.
//  *
//  * Die Frage ist wo der Fehler GS-2333 auftritt.
//  * Bei obj_members oder bei fehlender Rolle.
//  * @return {Promise<*>}
//  */
// async function getCoursesWithNoAdmins() {
//    const pool = await poolP
//    const q = `
//        SELECT asdf.obj_id, t.ref_id, asdf.numTn, asdf.title
//        FROM (SELECT om.obj_id, COUNT(*) as numTn, od.title, MAX(om.admin) as maxAdmin
//              FROM ${database}.obj_members om
//                       INNER JOIN ${database}.object_data od ON od.obj_id = om.obj_id
//              GROUP by om.obj_id
//              ORDER BY numTn DESC) asdf
//                 INNER JOIN ${database}.object_reference t ON t.obj_id = asdf.obj_id
//        WHERE asdf.maxAdmin = 0
//    `
//    const [results] = await pool.query(q)
//    return results
// }