@WidgetComponent

nm-simple-item-list-component

File

src/app/shared/widgets/imarket/simple-item-list/simpleitemlist.component.ts

Implements

OnInit OnDestroy

Metadata

changeDetection ChangeDetectionStrategy.OnPush
selector nm-simple-item-list-component
templateUrl ./simpleitemlist.component.html

Index

Widget inputs
Widget outputs
Properties
Methods
Inputs
Outputs
HostListeners

Constructor

constructor(currentLocaleService: CurrentLocaleService, linkService: ConditionalLinkUtilService, halService: HalService, cd: ChangeDetectorRef)
Parameters :
Name Type Optional
currentLocaleService CurrentLocaleService no
linkService ConditionalLinkUtilService no
halService HalService no
cd ChangeDetectorRef no

Inputs

configuration

Type: SimpleListConfiguration

data

Data sent drectly from controller

Type: any

enableKeyClick

Allow list keys to be clickable

Type: boolean

Default value: false

listItemClasses

Set classes to be applied for each list item individually

Type: string

Default value: ""

valueClasses

Set classes to be applied for value items

Type: string

Default value: ""

width

Width of list

Type: string

Outputs

buttonClicked

Event emitted when a button in 'BUTTON' switchcase is clicked, ouputs the button's identifier name

$event type: EventEmitter
chipClicked

Event emitted when a chip is clicked

$event type: EventEmitter
editedValueOutput

Event Emitted when edited value is saved

$event type: EventEmitter
iconClicked

Event emitted when an 'ICON' is clicked and 'overrideClick' is set to true, ouputs the icon's data

$event type: EventEmitter
keyClicked

Event Emitted when key in list has been clicked, outputs key's value

$event type: EventEmitter
togglerClicked

Event emitted when a toggler in 'TOGGLER' switchcase is clicked, ouputs the toggler's data

$event type: EventEmitter

HostListeners

document:click
Arguments : '$event.target'
document:click(targetElement: )

Methods

clearEditedValue
clearEditedValue()
Returns : void
disableSave
disableSave()
Returns : boolean
expandItems
expandItems()
Returns : void
ngOnDestroy
ngOnDestroy()
Returns : void
ngOnInit
ngOnInit()
Returns : void
onEditClick
onEditClick(value: )
Parameters :
Name Optional
value no
Returns : void
Public onKeyClick
onKeyClick(field: any)
Parameters :
Name Type Optional
field any no
Returns : void
openURL
openURL(data: , event: )
Parameters :
Name Optional
data no
event no
Returns : any
saveEditedValue
saveEditedValue()
Returns : void

Properties

Public baseRedirectionPage
baseRedirectionPage: string
Type : string
Public dataMap
dataMap: Map<any | any>
Type : Map<any | any>
Default value : new Map()
Public editButtonFlag
editButtonFlag: boolean
Type : boolean
Default value : false
editedElement
editedElement: ElementRef
Type : ElementRef
Decorators : ViewChild
Public editedValue
editedValue: string
Type : string
editInput
editInput: ElementRef
Type : ElementRef
Decorators : ViewChild
Public editValue
editValue:
Default value : false
Public initialEditValue
initialEditValue: string
Type : string
Public isExpanded
isExpanded: boolean
Type : boolean
Default value : false
keepOrder
keepOrder:
Default value : (obj1, obj2) => { return obj1; }
Private keysToBeExpanded
keysToBeExpanded: Set<any>
Type : Set<any>
Default value : new Set()
Public linkService
linkService: ConditionalLinkUtilService
Type : ConditionalLinkUtilService
Public minWidth
minWidth: string
Type : string
Public numberFormat
numberFormat: string
Type : string
Public selectedUiLocale
selectedUiLocale: string
Type : string
Private unsubscribe
unsubscribe:
Default value : NgUnsubscribe.create()

Accessors

data
setdata(data: any)

Data sent drectly from controller

Parameters :
Name Type Optional
data any no
Returns : void
import {
  Component,
  OnInit,
  OnDestroy,
  Input,
  Output,
  EventEmitter,
  HostListener,
  ViewChild,
  ElementRef,
  ChangeDetectionStrategy,
  ChangeDetectorRef,
} from "@angular/core";
import { getOrDefault } from "../../../widgets/widget.configuration";
import { NgUnsubscribe } from "../../../ng-unsubscribe";
import { takeUntil } from "rxjs/operators";
import { CurrentLocaleService } from "../../../components/i18n/currentLocale.service";
import { SimpleListConfiguration } from "./simple-item-list.component.widget";
import { ConditionalLinkUtilService } from "../../../widgets/imarket/list-cell-conditional-link/conditional-link-widget.component.service";
import { NgModel } from "@angular/forms";
import { HalService } from "../../../components/hal/hal.service";

