@miracledevs/paradigm-web-angular
Version:
An angular wrapper with base functionality and helper services.
317 lines • 26.9 kB
JavaScript
/**
* @fileoverview added by tsickle
* @suppress {checkTypes,extraRequire,missingOverride,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
*/
/*!
* Paradigm Framework - Angular Wrapper
* Copyright (c) 2017 Miracle Devs, Inc
* Licensed under MIT (https://github.com/MiracleDevs/Paradigm.Web.Shared/blob/master/LICENSE)
*/
import { ServiceBase } from './base.service';
import { DateExtensions, StringExtensions, ObjectExtensions } from '@miracledevs/paradigm-ui-web-shared';
import { Injectable } from '@angular/core';
import * as i0 from "@angular/core";
/**
* Represents a log provider.
* The interface was specifically made to
* match the one from \@see console that is
* the default provider used by \@see LoggingService.
* @record
*/
export function ILogProvider() { }
if (false) {
/**
* Adds a trace log.
* @param {?} message the message to be logged.
* @return {?}
*/
ILogProvider.prototype.trace = function (message) { };
/**
* Adds a debug log.
* @param {?} message the message to be logged.
* @return {?}
*/
ILogProvider.prototype.debug = function (message) { };
/**
* Adds an info log.
* @param {?} message the message to be logged.
* @return {?}
*/
ILogProvider.prototype.info = function (message) { };
/**
* Adds a warn log.
* @param {?} message the message to be logged.
* @return {?}
*/
ILogProvider.prototype.warn = function (message) { };
/**
* Adds an error log.
* @param {?} message the message to be logged.
* @return {?}
*/
ILogProvider.prototype.error = function (message) { };
/**
* Adds a critical error log.
* @param {?} message the message to be logged.
* @return {?}
*/
ILogProvider.prototype.critical = function (message) { };
}
/** @enum {number} */
const LogType = {
/**
* Represents a trace log.
*/
Trace: 0,
/**
* Represents a debug log.
*/
Debug: 1,
/**
* Represents an information log.
*/
Information: 2,
/**
* Represents a warning log.
*/
Warning: 3,
/**
* Represents an error log.
*/
Error: 4,
/**
* Represents a critical error log.
*/
Critical: 5,
};
export { LogType };
LogType[LogType.Trace] = 'Trace';
LogType[LogType.Debug] = 'Debug';
LogType[LogType.Information] = 'Information';
LogType[LogType.Warning] = 'Warning';
LogType[LogType.Error] = 'Error';
LogType[LogType.Critical] = 'Critical';
export class LoggingService extends ServiceBase {
/**
* Creates a new instance of \@see LoggingService.
*/
constructor() {
super();
this.logProvider = console;
this.setMessageTemplateForAll('[{0}][{1}] - {3}{2}');
this.minimumLevel = LogType.Information;
}
/**
* Sets a log provider.
* By default \@see console is used as provider.
* @param {?} logProvider
* @return {?}
*/
setLogProvider(logProvider) {
this.logProvider = logProvider;
}
/**
* Sets the message template for a given log type.
* There are some predefined content placeholders the user can utilize
* to configure the custom messages:
*
* {0}: The time when the log was added.
*
* {1}: The type of the log (Trace, Debug , Information, etc)
*
* {2}: A custom tag value provided by the user.
*
* {3}: The log message.
* @param {?} type
* @param {?} message
* @return {?}
*/
setMessageTemplate(type, message) {
if (type < 0 || type >= this.messageTemplates.length) {
throw new Error(LoggingService.typeNotRecognized);
}
if (ObjectExtensions.isNull(message)) {
throw new Error('The message template can not be null or undefined.');
}
this.messageTemplates[type] = message;
}
/**
* Sets the message template for all the types.
* There are some predefined content placeholders the user can utilize
* to configure the custom messages:
*
* {0}: The time when the log was added.
*
* {1}: The type of the log (Trace, Debug , Information, etc)
*
* {2}: A custom tag value provided by the user.
*
* {3}: The log message.
* @param {?} message
* @return {?}
*/
setMessageTemplateForAll(message) {
if (ObjectExtensions.isNull(message)) {
throw new Error('The message template can not be null or undefined.');
}
this.messageTemplates = [];
this.messageTemplates.push(message);
this.messageTemplates.push(message);
this.messageTemplates.push(message);
this.messageTemplates.push(message);
this.messageTemplates.push(message);
this.messageTemplates.push(message);
}
/**
* Sets the minimum log level.
* Log types smaller than this value will be ignored.
* @param {?} type
* @return {?}
*/
setMinimumLevel(type) {
if (type < 0 || type >= this.messageTemplates.length) {
throw new Error(LoggingService.typeNotRecognized);
}
this.minimumLevel = type;
}
/**
* Logs the specified message.
* @param {?} message the message to be logged.
* @param {?=} type the type of log entry.
* @param {?=} tag a tag value used for further analysis.
* @return {?}
*/
log(message, type = LogType.Trace, tag = null) {
if (type < 0 || type >= this.messageTemplates.length) {
throw new Error(LoggingService.typeNotRecognized);
}
if (ObjectExtensions.isNull(message)) {
throw new Error('The message can not be null or undefined.');
}
if (type < this.minimumLevel) {
return;
}
/** @type {?} */
const formattedMessage = StringExtensions.format(this.messageTemplates[type], DateExtensions.format(new Date(), 'hh:mm:ss'), LogType[type], tag, message);
switch (type) {
case LogType.Trace:
this.logProvider.trace(formattedMessage);
break;
case LogType.Debug:
this.logProvider.debug(formattedMessage);
break;
case LogType.Information:
this.logProvider.info(formattedMessage);
break;
case LogType.Warning:
this.logProvider.warn(formattedMessage);
break;
case LogType.Error:
this.logProvider.error(formattedMessage);
break;
case LogType.Critical:
if (this.logProvider.critical) {
this.logProvider.critical(formattedMessage);
}
else {
this.logProvider.error(formattedMessage);
}
break;
}
}
/**
* Adds a trace log entry.
* @param {?} message the message to be logged.
* @param {?=} tag a tag value for the entry.
* @return {?}
*/
trace(message, tag = null) {
this.log(message, LogType.Trace, tag);
}
/**
* Adds a debug log entry.
* @param {?} message the message to be logged.
* @param {?=} tag a tag value for the entry.
* @return {?}
*/
debug(message, tag = null) {
this.log(message, LogType.Debug, tag);
}
/**
* Adds an information log entry.
* @param {?} message the message to be logged.
* @param {?=} tag a tag value for the entry.
* @return {?}
*/
information(message, tag = null) {
this.log(message, LogType.Information, tag);
}
/**
* Adds a warning log entry.
* @param {?} message the message to be logged.
* @param {?=} tag a tag value for the entry.
* @return {?}
*/
warning(message, tag = null) {
this.log(message, LogType.Warning, tag);
}
/**
* Adds an error log entry.
* @param {?} message the message to be logged.
* @param {?=} tag a tag value for the entry.
* @return {?}
*/
error(message, tag = null) {
this.log(message, LogType.Error, tag);
}
/**
* Adds a critical error log entry.
* @param {?} message the message to be logged.
* @param {?=} tag a tag value for the entry.
* @return {?}
*/
critical(message, tag = null) {
this.log(message, LogType.Critical, tag);
}
}
/**
* Error message.
*/
LoggingService.typeNotRecognized = 'The provided type is not recognized as a valid log type.';
LoggingService.decorators = [
{ type: Injectable, args: [{
providedIn: 'root'
},] }
];
/** @nocollapse */
LoggingService.ctorParameters = () => [];
/** @nocollapse */ LoggingService.ngInjectableDef = i0.defineInjectable({ factory: function LoggingService_Factory() { return new LoggingService(); }, token: LoggingService, providedIn: "root" });
if (false) {
/**
* Error message.
* @type {?}
* @private
*/
LoggingService.typeNotRecognized;
/**
* An array of message templates.
* @type {?}
* @private
*/
LoggingService.prototype.messageTemplates;
/**
* The minimum log type that will logged.
* Log types smaller than this value will be ignored.
* @type {?}
* @private
*/
LoggingService.prototype.minimumLevel;
/**
* A log provider.
* By default \@see console will be used.
* @type {?}
* @private
*/
LoggingService.prototype.logProvider;
}
//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"logging.service.js","sourceRoot":"ng://@miracledevs/paradigm-web-angular/","sources":["lib/services/logging.service.ts"],"names":[],"mappings":"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","sourcesContent":["/*!\n * Paradigm Framework - Angular Wrapper\n * Copyright (c) 2017 Miracle Devs, Inc\n * Licensed under MIT (https://github.com/MiracleDevs/Paradigm.Web.Shared/blob/master/LICENSE)\n */\n\nimport { ServiceBase } from './base.service';\nimport { DateExtensions, Dictionary, StringExtensions, ObjectExtensions } from '@miracledevs/paradigm-ui-web-shared';\nimport { Injectable } from '@angular/core';\n\n/**\n * Represents a log provider.\n * The interface was specifically made to\n * match the one from @see console that is\n * the default provider used by @see LoggingService.\n */\nexport interface ILogProvider\n{\n    /**\n     * Adds a trace log.\n     * @param message the message to be logged.\n     */\n    trace(message: string): void;\n\n    /**\n     * Adds a debug log.\n     * @param message the message to be logged.\n     */\n    debug(message: string): void;\n\n    /**\n     * Adds an info log.\n     * @param message the message to be logged.\n     */\n    info(message: string): void;\n\n    /**\n     * Adds a warn log.\n     * @param message the message to be logged.\n     */\n    warn(message: string): void;\n\n    /**\n     * Adds an error log.\n     * @param message the message to be logged.\n     */\n    error(message: string): void;\n\n    /**\n     * Adds a critical error log.\n     * @param message the message to be logged.\n     */\n    critical?(message: string): void;\n}\n\n/**\n * Enumerates the types of logging entries.\n */\nexport enum LogType\n{\n    /**\n     * Represents a trace log.\n     */\n    Trace = 0,\n\n    /**\n     * Represents a debug log.\n     */\n    Debug = 1,\n\n    /**\n     * Represents an information log.\n     */\n    Information = 2,\n\n    /**\n     * Represents a warning log.\n     */\n    Warning = 3,\n\n    /**\n     * Represents an error log.\n     */\n    Error = 4,\n\n    /**\n     * Represents a critical error log.\n     */\n    Critical = 5\n}\n\n@Injectable({\n    providedIn: 'root'\n})\nexport class LoggingService extends ServiceBase\n{\n    /**\n     * Error message.\n     */\n    private static readonly typeNotRecognized: string = 'The provided type is not recognized as a valid log type.';\n\n    /**\n     * An array of message templates.\n     */\n    private messageTemplates: string[];\n\n    /**\n     * The minimum log type that will logged.\n     * Log types smaller than this value will be ignored.\n     */\n    private minimumLevel: LogType;\n\n    /**\n     * A log provider.\n     * By default @see console will be used.\n     */\n    private logProvider: ILogProvider;\n\n    /**\n     * Creates a new instance of @see LoggingService.\n     */\n    constructor()\n    {\n        super();\n        this.logProvider = console;\n        this.setMessageTemplateForAll('[{0}][{1}] - {3}{2}');\n        this.minimumLevel = LogType.Information;\n    }\n\n    /**\n     * Sets a log provider.\n     * By default @see console is used as provider.\n     */\n    setLogProvider(logProvider: ILogProvider): void\n    {\n        this.logProvider = logProvider;\n    }\n\n    /**\n     * Sets the message template for a given log type.\n     * There are some predefined content placeholders the user can utilize\n     * to configure the custom messages:\n     *\n     * {0}: The time when the log was added.\n     *\n     * {1}: The type of the log (Trace, Debug , Information, etc)\n     *\n     * {2}: A custom tag value provided by the user.\n     *\n     * {3}: The log message.\n     */\n    setMessageTemplate(type: LogType, message: string): void\n    {\n        if (type < 0 || type >= this.messageTemplates.length)\n        {\n            throw new Error(LoggingService.typeNotRecognized);\n        }\n\n        if (ObjectExtensions.isNull(message))\n        {\n            throw new Error('The message template can not be null or undefined.');\n        }\n\n        this.messageTemplates[type] = message;\n    }\n\n    /**\n     * Sets the message template for all the types.\n     * There are some predefined content placeholders the user can utilize\n     * to configure the custom messages:\n     *\n     * {0}: The time when the log was added.\n     *\n     * {1}: The type of the log (Trace, Debug , Information, etc)\n     *\n     * {2}: A custom tag value provided by the user.\n     *\n     * {3}: The log message.\n     */\n    setMessageTemplateForAll(message: string): void\n    {\n        if (ObjectExtensions.isNull(message))\n        {\n            throw new Error('The message template can not be null or undefined.');\n        }\n\n        this.messageTemplates = [];\n        this.messageTemplates.push(message);\n        this.messageTemplates.push(message);\n        this.messageTemplates.push(message);\n        this.messageTemplates.push(message);\n        this.messageTemplates.push(message);\n        this.messageTemplates.push(message);\n    }\n\n    /**\n     * Sets the minimum log level.\n     * Log types smaller than this value will be ignored.\n     */\n    setMinimumLevel(type: LogType): void\n    {\n        if (type < 0 || type >= this.messageTemplates.length)\n        {\n            throw new Error(LoggingService.typeNotRecognized);\n        }\n\n        this.minimumLevel = type;\n    }\n\n    /**\n     * Logs the specified message.\n     * @param message the message to be logged.\n     * @param type the type of log entry.\n     * @param tag a tag value used for further analysis.\n     */\n    log(message: string, type: LogType = LogType.Trace, tag: string = null): void\n    {\n        if (type < 0 || type >= this.messageTemplates.length)\n        {\n            throw new Error(LoggingService.typeNotRecognized);\n        }\n\n        if (ObjectExtensions.isNull(message))\n        {\n            throw new Error('The message can not be null or undefined.');\n        }\n\n        if (type < this.minimumLevel)\n        {\n            return;\n        }\n\n        const formattedMessage = StringExtensions.format(this.messageTemplates[type], DateExtensions.format(new Date(), 'hh:mm:ss'), LogType[type], tag, message);\n\n        switch (type)\n        {\n            case LogType.Trace:\n                this.logProvider.trace(formattedMessage);\n                break;\n\n            case LogType.Debug:\n                this.logProvider.debug(formattedMessage);\n                break;\n\n            case LogType.Information:\n                this.logProvider.info(formattedMessage);\n                break;\n\n            case LogType.Warning:\n                this.logProvider.warn(formattedMessage);\n                break;\n\n            case LogType.Error:\n                this.logProvider.error(formattedMessage);\n                break;\n\n            case LogType.Critical:\n                if (this.logProvider.critical)\n                {\n                    this.logProvider.critical(formattedMessage);\n                }\n                else\n                {\n                    this.logProvider.error(formattedMessage);\n                }\n                break;\n        }\n    }\n\n    /**\n     * Adds a trace log entry.\n     * @param message the message to be logged.\n     * @param tag a tag value for the entry.\n     */\n    trace(message: string, tag: string = null): void\n    {\n        this.log(message, LogType.Trace, tag);\n    }\n\n    /**\n     * Adds a debug log entry.\n     * @param message the message to be logged.\n     * @param tag a tag value for the entry.\n     */\n    debug(message: string, tag: string = null): void\n    {\n        this.log(message, LogType.Debug, tag);\n    }\n\n    /**\n     * Adds an information log entry.\n     * @param message the message to be logged.\n     * @param tag a tag value for the entry.\n     */\n    information(message: string, tag: string = null): void\n    {\n        this.log(message, LogType.Information, tag);\n    }\n\n    /**\n     * Adds a warning log entry.\n     * @param message the message to be logged.\n     * @param tag a tag value for the entry.\n     */\n    warning(message: string, tag: string = null): void\n    {\n        this.log(message, LogType.Warning, tag);\n    }\n\n    /**\n     * Adds an error log entry.\n     * @param message the message to be logged.\n     * @param tag a tag value for the entry.\n     */\n    error(message: string, tag: string = null): void\n    {\n        this.log(message, LogType.Error, tag);\n    }\n\n    /**\n     * Adds a critical error log entry.\n     * @param message the message to be logged.\n     * @param tag a tag value for the entry.\n     */\n    critical(message: string, tag: string = null): void\n    {\n        this.log(message, LogType.Critical, tag);\n    }\n}\n"]}