aril 1.0.39 → 1.0.41

package/theme/layout/app/history/history-sidebar.component.html

@@ -0,0 +1,88 @@
+<p-sidebar
+	[(visible)]="visible"
+	position="right"
+	[transitionOptions]="'.3s cubic-bezier(0, 0, 0.2, 1)'"
+	styleClass="layout-history-sidebar w-full sm:w-30rem"
+	*transloco="let t; read: 'history'">
+	<ng-template pTemplate="header">
+		<div class="flex align-items-center justify-content-between w-full">
+			<div class="flex align-items-center">
+				<i class="pi pi-history text-primary text-xl"></i>
+				<span class="font-bold text-lg">{{ t('pageHistory') }}</span>
+			</div>
+		</div>
+	</ng-template>
+
+	<div class="history-content">
+		@if (history().length > 0) {
+			<div class="search-section">
+				<div class="search-input-container">
+					<aril-text
+						class="w-full"
+						[placeholder]="t('searchHistory')"
+						[(ngModel)]="searchTerm"
+						(ngModelChange)="onSearchChange()">
+					</aril-text>
+
+					<aril-button
+						icon="TRASH"
+						color="danger"
+						size="sm"
+						class="ml-1"
+						[pTooltip]="t('confirmClearAll')"
+						tooltipPosition="left"
+						(clickEvent)="clearAllHistory($event)">
+					</aril-button>
+				</div>
+			</div>
+		}
+
+		@if (filteredHistory().length > 0) {
+			<div class="history-list">
+				<p-scrollPanel [style]="{ width: '100%', height: '100%' }">
+					<div class="history-items">
+						@for (item of filteredHistory(); track trackByItemId($index, item)) {
+							<div class="history-item" (click)="navigateToItem(item)">
+								<div class="item-content">
+									<div class="item-header">
+										<div class="item-title">
+											<i class="pi pi-external-link text-primary mr-2"></i>
+											<div class="title-info">
+												<span class="title-text">{{ getLocalizedTitle(item) }}</span>
+												<span class="route-text">{{ item.url }}</span>
+											</div>
+										</div>
+									</div>
+								</div>
+							</div>
+						}
+					</div>
+				</p-scrollPanel>
+			</div>
+		} @else {
+			<div class="empty-state">
+				<div class="empty-content">
+					<i class="pi pi-history empty-icon"></i>
+					<h3 class="empty-title">
+						{{ searchTerm() ? t('noSearchResults') : t('noHistory') }}
+					</h3>
+					<p class="empty-message">
+						{{ searchTerm() ? t('tryDifferentKeywords') : t('startBrowsing') }}
+					</p>
+					@if (searchTerm()) {
+						<aril-button
+							[label]="t('clearSearch')"
+							icon="TIMES"
+							color="secondary"
+							[outlined]="true"
+							size="sm"
+							(clickEvent)="searchTerm.set(''); onSearchChange()">
+						</aril-button>
+					}
+				</div>
+			</div>
+		}
+	</div>
+
+	<p-confirmDialog></p-confirmDialog>
+</p-sidebar>

package/theme/layout/app/history/history-sidebar.component.scss

