Improve user information service

Author: JacoMalan1

api/src/index.ts

@@ -10,18 +10,18 @@ export * from './lib/index';
 const expressServer = express();
 
 const createFunction = async (
-  expressInstance: express.Express
+  expressInstance: express.Express,
 ): Promise<void> => {
   const app = await NestFactory.create(
     ApiModule,
     new ExpressAdapter(expressInstance),
     {
       cors: {
         origin: true,
-        methods: ['GET', 'POST', 'OPTIONS', 'PUT', 'DELETE'],
+        methods: ['GET', 'POST', 'OPTIONS', 'PUT', 'DELETE', 'PATCH'],
         credentials: true,
       },
-    }
+    },
   );
   app.use(cookieParser());
   await app.init();

api/src/lib/user/user.controller.ts

@@ -28,30 +28,19 @@ export const EMAIL_REGEX =
 export class UserController {
   constructor(private userService: UserService) { }
 
-  @Get()
-  async getUserInfo(
-    @Param('username') username: string,
-    @Req() request: Request,
-    @Res() response: Response,
-  ): Promise<UserInfoResponse> {
-    const user = await this.userService.findUserByUsername(username);
-
-    if (!user) {
-      return { success: false, message: "Couldn't find the requested user" };
+  @Get('info')
+  async getUserInfo(@Req() request: Request): Promise<UserInfoResponse> {
+    console.log(' 🚀 ~ user.controller.ts:33 → User info', request.user);
+    if (!request.user) {
+      return { success: false, message: 'Not logged in' };
     }
-
-    if (user.username !== request.user?.username) {
-      response.status(401);
-      return { success: false, message: "You cannot see this user's details" };
-    }
-
     return {
       success: true,
-      message: 'User details retrieved',
+      message: 'User info returned',
       user: {
-        username: user.username,
-        email: user.email,
-        verified: user.verified,
+        username: request.user.username,
+        email: request.user.email,
+        verified: request.user.verified,
       },
     };
   }

api/src/lib/user/user.module.ts

@@ -16,11 +16,11 @@ export class UserModule implements NestModule {
   configure(consumer: MiddlewareConsumer) {
     consumer.apply(AuthenticationMiddleware).forRoutes(
       {
-        path: 'password',
+        path: 'user/password',
         method: RequestMethod.PATCH,
       },
       {
-        path: '',
+        path: 'user/info',
         method: RequestMethod.GET,
       },
     );

api/src/lib/user/user.service.ts

@@ -150,11 +150,13 @@ export class UserService implements OnModuleInit {
 
   async checkCookie(secret: string): Promise<User | undefined> {
     if (!this.firebaseService) {
+      console.error('  ~ user.service.ts:153 → No firebase service present');
       return undefined;
     }
 
     const firestore = this.firebaseService.getFirestore();
     if (!firestore) {
+      console.error('  ~ user.service.ts:153 → No firestore present');
       return undefined;
     }
 
@@ -170,6 +172,10 @@ export class UserService implements OnModuleInit {
 
     const cookie = query.docs[0].data() as Cookie;
     const user: User | undefined = (await cookie.userRef.get()).data() as User;
+    console.log(
+      ' 🚀 ~ user.service.ts:175 → User associated with cookie: ',
+      user,
+    );
     if (!user.verified) {
       return undefined;
     }

app/src/app/app.component.spec.ts

@@ -2,12 +2,10 @@ import { CUSTOM_ELEMENTS_SCHEMA } from '@angular/core';
 import { TestBed, waitForAsync } from '@angular/core/testing';
 
 import { AppComponent } from './app.component';
-import { NotificationService } from './notification.service';
 
 describe('AppComponent', () => {
   beforeEach(waitForAsync(() => {
     TestBed.configureTestingModule({
-      providers: [NotificationService],
       declarations: [AppComponent],
       schemas: [CUSTOM_ELEMENTS_SCHEMA],
     }).compileComponents();

app/src/app/app.component.ts

@@ -1,16 +1,10 @@
 import { Component } from '@angular/core';
-import { NotificationService } from './notification.service';
 
 @Component({
   selector: 'root',
   templateUrl: 'app.component.html',
   styleUrls: ['app.component.scss'],
 })
 export class AppComponent {
-  constructor(private notificationService: NotificationService) {
-    console.log(
-      ' 🚀 ~ app.component.ts:11 → Notification service',
-      this.notificationService,
-    );
-  }
+  constructor() { }
 }

app/src/app/app.module.ts

@@ -8,7 +8,6 @@ import { AppRoutingModule } from './app-routing.module';
 import { FormsModule } from '@angular/forms';
 import { AuthModule } from './auth/auth.module';
 import { CommonModule } from '@angular/common';
-import { NotificationService } from './notification.service';
 import { StatusPageModule } from './status/status.module';
 
 @NgModule({
@@ -23,10 +22,7 @@ import { StatusPageModule } from './status/status.module';
     AuthModule,
     IonicModule.forRoot(),
   ],
-  providers: [
-    NotificationService,
-    { provide: RouteReuseStrategy, useClass: IonicRouteStrategy },
-  ],
+  providers: [{ provide: RouteReuseStrategy, useClass: IonicRouteStrategy }],
   bootstrap: [AppComponent],
 })
 export class AppModule { }

app/src/app/auth/auth.service.ts

@@ -4,8 +4,8 @@ import {
   HttpResponse,
 } from '@angular/common/http';
 import { Injectable } from '@angular/core';
-import { ApiResponse } from '@gatekeeper/api';
-import { Observable, catchError, map } from 'rxjs';
+import { ApiResponse, UserInfoResponse } from '@gatekeeper/api';
+import { Observable, catchError, map, of } from 'rxjs';
 import { environment } from '../../environments/environment';
 
 @Injectable()
@@ -14,13 +14,65 @@ export class AuthService {
   private currentUser?: string;
   constructor(private http: HttpClient) {
     this.loggedIn = true;
+    this.http
+      .get<UserInfoResponse>(`${environment.apiUrl}/user/info`, {
+        withCredentials: true,
+        observe: 'response',
+      })
+      .pipe(
+        catchError((_err: HttpErrorResponse) => {
+          this.loggedIn = false;
+          return of(undefined);
+        }),
+      )
+      .subscribe((data) => {
+        if (data?.body?.success) {
+          this.loggedIn = true;
+          this.currentUser = data.body.user?.username;
+        }
+      });
   }
 
   isLoggedIn(): boolean {
     return this.loggedIn;
   }
 
+  getUserInfo(): Observable<UserInfoResponse> {
+    return this.http
+      .get<UserInfoResponse>(`${environment.apiUrl}/user/info`, {
+        withCredentials: true,
+        observe: 'response',
+      })
+      .pipe(
+        catchError((_err: HttpErrorResponse) => {
+          return of(undefined);
+        }),
+        map((data) => {
+          return data?.body || { success: false, message: 'Not logged in' };
+        }),
+      );
+  }
+
   getCurrentUser(): string | undefined {
+    if (!this.currentUser) {
+      this.http
+        .get<UserInfoResponse>(`${environment.apiUrl}/user/info`, {
+          withCredentials: true,
+          observe: 'response',
+        })
+        .pipe(
+          catchError((_err: HttpErrorResponse) => {
+            this.loggedIn = false;
+            return of(undefined);
+          }),
+        )
+        .subscribe((data) => {
+          if (data?.body?.success) {
+            this.loggedIn = true;
+            this.currentUser = data.body.user?.username;
+          }
+        });
+    }
     return this.currentUser;
   }
 
@@ -70,10 +122,10 @@ export class AuthService {
     email: string,
     password: string,
   ): Observable<ApiResponse> {
-    return this.http.post<ApiResponse>(
-      `${environment.apiUrl}/user`,
-      { username, email, password },
-      { withCredentials: true },
-    );
+    return this.http.post<ApiResponse>(`${environment.apiUrl}/user`, {
+      username,
+      email,
+      password,
+    });
   }
 }

app/src/app/profile/changePassword/change-password.component.ts

@@ -17,8 +17,8 @@ export class ChangePasswordComponent {
   currentPassword: string;
   newPassword: string;
   confirm: string;
-  toastMessage: string = '';
-  isToastOpen: boolean = false;
+  toastMessage: string;
+  isToastOpen: boolean;
 
   constructor(
     private profileService: ProfileService,
@@ -28,6 +28,8 @@ export class ChangePasswordComponent {
     this.currentPassword = '';
     this.newPassword = '';
     this.confirm = '';
+    this.toastMessage = '';
+    this.isToastOpen = false;
   }
 
   currentPasswordChange(event: Event) {

app/src/app/profile/profile.component.spec.ts

@@ -3,11 +3,12 @@ import { ProfilePageComponent } from './profile.component';
 import { ProfileService } from './profile.service';
 import { AuthService } from '../auth/auth.service';
 import { IonicModule } from '@ionic/angular';
+import { HttpClientModule } from '@angular/common/http';
 
 describe('ProfilePageComponent', () => {
   beforeEach(waitForAsync(() => {
     TestBed.configureTestingModule({
-      imports: [IonicModule],
+      imports: [IonicModule, HttpClientModule],
       declarations: [ProfilePageComponent],
       providers: [ProfileService, AuthService],
     }).compileComponents();

app/src/app/profile/profile.component.ts

@@ -1,18 +1,28 @@
-import { Component } from '@angular/core';
+import { Component, OnInit } from '@angular/core';
 import { AuthService } from '../auth/auth.service';
 
 @Component({
   selector: 'profile-page',
   templateUrl: 'profile.component.html',
   styleUrls: ['profile.component.scss'],
 })
-export class ProfilePageComponent {
+export class ProfilePageComponent implements OnInit {
   isModalOpen: boolean;
   username: string;
 
   constructor(private authService: AuthService) {
     this.isModalOpen = false;
-    this.username = this.authService.getCurrentUser() || 'Not logged in';
+    this.username = 'Not logged in';
+  }
+
+  ngOnInit() {
+    this.authService.getUserInfo().subscribe((data) => {
+      if (data.success) {
+        this.username = data.user?.username || 'Not logged in';
+      } else {
+        console.log('Failed to query user profile');
+      }
+    });
   }
 
   setModalOpen(state: boolean) {