客户管家 主页数据

fhKeeper/formulahousekeeper/management-crm/src/main/java/com/management/platform/controller/SalesOrderController.java

@@ -182,5 +182,13 @@ public class SalesOrderController {
         return msg;
     }
 
+    /**
+     * 销售简报数据
+     */
+    @RequestMapping("salesKit")
+    public HttpRespMsg salesKit(Integer queryType,Integer dateType,String startDate,String endDate){
+        return salesOrderService.salesKit(queryType,dateType,startDate,endDate);
+    }
+
 }
 

fhKeeper/formulahousekeeper/management-crm/src/main/java/com/management/platform/service/SalesOrderService.java

@@ -20,4 +20,6 @@ public interface SalesOrderService extends IService<SalesOrder> {
     HttpRespMsg importData(MultipartFile multipartFile);
 
     HttpRespMsg exportData(String userId, String orderName, String orderCode, String productCode) throws Exception;
+
+    HttpRespMsg salesKit(Integer queryType,Integer dateType, String startDate, String endDate);
 }

fhKeeper/formulahousekeeper/management-crm/src/main/java/com/management/platform/service/impl/SalesOrderServiceImpl.java

@@ -20,16 +20,28 @@ import org.apache.poi.ss.usermodel.CellType;
 import org.springframework.beans.factory.annotation.Value;
 import org.springframework.stereotype.Service;
 import org.springframework.util.StringUtils;
+import org.springframework.web.bind.annotation.RequestMapping;
 import org.springframework.web.multipart.MultipartFile;
 
 import javax.annotation.Resource;
+import javax.print.DocFlavor;
 import javax.servlet.http.HttpServletRequest;
 import java.io.*;
 import java.lang.reflect.InvocationTargetException;
 import java.lang.reflect.Method;
+import java.math.BigDecimal;
+import java.math.RoundingMode;
+import java.text.NumberFormat;
+import java.text.SimpleDateFormat;
+import java.time.LocalDate;
+import java.time.Year;
+import java.time.format.DateTimeFormatter;
+import java.time.temporal.TemporalAdjusters;
 import java.util.*;
 import java.util.stream.Collectors;
 
