survery-lib 0.1.9 → 0.1.11

package/src/lib/survery-lib.component.ts

@@ -0,0 +1,308 @@
+import { Component, EventEmitter, OnInit, Output, QueryList, ViewChildren } from '@angular/core';
+import { SurveyLibService } from './services/survey-lib.service';
+import { SurveyDto } from '../shared/dtos/survey.dto';
+import { FormBuilder, FormGroup } from '@ng-stack/forms';
+import { QuestionChildOfSurveryLibFormInterface, RuleQuestionChildOfSurveryLibFormInterface, SurveryLibFormInterface } from '../shared/form-interfaces/survery-lib.form-interface';
+import { QuestionTypeEnum } from '../shared/enums/question-type.enum';
+import { v4 as guidGenerator } from 'uuid';
+import { QuestionAnswerModel } from '../shared/models/question-answer.model';
+import { Observable, of } from 'rxjs';
+import { LogicPropertyEnum } from '../shared/enums/Logic-Property.enum';
+import { RuleExpDto } from '../shared/dtos/rule-exp.dto';
+import { OperatorEnum } from '../shared/enums/operator.enum';
+import { LogicActionEnum } from '../shared/enums/logic-action.enum';
+import { CheckRuleExpsUsecase } from './usecases/check-rule-exps.usecase';
+import { SurveyQuestionResult } from '../shared/models/survery-question-result.model';
+import { DefaultQuestionAnswerDto } from '../shared/dtos/default-question-answers.dto';
+import { QuestionBooleanTemplateComponent } from './components/question-boolean-template/question-boolean-template.component';
+import { QuestionTextTemplateComponent } from './components/question-text-template/question-text-template.component';
+import { QuestionRadioButtonTemplateComponent } from './components/question-radio-button-template/question-radio-button-template.component';
+import { QuestionDropdownTemplateComponent } from './components/question-dropdown-template/question-dropdown-template.component';
+import { QuestionCheckBoxTemplateComponent } from './components/question-check-box-template/question-check-box-template.component';
+import { QuestionMatrixTemplateComponent } from './components/question-matrix-template/question-matrix-template.component';
+declare var $: any;
+
+@Component({
+  selector: 'lib-survery-lib',
+  templateUrl: './survey-lib.component.html',
+  styleUrls: ['./survey-lib.component.scss']
+})
+export class SurveryLibComponent implements OnInit {
+
+  reloadDefaultAnswerId = guidGenerator() as string;
+  surveyData: SurveyDto;
+  defaultAnswers: DefaultQuestionAnswerDto[];
+  rForm: FormGroup<SurveryLibFormInterface>;
+
+  get fCtrls() {
+    return this.rForm.controls;
+  }
+
+  get questionTypeEnum() {
+    return QuestionTypeEnum;
+  }
+
+  get isFirstPage() {
+    return this.fCtrls.currentPageIndex.value == 0;
+  }
+
+  get isLastPage() {
+    return this.fCtrls.currentPageIndex.value == (this.surveyData?.surveyPages.length - 1);
+  }
+
+  get surveyResult(): { answers: SurveyQuestionResult[], currentPageIndex: number } {
+    return {
+      currentPageIndex: this.fCtrls.currentPageIndex.value,
+      answers:
+        this.fCtrls.questionArray.value.filter(x => x.isMatrixGroup != true).map(x => {
+          return {
+            SurveyPageIndex: x.surveyPageIndex,
+            QuestionId: x.questionId,
+            QuestionType: x.questionType,
+            AnswerId: x.answerId,
+            AnswerText: x.answerText,
+            AnswerIdArr: x.answerIdArr
+          } as SurveyQuestionResult
+        })
+    }
+  }
+
+  @Output() surveyResultEmit = new EventEmitter<SurveyQuestionResult[]>();
+
+  constructor(private _surveyLibService: SurveyLibService
+    , private _formBuilder: FormBuilder, private _checkRuleExpsUsecase: CheckRuleExpsUsecase) {
+
+    this.rForm = this._formBuilder.group<SurveryLibFormInterface>({
+      currentPageIndex: [0],
+      questionArray: this._formBuilder.array<QuestionChildOfSurveryLibFormInterface>([]),
+      ruleQuestionArray: this._formBuilder.array<RuleQuestionChildOfSurveryLibFormInterface>([])
+    });
+  }
+
+  ngOnInit(): void {
+    this._surveyLibService.surveyDataObsrv.subscribe(survey => {
+      this.fCtrls.questionArray.clear();
+      this.fCtrls.ruleQuestionArray.clear();
+      this.surveyData = null;
+
+      if (survey != null) {
+        this.surveyData = survey;
+        this.loadQuestions(survey);
+      }
+    });
+
+    this._surveyLibService.surveyAnswersObsrv.subscribe(value => {
+      this.defaultAnswers = [];
+
+      if (value != null) {
+        this.defaultAnswers =[...value.defaultAnswers];
+        this.fCtrls.currentPageIndex.setValue(value.currentpage);
+      }
+
+      console.log( this.reloadDefaultAnswerId);
+      this.reloadDefaultAnswerId =  guidGenerator() as string;
+      console.log( this.reloadDefaultAnswerId);
+    });
+  }
+
+  onPaggingNext() {
+    var isHaveInvalidRecords = this.haveInValidateQuestions();
+    if (isHaveInvalidRecords == false) {
+
+      var currentPageIndex = this.fCtrls.currentPageIndex.value;
+
+      if (currentPageIndex < (this.surveyData.surveyPages.length - 1)) {
+        currentPageIndex = Number(currentPageIndex) + 1;
+        this.fCtrls.currentPageIndex.setValue(currentPageIndex);
+      } else {
+        var questionArr = this.fCtrls.questionArray.value.filter(x => x.isMatrixGroup != true).map(x => {
+          return {
+            SurveyPageIndex: x.surveyPageIndex,
+            QuestionId: x.questionId,
+            QuestionType: x.questionType,
+            AnswerId: x.answerId,
+            AnswerText: x.answerText,
+            AnswerIdArr: x.answerIdArr
+          } as SurveyQuestionResult
+        });
+        this.surveyResultEmit.emit(questionArr);
+      }
+    }
+  }
+
+  onPaggingChange(index) {
+    const formValue = this.rForm.value;
+    if (index < formValue.currentPageIndex) {
+      this.fCtrls.currentPageIndex.setValue(index);
+    } else if (index == (formValue.currentPageIndex + 1)) {
+      this.onPaggingNext();
+    }
+  }
+
+  onPaggingBack() {
+    var currentPageIndex = this.fCtrls.currentPageIndex.value;
+    if (currentPageIndex > 0) {
+      currentPageIndex = Number(currentPageIndex) - 1;
+      this.fCtrls.currentPageIndex.setValue(currentPageIndex);
+    }
+  }
+
+  onUpdateAnswers(model: QuestionAnswerModel[]) {
+    model.forEach(elem => {
+      this.onUpdateAnswer(elem);
+    });
+  }
+
+  onUpdateAnswer(model: QuestionAnswerModel) {
+    const index = this.fCtrls.questionArray.value.findIndex(x => x.questionId == model.QuestionId);
+    var questionGroup = this.fCtrls.questionArray.controls[index];
+    questionGroup.controls.isValid.setValue(model.IsValid);
+
+    if (questionGroup.value.questionType == this.questionTypeEnum.TextInput) {
+      questionGroup.patchValue({
+        answerId: model.SurveyAnswerId,
+        answerText: model.Answer
+      });
+    } else if (questionGroup.value.questionType == this.questionTypeEnum.CheckBox || questionGroup.value.questionType == this.questionTypeEnum.DropDownMulti) {
+      questionGroup.controls.answerIdArr.setValue(model.Answer);
+    } else {
+      questionGroup.controls.answerId.setValue(model.Answer);
+    }
+
+    if (this.fCtrls.ruleQuestionArray.value.findIndex(x => x.questionId == model.QuestionId) > -1) {
+      this.checkRules()
+    }
+  }
+
+  private loadQuestions(survey: SurveyDto) {
+    survey.surveyPages.forEach((page, pageIndex) => {
+      page.surveyQuestionGroups.forEach(group => {
+
+        group.surveyQuestions.forEach(question => {
+
+          if (question.questionTypeId != 6) {
+            this.fCtrls.questionArray.push(this._formBuilder.group<QuestionChildOfSurveryLibFormInterface>({
+              surveyPageIndex: pageIndex,
+              questionId: [question.questionId],
+              questionType: [question.questionTypeId],
+              isMatrixGroup: [false],
+              answerId: [null],
+              answerIdArr: [null],
+              answerText: [null],
+              isRequired: [question.isRequired],
+              isValid: [null],
+              isDisabled: [question.isReadOnly],
+              isShow: [question.isVisable],
+              isDisabled_default: [question.isReadOnly],
+              isShow_default: [question.isVisable]
+            }));
+          } else {
+            this.fCtrls.questionArray.push(this._formBuilder.group<QuestionChildOfSurveryLibFormInterface>({
+              surveyPageIndex: pageIndex,
+              questionId: [question.questionId],
+              questionType: [question.questionTypeId],
+              isMatrixGroup: [true],
+              answerId: [null],
+              answerIdArr: [null],
+              answerText: [null],
+              isRequired: [question.isRequired],
+              isValid: [null],
+              isDisabled: [question.isReadOnly],
+              isShow: [question.isVisable],
+              isDisabled_default: [question.isReadOnly],
+              isShow_default: [question.isVisable],
+            }));
+
+            question.surveySubQuestions.forEach(subQuestion => {
+              this.fCtrls.questionArray.push(this._formBuilder.group<QuestionChildOfSurveryLibFormInterface>({
+                surveyPageIndex: pageIndex,
+                questionId: [subQuestion.questionId],
+                questionType: [subQuestion.questionTypeId],
+                isMatrixGroup: [false],
+                answerId: [null],
+                answerIdArr: [null],
+                answerText: [null],
+                isRequired: [question.isRequired],
+                isValid: [null],
+                isDisabled: [subQuestion.isReadOnly],
+                isShow: [subQuestion.isVisable],
+                isDisabled_default: [subQuestion.isReadOnly],
+                isShow_default: [subQuestion.isVisable]
+              }));
+            })
+          }
+        });
+
+      });
+    });
+
+    survey.surveyRules.forEach(rule => {
+      rule.ruleExps.forEach(ruleExp => {
+        this.fCtrls.ruleQuestionArray.push(this._formBuilder.group<RuleQuestionChildOfSurveryLibFormInterface>({
+          questionId: ruleExp.questionId
+        }));
+      });
+    })
+  }
+
+  private haveInValidateQuestions() {
+    const currentPageIndex = this.fCtrls.currentPageIndex.value;
+    var invalidRecords = this.fCtrls.questionArray.value.filter(x => x.surveyPageIndex == currentPageIndex
+      && x.isRequired == true && x.isValid != true
+      && x.isDisabled == false && x.isShow == true && x.isMatrixGroup != true);
+    if (invalidRecords.length > 0) {
+      $(`#survey-page_${currentPageIndex}`).addClass('survey-page_submitted');
+    }
+
+    if (invalidRecords.length > 0) {
+      console.log(invalidRecords);
+    }
+    return invalidRecords.length > 0;
+  }
+
+  private checkRules() {
+
+    this.surveyData.surveyRules.forEach(rule => {
+      this._checkRuleExpsUsecase.execute({
+        ruleExps: rule.ruleExps,
+        questions: this.fCtrls.questionArray.value
+      }).subscribe(result => {
+
+        var isPassed = result.exprestionResultArr.filter(x => x == false).length == 0;
+        if (isPassed) {
+
+          rule.ruleResultQuestions.forEach(resultQuestion => {
+            const index = this.fCtrls.questionArray.value.findIndex(x => x.questionId == resultQuestion.questionId);
+            var questionGroup = this.fCtrls.questionArray.at(index);
+            if (rule.logicActionId == LogicActionEnum.Show) {
+              questionGroup.controls.isShow.setValue(true);
+            } else if (rule.logicActionId == LogicActionEnum.Hide) {
+              questionGroup.controls.isShow.setValue(false);
+            } else if (rule.logicActionId == LogicActionEnum.Enable) {
+              questionGroup.controls.isDisabled.setValue(false);
+            } else if (rule.logicActionId == LogicActionEnum.Disable) {
+              questionGroup.controls.isDisabled.setValue(true);
+            } else if (rule.logicActionId == LogicActionEnum.SetAnswer) {
+
+            }
+
+          });
+        }
+        else {
+          rule.ruleResultQuestions.forEach(resultQuestion => {
+            const index = this.fCtrls.questionArray.value.findIndex(x => x.questionId == resultQuestion.questionId);
+            var questionGroup = this.fCtrls.questionArray.at(index);
+            questionGroup.patchValue({
+              isShow: questionGroup.value.isShow_default,
+              isDisabled: questionGroup.value.isDisabled_default
+            })
+          });
+        }
+      });
+
+    });
+  }
+
+
+
+}

