@adlfe/campaign-management-library 2.9.21 → 2.10.2

package/projects/adl-campaign-management-library-internal-test/src/app/ui/directives/format-input/number/input-number.directive.ts

@@ -0,0 +1,195 @@
+import {
+	Directive,
+	ElementRef,
+	HostListener,
+	Input,
+	OnChanges,
+	OnDestroy,
+	OnInit,
+	Self,
+} from '@angular/core';
+import { NgControl } from '@angular/forms';
+import { Subscription } from 'rxjs';
+
+@Directive({
+	selector: '[appInputNumber]',
+})
+export class InputNumberDirective implements OnInit, OnDestroy, OnChanges {
+	@Input()
+	private maxDigit: number;
+
+	@Input()
+	private minDigit: number;
+
+	@Input()
+	private maxValue: number;
+
+	@Input()
+	private minValue: number;
+
+	public allowComma: boolean;
+	public preventFirstNumberZero: boolean;
+	public subscribers: Subscription[];
+	public value: string;
+
+	@HostListener('blur', [])
+	public onBlur() {
+		this.checkMinMaxDigit();
+	}
+
+	@HostListener('keydown', ['$event'])
+	public onKeyDown(event: KeyboardEvent) {
+		if (this.preventFirstNumberZero && this.checkFirstNumberZero(event)) {
+			event.preventDefault();
+		}
+		if (this.allowComma && this.checkComma(event)) {
+			return;
+		}
+		if (this.checkCmdCtrlAny(event)) {
+			return;
+		}
+		if (this.checkSpecialKeys(event)) {
+			return;
+		}
+		if (this.checkNumber(event)) {
+			return;
+		}
+
+		event.preventDefault();
+	}
+
+	constructor(
+		@Self()
+		public ngControl: NgControl,
+		public elementRef: ElementRef
+	) {}
+
+	ngOnInit() {
+		this.subscribers = [];
+
+		this.setValueChange();
+	}
+
+	ngOnDestroy() {
+		this.subscribers.forEach((each) => each.unsubscribe());
+	}
+
+	ngOnChanges() {
+		this.value = this.ngControl.value;
+
+		this.valueChange();
+	}
+
+	private setValueChange() {
+		const subs = this.ngControl.valueChanges.subscribe((value) => {
+			this.value = value;
+
+			this.valueChange();
+		});
+
+		this.subscribers.push(subs);
+	}
+
+	public valueChange() {
+		this.checkMinMaxValue();
+	}
+
+	public checkMinMaxValue() {
+		if (this.value) {
+			if (
+				this.minValue !== undefined &&
+				Number(this.value) < Number(this.minValue)
+			) {
+				this.ngControl.control.setValue(this.minValue);
+			}
+
+			if (
+				this.maxValue !== undefined &&
+				Number(this.value) > Number(this.maxValue)
+			) {
+				this.ngControl.control.setValue(this.maxValue);
+			}
+		}
+	}
+
+	public checkMinMaxDigit() {
+		if (this.value) {
+			const valueDigit = this.value.toString().length;
+
+			if (this.minDigit !== undefined && valueDigit < this.minDigit) {
+				this.ngControl.control.setValue(
+					('0' + this.value).slice(-this.minDigit)
+				);
+			}
+			if (this.maxDigit !== undefined && valueDigit > this.maxDigit) {
+				this.ngControl.control.setValue(
+					this.value.substr(0, this.maxDigit)
+				);
+			}
+		}
+	}
+
+	private checkCmdCtrlAny(event: KeyboardEvent): boolean {
+		if (
+			(event.keyCode > 0 && event.ctrlKey === true) ||
+			(event.keyCode > 0 && event.metaKey === true)
+		) {
+			return true;
+		}
+
+		return false;
+	}
+
+	private checkSpecialKeys(event: KeyboardEvent): boolean {
+		const input = event.key;
+		const specialKeys = [
+			'ArrowLeft',
+			'ArrowRight',
+			'Backspace',
+			'Del',
+			'Delete',
+			'Enter',
+			'Escape',
+			'End',
+			'Home',
+			'Tab',
+		];
+
+		if (specialKeys.indexOf(input) !== -1) {
+			return true;
+		}
+
+		return false;
+	}
+
+	private checkNumber(event: KeyboardEvent): boolean {
+		const input = event.key;
+		const numberRegex = /[0-9]+/g;
+
+		if (numberRegex.test(input)) {
+			return true;
+		}
+
+		return false;
+	}
+
+	private checkFirstNumberZero(event: KeyboardEvent): boolean {
+		if (this.value) {
+			if (!this.value.length && event.key === '0') {
+				return true;
+			}
+
+			return false;
+		}
+	}
+
+	private checkComma(event: KeyboardEvent): boolean {
+		if (this.value) {
+			if (event.key === ',' && !/\,/g.test(this.value)) {
+				return true;
+			}
+
+			return false;
+		}
+	}
+}

