327 lines
8.4 KiB
TypeScript
327 lines
8.4 KiB
TypeScript
/** @file
|
|
* @author Edouard DUPIN
|
|
* @copyright 2018, Edouard DUPIN, all right reserved
|
|
* @license PROPRIETARY (see license file)
|
|
*/
|
|
|
|
import { ChangeDetectionStrategy, ChangeDetectorRef, Component, OnInit } from '@angular/core';
|
|
import { AdminUserService } from 'app/service';
|
|
import { AsyncActionState } from 'common/component';
|
|
import { SessionService } from 'common/service';
|
|
import {
|
|
checkEmailValidity,
|
|
checkLoginValidity,
|
|
createLoginState,
|
|
createPasswordState,
|
|
isBoolean,
|
|
isInArray,
|
|
isNullOrUndefined,
|
|
isNumber,
|
|
isObject,
|
|
isOptionalArrayOf,
|
|
isOptionalOf,
|
|
isString,
|
|
} from 'common/utils';
|
|
export enum SettingType {
|
|
TITLE = 'TITLE',
|
|
GROUP = 'GROUP',
|
|
LINE = 'LINE',
|
|
BOOLEAN = 'BOOLEAN',
|
|
STRING = 'STRING',
|
|
PASSWORD = 'PASSWORD',
|
|
}
|
|
export function isSettingType(data: any): data is SettingType {
|
|
return isInArray(data, ['TITLE', 'GROUP', 'LINE', 'BOOLEAN', 'STRING', 'PASSWORD']);
|
|
}
|
|
|
|
export interface SettingsItem {
|
|
// Type of the menu Node
|
|
type: SettingType;
|
|
// Displayed Title
|
|
title?: string;
|
|
// Description of the parameter
|
|
description?: string;
|
|
// Image to dsplay that describe the parameter
|
|
image?: string;
|
|
// If true the parameter is applied directly to the backend
|
|
directApply?: boolean;
|
|
// Parameter key to SET/GET
|
|
key?: string;
|
|
// Parameter key to SET/GET or the sub-menu
|
|
value?: SettingsItem[] | boolean | string | Number;
|
|
// whendata is change the value is set here:
|
|
newValue?: boolean | string | Number;
|
|
}
|
|
|
|
export function isSettingsItem(data: any): data is SettingsItem {
|
|
if (isNullOrUndefined(data)) {
|
|
return false;
|
|
}
|
|
if (!isObject(data)) {
|
|
return false;
|
|
}
|
|
if (!isSettingType(data.type)) {
|
|
return false;
|
|
}
|
|
if (!isOptionalOf(data.title, isString)) {
|
|
return false;
|
|
}
|
|
if (!isOptionalOf(data.description, isString)) {
|
|
return false;
|
|
}
|
|
if (!isOptionalOf(data.image, isString)) {
|
|
return false;
|
|
}
|
|
if (!isOptionalOf(data.directApply, isBoolean)) {
|
|
return false;
|
|
}
|
|
if (!isOptionalOf(data.key, isString)) {
|
|
return false;
|
|
}
|
|
if (
|
|
!isOptionalOf(data.value, isBoolean) &&
|
|
!isOptionalOf(data.value, isString) &&
|
|
!isOptionalOf(data.value, isNumber) &&
|
|
!isOptionalArrayOf(data.value, isSettingsItem)
|
|
) {
|
|
return false;
|
|
}
|
|
if (
|
|
!isOptionalOf(data.newValue, isBoolean) &&
|
|
!isOptionalOf(data.newValue, isString) &&
|
|
!isOptionalOf(data.newValue, isNumber)
|
|
) {
|
|
return false;
|
|
}
|
|
return true;
|
|
}
|
|
|
|
@Component({
|
|
selector: 'app-settings',
|
|
templateUrl: './manage-accounts.html',
|
|
styleUrls: ['./manage-accounts.less'],
|
|
changeDetection: ChangeDetectionStrategy.Default,
|
|
})
|
|
export class ManageAccountsScene implements OnInit {
|
|
users: any = [];
|
|
adminLogin: string = "";
|
|
|
|
constructor(
|
|
private adminUserService: AdminUserService,
|
|
private sessionService: SessionService,
|
|
private cdr: ChangeDetectorRef,
|
|
) {
|
|
}
|
|
ngOnInit() {
|
|
this.adminLogin = this.sessionService.getLogin();
|
|
let self = this;
|
|
this.adminUserService
|
|
.getUsers()
|
|
.then((response: any) => {
|
|
console.log(`??? get full response: ${JSON.stringify(response, null, 4)}`);
|
|
self.users = response;
|
|
})
|
|
.catch((error: any) => {
|
|
console.log(`??? get ERROR response: ${JSON.stringify(error, null, 4)}`);
|
|
});
|
|
}
|
|
|
|
onSetAdmin(value: boolean, user: any) {
|
|
user.admin = value;
|
|
console.log(`onSetAdmin: ${value} on ${user.login}`);
|
|
user.adminState = AsyncActionState.LOADING;
|
|
this.cdr.detectChanges();
|
|
let self = this;
|
|
this.adminUserService.setAdmin(user.id, value)
|
|
.then(
|
|
() => {
|
|
user.adminState = AsyncActionState.DONE;
|
|
self.cdr.detectChanges();
|
|
setTimeout(() => {
|
|
user.adminState = undefined;
|
|
self.cdr.detectChanges();
|
|
}, 3000);
|
|
|
|
}
|
|
).catch(
|
|
(error: any) => {
|
|
user.adminState = AsyncActionState.FAIL;
|
|
self.cdr.detectChanges();
|
|
setTimeout(() => {
|
|
user.adminState = undefined;
|
|
user.admin = !value;
|
|
self.cdr.detectChanges();
|
|
}, 3000);
|
|
}
|
|
);
|
|
}
|
|
onSetBlocked(value:boolean, user: any) {
|
|
user.blocked = value;
|
|
console.log(`onSetBlocked: ${value} on ${user.login}`);
|
|
user.blockedState = AsyncActionState.LOADING;
|
|
this.cdr.detectChanges();
|
|
let self = this;
|
|
this.adminUserService.setBlocked(user.id, value)
|
|
.then(
|
|
() => {
|
|
user.blockedState = AsyncActionState.DONE;
|
|
self.cdr.detectChanges();
|
|
setTimeout(() => {
|
|
user.blockedState = undefined;
|
|
self.cdr.detectChanges();
|
|
}, 3000);
|
|
}
|
|
).catch(
|
|
(error: any) => {
|
|
user.blockedState = AsyncActionState.FAIL;
|
|
self.cdr.detectChanges();
|
|
setTimeout(() => {
|
|
user.blockedState = undefined;
|
|
user.blocked = !value;
|
|
self.cdr.detectChanges();
|
|
}, 3000);
|
|
}
|
|
);
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
public password: string = '';
|
|
public passwordState: boolean|string = false;
|
|
|
|
public login: string = '';
|
|
public loginState: boolean|string = false;
|
|
|
|
public email: string = '';
|
|
public emailState: boolean|string = false;
|
|
|
|
public validateButtonCreateUserDisabled: boolean = true;
|
|
/**
|
|
* update the state of the validation button. if all is OK, the button will became clickable
|
|
*/
|
|
updateButtonVisibility(): void {
|
|
if (this.passwordState === true && this.loginState === true && this.emailState === true) {
|
|
this.validateButtonCreateUserDisabled = false;
|
|
} else {
|
|
this.validateButtonCreateUserDisabled = true;
|
|
}
|
|
}
|
|
/**
|
|
* Check if the current password is valid or not (update error message)
|
|
* @param newValue New password value.
|
|
*/
|
|
checkPassword(newValue: string): void {
|
|
this.password = newValue;
|
|
this.passwordState = createPasswordState(this.password);
|
|
this.updateButtonVisibility();
|
|
}
|
|
createState: string | boolean = undefined;
|
|
/**
|
|
* Request the creation of a new user.
|
|
*/
|
|
onCreateUser(): void {
|
|
console.log(`create user:`);
|
|
this.createState = AsyncActionState.LOADING;
|
|
let self = this;
|
|
this.adminUserService.createUsers(this.email, this.login, this.password)
|
|
.then(
|
|
(user_data: any) => {
|
|
self.createState = AsyncActionState.DONE;
|
|
console.log(`Get new user: ${JSON.stringify(user_data, null, 2)}`);
|
|
self.users.push(user_data);
|
|
self.cdr.detectChanges();
|
|
self.checkPassword("");
|
|
self.checkLogin(self.login);
|
|
self.checkEmail(self.email);
|
|
setTimeout(() => {
|
|
this.createState = undefined;
|
|
}, 3000);
|
|
}
|
|
).catch(
|
|
(error: any) => {
|
|
self.createState = AsyncActionState.FAIL;
|
|
setTimeout(() => {
|
|
self.createState = undefined;
|
|
}, 3000);
|
|
}
|
|
);
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
* Check the login writing rules
|
|
*/
|
|
checkLogin(newValue: string): void {
|
|
this.login = newValue;
|
|
this.loginState = createLoginState(this.login);
|
|
if (this.loginState === true) {
|
|
this.loginState = "Checking login ...";
|
|
let self = this;
|
|
this.adminUserService
|
|
.checkLogin(this.login)
|
|
.then((isNotUsed: boolean) => {
|
|
// check if the answer is correct with the question
|
|
if (newValue !== self.login) {
|
|
return;
|
|
}
|
|
if (isNotUsed === false) {
|
|
// the login exist ... ==> it is found...
|
|
self.loginState = 'Login already used ...';
|
|
self.updateButtonVisibility();
|
|
} else {
|
|
self.loginState = true;
|
|
self.updateButtonVisibility();
|
|
}
|
|
})
|
|
.catch((error: number) => {
|
|
console.log(`Status ${error}`);
|
|
self.loginState = 'ErrorOccured in fetching data ...';
|
|
self.updateButtonVisibility();
|
|
});
|
|
}
|
|
this.updateButtonVisibility();
|
|
}
|
|
|
|
checkEmail(newValue: string): void {
|
|
this.email = newValue;
|
|
if (!checkEmailValidity(this.email)) {
|
|
this.emailState = "E-mail is not well formated.";
|
|
this.updateButtonVisibility();
|
|
return;
|
|
}
|
|
this.emailState = "Checking email ...";
|
|
let self = this;
|
|
this.adminUserService.checkEMail(this.email).then(
|
|
(isNotUsed: boolean) => {
|
|
// check if the answer is correct with the question
|
|
if (newValue !== self.email) {
|
|
return;
|
|
}
|
|
if (isNotUsed === false) {
|
|
// the email exist ... ==> it is found...
|
|
self.emailState = 'email already used ...';
|
|
self.updateButtonVisibility();
|
|
} else {
|
|
self.emailState = true;
|
|
self.updateButtonVisibility();
|
|
return;
|
|
}
|
|
})
|
|
.catch((error: number) => {
|
|
console.log(`Status ${error}`);
|
|
self.emailState = 'ErrorOccured in fetching data ...';
|
|
self.updateButtonVisibility();
|
|
}
|
|
);
|
|
this.updateButtonVisibility();
|
|
}
|
|
formatTimestamp(unix_timestamp: number): string {
|
|
return new Date(unix_timestamp).toISOString().replace("T", " ").replace("Z", " GMT").replace(".000", "");
|
|
//return new Date(unix_timestamp).toUTCString();
|
|
//return new Date(unix_timestamp).toLocaleString();
|
|
}
|
|
}
|