+import static java.text.NumberFormat.getPercentInstance;
+
 /**
  * <p>
  *  服务实现类
@@ -61,6 +73,12 @@ public class SalesOrderServiceImpl extends ServiceImpl<SalesOrderMapper, SalesOr
     private SysFormMapper sysFormMapper;
     @Resource
     private WxCorpInfoService wxCorpInfoService;
+    @Resource
+    private CustomService customService;
+    @Resource
+    private BusinessOpportunityService businessOpportunityService;
+    @Resource
+    private ContactsService contactsService;
     @Value(value = "${upload.path}")
     private String path;
 
@@ -359,6 +377,183 @@ public class SalesOrderServiceImpl extends ServiceImpl<SalesOrderMapper, SalesOr
         return excelExportService.exportGeneralExcelByTitleAndList(wxCorpInfo,fileName,dataList,path);
     }
 
+    @Override
+    public HttpRespMsg salesKit(Integer queryType,Integer dateType,String startDate, String endDate) {
+        HttpRespMsg msg=new HttpRespMsg();
+        DateTimeFormatter df=DateTimeFormatter.ofPattern("yyyy-MM-dd");
+        LambdaQueryWrapper<Custom> customLambdaQueryWrapper = new LambdaQueryWrapper<>();
+        LambdaQueryWrapper<Custom> customLambdaQueryWrapper1 = new LambdaQueryWrapper<>();
+        LambdaQueryWrapper<Contacts> contactsLambdaQueryWrapper = new LambdaQueryWrapper<>();
+        LambdaQueryWrapper<Contacts> contactsLambdaQueryWrapper1 = new LambdaQueryWrapper<>();
+        LambdaQueryWrapper<BusinessOpportunity> businessOpportunityLambdaQueryWrapper = new LambdaQueryWrapper<>();
+        LambdaQueryWrapper<BusinessOpportunity> businessOpportunityLambdaQueryWrapper1 = new LambdaQueryWrapper<>();
+        LambdaQueryWrapper<SalesOrder> salesOrderLambdaQueryWrapper = new LambdaQueryWrapper<>();
+        LambdaQueryWrapper<SalesOrder> salesOrderLambdaQueryWrapper1 = new LambdaQueryWrapper<>();
+        User user = userMapper.selectById(request.getHeader("token"));
+        List<Department> allDeptList = departmentMapper.selectList(new LambdaQueryWrapper<Department>().eq(Department::getCompanyId, user.getCompanyId()));
+        if(!StringUtils.isEmpty(startDate)&&!StringUtils.isEmpty(endDate)){
+            customLambdaQueryWrapper.between(Custom::getCreateTime,startDate,endDate);
+            contactsLambdaQueryWrapper.between(Contacts::getCreateTime,startDate,endDate);
+            businessOpportunityLambdaQueryWrapper.between(BusinessOpportunity::getCreateTime,startDate,endDate);
+            salesOrderLambdaQueryWrapper.between(SalesOrder::getCreateTime,startDate,endDate);
+        }
+        if(dateType!=null){
+            switch (dateType){
+                case 0:
+                    //本月
+                    LocalDate now = LocalDate.now();
+                    LocalDate dateStartOfMonth = now.with(TemporalAdjusters.firstDayOfMonth());
+                    LocalDate dateEndOfMonth = now.with(TemporalAdjusters.lastDayOfMonth());
+                    customLambdaQueryWrapper.between(Custom::getCreateTime,dateStartOfMonth,dateEndOfMonth);
+                    customLambdaQueryWrapper1.between(Custom::getCreateTime,dateStartOfMonth.minusMonths(1),dateEndOfMonth.minusMonths(1));
+                    contactsLambdaQueryWrapper.between(Contacts::getCreateTime,dateStartOfMonth,dateEndOfMonth);
+                    contactsLambdaQueryWrapper1.between(Contacts::getCreateTime,dateStartOfMonth.minusMonths(1),dateEndOfMonth.minusMonths(1));
+                    businessOpportunityLambdaQueryWrapper.between(BusinessOpportunity::getCreateTime,dateStartOfMonth,dateEndOfMonth);
+                    businessOpportunityLambdaQueryWrapper1.between(BusinessOpportunity::getCreateTime,dateStartOfMonth.minusMonths(1),dateEndOfMonth.minusMonths(1));
+                    salesOrderLambdaQueryWrapper.between(SalesOrder::getCreateTime,dateStartOfMonth,dateEndOfMonth);
+                    salesOrderLambdaQueryWrapper1.between(SalesOrder::getCreateTime,dateStartOfMonth.minusMonths(1),dateEndOfMonth.minusMonths(1));
+                    break;
+                case 1:
+                    //本周
+                    LocalDate now1 = LocalDate.now();
+                    LocalDate dateStartOfWeek = now1.with(TemporalAdjusters.previousOrSame(java.time.DayOfWeek.MONDAY));
+                    LocalDate dateEndOfWeek = now1.with(TemporalAdjusters.nextOrSame(java.time.DayOfWeek.SUNDAY));
+                    customLambdaQueryWrapper.between(Custom::getCreateTime,dateStartOfWeek,dateEndOfWeek);
+                    customLambdaQueryWrapper1.between(Custom::getCreateTime,dateStartOfWeek.minusWeeks(1),dateEndOfWeek.minusWeeks(1));
+                    contactsLambdaQueryWrapper.between(Contacts::getCreateTime,dateStartOfWeek,dateEndOfWeek);
+                    contactsLambdaQueryWrapper1.between(Contacts::getCreateTime,dateStartOfWeek.minusWeeks(1),dateEndOfWeek.minusWeeks(1));
+                    businessOpportunityLambdaQueryWrapper.between(BusinessOpportunity::getCreateTime,dateStartOfWeek,dateEndOfWeek);
+                    businessOpportunityLambdaQueryWrapper1.between(BusinessOpportunity::getCreateTime,dateStartOfWeek.minusWeeks(1),dateEndOfWeek.minusWeeks(1));
+                    salesOrderLambdaQueryWrapper.between(SalesOrder::getCreateTime,dateStartOfWeek,dateEndOfWeek);
+                    salesOrderLambdaQueryWrapper1.between(SalesOrder::getCreateTime,dateStartOfWeek.minusWeeks(1),dateEndOfWeek.minusWeeks(1));
+                    break;
+                case 2:
+                    //本年
+                    Year year = Year.now();
+                    LocalDate dateStartOfYear = year.atDay(1).atStartOfDay().toLocalDate();
+                    LocalDate dateEndOfYear = year.plusYears(1).atDay(1).atStartOfDay().minusSeconds(1).toLocalDate();
+                    customLambdaQueryWrapper.between(Custom::getCreateTime,dateStartOfYear,dateEndOfYear);
+                    customLambdaQueryWrapper1.between(Custom::getCreateTime,dateStartOfYear.minusYears(1),dateEndOfYear.minusYears(1));
+                    contactsLambdaQueryWrapper.between(Contacts::getCreateTime,dateStartOfYear,dateEndOfYear);
+                    contactsLambdaQueryWrapper1.between(Contacts::getCreateTime,dateStartOfYear.minusYears(1),dateEndOfYear.minusYears(1));
+                    businessOpportunityLambdaQueryWrapper.between(BusinessOpportunity::getCreateTime,dateStartOfYear,dateEndOfYear);
+                    businessOpportunityLambdaQueryWrapper1.between(BusinessOpportunity::getCreateTime,dateStartOfYear.minusYears(1),dateEndOfYear.minusYears(1));
+                    salesOrderLambdaQueryWrapper.between(SalesOrder::getCreateTime,dateStartOfYear,dateEndOfYear);
+                    salesOrderLambdaQueryWrapper1.between(SalesOrder::getCreateTime,dateStartOfYear.minusYears(1),dateEndOfYear.minusYears(1));
+                    break;
+            }
+        }
+        if(queryType!=null){
+            switch (queryType){
+                case 0:
+                    //仅本人
+                    customLambdaQueryWrapper.eq(Custom::getCreatorId,user.getId());
+                    contactsLambdaQueryWrapper.eq(Contacts::getCreatorId,user.getId());
+                    businessOpportunityLambdaQueryWrapper.eq(BusinessOpportunity::getCreatorId,user.getId());
+                    salesOrderLambdaQueryWrapper.eq(SalesOrder::getCreatorId,user.getId());
+
+                    customLambdaQueryWrapper1.eq(Custom::getCreatorId,user.getId());
+                    contactsLambdaQueryWrapper1.eq(Contacts::getCreatorId,user.getId());
+                    businessOpportunityLambdaQueryWrapper1.eq(BusinessOpportunity::getCreatorId,user.getId());
+                    salesOrderLambdaQueryWrapper1.eq(SalesOrder::getCreatorId,user.getId());
+                    break;
+                case 1:
+                    //本人及下属
+                    List<Department> departmentList = departmentMapper.selectList(new LambdaQueryWrapper<Department>().eq(Department::getManagerId, user.getId()));
+                    List<Integer> deptIds = departmentList.stream().map(Department::getDepartmentId).distinct().collect(Collectors.toList());
+                    deptIds.add(-1);
+                    List<User> userList = userMapper.selectList(new LambdaQueryWrapper<User>().in(User::getDepartmentId, deptIds));
+                    List<String> userIds = userList.stream().map(User::getId).distinct().collect(Collectors.toList());
+                    userIds.add("-1");
+                    customLambdaQueryWrapper.in(Custom::getCreatorId,userIds);
+                    contactsLambdaQueryWrapper.in(Contacts::getCreatorId,userIds);
+                    businessOpportunityLambdaQueryWrapper.in(BusinessOpportunity::getCreatorId,userIds);
+                    salesOrderLambdaQueryWrapper.in(SalesOrder::getCreatorId,userIds);
+
+                    customLambdaQueryWrapper1.in(Custom::getCreatorId,userIds);
+                    contactsLambdaQueryWrapper1.in(Contacts::getCreatorId,userIds);
+                    businessOpportunityLambdaQueryWrapper1.in(BusinessOpportunity::getCreatorId,userIds);
+                    salesOrderLambdaQueryWrapper1.in(SalesOrder::getCreatorId,userIds);
+                    break;
+                case 2:
+                    //仅本部门
+                    Integer targetDeptId = user.getDepartmentId();
+                    List<User> users = userMapper.selectList(new LambdaQueryWrapper<User>().eq(User::getDepartmentId, targetDeptId));
+                    List<String> targetUserIds = users.stream().map(User::getId).distinct().collect(Collectors.toList());
+                    targetUserIds.add("-1");
+                    customLambdaQueryWrapper.in(Custom::getCreatorId,targetUserIds);
+                    contactsLambdaQueryWrapper.in(Contacts::getCreatorId,targetUserIds);
+                    businessOpportunityLambdaQueryWrapper.in(BusinessOpportunity::getCreatorId,targetUserIds);
+                    salesOrderLambdaQueryWrapper.in(SalesOrder::getCreatorId,targetUserIds);
+
+                    customLambdaQueryWrapper1.in(Custom::getCreatorId,targetUserIds);
+                    contactsLambdaQueryWrapper1.in(Contacts::getCreatorId,targetUserIds);
+                    businessOpportunityLambdaQueryWrapper1.in(BusinessOpportunity::getCreatorId,targetUserIds);
+                    salesOrderLambdaQueryWrapper1.in(SalesOrder::getCreatorId,targetUserIds);
+                    break;
+                case 3:
+                    //本部门及下属部门
+                    //仅本部门
+                    Integer targetDeptId1 = user.getDepartmentId();
+                    List<Integer> branchDepartment = getBranchDepartment(targetDeptId1, allDeptList);
+                    List<User> users1 = userMapper.selectList(new LambdaQueryWrapper<User>().in(User::getDepartmentId, branchDepartment));
+                    List<String> targetUserIds1 = users1.stream().map(User::getId).distinct().collect(Collectors.toList());
+                    targetUserIds1.add("-1");
+                    customLambdaQueryWrapper.in(Custom::getCreatorId,targetUserIds1);
+                    contactsLambdaQueryWrapper.in(Contacts::getCreatorId,targetUserIds1);
+                    businessOpportunityLambdaQueryWrapper.in(BusinessOpportunity::getCreatorId,targetUserIds1);
+                    salesOrderLambdaQueryWrapper.in(SalesOrder::getCreatorId,targetUserIds1);
+
+                    customLambdaQueryWrapper1.in(Custom::getCreatorId,targetUserIds1);
+                    contactsLambdaQueryWrapper1.in(Contacts::getCreatorId,targetUserIds1);
+                    businessOpportunityLambdaQueryWrapper1.in(BusinessOpportunity::getCreatorId,targetUserIds1);
+                    salesOrderLambdaQueryWrapper1.in(SalesOrder::getCreatorId,targetUserIds1);
+                    break;
+            }
+        }
+        Map<String,Object> resultMap=new HashMap<>();
+
+        int customCount = customService.count(customLambdaQueryWrapper);
+        int contactsCount = contactsService.count(contactsLambdaQueryWrapper);
+        int businessOpportunityCount = businessOpportunityService.count(businessOpportunityLambdaQueryWrapper);
+        Integer salesOrderCount = salesOrderMapper.selectCount(salesOrderLambdaQueryWrapper);
+
+        int customCount1 = customService.count(customLambdaQueryWrapper1);
+        int contactsCount1 = contactsService.count(contactsLambdaQueryWrapper1);
+        int businessOpportunityCount1 = businessOpportunityService.count(businessOpportunityLambdaQueryWrapper1);
+        Integer salesOrderCount1 = salesOrderMapper.selectCount(salesOrderLambdaQueryWrapper1);
+        Map<String,Object> customMap=new HashMap<>();
+        customMap.put("customCount",customCount);
+        customMap.put("customPromote",getPromote(customCount,customCount1));
+        resultMap.put("custom",customMap);
+        Map<String,Object> contactsMap=new HashMap<>();
+        contactsMap.put("contactsCount",contactsCount);
+        contactsMap.put("contactsPromote",getPromote(contactsCount,contactsCount1));
+        resultMap.put("contacts",contactsMap);
+        Map<String,Object> businessOpportunityMap=new HashMap<>();
+        businessOpportunityMap.put("businessOpportunityCount",businessOpportunityCount);
+        businessOpportunityMap.put("businessOpportunityPromote",getPromote(businessOpportunityCount,businessOpportunityCount1));
+        resultMap.put("businessOpportunity",businessOpportunityMap);
+        Map<String,Object> salesOrderMap=new HashMap<>();
+        salesOrderMap.put("salesOrderCount",salesOrderCount);
+        salesOrderMap.put("salesOrderPromote",getPromote(salesOrderCount,salesOrderCount1));
+        resultMap.put("salesOrder",salesOrderMap);
+        msg.setData(resultMap);
+        return msg;
+    }
+
+    private String getPromote(int num, int oldNum) {
+        BigDecimal numBd = new BigDecimal(num);
+        BigDecimal oldNumBd = new BigDecimal(oldNum);
+        numBd=numBd.subtract(oldNumBd);
+        if(oldNum>0){
+            numBd=numBd.divide(oldNumBd,2,RoundingMode.HALF_UP);
+        }
+        NumberFormat percentInstance =NumberFormat.getPercentInstance();
+        percentInstance.setMaximumFractionDigits(2);
+        return percentInstance.format(numBd.doubleValue());
+    }
+
     //递归获取子部门
     public List<Integer> getBranchDepartment(Integer departmentId, List<Department> departmentList) {
         List<Integer> list = new ArrayList<>();

fhKeeper/formulahousekeeper/management-platform/src/main/java/com/management/platform/service/impl/DingDingServiceImpl.java

@@ -2574,6 +2574,7 @@ public class DingDingServiceImpl implements DingDingService {
         JSONObject obj = JSONObject.parseObject(response.getBody());
         if (obj.getIntValue("errcode") == 0) {
             media_id = obj.getString("media_id");
+            System.out.println("钉钉转译media_id=========="+media_id);
             return media_id;
         }
         return null;
@@ -2595,6 +2596,8 @@ public class DingDingServiceImpl implements DingDingService {
             try {
                 TranslateFileResponse translateFileResponse = client.translateFileWithOptions(translateFileRequest, translateFileHeaders, new RuntimeOptions());
                 TranslateFileResponseBody body = translateFileResponse.body;
+                System.out.println("钉钉转译jobId=========="+body.jobId);
+                System.out.println("钉钉转译body=========="+body);
                 return body.jobId;
             } catch (TeaException err) {
                 if (!com.aliyun.teautil.Common.empty(err.code) && !com.aliyun.teautil.Common.empty(err.message)) {