首页 > 编程语言 >活动报名与缴费小程序开发笔记一

活动报名与缴费小程序开发笔记一

时间:2023-10-04 18:32:36浏览次数:45  
标签:STATUS comment JOIN 缴费 程序开发 笔记 let ACTIVITY true

项目背景

活动报名与缴费小程序的开发背景主要源于以下几个因素:

  • 1.数字化时代的需求: 随着移动互联网和智能手机的普及,人们习惯使用手机进行各种活动。传统的纸质报名表格和线下缴费方式变得相对繁琐,而数字化报名与缴费小程序提供了更便捷的解决方案。
  • 2.提高效率和减少人力成本: 对于活动举办者来说,传统的报名方式需要大量人力去处理报名表格、确认报名信息以及核实支付情况。自动化的小程序可以大大提高工作效率,减少人力成本。
  • 3.提供更好的用户体验: 活动报名与缴费小程序可以提供更好的用户体验。用户可以随时随地浏览活动信息、完成报名和支付,无需前往实体场地或填写繁琐的纸质表格,从而提高了用户的满意度。
  • 4.安全性和可追溯性: 小程序通常具有安全性较高的支付系统,可以保障用户的支付安全。同时,所有的报名和支付记录都被数字化存储,方便活动举办者进行管理和核实。
  • 5.数据分析和营销需求: 数字化的报名与缴费系统可以收集大量的数据,包括参与人数、地域分布、支付方式偏好等。这些数据对于市场营销和活动策划非常有价值,可以帮助活动举办者更好地了解用户需求,制定更精准的营销策略。

综上所述,活动报名与缴费小程序的开发背景主要是为了适应数字化时代的需求,提高效率、提供更好的用户体验,增加安全性,以及为数据分析和市场营销提供支持。这种数字化解决方案在现代社会得到了广泛应用,并且不断发展壮大。

功能规划

  • 1 用户注册与登录:用户可以注册一个账号并使用该账号登录,以便管理他们的报名和支付信息。
  • 2 活动浏览与搜索:用户可以浏览发布的活动列表,并使用搜索功能查找感兴趣的活动。
  • 3 活动详情:用户可以点击活动列表中的活动,查看活动的详细信息,包括活动介绍、时间、地点、费用等。
  • 4 报名流程:用户可以选择要参加的活动,并填写报名表格。表格可能包括个人信息(姓名、联系方式,后台可以自定义)、参与人数、特殊要求等。
  • 5 支付功能:用户可以选择微信支付完成报名费用的支付。支付完成后,系统会生成报名确认凭证。
  • 6 用户报名管理:用户可以查看已经报名的活动列表,以及报名状态和详细信息。用户可能还可以编辑报名信息或取消已报名的活动。
  • 7 评价与反馈:用户可以对参加的活动进行评价和反馈。他们可以分享他们的活动体验,并提供改进建议。

功能示意图

活动报名与缴费小程序开发笔记一_搜索

数据库设计

ActivityModel.DB_STRUCTURE = {
    _pid: 'string|true',
    ACTIVITY_ID: 'string|true',

    ACTIVITY_TITLE: 'string|true|comment=标题',
    ACTIVITY_STATUS: 'int|true|default=1|comment=状态 0=未启用,1=使用中',

    ACTIVITY_CATE_ID: 'string|true|default=0|comment=分类',
    ACTIVITY_CATE_NAME: 'string|false|comment=分类冗余',

    ACTIVITY_CANCEL_SET: 'int|true|default=1|comment=取消设置 0=不允,1=允许,2=仅截止前可取消',
    ACTIVITY_CHECK_SET: 'int|true|default=0|comment=审核 0=不需要审核,1=需要审核',
    ACTIVITY_IS_MENU: 'int|true|default=1|comment=是否公开展示名单',

    ACTIVITY_MAX_CNT: 'int|true|default=20|comment=人数上限 0=不限',
    ACTIVITY_START: 'int|false|comment=开始时间戳',
	ACTIVITY_END: 'int|false|comment=截止时间戳',
	ACTIVITY_START_DAY: 'string|false|comment=开始时间',
    ACTIVITY_END_DAY: 'string|false|comment=截止时间',
	ACTIVITY_STOP: 'int|true|default=0|comment=报名截止时间 0=永不过期',

	ACTIVITY_START_MONTH: 'string|false|comment=开始月份',
	ACTIVITY_END_MONTH: 'string|false|comment=截止月份',

    ACTIVITY_ORDER: 'int|true|default=9999',
    ACTIVITY_VOUCH: 'int|true|default=0',

    ACTIVITY_FORMS: 'array|true|default=[]',
    ACTIVITY_OBJ: 'object|true|default={}',

    ACTIVITY_JOIN_FORMS: 'array|true|default=[]',

    ACTIVITY_ADDRESS: 'string|false|comment=详细地址',
    ACTIVITY_ADDRESS_GEO: 'object|false|comment=详细地址坐标参数',

    ACTIVITY_QR: 'string|false',
    ACTIVITY_VIEW_CNT: 'int|true|default=0',
    ACTIVITY_COMMENT_CNT: 'int|true|default=0',

    ACTIVITY_METHOD: 'int|true|default=0|comment=支付方式 0=线下,1=线上',
    ACTIVITY_FEE: 'int|false|comment=支付金额 分',

    ACTIVITY_JOIN_CNT: 'int|true|default=0',
    ACTIVITY_PAY_CNT: 'int|true|default=0|comment=支付数',
    ACTIVITY_PAY_FEE: 'int|true|default=0|comment=支付额',

    ACTIVITY_USER_LIST: 'array|true|default=[]|comment={name,id,pic}',

    ACTIVITY_ADD_TIME: 'int|true',
    ACTIVITY_EDIT_TIME: 'int|true',
    ACTIVITY_ADD_IP: 'string|false',
    ACTIVITY_EDIT_IP: 'string|false',
};