package/projects/adl-campaign-management-library-internal-test/src/app/ui/directives/format-input/number/input-quantity.directive.ts

@@ -0,0 +1,72 @@
+import { DecimalPipe } from '@angular/common';
+import {
+	Directive,
+	HostListener,
+	OnChanges,
+	OnDestroy,
+	OnInit,
+} from '@angular/core';
+import { InputNumberDirective } from './input-number.directive';
+
+@Directive({
+	selector: '[appInputQuantity]',
+})
+export class InputQuantityDirective extends InputNumberDirective
+	implements OnInit, OnDestroy, OnChanges {
+	private decimalPipe: DecimalPipe;
+
+	@HostListener('blur', [])
+	public onBlur() {
+		super.onBlur();
+	}
+
+	@HostListener('keydown', ['$event'])
+	public onKeyDown(event: KeyboardEvent) {
+		super.onKeyDown(event);
+	}
+
+	ngOnInit() {
+		super.ngOnInit();
+
+		this.preventFirstNumberZero = true;
+	}
+
+	ngOnDestroy() {
+		super.ngOnDestroy();
+	}
+
+	ngOnChanges() {
+		super.ngOnChanges();
+	}
+
+	/**
+	 * override super.valueChange();
+	 */
+	public valueChange() {
+		this.transformToThousand();
+		this.checkMinMaxValue();
+		this.checkMinMaxDigit();
+	}
+
+	private transformToThousand() {
+		if (!this.decimalPipe) {
+			this.decimalPipe = new DecimalPipe('id-ID');
+		}
+
+		if (this.value) {
+			const targetValue = this.value.toString().split('.').join('');
+
+			this.ngControl.control.setValue(Number(targetValue), {
+				emitEvent: false,
+			});
+
+			const formatedValue = this.decimalPipe.transform(
+				Number(targetValue)
+			);
+
+			this.ngControl.valueAccessor.writeValue(formatedValue);
+
+			this.value = targetValue;
+		}
+	}
+}

package/projects/adl-campaign-management-library-internal-test/src/app/ui/directives/format-input/number/input-rupiah.directive.ts

@@ -0,0 +1,78 @@
+import {
+	Directive,
+	HostListener,
+	OnChanges,
+	OnDestroy,
+	OnInit,
+} from '@angular/core';
+import { RupiahPipe } from '../../../pipes/rupiah/rupiah';
+import { InputNumberDirective } from './input-number.directive';
+
+@Directive({
+	selector: '[appInputRupiah]',
+})
+export class InputRupiahDirective extends InputNumberDirective
+	implements OnInit, OnDestroy, OnChanges {
+	private rupiahPipe: RupiahPipe;
+
+	@HostListener('blur', [])
+	public onBlur() {
+		super.onBlur();
+	}
+
+	@HostListener('keydown', ['$event'])
+	public onKeyDown(event: KeyboardEvent) {
+		super.onKeyDown(event);
+	}
+
+	ngOnInit() {
+		super.ngOnInit();
+
+		this.preventFirstNumberZero = true;
+	}
+
+	ngOnDestroy() {
+		super.ngOnDestroy();
+	}
+
+	ngOnChanges() {
+		super.ngOnChanges();
+	}
+
+	/**
+	 * override super.valueChange();
+	 */
+	public valueChange() {
+		this.transformToRupiah();
+		this.checkMinMaxValue();
+		this.checkMinMaxDigit();
+	}
+
+	private transformToRupiah() {
+		if (!this.rupiahPipe) {
+			this.rupiahPipe = new RupiahPipe();
+		}
+
+		const targetValue = this.rupiahPipe.parse(String(this.value));
+
+		if (Number(targetValue) > 0) {
+			this.ngControl.control.setValue(Number(targetValue), {
+				emitEvent: false,
+			});
+
+			const formatedValue = this.rupiahPipe.transform(
+				Number(targetValue)
+			);
+
+			this.ngControl.valueAccessor.writeValue(formatedValue);
+		} else {
+			this.ngControl.control.setValue(null, {
+				emitEvent: false,
+			});
+
+			this.elementRef.nativeElement.value = null;
+		}
+
+		this.value = targetValue;
+	}
+}

