diff --git a/src/app/_services/auth.service.ts b/src/app/_services/auth.service.ts
index 937f2ce..87c79b5 100644
--- a/src/app/_services/auth.service.ts
+++ b/src/app/_services/auth.service.ts
@@ -11,91 +11,90 @@ import { Staff } from '@app/_models';
 import { BehaviorSubject, Observable } from 'rxjs';
 
 @Injectable({
-  providedIn: 'root',
+    providedIn: 'root',
 })
 export class AuthService {
-  mutableKeyStore: MutableKeyStore;
-  trustedUsers: Array<Staff> = [];
-  private trustedUsersList: BehaviorSubject<Array<Staff>> = new BehaviorSubject<Array<Staff>>(
-    this.trustedUsers
-  );
-  trustedUsersSubject: Observable<Array<Staff>> = this.trustedUsersList.asObservable();
+    mutableKeyStore: MutableKeyStore;
+    trustedUsers: Array<Staff> = [];
+    private trustedUsersList: BehaviorSubject<Array<Staff>> = new BehaviorSubject<Array<Staff>>(
+        this.trustedUsers
+    );
+    trustedUsersSubject: Observable<Array<Staff>> = this.trustedUsersList.asObservable();
 
-  constructor(
-    private httpClient: HttpClient,
-    private loggingService: LoggingService,
-    private errorDialogService: ErrorDialogService
-  ) {
-    this.mutableKeyStore = new MutablePgpKeyStore();
-  }
-
-  async init(): Promise<void> {
-    await this.mutableKeyStore.loadKeyring();
-    if (localStorage.getItem(btoa('CICADA_PRIVATE_KEY'))) {
-      await this.mutableKeyStore.importPrivateKey(localStorage.getItem(btoa('CICADA_PRIVATE_KEY')));
+    constructor(
+        private httpClient: HttpClient,
+        private loggingService: LoggingService,
+        private errorDialogService: ErrorDialogService
+    ) {
+        this.mutableKeyStore = new MutablePgpKeyStore();
     }
-  }
-  
-  getSessionToken(): string {
-    return sessionStorage.getItem(btoa('CICADA_SESSION_TOKEN'));
-  }
 
-  setSessionToken(token): void {
-    sessionStorage.setItem(btoa('CICADA_SESSION_TOKEN'), token);
-  }
-
-  setState(s): void {
-    document.getElementById('state').innerHTML = s;
-  }
-
-  getWithToken(): Promise<boolean> {
-      const headers = {
-        Authorization: 'Bearer ' + this.getSessionToken,
-        'Content-Type': 'application/json;charset=utf-8',
-        'x-cic-automerge': 'none',
-      };
-      const options = {
-        headers,
-      };
-      return fetch(environment.cicMetaUrl, options).then((response) => {
-        if (!response.ok) {
-            this.loggingService.sendErrorLevelMessage('failed to get with auth token.',
-                                                      this, 
-                                                      { error: "" });
-
-            return false;
+    async init(): Promise<void> {
+        await this.mutableKeyStore.loadKeyring();
+        if (localStorage.getItem(btoa('CICADA_PRIVATE_KEY'))) {
+            await this.mutableKeyStore.importPrivateKey(localStorage.getItem(btoa('CICADA_PRIVATE_KEY')));
         }
-        return true;
-      });
-  }
+    }
 
-  // TODO rename to send signed challenge and set session. Also separate these responsibilities
-  sendSignedChallenge(hobaResponseEncoded: any): Promise<any> {
-      const headers = {
-        Authorization: 'HOBA ' + hobaResponseEncoded,
-        'Content-Type': 'application/json;charset=utf-8',
-        'x-cic-automerge': 'none',
-      };
-      const options = {
-        headers,
-      };
-      return fetch(environment.cicMetaUrl, options)
-  }
+    getSessionToken(): string {
+        return sessionStorage.getItem(btoa('CICADA_SESSION_TOKEN'));
+    }
 
-  getChallenge(): Promise<any> {
-      return fetch(environment.cicMetaUrl)
+    setSessionToken(token): void {
+        sessionStorage.setItem(btoa('CICADA_SESSION_TOKEN'), token);
+    }
+
+    setState(s): void {
+        document.getElementById('state').innerHTML = s;
+    }
+
+    getWithToken(): Promise<boolean> {
+        const headers = {
+            Authorization: 'Bearer ' + this.getSessionToken,
+            'Content-Type': 'application/json;charset=utf-8',
+            'x-cic-automerge': 'none',
+        };
+        const options = {
+            headers,
+        };
+        return fetch(environment.cicMetaUrl, options).then((response) => {
+            if (!response.ok) {
+                this.loggingService.sendErrorLevelMessage('failed to get with auth token.',
+                                                          this, 
+                                                          { error: "" });
+                return false;
+            }
+            return true;
+        });
+    }
+
+    // TODO rename to send signed challenge and set session. Also separate these responsibilities
+    sendSignedChallenge(hobaResponseEncoded: any): Promise<any> {
+        const headers = {
+            Authorization: 'HOBA ' + hobaResponseEncoded,
+            'Content-Type': 'application/json;charset=utf-8',
+            'x-cic-automerge': 'none',
+        };
+        const options = {
+            headers,
+        };
+        return fetch(environment.cicMetaUrl, options)
+    }
+
+    getChallenge(): Promise<any> {
+        return fetch(environment.cicMetaUrl)
         .then(response => {
             if (response.status === 401) {
                 const authHeader: string = response.headers.get('WWW-Authenticate');
                 return hobaParseChallengeHeader(authHeader);
             }
         });
-  }
+    }
 
-  async login(): Promise<boolean> {
-    if (this.getSessionToken()) {
-        sessionStorage.removeItem(btoa('CICADA_SESSION_TOKEN'));
-    } else {
+    async login(): Promise<boolean> {
+        if (this.getSessionToken()) {
+            sessionStorage.removeItem(btoa('CICADA_SESSION_TOKEN'));
+        } 
         const o = await this.getChallenge();
 
         const r = await signChallenge(
@@ -106,20 +105,20 @@ export class AuthService {
         );
 
         const tokenResponse = await this.sendSignedChallenge(r)
-            .then(response => {
-                const token = response.headers.get('Token')
-                if (token) {
-                    return token
-                }
-                if (response.status === 401) {
-                    let e = new HttpError("You are not authorized to use this system", response.status)
-                    throw e
-                }
-                if (!response.ok) {
-                    let e = new HttpError("Unknown error from authentication server", response.status)
-                    throw e
-                }
-            })
+        .then(response => {
+            const token = response.headers.get('Token')
+            if (token) {
+                return token
+            }
+            if (response.status === 401) {
+                let e = new HttpError("You are not authorized to use this system", response.status)
+                throw e
+            }
+            if (!response.ok) {
+                let e = new HttpError("Unknown error from authentication server", response.status)
+                throw e
+            }
+        })
 
         if (tokenResponse) {
             this.setSessionToken(tokenResponse);
@@ -128,83 +127,82 @@ export class AuthService {
         }
         return false
     }
-  }
 
-  loginView(): void {
-    document.getElementById('one').style.display = 'none';
-    document.getElementById('two').style.display = 'block';
-    this.setState('Click button to log in with PGP key ' + this.mutableKeyStore.getPrivateKeyId());
-  }
-
-  async setKey(privateKeyArmored): Promise<boolean> {
-    try {
-      const isValidKeyCheck = await this.mutableKeyStore.isValidKey(privateKeyArmored);
-      if (!isValidKeyCheck) {
-        throw Error('The private key is invalid');
-      }
-      // TODO leaving this out for now.
-      // const isEncryptedKeyCheck = await this.mutableKeyStore.isEncryptedPrivateKey(privateKeyArmored);
-      // if (!isEncryptedKeyCheck) {
-      //   throw Error('The private key doesn\'t have a password!');
-      // }
-      const key = await this.mutableKeyStore.importPrivateKey(privateKeyArmored);
-      localStorage.setItem(btoa('CICADA_PRIVATE_KEY'), privateKeyArmored);
-    } catch (err) {
-      this.loggingService.sendErrorLevelMessage(
-        `Failed to set key: ${err.message || err.statusText}`,
-        this,
-        { error: err }
-      );
-      this.errorDialogService.openDialog({
-        message: `Failed to set key: ${err.message || err.statusText}`,
-      });
-      return false;
+    loginView(): void {
+        document.getElementById('one').style.display = 'none';
+        document.getElementById('two').style.display = 'block';
+        this.setState('Click button to log in with PGP key ' + this.mutableKeyStore.getPrivateKeyId());
     }
-    this.loginView();
-    return true;
-  }
 
-  logout(): void {
-    sessionStorage.removeItem(btoa('CICADA_SESSION_TOKEN'));
-    localStorage.removeItem(btoa('CICADA_PRIVATE_KEY'));
-    window.location.reload();
-  }
-
-  addTrustedUser(user: Staff): void {
-    const savedIndex = this.trustedUsers.findIndex((staff) => staff.userid === user.userid);
-    if (savedIndex === 0) {
-      return;
-    }
-    if (savedIndex > 0) {
-      this.trustedUsers.splice(savedIndex, 1);
-    }
-    this.trustedUsers.unshift(user);
-    this.trustedUsersList.next(this.trustedUsers);
-  }
-
-  getTrustedUsers(): void {
-    this.mutableKeyStore.getPublicKeys().forEach((key) => {
-      this.addTrustedUser(key.users[0].userId);
-    });
-  }
-
-  async getPublicKeys(): Promise<any> {
-    return new Promise((resolve, reject) => {
-      fetch(environment.publicKeysUrl).then((res) => {
-        if (!res.ok) {
-          // TODO does angular recommend an error interface?
-          return reject(rejectBody(res));
+    async setKey(privateKeyArmored): Promise<boolean> {
+        try {
+            const isValidKeyCheck = await this.mutableKeyStore.isValidKey(privateKeyArmored);
+            if (!isValidKeyCheck) {
+                throw Error('The private key is invalid');
+            }
+            // TODO leaving this out for now.
+            // const isEncryptedKeyCheck = await this.mutableKeyStore.isEncryptedPrivateKey(privateKeyArmored);
+            // if (!isEncryptedKeyCheck) {
+            //   throw Error('The private key doesn\'t have a password!');
+            // }
+            const key = await this.mutableKeyStore.importPrivateKey(privateKeyArmored);
+            localStorage.setItem(btoa('CICADA_PRIVATE_KEY'), privateKeyArmored);
+        } catch (err) {
+            this.loggingService.sendErrorLevelMessage(
+                `Failed to set key: ${err.message || err.statusText}`,
+                this,
+                { error: err }
+            );
+            this.errorDialogService.openDialog({
+                message: `Failed to set key: ${err.message || err.statusText}`,
+            });
+            return false;
         }
-        return resolve(res.text());
-      });
-    });
-  }
+        this.loginView();
+        return true;
+    }
 
-  getPrivateKey(): any {
-    return this.mutableKeyStore.getPrivateKey();
-  }
+    logout(): void {
+        sessionStorage.removeItem(btoa('CICADA_SESSION_TOKEN'));
+        localStorage.removeItem(btoa('CICADA_PRIVATE_KEY'));
+        window.location.reload();
+    }
 
-  getPrivateKeyInfo(): any {
-    return this.getPrivateKey().users[0].userId;
-  }
+    addTrustedUser(user: Staff): void {
+        const savedIndex = this.trustedUsers.findIndex((staff) => staff.userid === user.userid);
+        if (savedIndex === 0) {
+            return;
+        }
+        if (savedIndex > 0) {
+            this.trustedUsers.splice(savedIndex, 1);
+        }
+        this.trustedUsers.unshift(user);
+        this.trustedUsersList.next(this.trustedUsers);
+    }
+
+    getTrustedUsers(): void {
+        this.mutableKeyStore.getPublicKeys().forEach((key) => {
+            this.addTrustedUser(key.users[0].userId);
+        });
+    }
+
+    async getPublicKeys(): Promise<any> {
+        return new Promise((resolve, reject) => {
+            fetch(environment.publicKeysUrl).then((res) => {
+                if (!res.ok) {
+                    // TODO does angular recommend an error interface?
+                    return reject(rejectBody(res));
+                }
+                return resolve(res.text());
+            });
+        });
+    }
+
+    getPrivateKey(): any {
+        return this.mutableKeyStore.getPrivateKey();
+    }
+
+    getPrivateKeyInfo(): any {
+        return this.getPrivateKey().users[0].userId;
+    }
 }