fix: login (#161)

Author: Thaumy

.github/workflows/build-check.yml

@@ -3,7 +3,7 @@ name: Build and check the code format
 on:
     push:
         branches:
-            - main
+            - '*'
     pull_request_target:
         types:
             - opened

.vscode/launch.json

@@ -9,7 +9,7 @@
             "name": "Run Extension",
             "type": "extensionHost",
             "request": "launch",
-            "args": ["--extensionDevelopmentPath=${workspaceFolder}", "--disable-extensions"],
+            "args": ["--extensionDevelopmentPath=${workspaceFolder}"],
             "outFiles": ["${workspaceFolder}/dist/**/*.js"],
             "preLaunchTask": "${defaultBuildTask}",
             "env": {

__mocks__/vscode.ts

@@ -110,12 +110,12 @@ const QuickPickItemKind = {
 const TreeItem = jest.fn()
 const Disposable = jest.fn()
 ;(Disposable as any).from = jest.fn()
-const authentication = { registerAuthenticationProvider: jest.fn() }
+const auth = { registerAuthenticationProvider: jest.fn() }
 
 export = {
     ThemeColor,
     Disposable,
-    authentication,
+    auth,
     CodeLens,
     languages,
     StatusBarAlignment,

src/auth/access-token.ts

@@ -0,0 +1,3 @@
+export type AccessToken = {
+    exp: number
+}

src/auth/account-info.ts

@@ -0,0 +1,49 @@
+import { UserInfoSpec } from '@/services/oauth.api'
+import { trim } from 'lodash-es'
+import { AuthenticationSessionAccountInformation } from 'vscode'
+import { AuthProvider } from './auth-provider'
+
+export class AccountInfo implements AuthenticationSessionAccountInformation {
+    readonly label: string
+    readonly id: string
+
+    private _blogApp: string | null = null
+
+    private constructor(
+        public readonly name: string,
+        public readonly avatar: string,
+        public readonly website: string, //The user blog home page url
+        public readonly blogId: number,
+        public readonly sub: string, //UserId(data type is Guid)
+        public readonly accountId: number //SpaceUserId
+    ) {
+        this.id = `${this.accountId}-${AuthProvider.providerId}`
+        this.label = name
+    }
+
+    get userId() {
+        return this.sub
+    }
+
+    get blogApp(): string | null {
+        this._blogApp ??= this.parseBlogApp()
+        return this._blogApp
+    }
+
+    static newAnonymous = () => new AccountInfo('anonymous', '', '', -1, '', -1)
+
+    static from = (userInfo: UserInfoSpec) =>
+        new AccountInfo(
+            userInfo.name,
+            userInfo.picture,
+            userInfo.website,
+            parseInt(userInfo.blog_id, 10),
+            userInfo.sub,
+            parseInt(userInfo.account_id, 10)
+        )
+
+    private parseBlogApp = () =>
+        trim(this.website ?? '', '/')
+            .split('/')
+            .pop() ?? null
+}

src/auth/account-manager.ts

@@ -0,0 +1,123 @@
+import { AccountInfo } from './account-info'
+import { globalCtx } from '@/services/global-ctx'
+import vscode, { authentication, AuthenticationGetSessionOptions, Disposable } from 'vscode'
+import { accountViewDataProvider } from '@/tree-view-providers/account-view-data-provider'
+import { postsDataProvider } from '@/tree-view-providers/posts-data-provider'
+import { postCategoriesDataProvider } from '@/tree-view-providers/post-categories-tree-data-provider'
+import { Oauth } from '@/services/oauth.api'
+import { AuthProvider } from '@/auth/auth-provider'
+import { AuthSession } from '@/auth/auth-session'
+import { BlogExportProvider } from '@/tree-view-providers/blog-export-provider'
+import { AlertService } from '@/services/alert.service'
+
+const isAuthorizedStorageKey = 'isAuthorized'
+
+export const ACQUIRE_TOKEN_REJECT_UNAUTHENTICATED = 'unauthenticated'
+export const ACQUIRE_TOKEN_REJECT_EXPIRED = 'expired'
+
+class AccountManager extends vscode.Disposable {
+    private readonly _disposable = Disposable.from(
+        AuthProvider.instance.onDidChangeSessions(async ({ added }) => {
+            this._session = null
+            if (added != null && added.length > 0) await this.ensureSession()
+
+            await this.updateAuthStatus()
+
+            accountViewDataProvider.fireTreeDataChangedEvent()
+            postsDataProvider.fireTreeDataChangedEvent(undefined)
+            postCategoriesDataProvider.fireTreeDataChangedEvent()
+
+            BlogExportProvider.optionalInstance?.refreshRecords({ force: false, clearCache: true }).catch(console.warn)
+        })
+    )
+
+    private _session: AuthSession | null = null
+
+    constructor() {
+        super(() => {
+            this._disposable.dispose()
+        })
+    }
+
+    get isAuthorized() {
+        return this._session !== null
+    }
+
+    get currentUser(): AccountInfo {
+        return this._session?.account ?? AccountInfo.newAnonymous()
+    }
+
+    /**
+     * Acquire the access token.
+     * This will reject with a human-readable reason string if not sign-in or the token has expired.
+     * @returns The access token of the active session
+     */
+    async acquireToken(): Promise<string> {
+        const session = await this.ensureSession({ createIfNone: false })
+
+        if (session == null) return Promise.reject(ACQUIRE_TOKEN_REJECT_UNAUTHENTICATED)
+
+        if (session.isExpired) return Promise.reject(ACQUIRE_TOKEN_REJECT_EXPIRED)
+
+        return session.accessToken
+    }
+
+    async login() {
+        await this.ensureSession({ createIfNone: false, forceNewSession: true })
+    }
+
+    async logout() {
+        if (!this.isAuthorized) return
+
+        const session = await authentication.getSession(AuthProvider.providerId, [])
+
+        // WRN: For old version compatibility, **never** remove this line
+        await globalCtx.storage.update('user', undefined)
+
+        if (session === undefined) return
+
+        try {
+            await Oauth.revokeToken(session.accessToken)
+            await AuthProvider.instance.removeSession(session.id)
+        } catch (e: any) {
+            void AlertService.err(`登出发生错误: ${e}`)
+        }
+    }
+
+    async updateAuthStatus() {
+        await this.ensureSession({ createIfNone: false })
+
+        await vscode.commands.executeCommand(
+            'setContext',
+            `${globalCtx.extName}.${isAuthorizedStorageKey}`,
+            this.isAuthorized
+        )
+
+        if (this.isAuthorized) {
+            await vscode.commands.executeCommand('setContext', `${globalCtx.extName}.user`, {
+                name: this.currentUser.name,
+                avatar: this.currentUser.avatar,
+            })
+        }
+    }
+
+    private async ensureSession(opt?: AuthenticationGetSessionOptions): Promise<AuthSession | null> {
+        const session = await authentication.getSession(AuthProvider.instance.providerId, [], opt).then(
+            session => (session ? AuthSession.from(session) : null),
+            e => {
+                AlertService.err(`创建/获取 Session 失败: ${e}`)
+            }
+        )
+
+        if (session != null && session.account.accountId < 0) {
+            this._session = null
+            await AuthProvider.instance.removeSession(session.id)
+        } else {
+            this._session = session
+        }
+
+        return this._session
+    }
+}
+
+export const accountManager = new AccountManager()