// auth.service.ts
import { Injectable } from '@angular/core';
import { HttpClient } from '@angular/common/http';
import { BehaviorSubject, Observable, of } from 'rxjs';
import { map, tap, catchError } from 'rxjs/operators';
import { Router } from '@angular/router';
import { environment } from '../../../environments/environment';
import { User } from '../models/user.model';
import { AuthResponse } from '../models/auth-response.model';
import { JwtHelperService } from '@auth0/angular-jwt';
@Injectable({
providedIn: 'root'
})
export class AuthService {
private apiUrl = `${environment.apiUrl}/auth`;
private currentUserSubject = new BehaviorSubject<User | null>(null);
private jwtHelper = new JwtHelperService();
currentUser$ = this.currentUserSubject.asObservable();
isAuthenticated$ = this.currentUser$.pipe(map(user => !!user));
constructor(
private http: HttpClient,
private router: Router
) {
this.loadUserFromLocalStorage();
}
login(username: string, password: string): Observable<AuthResponse> {
return this.http.post<AuthResponse>(`${this.apiUrl}/login`, { username, password })
.pipe(
tap(response => {
this.setSession(response);
this.currentUserSubject.next(response.user);
})
);
}
register(user: User): Observable<User> {
return this.http.post<User>(`${this.apiUrl}/register`, user);
}
logout(): void {
localStorage.removeItem('token');
localStorage.removeItem('user');
this.currentUserSubject.next(null);
this.router.navigate(['/auth/login']);
}
isAuthenticated(): boolean {
const token = localStorage.getItem('token');
return !!token && !this.jwtHelper.isTokenExpired(token);
}
getCurrentUser(): User | null {
return this.currentUserSubject.value;
}
getToken(): string | null {
return localStorage.getItem('token');
}
hasRole(role: string): boolean {
const user = this.getCurrentUser();
return !!user && user.role === role;
}
private setSession(authResult: AuthResponse): void {
localStorage.setItem('token', authResult.token);
localStorage.setItem('user', JSON.stringify(authResult.user));
}
private loadUserFromLocalStorage(): void {
const token = localStorage.getItem('token');
const userJson = localStorage.getItem('user');
if (token && userJson && !this.jwtHelper.isTokenExpired(token)) {
try {
const user = JSON.parse(userJson);
this.currentUserSubject.next(user);
} catch (error) {
console.error('Kullanıcı yüklenirken hata:', error);
this.currentUserSubject.next(null);
}
} else {
this.currentUserSubject.next(null);
localStorage.removeItem('token');
localStorage.removeItem('user');
}
}
}
// product.service.ts
import { Injectable } from '@angular/core';
import { HttpClient, HttpParams } from '@angular/common/http';
import { Observable } from 'rxjs';
import { environment } from '../../../environments/environment';
import { Product } from '../models/product.model';
import { PaginatedResponse } from '../models/paginated-response.model';
@Injectable({
providedIn: 'root'
})
export class ProductService {
private apiUrl = `${environment.apiUrl}/products`;
constructor(private http: HttpClient) { }
getProducts(page = 0, size = 10, sort = 'id,asc'): Observable<PaginatedResponse<Product>> {
let params = new HttpParams()
.set('page', page.toString())
.set('size', size.toString())
.set('sort', sort);
return this.http.get<PaginatedResponse<Product>>(this.apiUrl, { params });
}
getProductById(id: number): Observable<Product> {
return this.http.get<Product>(`${this.apiUrl}/${id}`);
}
getProductsByCategory(categoryId: number, page = 0, size = 10, sort = 'id,asc'): Observable<PaginatedResponse<Product>> {
let params = new HttpParams()
.set('page', page.toString())
.set('size', size.toString())
.set('sort', sort);
return this.http.get<PaginatedResponse<Product>>(`${this.apiUrl}/category/${categoryId}`, { params });
}
searchProducts(keyword: string, page = 0, size = 10, sort = 'id,asc'): Observable<PaginatedResponse<Product>> {
let params = new HttpParams()
.set('keyword', keyword)
.set('page', page.toString())
.set('size', size.toString())
.set('sort', sort);
return this.http.get<PaginatedResponse<Product>>(`${this.apiUrl}/search`, { params });
}
createProduct(product: Product): Observable<Product> {
return this.http.post<Product>(this.apiUrl, product);
}
updateProduct(id: number, product: Product): Observable<Product> {
return this.http.put<Product>(`${this.apiUrl}/${id}`, product);
}
deleteProduct(id: number): Observable<void> {
return this.http.delete<void>(`${this.apiUrl}/${id}`);
}
}
// category.service.ts
import { Injectable } from '@angular/core';
import { HttpClient } from '@angular/common/http';
import { Observable } from 'rxjs';
import { environment } from '../../../environments/environment';
import { Category } from '../models/category.model';
@Injectable({
providedIn: 'root'
})
export class CategoryService {
private apiUrl = `${environment.apiUrl}/categories`;
constructor(private http: HttpClient) { }
getCategories(): Observable<Category[]> {
return this.http.get<Category[]>(this.apiUrl);
}
getCategoryById(id: number): Observable<Category> {
return this.http.get<Category>(`${this.apiUrl}/${id}`);
}
createCategory(category: Category): Observable<Category> {
return this.http.post<Category>(this.apiUrl, category);
}
updateCategory(id: number, category: Category): Observable<Category> {
return this.http.put<Category>(`${this.apiUrl}/${id}`, category);
}
deleteCategory(id: number): Observable<void> {
return this.http.delete<void>(`${this.apiUrl}/${id}`);
}
}
// order.service.ts
import { Injectable } from '@angular/core';
import { HttpClient, HttpParams } from '@angular/common/http';
import { Observable } from 'rxjs';
import { environment } from '../../../environments/environment';
import { Order } from '../models/order.model';
import { PaginatedResponse } from '../models/paginated-response.model';
@Injectable({
providedIn: 'root'
})
export class OrderService {
private apiUrl = `${environment.apiUrl}/orders`;
constructor(private http: HttpClient) { }
getOrders(page = 0, size = 10, sort = 'id,desc'): Observable<PaginatedResponse<Order>> {
let params = new HttpParams()
.set('page', page.toString())
.set('size', size.toString())
.set('sort', sort);
return this.http.get<PaginatedResponse<Order>>(this.apiUrl, { params });
}
getOrderById(id: number): Observable<Order> {
return this.http.get<Order>(`${this.apiUrl}/${id}`);
}
getOrdersByUser(userId: number, page = 0, size = 10, sort = 'id,desc'): Observable<PaginatedResponse<Order>> {
let params = new HttpParams()
.set('page', page.toString())
.set('size', size.toString())
.set('sort', sort);
return this.http.get<PaginatedResponse<Order>>(`${this.apiUrl}/user/${userId}`, { params });
}
createOrder(order: Order): Observable<Order> {
return this.http.post<Order>(this.apiUrl, order);
}
updateOrderStatus(id: number, status: string): Observable<Order> {
let params = new HttpParams()
.set('status', status);
return this.http.patch<Order>(`${this.apiUrl}/${id}/status`, null, { params });
}
deleteOrder(id: number): Observable<void> {
return this.http.delete<void>(`${this.apiUrl}/${id}`);
}
}
