A new start

script/mission/manager.js

@@ -0,0 +1,182 @@
+$(document).ready(function () {
+    console.log("Manager load");
+    //setInterval(ADis_GetAvailableMissions, 600000); // update availabla missions every 10 minutes
+    ADis_GetAvailableMissions(); // get availabla missions after page ready
+});
+
+
+//  - -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- --
+//  -
+//  -                   Grab Mission-Configuration from GitHub
+//  -
+//  - -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- --
+
+function ADis_GetAvailableMissions() {
+    // Get all available missions with there config
+    //$.getJSON(AutomaticDispose_URL + AutomaticDispose_Branch + "/all_missions.json", function (Response) {
+    for (let i in ADis_AllMissions) {
+        Mission = ADis_AllMissions[i];
+        ADis_AddAvailableMissions(Mission);
+    }
+    //});
+}
+
+function ADis_CollectMissions() {
+    return ADisDB.transaction('rw', [ADisDB.ADisMissionsOwn, ADisDB.ADisSettings, ADisDB.ADisAvailabelMissions], () => {
+        ADisSettings().then((setting) => {
+            if (setting['MissionsOwn-Automatic'] == 'true') {
+                return ADisDB.ADisMissionsOwn.where({
+                    done: 'false'
+                }).limit(1)
+            }
+        }).then((Missions) => {
+            if (Missions === undefined) {
+                return;
+            }
+            return Missions.count(function (count) {
+                if (count > 0) {
+                    return Missions.each(async (Mission) => {
+                        return await ADisDB.ADisAvailabelMissions.get({
+                            type: Mission.type
+                        }).then((available) => {
+                            if (available == undefined) {
+                                ADis_RemoveMissionFromQueue(Mission.missionID);
+                            }
+                        }).then(() => {
+                            if ($("#mission_" + Mission.missionID).length == 0) {
+                                return ADis_RemoveMissionFromQueue(Mission.missionID);
+
+                            }
+                        }).then(() => {
+
+                            if ($("#mission_" + Mission.missionID).css("display") == "none") {
+                                return ADis_RemoveMissionFromQueue(Mission.missionID);
+
+                            }
+                        }).then(() => {
+
+                            $("#mission_" + Mission.id).animate({
+                                opacity: 0.5
+                            }, 500);
+                        });
+                    });
+                }
+            })
+        }).then(() => {
+            $("#mission_list").find(".missionSideBarEntry").each(async function () {
+                var MissionID = $(this).attr("mission_id");
+                // var MissionType = $(this).attr("mission_type_id");
+                // var MissionName = $(this).find(".map_position_mover").text();
+
+                //      - -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- --
+                //      -           Emergency Missions  |  Automatic
+                //      - -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- --
+                await ADis_AddMission(MissionID);
+
+            });
+        });
+    });
+}
+
+function ADis_AddMission(ID) {
+    return ADisSettings().then((setting) => {
+        if (setting['MissionsOwn-Automatic'] == 'true') {
+            return ADisDB.ADisMissionsOwn.where({
+                missionID: ID
+            }).limit(1)
+        }
+    }).then((Missions) => {
+        if (Missions === undefined) {
+            return;
+        }
+        return Missions.count(function (count) {
+            if (count > 0) {
+                return Missions.each((Mission) => {
+                    var MissionElement = $("#mission_" + ID);
+
+                    var MissionID = MissionElement.attr("mission_id");
+                    var MissionType = MissionElement.attr("mission_type_id");
+                    var addr = MissionElement.find(".map_position_mover").text().split(",")
+                    var MissionName = addr[0];
+                    var MissionStreet = addr[1];
+                    var MissionVillage = addr[2];
+
+                    return ADisDB.ADisAvailabelMissions.get({
+                        type: MissionType
+                    }).then((available) => {
+                        return ADis_AddMissionToQueue({
+                            "id": MissionID,
+                            "type": MissionType,
+                            "name": MissionName,
+                            "street": MissionStreet,
+                            "village": MissionVillage,
+                            "available": (available !== undefined),
+                            "done": false,
+                            "last_check": Math.floor(new Date().getTime() / 1000),
+                            "next_check": Math.floor(new Date().getTime() / 1000) + 1
+                        });
+                    });
+                });
+            } else {
+                var MissionElement = $("#mission_" + ID);
+
+                var MissionID = MissionElement.attr("mission_id");
+                var MissionType = MissionElement.attr("mission_type_id");
+                var addr = MissionElement.find(".map_position_mover").text().split(",")
+                var MissionName = addr[0];
+                var MissionStreet = addr[1];
+                var MissionVillage = addr[2];
+
+                return ADisDB.ADisAvailabelMissions.get({
+                    type: MissionType
+                }).then((available) => {
+                    return ADis_AddMissionToQueue({
+                        "id": MissionID,
+                        "type": MissionType,
+                        "name": MissionName,
+                        "street": MissionStreet,
+                        "village": MissionVillage,
+                        "available": (available !== undefined),
+                        "done": false,
+                        "last_check": Math.floor(new Date().getTime() / 1000),
+                        "next_check": Math.floor(new Date().getTime() / 1000) + 1
+                    });
+                });
+            }
+        });
+    });
+
+}
+
+function ADis_AddAvailableMissions(Mission) {
+    return ADisDB.ADisAvailabelMissions.put({
+        missionID: Mission.id,
+        type: Mission.type,
+        name: Mission.name,
+        jsondata: Mission
+    }).catch((err) => {
+        console.error(err)
+    })
+}
+
+function ADis_AddMissionToQueue(Mission) {
+    return ADisDB.ADisMissionsOwn.put({
+        missionID: Mission.id,
+        type: Mission.type,
+        name: Mission.name,
+        available: Mission.available ? 'true' : 'false',
+        done: Mission.done ? 'true' : 'false',
+        street: Mission.street,
+        village: Mission.village,
+        last_check: Mission.last_check,
+        next_check: Mission.next_check
+    }).catch((err) => {
+        console.error(err)
+    });
+}
+
+function ADis_RemoveMissionFromQueue(MissionID) {
+    return ADisDB.ADisMissionsOwn.where({
+        missionID: MissionID
+    }).delete();
+}

