九块九付费进群源码_知识付费/社群变现系统_支持分销裂变功能

　　┌───────────────┐┌───────────────┐┌───────────────┐
　　│客户端集群│────►│Nginx负载均衡│────►│API网关服务│
　　└───────────────┘└───────────────┘└───────────────┘
　　│
　　▼
　　┌───────────────┬───────────────┬───────────────┐
　　│用户服务集群│支付服务集群│分销服务集群│
　　└───────────────┘└───────────────┘└───────────────┘
　　│││
　　▼▼▼
　　┌───────────────┬───────────────┬───────────────┐
　　│MySQL主库│Redis集群│MongoDB集群│
　　└───────────────┘└───────────────┘└───────────────┘

　　sql
　　CREATE TABLE`user`(
　　`id`bigint(20)NOT NULL AUTO_INCREMENT COMMENT'用户ID',
　　`openid`varchar(128)DEFAULT NULL COMMENT'微信OpenID',
　　`nickname`varchar(64)DEFAULT NULL COMMENT'用户昵称',
　　`avatar`varchar(255)DEFAULT NULL COMMENT'头像URL',
　　`phone`varchar(20)DEFAULT NULL COMMENT'手机号',
　　`inviter_id`bigint(20)DEFAULT NULL COMMENT'邀请人ID',
　　`create_time`datetime DEFAULT CURRENT_TIMESTAMP COMMENT'注册时间',
　　`update_time`datetime DEFAULT CURRENT_TIMESTAMP ON UPDATE CURRENT_TIMESTAMP COMMENT'更新时间',
　　PRIMARY KEY(`id`),
　　UNIQUE KEY`idx_openid`(`openid`)
　　)ENGINE=InnoDB DEFAULT CHARSET=utf8mb4 COMMENT='用户表';

　　sql
　　CREATE TABLE`group`(
　　`id`bigint(20)NOT NULL AUTO_INCREMENT COMMENT'社群ID',
　　`title`varchar(128)NOT NULL COMMENT'社群名称',
　　`description`text COMMENT'社群介绍',
　　`price`decimal(10,2)NOT NULL COMMENT'进群价格',
　　`owner_id`bigint(20)NOT NULL COMMENT'群主ID',
　　`member_count`int(11)DEFAULT'0'COMMENT'成员数量',
　　`status`tinyint(4)DEFAULT'1'COMMENT'状态:1正常2封禁',
　　`create_time`datetime DEFAULT CURRENT_TIMESTAMP COMMENT'创建时间',
　　PRIMARY KEY(`id`)
　　)ENGINE=InnoDB DEFAULT CHARSET=utf8mb4 COMMENT='社群表';

　　sql
　　CREATE TABLE`distribution`(
　　`id`bigint(20)NOT NULL AUTO_INCREMENT COMMENT'ID',
　　`user_id`bigint(20)NOT NULL COMMENT'用户ID',
　　`inviter_id`bigint(20)NOT NULL COMMENT'邀请人ID',
　　`level`tinyint(4)NOT NULL COMMENT'分销层级(1-3级)',
　　`commission_rate`decimal(5,2)NOT NULL COMMENT'佣金比例(%)',
　　`create_time`datetime DEFAULT CURRENT_TIMESTAMP COMMENT'创建时间',
　　PRIMARY KEY(`id`),
　　UNIQUE KEY`idx_user_inviter`(`user_id`,`inviter_id`)
　　)ENGINE=InnoDB DEFAULT CHARSET=utf8mb4 COMMENT='分销关系表';

　　┌──────────┐┌──────────┐┌────────────┐
　　│user│─────│distribution│─────│group│
　　└──────────┘└──────────┘└────────────┘
　　│││
　　└────────────────────┘│
　　││
　　┌──────────────┴──────────────┐┌────────┴────────┐
　　│group_member││order│
　　└────────────────────────────┘└────────────────┘

