@touchpoll/tp-survey 0.0.1

package/esm2022/lib/core/tp.servey.quota/tp.survey.quota.mjs

@@ -0,0 +1,82 @@
+import { executeLogicExpression } from '../../tp.survey.method';
+export class SurveyQuotas {
+    #completedQuota = { name: null, guid: null, guid2d: null };
+    #quotas = [];
+    #quotas2d = [];
+    #quotaLimitDestinationQuestionGuid = -1;
+    #quotaLimitDestinationQuestionNum = -1;
+    setQuotas(quotas1d = [], quotas2d = [], quotaLimitDestinationQuestionGuid = -1, destinationQuestionNum = -1) {
+        this.#quotas = quotas1d;
+        this.#quotas2d = quotas2d;
+        this.#quotaLimitDestinationQuestionGuid = quotaLimitDestinationQuestionGuid;
+        this.#quotaLimitDestinationQuestionNum = destinationQuestionNum;
+    }
+    guidIsDestinationQuestion(guid) {
+        return this.#quotaLimitDestinationQuestionGuid === guid;
+    }
+    get quotaIsCompleted() {
+        return this.#completedQuota && (!!this.#completedQuota.guid || !!this.#completedQuota.guid2d);
+    }
+    get destinationQuestionGuid() {
+        return this.#quotaLimitDestinationQuestionGuid;
+    }
+    get quotaCount() {
+        const quotas = this.#quotas && Array.isArray(this.#quotas) ? this.#quotas.length : 0;
+        const quotas2d = this.#quotas2d && Array.isArray(this.#quotas2d) ? this.#quotas2d.length : 0;
+        return quotas + quotas2d;
+    }
+    findFilledQuotas(currentQuestionNum, vars, interviewAnswers) {
+        /*
+        * Поиск заполненной квоты это очень дорогой процесс. Его нужно оптимизировать по максимуму.
+        * Перед поиском нужно выполнить ряд проверок.
+        * Проверка currentQuestionNum <= this.#quotaLimitDestinationQuestionNum Нужна для оптимизации.
+        * DestinationQuestion Желательно располагать после последнего квотного вопроса, потому что нет смысла постоянно проверять квоты, если вопросы которые используются для расчёта квоты меняться не будут.
+        * например Квота Q1 + Q2 <= 25. DestinationQuestion нужно делать номером 3 или 4. Потому что как бы респондент не отвечал на последующие вопросы, результат квот не измениться и каждый раз их пересчитывать смысла нет.
+        */
+        if ((this.destinationQuestionGuid > 0) && //Глобально в настройках анкеты должен быть указан вопрос который должен отобразиться при достижении квоты, если его нет, то и искать квоты смысла нет.
+            (this.quotaCount > 0) && //проверим если у нас вообще квоты
+            (currentQuestionNum <= this.#quotaLimitDestinationQuestionNum) && // номер текущий вопроса меньше номера вопроса для перехода по достижении квот
+            (!this.quotaIsCompleted) //и на финал проверим если ли уже заполненная квота, повторно не запускаем
+        ) {
+            new Promise((resolve, reject) => {
+                if (Array.isArray(this.#quotas)) {
+                    const completedQuota = this.#quotas.find(quota => executeLogicExpression(quota.expression, vars));
+                    if (!!completedQuota) {
+                        return resolve({ name: completedQuota.name, guid: completedQuota.quota_guid });
+                    }
+                }
+                if (Array.isArray(this.#quotas2d)) {
+                    const answers = this.#quotas2d.length > 0 ? interviewAnswers.map(a => ({ av: a.AnswerValue, qg: a.QuestionGUID })) : [];
+                    const filledQuota2dArray = this.#quotas2d.filter(quotaValues => quotaValues.qs.every(qvq => !!answers.find(intAnswer => intAnswer.qg === qvq.guid && intAnswer.av === qvq.value)));
+                    //если не нашли заполненных квот выходим
+                    if (filledQuota2dArray.length <= 0) {
+                        return;
+                    }
+                    //ищем квоту которая заполнена и у нее есть условие и оно выполняется.
+                    const quota2dWithExpression = filledQuota2dArray.find((q) => !!q.exp && executeLogicExpression(q.exp, vars));
+                    //если квота есть сообщим
+                    if (!!quota2dWithExpression) {
+                        return resolve({ name: null, guid2d: quota2dWithExpression.qvg });
+                    }
+                    //если квоты с Expression нет, ищем квоту которая заполнена и у нее нет условия
+                    const quota2dWithoutExpression = filledQuota2dArray.find((q) => !q.exp || (typeof q.exp === 'string' && q.exp.trim().length === 0));
+                    if (!!quota2dWithoutExpression) {
+                        return resolve({ name: null, guid2d: quota2dWithoutExpression.qvg });
+                    }
+                }
+                reject(null);
+            }).then(quota => {
+                if (!!quota) {
+                    this.#completedQuota = {
+                        name: quota.name,
+                        guid: 'guid' in quota ? quota.guid : null,
+                        guid2d: 'guid2d' in quota ? quota.guid2d : null,
+                    };
+                }
+            }).catch(err => {
+                console.error(err);
+            });
+        }
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"tp.survey.quota.js","sourceRoot":"","sources":["../../../../../../projects/tp.survey/src/lib/core/tp.servey.quota/tp.survey.quota.ts"],"names":[],"mappings":"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","sourcesContent":["import {IdbQuestionaryQuota, IdbQuestionaryQuota2dObject} from '../../tp.survey.interface';\r\nimport {Answer} from '../tp.survey.answer/tp.survey.answer';\r\nimport {executeLogicExpression} from '../../tp.survey.method';\r\nimport {LogicObject} from '../../tp.survey.type';\r\n\r\ntype QuotaCalculationResult = {\r\n  name: string;\r\n  guid: number;\r\n} | {\r\n  name: null;\r\n  guid2d: number;\r\n} | null;\r\n\r\nexport class SurveyQuotas {\r\n  #completedQuota: {name: string | null; guid: number| null; guid2d: number| null} = {name: null, guid: null, guid2d: null};\r\n  #quotas: Array<IdbQuestionaryQuota> = [];\r\n  #quotas2d: Array<IdbQuestionaryQuota2dObject> = [];\r\n  #quotaLimitDestinationQuestionGuid: number = -1;\r\n  #quotaLimitDestinationQuestionNum: number = -1;\r\n\r\n  setQuotas(quotas1d: Array<IdbQuestionaryQuota> = [], quotas2d: Array<IdbQuestionaryQuota2dObject> = [], quotaLimitDestinationQuestionGuid: number = -1, destinationQuestionNum: number = -1){\r\n    this.#quotas = quotas1d;\r\n    this.#quotas2d = quotas2d;\r\n    this.#quotaLimitDestinationQuestionGuid = quotaLimitDestinationQuestionGuid;\r\n    this.#quotaLimitDestinationQuestionNum = destinationQuestionNum;\r\n  }\r\n\r\n  guidIsDestinationQuestion(guid: number): boolean{\r\n    return this.#quotaLimitDestinationQuestionGuid === guid;\r\n  }\r\n\r\n\r\n  get quotaIsCompleted(): boolean {\r\n    return this.#completedQuota && (!!this.#completedQuota.guid || !!this.#completedQuota.guid2d)  ;\r\n  }\r\n\r\n  get destinationQuestionGuid(): number {\r\n    return this.#quotaLimitDestinationQuestionGuid\r\n  }\r\n\r\n  get quotaCount(): number {\r\n    const quotas   = this.#quotas &&  Array.isArray(this.#quotas) ? this.#quotas.length : 0;\r\n    const quotas2d = this.#quotas2d &&  Array.isArray(this.#quotas2d) ? this.#quotas2d.length : 0;\r\n    return quotas + quotas2d;\r\n  }\r\n\r\n  findFilledQuotas(currentQuestionNum: number, vars: LogicObject, interviewAnswers: Array<Answer>): void {\r\n    /*\r\n    * Поиск заполненной квоты это очень дорогой процесс. Его нужно оптимизировать по максимуму.\r\n    * Перед поиском нужно выполнить ряд проверок.\r\n    * Проверка currentQuestionNum <= this.#quotaLimitDestinationQuestionNum Нужна для оптимизации.\r\n    * DestinationQuestion Желательно располагать после последнего квотного вопроса, потому что нет смысла постоянно проверять квоты, если вопросы которые используются для расчёта квоты меняться не будут.\r\n    * например Квота Q1 + Q2 <= 25. DestinationQuestion нужно делать номером 3 или 4. Потому что как бы респондент не отвечал на последующие вопросы, результат квот не измениться и каждый раз их пересчитывать смысла нет.\r\n    */\r\n    if (\r\n     (this.destinationQuestionGuid > 0) && //Глобально в настройках анкеты должен быть указан вопрос который должен отобразиться при достижении квоты, если его нет, то и искать квоты смысла нет.\r\n     (this.quotaCount > 0) && //проверим если у нас вообще квоты\r\n     (currentQuestionNum <= this.#quotaLimitDestinationQuestionNum) && // номер текущий вопроса меньше номера вопроса для перехода по достижении квот\r\n     (!this.quotaIsCompleted) //и на финал проверим если ли уже заполненная квота, повторно не запускаем\r\n    ) {\r\n\r\n      new Promise<QuotaCalculationResult>((resolve, reject) => {\r\n        if (Array.isArray(this.#quotas)) {\r\n          const completedQuota = this.#quotas.find(quota => executeLogicExpression(quota.expression, vars));\r\n          if (!!completedQuota) {\r\n            return resolve({name: completedQuota.name, guid: completedQuota.quota_guid});\r\n          }\r\n        }\r\n\r\n        if (Array.isArray(this.#quotas2d)) {\r\n          const answers = this.#quotas2d.length > 0 ? interviewAnswers.map(a => ({av: a.AnswerValue, qg: a.QuestionGUID}) ) : [];\r\n\r\n          const filledQuota2dArray = this.#quotas2d.filter(quotaValues => quotaValues.qs.every(qvq => !!answers.find(intAnswer => intAnswer.qg === qvq.guid && intAnswer.av === qvq.value)));\r\n\r\n          //если не нашли заполненных квот выходим\r\n          if (filledQuota2dArray.length <= 0) {\r\n            return;\r\n          }\r\n\r\n          //ищем квоту которая заполнена и у нее есть условие и оно выполняется.\r\n          const quota2dWithExpression = filledQuota2dArray.find((q: IdbQuestionaryQuota2dObject) => !!q.exp && executeLogicExpression(q.exp, vars));\r\n\r\n          //если квота есть сообщим\r\n          if (!!quota2dWithExpression) {\r\n            return resolve({name: null, guid2d: quota2dWithExpression.qvg});\r\n          }\r\n\r\n          //если квоты с Expression нет, ищем квоту которая заполнена и у нее нет условия\r\n          const quota2dWithoutExpression = filledQuota2dArray.find((q: IdbQuestionaryQuota2dObject) => !q.exp  || (typeof q.exp  === 'string' && q.exp.trim().length === 0));\r\n          if (!!quota2dWithoutExpression) {\r\n            return resolve({name: null, guid2d: quota2dWithoutExpression.qvg});\r\n          }\r\n        }\r\n        reject(null)\r\n      }).then(quota => {\r\n        if (!!quota) {\r\n          this.#completedQuota = {\r\n            name: quota.name,\r\n            guid: 'guid' in  quota ? quota.guid : null,\r\n            guid2d: 'guid2d' in  quota ? quota.guid2d : null,\r\n          }\r\n        }\r\n      }).catch(err => {\r\n        console.error(err);\r\n      });\r\n    }\r\n  }\r\n}\r\n"]}

package/esm2022/lib/core/tp.survey.answer/tp.survey.answer.mjs

@@ -0,0 +1,30 @@
+import { MISSING_VALUE } from '../../tp.survey.const';
+export class Answer {
+    constructor(guid, version = -1) {
+        this.AnswerAdditional = {};
+        this.ViewedAlternativeValues = [];
+        this.ViewedSectionGuids = [];
+        this.AlternativeSequenceClicks = [];
+        this.StartedAt = 0;
+        this.FinishedAt = 0;
+        this.AnswerValue = MISSING_VALUE;
+        this.answerIsComplete = false;
+        this.QuestionGUID = guid;
+        this.QuestionVersion = version;
+    }
+    clear() {
+        this.StartedAt = 0;
+        this.FinishedAt = 0;
+        this.AnswerValue = MISSING_VALUE;
+        this.ViewedAlternativeValues.length = 0;
+        this.ViewedSectionGuids.length = 0;
+        this.AlternativeSequenceClicks.length = 0;
+        for (const key of Object.keys(this.AnswerAdditional)) {
+            this.AnswerAdditional[Number(key)] = null;
+        }
+    }
+    addAnswer(answerValue, answerAdditional, asComplete) {
+        this.AnswerValue = answerValue;
+    }
+}
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/lib/core/tp.survey.core/tp.survey.core.service.mjs

@@ -0,0 +1,370 @@
+import { DestroyRef, inject, Inject, Injectable, PLATFORM_ID } from '@angular/core';
+import { BehaviorSubject, filter, Subject } from 'rxjs';
+import { SurveyQuotas } from '../tp.servey.quota/tp.survey.quota';
+import { isPlatformBrowser } from '@angular/common';
+import { map } from 'rxjs/operators';
+import { QuestionsType, ResultativeStatus, SurveyEvents, ValidStatus } from '../../tp.survey.enum';
+import { MISSING_VALUE } from '../../tp.survey.const';
+import { takeUntilDestroyed } from '@angular/core/rxjs-interop';
+import * as i0 from "@angular/core";
+import * as i1 from "../tp.survey.logic/tp.survey.logic.service";
+import * as i2 from "../tp.survey.interview/tp.survey.interview.service";
+export class TpSurveyCoreService {
+    #currentQuestion;
+    #surveyQuotas;
+    #questionary;
+    #displayedQuestions; // нужно для навигации по кнопке back
+    #destroyRef;
+    constructor(platformId, _logic, _interview) {
+        this.platformId = platformId;
+        this._logic = _logic;
+        this._interview = _interview;
+        this._eventBus = new Subject();
+        this.#currentQuestion = new BehaviorSubject(null);
+        this.#surveyQuotas = new SurveyQuotas();
+        this.#displayedQuestions = []; // нужно для навигации по кнопке back
+        this.#destroyRef = inject(DestroyRef);
+        // запускам проверку квот, после скрытия каждого(почти) вопроса (seQuestionHide)
+        this._eventBus.asObservable().pipe(filter(ev => ev.key === SurveyEvents.seQuestionHide), takeUntilDestroyed(this.#destroyRef)).subscribe({
+            next: () => this.#surveyQuotas.findFilledQuotas(this.#currentQuestion.value?.QuestionNum ?? -1, Object.assign({}, this._logic.getLogicVars()), this._interview.getAnswerList())
+        });
+    }
+    setupSurvey(questionaryRawData, logicVars, answerList, questionGuid) {
+        //если анкеты нет, делать нечего.
+        if (!questionaryRawData) {
+            this.#currentQuestion.next(null);
+            return;
+        }
+        this.#questionary = questionaryRawData;
+        if (isPlatformBrowser(this.platformId)) {
+            //узнаем есть ли вопрос который указали для перехода при заполнении квоты
+            const destinationQuestion = this.#findQuestionByGuid(questionaryRawData.BaseParams.QuotaLimitDestinationQuestionGuid);
+            //инициализируем квоты
+            this.#surveyQuotas.setQuotas(questionaryRawData.Quotas, questionaryRawData.Quotas2d, destinationQuestion?.QuestionGuid ?? -1, destinationQuestion?.QuestionNum ?? -1);
+        }
+        //создадим ответы и логические переменные
+        this.#initiateQuestions(this.#questionary.Questions);
+        // Может быть 2 варианта запуска интервью, 1-новое интервью, 2-перезапуск старого интервью. В первом случае начало это lang или первый вопрос. Во втором, с последнего вопроса на который ответили.
+        let startQuestionNum = undefined;
+        //если загружаем ранее не законченное интервью, продолжаем с места последнего вопроса (случай номер 2)
+        if (!!logicVars && !!answerList && !!questionGuid) {
+            //загружаем старые логические переменные и ответы
+            this.#fillOldInterviewData(logicVars, answerList);
+            //ищем номер вопроса, который был последний перед сохранением.
+            const questionLastSave = this.#findQuestionByGuid(questionGuid);
+            //Вопрос могли удалить. Тогда начнем сначала.
+            if (!!questionLastSave) {
+                startQuestionNum = questionLastSave.QuestionNum;
+            }
+        }
+        if (startQuestionNum === undefined) {
+            //Это новое интервью, без ранее сохранённых данных(случай 1). Запускаем опрос, первый экран это Lang вопрос, но если выбора языка нет, пропускаем и переходим на 1-й вопрос
+            startQuestionNum = this.#activeLangCount > 1 ? 0 : this.#nextQuestionNum();
+        }
+        //пошлём событие о начале опроса
+        this._eventBus.next({ key: SurveyEvents.seSurveyStart, data: { questionary: this.#questionary } });
+        //показываем вопрос
+        this.#changeCurrentQuestion(this.#questionary.Questions[startQuestionNum]);
+    }
+    on(...key) {
+        return this._eventBus.asObservable().pipe(filter(event => key.includes(event.key)), map(event => event.data));
+    }
+    goToNextQuestion() {
+        const currentQuestion = this.#currentQuestion.value;
+        if (!currentQuestion) {
+            return;
+        }
+        //если ответ на текущий вопрос не закончен, выходим
+        if (!this._interview.questionIsComplete(currentQuestion.QuestionGuid)) {
+            return;
+        }
+        //если указан PostScript, выполним его
+        if (!!currentQuestion.PostScript) {
+            this._logic.executePostScript(currentQuestion.PostScript);
+        }
+        this.#changeCurrentQuestion(this.#questionary.Questions[this.#nextQuestionNum()]);
+    }
+    goToBackQuestion() {
+        this.#displayedQuestions.pop(); // удалим информацию о том что показывали этот вопрос
+        const previousQuestionNum = this.#displayedQuestions.pop(); // узнаем номер вопроса на который нам надо перейти, и удалим информацию что-бы не дублировать
+        if (!!previousQuestionNum) {
+            const prevQuestion = this.#questionary?.Questions[previousQuestionNum];
+            if (!!prevQuestion) {
+                this.#changeCurrentQuestion(prevQuestion);
+            }
+        }
+    }
+    questionIsComplete(guid) {
+        const answer = this._interview.findAnswerByGuid(guid);
+        return answer?.answerIsComplete ?? false;
+    }
+    #fillOldInterviewData(logicVars, answerList) {
+        //пропишем старые логические переменные
+        if (Array.isArray(logicVars)) {
+            logicVars.forEach(logicVarObj => {
+                this._logic.setLogicValue(logicVarObj.nm, logicVarObj.vl);
+            });
+        }
+        //пропишем старые ответы
+        this._interview.overrideAnswers(answerList);
+        //нужно вернуть время начала интервью, отдельно оно не сохраняется, поэтому возьмём минимальное время начала из ответов
+        //фильтруем все вопросы у которых оно указано(>0) и трансформируем в число.
+        const startedAtArray = answerList.filter(answer => answer.StartedAt > 0).map(answer => answer.StartedAt);
+        //берём минимальное
+        this._interview.startedAt = Math.min(...startedAtArray);
+    }
+    #changeCurrentQuestion(newQuestion) {
+        const currentQuestion = this.#currentQuestion.value;
+        const currentTime = new Date().getTime();
+        if (!!currentQuestion) {
+            /*
+            Сохраним время начала интервью. Фиксировать будем не с самого начала, а с ответа на первый вопрос.
+            Потому что практика такая, открыть анкету на планшете и ходить искать респондентов и из-за этого длительность интервью может быть нерелевантно.
+            * */
+            if (this._interview.startedAt === 0 && currentQuestion.QuestionNum >= 0) {
+                this._interview.startedAt = currentTime;
+            }
+            //нужно сохранить FinishedAt в ответах для старого вопроса
+            const answer = this._interview.findAnswerByGuid(currentQuestion.QuestionGuid);
+            if (!!answer) {
+                answer.FinishedAt = currentTime;
+            }
+            this._eventBus.next({ key: SurveyEvents.seQuestionHide, data: currentQuestion });
+        }
+        this.#displayedQuestions.push(newQuestion.QuestionNum);
+        this.#currentQuestion.next(newQuestion);
+        //нужно сохранить StartedAt в ответах для нового вопроса
+        const answerNew = this._interview.findAnswerByGuid(newQuestion.QuestionGuid);
+        if (!!answerNew) {
+            answerNew.StartedAt = currentTime;
+        }
+        this._eventBus.next({ key: SurveyEvents.seQuestionShow, data: newQuestion });
+        //если новый экран это end тогда завершаем интервью
+        if (newQuestion.QuestionType === 'END') {
+            this.#finishInterview();
+        }
+    }
+    currentQuestion$() {
+        return this.#currentQuestion.asObservable();
+    }
+    findAnswerByGuid(guid) {
+        return this._interview.findAnswerByGuid(guid);
+    }
+    setLogicValue(varName, value) {
+        this._logic.setLogicValue(varName, value);
+    }
+    getLogicVars() {
+        return this._logic.getLogicVars();
+    }
+    getAnswerList() {
+        return this._interview.getAnswerList();
+    }
+    updateAnswer(eventData) {
+        const answer = this._interview.findAnswerByGuid(eventData.guid);
+        if (!answer) {
+            return;
+        }
+        //вопросы которые в своем составе имеет секции, хранят ответы чуть по другому, точнее ответ на каждую секцию это отдельный объект в  _interview.answerList
+        //поэтому ответ для таких типов вопросов это [key: string]: Array<number> | number, где key(guid секции) это ответ на секцию, если key нет, секция не была показана
+        if (this.#currentQuestion.value?.QuestionType === QuestionsType.eqSL) {
+            const sectionList = this.#currentQuestion.value?.Sectionlist;
+            //пройдёмся по каждой секции и если для неё есть ответ, запишем, в противном случае вместо ответа укажем -97(MISSING_VALUE)
+            if (!!sectionList) {
+                sectionList.forEach(section => {
+                    const sectionInterviewAnswer = this._interview.findAnswerByGuid(section.SectionGuid);
+                    if (!sectionInterviewAnswer) {
+                        return;
+                    }
+                    const sectionQuestionAnswer = eventData.answer ? eventData.answer[section.SectionGuid.toString()] : undefined;
+                    sectionInterviewAnswer.AnswerValue = sectionQuestionAnswer === undefined ? MISSING_VALUE : sectionQuestionAnswer;
+                });
+            }
+            //ответ самого исходного вопроса должен быть 1
+            answer.AnswerValue = 1;
+        }
+        else {
+            //ответ на вопрос у которого нет секций
+            answer.AnswerValue = eventData.answer;
+        }
+        //на вопрос ответили тогда когда есть все ответы и выполняется логика кнопки далее(если её указали)
+        answer.answerIsComplete = eventData.isComplete && this.#nextButtonExpressionIsTrue();
+        //ViewedAlternativeValues и ViewedSectionGuids. Т.к. они readonly сначала удалим, потом добавим
+        answer.ViewedAlternativeValues.length = 0;
+        eventData.viewedAlternativeValues.forEach(oa => answer.ViewedAlternativeValues.push(oa));
+        answer.ViewedSectionGuids.length = 0;
+        eventData.viewedSectionGuids.forEach(oa => answer.ViewedSectionGuids.push(oa));
+        answer.AlternativeSequenceClicks.length = 0;
+        eventData.alternativeSequenceClicks.forEach(oa => answer.AlternativeSequenceClicks.push(oa));
+        Object.entries(answer.AnswerAdditional).forEach(([key]) => delete answer.AnswerAdditional[Number(key)]);
+        Object.entries(eventData.additionalAnswers).forEach(([key, value]) => answer.AnswerAdditional[Number(key)] = value);
+        this.updateLogic(eventData.logicVars);
+        this._eventBus.next({ key: SurveyEvents.seQuestionAnswersChange, data: { question: this.#currentQuestion.value, answerIsComplete: answer.answerIsComplete } });
+        //может возникнуть ситуация, когда нет ни одной альтернативы или секции для отображения.в этом случае вопрос показывать не нужно, как ответ записываем 0 и переходим на следующий
+        const question = this.#findQuestionByGuid(eventData.guid);
+        //ситуация для ss/ms вопросов,
+        if (!!question && answer.answerIsComplete && (question.QuestionType === 'SS' || question.QuestionType === 'MS') && (eventData.viewedAlternativeValues.length === 0)) {
+            this.goToNextQuestion();
+        }
+    }
+    updateLogic(logicVars) {
+        Object.entries(logicVars).forEach(([varName, value]) => {
+            this.setLogicValue(varName, value);
+        });
+    }
+    //возвращает количество активных языков
+    get #activeLangCount() {
+        //если анкета по какой-то причине ну указана, вернём 0
+        return this.#questionary?.BaseParams.LanguageList.filter(langObj => langObj.isActive).length ?? 0;
+    }
+    //возвращает количество вопросов
+    get #questionsCount() {
+        return this.#questionary?.Questions.length ?? 0;
+    }
+    #finishInterview() {
+        const currentTime = new Date();
+        let resultDirty;
+        try {
+            resultDirty = this._logic.executeLogic(this.#questionary?.BaseParams.ResultativeScript ?? '');
+        }
+        catch (e) {
+            resultDirty = false;
+        }
+        const interview = {
+            Language: 0, //todo lang
+            SpotId: 0,
+            DeviceId: 0,
+            DeviceType: 0,
+            Resultative: ResultativeStatus.rsUnset,
+            Valid: ValidStatus.vsUnset,
+            Wave: this.#questionary?.Info.current_wave ?? 0,
+            QuestionaryName: this.#questionary?.Info.name ?? '',
+            QuestionaryGuid: this.#questionary?.Info.questionary_guid ?? 0,
+            StartedAt: this._interview.startedAt,
+            FinishedAt: currentTime.getTime(),
+            TineZoneBias: currentTime.getTimezoneOffset(),
+            ResultatDirty: resultDirty,
+            Answers: {
+                AnsversList: Array.from(this._interview.getAnswerList())
+            },
+            additional_info: {
+                QuestionaryUpdateTimestamp: new Date(this.#questionary?.Info.last_update_timestamp ?? 0).getTime(),
+            },
+            ResultQuotaGuids: [],
+            ResultQuota2dGuids: [],
+            LogicVars: [],
+        };
+        const logicVars = this._logic.getLogicVars();
+        Object.entries(logicVars).forEach(([key, value]) => interview.LogicVars.push({ nm: key, vl: value }));
+        this._eventBus.next({ key: SurveyEvents.seSurveyEnd, data: interview });
+    }
+    #nextQuestionNum() {
+        const currentQuestion = this.#currentQuestion.value;
+        // проверим квоты
+        const currentGuid = currentQuestion?.QuestionGuid ?? 0;
+        if (this.#surveyQuotas.quotaIsCompleted && !this.#surveyQuotas.guidIsDestinationQuestion(currentGuid)) {
+            // у нас есть заполненная квота, найдем вопрос который нужно показать при заполнении квоты
+            const destinationQ = this.#findQuestionByGuid(this.#surveyQuotas.destinationQuestionGuid);
+            //если вопрос есть(его могли удалить из анкеты), показывает его
+            if (!!destinationQ) {
+                return destinationQ.QuestionNum;
+            }
+        }
+        // если нет заполненной квоты, переходим на следующий вопрос, ищем следующий вопрос который мы можем отобразить (до логика может запретить показ вопроса)
+        let nextQuestionNum = (currentQuestion?.QuestionNum ?? 0) + 1;
+        // но сначала проверим после логику
+        if (!!currentQuestion) {
+            const destQ = currentQuestion.logiclist.find(logObj => (logObj.DestinationQuestionGuid > 0) && this._logic.executeLogic(logObj.LogicText));
+            if (!!destQ) {
+                const destQNum = this.#findQuestionByGuid(destQ.DestinationQuestionGuid)?.QuestionNum;
+                if (Number.isSafeInteger(destQNum)) { // вопрос мог быть удалён, а логику оставить
+                    nextQuestionNum = destQNum;
+                }
+            }
+        }
+        // общее количество вопросов, цикл будет считать до этого количества
+        const questionCount = this.#questionsCount;
+        do {
+            //потенциально следующий вопрос
+            const q = this.#questionary.Questions[nextQuestionNum];
+            //если это последний вопрос или если выполняется BeforeExpression и этот вопрос не DestinationQuota, можем его показать
+            if (q.QuestionType === QuestionsType.eqEND || (this._logic.executeLogic(q.BeforeExpression) && !this.#surveyQuotas.guidIsDestinationQuestion(q.QuestionGuid))) {
+                return nextQuestionNum;
+            }
+            //вопрос нельзя показывать, увеличиваем счётчик текущего вопроса на 1
+            nextQuestionNum++;
+        } while (nextQuestionNum < questionCount - 1); // end вопрос должен всегда быть показан
+        return nextQuestionNum;
+    }
+    #initiateQuestions(questionList) {
+        questionList.forEach(question => {
+            //создаём пустой ответ для вопроса.
+            const answer = this._interview.createAnswer(question.QuestionGuid, question.Version);
+            //такого быть не должно, это ошибка
+            if (!answer) {
+                throw new Error('answer not found');
+            }
+            this._logic.setLogicValue(question.SysName, MISSING_VALUE); // переменная самого вопроса
+            //добавим доп ответы и логику для них
+            question.AdditionalAnswerlist.forEach(aa => {
+                answer.AnswerAdditional[aa.Value] = null;
+                this._logic.setLogicValue(`${question.SysName}${aa.SysName}`, MISSING_VALUE); // логика для переменных доп ответа
+            });
+            // если в тексте postScript есть запись типа setVar('varName',  value);  нужно инициализировать переменную varName значением -97.
+            if (!!question.PostScript) {
+                (question.PostScript.match(/(\bsetvar\b)\(['|"](.*?)['|"]/gim) ?? []).map(scriptVar => scriptVar.match(/['|"](.+)['|"]/i)[1]).forEach(varName => this._logic.setLogicValue(varName, null));
+            }
+            // для Вопросов SS/MS нужно прописать логику альтернатив sysname вопроса + sysname альтернативы
+            if (question.Sectionlist.length <= 0) { // для Вопросов SS/MS
+                question.Alternativelist.forEach(alt => this._logic.setLogicValue(`${question.SysName}${alt.SysName}`, MISSING_VALUE));
+            }
+            else {
+                //для вопросов у которых есть секции проинициализируем каждую секцию
+                question.Sectionlist.forEach(section => {
+                    //создаём пустой ответ для секции.
+                    const answerForSection = this._interview.createAnswer(section.SectionGuid, 1);
+                    //такого быть не должно, это ошибка
+                    if (!answerForSection) {
+                        throw new Error('answer not found');
+                    }
+                    // для Вопросов SL нужно прописать логику альтернатив и секций sysname секции + sysname альтернативы
+                    this._logic.setLogicValue(section.SysName, MISSING_VALUE); // переменная самой секции
+                    //логика альтернатив SL вопроса
+                    question.Alternativelist.forEach(alt => this._logic.setLogicValue(`${section.SysName}${alt.SysName}`, MISSING_VALUE));
+                });
+            }
+        });
+    }
+    //ищет вопрос на guid
+    #findQuestionByGuid(guid) {
+        if (!this.#questionary) {
+            return undefined;
+        }
+        return this.#questionary.Questions.find(q => q.QuestionGuid === guid);
+    }
+    #nextButtonExpressionIsTrue() {
+        const buttonNextExpression = this.#currentQuestion.value?.BtnNextExpression ?? '';
+        //если скрипта для кнопки далее нет, вернём true
+        if (buttonNextExpression.trim() === '') {
+            return true;
+        }
+        try {
+            return this._logic.executeLogic(buttonNextExpression);
+        }
+        catch (e) {
+            console.error(e);
+            return false;
+        }
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.0.6", ngImport: i0, type: TpSurveyCoreService, deps: [{ token: PLATFORM_ID }, { token: i1.TpSurveyLogicService }, { token: i2.TpSurveyInterviewService }], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "18.0.6", ngImport: i0, type: TpSurveyCoreService, providedIn: 'root' }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.0.6", ngImport: i0, type: TpSurveyCoreService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root'
+                }]
+        }], ctorParameters: () => [{ type: undefined, decorators: [{
+                    type: Inject,
+                    args: [PLATFORM_ID]
+                }] }, { type: i1.TpSurveyLogicService }, { type: i2.TpSurveyInterviewService }] });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"tp.survey.core.service.js","sourceRoot":"","sources":["../../../../../../projects/tp.survey/src/lib/core/tp.survey.core/tp.survey.core.service.ts"],"names":[],"mappings":"AAAA,OAAO,EAAC,UAAU,EAAE,MAAM,EAAE,MAAM,EAAE,UAAU,EAAE,WAAW,EAAC,MAAM,eAAe,CAAC;AAClF,OAAO,EAAC,eAAe,EAAE,MAAM,EAAc,OAAO,EAAC,MAAM,MAAM,CAAC;AAClE,OAAO,EAAC,YAAY,EAAC,MAAM,oCAAoC,CAAC;AAEhE,OAAO,EAAC,iBAAiB,EAAC,MAAM,iBAAiB,CAAC;AAClD,OAAO,EAAC,GAAG,EAAC,MAAM,gBAAgB,CAAC;AAGnC,OAAO,EAAC,aAAa,EAAE,iBAAiB,EAAE,YAAY,EAAE,WAAW,EAAC,MAAM,sBAAsB,CAAC;AAGjG,OAAO,EAAC,aAAa,EAAC,MAAM,uBAAuB,CAAC;AACpD,OAAO,EAAC,kBAAkB,EAAC,MAAM,4BAA4B,CAAC;;;;AAS9D,MAAM,OAAO,mBAAmB;IAErB,gBAAgB,CAAiD;IAC1E,aAAa,CAAsB;IACnC,YAAY,CAAkB;IAC9B,mBAAmB,CAAqB,CAAC,qCAAqC;IACrE,WAAW,CAAsB;IAC1C,YAAkD,UAAkB,EAAmB,MAA4B,EAAmB,UAAoC;QAAxH,eAAU,GAAV,UAAU,CAAQ;QAAmB,WAAM,GAAN,MAAM,CAAsB;QAAmB,eAAU,GAAV,UAAU,CAA0B;QANzJ,cAAS,GAAG,IAAI,OAAO,EAAkB,CAAC;QAClD,qBAAgB,GAAG,IAAI,eAAe,CAAqB,IAAI,CAAC,CAAC;QAC1E,kBAAa,GAAG,IAAI,YAAY,EAAE,CAAC;QAEnC,wBAAmB,GAAkB,EAAE,CAAC,CAAC,qCAAqC;QACrE,gBAAW,GAAG,MAAM,CAAC,UAAU,CAAC,CAAC;QAExC,gFAAgF;QAChF,IAAI,CAAC,SAAS,CAAC,YAAY,EAAE,CAAC,IAAI,CACjC,MAAM,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,GAAG,KAAK,YAAY,CAAC,cAAc,CAAE,EACrD,kBAAkB,CAAC,IAAI,CAAC,WAAW,CAAC,CACpC,CAAC,SAAS,CAAC;YACV,IAAI,EAAE,GAAG,EAAE,CAAC,IAAI,CAAC,aAAa,CAAC,gBAAgB,CAAC,IAAI,CAAC,gBAAgB,CAAC,KAAK,EAAE,WAAW,IAAI,CAAC,CAAC,EAAE,MAAM,CAAC,MAAM,CAAC,EAAE,EAAE,IAAI,CAAC,MAAM,CAAC,YAAY,EAAE,CAAC,EAAE,IAAI,CAAC,UAAU,CAAC,aAAa,EAAE,CAAC;SAChL,CAAC,CAAC;IACL,CAAC;IAED,WAAW,CAAC,kBAAkC,EAAE,SAAqC,EAAE,UAAmC,EAAE,YAAqB;QAC/I,iCAAiC;QACjC,IAAI,CAAC,kBAAkB,EAAE,CAAC;YACxB,IAAI,CAAC,gBAAgB,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC;YACjC,OAAO;QACT,CAAC;QAED,IAAI,CAAC,YAAY,GAAG,kBAAkB,CAAC;QAEvC,IAAI,iBAAiB,CAAC,IAAI,CAAC,UAAU,CAAC,EAAE,CAAC;YACvC,yEAAyE;YACzE,MAAM,mBAAmB,GAAG,IAAI,CAAC,mBAAmB,CAAC,kBAAkB,CAAC,UAAU,CAAC,iCAAiC,CAAC,CAAC;YAEtH,sBAAsB;YACtB,IAAI,CAAC,aAAa,CAAC,SAAS,CAAC,kBAAkB,CAAC,MAAM,EAAE,kBAAkB,CAAC,QAAQ,EAAE,mBAAmB,EAAE,YAAY,IAAI,CAAC,CAAC,EAAE,mBAAmB,EAAE,WAAW,IAAI,CAAC,CAAC,CAAC,CAAC;QACxK,CAAC;QAED,yCAAyC;QACzC,IAAI,CAAC,kBAAkB,CAAC,IAAI,CAAC,YAAY,CAAC,SAAS,CAAC,CAAA;QAEpD,mMAAmM;QACnM,IAAI,gBAAgB,GAAuB,SAAS,CAAC;QACrD,sGAAsG;QACtG,IAAI,CAAC,CAAC,SAAS,IAAI,CAAC,CAAC,UAAU,IAAI,CAAC,CAAC,YAAY,EAAE,CAAC;YAClD,iDAAiD;YACjD,IAAI,CAAC,qBAAqB,CAAC,SAAS,EAAE,UAAU,CAAC,CAAC;YAElD,8DAA8D;YAC9D,MAAM,gBAAgB,GAAG,IAAI,CAAC,mBAAmB,CAAC,YAAY,CAAC,CAAC;YAEhE,6CAA6C;YAC7C,IAAI,CAAC,CAAC,gBAAgB,EAAE,CAAC;gBACvB,gBAAgB,GAAG,gBAAgB,CAAC,WAAW,CAAC;YAClD,CAAC;QACH,CAAC;QACD,IAAI,gBAAgB,KAAK,SAAS,EAAE,CAAC;YACnC,2KAA2K;YAC3K,gBAAgB,GAAG,IAAI,CAAC,gBAAgB,GAAG,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,IAAI,CAAC,gBAAgB,EAAE,CAAC;QAC7E,CAAC;QAED,gCAAgC;QAChC,IAAI,CAAC,SAAS,CAAC,IAAI,CAAC,EAAC,GAAG,EAAE,YAAY,CAAC,aAAa,EAAE,IAAI,EAAE,EAAC,WAAW,EAAE,IAAI,CAAC,YAAY,EAAC,EAAC,CAAC,CAAC;QAE/F,mBAAmB;QACnB,IAAI,CAAC,sBAAsB,CAAC,IAAI,CAAC,YAAa,CAAC,SAAS,CAAC,gBAAgB,CAAC,CAAC,CAAC;IAC9E,CAAC;IAED,EAAE,CAAC,GAAG,GAAkB;QACtB,OAAO,IAAI,CAAC,SAAS,CAAC,YAAY,EAAE,CAAC,IAAI,CACxC,MAAM,CAAC,KAAK,CAAC,EAAE,CAAC,GAAG,CAAC,QAAQ,CAAC,KAAK,CAAC,GAAG,CAAC,CAAC,EACxC,GAAG,CAAC,KAAK,CAAC,EAAE,CAAC,KAAK,CAAC,IAAI,CAAC,CACxB,CAAC;IACJ,CAAC;IAED,gBAAgB;QACd,MAAM,eAAe,GAAG,IAAI,CAAC,gBAAgB,CAAC,KAAK,CAAC;QACpD,IAAI,CAAC,eAAe,EAAE,CAAC;YACrB,OAAO;QACT,CAAC;QACD,mDAAmD;QACnD,IAAI,CAAC,IAAI,CAAC,UAAU,CAAC,kBAAkB,CAAC,eAAe,CAAC,YAAY,CAAC,EAAE,CAAC;YACtE,OAAQ;QACV,CAAC;QAED,sCAAsC;QACtC,IAAI,CAAC,CAAC,eAAe,CAAC,UAAU,EAAE,CAAC;YACjC,IAAI,CAAC,MAAM,CAAC,iBAAiB,CAAC,eAAe,CAAC,UAAU,CAAC,CAAC;QAC5D,CAAC;QACD,IAAI,CAAC,sBAAsB,CAAC,IAAI,CAAC,YAAa,CAAC,SAAS,CAAC,IAAI,CAAC,gBAAgB,EAAE,CAAC,CAAC,CAAC;IACrF,CAAC;IAED,gBAAgB;QACd,IAAI,CAAC,mBAAmB,CAAC,GAAG,EAAE,CAAC,CAAC,qDAAqD;QACrF,MAAM,mBAAmB,GAAG,IAAI,CAAC,mBAAmB,CAAC,GAAG,EAAE,CAAC,CAAC,8FAA8F;QAC1J,IAAI,CAAC,CAAC,mBAAmB,EAAE,CAAC;YAC1B,MAAM,YAAY,GAAG,IAAI,CAAC,YAAY,EAAE,SAAS,CAAC,mBAAmB,CAAC,CAAC;YACvE,IAAI,CAAC,CAAC,YAAY,EAAE,CAAC;gBACnB,IAAI,CAAC,sBAAsB,CAAC,YAAY,CAAC,CAAC;YAC5C,CAAC;QACH,CAAC;IACH,CAAC;IAED,kBAAkB,CAAC,IAAY;QAC7B,MAAM,MAAM,GAAG,IAAI,CAAC,UAAU,CAAC,gBAAgB,CAAC,IAAI,CAAC,CAAC;QACtD,OAAO,MAAM,EAAE,gBAAgB,IAAI,KAAK,CAAA;IAC1C,CAAC;IAED,qBAAqB,CAAC,SAAoC,EAAE,UAAkC;QAC5F,uCAAuC;QACvC,IAAI,KAAK,CAAC,OAAO,CAAC,SAAS,CAAC,EAAE,CAAC;YAC7B,SAAS,CAAC,OAAO,CAAC,WAAW,CAAC,EAAE;gBAC9B,IAAI,CAAC,MAAM,CAAC,aAAa,CAAC,WAAW,CAAC,EAAE,EAAE,WAAW,CAAC,EAAE,CAAC,CAAC;YAC5D,CAAC,CAAC,CAAA;QACJ,CAAC;QAED,wBAAwB;QACxB,IAAI,CAAC,UAAU,CAAC,eAAe,CAAC,UAAU,CAAC,CAAC;QAE5C,uHAAuH;QACvH,2EAA2E;QAC3E,MAAM,cAAc,GAAI,UAAU,CAAC,MAAM,CAAC,MAAM,CAAC,EAAE,CAAC,MAAM,CAAC,SAAS,GAAG,CAAC,CAAC,CAAC,GAAG,CAAC,MAAM,CAAC,EAAE,CAAC,MAAM,CAAC,SAAS,CAAC,CAAC;QAE1G,mBAAmB;QACnB,IAAI,CAAC,UAAU,CAAC,SAAS,GAAG,IAAI,CAAC,GAAG,CAAC,GAAG,cAAc,CAAC,CAAC;IAC1D,CAAC;IAED,sBAAsB,CAAC,WAAwB;QAC7C,MAAM,eAAe,GAAG,IAAI,CAAC,gBAAgB,CAAC,KAAK,CAAC;QACpD,MAAM,WAAW,GAAG,IAAI,IAAI,EAAE,CAAC,OAAO,EAAE,CAAC;QAEzC,IAAI,CAAC,CAAC,eAAe,EAAE,CAAC;YACtB;;;gBAGI;YACJ,IAAI,IAAI,CAAC,UAAU,CAAC,SAAS,KAAK,CAAC,IAAI,eAAe,CAAC,WAAW,IAAI,CAAC,EAAE,CAAC;gBACxE,IAAI,CAAC,UAAU,CAAC,SAAS,GAAG,WAAW,CAAC;YAC1C,CAAC;YAED,0DAA0D;YAC1D,MAAM,MAAM,GAAG,IAAI,CAAC,UAAU,CAAC,gBAAgB,CAAC,eAAe,CAAC,YAAY,CAAC,CAAC;YAC9E,IAAI,CAAC,CAAC,MAAM,EAAE,CAAC;gBACb,MAAM,CAAC,UAAU,GAAG,WAAW,CAAC;YAClC,CAAC;YACD,IAAI,CAAC,SAAS,CAAC,IAAI,CAAC,EAAC,GAAG,EAAE,YAAY,CAAC,cAAc,EAAE,IAAI,EAAE,eAAe,EAAC,CAAC,CAAC;QACjF,CAAC;QACD,IAAI,CAAC,mBAAmB,CAAC,IAAI,CAAC,WAAW,CAAC,WAAW,CAAC,CAAC;QACvD,IAAI,CAAC,gBAAgB,CAAC,IAAI,CAAC,WAAW,CAAC,CAAC;QAExC,wDAAwD;QACxD,MAAM,SAAS,GAAG,IAAI,CAAC,UAAU,CAAC,gBAAgB,CAAC,WAAW,CAAC,YAAY,CAAC,CAAC;QAC7E,IAAI,CAAC,CAAC,SAAS,EAAE,CAAC;YAChB,SAAS,CAAC,SAAS,GAAG,WAAW,CAAC;QACpC,CAAC;QACD,IAAI,CAAC,SAAS,CAAC,IAAI,CAAC,EAAC,GAAG,EAAE,YAAY,CAAC,cAAc,EAAE,IAAI,EAAE,WAAW,EAAC,CAAC,CAAC;QAE3E,mDAAmD;QACnD,IAAI,WAAW,CAAC,YAAY,KAAK,KAAK,EAAE,CAAC;YACvC,IAAI,CAAC,gBAAgB,EAAE,CAAC;QAC1B,CAAC;IACH,CAAC;IAED,gBAAgB;QACd,OAAO,IAAI,CAAC,gBAAgB,CAAC,YAAY,EAAE,CAAC;IAC9C,CAAC;IAED,gBAAgB,CAAC,IAAY;QAC3B,OAAO,IAAI,CAAC,UAAU,CAAC,gBAAgB,CAAC,IAAI,CAAC,CAAC;IAChD,CAAC;IAED,aAAa,CAAC,OAAe,EAAE,KAAU;QACvC,IAAI,CAAC,MAAM,CAAC,aAAa,CAAC,OAAO,EAAE,KAAK,CAAC,CAAC;IAC5C,CAAC;IAED,YAAY;QACV,OAAO,IAAI,CAAC,MAAM,CAAC,YAAY,EAAE,CAAC;IACpC,CAAC;IAED,aAAa;QACX,OAAO,IAAI,CAAC,UAAU,CAAC,aAAa,EAAE,CAAC;IACzC,CAAC;IAED,YAAY,CAAC,SAAuB;QAClC,MAAM,MAAM,GAAG,IAAI,CAAC,UAAU,CAAC,gBAAgB,CAAC,SAAS,CAAC,IAAI,CAAC,CAAC;QAChE,IAAI,CAAC,MAAM,EAAE,CAAC;YACZ,OAAO;QACT,CAAC;QAED,0JAA0J;QAC1J,mKAAmK;QACnK,IAAI,IAAI,CAAC,gBAAgB,CAAC,KAAK,EAAE,YAAY,KAAK,aAAa,CAAC,IAAI,EAAE,CAAC;YACrE,MAAM,WAAW,GAAG,IAAI,CAAC,gBAAgB,CAAC,KAAK,EAAE,WAAW,CAAC;YAE7D,2HAA2H;YAC3H,IAAI,CAAC,CAAC,WAAW,EAAE,CAAC;gBAClB,WAAW,CAAC,OAAO,CAAC,OAAO,CAAC,EAAE;oBAC5B,MAAM,sBAAsB,GAAI,IAAI,CAAC,UAAU,CAAC,gBAAgB,CAAC,OAAO,CAAC,WAAW,CAAC,CAAC;oBACtF,IAAI,CAAC,sBAAsB,EAAC,CAAC;wBAC3B,OAAM;oBACR,CAAC;oBACD,MAAM,qBAAqB,GAAG,SAAS,CAAC,MAAM,CAAC,CAAC,CAAG,SAAS,CAAC,MAAuB,CAAC,OAAO,CAAC,WAAW,CAAC,QAAQ,EAAE,CAAC,CAAC,CAAC,CAAC,SAAS,CAAC;oBACjI,sBAAsB,CAAC,WAAW,GAAG,qBAAqB,KAAK,SAAS,CAAC,CAAC,CAAC,aAAa,CAAC,CAAC,CAAC,qBAAqB,CAAC;gBACnH,CAAC,CAAC,CAAC;YACL,CAAC;YACD,8CAA8C;YAC9C,MAAM,CAAC,WAAW,GAAG,CAAC,CAAC;QACzB,CAAC;aAAM,CAAC;YACN,uCAAuC;YACvC,MAAM,CAAC,WAAW,GAAG,SAAS,CAAC,MAAM,CAAC;QACxC,CAAC;QAED,mGAAmG;QACnG,MAAM,CAAC,gBAAgB,GAAG,SAAS,CAAC,UAAU,IAAI,IAAI,CAAC,2BAA2B,EAAE,CAAC;QAErF,+FAA+F;QAC/F,MAAM,CAAC,uBAAuB,CAAC,MAAM,GAAG,CAAC,CAAC;QAC1C,SAAS,CAAC,uBAAuB,CAAC,OAAO,CAAC,EAAE,CAAC,EAAE,CAAC,MAAM,CAAC,uBAAuB,CAAC,IAAI,CAAC,EAAE,CAAC,CAAC,CAAC;QAEzF,MAAM,CAAC,kBAAkB,CAAC,MAAM,GAAG,CAAC,CAAC;QACrC,SAAS,CAAC,kBAAkB,CAAC,OAAO,CAAC,EAAE,CAAC,EAAE,CAAC,MAAM,CAAC,kBAAkB,CAAC,IAAI,CAAC,EAAE,CAAC,CAAC,CAAC;QAE/E,MAAM,CAAC,yBAAyB,CAAC,MAAM,GAAG,CAAC,CAAC;QAC5C,SAAS,CAAC,yBAAyB,CAAC,OAAO,CAAC,EAAE,CAAC,EAAE,CAAC,MAAM,CAAC,yBAAyB,CAAC,IAAI,CAAC,EAAE,CAAC,CAAC,CAAC;QAG7F,MAAM,CAAC,OAAO,CAAC,MAAM,CAAC,gBAAgB,CAAC,CAAC,OAAO,CAAC,CAAC,CAAC,GAAG,CAAC,EAAE,EAAE,CAAC,OAAO,MAAM,CAAC,gBAAgB,CAAC,MAAM,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC;QACxG,MAAM,CAAC,OAAO,CAAC,SAAS,CAAC,iBAAiB,CAAC,CAAC,OAAO,CAAC,CAAC,CAAC,GAAG,EAAE,KAAK,CAAC,EAAE,EAAE,CAAC,MAAM,CAAC,gBAAgB,CAAC,MAAM,CAAC,GAAG,CAAC,CAAC,GAAG,KAAK,CAAC,CAAC;QAEpH,IAAI,CAAC,WAAW,CAAC,SAAS,CAAC,SAAS,CAAC,CAAC;QAEtC,IAAI,CAAC,SAAS,CAAC,IAAI,CAAC,EAAC,GAAG,EAAE,YAAY,CAAC,uBAAuB,EAAE,IAAI,EAAE,EAAC,QAAQ,EAAE,IAAI,CAAC,gBAAgB,CAAC,KAAK,EAAE,gBAAgB,EAAE,MAAM,CAAC,gBAAgB,EAAC,EAAC,CAAC,CAAC;QAE3J,iLAAiL;QACjL,MAAM,QAAQ,GAAG,IAAI,CAAC,mBAAmB,CAAC,SAAS,CAAC,IAAI,CAAC,CAAC;QAC1D,8BAA8B;QAC9B,IAAI,CAAC,CAAC,QAAQ,IAAI,MAAM,CAAC,gBAAgB,IAAI,CAAC,QAAQ,CAAC,YAAY,KAAK,IAAI,IAAI,QAAQ,CAAC,YAAY,KAAK,IAAI,CAAC,IAAI,CAAC,SAAS,CAAC,uBAAuB,CAAC,MAAM,KAAK,CAAC,CAAC,EAAE,CAAC;YACpK,IAAI,CAAC,gBAAgB,EAAE,CAAA;QACzB,CAAC;IACH,CAAC;IAED,WAAW,CAAC,SAA8B;QACxC,MAAM,CAAC,OAAO,CAAC,SAAS,CAAC,CAAC,OAAO,CAAC,CAAC,CAAC,OAAO,EAAE,KAAK,CAAC,EAAE,EAAE;YACrD,IAAI,CAAC,aAAa,CAAC,OAAO,EAAE,KAAK,CAAC,CAAA;QACpC,CAAC,CAAC,CAAA;IACJ,CAAC;IAED,uCAAuC;IACvC,IAAI,gBAAgB;QAClB,sDAAsD;QACtD,OAAO,IAAI,CAAC,YAAY,EAAE,UAAU,CAAC,YAAY,CAAC,MAAM,CAAE,OAAO,CAAC,EAAE,CAAC,OAAO,CAAC,QAAQ,CAAC,CAAC,MAAM,IAAI,CAAC,CAAC;IACrG,CAAC;IAED,gCAAgC;IAChC,IAAI,eAAe;QACjB,OAAO,IAAI,CAAC,YAAY,EAAE,SAAS,CAAC,MAAM,IAAI,CAAC,CAAC;IAClD,CAAC;IAED,gBAAgB;QACd,MAAM,WAAW,GAAG,IAAI,IAAI,EAAE,CAAC;QAC/B,IAAI,WAAW,CAAC;QAChB,IAAI,CAAC;YACH,WAAW,GAAG,IAAI,CAAC,MAAM,CAAC,YAAY,CAAC,IAAI,CAAC,YAAY,EAAE,UAAU,CAAC,iBAAiB,IAAI,EAAE,CAAC,CAAC;QAChG,CAAC;QAAA,OAAO,CAAC,EAAE,CAAC;YACV,WAAW,GAAG,KAAK,CAAC;QACtB,CAAC;QAED,MAAM,SAAS,GAAmB;YAChC,QAAQ,EAAE,CAAC,EAAK,WAAW;YAC3B,MAAM,EAAE,CAAC;YACT,QAAQ,EAAE,CAAC;YACX,UAAU,EAAE,CAAC;YACb,WAAW,EAAE,iBAAiB,CAAC,OAAO;YACtC,KAAK,EAAE,WAAW,CAAC,OAAO;YAC1B,IAAI,EAAE,IAAI,CAAC,YAAY,EAAE,IAAI,CAAC,YAAY,IAAI,CAAC;YAC/C,eAAe,EAAE,IAAI,CAAC,YAAY,EAAE,IAAI,CAAC,IAAI,IAAI,EAAE;YACnD,eAAe,EAAE,IAAI,CAAC,YAAY,EAAE,IAAI,CAAC,gBAAgB,IAAI,CAAC;YAC9D,SAAS,EAAE,IAAI,CAAC,UAAU,CAAC,SAAS;YACpC,UAAU,EAAE,WAAW,CAAC,OAAO,EAAE;YACjC,YAAY,EAAE,WAAW,CAAC,iBAAiB,EAAE;YAC7C,aAAa,EAAE,WAAW;YAC1B,OAAO,EAAE;gBACP,WAAW,EAAE,KAAK,CAAC,IAAI,CAAC,IAAI,CAAC,UAAU,CAAC,aAAa,EAAE,CAAC;aACzD;YACD,eAAe,EAAE;gBACf,0BAA0B,EAAE,IAAI,IAAI,CAAC,IAAI,CAAC,YAAY,EAAE,IAAI,CAAC,qBAAqB,IAAI,CAAC,CAAC,CAAC,OAAO,EAAE;aACnG;YACD,gBAAgB,EAAE,EAAE;YACpB,kBAAkB,EAAE,EAAE;YACtB,SAAS,EAAE,EAAE;SACd,CAAC;QAEF,MAAM,SAAS,GAAG,IAAI,CAAC,MAAM,CAAC,YAAY,EAAE,CAAC;QAC7C,MAAM,CAAC,OAAO,CAAC,SAAS,CAAC,CAAC,OAAO,CAAC,CAAC,CAAC,GAAG,EAAE,KAAK,CAAC,EAAE,EAAE,CAAC,SAAS,CAAC,SAAS,CAAC,IAAI,CAAC,EAAC,EAAE,EAAE,GAAG,EAAE,EAAE,EAAE,KAAK,EAAC,CAAC,CAAC,CAAC;QAEpG,IAAI,CAAC,SAAS,CAAC,IAAI,CAAC,EAAC,GAAG,EAAE,YAAY,CAAC,WAAW,EAAE,IAAI,EAAE,SAAS,EAAC,CAAC,CAAC;IACxE,CAAC;IAED,gBAAgB;QACd,MAAM,eAAe,GAAG,IAAI,CAAC,gBAAgB,CAAC,KAAK,CAAC;QACpD,iBAAiB;QACjB,MAAM,WAAW,GAAG,eAAe,EAAE,YAAY,IAAI,CAAC,CAAC;QACvD,IAAI,IAAI,CAAC,aAAa,CAAC,gBAAgB,IAAI,CAAC,IAAI,CAAC,aAAa,CAAC,yBAAyB,CAAC,WAAW,CAAC,EAAE,CAAC;YACtG,0FAA0F;YAC1F,MAAM,YAAY,GAAG,IAAI,CAAC,mBAAmB,CAAC,IAAI,CAAC,aAAa,CAAC,uBAAuB,CAAC,CAAC;YAC1F,+DAA+D;YAC/D,IAAI,CAAC,CAAC,YAAY,EAAE,CAAC;gBACnB,OAAO,YAAY,CAAC,WAAW,CAAC;YAClC,CAAC;QACH,CAAC;QAED,yJAAyJ;QACzJ,IAAI,eAAe,GAAG,CAAC,eAAe,EAAE,WAAW,IAAI,CAAC,CAAC,GAAG,CAAC,CAAC;QAE9D,mCAAmC;QACnC,IAAI,CAAC,CAAC,eAAe,EAAE,CAAC;YACtB,MAAM,KAAK,GAAG,eAAe,CAAC,SAAS,CAAC,IAAI,CAAC,MAAM,CAAC,EAAE,CAAC,CAAC,MAAM,CAAC,uBAAuB,GAAG,CAAC,CAAC,IAAI,IAAI,CAAC,MAAM,CAAC,YAAY,CAAC,MAAM,CAAC,SAAS,CAAC,CAAE,CAAC;YAC5I,IAAI,CAAC,CAAC,KAAK,EAAE,CAAC;gBACZ,MAAM,QAAQ,GAAG,IAAI,CAAC,mBAAmB,CAAC,KAAK,CAAC,uBAAuB,CAAC,EAAE,WAAW,CAAC;gBACtF,IAAI,MAAM,CAAC,aAAa,CAAC,QAAQ,CAAC,EAAE,CAAC,CAAC,4CAA4C;oBAChF,eAAe,GAAG,QAAS,CAAC;gBAC9B,CAAC;YACH,CAAC;QACH,CAAC;QAED,oEAAoE;QACpE,MAAM,aAAa,GAAG,IAAI,CAAC,eAAe,CAAC;QAC3C,GAAG,CAAC;YACF,+BAA+B;YAC/B,MAAM,CAAC,GAAG,IAAI,CAAC,YAAa,CAAC,SAAS,CAAC,eAAe,CAAC,CAAC;YAExD,uHAAuH;YACvH,IAAI,CAAC,CAAC,YAAY,KAAK,aAAa,CAAC,KAAK,IAAI,CAAC,IAAI,CAAC,MAAM,CAAC,YAAY,CAAC,CAAC,CAAC,gBAAgB,CAAC,IAAI,CAAC,IAAI,CAAC,aAAa,CAAC,yBAAyB,CAAC,CAAC,CAAC,YAAY,CAAC,CAAC,EAAG,CAAC;gBAC/J,OAAO,eAAe,CAAC;YACzB,CAAC;YACD,qEAAqE;YACrE,eAAe,EAAE,CAAC;QACpB,CAAC,QAAQ,eAAe,GAAG,aAAa,GAAG,CAAC,EAAE,CAAC,wCAAwC;QACvF,OAAO,eAAe,CAAC;IACzB,CAAC;IAED,kBAAkB,CAAC,YAAgC;QACjD,YAAY,CAAC,OAAO,CAAC,QAAQ,CAAC,EAAE;YAC9B,mCAAmC;YACnC,MAAM,MAAM,GAAG,IAAI,CAAC,UAAU,CAAC,YAAY,CAAC,QAAQ,CAAC,YAAY,EAAE,QAAQ,CAAC,OAAO,CAAC,CAAC;YAErF,mCAAmC;YACnC,IAAI,CAAC,MAAM,EAAE,CAAC;gBACZ,MAAM,IAAI,KAAK,CAAC,kBAAkB,CAAC,CAAC;YACtC,CAAC;YAED,IAAI,CAAC,MAAM,CAAC,aAAa,CAAC,QAAQ,CAAC,OAAO,EAAE,aAAa,CAAC,CAAC,CAAC,4BAA4B;YAExF,qCAAqC;YACrC,QAAQ,CAAC,oBAAoB,CAAC,OAAO,CAAC,EAAE,CAAC,EAAE;gBACzC,MAAM,CAAC,gBAAgB,CAAC,EAAE,CAAC,KAAK,CAAC,GAAG,IAAI,CAAC;gBACzC,IAAI,CAAC,MAAM,CAAC,aAAa,CAAC,GAAG,QAAQ,CAAC,OAAO,GAAG,EAAE,CAAC,OAAO,EAAE,EAAE,aAAa,CAAC,CAAC,CAAC,mCAAmC;YACnH,CAAC,CAAC,CAAC;YAEH,iIAAiI;YACjI,IAAI,CAAC,CAAC,QAAQ,CAAC,UAAU,EAAE,CAAC;gBAC1B,CAAC,QAAQ,CAAC,UAAU,CAAC,KAAK,CAAC,kCAAkC,CAAC,IAAI,EAAE,CAAC,CAAC,GAAG,CAAC,SAAS,CAAC,EAAE,CAAC,SAAS,CAAC,KAAK,CAAC,iBAAiB,CAAE,CAAC,CAAC,CAAC,CAAC,CAAC,OAAO,CAAC,OAAO,CAAC,EAAE,CAAC,IAAI,CAAC,MAAM,CAAC,aAAa,CAAC,OAAO,EAAE,IAAI,CAAC,CAAC,CAAC;YAC9L,CAAC;YAED,+FAA+F;YAC/F,IAAI,QAAQ,CAAC,WAAW,CAAC,MAAM,IAAI,CAAC,EAAE,CAAC,CAAA,qBAAqB;gBAC1D,QAAQ,CAAC,eAAe,CAAC,OAAO,CAAC,GAAG,CAAC,EAAE,CAAC,IAAI,CAAC,MAAM,CAAC,aAAa,CAAC,GAAG,QAAQ,CAAC,OAAO,GAAG,GAAG,CAAC,OAAO,EAAE,EAAE,aAAa,CAAC,CAAC,CAAC;YACzH,CAAC;iBAAM,CAAC;gBACN,oEAAoE;gBACpE,QAAQ,CAAC,WAAW,CAAC,OAAO,CAAC,OAAO,CAAC,EAAE;oBAErC,kCAAkC;oBAClC,MAAM,gBAAgB,GAAG,IAAI,CAAC,UAAU,CAAC,YAAY,CAAC,OAAO,CAAC,WAAW,EAAE,CAAC,CAAC,CAAC;oBAE9E,mCAAmC;oBACnC,IAAI,CAAC,gBAAgB,EAAE,CAAC;wBACtB,MAAM,IAAI,KAAK,CAAC,kBAAkB,CAAC,CAAC;oBACtC,CAAC;oBAED,oGAAoG;oBACpG,IAAI,CAAC,MAAM,CAAC,aAAa,CAAC,OAAO,CAAC,OAAO,EAAE,aAAa,CAAC,CAAC,CAAC,0BAA0B;oBAErF,+BAA+B;oBAC/B,QAAQ,CAAC,eAAe,CAAC,OAAO,CAAC,GAAG,CAAC,EAAE,CAAC,IAAI,CAAC,MAAM,CAAC,aAAa,CAAC,GAAG,OAAO,CAAC,OAAO,GAAG,GAAG,CAAC,OAAO,EAAE,EAAE,aAAa,CAAC,CAAC,CAAC;gBACxH,CAAC,CAAC,CAAA;YACJ,CAAC;QACH,CAAC,CAAC,CAAA;IACJ,CAAC;IAED,qBAAqB;IACrB,mBAAmB,CAAC,IAAY;QAC9B,IAAI,CAAC,IAAI,CAAC,YAAY,EAAE,CAAC;YACvB,OAAO,SAAS,CAAC;QACnB,CAAC;QACD,OAAO,IAAI,CAAC,YAAY,CAAC,SAAS,CAAC,IAAI,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,YAAY,KAAK,IAAI,CAAC,CAAC;IACxE,CAAC;IAED,2BAA2B;QACzB,MAAM,oBAAoB,GAAG,IAAI,CAAC,gBAAgB,CAAC,KAAK,EAAE,iBAAiB,IAAI,EAAE,CAAC;QAClF,gDAAgD;QAChD,IAAI,oBAAoB,CAAC,IAAI,EAAE,KAAK,EAAE,EAAE,CAAC;YACvC,OAAO,IAAI,CAAC;QACd,CAAC;QACD,IAAI,CAAC;YACH,OAAO,IAAI,CAAC,MAAM,CAAC,YAAY,CAAC,oBAAoB,CAAC,CAAC;QACxD,CAAC;QAAC,OAAO,CAAC,EAAE,CAAC;YACX,OAAO,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC;YACjB,OAAO,KAAK,CAAC;QACf,CAAC;IACH,CAAC;8GArZU,mBAAmB,kBAOV,WAAW;kHAPpB,mBAAmB,cAFlB,MAAM;;2FAEP,mBAAmB;kBAH/B,UAAU;mBAAC;oBACV,UAAU,EAAE,MAAM;iBACnB;;0BAQc,MAAM;2BAAC,WAAW","sourcesContent":["import {DestroyRef, inject, Inject, Injectable, PLATFORM_ID} from '@angular/core';\r\nimport {BehaviorSubject, filter, Observable, Subject} from 'rxjs';\r\nimport {SurveyQuotas} from '../tp.servey.quota/tp.survey.quota';\r\nimport {TpSurveyLogicService} from '../tp.survey.logic/tp.survey.logic.service';\r\nimport {isPlatformBrowser} from '@angular/common';\r\nimport {map} from 'rxjs/operators';\r\nimport {AnswerChange, IdbQuestion, IdbQuestionary, IInterviewData, IInterviewLogicVar, IQuestionAnswer} from '../../tp.survey.interface';\r\nimport {TpSurveyInterviewService} from '../tp.survey.interview/tp.survey.interview.service';\r\nimport {QuestionsType, ResultativeStatus, SurveyEvents, ValidStatus} from '../../tp.survey.enum';\r\nimport {Answer} from '../tp.survey.answer/tp.survey.answer';\r\nimport {AnswerSlType, LogicObject} from '../../tp.survey.type';\r\nimport {MISSING_VALUE} from '../../tp.survey.const';\r\nimport {takeUntilDestroyed} from '@angular/core/rxjs-interop';\r\n\r\ninterface BroadcastEvent {\r\n  key: string;\r\n  data?: any;\r\n}\r\n@Injectable({\r\n  providedIn: 'root'\r\n})\r\nexport class TpSurveyCoreService {\r\n  private readonly _eventBus = new Subject<BroadcastEvent>();\r\n  readonly #currentQuestion = new BehaviorSubject<IdbQuestion | null>(null);\r\n  #surveyQuotas = new SurveyQuotas();\r\n  #questionary?: IdbQuestionary;\r\n  #displayedQuestions: Array<number> = []; // нужно для навигации по кнопке back\r\n  readonly #destroyRef = inject(DestroyRef);\r\n  constructor(@Inject(PLATFORM_ID) private readonly platformId: object, private readonly _logic: TpSurveyLogicService, private readonly _interview: TpSurveyInterviewService) {\r\n    // запускам проверку квот, после скрытия каждого(почти) вопроса (seQuestionHide)\r\n    this._eventBus.asObservable().pipe(\r\n     filter(ev => ev.key === SurveyEvents.seQuestionHide ),\r\n     takeUntilDestroyed(this.#destroyRef),\r\n    ).subscribe({\r\n      next: () => this.#surveyQuotas.findFilledQuotas(this.#currentQuestion.value?.QuestionNum ?? -1, Object.assign({}, this._logic.getLogicVars()), this._interview.getAnswerList())\r\n    });\r\n  }\r\n\r\n  setupSurvey(questionaryRawData: IdbQuestionary, logicVars?: Array<IInterviewLogicVar>, answerList?: Array<IQuestionAnswer>, questionGuid?: number) {\r\n    //если анкеты нет, делать нечего.\r\n    if (!questionaryRawData) {\r\n      this.#currentQuestion.next(null);\r\n      return;\r\n    }\r\n\r\n    this.#questionary = questionaryRawData;\r\n\r\n    if (isPlatformBrowser(this.platformId)) {\r\n      //узнаем есть ли вопрос который указали для перехода при заполнении квоты\r\n      const destinationQuestion = this.#findQuestionByGuid(questionaryRawData.BaseParams.QuotaLimitDestinationQuestionGuid);\r\n\r\n      //инициализируем квоты\r\n      this.#surveyQuotas.setQuotas(questionaryRawData.Quotas, questionaryRawData.Quotas2d, destinationQuestion?.QuestionGuid ?? -1, destinationQuestion?.QuestionNum ?? -1);\r\n    }\r\n\r\n    //создадим ответы и логические переменные\r\n    this.#initiateQuestions(this.#questionary.Questions)\r\n\r\n    // Может быть 2 варианта запуска интервью, 1-новое интервью, 2-перезапуск старого интервью. В первом случае начало это lang или первый вопрос. Во втором, с последнего вопроса на который ответили.\r\n    let startQuestionNum: number | undefined = undefined;\r\n    //если загружаем ранее не законченное интервью, продолжаем с места последнего вопроса (случай номер 2)\r\n    if (!!logicVars && !!answerList && !!questionGuid) {\r\n      //загружаем старые логические переменные и ответы\r\n      this.#fillOldInterviewData(logicVars, answerList);\r\n\r\n      //ищем номер вопроса, который был последний перед сохранением.\r\n      const questionLastSave = this.#findQuestionByGuid(questionGuid);\r\n\r\n      //Вопрос могли удалить. Тогда начнем сначала.\r\n      if (!!questionLastSave) {\r\n        startQuestionNum = questionLastSave.QuestionNum;\r\n      }\r\n    }\r\n    if (startQuestionNum === undefined) {\r\n      //Это новое интервью, без ранее сохранённых данных(случай 1). Запускаем опрос, первый экран это Lang вопрос, но если выбора языка нет, пропускаем и переходим на 1-й вопрос\r\n      startQuestionNum = this.#activeLangCount > 1 ? 0 : this.#nextQuestionNum();\r\n    }\r\n\r\n    //пошлём событие о начале опроса\r\n    this._eventBus.next({key: SurveyEvents.seSurveyStart, data: {questionary: this.#questionary}});\r\n\r\n    //показываем вопрос\r\n    this.#changeCurrentQuestion(this.#questionary!.Questions[startQuestionNum]);\r\n  }\r\n\r\n  on(...key: Array<string>): Observable<any> {\r\n    return this._eventBus.asObservable().pipe(\r\n     filter(event => key.includes(event.key)),\r\n     map(event => event.data)\r\n    );\r\n  }\r\n\r\n  goToNextQuestion(): void {\r\n    const currentQuestion = this.#currentQuestion.value;\r\n    if (!currentQuestion) {\r\n      return;\r\n    }\r\n    //если ответ на текущий вопрос не закончен, выходим\r\n    if (!this._interview.questionIsComplete(currentQuestion.QuestionGuid)) {\r\n      return ;\r\n    }\r\n\r\n    //если указан PostScript, выполним его\r\n    if (!!currentQuestion.PostScript) {\r\n      this._logic.executePostScript(currentQuestion.PostScript);\r\n    }\r\n    this.#changeCurrentQuestion(this.#questionary!.Questions[this.#nextQuestionNum()]);\r\n  }\r\n\r\n  goToBackQuestion(): void {\r\n    this.#displayedQuestions.pop(); // удалим информацию о том что показывали этот вопрос\r\n    const previousQuestionNum = this.#displayedQuestions.pop(); // узнаем номер вопроса на который нам надо перейти, и удалим информацию что-бы не дублировать\r\n    if (!!previousQuestionNum) {\r\n      const prevQuestion = this.#questionary?.Questions[previousQuestionNum];\r\n      if (!!prevQuestion) {\r\n        this.#changeCurrentQuestion(prevQuestion);\r\n      }\r\n    }\r\n  }\r\n\r\n  questionIsComplete(guid: number): boolean {\r\n    const answer = this._interview.findAnswerByGuid(guid);\r\n    return answer?.answerIsComplete ?? false\r\n  }\r\n\r\n  #fillOldInterviewData(logicVars: Array<IInterviewLogicVar>, answerList: Array<IQuestionAnswer>): void{\r\n    //пропишем старые логические переменные\r\n    if (Array.isArray(logicVars)) {\r\n      logicVars.forEach(logicVarObj => {\r\n        this._logic.setLogicValue(logicVarObj.nm, logicVarObj.vl);\r\n      })\r\n    }\r\n\r\n    //пропишем старые ответы\r\n    this._interview.overrideAnswers(answerList);\r\n\r\n    //нужно вернуть время начала интервью, отдельно оно не сохраняется, поэтому возьмём минимальное время начала из ответов\r\n    //фильтруем все вопросы у которых оно указано(>0) и трансформируем в число.\r\n    const startedAtArray =  answerList.filter(answer => answer.StartedAt > 0).map(answer => answer.StartedAt);\r\n\r\n    //берём минимальное\r\n    this._interview.startedAt = Math.min(...startedAtArray);\r\n  }\r\n\r\n  #changeCurrentQuestion(newQuestion: IdbQuestion): void {\r\n    const currentQuestion = this.#currentQuestion.value;\r\n    const currentTime = new Date().getTime();\r\n\r\n    if (!!currentQuestion) {\r\n      /*\r\n      Сохраним время начала интервью. Фиксировать будем не с самого начала, а с ответа на первый вопрос.\r\n      Потому что практика такая, открыть анкету на планшете и ходить искать респондентов и из-за этого длительность интервью может быть нерелевантно.\r\n      * */\r\n      if (this._interview.startedAt === 0 && currentQuestion.QuestionNum >= 0) {\r\n        this._interview.startedAt = currentTime;\r\n      }\r\n\r\n      //нужно сохранить FinishedAt в ответах для старого вопроса\r\n      const answer = this._interview.findAnswerByGuid(currentQuestion.QuestionGuid);\r\n      if (!!answer) {\r\n        answer.FinishedAt = currentTime;\r\n      }\r\n      this._eventBus.next({key: SurveyEvents.seQuestionHide, data: currentQuestion});\r\n    }\r\n    this.#displayedQuestions.push(newQuestion.QuestionNum);\r\n    this.#currentQuestion.next(newQuestion);\r\n\r\n    //нужно сохранить StartedAt в ответах для нового вопроса\r\n    const answerNew = this._interview.findAnswerByGuid(newQuestion.QuestionGuid);\r\n    if (!!answerNew) {\r\n      answerNew.StartedAt = currentTime;\r\n    }\r\n    this._eventBus.next({key: SurveyEvents.seQuestionShow, data: newQuestion});\r\n\r\n    //если новый экран это end тогда завершаем интервью\r\n    if (newQuestion.QuestionType === 'END') {\r\n      this.#finishInterview();\r\n    }\r\n  }\r\n\r\n  currentQuestion$(): Observable<IdbQuestion | null> {\r\n    return this.#currentQuestion.asObservable();\r\n  }\r\n\r\n  findAnswerByGuid(guid: number): Answer | undefined {\r\n    return this._interview.findAnswerByGuid(guid);\r\n  }\r\n\r\n  setLogicValue(varName: string, value: any): void {\r\n    this._logic.setLogicValue(varName, value);\r\n  }\r\n\r\n  getLogicVars(): LogicObject {\r\n    return this._logic.getLogicVars();\r\n  }\r\n\r\n  getAnswerList(): Array<Answer> {\r\n    return this._interview.getAnswerList();\r\n  }\r\n\r\n  updateAnswer(eventData: AnswerChange): void {\r\n    const answer = this._interview.findAnswerByGuid(eventData.guid);\r\n    if (!answer) {\r\n      return;\r\n    }\r\n\r\n    //вопросы которые в своем составе имеет секции, хранят ответы чуть по другому, точнее ответ на каждую секцию это отдельный объект в  _interview.answerList\r\n    //поэтому ответ для таких типов вопросов это [key: string]: Array<number> | number, где key(guid секции) это ответ на секцию, если key нет, секция не была показана\r\n    if (this.#currentQuestion.value?.QuestionType === QuestionsType.eqSL) {\r\n      const sectionList = this.#currentQuestion.value?.Sectionlist;\r\n\r\n      //пройдёмся по каждой секции и если для неё есть ответ, запишем, в противном случае вместо ответа укажем -97(MISSING_VALUE)\r\n      if (!!sectionList) {\r\n        sectionList.forEach(section => {\r\n          const sectionInterviewAnswer =  this._interview.findAnswerByGuid(section.SectionGuid);\r\n          if (!sectionInterviewAnswer){\r\n            return\r\n          }\r\n          const sectionQuestionAnswer = eventData.answer ?  (eventData.answer as AnswerSlType)[section.SectionGuid.toString()] : undefined;\r\n          sectionInterviewAnswer.AnswerValue = sectionQuestionAnswer === undefined ? MISSING_VALUE : sectionQuestionAnswer;\r\n        });\r\n      }\r\n      //ответ самого исходного вопроса должен быть 1\r\n      answer.AnswerValue = 1;\r\n    } else {\r\n      //ответ на вопрос у которого нет секций\r\n      answer.AnswerValue = eventData.answer;\r\n    }\r\n\r\n    //на вопрос ответили тогда когда есть все ответы и выполняется логика кнопки далее(если её указали)\r\n    answer.answerIsComplete = eventData.isComplete && this.#nextButtonExpressionIsTrue();\r\n\r\n    //ViewedAlternativeValues и ViewedSectionGuids. Т.к. они readonly сначала удалим, потом добавим\r\n    answer.ViewedAlternativeValues.length = 0;\r\n    eventData.viewedAlternativeValues.forEach(oa => answer.ViewedAlternativeValues.push(oa));\r\n\r\n    answer.ViewedSectionGuids.length = 0;\r\n    eventData.viewedSectionGuids.forEach(oa => answer.ViewedSectionGuids.push(oa));\r\n\r\n    answer.AlternativeSequenceClicks.length = 0;\r\n    eventData.alternativeSequenceClicks.forEach(oa => answer.AlternativeSequenceClicks.push(oa));\r\n\r\n\r\n    Object.entries(answer.AnswerAdditional).forEach(([key]) => delete answer.AnswerAdditional[Number(key)]);\r\n    Object.entries(eventData.additionalAnswers).forEach(([key, value]) => answer.AnswerAdditional[Number(key)] = value);\r\n\r\n    this.updateLogic(eventData.logicVars);\r\n\r\n    this._eventBus.next({key: SurveyEvents.seQuestionAnswersChange, data: {question: this.#currentQuestion.value, answerIsComplete: answer.answerIsComplete}});\r\n\r\n    //может возникнуть ситуация, когда нет ни одной альтернативы или секции для отображения.в этом случае вопрос показывать не нужно, как ответ записываем 0 и переходим на следующий\r\n    const question = this.#findQuestionByGuid(eventData.guid);\r\n    //ситуация для ss/ms вопросов,\r\n    if (!!question && answer.answerIsComplete && (question.QuestionType === 'SS' || question.QuestionType === 'MS') && (eventData.viewedAlternativeValues.length === 0)) {\r\n      this.goToNextQuestion()\r\n    }\r\n  }\r\n\r\n  updateLogic(logicVars: Record<string, any>): void{\r\n    Object.entries(logicVars).forEach(([varName, value]) => {\r\n      this.setLogicValue(varName, value)\r\n    })\r\n  }\r\n\r\n  //возвращает количество активных языков\r\n  get #activeLangCount(): number {\r\n    //если анкета по какой-то причине ну указана, вернём 0\r\n    return this.#questionary?.BaseParams.LanguageList.filter( langObj => langObj.isActive).length ?? 0;\r\n  }\r\n\r\n  //возвращает количество вопросов\r\n  get #questionsCount(): number {\r\n    return this.#questionary?.Questions.length ?? 0;\r\n  }\r\n\r\n  #finishInterview(): void {\r\n    const currentTime = new Date();\r\n    let resultDirty;\r\n    try {\r\n      resultDirty = this._logic.executeLogic(this.#questionary?.BaseParams.ResultativeScript ?? '');\r\n    }catch (e) {\r\n      resultDirty = false;\r\n    }\r\n\r\n    const interview: IInterviewData = {\r\n      Language: 0,    //todo lang\r\n      SpotId: 0,\r\n      DeviceId: 0,\r\n      DeviceType: 0,\r\n      Resultative: ResultativeStatus.rsUnset,\r\n      Valid: ValidStatus.vsUnset,\r\n      Wave: this.#questionary?.Info.current_wave ?? 0,\r\n      QuestionaryName: this.#questionary?.Info.name ?? '',\r\n      QuestionaryGuid: this.#questionary?.Info.questionary_guid ?? 0,\r\n      StartedAt: this._interview.startedAt,\r\n      FinishedAt: currentTime.getTime(),\r\n      TineZoneBias: currentTime.getTimezoneOffset(),\r\n      ResultatDirty: resultDirty,\r\n      Answers: {\r\n        AnsversList: Array.from(this._interview.getAnswerList())\r\n      },\r\n      additional_info: {\r\n        QuestionaryUpdateTimestamp: new Date(this.#questionary?.Info.last_update_timestamp ?? 0).getTime() ,\r\n      },\r\n      ResultQuotaGuids: [],\r\n      ResultQuota2dGuids: [],\r\n      LogicVars: [],\r\n    };\r\n\r\n    const logicVars = this._logic.getLogicVars();\r\n    Object.entries(logicVars).forEach(([key, value]) => interview.LogicVars.push({nm: key, vl: value}));\r\n\r\n    this._eventBus.next({key: SurveyEvents.seSurveyEnd, data: interview});\r\n  }\r\n\r\n  #nextQuestionNum(): number {\r\n    const currentQuestion = this.#currentQuestion.value;\r\n    // проверим квоты\r\n    const currentGuid = currentQuestion?.QuestionGuid ?? 0;\r\n    if (this.#surveyQuotas.quotaIsCompleted && !this.#surveyQuotas.guidIsDestinationQuestion(currentGuid)) {\r\n      // у нас есть заполненная квота, найдем вопрос который нужно показать при заполнении квоты\r\n      const destinationQ = this.#findQuestionByGuid(this.#surveyQuotas.destinationQuestionGuid);\r\n      //если вопрос есть(его могли удалить из анкеты), показывает его\r\n      if (!!destinationQ) {\r\n        return destinationQ.QuestionNum;\r\n      }\r\n    }\r\n\r\n    // если нет заполненной квоты, переходим на следующий вопрос, ищем следующий вопрос который мы можем отобразить (до логика может запретить показ вопроса)\r\n    let nextQuestionNum = (currentQuestion?.QuestionNum ?? 0) + 1;\r\n\r\n    // но сначала проверим после логику\r\n    if (!!currentQuestion) {\r\n      const destQ = currentQuestion.logiclist.find(logObj => (logObj.DestinationQuestionGuid > 0) && this._logic.executeLogic(logObj.LogicText) );\r\n      if (!!destQ) {\r\n        const destQNum = this.#findQuestionByGuid(destQ.DestinationQuestionGuid)?.QuestionNum;\r\n        if (Number.isSafeInteger(destQNum)) { // вопрос мог быть удалён, а логику оставить\r\n          nextQuestionNum = destQNum!;\r\n        }\r\n      }\r\n    }\r\n\r\n    // общее количество вопросов, цикл будет считать до этого количества\r\n    const questionCount = this.#questionsCount;\r\n    do {\r\n      //потенциально следующий вопрос\r\n      const q = this.#questionary!.Questions[nextQuestionNum];\r\n\r\n      //если это последний вопрос или если выполняется BeforeExpression и этот вопрос не DestinationQuota, можем его показать\r\n      if (q.QuestionType === QuestionsType.eqEND || (this._logic.executeLogic(q.BeforeExpression) && !this.#surveyQuotas.guidIsDestinationQuestion(q.QuestionGuid)) ) {\r\n        return nextQuestionNum;\r\n      }\r\n      //вопрос нельзя показывать, увеличиваем счётчик текущего вопроса на 1\r\n      nextQuestionNum++;\r\n    } while (nextQuestionNum < questionCount - 1); // end вопрос должен всегда быть показан\r\n    return nextQuestionNum;\r\n  }\r\n\r\n  #initiateQuestions(questionList: Array<IdbQuestion>): void{\r\n    questionList.forEach(question => {\r\n      //создаём пустой ответ для вопроса.\r\n      const answer = this._interview.createAnswer(question.QuestionGuid, question.Version);\r\n\r\n      //такого быть не должно, это ошибка\r\n      if (!answer) {\r\n        throw new Error('answer not found');\r\n      }\r\n\r\n      this._logic.setLogicValue(question.SysName, MISSING_VALUE); // переменная самого вопроса\r\n\r\n      //добавим доп ответы и логику для них\r\n      question.AdditionalAnswerlist.forEach(aa => {\r\n        answer.AnswerAdditional[aa.Value] = null;\r\n        this._logic.setLogicValue(`${question.SysName}${aa.SysName}`, MISSING_VALUE); // логика для переменных доп ответа\r\n      });\r\n\r\n      // если в тексте postScript есть запись типа setVar('varName',  value);  нужно инициализировать переменную varName значением -97.\r\n      if (!!question.PostScript) {\r\n        (question.PostScript.match(/(\\bsetvar\\b)\\(['|\"](.*?)['|\"]/gim) ?? []).map(scriptVar => scriptVar.match(/['|\"](.+)['|\"]/i)![1]).forEach(varName => this._logic.setLogicValue(varName, null));\r\n      }\r\n\r\n      // для Вопросов SS/MS нужно прописать логику альтернатив sysname вопроса + sysname альтернативы\r\n      if (question.Sectionlist.length <= 0) {// для Вопросов SS/MS\r\n        question.Alternativelist.forEach(alt => this._logic.setLogicValue(`${question.SysName}${alt.SysName}`, MISSING_VALUE));\r\n      } else {\r\n        //для вопросов у которых есть секции проинициализируем каждую секцию\r\n        question.Sectionlist.forEach(section => {\r\n\r\n          //создаём пустой ответ для секции.\r\n          const answerForSection = this._interview.createAnswer(section.SectionGuid, 1);\r\n\r\n          //такого быть не должно, это ошибка\r\n          if (!answerForSection) {\r\n            throw new Error('answer not found');\r\n          }\r\n\r\n          // для Вопросов SL нужно прописать логику альтернатив и секций sysname секции + sysname альтернативы\r\n          this._logic.setLogicValue(section.SysName, MISSING_VALUE); // переменная самой секции\r\n\r\n          //логика альтернатив SL вопроса\r\n          question.Alternativelist.forEach(alt => this._logic.setLogicValue(`${section.SysName}${alt.SysName}`, MISSING_VALUE));\r\n        })\r\n      }\r\n    })\r\n  }\r\n\r\n  //ищет вопрос на guid\r\n  #findQuestionByGuid(guid: number): IdbQuestion | undefined {\r\n    if (!this.#questionary) {\r\n      return undefined;\r\n    }\r\n    return this.#questionary.Questions.find(q => q.QuestionGuid === guid);\r\n  }\r\n\r\n  #nextButtonExpressionIsTrue(): boolean{\r\n    const buttonNextExpression = this.#currentQuestion.value?.BtnNextExpression ?? '';\r\n    //если скрипта для кнопки далее нет, вернём true\r\n    if (buttonNextExpression.trim() === '') {\r\n      return true;\r\n    }\r\n    try {\r\n      return this._logic.executeLogic(buttonNextExpression);\r\n    } catch (e) {\r\n      console.error(e);\r\n      return false;\r\n    }\r\n  }\r\n}\r\n"]}