script/mission/opener-krankentransporte.js

@@ -0,0 +1,130 @@
+$(document).ready(function () {
+    console.log('Krankentransporte geladen!');
+    setTimeout(ADis_OpenNextKrankentransporte, 5000);
+    setTimeout(ADis_CollectKrankentransporte, 500);
+});
+
+//  - -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- --
+//  -
+//  -           Collect Krankentransporte
+//  -
+//  - -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- --
+
+function ADis_CollectKrankentransporte() {
+
+    var observer2 = new MutationObserver(function (mutations) {
+        if (mutations[0].type == "childList") {
+            if (mutations[0].addedNodes.length >= 1) {
+                // do it here
+                for (var i = 0; i < mutations[0].addedNodes.length; i++)
+                    ADis_ReadAndAddKrankentransporte(mutations[0].addedNodes[i].attributes.getNamedItem("mission_id").value)
+            }
+        } else {
+            console.log("DEBUG Krankentransporte", mutations);
+        }
+    });
+
+    // Notify new alerts
+    var targetNode2 = document.getElementById("mission_list_krankentransporte");
+    observer2.observe(targetNode2, {
+        attributes: false,
+        //attributeFilter: ['class'],
+        //attributeOldValue: true,
+        characterData: false,
+        characterDataOldValue: false,
+        childList: true,
+        subtree: false
+    });
+
+    ADis_ReadAndAddKrankentransporte();
+}
+
+function ADis_ReadAndAddKrankentransporte(MissionID) {
+    if (typeof MissionID != "undefined") {
+        ADis_AddKrankentransportToQueue(MissionID);
+    } else {
+        $("#mission_list_krankentransporte").find(".missionSideBarEntry").each(function () {
+            MissionID = $(this).attr("mission_id");
+
+            //      - -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- --
+            //      -
+            //      -           Ambulance Service  |  Full-Automatic
+            //      - -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- --
+
+            ADis_AddKrankentransportToQueue(MissionID);
+        });
+    }
+}
+
+function ADis_OpenNextKrankentransporte() {
+    return ADisDB.transaction('rw', [ADisDB.ADisKrankentransport, ADisDB.ADisSettings, ADisDB.ADisAvailabelMissions], () => {
+        ADisSettings().then((setting) => {
+            if (setting['Krankentransport-Automatic'] == 'true') {
+                return ADisDB.ADisKrankentransport.where({
+                    done: 'false'
+                }).and(function (item) {
+                    return item.next_check <= Math.floor(new Date().getTime() / 1000)
+                }).limit(1)
+            }
+        }).then((Wunsch) => {
+            if (Wunsch !== undefined) {
+                return Wunsch.count(function (count) {
+                    if (count > 0) {
+                        return Wunsch.each((myWunsch) => {
+                            let MissionID = myWunsch.missionID;
+                            myWunsch.last_check = Math.floor(new Date().getTime() / 1000);
+                            myWunsch.next_check = Math.floor(new Date().getTime() / 1000) + 300;
+                            return ADis_UpdateKrankentransport(myWunsch).then(() => {
+                                if ($("#adis-krankentransporte-frame").attr("mission_id") == "empty") {
+                                    $("#adis-krankentransporte-frame").attr("src", "https://www.leitstellenspiel.de/missions/" + MissionID);
+                                    $("#adis-krankentransporte-frame").attr("mission_id", MissionID);
+
+                                    KrankentransportFrameWatchDog = setTimeout(async function () {
+                                        $("#adis-krankentransporte-frame").attr("src", "");
+                                        $("#adis-krankentransporte-frame").attr("mission_id", "empty");
+                                        setTimeout(ADis_OpenNextKrankentransporte, 1000);
+                                    }, 3500);
+                                }
+                            });
+                        });
+                    }
+                    return setTimeout(ADis_OpenNextKrankentransporte, 5000);
+                });
+            }
+            return setTimeout(ADis_OpenNextKrankentransporte, 5000);
+        });
+    });
+}
+
+
+window.ADis_AddKrankentransportToQueue = function ADis_AddKrankentransportToQueue(MissionID) {
+    return ADisDB.ADisKrankentransport.put({
+        missionID: MissionID,
+        last_check: Math.floor(new Date().getTime() / 1000),
+        next_check: Math.floor(new Date().getTime() / 1000) + 1,
+        done: 'false'
+    }).catch((err) => {
+        console.error(err)
+    });
+}
+
+window.ADis_UpdateKrankentransport = function ADis_UpdateKrankentransport(Mission) {
+    return ADisDB.ADisKrankentransport.put(Mission).catch((err) => {
+        console.error(err)
+    })
+}
+
+window.ADis_UpdateKrankentransportToDone = function ADis_UpdateKrankentransportToDone(MissionID) {
+    return ADisDB.ADisKrankentransport.update(MissionID, {
+        missionID: MissionID,
+        done: 'true'
+    }).catch((err) => {
+        console.error(err)
+    });
+}
+
+window.ADis_RemoveKrankentransportFromQueue = function ADis_RemoveKrankentransportFromQueue(MissionID) {
+    return ADisDB.ADisKrankentransport.where({
+        missionID: MissionID
+    }).delete();
+}