ActivityJoinModel.DB_STRUCTURE = {
    _pid: 'string|true',
    ACTIVITY_JOIN_ID: 'string|true',
    ACTIVITY_JOIN_ACTIVITY_ID: 'string|true|comment=报名PK',

    ACTIVITY_JOIN_IS_ADMIN: 'int|true|default=0|comment=是否管理员添加 0/1',

    ACTIVITY_JOIN_CODE: 'string|true|comment=核验码15位',
    ACTIVITY_JOIN_IS_CHECKIN: 'int|true|default=0|comment=是否签到 0/1 ',
    ACTIVITY_JOIN_CHECKIN_TIME: 'int|false|default=0|签到时间',
    ACTIVITY_JOIN_CANCEL_TIME: 'int|true|default=0|comment=取消时间',

    ACTIVITY_JOIN_USER_ID: 'string|true|comment=用户ID',


    ACTIVITY_JOIN_FORMS: 'array|true|default=[]|comment=表单',
    ACTIVITY_JOIN_OBJ: 'object|true|default={}',

    ACTIVITY_JOIN_STATUS: 'int|true|default=1|comment=状态  0=待审核 1=报名成功, 98=自己取消,99=审核未过/取消',
    ACTIVITY_JOIN_REASON: 'string|false|comment=审核拒绝或者取消理由',


    ACTIVITY_JOIN_FEE: 'int|true|default=0|comment=需支付费用 分',

    ACTIVITY_JOIN_PAY_TRADE_NO: 'string|false|comment=商家订单号 32位',
    ACTIVITY_JOIN_PAY_STATUS: 'int|true|default=0|comment=支付状态 0=未支付 1=已支付 8=已退款 99=无需支付',
    ACTIVITY_JOIN_PAY_FEE: 'int|true|default=0|comment=已支付费用 分',
    ACTIVITY_JOIN_PAY_TIME: 'int|true|default=0|comment=支付时间',

    ACTIVITY_JOIN_ADD_TIME: 'int|true',
    ACTIVITY_JOIN_EDIT_TIME: 'int|true',
    ACTIVITY_JOIN_ADD_IP: 'string|false',
    ACTIVITY_JOIN_EDIT_IP: 'string|false',
};

难点攻关

class ActivityService extends BaseProjectService {

	async minuteJob() {
		console.log('### minuteJob >>>>>');


		// 未支付的成功订单取消  
		let time = this._timestamp - 6 * 60 * 1000;
		console.log('###### Begin>>> 未支付订单6分钟后取消, time<=' + time + ', ' + timeUtil.timestamp2Time(time));


		let where = {
			ACTIVITY_JOIN_STATUS: ['in', [ActivityJoinModel.STATUS.WAIT, ActivityJoinModel.STATUS.SUCC]],
			ACTIVITY_JOIN_PAY_STATUS: 0,
			ACTIVITY_JOIN_ADD_TIME: ['<=', time],
		}
		let rows = await ActivityJoinModel.getAll(where, '*', {}, 3000, false);
		console.log('未支付订单6分钟后取消, count=', rows.length);

		for (let k in rows) {
			let activityJoin = rows[k];

			let tradeNo = activityJoin.ACTIVITY_JOIN_PAY_TRADE_NO;

			if (!await this.fixActivityJoinPay(tradeNo, activityJoin.ACTIVITY_JOIN_ACTIVITY_ID)) {
				console.log('该报名记录未支付,已取消并删除!', activityJoin);
			}

		}

		console.log('###### END. 未支付订单6分钟后取消');

	}