package/src/lib/survery-lib.module.ts

@@ -0,0 +1,47 @@
+import { ModuleWithProviders, NgModule } from '@angular/core';
+import { SurveryLibComponent } from './survery-lib.component';
+import { CommonModule } from '@angular/common';
+import { HttpClientModule } from '@angular/common/http';
+import { ReactiveFormsModule, FormsModule } from '@angular/forms';
+import { NgsFormsModule } from '@ng-stack/forms';
+import { QuestionTextTemplateComponent } from './components/question-text-template/question-text-template.component';
+import { QuestionRadioButtonTemplateComponent } from './components/question-radio-button-template/question-radio-button-template.component';
+import { QuestionCheckBoxTemplateComponent } from './components/question-check-box-template/question-check-box-template.component';
+import { QuestionDropdownTemplateComponent } from './components/question-dropdown-template/question-dropdown-template.component';
+import { QuestionMatrixTemplateComponent } from './components/question-matrix-template/question-matrix-template.component';
+import { QuestionBooleanTemplateComponent } from './components/question-boolean-template/question-boolean-template.component';
+import { FilterQuestionPipe } from './pipes/filter-question.pipe';
+import { DefaultQuestionAnswerPipe } from './pipes/default-question-answer.pipe';
+import { DefaultQuestionAnswersPipe } from './pipes/default-question-answers.pipe';
+import { QuestionDropdownMultiTemplateComponent } from './components/question-dropdown-multi-template/question-dropdown-multi-template.component';
+import { NgSelectModule } from '@ng-select/ng-select';
+
+
+@NgModule({
+  declarations: [
+    SurveryLibComponent,
+    QuestionTextTemplateComponent,
+    QuestionRadioButtonTemplateComponent,
+    QuestionCheckBoxTemplateComponent,
+    QuestionDropdownTemplateComponent,
+    QuestionMatrixTemplateComponent,
+    QuestionBooleanTemplateComponent,
+    QuestionDropdownMultiTemplateComponent,
+    FilterQuestionPipe,
+    DefaultQuestionAnswerPipe,
+    DefaultQuestionAnswersPipe
+  ],
+  imports: [
+    CommonModule, HttpClientModule, ReactiveFormsModule, FormsModule , NgsFormsModule ,NgSelectModule
+  ],
+  exports: [
+    SurveryLibComponent
+  ]
+})
+export class SurveryLibModule {
+  public static forRoot(): ModuleWithProviders<SurveryLibModule> {
+    return {
+      ngModule: SurveryLibModule
+    }
+  }
+ }