@Component({
  selector: "nm-simple-item-list-component",
  templateUrl: "./simpleitemlist.component.html",
  changeDetection: ChangeDetectionStrategy.OnPush,
})
export class SimpleItemListComponent implements OnInit, OnDestroy {
  /**
   * Data sent drectly from controller
   */
  @Input("data")
  public set data(data: any) {
    this.dataMap = data;
    if (data) {
      Object.keys(data).forEach((key) => {
        const value = data[key];

        if (value && value.hideListItem) {
          this.keysToBeExpanded.add(key);
        }
      });
    }
  }
  /**
   * Width of list
   */
  @Input() public width: string;
  /**
   * Allow list keys to be clickable
   */
  @Input() enableKeyClick: boolean = false;
  /**
   * Set classes to be applied for each list item individually
   */
  @Input() public listItemClasses: string = "";
  /**
   * Set classes to be applied for value items
   */
  @Input() public valueClasses: string = "";
  /**
   * Event emitted when a button in 'BUTTON' switchcase is clicked, ouputs the button's identifier name
   */
  @Output() public buttonClicked = new EventEmitter<string>();
  /**
   * Event emitted when a toggler in 'TOGGLER' switchcase is clicked, ouputs the toggler's data
   */
  @Output() public togglerClicked = new EventEmitter<string>();
  /**
   * Event emitted when an 'ICON' is clicked and 'overrideClick' is set to true, ouputs the icon's data
   */
  @Output() public iconClicked = new EventEmitter<any>();
  /**
   * Event Emitted when key in list has been clicked, outputs key's value
   */
  @Output() public keyClicked = new EventEmitter<any>();
  /**
   * Event Emitted when edited value is saved
   */
  @Output() public editedValueOutput = new EventEmitter<string>();
  /**
   * Event emitted when a chip is clicked
   */
  @Output() public chipClicked = new EventEmitter<any>();

  @Input() configuration: SimpleListConfiguration;

  @ViewChild("editedElement") editedElement: ElementRef;
  @ViewChild("editInput", { static: false }) editInput: ElementRef;

  private unsubscribe = NgUnsubscribe.create();
  public minWidth: string;
  public numberFormat: string;
  public selectedUiLocale: string;
  public baseRedirectionPage: string;
  public editValue = false;
  public initialEditValue: string;
  public editedValue: string;
  public editButtonFlag: boolean = false;
  public dataMap: Map<any, any> = new Map();
  public isExpanded: boolean = false;

  private keysToBeExpanded: Set<any> = new Set();

  constructor(
    private currentLocaleService: CurrentLocaleService,
    public linkService: ConditionalLinkUtilService,
    private halService: HalService,
    private cd: ChangeDetectorRef
  ) {
    this.currentLocaleService
      .getCurrentLocale()
      .pipe(takeUntil(this.unsubscribe))
      .subscribe((locale) => {
        this.selectedUiLocale = locale;
      });
  }

  ngOnInit() {
    if (this.configuration) {
      this.numberFormat = getOrDefault(
        this.configuration.configuration.numberFormat,
        "1.2-2"
      );
      this.width = getOrDefault(this.configuration.configuration.width, "100%");
      this.minWidth = this.configuration.configuration.minWidth;
      this.baseRedirectionPage = this.configuration.configuration.baseRedirectionPage;
      this.enableKeyClick = getOrDefault(
        this.configuration.configuration.enableKeyClick,
        false
      );

      const listItemClasses = this.configuration.configuration.listItemClasses;
      if (listItemClasses) {
        this.listItemClasses = listItemClasses;
      }

      const data = this.configuration.configuration.data;
      if (data) {
        this.dataMap = data;
      }
    }
  }

  keepOrder = (obj1, obj2) => {
    return obj1;
  };

  openURL(data, event) {
    const overrideClick = this.linkService.onLinkClick(
      data,
      this.baseRedirectionPage,
      event
    );

    if (overrideClick) {
      this.iconClicked.emit(data);
      return false;
    }

    return overrideClick;
  }

  expandItems() {
    this.keysToBeExpanded.forEach((key) => {
      const field = this.dataMap[key];

      if (field) {
        field.hideListItem = this.isExpanded;
      }
    });

    this.isExpanded = !this.isExpanded;
  }

  onEditClick(value) {
    this.editValue = true;
    this.editedValue = value;
    this.initialEditValue = value;
    this.editButtonFlag = true;
  }

