Server : Apache/2.4.41 (Ubuntu) System : Linux absol.cf 5.4.0-198-generic #218-Ubuntu SMP Fri Sep 27 20:18:53 UTC 2024 x86_64 User : www-data ( 33) PHP Version : 7.4.33 Disable Function : pcntl_alarm,pcntl_fork,pcntl_waitpid,pcntl_wait,pcntl_wifexited,pcntl_wifstopped,pcntl_wifsignaled,pcntl_wifcontinued,pcntl_wexitstatus,pcntl_wtermsig,pcntl_wstopsig,pcntl_signal,pcntl_signal_get_handler,pcntl_signal_dispatch,pcntl_get_last_error,pcntl_strerror,pcntl_sigprocmask,pcntl_sigwaitinfo,pcntl_sigtimedwait,pcntl_exec,pcntl_getpriority,pcntl_setpriority,pcntl_async_signals,pcntl_unshare, Directory :  /var/www/html/libs/absol-full/dist/js/

Upload File : current_dir [ Writeable ] document_root [ Writeable ]

/*** module: node_modules/absol-poser/fragment/PoserEvaluation.js ***/
"use strict";

Object.defineProperty(exports, "__esModule", {
  value: true
});
exports.default = void 0;

var _Fragment = _interopRequireDefault(require("absol/src/AppPattern/Fragment"));

var _EventEmitter = _interopRequireDefault(require("absol/src/HTML5/EventEmitter"));

var _OOP = _interopRequireDefault(require("absol/src/HTML5/OOP"));

var _Core = require("../dom/Core");

require("../css/poserevaluation.css");

var _PVSection = _interopRequireDefault(require("../dom/viewer/PVSection"));

var _utils = require("absol-acomp/js/utils");

var _utils2 = require("../utils");


/***
 * @augments Fragment
 * @augments EventEmitter
 * @param {{readOnly: boolean}=} opt
 * @constructor
 */
function PoserEvaluation(opt) {
  this.opt = Object.assign({
    readOnly: false,
    hasScroller: true,
    hasSection: true,
    autoEvaluate: true
  }, opt || {});

  _Fragment.default.call(this);

  _EventEmitter.default.call(this);
}

_OOP.default.mixClass(PoserEvaluation, _Fragment.default, _EventEmitter.default);

PoserEvaluation.prototype.createView = function () {
  this.$view = (0, _Core._)({
    class: 'ap-evaluation'
  });
  this.$view.afterAttached().then(() => this.start());

  if (this.opt.readOnly) {
    this.$view.addClass('ap-read-only');
  }

  if (!this.opt.hasScroller) {
    this.$view.addClass('ap-without-scroller');
  }

  if (!this.opt.hasSection) {
    this.$view.addClass('ap-without-section');
  }
};

PoserEvaluation.prototype.onResume = function () {
  if (this.$view) (0, _utils2.autoThemeVariable)(this.$view);
};
/***
 *
 * @param {{sections:[], result:[], order?:[]}}data
 */