script/mission/opener-ownmission.js

@@ -0,0 +1,122 @@
+$(document).ready(function () {
+    setTimeout(ADis_OpenNextOwnMissions, 5000);
+    setTimeout(ADis_CollectOwnMissions, 500);
+});
+
+//  - -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- --
+//  -
+//  -           Collect Own Missions
+//  -
+//  - -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- --
+
+function ADis_CollectOwnMissions() {
+
+    var observer2 = new MutationObserver(function (mutations) {
+        if (mutations[0].type == "childList") {
+            if (mutations[0].addedNodes.length >= 1) {
+                // do it here
+                for (var i = 0; i < mutations[0].addedNodes.length; i++)
+                    ADis_ReadAndAddOwnMissions(mutations[0].addedNodes[i].attributes.getNamedItem("mission_id").value)
+            }
+        } else {
+            console.log("DEBUG OwnMissions", mutations);
+        }
+    });
+
+    // Notify new alerts
+    var targetNode2 = document.getElementById("mission_list");
+    observer2.observe(targetNode2, {
+        attributes: false,
+        //attributeFilter: ['class'],
+        //attributeOldValue: true,
+        characterData: false,
+        characterDataOldValue: false,
+        childList: true,
+        subtree: false
+    });
+
+    ADis_ReadAndAddOwnMissions();
+}
+
+function ADis_ReadAndAddOwnMissions(MissionID) {
+    if (typeof MissionID != "undefined") {
+        ADis_AddOwnMissionsToQueue(MissionID);
+    } else {
+        $("#mission_list").find(".missionSideBarEntry").each(function () {
+            MissionID = $(this).attr("mission_id");
+
+            //      - -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- --
+            //      -
+            //      -           Ambulance Service  |  Full-Automatic
+            //      - -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- --
+
+            ADis_AddOwnMissionsToQueue(MissionID);
+        });
+    }
+}
+
+function ADis_OpenNextOwnMissions() {
+    ADisSettings().then((setting) => {
+        if (setting['MissionsOwn-Automatic'] == 'true') {
+            return ADisDB.ADisMissionsOwn.where({
+                done: 'false'
+            }).and(function (item) {
+                return item.next_check <= Math.floor(new Date().getTime() / 1000)
+            }).limit(1)
+        }
+    }).then((Wunsch) => {
+        if (Wunsch !== undefined) {
+            return Wunsch.count(function (count) {
+                if (count > 0) {
+                    return Wunsch.each((myWunsch) => {
+                        let MissionID = myWunsch.missionID;
+                        myWunsch.next_check = Math.floor(new Date().getTime() / 1000) + 300;
+                        
+                        return ADis_UpdateOwnMissions(myWunsch).then(() => {
+                            if ($("#adis-ownmissions-frame").attr("mission_id") == "empty") {
+                                $("#adis-ownmissions-frame").attr("src", "https://www.leitstellenspiel.de/missions/" + MissionID);
+                                $("#adis-ownmissions-frame").attr("mission_id", MissionID);
+
+                                OwnMissionsFrameWatchDog = setTimeout(async function () {
+                                    ADis_RemoveOwnMissionsFromQueue(MissionID).then((deleteCount) => {
+                                        // TODO: tellParent("ADisMissionDone(" + window.name + "," + MissionID + ");");
+                                        $("#adis-ownmissions-frame").attr("src", "");
+                                        $("#adis-ownmissions-frame").attr("mission_id", "empty");
+                                        setTimeout(ADis_OpenNextOwnMissions, 1000);
+                                    });
+                                }, 5000);
+                            }
+                        });
+                    });
+                }
+                return setTimeout(ADis_OpenNextOwnMissions, 5000);
+            });
+        }
+        return setTimeout(ADis_OpenNextOwnMissions, 5000);
+    });
+}
+
+
+window.ADis_AddOwnMissionsToQueue = function ADis_AddOwnMissionsToQueue(MissionID) {
+    return ADisDB.ADisMissionsOwn.add({
+        missionID: MissionID,
+        done: 'false'
+    }).catch((err) => {})
+}
+
+window.ADis_UpdateOwnMissions = function ADis_UpdateOwnMissions(Mission) {
+    return ADisDB.ADisMissionsOwn.put(Mission).catch((err) => {})
+}
+
+window.ADis_UpdateOwnMissionsToDone = function ADis_UpdateOwnMissionsToDone(MissionID) {
+    return ADisDB.ADisMissionsOwn.update(MissionID, {
+        missionID: MissionID,
+        done: 'true'
+    }).catch((err) => {})
+}
+
+window.ADis_RemoveOwnMissionsFromQueue = function ADis_RemoveOwnMissionsFromQueue(MissionID) {
+    return ADisDB.ADisMissionsOwn.where({
+        missionID: MissionID
+    }).delete();
+}