  clearEditedValue() {
    this.editValue = false;
    this.editedValue = this.initialEditValue;
  }

  disableSave() {
    let maxLength;
    if (this.editInput) {
      maxLength = this.editInput.nativeElement.maxLength;
    }
    return !(
      this.editedValue != undefined &&
      (this.editedValue.length === 0 ||
        (maxLength && this.editedValue.length === Number(maxLength)))
    );
  }

  saveEditedValue() {
    if (this.disableSave()) {
      return;
    }
    this.editValue = false;
    if (this.editedValue !== this.initialEditValue) {
      this.editedValueOutput.emit(this.editedValue);
    }
  }

  @HostListener("document:click", ["$event.target"])
  public onDocumentClick(targetElement) {
    if (this.editedElement) {
      const clickedInside = this.editedElement.nativeElement.contains(
        targetElement
      );
      if (this.editValue && !clickedInside && !this.editButtonFlag) {
        this.saveEditedValue();
      }
      this.editButtonFlag = false;
    }
  }

  public onKeyClick(field: any): void {
    if (field) {
      const type = field.type;

      if (type === "HALACTION" && field.keyData) {
        this.halService
          .execute(field.keyData.key, field.keyData.data)
          .pipe(takeUntil(this.unsubscribe))
          .subscribe();
      } else {
        this.keyClicked.emit(field);
      }
    }
  }

  ngOnDestroy() {
    this.unsubscribe.destroy();
  }
}
<mat-list
  *ngIf="dataMap"
  [style.width]="width"
  [style.min-width]="minWidth"
  class="nm-simple-item-list"