PoserEvaluation.prototype.setData = function (data) {
  var self = this;
  var view = this.getView();
  this._data = data;
  view.clearChild();
  var count = 0;
  var id2order = null;
  if (data.order) id2order = data.order.reduce((ac, cr, i) => {
    ac[cr] = i;
    return ac;
  }, {});

  if (data.sections) {
    data.sections.forEach((st, stIdx) => {
      var stn = (0, _Core._)({
        tag: _PVSection.default.tag,
        props: {
          data: st.section,
          idx: stIdx + 1
        }
      });
      view.addChild(stn);
      var sortedQuestion = st.questions.slice();
      if (id2order) sortedQuestion.sort((a, b) => id2order[a.ident] - id2order[b.ident]);
      sortedQuestion.forEach((oqt, index, array) => {
        var qt = Object.assign({}, oqt);
        var designedScore = qt.score;
        delete qt.score;
        var qtElt = (0, _Core._)({
          tag: 'PRQuestion'.toLowerCase(),
          props: {
            idx: count + 1,
            data: qt,
            designedScore: designedScore || 1,
            // evaluatedScore: evaluatedScore,
            note: qt.note,
            readOnly: this.opt.readOnly
          },
          on: {
            evaluationchange: function (event) {
              self.emit('evaluationchange', {
                type: 'evaluationchange',
                originalEvent: event.originalEvent || event,
                target: self,
                question: qt,
                questionElt: qtElt,
                property: event.property
              });
            }
          }
        });
        if (index + 1 === array.length) qtElt.addClass('ap-last-question');
        var questionIdent = qt.ident;

        if (data.result && data.result[questionIdent]) {
          qtElt.result = data.result[questionIdent].value;
          qtElt.resultIdent = data.result[questionIdent].ident;
        }

        var evaluatedScore = this._evaluateScore(oqt, data.result[questionIdent]);

        if (this.opt.autoEvaluate) {
          qtElt.evaluatedScore = evaluatedScore;
          qtElt.autoEvaluatedScore = evaluatedScore;
          qtElt.attr('data-evaluated-score', evaluatedScore + '');
        }

        view.addChild(qtElt);
        count++;
      });
    });
  }
};

PoserEvaluation.prototype.evaluators = {
  multiple_choice: (question, result) => {
    if (result && result.value && result.value.idx === question.correct_answer) {
      return question.score;
    } else {
      return 0;
    }
  },
  checkboxes: (question, result) => {
    var spw;
    var rightAns = 0,
        wrongAns = 0;

    if (result && result.value && question.correct_answer && question.correct_answer.length) {
      spw = question.score / question.correct_answer.length;
      result.value.forEach(ans => {
        if (question.correct_answer.indexOf(ans.idx) >= 0) {
          rightAns++;
        } else {
          wrongAns++;
        }
      });
      if (rightAns <= wrongAns) return 0;
      return spw * (rightAns - wrongAns);
    } else {
      return 0;
    }
  }
};

PoserEvaluation.prototype._evaluateScore = function (question, result) {
  if (!result) return 0;
  var evaluator = this.evaluators[question.type];
  if (!evaluator) return 0;
  return evaluator(question, result);
};

PoserEvaluation.prototype.getData = function () {
  return this._data;
};

PoserEvaluation.prototype.getEvaluation = function () {
  var count = 1;
  var dict = {
    "0": true
  };

  var getOnce = () => {
    while (dict[count]) ++count;

    dict[count] = true;
    return count;
  };

  this.getView();
  return Array.prototype.filter.call(this.$view.childNodes, function (elt) {
    return elt.containsClass && elt.containsClass('ap-question');
  }).reduce((ac, elt) => {
    var questionIdent = elt.data.ident;
    var evaluatedScore = elt.evaluatedScore;
    if (!(0, _utils.isRealNumber)(evaluatedScore)) evaluatedScore = elt.designedScore;
    var ident = elt.evaluationIdent;

    if (!(0, _utils.isNaturalNumber)(ident) || ident === 0 || dict[ident]) {
      ident = getOnce();
    } else {
      dict[ident] = true;
    }

    ac[questionIdent] = {
      ident: ident,
      score: evaluatedScore,
      feedback: elt.feedback
    };
    return ac;
  }, {});
};

PoserEvaluation.prototype.setEvaluation = function (evaluationData) {
  evaluationData = evaluationData || {};
  this.getView();
  return Array.prototype.filter.call(this.$view.childNodes, function (elt) {
    return elt.containsClass && elt.containsClass('ap-question');
  }).forEach(elt => {
    var questionIdent = elt.data.ident;
    var evaluation = evaluationData[questionIdent] || {};
    elt.evaluationIdent = evaluation.ident || 0;

    if ('score' in evaluation && !isNaN(evaluation.score)) {
      elt.evaluatedScore = evaluation.score;
    } else if (!this.opt.autoEvaluate) {
      elt.evaluatedScore = evaluation.score || 0;
    }

    elt.feedback = evaluation.feedback || '';
  }, {});
};

var _default = PoserEvaluation;
exports.default = _default;