Some refactoring

gulpfile.js

@@ -110,6 +110,7 @@ gulp.task('test-coverage', function() {
         ,'!out/src/extension.js'
         ,'!out/src/extensionmanager.js'
         ,'!out/src/team-extension.js'
+        ,'!out/src/clients/baseclient.js'
         ,'!out/src/clients/buildclient.js'
         ,'!out/src/clients/coreapiclient.js'
         ,'!out/src/clients/feedbackclient.js'

src/clients/baseclient.ts

@@ -0,0 +1,58 @@
+/*---------------------------------------------------------------------------------------------
+*  Copyright (c) Microsoft Corporation. All rights reserved.
+*  Licensed under the MIT License. See License.txt in the project root for license information.
+*--------------------------------------------------------------------------------------------*/
+"use strict";
+
+import { StatusBarItem } from "vscode";
+import { Logger } from "../helpers/logger";
+import { Telemetry } from "../services/telemetry";
+import { TeamServerContext} from "../contexts/servercontext";
+import { CommandNames } from "../helpers/constants";
+import { Strings } from "../helpers/strings";
+import { Utils } from "../helpers/utils";
+import { VsCodeUtils } from "../helpers/vscodeutils";
+
+export abstract class BaseClient {
+    protected _serverContext: TeamServerContext;
+    protected _statusBarItem: StatusBarItem;
+
+    constructor(context: TeamServerContext, statusBarItem: StatusBarItem) {
+        this._serverContext = context;
+        this._statusBarItem = statusBarItem;
+    }
+
+    protected handleError(err: Error, offlineText: string, polling: boolean, infoMessage?: string) : void {
+        let offline: boolean = Utils.IsOffline(err);
+        let msg: string = Utils.GetMessageForStatusCode(err, err.message);
+        let logPrefix: string = (infoMessage === undefined) ? "" : infoMessage + " ";
+
+        //When polling, we never display an error, we only log it (no telemetry either)
+        if (polling === true) {
+            Logger.LogError(logPrefix + msg);
+            if (offline === true) {
+                if (this._statusBarItem !== undefined) {
+                    this._statusBarItem.text = offlineText;
+                    this._statusBarItem.tooltip = Strings.StatusCodeOffline + " " + Strings.ClickToRetryConnection;
+                    this._statusBarItem.command = CommandNames.RefreshPollingStatus;
+                }
+            } else {
+                //Could happen if PAT doesn't have proper permissions
+                if (this._statusBarItem !== undefined) {
+                    this._statusBarItem.text = offlineText;
+                    this._statusBarItem.tooltip = msg;
+                }
+            }
+        //If we aren't polling, we always log an error and, optionally, send telemetry
+        } else {
+            let logMessage: string = logPrefix + msg;
+            if (offline === true) {
+                Logger.LogError(logMessage);
+            } else {
+                Logger.LogError(logMessage);
+                Telemetry.SendException(err);
+            }
+            VsCodeUtils.ShowErrorMessage(msg);
+        }
+    }
+}

src/clients/buildclient.ts

@@ -13,17 +13,14 @@ import { TeamServerContext} from "../contexts/servercontext";
 import { CommandNames, TelemetryEvents, WellKnownRepositoryTypes } from "../helpers/constants";
 import { Strings } from "../helpers/strings";
 import { Utils } from "../helpers/utils";
-import { VsCodeUtils } from "../helpers/vscodeutils";
 import { IRepositoryContext, RepositoryType } from "../contexts/repositorycontext";
+import { BaseClient } from "./baseclient";
 
-export class BuildClient {
-    private _serverContext: TeamServerContext;
-    private _statusBarItem: StatusBarItem;
+export class BuildClient extends BaseClient {
     private _buildSummaryUrl: string;
 
     constructor(context: TeamServerContext, statusBarItem: StatusBarItem) {
-        this._serverContext = context;
-        this._statusBarItem = statusBarItem;
+        super(context, statusBarItem);
     }
 
     //Gets any available build status information and adds it to the status bar
@@ -69,7 +66,7 @@ export class BuildClient {
                 }
             }
         } catch (err) {
-            this.handleError(err, polling, "Failed to get current build status");
+            this.handleError(err, BuildClient.GetOfflineBuildStatusText(), polling, "Failed to get current build status");
         }
     }
 
@@ -114,40 +111,6 @@ export class BuildClient {
         Utils.OpenUrl(url);
     }
 
-    private handleError(reason: any, polling: boolean, infoMessage?: string) : void {
-        let offline: boolean = Utils.IsOffline(reason);
-        let msg: string = Utils.GetMessageForStatusCode(reason, reason.message);
-        let logPrefix: string = (infoMessage === undefined) ? "" : infoMessage + " ";
-
-        //When polling, we never display an error, we only log it (no telemetry either)
-        if (polling === true) {
-            Logger.LogError(logPrefix + msg);
-            if (offline === true) {
-                if (this._statusBarItem !== undefined) {
-                    this._statusBarItem.text = BuildClient.GetOfflineBuildStatusText();
-                    this._statusBarItem.tooltip = Strings.StatusCodeOffline + " " + Strings.ClickToRetryConnection;
-                    this._statusBarItem.command = CommandNames.RefreshPollingStatus;
-                }
-            } else {
-                //Could happen if PAT doesn't have proper permissions
-                if (this._statusBarItem !== undefined) {
-                    this._statusBarItem.text = BuildClient.GetOfflineBuildStatusText();
-                    this._statusBarItem.tooltip = msg;
-                }
-            }
-        //If we aren't polling, we always log an error and, optionally, send telemetry
-        } else {
-            let logMessage: string = logPrefix + msg;
-            if (offline === true) {
-                Logger.LogError(logMessage);
-            } else {
-                Logger.LogError(logMessage);
-                Telemetry.SendException(logMessage);
-            }
-            VsCodeUtils.ShowErrorMessage(msg);
-        }
-    }
-
     public static GetOfflineBuildStatusText() : string {
         return `$(icon octicon-package) ` + `???`;
     }

src/clients/feedbackclient.ts

@@ -54,7 +54,7 @@ export class FeedbackClient {
         } catch (err) {
             let message: string = Utils.GetMessageForStatusCode(0, err.message, "Failed getting SendFeedback selection");
             Logger.LogError(message);
-            Telemetry.SendException(message);
+            Telemetry.SendException(err);
         }
     }
 }