@@ -0,0 +1,191 @@
+:host ::ng-deep {
+	.layout-history-sidebar {
+		.p-sidebar-content {
+			padding: 0;
+			background: var(--surface-ground);
+		}
+		.p-sidebar-header {
+			background: var(--primary-color);
+			color: var(--primary-color-text);
+			border-bottom: 1px solid var(--primary-600);
+			padding: 1rem 0.5rem;
+
+			i {
+				color: var(--primary-color-text);
+				font-size: 1.1rem;
+			}
+
+			span {
+				font-size: 1.1rem;
+				font-weight: 600;
+				color: var(--primary-color-text);
+			}
+		}
+	}
+}
+
+.history-content {
+	display: flex;
+	flex-direction: column;
+	height: 92vh;
+	background: var(--surface-0);
+}
+
+.search-section {
+	padding: 1rem;
+	border-bottom: 1px solid var(--surface-border);
+	background: var(--surface-0);
+	width: 100%;
+}
+
+.search-input-container {
+	display: flex;
+	align-items: center;
+	justify-content: space-between;
+	width: 100%;
+}
+
+// History List
+.history-list {
+	flex: 1;
+	overflow: hidden;
+}
+
+.history-items {
+	padding: 0.5rem;
+}
+
+.history-item {
+	background: var(--surface-0);
+	border: 1px solid var(--surface-border);
+	border-radius: 8px;
+	margin-bottom: 0.5rem;
+	cursor: pointer;
+	transition: all 0.2s ease;
+	position: relative;
+	overflow: hidden;
+
+	&:hover {
+		border-color: var(--primary-200);
+		background: var(--primary-50);
+		transform: translateY(-1px);
+		box-shadow: 0 2px 8px rgba(0, 0, 0, 0.1);
+		.remove-btn {
+			opacity: 1;
+		}
+	}
+	&:last-child {
+		margin-bottom: 0;
+	}
+}
+
+.item-content {
+	padding: 1rem 0.75rem;
+}
+
+.item-header {
+	display: flex;
+	align-items: center;
+	justify-content: space-between;
+}
+
+.item-title {
+	display: flex;
+	align-items: center;
+	flex: 1;
+	min-width: 0;
+
+	.title-info {
+		display: flex;
+		flex-direction: column;
+		flex: 1;
+		min-width: 0;
+	}
+
+	.title-text {
+		font-weight: 600;
+		color: var(--text-color);
+		font-size: 1rem;
+		line-height: 1.3;
+		overflow: hidden;
+		text-overflow: ellipsis;
+		white-space: nowrap;
+	}
+
+	.route-text {
+		font-size: 0.75rem;
+		color: var(--text-color-secondary);
+		font-weight: 400;
+		line-height: 1.2;
+		margin-top: 0.25rem;
+		overflow: hidden;
+		text-overflow: ellipsis;
+		white-space: nowrap;
+		opacity: 0.8;
+	}
+}
+
+.empty-state {
+	flex: 1;
+	display: flex;
+	align-items: center;
+	justify-content: center;
+	padding: 2rem;
+}
+
+.empty-content {
+	text-align: center;
+	max-width: 300px;
+}
+
+.empty-icon {
+	font-size: 3rem;
+	color: var(--text-color-secondary);
+	margin-bottom: 1rem;
+	opacity: 0.5;
+}
+
+.empty-title {
+	font-size: 1.1rem;
+	font-weight: 600;
+	color: var(--text-color);
+	margin-bottom: 0.5rem;
+}
+
+.empty-message {
+	font-size: 0.9rem;
+	color: var(--text-color-secondary);
+	line-height: 1.4;
+	margin-bottom: 1.5rem;
+}
+
+@media (max-width: 768px) {
+	.history-content {
+		height: calc(100vh - 3.5rem);
+	}
+
+	.search-section {
+		padding: 0.75rem;
+	}
+
+	.item-content {
+		padding: 0.5rem;
+	}
+
+	.item-title .title-text {
+		font-size: 0.85rem;
+	}
+}
+
+// Custom Scrollbar
+:host ::ng-deep {
+	.p-scrollpanel-bar-y {
+		background: var(--primary-200);
+		width: 4px;
+		border-radius: 2px;
+	}
+
+	.p-scrollpanel-bar-y:hover {
+		background: var(--primary-300);
+	}
+}

package/theme/layout/app/history/history-sidebar.component.ts