script/mission/opener-plannedevents.js

@@ -0,0 +1,122 @@
+$(document).ready(function () {
+    setTimeout(ADis_OpenNextPlannedEvents, 5000);
+    setTimeout(ADis_CollectPlannedEvents, 500);
+});
+
+//  - -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- --
+//  -
+//  -           Collect Own Missions
+//  -
+//  - -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- --
+
+function ADis_CollectPlannedEvents() {
+
+    var observer2 = new MutationObserver(function (mutations) {
+        if (mutations[0].type == "childList") {
+            if (mutations[0].addedNodes.length >= 1) {
+                // do it here
+                for (var i = 0; i < mutations[0].addedNodes.length; i++)
+                    ADis_ReadAndAddPlannedEvents(mutations[0].addedNodes[i].attributes.getNamedItem("mission_id").value)
+            }
+        } else {
+            console.log("DEBUG PlannedEvents", mutations);
+        }
+    });
+
+    // Notify new alerts
+    var targetNode2 = document.getElementById("mission_list_sicherheitswache");
+    observer2.observe(targetNode2, {
+        attributes: false,
+        //attributeFilter: ['class'],
+        //attributeOldValue: true,
+        characterData: false,
+        characterDataOldValue: false,
+        childList: true,
+        subtree: false
+    });
+
+    ADis_ReadAndAddPlannedEvents();
+}
+
+function ADis_ReadAndAddPlannedEvents(MissionID) {
+    if (typeof MissionID != "undefined") {
+        ADis_AddPlannedEventsToQueue(MissionID);
+    } else {
+        $("#mission_list_sicherheitswache").find(".missionSideBarEntry").each(function () {
+            MissionID = $(this).attr("mission_id");
+
+            //      - -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- --
+            //      -
+            //      -           Ambulance Service  |  Full-Automatic
+            //      - -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- --
+
+            ADis_AddPlannedEventsToQueue(MissionID);
+        });
+    }
+}
+
+function ADis_OpenNextPlannedEvents() {
+    ADisSettings().then((setting) => {
+        if (setting['MissionsOwn-Automatic'] == 'true') {
+            return ADisDB.ADisMissionsOwn.where({
+                done: 'false'
+            }).and(function (item) {
+                return item.next_check > Math.floor(new Date().getTime() / 1000)
+            }).limit(1)
+        }
+    }).then((Wunsch) => {
+        if (Wunsch !== undefined) {
+            return Wunsch.count(function (count) {
+                if (count > 0) {
+                    return Wunsch.each((myWunsch) => {
+                        let MissionID = myWunsch.missionID;
+                        myWunsch.next_check = Math.floor(new Date().getTime() / 1000) + 300;
+
+                        return ADis_UpdatePlannedEvents(myWunsch).then(() => {
+                            if ($("#adis-plannedevents-frame").attr("mission_id") == "empty") {
+                                $("#adis-plannedevents-frame").attr("src", "https://www.leitstellenspiel.de/missions/" + MissionID);
+                                $("#adis-plannedevents-frame").attr("mission_id", MissionID);
+
+                                PlannedEventsFrameWatchDog = setTimeout(async function () {
+                                    ADis_RemovePlannedEventsFromQueue(MissionID).then((deleteCount) => {
+                                        // TODO: tellParent("ADisMissionDone(" + window.name + "," + MissionID + ");");
+                                        $("#adis-plannedevents-frame").attr("src", "");
+                                        $("#adis-plannedevents-frame").attr("mission_id", "empty");
+                                        setTimeout(ADis_OpenNextPlannedEvents, 1000);
+                                    });
+                                }, 5000);
+                            }
+                        });
+                    });
+                }
+                return setTimeout(ADis_OpenNextPlannedEvents, 5000);
+            });
+        }
+        return setTimeout(ADis_OpenNextPlannedEvents, 5000);
+    });
+}
+
+
+window.ADis_AddPlannedEventsToQueue = function ADis_AddPlannedEventsToQueue(MissionID) {
+    return ADisDB.ADisMissionsOwn.add({
+        missionID: MissionID,
+        done: 'false'
+    }).catch((err) => {})
+}
+
+window.ADis_UpdatePlannedEvents = function ADis_UpdatePlannedEvents(Mission) {
+    return ADisDB.ADisMissionsOwn.put(Mission).catch((err) => {})
+}
+
+window.ADis_UpdatePlannedEventsToDone = function ADis_UpdatePlannedEventsToDone(MissionID) {
+    return ADisDB.ADisMissionsOwn.update(MissionID, {
+        missionID: MissionID,
+        done: 'true'
+    }).catch((err) => {})
+}
+
+window.ADis_RemovePlannedEventsFromQueue = function ADis_RemovePlannedEventsFromQueue(MissionID) {
+    return ADisDB.ADisMissionsOwn.where({
+        missionID: MissionID
+    }).delete();
+}