package/src/lib/survey-lib.component.html

@@ -0,0 +1,67 @@
+<div class="survay-card" *ngIf="surveyData != null">
+  <div *ngFor="let surveyPage of surveyData?.surveyPages; let surveyPageIndex = index"
+    [attr.id]="'survey-page_'+surveyPageIndex" [ngClass]="{'d-none': surveyPageIndex != fCtrls.currentPageIndex.value}">
+    <ng-container *ngFor="let item of surveyPage.surveyQuestionGroups">
+      <div class="survay-card">
+        <div class="survay-card-body">
+          <div class="survay-group">
+            <div class="title">
+              <h2 class="group-title">
+                {{item.questionGroupName}}
+              </h2>
+              <span class="group-sub-title ">
+                {{item.questionGroupDescription}}
+              </span>
+            </div>
+            <ng-container *ngFor="let question of item.surveyQuestions">
+              <lib-question-boolean-template #questionBooleanTemplate [setQuestion]="question" (emitter)="onUpdateAnswer($event)"
+                *ngIf="question.questionTypeId == questionTypeEnum.Boolean"
+                [isShow]=" (question|filterQuestion : fCtrls.questionArray.value).isShow"
+                [isDisabled]="(question|filterQuestion : fCtrls.questionArray.value).isDisabled" ></lib-question-boolean-template>
+
+              <lib-question-text-template #questionTextTemplate [setQuestion]="question" (emitter)="onUpdateAnswer($event)"
+                *ngIf="question.questionTypeId == questionTypeEnum.TextInput"
+                [isShow]=" (question|filterQuestion : fCtrls.questionArray.value).isShow"
+                [isDisabled]="(question|filterQuestion : fCtrls.questionArray.value).isDisabled"
+                [isTextArea]="question.isAdvanceTextArea" ></lib-question-text-template>
+
+              <lib-question-radio-button-template #questionRadioButtonTemplate [setQuestion]="question" (emitter)="onUpdateAnswer($event)"
+                *ngIf="question.questionTypeId == questionTypeEnum.RadioButton"
+                [isShow]=" (question|filterQuestion : fCtrls.questionArray.value).isShow"
+                [isDisabled]="(question|filterQuestion : fCtrls.questionArray.value).isDisabled" ></lib-question-radio-button-template>
+
+              <lib-question-dropdown-template #questionDropdownTemplate [setQuestion]="question" (emitter)="onUpdateAnswer($event)"
+                *ngIf="question.questionTypeId == questionTypeEnum.DropDown"
+                [isShow]=" (question|filterQuestion : fCtrls.questionArray.value).isShow"
+                [isDisabled]="(question|filterQuestion : fCtrls.questionArray.value).isDisabled" ></lib-question-dropdown-template>
+
+                <lib-question-dropdown-multi-template [setQuestion]="question" (emitter)="onUpdateAnswer($event)"
+                *ngIf="question.questionTypeId == questionTypeEnum.DropDownMulti"
+                [isShow]=" (question|filterQuestion : fCtrls.questionArray.value).isShow"
+                [isDisabled]="(question|filterQuestion : fCtrls.questionArray.value).isDisabled"></lib-question-dropdown-multi-template>
+                
+              <lib-question-check-box-template #questionCheckBoxTemplate [setQuestion]="question" (emitter)="onUpdateAnswer($event)"
+                *ngIf="question.questionTypeId == questionTypeEnum.CheckBox"
+                [isShow]=" (question|filterQuestion : fCtrls.questionArray.value).isShow"
+                [isDisabled]="(question|filterQuestion : fCtrls.questionArray.value).isDisabled" ></lib-question-check-box-template>
+
+              <lib-question-matrix-template #questionMatrixTemplate [setQuestion]="question" (emitter)="onUpdateAnswer($event)"
+                *ngIf="question.questionTypeId == questionTypeEnum.Matrix"
+                [isShow]=" (question|filterQuestion : fCtrls.questionArray.value).isShow"
+                [isDisabled]="(question|filterQuestion : fCtrls.questionArray.value).isDisabled" ></lib-question-matrix-template>
+            </ng-container>
+          </div>
+        </div>
+      </div>
+    </ng-container>
+  </div>
+  <div class="survay-card-footr" *ngIf="surveyData != null">
+    <div class="container" style=" justify-content: start;">
+      <div class="survay-pagination fw-bold" >
+        <span>{{fCtrls.currentPageIndex.value + 1}}</span>
+        <span class="ms-2 me-2">of</span>
+        <span>{{surveyData.surveyPages.length}}</span>
+      </div>
+    </div>
+  </div>
+</div>