@@ -0,0 +1,139 @@
+import { CommonModule } from '@angular/common';
+import { Component, OnDestroy, OnInit, signal } from '@angular/core';
+import { FormsModule } from '@angular/forms';
+
+import { ConfirmationService, MessageService } from 'primeng/api';
+import { BadgeModule } from 'primeng/badge';
+import { ConfirmDialogModule } from 'primeng/confirmdialog';
+import { InputTextModule } from 'primeng/inputtext';
+import { ScrollPanelModule } from 'primeng/scrollpanel';
+import { SidebarModule } from 'primeng/sidebar';
+import { TooltipModule } from 'primeng/tooltip';
+
+import { TranslocoModule, TranslocoService } from '@ngneat/transloco';
+import { Subject, takeUntil } from 'rxjs';
+
+import { ButtonComponent } from 'aril/ui/button';
+import { TextComponent } from 'aril/ui/text';
+
+import { LayoutService } from '../../service/app.layout.service';
+import { HistoryItem, HistoryService } from './history.service';
+
+@Component({
+	standalone: true,
+	selector: 'app-history-sidebar',
+	imports: [
+		CommonModule,
+		FormsModule,
+		SidebarModule,
+		ButtonComponent,
+		InputTextModule,
+		ScrollPanelModule,
+		ConfirmDialogModule,
+		TooltipModule,
+		BadgeModule,
+		TranslocoModule,
+		TextComponent
+	],
+	templateUrl: './history-sidebar.component.html',
+	styleUrls: ['./history-sidebar.component.scss'],
+	providers: [ConfirmationService]
+})
+export class HistorySidebarComponent implements OnInit, OnDestroy {
+	history = signal<HistoryItem[]>([]);
+	filteredHistory = signal<HistoryItem[]>([]);
+	searchTerm = signal<string>('');
+
+	private destroy$ = new Subject<void>();
+
+	constructor(
+		public layoutService: LayoutService,
+		private historyService: HistoryService,
+		private confirmationService: ConfirmationService,
+		private messageService: MessageService,
+		private translocoService: TranslocoService
+	) {}
+
+	ngOnInit(): void {
+		this.historyService.history$.pipe(takeUntil(this.destroy$)).subscribe((history) => {
+			this.history.set(history);
+			this.applyFilter();
+		});
+	}
+
+	ngOnDestroy(): void {
+		this.destroy$.next();
+		this.destroy$.complete();
+	}
+
+	get visible(): boolean {
+		return this.layoutService.state.historySidebarVisible;
+	}
+
+	set visible(value: boolean) {
+		this.layoutService.state.historySidebarVisible = value;
+	}
+
+	onSearchChange(): void {
+		this.applyFilter();
+	}
+
+	private applyFilter(): void {
+		const searchTerm = this.searchTerm();
+		if (!searchTerm.trim()) {
+			this.filteredHistory.set(this.history());
+		} else {
+			const filtered = this.historyService.getHistoryItemsBySearchTerm(searchTerm);
+			this.filteredHistory.set(filtered);
+		}
+	}
+
+	navigateToItem(item: HistoryItem): void {
+		this.historyService.navigateToHistoryItem(item);
+		this.visible = false;
+	}
+
+	clearAllHistory(event: Event): void {
+		this.confirmationService.confirm({
+			target: event.target as EventTarget,
+			message: this.translocoService.translate('history.confirmClearAllMessage'),
+			header: this.translocoService.translate('history.deleteConfirmation'),
+			icon: 'pi pi-info-circle',
+			acceptLabel: this.translocoService.translate('history.acceptButtonLabel'),
+			rejectLabel: this.translocoService.translate('history.rejectButtonLabel'),
+			acceptButtonStyleClass: 'p-button-success',
+			rejectButtonStyleClass: 'p-button-danger p-button-outlined',
+			accept: () => {
+				this.historyService.clearHistory();
+				this.messageService.add({
+					severity: 'success',
+					summary: this.translocoService.translate('history.acceptButtonLabel'),
+					detail: this.translocoService.translate('history.clearAll')
+				});
+			}
+		});
+	}
+
+	trackByItemId(index: number, item: HistoryItem) {
+		return item.id || index;
+	}
+
+	getLocalizedTitle(item: HistoryItem): string {
+		const currentLang = this.translocoService.getActiveLang() as 'tr' | 'en';
+
+		// Use multiLanguageTitle if available
+		if (item.multiLanguageTitle) {
+			const localizedTitle = item.multiLanguageTitle[currentLang];
+			if (localizedTitle) {
+				return localizedTitle;
+			}
+			// Fallback to Turkish if current language not available
+			if (item.multiLanguageTitle.tr) {
+				return item.multiLanguageTitle.tr;
+			}
+		}
+
+		// Fallback to original title
+		return item.title;
+	}
+}