	// 获取当前活动状态
	getJoinStatusDesc(activity) {
		let timestamp = this._timestamp;

		if (activity.ACTIVITY_STATUS == 0)
			return '活动停止';
		else if (activity.ACTIVITY_END <= timestamp)
			return '活动结束';
		else if (activity.ACTIVITY_STOP <= timestamp)
			return '报名结束';
		else if (activity.ACTIVITY_MAX_CNT > 0
			&& activity.ACTIVITY_JOIN_CNT >= activity.ACTIVITY_MAX_CNT)
			return '报名已满';
		else
			return '报名中';
	}

	/** 浏览信息 */
	async viewActivity(userId, id) {

		await this.fixUserActivityJoinPayRecord(userId);

		let fields = '*';

		let where = {
			_id: id,
			ACTIVITY_STATUS: ActivityModel.STATUS.COMM
		}
		let activity = await ActivityModel.getOne(where, fields);
		if (!activity) return null;

		ActivityModel.inc(id, 'ACTIVITY_VIEW_CNT', 1);

		// 判断是否有报名
		let whereJoin = {
			ACTIVITY_JOIN_USER_ID: userId,
			ACTIVITY_JOIN_ACTIVITY_ID: id,
			ACTIVITY_JOIN_STATUS: ['in', [ActivityJoinModel.STATUS.WAIT, ActivityJoinModel.STATUS.SUCC]]
		}
		let activityJoin = await ActivityJoinModel.getOne(whereJoin);
		if (activityJoin) {
			activity.myActivityJoinId = activityJoin._id;
			activity.myActivityJoinTag = (activityJoin.ACTIVITY_JOIN_STATUS == ActivityJoinModel.STATUS.WAIT) ? '待审核' : '已报名';
			if (activity.myActivityJoinTag == '已报名' && activityJoin.ACTIVITY_JOIN_PAY_STATUS == 1) {
				activity.myActivityJoinTag = '已报名缴费';
			}
		}
		else {
			activity.myActivityJoinId = '';
			activity.myActivityJoinTag = '';
		}


		return activity;
	}

	/** 取得分页列表 */
	async getActivityList({
		cateId, //分类查询条件
		search, // 搜索条件
		sortType, // 搜索菜单
		sortVal, // 搜索菜单
		orderBy, // 排序 
		page,
		size,
		isTotal = true,
		oldTotal
	}) {

		orderBy = orderBy || {
			'ACTIVITY_ORDER': 'asc',
			'ACTIVITY_ADD_TIME': 'desc'
		};
		let fields = 'ACTIVITY_START_MONTH,ACTIVITY_END_MONTH,ACTIVITY_START_DAY,ACTIVITY_END_DAY,ACTIVITY_USER_LIST,ACTIVITY_STOP,ACTIVITY_JOIN_CNT,ACTIVITY_OBJ,ACTIVITY_VIEW_CNT,ACTIVITY_TITLE,ACTIVITY_MAX_CNT,ACTIVITY_START,ACTIVITY_END,ACTIVITY_ORDER,ACTIVITY_STATUS,ACTIVITY_CATE_NAME,ACTIVITY_OBJ';

		let where = {};
		where.and = {
			_pid: this.getProjectId() //复杂的查询在此处标注PID
		};
		if (cateId && cateId !== '0') where.and.ACTIVITY_CATE_ID = cateId;

		where.and.ACTIVITY_STATUS = ActivityModel.STATUS.COMM; // 状态  


		if (util.isDefined(search) && search) {
			where.or = [{
				ACTIVITY_TITLE: ['like', search]
			},];
		} else if (sortType && util.isDefined(sortVal)) {
			// 搜索菜单
			switch (sortType) {
				case 'cateId': {
					if (sortVal) where.and.ACTIVITY_CATE_ID = String(sortVal);
					break;
				}
				case 'sort': {
					// 排序
					orderBy = this.fmtOrderBySort(sortVal, 'ACTIVITY_ADD_TIME');
					break;
				}
				case 'today': { //今天
					let time = timeUtil.time('Y-M-D');
					where.and.ACTIVITY_START_DAY = ['<=', time];
					where.and.ACTIVITY_END_DAY = ['>=', time];
					break;
				}
				case 'tomorrow': { //明日
					let time = timeUtil.time('Y-M-D', 86400);
					where.and.ACTIVITY_START_DAY = ['<=', time];
					where.and.ACTIVITY_END_DAY = ['>=', time];
					break;
				}
				case 'month': { //本月
					let month = timeUtil.time('Y-M');
					where.and.ACTIVITY_START_MONTH = ['<=', month];
					where.and.ACTIVITY_END_MONTH = ['>=', month];
					break;
				}
			}
		}

		return await ActivityModel.getList(where, fields, orderBy, page, size, isTotal, oldTotal);
	}