src/clients/gitclient.ts

@@ -15,16 +15,14 @@ import { IRepositoryContext, RepositoryType } from "../contexts/repositorycontex
 import { TeamServerContext} from "../contexts/servercontext";
 import { GitVcService, PullRequestScore } from "../services/gitvc";
 import { Telemetry } from "../services/telemetry";
+import { BaseClient } from "./baseclient";
 
-var path = require("path");
+import * as path from "path";
 
-export class GitClient {
-    private _serverContext: TeamServerContext;
-    private _statusBarItem: StatusBarItem;
+export class GitClient extends BaseClient {
 
     constructor(context: TeamServerContext, statusBarItem: StatusBarItem) {
-        this._serverContext = context;
-        this._statusBarItem = statusBarItem;
+        super(context, statusBarItem);
     }
 
     //Initial method to display, select and navigate to my pull requests
@@ -45,7 +43,7 @@ export class GitClient {
                 Utils.OpenUrl(discUrl);
             }
         } catch (err) {
-            this.handleError(err, "Error selecting pull request from QuickPick");
+            this.handleError(err, GitClient.GetOfflinePullRequestStatusText(), false, "Error selecting pull request from QuickPick");
         }
     }
 
@@ -122,7 +120,7 @@ export class GitClient {
             //Remove the default Strings.BrowseYourPullRequests item from the calculation
             this._statusBarItem.text = GitClient.GetPullRequestStatusText(requests.length - 1);
         } catch (err) {
-            this.handleError(err, "Attempting to poll my pull requests", true);
+            this.handleError(err, GitClient.GetOfflinePullRequestStatusText(), true, "Attempting to poll my pull requests");
         }
     }
 