package/theme/layout/app/history/history.service.d.ts

@@ -0,0 +1,36 @@
+import { Observable } from 'rxjs';
+import * as i0 from "@angular/core";
+export interface HistoryItem {
+    id: string;
+    title: string;
+    multiLanguageTitle?: {
+        tr?: string;
+        en?: string;
+    };
+    url: string;
+    timestamp: number;
+}
+export declare class HistoryService {
+    private readonly STORAGE_KEY;
+    private readonly MAX_HISTORY_SIZE;
+    private historySubject;
+    history$: Observable<HistoryItem[]>;
+    private excludedPaths;
+    private router;
+    private translocoService;
+    constructor();
+    private initializeRouterTracking;
+    private addToHistory;
+    private shouldExcludeUrl;
+    private findMenuItemByPath;
+    private findMenuItemRecursive;
+    private generateId;
+    private loadHistoryFromStorage;
+    private saveHistoryToStorage;
+    clearHistory(): void;
+    navigateToHistoryItem(item: HistoryItem): void;
+    private getHistoryFromStorage;
+    getHistoryItemsBySearchTerm(searchTerm: string): HistoryItem[];
+    static ɵfac: i0.ɵɵFactoryDeclaration<HistoryService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<HistoryService>;
+}

package/theme/layout/app/history/history.service.ts

