WebSVN – Moodle – Diff – /course/format/amd/src/local/courseeditor/mutations.js

         }])[0];
         return JSON.parse(ajaxresult);
+    }
+    /**
+     * Private method to call core_courseformat_create_module webservice.
+     *
+     * @deprecated since Moodle 5.0 MDL-83469.
+     * @todo MDL-83851 This will be deleted in Moodle 6.0.
+     * @method _callEditWebservice
+     * @param {number} courseId
+     * @param {string} modName module name
+     * @param {number} targetSectionNum target section number
+     * @param {number} targetCmId optional target cm id
+     */
+    async _callAddModuleWebservice(courseId, modName, targetSectionNum, targetCmId) {
+        log.debug('_callAddModuleWebservice() is deprecated. Use _callNewModuleWebservice() instead');
+        const args = {
+            courseid: courseId,
+            modname: modName,
+            targetsectionnum: targetSectionNum,
+        };
+        if (targetCmId) {
+            args.targetcmid = targetCmId;
+        }
+        let ajaxresult = await ajax.call([{
+            methodname: 'core_courseformat_create_module',
+            args,
+        }])[0];
+        return JSON.parse(ajaxresult);
+    }
+    /**
+     * Private method to call core_courseformat_new_module webservice.
+     *
+     * @method _callEditWebservice
+     * @param {number} courseId
+     * @param {string} modName module name
+     * @param {number} targetSectionId target section number
+     * @param {number} targetCmId optional target cm id
+     */
+    async _callNewModuleWebservice(courseId, modName, targetSectionId, targetCmId) {
+        const args = {
+            courseid: courseId,
+            modname: modName,
+            targetsectionid: targetSectionId,
+        };
+        if (targetCmId) {
+            args.targetcmid = targetCmId;
+        }
+        let ajaxresult = await ajax.call([{
+            methodname: 'core_courseformat_new_module',
+            args,
+        }])[0];
+        return JSON.parse(ajaxresult);
+    }
     /**
      * Execute a basic section state action.
      * @param {StateManager} stateManager the current state manager
      * @param {string} action the action name
      * @param {array} sectionIds the section ids
      * @param {Object|undefined} data extra params for the log entry
      * @param {string|undefined} data.itemType the element type (will be taken from action if none)
      * @param {int|null|undefined} data.targetSectionId the target section id
      * @param {int|null|undefined} data.targetCmId the target cm id
      * @param {String|null|undefined} data.component optional component (for format plugins)
+     * @param {Object|undefined} [data.feedbackParams] the params to build the feedback message
      * @return {Object} the log entry
      */
     async _getLoggerEntry(stateManager, action, itemIds, data = {}) {
         if (!isLoggerSet) {
             // In case the logger has not been set from init(), ensure we set the logger.
             stateManager.setLogger(new SRLogger());
             isLoggerSet = true;
+        }
-        const feedbackParams = {
+        let feedbackParams = {
             action,
             itemType: data.itemType ?? action.split('_')[0],
         };
         let batch = '';
         if (itemIds.length > 1) {
             feedbackParams.targetSectionName = stateManager.get('section', data.targetSectionId).title;
+        }
         if (data.targetCmId) {
             feedbackParams.targetCmName = stateManager.get('cm', data.targetCmId).name;
+        }
+        if (data.feedbackParams) {
+            feedbackParams = {...feedbackParams, ...data.feedbackParams};
+        }
         const message = await getString(
             `${action.toLowerCase()}_feedback${batch}`,
             data.component ?? 'core_courseformat',
         stateManager.processUpdates(updates);
         this.cmLock(stateManager, cmids, false);
+    }
-    /**
-     * Move course modules to specific course location.
-     *
-     * @deprecated since Moodle 4.4 MDL-77038.
-     * @todo MDL-80116 This will be deleted in Moodle 4.8.
-     * @param {StateManager} stateManager the current state manager
-     * @param {array} sectionIds the list of section ids to move
-     * @param {number} targetSectionId the target section id
-     */
-    async sectionMove(stateManager, sectionIds, targetSectionId) {
-        log.debug('sectionMove() is deprecated. Use sectionMoveAfter() instead');
-        if (!targetSectionId) {
-            throw new Error(`Mutation sectionMove requires targetSectionId`);
-        }
-        const course = stateManager.get('course');
-        this.sectionLock(stateManager, sectionIds, true);
-        const updates = await this._callEditWebservice('section_move', course.id, sectionIds, targetSectionId);
-        this.bulkReset(stateManager);
-        stateManager.processUpdates(updates);
-        this.sectionLock(stateManager, sectionIds, false);
-    }
     /**
      * Move course modules after a specific course location.
+     *
      * @param {StateManager} stateManager the current state manager
      * @param {array} sectionIds the list of section ids to move
             targetSectionId = 0;
+        }
         const course = stateManager.get('course');
         const updates = await this._callEditWebservice('section_add', course.id, [], targetSectionId);
         stateManager.processUpdates(updates);
+        const logEntry = this._getLoggerEntry(stateManager, 'section_add', []);
+        stateManager.addLoggerEntry(await logEntry);
+    }
     /**
      * Delete sections.
+     *
      * @param {StateManager} stateManager the current state manager
      * @param {array} sectionIds the list of course modules ids
      */
     async sectionDelete(stateManager, sectionIds) {
+        const course = stateManager.get('course');
-        const course = stateManager.get('course');
+        const logEntry = this._getLoggerEntry(stateManager, 'section_delete', sectionIds);
         const updates = await this._callEditWebservice('section_delete', course.id, sectionIds);
         this.bulkReset(stateManager);
+        stateManager.processUpdates(updates);
-        stateManager.processUpdates(updates);
+        stateManager.addLoggerEntry(await logEntry);
+    }
     /**
      * Delete cms.
      * @param {StateManager} stateManager the current state manager
      * @param {array} cmIds the list of section ids
      */
+    async cmDelete(stateManager, cmIds) {
-    async cmDelete(stateManager, cmIds) {
+        const course = stateManager.get('course');
-        const course = stateManager.get('course');
+        const logEntry = this._getLoggerEntry(stateManager, 'cm_delete', cmIds);
         this.cmLock(stateManager, cmIds, true);
         const updates = await this._callEditWebservice('cm_delete', course.id, cmIds);
         this.bulkReset(stateManager);
+        this.cmLock(stateManager, cmIds, false);
+        stateManager.processUpdates(updates);
+        stateManager.addLoggerEntry(await logEntry);
+    }
+    /**
+     * Add a new module to a specific course section.
+     *
+     * @deprecated since Moodle 5.0 MDL-83469.
+     * @todo MDL-83851 This will be deleted in Moodle 6.0.
+     * @param {StateManager} stateManager the current state manager
+     * @param {string} modName the modulename to add
+     * @param {number} targetSectionNum the target section number
+     * @param {number} targetCmId optional the target cm id
+     */
+    async addModule(stateManager, modName, targetSectionNum, targetCmId) {
+        log.debug('addModule() is deprecated. Use newModule() instead');
+        if (!modName) {
+            throw new Error(`Mutation addModule requires moduleName`);
+        }
+        if (!targetSectionNum) {
+            throw new Error(`Mutation addModule requires targetSectionNum`);
+        }
+        if (!targetCmId) {
+            targetCmId = 0;
+        }
+        const course = stateManager.get('course');
+        const updates = await this._callAddModuleWebservice(course.id, modName, targetSectionNum, targetCmId);
+        stateManager.processUpdates(updates);
+    }
+    /**
+     * Add a new module to a specific course section.
+     *
+     * @param {StateManager} stateManager the current state manager
+     * @param {string} modName the modulename to add
+     * @param {number} targetSectionId the target section id
+     * @param {number} targetCmId optional the target cm id
+     */
+    async newModule(stateManager, modName, targetSectionId, targetCmId) {
+        if (!modName) {
+            throw new Error(`Mutation newModule requires moduleName`);
+        }
+        if (!targetSectionId) {
+            throw new Error(`Mutation newModule requires targetSectionId`);
+        }
+        if (!targetCmId) {
+            targetCmId = 0;
+        }
+        const course = stateManager.get('course');
+        const pluginname = await getString(
+            'pluginname',
+            `${modName.toLowerCase()}`,
+        );
+        const logEntry = this._getLoggerEntry(stateManager, 'cm_add', [], {
+            feedbackParams: {
+                'modname': pluginname,
+            },
+        });
+        const updates = await this._callNewModuleWebservice(course.id, modName, targetSectionId, targetCmId);
-        this.cmLock(stateManager, cmIds, false);
+        stateManager.processUpdates(updates);
-        stateManager.processUpdates(updates);
+        stateManager.addLoggerEntry(await logEntry);
+    }
+     *
      * @param {StateManager} stateManager the current state manager
      * @param {array} cmIds the list of course modules ids
      * @param {bool} complete the new completion value
      */
-    cmCompletion(stateManager, cmIds, complete) {
+    async cmCompletion(stateManager, cmIds, complete) {
-        const newValue = (complete) ? 1 : 0;
+        const newState = (complete) ? 1 : 0;
-        this._setElementsValue(stateManager, 'cm', cmIds, 'completionstate', newValue);
+        const action = (newState == 1) ? 'cm_complete' : 'cm_uncomplete';
+        const logEntry = this._getLoggerEntry(stateManager, action, cmIds);
+        stateManager.setReadOnly(false);
+        cmIds.forEach((id) => {
+            const element = stateManager.get('cm', id);
+            if (element) {
+                element.isoverallcomplete = complete;
+                element.completionstate = newState;
+            }
+        });
+        stateManager.setReadOnly(true);
+        stateManager.addLoggerEntry(await logEntry);
+    }
     /**
      * Move cms to the right: indent = 1.
             newPageItem = stateManager.get(type, id);
             if (!newPageItem) {
                 return;
+            }
+        }
+        const course = stateManager.get('course');
+        if (course.pageItem && course.pageItem.type === type && course.pageItem.id === id) {
+            return;
+        }
         stateManager.setReadOnly(false);
         // Remove the current page item.
-        const course = stateManager.get('course');
         course.pageItem = null;
         // Save the new page item.
         if (newPageItem) {
             course.pageItem = {
                 id,

Proyectos de Subversion Moodle

(root)/course/format/amd/src/local/courseeditor/mutations.js – Rev 1 → 1441