@@ -179,40 +177,6 @@ export class GitClient {
         return { label: scoreLabel + " (" + displayName + ") " + title, description: description, id: id };
     }
 
-    private handleError(reason: any, infoMessage?: string, polling?: boolean) : void {
-        let offline: boolean = Utils.IsOffline(reason);
-        let msg: string = Utils.GetMessageForStatusCode(reason, reason.message);
-        let logPrefix: string = (infoMessage === undefined) ? "" : infoMessage + " ";
-
-        //When polling, we never display an error, we only log it (no telemetry either)
-        if (polling === true) {
-            Logger.LogError(logPrefix + msg);
-            if (offline === true) {
-                if (this._statusBarItem !== undefined) {
-                    this._statusBarItem.text = GitClient.GetOfflinePullRequestStatusText();
-                    this._statusBarItem.tooltip = Strings.StatusCodeOffline + " " + Strings.ClickToRetryConnection;
-                    this._statusBarItem.command = CommandNames.RefreshPollingStatus;
-                }
-            } else {
-                //Could happen if PAT doesn't have proper permissions
-                if (this._statusBarItem !== undefined) {
-                    this._statusBarItem.text = GitClient.GetOfflinePullRequestStatusText();
-                    this._statusBarItem.tooltip = msg;
-                }
-            }
-        //If we aren't polling, we always log an error and, optionally, send telemetry
-        } else {
-            let logMessage: string = logPrefix + msg;
-            if (offline === true) {
-                Logger.LogError(logMessage);
-            } else {
-                Logger.LogError(logMessage);
-                Telemetry.SendException(logMessage);
-            }
-            VsCodeUtils.ShowErrorMessage(msg);
-        }
-    }
-
     public static GetOfflinePullRequestStatusText() : string {
         return `$(icon octicon-git-pull-request) ` + `???`;
     }

src/clients/witclient.ts

@@ -10,21 +10,19 @@ import { Logger } from "../helpers/logger";
 import { SimpleWorkItem, WorkItemTrackingService } from "../services/workitemtracking";
 import { Telemetry } from "../services/telemetry";
 import { TeamServerContext} from "../contexts/servercontext";
-import { BaseQuickPickItem, VsCodeUtils, WorkItemQueryQuickPickItem } from "../helpers/vscodeutils";
-import { CommandNames, TelemetryEvents, WitQueries, WitTypes } from "../helpers/constants";
+import { BaseQuickPickItem, WorkItemQueryQuickPickItem } from "../helpers/vscodeutils";
+import { TelemetryEvents, WitQueries, WitTypes } from "../helpers/constants";
 import { Strings } from "../helpers/strings";
 import { Utils } from "../helpers/utils";
 import { IPinnedQuery } from "../helpers/settings";
+import { BaseClient } from "./baseclient";
 
-export class WitClient {
-    private _serverContext: TeamServerContext;
-    private _statusBarItem: StatusBarItem;
+export class WitClient extends BaseClient {
     private _pinnedQuery: IPinnedQuery;
     private _myQueriesFolder: string;
 
     constructor(context: TeamServerContext, pinnedQuery: IPinnedQuery, statusBarItem: StatusBarItem) {
-        this._serverContext = context;
-        this._statusBarItem = statusBarItem;
+        super(context, statusBarItem);
         this._pinnedQuery = pinnedQuery;
     }
 
@@ -51,7 +49,7 @@ export class WitClient {
                 Utils.OpenUrl(newItemUrl);
             }
         } catch (err) {
-            this.handleError(err, "Error creating new work item");
+            this.handleError(err, WitClient.GetOfflinePinnedQueryStatusText(), false, "Error creating new work item");
         }
     }
 