	/** 取得某一个报名分页列表 */
	async getActivityJoinList(activityId, {
		search, // 搜索条件
		sortType, // 搜索菜单
		sortVal, // 搜索菜单
		orderBy, // 排序 
		page,
		size,
		isTotal = true,
		oldTotal
	}) {
		orderBy = orderBy || {
			'ACTIVITY_JOIN_ADD_TIME': 'desc'
		};
		let fields = 'ACTIVITY_JOIN_OBJ,ACTIVITY_JOIN_IS_CHECKIN,ACTIVITY_JOIN_REASON,ACTIVITY_JOIN_ACTIVITY_ID,ACTIVITY_JOIN_STATUS,ACTIVITY_JOIN_ADD_TIME,user.USER_PIC,user.USER_NAME,user.USER_OBJ';

		let where = {
			ACTIVITY_JOIN_ACTIVITY_ID: activityId,
			ACTIVITY_JOIN_STATUS: ActivityModel.STATUS.COMM
		};

		let joinParams = {
			from: UserModel.CL,
			localField: 'ACTIVITY_JOIN_USER_ID',
			foreignField: 'USER_MINI_OPENID',
			as: 'user',
		};

		let result = await ActivityJoinModel.getListJoin(joinParams, where, fields, orderBy, page, size, isTotal, oldTotal);

		return result;
	}


	/** 取得我的报名分页列表 */
	async getMyActivityJoinList(userId, {
		search, // 搜索条件
		sortType, // 搜索菜单
		sortVal, // 搜索菜单
		orderBy, // 排序 
		page,
		size,
		isTotal = true,
		oldTotal
	}) {

		await this.fixUserActivityJoinPayRecord(userId);

		orderBy = orderBy || {
			'ACTIVITY_JOIN_ADD_TIME': 'desc'
		};
		let fields = 'ACTIVITY_JOIN_PAY_STATUS,ACTIVITY_JOIN_IS_CHECKIN,ACTIVITY_JOIN_REASON,ACTIVITY_JOIN_ACTIVITY_ID,ACTIVITY_JOIN_STATUS,ACTIVITY_JOIN_ADD_TIME,activity.ACTIVITY_END,activity.ACTIVITY_START,activity.ACTIVITY_TITLE';

		let where = {
			ACTIVITY_JOIN_USER_ID: userId
		};

		if (util.isDefined(search) && search) {
			where['activity.ACTIVITY_TITLE'] = {
				$regex: '.*' + search,
				$options: 'i'
			};
		} else if (sortType) {
			// 搜索菜单
			switch (sortType) {
				case 'timedesc': { //按时间倒序
					orderBy = {
						'activity.ACTIVITY_START': 'desc',
						'ACTIVITY_JOIN_ADD_TIME': 'desc'
					};
					break;
				}
				case 'timeasc': { //按时间正序
					orderBy = {
						'activity.ACTIVITY_START': 'asc',
						'ACTIVITY_JOIN_ADD_TIME': 'asc'
					};
					break;
				}
				case 'succ': {
					where.ACTIVITY_JOIN_STATUS = ActivityJoinModel.STATUS.SUCC;
					break;
				}
				case 'wait': {
					where.ACTIVITY_JOIN_STATUS = ActivityJoinModel.STATUS.WAIT;
					break;
				}
				case 'usercancel': {
					where.ACTIVITY_JOIN_STATUS = ActivityJoinModel.STATUS.CANCEL;
					break;
				}
				case 'cancel': {
					where.ACTIVITY_JOIN_STATUS = ActivityJoinModel.STATUS.ADMIN_CANCEL;
					break;
				}
			}
		}

		let joinParams = {
			from: ActivityModel.CL,
			localField: 'ACTIVITY_JOIN_ACTIVITY_ID',
			foreignField: '_id',
			as: 'activity',
		};

		let result = await ActivityJoinModel.getListJoin(joinParams, where, fields, orderBy, page, size, isTotal, oldTotal);

		return result;
	}

	/** 取得我的报名详情 */
	async getMyActivityJoinDetail(userId, activityJoinId) {

		let fields = '*';

		let where = {
			_id: activityJoinId,
			ACTIVITY_JOIN_USER_ID: userId
		};
		let activityJoin = await ActivityJoinModel.getOne(where, fields);
		if (activityJoin) {
			activityJoin.activity = await ActivityModel.getOne(activityJoin.ACTIVITY_JOIN_ACTIVITY_ID, 'ACTIVITY_TITLE,ACTIVITY_START,ACTIVITY_END');
		}
		return activityJoin;
	}