　　javascript
　　//付费进群核心处理服务-groupService.js
　　const groupModel=require('../models/group');
　　const orderModel=require('../models/order');
　　const userModel=require('../models/user');
　　const distributionService=require('./distributionService');
　　const paymentService=require('./paymentService');
　　/
　　*处理用户付费进群请求
　　*param{number}userId-用户ID
　　*param{number}groupId-社群ID
　　*param{number}inviterId-邀请人ID(可选)
　　*returns{Object}支付链接或错误信息
　　*/
　　async function payToJoinGroup(userId,groupId,inviterId=null){
　　//1.校验社群存在性与状态
　　const group=await groupModel.findById(groupId);
　　if(!group||group.status!==1){
　　throw new Error('社群不存在或已封禁');
　　}
　　//2.校验用户是否已加入
　　const hasJoined=await groupModel.checkUserInGroup(userId,groupId);
　　if(hasJoined){
　　throw new Error('您已加入该社群');
　　}
　　//3.创建订单
　　const orderNo=generateOrderNo();//生成订单号
　　const orderAmount=group.price;//订单金额
　　const order=await orderModel.createOrder({
　　order_no:orderNo,
　　user_id:userId,
　　group_id:groupId,
　　amount:orderAmount,
　　inviter_id:inviterId,
　　status:'pending'//待支付状态
　　});
　　//4.处理分销关系(如果有邀请人)
　　if(inviterId){
　　await distributionService.establishRelation(userId,inviterId,groupId);
　　}
　　//5.调用支付接口生成支付链接
　　const paymentParams={
　　orderNo,
　　amount:orderAmount,
　　description:`加入社群:${group.title}`,
　　returnUrl:`https://www.example.com/join-group/${groupId}`,
　　notifyUrl:'https://api.example.com/payment/notify'
　　};
　　let paymentResult;
　　try{
　　paymentResult=await paymentService.createPayment(paymentParams);
　　}catch(error){
　　await orderModel.updateOrderStatus(orderNo,'failed',error.message);
　　throw error;
　　}
　　return{
　　orderNo,
　　paymentUrl:paymentResult.paymentUrl,
　　qrCodeUrl:paymentResult.qrCodeUrl
　　};
　　}
　　/
　　*支付回调处理
　　*param{Object}paymentNotify-支付通知参数
　　*returns{boolean}处理结果
　　*/
　　async function handlePaymentNotify(paymentNotify){
　　//1.验证支付通知合法性
　　const isValid=await paymentService.verifyNotify(paymentNotify);
　　if(!isValid){
　　return false;
　　}
　　//2.解析通知参数
　　const{orderNo,paymentStatus,transactionId}=paymentNotify;
　　//3.查询订单
　　const order=await orderModel.findByOrderNo(orderNo);
　　if(!order||order.status!=='pending'){
　　return true;//订单不存在或非待支付状态，忽略通知
　　}
　　//4.处理支付成功逻辑
　　if(paymentStatus==='success'){
　　//4.1更新订单状态
　　await orderModel.updateOrderStatus(
　　orderNo,
　　'success',
　　`支付成功,交易号:${transactionId}`
　　);
　　//4.2添加用户到社群
　　await groupModel.addUserToGroup(order.user_id,order.group_id);
　　//4.3分发分销佣金
　　if(order.inviter_id){
　　await distributionService.distributeCommission(
　　order.user_id,
　　order.inviter_id,
　　order.group_id,
　　order.amount
　　);
　　}
　　//4.4发送进群通知
　　await sendJoinGroupNotification(order.user_id,order.group_id);
　　}else{
　　//处理支付失败
　　await orderModel.updateOrderStatus(
　　orderNo,
　　'failed',
　　`支付失败,状态:${paymentStatus}`
　　);
　　}
　　return true;
　　}

