mirror of https://github.com/abpframework/abp
You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
2847 lines
76 KiB
2847 lines
76 KiB
import {
|
|
ConfigState,
|
|
ChangePassword,
|
|
StartLoader,
|
|
StopLoader,
|
|
GetProfile,
|
|
UpdateProfile,
|
|
ProfileState,
|
|
RestOccurError,
|
|
LazyLoadService,
|
|
CoreModule,
|
|
} from '@abp/ng.core';
|
|
import {
|
|
Component,
|
|
EventEmitter,
|
|
Renderer2,
|
|
Input,
|
|
Output,
|
|
ViewChild,
|
|
Injectable,
|
|
ɵɵdefineInjectable,
|
|
ɵɵinject,
|
|
ElementRef,
|
|
ChangeDetectorRef,
|
|
ContentChild,
|
|
ViewChildren,
|
|
NgZone,
|
|
ApplicationRef,
|
|
ComponentFactoryResolver,
|
|
RendererFactory2,
|
|
Injector,
|
|
INJECTOR,
|
|
APP_INITIALIZER,
|
|
NgModule,
|
|
} from '@angular/core';
|
|
import { MessageService } from 'primeng/components/common/messageservice';
|
|
import { ToastModule } from 'primeng/toast';
|
|
import { Subject, ReplaySubject, BehaviorSubject, fromEvent, interval, timer, Observable, forkJoin } from 'rxjs';
|
|
import { Router, NavigationStart, NavigationEnd, NavigationError } from '@angular/router';
|
|
import { Store, ofActionSuccessful, Actions, Select } from '@ngxs/store';
|
|
import { Validators, FormBuilder } from '@angular/forms';
|
|
import { comparePasswords, takeUntilDestroy, NgxValidateCoreModule } from '@ngx-validate/core';
|
|
import snq from 'snq';
|
|
import { finalize, takeUntil, debounceTime, filter, withLatestFrom, take } from 'rxjs/operators';
|
|
import { animation, style, animate, trigger, transition, useAnimation, keyframes, state } from '@angular/animations';
|
|
import { __decorate, __metadata } from 'tslib';
|
|
import { HttpErrorResponse } from '@angular/common/http';
|
|
|
|
/**
|
|
* @fileoverview added by tsickle
|
|
* @suppress {checkTypes,constantProperty,extraRequire,missingOverride,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
|
|
*/
|
|
class BreadcrumbComponent {
|
|
/**
|
|
* @param {?} router
|
|
* @param {?} store
|
|
*/
|
|
constructor(router, store) {
|
|
this.router = router;
|
|
this.store = store;
|
|
this.segments = [];
|
|
this.show = !!this.store.selectSnapshot(
|
|
/**
|
|
* @param {?} state
|
|
* @return {?}
|
|
*/
|
|
state => state.LeptonLayoutState,
|
|
);
|
|
}
|
|
/**
|
|
* @return {?}
|
|
*/
|
|
ngOnInit() {
|
|
/** @type {?} */
|
|
const splittedUrl = this.router.url.split('/').filter(
|
|
/**
|
|
* @param {?} chunk
|
|
* @return {?}
|
|
*/
|
|
(chunk => chunk),
|
|
);
|
|
/** @type {?} */
|
|
const currentUrl = this.store.selectSnapshot(ConfigState.getRoute(splittedUrl[0]));
|
|
this.segments.push(currentUrl.name);
|
|
if (splittedUrl.length > 1) {
|
|
const [, ...arr] = splittedUrl;
|
|
/** @type {?} */
|
|
let childRoute = currentUrl;
|
|
for (let i = 0; i < arr.length; i++) {
|
|
/** @type {?} */
|
|
const element = arr[i];
|
|
childRoute = childRoute.children.find(
|
|
/**
|
|
* @param {?} child
|
|
* @return {?}
|
|
*/
|
|
child => child.path === element,
|
|
);
|
|
this.segments.push(childRoute.name);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
BreadcrumbComponent.decorators = [
|
|
{
|
|
type: Component,
|
|
args: [
|
|
{
|
|
selector: 'abp-breadcrumb',
|
|
template:
|
|
'<ol *ngIf="show" class="breadcrumb">\n <li class="breadcrumb-item">\n <a routerLink="/"><i class="fa fa-home"></i> </a>\n </li>\n <li\n *ngFor="let segment of segments; let last = last"\n class="breadcrumb-item"\n [class.active]="last"\n aria-current="page"\n >\n {{ segment | abpLocalization }}\n </li>\n</ol>\n',
|
|
},
|
|
],
|
|
},
|
|
];
|
|
/** @nocollapse */
|
|
BreadcrumbComponent.ctorParameters = () => [{ type: Router }, { type: Store }];
|
|
if (false) {
|
|
/** @type {?} */
|
|
BreadcrumbComponent.prototype.show;
|
|
/** @type {?} */
|
|
BreadcrumbComponent.prototype.segments;
|
|
/**
|
|
* @type {?}
|
|
* @private
|
|
*/
|
|
BreadcrumbComponent.prototype.router;
|
|
/**
|
|
* @type {?}
|
|
* @private
|
|
*/
|
|
BreadcrumbComponent.prototype.store;
|
|
}
|
|
|
|
/**
|
|
* @fileoverview added by tsickle
|
|
* @suppress {checkTypes,constantProperty,extraRequire,missingOverride,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
|
|
*/
|
|
class ButtonComponent {
|
|
/**
|
|
* @param {?} renderer
|
|
*/
|
|
constructor(renderer) {
|
|
this.renderer = renderer;
|
|
this.buttonClass = 'btn btn-primary';
|
|
this.loading = false;
|
|
this.disabled = false;
|
|
// tslint:disable-next-line: no-output-native
|
|
this.click = new EventEmitter();
|
|
// tslint:disable-next-line: no-output-native
|
|
this.focus = new EventEmitter();
|
|
// tslint:disable-next-line: no-output-native
|
|
this.blur = new EventEmitter();
|
|
/**
|
|
* @deprecated Use buttonType instead. To be deleted in v1
|
|
*/
|
|
this.type = 'button';
|
|
}
|
|
/**
|
|
* @return {?}
|
|
*/
|
|
get icon() {
|
|
return `${this.loading ? 'fa fa-spinner fa-spin' : this.iconClass || 'd-none'}`;
|
|
}
|
|
/**
|
|
* @return {?}
|
|
*/
|
|
ngOnInit() {
|
|
if (this.attributes) {
|
|
Object.keys(this.attributes).forEach(
|
|
/**
|
|
* @param {?} key
|
|
* @return {?}
|
|
*/
|
|
key => {
|
|
this.renderer.setAttribute(this.buttonRef.nativeElement, key, this.attributes[key]);
|
|
},
|
|
);
|
|
}
|
|
}
|
|
}
|
|
ButtonComponent.decorators = [
|
|
{
|
|
type: Component,
|
|
args: [
|
|
{
|
|
selector: 'abp-button',
|
|
// tslint:disable-next-line: component-max-inline-declarations
|
|
template: `
|
|
<button
|
|
#button
|
|
[attr.type]="buttonType || type"
|
|
[ngClass]="buttonClass"
|
|
[disabled]="loading || disabled"
|
|
(click)="click.emit($event)"
|
|
(focus)="focus.emit($event)"
|
|
(blur)="blur.emit($event)"
|
|
>
|
|
<i [ngClass]="icon" class="mr-1"></i><ng-content></ng-content>
|
|
</button>
|
|
`,
|
|
},
|
|
],
|
|
},
|
|
];
|
|
/** @nocollapse */
|
|
ButtonComponent.ctorParameters = () => [{ type: Renderer2 }];
|
|
ButtonComponent.propDecorators = {
|
|
buttonClass: [{ type: Input }],
|
|
buttonType: [{ type: Input }],
|
|
iconClass: [{ type: Input }],
|
|
loading: [{ type: Input }],
|
|
disabled: [{ type: Input }],
|
|
attributes: [{ type: Input }],
|
|
click: [{ type: Output }],
|
|
focus: [{ type: Output }],
|
|
blur: [{ type: Output }],
|
|
buttonRef: [{ type: ViewChild, args: ['button', { static: true }] }],
|
|
type: [{ type: Input }],
|
|
};
|
|
if (false) {
|
|
/** @type {?} */
|
|
ButtonComponent.prototype.buttonClass;
|
|
/** @type {?} */
|
|
ButtonComponent.prototype.buttonType;
|
|
/** @type {?} */
|
|
ButtonComponent.prototype.iconClass;
|
|
/** @type {?} */
|
|
ButtonComponent.prototype.loading;
|
|
/** @type {?} */
|
|
ButtonComponent.prototype.disabled;
|
|
/** @type {?} */
|
|
ButtonComponent.prototype.attributes;
|
|
/** @type {?} */
|
|
ButtonComponent.prototype.click;
|
|
/** @type {?} */
|
|
ButtonComponent.prototype.focus;
|
|
/** @type {?} */
|
|
ButtonComponent.prototype.blur;
|
|
/** @type {?} */
|
|
ButtonComponent.prototype.buttonRef;
|
|
/**
|
|
* @deprecated Use buttonType instead. To be deleted in v1
|
|
* @type {?}
|
|
*/
|
|
ButtonComponent.prototype.type;
|
|
/**
|
|
* @type {?}
|
|
* @private
|
|
*/
|
|
ButtonComponent.prototype.renderer;
|
|
}
|
|
|
|
/**
|
|
* @fileoverview added by tsickle
|
|
* @suppress {checkTypes,constantProperty,extraRequire,missingOverride,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
|
|
*/
|
|
/**
|
|
* @abstract
|
|
* @template T
|
|
*/
|
|
class AbstractToaster {
|
|
/**
|
|
* @param {?} messageService
|
|
*/
|
|
constructor(messageService) {
|
|
this.messageService = messageService;
|
|
this.key = 'abpToast';
|
|
this.sticky = false;
|
|
}
|
|
/**
|
|
* @param {?} message
|
|
* @param {?} title
|
|
* @param {?=} options
|
|
* @return {?}
|
|
*/
|
|
info(message, title, options) {
|
|
return this.show(message, title, 'info', options);
|
|
}
|
|
/**
|
|
* @param {?} message
|
|
* @param {?} title
|
|
* @param {?=} options
|
|
* @return {?}
|
|
*/
|
|
success(message, title, options) {
|
|
return this.show(message, title, 'success', options);
|
|
}
|
|
/**
|
|
* @param {?} message
|
|
* @param {?} title
|
|
* @param {?=} options
|
|
* @return {?}
|
|
*/
|
|
warn(message, title, options) {
|
|
return this.show(message, title, 'warn', options);
|
|
}
|
|
/**
|
|
* @param {?} message
|
|
* @param {?} title
|
|
* @param {?=} options
|
|
* @return {?}
|
|
*/
|
|
error(message, title, options) {
|
|
return this.show(message, title, 'error', options);
|
|
}
|
|
/**
|
|
* @protected
|
|
* @param {?} message
|
|
* @param {?} title
|
|
* @param {?} severity
|
|
* @param {?=} options
|
|
* @return {?}
|
|
*/
|
|
show(message, title, severity, options) {
|
|
this.messageService.clear(this.key);
|
|
this.messageService.add(
|
|
Object.assign(
|
|
{ severity, detail: message || '', summary: title || '' },
|
|
options,
|
|
{ key: this.key },
|
|
typeof (options || /** @type {?} */ ({})).sticky === 'undefined' && { sticky: this.sticky },
|
|
),
|
|
);
|
|
this.status$ = new Subject();
|
|
return this.status$;
|
|
}
|
|
/**
|
|
* @param {?=} status
|
|
* @return {?}
|
|
*/
|
|
clear(status) {
|
|
this.messageService.clear(this.key);
|
|
this.status$.next(status || 'dismiss' /* dismiss */);
|
|
this.status$.complete();
|
|
}
|
|
}
|
|
if (false) {
|
|
/** @type {?} */
|
|
AbstractToaster.prototype.status$;
|
|
/** @type {?} */
|
|
AbstractToaster.prototype.key;
|
|
/** @type {?} */
|
|
AbstractToaster.prototype.sticky;
|
|
/**
|
|
* @type {?}
|
|
* @protected
|
|
*/
|
|
AbstractToaster.prototype.messageService;
|
|
}
|
|
|
|
/**
|
|
* @fileoverview added by tsickle
|
|
* @suppress {checkTypes,constantProperty,extraRequire,missingOverride,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
|
|
*/
|
|
class ToasterService extends AbstractToaster {
|
|
/**
|
|
* @param {?} messages
|
|
* @return {?}
|
|
*/
|
|
addAll(messages) {
|
|
this.messageService.addAll(
|
|
messages.map(
|
|
/**
|
|
* @param {?} message
|
|
* @return {?}
|
|
*/
|
|
message => Object.assign({ key: this.key }, message),
|
|
),
|
|
);
|
|
}
|
|
}
|
|
ToasterService.decorators = [{ type: Injectable, args: [{ providedIn: 'root' }] }];
|
|
/** @nocollapse */ ToasterService.ngInjectableDef = ɵɵdefineInjectable({
|
|
factory: function ToasterService_Factory() {
|
|
return new ToasterService(ɵɵinject(MessageService));
|
|
},
|
|
token: ToasterService,
|
|
providedIn: 'root',
|
|
});
|
|
|
|
/**
|
|
* @fileoverview added by tsickle
|
|
* @suppress {checkTypes,constantProperty,extraRequire,missingOverride,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
|
|
*/
|
|
const { minLength, required } = Validators;
|
|
/** @type {?} */
|
|
const PASSWORD_FIELDS = ['newPassword', 'repeatNewPassword'];
|
|
class ChangePasswordComponent {
|
|
/**
|
|
* @param {?} fb
|
|
* @param {?} store
|
|
* @param {?} toasterService
|
|
*/
|
|
constructor(fb, store, toasterService) {
|
|
this.fb = fb;
|
|
this.store = store;
|
|
this.toasterService = toasterService;
|
|
this.visibleChange = new EventEmitter();
|
|
this.modalBusy = false;
|
|
this.mapErrorsFn
|
|
/**
|
|
* @param {?} errors
|
|
* @param {?} groupErrors
|
|
* @param {?} control
|
|
* @return {?}
|
|
*/ = (errors, groupErrors, control) => {
|
|
if (PASSWORD_FIELDS.indexOf(control.name) < 0) return errors;
|
|
return errors.concat(
|
|
groupErrors.filter(
|
|
/**
|
|
* @param {?} __0
|
|
* @return {?}
|
|
*/
|
|
({ key }) => key === 'passwordMismatch',
|
|
),
|
|
);
|
|
};
|
|
}
|
|
/**
|
|
* @return {?}
|
|
*/
|
|
get visible() {
|
|
return this._visible;
|
|
}
|
|
/**
|
|
* @param {?} value
|
|
* @return {?}
|
|
*/
|
|
set visible(value) {
|
|
this._visible = value;
|
|
this.visibleChange.emit(value);
|
|
}
|
|
/**
|
|
* @return {?}
|
|
*/
|
|
ngOnInit() {
|
|
this.form = this.fb.group(
|
|
{
|
|
password: ['', required],
|
|
newPassword: ['', required],
|
|
repeatNewPassword: ['', required],
|
|
},
|
|
{
|
|
validators: [comparePasswords(PASSWORD_FIELDS)],
|
|
},
|
|
);
|
|
}
|
|
/**
|
|
* @return {?}
|
|
*/
|
|
onSubmit() {
|
|
if (this.form.invalid) return;
|
|
this.modalBusy = true;
|
|
this.store
|
|
.dispatch(
|
|
new ChangePassword({
|
|
currentPassword: this.form.get('password').value,
|
|
newPassword: this.form.get('newPassword').value,
|
|
}),
|
|
)
|
|
.pipe(
|
|
finalize(
|
|
/**
|
|
* @return {?}
|
|
*/
|
|
() => {
|
|
this.modalBusy = false;
|
|
},
|
|
),
|
|
)
|
|
.subscribe({
|
|
/**
|
|
* @return {?}
|
|
*/
|
|
next: () => {
|
|
this.visible = false;
|
|
this.form.reset();
|
|
},
|
|
/**
|
|
* @param {?} err
|
|
* @return {?}
|
|
*/
|
|
error: err => {
|
|
this.toasterService.error(
|
|
snq(
|
|
/**
|
|
* @return {?}
|
|
*/
|
|
() => err.error.error.message,
|
|
'AbpAccount::DefaultErrorMessage',
|
|
),
|
|
'Error',
|
|
{
|
|
life: 7000,
|
|
},
|
|
);
|
|
},
|
|
});
|
|
}
|
|
/**
|
|
* @return {?}
|
|
*/
|
|
openModal() {
|
|
this.visible = true;
|
|
}
|
|
/**
|
|
* @param {?} __0
|
|
* @return {?}
|
|
*/
|
|
ngOnChanges({ visible }) {
|
|
if (!visible) return;
|
|
if (visible.currentValue) {
|
|
this.openModal();
|
|
} else if (visible.currentValue === false && this.visible) {
|
|
this.visible = false;
|
|
}
|
|
}
|
|
}
|
|
ChangePasswordComponent.decorators = [
|
|
{
|
|
type: Component,
|
|
args: [
|
|
{
|
|
selector: 'abp-change-password',
|
|
template:
|
|
'<abp-modal [(visible)]="visible" [busy]="modalBusy">\n <ng-template #abpHeader>\n <h4>{{ \'AbpIdentity::ChangePassword\' | abpLocalization }}</h4>\n </ng-template>\n <ng-template #abpBody>\n <form [formGroup]="form" (ngSubmit)="onSubmit()" [mapErrorsFn]="mapErrorsFn">\n <div class="form-group">\n <label for="current-password">{{ \'AbpIdentity::DisplayName:CurrentPassword\' | abpLocalization }}</label\n ><span> * </span\n ><input type="password" id="current-password" class="form-control" formControlName="password" autofocus />\n </div>\n <div class="form-group">\n <label for="new-password">{{ \'AbpIdentity::DisplayName:NewPassword\' | abpLocalization }}</label\n ><span> * </span><input type="password" id="new-password" class="form-control" formControlName="newPassword" />\n </div>\n <div class="form-group">\n <label for="confirm-new-password">{{ \'AbpIdentity::DisplayName:NewPasswordConfirm\' | abpLocalization }}</label\n ><span> * </span\n ><input type="password" id="confirm-new-password" class="form-control" formControlName="repeatNewPassword" />\n </div>\n </form>\n </ng-template>\n <ng-template #abpFooter>\n <button type="button" class="btn btn-secondary color-white" #abpClose>\n {{ \'AbpIdentity::Cancel\' | abpLocalization }}\n </button>\n <abp-button iconClass="fa fa-check" buttonClass="btn btn-primary color-white" (click)="onSubmit()">{{\n \'AbpIdentity::Save\' | abpLocalization\n }}</abp-button>\n </ng-template>\n</abp-modal>\n',
|
|
},
|
|
],
|
|
},
|
|
];
|
|
/** @nocollapse */
|
|
ChangePasswordComponent.ctorParameters = () => [{ type: FormBuilder }, { type: Store }, { type: ToasterService }];
|
|
ChangePasswordComponent.propDecorators = {
|
|
visible: [{ type: Input }],
|
|
visibleChange: [{ type: Output }],
|
|
modalContent: [{ type: ViewChild, args: ['modalContent', { static: false }] }],
|
|
};
|
|
if (false) {
|
|
/**
|
|
* @type {?}
|
|
* @protected
|
|
*/
|
|
ChangePasswordComponent.prototype._visible;
|
|
/** @type {?} */
|
|
ChangePasswordComponent.prototype.visibleChange;
|
|
/** @type {?} */
|
|
ChangePasswordComponent.prototype.modalContent;
|
|
/** @type {?} */
|
|
ChangePasswordComponent.prototype.form;
|
|
/** @type {?} */
|
|
ChangePasswordComponent.prototype.modalBusy;
|
|
/** @type {?} */
|
|
ChangePasswordComponent.prototype.mapErrorsFn;
|
|
/**
|
|
* @type {?}
|
|
* @private
|
|
*/
|
|
ChangePasswordComponent.prototype.fb;
|
|
/**
|
|
* @type {?}
|
|
* @private
|
|
*/
|
|
ChangePasswordComponent.prototype.store;
|
|
/**
|
|
* @type {?}
|
|
* @private
|
|
*/
|
|
ChangePasswordComponent.prototype.toasterService;
|
|
}
|
|
|
|
/**
|
|
* @fileoverview added by tsickle
|
|
* @suppress {checkTypes,constantProperty,extraRequire,missingOverride,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
|
|
*/
|
|
/**
|
|
* @param {?} count
|
|
* @return {?}
|
|
*/
|
|
function getRandomBackgroundColor(count) {
|
|
/** @type {?} */
|
|
const colors = [];
|
|
for (let i = 0; i < count; i++) {
|
|
/** @type {?} */
|
|
const r = ((i + 5) * (i + 5) * 474) % 255;
|
|
/** @type {?} */
|
|
const g = ((i + 5) * (i + 5) * 1600) % 255;
|
|
/** @type {?} */
|
|
const b = ((i + 5) * (i + 5) * 84065) % 255;
|
|
colors.push('rgba(' + r + ', ' + g + ', ' + b + ', 0.7)');
|
|
}
|
|
return colors;
|
|
}
|
|
/** @type {?} */
|
|
const chartJsLoaded$ = new ReplaySubject(1);
|
|
|
|
/**
|
|
* @fileoverview added by tsickle
|
|
* @suppress {checkTypes,constantProperty,extraRequire,missingOverride,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
|
|
*/
|
|
class ChartComponent {
|
|
/**
|
|
* @param {?} el
|
|
* @param {?} cdRef
|
|
*/
|
|
constructor(el, cdRef) {
|
|
this.el = el;
|
|
this.cdRef = cdRef;
|
|
this.options = {};
|
|
this.plugins = [];
|
|
this.responsive = true;
|
|
// tslint:disable-next-line: no-output-on-prefix
|
|
this.onDataSelect = new EventEmitter();
|
|
this.initialized = new BehaviorSubject(this);
|
|
this.onCanvasClick
|
|
/**
|
|
* @param {?} event
|
|
* @return {?}
|
|
*/ = event => {
|
|
if (this.chart) {
|
|
/** @type {?} */
|
|
const element = this.chart.getElementAtEvent(event);
|
|
/** @type {?} */
|
|
const dataset = this.chart.getDatasetAtEvent(event);
|
|
if (element && element[0] && dataset) {
|
|
this.onDataSelect.emit({
|
|
originalEvent: event,
|
|
element: element[0],
|
|
dataset,
|
|
});
|
|
}
|
|
}
|
|
};
|
|
this.initChart
|
|
/**
|
|
* @return {?}
|
|
*/ = () => {
|
|
/** @type {?} */
|
|
const opts = this.options || {};
|
|
opts.responsive = this.responsive;
|
|
// allows chart to resize in responsive mode
|
|
if (opts.responsive && (this.height || this.width)) {
|
|
opts.maintainAspectRatio = false;
|
|
}
|
|
this.chart = new Chart(this.el.nativeElement.children[0].children[0], {
|
|
type: this.type,
|
|
data: this.data,
|
|
options: this.options,
|
|
plugins: this.plugins,
|
|
});
|
|
this.cdRef.detectChanges();
|
|
};
|
|
this.generateLegend
|
|
/**
|
|
* @return {?}
|
|
*/ = () => {
|
|
if (this.chart) {
|
|
return this.chart.generateLegend();
|
|
}
|
|
};
|
|
this.refresh
|
|
/**
|
|
* @return {?}
|
|
*/ = () => {
|
|
if (this.chart) {
|
|
this.chart.update();
|
|
this.cdRef.detectChanges();
|
|
}
|
|
};
|
|
this.reinit
|
|
/**
|
|
* @return {?}
|
|
*/ = () => {
|
|
if (this.chart) {
|
|
this.chart.destroy();
|
|
this.initChart();
|
|
}
|
|
};
|
|
}
|
|
/**
|
|
* @return {?}
|
|
*/
|
|
get data() {
|
|
return this._data;
|
|
}
|
|
/**
|
|
* @param {?} val
|
|
* @return {?}
|
|
*/
|
|
set data(val) {
|
|
this._data = val;
|
|
this.reinit();
|
|
}
|
|
/**
|
|
* @return {?}
|
|
*/
|
|
get canvas() {
|
|
return this.el.nativeElement.children[0].children[0];
|
|
}
|
|
/**
|
|
* @return {?}
|
|
*/
|
|
get base64Image() {
|
|
return this.chart.toBase64Image();
|
|
}
|
|
/**
|
|
* @return {?}
|
|
*/
|
|
ngAfterViewInit() {
|
|
chartJsLoaded$.subscribe(
|
|
/**
|
|
* @return {?}
|
|
*/
|
|
() => {
|
|
try {
|
|
// tslint:disable-next-line: no-unused-expression
|
|
Chart;
|
|
} catch (error) {
|
|
console.error(`Chart is not found. Import the Chart from app.module like shown below:
|
|
import('chart.js');
|
|
`);
|
|
return;
|
|
}
|
|
this.initChart();
|
|
this._initialized = true;
|
|
},
|
|
);
|
|
}
|
|
/**
|
|
* @return {?}
|
|
*/
|
|
ngOnDestroy() {
|
|
if (this.chart) {
|
|
this.chart.destroy();
|
|
this._initialized = false;
|
|
this.chart = null;
|
|
}
|
|
}
|
|
}
|
|
ChartComponent.decorators = [
|
|
{
|
|
type: Component,
|
|
args: [
|
|
{
|
|
selector: 'abp-chart',
|
|
template:
|
|
'<div\n style="position:relative"\n [style.width]="responsive && !width ? null : width"\n [style.height]="responsive && !height ? null : height"\n>\n <canvas\n [attr.width]="responsive && !width ? null : width"\n [attr.height]="responsive && !height ? null : height"\n (click)="onCanvasClick($event)"\n ></canvas>\n</div>\n',
|
|
},
|
|
],
|
|
},
|
|
];
|
|
/** @nocollapse */
|
|
ChartComponent.ctorParameters = () => [{ type: ElementRef }, { type: ChangeDetectorRef }];
|
|
ChartComponent.propDecorators = {
|
|
type: [{ type: Input }],
|
|
options: [{ type: Input }],
|
|
plugins: [{ type: Input }],
|
|
width: [{ type: Input }],
|
|
height: [{ type: Input }],
|
|
responsive: [{ type: Input }],
|
|
onDataSelect: [{ type: Output }],
|
|
initialized: [{ type: Output }],
|
|
data: [{ type: Input }],
|
|
};
|
|
if (false) {
|
|
/** @type {?} */
|
|
ChartComponent.prototype.type;
|
|
/** @type {?} */
|
|
ChartComponent.prototype.options;
|
|
/** @type {?} */
|
|
ChartComponent.prototype.plugins;
|
|
/** @type {?} */
|
|
ChartComponent.prototype.width;
|
|
/** @type {?} */
|
|
ChartComponent.prototype.height;
|
|
/** @type {?} */
|
|
ChartComponent.prototype.responsive;
|
|
/** @type {?} */
|
|
ChartComponent.prototype.onDataSelect;
|
|
/** @type {?} */
|
|
ChartComponent.prototype.initialized;
|
|
/**
|
|
* @type {?}
|
|
* @private
|
|
*/
|
|
ChartComponent.prototype._initialized;
|
|
/** @type {?} */
|
|
ChartComponent.prototype._data;
|
|
/** @type {?} */
|
|
ChartComponent.prototype.chart;
|
|
/** @type {?} */
|
|
ChartComponent.prototype.onCanvasClick;
|
|
/** @type {?} */
|
|
ChartComponent.prototype.initChart;
|
|
/** @type {?} */
|
|
ChartComponent.prototype.generateLegend;
|
|
/** @type {?} */
|
|
ChartComponent.prototype.refresh;
|
|
/** @type {?} */
|
|
ChartComponent.prototype.reinit;
|
|
/** @type {?} */
|
|
ChartComponent.prototype.el;
|
|
/**
|
|
* @type {?}
|
|
* @private
|
|
*/
|
|
ChartComponent.prototype.cdRef;
|
|
}
|
|
|
|
/**
|
|
* @fileoverview added by tsickle
|
|
* @suppress {checkTypes,constantProperty,extraRequire,missingOverride,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
|
|
*/
|
|
class ConfirmationService extends AbstractToaster {
|
|
/**
|
|
* @param {?} messageService
|
|
*/
|
|
constructor(messageService) {
|
|
super(messageService);
|
|
this.messageService = messageService;
|
|
this.key = 'abpConfirmation';
|
|
this.sticky = true;
|
|
this.destroy$ = new Subject();
|
|
}
|
|
/**
|
|
* @param {?} message
|
|
* @param {?} title
|
|
* @param {?} severity
|
|
* @param {?=} options
|
|
* @return {?}
|
|
*/
|
|
show(message, title, severity, options) {
|
|
this.listenToEscape();
|
|
return super.show(message, title, severity, options);
|
|
}
|
|
/**
|
|
* @param {?=} status
|
|
* @return {?}
|
|
*/
|
|
clear(status) {
|
|
super.clear(status);
|
|
this.destroy$.next();
|
|
}
|
|
/**
|
|
* @return {?}
|
|
*/
|
|
listenToEscape() {
|
|
fromEvent(document, 'keyup')
|
|
.pipe(
|
|
takeUntil(this.destroy$),
|
|
debounceTime(150),
|
|
filter(
|
|
/**
|
|
* @param {?} key
|
|
* @return {?}
|
|
*/
|
|
key => key && key.code === 'Escape',
|
|
),
|
|
)
|
|
.subscribe(
|
|
/**
|
|
* @param {?} _
|
|
* @return {?}
|
|
*/
|
|
_ => {
|
|
this.clear();
|
|
},
|
|
);
|
|
}
|
|
}
|
|
ConfirmationService.decorators = [{ type: Injectable, args: [{ providedIn: 'root' }] }];
|
|
/** @nocollapse */
|
|
ConfirmationService.ctorParameters = () => [{ type: MessageService }];
|
|
/** @nocollapse */ ConfirmationService.ngInjectableDef = ɵɵdefineInjectable({
|
|
factory: function ConfirmationService_Factory() {
|
|
return new ConfirmationService(ɵɵinject(MessageService));
|
|
},
|
|
token: ConfirmationService,
|
|
providedIn: 'root',
|
|
});
|
|
if (false) {
|
|
/** @type {?} */
|
|
ConfirmationService.prototype.key;
|
|
/** @type {?} */
|
|
ConfirmationService.prototype.sticky;
|
|
/** @type {?} */
|
|
ConfirmationService.prototype.destroy$;
|
|
/**
|
|
* @type {?}
|
|
* @protected
|
|
*/
|
|
ConfirmationService.prototype.messageService;
|
|
}
|
|
|
|
/**
|
|
* @fileoverview added by tsickle
|
|
* @suppress {checkTypes,constantProperty,extraRequire,missingOverride,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
|
|
*/
|
|
class ConfirmationComponent {
|
|
/**
|
|
* @param {?} confirmationService
|
|
*/
|
|
constructor(confirmationService) {
|
|
this.confirmationService = confirmationService;
|
|
this.confirm = 'confirm' /* confirm */;
|
|
this.reject = 'reject' /* reject */;
|
|
this.dismiss = 'dismiss' /* dismiss */;
|
|
}
|
|
/**
|
|
* @param {?} status
|
|
* @return {?}
|
|
*/
|
|
close(status) {
|
|
this.confirmationService.clear(status);
|
|
}
|
|
}
|
|
ConfirmationComponent.decorators = [
|
|
{
|
|
type: Component,
|
|
args: [
|
|
{
|
|
selector: 'abp-confirmation',
|
|
// tslint:disable-next-line: component-max-inline-declarations
|
|
template: `
|
|
<p-toast
|
|
position="center"
|
|
key="abpConfirmation"
|
|
(onClose)="close(dismiss)"
|
|
[modal]="true"
|
|
[baseZIndex]="1000"
|
|
styleClass="abp-confirm"
|
|
>
|
|
<ng-template let-message pTemplate="message">
|
|
<i class="fa fa-exclamation-circle abp-confirm-icon"></i>
|
|
<div *ngIf="message.summary" class="abp-confirm-summary">
|
|
{{ message.summary | abpLocalization: message.titleLocalizationParams }}
|
|
</div>
|
|
<div class="abp-confirm-body">
|
|
{{ message.detail | abpLocalization: message.messageLocalizationParams }}
|
|
</div>
|
|
|
|
<div class="abp-confirm-footer justify-content-center">
|
|
<button
|
|
*ngIf="!message.hideCancelBtn"
|
|
id="cancel"
|
|
type="button"
|
|
class="btn btn-sm btn-primary"
|
|
(click)="close(reject)"
|
|
>
|
|
{{ message.cancelCopy || 'AbpIdentity::Cancel' | abpLocalization }}
|
|
</button>
|
|
<button
|
|
*ngIf="!message.hideYesBtn"
|
|
id="confirm"
|
|
type="button"
|
|
class="btn btn-sm btn-primary"
|
|
(click)="close(confirm)"
|
|
autofocus
|
|
>
|
|
<span>{{ message.yesCopy || 'AbpIdentity::Yes' | abpLocalization }}</span>
|
|
</button>
|
|
</div>
|
|
</ng-template>
|
|
</p-toast>
|
|
`,
|
|
},
|
|
],
|
|
},
|
|
];
|
|
/** @nocollapse */
|
|
ConfirmationComponent.ctorParameters = () => [{ type: ConfirmationService }];
|
|
if (false) {
|
|
/** @type {?} */
|
|
ConfirmationComponent.prototype.confirm;
|
|
/** @type {?} */
|
|
ConfirmationComponent.prototype.reject;
|
|
/** @type {?} */
|
|
ConfirmationComponent.prototype.dismiss;
|
|
/**
|
|
* @type {?}
|
|
* @private
|
|
*/
|
|
ConfirmationComponent.prototype.confirmationService;
|
|
}
|
|
|
|
/**
|
|
* @fileoverview added by tsickle
|
|
* @suppress {checkTypes,constantProperty,extraRequire,missingOverride,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
|
|
*/
|
|
class ErrorComponent {
|
|
constructor() {
|
|
this.title = 'Oops!';
|
|
this.details = 'Sorry, an error has occured.';
|
|
}
|
|
/**
|
|
* @return {?}
|
|
*/
|
|
destroy() {
|
|
this.renderer.removeChild(this.host, this.elementRef.nativeElement);
|
|
}
|
|
}
|
|
ErrorComponent.decorators = [
|
|
{
|
|
type: Component,
|
|
args: [
|
|
{
|
|
selector: 'abp-error',
|
|
template:
|
|
'<div class="error">\n <button id="abp-close-button mr-3" type="button" class="close" (click)="destroy()">\n <span aria-hidden="true">×</span>\n </button>\n <div class="row centered">\n <div class="col-md-12">\n <div class="error-template">\n <h1>\n {{ title | abpLocalization }}\n </h1>\n <div class="error-details">\n {{ details | abpLocalization }}\n </div>\n <div class="error-actions">\n <a (click)="destroy()" routerLink="/" class="btn btn-primary btn-md mt-2"\n ><span class="glyphicon glyphicon-home"></span>\n {{ { key: \'::Menu:Home\', defaultValue: \'Home\' } | abpLocalization }}\n </a>\n </div>\n </div>\n </div>\n </div>\n</div>\n',
|
|
styles: [
|
|
'.error{position:fixed;top:0;background-color:#fff;width:100vw;height:100vh;z-index:999999}.centered{position:fixed;top:50%;left:50%;transform:translate(-50%,-50%)}',
|
|
],
|
|
},
|
|
],
|
|
},
|
|
];
|
|
if (false) {
|
|
/** @type {?} */
|
|
ErrorComponent.prototype.title;
|
|
/** @type {?} */
|
|
ErrorComponent.prototype.details;
|
|
/** @type {?} */
|
|
ErrorComponent.prototype.renderer;
|
|
/** @type {?} */
|
|
ErrorComponent.prototype.elementRef;
|
|
/** @type {?} */
|
|
ErrorComponent.prototype.host;
|
|
}
|
|
|
|
/**
|
|
* @fileoverview added by tsickle
|
|
* @suppress {checkTypes,constantProperty,extraRequire,missingOverride,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
|
|
*/
|
|
class LoaderBarComponent {
|
|
/**
|
|
* @param {?} actions
|
|
* @param {?} router
|
|
* @param {?} cdRef
|
|
*/
|
|
constructor(actions, router, cdRef) {
|
|
this.actions = actions;
|
|
this.router = router;
|
|
this.cdRef = cdRef;
|
|
this.containerClass = 'abp-loader-bar';
|
|
this.color = '#77b6ff';
|
|
this.isLoading = false;
|
|
this.progressLevel = 0;
|
|
this.filter
|
|
/**
|
|
* @param {?} action
|
|
* @return {?}
|
|
*/ = action => action.payload.url.indexOf('openid-configuration') < 0;
|
|
actions
|
|
.pipe(
|
|
ofActionSuccessful(StartLoader, StopLoader),
|
|
filter(this.filter),
|
|
takeUntilDestroy(this),
|
|
)
|
|
.subscribe(
|
|
/**
|
|
* @param {?} action
|
|
* @return {?}
|
|
*/
|
|
action => {
|
|
if (action instanceof StartLoader) this.startLoading();
|
|
else this.stopLoading();
|
|
},
|
|
);
|
|
router.events
|
|
.pipe(
|
|
filter(
|
|
/**
|
|
* @param {?} event
|
|
* @return {?}
|
|
*/
|
|
event =>
|
|
event instanceof NavigationStart || event instanceof NavigationEnd || event instanceof NavigationError,
|
|
),
|
|
takeUntilDestroy(this),
|
|
)
|
|
.subscribe(
|
|
/**
|
|
* @param {?} event
|
|
* @return {?}
|
|
*/
|
|
event => {
|
|
if (event instanceof NavigationStart) this.startLoading();
|
|
else this.stopLoading();
|
|
},
|
|
);
|
|
}
|
|
/**
|
|
* @return {?}
|
|
*/
|
|
get boxShadow() {
|
|
return `0 0 10px rgba(${this.color}, 0.5)`;
|
|
}
|
|
/**
|
|
* @return {?}
|
|
*/
|
|
ngOnDestroy() {
|
|
this.interval.unsubscribe();
|
|
}
|
|
/**
|
|
* @return {?}
|
|
*/
|
|
startLoading() {
|
|
if (this.isLoading || this.progressLevel !== 0) return;
|
|
this.isLoading = true;
|
|
this.interval = interval(350).subscribe(
|
|
/**
|
|
* @return {?}
|
|
*/
|
|
() => {
|
|
if (this.progressLevel < 75) {
|
|
this.progressLevel += Math.random() * 10;
|
|
} else if (this.progressLevel < 90) {
|
|
this.progressLevel += 0.4;
|
|
} else if (this.progressLevel < 100) {
|
|
this.progressLevel += 0.1;
|
|
} else {
|
|
this.interval.unsubscribe();
|
|
}
|
|
this.cdRef.detectChanges();
|
|
},
|
|
);
|
|
}
|
|
/**
|
|
* @return {?}
|
|
*/
|
|
stopLoading() {
|
|
this.interval.unsubscribe();
|
|
this.progressLevel = 100;
|
|
this.isLoading = false;
|
|
if (this.timer && !this.timer.closed) return;
|
|
this.timer = timer(820).subscribe(
|
|
/**
|
|
* @return {?}
|
|
*/
|
|
() => {
|
|
this.progressLevel = 0;
|
|
this.cdRef.detectChanges();
|
|
},
|
|
);
|
|
}
|
|
}
|
|
LoaderBarComponent.decorators = [
|
|
{
|
|
type: Component,
|
|
args: [
|
|
{
|
|
selector: 'abp-loader-bar',
|
|
template: `
|
|
<div id="abp-loader-bar" [ngClass]="containerClass" [class.is-loading]="isLoading">
|
|
<div
|
|
class="abp-progress"
|
|
[style.width.vw]="progressLevel"
|
|
[ngStyle]="{
|
|
'background-color': color,
|
|
'box-shadow': boxShadow
|
|
}"
|
|
></div>
|
|
</div>
|
|
`,
|
|
styles: [
|
|
'.abp-loader-bar{left:0;opacity:0;position:fixed;top:0;transition:opacity .4s linear .4s;z-index:99999}.abp-loader-bar.is-loading{opacity:1;transition:none}.abp-loader-bar .abp-progress{height:3px;left:0;position:fixed;top:0;transition:width .4s}',
|
|
],
|
|
},
|
|
],
|
|
},
|
|
];
|
|
/** @nocollapse */
|
|
LoaderBarComponent.ctorParameters = () => [{ type: Actions }, { type: Router }, { type: ChangeDetectorRef }];
|
|
LoaderBarComponent.propDecorators = {
|
|
containerClass: [{ type: Input }],
|
|
color: [{ type: Input }],
|
|
isLoading: [{ type: Input }],
|
|
filter: [{ type: Input }],
|
|
};
|
|
if (false) {
|
|
/** @type {?} */
|
|
LoaderBarComponent.prototype.containerClass;
|
|
/** @type {?} */
|
|
LoaderBarComponent.prototype.color;
|
|
/** @type {?} */
|
|
LoaderBarComponent.prototype.isLoading;
|
|
/** @type {?} */
|
|
LoaderBarComponent.prototype.progressLevel;
|
|
/** @type {?} */
|
|
LoaderBarComponent.prototype.interval;
|
|
/** @type {?} */
|
|
LoaderBarComponent.prototype.timer;
|
|
/** @type {?} */
|
|
LoaderBarComponent.prototype.filter;
|
|
/**
|
|
* @type {?}
|
|
* @private
|
|
*/
|
|
LoaderBarComponent.prototype.actions;
|
|
/**
|
|
* @type {?}
|
|
* @private
|
|
*/
|
|
LoaderBarComponent.prototype.router;
|
|
/**
|
|
* @type {?}
|
|
* @private
|
|
*/
|
|
LoaderBarComponent.prototype.cdRef;
|
|
}
|
|
|
|
/**
|
|
* @fileoverview added by tsickle
|
|
* @suppress {checkTypes,constantProperty,extraRequire,missingOverride,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
|
|
*/
|
|
/** @type {?} */
|
|
const fadeIn = animation([style({ opacity: '0' }), animate('{{ time}} {{ easing }}', style({ opacity: '1' }))], {
|
|
params: { time: '350ms', easing: 'ease' },
|
|
});
|
|
/** @type {?} */
|
|
const fadeOut = animation([style({ opacity: '1' }), animate('{{ time}} {{ easing }}', style({ opacity: '0' }))], {
|
|
params: { time: '350ms', easing: 'ease' },
|
|
});
|
|
/** @type {?} */
|
|
const fadeInDown = animation(
|
|
[
|
|
style({ opacity: '0', transform: '{{ transform }} translateY(-20px)' }),
|
|
animate('{{ time }} {{ easing }}', style({ opacity: '1', transform: '{{ transform }} translateY(0)' })),
|
|
],
|
|
{ params: { time: '350ms', easing: 'ease', transform: '' } },
|
|
);
|
|
/** @type {?} */
|
|
const fadeInUp = animation(
|
|
[
|
|
style({ opacity: '0', transform: '{{ transform }} translateY(20px)' }),
|
|
animate('{{ time }} {{ easing }}', style({ opacity: '1', transform: '{{ transform }} translateY(0)' })),
|
|
],
|
|
{ params: { time: '350ms', easing: 'ease', transform: '' } },
|
|
);
|
|
/** @type {?} */
|
|
const fadeInLeft = animation(
|
|
[
|
|
style({ opacity: '0', transform: '{{ transform }} translateX(20px)' }),
|
|
animate('{{ time }} {{ easing }}', style({ opacity: '1', transform: '{{ transform }} translateX(0)' })),
|
|
],
|
|
{ params: { time: '350ms', easing: 'ease', transform: '' } },
|
|
);
|
|
/** @type {?} */
|
|
const fadeInRight = animation(
|
|
[
|
|
style({ opacity: '0', transform: '{{ transform }} translateX(-20px)' }),
|
|
animate('{{ time }} {{ easing }}', style({ opacity: '1', transform: '{{ transform }} translateX(0)' })),
|
|
],
|
|
{ params: { time: '350ms', easing: 'ease', transform: '' } },
|
|
);
|
|
/** @type {?} */
|
|
const fadeOutDown = animation(
|
|
[
|
|
style({ opacity: '1', transform: '{{ transform }} translateY(0)' }),
|
|
animate('{{ time }} {{ easing }}', style({ opacity: '0', transform: '{{ transform }} translateY(20px)' })),
|
|
],
|
|
{ params: { time: '350ms', easing: 'ease', transform: '' } },
|
|
);
|
|
/** @type {?} */
|
|
const fadeOutUp = animation(
|
|
[
|
|
style({ opacity: '1', transform: '{{ transform }} translateY(0)' }),
|
|
animate('{{ time }} {{ easing }}', style({ opacity: '0', transform: '{{ transform }} translateY(-20px)' })),
|
|
],
|
|
{ params: { time: '350ms', easing: 'ease', transform: '' } },
|
|
);
|
|
/** @type {?} */
|
|
const fadeOutLeft = animation(
|
|
[
|
|
style({ opacity: '1', transform: '{{ transform }} translateX(0)' }),
|
|
animate('{{ time }} {{ easing }}', style({ opacity: '0', transform: '{{ transform }} translateX(20px)' })),
|
|
],
|
|
{ params: { time: '350ms', easing: 'ease', transform: '' } },
|
|
);
|
|
/** @type {?} */
|
|
const fadeOutRight = animation(
|
|
[
|
|
style({ opacity: '1', transform: '{{ transform }} translateX(0)' }),
|
|
animate('{{ time }} {{ easing }}', style({ opacity: '0', transform: '{{ transform }} translateX(-20px)' })),
|
|
],
|
|
{ params: { time: '350ms', easing: 'ease', transform: '' } },
|
|
);
|
|
|
|
/**
|
|
* @fileoverview added by tsickle
|
|
* @suppress {checkTypes,constantProperty,extraRequire,missingOverride,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
|
|
*/
|
|
/** @type {?} */
|
|
const fadeAnimation = trigger('fade', [
|
|
transition(':enter', useAnimation(fadeIn)),
|
|
transition(':leave', useAnimation(fadeOut)),
|
|
]);
|
|
/** @type {?} */
|
|
const dialogAnimation = trigger('dialog', [
|
|
transition(':enter', useAnimation(fadeInDown)),
|
|
transition(':leave', useAnimation(fadeOut)),
|
|
]);
|
|
|
|
/**
|
|
* @fileoverview added by tsickle
|
|
* @suppress {checkTypes,constantProperty,extraRequire,missingOverride,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
|
|
*/
|
|
class ModalComponent {
|
|
/**
|
|
* @param {?} renderer
|
|
* @param {?} confirmationService
|
|
*/
|
|
constructor(renderer, confirmationService) {
|
|
this.renderer = renderer;
|
|
this.confirmationService = confirmationService;
|
|
this.centered = false;
|
|
this.modalClass = '';
|
|
this.size = 'lg';
|
|
this.visibleChange = new EventEmitter();
|
|
this.init = new EventEmitter();
|
|
this.appear = new EventEmitter();
|
|
this.disappear = new EventEmitter();
|
|
this._visible = false;
|
|
this._busy = false;
|
|
this.isModalOpen = false;
|
|
this.isConfirmationOpen = false;
|
|
this.destroy$ = new Subject();
|
|
}
|
|
/**
|
|
* @return {?}
|
|
*/
|
|
get visible() {
|
|
return this._visible;
|
|
}
|
|
/**
|
|
* @param {?} value
|
|
* @return {?}
|
|
*/
|
|
set visible(value) {
|
|
if (typeof value !== 'boolean') return;
|
|
this.isModalOpen = value;
|
|
this._visible = value;
|
|
this.visibleChange.emit(value);
|
|
if (value) {
|
|
setTimeout(
|
|
/**
|
|
* @return {?}
|
|
*/
|
|
() => this.listen(),
|
|
0,
|
|
);
|
|
this.renderer.addClass(document.body, 'modal-open');
|
|
this.appear.emit();
|
|
} else {
|
|
this.renderer.removeClass(document.body, 'modal-open');
|
|
this.disappear.emit();
|
|
}
|
|
}
|
|
/**
|
|
* @return {?}
|
|
*/
|
|
get busy() {
|
|
return this._busy;
|
|
}
|
|
/**
|
|
* @param {?} value
|
|
* @return {?}
|
|
*/
|
|
set busy(value) {
|
|
if (this.abpSubmit && this.abpSubmit instanceof ButtonComponent) {
|
|
this.abpSubmit.loading = value;
|
|
}
|
|
this._busy = value;
|
|
}
|
|
/**
|
|
* @return {?}
|
|
*/
|
|
ngOnDestroy() {
|
|
this.destroy$.next();
|
|
}
|
|
/**
|
|
* @return {?}
|
|
*/
|
|
close() {
|
|
if (this.busy) return;
|
|
/** @type {?} */
|
|
const nodes = getFlatNodes(
|
|
/** @type {?} */ (this.modalContent.nativeElement.querySelector('#abp-modal-body')).childNodes,
|
|
);
|
|
if (hasNgDirty(nodes)) {
|
|
if (this.isConfirmationOpen) return;
|
|
this.isConfirmationOpen = true;
|
|
this.confirmationService
|
|
.warn('AbpAccount::AreYouSureYouWantToCancelEditingWarningMessage', 'AbpAccount::AreYouSure')
|
|
.subscribe(
|
|
/**
|
|
* @param {?} status
|
|
* @return {?}
|
|
*/
|
|
status => {
|
|
this.isConfirmationOpen = false;
|
|
if (status === 'confirm' /* confirm */) {
|
|
this.visible = false;
|
|
}
|
|
},
|
|
);
|
|
} else {
|
|
this.visible = false;
|
|
}
|
|
}
|
|
/**
|
|
* @return {?}
|
|
*/
|
|
listen() {
|
|
fromEvent(document, 'keyup')
|
|
.pipe(
|
|
takeUntil(this.destroy$),
|
|
debounceTime(150),
|
|
filter(
|
|
/**
|
|
* @param {?} key
|
|
* @return {?}
|
|
*/
|
|
key => key && key.code === 'Escape',
|
|
),
|
|
)
|
|
.subscribe(
|
|
/**
|
|
* @param {?} _
|
|
* @return {?}
|
|
*/
|
|
_ => {
|
|
this.close();
|
|
},
|
|
);
|
|
setTimeout(
|
|
/**
|
|
* @return {?}
|
|
*/
|
|
() => {
|
|
if (!this.abpClose) return;
|
|
fromEvent(this.abpClose.nativeElement, 'click')
|
|
.pipe(
|
|
takeUntil(this.destroy$),
|
|
filter(
|
|
/**
|
|
* @return {?}
|
|
*/
|
|
() => !!this.modalContent,
|
|
),
|
|
)
|
|
.subscribe(
|
|
/**
|
|
* @return {?}
|
|
*/
|
|
() => this.close(),
|
|
);
|
|
},
|
|
0,
|
|
);
|
|
this.init.emit();
|
|
}
|
|
}
|
|
ModalComponent.decorators = [
|
|
{
|
|
type: Component,
|
|
args: [
|
|
{
|
|
selector: 'abp-modal',
|
|
template:
|
|
'<ng-container *ngIf="visible">\n <div class="modal show {{ modalClass }}" tabindex="-1" role="dialog">\n <div class="modal-backdrop" [@fade]="isModalOpen" (click)="close()"></div>\n <div\n id="abp-modal-dialog"\n class="modal-dialog modal-{{ size }}"\n role="document"\n [@dialog]="isModalOpen"\n #abpModalContent\n >\n <div id="abp-modal-content" class="modal-content">\n <div id="abp-modal-header" class="modal-header">\n <ng-container *ngTemplateOutlet="abpHeader"></ng-container>\n \u200B\n <button id="abp-modal-close-button" type="button" class="close" aria-label="Close" (click)="close()">\n <span aria-hidden="true">×</span>\n </button>\n </div>\n <div id="abp-modal-body" class="modal-body">\n <ng-container *ngTemplateOutlet="abpBody"></ng-container>\n </div>\n <div id="abp-modal-footer" class="modal-footer">\n <ng-container *ngTemplateOutlet="abpFooter"></ng-container>\n </div>\n </div>\n </div>\n <ng-content></ng-content>\n </div>\n</ng-container>\n',
|
|
animations: [fadeAnimation, dialogAnimation],
|
|
},
|
|
],
|
|
},
|
|
];
|
|
/** @nocollapse */
|
|
ModalComponent.ctorParameters = () => [{ type: Renderer2 }, { type: ConfirmationService }];
|
|
ModalComponent.propDecorators = {
|
|
visible: [{ type: Input }],
|
|
busy: [{ type: Input }],
|
|
centered: [{ type: Input }],
|
|
modalClass: [{ type: Input }],
|
|
size: [{ type: Input }],
|
|
abpSubmit: [{ type: ContentChild, args: [ButtonComponent, { static: false, read: ButtonComponent }] }],
|
|
abpHeader: [{ type: ContentChild, args: ['abpHeader', { static: false }] }],
|
|
abpBody: [{ type: ContentChild, args: ['abpBody', { static: false }] }],
|
|
abpFooter: [{ type: ContentChild, args: ['abpFooter', { static: false }] }],
|
|
abpClose: [{ type: ContentChild, args: ['abpClose', { static: false, read: ElementRef }] }],
|
|
modalContent: [{ type: ViewChild, args: ['abpModalContent', { static: false }] }],
|
|
abpButtons: [{ type: ViewChildren, args: ['abp-button'] }],
|
|
visibleChange: [{ type: Output }],
|
|
init: [{ type: Output }],
|
|
appear: [{ type: Output }],
|
|
disappear: [{ type: Output }],
|
|
};
|
|
if (false) {
|
|
/** @type {?} */
|
|
ModalComponent.prototype.centered;
|
|
/** @type {?} */
|
|
ModalComponent.prototype.modalClass;
|
|
/** @type {?} */
|
|
ModalComponent.prototype.size;
|
|
/** @type {?} */
|
|
ModalComponent.prototype.abpSubmit;
|
|
/** @type {?} */
|
|
ModalComponent.prototype.abpHeader;
|
|
/** @type {?} */
|
|
ModalComponent.prototype.abpBody;
|
|
/** @type {?} */
|
|
ModalComponent.prototype.abpFooter;
|
|
/** @type {?} */
|
|
ModalComponent.prototype.abpClose;
|
|
/** @type {?} */
|
|
ModalComponent.prototype.modalContent;
|
|
/** @type {?} */
|
|
ModalComponent.prototype.abpButtons;
|
|
/** @type {?} */
|
|
ModalComponent.prototype.visibleChange;
|
|
/** @type {?} */
|
|
ModalComponent.prototype.init;
|
|
/** @type {?} */
|
|
ModalComponent.prototype.appear;
|
|
/** @type {?} */
|
|
ModalComponent.prototype.disappear;
|
|
/** @type {?} */
|
|
ModalComponent.prototype._visible;
|
|
/** @type {?} */
|
|
ModalComponent.prototype._busy;
|
|
/** @type {?} */
|
|
ModalComponent.prototype.isModalOpen;
|
|
/** @type {?} */
|
|
ModalComponent.prototype.isConfirmationOpen;
|
|
/** @type {?} */
|
|
ModalComponent.prototype.destroy$;
|
|
/**
|
|
* @type {?}
|
|
* @private
|
|
*/
|
|
ModalComponent.prototype.renderer;
|
|
/**
|
|
* @type {?}
|
|
* @private
|
|
*/
|
|
ModalComponent.prototype.confirmationService;
|
|
}
|
|
/**
|
|
* @param {?} nodes
|
|
* @return {?}
|
|
*/
|
|
function getFlatNodes(nodes) {
|
|
return Array.from(nodes).reduce(
|
|
/**
|
|
* @param {?} acc
|
|
* @param {?} val
|
|
* @return {?}
|
|
*/
|
|
(acc, val) => [...acc, ...(val.childNodes && val.childNodes.length ? getFlatNodes(val.childNodes) : [val])],
|
|
[],
|
|
);
|
|
}
|
|
/**
|
|
* @param {?} nodes
|
|
* @return {?}
|
|
*/
|
|
function hasNgDirty(nodes) {
|
|
return (
|
|
nodes.findIndex(
|
|
/**
|
|
* @param {?} node
|
|
* @return {?}
|
|
*/
|
|
node => (node.className || '').indexOf('ng-dirty') > -1,
|
|
) > -1
|
|
);
|
|
}
|
|
|
|
/**
|
|
* @fileoverview added by tsickle
|
|
* @suppress {checkTypes,constantProperty,extraRequire,missingOverride,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
|
|
*/
|
|
const { maxLength, required: required$1, email } = Validators;
|
|
class ProfileComponent {
|
|
/**
|
|
* @param {?} fb
|
|
* @param {?} store
|
|
*/
|
|
constructor(fb, store) {
|
|
this.fb = fb;
|
|
this.store = store;
|
|
this.visibleChange = new EventEmitter();
|
|
this.modalBusy = false;
|
|
}
|
|
/**
|
|
* @return {?}
|
|
*/
|
|
get visible() {
|
|
return this._visible;
|
|
}
|
|
/**
|
|
* @param {?} value
|
|
* @return {?}
|
|
*/
|
|
set visible(value) {
|
|
this._visible = value;
|
|
this.visibleChange.emit(value);
|
|
}
|
|
/**
|
|
* @return {?}
|
|
*/
|
|
buildForm() {
|
|
this.store
|
|
.dispatch(new GetProfile())
|
|
.pipe(
|
|
withLatestFrom(this.profile$),
|
|
take(1),
|
|
)
|
|
.subscribe(
|
|
/**
|
|
* @param {?} __0
|
|
* @return {?}
|
|
*/
|
|
([, profile]) => {
|
|
this.form = this.fb.group({
|
|
userName: [profile.userName, [required$1, maxLength(256)]],
|
|
email: [profile.email, [required$1, email, maxLength(256)]],
|
|
name: [profile.name || '', [maxLength(64)]],
|
|
surname: [profile.surname || '', [maxLength(64)]],
|
|
phoneNumber: [profile.phoneNumber || '', [maxLength(16)]],
|
|
});
|
|
},
|
|
);
|
|
}
|
|
/**
|
|
* @return {?}
|
|
*/
|
|
submit() {
|
|
if (this.form.invalid) return;
|
|
this.modalBusy = true;
|
|
this.store.dispatch(new UpdateProfile(this.form.value)).subscribe(
|
|
/**
|
|
* @return {?}
|
|
*/
|
|
() => {
|
|
this.modalBusy = false;
|
|
this.visible = false;
|
|
this.form.reset();
|
|
},
|
|
);
|
|
}
|
|
/**
|
|
* @return {?}
|
|
*/
|
|
openModal() {
|
|
this.buildForm();
|
|
this.visible = true;
|
|
}
|
|
/**
|
|
* @param {?} __0
|
|
* @return {?}
|
|
*/
|
|
ngOnChanges({ visible }) {
|
|
if (!visible) return;
|
|
if (visible.currentValue) {
|
|
this.openModal();
|
|
} else if (visible.currentValue === false && this.visible) {
|
|
this.visible = false;
|
|
}
|
|
}
|
|
}
|
|
ProfileComponent.decorators = [
|
|
{
|
|
type: Component,
|
|
args: [
|
|
{
|
|
selector: 'abp-profile',
|
|
template:
|
|
'<abp-modal [(visible)]="visible" [busy]="modalBusy">\n <ng-template #abpHeader>\n <h4>{{ \'AbpIdentity::PersonalInfo\' | abpLocalization }}</h4>\n </ng-template>\n <ng-template #abpBody>\n <form novalidate *ngIf="form" [formGroup]="form" (ngSubmit)="submit()">\n <div class="form-group">\n <label for="username">{{ \'AbpIdentity::DisplayName:UserName\' | abpLocalization }}</label\n ><span> * </span><input type="text" id="username" class="form-control" formControlName="userName" autofocus />\n </div>\n <div class="row">\n <div class="col col-md-6">\n <div class="form-group">\n <label for="name">{{ \'AbpIdentity::DisplayName:Name\' | abpLocalization }}</label\n ><input type="text" id="name" class="form-control" formControlName="name" />\n </div>\n </div>\n <div class="col col-md-6">\n <div class="form-group">\n <label for="surname">{{ \'AbpIdentity::DisplayName:Surname\' | abpLocalization }}</label\n ><input type="text" id="surname" class="form-control" formControlName="surname" />\n </div>\n </div>\n </div>\n <div class="form-group">\n <label for="email-address">{{ \'AbpIdentity::DisplayName:Email\' | abpLocalization }}</label\n ><span> * </span><input type="text" id="email-address" class="form-control" formControlName="email" />\n </div>\n <div class="form-group">\n <label for="phone-number">{{ \'AbpIdentity::DisplayName:PhoneNumber\' | abpLocalization }}</label\n ><input type="text" id="phone-number" class="form-control" formControlName="phoneNumber" />\n </div>\n </form>\n </ng-template>\n <ng-template #abpFooter>\n <button #abpClose type="button" class="btn btn-secondary color-white">\n {{ \'AbpIdentity::Cancel\' | abpLocalization }}\n </button>\n <abp-button iconClass="fa fa-check" buttonClass="btn btn-primary color-white" (click)="submit()">{{ \'AbpIdentity::Save\' | abpLocalization }}</abp-button>\n </ng-template>\n</abp-modal>\n',
|
|
},
|
|
],
|
|
},
|
|
];
|
|
/** @nocollapse */
|
|
ProfileComponent.ctorParameters = () => [{ type: FormBuilder }, { type: Store }];
|
|
ProfileComponent.propDecorators = {
|
|
visible: [{ type: Input }],
|
|
visibleChange: [{ type: Output }],
|
|
};
|
|
__decorate(
|
|
[Select(ProfileState.getProfile), __metadata('design:type', Observable)],
|
|
ProfileComponent.prototype,
|
|
'profile$',
|
|
void 0,
|
|
);
|
|
if (false) {
|
|
/**
|
|
* @type {?}
|
|
* @protected
|
|
*/
|
|
ProfileComponent.prototype._visible;
|
|
/** @type {?} */
|
|
ProfileComponent.prototype.visibleChange;
|
|
/** @type {?} */
|
|
ProfileComponent.prototype.profile$;
|
|
/** @type {?} */
|
|
ProfileComponent.prototype.form;
|
|
/** @type {?} */
|
|
ProfileComponent.prototype.modalBusy;
|
|
/**
|
|
* @type {?}
|
|
* @private
|
|
*/
|
|
ProfileComponent.prototype.fb;
|
|
/**
|
|
* @type {?}
|
|
* @private
|
|
*/
|
|
ProfileComponent.prototype.store;
|
|
}
|
|
|
|
/**
|
|
* @fileoverview added by tsickle
|
|
* @suppress {checkTypes,constantProperty,extraRequire,missingOverride,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
|
|
*/
|
|
class ToastComponent {}
|
|
ToastComponent.decorators = [
|
|
{
|
|
type: Component,
|
|
args: [
|
|
{
|
|
selector: 'abp-toast',
|
|
// tslint:disable-next-line: component-max-inline-declarations
|
|
template: `
|
|
<p-toast position="bottom-right" key="abpToast" styleClass="abp-toast" [baseZIndex]="1000">
|
|
<ng-template let-message pTemplate="message">
|
|
<span
|
|
class="ui-toast-icon pi"
|
|
[ngClass]="{
|
|
'pi-info-circle': message.severity == 'info',
|
|
'pi-exclamation-triangle': message.severity == 'warn',
|
|
'pi-times': message.severity == 'error',
|
|
'pi-check': message.severity == 'success'
|
|
}"
|
|
></span>
|
|
<div class="ui-toast-message-text-content">
|
|
<div class="ui-toast-summary">{{ message.summary | abpLocalization: message.titleLocalizationParams }}</div>
|
|
<div class="ui-toast-detail">{{ message.detail | abpLocalization: message.messageLocalizationParams }}</div>
|
|
</div>
|
|
</ng-template>
|
|
</p-toast>
|
|
`,
|
|
},
|
|
],
|
|
},
|
|
];
|
|
|
|
/**
|
|
* @fileoverview added by tsickle
|
|
* @suppress {checkTypes,constantProperty,extraRequire,missingOverride,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
|
|
*/
|
|
class SortOrderIconComponent {
|
|
constructor() {
|
|
this.selectedKeyChange = new EventEmitter();
|
|
this.orderChange = new EventEmitter();
|
|
}
|
|
/**
|
|
* @param {?} value
|
|
* @return {?}
|
|
*/
|
|
set selectedKey(value) {
|
|
this._selectedKey = value;
|
|
this.selectedKeyChange.emit(value);
|
|
}
|
|
/**
|
|
* @return {?}
|
|
*/
|
|
get selectedKey() {
|
|
return this._selectedKey;
|
|
}
|
|
/**
|
|
* @param {?} value
|
|
* @return {?}
|
|
*/
|
|
set order(value) {
|
|
this._order = value;
|
|
this.orderChange.emit(value);
|
|
}
|
|
/**
|
|
* @return {?}
|
|
*/
|
|
get order() {
|
|
return this._order;
|
|
}
|
|
/**
|
|
* @return {?}
|
|
*/
|
|
get icon() {
|
|
if (!this.selectedKey) return 'fa-sort';
|
|
if (this.selectedKey === this.key) return `fa-sort-${this.order}`;
|
|
else return '';
|
|
}
|
|
/**
|
|
* @param {?} key
|
|
* @return {?}
|
|
*/
|
|
sort(key) {
|
|
this.selectedKey = key;
|
|
switch (this.order) {
|
|
case '':
|
|
this.order = 'asc';
|
|
break;
|
|
case 'asc':
|
|
this.order = 'desc';
|
|
this.orderChange.emit('desc');
|
|
break;
|
|
case 'desc':
|
|
this.order = '';
|
|
this.selectedKey = '';
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
SortOrderIconComponent.decorators = [
|
|
{
|
|
type: Component,
|
|
args: [
|
|
{
|
|
selector: 'abp-sort-order-icon',
|
|
template: '<span class="float-right {{ iconClass }}">\n <i class="fa {{ icon }}"></i>\n</span>\n',
|
|
},
|
|
],
|
|
},
|
|
];
|
|
SortOrderIconComponent.propDecorators = {
|
|
selectedKey: [{ type: Input }],
|
|
selectedKeyChange: [{ type: Output }],
|
|
key: [{ type: Input }],
|
|
order: [{ type: Input }],
|
|
orderChange: [{ type: Output }],
|
|
iconClass: [{ type: Input }],
|
|
};
|
|
if (false) {
|
|
/**
|
|
* @type {?}
|
|
* @private
|
|
*/
|
|
SortOrderIconComponent.prototype._order;
|
|
/**
|
|
* @type {?}
|
|
* @private
|
|
*/
|
|
SortOrderIconComponent.prototype._selectedKey;
|
|
/** @type {?} */
|
|
SortOrderIconComponent.prototype.selectedKeyChange;
|
|
/** @type {?} */
|
|
SortOrderIconComponent.prototype.key;
|
|
/** @type {?} */
|
|
SortOrderIconComponent.prototype.orderChange;
|
|
/** @type {?} */
|
|
SortOrderIconComponent.prototype.iconClass;
|
|
}
|
|
|
|
/**
|
|
* @fileoverview added by tsickle
|
|
* @suppress {checkTypes,constantProperty,extraRequire,missingOverride,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
|
|
*/
|
|
var styles = `
|
|
.is-invalid .form-control {
|
|
border-color: #dc3545;
|
|
border-style: solid !important;
|
|
}
|
|
|
|
.is-invalid .invalid-feedback,
|
|
.is-invalid + * .invalid-feedback {
|
|
display: block;
|
|
}
|
|
|
|
.data-tables-filter {
|
|
text-align: right;
|
|
}
|
|
|
|
.pointer {
|
|
cursor: pointer;
|
|
}
|
|
|
|
.navbar .dropdown-submenu a::after {
|
|
transform: rotate(-90deg);
|
|
position: absolute;
|
|
right: 16px;
|
|
top: 18px;
|
|
}
|
|
|
|
.navbar .dropdown-menu {
|
|
min-width: 215px;
|
|
}
|
|
|
|
.ui-table-scrollable-body::-webkit-scrollbar {
|
|
height: 5px !important;
|
|
}
|
|
|
|
.ui-table-scrollable-body::-webkit-scrollbar-track {
|
|
background: #ddd;
|
|
}
|
|
|
|
.ui-table-scrollable-body::-webkit-scrollbar-thumb {
|
|
background: #8a8686;
|
|
}
|
|
|
|
.modal.show {
|
|
display: block !important;
|
|
}
|
|
|
|
.modal-backdrop {
|
|
position: absolute !important;
|
|
top: 0 !important;
|
|
left: 0 !important;
|
|
width: 100% !important;
|
|
height: 100% !important;
|
|
background-color: rgba(0, 0, 0, 0.6) !important;
|
|
z-index: 1040 !important;
|
|
}
|
|
|
|
.modal-dialog {
|
|
z-index: 1050 !important;
|
|
}
|
|
|
|
.abp-ellipsis-inline {
|
|
display: inline-block;
|
|
overflow: hidden;
|
|
text-overflow: ellipsis;
|
|
white-space: nowrap;
|
|
}
|
|
|
|
.abp-ellipsis {
|
|
overflow: hidden !important;
|
|
text-overflow: ellipsis;
|
|
white-space: nowrap;
|
|
}
|
|
|
|
.abp-toast .ui-toast-message {
|
|
box-sizing: border-box !important;
|
|
border: 2px solid transparent !important;
|
|
border-radius: 4px !important;
|
|
background-color: #f4f4f7 !important;
|
|
color: #1b1d29 !important;
|
|
}
|
|
|
|
.abp-toast .ui-toast-message-content {
|
|
padding: 10px !important;
|
|
}
|
|
|
|
.abp-toast .ui-toast-message-content .ui-toast-icon {
|
|
top: 0 !important;
|
|
left: 0 !important;
|
|
padding: 10px !important;
|
|
}
|
|
|
|
.abp-toast .ui-toast-summary {
|
|
margin: 0 !important;
|
|
font-weight: 700 !important;
|
|
}
|
|
|
|
.abp-toast .ui-toast-message.ui-toast-message-error {
|
|
border-color: #ba1659 !important;
|
|
}
|
|
|
|
.abp-toast .ui-toast-message.ui-toast-message-error .ui-toast-message-content .ui-toast-icon {
|
|
color: #ba1659 !important;
|
|
}
|
|
|
|
.abp-toast .ui-toast-message.ui-toast-message-warning {
|
|
border-color: #ed5d98 !important;
|
|
}
|
|
|
|
.abp-toast .ui-toast-message.ui-toast-message-warning .ui-toast-message-content .ui-toast-icon {
|
|
color: #ed5d98 !important;
|
|
}
|
|
|
|
.abp-toast .ui-toast-message.ui-toast-message-success {
|
|
border-color: #1c9174 !important;
|
|
}
|
|
|
|
.abp-toast .ui-toast-message.ui-toast-message-success .ui-toast-message-content .ui-toast-icon {
|
|
color: #1c9174 !important;
|
|
}
|
|
|
|
.abp-toast .ui-toast-message.ui-toast-message-info {
|
|
border-color: #fccb31 !important;
|
|
}
|
|
|
|
.abp-toast .ui-toast-message.ui-toast-message-info .ui-toast-message-content .ui-toast-icon {
|
|
color: #fccb31 !important;
|
|
}
|
|
|
|
.abp-confirm .ui-toast-message {
|
|
box-sizing: border-box !important;
|
|
padding: 0px !important;
|
|
border:0 none !important;
|
|
border-radius: 4px !important;
|
|
background-color: #fff !important;
|
|
color: rgba(0, 0, 0, .65) !important;
|
|
font-family: "Poppins", sans-serif;
|
|
text-align: center !important;
|
|
}
|
|
|
|
.abp-confirm .ui-toast-message-content {
|
|
padding: 0px !important;
|
|
}
|
|
|
|
.abp-confirm .abp-confirm-icon {
|
|
margin: 32px 50px 5px !important;
|
|
color: #f8bb86 !important;
|
|
font-size: 52px !important;
|
|
}
|
|
|
|
.abp-confirm .ui-toast-close-icon {
|
|
display: none !important;
|
|
}
|
|
|
|
.abp-confirm .abp-confirm-summary {
|
|
display: block !important;
|
|
margin-bottom: 13px !important;
|
|
padding: 13px 16px 0px !important;
|
|
font-weight: 600 !important;
|
|
font-size: 18px !important;
|
|
}
|
|
|
|
.abp-confirm .abp-confirm-body {
|
|
display: inline-block !important;
|
|
padding: 0px 10px !important;
|
|
}
|
|
|
|
.abp-confirm .abp-confirm-footer {
|
|
display: block !important;
|
|
margin-top: 30px !important;
|
|
padding: 16px !important;
|
|
background-color: #f4f4f7 !important;
|
|
text-align: right !important;
|
|
}
|
|
|
|
.abp-confirm .abp-confirm-footer .btn {
|
|
margin-left: 10px !important;
|
|
}
|
|
|
|
.ui-widget-overlay {
|
|
z-index: 1000;
|
|
}
|
|
|
|
.color-white {
|
|
color: #FFF !important;
|
|
}
|
|
|
|
/* <animations */
|
|
|
|
.fade-in-top {
|
|
animation: fadeInTop 0.2s ease-in-out;
|
|
}
|
|
|
|
.fade-out-top {
|
|
animation: fadeOutTop 0.2s ease-in-out;
|
|
}
|
|
|
|
.abp-collapsed {
|
|
-moz-transition: margin ease-in-out 0.5s;
|
|
-ms-transition: margin ease-in-out 0.5s;
|
|
-o-transition: margin ease-in-out 0.5s;
|
|
-webkit-transition: margin ease-in-out 0.5s;
|
|
transition: margin ease-in-out 0.5s;
|
|
margin-top: -100%;
|
|
}
|
|
|
|
.abp-collapsed.expanded {
|
|
margin-top: 0 !important;
|
|
}
|
|
|
|
@keyframes fadeInTop {
|
|
from {
|
|
transform: translateY(-5px);
|
|
opacity: 0;
|
|
}
|
|
|
|
to {
|
|
transform: translateY(0px);
|
|
opacity: 1;
|
|
}
|
|
}
|
|
|
|
@keyframes fadeOutTop {
|
|
to {
|
|
transform: translateY(-5px);
|
|
opacity: 0;
|
|
}
|
|
}
|
|
|
|
/* </animations */
|
|
|
|
`;
|
|
|
|
/**
|
|
* @fileoverview added by tsickle
|
|
* @suppress {checkTypes,constantProperty,extraRequire,missingOverride,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
|
|
*/
|
|
/** @type {?} */
|
|
const DEFAULT_ERROR_MESSAGES = {
|
|
defaultError: {
|
|
title: 'An error has occurred!',
|
|
details: 'Error detail not sent by server.',
|
|
},
|
|
defaultError401: {
|
|
title: 'You are not authenticated!',
|
|
details: 'You should be authenticated (sign in) in order to perform this operation.',
|
|
},
|
|
defaultError403: {
|
|
title: 'You are not authorized!',
|
|
details: 'You are not allowed to perform this operation.',
|
|
},
|
|
defaultError404: {
|
|
title: 'Resource not found!',
|
|
details: 'The resource requested could not found on the server.',
|
|
},
|
|
defaultError500: {
|
|
title: '500',
|
|
details: { key: 'AbpAccount::InternalServerErrorMessage', defaultValue: 'Error detail not sent by server.' },
|
|
},
|
|
defaultErrorUnknown: {
|
|
title: 'Unknown Error',
|
|
details: { key: 'AbpAccount::InternalServerErrorMessage', defaultValue: 'Error detail not sent by server.' },
|
|
},
|
|
};
|
|
class ErrorHandler {
|
|
/**
|
|
* @param {?} actions
|
|
* @param {?} router
|
|
* @param {?} ngZone
|
|
* @param {?} store
|
|
* @param {?} confirmationService
|
|
* @param {?} appRef
|
|
* @param {?} cfRes
|
|
* @param {?} rendererFactory
|
|
* @param {?} injector
|
|
*/
|
|
constructor(actions, router, ngZone, store, confirmationService, appRef, cfRes, rendererFactory, injector) {
|
|
this.actions = actions;
|
|
this.router = router;
|
|
this.ngZone = ngZone;
|
|
this.store = store;
|
|
this.confirmationService = confirmationService;
|
|
this.appRef = appRef;
|
|
this.cfRes = cfRes;
|
|
this.rendererFactory = rendererFactory;
|
|
this.injector = injector;
|
|
actions.pipe(ofActionSuccessful(RestOccurError)).subscribe(
|
|
/**
|
|
* @param {?} res
|
|
* @return {?}
|
|
*/
|
|
res => {
|
|
const { payload: err = /** @type {?} */ ({}) } = res;
|
|
/** @type {?} */
|
|
const body = snq(
|
|
/**
|
|
* @return {?}
|
|
*/
|
|
(() => /** @type {?} */ (err).error.error),
|
|
DEFAULT_ERROR_MESSAGES.defaultError.title,
|
|
);
|
|
if (err instanceof HttpErrorResponse && err.headers.get('_AbpErrorFormat')) {
|
|
/** @type {?} */
|
|
const confirmation$ = this.showError(null, null, body);
|
|
if (err.status === 401) {
|
|
confirmation$.subscribe(
|
|
/**
|
|
* @return {?}
|
|
*/
|
|
() => {
|
|
this.navigateToLogin();
|
|
},
|
|
);
|
|
}
|
|
} else {
|
|
switch (/** @type {?} */ (err).status) {
|
|
case 401:
|
|
this.showError(
|
|
DEFAULT_ERROR_MESSAGES.defaultError401.details,
|
|
DEFAULT_ERROR_MESSAGES.defaultError401.title,
|
|
).subscribe(
|
|
/**
|
|
* @return {?}
|
|
*/
|
|
() => this.navigateToLogin(),
|
|
);
|
|
break;
|
|
case 403:
|
|
this.createErrorComponent({
|
|
title: DEFAULT_ERROR_MESSAGES.defaultError403.title,
|
|
details: DEFAULT_ERROR_MESSAGES.defaultError403.details,
|
|
});
|
|
break;
|
|
case 404:
|
|
this.showError(
|
|
DEFAULT_ERROR_MESSAGES.defaultError404.details,
|
|
DEFAULT_ERROR_MESSAGES.defaultError404.title,
|
|
);
|
|
break;
|
|
case 500:
|
|
this.createErrorComponent({
|
|
title: DEFAULT_ERROR_MESSAGES.defaultError500.title,
|
|
details: DEFAULT_ERROR_MESSAGES.defaultError500.details,
|
|
});
|
|
break;
|
|
case 0:
|
|
if (/** @type {?} */ (err).statusText === 'Unknown Error') {
|
|
this.createErrorComponent({
|
|
title: DEFAULT_ERROR_MESSAGES.defaultErrorUnknown.title,
|
|
details: DEFAULT_ERROR_MESSAGES.defaultErrorUnknown.details,
|
|
});
|
|
}
|
|
break;
|
|
default:
|
|
this.showError(DEFAULT_ERROR_MESSAGES.defaultError.details, DEFAULT_ERROR_MESSAGES.defaultError.title);
|
|
break;
|
|
}
|
|
}
|
|
},
|
|
);
|
|
}
|
|
/**
|
|
* @private
|
|
* @param {?=} message
|
|
* @param {?=} title
|
|
* @param {?=} body
|
|
* @return {?}
|
|
*/
|
|
showError(message, title, body) {
|
|
if (body) {
|
|
if (body.details) {
|
|
message = body.details;
|
|
title = body.message;
|
|
} else {
|
|
message = body.message || DEFAULT_ERROR_MESSAGES.defaultError.title;
|
|
}
|
|
}
|
|
return this.confirmationService.error(message, title, {
|
|
hideCancelBtn: true,
|
|
yesCopy: 'OK',
|
|
});
|
|
}
|
|
/**
|
|
* @private
|
|
* @return {?}
|
|
*/
|
|
navigateToLogin() {
|
|
this.ngZone.run(
|
|
/**
|
|
* @return {?}
|
|
*/
|
|
() => {
|
|
this.router.navigate(['/account/login'], {
|
|
state: { redirectUrl: this.router.url },
|
|
});
|
|
},
|
|
);
|
|
}
|
|
/**
|
|
* @param {?} instance
|
|
* @return {?}
|
|
*/
|
|
createErrorComponent(instance) {
|
|
/** @type {?} */
|
|
const renderer = this.rendererFactory.createRenderer(null, null);
|
|
/** @type {?} */
|
|
const host = renderer.selectRootElement(document.body, true);
|
|
/** @type {?} */
|
|
const componentRef = this.cfRes.resolveComponentFactory(ErrorComponent).create(this.injector);
|
|
for (const key in componentRef.instance) {
|
|
if (componentRef.instance.hasOwnProperty(key)) {
|
|
componentRef.instance[key] = instance[key];
|
|
}
|
|
}
|
|
this.appRef.attachView(componentRef.hostView);
|
|
renderer.appendChild(host, /** @type {?} */ (componentRef.hostView).rootNodes[0]);
|
|
componentRef.instance.renderer = renderer;
|
|
componentRef.instance.elementRef = componentRef.location;
|
|
componentRef.instance.host = host;
|
|
}
|
|
}
|
|
ErrorHandler.decorators = [{ type: Injectable, args: [{ providedIn: 'root' }] }];
|
|
/** @nocollapse */
|
|
ErrorHandler.ctorParameters = () => [
|
|
{ type: Actions },
|
|
{ type: Router },
|
|
{ type: NgZone },
|
|
{ type: Store },
|
|
{ type: ConfirmationService },
|
|
{ type: ApplicationRef },
|
|
{ type: ComponentFactoryResolver },
|
|
{ type: RendererFactory2 },
|
|
{ type: Injector },
|
|
];
|
|
/** @nocollapse */ ErrorHandler.ngInjectableDef = ɵɵdefineInjectable({
|
|
factory: function ErrorHandler_Factory() {
|
|
return new ErrorHandler(
|
|
ɵɵinject(Actions),
|
|
ɵɵinject(Router),
|
|
ɵɵinject(NgZone),
|
|
ɵɵinject(Store),
|
|
ɵɵinject(ConfirmationService),
|
|
ɵɵinject(ApplicationRef),
|
|
ɵɵinject(ComponentFactoryResolver),
|
|
ɵɵinject(RendererFactory2),
|
|
ɵɵinject(INJECTOR),
|
|
);
|
|
},
|
|
token: ErrorHandler,
|
|
providedIn: 'root',
|
|
});
|
|
if (false) {
|
|
/**
|
|
* @type {?}
|
|
* @private
|
|
*/
|
|
ErrorHandler.prototype.actions;
|
|
/**
|
|
* @type {?}
|
|
* @private
|
|
*/
|
|
ErrorHandler.prototype.router;
|
|
/**
|
|
* @type {?}
|
|
* @private
|
|
*/
|
|
ErrorHandler.prototype.ngZone;
|
|
/**
|
|
* @type {?}
|
|
* @private
|
|
*/
|
|
ErrorHandler.prototype.store;
|
|
/**
|
|
* @type {?}
|
|
* @private
|
|
*/
|
|
ErrorHandler.prototype.confirmationService;
|
|
/**
|
|
* @type {?}
|
|
* @private
|
|
*/
|
|
ErrorHandler.prototype.appRef;
|
|
/**
|
|
* @type {?}
|
|
* @private
|
|
*/
|
|
ErrorHandler.prototype.cfRes;
|
|
/**
|
|
* @type {?}
|
|
* @private
|
|
*/
|
|
ErrorHandler.prototype.rendererFactory;
|
|
/**
|
|
* @type {?}
|
|
* @private
|
|
*/
|
|
ErrorHandler.prototype.injector;
|
|
}
|
|
|
|
/**
|
|
* @fileoverview added by tsickle
|
|
* @suppress {checkTypes,constantProperty,extraRequire,missingOverride,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
|
|
*/
|
|
class TableEmptyMessageComponent {
|
|
constructor() {
|
|
this.colspan = 2;
|
|
this.localizationResource = 'AbpAccount';
|
|
this.localizationProp = 'NoDataAvailableInDatatable';
|
|
}
|
|
/**
|
|
* @return {?}
|
|
*/
|
|
get emptyMessage() {
|
|
return this.message || `${this.localizationResource}::${this.localizationProp}`;
|
|
}
|
|
}
|
|
TableEmptyMessageComponent.decorators = [
|
|
{
|
|
type: Component,
|
|
args: [
|
|
{
|
|
// tslint:disable-next-line: component-selector
|
|
selector: '[abp-table-empty-message]',
|
|
template: `
|
|
<td class="text-center" [attr.colspan]="colspan">
|
|
{{ emptyMessage | abpLocalization }}
|
|
</td>
|
|
`,
|
|
},
|
|
],
|
|
},
|
|
];
|
|
TableEmptyMessageComponent.propDecorators = {
|
|
colspan: [{ type: Input }],
|
|
message: [{ type: Input }],
|
|
localizationResource: [{ type: Input }],
|
|
localizationProp: [{ type: Input }],
|
|
};
|
|
if (false) {
|
|
/** @type {?} */
|
|
TableEmptyMessageComponent.prototype.colspan;
|
|
/** @type {?} */
|
|
TableEmptyMessageComponent.prototype.message;
|
|
/** @type {?} */
|
|
TableEmptyMessageComponent.prototype.localizationResource;
|
|
/** @type {?} */
|
|
TableEmptyMessageComponent.prototype.localizationProp;
|
|
}
|
|
|
|
/**
|
|
* @fileoverview added by tsickle
|
|
* @suppress {checkTypes,constantProperty,extraRequire,missingOverride,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
|
|
*/
|
|
/**
|
|
* @param {?} injector
|
|
* @return {?}
|
|
*/
|
|
function appendScript(injector) {
|
|
/** @type {?} */
|
|
const fn
|
|
/**
|
|
* @return {?}
|
|
*/ = (() => {
|
|
import('chart.js').then(
|
|
/**
|
|
* @return {?}
|
|
*/
|
|
() => chartJsLoaded$.next(true),
|
|
);
|
|
/** @type {?} */
|
|
const lazyLoadService = injector.get(LazyLoadService);
|
|
return forkJoin(
|
|
lazyLoadService.load(
|
|
null,
|
|
'style',
|
|
styles,
|
|
'head',
|
|
'afterbegin',
|
|
) /* lazyLoadService.load(null, 'script', scripts) */,
|
|
).toPromise();
|
|
});
|
|
return fn;
|
|
}
|
|
class ThemeSharedModule {
|
|
/**
|
|
* @return {?}
|
|
*/
|
|
static forRoot() {
|
|
return {
|
|
ngModule: ThemeSharedModule,
|
|
providers: [
|
|
{
|
|
provide: APP_INITIALIZER,
|
|
multi: true,
|
|
deps: [Injector, ErrorHandler],
|
|
useFactory: appendScript,
|
|
},
|
|
{ provide: MessageService, useClass: MessageService },
|
|
],
|
|
};
|
|
}
|
|
}
|
|
ThemeSharedModule.decorators = [
|
|
{
|
|
type: NgModule,
|
|
args: [
|
|
{
|
|
imports: [CoreModule, ToastModule, NgxValidateCoreModule],
|
|
declarations: [
|
|
BreadcrumbComponent,
|
|
ButtonComponent,
|
|
ChangePasswordComponent,
|
|
ChartComponent,
|
|
ConfirmationComponent,
|
|
ErrorComponent,
|
|
LoaderBarComponent,
|
|
ModalComponent,
|
|
ProfileComponent,
|
|
TableEmptyMessageComponent,
|
|
ToastComponent,
|
|
SortOrderIconComponent,
|
|
],
|
|
exports: [
|
|
BreadcrumbComponent,
|
|
ButtonComponent,
|
|
ChangePasswordComponent,
|
|
ChartComponent,
|
|
ConfirmationComponent,
|
|
LoaderBarComponent,
|
|
ModalComponent,
|
|
ProfileComponent,
|
|
TableEmptyMessageComponent,
|
|
ToastComponent,
|
|
SortOrderIconComponent,
|
|
],
|
|
entryComponents: [ErrorComponent],
|
|
},
|
|
],
|
|
},
|
|
];
|
|
|
|
/**
|
|
* @fileoverview added by tsickle
|
|
* @suppress {checkTypes,constantProperty,extraRequire,missingOverride,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
|
|
*/
|
|
/** @type {?} */
|
|
const bounceIn = animation(
|
|
[
|
|
style({ opacity: '0', display: '{{ display }}' }),
|
|
animate(
|
|
'{{ time}} {{ easing }}',
|
|
keyframes([
|
|
style({ opacity: '0', transform: '{{ transform }} scale(0.0)', offset: 0 }),
|
|
style({ opacity: '0', transform: '{{ transform }} scale(0.8)', offset: 0.5 }),
|
|
style({ opacity: '1', transform: '{{ transform }} scale(1.0)', offset: 1 }),
|
|
]),
|
|
),
|
|
],
|
|
{
|
|
params: {
|
|
time: '350ms',
|
|
easing: 'cubic-bezier(.7,.31,.72,1.47)',
|
|
display: 'block',
|
|
transform: 'translate(-50%, -50%)',
|
|
},
|
|
},
|
|
);
|
|
|
|
/**
|
|
* @fileoverview added by tsickle
|
|
* @suppress {checkTypes,constantProperty,extraRequire,missingOverride,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
|
|
*/
|
|
/** @type {?} */
|
|
const collapseY = animation(
|
|
[
|
|
style({ height: '*', overflow: 'hidden', 'box-sizing': 'border-box' }),
|
|
animate('{{ time }} {{ easing }}', style({ height: '0', padding: '0px' })),
|
|
],
|
|
{ params: { time: '350ms', easing: 'ease' } },
|
|
);
|
|
/** @type {?} */
|
|
const collapseYWithMargin = animation(
|
|
[style({ 'margin-top': '0' }), animate('{{ time }} {{ easing }}', style({ 'margin-top': '-100%' }))],
|
|
{
|
|
params: { time: '500ms', easing: 'ease' },
|
|
},
|
|
);
|
|
/** @type {?} */
|
|
const collapseX = animation(
|
|
[
|
|
style({ width: '*', overflow: 'hidden', 'box-sizing': 'border-box' }),
|
|
animate('{{ time }} {{ easing }}', style({ width: '0', padding: '0px' })),
|
|
],
|
|
{ params: { time: '350ms', easing: 'ease' } },
|
|
);
|
|
/** @type {?} */
|
|
const expandY = animation(
|
|
[
|
|
style({ height: '0', overflow: 'hidden', 'box-sizing': 'border-box' }),
|
|
animate('{{ time }} {{ easing }}', style({ height: '*', padding: '*' })),
|
|
],
|
|
{ params: { time: '350ms', easing: 'ease' } },
|
|
);
|
|
/** @type {?} */
|
|
const expandYWithMargin = animation(
|
|
[style({ 'margin-top': '-100%' }), animate('{{ time }} {{ easing }}', style({ 'margin-top': '0' }))],
|
|
{
|
|
params: { time: '500ms', easing: 'ease' },
|
|
},
|
|
);
|
|
/** @type {?} */
|
|
const expandX = animation(
|
|
[
|
|
style({ width: '0', overflow: 'hidden', 'box-sizing': 'border-box' }),
|
|
animate('{{ time }} {{ easing }}', style({ width: '*', padding: '*' })),
|
|
],
|
|
{ params: { time: '350ms', easing: 'ease' } },
|
|
);
|
|
/** @type {?} */
|
|
const collapse = trigger('collapse', [
|
|
state('collapsed', style({ height: '0', overflow: 'hidden' })),
|
|
state('expanded', style({ height: '*', overflow: 'hidden' })),
|
|
transition('expanded => collapsed', useAnimation(collapseY)),
|
|
transition('collapsed => expanded', useAnimation(expandY)),
|
|
]);
|
|
/** @type {?} */
|
|
const collapseWithMargin = trigger('collapseWithMargin', [
|
|
state('collapsed', style({ 'margin-top': '-100%' })),
|
|
state('expanded', style({ 'margin-top': '0' })),
|
|
transition('expanded => collapsed', useAnimation(collapseYWithMargin), {
|
|
params: { time: '400ms', easing: 'linear' },
|
|
}),
|
|
transition('collapsed => expanded', useAnimation(expandYWithMargin)),
|
|
]);
|
|
/** @type {?} */
|
|
const collapseLinearWithMargin = trigger('collapseLinearWithMargin', [
|
|
state('collapsed', style({ 'margin-top': '-100%' })),
|
|
state('expanded', style({ 'margin-top': '0' })),
|
|
transition(
|
|
'expanded => collapsed',
|
|
useAnimation(collapseYWithMargin, { params: { time: '200ms', easing: 'linear' } }),
|
|
),
|
|
transition('collapsed => expanded', useAnimation(expandYWithMargin, { params: { time: '250ms', easing: 'linear' } })),
|
|
]);
|
|
|
|
/**
|
|
* @fileoverview added by tsickle
|
|
* @suppress {checkTypes,constantProperty,extraRequire,missingOverride,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
|
|
*/
|
|
/** @type {?} */
|
|
const slideFromBottom = trigger('slideFromBottom', [
|
|
transition('* <=> *', [
|
|
style({ 'margin-top': '20px', opacity: '0' }),
|
|
animate('0.2s ease-out', style({ opacity: '1', 'margin-top': '0px' })),
|
|
]),
|
|
]);
|
|
|
|
/**
|
|
* @fileoverview added by tsickle
|
|
* @suppress {checkTypes,constantProperty,extraRequire,missingOverride,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
|
|
*/
|
|
|
|
/**
|
|
* @fileoverview added by tsickle
|
|
* @suppress {checkTypes,constantProperty,extraRequire,missingOverride,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
|
|
*/
|
|
|
|
/**
|
|
* @fileoverview added by tsickle
|
|
* @suppress {checkTypes,constantProperty,extraRequire,missingOverride,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
|
|
*/
|
|
var Confirmation;
|
|
(function(Confirmation) {
|
|
/**
|
|
* @record
|
|
*/
|
|
function Options() {}
|
|
Confirmation.Options = Options;
|
|
if (false) {
|
|
/** @type {?|undefined} */
|
|
Options.prototype.hideCancelBtn;
|
|
/** @type {?|undefined} */
|
|
Options.prototype.hideYesBtn;
|
|
/** @type {?|undefined} */
|
|
Options.prototype.cancelCopy;
|
|
/** @type {?|undefined} */
|
|
Options.prototype.yesCopy;
|
|
}
|
|
})(Confirmation || (Confirmation = {}));
|
|
|
|
/**
|
|
* @fileoverview added by tsickle
|
|
* @suppress {checkTypes,constantProperty,extraRequire,missingOverride,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
|
|
*/
|
|
/**
|
|
* @record
|
|
*/
|
|
function SettingTab() {}
|
|
if (false) {
|
|
/** @type {?} */
|
|
SettingTab.prototype.component;
|
|
/** @type {?} */
|
|
SettingTab.prototype.name;
|
|
/** @type {?} */
|
|
SettingTab.prototype.order;
|
|
/** @type {?|undefined} */
|
|
SettingTab.prototype.requiredPolicy;
|
|
}
|
|
/** @type {?} */
|
|
const SETTING_TABS = /** @type {?} */ ([]);
|
|
/**
|
|
* @param {?} tab
|
|
* @return {?}
|
|
*/
|
|
function addSettingTab(tab) {
|
|
if (!Array.isArray(tab)) {
|
|
tab = [tab];
|
|
}
|
|
SETTING_TABS.push(...tab);
|
|
}
|
|
/**
|
|
* @return {?}
|
|
*/
|
|
function getSettingTabs() {
|
|
return SETTING_TABS;
|
|
}
|
|
|
|
/**
|
|
* @fileoverview added by tsickle
|
|
* @suppress {checkTypes,constantProperty,extraRequire,missingOverride,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
|
|
*/
|
|
var Statistics;
|
|
(function(Statistics) {
|
|
/**
|
|
* @record
|
|
*/
|
|
function Response() {}
|
|
Statistics.Response = Response;
|
|
if (false) {
|
|
/** @type {?} */
|
|
Response.prototype.data;
|
|
}
|
|
/**
|
|
* @record
|
|
*/
|
|
function Data() {}
|
|
Statistics.Data = Data;
|
|
/**
|
|
* @record
|
|
*/
|
|
function Filter() {}
|
|
Statistics.Filter = Filter;
|
|
if (false) {
|
|
/** @type {?} */
|
|
Filter.prototype.startDate;
|
|
/** @type {?} */
|
|
Filter.prototype.endDate;
|
|
}
|
|
})(Statistics || (Statistics = {}));
|
|
|
|
/**
|
|
* @fileoverview added by tsickle
|
|
* @suppress {checkTypes,constantProperty,extraRequire,missingOverride,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
|
|
*/
|
|
var Toaster;
|
|
(function(Toaster) {
|
|
/**
|
|
* @record
|
|
*/
|
|
function Options() {}
|
|
Toaster.Options = Options;
|
|
if (false) {
|
|
/** @type {?|undefined} */
|
|
Options.prototype.id;
|
|
/** @type {?|undefined} */
|
|
Options.prototype.closable;
|
|
/** @type {?|undefined} */
|
|
Options.prototype.life;
|
|
/** @type {?|undefined} */
|
|
Options.prototype.sticky;
|
|
/** @type {?|undefined} */
|
|
Options.prototype.data;
|
|
/** @type {?|undefined} */
|
|
Options.prototype.messageLocalizationParams;
|
|
/** @type {?|undefined} */
|
|
Options.prototype.titleLocalizationParams;
|
|
}
|
|
})(Toaster || (Toaster = {}));
|
|
|
|
/**
|
|
* @fileoverview added by tsickle
|
|
* @suppress {checkTypes,constantProperty,extraRequire,missingOverride,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
|
|
*/
|
|
|
|
/**
|
|
* @fileoverview added by tsickle
|
|
* @suppress {checkTypes,constantProperty,extraRequire,missingOverride,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
|
|
*/
|
|
|
|
/**
|
|
* @fileoverview added by tsickle
|
|
* @suppress {checkTypes,constantProperty,extraRequire,missingOverride,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
|
|
*/
|
|
|
|
/**
|
|
* @fileoverview added by tsickle
|
|
* @suppress {checkTypes,constantProperty,extraRequire,missingOverride,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
|
|
*/
|
|
|
|
/**
|
|
* @fileoverview added by tsickle
|
|
* @suppress {checkTypes,constantProperty,extraRequire,missingOverride,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
|
|
*/
|
|
|
|
export {
|
|
BreadcrumbComponent,
|
|
ButtonComponent,
|
|
ChangePasswordComponent,
|
|
ChartComponent,
|
|
ConfirmationComponent,
|
|
ConfirmationService,
|
|
LoaderBarComponent,
|
|
ModalComponent,
|
|
ProfileComponent,
|
|
SortOrderIconComponent,
|
|
TableEmptyMessageComponent,
|
|
ThemeSharedModule,
|
|
ToastComponent,
|
|
Toaster,
|
|
ToasterService,
|
|
addSettingTab,
|
|
appendScript,
|
|
bounceIn,
|
|
chartJsLoaded$,
|
|
collapse,
|
|
collapseLinearWithMargin,
|
|
collapseWithMargin,
|
|
collapseX,
|
|
collapseY,
|
|
collapseYWithMargin,
|
|
dialogAnimation,
|
|
expandX,
|
|
expandY,
|
|
expandYWithMargin,
|
|
fadeAnimation,
|
|
fadeIn,
|
|
fadeInDown,
|
|
fadeInLeft,
|
|
fadeInRight,
|
|
fadeInUp,
|
|
fadeOut,
|
|
fadeOutDown,
|
|
fadeOutLeft,
|
|
fadeOutRight,
|
|
fadeOutUp,
|
|
getRandomBackgroundColor,
|
|
getSettingTabs,
|
|
slideFromBottom,
|
|
BreadcrumbComponent as ɵa,
|
|
ButtonComponent as ɵb,
|
|
ChangePasswordComponent as ɵc,
|
|
ToasterService as ɵd,
|
|
AbstractToaster as ɵe,
|
|
ChartComponent as ɵf,
|
|
ConfirmationComponent as ɵg,
|
|
ConfirmationService as ɵh,
|
|
ErrorComponent as ɵi,
|
|
LoaderBarComponent as ɵj,
|
|
ModalComponent as ɵk,
|
|
fadeAnimation as ɵl,
|
|
dialogAnimation as ɵm,
|
|
fadeIn as ɵn,
|
|
fadeOut as ɵo,
|
|
fadeInDown as ɵp,
|
|
ProfileComponent as ɵq,
|
|
TableEmptyMessageComponent as ɵr,
|
|
ToastComponent as ɵs,
|
|
SortOrderIconComponent as ɵt,
|
|
ErrorHandler as ɵu,
|
|
};
|
|
//# sourceMappingURL=abp-ng.theme.shared.js.map
|