use some status information to handle errors better

src/services/airport.ts

@@ -1,12 +1,21 @@
 import axios from 'axios';
 import { Configuration } from './configuration';
 import { Session } from './session';
-import { AirportOverview } from '../types';
+import {
+  AirportOverviewBackend,
+  AirportOverview,
+  BackendReturnStatus,
+} from '../types';
 
 export class Airport {
-  static async all(): Promise<AirportOverview[]> {
+  static async all(): Promise<AirportOverviewBackend> {
     const token = Session.bearerToken();
-    if (!token) return [];
+    if (!token) {
+      return {
+        status: BackendReturnStatus.Unauthorized,
+        airports: [],
+      };
+    }
 
     return axios
       .get<AirportOverview[]>(`${Configuration.resourceServer}/airport/all`, {
@@ -14,7 +23,17 @@ export class Airport {
           Authorization: `Bearer ${token}`,
         },
       })
-      .then((response) => response.data)
-      .catch(() => []);
+      .then((response) => {
+        return {
+          status: BackendReturnStatus.Ok,
+          airports: response.data,
+        };
+      })
+      .catch((err) => {
+        return {
+          status: err.status === 401 ? BackendReturnStatus.Unauthorized : BackendReturnStatus.Failure,
+          airports: [],
+        };
+      });
   }
 }

src/services/auth.ts

@@ -1,12 +1,17 @@
 import axios from 'axios';
 import { Configuration } from './configuration';
 import { Session } from './session';
-import { User } from '../types';
+import {
+  BackendReturnStatus,
+  DefaultUser,
+  UserBackend,
+  User,
+} from '../types';
 
 export class Auth {
-  static async tokenIsValid(): Promise<boolean> {
+  static async tokenIsValid(): Promise<BackendReturnStatus> {
     const token = Session.bearerToken();
-    if (!token) return false;
+    if (!token) return BackendReturnStatus.Unauthorized;
 
     return axios
       .get<void>(`${Configuration.resourceServer}/auth/validate`, {
@@ -14,13 +19,21 @@ export class Auth {
           Authorization: `Bearer ${token}`,
         },
       })
-      .then(() => true)
-      .catch(() => false);
+      .then(() => BackendReturnStatus.Ok)
+      .catch((err) => {
+        if (err.status === 401) return BackendReturnStatus.Unauthorized;
+        return BackendReturnStatus.Failure;
+      });
   }
 
-  static async user(): Promise<User | undefined> {
+  static async user(): Promise<UserBackend> {
     const token = Session.bearerToken();
-    if (!token) return undefined;
+    if (!token) {
+      return {
+        status: BackendReturnStatus.Unauthorized,
+        user: DefaultUser,
+      };
+    }
 
     return axios
       .get<User>(`${Configuration.resourceServer}/auth/user`, {
@@ -28,7 +41,31 @@ export class Auth {
           Authorization: `Bearer ${token}`,
         },
       })
-      .then((response) => response.data)
-      .catch(() => undefined);
+      .then((response) => {
+        return {
+          status: BackendReturnStatus.Ok,
+          user: response.data,
+        };
+      })
+      .catch((err) => {
+        return {
+          status: err.status === 401 ? BackendReturnStatus.Unauthorized : BackendReturnStatus.Failure,
+          user: DefaultUser,
+        };
+      });
+  }
+
+  static async refreshRadarScopeKey(): Promise<boolean> {
+    const token = Session.bearerToken();
+    if (!token) return false;
+
+    return axios
+      .get<void>(`${Configuration.resourceServer}/auth/refreshRadarScopeKey`, {
+        headers: {
+          Authorization: `Bearer ${token}`,
+        },
+      })
+      .then(() => true)
+      .catch(() => false);
   }
 }