　　javascript
　　//微信支付服务-wechatPayment.js
　　const axios=require('axios');
　　const crypto=require('crypto');
　　const fs=require('fs');
　　const path=require('path');
　　class WechatPayment{
　　constructor(mchId,mchKey,certPath,keyPath){
　　this.mchId=mchId;
　　this.mchKey=mchKey;
　　this.certPath=certPath;
　　this.keyPath=keyPath;
　　this.apiBase='https://api.mch.weixin.qq.com/v3';
　　}
　　//生成API请求签名
　　generateSignature(method,url,timestamp,nonce,body){
　　const key=fs.readFileSync(this.keyPath,'utf8');
　　const message=[timestamp,nonce,method,url,body||''].join('n');
　　const signature=crypto.createSign('RSA-SHA256')
　　.update(message)
　　.sign(key,'base64');
　　return signature;
　　}
　　//创建H5支付订单
　　async createH5Payment(orderNo,amount,description,returnUrl){
　　const timestamp=Date.now()+'';
　　const nonce=Math.random().toString(36).substr(2,10);
　　const body={
　　out_trade_no:orderNo,
　　attach:'付费进群',
　　description:description,
　　amount:{
　　total:Math.round(amount*100),//转换为分
　　currency:'CNY'
　　},
　　payer:{
　　openid:''//H5支付无需openid
　　},
　　trade_type:'H5',
　　scene_info:{
　　h5_info:{
　　type:'Wap',
　　wap_url:'https://www.example.com',
　　wap_name:'知识付费平台'
　　}
　　},
　　notify_url:'https://api.example.com/wechat/pay/notify'
　　};
　　const url='/pay/transactions/h5';
　　const signature=this.generateSignature(
　　'POST',
　　url,
　　timestamp,
　　nonce,
　　JSON.stringify(body)
　　);
　　const headers={
　　'Content-Type':'application/json',
　　'Wechatpay-Timestamp':timestamp,
　　'Wechatpay-Nonce':nonce,
　　'Wechatpay-Signature':signature,
　　'Wechatpay-Mch-Id':this.mchId
　　};
　　const response=await axios.post(
　　this.apiBase+url,
　　body,
　　{headers}
　　);
　　return{
　　paymentUrl:response.data.h5_url,
　　qrCodeUrl:this.generateQrCode(response.data.h5_url)
　　};
　　}
　　//生成支付二维码
　　generateQrCode(url){
　　//实际项目中可使用qrcode-generator等库生成二维码
　　return`https://api.qrcode.example.com/create?url=${encodeURIComponent(url)}`;
　　}
　　}

　　javascript
　　//分销服务-distributionService.js
　　const distributionModel=require('../models/distribution');
　　const userModel=require('../models/user');
　　const commissionModel=require('../models/commission');
　　const walletService=require('./walletService');
　　/
　　*建立分销关系
　　*param{number}userId-被邀请用户ID
　　*param{number}inviterId-邀请人ID
　　*param{number}groupId-社群ID
　　*returns{boolean}建立结果
　　*/
　　async function establishRelation(userId,inviterId,groupId){
　　//1.校验邀请人有效性
　　const inviter=await userModel.findById(inviterId);
　　if(!inviter){
　　throw new Error('邀请人不存在');
　　}
　　//2.检查是否已存在分销关系
　　const existingRelation=await distributionModel.findByUser(userId);
　　if(existingRelation){
　　return true;//已存在分销关系，不再重复建立
　　}
　　//3.构建分销关系链(最多三级)
　　const relationChain=[inviterId];
　　let currentInviterId=inviterId;
　　//查找上级邀请人，构建关系链
　　for(let i=1;i<3;i++){
　　const parentRelation=await distributionModel.findByUser(currentInviterId);
　　if(parentRelation){
　　relationChain.push(parentRelation.inviter_id);
　　currentInviterId=parentRelation.inviter_id;
　　}else{
　　break;
　　}
　　}
　　//4.保存分销关系
　　const relations=[];
　　relationChain.forEach((inviterId,index)=>{
　　if(index<3){//最多三级分销
　　relations.push({
　　user_id:userId,
　　inviter_id:inviterId,
　　level:index+1,
　　commission_rate:getCommissionRate(index+1)//获取对应层级佣金比例
　　});
　　}
　　});
　　await distributionModel.batchCreate(relations);
　　return true;
　　}
　　/
　　*分发分销佣金
　　*param{number}buyerId-购买用户ID
　　*param{number}inviterId-直接邀请人ID
　　*param{number}groupId-社群ID
　　*param{number}amount-订单金额
　　*returns{Promise<number[]>}各层级佣金金额
　　*/
　　async function distributeCommission(buyerId,inviterId,groupId,amount){
　　//1.获取分销关系
　　const relations=await distributionModel.findByUser(buyerId);
　　if(!relations||relations.length===0){
　　return[];//无分销关系，不进行佣金分发
　　}
　　//2.计算各层级佣金
　　const commissions=[];
　　let totalCommission=0;
　　const groupCommissionConfig=await getGroupCommissionConfig(groupId);//获取社群佣金配置
　　relations.forEach(relation=>{
　　if(relation.level>3)return;//超过三级分销，不再分发
　　const rate=groupCommissionConfig[`level${relation.level}_rate`]||0;
　　const commission=amount*rate/100;
　　if(commission>0){
　　commissions.push({
　　inviter_id:relation.inviter_id,
　　amount:commission,
　　level:relation.level,
　　buyer_id:buyerId,
　　group_id:groupId,
　　order_amount:amount
　　});
　　totalCommission+=commission;
　　}
　　});
　　//3.保存佣金记录
　　const commissionIds=await commissionModel.batchCreate(commissions);
　　//4.发放佣金到钱包(异步处理)
　　for(const commission of commissions){
　　await walletService.addBalance(
　　commission.inviter_id,
　　commission.amount,
　　'分销佣金',
　　`社群${groupId}付费进群佣金`
　　);
　　}
　　return commissionIds;
　　}
　　/
　　*获取分销层级佣金比例
　　*param{number}level-分销层级(1-3)
　　*returns{number}佣金比例(%)
　　*/
　　function getCommissionRate(level){
　　const defaultRates={
　　1:30,
　　2:15,
　　3:5
　　};
　　return defaultRates[level]||0;
　　}

