wurenzhi
2b86715c09
- 移除未使用的TabPane组件 - 修复类型定义和导入方式 - 优化mock数据源的环境变量判断逻辑 - 更新文档结构并归档旧文件 - 添加新的UI组件和Memo组件 - 调整API路径和响应处理
317 lines
12 KiB
TypeScript
317 lines
12 KiB
TypeScript
import db from '../config/database';
|
|
import { DomainEventBus } from '../core/runtime/DomainEventBus';
|
|
import { logger } from '../utils/logger';
|
|
|
|
export interface PlatformAccount {
|
|
id: string;
|
|
tenantId: string;
|
|
platform: string;
|
|
accountName: string;
|
|
accountId: string;
|
|
status: 'ACTIVE' | 'INACTIVE' | 'EXPIRED' | 'ERROR';
|
|
token?: string;
|
|
refreshToken?: string;
|
|
expiresAt?: string;
|
|
shopId?: string;
|
|
config?: Record<string, any>;
|
|
lastSyncAt?: string;
|
|
createdAt: string;
|
|
updatedAt: string;
|
|
}
|
|
|
|
export interface PlatformAccountStats {
|
|
total: number;
|
|
active: number;
|
|
inactive: number;
|
|
expired: number;
|
|
error: number;
|
|
}
|
|
|
|
export class PlatformAccountService {
|
|
private static TABLE = 'cf_platform_account';
|
|
|
|
static async initTable(): Promise<void> {
|
|
const hasTable = await db.schema.hasTable(this.TABLE);
|
|
if (!hasTable) {
|
|
await db.schema.createTable(this.TABLE, (table) => {
|
|
table.string('id', 64).primary();
|
|
table.string('tenant_id', 64).notNullable();
|
|
table.string('platform', 64).notNullable();
|
|
table.string('account_name', 128).notNullable();
|
|
table.string('account_id', 128).notNullable();
|
|
table.enum('status', ['ACTIVE', 'INACTIVE', 'EXPIRED', 'ERROR']).defaultTo('ACTIVE');
|
|
table.text('token');
|
|
table.text('refresh_token');
|
|
table.timestamp('expires_at');
|
|
table.string('shop_id', 64);
|
|
table.json('config');
|
|
table.timestamp('last_sync_at');
|
|
table.timestamps(true, true);
|
|
table.index(['tenant_id', 'platform']);
|
|
table.index(['shop_id']);
|
|
table.unique(['tenant_id', 'platform', 'account_id']);
|
|
});
|
|
}
|
|
}
|
|
|
|
static async list(tenantId: string, filters?: { platform?: string; status?: string; shopId?: string }): Promise<PlatformAccount[]> {
|
|
let query = db(this.TABLE).where('tenant_id', tenantId);
|
|
if (filters?.platform) query = query.where('platform', filters.platform);
|
|
if (filters?.status) query = query.where('status', filters.status);
|
|
if (filters?.shopId) query = query.where('shop_id', filters.shopId);
|
|
return query.orderBy('created_at', 'desc');
|
|
}
|
|
|
|
static async getById(id: string): Promise<PlatformAccount | null> {
|
|
const account = await db(this.TABLE).where({ id }).first();
|
|
return account || null;
|
|
}
|
|
|
|
static async create(tenantId: string, data: {
|
|
platform: string;
|
|
accountName: string;
|
|
accountId: string;
|
|
token?: string;
|
|
refreshToken?: string;
|
|
expiresAt?: string;
|
|
shopId?: string;
|
|
config?: Record<string, any>;
|
|
}): Promise<PlatformAccount> {
|
|
const id = this.generateId();
|
|
const now = new Date().toISOString();
|
|
const account: PlatformAccount = {
|
|
id,
|
|
tenantId,
|
|
platform: data.platform,
|
|
accountName: data.accountName,
|
|
accountId: data.accountId,
|
|
status: 'ACTIVE',
|
|
token: data.token,
|
|
refreshToken: data.refreshToken,
|
|
expiresAt: data.expiresAt,
|
|
shopId: data.shopId,
|
|
config: data.config,
|
|
createdAt: now,
|
|
updatedAt: now,
|
|
};
|
|
await db(this.TABLE).insert({
|
|
id: account.id,
|
|
tenant_id: account.tenantId,
|
|
platform: account.platform,
|
|
account_name: account.accountName,
|
|
account_id: account.accountId,
|
|
status: account.status,
|
|
token: account.token,
|
|
refresh_token: account.refreshToken,
|
|
expires_at: account.expiresAt,
|
|
shop_id: account.shopId,
|
|
config: account.config ? JSON.stringify(account.config) : null,
|
|
created_at: account.createdAt,
|
|
updated_at: account.updatedAt,
|
|
});
|
|
await DomainEventBus.publish('platform_account.created', { accountId: id, tenantId, platform: data.platform });
|
|
return account;
|
|
}
|
|
|
|
static async update(id: string, data: Partial<PlatformAccount>): Promise<PlatformAccount> {
|
|
const updateData: Record<string, any> = { updated_at: new Date().toISOString() };
|
|
if (data.accountName) updateData.account_name = data.accountName;
|
|
if (data.status) updateData.status = data.status;
|
|
if (data.token !== undefined) updateData.token = data.token;
|
|
if (data.refreshToken !== undefined) updateData.refresh_token = data.refreshToken;
|
|
if (data.expiresAt !== undefined) updateData.expires_at = data.expiresAt;
|
|
if (data.shopId !== undefined) updateData.shop_id = data.shopId;
|
|
if (data.config) updateData.config = JSON.stringify(data.config);
|
|
await db(this.TABLE).where({ id }).update(updateData);
|
|
const account = await this.getById(id);
|
|
await DomainEventBus.publish('platform_account.updated', { accountId: id });
|
|
return account!;
|
|
}
|
|
|
|
static async delete(id: string): Promise<void> {
|
|
await db(this.TABLE).where({ id }).delete();
|
|
await DomainEventBus.publish('platform_account.deleted', { accountId: id });
|
|
}
|
|
|
|
static async refreshToken(id: string): Promise<{ success: boolean; message: string }> {
|
|
const account = await this.getById(id);
|
|
if (!account) return { success: false, message: 'Account not found' };
|
|
if (!account.refreshToken) return { success: false, message: 'No refresh token available' };
|
|
try {
|
|
const newToken = await this.callPlatformRefreshApi(account.platform, account.refreshToken);
|
|
await db(this.TABLE).where({ id }).update({
|
|
token: newToken.token,
|
|
expires_at: newToken.expiresAt,
|
|
status: 'ACTIVE',
|
|
updated_at: new Date().toISOString(),
|
|
});
|
|
await DomainEventBus.publish('platform_account.token_refreshed', { accountId: id });
|
|
return { success: true, message: 'Token refreshed successfully' };
|
|
} catch (error: any) {
|
|
await db(this.TABLE).where({ id }).update({
|
|
status: 'ERROR',
|
|
updated_at: new Date().toISOString(),
|
|
});
|
|
return { success: false, message: error.message };
|
|
}
|
|
}
|
|
|
|
static async testConnection(id: string): Promise<{ success: boolean; message: string }> {
|
|
const account = await this.getById(id);
|
|
if (!account) return { success: false, message: 'Account not found' };
|
|
try {
|
|
const isValid = await this.validateToken(account.platform, account.token!);
|
|
if (isValid) {
|
|
await db(this.TABLE).where({ id }).update({ status: 'ACTIVE', updated_at: new Date().toISOString() });
|
|
return { success: true, message: 'Connection successful' };
|
|
}
|
|
await db(this.TABLE).where({ id }).update({ status: 'EXPIRED', updated_at: new Date().toISOString() });
|
|
return { success: false, message: 'Token expired' };
|
|
} catch (error: any) {
|
|
await db(this.TABLE).where({ id }).update({ status: 'ERROR', updated_at: new Date().toISOString() });
|
|
return { success: false, message: error.message };
|
|
}
|
|
}
|
|
|
|
static async syncAccount(id: string): Promise<{ success: boolean; message: string }> {
|
|
const account = await this.getById(id);
|
|
if (!account) return { success: false, message: 'Account not found' };
|
|
try {
|
|
await db(this.TABLE).where({ id }).update({
|
|
last_sync_at: new Date().toISOString(),
|
|
updated_at: new Date().toISOString(),
|
|
});
|
|
await DomainEventBus.publish('platform_account.sync_requested', { accountId: id, platform: account.platform });
|
|
return { success: true, message: 'Sync initiated' };
|
|
} catch (error: any) {
|
|
return { success: false, message: error.message };
|
|
}
|
|
}
|
|
|
|
static async getStats(tenantId: string): Promise<PlatformAccountStats> {
|
|
const accounts = await this.list(tenantId);
|
|
return {
|
|
total: accounts.length,
|
|
active: accounts.filter((a) => a.status === 'ACTIVE').length,
|
|
inactive: accounts.filter((a) => a.status === 'INACTIVE').length,
|
|
expired: accounts.filter((a) => a.status === 'EXPIRED').length,
|
|
error: accounts.filter((a) => a.status === 'ERROR').length,
|
|
};
|
|
}
|
|
|
|
static generateOAuthUrl(accountId: string, platform: string): string {
|
|
const OAUTH_CONFIG: Record<string, { authUrl: string; clientId: string; scope: string }> = {
|
|
AMAZON: {
|
|
authUrl: 'https://sellercentral.amazon.com/apps/authorize/consent',
|
|
clientId: process.env.AMAZON_CLIENT_ID || '',
|
|
scope: 'sellingpartnerapi::migration',
|
|
},
|
|
EBAY: {
|
|
authUrl: 'https://auth.ebay.com/oauth2/authorize',
|
|
clientId: process.env.EBAY_CLIENT_ID || '',
|
|
scope: 'https://api.ebay.com/oauth/api_scope',
|
|
},
|
|
SHOPIFY: {
|
|
authUrl: `https://{shop}.myshopify.com/admin/oauth/authorize`,
|
|
clientId: process.env.SHOPIFY_CLIENT_ID || '',
|
|
scope: 'read_products,write_products,read_orders,write_orders',
|
|
},
|
|
SHOPEE: {
|
|
authUrl: 'https://partner.shopeemobile.com/api/v2/shop/auth_partner',
|
|
clientId: process.env.SHOPEE_PARTNER_ID || '',
|
|
scope: '',
|
|
},
|
|
TIKTOK: {
|
|
authUrl: 'https://services.tiktokshop.com/open/authorize',
|
|
clientId: process.env.TIKTOK_APP_ID || '',
|
|
scope: '',
|
|
},
|
|
};
|
|
|
|
const config = OAUTH_CONFIG[platform.toUpperCase()];
|
|
if (!config) {
|
|
throw new Error(`Unsupported platform: ${platform}`);
|
|
}
|
|
|
|
const redirectUri = `${process.env.API_BASE_URL}/api/platform-auth/callback/${platform.toLowerCase()}`;
|
|
const state = Buffer.from(JSON.stringify({ accountId, timestamp: Date.now() })).toString('base64');
|
|
|
|
const params = new URLSearchParams({
|
|
client_id: config.clientId,
|
|
redirect_uri: redirectUri,
|
|
response_type: 'code',
|
|
scope: config.scope,
|
|
state,
|
|
});
|
|
|
|
return `${config.authUrl}?${params.toString()}`;
|
|
}
|
|
|
|
static async handleOAuthCallback(platform: string, code: string, state: string): Promise<{ success: boolean; error?: string }> {
|
|
try {
|
|
const stateData = JSON.parse(Buffer.from(state, 'base64').toString());
|
|
const { accountId } = stateData;
|
|
|
|
const account = await this.getById(accountId);
|
|
if (!account) {
|
|
return { success: false, error: 'Account not found' };
|
|
}
|
|
|
|
const tokens = await this.exchangeCodeForTokens(platform, code);
|
|
|
|
await db(this.TABLE).where({ id: accountId }).update({
|
|
token: tokens.accessToken,
|
|
refresh_token: tokens.refreshToken,
|
|
expires_at: tokens.expiresAt,
|
|
status: 'ACTIVE',
|
|
updated_at: new Date().toISOString(),
|
|
});
|
|
|
|
await DomainEventBus.publish('platform_account.authorized', { accountId, platform });
|
|
|
|
return { success: true };
|
|
} catch (error: any) {
|
|
logger.error(`[PlatformAccountService] OAuth callback error: ${error.message}`);
|
|
return { success: false, error: error.message };
|
|
}
|
|
}
|
|
|
|
static async disconnect(id: string): Promise<void> {
|
|
await db(this.TABLE).where({ id }).update({
|
|
status: 'INACTIVE',
|
|
token: null,
|
|
refresh_token: null,
|
|
updated_at: new Date().toISOString(),
|
|
});
|
|
|
|
await DomainEventBus.publish('platform_account.disconnected', { accountId: id });
|
|
}
|
|
|
|
private static async exchangeCodeForTokens(platform: string, code: string): Promise<{
|
|
accessToken: string;
|
|
refreshToken: string;
|
|
expiresAt: string;
|
|
}> {
|
|
return {
|
|
accessToken: `access_${platform}_${Date.now()}`,
|
|
refreshToken: `refresh_${platform}_${Date.now()}`,
|
|
expiresAt: new Date(Date.now() + 3600000 * 24 * 30).toISOString(),
|
|
};
|
|
}
|
|
|
|
private static async callPlatformRefreshApi(platform: string, refreshToken: string): Promise<{ token: string; expiresAt: string }> {
|
|
return {
|
|
token: `new_token_${Date.now()}`,
|
|
expiresAt: new Date(Date.now() + 3600000).toISOString(),
|
|
};
|
|
}
|
|
|
|
private static async validateToken(platform: string, token: string): Promise<boolean> {
|
|
return !!token;
|
|
}
|
|
|
|
private static generateId(): string {
|
|
return `pa_${Date.now()}_${Math.random().toString(36).substr(2, 9)}`;
|
|
}
|
|
}
|