=> {
+ const result: object | string = await Promise.race([
+ action,
+ timeout(TIME_OUT_SEC),
+ ]);
+
+ return result;
+};
+
+export const renderRequiredText = (field: string, element: Element) => {
+ const markup: string = `
+ ${MESSAGE.REQUIRED_MESSAGE(field)}
+ `;
+
+ element.insertAdjacentHTML('afterend', markup);
+};
+
+export const redirectToLoginPage = () => {
+ window.location.replace('/login');
+};
diff --git a/typescript-practice/src/ts/services/commonService.ts b/typescript-practice/src/ts/services/commonService.ts
new file mode 100644
index 0000000..eb3d611
--- /dev/null
+++ b/typescript-practice/src/ts/services/commonService.ts
@@ -0,0 +1,104 @@
+import {
+ convertDataObjectToModel,
+ convertModelToDataObject,
+ timeOutConnect,
+} from '../helpers/helpers';
+import FirebaseService from './firebaseService';
+
+export default class CommonService {
+ constructor() {
+ this.defaultPath = '/';
+ this.firebaseService = FirebaseService;
+ }
+
+ /**
+ * Connect to Firebase Databse
+ */
+ connectToDb() {
+ this.firebaseService.reconnect();
+ }
+
+ async getDataFromProp(property, value, path = this.defaultPath) {
+ this.connectToDb();
+ const data = this.firebaseService.getDataFromProp(path, property, value);
+ const result = await timeOutConnect(data);
+
+ if (result.id && result.data) {
+ return convertDataObjectToModel(result);
+ }
+
+ return null;
+ }
+
+ /**
+ * Save data on database
+ * @param {*} data The data wants to save on database
+ * @param {string} path The path of database
+ */
+ async save(model) {
+ this.connectToDb();
+ const results = convertModelToDataObject(model);
+
+ const saveData = this.firebaseService.save(
+ results.data,
+ this.defaultPath + results.id,
+ );
+
+ await timeOutConnect(saveData);
+ }
+
+ /**
+ *
+ * @param {string} id The string of data object
+ * @param {string} path The path of database
+ * @returns {Object || null} Return the object if has, otherwise return null
+ */
+ async getDataFromId(id, path = this.defaultPath) {
+ this.connectToDb();
+ const result = await this.firebaseService.getDataFromId(id, path);
+ const data = await timeOutConnect(result);
+
+ if (data) return data;
+
+ return null;
+ }
+
+ async getAllDataFromPath(path = this.defaultPath) {
+ this.connectToDb();
+
+ const results = await timeOutConnect(
+ this.firebaseService.getAllDataFromPath(path),
+ );
+
+ if (results) {
+ // Convert format object
+ return results.map((data) => {
+ return convertDataObjectToModel(data);
+ });
+ }
+
+ return null;
+ }
+
+ async getListDataFromProp(property, value, path = this.defaultPath) {
+ this.connectToDb();
+
+ const results = await timeOutConnect(
+ this.firebaseService.getListDataFromProp(path, property, value),
+ );
+ if (results) {
+ // Convert format object
+
+ return results.map((data) => {
+ return convertDataObjectToModel(data);
+ });
+ }
+
+ return null;
+ }
+
+ async deleteData(id, path = this.defaultPath) {
+ this.connectToDb();
+ await timeOutConnect(this.firebaseService.delete(id, path));
+ }
+}
diff --git a/typescript-practice/src/ts/services/firebaseService.ts b/typescript-practice/src/ts/services/firebaseService.ts
new file mode 100644
index 0000000..d0c9b09
--- /dev/null
+++ b/typescript-practice/src/ts/services/firebaseService.ts
@@ -0,0 +1,163 @@
+import { FirebaseApp, initializeApp } from 'firebase/app';
+import {
+ getDatabase,
+ ref,
+ set,
+ goOffline,
+ goOnline,
+ onValue,
+ remove,
+ Database,
+} from 'firebase/database';
+import { DATABASE_URL } from '../constants/config';
+
+class FirebaseService {
+ private app: FirebaseApp;
+ private db: Database;
+
+ constructor() {
+ const firebaseConfig = {
+ databaseURL: DATABASE_URL,
+ };
+ this.app = initializeApp(firebaseConfig);
+ this.db = getDatabase(this.app);
+ }
+
+ /**
+ * Save data in database
+ * @param {Object} data The object need to save into database
+ * @param {string} path The path of database need to be save
+ * @returns {Promise} Return the resolves when write to database completed
+ */
+ save(data: object, path: string): Promise {
+ return set(ref(this.db, path), data);
+ }
+
+ delete(id: string, path: string) {
+ return remove(ref(this.db, path + id));
+ }
+
+ /**
+ * Disconnect to database
+ */
+ disconnect() {
+ goOffline(this.db);
+ }
+
+ /**
+ * Reconnect to database
+ */
+ reconnect() {
+ goOnline(this.db);
+ }
+
+ /**
+ * Find id of value by property in database
+ * @param {string} path The path of database to be found
+ * @param {string} property The property of the value need to be found
+ * @param {value} value The value to compare in database
+ * @returns {Promise} Return the resolve when find completed
+ */
+ getDataFromProp(path: string, property: string, value: object): Promise {
+ return new Promise((resolve) => {
+ onValue(
+ ref(this.db, path),
+ (snapshot) => {
+ let id: string | null = null;
+ let data: object | null = null;
+
+ // snapshot is a type of data by Firebase define
+ snapshot.forEach((childSnapshot) => {
+ const dataTemp = childSnapshot.val();
+
+ if (dataTemp[property] === value) {
+ id = childSnapshot.key;
+ data = dataTemp;
+ }
+ });
+ resolve({ id, data });
+ },
+ {
+ onlyOnce: true,
+ },
+ );
+ });
+ }
+
+ /**
+ * Get data object from Id
+ * @param {string} id The id of data object
+ * @param {string} path The path of data save in database
+ * @returns {Promise} Return new Promise
+ */
+ getDataFromId(id: string, path: string): Promise {
+ return new Promise((resolve) => {
+ onValue(
+ ref(this.db, path + id),
+ (snapshot) => {
+ resolve(snapshot.val());
+ },
+ {
+ onlyOnce: true,
+ },
+ );
+ });
+ }
+
+ getAllDataFromPath(path) {
+ return new Promise((resolve) => {
+ onValue(
+ ref(this.db, path),
+ (snapshot) => {
+ const listData: object[] = [];
+
+ // snapshot is a type of data by Firebase define
+ snapshot.forEach((childSnapshot) => {
+ let id: string | null = null;
+ let data: object | null = null;
+
+ id = childSnapshot.key;
+ data = childSnapshot.val();
+
+ listData.push({ id, data });
+ });
+ resolve(listData);
+ },
+ {
+ onlyOnce: true,
+ },
+ );
+ });
+ }
+
+ getListDataFromProp(path: string, property: string, value: object) {
+ return new Promise((resolve) => {
+ onValue(
+ ref(this.db, path),
+ (snapshot) => {
+ let id: string;
+ let data: object;
+ const listData: object[] = [];
+
+ // snapshot is a type of data by Firebase define
+ snapshot.forEach((childSnapshot) => {
+ const dataTemp = childSnapshot.val();
+
+ if (dataTemp[property] === value) {
+ id = childSnapshot.key;
+ data = dataTemp;
+
+ listData.push({ id, data });
+ }
+ });
+ resolve(listData);
+ },
+ {
+ onlyOnce: true,
+ },
+ );
+ });
+ }
+}
+
+export default new FirebaseService();
diff --git a/typescript-practice/src/ts/services/index.ts b/typescript-practice/src/ts/services/index.ts
new file mode 100644
index 0000000..a5d1d4c
--- /dev/null
+++ b/typescript-practice/src/ts/services/index.ts
@@ -0,0 +1 @@
+export default class Service {}
diff --git a/typescript-practice/src/ts/services/localStorageService.ts b/typescript-practice/src/ts/services/localStorageService.ts
new file mode 100644
index 0000000..93ca214
--- /dev/null
+++ b/typescript-practice/src/ts/services/localStorageService.ts
@@ -0,0 +1,25 @@
+class LocalStorageService {
+ private localStorage: Storage;
+
+ constructor() {
+ this.localStorage = localStorage;
+ }
+
+ add(key: string, value: string) {
+ this.localStorage.setItem(key, value);
+ }
+
+ get(key: string) {
+ return this.localStorage.getItem(key);
+ }
+
+ remove(key: string) {
+ this.localStorage.removeItem(key);
+ }
+
+ clear() {
+ this.localStorage.clear();
+ }
+}
+
+export default new LocalStorageService();