@bnsights/bbsf-admin-portal 1.0.69 → 1.0.70

package/esm2015/lib/Pages/shared/components/survey/survey-info/survey-info.component.js

@@ -183,6 +183,19 @@ export class SurveyInfoComponent extends AppBaseComponent {
             // Add legend
             let legend = chart.children.push(am5.Legend.new(root, {}));
             legend.data.push(series1);
+            if (!this.EN) {
+                legend.labels.template.setAll({
+                    textAlign: 'right',
+                    x: 50,
+                });
+                legend.valueLabels.template.setAll({
+                    textAlign: "right",
+                    paddingRight: 15
+                });
+                legend.itemContainers.template.setAll({
+                    reverseChildren: true,
+                });
+            }
             this.root = root;
         });
         // //chart overview
@@ -234,6 +247,19 @@ export class SurveyInfoComponent extends AppBaseComponent {
             // Add legend
             let legend = chart.children.push(am5.Legend.new(root, {}));
             legend.data.setAll(chart.series.values);
+            if (!this.EN) {
+                legend.labels.template.setAll({
+                    textAlign: 'right',
+                    x: 50,
+                });
+                legend.valueLabels.template.setAll({
+                    textAlign: "right",
+                    paddingRight: 15
+                });
+                legend.itemContainers.template.setAll({
+                    reverseChildren: true,
+                });
+            }
             this.root = root;
         });
     }