@@ -82,7 +80,7 @@ export class WitClient {
                 }
             }
         } catch (err) {
-            this.handleError(err, "Error showing work item queries");
+            this.handleError(err, WitClient.GetOfflinePinnedQueryStatusText(), false, "Error showing work item queries");
         }
     }
 
@@ -93,7 +91,7 @@ export class WitClient {
             let queryText: string = await this.getPinnedQueryText();
             await this.showWorkItems(queryText);
         } catch (err) {
-            this.handleError(err, "Error showing pinned query work items");
+            this.handleError(err, WitClient.GetOfflinePinnedQueryStatusText(), false, "Error showing pinned query work items");
         }
     }
 
@@ -103,7 +101,7 @@ export class WitClient {
         try {
             await this.showWorkItems(WitQueries.MyWorkItems);
         } catch (err) {
-            this.handleError(err, "Error showing my work items");
+            this.handleError(err, WitClient.GetOfflinePinnedQueryStatusText(), false, "Error showing my work items");
         }
     }
 
@@ -144,7 +142,7 @@ export class WitClient {
             let svc: WorkItemTrackingService = new WorkItemTrackingService(this._serverContext);
             return svc.GetQueryResultCount(this._serverContext.RepoInfo.TeamProject, queryText);
         } catch (err) {
-            this.handleError(err, "Error getting pinned query result count");
+            this.handleError(err, WitClient.GetOfflinePinnedQueryStatusText(), false, "Error getting pinned query result count");
         }
     }
 
@@ -240,40 +238,6 @@ export class WitClient {
         return workItemTypes;
     }
 
-    private handleError(reason: any, infoMessage?: string, polling?: boolean) : void {
-        let offline: boolean = Utils.IsOffline(reason);
-        let msg: string = Utils.GetMessageForStatusCode(reason, reason.message);
-        let logPrefix: string = (infoMessage === undefined) ? "" : infoMessage + " ";
-
-        //When polling, we never display an error, we only log it (no telemetry either)
-        if (polling === true) {
-            Logger.LogError(logPrefix + msg);
-            if (offline === true) {
-                if (this._statusBarItem !== undefined) {
-                    this._statusBarItem.text = WitClient.GetOfflinePinnedQueryStatusText();
-                    this._statusBarItem.tooltip = Strings.StatusCodeOffline + " " + Strings.ClickToRetryConnection;
-                    this._statusBarItem.command = CommandNames.RefreshPollingStatus;
-                }
-            } else {
-                //Could happen if PAT doesn't have proper permissions
-                if (this._statusBarItem !== undefined) {
-                    this._statusBarItem.text = WitClient.GetOfflinePinnedQueryStatusText();
-                    this._statusBarItem.tooltip = msg;
-                }
-            }
-        //If we aren't polling, we always log an error and, optionally, send telemetry
-        } else {
-            let logMessage: string = logPrefix + msg;
-            if (offline === true) {
-                Logger.LogError(logMessage);
-            } else {
-                Logger.LogError(logMessage);
-                Telemetry.SendException(logMessage);
-            }
-            VsCodeUtils.ShowErrorMessage(msg);
-        }
-    }
-
     private logTelemetryForWorkItem(wit: string): void {
         switch (wit) {
             case WitTypes.Bug:
@@ -291,8 +255,8 @@ export class WitClient {
         this.GetPinnedQueryResultCount().then((items) => {
             this._statusBarItem.tooltip = Strings.ViewYourPinnedQuery;
             this._statusBarItem.text = WitClient.GetPinnedQueryStatusText(items);
-        }).catch((reason) => {
-            this.handleError(reason, "Failed to get pinned query count during polling", true);
+        }).catch((err) => {
+            this.handleError(err, WitClient.GetOfflinePinnedQueryStatusText(), true, "Failed to get pinned query count during polling");
         });
     }