yhlxj/netflix-dao/src/main/resources/mapper/GroupRelationMapper.xml

<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE mapper PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN" "http://mybatis.org/dtd/mybatis-3-mapper.dtd">
<mapper namespace="com.cyksj.mapper.GroupsRelationMapper">

    <update id="updateExpiryTime">
        update groups_relation
        set start_time = null,
        expiry_time = null,
        status = #{entity.status},
        renew_status = #{entity.renewStatus},
        is_handle = #{entity.isHandle},
        user_id = #{entity.userId},
        account = null,
        customer_service = null,
        password = null,
        recharge_status = null,
        send_time = null,
        submit_time = null,
        operator = null,
        yhs_id = 0,
        cmt = 0,
        aq_type = 1,
        invite_link = null,
        contact = null,
        is_vip = 0,
        recharge_num = null,
        recharge_remain_num = null,
        card_key = null,
        gpt_task_id = null,
        recharge_error_info = null,
        bp_verify_code = null,
        gpt_token = null,
        is_frozen = 0,
        unfrozen_time = null,
        reserved_days = null,
        recharge_remark = null,
        is_recover = 0,
        compensation_days = 0
        where id = #{entity.id}
        <if test="expireTime != null">
            and expiry_time = #{expireTime}
        </if>
    </update>

    <update id="incrExpiryTime">
        update groups_relation set expiry_time = DATE_ADD(expiry_time,interval 1 day) where id = #{relationId} and user_id = #{userId}
    </update>

    <select id="selectCompensateRelations" resultType="com.cyksj.model.entity.GroupsRelation">
        select gr.*
        from groups_relation gr
        inner join groups_trips gt on gt.id = gr.groups_id
        inner join goods_don_sku sku on sku.id = gt.sku_id
        where sku.goods_id = #{goodsId}
          and gt.status = 'validity'
          and gr.status in ('validity', 'outside')
          and gr.user_id != 0
          and gr.expiry_time is not null
        <if test="skuId != null">
            and gt.sku_id = #{skuId}
        </if>
        <if test="isMirror != null">
            and sku.is_mirror = #{isMirror}
        </if>
        <if test="userId != null">
            and gr.user_id = #{userId}
        </if>
        order by gr.user_id, gr.expiry_time desc, gr.id desc
    </select>

    <update id="updateUserVipSkusExpiryTime">
        update groups_relation set expiry_time = #{expiryTime},
        update_time = now()
        where id in (select * from(
        select gr.id from groups_relation gr inner join groups_trips gt on gt.id = gr.groups_id
        where gt.sku_id in
        <foreach collection="vipSkuIds" item="item" open="(" separator="," close=")">
            #{item}
        </foreach>
        and gr.user_id in
        <foreach collection="userIds" item="item" open="(" separator="," close=")">
            #{item}
        </foreach>
        and is_vip)s)
    </update>

    <select id="getAccountIdsByUserIdOrNickNameOrSubmitAccount" resultType="java.lang.Long">
        select gr.groups_id
        from groups_relation gr,
             `user` u
                where  gr.user_id = u.id
        <if test="nickName != null and nickName != ''">
            and u.nickname like '%${nickName}%'
        </if>
        <if test="userId != null">
            and u.id = #{userId,jdbcType=BIGINT}
        </if>
        <if test="submitAccount != null and submitAccount != ''">
            and gr.account = #{submitAccount,jdbcType=VARCHAR}
        </if>
        group by gr.groups_id
    </select>

    <select id="getGroupTripsSkuIdByRelationId" resultType="java.lang.Long">
        select gt.sku_id from `groups_trips` gt left join `groups_relation` gr on gr.groups_id = gt.id where gr.id = #{relationId} limit 1
    </select>

    <select id="selectSimilarExpiredRelation" resultType="java.lang.Long">
        select s.id
        from (select gt.id, min(gr.expiry_time) minExpiryTime
        from `groups_trips` gt
        left join `groups_relation` gr on gr.groups_id = gt.id
        where gt.sku_id = #{skuId}
        and (gt.available_parking_num = 0 or (select count(*)
        from groups_relation gr
        where gr.groups_id = gt.id and gr.user_id != 0 and gr.num &lt;=
        #{maxNum}) &lt; gt.available_parking_num) and gt.available_num > 0
        and gt.status = 'validity'
        and gr.status = 'validity'
        and gr.user_id != 0
        and gr.expiry_time is not null
        group by gr.groups_id) s
        where s.minExpiryTime >= #{minExpiryTime}
        <if test="ip != null">
            and not exists (select 1 from (select id, user_id from groups_relation gnr where gnr.groups_id = s.id and gnr.user_id != 0) gr inner join
            order_don o on o.user_id = gr.user_id and o.relation_id = gr.id
            inner join order_don_location_relate ocr on ocr.order_id = o.id where ocr.ip = #{ip} limit 1)
        </if>
        order by minExpiryTime desc limit 1
    </select>

    <select id="selectRelationByGoodsId" resultType="com.cyksj.model.manage.views.GroupsRelationView">
        select gr.*
        from groups_relation gr
        left join groups_trips gt on gr.groups_id = gt.id
        left join account a on a.id = gt.account_id
        left join user u on gr.user_id = u.id
        left join goods_don g on a.goods_id = g.id
        where g.id = #{goodsId}
        and gr.user_id in
        <foreach collection="userIds" item="item" open="(" separator="," close=")">
            #{item}
        </foreach>
        and gt.status = 'validity'
        and gr.status = 'validity'
        and gr.yhs_id = #{yhsId}
        and gr.expiry_time > now()
    </select>

    <select id="getGroupRelationViewByUserIdAndRelationId"
            resultType="com.cyksj.model.manage.views.GroupsRelationView">
        select gr.*,
               a.account as tripsAccount,
               g.title
        from groups_relation gr
                 left join groups_trips gt on gt.id = gr.groups_id
                 left join account a on a.id = gt.account_id
                 left join goods_don g on g.id = a.goods_id
        where gr.id = #{relationId} and gr.user_id = #{userId}
    </select>

    <select id="getBindPhoneByUserId" resultType="java.lang.String">
        select if(login_phone != '', login_phone,
                  (select phone from user_bind_detail where user_id = #{userId} or email_user_id = #{userId} limit 1))
        from user
        where id = #{userId} limit 1
    </select>

    <select id="selectViewPwdCount" resultType="java.lang.Integer">
        select count(distinct relation_id)
        from (select id, user_id from `groups_relation` where groups_id = #{groupsId} and `status` = 'validity') s
                 inner join ticket_pwd_view_record cr on cr.relation_id = s.id and s.user_id = cr.user_id
    </select>

    <select id="selectRandomOneRelationByGroupsId" resultType="com.cyksj.model.entity.GroupsRelation">
        select *
        from groups_relation
        where groups_id = #{groupsId}
          and user_id = 0
          and status = 'none'
          and not exists (
              select 1 from order_don_ticket_record ticket
              where ticket.active_relation_id = groups_relation.id
          )
        order by rand() limit 1
    </select>

    <select id="selectExpiredRelationByCondition" resultType="com.cyksj.model.entity.GroupsRelation">
        select gr.*
        from groups_relation gr
        inner join groups_trips gt on gt.id = gr.groups_id
        where gt.sku_id not in
        <foreach collection="list" item="item" open="(" separator="," close=")">
            #{item}
        </foreach>
        and gr.expiry_time &lt;= #{now}
    </select>

    <select id="selectOutsideRelationByGroupsId" resultType="com.cyksj.model.entity.GroupsRelation">
        select *
        from groups_relation
        where groups_id = #{groupsId}
          and user_id = 0
          and num > #{relationNum}
          and status = 'outside'
          and not exists (
              select 1 from order_don_ticket_record ticket
              where ticket.active_relation_id = groups_relation.id
          )
        order by rand() limit 1
    </select>

    <select id="selectExpiredChatGPTRelation" resultType="com.cyksj.model.entity.GroupsRelation">
        select gr.*
        from groups_relation gr
        inner join groups_trips gt on gt.id = gr.groups_id
        where gt.sku_id in
        <foreach collection="list" item="item" open="(" separator="," close=")">
            #{item}
        </foreach>
        and gr.expiry_time &lt;= #{nextBeginDay}
    </select>

    <select id="getUserRelationUserViews" resultType="com.cyksj.model.views.GroupsRelationUserView">
        select gr.*,
        u.nickname,
        u.headimgurl
        from (select * from (select id as relation_id,
        user_id,
        1 as isSelf from groups_relation where id = #{relationId}
        and status in
        <foreach collection="status" item="item" open="(" separator="," close=")">
            #{item}
        </foreach>
        limit 1)s1
        union all
        select * from (select id as realtion_id,
        user_id,
        if(user_id = #{userId},true,false) as isSelf from groups_relation where id != #{relationId}
        and groups_id = #{groupsId}
        and status in
        <foreach collection="status" item="item" open="(" separator="," close=")">
            #{item}
        </foreach>
        limit 4)s2)gr inner join user u on u.id = gr.user_id
    </select>

    <select id="getTicketGoodsId" resultType="java.lang.Long">
        select distinct goods_id from (select sku.goods_id from (select * from `groups_relation` where status in
        <foreach collection="status" item="item" open="(" separator="," close=")">
            #{item}
        </foreach>
        and user_id in
        <foreach collection="list" item="item" open="(" separator="," close=")">
            #{item}
        </foreach>)gr left join groups_trips gt on gt.id = gr.groups_id
        left join goods_don_sku sku on sku.id = gt.sku_id
        union all
        select goods_id from order_don o where user_id in
        <foreach collection="list" item="item" open="(" separator="," close=")">
            #{item}
        </foreach>
        and relation_id = 0 and status not in ('close','noPayment','refund'))s
    </select>

    <select id="getRecommendGoodsViews" resultType="com.cyksj.model.views.UserRecommendGoodsFrontView">
        select * from (select
        id as goodsId,
        title,
        logo,
        img,
        tags,
        sort_by,
        `type`,
        min_months as months,
        min_days as days,
        min_price as price,
        og_title,
        og_description,
        description,
        og_keywords,
        detail_route,
        (
        case when type = 2 and ${isPayNf} then 999
        when category = 1 then 888
        when category = 2 then 777
        when category = 3 then 755
        else 666 end
        ) as sorted
        from `goods_don` where deleted is true and status is true
        <if test="list!=null and list.size()>0">
            and id not in
            <foreach collection="list" item="item" open="(" separator="," close=")">
                #{item}
            </foreach>
        </if>
        <if test="isPayNf">
            and type in (1,2)
        </if>
        <if test="!isPayNf">
            and type = 1
        </if>
        <if test="filterCourseGoods!=null and filterCourseGoods">
            and (special_type is null or special_type != 'courseware')
        </if>
        <if test="yhShopGoodsIds!=null and yhShopGoodsIds.size()>0">
            and id in
            <foreach collection="yhShopGoodsIds" item="item" open="(" separator="," close=")">
                #{item}
            </foreach>
        </if>
        ) s order by s.sorted desc,sort_by asc
    </select>

    <select id="getOutSideGroupsTripsRelationByGoodsId" resultType="java.lang.Long">
        select gt.id
        from `groups_trips` gt
                 inner join account a on a.id = gt.account_id
        where gt.sku_id = #{skuId}
          and gt.status = 'validity'
          and a.expiry_time >= #{beginOfDay}
          and (select count(*)
               from groups_relation gr
               where gr.num > #{skuNum}
                 and gr.num &lt;= #{maxNum}
                 and gr.groups_id = gt.id
                 and gr.user_id
            != 0)
         &lt; #{extraNum}
          and
            (
        select count(*)
        from groups_relation gr
        where gr.groups_id = gt.id
          and gr.user_id
            = #{userId}) = 0
          and (gt.available_parking_num = 0 or (select count(*) from groups_relation gr where gr.groups_id = gt.id and gr.user_id != 0 and gr.num &lt;= #{maxNum}) &lt; gt.available_parking_num)
        order by RAND() limit 1
    </select>

    <select id="selectAvailableRelation" resultType="java.lang.Integer">
        select count(gr.id)
        from account a
                 inner join `groups_trips` gt on gt.account_id = a.id
            and gt.`status` = 'validity'
            and gt.sku_id = #{skuId}
                 inner join groups_relation gr on gr.groups_id = gt.id
            and gr.status in ('none', 'locking')
            and gt.available_parking_num = 0
            and gr.num &lt;= #{skuNum}
    </select>

    <select id="selectSpecialGroupsRelationAvailable" resultType="java.lang.Integer">
        select ifnull(sum(a1 + (#{extractNum} - t1)), 0)
        from (select gt.id,
                     (select count(*)
                      from groups_relation gr2
                      where gr2.groups_id = gt.id
                        and num > #{skuNum}
                        and num &lt;= #{maxNum})                         t1,
                     (select count(*)
                      from groups_relation gr2
                      where gr2.groups_id = gt.id
                        and num > #{skuNum}
                        and num &lt;= #{maxNum}
                        and (gr2.user_id = 0 or gr2.status = 'locking')) a1
              from account a
                       inner join `groups_trips` gt on gt.account_id = a.id
                  and gt.`status` = 'validity'
                  and gt.available_parking_num = 0
                  and gt.sku_id = #{skuId}
            and a.expiry_time >= #{tenExpiry}) s
        where (t1 = #{extractNum} and a1 = 0) = 0
    </select>

    <select id="selectNumWaitingGroups" resultType="java.lang.Integer">
        select count(gr.id)
        from `groups_trips` gt
                 inner join groups_relation gr on gr.groups_id = gt.id
            and gt.`status` = 'waiting'
            and gt.sku_id = #{skuId}
            and gr.user_id != 0
            and gr.status in ('validity','outside')
    </select>

    <select id="selectLimitAvailableNum" resultType="java.lang.Integer">
        select sum(s1 - s2)
        from (select available_parking_num          as s1,
                     (select count(*)
                      from groups_relation gr
                      where gr.groups_id = gt.id
                        and gr.status in ('validity', 'outside')
                        and gr.num &lt;= #{maxNum}) as s2
              from groups_trips gt
              where gt.sku_id = #{skuId}
                and gt.status = 'validity'
                and gt.available_parking_num != 0) t
        where t.s1 >= s2
    </select>

    <select id="getGroupRelationAccountView" resultType="com.cyksj.model.manage.views.GroupsRelationBackView">
        select s.account, a.account as tripsAccount,a.act_code,a.act_code_url
        from (select groups_id, account from groups_relation where id = #{relationId} limit 1) s
                 inner join groups_trips gt on gt.id = s.groups_id
                 left join account a on a.id = gt.account_id
    </select>

    <select id="getAreaPhoneByUserId" resultType="com.cyksj.model.entity.PhoneCode">
        select s.phone, pc.cid
        from (select if(login_phone != '', login_phone,
                        (select phone
                         from user_bind_detail
                         where user_id = u.id
                            or email_user_id = u.id limit 1)) as phone
              from user u
              where id = #{userId} limit 1) s
                 left join phone_code pc on pc.phone = s.phone
    </select>

    <select id="getUserHasPayGoods" resultType="com.cyksj.model.views.RenewalView">
        select g.id as goods_id,g.title,g.logo from groups_relation gr inner join groups_trips gt on gt.id = gr.groups_id
        inner join goods_don_sku sku on sku.id = gt.sku_id inner join goods_don g on g.id = sku.goods_id
        where gr.status in ('validity', 'outside')
        and (gr.cmt is null or gr.cmt != 2)
        and (gr.expiry_time is null or gr.expiry_time > #{now} or (sku.is_mirror and gr.expiry_time > DATE_ADD(#{now},interval -7 day)))
        and gr.user_id != 0
        and gr.user_id in
        <foreach collection="list" item="item" open="(" separator="," close=")">
            #{item}
        </foreach>
        group by g.id,g.title,g.logo
        order by goods_id
    </select>

    <select id="getExperienceTicket" resultType="java.lang.Long">
        select gr.id
        from (select id, groups_id from groups_relation where user_id = #{userId}) gr
                 inner join groups_trips gt on gt.id = gr.groups_id
        where gt.sku_id = #{skuId} limit 1
    </select>

    <select id="selectGoodsDonQaByGoodsId" resultType="java.lang.Long">
        select count(1)
        from (select question_id from goods_don_qa_relate where goods_id = #{goodsId} and deleted is true) s
                 inner join goods_don_qa qa on qa.id = s.question_id
        where qa.type = 2
          and qa.status is true
          and qa.deleted is true
    </select>

    <select id="selectRelationByAccountAndNum" resultType="com.cyksj.model.entity.GroupsRelation">
        select gr.id, gr.user_id, gr.num
        from (select id
              from account
              where account = #{account}
                and password = #{password}
                and goods_id = #{goodsId} limit 1) a
                 inner join groups_trips gt
                            on gt.account_id = a.id
                 inner join groups_relation gr on gr.groups_id = gt.id
        where gr.num = #{num} and gr.expiry_time > now() limit 1
    </select>

    <select id="selectExtraRelation" resultType="com.cyksj.model.entity.GroupsRelation">
        select gr.*
        from (select * from groups_relation where user_id = #{userId} and id != #{relationId} and status not in ('none','locking')) gr
                 inner join groups_trips gt on gt.id = gr.groups_id
            and gt.sku_id = #{skuId}
            and not exists (select 1 from order_don o where o.user_id = gr.user_id and o.relation_id = gr.id and o.status not in ('close','noPayment','refund'))
    </select>

    <select id="selectUserTickets" resultType="com.cyksj.model.views.UserTicketView">
        select gr.id as relation_id,
        gr.user_id,
        g.id as goods_id,
        gt.sku_id,
        g.title,
        gdk.spec_val,
        g.third_exchange_url,
        g.third_party_purchase_url,
        gr.expiry_time,
        gdk.is_mirror,
        gdk.gpt_limit_num as gptUserLimitNum,
        gdk.gpt_limit_time as gptUserLimitTime,
        gdk.num as skuNum,
        gdk.is_banned_check,
        gr.is_frozen,
        gr.unfrozen_time,
        gr.reserved_days
        from groups_relation gr left join groups_trips gt on gt.id = gr.groups_id
        left join goods_don_sku gdk on gdk.id = gt.sku_id left join goods_don g on g.id = gdk.goods_id
        where gr.user_id in
        <foreach collection="userIds" item="item" open="(" separator="," close=")">
            #{item}
        </foreach>
        and gr.status in ('validity','outside')
        and (gr.cmt is null or gr.cmt != 2)
        and gr.is_vip = 0
        and (gr.expiry_time is null or gr.expiry_time > now() or (gdk.is_mirror and gr.expiry_time >
        DATE_ADD(now(),interval -7 day)))
        <if test="goodsId != null">
            and g.id = #{goodsId}
        </if>
        <if test="skuId != null">
            and gt.sku_id = #{skuId}
        </if>
    </select>

    <select id="selectCountByGoodsId" resultType="java.lang.Integer">
        select count(1) from groups_relation gr inner join groups_trips gt on gt.id = gr.groups_id inner join
        goods_don_sku sku on sku.id = gt.sku_id
        where sku.goods_id = #{goodsId}
          and gr.user_id in
        <foreach collection="userIds" item="item" open="(" separator="," close=")">
            #{item}
        </foreach>
        and gr.expiry_time > #{now}
    </select>

    <select id="selectRechargeRecordNum" resultType="com.cyksj.model.response.GptRechargeStatisticsRecordResp">
        select gur.operator,count(1) as num from gpt_user_recharge_num_record gur left join order_don o on o.user_id = gur.user_id and o.relation_id = gur.relation_id
        where gur.num &lt; 0
        and gur.operator != ''
        and gur.created_time between #{start} and #{end}
        <if test="goodsIds != null">
            and o.goods_id in
            <foreach collection="goodsIds" item="item" open="(" separator="," close=")">
                #{item}
            </foreach>
        </if>
        <if test="operator != null">
            and gur.operator = #{operator}
        </if>
        group by gur.operator
        order by num desc
    </select>
</mapper>