	// 修正某用户所有未支付的成功订单状态,无须支付的不用处理
	async fixUserActivityJoinPayRecord(userId) {
		let where = {
			ACTIVITY_JOIN_USER_ID: userId,
			ACTIVITY_JOIN_PAY_STATUS: 0,
			ACTIVITY_JOIN_STATUS: ['in', [ActivityJoinModel.STATUS.WAIT, ActivityJoinModel.STATUS.SUCC]],
		}
		let list = await ActivityJoinModel.getAll(where);

		for (let k = 0; k < list.length; k++) {
			await this.fixActivityJoinPay(list[k].ACTIVITY_JOIN_PAY_TRADE_NO, list[k].ACTIVITY_JOIN_ACTIVITY_ID);
		}
	}

	// 修正某订单状态 (仅需支付订单)
	async fixActivityJoinPay(tradeNo, activityId) {

		if (!tradeNo) {
			// 无支付号空单 删除
			await ActivityJoinModel.del({ ACTIVITY_JOIN_PAY_TRADE_NO: tradeNo });

			// 重新统计
			this.statActivityJoin(activityId);

			return false;
		}

		let payService = new PayService();
		if (!await payService.fixPayResult(tradeNo)) {
			// 关闭未支付单
			payService.closePay(tradeNo);

			// 未支付 
			await ActivityJoinModel.del({ ACTIVITY_JOIN_PAY_TRADE_NO: tradeNo });

			// 重新统计
			this.statActivityJoin(activityId);

			return false;
		}

		// 已支付
		let pay = await PayModel.getOne({ PAY_TRADE_NO: tradeNo });
		if (!pay) this.AppError('支付流水异常,请核查');

		// 更新支付信息
		let data = {
			ACTIVITY_JOIN_PAY_STATUS: 1,
			ACTIVITY_JOIN_PAY_TRADE_NO: tradeNo,
			ACTIVITY_JOIN_PAY_FEE: pay.PAY_TOTAL_FEE,
			ACTIVITY_JOIN_PAY_TIME: pay.PAY_END_TIME,
		}
		await ActivityJoinModel.edit({ ACTIVITY_JOIN_PAY_TRADE_NO: tradeNo }, data);


		// 重新统计
		this.statActivityJoin(activityId);
		return true;
	}

	//################## 报名  
	async statActivityJoin(activityId) {
		// 报名数
		let where = {
			ACTIVITY_JOIN_ACTIVITY_ID: activityId,
			ACTIVITY_JOIN_STATUS: ['in', [ActivityJoinModel.STATUS.WAIT, ActivityJoinModel.STATUS.SUCC]]
		}
		let cnt = await ActivityJoinModel.count(where);


		// 已支付记录
		let wherePayCnt = {
			ACTIVITY_JOIN_ACTIVITY_ID: activityId,
			ACTIVITY_JOIN_PAY_STATUS: 1,
			ACTIVITY_JOIN_STATUS: ['in', [ActivityJoinModel.STATUS.WAIT, ActivityJoinModel.STATUS.SUCC]]
		}
		let payCnt = await ActivityJoinModel.count(wherePayCnt);


		// 已支付金额
		let wherePayFee = {
			ACTIVITY_JOIN_ACTIVITY_ID: activityId,
			ACTIVITY_JOIN_PAY_STATUS: 1,
			ACTIVITY_JOIN_STATUS: ['in', [ActivityJoinModel.STATUS.WAIT, ActivityJoinModel.STATUS.SUCC]]
		}
		let payFee = await ActivityJoinModel.sum(wherePayFee, 'ACTIVITY_JOIN_PAY_FEE');


		// 报名用户头像列表
		let whereUserList = {
			ACTIVITY_JOIN_ACTIVITY_ID: activityId,
			ACTIVITY_JOIN_STATUS: ActivityJoinModel.STATUS.SUCC,
			ACTIVITY_JOIN_PAY_STATUS: ['in', [1, 99]]
		}
		let joinParams = {
			from: UserModel.CL,
			localField: 'ACTIVITY_JOIN_USER_ID',
			foreignField: 'USER_MINI_OPENID',
			as: 'user',
		};
		let orderBy = {
			ACTIVITY_JOIN_ADD_TIME: 'desc'
		}
		let userList = await ActivityJoinModel.getListJoin(joinParams, whereUserList, 'ACTIVITY_JOIN_ADD_TIME,user.USER_MINI_OPENID,user.USER_NAME,user.USER_PIC', orderBy, 1, 6, false, 0);
		userList = userList.list;

		for (let k = 0; k < userList.length; k++) {
			userList[k] = userList[k].user;
		}

		let data = {
			ACTIVITY_JOIN_CNT: cnt,
			ACTIVITY_PAY_CNT: payCnt,
			ACTIVITY_PAY_FEE: payFee,

			ACTIVITY_USER_LIST: userList
		}
		await ActivityModel.edit(activityId, data);
	}

