unictive-angular 1.0.37 → 1.0.40

package/bin/utils/createStructure.js

@@ -7,17 +7,23 @@ const path_template = path.join(__dirname, "resource");
 // Bisa, Anda dapat menambahkan nama file ke dalam array folders_to_copy.
 // Misal:
 const folders_to_copy = [
+  "workers-site",
   "src/app/API",
   "src/app/core",
   "src/app/shared",
+  "src/app/PAGES",
   "src/app/app.config.ts",
   "src/app/app.routes.ts",
   "src/app/app.ts",
+  "src/app/app.html",
   "src/environments",
+
   // "package.json",
   // "tailwind.config.js",
+  "src/tailwind.css",
   ".postcssrc.json",
   "tsconfig.json",
+  "bitbucket-pipelines.yml",
 ];
 
 async function copy_template() {

package/bin/utils/resource/.postcssrc.json

@@ -1,7 +1,6 @@
 {
     "plugins": {
-      "@tailwindcss/postcss": {},
-      "autoprefixer": {}
+      "@tailwindcss/postcss": {}
     }
 
   }

package/bin/utils/resource/bitbucket-pipelines.yml

@@ -0,0 +1,31 @@
+image: node:22 # Gunakan image Node.js versi 22 untuk menjalankan pipeline
+
+definitions:
+  caches:
+    sonar: ~/.sonar
+    node: ~/.npm # Cache untuk dependencies Node.js
+
+  steps:
+    - step: &build-angular
+        name: Build Angular App
+        image: node:22
+        caches:
+          - node
+        script:
+          - npm install -g wrangler # Install Wrangler CLI versi terbaru
+          - npm install --force # Install dependencies dari package.json di root
+          - npm run build
+          - cd workers-site
+          - npm install
+          - ls
+          - cd ../
+          - CLOUDFLARE_API_TOKEN=$CF_API_TOKEN wrangler deploy --config wrangler.toml
+
+clone:
+  depth: full # Clone seluruh history git (diperlukan SonarQube)
+
+pipelines:
+  branches:
+    staging:
+      # - step: *sonar-analysis
+      - step: *build-angular

package/bin/utils/resource/src/app/API/auth/auth.service.ts

@@ -0,0 +1,160 @@
+import { HttpClient } from '@angular/common/http';
+import { effect, Injectable } from '@angular/core';
+import { singleStoreFactory } from '@core/config/single-store';
+import { AbstractApiService } from '@core/interceptors/jsonrpc';
+import { Entity_User } from '@core/models/entities/user.entity';
+
+import { HelperService, Popup_m } from '@core/services/helper.service';
+import { ForceLogoutReason, ListenerService } from '@core/services/listener.service';
+
+import { logger } from '@shared/utils/logger';
+import { environment } from 'src/environments/environment';
+
+
+@Injectable({
+  providedIn: 'root'
+})
+export class AuthService extends AbstractApiService<any> {
+
+  private isLoggingOut = false;
+
+  constructor(
+    http: HttpClient,
+    private helper: HelperService,
+    private listener: ListenerService
+  ) {
+    super(http, '');
+
+
+    effect(() => {
+      const event = this.listener.forceLogout();
+
+      if (!event || this.isLoggingOut) return;
+
+      this.isLoggingOut = true;
+      this.handleForceLogout(event);
+    });
+  }
+  mockUser = {
+
+    key: "ABC123",
+    peopleId: 123,
+    peopleName: "John Doe",
+    peopleUsername: "johndoe",
+    nip: "123456789",
+    imageProfile: "https://example.com/profile.jpg",
+    positionActive: "Manager",
+    roleActive: 5,
+    positionHistory: {}
+
+  };
+
+
+  async post_login(
+    data: { username: string; password: string },
+    param?: any,
+  ) {
+
+    return Entity_User.load(async () => {
+
+      const params = param ? param : {};
+      const res = await this.post(data, '/login', params);
+      if (res) {
+
+
+        if (res?.data?.is_internal) {
+          this.setLogin(true);
+          this.helper.setStorage('users', res?.data?.user);
+          this.helper.setStorage(environment.tokenName, { token: res?.data?.token, expired: res?.data?.expiresAt });
+        }
+      }
+      logger.log('Logged', res?.data?.user);
+      return res?.data;
+    });
+  }
+
+  initFromApi() {
+    this.helper.getStorage(environment.tokenName).then((res) => {
+      if (res) {
+        this.getUserdata();
+      }
+    })
+  }
+
+  getUserdata(useMock: boolean = false) {
+
+    this.helper.getStorage('users').then((res: any) => {
+      if (res) {
+        Entity_User.set(res);
+      }
+    })
+
+    return Entity_User.load(async () => {
+      let isRole = null;
+      await this.helper.getStorage('role').then((res) => {
+        if (res) {
+          isRole = res;
+        }
+      });
+
+      const res = await this.get(isRole ? `/refresh?role=${isRole}` : '/refresh');
+      if (res) {
+        this.setLogin(true);
+        this.helper.setStorage('users', res?.data?.user);
+      }
+      // logger.log('userdata', res?.data?.user);
+      return res?.data?.user;
+    });
+  }
+
+
+
+
+  setLogin(state: boolean) {
+    const isLogin = singleStoreFactory<{ isLogin: boolean }>();
+    isLogin.set({ isLogin: state });
+  }
+
+
+
+  async logout() {
+    this.helper.showLoading('Logging out...');
+
+    setTimeout(async () => {
+
+
+
+      this.helper.removeStorage('users');
+      this.helper.removeStorage(environment.tokenName);
+      this.helper.removeStorage('isGoogleLogin');
+
+
+      window.location.href = '/';
+      window.location.reload();
+    }, 2000);
+    // await this.logoutNadia();
+  }
+
+
+  handleForceLogout(event: { reason: ForceLogoutReason; payload?: any; at: number }) {
+
+    console.warn('Force logout:', event.reason);
+
+    const popup: Popup_m = {
+      type: 'warning',
+      title: 'Logged out',
+      message: 'Your account has been logged in from another device. You have been logged out for security reasons.',
+      button: 'OK',
+      showCancel: false,
+    };
+
+
+
+    this.helper.confirmationAlert(popup, false).then((ok) => {
+      if (!ok) return;
+      this.listener.clear();
+      this.logout();
+    });
+  }
+
+}

package/bin/utils/resource/src/app/PAGES/authentication/login/login.component.spec.ts

@@ -0,0 +1,28 @@
+/* tslint:disable:no-unused-variable */
+import { async, ComponentFixture, TestBed } from '@angular/core/testing';
+import { By } from '@angular/platform-browser';
+import { DebugElement } from '@angular/core';
+
+import { LoginComponent } from './login.component';
+
+describe('LoginComponent', () => {
+  let component: LoginComponent;
+  let fixture: ComponentFixture<LoginComponent>;
+
+  beforeEach(async(() => {
+    TestBed.configureTestingModule({
+      declarations: [ LoginComponent ]
+    })
+    .compileComponents();
+  }));
+
+  beforeEach(() => {
+    fixture = TestBed.createComponent(LoginComponent);
+    component = fixture.componentInstance;
+    fixture.detectChanges();
+  });
+
+  it('should create', () => {
+    expect(component).toBeTruthy();
+  });
+});

package/bin/utils/resource/src/app/{MODULES → PAGES}/authentication/login/login.component.ts

@@ -1,12 +1,18 @@
 import { Component, OnInit } from '@angular/core';
-import { FormBuilder, FormGroup, Validators } from '@angular/forms';
+import { FormBuilder, FormGroup, Validators, FormsModule, ReactiveFormsModule } from '@angular/forms';
 import { emailPatternValidator } from '@shared/utils/validator_pattern';
+import { CommonModule } from '@angular/common';
+import { InputTextComponent } from '@shared/ui/input-text/input-text.component';
 
 @Component({
   selector: 'app-login',
   templateUrl: './login.component.html',
-  styleUrls: ['./login.component.scss'],
-  standalone: false
+  styleUrls: ['./login.component.css'],
+  imports: [CommonModule,
+    ReactiveFormsModule,
+    FormsModule,
+    InputTextComponent
+  ],
 })
 export class LoginComponent implements OnInit {
   form!: FormGroup;

package/bin/utils/resource/src/app/PAGES/authentication/page404/page404.component.spec.ts

@@ -0,0 +1,28 @@
+/* tslint:disable:no-unused-variable */
+import { async, ComponentFixture, TestBed } from '@angular/core/testing';
+import { By } from '@angular/platform-browser';
+import { DebugElement } from '@angular/core';
+
+import { Page404Component } from './page404.component';
+
+describe('Page404Component', () => {
+  let component: Page404Component;
+  let fixture: ComponentFixture<Page404Component>;
+
+  beforeEach(async(() => {
+    TestBed.configureTestingModule({
+      declarations: [ Page404Component ]
+    })
+    .compileComponents();
+  }));
+
+  beforeEach(() => {
+    fixture = TestBed.createComponent(Page404Component);
+    component = fixture.componentInstance;
+    fixture.detectChanges();
+  });
+
+  it('should create', () => {
+    expect(component).toBeTruthy();
+  });
+});

package/bin/utils/resource/src/app/{MODULES → PAGES}/authentication/page404/page404.component.ts

@@ -3,8 +3,7 @@ import { Component, OnInit } from '@angular/core';
 @Component({
   selector: 'app-page404',
   templateUrl: './page404.component.html',
-  styleUrls: ['./page404.component.scss'],
-  standalone: false
+  styleUrls: ['./page404.component.css']
 })
 export class Page404Component implements OnInit {
 

package/bin/utils/resource/src/app/PAGES/home/home.component.html

@@ -0,0 +1,5 @@
+<p>
+  home works!
+</p>
+
+<app-widget_game></app-widget_game>

package/bin/utils/resource/src/app/PAGES/home/home.component.spec.ts

@@ -0,0 +1,28 @@
+/* tslint:disable:no-unused-variable */
+import { async, ComponentFixture, TestBed } from '@angular/core/testing';
+import { By } from '@angular/platform-browser';
+import { DebugElement } from '@angular/core';
+
+import { HomeComponent } from './home.component';
+
+describe('HomeComponent', () => {
+  let component: HomeComponent;
+  let fixture: ComponentFixture<HomeComponent>;
+
+  beforeEach(async(() => {
+    TestBed.configureTestingModule({
+      declarations: [ HomeComponent ]
+    })
+    .compileComponents();
+  }));
+
+  beforeEach(() => {
+    fixture = TestBed.createComponent(HomeComponent);
+    component = fixture.componentInstance;
+    fixture.detectChanges();
+  });
+
+  it('should create', () => {
+    expect(component).toBeTruthy();
+  });
+});

package/bin/utils/resource/src/app/{MODULES → PAGES}/home/home.component.ts

@@ -1,10 +1,10 @@
 import { Component, OnInit } from '@angular/core';
-
+import { Widget_gameModule } from '@shared/widgets/widget_game/widget_game.module';
 @Component({
   selector: 'app-home',
   templateUrl: './home.component.html',
-  styleUrls: ['./home.component.scss'],
-  standalone: false
+  styleUrls: ['./home.component.css'],
+  imports: [Widget_gameModule],
 })
 export class HomeComponent implements OnInit {
 

package/bin/utils/resource/src/app/app.config.ts

@@ -1,5 +1,7 @@
 import {
   ApplicationConfig,
+  inject,
+  provideAppInitializer,
   provideBrowserGlobalErrorListeners,
   provideZonelessChangeDetection,
 } from '@angular/core';
@@ -9,12 +11,40 @@ import { routes } from './app.routes';
 import { provideHttpClient, withInterceptors } from '@angular/common/http';
 import { jwtInterceptor } from '@core/interceptors/jwt.interceptor';
 import { errorInterceptor } from '@core/interceptors/error.interceptor';
+import { provideAnimationsAsync } from '@angular/platform-browser/animations/async';
+
+import { AuthService } from '@api/auth/auth.service';
+import { providePrimeNG } from 'primeng/config';
+import Aura from '@primeuix/themes/aura';
+
+export function appInitFactoryFromApi(auth: AuthService) {
+  return auth.initFromApi();
+}
 
 export const appConfig: ApplicationConfig = {
   providers: [
     provideBrowserGlobalErrorListeners(),
+    provideAnimationsAsync(),
     provideZonelessChangeDetection(),
     provideRouter(routes),
     provideHttpClient(withInterceptors([jwtInterceptor, errorInterceptor])),
+    provideAppInitializer(() => appInitFactoryFromApi(inject(AuthService))),
+
+    providePrimeNG({
+      theme: {
+        preset: Aura,
+        options: {
+          darkModeSelector: '[data-theme="dark"]',
+          lightModeSelector: '[data-theme="light"]',
+        },
+      },
+
+      zIndex: {
+        modal: 1100,    // dialog, sidebar
+        overlay: 1000,  // dropdown, overlaypanel
+        menu: 1000,     // overlay menus
+        tooltip: 1100   // tooltip
+      }
+    }),
   ],
 };

package/bin/utils/resource/src/app/app.routes.ts

@@ -3,20 +3,17 @@ import { Routes } from '@angular/router';
 export const routes: Routes = [
     {
         path: '',
-        loadChildren: () => import('./MODULES/home/home.module').then(m => m.HomeModule)
+        loadComponent: () => import('./PAGES/home/home.component').then(m => m.HomeComponent)
     },
 
     //MARK: AUTHENTICATION
     {
         path: 'login',
-        loadChildren: () => import('./MODULES/authentication/login/login.module').then(m => m.LoginModule)
-    },
-    {
-        path: 'register',
-        loadChildren: () => import('./MODULES/authentication/register/register.module').then(m => m.RegisterModule)
+        loadComponent: () => import('./PAGES/authentication/login/login.component').then(m => m.LoginComponent)
     },
+
     {
         path: '**',
-        loadChildren: () => import('./MODULES/authentication/page404/page404.module').then(m => m.Page404Module)
+        loadComponent: () => import('./PAGES/authentication/page404/page404.component').then(m => m.Page404Component)
     }
 ];

package/bin/utils/resource/src/app/app.ts

@@ -1,21 +1,21 @@
 import { ChangeDetectorRef, Component, effect, OnInit } from '@angular/core';
 import { RouterOutlet } from '@angular/router';
 import { Entity_User } from '@core/models/entities/user.entity';
-import { Repo_User } from '@core/respository/user/user_repo';
-
 import { logger } from '@shared/utils/logger';
+
+
 @Component({
   selector: 'app-root',
   imports: [RouterOutlet],
   templateUrl: './app.html',
-  styleUrl: './app.scss',
+  styleUrl: './app.css',
 })
 export class App implements OnInit {
   protected title = 'OLD PROJECT';
 
   user = Entity_User.state();
 
-  constructor(private cdr: ChangeDetectorRef, private repo_user: Repo_User) {
+  constructor(private cdr: ChangeDetectorRef) {
     effect(() => {
       const user = this.user.value;
       logger.log('User state changed:', user);
@@ -26,7 +26,8 @@ export class App implements OnInit {
 
   ngOnInit(): void {
 
-    this.repo_user.load_user();
+
+
 
     //MARK:TEST
     setTimeout(() => {

package/bin/utils/resource/src/app/core/config/entity-store.ts

@@ -1,4 +1,5 @@
 import { signal, computed } from '@angular/core';
+import { filter } from 'rxjs';
 
 export interface EntityState<T> {
     value: T[];
@@ -6,37 +7,60 @@ export interface EntityState<T> {
     error?: string;
 }
 
-export function entityStoreFactory<T extends { id: string | number }>() {
+export function entityStoreFactory<
+    T extends Record<any, any>,
+    K extends keyof T = 'id'
+>(keyField?: K | any) {
+
+    // console.log('ListStoreFactory keyField:', keyField);
+    const field = (keyField ?? ('id' as K));
+
     const _state = signal<EntityState<T>>({ value: [], loading: false });
 
+    const mapByKey = computed(() => {
+        const map = new Map<T[K], T>();
+        for (const item of _state().value) {
+            map.set(item[field], item);
+        }
+        return map;
+    });
+
     return {
         state: _state,
+        keyField: field,
+        mapByKey,
 
-        // Mutations
+        // --- Mutations ---
         setAll(value: T[]) {
             _state.set({ value, loading: false });
         },
 
+        filtered(predicate?: (item: T) => boolean) {
+            return computed(() =>
+                predicate ? _state().value.filter(predicate) : _state().value
+            );
+        },
+
         add(item: T) {
             _state.update((curr) => ({
                 ...curr,
-                value: [...curr.value, item]
+                value: [...curr.value, item],
             }));
         },
 
-        update(id: T['id'], partial: Partial<T>) {
+        update(key: T[K], partial: Partial<T>) {
             _state.update((curr) => ({
                 ...curr,
                 value: curr.value.map((i) =>
-                    i.id === id ? { ...i, ...partial } : i
-                )
+                    i[field] === key ? { ...i, ...partial } : i
+                ),
             }));
         },
 
-        remove(id: T['id']) {
+        remove(key: T[K]) {
             _state.update((curr) => ({
                 ...curr,
-                value: curr.value.filter((i) => i.id !== id)
+                value: curr.value.filter((i) => i[field] !== key),
             }));
         },
 
@@ -44,26 +68,31 @@ export function entityStoreFactory<T extends { id: string | number }>() {
             _state.set({ value: [], loading: false });
         },
 
-        // Selectors
-        getById: (id: T['id']) =>
-            computed(() => _state().value.find((i) => i.id === id)),
+        // --- Selectors ---
+        getByKey: (key: T[K]) => computed(() => mapByKey().get(key)),
 
         all: computed(() => _state().value),
         count: computed(() => _state().value.length),
 
-        // Async Loader
+        // --- Async Loader ---
         async load(fetchFn: () => Promise<T[]>) {
-            _state.update((curr) => ({ ...curr, loading: true, error: undefined }));
+            _state.update((curr) => ({
+                ...curr,
+                loading: true,
+                error: undefined,
+            }));
             try {
                 const data = await fetchFn();
                 _state.set({ value: data, loading: false });
+                return data;
             } catch (err: any) {
                 _state.update((curr) => ({
                     ...curr,
                     loading: false,
-                    error: err.message ?? 'Unknown error'
+                    error: err.message ?? 'Unknown error',
                 }));
+                return [];
             }
-        }
+        },
     };
 }

package/bin/utils/resource/src/app/core/config/single-store.ts

@@ -39,12 +39,14 @@ export function singleStoreFactory<T>() {
             try {
                 const data = await fetchFn();
                 _state.set({ value: data, loading: false });
+                return data;
             } catch (err: any) {
                 _state.update((curr) => ({
                     ...curr,
                     loading: false,
                     error: err.message ?? 'Unknown error'
                 }));
+                return Promise.reject(err);
             }
         }
     };

package/bin/utils/resource/src/app/core/guards/auth.guard.ts

@@ -0,0 +1,43 @@
+import { inject } from '@angular/core';
+import { CanActivateFn, Router } from '@angular/router';
+import { AuthService } from '@api/auth/auth.service';
+import { HelperService } from '@core/services/helper.service';
+import { StorageMap } from '@ngx-pwa/local-storage';
+import { logger } from '@shared/utils/logger';
+import { lastValueFrom, map } from 'rxjs';
+import { environment } from 'src/environments/environment';
+
+export const authGuard: CanActivateFn = (route, state) => {
+    const router = inject(Router);
+    const storage = inject(StorageMap);
+    const auth = inject(AuthService);
+
+    return storage.get(environment.tokenName).pipe(
+        map((token: any) => {
+            if (token) {
+                auth.setLogin(true);
+
+                // logger.log('Token', token);
+
+
+
+                // router.navigateByUrl('/');
+                // helper.showPopup(
+                //   'error',
+                //   'Maaf',
+                //   'Mohon untuk logout akun terlebih dahulu di browser ini!'
+                // );
+                return true;
+            } else {
+                auth.setLogin(false);
+                lastValueFrom(storage.clear());
+                router.navigateByUrl('/login');
+                setTimeout(() => {
+                    window.location.reload();
+                }, 2000);
+                return false;
+
+            }
+        })
+    );
+};