　　javascript
　　//异常交易检测服务-antiCheatService.js
　　async function detectAbnormalTransaction(order){
　　//1.检测同一用户短时间内多次购买
　　const recentOrders=await orderModel.findRecentOrders(
　　order.user_id,
　　'1 hour',
　　5
　　);
　　if(recentOrders.length>=5){
　　return{
　　isAbnormal:true,
　　reason:'同一用户短时间内多次购买'
　　};
　　}
　　//2.检测同一IP地址大量购买
　　const ip=order.ip||'';
　　if(ip){
　　const ipOrders=await orderModel.findOrdersByIp(
　　ip,
　　'1 day',
　　20
　　);
　　if(ipOrders.length>=20){
　　return{
　　isAbnormal:true,
　　reason:'同一IP地址大量购买'
　　};
　　}
　　}
　　//3.检测邀请链异常(如自邀循环)
　　if(order.inviter_id&&order.inviter_id===order.user_id){
　　return{
　　isAbnormal:true,
　　reason:'邀请人ID与购买人ID相同'
　　};
　　}
　　return{isAbnormal:false};
　　}

　　javascript
　　//实时消息服务-messageService.js
　　const io=require('socket.io')(8080,{
　　cors:{
　　origin:'*'
　　}
　　});
　　//存储用户与socket的映射关系
　　const userSocketMap=new Map();
　　//连接事件处理
　　io.on('connection',(socket)=>{
　　console.log('新客户端连接:',socket.id);
　　//用户登录事件
　　socket.on('user.login',(userId)=>{
　　userSocketMap.set(userId,socket.id);
　　console.log(`用户${userId}登录，socketID:${socket.id}`);
　　//推送未读消息
　　const unreadMessages=getUnreadMessages(userId);
　　if(unreadMessages.length>0){
　　socket.emit('message.unread',unreadMessages);
　　}
　　});
　　//发送群消息事件
　　socket.on('group.message.send',async(messageData)=>{
　　const{groupId,userId,content,messageType='text'}=messageData;
　　//1.校验用户是否在群内
　　const isInGroup=await groupModel.checkUserInGroup(userId,groupId);
　　if(!isInGroup){
　　socket.emit('error',{message:'您不在该社群中'});
　　return;
　　}
　　//2.保存消息到数据库
　　const messageId=await saveGroupMessage({
　　group_id:groupId,
　　user_id:userId,
　　content:content,
　　message_type:messageType,
　　send_time:new Date()
　　});
　　//3.获取消息发送者信息
　　const userInfo=await userModel.getUserInfo(userId);
　　//4.推送给群内所有成员
　　const groupMembers=await groupModel.getGroupMembers(groupId);
　　const payload={
　　id:messageId,
　　groupId:groupId,
　　userId:userId,
　　nickName:userInfo.nickname,
　　avatar:userInfo.avatar,
　　content:content,
　　messageType:messageType,
　　sendTime:new Date().toISOString()
　　};
　　groupMembers.forEach(member=>{
　　const socketId=userSocketMap.get(member.user_id);
　　if(socketId){
　　io.to(socketId).emit('group.message.receive',payload);
　　}else{
　　//离线消息记录
　　saveOfflineMessage(member.user_id,groupId,payload);
　　}
　　});
　　});
　　//断开连接事件
　　socket.on('disconnect',()=>{
　　console.log('客户端断开连接:',socket.id);
　　//清理用户socket映射
　　for(const[userId,id]of userSocketMap.entries()){
　　if(id===socket.id){
　　userSocketMap.delete(userId);
　　break;
　　}
　　}
　　});
　　});
　　//导出socket.io实例
　　module.exports=io;