	/**  报名前获取关键信息 */
	async detailForActivityJoin(userId, activityId) {

		await this.fixUserActivityJoinPayRecord(userId);

		let fields = 'ACTIVITY_JOIN_FORMS, ACTIVITY_TITLE, ACTIVITY_FEE, ACTIVITY_METHOD';

		let where = {
			_id: activityId,
			ACTIVITY_STATUS: ActivityModel.STATUS.COMM
		}
		let activity = await ActivityModel.getOne(where, fields);
		if (!activity)
			this.AppError('该活动不存在');

		let whereMy = {
			ACTIVITY_JOIN_USER_ID: userId,
		}
		let orderByMy = {
			ACTIVITY_JOIN_ADD_TIME: 'desc'
		}

		//***取得本人所有记录
		let joinList = await ActivityJoinModel.getAll(whereMy, 'ACTIVITY_JOIN_OBJ,ACTIVITY_JOIN_FORMS', orderByMy);
		let addressList = [];
		let addressList2 = [];
		for (let k = 0; k < joinList.length; k++) {
			let exist = false;
			for (let j = 0; j < addressList.length; j++) {
				if (addressList[j].name === joinList[k].ACTIVITY_JOIN_OBJ.name) {
					exist = true;
					break;
				}
			}

			if (!exist) {
				addressList.push(joinList[k].ACTIVITY_JOIN_OBJ);
				addressList2.push(joinList[k].ACTIVITY_JOIN_FORMS);
			}
		}

		// 取出本人最近一次的填写表单
		let joinMy = await ActivityJoinModel.getOne(whereMy, 'ACTIVITY_JOIN_FORMS', orderByMy);
		joinMy = null;

		let myForms = joinMy ? joinMy.ACTIVITY_JOIN_FORMS : [];
		activity.myForms = myForms;

		activity.addressList = addressList;
		activity.addressList2 = addressList2;

		activity.ACTIVITY_FEE = Number(dataUtil.fmtMoney(activity.ACTIVITY_FEE / 100));

		return activity;
	}

	/** 取消我的报名 只有成功和待审核可以取消   */
	async cancelMyActivityJoin(userId, activityJoinId) {
		let where = {
			_id: activityJoinId,
			ACTIVITY_JOIN_USER_ID: userId,
			ACTIVITY_JOIN_STATUS: ['in', [ActivityJoinModel.STATUS.WAIT, ActivityJoinModel.STATUS.SUCC]] //只有成功和待审核可以取消
		};
		let activityJoin = await ActivityJoinModel.getOne(where);

		if (!activityJoin) {
			this.AppError('未找到可取消的报名记录');
		}

		if (activityJoin.ACTIVITY_JOIN_IS_CHECKIN == 1)
			this.AppError('该活动已经签到,无法取消报名');

		let activity = await ActivityModel.getOne(activityJoin.ACTIVITY_JOIN_ACTIVITY_ID);
		if (!activity)
			this.AppError('该活动不存在');

		if (activity.ACTIVITY_END <= this._timestamp)
			this.AppError('该活动已经结束,无法取消');

		if (activity.ACTIVITY_CANCEL_SET == 0)
			this.AppError('该活动不能取消报名');

		if (activity.ACTIVITY_CANCEL_SET == 2 && activity.ACTIVITY_STOP < this._timestamp)
			this.AppError('该活动已经截止报名,不能取消');

		if (activityJoin.ACTIVITY_JOIN_PAY_STATUS == 99) {
			// 无须支付
			// 更新记录 
			let data = {
				ACTIVITY_JOIN_STATUS: ActivityJoinModel.STATUS.CANCEL,
				ACTIVITY_JOIN_CANCEL_TIME: this._timestamp,
			}
			await ActivityJoinModel.edit(activityJoinId, data);
		}
		else {
			let tradeNo = activityJoin.ACTIVITY_JOIN_PAY_TRADE_NO;
			if (!await this.fixActivityJoinPay(tradeNo, activityJoin.ACTIVITY_JOIN_ACTIVITY_ID)) {
				this.AppError('该报名记录未支付,已取消并删除!');
			}
			let payService = new PayService();
			await payService.refundPay(tradeNo, '用户取消报名');

			// 更新记录 
			let data = {
				ACTIVITY_JOIN_STATUS: ActivityJoinModel.STATUS.CANCEL,
				ACTIVITY_JOIN_CANCEL_TIME: this._timestamp,
				ACTIVITY_JOIN_PAY_STATUS: 8,
			}
			await ActivityJoinModel.edit(activityJoinId, data);
		}


		// 统计
		await this.statActivityJoin(activityJoin.ACTIVITY_JOIN_ACTIVITY_ID);
	}