script/mission/opener-verbandevents.js

@@ -0,0 +1,118 @@
+$(document).ready(function () {
+    setTimeout(ADis_OpenNextVerbandEvents, 5000);
+    setTimeout(ADis_CollectVerbandEvents, 500);
+});
+
+//  - -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- --
+//  -
+//  -           Collect Verband Missions
+//  -
+//  - -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- --
+
+function ADis_CollectVerbandEvents() {
+
+    var observer2 = new MutationObserver(function (mutations) {
+        if (mutations[0].type == "childList") {
+            if (mutations[0].addedNodes.length >= 1) {
+                // do it here
+                for (var i = 0; i < mutations[0].addedNodes.length; i++)
+                    ADis_ReadAndAddVerbandEvents(mutations[0].addedNodes[i].attributes.getNamedItem("mission_id").value)
+            }
+        } else {
+            console.log("DEBUG VerbandEvents", mutations);
+        }
+    });
+
+    // Notify new alerts
+    var targetNode2 = document.getElementById("mission_list_alliance_event");
+    observer2.observe(targetNode2, {
+        attributes: false,
+        //attributeFilter: ['class'],
+        //attributeOldValue: true,
+        characterData: false,
+        characterDataOldValue: false,
+        childList: true,
+        subtree: false
+    });
+
+    ADis_ReadAndAddVerbandEvents();
+}
+
+function ADis_ReadAndAddVerbandEvents(MissionID) {
+    if (typeof MissionID != "undefined") {
+        ADis_AddVerbandEventsToQueue(MissionID);
+    } else {
+        $("#mission_list_alliance_event").find(".missionSideBarEntry").each(function () {
+            MissionID = $(this).attr("mission_id");
+
+            //      - -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- --
+            //      -
+            //      -           Ambulance Service  |  Full-Automatic
+            //      - -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- --
+
+            ADis_AddVerbandEventsToQueue(MissionID);
+        });
+    }
+}
+
+function ADis_OpenNextVerbandEvents() {
+    ADisSettings().then((setting) => {
+        if (setting['AllianceEvent-Automatic'] == 'true') {
+            return ADisDB.ADisMissionsVerbandEvent.where({
+                done: 'false'
+            }).limit(1)
+        }
+    }).then((Wunsch) => {
+        if (Wunsch !== undefined) {
+            return Wunsch.count(function (count) {
+                if (count > 0) {
+                    return Wunsch.each((myWunsch) => {
+                        let MissionID = myWunsch.missionID;
+                        return ADis_UpdateVerbandEventsToDone(MissionID).then(() => {
+                            if ($("#adis-verbandmission-frame").attr("mission_id") == "empty") {
+                                $("#adis-verbandmission-frame").attr("src", "https://www.leitstellenspiel.de/missions/" + MissionID);
+                                $("#adis-verbandmission-frame").attr("mission_id", MissionID);
+
+                                VerbandEventsFrameWatchDog = setTimeout(async function () {
+                                    ADis_RemoveVerbandEventsFromQueue(MissionID).then((deleteCount) => {
+                                        // TODO: tellParent("ADisMissionDone(" + window.name + "," + MissionID + ");");
+                                        $("#adis-verbandmission-frame").attr("src", "");
+                                        $("#adis-verbandmission-frame").attr("mission_id", "empty");
+                                        setTimeout(ADis_OpenNextVerbandEvents, 1000);
+                                    });
+                                }, 5000);
+                            }
+                        });
+                    });
+                }
+                return setTimeout(ADis_OpenNextVerbandEvents, 5000);
+            });
+        }
+        return setTimeout(ADis_OpenNextVerbandEvents, 5000);
+    });
+}
+
+
+window.ADis_AddVerbandEventsToQueue = function ADis_AddVerbandEventsToQueue(MissionID) {
+    return ADisDB.ADisMissionsVerbandEvent.add({
+        missionID: MissionID,
+        done: 'false'
+    }).catch((err) => {})
+}
+
+window.ADis_UpdateVerbandEvents = function ADis_UpdateVerbandEvents(Mission) {
+    return ADisDB.ADisMissionsVerbandEvent.put(Mission).catch((err) => {})
+}
+
+window.ADis_UpdateVerbandEventsToDone = function ADis_UpdateVerbandEventsToDone(MissionID) {
+    return ADisDB.ADisMissionsVerbandEvent.update(MissionID, {
+        missionID: MissionID,
+        done: 'true'
+    }).catch((err) => {})
+}
+
+window.ADis_RemoveVerbandEventsFromQueue = function ADis_RemoveVerbandEventsFromQueue(MissionID) {
+    return ADisDB.ADisMissionsVerbandEvent.where({
+        missionID: MissionID
+    }).delete();
+}