　　javascript
　　//异步任务处理-asyncTaskService.js
　　const queue=require('bull');
　　const paymentQueue=new queue('payment','redis://localhost:6379');
　　const distributionQueue=new queue('distribution','redis://localhost:6379');
　　//处理支付成功后的异步任务
　　paymentQueue.process(async(job)=>{
　　const{orderNo,userId,groupId,inviterId}=job.data;
　　try{
　　//1.添加用户到社群
　　await groupModel.addUserToGroup(userId,groupId);
　　//2.分发分销佣金
　　if(inviterId){
　　await distributionService.distributeCommission(
　　userId,
　　inviterId,
　　groupId,
　　job.data.amount
　　);
　　}
　　//3.发送进群通知
　　await sendJoinGroupNotification(userId,groupId);
　　return{success:true};
　　}catch(error){
　　console.error('支付异步任务处理失败:',error);
　　return{success:false,error:error.message};
　　}
　　});
　　//处理分销佣金发放
　　distributionQueue.process(async(job)=>{
　　const{inviterId,amount,orderId}=job.data;
　　try{
　　//1.保存佣金记录
　　const commissionId=await commissionModel.create({
　　inviter_id:inviterId,
　　amount:amount,
　　order_id:orderId,
　　status:'pending'
　　});
　　//2.发放佣金到钱包
　　await walletService.addBalance(
　　inviterId,
　　amount,
　　'分销佣金',
　　`订单${orderId}分销佣金`
　　);
　　//3.更新佣金状态
　　await commissionModel.updateStatus(commissionId,'success');
　　return{success:true};
　　}catch(error){
　　console.error('分销佣金发放失败:',error);
　　await commissionModel.updateStatus(job.data.commissionId,'failed',error.message);
　　return{success:false,error:error.message};
　　}
　　});

　　javascript
　　//监控告警服务-monitorAlertService.js
　　const axios=require('axios');
　　/
　　*监控系统指标
　　*param{Object}metrics-监控指标
　　*/
　　function monitorSystemMetrics(metrics){
　　//1.系统资源监控
　　if(metrics.cpuUsage>80){
　　sendAlert('CPU使用率过高',`服务器CPU使用率达到${metrics.cpuUsage}%`);
　　}
　　if(metrics.memoryUsage>85){
　　sendAlert('内存使用率过高',`服务器内存使用率达到${metrics.memoryUsage}%`);
　　}
　　//2.应用性能监控
　　if(metrics.avgResponseTime>500){
　　sendAlert('接口响应缓慢',`接口平均响应时间达到${metrics.avgResponseTime}ms`);
　　}
　　if(metrics.errorRate>5){
　　sendAlert('接口错误率高',`接口错误率达到${metrics.errorRate}%`);
　　}
　　//3.业务指标监控
　　if(metrics.dailyPayments<10&&metrics.isWeekday){
　　sendAlert('业务量异常',`工作日付费用户数仅${metrics.dailyPayments}人`);
　　}
　　if(metrics.commissionAmount>10000&&!metrics.isVerified){
　　sendAlert('大额佣金预警',`未审核佣金金额达到${metrics.commissionAmount}元`);
　　}
　　}
　　/
　　*发送告警通知
　　*param{string}title-告警标题
　　*param{string}message-告警内容
　　*/
　　async function sendAlert(title,message){
　　try{
　　//1.发送钉钉告警
　　await axios.post('https://oapi.dingtalk.com/robot/send',{
　　msgtype:'text',
　　text:{
　　content:`[告警]${title}nn${message}`
　　}
　　});
　　//2.发送短信告警(调用短信API)
　　await sendSmsAlert('13800138000',`[知识付费系统]${title}n${message}`);
　　//3.发送邮件告警
　　await sendEmailAlert('admin example.com',title,message);
　　console.log('告警通知已发送');
　　}catch(error){
　　console.error('发送告警通知失败:',error);
　　}
　　}