	/** 用户自助签到 */
	async myJoinSelf(userId, activityId) {
		let activity = await ActivityModel.getOne(activityId);
		if (!activity)
			this.AppError('活动不存在或者已经关闭');

		let day = timeUtil.timestamp2Time(activity.ACTIVITY_START, 'Y-M-D');

		let today = timeUtil.time('Y-M-D');
		if (day != today)
			this.AppError('仅在活动当天可以签到,当前签到码的日期是' + day);

		let whereSucc = {
			ACTIVITY_JOIN_USER_ID: userId,
			ACTIVITY_JOIN_STATUS: ActivityJoinModel.STATUS.SUCC
		}
		let cntSucc = await ActivityJoinModel.count(whereSucc);

		let whereCheckin = {
			ACTIVITY_JOIN_USER_ID: userId,
			ACTIVITY_JOIN_IS_CHECKIN: 1,
			ACTIVITY_JOIN_STATUS: ActivityJoinModel.STATUS.SUCC
		}
		let cntCheckin = await ActivityJoinModel.count(whereCheckin);

		let ret = '';
		if (cntSucc == 0) {
			ret = '您没有本次活动报名成功的记录,请在「个人中心 - 我的活动报名」查看详情~';
		} else if (cntSucc == cntCheckin) {
			// 同一活动多次报名的情况
			ret = '您已签到,无须重复签到,请在「个人中心 - 我的活动报名」查看详情~';
		} else {
			let where = {
				ACTIVITY_JOIN_USER_ID: userId,
				ACTIVITY_JOIN_IS_CHECKIN: 0,
				ACTIVITY_JOIN_STATUS: ActivityJoinModel.STATUS.SUCC
			}
			let data = {
				ACTIVITY_JOIN_IS_CHECKIN: 1,
				ACTIVITY_JOIN_CHECKIN_TIME: this._timestamp,
			}
			await ActivityJoinModel.edit(where, data);
			ret = '签到成功,请在「个人中心 - 我的活动报名」查看详情~'
		}
		return {
			ret
		};
	}

	/** 按天获取报名项目 */
	async getActivityListByDay(day) {
		let start = timeUtil.time2Timestamp(day);
		let end = start + 86400 * 1000 - 1;
		let where = {
			ACTIVITY_STATUS: ActivityModel.STATUS.COMM,
			ACTIVITY_START: ['between', start, end],
		};

		let orderBy = {
			'ACTIVITY_ORDER': 'asc',
			'ACTIVITY_ADD_TIME': 'desc'
		};

		let fields = 'ACTIVITY_TITLE,ACTIVITY_START,ACTIVITY_OBJ.cover';

		let list = await ActivityModel.getAll(where, fields, orderBy);

		let retList = [];

		for (let k = 0; k < list.length; k++) {

			let node = {};
			node.timeDesc = timeUtil.timestamp2Time(list[k].ACTIVITY_START, 'h:m');
			node.title = list[k].ACTIVITY_TITLE;
			node.pic = list[k].ACTIVITY_OBJ.cover[0];
			node._id = list[k]._id;
			retList.push(node);

		}
		return retList;
	}

	/**
	 * 获取从某天开始可报名的日期
	 * @param {*} fromDay  日期 Y-M-D
	 */
	async getActivityHasDaysFromDay(fromDay) {
		let where = {
			ACTIVITY_START: ['>=', timeUtil.time2Timestamp(fromDay)],
		};

		let fields = 'ACTIVITY_START';
		let list = await ActivityModel.getAllBig(where, fields);

		let retList = [];
		for (let k = 0; k < list.length; k++) {
			let day = timeUtil.timestamp2Time(list[k].ACTIVITY_START, 'Y-M-D');
			if (!retList.includes(day)) retList.push(day);
		}
		return retList;
	}


}

UI设计

活动报名与缴费小程序开发笔记一_搜索_02

活动报名与缴费小程序开发笔记一_分页_03

活动报名与缴费小程序开发笔记一_IP_04

活动报名与缴费小程序开发笔记一_分页_05

活动报名与缴费小程序开发笔记一_分页_06

活动报名与缴费小程序开发笔记一_IP_07

活动报名与缴费小程序开发笔记一_搜索_08

活动报名与缴费小程序开发笔记一_分页_09

后台设计

活动报名与缴费小程序开发笔记一_分页_10

活动报名与缴费小程序开发笔记一_IP_11

