micord/ervu-business-metrics
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions

SUPPORT-8728: перенос и удаление неиспользуемых методов

Browse source
This commit is contained in:
Рауф Латыпов 2024-12-06 01:11:48 +03:00
parent 34ca75241d
commit 96767eefde
25 changed files with 127 additions and 1167 deletions
Download patch file Download diff file Expand all files Collapse all files

1
backend/src/main/java/component/model/TreeItemDto.java
View file

@ -12,7 +12,6 @@ public class TreeItemDto {
public String label;
public TreeItemDto[] children;
public Object businessId;
public String domainId;
public TreeItemDto(Object id, Object parentId, String label) {
this.id = id;

5
backend/src/main/java/component/rpc/TreeItemRpcService.java
View file

@ -20,9 +20,4 @@ public class TreeItemRpcService extends Behavior {
public List<TreeItemDto> loadTreeData() {
return treeItemService.loadTreeData();
}
@RpcCall
public List<TreeItemDto> loadTreeDataByDomainId(String domainId) {
return treeItemService.loadTreeDataByDomainId(domainId);
}
}

31
backend/src/main/java/component/service/TreeItemService.java
View file

@ -39,39 +39,14 @@ public class TreeItemService {
public EntityColumn labelColumn;
@GraphSource(value = TreeItemRpcService.class, scanMode = GraphSource.ScanMode.SELF)
public EntityColumn businessIdColumn;
@GraphSource(value = TreeItemRpcService.class, scanMode = GraphSource.ScanMode.SELF)
public EntityColumn domainIdColumn;
public List<TreeItemDto> loadTreeData() {
List<TreeItemDto> loadedTreeItems = loadTreeItems();
loadedTreeItems.forEach(item -> item.domainId = null);
return loadedTreeItems.stream()
.filter(item -> item.parentId == null)
.toList();
}
public List<TreeItemDto> loadTreeDataByDomainId(String domainId) {
if (domainId == null || domainIdColumn == null) {
return loadTreeData();
}
List<TreeItemDto> filteredTreeItems = loadTreeItems().stream()
.filter(item -> item.domainId.equalsIgnoreCase(domainId))
.toList();
filteredTreeItems.forEach(this::setDomainIdToNull);
return filteredTreeItems;
}
private void setDomainIdToNull(TreeItemDto treeItem) {
treeItem.domainId = null;
TreeItemDto[] treeItemChildren = treeItem.children;
if (treeItemChildren != null && treeItemChildren.length > 0) {
for (TreeItemDto child : treeItemChildren) {
setDomainIdToNull(child);
}
}
}
private List<TreeItemDto> loadTreeItems() {
List<TreeItemDto> loadedList = this.loadDao.load(getColumns(), new LoadOptions()).stream()
.map(this::toTreeItemDto)
@ -105,9 +80,6 @@ public class TreeItemService {
if (businessIdColumn != null) {
columnSet.add(businessIdColumn);
}
if (domainIdColumn != null) {
columnSet.add(domainIdColumn);
}
return columnSet;
}
@ -118,9 +90,6 @@ public class TreeItemService {
if (businessIdColumn != null) {
treeItemDto.businessId = tableRow.get(businessIdColumn);
}
if (domainIdColumn != null) {
treeItemDto.domainId =(String) tableRow.get(domainIdColumn);
}
return treeItemDto;
}
}

4
frontend/src/ts/component/external/ngx-treeview/dropdown-treeview-select/dropdown-treeview-select-i18n.ts vendored
View file

@ -1,6 +1,6 @@
import {Injectable} from "@angular/core";
import {DefaultTreeviewI18n} from "../lib/treeview-i18n";
import {TreeviewItem, TreeviewSelection} from "../lib/treeview-item";
import {DefaultTreeviewI18n, TreeviewItem, TreeviewSelection} from "ngx-treeview";
@Injectable()
export class DropdownTreeviewSelectI18n extends DefaultTreeviewI18n {

15
frontend/src/ts/component/external/ngx-treeview/dropdown-treeview-select/dropdown-treeview-select.component.ts vendored
View file

@ -8,12 +8,13 @@ import {
ViewChild
} from '@angular/core';
import {DropdownTreeviewSelectI18n} from './dropdown-treeview-select-i18n';
import { DropdownTreeviewComponent } from "../lib/dropdown-treeview.component";
import { TreeviewConfig } from "../lib/treeview-config";
import { TreeviewHelper } from "../lib/treeview-helper";
import { TreeviewI18n } from "../lib/treeview-i18n";
import { TreeviewItem } from "../lib/treeview-item";
import { isNil } from '../lib/utils';
import {
DropdownTreeviewComponent,
TreeviewConfig,
TreeviewHelper,
TreeviewI18n,
TreeviewItem
} from "ngx-treeview";
@Component({
moduleId: module.id,
@ -54,7 +55,7 @@ export class DropdownTreeviewSelectComponent implements OnChanges {
}
private updateSelectedItem(): void {
if (!isNil(this.items)) {
if (this.items !== null) {
const selectedItem = TreeviewHelper.findItemInList(this.items, this.value);
this.selectItem(selectedItem);
}

22
frontend/src/ts/component/external/ngx-treeview/lib/dropdown-menu.directive.ts vendored
View file

@ -1,22 +0,0 @@
import { Directive, HostListener } from '@angular/core';
import { DropdownDirective } from './dropdown.directive';
@Directive({
selector: '[ngxDropdownMenu]',
host: {
'[class.dropdown-menu]': 'true',
'[class.show]': 'dropdown.isOpen'
}
})
export class DropdownMenuDirective {
constructor(public dropdown: DropdownDirective) {
}
@HostListener('click', ['$event'])
onClick(event: MouseEvent): void {
if (event.button !== 2 && event.srcElement.attributes[0]
&& event.srcElement.attributes[0].nodeValue === 'form-check-label') {
this.dropdown.close();
}
}
}

17
frontend/src/ts/component/external/ngx-treeview/lib/dropdown-toggle.directive.ts vendored
View file

@ -1,17 +0,0 @@
import { Directive, ElementRef } from '@angular/core';
import { DropdownDirective } from './dropdown.directive';
@Directive({
selector: '[ngxDropdownToggle]',
host: {
class: 'dropdown-toggle',
'aria-haspopup': 'true',
'[attr.aria-expanded]': 'dropdown.isOpen',
'(click)': 'dropdown.toggle()'
}
})
export class DropdownToggleDirective {
constructor(public dropdown: DropdownDirective, elementRef: ElementRef) {
dropdown.toggleElement = elementRef.nativeElement;
}
}

49
frontend/src/ts/component/external/ngx-treeview/lib/dropdown-treeview.component.ts vendored
View file

@ -1,49 +0,0 @@
import {
Component,
EventEmitter,
Input,
Output,
ViewChild,
TemplateRef,
ChangeDetectionStrategy
} from '@angular/core';
import { TreeviewI18n } from './treeview-i18n';
import { TreeviewItem } from './treeview-item';
import { TreeviewConfig } from './treeview-config';
import { TreeviewComponent } from './treeview.component';
import { TreeviewHeaderTemplateContext } from './treeview-header-template-context';
import { TreeviewItemTemplateContext } from './treeview-item-template-context';
@Component({
moduleId: module.id,
selector: 'ngx-dropdown-treeview',
templateUrl: './../../../../../../src/resources/template/component/external/ngx-treeview/dropdown-treeview.component.html',
changeDetection: ChangeDetectionStrategy.OnPush
})
export class DropdownTreeviewComponent {
@Input() buttonClass = 'btn-outline-secondary';
@Input() headerTemplate: TemplateRef<TreeviewHeaderTemplateContext>;
@Input() itemTemplate: TemplateRef<TreeviewItemTemplateContext>;
@Input() items: TreeviewItem[];
@Input() config: TreeviewConfig;
@Output() selectedChange = new EventEmitter<any[]>(true);
@Output() filterChange = new EventEmitter<string>();
@ViewChild(TreeviewComponent) treeviewComponent: TreeviewComponent;
buttonLabel: string;
constructor(
public i18n: TreeviewI18n,
private defaultConfig: TreeviewConfig
) {
this.config = this.defaultConfig;
}
onSelectedChange(values: any[]): void {
this.buttonLabel = this.i18n.getText(this.treeviewComponent.selection);
this.selectedChange.emit(values);
}
onFilterChange(text: string): void {
this.filterChange.emit(text);
}
}

54
frontend/src/ts/component/external/ngx-treeview/lib/dropdown.directive.ts vendored
View file

@ -1,54 +0,0 @@
import { Directive, Input, Output, HostBinding, HostListener, EventEmitter } from '@angular/core';
import { isNil } from './utils';
@Directive({
selector: '[ngxDropdown]',
exportAs: 'ngxDropdown'
})
export class DropdownDirective {
toggleElement: any;
@Input('open') internalOpen = false;
@Output() openChange = new EventEmitter<boolean>();
@HostBinding('class.show') get isOpen(): boolean {
return this.internalOpen;
}
@HostListener('keyup.esc')
onKeyupEsc(): void {
this.close();
}
@HostListener('document:click', ['$event'])
onDocumentClick(event: MouseEvent): void {
if (event.button !== 2 && !this.isEventFromToggle(event)) {
this.close();
}
}
open(): void {
if (!this.internalOpen) {
this.internalOpen = true;
this.openChange.emit(true);
}
}
close(): void {
if (this.internalOpen) {
this.internalOpen = false;
this.openChange.emit(false);
}
}
toggle(): void {
if (this.isOpen) {
this.close();
} else {
this.open();
}
}
private isEventFromToggle(event: MouseEvent): boolean {
return !isNil(this.toggleElement) && this.toggleElement.contains(event.target);
}
}

26
frontend/src/ts/component/external/ngx-treeview/lib/treeview-config.ts vendored
View file

@ -1,26 +0,0 @@
import { Injectable } from '@angular/core';
@Injectable()
export class TreeviewConfig {
hasAllCheckBox = true;
hasFilter = false;
hasCollapseExpand = false;
decoupleChildFromParent = false;
maxHeight = 500;
get hasDivider(): boolean {
return this.hasFilter || this.hasAllCheckBox || this.hasCollapseExpand;
}
public static create(fields?: {
hasAllCheckBox?: boolean,
hasFilter?: boolean,
hasCollapseExpand?: boolean,
decoupleChildFromParent?: boolean
maxHeight?: number,
}): TreeviewConfig {
const config = new TreeviewConfig();
Object.assign(config, fields);
return config;
}
}

107
frontend/src/ts/component/external/ngx-treeview/lib/treeview-event-parser.ts vendored
View file

@ -1,107 +0,0 @@
import { Injectable } from '@angular/core';
import { TreeviewItem } from './treeview-item';
import {TreeviewComponent} from './treeview.component';
import { isNil } from './utils';
@Injectable()
export abstract class TreeviewEventParser {
abstract getSelectedChange(component: TreeviewComponent): any[];
}
@Injectable()
export class DefaultTreeviewEventParser extends TreeviewEventParser {
getSelectedChange(component: TreeviewComponent): any[] {
const checkedItems = component.selection.checkedItems;
if (!isNil(checkedItems)) {
return checkedItems.map(item => item.value);
}
return [];
}
}
export interface DownlineTreeviewItem {
item: TreeviewItem;
parent: DownlineTreeviewItem;
}
@Injectable()
export class DownlineTreeviewEventParser extends TreeviewEventParser {
getSelectedChange(component: TreeviewComponent): any[] {
const items = component.items;
if (!isNil(items)) {
let result: DownlineTreeviewItem[] = [];
items.forEach(item => {
const links = this.getLinks(item, null);
if (!isNil(links)) {
result = result.concat(links);
}
});
return result;
}
return [];
}
private getLinks(item: TreeviewItem, parent: DownlineTreeviewItem): DownlineTreeviewItem[] {
if (!isNil(item.children)) {
const link = {
item,
parent
};
let result: DownlineTreeviewItem[] = [];
item.children.forEach(child => {
const links = this.getLinks(child, link);
if (!isNil(links)) {
result = result.concat(links);
}
});
return result;
}
if (item.checked) {
return [{
item,
parent
}];
}
return null;
}
}
@Injectable()
export class OrderDownlineTreeviewEventParser extends TreeviewEventParser {
private currentDownlines: DownlineTreeviewItem[] = [];
private parser = new DownlineTreeviewEventParser();
getSelectedChange(component: TreeviewComponent): any[] {
const newDownlines: DownlineTreeviewItem[] = this.parser.getSelectedChange(component);
if (this.currentDownlines.length === 0) {
this.currentDownlines = newDownlines;
} else {
const intersectDownlines: DownlineTreeviewItem[] = [];
this.currentDownlines.forEach(downline => {
let foundIndex = -1;
const length = newDownlines.length;
for (let i = 0; i < length; i++) {
if (downline.item.value === newDownlines[i].item.value) {
foundIndex = i;
break;
}
}
if (foundIndex !== -1) {
intersectDownlines.push(newDownlines[foundIndex]);
newDownlines.splice(foundIndex, 1);
}
});
this.currentDownlines = intersectDownlines.concat(newDownlines);
}
return this.currentDownlines;
}
}

10
frontend/src/ts/component/external/ngx-treeview/lib/treeview-header-template-context.ts vendored
View file

@ -1,10 +0,0 @@
import { TreeviewItem } from './treeview-item';
import { TreeviewConfig } from './treeview-config';
export interface TreeviewHeaderTemplateContext {
config: TreeviewConfig;
item: TreeviewItem;
onCollapseExpand: () => void;
onCheckedChange: (checked: boolean) => void;
onFilterTextChange: (text: string) => void;
}

94
frontend/src/ts/component/external/ngx-treeview/lib/treeview-helper.ts vendored
View file

@ -1,94 +0,0 @@
import { TreeviewItem } from './treeview-item';
import { isNil, pull } from './utils';
export const TreeviewHelper = {
findItem,
findItemInList,
findParent,
removeItem,
concatSelection
};
function findItem(root: TreeviewItem, value: any): TreeviewItem {
if (isNil(root)) {
return undefined;
}
if (root.value === value) {
return root;
}
if (root.children) {
for (const child of root.children) {
const foundItem = findItem(child, value);
if (foundItem) {
return foundItem;
}
}
}
return undefined;
}
function findItemInList(list: TreeviewItem[], value: any): TreeviewItem {
if (isNil(list)) {
return undefined;
}
for (const item of list) {
const foundItem = findItem(item, value);
if (foundItem) {
return foundItem;
}
}
return undefined;
}
function findParent(root: TreeviewItem, item: TreeviewItem): TreeviewItem {
if (isNil(root) || isNil(root.children)) {
return undefined;
}
for (const child of root.children) {
if (child === item) {
return root;
} else {
const parent = findParent(child, item);
if (parent) {
return parent;
}
}
}
return undefined;
}
function removeItem(root: TreeviewItem, item: TreeviewItem): boolean {
const parent = findParent(root, item);
if (parent) {
pull(parent.children, item);
if (parent.children.length === 0) {
parent.children = undefined;
} else {
parent.correctChecked();
}
return true;
}
return false;
}
function concatSelection(items: TreeviewItem[], checked: TreeviewItem[], unchecked: TreeviewItem[]): { [k: string]: TreeviewItem[] } {
let checkedItems = [...checked];
let uncheckedItems = [...unchecked];
for (const item of items) {
const selection = item.getSelection();
checkedItems = checkedItems.concat(selection.checkedItems);
uncheckedItems = uncheckedItems.concat(selection.uncheckedItems);
}
return {
checked: checkedItems,
unchecked: uncheckedItems
};
}

49
frontend/src/ts/component/external/ngx-treeview/lib/treeview-i18n.ts vendored
View file

@ -1,49 +0,0 @@
import { Injectable } from '@angular/core';
import { TreeviewSelection } from './treeview-item';
@Injectable()
export abstract class TreeviewI18n {
abstract getText(selection: TreeviewSelection): string;
abstract getAllCheckboxText(): string;
abstract getFilterPlaceholder(): string;
abstract getFilterNoItemsFoundText(): string;
abstract getTooltipCollapseExpandText(isCollapse: boolean): string;
}
@Injectable()
export class DefaultTreeviewI18n extends TreeviewI18n {
getText(selection: TreeviewSelection): string {
if (selection.uncheckedItems.length === 0) {
if (selection.checkedItems.length > 0) {
return this.getAllCheckboxText();
} else {
return '';
}
}
switch (selection.checkedItems.length) {
case 0:
return 'Select options';
case 1:
return selection.checkedItems[0].text;
default:
return `${selection.checkedItems.length} options selected`;
}
}
getAllCheckboxText(): string {
return 'Все';
}
getFilterPlaceholder(): string {
return 'Поиск';
}
getFilterNoItemsFoundText(): string {
return 'Элементы не найдены';
}
getTooltipCollapseExpandText(isCollapse: boolean): string {
return isCollapse ? 'Развернуть' : 'Свернуть';
}
}

7
frontend/src/ts/component/external/ngx-treeview/lib/treeview-item-template-context.ts vendored
View file

@ -1,7 +0,0 @@
import { TreeviewItem } from './treeview-item';
export interface TreeviewItemTemplateContext {
item: TreeviewItem;
onCollapseExpand: () => void;
onCheckedChange: () => void;
}

68
frontend/src/ts/component/external/ngx-treeview/lib/treeview-item.component.ts vendored
View file

@ -1,68 +0,0 @@
import {
ChangeDetectionStrategy,
Component,
EventEmitter,
Input,
Output,
TemplateRef
} from '@angular/core';
import { TreeviewConfig } from './treeview-config';
import { TreeviewItem } from './treeview-item';
import { TreeviewItemTemplateContext } from './treeview-item-template-context';
import { isNil } from './utils';
@Component({
moduleId: module.id,
selector: 'ngx-treeview-item',
templateUrl: './../../../../../../src/resources/template/component/external/ngx-treeview/treeview-item.component.html',
changeDetection: ChangeDetectionStrategy.OnPush
})
export class TreeviewItemComponent {
@Input() config: TreeviewConfig;
@Input() template: TemplateRef<TreeviewItemTemplateContext>;
@Input() item: TreeviewItem;
@Output() checkedChange = new EventEmitter<boolean>();
constructor(
private defaultConfig: TreeviewConfig
) {
this.config = this.defaultConfig;
}
onCollapseExpand = () => {
this.item.collapsed = !this.item.collapsed;
}
onCheckedChange = () => {
const checked = this.item.checked;
if (!isNil(this.item.children) && !this.config.decoupleChildFromParent) {
this.item.children.forEach(child => child.setCheckedRecursive(checked));
}
this.checkedChange.emit(checked);
}
onChildCheckedChange(child: TreeviewItem, checked: boolean): void {
if (!this.config.decoupleChildFromParent) {
let itemChecked: boolean = null;
for (const childItem of this.item.children) {
if (itemChecked === null) {
itemChecked = childItem.checked;
} else if (itemChecked !== childItem.checked) {
itemChecked = undefined;
break;
}
}
if (itemChecked === null) {
itemChecked = false;
}
if (this.item.checked !== itemChecked) {
this.item.checked = itemChecked;
}
}
this.checkedChange.emit(checked);
}
}

185
frontend/src/ts/component/external/ngx-treeview/lib/treeview-item.ts vendored
View file

@ -1,185 +0,0 @@
import { TreeviewHelper } from './treeview-helper';
import { isBoolean, isNil, isString } from './utils';
export interface TreeviewSelection {
checkedItems: TreeviewItem[];
uncheckedItems: TreeviewItem[];
}
export interface TreeItem {
text: string;
value: any;
disabled?: boolean;
checked?: boolean;
collapsed?: boolean;
children?: TreeItem[];
}
export class TreeviewItem {
private internalDisabled = false;
private internalChecked = true;
private internalCollapsed = false;
private internalChildren: TreeviewItem[];
text: string;
value: any;
constructor(item: TreeItem, autoCorrectChecked = false) {
if (isNil(item)) {
throw new Error('Item must be defined');
}
if (isString(item.text)) {
this.text = item.text;
} else {
throw new Error('A text of item must be string object');
}
this.value = item.value;
if (isBoolean(item.checked)) {
this.checked = item.checked;
}
if (isBoolean(item.collapsed)) {
this.collapsed = item.collapsed;
}
if (isBoolean(item.disabled)) {
this.disabled = item.disabled;
}
if (!isNil(item.children) && item.children.length > 0) {
this.children = item.children.map(child => {
if (this.disabled === true) {
child.disabled = true;
}
return new TreeviewItem(child);
});
}
if (autoCorrectChecked) {
this.correctChecked();
}
}
get checked(): boolean {
return this.internalChecked;
}
set checked(value: boolean) {
if (!this.internalDisabled) {
if (this.internalChecked !== value) {
this.internalChecked = value;
}
}
}
get indeterminate(): boolean {
return this.checked === undefined;
}
setCheckedRecursive(value: boolean): void {
if (!this.internalDisabled) {
this.internalChecked = value;
if (!isNil(this.internalChildren)) {
this.internalChildren.forEach(child => child.setCheckedRecursive(value));
}
}
}
get disabled(): boolean {
return this.internalDisabled;
}
set disabled(value: boolean) {
if (this.internalDisabled !== value) {
this.internalDisabled = value;
if (!isNil(this.internalChildren)) {
this.internalChildren.forEach(child => child.disabled = value);
}
}
}
get collapsed(): boolean {
return this.internalCollapsed;
}
set collapsed(value: boolean) {
if (this.internalCollapsed !== value) {
this.internalCollapsed = value;
}
}
setCollapsedRecursive(value: boolean): void {
this.internalCollapsed = value;
if (!isNil(this.internalChildren)) {
this.internalChildren.forEach(child => child.setCollapsedRecursive(value));
}
}
get children(): TreeviewItem[] {
return this.internalChildren;
}
set children(value: TreeviewItem[]) {
if (this.internalChildren !== value) {
if (!isNil(value) && value.length === 0) {
throw new Error('Children must be not an empty array');
}
this.internalChildren = value;
if (!isNil(this.internalChildren)) {
let checked = null;
this.internalChildren.forEach(child => {
if (checked === null) {
checked = child.checked;
} else {
if (child.checked !== checked) {
checked = undefined;
return;
}
}
});
this.internalChecked = checked;
}
}
}
getSelection(): TreeviewSelection {
let checkedItems: TreeviewItem[] = [];
let uncheckedItems: TreeviewItem[] = [];
if (isNil(this.internalChildren)) {
if (this.internalChecked) {
checkedItems.push(this);
} else {
uncheckedItems.push(this);
}
} else {
const selection = TreeviewHelper.concatSelection(this.internalChildren, checkedItems, uncheckedItems);
checkedItems = selection.checked;
uncheckedItems = selection.unchecked;
}
return {
checkedItems,
uncheckedItems
};
}
correctChecked(): void {
this.internalChecked = this.getCorrectChecked();
}
private getCorrectChecked(): boolean {
let checked: boolean = null;
if (!isNil(this.internalChildren)) {
for (const child of this.internalChildren) {
child.internalChecked = child.getCorrectChecked();
if (checked === null) {
checked = child.internalChecked;
} else if (checked !== child.internalChecked) {
checked = undefined;
break;
}
}
} else {
checked = this.checked;
}
return checked;
}
}

242
frontend/src/ts/component/external/ngx-treeview/lib/treeview.component.ts vendored
View file

@ -1,242 +0,0 @@
import {
Component,
Input,
Output,
EventEmitter,
OnChanges,
OnInit,
SimpleChanges,
TemplateRef,
ChangeDetectionStrategy
} from '@angular/core';
import { TreeviewI18n } from './treeview-i18n';
import { TreeviewItem, TreeviewSelection } from './treeview-item';
import { TreeviewConfig } from './treeview-config';
import { TreeviewEventParser } from './treeview-event-parser';
import { TreeviewHeaderTemplateContext } from './treeview-header-template-context';
import { TreeviewItemTemplateContext } from './treeview-item-template-context';
import { TreeviewHelper } from './treeview-helper';
import { isNil } from './utils';
class FilterTreeviewItem extends TreeviewItem {
private readonly refItem: TreeviewItem;
constructor(item: TreeviewItem) {
super({
text: item.text,
value: item.value,
disabled: item.disabled,
checked: item.checked,
collapsed: item.collapsed,
children: item.children
});
this.refItem = item;
}
updateRefChecked(): void {
this.children.forEach(child => {
if (child instanceof FilterTreeviewItem) {
child.updateRefChecked();
}
});
let refChecked = this.checked;
if (refChecked) {
for (const refChild of this.refItem.children) {
if (!refChild.checked) {
refChecked = false;
break;
}
}
}
this.refItem.checked = refChecked;
}
}
@Component({
moduleId: module.id,
selector: 'ngx-treeview',
templateUrl: './../../../../../../src/resources/template/component/external/ngx-treeview/treeview.component.html',
changeDetection: ChangeDetectionStrategy.OnPush
})
export class TreeviewComponent implements OnChanges, OnInit {
@Input() headerTemplate: TemplateRef<TreeviewHeaderTemplateContext>;
@Input() itemTemplate: TemplateRef<TreeviewItemTemplateContext>;
@Input() items: TreeviewItem[];
@Input() config: TreeviewConfig;
@Output() selectedChange = new EventEmitter<any[]>();
@Output() filterChange = new EventEmitter<string>();
headerTemplateContext: TreeviewHeaderTemplateContext;
allItem: TreeviewItem;
filterText = '';
filterItems: TreeviewItem[];
selection: TreeviewSelection;
constructor(
public i18n: TreeviewI18n,
private defaultConfig: TreeviewConfig,
private eventParser: TreeviewEventParser
) {
this.config = this.defaultConfig;
this.allItem = new TreeviewItem({ text: 'All', value: undefined });
}
get hasFilterItems(): boolean {
return !isNil(this.filterItems) && this.filterItems.length > 0;
}
get maxHeight(): string {
return `${this.config.maxHeight}`;
}
ngOnInit(): void {
this.createHeaderTemplateContext();
this.generateSelection();
}
ngOnChanges(changes: SimpleChanges): void {
const itemsSimpleChange = changes.items;
if (!isNil(itemsSimpleChange) && !isNil(this.items)) {
this.updateFilterItems();
this.updateCollapsedOfAll();
this.raiseSelectedChange();
}
}
onAllCollapseExpand(): void {
this.allItem.collapsed = !this.allItem.collapsed;
this.filterItems.forEach(item => item.setCollapsedRecursive(this.allItem.collapsed));
}
onFilterTextChange(text: string): void {
this.filterText = text;
this.filterChange.emit(text);
this.updateFilterItems();
}
onAllCheckedChange(): void {
const checked = this.allItem.checked;
this.filterItems.forEach(item => {
item.setCheckedRecursive(checked);
if (item instanceof FilterTreeviewItem) {
item.updateRefChecked();
}
});
this.raiseSelectedChange();
}
onItemCheckedChange(item: TreeviewItem, checked: boolean): void {
if (item instanceof FilterTreeviewItem) {
item.updateRefChecked();
}
this.updateCheckedOfAll();
this.raiseSelectedChange();
}
raiseSelectedChange(): void {
this.generateSelection();
const values = this.eventParser.getSelectedChange(this);
setTimeout(() => {
this.selectedChange.emit(values);
});
}
private createHeaderTemplateContext(): void {
this.headerTemplateContext = {
config: this.config,
item: this.allItem,
onCheckedChange: () => this.onAllCheckedChange(),
onCollapseExpand: () => this.onAllCollapseExpand(),
onFilterTextChange: (text) => this.onFilterTextChange(text)
};
}
private generateSelection(): void {
let checkedItems: TreeviewItem[] = [];
let uncheckedItems: TreeviewItem[] = [];
if (!isNil(this.items)) {
const selection = TreeviewHelper.concatSelection(this.items, checkedItems, uncheckedItems);
checkedItems = selection.checked;
uncheckedItems = selection.unchecked;
}
this.selection = {
checkedItems,
uncheckedItems
};
}
private updateFilterItems(): void {
if (this.filterText !== '') {
const filterItems: TreeviewItem[] = [];
const filterText = this.filterText.toLowerCase();
this.items.forEach(item => {
const newItem = this.filterItem(item, filterText);
if (!isNil(newItem)) {
filterItems.push(newItem);
}
});
this.filterItems = filterItems;
} else {
this.filterItems = this.items;
}
this.updateCheckedOfAll();
}
private filterItem(item: TreeviewItem, filterText: string): TreeviewItem {
const isMatch = item.text.toLowerCase().includes(filterText);
if (isMatch) {
return item;
} else {
if (!isNil(item.children)) {
const children: TreeviewItem[] = [];
item.children.forEach(child => {
const newChild = this.filterItem(child, filterText);
if (!isNil(newChild)) {
children.push(newChild);
}
});
if (children.length > 0) {
const newItem = new FilterTreeviewItem(item);
newItem.collapsed = false;
newItem.children = children;
return newItem;
}
}
}
return undefined;
}
private updateCheckedOfAll(): void {
let itemChecked: boolean = null;
for (const filterItem of this.filterItems) {
if (itemChecked === null) {
itemChecked = filterItem.checked;
} else if (itemChecked !== filterItem.checked) {
itemChecked = undefined;
break;
}
}
if (itemChecked === null) {
itemChecked = false;
}
this.allItem.checked = itemChecked;
}
private updateCollapsedOfAll(): void {
let hasItemExpanded = false;
for (const filterItem of this.filterItems) {
if (!filterItem.collapsed) {
hasItemExpanded = true;
break;
}
}
this.allItem.collapsed = !hasItemExpanded;
}
}

48
frontend/src/ts/component/external/ngx-treeview/lib/treeview.module.ts vendored
View file

@ -1,48 +0,0 @@
import { NgModule, ModuleWithProviders } from '@angular/core';
import { FormsModule } from '@angular/forms';
import { CommonModule } from '@angular/common';
import { DropdownDirective } from './dropdown.directive';
import { DropdownMenuDirective } from './dropdown-menu.directive';
import { DropdownToggleDirective } from './dropdown-toggle.directive';
import { DropdownTreeviewComponent } from './dropdown-treeview.component';
import { TreeviewComponent } from './treeview.component';
import { TreeviewItemComponent } from './treeview-item.component';
import { TreeviewPipe } from './treeview.pipe';
import { TreeviewI18n, DefaultTreeviewI18n } from './treeview-i18n';
import { TreeviewConfig } from './treeview-config';
import { TreeviewEventParser, DefaultTreeviewEventParser } from './treeview-event-parser';
@NgModule({
imports: [
FormsModule,
CommonModule
],
declarations: [
// TreeviewComponent,
// TreeviewItemComponent,
TreeviewPipe,
DropdownDirective,
DropdownMenuDirective,
DropdownToggleDirective
// DropdownTreeviewComponent
], exports: [
// TreeviewComponent,
TreeviewPipe,
DropdownDirective,
DropdownMenuDirective,
DropdownToggleDirective
// DropdownTreeviewComponent
]
})
export class TreeviewModule {
static forRoot(): ModuleWithProviders {
return {
ngModule: TreeviewModule,
providers: [
TreeviewConfig,
{ provide: TreeviewI18n, useClass: DefaultTreeviewI18n },
{ provide: TreeviewEventParser, useClass: DefaultTreeviewEventParser }
]
};
}
}

16
frontend/src/ts/component/external/ngx-treeview/lib/treeview.pipe.ts vendored
View file

@ -1,16 +0,0 @@
import { Pipe, PipeTransform } from '@angular/core';
import { TreeviewItem } from './treeview-item';
import { isNil } from './utils';
@Pipe({
name: 'ngxTreeview'
})
export class TreeviewPipe implements PipeTransform {
transform(objects: any[], textField: string): TreeviewItem[] {
if (isNil(objects)) {
return undefined;
}
return objects.map(object => new TreeviewItem({ text: object[textField], value: object }));
}
}

45
frontend/src/ts/component/external/ngx-treeview/lib/utils.ts vendored
View file

@ -1,45 +0,0 @@
export default class Utils {
static isBoolean(value): boolean { return isBoolean(value); }
static isNil(value): boolean { return isNil(value); }
static isString(value): boolean { return isString(value); }
};
export const isBoolean = (value:any): boolean => {
return value === true || value === false; // todo not completed; to complete from 'lodash'
};
export const isNil = (value:any): boolean => {
// from 'lodash'
return value == null;
};
export const isString = (value:any): boolean => {
return typeof value == 'string'; // todo not completed; to complete from 'lodash'
};
export const pull = (array:any[], item:any): any[] => {
// modified 'remove' from 'lodash'
// mutate array
const result = [];
if (!(array && array.length)) {
return result;
}
const indexes = [];
array.forEach((value, index) => {
if (value === item) {
result.push(value);
indexes.push(index);
}
});
for (const index of indexes.reverse()) {
array.splice(index, 1);
}
return result;
};
export const reverse = (array:any[]): any[] => {
// from 'lodash'
return array == null ? array : array.reverse();
};

57
frontend/src/ts/component/field/DropdownTreeViewComponent.ts
View file

@ -1,11 +1,20 @@
import {ChangeDetectionStrategy, ChangeDetectorRef, Component, ElementRef} from "@angular/core";
import {Control, Event, UserService, Visible} from "@webbpm/base-package";
import {TreeItem, TreeviewItem} from "../external/ngx-treeview/lib/treeview-item";
import {
DropdownTreeviewSelectI18n
} from "../external/ngx-treeview/dropdown-treeview-select/dropdown-treeview-select-i18n";
ChangeDetectionStrategy,
ChangeDetectorRef,
Component,
ElementRef
} from "@angular/core";
import {
Event,
InputControl,
UserService,
Visible
} from "@webbpm/base-package";
import {TreeItemDto} from "../../generated/component/model/TreeItemDto";
import {TreeItemRpcService} from "../../generated/component/rpc/TreeItemRpcService";
import {DropdownTreeviewSelectI18n} from "../external/ngx-treeview/dropdown-treeview-select/dropdown-treeview-select-i18n";
import {TreeItem, TreeviewItem} from "ngx-treeview";
@Component({
moduleId: module.id,
@ -16,7 +25,7 @@ import {TreeItemRpcService} from "../../generated/component/rpc/TreeItemRpcServi
}],
changeDetection: ChangeDetectionStrategy.OnPush
})
export class DropdownTreeViewComponent extends Control {
export class DropdownTreeViewComponent extends InputControl {
public collapseLevel: number;
public maxHeight: number;
@ -31,8 +40,7 @@ export class DropdownTreeViewComponent extends Control {
private rpcService: TreeItemRpcService;
constructor(el: ElementRef, cd: ChangeDetectorRef,
// todo replace UserService by another one from SUPPORT-8421 providing accountId or domainId
private i18n: DropdownTreeviewSelectI18n, private userService: UserService) {
private i18n: DropdownTreeviewSelectI18n) {
super(el, cd);
}
@ -44,8 +52,6 @@ export class DropdownTreeViewComponent extends Control {
@Visible()
public loadTreeItems(): void {
// todo replace the called method by
// this.rpcService.loadTreeDataByDomainId(domainId)
this.rpcService.loadTreeData()
.then((res: TreeItemDto[]) => {
this.items = res.map(value => new TreeviewItem(this.createTreeItem(value)));
@ -78,6 +84,7 @@ export class DropdownTreeViewComponent extends Control {
public onValueChange($event: any) {
this.valueChangeEvent.trigger($event);
this.applyListener(this.changeListeners);
}
@Visible()
@ -104,4 +111,34 @@ export class DropdownTreeViewComponent extends Control {
viewItem.children.forEach((value) => this.checkCollapseLevelRecursive(value, level + 1))
}
}
getPresentationValue(): string | number | boolean {
return this.value;
}
getValue(): any {
return this.value;
}
getValueAsModel(): any {
return this.value ? this.value : null;
}
setValue(value: any): any {
this.value = value;
}
onChange() {
super.onChange();
this.valueChangeEvent.trigger(this.value);
}
subscribeToModelChange() {
//empty because there is no ngModel here
}
unsubscribeToModelChange() {
//empty because there is no ngModel here
}
}

10
frontend/src/ts/modules/app/app.module.ts
View file

@ -23,10 +23,7 @@ import {FilterContainer} from "../../ervu_business_metrics/component/filter/Filt
import {TokenInterceptor} from "./interceptor/token-interceptor.service";
import {DropdownTreeViewComponent} from "../../component/field/DropdownTreeViewComponent";
import {DropdownTreeviewSelectComponent} from "../../component/external/ngx-treeview/dropdown-treeview-select/dropdown-treeview-select.component";
import {DropdownTreeviewComponent} from "../../component/external/ngx-treeview/lib/dropdown-treeview.component";
import {TreeviewModule} from '../../component/external/ngx-treeview/lib/treeview.module';
import {TreeviewComponent} from "../../component/external/ngx-treeview/lib/treeview.component";
import {TreeviewItemComponent} from "../../component/external/ngx-treeview/lib/treeview-item.component";
import {TreeviewModule} from "ngx-treeview";
registerLocaleData(localeRu);
export const DIRECTIVES = [
@ -37,10 +34,7 @@ export const DIRECTIVES = [
forwardRef(() => ErvuChartV2),
forwardRef(() => FilterContainer),
forwardRef(() => DropdownTreeViewComponent),
forwardRef(() => DropdownTreeviewComponent),
forwardRef(() => DropdownTreeviewSelectComponent),
forwardRef(() => TreeviewComponent),
forwardRef(() => TreeviewItemComponent)
forwardRef(() => DropdownTreeviewSelectComponent)
];
@NgModule({

6
frontend/systemjs.config.js
View file

@ -62,7 +62,8 @@
'chartjs-adapter-moment': 'npm:chartjs-adapter-moment/dist/chartjs-adapter-moment.js',
'tslib': 'npm:tslib/tslib.js',
'ngx-international-phone-number': 'npm:ngx-international-phone-number/ngx-international-phone-number.umd.js',
'google-libphonenumber': 'npm:google-libphonenumber/dist/libphonenumber.js'
'google-libphonenumber': 'npm:google-libphonenumber/dist/libphonenumber.js',
'ngx-treeview': 'npm:ngx-treeview'
},
packages: {
'webbpm': { main: 'main', defaultExtension: 'js'},
@ -87,7 +88,8 @@
'inputmask': {
main: 'dist/inputmask.js',
defaultExtension: 'js'
}
},
'ngx-treeview': { main: "bundles/ngx-treeview.umd.js", defaultExtension: 'js'}
}
});
})(this);

6
frontend/systemjs.preview.config.js
View file

@ -62,7 +62,8 @@
'chartjs-adapter-moment': 'npm:chartjs-adapter-moment/dist/chartjs-adapter-moment.js',
'tslib': 'npm:tslib/tslib.js',
'ngx-international-phone-number': 'npm:ngx-international-phone-number/ngx-international-phone-number.umd.js',
'google-libphonenumber': 'npm:google-libphonenumber/dist/libphonenumber.js'
'google-libphonenumber': 'npm:google-libphonenumber/dist/libphonenumber.js',
'ng2-dropdown-treeview': 'npm:ng2-dropdown-treeview'
},
packages: {
'preview': { main: './modules/preview/preview.main', defaultExtension: 'js'},
@ -86,7 +87,8 @@
'inputmask': {
main: 'dist/inputmask.js',
defaultExtension: 'js'
}
},
'ng2-dropdown-treeview':{ main: "bundles/ng2-dropdown-treeview.umd.js", defaultExtension: 'js'}
}
});
})(this);