package/projects/adl-campaign-management-library-internal-test/src/app/ui/directives/format-input/only-number/index.ts

@@ -0,0 +1 @@
+export * from './only-number.directive';

package/projects/adl-campaign-management-library-internal-test/src/app/ui/directives/format-input/only-number/only-number.directive.ts

@@ -0,0 +1,196 @@
+import {Directive, ElementRef, HostListener, Input, OnDestroy, OnInit, Self} from '@angular/core';
+import {NgControl} from '@angular/forms';
+import {Subscription} from 'rxjs';
+
+@Directive({
+	selector: '[appOnlyNumber]'
+})
+export class OnlyNumberDirective implements OnInit, OnDestroy {
+	private debounceTimer: any;
+	private subscription: Subscription[];
+	private value: number;
+
+	@Input()
+	public allowComma: boolean;
+
+	@Input()
+	public  allowColon: boolean;
+
+	@Input()
+	public limitColon: number;
+
+	@Input()
+	public allowOperator: boolean;
+
+	@Input()
+	public limitComma: number;
+
+	@Input()
+	public minNumber: number;
+
+	@Input()
+	public maxNumber: number;
+
+	@HostListener('keydown', ['$event'])
+	onKeyDown(event: KeyboardEvent) {
+		const input = event.key;
+		const numberRegex = /[0-9]+/g;
+		const operatorKeys = ['+', '-', '*', '/', '(', ')'];
+		const specialKeys = [
+			'ArrowLeft',
+			'ArrowRight',
+			'Backspace',
+			'Del',
+			'Delete',
+			'Enter',
+			'Escape',
+			'End',
+			'Home',
+			'Tab'
+		];
+		const value = this.elementRef.nativeElement.value;
+
+		/* Allow Select All, Copy, Paste, Cut */
+
+		if (
+			(event.keyCode === 65 && event.ctrlKey === true) || // Ctrl + A
+			(event.keyCode === 67 && event.ctrlKey === true) || // Ctrl + C
+			(event.keyCode === 86 && event.ctrlKey === true) || // Ctrl + V
+			(event.keyCode === 88 && event.ctrlKey === true) || // Ctrl + X
+			(event.keyCode === 65 && event.metaKey === true) || // Cmd + A
+			(event.keyCode === 67 && event.metaKey === true) || // Cmd + C
+			(event.keyCode === 86 && event.metaKey === true) || // Cmd + V
+			(event.keyCode === 88 && event.metaKey === true) // Cmd + X
+		) {
+			return;
+		}
+
+		/* Allow Special Key */
+
+		if (specialKeys.indexOf(event.key) !== -1) {
+			return;
+		}
+
+		/* Allow Comma */
+
+		if (this.allowComma) {
+			if (this.limitComma !== undefined && numberRegex.test(input)) {
+				const current = this.elementRef.nativeElement.value;
+				const position = this.elementRef.nativeElement.selectionStart;
+				const next = [
+					current.slice(0, position),
+					event.key === 'Decimal' ? '.' : event.key,
+					current.slice(position)
+				].join('');
+				const afterComma = next.split('.')[1];
+
+				if (afterComma && afterComma.length > this.limitComma) {
+					event.preventDefault();
+				}
+
+				return;
+			}
+
+			if (event.key === '.' && !/\./g.test(value)) {
+				return;
+			}
+		}
+
+		/* Allow Colon */
+		if (this.allowColon) {
+			if (this.limitColon !== undefined && numberRegex.test(input)) {
+				const current = this.elementRef.nativeElement.value;
+				const position = this.elementRef.nativeElement.selectionStart;
+				const next = [
+					current.slice(0, position),
+					event.key === 'Decimal' ? ':' : event.key,
+					current.slice(position)
+				].join('');
+				const afterColon = next.split(':')[1];
+
+				if (afterColon && afterColon.length > this.limitColon) {
+					event.preventDefault();
+				}
+
+				return;
+			}
+
+			if (event.key === ':' && !/\./g.test(value)) {
+				return;
+			}
+		}
+
+		/* Allow Operator */
+
+		if (this.allowOperator) {
+			if (operatorKeys.indexOf(event.key) !== -1) {
+				return;
+			}
+		}
+
+		/* Allow Number */
+
+		if (numberRegex.test(input)) {
+			return;
+		}
+
+		event.preventDefault();
+	}
+
+	@HostListener('paste', ['$event'])
+	onPaste(event: ClipboardEvent) {
+		event.preventDefault();
+
+		const pastedInput: string = event.clipboardData
+			.getData('text/plain')
+			.replace(/\D/g, '');
+
+		document.execCommand('insertText', false, pastedInput);
+	}
+
+	constructor(
+		@Self()
+		private ngControl: NgControl,
+		private elementRef: ElementRef
+	) {}
+
+	ngOnInit() {
+		this.subscription = [];
+
+		this.setValueChanges();
+	}
+
+	ngOnDestroy() {
+		this.subscription.forEach(each => each.unsubscribe());
+	}
+
+	private setValueChanges() {
+		const subs = this.ngControl.valueChanges.subscribe(value => {
+			this.value = Number(value);
+
+			clearTimeout(this.debounceTimer);
+
+			this.debounceTimer = setTimeout(() => {
+				this.checkLimit();
+			}, 100);
+		});
+
+		this.subscription.push(subs);
+	}
+
+	private checkLimit() {
+		if (
+			this.minNumber !== undefined &&
+			this.value < Number(this.minNumber)
+		) {
+			this.ngControl.control.setValue(Number(this.minNumber));
+		}
+
+		if (
+			this.maxNumber !== undefined &&
+			this.value > Number(this.maxNumber)
+		) {
+			this.ngControl.control.setValue(Number(this.maxNumber));
+		}
+	}
+}