script/mission/opener-verbandmissions.js

@@ -0,0 +1,118 @@
+$(document).ready(function () {
+    setTimeout(ADis_OpenNextVerbandMissions, 5000);
+    setTimeout(ADis_CollectVerbandMissions, 500);
+});
+
+//  - -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- --
+//  -
+//  -           Collect Verband Missions
+//  -
+//  - -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- --
+
+function ADis_CollectVerbandMissions() {
+
+    var observer2 = new MutationObserver(function (mutations) {
+        if (mutations[0].type == "childList") {
+            if (mutations[0].addedNodes.length >= 1) {
+                // do it here
+                for (var i = 0; i < mutations[0].addedNodes.length; i++)
+                    ADis_ReadAndAddVerbandMissions(mutations[0].addedNodes[i].attributes.getNamedItem("mission_id").value)
+            }
+        } else {
+            console.log("DEBUG VerbandMissions", mutations);
+        }
+    });
+
+    // Notify new alerts
+    var targetNode2 = document.getElementById("mission_list_alliance");
+    observer2.observe(targetNode2, {
+        attributes: false,
+        //attributeFilter: ['class'],
+        //attributeOldValue: true,
+        characterData: false,
+        characterDataOldValue: false,
+        childList: true,
+        subtree: false
+    });
+
+    ADis_ReadAndAddVerbandMissions();
+}
+
+function ADis_ReadAndAddVerbandMissions(MissionID) {
+    if (typeof MissionID != "undefined") {
+        ADis_AddVerbandMissionsToQueue(MissionID);
+    } else {
+        $("#mission_list_alliance").find(".missionSideBarEntry").each(function () {
+            MissionID = $(this).attr("mission_id");
+
+            //      - -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- --
+            //      -
+            //      -           Ambulance Service  |  Full-Automatic
+            //      - -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- --
+
+            ADis_AddVerbandMissionsToQueue(MissionID);
+        });
+    }
+}
+
+function ADis_OpenNextVerbandMissions() {
+    ADisSettings().then((setting) => {
+        if (setting['Alliance-Automatic'] == 'true') {
+            return ADisDB.ADisVerbandMissions.where({
+                done: 'false'
+            }).limit(1)
+        }
+    }).then((Wunsch) => {
+        if (Wunsch !== undefined) {
+            return Wunsch.count(function (count) {
+                if (count > 0) {
+                    return Wunsch.each((myWunsch) => {
+                        let MissionID = myWunsch.missionID;
+                        return ADis_UpdateVerbandMissionsToDone(MissionID).then(() => {
+                            if ($("#adis-verbandmission-frame").attr("mission_id") == "empty") {
+                                $("#adis-verbandmission-frame").attr("src", "https://www.leitstellenspiel.de/missions/" + MissionID);
+                                $("#adis-verbandmission-frame").attr("mission_id", MissionID);
+
+                                VerbandMissionsFrameWatchDog = setTimeout(async function () {
+                                    ADis_RemoveVerbandMissionsFromQueue(MissionID).then((deleteCount) => {
+                                        // TODO: tellParent("ADisMissionDone(" + window.name + "," + MissionID + ");");
+                                        $("#adis-verbandmission-frame").attr("src", "");
+                                        $("#adis-verbandmission-frame").attr("mission_id", "empty");
+                                        setTimeout(ADis_OpenNextVerbandMissions, 1000);
+                                    });
+                                }, 5000);
+                            }
+                        });
+                    });
+                }
+                return setTimeout(ADis_OpenNextVerbandMissions, 5000);
+            });
+        }
+        return setTimeout(ADis_OpenNextVerbandMissions, 5000);
+    });
+}
+
+
+window.ADis_AddVerbandMissionsToQueue = function ADis_AddVerbandMissionsToQueue(MissionID) {
+    return ADisDB.ADisMissionsVerband.add({
+        missionID: MissionID,
+        done: 'false'
+    }).catch((err) => {})
+}
+
+window.ADis_UpdateVerbandMissions = function ADis_UpdateVerbandMissions(Mission) {
+    return ADisDB.ADisMissionsVerband.put(Mission).catch((err) => {})
+}
+
+window.ADis_UpdateVerbandMissionsToDone = function ADis_UpdateVerbandMissionsToDone(MissionID) {
+    return ADisDB.ADisMissionsVerband.update(MissionID, {
+        missionID: MissionID,
+        done: 'true'
+    }).catch((err) => {})
+}
+
+window.ADis_RemoveVerbandMissionsFromQueue = function ADis_RemoveVerbandMissionsFromQueue(MissionID) {
+    return ADisDB.ADisMissionsVerband.where({
+        missionID: MissionID
+    }).delete();
+}