460 lines
13 KiB
TypeScript
460 lines
13 KiB
TypeScript
import { Provide, Inject } from '@midwayjs/core';
|
||
import { InjectEntityModel } from '@midwayjs/typeorm';
|
||
import { Order } from '../entity/order.entity';
|
||
import { Repository } from 'typeorm';
|
||
import { CustomerTag } from '../entity/customer_tag.entity';
|
||
import { Customer } from '../entity/customer.entity';
|
||
import { SiteApiService } from './site-api.service';
|
||
import { UnifiedCustomerDTO, UnifiedSearchParamsDTO } from '../dto/site-api.dto';
|
||
import { SyncOperationResult, BatchErrorItem } from '../dto/batch.dto';
|
||
|
||
@Provide()
|
||
export class CustomerService {
|
||
@InjectEntityModel(Order)
|
||
orderModel: Repository<Order>;
|
||
|
||
@InjectEntityModel(CustomerTag)
|
||
customerTagModel: Repository<CustomerTag>;
|
||
|
||
@InjectEntityModel(Customer)
|
||
customerModel: Repository<Customer>;
|
||
|
||
@Inject()
|
||
siteApiService: SiteApiService;
|
||
|
||
/**
|
||
* 根据邮箱查找客户
|
||
*/
|
||
async findCustomerByEmail(email: string): Promise<Customer | null> {
|
||
return await this.customerModel.findOne({ where: { email } });
|
||
}
|
||
|
||
/**
|
||
* 将站点客户数据映射为本地客户实体数据
|
||
* 处理字段映射和数据转换，确保所有字段正确同步
|
||
*/
|
||
private mapSiteCustomerToCustomer(siteCustomer: UnifiedCustomerDTO, siteId: number): Partial<Customer> {
|
||
return {
|
||
site_id: siteId, // 使用站点ID而不是客户ID
|
||
origin_id: "" + siteCustomer.id,
|
||
email: siteCustomer.email,
|
||
first_name: siteCustomer.first_name,
|
||
last_name: siteCustomer.last_name,
|
||
fullname: siteCustomer.fullname || `${siteCustomer.first_name || ''} ${siteCustomer.last_name || ''}`.trim(),
|
||
username: siteCustomer.username || '',
|
||
phone: siteCustomer.phone || '',
|
||
avatar: siteCustomer.avatar,
|
||
billing: siteCustomer.billing,
|
||
shipping: siteCustomer.shipping,
|
||
raw: siteCustomer.raw || siteCustomer,
|
||
site_created_at: this.parseDate(siteCustomer.date_created),
|
||
site_updated_at: this.parseDate(siteCustomer.date_modified)
|
||
};
|
||
}
|
||
|
||
|
||
/**
|
||
* 解析日期字符串或时间戳
|
||
*/
|
||
private parseDate(dateValue: any): Date | null {
|
||
if (!dateValue) return null;
|
||
|
||
if (dateValue instanceof Date) {
|
||
return dateValue;
|
||
}
|
||
|
||
if (typeof dateValue === 'number') {
|
||
// 处理Unix时间戳（秒或毫秒）
|
||
return new Date(dateValue > 9999999999 ? dateValue : dateValue * 1000);
|
||
}
|
||
|
||
if (typeof dateValue === 'string') {
|
||
const date = new Date(dateValue);
|
||
return isNaN(date.getTime()) ? null : date;
|
||
}
|
||
|
||
return null;
|
||
}
|
||
|
||
/**
|
||
* 创建新客户
|
||
*/
|
||
async createCustomer(customerData: Partial<Customer>): Promise<Customer> {
|
||
const customer = this.customerModel.create(customerData);
|
||
return await this.customerModel.save(customer);
|
||
}
|
||
|
||
/**
|
||
* 更新客户信息
|
||
*/
|
||
async updateCustomer(id: number, customerData: Partial<Customer>): Promise<Customer> {
|
||
await this.customerModel.update(id, customerData);
|
||
return await this.customerModel.findOne({ where: { id } });
|
||
}
|
||
|
||
/**
|
||
* 创建或更新客户（upsert）
|
||
* 如果客户存在则更新，不存在则创建
|
||
*/
|
||
async upsertCustomer(
|
||
customerData: Partial<Customer>,
|
||
): Promise<{ customer: Customer; isCreated: boolean }> {
|
||
if(!customerData.email) throw new Error("客户邮箱不能为空");
|
||
// 首先尝试根据邮箱查找现有客户
|
||
const existingCustomer = await this.findCustomerByEmail(customerData.email);
|
||
|
||
if (existingCustomer) {
|
||
// 如果客户存在，更新客户信息
|
||
const updatedCustomer = await this.updateCustomer(existingCustomer.id, customerData);
|
||
return { customer: updatedCustomer, isCreated: false };
|
||
} else {
|
||
// 如果客户不存在，创建新客户
|
||
const newCustomer = await this.createCustomer(customerData);
|
||
return { customer: newCustomer, isCreated: true };
|
||
}
|
||
}
|
||
|
||
/**
|
||
* 批量创建或更新客户
|
||
* 使用事务确保数据一致性
|
||
*/
|
||
async upsertManyCustomers(
|
||
customersData: Array<Partial<Customer>>
|
||
): Promise<{
|
||
customers: Customer[];
|
||
created: number;
|
||
updated: number;
|
||
processed: number;
|
||
errors: BatchErrorItem[];
|
||
}> {
|
||
const results = {
|
||
customers: [],
|
||
created: 0,
|
||
updated: 0,
|
||
processed: 0,
|
||
errors: []
|
||
};
|
||
|
||
// 批量处理每个客户
|
||
for (const customerData of customersData) {
|
||
try {
|
||
const result = await this.upsertCustomer(customerData);
|
||
results.customers.push(result.customer);
|
||
|
||
if (result.isCreated) {
|
||
results.created++;
|
||
} else {
|
||
results.updated++;
|
||
}
|
||
results.processed++;
|
||
} catch (error) {
|
||
// 记录错误但不中断整个批量操作
|
||
results.errors.push({
|
||
identifier: customerData.email || String(customerData.id) || 'unknown',
|
||
error: error.message
|
||
});
|
||
}
|
||
}
|
||
|
||
return results;
|
||
}
|
||
|
||
/**
|
||
* 从站点同步客户数据
|
||
* 第一步：调用adapter获取站点客户数据
|
||
* 第二步：通过upsertManyCustomers保存这些客户
|
||
*/
|
||
async syncCustomersFromSite(
|
||
siteId: number,
|
||
params?: UnifiedSearchParamsDTO
|
||
): Promise<SyncOperationResult> {
|
||
try {
|
||
// 第一步：获取适配器并从站点获取客户数据
|
||
const adapter = await this.siteApiService.getAdapter(siteId);
|
||
const siteCustomersResult = await adapter.getCustomers(params || {});
|
||
|
||
// 第二步：将站点客户数据转换为客户实体数据
|
||
const customersData = siteCustomersResult.items.map(siteCustomer => {
|
||
return this.mapSiteCustomerToCustomer(siteCustomer, siteId);
|
||
});
|
||
|
||
// 第三步：批量upsert客户数据
|
||
const upsertResult = await this.upsertManyCustomers(customersData);
|
||
return {
|
||
total: siteCustomersResult.total,
|
||
processed: upsertResult.customers.length,
|
||
synced: upsertResult.customers.length,
|
||
updated: upsertResult.updated,
|
||
created: upsertResult.created,
|
||
errors: upsertResult.errors
|
||
};
|
||
|
||
} catch (error) {
|
||
// 如果获取适配器或站点数据失败，抛出错误
|
||
throw new Error(`同步客户数据失败: ${error.message}`);
|
||
}
|
||
}
|
||
|
||
async getCustomerStatisticList(param: Record<string, any>) {
|
||
const {
|
||
current = 1,
|
||
pageSize = 10,
|
||
email,
|
||
tags,
|
||
sorterKey,
|
||
sorterValue,
|
||
state,
|
||
first_purchase_date,
|
||
customerId,
|
||
rate,
|
||
} = param;
|
||
|
||
const whereConds: string[] = [];
|
||
const havingConds: string[] = [];
|
||
|
||
// 邮箱搜索
|
||
if (email) {
|
||
whereConds.push(`o.customer_email LIKE '%${email}%'`);
|
||
}
|
||
|
||
// 省份搜索
|
||
if (state) {
|
||
whereConds.push(
|
||
`JSON_UNQUOTE(JSON_EXTRACT(o.billing, '$.state')) = '${state}'`
|
||
);
|
||
}
|
||
|
||
// customerId 过滤
|
||
if (customerId) {
|
||
whereConds.push(`c.id = ${Number(customerId)}`);
|
||
}
|
||
|
||
// rate 过滤
|
||
if (rate) {
|
||
whereConds.push(`c.rate = ${Number(rate)}`);
|
||
}
|
||
|
||
// tags 过滤
|
||
if (tags) {
|
||
const tagList = tags
|
||
.split(',')
|
||
.map(tag => `'${tag.trim()}'`)
|
||
.join(',');
|
||
havingConds.push(`
|
||
EXISTS (
|
||
SELECT 1 FROM customer_tag ct
|
||
WHERE ct.email = o.customer_email
|
||
AND ct.tag IN (${tagList})
|
||
)
|
||
`);
|
||
}
|
||
|
||
// 首次购买时间过滤
|
||
if (first_purchase_date) {
|
||
havingConds.push(
|
||
`DATE_FORMAT(MIN(o.date_paid), '%Y-%m') = '${first_purchase_date}'`
|
||
);
|
||
}
|
||
|
||
// 公用过滤
|
||
const baseQuery = `
|
||
${whereConds.length ? `WHERE ${whereConds.join(' AND ')}` : ''}
|
||
GROUP BY o.customer_email
|
||
${havingConds.length ? `HAVING ${havingConds.join(' AND ')}` : ''}
|
||
`;
|
||
|
||
// 主查询
|
||
const sql = `
|
||
SELECT
|
||
o.customer_email AS email,
|
||
MIN(o.date_created) AS date_created,
|
||
MIN(o.date_paid) AS first_purchase_date,
|
||
MAX(o.date_paid) AS last_purchase_date,
|
||
COUNT(DISTINCT o.id) AS orders,
|
||
SUM(o.total) AS total,
|
||
ANY_VALUE(o.shipping) AS shipping,
|
||
ANY_VALUE(o.billing) AS billing,
|
||
(
|
||
SELECT JSON_ARRAYAGG(tag)
|
||
FROM customer_tag ct
|
||
WHERE ct.email = o.customer_email
|
||
) AS tags,
|
||
c.id AS customerId,
|
||
c.rate AS rate,
|
||
yoone_stats.yoone_orders,
|
||
yoone_stats.yoone_total
|
||
FROM \`order\` o
|
||
LEFT JOIN customer c ON o.customer_email = c.email
|
||
LEFT JOIN (
|
||
SELECT
|
||
oo.customer_email,
|
||
COUNT(DISTINCT oi.orderId) AS yoone_orders,
|
||
SUM(oi.total) AS yoone_total
|
||
FROM order_item oi
|
||
JOIN \`order\` oo ON oi.orderId = oo.id
|
||
WHERE oi.name LIKE '%yoone%'
|
||
GROUP BY oo.customer_email
|
||
) yoone_stats ON yoone_stats.customer_email = o.customer_email
|
||
${baseQuery}
|
||
${sorterKey
|
||
? `ORDER BY ${sorterKey} ${sorterValue === 'descend' ? 'DESC' : 'ASC'}`
|
||
: 'ORDER BY orders ASC, yoone_total DESC'}
|
||
LIMIT ${pageSize} OFFSET ${(current - 1) * pageSize}
|
||
`;
|
||
|
||
// 统计总数
|
||
const countSql = `
|
||
SELECT COUNT(*) AS total FROM (
|
||
SELECT o.customer_email
|
||
FROM \`order\` o
|
||
LEFT JOIN customer c ON o.customer_email = c.email
|
||
${baseQuery}
|
||
) AS sub
|
||
`;
|
||
|
||
const [items, countResult] = await Promise.all([
|
||
this.orderModel.query(sql),
|
||
this.orderModel.query(countSql),
|
||
]);
|
||
|
||
const total = countResult[0]?.total || 0;
|
||
|
||
return {
|
||
items,
|
||
total,
|
||
current,
|
||
pageSize,
|
||
};
|
||
}
|
||
|
||
/**
|
||
* 获取纯粹的客户列表（不包含订单统计信息）
|
||
* 支持基本的分页、搜索和排序功能
|
||
* 使用TypeORM查询构建器实现
|
||
*/
|
||
async getCustomerList(param: Record<string, any>): Promise<any>{
|
||
const {
|
||
current = 1,
|
||
pageSize = 10,
|
||
email,
|
||
firstName,
|
||
lastName,
|
||
phone,
|
||
state,
|
||
rate,
|
||
sorterKey,
|
||
sorterValue,
|
||
} = param;
|
||
|
||
// 创建查询构建器
|
||
const queryBuilder = this.customerModel
|
||
.createQueryBuilder('c')
|
||
.leftJoinAndSelect(
|
||
'customer_tag',
|
||
'ct',
|
||
'ct.email = c.email'
|
||
)
|
||
.select([
|
||
'c.id',
|
||
'c.email',
|
||
'c.first_name',
|
||
'c.last_name',
|
||
'c.fullname',
|
||
'c.username',
|
||
'c.phone',
|
||
'c.avatar',
|
||
'c.billing',
|
||
'c.shipping',
|
||
'c.rate',
|
||
'c.site_id',
|
||
'c.created_at',
|
||
'c.updated_at',
|
||
'c.site_created_at',
|
||
'c.site_updated_at',
|
||
'GROUP_CONCAT(ct.tag) as tags'
|
||
])
|
||
.groupBy('c.id');
|
||
|
||
// 邮箱搜索
|
||
if (email) {
|
||
queryBuilder.andWhere('c.email LIKE :email', { email: `%${email}%` });
|
||
}
|
||
|
||
// 姓名搜索
|
||
if (firstName) {
|
||
queryBuilder.andWhere('c.first_name LIKE :firstName', { firstName: `%${firstName}%` });
|
||
}
|
||
|
||
if (lastName) {
|
||
queryBuilder.andWhere('c.last_name LIKE :lastName', { lastName: `%${lastName}%` });
|
||
}
|
||
|
||
// 电话搜索
|
||
if (phone) {
|
||
queryBuilder.andWhere('c.phone LIKE :phone', { phone: `%${phone}%` });
|
||
}
|
||
|
||
// 省份搜索
|
||
if (state) {
|
||
queryBuilder.andWhere("JSON_UNQUOTE(JSON_EXTRACT(c.billing, '$.state')) = :state", { state });
|
||
}
|
||
|
||
// 评分过滤
|
||
if (rate !== undefined && rate !== null) {
|
||
queryBuilder.andWhere('c.rate = :rate', { rate: Number(rate) });
|
||
}
|
||
|
||
// 排序处理
|
||
if (sorterKey) {
|
||
const order = sorterValue === 'descend' ? 'DESC' : 'ASC';
|
||
queryBuilder.orderBy(`c.${sorterKey}`, order);
|
||
} else {
|
||
queryBuilder.orderBy('c.created_at', 'DESC');
|
||
}
|
||
|
||
// 分页
|
||
queryBuilder.skip((current - 1) * pageSize).take(pageSize);
|
||
|
||
// 执行查询
|
||
const [items, total] = await queryBuilder.getManyAndCount();
|
||
|
||
// 处理tags字段，将逗号分隔的字符串转换为数组
|
||
const processedItems = items.map(item => {
|
||
const plainItem = JSON.parse(JSON.stringify(item));
|
||
plainItem.tags = plainItem.tags ? plainItem.tags.split(',').filter(tag => tag) : [];
|
||
return plainItem;
|
||
});
|
||
|
||
return {
|
||
items: processedItems,
|
||
total,
|
||
current,
|
||
pageSize,
|
||
};
|
||
}
|
||
|
||
|
||
async addTag(email: string, tag: string) {
|
||
const isExist = await this.customerTagModel.findOneBy({ email, tag });
|
||
if (isExist) throw new Error(`${tag}已存在`);
|
||
return await this.customerTagModel.save({ email, tag });
|
||
}
|
||
|
||
async delTag(email: string, tag: string) {
|
||
const isExist = await this.customerTagModel.findOneBy({ email, tag });
|
||
if (!isExist) throw new Error(`${tag}不存在`);
|
||
return await this.customerTagModel.delete({ email, tag });
|
||
}
|
||
|
||
async getTags() {
|
||
const tags = await this.customerTagModel
|
||
.createQueryBuilder('tag')
|
||
.select('DISTINCT tag.tag', 'tag')
|
||
.getRawMany();
|
||
return tags.map(t => t.tag);
|
||
}
|
||
|
||
async setRate(params: { id: number; rate: number }) {
|
||
return await this.customerModel.update(params.id, { rate: params.rate });
|
||
}
|
||
} |