@@ -469,4 +495,4 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "12.2.13", ngImpo
                 type: ViewChild,
                 args: ['pagingSubmissionViewElement', { static: false }]
             }] } });
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"survey-info.component.js","sourceRoot":"","sources":["../../../../../../../../../projects/bbsf-admin-portal/src/lib/Pages/shared/components/survey/survey-info/survey-info.component.ts","../../../../../../../../../projects/bbsf-admin-portal/src/lib/Pages/shared/components/survey/survey-info/survey-info.component.html"],"names":[],"mappings":"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","sourcesContent":["import { PublishSurveyComponent } from './publish-survey/publish-survey.component';\r\nimport { AddQuestionComponent } from './add-question/add-question.component';\r\nimport { DeleteQuestionComponent } from './delete-question/delete-question.component';\r\nimport { EditQuestionComponent } from './edit-question/edit-question.component';\r\nimport { EditSurveyComponent } from './../edit-survey/edit-survey.component';\r\nimport { DeleteSurveyComponent } from './../delete-survey/delete-survey.component';\r\nimport { FormGroup } from '@angular/forms';\r\nimport { Component, Inject, Injector, NgZone, OnInit, PLATFORM_ID, ViewChild } from '@angular/core';\r\nimport { AppBaseComponent, BreadCrumb, ControlLayout, DropdownActionItem, FilterItem, FilterType, ForceDirection, InputType, PageHeaderOptions, PagingComponent, PagingOptions, TextBoxOptions } from '@bnsights/bbsf-controls';\r\nimport { CdkDragDrop, moveItemInArray } from '@angular/cdk/drag-drop';\r\nimport { isPlatformBrowser } from \"@angular/common\";\r\nimport * as am5 from \"@amcharts/amcharts5\";\r\nimport * as am5xy from \"@amcharts/amcharts5/xy\";\r\nimport am5themes_Animated from \"@amcharts/amcharts5/themes/Animated\";\r\nimport { ActivatedRoute, Router } from '@angular/router';\r\nimport { MasterLayoutService } from '@bnsights/bbsf-utilities';\r\nimport { UnPublishSurveyComponent } from './unpublish-survey/unpublish-survey.component';\r\nimport { DeleteSubmissionComponent } from '../submissions/delete-submission/delete-submission.component';\r\nimport { EliminateSubmissionComponent } from '../submissions/eliminate-submission/eliminate-submission.component';\r\nimport { UnEliminateSubmissionComponent } from '../submissions/uneliminate-submission/uneliminate-submission.component';\r\nimport { AudienceType, SurveyOptionType, SurveyStatusEnum } from '../../../Enums/Enums';\r\nimport { SurveyQuestionDTO } from '../../../models/SurveyModels/survey-question';\r\nimport { SurveyService } from '../../../Services/survey.service';\r\nimport { SurveyQuestionService } from '../../../Services/survey-question.service';\r\n\r\n\r\n@Component({\r\n  selector: 'app-survey-info',\r\n  templateUrl: './survey-info.component.html',\r\n  styleUrls: ['./survey-info.component.css']\r\n\r\n})\r\nexport class SurveyInfoComponent extends AppBaseComponent implements OnInit {\r\n  pageHeaderOptions: PageHeaderOptions;\r\n  breadCrumb: BreadCrumb[];\r\n  surveyForm = new FormGroup({});\r\n  @ViewChild('pagingViewElement', { static: false }) pagingElement: PagingComponent<any>;\r\n  @ViewChild('deleteConfirmationModalControl', { static: false }) deleteConfirmationModalControl: DeleteSurveyComponent;\r\n  @ViewChild('editModal', { static: false }) editModal: EditSurveyComponent;\r\n  @ViewChild('editQuestionModal', { static: false }) editQuestionModal: EditQuestionComponent;\r\n  @ViewChild('deleteQuestionModal', { static: false }) deleteQuestionConfirmationModalControl: DeleteQuestionComponent;\r\n  @ViewChild('addQuestionModal', { static: false }) AddQuestionComponent: AddQuestionComponent;\r\n  @ViewChild('addPublishModal', { static: false }) addPublishModal: PublishSurveyComponent;\r\n  @ViewChild('addUnPublishModal', { static: false }) addUnPublishModal: UnPublishSurveyComponent;\r\n  @ViewChild('deleteSubmissionModal', { static: false }) deleteSubmissionConfirmationModalControl: DeleteSubmissionComponent;\r\n  @ViewChild('eliminateModal', { static: false }) eliminateSubmissionConfirmationModalControl: EliminateSubmissionComponent;\r\n  @ViewChild('unEliminateModal', { static: false }) unEliminateSubmissionConfirmationModalControl: UnEliminateSubmissionComponent;\r\n\r\n  TextBoxWithExternalURL: TextBoxOptions;\r\n  TextBoxWithInternalURL: TextBoxOptions;\r\n  urlForm = new FormGroup({});\r\n  SearchTextBox = new FormGroup({});\r\n  EN: boolean;\r\n  SearchTextBoxOptions: TextBoxOptions;\r\n  private root!: am5.Root;\r\n  surveyID: any;\r\n  survey: any;\r\n  loadInfo: boolean = false;\r\n  public SurveyStatusEnum = SurveyStatusEnum;\r\n  public AudienceTypeEnum = AudienceType;\r\n  surveyQuestions: SurveyQuestionDTO[] = [];\r\n  apiQuestionURL = this.surveyQuestionService.apiURL;\r\n  filtersQuestionForm = new FormGroup({});\r\n  canTakeSurvey: boolean = false\r\n  //Questions Section\r\n  @ViewChild('pagingQuestionViewElement', { static: false }) pagingQuestionElement: PagingComponent<any>;\r\n  pagingQuestionResult: any[] = [];\r\n  pagingQuestionOptions: PagingOptions;\r\n  showPageContent: boolean;\r\n  canEditQuestion: boolean;\r\n  canAddQuestion: boolean;\r\n  canDeleteQuestion: boolean;\r\n  searchQuestionTextFilter: any;\r\n  SurveyIDOptions: any;\r\n  searchSurveyIDFilter: FilterItem;\r\n\r\n\r\n  //Submission Section\r\n  filtersSubmissionForm = new FormGroup({});\r\n  @ViewChild('pagingSubmissionViewElement', { static: false }) pagingSubmissionElement: PagingComponent<any>;\r\n  pagingSubmissionResult: any[] = [];\r\n  pagingSubmissionOptions: PagingOptions;\r\n  showSubmissionPageContent: boolean;\r\n  searchSubmissionTextFilter: FilterItem;\r\n  searchSurveySubmissionIDFilter: FilterItem;\r\n  questionOverviewResult: any;\r\n  pagingQuestionResultOriginal: any;\r\n  showOverview: boolean;\r\n  showNav: boolean\r\n  constructor(private injector: Injector, @Inject(PLATFORM_ID) private platformId, private zone: NgZone, private router: Router\r\n    , private masterLayoutService: MasterLayoutService, private surveyService: SurveyService, private surveyQuestionService: SurveyQuestionService, private activatedRoute: ActivatedRoute) {\r\n    super(injector);\r\n    this.router.routeReuseStrategy.shouldReuseRoute = () => false;\r\n    this.surveyID = this.activatedRoute.snapshot.params[\"id\"];\r\n  }\r\n  // Run the function only in the browser\r\n  browserOnly(f: () => void) {\r\n    if (isPlatformBrowser(this.platformId)) {\r\n      this.zone.runOutsideAngular(() => {\r\n        f();\r\n      });\r\n    }\r\n  }\r\n\r\n  ngAfterViewInit() {\r\n\r\n  }\r\n\r\n  maybeDisposeRoot(divId) {\r\n    am5.array.each(am5.registry.rootElements, (root) => {\r\n      if (root) {\r\n        if (root.dom.id == divId) {\r\n          root.dispose();\r\n        }\r\n      }\r\n    });\r\n\r\n  };\r\n\r\n  loadChart(item) {\r\n\r\n    // Chart code goes in here\r\n    this.browserOnly(() => {\r\n      let name = `chartdiv`;\r\n      this.maybeDisposeRoot(name)\r\n      let root = am5.Root.new(name);\r\n      root.setThemes([am5themes_Animated.new(root)]);\r\n\r\n      let chart = root.container.children.push(\r\n        am5xy.XYChart.new(root, {\r\n          panX: false,\r\n          panY: false,\r\n          wheelX: 'none',\r\n          wheelY: 'none',\r\n          paddingBottom: 50,\r\n          paddingTop: 40,\r\n          layout: root.verticalLayout,\r\n\r\n        })\r\n      );\r\n\r\n      // Define data\r\n      let data = item.options.map(value => { return { 'name': value.localizedTitle, 'value': value.numberOfSelectedTime } })\r\n      // Create Y-axis\r\n      let yAxis = chart.yAxes.push(\r\n        am5xy.ValueAxis.new(root, {\r\n          baseValue: 0,\r\n          maxPrecision: 0,\r\n          extraTooltipPrecision: 100,\r\n          renderer: am5xy.AxisRendererY.new(root, {})\r\n        })\r\n      );\r\n\r\n      // Create X-Axis\r\n      let xAxis = chart.xAxes.push(\r\n        am5xy.CategoryAxis.new(root, {\r\n          renderer: am5xy.AxisRendererX.new(root, {}),\r\n          categoryField: \"name\"\r\n        })\r\n      );\r\n      xAxis.data.setAll(data);\r\n\r\n      // Create series\r\n      let series1 = chart.series.push(\r\n        am5xy.ColumnSeries.new(root, {\r\n          name: \"Question Options\",\r\n          xAxis: xAxis,\r\n          yAxis: yAxis,\r\n          valueYField: \"value\",\r\n          categoryXField: \"name\",\r\n            \r\n        })\r\n      );\r\n  \r\n\r\n      series1.data.setAll(data);\r\n      series1.set(\"fill\", am5.color(\"#b68a35\")); // set Series color to red\r\n      series1.set(\"stroke\", am5.color(\"#b68a35\")); // set Series color to red\r\n\r\n      // Add legend\r\n      let legend = chart.children.push(am5.Legend.new(root, {}));\r\n      legend.data.push(series1);\r\n\r\n  \r\n      this.root = root;\r\n\r\n    });\r\n\r\n    // //chart overview\r\n    this.browserOnly(() => {\r\n      let nameOverView = `chartOverview`;\r\n      this.maybeDisposeRoot(nameOverView)\r\n      let root = am5.Root.new(nameOverView);\r\n\r\n      root.setThemes([am5themes_Animated.new(root)]);\r\n\r\n      let chart = root.container.children.push(\r\n        am5xy.XYChart.new(root, {\r\n          panY: false,\r\n          layout: root.verticalLayout\r\n        })\r\n      );\r\n\r\n\r\n      // Define data\r\n\r\n      let data = [];\r\n      for (const key in item.results) {\r\n        if (Object.prototype.hasOwnProperty.call(item.results, key)) {\r\n          const value = item.results[key];\r\n          let object = {\r\n            category: \">=\" + key,\r\n            value: value\r\n          }\r\n          data.push(object)\r\n        }\r\n      }\r\n\r\n      // Create Y-axis\r\n      let yAxis = chart.yAxes.push(\r\n        am5xy.ValueAxis.new(root, {\r\n          baseValue: 0,\r\n          maxPrecision: 0,\r\n          extraTooltipPrecision: 100,\r\n          renderer: am5xy.AxisRendererY.new(root, {})\r\n        })\r\n      );\r\n\r\n      // Create X-Axis\r\n      let xAxis = chart.xAxes.push(\r\n        am5xy.CategoryAxis.new(root, {\r\n          renderer: am5xy.AxisRendererX.new(root, {}),\r\n          categoryField: \"category\"\r\n        })\r\n      );\r\n      xAxis.data.setAll(data);\r\n\r\n      // Create series\r\n      let series1 = chart.series.push(\r\n        am5xy.ColumnSeries.new(root, {\r\n          name: \"Score\",\r\n          xAxis: xAxis,\r\n          yAxis: yAxis,\r\n          valueYField: \"value\",\r\n          categoryXField: \"category\",\r\n        })\r\n      );\r\n      series1.data.setAll(data);\r\n      series1.set(\"fill\", am5.color(\"#b68a35\")); // set Series color to red\r\n      series1.set(\"stroke\", am5.color(\"#b68a35\")); // set Series color to red\r\n      // Add legend\r\n      let legend = chart.children.push(am5.Legend.new(root, {}));\r\n      legend.data.setAll(chart.series.values);\r\n\r\n      this.root = root;\r\n    });\r\n\r\n  }\r\n  ngOnDestroy() {\r\n    // Clean up root element when the component is removed\r\n    this.browserOnly(() => {\r\n      if (this.root) {\r\n        this.root.dispose();\r\n      }\r\n    });\r\n  }\r\n\r\n  ngOnInit(): void {\r\n    this.surveyService.getInfo(this.surveyID).subscribe(result => {\r\n      this.survey = result;\r\n\r\n      this.TextBoxWithExternalURL = new TextBoxOptions();\r\n      this.TextBoxWithExternalURL.Name = \"TextBoxWithExternalURL\"\r\n      this.TextBoxWithExternalURL.LabelKey = \"External_URL\"\r\n      this.TextBoxWithExternalURL.Type = InputType.Text\r\n      this.TextBoxWithExternalURL.ViewType = ControlLayout.Vertical\r\n      this.TextBoxWithExternalURL.ForceDirection = ForceDirection.English\r\n      this.TextBoxWithExternalURL.EnableCopyToClipboard = true\r\n      this.TextBoxWithExternalURL.Value = this.survey.externalURL\r\n\r\n      this.TextBoxWithInternalURL = new TextBoxOptions();\r\n      this.TextBoxWithInternalURL.Name = \"TextBoxWithInternalURL\"\r\n      this.TextBoxWithInternalURL.LabelKey = \"Internal_URL\"\r\n      this.TextBoxWithInternalURL.Type = InputType.Text\r\n      this.TextBoxWithInternalURL.ViewType = ControlLayout.Vertical\r\n      this.TextBoxWithInternalURL.ForceDirection = ForceDirection.English\r\n      this.TextBoxWithInternalURL.EnableCopyToClipboard = true\r\n      this.TextBoxWithInternalURL.Value = this.survey.internalURL\r\n\r\n\r\n      this.breadCrumb = [];\r\n      this.breadCrumb.push(new BreadCrumb(this.l(\"Home\"), false, \"/\"), new BreadCrumb(this.l(\"Surveys_Header\"), false, '../../'), new BreadCrumb(this.l(\"Survey_Details\"), true));\r\n      this.pageHeaderOptions = new PageHeaderOptions();\r\n      this.pageHeaderOptions.TitleValue =this.survey.localizedTitle;\r\n      this.pageHeaderOptions.SearchTextBox.Active = false;\r\n      this.pageHeaderOptions.BreadCrumb.Active = true;\r\n      this.pageHeaderOptions.BreadCrumb.BreadCrumbItems = this.breadCrumb;\r\n      this.pageHeaderOptions.DropDownActions.Active = true;\r\n      this.pageHeaderOptions.DropDownActions.DropdownActionItems.push(\r\n        new DropdownActionItem(this.l(\"Edit\"), \"/assets/images/Edit.svg\", this.showEditModal),\r\n        new DropdownActionItem(this.l(\"Delete\"), '/assets/images/Trash.svg', this.showDeleteModal),\r\n        new DropdownActionItem(this.l(\"Export\"), '/assets/images/export.svg', this.export)\r\n        );\r\n\r\n      if (this.survey.totalQuestionCount > 0)\r\n        this.pageHeaderOptions.DropDownActions.DropdownActionItems.push(\r\n          new DropdownActionItem( this.l(\"Preview\"), '/assets/images/views.svg', this.previewSurvey));\r\n      if (this.survey.statusItemID.toLocaleLowerCase() == this.SurveyStatusEnum.ScoringTypeEnum_Published.toLocaleLowerCase())\r\n        this.canTakeSurvey = true\r\n\r\n      if (this.survey.statusItemID.toLocaleLowerCase() == this.SurveyStatusEnum.ScoringTypeEnum_Draft.toLocaleLowerCase()\r\n        || this.survey.statusItemID.toLocaleLowerCase() == this.SurveyStatusEnum.ScoringTypeEnum_Closed.toLocaleLowerCase())\r\n        this.pageHeaderOptions.DropDownActions.DropdownActionItems.push(new DropdownActionItem(this.l(\"Publish\"), '/assets/images/Submit.svg', this.showPublishModal))\r\n      else\r\n        this.pageHeaderOptions.DropDownActions.DropdownActionItems.push(new DropdownActionItem(this.l(\"UnPublish\"), '/assets/images/unlink.svg', this.showUnPublishModal),)\r\n\r\n      this.EN = this.utilityService.isCurrentLanguageEnglish();\r\n      this.loadQuestionSection();\r\n      this.loadSubmissionSection();\r\n      this.pageTitle = this.survey.localizedTitle\r\n      this.updatePageTitle(this.survey.localizedTitle);\r\n      this.loadInfo = true;\r\n\r\n\r\n    });\r\n  }\r\n  showEditModal = () => {\r\n    this.editModal.showEditModal(this.surveyID);\r\n  }\r\n  showDeleteModal = () => {\r\n    this.deleteConfirmationModalControl.showDeleteModal(this.surveyID);\r\n\r\n  }\r\n  showEditQuestionModal(id,isViewOnly) {\r\n    this.editQuestionModal.editModal(id, this.survey.audienceItemID,isViewOnly);\r\n\r\n  }\r\n  showAddQuestionModal() {\r\n    this.AddQuestionComponent.addModal(this.surveyID, this.survey.audienceItemID);\r\n\r\n  }\r\n  showDeleteQuestionModal = (id) => {\r\n    this.deleteQuestionConfirmationModalControl.showDeleteModal(id);\r\n\r\n  }\r\n  showPublishModal = () => {\r\n    this.addPublishModal.publishModal(this.surveyID, this.pagingQuestionResult);\r\n\r\n  }\r\n  showUnPublishModal = () => {\r\n    this.addUnPublishModal.showConfirmationModal(this.surveyID);\r\n\r\n  }\r\n  drop(event: CdkDragDrop<string[]>) {\r\n    moveItemInArray(this.pagingQuestionResult, event.previousIndex, event.currentIndex);\r\n    for (let index = 0; index < this.pagingQuestionResult.length; index++) {\r\n      this.pagingQuestionResult[index].displayOrder = index + 1;\r\n    }\r\n    this.surveyQuestionService.updateDisplayOrder(this.pagingQuestionResult).subscribe(e => {\r\n      this.utilityService.stopBlockUI();\r\n    });\r\n  }\r\n  previewSurvey = () => {\r\n    this.router.navigate(['../../info/preview', this.surveyID, this.survey.audienceItemID], {relativeTo: this.activatedRoute});\r\n  }\r\n  takeSurvey = () => {\r\n    this.router.navigate(['../../info/submission', this.surveyID], {relativeTo: this.activatedRoute});\r\n  }\r\n\r\n  getStatus(status) {\r\n    var Statuses = '';\r\n    switch (status.toLocaleLowerCase()) {\r\n      case this.SurveyStatusEnum.ScoringTypeEnum_Draft.toLocaleLowerCase():\r\n        Statuses = 'badge-secondary';\r\n        this.canEditQuestion = true;\r\n        this.canDeleteQuestion = true;\r\n        this.canAddQuestion = true;\r\n        break;\r\n      case this.SurveyStatusEnum.ScoringTypeEnum_Closed.toLocaleLowerCase():\r\n        Statuses = 'badge-danger';\r\n        this.canEditQuestion = false;\r\n        this.canDeleteQuestion = true;\r\n        this.canAddQuestion = false;\r\n\r\n        break;\r\n      case this.SurveyStatusEnum.ScoringTypeEnum_Published.toLocaleLowerCase():\r\n        Statuses = 'badge-success';\r\n        this.canEditQuestion = false;\r\n        this.canDeleteQuestion = false;\r\n        this.canAddQuestion = false;\r\n        break;\r\n      case this.SurveyStatusEnum.ScoringTypeEnum_Upcoming.toLocaleLowerCase():\r\n        Statuses = 'badge-success';\r\n        this.canEditQuestion = true;\r\n        this.canDeleteQuestion = true;\r\n        this.canAddQuestion = true;\r\n        break;\r\n\r\n      default:\r\n        break;\r\n    }\r\n    return Statuses;\r\n  }\r\n\r\n  loadQuestionSection() {\r\n    this.SearchTextBoxOptions = new TextBoxOptions();\r\n    this.SearchTextBoxOptions.Name = \"SearchTextBox\";\r\n    this.SearchTextBoxOptions.Type = InputType.Text;\r\n    this.SearchTextBoxOptions.TrimTextOnChange = true;\r\n    this.SearchTextBoxOptions.Placeholder = this.l(\"Search\");\r\n    this.SearchTextBoxOptions.ExtraClasses = \"form-control form-control-sm form-control-solid search-box\";\r\n    this.SearchTextBoxOptions.HideLabel = true;\r\n    this.SearchTextBoxOptions.Icon = \"../../../assets/images/search.svg\"\r\n\r\n\r\n\r\n\r\n    this.SurveyIDOptions = new TextBoxOptions();\r\n    this.SurveyIDOptions.Name = \"SurveyID\";\r\n    this.SurveyIDOptions.Value = this.surveyID;\r\n\r\n    this.searchSurveyIDFilter = new FilterItem();\r\n    this.searchSurveyIDFilter.FormControlName = this.SurveyIDOptions.Name;\r\n    this.searchSurveyIDFilter.ActionParameterName = \"SurveyID\";\r\n    this.searchSurveyIDFilter.IsFormControl = true;\r\n    this.searchSurveyIDFilter.FilterType = FilterType.TextBox;\r\n\r\n\r\n\r\n    this.pagingQuestionOptions = new PagingOptions();\r\n    this.pagingQuestionOptions.PageSize = 1000;\r\n    this.pagingQuestionOptions.DisableBlockUI = true;\r\n    this.pagingQuestionOptions.ActionPostURL = this.apiQuestionURL + 'GetAllQuestions';\r\n    this.pagingQuestionOptions.Filters = [this.searchSurveyIDFilter];\r\n\r\n\r\n\r\n  }\r\n  setQuestionListingResult(result) {\r\n    this.pagingQuestionResult = result;\r\n    this.pagingQuestionResultOriginal = result;\r\n    this.showPageContent = true;\r\n    this.utilityService.stopBlockUI();\r\n    let overviewQuestions = this.pagingQuestionResultOriginal.filter(item => item.questionTypeItemID == SurveyOptionType.RadioButton || item.questionTypeItemID == SurveyOptionType.SingleSelect || item.questionTypeItemID == SurveyOptionType.MultipleSelect)\r\n    if (overviewQuestions.length > 0)\r\n      this.loadSurveyOverview();\r\n  }\r\n\r\n\r\n  onSuccessHandler = (success: any) => {\r\n    this.utilityService.notifySuccessMessage(this.l(\"RecordUpdated\"), null, null, false);\r\n    this.masterLayoutService.reloadComponent();\r\n  }\r\n\r\n  onSuccessDeleteHandler = (success: any) => {\r\n    this.utilityService.notifySuccessMessage(this.l(\"RecordDeleted\"), null, null, false);\r\n    this.router.navigate([\"../../\"], {relativeTo: this.activatedRoute});\r\n  }\r\n\r\n  onSuccessAddQuestionHandler = (success: any) => {\r\n    this.utilityService.notifySuccessMessage(this.l(\"RecordAdded\"), null, null, false);\r\n    this.masterLayoutService.reloadComponent();\r\n  }\r\n  onSuccessEditQuestionHandler = (success: any) => {\r\n    this.utilityService.notifySuccessMessage(this.l(\"RecordUpdated\"), null, null, false);\r\n    this.masterLayoutService.reloadComponent();\r\n  }\r\n\r\n  onSuccessDeleteQuestionHandler = (success: any) => {\r\n    this.utilityService.notifySuccessMessage(this.l(\"RecordDeleted\"), null, null, false);\r\n    this.masterLayoutService.reloadComponent();\r\n  }\r\n\r\n\r\n\r\n  showDeleteSubmissionModal = (id) => {\r\n    this.deleteSubmissionConfirmationModalControl.showDeleteModal(id);\r\n\r\n  }\r\n  showEliminateSubmissionModal = (id) => {\r\n    this.eliminateSubmissionConfirmationModalControl.showEliminateModal(id);\r\n  }\r\n  showUnEliminateSubmissionModal = (id) => {\r\n    this.unEliminateSubmissionConfirmationModalControl.showUnEliminateModal(id);\r\n  }\r\n  onSuccessDeleteHandlerSubmission = (success: any) => {\r\n    this.utilityService.notifySuccessMessage(this.l(\"RecordDeleted\"), null, null, false);\r\n    this.loadSubmissionSection();\r\n  }\r\n  loadSubmissionSection() {\r\n    this.SearchTextBoxOptions = new TextBoxOptions();\r\n    this.SearchTextBoxOptions.Name = \"SearchTextBox\";\r\n    this.SearchTextBoxOptions.Type = InputType.Text;\r\n    this.SearchTextBoxOptions.TrimTextOnChange = true;\r\n    this.SearchTextBoxOptions.Placeholder = this.l(\"Search\");\r\n    this.SearchTextBoxOptions.ExtraClasses = \"form-control form-control-sm form-control-solid search-box\";\r\n    this.SearchTextBoxOptions.HideLabel = true;\r\n    this.SearchTextBoxOptions.Icon = \"../../../assets/images/search.svg\"\r\n\r\n    this.searchSubmissionTextFilter = new FilterItem();\r\n    this.searchSubmissionTextFilter.FormControlName = this.SearchTextBoxOptions.Name;\r\n    this.searchSubmissionTextFilter.ActionParameterName = \"SearchText\";\r\n    this.searchSubmissionTextFilter.IsFormControl = true;\r\n    this.searchSubmissionTextFilter.FilterType = FilterType.TextBox;\r\n\r\n\r\n    this.SurveyIDOptions = new TextBoxOptions();\r\n    this.SurveyIDOptions.Name = \"SurveyID\";\r\n    this.SurveyIDOptions.Value = this.surveyID;\r\n\r\n    this.searchSurveySubmissionIDFilter = new FilterItem();\r\n    this.searchSurveySubmissionIDFilter.FormControlName = this.SurveyIDOptions.Name;\r\n    this.searchSurveySubmissionIDFilter.ActionParameterName = \"SurveyID\";\r\n    this.searchSurveySubmissionIDFilter.IsFormControl = true;\r\n    this.searchSurveySubmissionIDFilter.FilterType = FilterType.TextBox;\r\n\r\n\r\n\r\n    this.pagingSubmissionOptions = new PagingOptions();\r\n    this.pagingSubmissionOptions.PageSize = 10;\r\n    this.pagingSubmissionOptions.DisableBlockUI = true;\r\n    this.pagingSubmissionOptions.ActionPostURL = this.surveyService.apiURL + 'GetAllSurveySubmission';\r\n    this.pagingSubmissionOptions.OnKeyPressFiltersControlNames = [this.SearchTextBoxOptions.Name];\r\n    this.pagingSubmissionOptions.Filters = [this.searchSurveySubmissionIDFilter, this.searchSubmissionTextFilter];\r\n\r\n\r\n\r\n  }\r\n  setSubmissionListingResult(result) {\r\n    this.pagingSubmissionResult = result;\r\n    this.showSubmissionPageContent = true;\r\n    this.utilityService.stopBlockUI();\r\n  }\r\n  loadSurveyOverview() {\r\n    this.surveyService.getSurveyOverview(this.surveyID).subscribe((res) => {\r\n      this.questionOverviewResult = res as any\r\n      this.showOverview = true;\r\n      this.loadChart(this.questionOverviewResult[0]);\r\n    })\r\n  }\r\n\r\n  export = () => {\r\n    this.surveyService\r\n      .export(this.surveyID)\r\n      .subscribe((result) => {\r\n        this.download((result as any) as Blob, this.pageTitle + \".xlsx\");\r\n      });\r\n  }\r\n\r\n  searchInQuestionList(value) {\r\n    if (value)\r\n      this.pagingQuestionResult = this.pagingQuestionResultOriginal.filter(item => item.localizedText.toLowerCase().includes(value.toLowerCase()))\r\n    else\r\n      this.pagingQuestionResult = this.pagingQuestionResultOriginal;\r\n  }\r\n\r\n}\r\n","<!--toolbar-->\r\n<div *ngIf=\"loadInfo\">\r\n  <bbsf-page-header-component [options]=\"pageHeaderOptions\"></bbsf-page-header-component>\r\n</div>\r\n<!--end toolbar-->\r\n<div class=\"container-xxl\">\r\n  <div class=\"info-container\" *ngIf=\"loadInfo\">\r\n    <div class=\"section-margin-bottom\">\r\n      <div class=\"d-flex justify-content-between align-items-center\">\r\n        <div class=\"survery-date border-0\">\r\n          <div class=\"icon-boxes align-items-baseline\">\r\n            <div ngbTooltip=\"{{l('Date')}}\" class=\"icon-box\">\r\n              <div class=\"symbol\">\r\n                <span class=\"symbol-label\">\r\n                  <span class=\"svg-icon svg-icon-4\" [inlineSVG]=\"'/assets/images/calendar.svg'\">\r\n                  </span>\r\n                </span>\r\n              </div>\r\n              <span class=\"survey-counter-title\" *ngIf=\"survey.startDate==null\">\r\n                {{l('NotStartedYet')}}\r\n              </span>\r\n              <span class=\"survey-counter-title d-flex flex-stack\" *ngIf=\"survey.startDate!=null\">\r\n                {{survey.startDate |surveyDate}} - {{survey.endDate!=null?(survey.endDate|surveyDate):\"\"}}\r\n                <span class=\"badge badge-light\" *ngIf=\"survey.endDate==null\">{{l('HasNoEnd')}}</span>\r\n              </span>\r\n            </div>\r\n          </div>\r\n        </div>\r\n        <div>\r\n          <span class=\"badge badge-light\" [ngClass]=\"getStatus(survey.statusItemID)\">{{survey.localizedStatus}}</span>\r\n          <span ngbTooltip=\"{{l('Audience')}}\" class=\"badge badge-light mx-2\">{{survey.localizedAudience}}</span>\r\n        </div>\r\n      </div>\r\n      <div class=\"row card-data\">\r\n        <div class=\"col-lg-6\">\r\n          <BBSF-TextBox *ngIf=\"canTakeSurvey&& (survey.audienceItemID==AudienceTypeEnum.Internal||survey.audienceItemID==AudienceTypeEnum.Both)\"\r\n                        [options]=\"TextBoxWithInternalURL\" [group]=\"urlForm\"></BBSF-TextBox>\r\n\r\n        </div>\r\n        <div class=\"col-lg-6\">\r\n          <BBSF-TextBox *ngIf=\"canTakeSurvey&& (survey.audienceItemID==AudienceTypeEnum.External||survey.audienceItemID==AudienceTypeEnum.Both)\"\r\n                        [options]=\"TextBoxWithExternalURL\" [group]=\"urlForm\"></BBSF-TextBox>\r\n        </div>\r\n      </div>\r\n      <p class=\"card-description\" *ngIf=\"survey.localizedDesc\">\r\n        {{survey.localizedDesc}}\r\n      </p>\r\n    </div>\r\n    <div class=\"section-margin-bottom\">\r\n      <ul ngbNav #nav=\"ngbNav\" class=\"nav nav-stretch nav-line-tabs nav-custom\">\r\n        <li ngbNavItem class=\"nav-item\" [destroyOnHide]=\"true\">\r\n          <a class=\"nav-link\" ngbNavLink>\r\n            <h4>\r\n              {{l('Questions')}}\r\n            </h4>\r\n          </a>\r\n          <ng-template ngbNavContent>\r\n            <div class=\"section-info\">\r\n              <div class=\"tabs-search page-subheader justify-content-between\">\r\n                <BBSF-TextBox [options]=\"SearchTextBoxOptions\" [group]=\"filtersQuestionForm\"\r\n                              (OnChange)=\"searchInQuestionList($event)\"></BBSF-TextBox>\r\n                <BBSF-TextBox [options]=\"SurveyIDOptions\" [group]=\"filtersQuestionForm\" hidden></BBSF-TextBox>\r\n                <button type=\"button\" *ngIf=\"canAddQuestion\" class=\"btn btn-brand btn-sm subheader-btn\"\r\n                        (click)=\"showAddQuestionModal()\">\r\n                  {{l('Add')}}\r\n                </button>\r\n              </div>\r\n              <div [hidden]=\"pagingQuestionResult.length == 0\">\r\n                <div ngbNavContent cdkDropList (cdkDropListDropped)=\"drop($event)\">\r\n                  <div class=\"question-info\" [cdkDragDisabled]=\"canTakeSurvey\" cdkDrag\r\n                       *ngFor=\"let item of pagingQuestionResult; let i=index\">\r\n                    <div class=\"symbol symbol-25px me-4\" cdkDragHandle *ngIf=\"!canTakeSurvey\">\r\n                      <span class=\"symbol-label\">\r\n                        <span class=\"svg-icon svg-icon-7\" [inlineSVG]=\"'/assets/images/reorder.svg'\">\r\n                        </span>\r\n                      </span>\r\n                    </div>\r\n                    <div class=\"card card-listing\">\r\n                      <div class=\"card-header\">\r\n                        <div class=\"card-title\">\r\n                          <span class=\"badge badge-light\"\r\n                                ngbTooltip=\"{{l('Type')}}\">{{item.localizedQuestionTypeItem}}</span>\r\n                          <span class=\"badge badge-light mx-2\"\r\n                                ngbTooltip=\"{{l('Audience')}}\">{{item.localizedAudienceType}}</span>\r\n                          <span class=\"badge badge-brand-light mx-2\"\r\n                                *ngIf=\"item.isRelatedToSurveyQuestion\">{{l('Linked')}}</span>\r\n                          <span class=\"badge badge-light mx-2\" *ngIf=\"!item.isVisible\" ngbTooltip=\"{{l('NotVisible')}}\">\r\n                            {{l(\"NotVisible\")}}\r\n                          </span>\r\n                        </div>\r\n                        <div class=\"card-toolbar\">\r\n                          <div ngbDropdown container=\"body\" class=\"dropdown-custom\"\r\n                               [placement]=\"EN ? 'bottom-right' : 'bottom-left'\">\r\n                            <button type=\"button\" class=\"dropdown-toggle-custom btn btn-clear\" ngbDropdownToggle>\r\n                              <span class=\"svg-icon svg-icon-3\"\r\n                                    [inlineSVG]=\"'/assets/images/card-dropdown.svg'\"></span>\r\n                            </button>\r\n                            <div ngbDropdownMenu class=\"dropdown-menu-custom\">\r\n                              <button *ngIf=\"!(canEditQuestion&&canDeleteQuestion)\"\r\n                                      (click)=\"showEditQuestionModal(item.iD_GUID,true)\" apppreventdoubleclick type=\"button\"\r\n                                      ngbDropdownItem class=\"dropdown-button\">\r\n                                <span class=\"svg-icon svg-icon-3\" [inlineSVG]=\"'/assets/images/info.svg'\">\r\n                                </span>\r\n                                {{l(\"Details\")}}\r\n                              </button>\r\n\r\n                              <button *ngIf=\"canEditQuestion\" (click)=\"showEditQuestionModal(item.iD_GUID,false)\"\r\n                                      apppreventdoubleclick type=\"button\" ngbDropdownItem class=\"dropdown-button\">\r\n                                <span class=\"svg-icon svg-icon-3\" [inlineSVG]=\"'/assets/images/Edit.svg'\">\r\n                                </span>\r\n                                {{l(\"Edit\")}}\r\n                              </button>\r\n                              <button type=\"button\" *ngIf=\"canDeleteQuestion\"\r\n                                      (click)=\"showDeleteQuestionModal(item.iD_GUID)\" apppreventdoubleclick ngbDropdownItem\r\n                                      class=\"dropdown-button\">\r\n                                <span class=\"svg-icon svg-icon-3\"\r\n                                      [inlineSVG]=\"'/assets/images/Trash.svg'\"></span> {{l(\"Delete\")}}\r\n                              </button>\r\n                            </div>\r\n                          </div>\r\n                        </div>\r\n                      </div>\r\n                      <div class=\"card-body\">\r\n                        <div class=\"survey-counter\">\r\n                          <span class=\"survey-counter-title\">{{item.localizedText}}</span>\r\n                          <span class=\"badge badge-light-brand badge-square ms-2 me-0\"\r\n                                ngbTooltip=\"{{l('Score')}}\">{{item.totalScore}}</span>\r\n                        </div>\r\n                      </div>\r\n                    </div>\r\n                  </div>\r\n                </div>\r\n                <BBSF-Paging (Items)=\"setQuestionListingResult($event)\" [options]=\"pagingQuestionOptions\"\r\n                             [group]=\"filtersQuestionForm\" #pagingQuestionViewElement></BBSF-Paging>\r\n              </div>\r\n            </div>\r\n            <app-no-results *ngIf=\"pagingQuestionResult.length == 0\"></app-no-results>\r\n\r\n          </ng-template>\r\n        </li>\r\n        <li ngbNavItem class=\"nav-item\" [destroyOnHide]=\"true\">\r\n          <a class=\"nav-link\" ngbNavLink>\r\n            <h4>\r\n              {{l('Submissions')}}\r\n            </h4>\r\n          </a>\r\n          <ng-template ngbNavContent>\r\n            <div class=\"section-info\" ngbNavContent>\r\n              <div class=\"tabs-search page-subheader justify-content-between\">\r\n                <BBSF-TextBox [options]=\"SearchTextBoxOptions\" [group]=\"filtersSubmissionForm\"></BBSF-TextBox>\r\n                <BBSF-TextBox [options]=\"SurveyIDOptions\" [group]=\"filtersSubmissionForm\" hidden></BBSF-TextBox>\r\n              </div>\r\n              <div class=\"info-container\" [hidden]=\"pagingSubmissionResult.length == 0\">\r\n                <div class=\"table-responsive\">\r\n                  <table class=\"table table-custom\">\r\n                    <thead>\r\n                      <tr class=\"table-header\">\r\n                        <th> {{l('Name')}}</th>\r\n                        <th>{{l('Email')}}</th>\r\n                        <th>{{l('Type')}}</th>\r\n                        <th>{{l('Created')}}</th>\r\n                        <th>{{l('Score')}}</th>\r\n                        <th class=\"table-action\">{{l(\"Action\")}}</th>\r\n                      </tr>\r\n                    </thead>\r\n                    <tbody class=\"table-body\">\r\n                      <tr *ngFor=\"let item of pagingSubmissionResult; let i=index\">\r\n                        <td>\r\n                          <span class=\"line-clamp-2\">\r\n                            {{item.localizedName}}\r\n                            <span class=\"badge badge-danger mx-2\" *ngIf=\"item.isEliminated&&item.allowElimination\">\r\n                              {{l('Eliminated')}}\r\n                            </span>\r\n                          </span>\r\n                        </td>\r\n                        <td>\r\n                          {{item.email}}\r\n                        </td>\r\n                        <td>\r\n                          <div class=\"badge badge-light\">\r\n                            {{item.isInternalUser? l('InternalUsers'):l('ExternalUsers')}}\r\n                          </div>\r\n                        </td>\r\n                        <td>{{item.created|surveyDate}}</td>\r\n                        <td>{{item.totalScore}}</td>\r\n                        <td class=\"table-action\">\r\n                          <button type=\"button\" ngbTooltip=\"{{l('Preview')}}\"\r\n                                  [routerLink]=\"['../../info/result', item.iD_GUID]\" class=\"btn btn-sm p-2\">\r\n                            <span class=\"svg-icon svg-icon-3\"\r\n                                  [inlineSVG]=\"'/assets/images/answers.svg'\"></span>\r\n                          </button>\r\n\r\n                          <button type=\"button\" *ngIf=\"!item.isEliminated&&item.allowElimination\"\r\n                                  ngbTooltip=\"{{this.l('EliminateHint')}}\" class=\"btn btn-sm p-2\">\r\n                            <span class=\"svg-icon svg-icon-3\" (click)=\"showEliminateSubmissionModal(item.iD_GUID)\"\r\n                                  apppreventdoubleclick\r\n                                  [inlineSVG]=\"'/assets/images/unlink.svg'\"></span>\r\n                          </button>\r\n\r\n                          <button type=\"button\" *ngIf=\"item.isEliminated&&item.allowElimination\"\r\n                                  ngbTooltip=\"{{this.l('UnEliminate')}}\" class=\"btn btn-sm p-2\">\r\n                            <span class=\"svg-icon svg-icon-3\" (click)=\"showUnEliminateSubmissionModal(item.iD_GUID)\"\r\n                                  apppreventdoubleclick [inlineSVG]=\"'/assets/images/link.svg'\"></span>\r\n                          </button>\r\n\r\n                          <button type=\"button\" ngbTooltip=\"{{l('Delete')}}\" class=\"btn btn-sm p-2\">\r\n                            <span class=\"svg-icon svg-icon-3\" (click)=\"showDeleteSubmissionModal(item.iD_GUID)\"\r\n                                  apppreventdoubleclick [inlineSVG]=\"'/assets/images/Trash.svg'\"></span>\r\n                          </button>\r\n                        </td>\r\n                      </tr>\r\n                    </tbody>\r\n                  </table>\r\n                </div>\r\n              </div>\r\n              <BBSF-Paging (Items)=\"setSubmissionListingResult($event)\" [options]=\"pagingSubmissionOptions\"\r\n                           [group]=\"filtersSubmissionForm\" #pagingSubmissionViewElement></BBSF-Paging>\r\n            </div>\r\n            <app-no-results *ngIf=\"pagingSubmissionResult.length == 0\"></app-no-results>\r\n\r\n          </ng-template>\r\n        </li>\r\n        <li ngbNavItem class=\"nav-item\" *ngIf=\"showOverview\" [destroyOnHide]=\"true\">\r\n          <a class=\"nav-link\" ngbNavLink (click)=\"loadSurveyOverview()\">\r\n            <h4>\r\n              {{l(\"Overview\") }}\r\n            </h4>\r\n          </a>\r\n          <ng-template ngbNavContent>\r\n            <div class=\"section-info\" ngbNavContent>\r\n\r\n              <div class=\"row\">\r\n                <div class=\"col-md-3\">\r\n                  <div class=\"chart-container\">\r\n                    <div class=\"chart-title\"> {{l(\"Questions\") }}</div>\r\n                    <ul ngbNav #nav=\"ngbNav\" class=\"nav-pills custom-navs\" orientation=\"vertical\">\r\n                      <li ngbNavItem=\"{{item.localizedTitle}}\" [destroyOnHide]=\"true\"\r\n                          *ngFor=\"let item of questionOverviewResult\" (click)=\"loadChart(item)\">\r\n                        <a ngbNavLink>{{item.localizedTitle}}</a>\r\n\r\n                      </li>\r\n\r\n                    </ul>\r\n                  </div>\r\n                </div>\r\n                <div class=\"col-md-9\">\r\n                  <div class=\"chart-container\">\r\n                    <div class=\"chart-title\">{{l(\"Overview\") }}</div>\r\n                    <div id=\"chartdiv\" style=\"width: 100%; height: 400px\"></div>\r\n                    <div class=\"hide-logo\"></div>\r\n                  </div>\r\n                  <div class=\"chart-container\">\r\n                    <div class=\"chart-title\">{{l(\"Score\") }} </div>\r\n                    <div id=\"chartOverview\" style=\"width: 100%; height: 400px\"></div>\r\n                    <div class=\"hide-logo\"></div>\r\n                  </div>\r\n                </div>\r\n              </div>\r\n            </div>\r\n          </ng-template>\r\n        </li>\r\n      </ul>\r\n\r\n\r\n      <div [ngbNavOutlet]=\"nav\"></div>\r\n    </div>\r\n  </div>\r\n</div>\r\n\r\n  <app-edit-survey #editModal [pagingElement]=\"pagingElement\" [onSuccessHandler]=\"onSuccessHandler\"></app-edit-survey>\r\n  <app-delete-survey #deleteConfirmationModalControl [pagingElement]=\"pagingElement\"\r\n                     [onSuccessHandler]=\"onSuccessDeleteHandler\"></app-delete-survey>\r\n  <app-add-question #addQuestionModal [pagingElement]=\"pagingQuestionElement\" [onSuccessAddHandler]=\"onSuccessAddQuestionHandler\"></app-add-question>\r\n  <app-edit-question #editQuestionModal [pagingElement]=\"pagingQuestionElement\" [onSuccessEditHandler]=\"onSuccessEditQuestionHandler\"></app-edit-question>\r\n  <app-delete-question #deleteQuestionModal [pagingElement]=\"pagingQuestionElement\" [onSuccessHandler]=\"onSuccessDeleteQuestionHandler\"></app-delete-question>\r\n  <app-publish-survey #addPublishModal [pagingElement]=\"pagingElement\" [onSuccessHandler]=\"onSuccessHandler\" *ngIf=\"loadInfo\" [showToggle]=\"survey.isShowToggleOfScoreResultAfterSubmission\">\r\n  </app-publish-survey>\r\n  <app-unpublish-survey #addUnPublishModal [pagingElement]=\"pagingElement\" [onSuccessHandler]=\"onSuccessHandler\">\r\n  </app-unpublish-survey>\r\n  <app-delete-submission #deleteSubmissionModal [pagingElement]=\"pagingSubmissionElement\"\r\n                         [onSuccessHandler]=\"onSuccessDeleteHandlerSubmission\"></app-delete-submission>\r\n  <app-eliminate-submission #eliminateModal [pagingElement]=\"pagingSubmissionElement\"\r\n                            [onSuccessHandler]=\"onSuccessHandler\"></app-eliminate-submission>\r\n  <app-unEliminate-submission #unEliminateModal [pagingElement]=\"pagingSubmissionElement\"\r\n                              [onSuccessHandler]=\"onSuccessHandler\"></app-unEliminate-submission>\r\n"]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"survey-info.component.js","sourceRoot":"","sources":["../../../../../../../../../projects/bbsf-admin-portal/src/lib/Pages/shared/components/survey/survey-info/survey-info.component.ts","../../../../../../../../../projects/bbsf-admin-portal/src/lib/Pages/shared/components/survey/survey-info/survey-info.component.html"],"names":[],"mappings":"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","sourcesContent":["import { PublishSurveyComponent } from './publish-survey/publish-survey.component';\r\nimport { AddQuestionComponent } from './add-question/add-question.component';\r\nimport { DeleteQuestionComponent } from './delete-question/delete-question.component';\r\nimport { EditQuestionComponent } from './edit-question/edit-question.component';\r\nimport { EditSurveyComponent } from './../edit-survey/edit-survey.component';\r\nimport { DeleteSurveyComponent } from './../delete-survey/delete-survey.component';\r\nimport { FormGroup } from '@angular/forms';\r\nimport { Component, Inject, Injector, NgZone, OnInit, PLATFORM_ID, ViewChild } from '@angular/core';\r\nimport { AppBaseComponent, BreadCrumb, ControlLayout, DropdownActionItem, FilterItem, FilterType, ForceDirection, InputType, PageHeaderOptions, PagingComponent, PagingOptions, TextBoxOptions } from '@bnsights/bbsf-controls';\r\nimport { CdkDragDrop, moveItemInArray } from '@angular/cdk/drag-drop';\r\nimport { isPlatformBrowser } from \"@angular/common\";\r\nimport * as am5 from \"@amcharts/amcharts5\";\r\nimport * as am5xy from \"@amcharts/amcharts5/xy\";\r\nimport am5themes_Animated from \"@amcharts/amcharts5/themes/Animated\";\r\nimport { ActivatedRoute, Router } from '@angular/router';\r\nimport { MasterLayoutService } from '@bnsights/bbsf-utilities';\r\nimport { UnPublishSurveyComponent } from './unpublish-survey/unpublish-survey.component';\r\nimport { DeleteSubmissionComponent } from '../submissions/delete-submission/delete-submission.component';\r\nimport { EliminateSubmissionComponent } from '../submissions/eliminate-submission/eliminate-submission.component';\r\nimport { UnEliminateSubmissionComponent } from '../submissions/uneliminate-submission/uneliminate-submission.component';\r\nimport { AudienceType, SurveyOptionType, SurveyStatusEnum } from '../../../Enums/Enums';\r\nimport { SurveyQuestionDTO } from '../../../models/SurveyModels/survey-question';\r\nimport { SurveyService } from '../../../Services/survey.service';\r\nimport { SurveyQuestionService } from '../../../Services/survey-question.service';\r\n\r\n\r\n@Component({\r\n  selector: 'app-survey-info',\r\n  templateUrl: './survey-info.component.html',\r\n  styleUrls: ['./survey-info.component.css']\r\n\r\n})\r\nexport class SurveyInfoComponent extends AppBaseComponent implements OnInit {\r\n  pageHeaderOptions: PageHeaderOptions;\r\n  breadCrumb: BreadCrumb[];\r\n  surveyForm = new FormGroup({});\r\n  @ViewChild('pagingViewElement', { static: false }) pagingElement: PagingComponent<any>;\r\n  @ViewChild('deleteConfirmationModalControl', { static: false }) deleteConfirmationModalControl: DeleteSurveyComponent;\r\n  @ViewChild('editModal', { static: false }) editModal: EditSurveyComponent;\r\n  @ViewChild('editQuestionModal', { static: false }) editQuestionModal: EditQuestionComponent;\r\n  @ViewChild('deleteQuestionModal', { static: false }) deleteQuestionConfirmationModalControl: DeleteQuestionComponent;\r\n  @ViewChild('addQuestionModal', { static: false }) AddQuestionComponent: AddQuestionComponent;\r\n  @ViewChild('addPublishModal', { static: false }) addPublishModal: PublishSurveyComponent;\r\n  @ViewChild('addUnPublishModal', { static: false }) addUnPublishModal: UnPublishSurveyComponent;\r\n  @ViewChild('deleteSubmissionModal', { static: false }) deleteSubmissionConfirmationModalControl: DeleteSubmissionComponent;\r\n  @ViewChild('eliminateModal', { static: false }) eliminateSubmissionConfirmationModalControl: EliminateSubmissionComponent;\r\n  @ViewChild('unEliminateModal', { static: false }) unEliminateSubmissionConfirmationModalControl: UnEliminateSubmissionComponent;\r\n\r\n  TextBoxWithExternalURL: TextBoxOptions;\r\n  TextBoxWithInternalURL: TextBoxOptions;\r\n  urlForm = new FormGroup({});\r\n  SearchTextBox = new FormGroup({});\r\n  EN: boolean;\r\n  SearchTextBoxOptions: TextBoxOptions;\r\n  private root!: am5.Root;\r\n  surveyID: any;\r\n  survey: any;\r\n  loadInfo: boolean = false;\r\n  public SurveyStatusEnum = SurveyStatusEnum;\r\n  public AudienceTypeEnum = AudienceType;\r\n  surveyQuestions: SurveyQuestionDTO[] = [];\r\n  apiQuestionURL = this.surveyQuestionService.apiURL;\r\n  filtersQuestionForm = new FormGroup({});\r\n  canTakeSurvey: boolean = false\r\n  //Questions Section\r\n  @ViewChild('pagingQuestionViewElement', { static: false }) pagingQuestionElement: PagingComponent<any>;\r\n  pagingQuestionResult: any[] = [];\r\n  pagingQuestionOptions: PagingOptions;\r\n  showPageContent: boolean;\r\n  canEditQuestion: boolean;\r\n  canAddQuestion: boolean;\r\n  canDeleteQuestion: boolean;\r\n  searchQuestionTextFilter: any;\r\n  SurveyIDOptions: any;\r\n  searchSurveyIDFilter: FilterItem;\r\n\r\n\r\n  //Submission Section\r\n  filtersSubmissionForm = new FormGroup({});\r\n  @ViewChild('pagingSubmissionViewElement', { static: false }) pagingSubmissionElement: PagingComponent<any>;\r\n  pagingSubmissionResult: any[] = [];\r\n  pagingSubmissionOptions: PagingOptions;\r\n  showSubmissionPageContent: boolean;\r\n  searchSubmissionTextFilter: FilterItem;\r\n  searchSurveySubmissionIDFilter: FilterItem;\r\n  questionOverviewResult: any;\r\n  pagingQuestionResultOriginal: any;\r\n  showOverview: boolean;\r\n  showNav: boolean\r\n  constructor(private injector: Injector, @Inject(PLATFORM_ID) private platformId, private zone: NgZone, private router: Router\r\n    , private masterLayoutService: MasterLayoutService, private surveyService: SurveyService, private surveyQuestionService: SurveyQuestionService, private activatedRoute: ActivatedRoute) {\r\n    super(injector);\r\n    this.router.routeReuseStrategy.shouldReuseRoute = () => false;\r\n    this.surveyID = this.activatedRoute.snapshot.params[\"id\"];\r\n  }\r\n  // Run the function only in the browser\r\n  browserOnly(f: () => void) {\r\n    if (isPlatformBrowser(this.platformId)) {\r\n      this.zone.runOutsideAngular(() => {\r\n        f();\r\n      });\r\n    }\r\n  }\r\n\r\n  ngAfterViewInit() {\r\n\r\n  }\r\n\r\n  maybeDisposeRoot(divId) {\r\n    am5.array.each(am5.registry.rootElements, (root) => {\r\n      if (root) {\r\n        if (root.dom.id == divId) {\r\n          root.dispose();\r\n        }\r\n      }\r\n    });\r\n\r\n  };\r\n\r\n  loadChart(item) {\r\n\r\n    // Chart code goes in here\r\n    this.browserOnly(() => {\r\n      let name = `chartdiv`;\r\n      this.maybeDisposeRoot(name)\r\n      let root = am5.Root.new(name);\r\n      root.setThemes([am5themes_Animated.new(root)]);\r\n\r\n      let chart = root.container.children.push(\r\n        am5xy.XYChart.new(root, {\r\n          panX: false,\r\n          panY: false,\r\n          wheelX: 'none',\r\n          wheelY: 'none',\r\n          paddingBottom: 50,\r\n          paddingTop: 40,\r\n          layout: root.verticalLayout,\r\n\r\n        })\r\n      );\r\n\r\n      // Define data\r\n      let data = item.options.map(value => { return { 'name': value.localizedTitle, 'value': value.numberOfSelectedTime } })\r\n      // Create Y-axis\r\n      let yAxis = chart.yAxes.push(\r\n        am5xy.ValueAxis.new(root, {\r\n          baseValue: 0,\r\n          maxPrecision: 0,\r\n          extraTooltipPrecision: 100,\r\n          renderer: am5xy.AxisRendererY.new(root, {})\r\n        })\r\n      );\r\n\r\n      // Create X-Axis\r\n      let xAxis = chart.xAxes.push(\r\n        am5xy.CategoryAxis.new(root, {\r\n          renderer: am5xy.AxisRendererX.new(root, {}),\r\n          categoryField: \"name\"\r\n        })\r\n      );\r\n      xAxis.data.setAll(data);\r\n\r\n      // Create series\r\n      let series1 = chart.series.push(\r\n        am5xy.ColumnSeries.new(root, {\r\n          name: \"Question Options\",\r\n          xAxis: xAxis,\r\n          yAxis: yAxis,\r\n          valueYField: \"value\",\r\n          categoryXField: \"name\",\r\n            \r\n        })\r\n      );\r\n  \r\n\r\n      series1.data.setAll(data);\r\n      series1.set(\"fill\", am5.color(\"#b68a35\")); // set Series color to red\r\n      series1.set(\"stroke\", am5.color(\"#b68a35\")); // set Series color to red\r\n\r\n      // Add legend\r\n      let legend = chart.children.push(am5.Legend.new(root, {}));\r\n      legend.data.push(series1);\r\n\r\n      if (!this.EN) {\r\n        legend.labels.template.setAll({\r\n          textAlign: 'right',\r\n          x: 50,\r\n        });\r\n        legend.valueLabels.template.setAll({\r\n         textAlign:\"right\",\r\n         paddingRight:15\r\n        });\r\n      legend.itemContainers.template.setAll({\r\n        reverseChildren: true,\r\n      });\r\n      }\r\n      this.root = root;\r\n\r\n    });\r\n\r\n    // //chart overview\r\n    this.browserOnly(() => {\r\n      let nameOverView = `chartOverview`;\r\n      this.maybeDisposeRoot(nameOverView)\r\n      let root = am5.Root.new(nameOverView);\r\n\r\n      root.setThemes([am5themes_Animated.new(root)]);\r\n\r\n      let chart = root.container.children.push(\r\n        am5xy.XYChart.new(root, {\r\n          panY: false,\r\n          layout: root.verticalLayout\r\n        })\r\n      );\r\n\r\n\r\n      // Define data\r\n\r\n      let data = [];\r\n      for (const key in item.results) {\r\n        if (Object.prototype.hasOwnProperty.call(item.results, key)) {\r\n          const value = item.results[key];\r\n          let object = {\r\n            category: \">=\" + key,\r\n            value: value\r\n          }\r\n          data.push(object)\r\n        }\r\n      }\r\n\r\n      // Create Y-axis\r\n      let yAxis = chart.yAxes.push(\r\n        am5xy.ValueAxis.new(root, {\r\n          baseValue: 0,\r\n          maxPrecision: 0,\r\n          extraTooltipPrecision: 100,\r\n          renderer: am5xy.AxisRendererY.new(root, {})\r\n        })\r\n      );\r\n\r\n      // Create X-Axis\r\n      let xAxis = chart.xAxes.push(\r\n        am5xy.CategoryAxis.new(root, {\r\n          renderer: am5xy.AxisRendererX.new(root, {}),\r\n          categoryField: \"category\"\r\n        })\r\n      );\r\n      xAxis.data.setAll(data);\r\n\r\n      // Create series\r\n      let series1 = chart.series.push(\r\n        am5xy.ColumnSeries.new(root, {\r\n          name: \"Score\",\r\n          xAxis: xAxis,\r\n          yAxis: yAxis,\r\n          valueYField: \"value\",\r\n          categoryXField: \"category\",\r\n        })\r\n      );\r\n      series1.data.setAll(data);\r\n      series1.set(\"fill\", am5.color(\"#b68a35\")); // set Series color to red\r\n      series1.set(\"stroke\", am5.color(\"#b68a35\")); // set Series color to red\r\n      // Add legend\r\n      let legend = chart.children.push(am5.Legend.new(root, {}));\r\n      legend.data.setAll(chart.series.values);\r\n      if (!this.EN) {\r\n        legend.labels.template.setAll({\r\n          textAlign: 'right',\r\n          x: 50,\r\n        });\r\n        legend.valueLabels.template.setAll({\r\n         textAlign:\"right\",\r\n         paddingRight:15\r\n        });\r\n      legend.itemContainers.template.setAll({\r\n        reverseChildren: true,\r\n      });\r\n      }\r\n      this.root = root;\r\n    });\r\n\r\n  }\r\n  ngOnDestroy() {\r\n    // Clean up root element when the component is removed\r\n    this.browserOnly(() => {\r\n      if (this.root) {\r\n        this.root.dispose();\r\n      }\r\n    });\r\n  }\r\n\r\n  ngOnInit(): void {\r\n    this.surveyService.getInfo(this.surveyID).subscribe(result => {\r\n      this.survey = result;\r\n\r\n      this.TextBoxWithExternalURL = new TextBoxOptions();\r\n      this.TextBoxWithExternalURL.Name = \"TextBoxWithExternalURL\"\r\n      this.TextBoxWithExternalURL.LabelKey = \"External_URL\"\r\n      this.TextBoxWithExternalURL.Type = InputType.Text\r\n      this.TextBoxWithExternalURL.ViewType = ControlLayout.Vertical\r\n      this.TextBoxWithExternalURL.ForceDirection = ForceDirection.English\r\n      this.TextBoxWithExternalURL.EnableCopyToClipboard = true\r\n      this.TextBoxWithExternalURL.Value = this.survey.externalURL\r\n\r\n      this.TextBoxWithInternalURL = new TextBoxOptions();\r\n      this.TextBoxWithInternalURL.Name = \"TextBoxWithInternalURL\"\r\n      this.TextBoxWithInternalURL.LabelKey = \"Internal_URL\"\r\n      this.TextBoxWithInternalURL.Type = InputType.Text\r\n      this.TextBoxWithInternalURL.ViewType = ControlLayout.Vertical\r\n      this.TextBoxWithInternalURL.ForceDirection = ForceDirection.English\r\n      this.TextBoxWithInternalURL.EnableCopyToClipboard = true\r\n      this.TextBoxWithInternalURL.Value = this.survey.internalURL\r\n\r\n\r\n      this.breadCrumb = [];\r\n      this.breadCrumb.push(new BreadCrumb(this.l(\"Home\"), false, \"/\"), new BreadCrumb(this.l(\"Surveys_Header\"), false, '../../'), new BreadCrumb(this.l(\"Survey_Details\"), true));\r\n      this.pageHeaderOptions = new PageHeaderOptions();\r\n      this.pageHeaderOptions.TitleValue =this.survey.localizedTitle;\r\n      this.pageHeaderOptions.SearchTextBox.Active = false;\r\n      this.pageHeaderOptions.BreadCrumb.Active = true;\r\n      this.pageHeaderOptions.BreadCrumb.BreadCrumbItems = this.breadCrumb;\r\n      this.pageHeaderOptions.DropDownActions.Active = true;\r\n      this.pageHeaderOptions.DropDownActions.DropdownActionItems.push(\r\n        new DropdownActionItem(this.l(\"Edit\"), \"/assets/images/Edit.svg\", this.showEditModal),\r\n        new DropdownActionItem(this.l(\"Delete\"), '/assets/images/Trash.svg', this.showDeleteModal),\r\n        new DropdownActionItem(this.l(\"Export\"), '/assets/images/export.svg', this.export)\r\n        );\r\n\r\n      if (this.survey.totalQuestionCount > 0)\r\n        this.pageHeaderOptions.DropDownActions.DropdownActionItems.push(\r\n          new DropdownActionItem( this.l(\"Preview\"), '/assets/images/views.svg', this.previewSurvey));\r\n      if (this.survey.statusItemID.toLocaleLowerCase() == this.SurveyStatusEnum.ScoringTypeEnum_Published.toLocaleLowerCase())\r\n        this.canTakeSurvey = true\r\n\r\n      if (this.survey.statusItemID.toLocaleLowerCase() == this.SurveyStatusEnum.ScoringTypeEnum_Draft.toLocaleLowerCase()\r\n        || this.survey.statusItemID.toLocaleLowerCase() == this.SurveyStatusEnum.ScoringTypeEnum_Closed.toLocaleLowerCase())\r\n        this.pageHeaderOptions.DropDownActions.DropdownActionItems.push(new DropdownActionItem(this.l(\"Publish\"), '/assets/images/Submit.svg', this.showPublishModal))\r\n      else\r\n        this.pageHeaderOptions.DropDownActions.DropdownActionItems.push(new DropdownActionItem(this.l(\"UnPublish\"), '/assets/images/unlink.svg', this.showUnPublishModal),)\r\n\r\n      this.EN = this.utilityService.isCurrentLanguageEnglish();\r\n      this.loadQuestionSection();\r\n      this.loadSubmissionSection();\r\n      this.pageTitle = this.survey.localizedTitle\r\n      this.updatePageTitle(this.survey.localizedTitle);\r\n      this.loadInfo = true;\r\n\r\n\r\n    });\r\n  }\r\n  showEditModal = () => {\r\n    this.editModal.showEditModal(this.surveyID);\r\n  }\r\n  showDeleteModal = () => {\r\n    this.deleteConfirmationModalControl.showDeleteModal(this.surveyID);\r\n\r\n  }\r\n  showEditQuestionModal(id,isViewOnly) {\r\n    this.editQuestionModal.editModal(id, this.survey.audienceItemID,isViewOnly);\r\n\r\n  }\r\n  showAddQuestionModal() {\r\n    this.AddQuestionComponent.addModal(this.surveyID, this.survey.audienceItemID);\r\n\r\n  }\r\n  showDeleteQuestionModal = (id) => {\r\n    this.deleteQuestionConfirmationModalControl.showDeleteModal(id);\r\n\r\n  }\r\n  showPublishModal = () => {\r\n    this.addPublishModal.publishModal(this.surveyID, this.pagingQuestionResult);\r\n\r\n  }\r\n  showUnPublishModal = () => {\r\n    this.addUnPublishModal.showConfirmationModal(this.surveyID);\r\n\r\n  }\r\n  drop(event: CdkDragDrop<string[]>) {\r\n    moveItemInArray(this.pagingQuestionResult, event.previousIndex, event.currentIndex);\r\n    for (let index = 0; index < this.pagingQuestionResult.length; index++) {\r\n      this.pagingQuestionResult[index].displayOrder = index + 1;\r\n    }\r\n    this.surveyQuestionService.updateDisplayOrder(this.pagingQuestionResult).subscribe(e => {\r\n      this.utilityService.stopBlockUI();\r\n    });\r\n  }\r\n  previewSurvey = () => {\r\n    this.router.navigate(['../../info/preview', this.surveyID, this.survey.audienceItemID], {relativeTo: this.activatedRoute});\r\n  }\r\n  takeSurvey = () => {\r\n    this.router.navigate(['../../info/submission', this.surveyID], {relativeTo: this.activatedRoute});\r\n  }\r\n\r\n  getStatus(status) {\r\n    var Statuses = '';\r\n    switch (status.toLocaleLowerCase()) {\r\n      case this.SurveyStatusEnum.ScoringTypeEnum_Draft.toLocaleLowerCase():\r\n        Statuses = 'badge-secondary';\r\n        this.canEditQuestion = true;\r\n        this.canDeleteQuestion = true;\r\n        this.canAddQuestion = true;\r\n        break;\r\n      case this.SurveyStatusEnum.ScoringTypeEnum_Closed.toLocaleLowerCase():\r\n        Statuses = 'badge-danger';\r\n        this.canEditQuestion = false;\r\n        this.canDeleteQuestion = true;\r\n        this.canAddQuestion = false;\r\n\r\n        break;\r\n      case this.SurveyStatusEnum.ScoringTypeEnum_Published.toLocaleLowerCase():\r\n        Statuses = 'badge-success';\r\n        this.canEditQuestion = false;\r\n        this.canDeleteQuestion = false;\r\n        this.canAddQuestion = false;\r\n        break;\r\n      case this.SurveyStatusEnum.ScoringTypeEnum_Upcoming.toLocaleLowerCase():\r\n        Statuses = 'badge-success';\r\n        this.canEditQuestion = true;\r\n        this.canDeleteQuestion = true;\r\n        this.canAddQuestion = true;\r\n        break;\r\n\r\n      default:\r\n        break;\r\n    }\r\n    return Statuses;\r\n  }\r\n\r\n  loadQuestionSection() {\r\n    this.SearchTextBoxOptions = new TextBoxOptions();\r\n    this.SearchTextBoxOptions.Name = \"SearchTextBox\";\r\n    this.SearchTextBoxOptions.Type = InputType.Text;\r\n    this.SearchTextBoxOptions.TrimTextOnChange = true;\r\n    this.SearchTextBoxOptions.Placeholder = this.l(\"Search\");\r\n    this.SearchTextBoxOptions.ExtraClasses = \"form-control form-control-sm form-control-solid search-box\";\r\n    this.SearchTextBoxOptions.HideLabel = true;\r\n    this.SearchTextBoxOptions.Icon = \"../../../assets/images/search.svg\"\r\n\r\n\r\n\r\n\r\n    this.SurveyIDOptions = new TextBoxOptions();\r\n    this.SurveyIDOptions.Name = \"SurveyID\";\r\n    this.SurveyIDOptions.Value = this.surveyID;\r\n\r\n    this.searchSurveyIDFilter = new FilterItem();\r\n    this.searchSurveyIDFilter.FormControlName = this.SurveyIDOptions.Name;\r\n    this.searchSurveyIDFilter.ActionParameterName = \"SurveyID\";\r\n    this.searchSurveyIDFilter.IsFormControl = true;\r\n    this.searchSurveyIDFilter.FilterType = FilterType.TextBox;\r\n\r\n\r\n\r\n    this.pagingQuestionOptions = new PagingOptions();\r\n    this.pagingQuestionOptions.PageSize = 1000;\r\n    this.pagingQuestionOptions.DisableBlockUI = true;\r\n    this.pagingQuestionOptions.ActionPostURL = this.apiQuestionURL + 'GetAllQuestions';\r\n    this.pagingQuestionOptions.Filters = [this.searchSurveyIDFilter];\r\n\r\n\r\n\r\n  }\r\n  setQuestionListingResult(result) {\r\n    this.pagingQuestionResult = result;\r\n    this.pagingQuestionResultOriginal = result;\r\n    this.showPageContent = true;\r\n    this.utilityService.stopBlockUI();\r\n    let overviewQuestions = this.pagingQuestionResultOriginal.filter(item => item.questionTypeItemID == SurveyOptionType.RadioButton || item.questionTypeItemID == SurveyOptionType.SingleSelect || item.questionTypeItemID == SurveyOptionType.MultipleSelect)\r\n    if (overviewQuestions.length > 0)\r\n      this.loadSurveyOverview();\r\n  }\r\n\r\n\r\n  onSuccessHandler = (success: any) => {\r\n    this.utilityService.notifySuccessMessage(this.l(\"RecordUpdated\"), null, null, false);\r\n    this.masterLayoutService.reloadComponent();\r\n  }\r\n\r\n  onSuccessDeleteHandler = (success: any) => {\r\n    this.utilityService.notifySuccessMessage(this.l(\"RecordDeleted\"), null, null, false);\r\n    this.router.navigate([\"../../\"], {relativeTo: this.activatedRoute});\r\n  }\r\n\r\n  onSuccessAddQuestionHandler = (success: any) => {\r\n    this.utilityService.notifySuccessMessage(this.l(\"RecordAdded\"), null, null, false);\r\n    this.masterLayoutService.reloadComponent();\r\n  }\r\n  onSuccessEditQuestionHandler = (success: any) => {\r\n    this.utilityService.notifySuccessMessage(this.l(\"RecordUpdated\"), null, null, false);\r\n    this.masterLayoutService.reloadComponent();\r\n  }\r\n\r\n  onSuccessDeleteQuestionHandler = (success: any) => {\r\n    this.utilityService.notifySuccessMessage(this.l(\"RecordDeleted\"), null, null, false);\r\n    this.masterLayoutService.reloadComponent();\r\n  }\r\n\r\n\r\n\r\n  showDeleteSubmissionModal = (id) => {\r\n    this.deleteSubmissionConfirmationModalControl.showDeleteModal(id);\r\n\r\n  }\r\n  showEliminateSubmissionModal = (id) => {\r\n    this.eliminateSubmissionConfirmationModalControl.showEliminateModal(id);\r\n  }\r\n  showUnEliminateSubmissionModal = (id) => {\r\n    this.unEliminateSubmissionConfirmationModalControl.showUnEliminateModal(id);\r\n  }\r\n  onSuccessDeleteHandlerSubmission = (success: any) => {\r\n    this.utilityService.notifySuccessMessage(this.l(\"RecordDeleted\"), null, null, false);\r\n    this.loadSubmissionSection();\r\n  }\r\n  loadSubmissionSection() {\r\n    this.SearchTextBoxOptions = new TextBoxOptions();\r\n    this.SearchTextBoxOptions.Name = \"SearchTextBox\";\r\n    this.SearchTextBoxOptions.Type = InputType.Text;\r\n    this.SearchTextBoxOptions.TrimTextOnChange = true;\r\n    this.SearchTextBoxOptions.Placeholder = this.l(\"Search\");\r\n    this.SearchTextBoxOptions.ExtraClasses = \"form-control form-control-sm form-control-solid search-box\";\r\n    this.SearchTextBoxOptions.HideLabel = true;\r\n    this.SearchTextBoxOptions.Icon = \"../../../assets/images/search.svg\"\r\n\r\n    this.searchSubmissionTextFilter = new FilterItem();\r\n    this.searchSubmissionTextFilter.FormControlName = this.SearchTextBoxOptions.Name;\r\n    this.searchSubmissionTextFilter.ActionParameterName = \"SearchText\";\r\n    this.searchSubmissionTextFilter.IsFormControl = true;\r\n    this.searchSubmissionTextFilter.FilterType = FilterType.TextBox;\r\n\r\n\r\n    this.SurveyIDOptions = new TextBoxOptions();\r\n    this.SurveyIDOptions.Name = \"SurveyID\";\r\n    this.SurveyIDOptions.Value = this.surveyID;\r\n\r\n    this.searchSurveySubmissionIDFilter = new FilterItem();\r\n    this.searchSurveySubmissionIDFilter.FormControlName = this.SurveyIDOptions.Name;\r\n    this.searchSurveySubmissionIDFilter.ActionParameterName = \"SurveyID\";\r\n    this.searchSurveySubmissionIDFilter.IsFormControl = true;\r\n    this.searchSurveySubmissionIDFilter.FilterType = FilterType.TextBox;\r\n\r\n\r\n\r\n    this.pagingSubmissionOptions = new PagingOptions();\r\n    this.pagingSubmissionOptions.PageSize = 10;\r\n    this.pagingSubmissionOptions.DisableBlockUI = true;\r\n    this.pagingSubmissionOptions.ActionPostURL = this.surveyService.apiURL + 'GetAllSurveySubmission';\r\n    this.pagingSubmissionOptions.OnKeyPressFiltersControlNames = [this.SearchTextBoxOptions.Name];\r\n    this.pagingSubmissionOptions.Filters = [this.searchSurveySubmissionIDFilter, this.searchSubmissionTextFilter];\r\n\r\n\r\n\r\n  }\r\n  setSubmissionListingResult(result) {\r\n    this.pagingSubmissionResult = result;\r\n    this.showSubmissionPageContent = true;\r\n    this.utilityService.stopBlockUI();\r\n  }\r\n  loadSurveyOverview() {\r\n    this.surveyService.getSurveyOverview(this.surveyID).subscribe((res) => {\r\n      this.questionOverviewResult = res as any\r\n      this.showOverview = true;\r\n      this.loadChart(this.questionOverviewResult[0]);\r\n    })\r\n  }\r\n\r\n  export = () => {\r\n    this.surveyService\r\n      .export(this.surveyID)\r\n      .subscribe((result) => {\r\n        this.download((result as any) as Blob, this.pageTitle + \".xlsx\");\r\n      });\r\n  }\r\n\r\n  searchInQuestionList(value) {\r\n    if (value)\r\n      this.pagingQuestionResult = this.pagingQuestionResultOriginal.filter(item => item.localizedText.toLowerCase().includes(value.toLowerCase()))\r\n    else\r\n      this.pagingQuestionResult = this.pagingQuestionResultOriginal;\r\n  }\r\n\r\n}\r\n","<!--toolbar-->\r\n<div *ngIf=\"loadInfo\">\r\n  <bbsf-page-header-component [options]=\"pageHeaderOptions\"></bbsf-page-header-component>\r\n</div>\r\n<!--end toolbar-->\r\n<div class=\"container-xxl\">\r\n  <div class=\"info-container\" *ngIf=\"loadInfo\">\r\n    <div class=\"section-margin-bottom\">\r\n      <div class=\"d-flex justify-content-between align-items-center\">\r\n        <div class=\"survery-date border-0\">\r\n          <div class=\"icon-boxes align-items-baseline\">\r\n            <div ngbTooltip=\"{{l('Date')}}\" class=\"icon-box\">\r\n              <div class=\"symbol\">\r\n                <span class=\"symbol-label\">\r\n                  <span class=\"svg-icon svg-icon-4\" [inlineSVG]=\"'/assets/images/calendar.svg'\">\r\n                  </span>\r\n                </span>\r\n              </div>\r\n              <span class=\"survey-counter-title\" *ngIf=\"survey.startDate==null\">\r\n                {{l('NotStartedYet')}}\r\n              </span>\r\n              <span class=\"survey-counter-title d-flex flex-stack\" *ngIf=\"survey.startDate!=null\">\r\n                {{survey.startDate |surveyDate}} - {{survey.endDate!=null?(survey.endDate|surveyDate):\"\"}}\r\n                <span class=\"badge badge-light\" *ngIf=\"survey.endDate==null\">{{l('HasNoEnd')}}</span>\r\n              </span>\r\n            </div>\r\n          </div>\r\n        </div>\r\n        <div>\r\n          <span class=\"badge badge-light\" [ngClass]=\"getStatus(survey.statusItemID)\">{{survey.localizedStatus}}</span>\r\n          <span ngbTooltip=\"{{l('Audience')}}\" class=\"badge badge-light mx-2\">{{survey.localizedAudience}}</span>\r\n        </div>\r\n      </div>\r\n      <div class=\"row card-data\">\r\n        <div class=\"col-lg-6\">\r\n          <BBSF-TextBox *ngIf=\"canTakeSurvey&& (survey.audienceItemID==AudienceTypeEnum.Internal||survey.audienceItemID==AudienceTypeEnum.Both)\"\r\n                        [options]=\"TextBoxWithInternalURL\" [group]=\"urlForm\"></BBSF-TextBox>\r\n\r\n        </div>\r\n        <div class=\"col-lg-6\">\r\n          <BBSF-TextBox *ngIf=\"canTakeSurvey&& (survey.audienceItemID==AudienceTypeEnum.External||survey.audienceItemID==AudienceTypeEnum.Both)\"\r\n                        [options]=\"TextBoxWithExternalURL\" [group]=\"urlForm\"></BBSF-TextBox>\r\n        </div>\r\n      </div>\r\n      <p class=\"card-description\" *ngIf=\"survey.localizedDesc\">\r\n        {{survey.localizedDesc}}\r\n      </p>\r\n    </div>\r\n    <div class=\"section-margin-bottom\">\r\n      <ul ngbNav #nav=\"ngbNav\" class=\"nav nav-stretch nav-line-tabs nav-custom\">\r\n        <li ngbNavItem class=\"nav-item\" [destroyOnHide]=\"true\">\r\n          <a class=\"nav-link\" ngbNavLink>\r\n            <h4>\r\n              {{l('Questions')}}\r\n            </h4>\r\n          </a>\r\n          <ng-template ngbNavContent>\r\n            <div class=\"section-info\">\r\n              <div class=\"tabs-search page-subheader justify-content-between\">\r\n                <BBSF-TextBox [options]=\"SearchTextBoxOptions\" [group]=\"filtersQuestionForm\"\r\n                              (OnChange)=\"searchInQuestionList($event)\"></BBSF-TextBox>\r\n                <BBSF-TextBox [options]=\"SurveyIDOptions\" [group]=\"filtersQuestionForm\" hidden></BBSF-TextBox>\r\n                <button type=\"button\" *ngIf=\"canAddQuestion\" class=\"btn btn-brand btn-sm subheader-btn\"\r\n                        (click)=\"showAddQuestionModal()\">\r\n                  {{l('Add')}}\r\n                </button>\r\n              </div>\r\n              <div [hidden]=\"pagingQuestionResult.length == 0\">\r\n                <div ngbNavContent cdkDropList (cdkDropListDropped)=\"drop($event)\">\r\n                  <div class=\"question-info\" [cdkDragDisabled]=\"canTakeSurvey\" cdkDrag\r\n                       *ngFor=\"let item of pagingQuestionResult; let i=index\">\r\n                    <div class=\"symbol symbol-25px me-4\" cdkDragHandle *ngIf=\"!canTakeSurvey\">\r\n                      <span class=\"symbol-label\">\r\n                        <span class=\"svg-icon svg-icon-7\" [inlineSVG]=\"'/assets/images/reorder.svg'\">\r\n                        </span>\r\n                      </span>\r\n                    </div>\r\n                    <div class=\"card card-listing\">\r\n                      <div class=\"card-header\">\r\n                        <div class=\"card-title\">\r\n                          <span class=\"badge badge-light\"\r\n                                ngbTooltip=\"{{l('Type')}}\">{{item.localizedQuestionTypeItem}}</span>\r\n                          <span class=\"badge badge-light mx-2\"\r\n                                ngbTooltip=\"{{l('Audience')}}\">{{item.localizedAudienceType}}</span>\r\n                          <span class=\"badge badge-brand-light mx-2\"\r\n                                *ngIf=\"item.isRelatedToSurveyQuestion\">{{l('Linked')}}</span>\r\n                          <span class=\"badge badge-light mx-2\" *ngIf=\"!item.isVisible\" ngbTooltip=\"{{l('NotVisible')}}\">\r\n                            {{l(\"NotVisible\")}}\r\n                          </span>\r\n                        </div>\r\n                        <div class=\"card-toolbar\">\r\n                          <div ngbDropdown container=\"body\" class=\"dropdown-custom\"\r\n                               [placement]=\"EN ? 'bottom-right' : 'bottom-left'\">\r\n                            <button type=\"button\" class=\"dropdown-toggle-custom btn btn-clear\" ngbDropdownToggle>\r\n                              <span class=\"svg-icon svg-icon-3\"\r\n                                    [inlineSVG]=\"'/assets/images/card-dropdown.svg'\"></span>\r\n                            </button>\r\n                            <div ngbDropdownMenu class=\"dropdown-menu-custom\">\r\n                              <button *ngIf=\"!(canEditQuestion&&canDeleteQuestion)\"\r\n                                      (click)=\"showEditQuestionModal(item.iD_GUID,true)\" apppreventdoubleclick type=\"button\"\r\n                                      ngbDropdownItem class=\"dropdown-button\">\r\n                                <span class=\"svg-icon svg-icon-3\" [inlineSVG]=\"'/assets/images/info.svg'\">\r\n                                </span>\r\n                                {{l(\"Details\")}}\r\n                              </button>\r\n\r\n                              <button *ngIf=\"canEditQuestion\" (click)=\"showEditQuestionModal(item.iD_GUID,false)\"\r\n                                      apppreventdoubleclick type=\"button\" ngbDropdownItem class=\"dropdown-button\">\r\n                                <span class=\"svg-icon svg-icon-3\" [inlineSVG]=\"'/assets/images/Edit.svg'\">\r\n                                </span>\r\n                                {{l(\"Edit\")}}\r\n                              </button>\r\n                              <button type=\"button\" *ngIf=\"canDeleteQuestion\"\r\n                                      (click)=\"showDeleteQuestionModal(item.iD_GUID)\" apppreventdoubleclick ngbDropdownItem\r\n                                      class=\"dropdown-button\">\r\n                                <span class=\"svg-icon svg-icon-3\"\r\n                                      [inlineSVG]=\"'/assets/images/Trash.svg'\"></span> {{l(\"Delete\")}}\r\n                              </button>\r\n                            </div>\r\n                          </div>\r\n                        </div>\r\n                      </div>\r\n                      <div class=\"card-body\">\r\n                        <div class=\"survey-counter\">\r\n                          <span class=\"survey-counter-title\">{{item.localizedText}}</span>\r\n                          <span class=\"badge badge-light-brand badge-square ms-2 me-0\"\r\n                                ngbTooltip=\"{{l('Score')}}\">{{item.totalScore}}</span>\r\n                        </div>\r\n                      </div>\r\n                    </div>\r\n                  </div>\r\n                </div>\r\n                <BBSF-Paging (Items)=\"setQuestionListingResult($event)\" [options]=\"pagingQuestionOptions\"\r\n                             [group]=\"filtersQuestionForm\" #pagingQuestionViewElement></BBSF-Paging>\r\n              </div>\r\n            </div>\r\n            <app-no-results *ngIf=\"pagingQuestionResult.length == 0\"></app-no-results>\r\n\r\n          </ng-template>\r\n        </li>\r\n        <li ngbNavItem class=\"nav-item\" [destroyOnHide]=\"true\">\r\n          <a class=\"nav-link\" ngbNavLink>\r\n            <h4>\r\n              {{l('Submissions')}}\r\n            </h4>\r\n          </a>\r\n          <ng-template ngbNavContent>\r\n            <div class=\"section-info\" ngbNavContent>\r\n              <div class=\"tabs-search page-subheader justify-content-between\">\r\n                <BBSF-TextBox [options]=\"SearchTextBoxOptions\" [group]=\"filtersSubmissionForm\"></BBSF-TextBox>\r\n                <BBSF-TextBox [options]=\"SurveyIDOptions\" [group]=\"filtersSubmissionForm\" hidden></BBSF-TextBox>\r\n              </div>\r\n              <div class=\"info-container\" [hidden]=\"pagingSubmissionResult.length == 0\">\r\n                <div class=\"table-responsive\">\r\n                  <table class=\"table table-custom\">\r\n                    <thead>\r\n                      <tr class=\"table-header\">\r\n                        <th> {{l('Name')}}</th>\r\n                        <th>{{l('Email')}}</th>\r\n                        <th>{{l('Type')}}</th>\r\n                        <th>{{l('Created')}}</th>\r\n                        <th>{{l('Score')}}</th>\r\n                        <th class=\"table-action\">{{l(\"Action\")}}</th>\r\n                      </tr>\r\n                    </thead>\r\n                    <tbody class=\"table-body\">\r\n                      <tr *ngFor=\"let item of pagingSubmissionResult; let i=index\">\r\n                        <td>\r\n                          <span class=\"line-clamp-2\">\r\n                            {{item.localizedName}}\r\n                            <span class=\"badge badge-danger mx-2\" *ngIf=\"item.isEliminated&&item.allowElimination\">\r\n                              {{l('Eliminated')}}\r\n                            </span>\r\n                          </span>\r\n                        </td>\r\n                        <td>\r\n                          {{item.email}}\r\n                        </td>\r\n                        <td>\r\n                          <div class=\"badge badge-light\">\r\n                            {{item.isInternalUser? l('InternalUsers'):l('ExternalUsers')}}\r\n                          </div>\r\n                        </td>\r\n                        <td>{{item.created|surveyDate}}</td>\r\n                        <td>{{item.totalScore}}</td>\r\n                        <td class=\"table-action\">\r\n                          <button type=\"button\" ngbTooltip=\"{{l('Preview')}}\"\r\n                                  [routerLink]=\"['../../info/result', item.iD_GUID]\" class=\"btn btn-sm p-2\">\r\n                            <span class=\"svg-icon svg-icon-3\"\r\n                                  [inlineSVG]=\"'/assets/images/answers.svg'\"></span>\r\n                          </button>\r\n\r\n                          <button type=\"button\" *ngIf=\"!item.isEliminated&&item.allowElimination\"\r\n                                  ngbTooltip=\"{{this.l('EliminateHint')}}\" class=\"btn btn-sm p-2\">\r\n                            <span class=\"svg-icon svg-icon-3\" (click)=\"showEliminateSubmissionModal(item.iD_GUID)\"\r\n                                  apppreventdoubleclick\r\n                                  [inlineSVG]=\"'/assets/images/unlink.svg'\"></span>\r\n                          </button>\r\n\r\n                          <button type=\"button\" *ngIf=\"item.isEliminated&&item.allowElimination\"\r\n                                  ngbTooltip=\"{{this.l('UnEliminate')}}\" class=\"btn btn-sm p-2\">\r\n                            <span class=\"svg-icon svg-icon-3\" (click)=\"showUnEliminateSubmissionModal(item.iD_GUID)\"\r\n                                  apppreventdoubleclick [inlineSVG]=\"'/assets/images/link.svg'\"></span>\r\n                          </button>\r\n\r\n                          <button type=\"button\" ngbTooltip=\"{{l('Delete')}}\" class=\"btn btn-sm p-2\">\r\n                            <span class=\"svg-icon svg-icon-3\" (click)=\"showDeleteSubmissionModal(item.iD_GUID)\"\r\n                                  apppreventdoubleclick [inlineSVG]=\"'/assets/images/Trash.svg'\"></span>\r\n                          </button>\r\n                        </td>\r\n                      </tr>\r\n                    </tbody>\r\n                  </table>\r\n                </div>\r\n              </div>\r\n              <BBSF-Paging (Items)=\"setSubmissionListingResult($event)\" [options]=\"pagingSubmissionOptions\"\r\n                           [group]=\"filtersSubmissionForm\" #pagingSubmissionViewElement></BBSF-Paging>\r\n            </div>\r\n            <app-no-results *ngIf=\"pagingSubmissionResult.length == 0\"></app-no-results>\r\n\r\n          </ng-template>\r\n        </li>\r\n        <li ngbNavItem class=\"nav-item\" *ngIf=\"showOverview\" [destroyOnHide]=\"true\">\r\n          <a class=\"nav-link\" ngbNavLink (click)=\"loadSurveyOverview()\">\r\n            <h4>\r\n              {{l(\"Overview\") }}\r\n            </h4>\r\n          </a>\r\n          <ng-template ngbNavContent>\r\n            <div class=\"section-info\" ngbNavContent>\r\n\r\n              <div class=\"row\">\r\n                <div class=\"col-md-3\">\r\n                  <div class=\"chart-container\">\r\n                    <div class=\"chart-title\"> {{l(\"Questions\") }}</div>\r\n                    <ul ngbNav #nav=\"ngbNav\" class=\"nav-pills custom-navs\" orientation=\"vertical\">\r\n                      <li ngbNavItem=\"{{item.localizedTitle}}\" [destroyOnHide]=\"true\"\r\n                          *ngFor=\"let item of questionOverviewResult\" (click)=\"loadChart(item)\">\r\n                        <a ngbNavLink>{{item.localizedTitle}}</a>\r\n\r\n                      </li>\r\n\r\n                    </ul>\r\n                  </div>\r\n                </div>\r\n                <div class=\"col-md-9\">\r\n                  <div class=\"chart-container\">\r\n                    <div class=\"chart-title\">{{l(\"Overview\") }}</div>\r\n                    <div id=\"chartdiv\" style=\"width: 100%; height: 400px\"></div>\r\n                    <div class=\"hide-logo\"></div>\r\n                  </div>\r\n                  <div class=\"chart-container\">\r\n                    <div class=\"chart-title\">{{l(\"Score\") }} </div>\r\n                    <div id=\"chartOverview\" style=\"width: 100%; height: 400px\"></div>\r\n                    <div class=\"hide-logo\"></div>\r\n                  </div>\r\n                </div>\r\n              </div>\r\n            </div>\r\n          </ng-template>\r\n        </li>\r\n      </ul>\r\n\r\n\r\n      <div [ngbNavOutlet]=\"nav\"></div>\r\n    </div>\r\n  </div>\r\n</div>\r\n\r\n  <app-edit-survey #editModal [pagingElement]=\"pagingElement\" [onSuccessHandler]=\"onSuccessHandler\"></app-edit-survey>\r\n  <app-delete-survey #deleteConfirmationModalControl [pagingElement]=\"pagingElement\"\r\n                     [onSuccessHandler]=\"onSuccessDeleteHandler\"></app-delete-survey>\r\n  <app-add-question #addQuestionModal [pagingElement]=\"pagingQuestionElement\" [onSuccessAddHandler]=\"onSuccessAddQuestionHandler\"></app-add-question>\r\n  <app-edit-question #editQuestionModal [pagingElement]=\"pagingQuestionElement\" [onSuccessEditHandler]=\"onSuccessEditQuestionHandler\"></app-edit-question>\r\n  <app-delete-question #deleteQuestionModal [pagingElement]=\"pagingQuestionElement\" [onSuccessHandler]=\"onSuccessDeleteQuestionHandler\"></app-delete-question>\r\n  <app-publish-survey #addPublishModal [pagingElement]=\"pagingElement\" [onSuccessHandler]=\"onSuccessHandler\" *ngIf=\"loadInfo\" [showToggle]=\"survey.isShowToggleOfScoreResultAfterSubmission\">\r\n  </app-publish-survey>\r\n  <app-unpublish-survey #addUnPublishModal [pagingElement]=\"pagingElement\" [onSuccessHandler]=\"onSuccessHandler\">\r\n  </app-unpublish-survey>\r\n  <app-delete-submission #deleteSubmissionModal [pagingElement]=\"pagingSubmissionElement\"\r\n                         [onSuccessHandler]=\"onSuccessDeleteHandlerSubmission\"></app-delete-submission>\r\n  <app-eliminate-submission #eliminateModal [pagingElement]=\"pagingSubmissionElement\"\r\n                            [onSuccessHandler]=\"onSuccessHandler\"></app-eliminate-submission>\r\n  <app-unEliminate-submission #unEliminateModal [pagingElement]=\"pagingSubmissionElement\"\r\n                              [onSuccessHandler]=\"onSuccessHandler\"></app-unEliminate-submission>\r\n"]}