package/src/lib/survey-lib.component.scss

@@ -0,0 +1,4 @@
+.disable__btn {
+    background-color: gray !important;
+    cursor: not-allowed;
+}

package/{lib/usecases/base/use-case.d.ts → src/lib/usecases/base/use-case.ts}

@@ -1,7 +1,9 @@
-import { Observable } from 'rxjs';
-export interface UseCase<S, T> {
-    execute(params: S): Observable<T>;
-}
-export interface UseCaseWithoutObserv<S, T> {
-    execute(params: S): T;
-}
+import { Observable } from 'rxjs';
+
+export interface UseCase<S, T> {
+  execute(params: S): Observable<T>;
+}
+
+export interface UseCaseWithoutObserv<S, T> {
+  execute(params: S): T;
+}

package/src/lib/usecases/check-rule-exps.usecase.ts

@@ -0,0 +1,188 @@
+import { Observable, of } from "rxjs";
+import { UseCase } from "./base/use-case";
+import { SurveyRuleDto } from "../../shared/dtos/survey-rule.dto";
+import { Injectable } from "@angular/core";
+import { QuestionChildOfSurveryLibFormInterface } from "../../shared/form-interfaces/survery-lib.form-interface";
+import { RuleExpDto } from "../../shared/dtos/rule-exp.dto";
+import { QuestionTypeEnum } from "../../shared/enums/question-type.enum";
+import { LogicPropertyEnum } from "../../shared/enums/Logic-Property.enum";
+import { OperatorEnum } from "../../shared/enums/operator.enum";
+
+@Injectable({
+  providedIn: 'root'
+})
+export class CheckRuleExpsUsecase implements UseCase<CheckRulesUsecaseModel, CheckRulesUsecaseResult>{
+
+  constructor() {
+
+  }
+
+  execute(params: CheckRulesUsecaseModel): Observable<CheckRulesUsecaseResult> {
+
+    var useCaseResult: CheckRulesUsecaseResult = {
+      exprestionResultArr: []
+    };
+
+    params.ruleExps.forEach(ruleExp => {
+      const index = params.questions.findIndex(x => x.questionId == ruleExp.questionId);
+      var questionGroupValue = params.questions.at(index);
+
+      var result: boolean;
+
+      if (questionGroupValue.questionType == QuestionTypeEnum.TextInput) {
+        result = this.checkRuleExpForAnswerText(ruleExp, questionGroupValue.answerText)
+      } 
+      else if (questionGroupValue.questionType == QuestionTypeEnum.CheckBox) {
+        result = this.checkRuleExpForAnswerIdArr(ruleExp, questionGroupValue.answerIdArr);
+      } 
+      else {
+        result = this.checkRuleExpForAnswerId(ruleExp, questionGroupValue.answerId);
+      }
+
+      var answers =ruleExp.ruleExpAnswers.map(x=>x.answerId+'-'+x.answerTitle);
+      console.log(`Question ${questionGroupValue.questionId} type ${QuestionTypeEnum[questionGroupValue.questionType]} --- ${result == true ?'passed':'not passed'} ---`,
+      ` answers (${answers.join(' , ')}) logic (${ LogicPropertyEnum[ruleExp.logicPropertyId]}) operator (${OperatorEnum [ruleExp.opporator]})`);
+
+      useCaseResult.exprestionResultArr.push(result);
+    });
+
+    return of(useCaseResult);
+  }
+
+  private checkRuleExpForAnswerId(ruleExp: RuleExpDto, answerId: number) {
+    var ruleExpResultArr: boolean[] = [];
+    if (ruleExp.logicPropertyId == LogicPropertyEnum.GreaterThan) {
+
+      ruleExp.ruleExpAnswers.forEach(answer => {
+        var result = answerId > answer.answerId
+        ruleExpResultArr.push(result);
+      });
+
+    } else if (ruleExp.logicPropertyId == LogicPropertyEnum.GreaterThanOrEqual) {
+
+      ruleExp.ruleExpAnswers.forEach(answer => {
+        var result = answerId >= answer.answerId
+        ruleExpResultArr.push(result);
+      });
+
+    } else if (ruleExp.logicPropertyId == LogicPropertyEnum.LessThan) {
+
+      ruleExp.ruleExpAnswers.forEach(answer => {
+        var result = answerId < answer.answerId
+        ruleExpResultArr.push(result);
+      });
+
+    } else if (ruleExp.logicPropertyId == LogicPropertyEnum.LessThanOrEqual) {
+
+      ruleExp.ruleExpAnswers.forEach(answer => {
+        var result = answerId <= answer.answerId
+        ruleExpResultArr.push(result);
+      });
+
+    } else if (ruleExp.logicPropertyId == LogicPropertyEnum.Equal) {
+
+      ruleExp.ruleExpAnswers.forEach(answer => {
+        var result = answerId == answer.answerId
+        ruleExpResultArr.push(result);
+      });
+
+    } else if (ruleExp.logicPropertyId == LogicPropertyEnum.NotEqual) {
+
+      ruleExp.ruleExpAnswers.forEach(answer => {
+        var result = answerId != answer.answerId
+        ruleExpResultArr.push(result);
+      });
+
+    } else if (ruleExp.logicPropertyId == LogicPropertyEnum.IsEmpty) {
+
+      var result = answerId == null
+      ruleExpResultArr.push(result);
+
+    } else if (ruleExp.logicPropertyId == LogicPropertyEnum.IsNotEmpty) {
+
+      var result = answerId != null
+      ruleExpResultArr.push(result);
+
+    } else if (ruleExp.logicPropertyId == LogicPropertyEnum.AnyOf) {
+
+      var answerIdArr: number[] = ruleExp.ruleExpAnswers.map(x => x.answerId);
+      var result = answerIdArr.findIndex(x => x == answerId) > -1
+      ruleExpResultArr.push(result);
+
+    } else if (ruleExp.logicPropertyId == LogicPropertyEnum.Then) {
+
+      var answerIdArr: number[] = ruleExp.ruleExpAnswers.map(x => x.answerId);
+      var result = answerIdArr.findIndex(x => x == answerId) == -1
+      ruleExpResultArr.push(result);
+
+    }
+
+    if (ruleExpResultArr.length == 0) {
+      return false;
+    }
+    else if (ruleExp.ruleExpAnswers.length == 1) {
+      return ruleExpResultArr.filter(x => x == true).length > 0
+    }
+    else if (ruleExp.opporator == OperatorEnum.Or) {
+      return ruleExpResultArr.filter(x => x == true).length > 0
+    } else {
+      return ruleExpResultArr.filter(x => x == false).length == 0
+    }
+  }
+
+  private checkRuleExpForAnswerIdArr(ruleExp: RuleExpDto, answerIdArr: number[]) {
+    var ruleExpResultArr: boolean[] = [];
+
+    answerIdArr?.forEach(answer => {
+      var isResult = this.checkRuleExpForAnswerId(ruleExp, answer);
+      ruleExpResultArr.push(isResult);
+    })
+
+    if (ruleExpResultArr.length == 0) {
+      return false;
+    }
+    else if (ruleExp.ruleExpAnswers.length == 1) {
+      return ruleExpResultArr.filter(x => x == true).length > 0
+    }
+    else if (ruleExp.opporator == OperatorEnum.Or) {
+      return ruleExpResultArr.filter(x => x == true).length > 0
+    } else {
+      return ruleExpResultArr.filter(x => x == false).length == 0
+    }
+  }
+
+  private checkRuleExpForAnswerText(ruleExp: RuleExpDto, answer: string) {
+    var ruleExpResultArr: boolean[] = [];
+    if (ruleExp.logicPropertyId == LogicPropertyEnum.IsEmpty) {
+
+      var result = answer == null || answer == ''
+      ruleExpResultArr.push(result);
+
+    } else if (ruleExp.logicPropertyId == LogicPropertyEnum.IsNotEmpty) {
+
+      var result = answer != null && answer != ''
+      ruleExpResultArr.push(result);
+
+    }
+
+
+    if (ruleExp.ruleExpAnswers.length == 1) {
+      return ruleExpResultArr.filter(x => x == true).length > 0
+    }
+    else if (ruleExp.opporator == OperatorEnum.Or) {
+      return ruleExpResultArr.filter(x => x == true).length > 0
+    } else {
+      return ruleExpResultArr.filter(x => x == false).length == 0
+    }
+  }
+
+}
+
+export class CheckRulesUsecaseModel {
+  ruleExps: RuleExpDto[];
+  questions: QuestionChildOfSurveryLibFormInterface[];
+}
+
+export class CheckRulesUsecaseResult {
+  exprestionResultArr: boolean[];
+}

package/{public-api.d.ts → src/public-api.ts}

@@ -1,4 +1,8 @@
+/*
+ * Public API Surface of survery-lib
+ */
+
 export * from './lib/survery-lib.component';
 export * from './lib/services/survey-lib.service';
 export * from './lib/survery-lib.module';
-export * from './shared/models/survery-question-result.model';
+export * from './shared/models/survery-question-result.model'

package/src/shared/dtos/default-question-answers.dto.ts

@@ -0,0 +1,10 @@
+import { QuestionTypeEnum } from "../enums/question-type.enum";
+
+export class DefaultQuestionAnswerDto{
+    QuestionId;
+    QuestionType :QuestionTypeEnum;
+    AnswerId;
+    AnswerText;
+    AnswerIdArr :string[];
+    ParentQuestionId;
+}

package/{shared/dtos/rule-exp-answer.dto.d.ts → src/shared/dtos/rule-exp-answer.dto.ts}

@@ -1,5 +1,5 @@
-export interface RuleExpAnswerDto {
-    answerId: number;
-    answerTitle: string;
-    textAnswer?: any;
-}
+export interface RuleExpAnswerDto {
+    answerId: number;
+    answerTitle: string;
+    textAnswer?: any;
+  }