@@ -0,0 +1,182 @@
+import { Injectable, inject } from '@angular/core';
+import { Router, NavigationEnd } from '@angular/router';
+import { BehaviorSubject, Observable } from 'rxjs';
+import { filter, map } from 'rxjs/operators';
+import { TranslocoService } from '@ngneat/transloco';
+
+import { PluginMenuItem } from 'aril/boot/config/apps';
+
+export interface HistoryItem {
+	id: string;
+	title: string;
+	multiLanguageTitle?: {
+		tr?: string;
+		en?: string;
+	};
+	url: string;
+	timestamp: number;
+}
+
+@Injectable({
+	providedIn: 'root'
+})
+export class HistoryService {
+	private readonly STORAGE_KEY = 'page_history';
+	private readonly MAX_HISTORY_SIZE = 20;
+
+	private historySubject = new BehaviorSubject<HistoryItem[]>([]);
+	public history$: Observable<HistoryItem[]> = this.historySubject.asObservable();
+
+	// Excluded paths that shouldn't be tracked
+	private excludedPaths = ['/login', '/logout', '/error', '/not-found', '/unauthorized'];
+
+	private router = inject(Router);
+	private translocoService = inject(TranslocoService);
+
+	constructor() {
+		this.loadHistoryFromStorage();
+		this.initializeRouterTracking();
+	}
+
+	private initializeRouterTracking(): void {
+		this.router.events
+			.pipe(
+				filter((event) => event instanceof NavigationEnd),
+				map((event) => event as NavigationEnd)
+			)
+			.subscribe((event: NavigationEnd) => {
+				this.addToHistory(event.urlAfterRedirects || event.url);
+			});
+	}
+
+	private addToHistory(url: string): void {
+		// Skip if URL should be excluded
+		if (this.shouldExcludeUrl(url)) {
+			return;
+		}
+
+		const menuItem = this.findMenuItemByPath(url);
+		const multiLanguageTitle: { tr?: string; en?: string } = {};
+
+		// Get titles for both languages if menu item exists
+		if (menuItem) {
+			multiLanguageTitle.tr = menuItem.label['tr'];
+			multiLanguageTitle.en = menuItem.label['en'];
+		} else {
+			// Fallback for pages not in menu
+			multiLanguageTitle.tr = 'Bilinmeyen Sayfa';
+			multiLanguageTitle.en = 'Unknown Page';
+		}
+
+		const currentLang = this.translocoService.getActiveLang() as 'tr' | 'en';
+		const title = multiLanguageTitle[currentLang] || multiLanguageTitle.tr || 'Unknown Page';
+		const timestamp = Date.now();
+		const id = this.generateId(url, timestamp);
+
+		const newItem: HistoryItem = {
+			id,
+			title,
+			multiLanguageTitle,
+			url,
+			timestamp
+		};
+
+		let history = this.getHistoryFromStorage();
+		history = history.filter((item) => item.url !== url);
+		history.unshift(newItem);
+
+		// Limit history size
+		if (history.length > this.MAX_HISTORY_SIZE) {
+			history = history.slice(0, this.MAX_HISTORY_SIZE);
+		}
+
+		this.saveHistoryToStorage(history);
+		this.historySubject.next(history);
+	}
+
+	private shouldExcludeUrl(url: string): boolean {
+		return this.excludedPaths.some((excludedPath) => url.startsWith(excludedPath));
+	}
+
+	private findMenuItemByPath(path: string): PluginMenuItem | null {
+		const menuItems = (<any>globalThis).hostMenuItems?.() || [];
+
+		// Special handling for home page route
+		if (path === '/' || path === '') {
+			return menuItems.find((item: PluginMenuItem) => item.routerLink === '/') || null;
+		}
+
+		// Remove leading slash if present for other routes
+		const cleanPath = path.startsWith('/') ? path.substring(1) : path;
+		return this.findMenuItemRecursive(menuItems, cleanPath);
+	}
+
+	private findMenuItemRecursive(items: PluginMenuItem[], path: string): PluginMenuItem | null {
+		for (const item of items) {
+			if (item.routerLink === path) {
+				return item;
+			}
+
+			if (item.routerLink && path.startsWith(item.routerLink + '/')) {
+				return item;
+			}
+
+			if (item.items) {
+				const found = this.findMenuItemRecursive(item.items, path);
+				if (found) {
+					return found;
+				}
+			}
+		}
+
+		return null;
+	}
+
+	private generateId(url: string, timestamp: number): string {
+		return `${url.replace(/[^a-zA-Z0-9]/g, '_')}_${timestamp}`;
+	}
+
+	private loadHistoryFromStorage(): void {
+		const history = this.getHistoryFromStorage();
+		this.historySubject.next(history);
+	}
+
+	private saveHistoryToStorage(history: HistoryItem[]): void {
+		try {
+			localStorage.setItem(this.STORAGE_KEY, JSON.stringify(history));
+		} catch (error) {
+			console.warn('Failed to save navigation history to localStorage:', error);
+		}
+	}
+
+	public clearHistory(): void {
+		localStorage.removeItem(this.STORAGE_KEY);
+		this.historySubject.next([]);
+	}
+
+	public navigateToHistoryItem(item: HistoryItem): void {
+		this.router.navigate([item.url]);
+	}
+
+	private getHistoryFromStorage(): HistoryItem[] {
+		try {
+			const stored = localStorage.getItem(this.STORAGE_KEY);
+			return stored ? JSON.parse(stored) : [];
+		} catch (error) {
+			console.warn('Failed to load navigation history from localStorage:', error);
+			return [];
+		}
+	}
+
+	public getHistoryItemsBySearchTerm(searchTerm: string): HistoryItem[] {
+		const history = this.getHistoryFromStorage();
+		const lowerSearchTerm = searchTerm.toLowerCase();
+		const currentLang = this.translocoService.getActiveLang() as 'tr' | 'en';
+
+		return history.filter((item) => {
+			// Search in current language title
+			const currentTitle = item.multiLanguageTitle?.[currentLang] || item.title;
+			return currentTitle.toLowerCase().includes(lowerSearchTerm) || item.url.toLowerCase().includes(lowerSearchTerm);
+		});
+	}
+}

