大学生活动社交小程序开发笔记（1）

头像
CC同学呀
     湖南
    阅读 18 分钟

    可研分析

    大学生活动社交小程序是一种基于移动互联网的社交平台，旨在为大学生提供一个方便、快捷、安全的社交和活动交流平台

    功能规划

    • 活动发布：平台可以发布将要举行的活动，包括时间、地点、费用等信息，并邀请其他用户参加。
    • 活动搜索：用户可以根据自己的兴趣爱好搜索活动，并参加感兴趣的活动。
    • 活动评价：用户可以对参加过的活动进行评价和反馈，帮助其他用户更好地选择活动。
    • 打卡模块：可以帮助大学生记录和评比每天的学习、阅读、文艺、体育、体育等活动。通过完成一个个小目标帮助大学生更好地管理自己的时间和目标。

    • image.png

      实现目标

      大学生活动社交小程序可以帮助大学生更好地组织和参加活动，扩展社交圈子，丰富大学生活。 本项目前后端完整代码包括公告通知，校园风采，活动分类与列表，活动报名与评价，打卡项目列表，打卡排行与每日动态，我的活动报名，我的每日打卡；后台打卡项目管理，打卡记录管理与导出，后台活动与报名管理，报名审核与数据导出等功能，活动组织方可以自定义要填写的内容

    数据库设计

    
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_STOP: 'int|true|default=0|comment=报名截止时间 0=永不过期',

    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_JOIN_CNT: 'int|true|default=0',
    ACTIVITY_COMMENT_CNT: 'int|true|default=0',

    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_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=报名成功, 99=审核未过',
    ACTIVITY_JOIN_REASON: 'string|false|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 {

    // 获取当前活动状态
    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) {

        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) ? '待审核' : '已报名';
        }

        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_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 start = timeUtil.getDayFirstTimestamp();
                    let end = start + 86400 * 1000 - 1;
                    where.and.ACTIVITY_START = ['between', start, end];
                    break;
                }
                case 'tomorrow': { //明日
                    let start = timeUtil.getDayFirstTimestamp() + 86400 * 1000;
                    let end = start + 86400 * 1000 - 1;
                    where.and.ACTIVITY_START = ['between', start, end];
                    break;
                }
                case 'month': { //本月
                    let day = timeUtil.time('Y-M-D');
                    let start = timeUtil.getMonthFirstTimestamp(day);
                    let end = timeUtil.getMonthLastTimestamp(day);

                    where.and.ACTIVITY_START = ['between', start, end];
                    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
    }) {
        orderBy = orderBy || {
            'ACTIVITY_JOIN_ADD_TIME': 'desc'
        };
        let fields = '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 '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 activityJoin(userId, activityId, forms) {

        // 报名是否结束
        let whereActivity = {
            _id: activityId,
            ACTIVITY_STATUS: ActivityModel.STATUS.COMM
        }
        let activity = await ActivityModel.getOne(whereActivity);
        if (!activity)
            this.AppError('该活动不存在或者已经停止');

        // 是否活动结束
        if (activity.ACTIVITY_END < this._timestamp)
            this.AppError('该活动已经结束，请选择其他活动');

        // 是否过了报名截止期
        if (activity.ACTIVITY_STOP < this._timestamp)
            this.AppError('该活动报名已经截止，请选择其他活动');


        // 人数是否满
        if (activity.ACTIVITY_MAX_CNT > 0) {
            let whereCnt = {
                ACTIVITY_JOIN_ACTIVITY_ID: activityId,
                ACTIVITY_JOIN_STATUS: ['in', [ActivityJoinModel.STATUS.WAIT, ActivityJoinModel.STATUS.SUCC]]
            }
            let cntJoin = await ActivityJoinModel.count(whereCnt);
            if (cntJoin >= activity.ACTIVITY_MAX_CNT)
                this.AppError('该活动报名已满，请选择其他活动');
        }

        // 自己是否已经有报名
        let whereMy = {
            ACTIVITY_JOIN_USER_ID: userId,
            ACTIVITY_JOIN_ACTIVITY_ID: activityId,
            ACTIVITY_JOIN_STATUS: ['in', [ActivityJoinModel.STATUS.WAIT, ActivityJoinModel.STATUS.SUCC]]
        }
        let my = await ActivityJoinModel.getOne(whereMy);
        if (my) {
            if (my.ACTIVITY_JOIN_STATUS == ActivityJoinModel.STATUS.WAIT)
                this.AppError('您已经报名，正在等待审核，无须重复报名');
            else
                this.AppError('您已经报名成功，无须重复报名');
        }


        // 入库
        let data = {
            ACTIVITY_JOIN_USER_ID: userId,
            ACTIVITY_JOIN_ACTIVITY_ID: activityId,
            ACTIVITY_JOIN_STATUS: (activity.ACTIVITY_CHECK_SET == 0) ? ActivityJoinModel.STATUS.SUCC : ActivityJoinModel.STATUS.WAIT,
            ACTIVITY_JOIN_FORMS: forms,
            ACTIVITY_JOIN_OBJ: dataUtil.dbForms2Obj(forms),
            ACTIVITY_JOIN_CODE: dataUtil.genRandomIntString(15),

        }

        let activityJoinId = await ActivityJoinModel.insert(data); 

        // 统计数量
        await this.statActivityJoin(activityId);

        let check = activity.ACTIVITY_CHECK_SET;

        return { activityJoinId, check }

    } 
 

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


        // 用户列表
        where = {
            ACTIVITY_JOIN_ACTIVITY_ID: id,
            ACTIVITY_JOIN_STATUS: ActivityJoinModel.STATUS.SUCC
        }
        let joinParams = {
            from: UserModel.CL,
            localField: 'ACTIVITY_JOIN_USER_ID',
            foreignField: 'USER_MINI_OPENID',
            as: 'user',
        };
        let orderBy = {
            ACTIVITY_JOIN_ADD_TIME: 'desc'
        }
        let list = await ActivityJoinModel.getListJoin(joinParams, where, 'ACTIVITY_JOIN_ADD_TIME,user.USER_MINI_OPENID,user.USER_NAME,user.USER_PIC', orderBy, 1, 6, false, 0);
        list = list.list;

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

        await ActivityModel.edit(id, { ACTIVITY_JOIN_CNT: cnt, ACTIVITY_USER_LIST: list });
    }

    /**  报名前获取关键信息 */
    async detailForActivityJoin(userId, activityId) {
        let fields = 'ACTIVITY_JOIN_FORMS, ACTIVITY_TITLE';

        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 joinMy = await ActivityJoinModel.getOne(whereMy, 'ACTIVITY_JOIN_FORMS', orderByMy);


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

        return activity;
    }

    /** 取消我的报名 只有成功和待审核可以取消 取消即为删除记录 */
    async cancelMyActivityJoin(userId, activityJoinId) {
        let where = {
            ACTIVITY_JOIN_USER_ID: userId,
            _id: activityJoinId,
            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('该活动已经截止报名，不能取消');

        await ActivityJoinModel.del(where); 

        // 统计
        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设计

    image.png
    image.png
    image.png
    image.png
    image.png
    image.png
    image.png
    image.png
    image.png
    image.png
    image.png

    后台UI

    image.png
    image.png
    image.png
    image.png
    image.png
    image.png

    git地址

    git代码地址

    小程序
    CC同学呀
    27 声望13 粉丝

    鹅厂程序猿一枚，交流v: cclinux0730

    « 上一篇
    读书会活动打卡小程序开发笔记（一）
    下一篇 »
    从0到1：垃圾上门回收预约小程序开发笔记

    引用和评论

    推荐阅读
    头像
    从0到1：多服务厅预约小程序开发笔记（上）

    CC同学呀阅读 166

    头像
    开发自定义Taro插件解决跨平台难题

    南玖赞 1阅读 1.5k

    头像
    如何通过即构小程序组件实现直播带货功能？

    ZEGO即构阅读 1.6k

    头像
    移动端、微信小程序兼容性问题汇总（持续更新……

    池月赞 1阅读 690

    头像
    【工具推荐】KillWxapkg v2.4(最新版) - 自动化反编译微信小程序，小程序安全评估工具

    0day漏洞文库阅读 1.1k

    头像
    在线客服源码|网站客服聊天系统源码 带搭建教程

    英姿勃勃的柑橘阅读 503

    头像
    平替WordPress/Zendesk，3分钟零代码用HelpLook建立一个企业网站

    HelpLook阅读 375

    0 条评论
    得票最新