frontend-hideyoshi.com/src/app/shared/auth/auth.service.ts

import { HttpClient, HttpHeaders, HttpParams } from '@angular/common/http';
import { Injectable } from '@angular/core';
import {first, firstValueFrom, map, Observable, of, Subject, take, tap} from 'rxjs';
import { catchError } from 'rxjs/operators';
import { environment } from 'src/environments/environment';
import { HttpError } from '../model/httpError/httpError.model';
import { User } from '../model/user/user.model';
import * as http from "http";

@Injectable({
    providedIn: 'root'
})
export class AuthService {

    private userAuthenticated!: User;

    authSubject = new Subject<User | HttpError | null>();

    readonly BACKEND_PATH = environment.backendPath;

    readonly BACKEND_OAUTH_PATH = environment.backendOAuthPath;

    constructor(private http: HttpClient) { }
    login(userAuthAtempt: User): void {
        this.validateUser(this.loginUser(userAuthAtempt));
    }

    googleLogin() {
        window.open(this.BACKEND_OAUTH_PATH + '/oauth2/authorization/google', '_self');
    }

    githubLogin() {
        window.open(this.BACKEND_OAUTH_PATH + '/oauth2/authorization/github', '_self');
    }

    loginGoogleUser(p: any): void {
        this.validateUser(this.fetchGoogleOAuthToken(p))
    }

    loginGithubUser(p: any): void {
        this.validateUser(this.fetchGithubOAuthToken(p))
    }

    signup(userAuthAtempt: User): void {
        this.validateUser(this.createUser(userAuthAtempt));

    }

    autoLogin(): void {
        this.validateUser(this.validateSession());
    }

    logout() {
        this.authSubject.next(null);
        this.destroySessions().subscribe()
    }

    deleteAccount() {
        return this.deleteAccountRequest();
    }

    addProfilePicture(file: File): void {
        const fileType = file.type.split('/')[1];
        this.getAddProfilePictureUrl(fileType).subscribe({
            next: (url: string|null) => {
                if (url != null) {
                    this.uploadProfilePicture(url, file).then(
                        (response: Observable<any>) => {
                            response.subscribe({
                                next: (response: any) => {
                                    this.processProfilePicture().subscribe();
                                }
                            });
                        }
                    );
                }
            }
        })
    }

    private loginUser(userAuthAtempt: User): Observable<User|any> {

        let loginParams = new URLSearchParams();
        loginParams.set("username", userAuthAtempt.username!);
        loginParams.set("password", userAuthAtempt.password!);

        let headers = new HttpHeaders({
            'Content-Type': 'application/x-www-form-urlencoded'
        });

        return this.http.post<User>(
            this.BACKEND_PATH + "/user/login",
            loginParams,
            { headers: headers, withCredentials: true }
        ).pipe(
            first()
        )
    }

    private fetchGoogleOAuthToken(p: any): Observable<User|any> {

        let params = new HttpParams(
            {
                fromObject: p
            }
        );

        return this.http.get<User>(
            this.BACKEND_OAUTH_PATH + '/login/oauth2/code/google',
            {
                withCredentials: true,
                params: params
            },
        ).pipe(
            first()
        );
    }

    private fetchGithubOAuthToken(p: any): Observable<User|any> {

        let params = new HttpParams(
            {
                fromObject: p
            }
        );

        return this.http.get<User>(
            this.BACKEND_OAUTH_PATH + '/login/oauth2/code/github',
            {
                withCredentials: true,
                params: params
            },
        ).pipe(
            first()
        );
    }

    private createUser(newUser: User) {
        return this.http.post<User>(
            this.BACKEND_PATH + "/user/signup",
            newUser,
            { withCredentials: true }
        ).pipe(
            first()
        )
    }

    private refreshAccessToken() {
        return firstValueFrom(this.http.post(
            this.BACKEND_PATH + "/user/login/refresh",
            this.userAuthenticated.refreshToken,
            { withCredentials: true }
        ));
    }

    private validateSession(): Observable<User> {
        return this.http.get<User>(
            this.BACKEND_PATH + '/session/validate',
            { withCredentials: true }
        );
    }

    private destroySessions() {
        return this.http.delete(
            this.BACKEND_PATH + '/session/destroy',
            { withCredentials: true }
        );
    }

    private deleteAccountRequest() {
        let headers = this.createAuthorizationHeader()

        return this.http.delete(
            this.BACKEND_PATH + `/user/delete`,
            { headers: headers, withCredentials: true }
        );
    }

    private validateUser(userAuthAtempt: Observable<User>) {
        userAuthAtempt.pipe(
            catchError(error => {
                if (error.status == 0) {
                    return of(<HttpError>{
                        title: "Service Unavailable",
                        status: 500,
                        details: "Service Unavailable, please try again later.",
                        developerMessage: "Service Unavailable, please try again later.",
                        timestamp: new Date().toISOString()
                    });
                }
                return of(<HttpError>error.error);
            }),
            first()
        ).subscribe({
            next: userAuthentication => {
                this.userAuthenticated = <User>userAuthentication;
                this.authSubject.next(this.userAuthenticated);
            }
        });
    }

    private getAddProfilePictureUrl(fileType: string): Observable<string|null> {
        return this.http.post<{ presigned_url: string, file_key: string }>(
            this.BACKEND_PATH + '/user/profile-picture?fileType=' + fileType,
            null,
            {
                headers: this.createAuthorizationHeader(),
                withCredentials: true
            }
        ).pipe(
            first(),
            map((res) => {
                if (!!res && !!res.presigned_url) {
                    return res.presigned_url;
                }
                return null
            })
        )
    }

    private async uploadProfilePicture(url: string, file: File): Promise<Observable<any>> {
        const fileData = await this.readAsArrayBuffer(file);
        let headers = new HttpHeaders({
            'Content-Type': file.type
        })
        return this.http.put(
            url,
            fileData,
            {
                headers: headers,
            }
        );
    }

    private processProfilePicture() {
        return this.http.post(
            this.BACKEND_PATH + '/user/profile-picture/proccess',
            null,
            {
                headers: this.createAuthorizationHeader(),
                withCredentials: true
            }
        )
    }

    private createAuthorizationHeader(): HttpHeaders {
        return new HttpHeaders({
            'Content-Type': 'application/json',
            'Authorization': 'Bearer ' + this.userAuthenticated.accessToken?.token
        });
    }

    private async readAsArrayBuffer(file: File): Promise<ArrayBuffer> {
        const reader = new FileReader();
        reader.readAsArrayBuffer(file)
        return new Promise<ArrayBuffer>((resolve, reject) => {
            reader.onload = () => {
                resolve(reader.result as ArrayBuffer);
            };
            reader.onerror = () => {
                reject(reader.error);
            };
        });
    }
}