• Version 10.0.0
  • Published
  • 180 kB
  • 1 dependency
  • MIT license


npm i abp-ng2-module
yarn add abp-ng2-module
pnpm add abp-ng2-module


This library was generated with [Angular CLI](https://github.com/angular/angular-cli) version 9.0.7.





class AbpHttpConfigurationService

class AbpHttpConfigurationService {}


    constructor(_messageService: MessageService, _logService: LogService);

      property defaultError

      defaultError: IErrorInfo;

        property defaultError401

        defaultError401: IErrorInfo;

          property defaultError403

          defaultError403: IErrorInfo;

            property defaultError404

            defaultError404: IErrorInfo;

              property ɵfac

              static ɵfac: i0.ɵɵFactoryDeclaration<AbpHttpConfigurationService, never>;

                property ɵprov

                static ɵprov: i0.ɵɵInjectableDeclaration<AbpHttpConfigurationService>;

                  method blobToText

                  blobToText: (blob: any) => Observable<string>;

                    method getAbpAjaxResponseOrNull

                    getAbpAjaxResponseOrNull: (response: HttpResponse<any>) => IAjaxResponse | null;

                      method handleAbpResponse

                      handleAbpResponse: (
                      response: HttpResponse<any>,
                      ajaxResponse: IAjaxResponse
                      ) => HttpResponse<any>;

                        method handleNonAbpErrorResponse

                        handleNonAbpErrorResponse: (response: HttpResponse<any>) => void;

                          method handleResponse

                          handleResponse: (response: HttpResponse<any>) => HttpResponse<any>;

                            method handleTargetUrl

                            handleTargetUrl: (targetUrl: string) => void;

                              method handleUnAuthorizedRequest

                              handleUnAuthorizedRequest: (messagePromise: any, targetUrl?: string) => void;

                                method logError

                                logError: (error: IErrorInfo) => void;

                                  method showError

                                  showError: (error: IErrorInfo) => any;

                                    class AbpHttpInterceptor

                                    class AbpHttpInterceptor implements HttpInterceptor {}


                                      constructor(configuration: AbpHttpConfigurationService, _injector: Injector);

                                        property configuration

                                        protected configuration: AbpHttpConfigurationService;

                                          property ɵfac

                                          static ɵfac: i0.ɵɵFactoryDeclaration<AbpHttpInterceptor, never>;

                                            property ɵprov

                                            static ɵprov: i0.ɵɵInjectableDeclaration<AbpHttpInterceptor>;

                                              method addAcceptLanguageHeader

                                              protected addAcceptLanguageHeader: (headers: HttpHeaders) => HttpHeaders;

                                                method addAspNetCoreCultureHeader

                                                protected addAspNetCoreCultureHeader: (headers: HttpHeaders) => HttpHeaders;

                                                  method addAuthorizationHeaders

                                                  protected addAuthorizationHeaders: (headers: HttpHeaders) => HttpHeaders;

                                                    method addTenantIdHeader

                                                    protected addTenantIdHeader: (headers: HttpHeaders) => HttpHeaders;

                                                      method addXRequestedWithHeader

                                                      protected addXRequestedWithHeader: (headers: HttpHeaders) => HttpHeaders;

                                                        method handleErrorResponse

                                                        protected handleErrorResponse: (error: any) => Observable<never>;

                                                          method handleSuccessResponse

                                                          protected handleSuccessResponse: (
                                                          event: HttpEvent<any>
                                                          ) => Observable<HttpEvent<any>>;

                                                            method intercept

                                                            intercept: (
                                                            request: HttpRequest<any>,
                                                            next: HttpHandler
                                                            ) => Observable<HttpEvent<any>>;

                                                              method normalizeRequestHeaders

                                                              protected normalizeRequestHeaders: (
                                                              request: HttpRequest<any>
                                                              ) => HttpRequest<any>;

                                                                method tryGetRefreshTokenService

                                                                protected tryGetRefreshTokenService: () => Observable<boolean>;

                                                                  class AbpModule

                                                                  class AbpModule {}

                                                                    property ɵfac

                                                                    static ɵfac: i0.ɵɵFactoryDeclaration<AbpModule, never>;

                                                                      property ɵinj

                                                                      static ɵinj: i0.ɵɵInjectorDeclaration<AbpModule>;

                                                                        property ɵmod

                                                                        static ɵmod: i0.ɵɵNgModuleDeclaration<AbpModule, never, never, never>;

                                                                          class AbpMultiTenancyService

                                                                          class AbpMultiTenancyService {}

                                                                            property isEnabled

                                                                            readonly isEnabled: boolean;

                                                                              property ɵfac

                                                                              static ɵfac: i0.ɵɵFactoryDeclaration<AbpMultiTenancyService, never>;

                                                                                property ɵprov

                                                                                static ɵprov: i0.ɵɵInjectableDeclaration<AbpMultiTenancyService>;

                                                                                  class AbpSessionService

                                                                                  class AbpSessionService {}

                                                                                    property impersonatorTenantId

                                                                                    readonly impersonatorTenantId: number;

                                                                                      property impersonatorUserId

                                                                                      readonly impersonatorUserId: number;

                                                                                        property multiTenancySide

                                                                                        readonly multiTenancySide: abp.multiTenancy.sides;

                                                                                          property ɵfac

                                                                                          static ɵfac: i0.ɵɵFactoryDeclaration<AbpSessionService, never>;

                                                                                            property ɵprov

                                                                                            static ɵprov: i0.ɵɵInjectableDeclaration<AbpSessionService>;

                                                                                              property tenantId

                                                                                              readonly tenantId: number;

                                                                                                property userId

                                                                                                readonly userId: number;

                                                                                                  class AbpUserConfigurationService

                                                                                                  class AbpUserConfigurationService {}


                                                                                                    constructor(_http: HttpClient);

                                                                                                      property ɵfac

                                                                                                      static ɵfac: i0.ɵɵFactoryDeclaration<AbpUserConfigurationService, never>;

                                                                                                        property ɵprov

                                                                                                        static ɵprov: i0.ɵɵInjectableDeclaration<AbpUserConfigurationService>;

                                                                                                          method initialize

                                                                                                          initialize: () => void;

                                                                                                            class FeatureCheckerService

                                                                                                            class FeatureCheckerService {}

                                                                                                              property ɵfac

                                                                                                              static ɵfac: i0.ɵɵFactoryDeclaration<FeatureCheckerService, never>;

                                                                                                                property ɵprov

                                                                                                                static ɵprov: i0.ɵɵInjectableDeclaration<FeatureCheckerService>;

                                                                                                                  method get

                                                                                                                  get: (featureName: string) => abp.features.IFeature;

                                                                                                                    method getValue

                                                                                                                    getValue: (featureName: string) => string;

                                                                                                                      method isEnabled

                                                                                                                      isEnabled: (featureName: string) => boolean;

                                                                                                                        class LocalizationService

                                                                                                                        class LocalizationService {}

                                                                                                                          property currentLanguage

                                                                                                                          readonly currentLanguage: abp.localization.ILanguageInfo;

                                                                                                                            property languages

                                                                                                                            readonly languages: abp.localization.ILanguageInfo[];

                                                                                                                              property ɵfac

                                                                                                                              static ɵfac: i0.ɵɵFactoryDeclaration<LocalizationService, never>;

                                                                                                                                property ɵprov

                                                                                                                                static ɵprov: i0.ɵɵInjectableDeclaration<LocalizationService>;

                                                                                                                                  method getSource

                                                                                                                                  getSource: (sourceName: string) => (...key: string[]) => string;

                                                                                                                                    method localize

                                                                                                                                    localize: (key: string, sourceName: string) => string;

                                                                                                                                      class LogService

                                                                                                                                      class LogService {}

                                                                                                                                        property ɵfac

                                                                                                                                        static ɵfac: i0.ɵɵFactoryDeclaration<LogService, never>;

                                                                                                                                          property ɵprov

                                                                                                                                          static ɵprov: i0.ɵɵInjectableDeclaration<LogService>;

                                                                                                                                            method debug

                                                                                                                                            debug: (logObject?: any) => void;

                                                                                                                                              method error

                                                                                                                                              error: (logObject?: any) => void;

                                                                                                                                                method fatal

                                                                                                                                                fatal: (logObject?: any) => void;

                                                                                                                                                  method info

                                                                                                                                                  info: (logObject?: any) => void;

                                                                                                                                                    method warn

                                                                                                                                                    warn: (logObject?: any) => void;

                                                                                                                                                      class MessageService

                                                                                                                                                      class MessageService {}

                                                                                                                                                        property ɵfac

                                                                                                                                                        static ɵfac: i0.ɵɵFactoryDeclaration<MessageService, never>;

                                                                                                                                                          property ɵprov

                                                                                                                                                          static ɵprov: i0.ɵɵInjectableDeclaration<MessageService>;

                                                                                                                                                            method confirm

                                                                                                                                                            confirm: (
                                                                                                                                                            message: string,
                                                                                                                                                            title?: string,
                                                                                                                                                            callback?: (result: boolean, info?: any) => void,
                                                                                                                                                            options?: any
                                                                                                                                                            ) => any;

                                                                                                                                                              method error

                                                                                                                                                              error: (message: string, title?: string, options?: any) => any;

                                                                                                                                                                method info

                                                                                                                                                                info: (message: string, title?: string, options?: any) => any;

                                                                                                                                                                  method success

                                                                                                                                                                  success: (message: string, title?: string, options?: any) => any;

                                                                                                                                                                    method warn

                                                                                                                                                                    warn: (message: string, title?: string, options?: any) => any;

                                                                                                                                                                      class NotifyService

                                                                                                                                                                      class NotifyService {}

                                                                                                                                                                        property ɵfac

                                                                                                                                                                        static ɵfac: i0.ɵɵFactoryDeclaration<NotifyService, never>;

                                                                                                                                                                          property ɵprov

                                                                                                                                                                          static ɵprov: i0.ɵɵInjectableDeclaration<NotifyService>;

                                                                                                                                                                            method error

                                                                                                                                                                            error: (message: string, title?: string, options?: any) => void;

                                                                                                                                                                              method info

                                                                                                                                                                              info: (message: string, title?: string, options?: any) => void;

                                                                                                                                                                                method success

                                                                                                                                                                                success: (message: string, title?: string, options?: any) => void;

                                                                                                                                                                                  method warn

                                                                                                                                                                                  warn: (message: string, title?: string, options?: any) => void;

                                                                                                                                                                                    class PermissionCheckerService

                                                                                                                                                                                    class PermissionCheckerService {}

                                                                                                                                                                                      property ɵfac

                                                                                                                                                                                      static ɵfac: i0.ɵɵFactoryDeclaration<PermissionCheckerService, never>;

                                                                                                                                                                                        property ɵprov

                                                                                                                                                                                        static ɵprov: i0.ɵɵInjectableDeclaration<PermissionCheckerService>;

                                                                                                                                                                                          method isGranted

                                                                                                                                                                                          isGranted: (permissionName: string) => boolean;

                                                                                                                                                                                            class RefreshTokenService

                                                                                                                                                                                            abstract class RefreshTokenService {}

                                                                                                                                                                                              property ɵfac

                                                                                                                                                                                              static ɵfac: i0.ɵɵFactoryDeclaration<RefreshTokenService, never>;

                                                                                                                                                                                                property ɵprov

                                                                                                                                                                                                static ɵprov: i0.ɵɵInjectableDeclaration<RefreshTokenService>;

                                                                                                                                                                                                  method tryAuthWithRefreshToken

                                                                                                                                                                                                  abstract tryAuthWithRefreshToken: () => Observable<boolean>;
                                                                                                                                                                                                  • Try to authenticate with refresh token and return if auth succeed

                                                                                                                                                                                                  class SettingService

                                                                                                                                                                                                  class SettingService {}

                                                                                                                                                                                                    property ɵfac

                                                                                                                                                                                                    static ɵfac: i0.ɵɵFactoryDeclaration<SettingService, never>;

                                                                                                                                                                                                      property ɵprov

                                                                                                                                                                                                      static ɵprov: i0.ɵɵInjectableDeclaration<SettingService>;

                                                                                                                                                                                                        method get

                                                                                                                                                                                                        get: (name: string) => string;

                                                                                                                                                                                                          method getBoolean

                                                                                                                                                                                                          getBoolean: (name: string) => boolean;

                                                                                                                                                                                                            method getInt

                                                                                                                                                                                                            getInt: (name: string) => number;

                                                                                                                                                                                                              class TokenService

                                                                                                                                                                                                              class TokenService {}

                                                                                                                                                                                                                property ɵfac

                                                                                                                                                                                                                static ɵfac: i0.ɵɵFactoryDeclaration<TokenService, never>;

                                                                                                                                                                                                                  property ɵprov

                                                                                                                                                                                                                  static ɵprov: i0.ɵɵInjectableDeclaration<TokenService>;

                                                                                                                                                                                                                    method clearRefreshToken

                                                                                                                                                                                                                    clearRefreshToken: () => void;

                                                                                                                                                                                                                      method clearToken

                                                                                                                                                                                                                      clearToken: () => void;

                                                                                                                                                                                                                        method getRefreshToken

                                                                                                                                                                                                                        getRefreshToken: () => string;

                                                                                                                                                                                                                          method getRefreshTokenCookieName

                                                                                                                                                                                                                          getRefreshTokenCookieName: () => string;

                                                                                                                                                                                                                            method getToken

                                                                                                                                                                                                                            getToken: () => string;

                                                                                                                                                                                                                              method getTokenCookieName

                                                                                                                                                                                                                              getTokenCookieName: () => string;

                                                                                                                                                                                                                                method setRefreshToken

                                                                                                                                                                                                                                setRefreshToken: (refreshToken: string, expireDate?: Date) => void;

                                                                                                                                                                                                                                  method setToken

                                                                                                                                                                                                                                  setToken: (authToken: string, expireDate?: Date) => void;

                                                                                                                                                                                                                                    class UtilsService

                                                                                                                                                                                                                                    class UtilsService {}

                                                                                                                                                                                                                                      property ɵfac

                                                                                                                                                                                                                                      static ɵfac: i0.ɵɵFactoryDeclaration<UtilsService, never>;

                                                                                                                                                                                                                                        property ɵprov

                                                                                                                                                                                                                                        static ɵprov: i0.ɵɵInjectableDeclaration<UtilsService>;

                                                                                                                                                                                                                                          method deleteCookie

                                                                                                                                                                                                                                          deleteCookie: (key: string, path?: string) => void;

                                                                                                                                                                                                                                            method getCookieValue

                                                                                                                                                                                                                                            getCookieValue: (key: string) => string;

                                                                                                                                                                                                                                              method setCookieValue

                                                                                                                                                                                                                                              setCookieValue: (
                                                                                                                                                                                                                                              key: string,
                                                                                                                                                                                                                                              value: string,
                                                                                                                                                                                                                                              expireDate?: Date,
                                                                                                                                                                                                                                              path?: string,
                                                                                                                                                                                                                                              domain?: string,
                                                                                                                                                                                                                                              attributes?: any
                                                                                                                                                                                                                                              ) => void;


                                                                                                                                                                                                                                                interface IAjaxResponse

                                                                                                                                                                                                                                                interface IAjaxResponse {}

                                                                                                                                                                                                                                                  property error

                                                                                                                                                                                                                                                  error?: IErrorInfo;

                                                                                                                                                                                                                                                    property result

                                                                                                                                                                                                                                                    result?: any;

                                                                                                                                                                                                                                                      property success

                                                                                                                                                                                                                                                      success: boolean;

                                                                                                                                                                                                                                                        property targetUrl

                                                                                                                                                                                                                                                        targetUrl?: string;

                                                                                                                                                                                                                                                          property unAuthorizedRequest

                                                                                                                                                                                                                                                          unAuthorizedRequest: boolean;

                                                                                                                                                                                                                                                            interface IErrorInfo

                                                                                                                                                                                                                                                            interface IErrorInfo {}

                                                                                                                                                                                                                                                              property code

                                                                                                                                                                                                                                                              code: number;

                                                                                                                                                                                                                                                                property details

                                                                                                                                                                                                                                                                details: string;

                                                                                                                                                                                                                                                                  property message

                                                                                                                                                                                                                                                                  message: string;

                                                                                                                                                                                                                                                                    property validationErrors

                                                                                                                                                                                                                                                                    validationErrors: IValidationErrorInfo[];

                                                                                                                                                                                                                                                                      interface IValidationErrorInfo

                                                                                                                                                                                                                                                                      interface IValidationErrorInfo {}

                                                                                                                                                                                                                                                                        property members

                                                                                                                                                                                                                                                                        members: string[];

                                                                                                                                                                                                                                                                          property message

                                                                                                                                                                                                                                                                          message: string;

                                                                                                                                                                                                                                                                            Package Files (18)

                                                                                                                                                                                                                                                                            Dependencies (1)

                                                                                                                                                                                                                                                                            Dev Dependencies (0)

                                                                                                                                                                                                                                                                            No dev dependencies.

                                                                                                                                                                                                                                                                            Peer Dependencies (2)


                                                                                                                                                                                                                                                                            To add a badge like this onejsDocs.io badgeto your package's README, use the codes available below.

                                                                                                                                                                                                                                                                            You may also use Shields.io to create a custom badge linking to https://www.jsdocs.io/package/abp-ng2-module.

                                                                                                                                                                                                                                                                            • Markdown
                                                                                                                                                                                                                                                                            • HTML
                                                                                                                                                                                                                                                                              <a href="https://www.jsdocs.io/package/abp-ng2-module"><img src="https://img.shields.io/badge/jsDocs.io-reference-blue" alt="jsDocs.io"></a>