package/projects/adl-campaign-management-library-internal-test/src/app/ui/http-body-resp.model.ts

@@ -0,0 +1,27 @@
+export class HttpBodyRespModel {
+	public status: number;
+	public errorCode: number;
+	public message: string;
+	public data: any;
+	public totalRecord: number;
+
+	public convert(dto: any): HttpBodyRespModel {
+		if (dto.status) {
+			this.status = dto.status;
+		}
+		if (dto.errorCode) {
+			this.errorCode = dto.errorCode;
+		}
+		if (dto.message) {
+			this.message = dto.message;
+		}
+		if (dto.data) {
+			this.data = dto.data;
+		}
+		if (dto.totalRecord >= 0) {
+			this.totalRecord = dto.totalRecord;
+		}
+
+		return this;
+	}
+}

package/projects/adl-campaign-management-library-internal-test/src/app/ui/http-param-generator.ts

@@ -0,0 +1,19 @@
+import { HttpParams } from '@angular/common/http';
+
+export const generateHttpParams =
+	(params: Object): HttpParams => {
+		let httpParams = new HttpParams();
+
+		if (params) {
+			Object.keys(params).forEach((key) => {
+				if (params[key] !== null
+					&& params[key] !== undefined
+					&& params[key] !== '') {
+
+					httpParams = httpParams.set(key, params[key]);
+				}
+			});
+		}
+
+		return httpParams;
+	};