>
  <div *ngFor="let field of dataMap | keyvalue: keepOrder">
    <mat-list-item
      *ngIf="field.value ? !field.value.hideListItem : true"
      class="nm-simple-item {{ listItemClasses }}"
      [ngClass]="field.value.listItemClasses"
      [class.--enableLabelMargin]="editValue && field.value.type === 'EDIT'"
    >
      <nm-ellipsis
        *ngIf="field.value ? !field.value.hideLabel : true"
        [content]="field.key | translate"
        (click)="enableKeyClick ? onKeyClick(field.value) : ''"
        class="nm-simple-item__label"
        [class.--enableLink]="enableKeyClick"
      >
      </nm-ellipsis>
      <ng-container *ngIf="field.value">
        <div
          [ngSwitch]="field.value.type"
          class="nm-simple-item__value {{ valueClasses }}"
          [ngClass]="field.value.valueClasses"
        >
          <div *ngSwitchCase="'STATE'">
            <nm-trafficlight [status]="field.value.data"></nm-trafficlight>
          </div>
          <nm-ellipsis
            *ngSwitchCase="'DATE'"
            [content]="field.value.data | datepipe: 'standardDate'"
          ></nm-ellipsis>
          <nm-ellipsis
            *ngSwitchCase="'TIME'"
            [content]="field.value.data | datepipe: 'mediumDateTime'"
          ></nm-ellipsis>
          <nm-ellipsis
            *ngSwitchCase="'NUMBER'"
            [content]="field.value.data | number: numberFormat:selectedUiLocale"
          ></nm-ellipsis>
          <nm-ellipsis
            *ngSwitchCase="'TRANSLATE'"
            [content]="field.value.data | translate"
          ></nm-ellipsis>
          <div *ngSwitchCase="'LINK'">
            <ng-container
              *ngTemplateOutlet="links; context: { link: field.value.data }"
            ></ng-container>
          </div>
          <div *ngSwitchCase="'HALACTION'" class="nm-simple-item__actions">
            <ng-container
              *ngTemplateOutlet="
                halActions;
                context: { actions: field.value.data }
              "
            ></ng-container>
          </div>
          <div *ngSwitchCase="'ACTION_AND_LINK'">
            <div
              *ngFor="let actionLinkData of field.value.data"
              class="nm-simple-item__action-and-link"
            >
              <ng-container
                *ngTemplateOutlet="
                  links;
                  context: { link: actionLinkData.link }
                "
              ></ng-container>
              <ng-container
                *ngTemplateOutlet="
                  halActions;
                  context: { actions: actionLinkData.halAction }
                "
              ></ng-container>
            </div>
          </div>
          <div *ngSwitchCase="'TOGGLER'">
            <div class="nm-simple-item__button">
              <mat-slide-toggle
                [disabled]="field.value.data.disabled"
                [(ngModel)]="field.value.data.state"
                (change)="togglerClicked.emit(field.value.data.state)"
              ></mat-slide-toggle>
            </div>
          </div>
          <div *ngSwitchCase="'EXPAND_BUTTON'">
            <div>
              <button
                class="__button"
                mat-button
                type="button"
                (click)="expandItems()"
              >
                <span>{{
                  (isExpanded
                    ? field.value.data.showLessText
                    : field.value.data.showMoreText
                  ) | translate
                }}</span>
              </button>
            </div>
          </div>
          <div *ngSwitchCase="'BUTTON'">
            <div class="nm-simple-item__buttonWrapper">
              <nm-button
                buttonClass ="__button"
                [disabled]="field.value.data.disabled"
                (fireEvent)="buttonClicked.emit(field.value.data)"
                [buttonType]=" field.value.data.type"
                [icon]="field.value.data.icon"
                [buttonColor]="
                  field.value.data.buttonColor
                "
                [placeholder]="field.value.data.description | translate"
              >
              </nm-button>
            </div>
          </div>
          <div *ngSwitchCase="'CURRENCY'">
            <div *ngIf="field.value.data">
              <nm-ellipsis
                [content]="
                  (field.value.data.amount | number: '1.2-2':selectedUiLocale) +
                  ' ' +
                  field.value.data.currency
                "
              ></nm-ellipsis>
            </div>
          </div>
          <div *ngSwitchCase="'DESCRIPTION'" class="--description">
            <div *ngIf="field.value.data">
              {{ field.value.data }}
            </div>
          </div>
          <div #editedElement *ngSwitchCase="'EDIT'">
            <ng-container *ngIf="editValue; else originalValue">
              <div class="--editableField">
                <mat-form-field floatLabel="never">
                  <input
                    #editInput
                    [(ngModel)]="editedValue"
                    (keydown.enter)="saveEditedValue()"
                    maxlength="{{ field.value.data.maxLength }}"
                    autofocus
                    matInput
                  />
                  <mat-hint class="__hint">
                    {{
                      field.value.data.hint
                        ? (field.value.data.hint | translate)
                        : ""
                    }}
                  </mat-hint>
                </mat-form-field>
                <div>
                  <button
                    mat-icon-button
                    primary
                    matSuffix
                    (click)="saveEditedValue()"
                    class="__button"
                    [disabled]="disableSave()"
                  >
                    <mat-icon>done</mat-icon>
                  </button>
                  <button
                    mat-icon-button
                    primary
                    matSuffix
                    class="__button"
                    (click)="clearEditedValue()"
                  >
                    <mat-icon>clear</mat-icon>
                  </button>
                </div>
              </div>
            </ng-container>

            <ng-template #originalValue>
              <span>{{
                field.value.data.value
                  ? field.value.data.value
                  : (field.value.data.label | translate)
              }}</span>
              <button
                mat-icon-button
                primary
                matSuffix
                (click)="onEditClick(field.value.data.value)"
              >
                <mat-icon>edit</mat-icon>
              </button>
            </ng-template>
          </div>

          <div *ngSwitchCase="'CHIPLIST'">
            <nm-chiplist
              *ngIf="field.value.data"
              [configuration]="field.value.data.chipConfiguration"
              [chipsData]="field.value.data.source"
              (onChipClick)="chipClicked.emit($event)"
              [selectable]="field.value.data.selectable"
            >
            </nm-chiplist>
          </div>

          <nm-ellipsis
            *ngSwitchDefault
            [content]="field.value.data"
          ></nm-ellipsis>
        </div>
      </ng-container>
    </mat-list-item>
  </div>
</mat-list>

<ng-template #halActions let-actions="actions">
  <span class="__icon {{ act.key }}" *ngFor="let act of actions">
    <ng-container *ngIf="act.data.hidden !== true">
      <nm-action-icon
        [action]="act.data"
        [name]="act.key"
        [disabled]="act.data.disabled ? act.data.disabled : false"
      >
      </nm-action-icon>
    </ng-container>
  </span>
</ng-template>

<ng-template #links let-link="link">
  <div
    *ngFor="let linkData of link; let i = index"
    class="nm-simple-item__linkList"
  >
    <a
      (click)="openURL(linkData, $event)"
      [matTooltip]="linkData.tooltip"
      tabindex="-1"
      [href]="linkService.getLink(linkData, baseRedirectionPage)"
    >
      <span>{{
        linkData.value ? (linkData.value | translate) : linkData.link
      }}</span>
    </a>
    <span *ngIf="i < link.length - 1">,</span>
  </div>
</ng-template>
Legend
Html element
Component
Html element with directive

results matching ""

    No results matching ""