活动报名与缴费小程序开发笔记一_搜索_12

活动报名与缴费小程序开发笔记一_搜索_13

活动报名与缴费小程序开发笔记一_IP_14

活动报名与缴费小程序开发笔记一_搜索_15

活动报名与缴费小程序开发笔记一_IP_16

活动报名与缴费小程序开发笔记一_搜索_17

活动报名与缴费小程序开发笔记一_分页_18

活动报名与缴费小程序开发笔记一_分页_19

git源码

源码下载

标签:STATUS,comment,JOIN,缴费,程序开发,笔记,let,ACTIVITY,true
From: https://blog.51cto.com/code942/7705555

相关文章

  • 流畅的python笔记 (二) 2.序列构成的数组
    内置序列类型分类1:容器序列(能存放不同类型):list,tuple,collections.deque扁平序列(不能存放不同类型):str,bytes,bytearray,memoryview,array.array分类2:可变序列(能被修改):list,bytearray,array.array,collections.deque,memoryview不可变序列:tuple,str,bytes列表推导......
  • Python笔记
    第一章、Python概述1.1 扩展库安装方法使用pip命令安装扩展库。在cmd命令行中输入pip,回车后可以看到pip命令的使用说明。1.2 常用的pip命令pip命令示例说明pipfreeze[>requirements.txt]列出已安装扩展库及其版本号(不知道怎么用。。?)pipinstallSomePacka......
  • 【做题笔记】dp,但是国庆限定版
    Day1方块消除传送门看到这个数据范围就可以猜测正解是\(O(n^4)\)的dp,与这个差不多相符合的可以想到区间dp。然后大胆猜测一下就是区间dp,令\(dp[i][j]\)表示消除掉\([i,j]\)后的最大价值,这个显然可以从长度更短的区间转移过来。所以此题我们可以从区间dp的方向思考......
  • 《敏捷软件需求》阅读笔记一
    以下是关于敏捷软件需求这本书籍的前八章的阅读心得体会,涵盖了每章的主要观点和个人体会:第一章:敏捷方法概述    第一章介绍了敏捷方法的起源和核心原则,其中最关键的原则是个体与交互、工作的软件、客户合作和响应变化。我学到了敏捷方法的灵活性和迭代开发是应对不断变化......
  • HTML学习笔记——简单介绍
    什么是HTMLHTML:HyperTextMarkupLanguageHTML是一种用来告知浏览器如何组织页面的标记语言。其由一系列的元素组成,这些元素用来包围或者标记不同部分的内容,让它以某种方式呈现或者工作。简单拆分一个HTML元素观察下面一个HTML元素<p>HelloWorld!</p><p>HelloWo......
  • Java 学习笔记一
    dos环境下(Windows即cmd)的Java命令先用javac文件名.java;命令,编译java文件,生成一个后缀为class、名与类名相同的文件。再用java类名命令,执行文件。注释当类名前的修饰符为public时,类名必须和源文件名一致。并且以上操作不能执行带package的java文件。和C......
  • Qemu源码分析(11)—Apple的学习笔记
    一,前言昨天了解了qemu中虚拟开发板的内存创建,接着再了解下中断创建和使用。二,分析昨天看了flash初始化,后面的我理解应该一样,接着发现sram初始化后,本来以为和flash是一样的,结果多了如下一句,通过注释也很好理解就是把1个bit展开为了1个byte,这样1M的sram变成了32M空间。//Bitbandthe......
  • 10.4 国庆 环形dp与基环树笔记
    1.知识点环形dp环形dp的概念•环形dp与基环树在许多环形结构的问题中,我们可以在环中从某个位置把环断开,把这个环变成线性的,然后进行\(dp\)等操作。•把能通过上述操作解决的环形问题称作"可拆解的环形问题"。环形dp的两种策略•第一次在任意位置把环断开成链,按照......
  • 【文化课学习笔记】【化学】选必一:化学反应速率
    【化学】选必一:化学反应速率化学反应速率的相关概念及计算概念及数学表达式概念:化学反应速率是定量描述化学反应进行快慢的物理量。通常用单位时间内反应物浓度的减小或生成物浓度的增加来表示。数学表达式:\(v=\dfrac{\Deltac}{\Deltat}\)。由于速率一定是正值,所以浓度变化......
  • 笔记——树状数组
    蓝月の笔记——树状数组篇在可恶的OI里,我们尝尝会遇到一些区间问题,例如区间修改单点查询,单点修改区间查询,区间修改单点查询,单点修改单点查询。其中,单点修改区间查询,就是树状数组最经典的用法啦!Luogu-P3374给定一个长度为\(n\)的序列\(a_1,a_2,\cdots,a_n\)和两种操作:......