ngOnInit()

in web/frontend/src/app/pages/streams/modules/schema-editor/components/class-list-grid/class-list-grid.component.ts [64:224]
148 lines of code
20 McCabe index (conditional complexity)

  ngOnInit() {
    this.isWriter$ = this.permissionsService.isWriter();
    this.gridContextMenuService.disableColumns();
    this.gridOptions$ = this.tabId().pipe(
      map((id) => {
        return this.gridService.options(id, {
          enableFilter: false,
          deltaRowDataMode: true,
          getRowNodeId: ({name}) => name,
          getRowStyle: (params) => {
            return {display: params?.data?._props?._isVisible ? 'block' : 'none'};
          },
          rowClassRules: {
            classItem: ({data}) => data && !data.isEnum,
            enumItem: ({data}) => data?.isEnum,
            'type-edited': ({data}) => this.seFieldFormsService.typeHasChanges(data),
            hasError: ({data}) => this.seFieldFormsService.showErrorOnType(data),
            'ag-row-selected': ({data}) => data?._props?._isSelected,
          },
        });
      }),
    );

    const columns = [
      columnsVisibleColumn(false),
      {
        headerName: 'Use',
        field: '_props._isUsed',
        filter: false,
        cellRenderer: 'isUsedCbComponent',
        pinned: 'left',
        sortable: false,
        lockPosition: true,
        suppressMenu: true,
        resizable: false,
      },
      {
        sortable: true,
        lockPosition: true,
        suppressMenu: true,
        cellRenderer: 'treeDataCellComponent',
        field: 'name',
        filter: 'agTextColumnFilter',
        headerName: 'Name',
        cellClass: ({data}) => (data?._props?._isEdited ? 'isEdited' : ''),
      },
      {
        headerName: 'Title',
        field: 'title',
        filter: true,
        width: 100,
        sortable: false,
        lockPosition: true,
        suppressMenu: true,
      },
      {
        headerName: 'Abstract',
        field: 'isAbstract',
        filter: false,
        cellRenderer: 'isAbstractCbComponent',
        sortable: false,
        lockPosition: true,
        suppressMenu: true,
      },
    ];

    const data$ = this.appStore.pipe(
      select(getAllSchemaItems),
      map((schemaAll) => {
        if (schemaAll && schemaAll.length) {
          this.schemaAll = [...schemaAll];
        }

        const rowData = [...schemaAll];

        for (const row of rowData) {
          if (row.isEnum) {
            row._props._hierarchy = ['Enumerators', row.name];
          } else {
            row._props._hierarchy = ['Types', ...this.getTypeHierarchy(row, this.schemaAll)];
          }
          row._props._isVisible = true;
        }

        rowData.sort((prev, next) => {
          if (prev.isEnum && !next.isEnum) {
            return 1;
          } else if (!prev.isEnum && next.isEnum) {
            return -1;
          }
          return 0;
        });

        return rowData;
      }),
      takeUntil(this.seDataService.showClassListGrid().pipe(filter((show) => !show))),
    );

    this.tabId()
      .pipe(
        switchMap(() => this.gridService.setColumns(columns)),
        tap(() => (this.columnsSet = false)),
        switchMap(() => data$),
        switchMap((data) => {
          let selectedField;
          const type = data.find((type) => {
            return type.fields.find((field) => {
              if (field._props._isSelected) {
                selectedField = field;
              }

              return field._props._isSelected;
            });
          });

          this.seFieldFormsService.selectedChange(
            type?._props._uuid || '',
            selectedField?._props._uuid || '',
          );
          return this.gridService.setRowData(data).pipe(map(() => data));
        }),
        filter(() => !this.columnsSet),
        switchMap((data) => {
          this.columnsSet = data.length > 0;
          if (this.columnsSet) {
            this.selectInitial(data);
          }

          return this.gridService.resizeColumnsOnData(data).pipe(map(() => data));
        }),
        takeUntil(this.destroy$),
      )
      .subscribe();

    this.gridService
      .onDoubleClicked()
      .pipe(takeUntil(this.destroy$), withLatestFrom(this.isWriter$))
      .subscribe(([event, isWriter]) => {
        if (!event?.data || !isWriter) return;
        this.showEditItemModal(event.data);
      });

    this.gridService
      .onSelectionChanged()
      .pipe(takeUntil(this.destroy$))
      .subscribe((event: SelectionChangedEvent) => {
        const item = event.api.getSelectedRows()[0];
        if (item?._props && !item._props._isSelected) {
          this.seSelectionService.onSelectType(item?._props._uuid);
          this.appStore.dispatch(SetSelectedSchemaItem({itemName: item.name}));
        }
      });

    this.seFieldFormsService
      .hasChanges()
      .pipe(
        takeUntil(this.destroy$),
        switchMap(() => this.gridService.redrawRows()),
      )
      .subscribe();
  }