asymmetry: enable filtering on SymmetryArrows, BackwardTravelTime, Asymmetric Trainruns

Signed-off-by: Louis Greiner <[email protected]>

Author: louisgreiner

src/app/data-structures/business.data.structures.ts

@@ -294,15 +294,18 @@ export interface FilterSettingDto {
   filterNoteLabels: number[]; // labels to filter out (labels only of type - LabelRef: note)
   filterTrainrunLabels: number[]; // labels to filter out (labels only of type - LabelRef: trainrun)
   filterDirectionArrows: boolean; // flag for trainrun direction arrows (hide/show)
+  filterAsymmetryArrows: boolean; // flag for trainrun section asymmetry arrows (hide/show)
   filterArrivalDepartureTime: boolean; // flag for arrival and departure time filtering (hide/show)
   filterTravelTime: boolean; // flag for travel time filter (hide/show)
+  filterBackwardTravelTime: boolean; // flag for trainrun section backward travel times (hide/show)
   filterTrainrunName: boolean; // flag for trainrun time filter (hide/show)
   filterConnections: boolean; // flag for connections filtering (hide/show)
   filterShowNonStopTime: boolean; // flag for non-stop time filtering (hide/show)
   filterTrainrunCategory: TrainrunCategory[]; // list of category to filter out
   filterTrainrunFrequency: TrainrunFrequency[]; // list of frequency to filter out
   filterTrainrunTimeCategory: TrainrunTimeCategory[]; // list of time categroy to filter out
   filterDirection: Direction[]; // list of trainrun direction to filter out
+  filterSymmetry: boolean[]; // list of trainrun symmetry values (true/false) to filter out
   filterAllEmptyNodes: boolean; // flag to filter all empty nodes (hide/show)
   filterAllNonStopNodes: boolean; // flag to filter all only non-stop nodes (hide/show)
   filterNotes: boolean; // flag to filter notes (hide/show)

src/app/models/filterSettings.model.ts

@@ -19,16 +19,19 @@ export class FilterSetting {
   public filterNodeLabels: number[];
   public filterNoteLabels: number[];
   public filterTrainrunLabels: number[];
-  public filterDirectionArrows;
+  public filterDirectionArrows: boolean;
+  public filterAsymmetryArrows: boolean;
   public filterArrivalDepartureTime;
   public filterTravelTime;
+  public filterBackwardTravelTime: boolean;
   public filterTrainrunName;
   public filterConnections;
   public filterShowNonStopTime;
   public filterTrainrunCategory: TrainrunCategory[];
   public filterTrainrunFrequency: TrainrunFrequency[];
   public filterTrainrunTimeCategory: TrainrunTimeCategory[];
   public filterDirection: Direction[];
+  public filterSymmetry: boolean[];
   public filterAllEmptyNodes;
   public filterAllNonStopNodes;
   public filterNotes;
@@ -44,16 +47,19 @@ export class FilterSetting {
       filterNodeLabels,
       filterNoteLabels,
       filterTrainrunLabels,
-      filterDirectionArrows: filterDirectionArrows,
+      filterDirectionArrows,
+      filterAsymmetryArrows,
       filterArrivalDepartureTime,
       filterTravelTime,
+      filterBackwardTravelTime,
       filterTrainrunName,
       filterConnections,
       filterShowNonStopTime,
       filterTrainrunCategory,
       filterTrainrunFrequency,
       filterTrainrunTimeCategory,
       filterDirection: filterDirection,
+      filterSymmetry: filterSymmetry,
       filterAllEmptyNodes,
       filterAllNonStopNodes,
       filterNotes,
@@ -68,15 +74,18 @@ export class FilterSetting {
       filterNoteLabels: [],
       filterTrainrunLabels: [],
       filterDirectionArrows: true,
+      filterAsymmetryArrows: true,
       filterArrivalDepartureTime: true,
       filterTravelTime: true,
+      filterBackwardTravelTime: true,
       filterTrainrunName: true,
       filterConnections: true,
       filterShowNonStopTime: true,
       filterTrainrunCategory: null,
       filterTrainrunFrequency: null,
       filterTrainrunTimeCategory: null,
       filterDirection: null,
+      filterSymmetry: null,
       filterAllEmptyNodes: false,
       filterAllNonStopNodes: false,
       filterNotes: false,
@@ -92,15 +101,18 @@ export class FilterSetting {
     this.filterNoteLabels = filterNoteLabels;
     this.filterTrainrunLabels = filterTrainrunLabels;
     this.filterDirectionArrows = filterDirectionArrows;
+    this.filterAsymmetryArrows = filterAsymmetryArrows;
     this.filterArrivalDepartureTime = filterArrivalDepartureTime;
     this.filterTravelTime = filterTravelTime;
+    this.filterBackwardTravelTime = filterBackwardTravelTime;
     this.filterTrainrunName = filterTrainrunName;
     this.filterConnections = filterConnections;
     this.filterShowNonStopTime = filterShowNonStopTime;
     this.filterTrainrunCategory = filterTrainrunCategory;
     this.filterTrainrunFrequency = filterTrainrunFrequency;
     this.filterTrainrunTimeCategory = filterTrainrunTimeCategory;
     this.filterDirection = filterDirection;
+    this.filterSymmetry = filterSymmetry;
     this.filterAllEmptyNodes = filterAllEmptyNodes;
     this.filterAllNonStopNodes = filterAllNonStopNodes;
     this.filterNotes = filterNotes;
@@ -173,15 +185,18 @@ export class FilterSetting {
       this.filterNoteLabels.length === 0 &&
       this.filterTrainrunLabels.length === 0 &&
       this.filterDirectionArrows === true &&
+      this.filterAsymmetryArrows === true &&
       this.filterArrivalDepartureTime === true &&
       this.filterTravelTime === true &&
+      this.filterBackwardTravelTime === true &&
       this.filterTrainrunName === true &&
       this.filterConnections === true &&
       this.filterShowNonStopTime === true &&
       this.filterTrainrunCategory.length === trainrunCategoriesLength &&
       this.filterTrainrunFrequency.length === frainrunFrequenciesLength &&
       this.filterTrainrunTimeCategory.length === trainrunTimeCategoryLength &&
       this.filterDirection.length === Object.values(Direction).length &&
+      this.filterSymmetry.length === 2 &&
       this.filterAllEmptyNodes === false &&
       this.filterAllNonStopNodes === false &&
       this.filterNotes === false &&
@@ -200,15 +215,18 @@ export class FilterSetting {
       filterNoteLabels: this.filterNoteLabels,
       filterTrainrunLabels: this.filterTrainrunLabels,
       filterDirectionArrows: this.filterDirectionArrows,
+      filterAsymmetryArrows: this.filterAsymmetryArrows,
       filterArrivalDepartureTime: this.filterArrivalDepartureTime,
       filterTravelTime: this.filterTravelTime,
+      filterBackwardTravelTime: this.filterBackwardTravelTime,
       filterTrainrunName: this.filterTrainrunName,
       filterConnections: this.filterConnections,
       filterShowNonStopTime: this.filterShowNonStopTime,
       filterTrainrunCategory: this.filterTrainrunCategory,
       filterTrainrunFrequency: this.filterTrainrunFrequency,
       filterTrainrunTimeCategory: this.filterTrainrunTimeCategory,
       filterDirection: this.filterDirection,
+      filterSymmetry: this.filterSymmetry,
       filterAllEmptyNodes: this.filterAllEmptyNodes,
       filterAllNonStopNodes: this.filterAllNonStopNodes,
       filterNotes: this.filterNotes,

src/app/services/data/data.service.ts

@@ -224,6 +224,16 @@ export class DataService implements OnDestroy {
     return this.trainrunService.getTrainruns();
   }
 
+  getTrainrunSections() {
+    return this.trainrunSectionService.getTrainrunSections();
+  }
+
+  getTrainrunSectionsByTrainrunId(trainrunId: number) {
+    return this.trainrunSectionService.getAllTrainrunSectionsForTrainrun(
+      trainrunId,
+    );
+  }
+
   getTrainrunCategory(categoryId: number): TrainrunCategory {
     const found = this.netzgrafikDtoStore.netzgrafikDto.metadata.trainrunCategories.find(
       (trainrunCategory) => trainrunCategory.id === categoryId,

src/app/services/ui/filter.service.ts

@@ -396,12 +396,17 @@ export class FilterService implements OnDestroy {
     const filterTrainrunSection = this.checkFilterTrainrunLabels(
       trainrun.getLabelIds(),
     );
+    const asymmetry = this.dataService.getTrainrunSectionsByTrainrunId(trainrun.getId()).some(
+      (trainrunSection: TrainrunSection) =>
+        this.isFilterSymmetryEnabled(trainrunSection.isSymmetric())
+    );
     return (
       filterTrainrunSection &&
       this.isFilterTrainrunFrequencyEnabled(trainrun.getTrainrunFrequency()) &&
       this.isFilterTrainrunCategoryEnabled(trainrun.getTrainrunCategory()) &&
       this.isFilterTrainrunTimeCategoryEnabled(trainrun.getTrainrunTimeCategory()) &&
-      this.isFilterDirectionEnabled(trainrun.getDirection())
+      this.isFilterDirectionEnabled(trainrun.getDirection()) &&
+      asymmetry
     );
   }
 
@@ -580,6 +585,20 @@ export class FilterService implements OnDestroy {
     this.filterChanged();
   }
 
+  isFilterAsymmetryArrowsEnabled(): boolean {
+    return this.activeFilterSetting.filterAsymmetryArrows;
+  }
+
+  enableFilterAsymmetryArrows() {
+    this.activeFilterSetting.filterAsymmetryArrows = true;
+    this.filterChanged();
+  }
+
+  disableFilterAsymmetryArrows() {
+    this.activeFilterSetting.filterAsymmetryArrows = false;
+    this.filterChanged();
+  }
+
   isFilterArrivalDepartureTimeEnabled(): boolean {
     return this.activeFilterSetting.filterArrivalDepartureTime;
   }
@@ -622,6 +641,20 @@ export class FilterService implements OnDestroy {
     this.filterChanged();
   }
 
+  isFilterBackwardTravelTimeEnabled(): boolean {
+    return this.activeFilterSetting.filterBackwardTravelTime;
+  }
+
+  enableFilterBackwardTravelTime() {
+    this.activeFilterSetting.filterBackwardTravelTime = true;
+    this.filterChanged();
+  }
+
+  disableFilterBackwardTravelTime() {
+    this.activeFilterSetting.filterBackwardTravelTime = false;
+    this.filterChanged();
+  }
+
   isFilterTrainrunNameEnabled(): boolean {
     return this.activeFilterSetting.filterTrainrunName;
   }
@@ -774,6 +807,34 @@ export class FilterService implements OnDestroy {
     this.filterChanged();
   }
 
+  isFilterSymmetryEnabled(symmetry: boolean): boolean {
+    return this.activeFilterSetting.filterSymmetry.includes(
+      symmetry,
+    );
+  }
+
+  enableFilterSymmetry(symmetry: boolean) {
+    if (
+      !this.activeFilterSetting.filterSymmetry.includes(symmetry)
+    ) {
+      this.activeFilterSetting.filterSymmetry.push(symmetry);
+      this.filterChanged();
+    }
+  }
+
+  disableFilterSymmetry(symmetry: boolean) {
+    this.activeFilterSetting.filterSymmetry =
+      this.activeFilterSetting.filterSymmetry.filter(
+        (sym) => sym !== symmetry,
+      );
+    this.filterChanged();
+  }
+
+  resetFilterSymmetry() {
+    this.activeFilterSetting.filterSymmetry = [true, false];
+    this.filterChanged();
+  }
+
   isAnyFilterActive(): boolean {
     return (
       !this.isDisplayFilteringActive() ||
@@ -825,6 +886,13 @@ export class FilterService implements OnDestroy {
           return;
         }
       });
+    [true, false].forEach((symmetry: boolean) => {
+      const isFilter = this.isFilterSymmetryEnabled(symmetry);
+      if (!isFilter) {
+        isActive = false;
+        return;
+      }
+    });
     return isActive;
   }
 
@@ -838,10 +906,12 @@ export class FilterService implements OnDestroy {
     return (
       !this.isFilterNotesEnabled() &&
       this.isFilterDirectionArrowsEnabled() &&
+      this.isFilterAsymmetryArrowsEnabled() &&
       this.isFilterArrivalDepartureTimeEnabled() &&
       this.isFilterConnectionsEnabled() &&
       this.isFilterTrainrunNameEnabled() &&
       this.isFilterTravelTimeEnabled() &&
+      this.isFilterBackwardTravelTimeEnabled() &&
       this.isFilterShowNonStopTimeEnabled()
     );
   }
@@ -952,6 +1022,7 @@ export class FilterService implements OnDestroy {
         filterSetting.filterDirection =
           this.dataService.getDirections();
       }
+      filterSetting.filterSymmetry = [true, false];
     }
   }
 }

src/app/view/editor-filter-view/editor-filter-view.component.html

@@ -52,20 +52,33 @@ <h2 class="SummaryTitle">{{ 'app.view.editor-filter-view.filter' | translate }}<
       </button>
     </div>
 
-    <div *ngIf="hasOneWayTrainruns()">
+    <div *ngIf="hasOneWayTrainruns() || isAsymmetryActive()">
       <sbb-label class="sbb-mt-m">{{ 'app.view.editor-filter-view.symmetry' | translate }}</sbb-label>
       <div class="sbb-trainrun-chip-group">
-        <button
-          [class]="getDirectionClassname(direction)"
-          (click)="onDirectionChanged(direction)"
-          mode="ghost"
-          [title]="getDirectionTooltip(direction)"
-          *ngFor="
-            let direction of this.dataService.getDirections()
-          "
-        >
-          {{ makeDirectionButtonLabel(direction) }}
-        </button>
+        <ng-container *ngIf="hasOneWayTrainruns()">
+          <button
+            [class]="getDirectionClassname(direction)"
+            (click)="onDirectionChanged(direction)"
+            mode="ghost"
+            [title]="getDirectionTooltip(direction)"
+            *ngFor="
+              let direction of this.dataService.getDirections()
+            "
+          >
+            {{ makeDirectionButtonLabel(direction) }}
+          </button>
+        </ng-container>
+        <ng-container *ngIf="isAsymmetryActive()">
+          <button
+            *ngFor="let symmetry of [true, false]"
+            [class]="getSymmetryClassname(symmetry)"
+            (click)="onSymmetryChanged(symmetry)"
+            mode="ghost"
+            [title]="getSymmetryTooltip(symmetry)"
+          >
+            {{ makeSymmetryButtonLabel(symmetry) }}
+          </button>
+        </ng-container>
       </div>
     </div>
 
@@ -150,6 +163,16 @@ <h2 class="SummaryTitle">{{ 'app.view.editor-filter-view.filter' | translate }}<
         (change)="filterDirectionArrowsChanged()"
         >{{ 'app.view.editor-filter-view.display-direction-arrows' | translate }}
       </sbb-checkbox>
+      <sbb-checkbox
+        [(ngModel)]="filterAsymmetryArrows"
+        (change)="filterAsymmetryArrowsChanged()"
+        >{{ 'app.view.editor-filter-view.display-asymmetry-arrows' | translate }}
+      </sbb-checkbox>
+      <sbb-checkbox
+        [(ngModel)]="filterBackwardTravelTime"
+        (change)="filterBackwardTravelTimeChanged()"
+        >{{ 'app.view.editor-filter-view.display-backward-travel-times' | translate }}
+      </sbb-checkbox>
     </div>
 
     <br />