package/projects/adl-campaign-management-library-internal-test/src/app/ui/pipes/rupiah/rupiah/index.ts

@@ -0,0 +1 @@
+export * from './rupiah.pipe';

package/projects/adl-campaign-management-library-internal-test/src/app/ui/pipes/rupiah/rupiah/rupiah.pipe.spec.ts

@@ -0,0 +1,31 @@
+import { inject, TestBed } from '@angular/core/testing';
+import { RupiahPipe } from './rupiah.pipe';
+
+describe('Pipe: Rupiah', () => {
+	beforeEach(() => {
+		TestBed.configureTestingModule({
+			providers: [RupiahPipe],
+		});
+	});
+
+	it('should has default transform value when null', inject(
+		[RupiahPipe],
+		(rupiah: RupiahPipe) => {
+			expect(rupiah.transform(null)).toBe('Rp 0');
+		}
+	));
+
+	it('should has default transform value when negative', inject(
+		[RupiahPipe],
+		(rupiah: RupiahPipe) => {
+			expect(rupiah.transform(-10000)).toBe('Rp 0');
+		}
+	));
+
+	it("should transform to 'Rp XX.XXX' format", inject(
+		[RupiahPipe],
+		(rupiah: RupiahPipe) => {
+			expect(rupiah.transform(10000)).toBe('Rp 10.000');
+		}
+	));
+});

package/projects/adl-campaign-management-library-internal-test/src/app/ui/pipes/rupiah/rupiah/rupiah.pipe.ts

@@ -0,0 +1,23 @@
+import { Pipe, PipeTransform } from '@angular/core';
+
+@Pipe({ name: 'rupiah' })
+export class RupiahPipe implements PipeTransform {
+	public transform(value: number): string {
+		value = value && value > 0 ? value : 0;
+
+		return 'Rp ' + value.toString().replace(/\B(?=(\d{3})+(?!\d))/g, '.');
+	}
+
+	public parse(value: string): string {
+		return value
+			.toString()
+			.split('.')
+			.join('')
+			.split(',')
+			.join('')
+			.split(' ')
+			.join('')
+			.replace('R', '')
+			.replace('p', '');
+	}
+}

package/projects/adl-campaign-management-library-internal-test/src/app/ui/pipes/rupiah/rupiah.module.ts

@@ -0,0 +1,13 @@
+import { NgModule } from '@angular/core';
+
+import { RupiahPipe } from './rupiah';
+
+@NgModule({
+	declarations: [
+		RupiahPipe
+	],
+	exports: [
+		RupiahPipe
+	]
+})
+export class RupiahModule { }

package/projects/adl-campaign-management-library-internal-test/src/app/ui/pipes/safe/safe/index.ts

@@ -0,0 +1 @@
+export * from './safe.pipe';

package/projects/adl-campaign-management-library-internal-test/src/app/ui/pipes/safe/safe/safe.pipe.ts

@@ -0,0 +1,36 @@
+import { Pipe, PipeTransform } from '@angular/core';
+import {
+	DomSanitizer,
+	SafeHtml,
+	SafeResourceUrl,
+	SafeScript,
+	SafeStyle,
+	SafeUrl,
+} from '@angular/platform-browser';
+
+@Pipe({
+	name: 'safe',
+})
+export class SafePipe implements PipeTransform {
+	constructor(protected domSanitizer: DomSanitizer) {}
+
+	transform(
+		value: string,
+		type: string
+	): SafeHtml | SafeStyle | SafeScript | SafeUrl | SafeResourceUrl {
+		switch (type) {
+			case 'html':
+				return this.domSanitizer.bypassSecurityTrustHtml(value);
+			case 'style':
+				return this.domSanitizer.bypassSecurityTrustStyle(value);
+			case 'script':
+				return this.domSanitizer.bypassSecurityTrustScript(value);
+			case 'url':
+				return this.domSanitizer.bypassSecurityTrustUrl(value);
+			case 'resourceUrl':
+				return this.domSanitizer.bypassSecurityTrustResourceUrl(value);
+			default:
+				return this.domSanitizer.bypassSecurityTrustHtml(value);
+		}
+	}
+}