公会-运营负责人-统计

accompany-base/accompany-core/src/main/java/com/accompany/common/redis/RedisKey.java

@@ -1399,7 +1399,9 @@ public enum RedisKey {
 
     week_new_guild_count,
     week_active_guild_member_diamond_count,
+    week_active_guild_member_diamond_zone_count,
     week_active_guild_member_gold_count,
+    week_active_guild_member_gold_zone_count,
 
     //小游戏榜单
     mini_game_week_jackpot_pool,

accompany-business/accompany-business-sdk/src/main/java/com/accompany/business/dto/WeekGuildOperatorRegionStat.java

@@ -0,0 +1,28 @@
+package com.accompany.business.dto;
+
+import lombok.Data;
+
+import java.math.BigDecimal;
+
+@Data
+public class WeekGuildOperatorRegionStat {
+
+    private Integer partitionId;
+    private String partitionDesc;
+
+    private Integer operatorId;
+
+    private Integer regionId;
+    private String regionDesc;
+
+    private Integer newGuildCount;
+    private Integer newActiveGuildCount;
+    private BigDecimal newGuildDiamondFlow;
+    private BigDecimal newGuildGoldFlow;
+
+    private Integer guildCount;
+    private Integer activeGuildCount;
+    private BigDecimal guildDiamondFlow;
+    private BigDecimal guildGoldFlow;
+
+}

accompany-business/accompany-business-sdk/src/main/java/com/accompany/business/model/WeekGuildOperatorStat.java

@@ -0,0 +1,41 @@
+
+package com.accompany.business.model;
+
+import com.baomidou.mybatisplus.annotation.TableId;
+import io.swagger.annotations.ApiModel;
+import io.swagger.annotations.ApiModelProperty;
+import lombok.Data;
+
+import java.math.BigDecimal;
+
+@ApiModel
+@Data
+public class WeekGuildOperatorStat {
+
+    @TableId
+    @ApiModelProperty("日期")
+    private String date;
+    @ApiModelProperty("周日")
+    private String endDate;
+
+    private Integer partitionId;
+    private Integer operatorId;
+
+    private Integer newGuildCount;
+    private Integer newActiveGuildCount;
+    private BigDecimal newGuildTotalDiamondFlow;
+    private BigDecimal newGuildTotalGoldFlow;
+
+    private Integer guildCount;
+    private Integer activeGuildCount;
+    private BigDecimal guildTotalDiamondFlow;
+    private BigDecimal guildTotalGoldFlow;
+
+    private BigDecimal lastWeekGuildTotalDiamondFlow;
+    private BigDecimal lastWeekGuildTotalGoldFlow;
+    private BigDecimal guildTotalDiamondFlowWow;
+    private BigDecimal guildTotalGoldFlowWow;
+
+    private String regionStat;
+
+}

accompany-business/accompany-business-sdk/src/main/java/com/accompany/business/model/guild/WeekGuildOperatorDetailStat.java

@@ -0,0 +1,39 @@
+package com.accompany.business.model.guild;
+
+import lombok.Data;
+
+import java.math.BigDecimal;
+import java.util.Date;
+
+@Data
+public class WeekGuildOperatorDetailStat {
+
+    private String date;
+    private String endDate;
+
+    private Integer operatorId;
+    private Integer guildId;
+    private Integer partitionId;
+
+    private Long guildOwnerErbanNo;
+    private Integer regionId;
+
+    private Date guildCreateTime;
+    private Boolean newGuild;
+
+    private BigDecimal guildDiamondFlow;
+    private BigDecimal guildGoldFlow;
+
+    private BigDecimal lastGuildDiamondFlow;
+    private BigDecimal lastGuildGoldFlow;
+
+    private BigDecimal guildDiamondFlowSub;
+    private BigDecimal guildGoldFlowSub;
+
+    private BigDecimal guildDiamondFlowWow;
+    private BigDecimal guildGoldFlowWow;
+
+    private String mark;
+    private Integer adminId;
+
+}

accompany-business/accompany-business-service/src/main/java/com/accompany/business/mybatismapper/WeekGuildOperatorDetailStatMapper.java

@@ -0,0 +1,10 @@
+package com.accompany.business.mybatismapper;
+
+import com.accompany.business.model.guild.WeekGuildOperatorDetailStat;
+import com.baomidou.mybatisplus.core.mapper.BaseMapper;
+import org.apache.ibatis.annotations.Mapper;
+
+@Mapper
+public interface WeekGuildOperatorDetailStatMapper extends BaseMapper<WeekGuildOperatorDetailStat> {
+
+}

accompany-business/accompany-business-service/src/main/java/com/accompany/business/mybatismapper/WeekGuildOperatorStatMapper.java

@@ -0,0 +1,11 @@
+package com.accompany.business.mybatismapper;
+
+import com.accompany.business.model.WeekGuildOperatorStat;
+import com.accompany.business.model.WeekGuildStat;
+import com.baomidou.mybatisplus.core.mapper.BaseMapper;
+import org.apache.ibatis.annotations.Mapper;
+
+@Mapper
+public interface WeekGuildOperatorStatMapper extends BaseMapper<WeekGuildOperatorStat> {
+
+}

accompany-business/accompany-business-service/src/main/java/com/accompany/business/service/WeekActiveGuildMemberStatService.java

@@ -1,13 +1,16 @@
 package com.accompany.business.service;
 
+import com.accompany.common.constant.Constant;
 import com.accompany.common.redis.RedisKey;
 import com.accompany.common.utils.DateTimeUtil;
+import com.accompany.core.enumeration.PartitionEnum;
 import org.redisson.api.RMap;
 import org.redisson.api.RedissonClient;
 import org.springframework.beans.factory.annotation.Autowired;
 import org.springframework.stereotype.Service;
 
 import java.math.BigDecimal;
+import java.time.DayOfWeek;
 import java.util.Date;
 
 @Service
@@ -28,6 +31,8 @@ public class WeekActiveGuildMemberStatService {
         RMap<String, Number> goldCountMap = getGoldCountMap(monday);
         goldCountMap.addAndGet(key, goldNum);
         goldCountMap.expire(DateTimeUtil.addDays(now, 14).toInstant());
+
+        zoneMark(partitionId, guildId, uid, diamondNum, goldNum, now);
     }
 
     public RMap<String, Number> getDiamondCountMap(String monday) {
@@ -38,4 +43,31 @@ public class WeekActiveGuildMemberStatService {
         return redissonClient.getMap(RedisKey.week_active_guild_member_gold_count.getKey(monday));
     }
 
+    public void zoneMark(Integer partitionId, Integer guildId, Long uid, BigDecimal diamondNum, BigDecimal goldNum, Date now){
+        PartitionEnum partitionEnum = PartitionEnum.getByPartitionId(partitionId);
+        if (!Constant.ClanMode.GUILD.equals(partitionEnum.getClanMode())){
+            return;
+        }
+
+        String key = String.join("_", guildId.toString(), uid.toString());
+
+        String zoneMonday = DateTimeUtil.convertWithZoneId(now, partitionEnum.getZoneId()).with(DayOfWeek.MONDAY).format(DateTimeUtil.dateFormatter);
+
+        RMap<String, Number> diamondCountMap = getZoneDiamondCountMap(partitionId, zoneMonday);
+        diamondCountMap.addAndGet(key, diamondNum);
+        diamondCountMap.expire(DateTimeUtil.addDays(now, 14).toInstant());
+
+        RMap<String, Number> goldCountMap = getZoneGoldCountMap(partitionId, zoneMonday);
+        goldCountMap.addAndGet(key, goldNum);
+        goldCountMap.expire(DateTimeUtil.addDays(now, 14).toInstant());
+    }
+
+    public RMap<String, Number> getZoneDiamondCountMap(Integer partitionId, String monday) {
+        return redissonClient.getMap(RedisKey.week_active_guild_member_diamond_zone_count.getKey(String.valueOf(partitionId), monday));
+    }
+
+    public RMap<String, Number> getZoneGoldCountMap(Integer partitionId, String monday) {
+        return redissonClient.getMap(RedisKey.week_active_guild_member_gold_zone_count.getKey(String.valueOf(partitionId), monday));
+    }
+
 }

accompany-business/accompany-business-service/src/main/java/com/accompany/business/service/WeekGuildOperatorStatService.java

@@ -0,0 +1,276 @@
+package com.accompany.business.service;
+
+import com.accompany.business.dto.WeekGuildOperatorRegionStat;
+import com.accompany.business.model.WeekGuildOperatorStat;
+import com.accompany.business.model.guild.WeekGuildOperatorDetailStat;
+import com.accompany.business.model.guild.Guild;
+import com.accompany.business.model.guild.GuildOperator;
+import com.accompany.business.mybatismapper.WeekGuildOperatorDetailStatMapper;
+import com.accompany.business.mybatismapper.WeekGuildOperatorStatMapper;
+import com.accompany.business.service.guild.GuildOperatorService;
+import com.accompany.business.service.guild.GuildService;
+import com.accompany.business.service.user.UsersService;
+import com.accompany.common.utils.DateTimeUtil;
+import com.accompany.core.enumeration.PartitionEnum;
+import com.accompany.core.model.Users;
+import com.accompany.core.service.region.RegionInfoService;
+import com.alibaba.fastjson.JSON;
+import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;;
+import lombok.extern.slf4j.Slf4j;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.stereotype.Service;
+import org.springframework.util.CollectionUtils;
+
+import javax.annotation.Resource;
+import java.math.BigDecimal;
+import java.math.RoundingMode;
+import java.time.*;
+import java.util.*;
+import java.util.concurrent.ThreadPoolExecutor;
+import java.util.stream.Collectors;
+
+@Slf4j
+@Service
+public class WeekGuildOperatorStatService {
+
+    @Autowired
+    private GuildOperatorService guildOperatorService;
+    @Autowired
+    private WeekActiveGuildMemberStatService weekActiveGuildMemberStatService;
+    @Autowired
+    private WeekGuildOperatorStatMapper statMapper;
+    @Autowired
+    private WeekGuildOperatorDetailStatMapper detailStatMapper;
+    @Autowired
+    private GuildService guildService;
+    @Resource(name = "bizExecutor")
+    private ThreadPoolExecutor bizExecutor;
+    @Autowired
+    private UsersService usersService;
+    @Autowired
+    private RegionInfoService regionInfoService;
+
+    public void stat(List<PartitionEnum> partitionEnumList) {
+        for (PartitionEnum partitionEnum: partitionEnumList){
+            bizExecutor.execute(() -> {
+                ZonedDateTime monday = DateTimeUtil.getDateTimeByZoneId(partitionEnum.getZoneId()).with(DayOfWeek.MONDAY);
+                String lastWeekMonday = monday.minusWeeks(1L).format(DateTimeUtil.dateFormatter);
+                String lastWeekSunday = monday.minusDays(1L).format(DateTimeUtil.dateFormatter);
+                stat(partitionEnum.getId(), partitionEnum.getZoneId(), lastWeekMonday, lastWeekSunday, true);
+            });
+        }
+    }
+
+    public void stat(Integer partitionId, String zoneId, String monday, String sunday, boolean needSaveRecord) {
+
+        List<GuildOperator> guildOperatorList = guildOperatorService.listByPartitionId(partitionId);
+        if (CollectionUtils.isEmpty(guildOperatorList)){
+            log.error("[WeekGuildOperatorStat] partitionId {} 分区下没有有效的公会运营负责人", partitionId);
+            return;
+        }
+
+        ZonedDateTime zonedStartTime = ZonedDateTime.of(LocalDate.parse(monday, DateTimeUtil.dateFormatter), LocalTime.MIN, ZoneId.of(zoneId));
+        Date systemStartTime = Date.from(zonedStartTime.withZoneSameLocal(ZoneId.systemDefault()).toInstant());
+
+        ZonedDateTime zonedEndTime = ZonedDateTime.of(LocalDate.parse(sunday, DateTimeUtil.dateFormatter), LocalTime.MAX, ZoneId.of(zoneId));
+        Date systemEndTime = Date.from(zonedEndTime.withZoneSameLocal(ZoneId.systemDefault()).toInstant());
+
+        String lastMonday = DateTimeUtil.convertDate(
+                DateTimeUtil.addDays(DateTimeUtil.convertStrToDate(monday, DateTimeUtil.DEFAULT_DATE_PATTERN), -7), DateTimeUtil.DEFAULT_DATE_PATTERN);
+
+        Map<String, Number> diamondCountMap = weekActiveGuildMemberStatService.getZoneDiamondCountMap(partitionId, monday).readAllMap();
+        Map<String, Number> goldCountMap = weekActiveGuildMemberStatService.getZoneGoldCountMap(partitionId, monday).readAllMap();
+
+        List<WeekGuildOperatorDetailStat> memberStatDtoList = goldCountMap.entrySet().stream().map(entry->{
+            String key = entry.getKey();
+            String[] keyArray = key.split("_");
+
+            WeekGuildOperatorDetailStat dto = new WeekGuildOperatorDetailStat();
+
+            dto.setDate(monday);
+            dto.setEndDate(sunday);
+
+            dto.setPartitionId(partitionId);
+            dto.setGuildId(Integer.valueOf(keyArray[0]));
+
+            dto.setGuildDiamondFlow(diamondCountMap.containsKey(key)? new BigDecimal(diamondCountMap.get(key).toString()): BigDecimal.ZERO);
+            dto.setGuildGoldFlow(new BigDecimal(entry.getValue().toString()));
+
+            return dto;
+        }).toList();
+
+        List<Guild> validGuildList = guildService.listGuildByPartitionId(partitionId).stream().filter(guild -> Boolean.TRUE.equals(guild.getEnable()))
+                .filter(g->null != g.getOperatorId()).toList();
+        if (CollectionUtils.isEmpty(validGuildList)){
+            log.error("[WeekGuildOperatorStat] partitionId {} 分区下没有有效的公会", partitionId);
+            return;
+        }
+
+        List<Long> vaildGuildOwnerUidList = validGuildList.stream().map(Guild::getOwnerUid).distinct().toList();
+        Map<Long, Users> ownerUsersMap = usersService.getUsersMapByUids(vaildGuildOwnerUidList);
+
+        Map<Integer, BigDecimal> diamondFlowMap = memberStatDtoList.stream().collect(Collectors.groupingBy(WeekGuildOperatorDetailStat::getGuildId, Collectors.reducing(BigDecimal.ZERO, WeekGuildOperatorDetailStat::getGuildDiamondFlow, BigDecimal::add)));
+        Map<Integer, BigDecimal> goldFlowMap = memberStatDtoList.stream().collect(Collectors.groupingBy(WeekGuildOperatorDetailStat::getGuildId, Collectors.reducing(BigDecimal.ZERO, WeekGuildOperatorDetailStat::getGuildGoldFlow, BigDecimal::add)));
+
+        List<WeekGuildOperatorDetailStat> lastWeekDetailStatList = detailStatMapper.selectList(new LambdaQueryWrapper<WeekGuildOperatorDetailStat>()
+                .eq(WeekGuildOperatorDetailStat::getDate, lastMonday).eq(WeekGuildOperatorDetailStat::getPartitionId, partitionId));
+        Map<Integer, WeekGuildOperatorDetailStat> lastWeekDetailStatMap = lastWeekDetailStatList.stream()
+                .collect(Collectors.toMap(WeekGuildOperatorDetailStat::getGuildId, dto->dto));
+
+        List<WeekGuildOperatorDetailStat> detailStatList = validGuildList.stream()
+                .map(guild->{
+                    WeekGuildOperatorDetailStat dto = new WeekGuildOperatorDetailStat();
+                    dto.setDate(monday);
+                    dto.setEndDate(sunday);
+
+                    dto.setPartitionId(guild.getPartitionId());
+                    dto.setGuildId(guild.getId());
+
+                    dto.setOperatorId(guild.getOperatorId());
+
+                    Users owner = ownerUsersMap.get(guild.getOwnerUid());
+                    if (null != owner){
+                        dto.setRegionId(owner.getRegionId());
+
+                        dto.setGuildOwnerErbanNo(owner.getErbanNo());
+                    }
+
+                    dto.setGuildCreateTime(guild.getCreateTime());
+                    dto.setNewGuild(DateTimeUtil.isBetweenDate(guild.getCreateTime(), systemStartTime, systemEndTime));
+
+                    dto.setGuildDiamondFlow(diamondFlowMap.get(guild.getId()));
+                    dto.setGuildGoldFlow(goldFlowMap.get(guild.getId()));
+
+                    dto.setLastGuildDiamondFlow(BigDecimal.ZERO);
+                    dto.setLastGuildGoldFlow(BigDecimal.ZERO);
+                    dto.setGuildDiamondFlowWow(BigDecimal.ONE);
+                    dto.setGuildGoldFlowWow(BigDecimal.ONE);
+                    dto.setGuildDiamondFlowSub(BigDecimal.ZERO);
+                    dto.setGuildGoldFlowSub(BigDecimal.ZERO);
+
+                    WeekGuildOperatorDetailStat lastWeek = lastWeekDetailStatMap.get(guild.getId());
+                    if (null != lastWeek){
+                        dto.setLastGuildDiamondFlow(lastWeek.getGuildDiamondFlow());
+                        dto.setLastGuildGoldFlow(lastWeek.getGuildGoldFlow());
+
+                        dto.setGuildDiamondFlowSub(dto.getGuildDiamondFlow().subtract(lastWeek.getGuildDiamondFlow()));
+                        dto.setGuildGoldFlowSub(dto.getGuildGoldFlow().subtract(lastWeek.getGuildGoldFlow()));
+
+                        BigDecimal guildDiamondFlowWow = lastWeek.getGuildDiamondFlow().compareTo(BigDecimal.ZERO) > 0 ?
+                                (dto.getGuildDiamondFlow().subtract(lastWeek.getGuildDiamondFlow())).divide(lastWeek.getGuildDiamondFlow(), 2, RoundingMode.HALF_UP): BigDecimal.ONE;
+                        dto.setGuildDiamondFlowWow(guildDiamondFlowWow);
+
+                        BigDecimal guildGoldFlowWow = lastWeek.getGuildGoldFlow().compareTo(BigDecimal.ZERO) > 0 ?
+                                (dto.getGuildGoldFlow().subtract(lastWeek.getGuildGoldFlow())).divide(lastWeek.getGuildGoldFlow(), 2, RoundingMode.HALF_UP): BigDecimal.ONE;
+                        dto.setGuildGoldFlowWow(guildGoldFlowWow);
+                    } else {
+                        dto.setLastGuildDiamondFlow(BigDecimal.ZERO);
+                        dto.setLastGuildGoldFlow(BigDecimal.ZERO);
+                        dto.setGuildDiamondFlowWow(BigDecimal.ZERO);
+                        dto.setGuildGoldFlowWow(BigDecimal.ZERO);
+                    }
+
+                    return dto;
+                }).toList();
+
+        if (!CollectionUtils.isEmpty(detailStatList) && needSaveRecord){
+            detailStatMapper.insert(detailStatList);
+        }
+
+        Map<Integer, String> regionNameMap = regionInfoService.getRegionName();
+
+        Map<Integer, List<WeekGuildOperatorDetailStat>> groupByOperatorId = detailStatList.stream().collect(Collectors.groupingBy(WeekGuildOperatorDetailStat::getOperatorId));
+        List<WeekGuildOperatorStat> statList = groupByOperatorId.entrySet().stream().map(entry -> {
+            Integer operatorId = entry.getKey();
+            List<WeekGuildOperatorDetailStat> operatorDetailStatList = entry.getValue();
+
+            WeekGuildOperatorStat stat = new WeekGuildOperatorStat();
+            stat.setDate(monday);
+            stat.setEndDate(sunday);
+            stat.setOperatorId(operatorId);
+            stat.setPartitionId(partitionId);
+
+            stat.setNewGuildCount((int) operatorDetailStatList.stream().filter(WeekGuildOperatorDetailStat::getNewGuild).count());
+            stat.setNewActiveGuildCount((int) operatorDetailStatList.stream().filter(WeekGuildOperatorDetailStat::getNewGuild)
+                    .filter(s->s.getGuildDiamondFlow().compareTo(BigDecimal.ZERO) > 0).count());
+            stat.setNewGuildTotalDiamondFlow(operatorDetailStatList.stream().filter(WeekGuildOperatorDetailStat::getNewGuild)
+                    .map(WeekGuildOperatorDetailStat::getGuildDiamondFlow).reduce(BigDecimal::add).orElse(BigDecimal.ZERO));
+            stat.setNewGuildTotalGoldFlow(operatorDetailStatList.stream().filter(WeekGuildOperatorDetailStat::getNewGuild)
+                    .map(WeekGuildOperatorDetailStat::getGuildGoldFlow).reduce(BigDecimal::add).orElse(BigDecimal.ZERO));
+
+            stat.setGuildCount(operatorDetailStatList.size());
+            stat.setActiveGuildCount((int) operatorDetailStatList.stream().filter(s->s.getGuildDiamondFlow().compareTo(BigDecimal.ZERO) > 0).count());
+
+            BigDecimal guildTotalDiamondFlow = operatorDetailStatList.stream().map(WeekGuildOperatorDetailStat::getGuildDiamondFlow).reduce(BigDecimal::add).orElse(BigDecimal.ZERO);
+            stat.setGuildTotalDiamondFlow(guildTotalDiamondFlow);
+            BigDecimal guildTotalGoldFlow = operatorDetailStatList.stream().map(WeekGuildOperatorDetailStat::getGuildGoldFlow).reduce(BigDecimal::add).orElse(BigDecimal.ZERO);
+            stat.setGuildTotalGoldFlow(guildTotalGoldFlow);
+
+            BigDecimal lastWeekGuildTotalDiamondFlow = operatorDetailStatList.stream().map(WeekGuildOperatorDetailStat::getLastGuildDiamondFlow).reduce(BigDecimal::add).orElse(BigDecimal.ZERO);
+            stat.setLastWeekGuildTotalDiamondFlow(lastWeekGuildTotalDiamondFlow);
+            BigDecimal lastWeekGuildTotalGoldFlow = operatorDetailStatList.stream().map(WeekGuildOperatorDetailStat::getLastGuildGoldFlow).reduce(BigDecimal::add).orElse(BigDecimal.ZERO);
+            stat.setLastWeekGuildTotalGoldFlow(lastWeekGuildTotalGoldFlow);
+
+            BigDecimal guildDiamondFlowWow = lastWeekGuildTotalDiamondFlow.compareTo(BigDecimal.ZERO) > 0 ?
+                    (guildTotalDiamondFlow.subtract(lastWeekGuildTotalDiamondFlow)).divide(lastWeekGuildTotalDiamondFlow, 2, RoundingMode.HALF_UP): BigDecimal.ONE;
+            stat.setGuildTotalDiamondFlow(guildDiamondFlowWow);
+
+            BigDecimal guildGoldFlowWow = lastWeekGuildTotalGoldFlow.compareTo(BigDecimal.ZERO) > 0 ?
+                    (guildTotalGoldFlow.subtract(lastWeekGuildTotalGoldFlow)).divide(lastWeekGuildTotalGoldFlow, 2, RoundingMode.HALF_UP): BigDecimal.ONE;
+            stat.setGuildTotalGoldFlowWow(guildGoldFlowWow);
+
+            List<WeekGuildOperatorRegionStat> regionStat = groupByRegionStat(partitionId, operatorId, operatorDetailStatList, regionNameMap);
+            stat.setRegionStat(JSON.toJSONString(regionStat));
+
+            return stat;
+
+        }).toList();
+
+        if (CollectionUtils.isEmpty(statList) || !needSaveRecord){
+            return;
+        }
+        statMapper.insertOrUpdate(statList);
+    }
+
+    private List<WeekGuildOperatorRegionStat> groupByRegionStat(Integer partitionId, Integer operatorId,
+                                                                List<WeekGuildOperatorDetailStat> operatorDetailStatList,
+                                                                Map<Integer, String> regionNameMap) {
+        PartitionEnum partitionEnum = PartitionEnum.getByPartitionId(partitionId);
+
+        Map<Integer, List<WeekGuildOperatorDetailStat>> groupByRegion = operatorDetailStatList.stream().collect(Collectors.groupingBy(WeekGuildOperatorDetailStat::getRegionId));
+        return groupByRegion.entrySet().stream().map(entry -> {
+            //nullable
+            Integer regionId = entry.getKey();
+            if (regionId == null) {
+                regionId = 0;
+            }
+            List<WeekGuildOperatorDetailStat> detailStatList = entry.getValue();
+
+            WeekGuildOperatorRegionStat stat = new WeekGuildOperatorRegionStat();
+            stat.setPartitionId(partitionId);
+            stat.setPartitionDesc(partitionEnum.getDesc());
+
+            stat.setOperatorId(operatorId);
+
+            stat.setRegionId(regionId);
+            stat.setRegionDesc(regionNameMap.getOrDefault(regionId, "空"));
+
+            stat.setNewGuildCount((int) detailStatList.stream().filter(WeekGuildOperatorDetailStat::getNewGuild).count());
+            stat.setNewActiveGuildCount((int) detailStatList.stream().filter(WeekGuildOperatorDetailStat::getNewGuild)
+                    .filter(s->s.getGuildDiamondFlow().compareTo(BigDecimal.ZERO) > 0).count());
+
+            stat.setNewGuildDiamondFlow(detailStatList.stream().filter(WeekGuildOperatorDetailStat::getNewGuild).map(WeekGuildOperatorDetailStat::getGuildDiamondFlow).reduce(BigDecimal::add).orElse(BigDecimal.ZERO));
+            stat.setNewGuildGoldFlow(detailStatList.stream().filter(WeekGuildOperatorDetailStat::getNewGuild).map(WeekGuildOperatorDetailStat::getGuildGoldFlow).reduce(BigDecimal::add).orElse(BigDecimal.ZERO));
+
+            stat.setGuildCount(detailStatList.size());
+            stat.setActiveGuildCount((int) detailStatList.stream().filter(s->s.getGuildDiamondFlow().compareTo(BigDecimal.ZERO) > 0).count());
+
+            stat.setGuildDiamondFlow(detailStatList.stream().map(WeekGuildOperatorDetailStat::getGuildDiamondFlow).reduce(BigDecimal::add).orElse(BigDecimal.ZERO));
+            stat.setGuildGoldFlow(detailStatList.stream().map(WeekGuildOperatorDetailStat::getGuildGoldFlow).reduce(BigDecimal::add).orElse(BigDecimal.ZERO));
+
+            return stat;
+
+        }).toList();
+    }
+
+}

accompany-business/accompany-business-service/src/main/resources/accompany/sqlmappers/WeekGuildOperatorDetailStatMapper.xml

@@ -0,0 +1,5 @@
+<?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.accompany.business.mybatismapper.WeekGuildOperatorDetailStatMapper">
+
+</mapper>

accompany-business/accompany-business-service/src/main/resources/accompany/sqlmappers/WeekGuildOperatorStatMapper.xml

@@ -0,0 +1,5 @@
+<?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.accompany.business.mybatismapper.WeekGuildOperatorStatMapper">
+
+</mapper>

accompany-scheduler/accompany-scheduler-service/src/main/java/com/accompany/scheduler/task/GuildOperatorWeekStatTask.java

@@ -0,0 +1,32 @@
+package com.accompany.scheduler.task;
+
+import com.accompany.business.service.WeekGuildOperatorStatService;
+import com.accompany.core.enumeration.PartitionEnum;
+import com.accompany.scheduler.base.BaseTask;
+import lombok.extern.slf4j.Slf4j;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.scheduling.annotation.Scheduled;
+import org.springframework.stereotype.Component;
+
+import java.util.List;
+
+@Component
+@Slf4j
+public class GuildOperatorWeekStatTask extends BaseTask {
+
+    @Autowired
+    private WeekGuildOperatorStatService weekGuildOperatorStatService;
+
+    @Scheduled(cron = "1 0 0 ? * MON")
+    public void statWeekEn() {
+        List<PartitionEnum> partitionEnumList = List.of(PartitionEnum.ENGLISH2);
+        weekGuildOperatorStatService.stat(partitionEnumList);
+    }
+
+    @Scheduled(cron = "1 0 0 ? * MON", zone = "Asia/Riyadh")
+    public void statWeekAr() {
+        List<PartitionEnum> partitionEnumList = List.of(PartitionEnum.ARAB, PartitionEnum.TURKEY);
+        weekGuildOperatorStatService.stat(partitionEnumList);
+    }
+
+}

accompany-scheduler/accompany-scheduler-service/src/main/java/com/accompany/scheduler/task/GuildWeekStatTask.java

@@ -1,8 +1,6 @@
 package com.accompany.scheduler.task;
 
-import com.accompany.business.service.WeekActiveGuildMemberStatService;
 import com.accompany.business.service.WeekGuildStatService;
-import com.accompany.business.service.WeekNewGuildStatService;
 import com.accompany.common.utils.DateTimeUtil;
 import com.accompany.scheduler.base.BaseTask;
 import lombok.extern.slf4j.Slf4j;