package/theme/layout/app/layout/app.layout.component.html

@@ -8,6 +8,9 @@
 		</div>
 	</div>
 	<app-profilemenu />
+	<app-history-sidebar />
+	<app-site-map-sidebar />
+	<app-favorite-pages-sidebar />
 	<!--<app-config></app-config>-->
 	<app-chatbot></app-chatbot>
 	<div class="layout-mask"></div>

package/theme/layout/app/layout/app.layout.component.ts

@@ -13,6 +13,9 @@ import { Subscription, filter } from 'rxjs';
 import { LayoutService } from '../../service/app.layout.service';
 import { AppMenuService } from '../../service/app.menu.service';
 import { AppProfileSidebarComponent } from '../profileSidebar/app.profilesidebar.component';
+import { HistorySidebarComponent } from '../history/history-sidebar.component';
+import { SiteMapSidebarComponent } from '../site-map/site-map-sidebar.component';
+import { FavoritePagesSidebarComponent } from '../favorite-pages/favorite-pages-sidebar.component';
 import { AppSidebarComponent } from '../sidebar/app.sidebar.component';
 import { AppTopbarComponent } from '../topbar/app.topbar.component';
 import { AppChatbotComponent } from '../chatbot/app.chatbot.component';
@@ -31,6 +34,9 @@ import { ExpandableMenuComponent } from '../expandableMenu/expandable-menu.compo
 		ToastModule,
 		AppTopbarComponent,
 		AppProfileSidebarComponent,
+		HistorySidebarComponent,
+		SiteMapSidebarComponent,
+		FavoritePagesSidebarComponent,
 		AppChatbotComponent,
 		AppSidebarComponent,
 		ExpandableMenuComponent
@@ -174,4 +180,4 @@ export class AppLayoutComponent implements OnDestroy {
 			this.menuOutsideClickListener();
 		}
 	}
-}
+}

package/theme/layout/app/profileSidebar/app.profilesidebar.component.d.ts

@@ -1,14 +1,29 @@
+import { OnInit } from '@angular/core';
+import { DialogService } from 'primeng/dynamicdialog';
+import { TranslocoService } from '@ngneat/transloco';
 import { KeycloakService } from 'keycloak-angular';
 import { LayoutService } from '../../service/app.layout.service';
+import { ProfileService, UserResponseDTO } from './profile.service';
 import * as i0 from "@angular/core";
-export declare class AppProfileSidebarComponent {
+export declare class AppProfileSidebarComponent implements OnInit {
     layoutService: LayoutService;
     private readonly keycloak;
+    private readonly profileService;
+    private readonly dialogService;
+    private readonly translocoService;
     username: string;
-    constructor(layoutService: LayoutService, keycloak: KeycloakService);
+    userProfile: import("@angular/core").WritableSignal<UserResponseDTO | null>;
+    private subjects;
+    getUserService: import("@angular/core").Signal<import("../../../../../../dist/http").ServiceResponse<UserResponseDTO> | undefined>;
+    constructor(layoutService: LayoutService, keycloak: KeycloakService, profileService: ProfileService, dialogService: DialogService, translocoService: TranslocoService);
+    ngOnInit(): void;
+    private initializeEffects;
+    private loadUserProfile;
     get visible(): boolean;
     set visible(_val: boolean);
     logout(): void;
+    editProfile(): void;
+    changePassword(): void;
     static ɵfac: i0.ɵɵFactoryDeclaration<AppProfileSidebarComponent, never>;
     static ɵcmp: i0.ɵɵComponentDeclaration<AppProfileSidebarComponent, "app-profilemenu", never, {}, {}, never, never, true, never>;
 }