Commit 5f3061b8 authored by Administrator's avatar Administrator

原 search迁移

parent 41393b1c
package com.dsk.jsk.controller;
import com.dsk.common.core.domain.AjaxResult;
import com.dsk.jsk.domain.*;
import com.dsk.jsk.service.service.EconomicService;
import com.dsk.jsk.util.IpUtil;
import com.dsk.search.domain.OpRegionalLocalDto;
import lombok.extern.slf4j.Slf4j;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.PostMapping;
import org.springframework.web.bind.annotation.RequestBody;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;
import javax.servlet.http.HttpServletRequest;
import javax.validation.Valid;
/**
* @ClassName RegionalEconomicDataController
* @Description 区域经济大全
* @Author Dgm
* @Date 2023/5/18 10:09
* @Version 1.0.0
*/
@Slf4j
@RestController
@RequestMapping(value ="/economic")
public class RegionalEconomicDataController {
@Autowired
private EconomicService economicService;
/***
*@Description: 全国经济大全分页列表
*@Param:
*@return: com.dsk.common.core.domain.AjaxResult
*@Author: Dgm
*@date: 2023/5/18 10:29
*/
@PostMapping("/national/nationalPage")
public AjaxResult nationalPage(@RequestBody @Valid OpRegionalEconomicDataV1PageDto dto) {
return economicService.nationalPage(dto);
}
/***
*@Description: 获取年份
*@Param:
*@return: com.dsk.acc.security.common.msg.RestResponse
*@Author: Dgm
*@date: 2023/5/18 10:29
*/
@PostMapping("/years/list")
public AjaxResult yearsList(@RequestBody OpRegionalEconomicDataYearsListDto dto) {
return economicService.yearsList(dto);
}
/***
*@Description: 全国经济大全详情
*@Param:
*@return: com.dsk.common.core.domain.AjaxResult
*@Author: Dgm
*@date: 2023/5/18 10:29
*/
@PostMapping("/details")
public AjaxResult details(@RequestBody @Valid OpRegionalEconomicDataDetailsDto detailsDto) {
return economicService.details(detailsDto);
}
/***
*@Description: 获取当前地区
*@Param:
*@return: com.dsk.common.core.domain.AjaxResult
*@Author: Dgm
*@date: 2023/5/18 10:29
*/
@PostMapping(value = "location")
public AjaxResult location(@RequestBody OpRegionalLocalDto vo, HttpServletRequest request){
String ip = IpUtil.getIpAddr(request);
vo.setIp(ip);
return economicService.location(vo);
}
/***
*@Description: 地区经济-统计
*@Param:
*@return: com.dsk.common.core.domain.AjaxResult
*@Author: Dgm
*@date: 2023/5/18 10:29
*/
@PostMapping("/statistics/regional")
public AjaxResult statisticsRegional(@RequestBody OpRegionalEconomicDataStatisticsRegionalDto dto) {
return economicService.statisticsRegional(dto);
}
/***
*@Description: 地区经济-主要指标列表
*@Param:
*@return: com.dsk.common.core.domain.AjaxResult
*@Author: Dgm
*@date: 2023/5/18 10:29
*/
@PostMapping("/regional/list")
public AjaxResult regionalList(@RequestBody OpRegionalEconomicDataRegionalListDto dto) {
return economicService.regionalList(dto);
}
/***
*@Description: 地区经济
*@Param:
*@return: com.dsk.acc.security.common.msg.RestResponse
*@Author: Dgm
*@date: 2023/5/18 10:29
*/
@PostMapping("/regional/compare")
public AjaxResult regionalCompare(@RequestBody OpRegionalEconomicDataStatisticsRegionalDto dto) {
return economicService.regionalCompare(dto);
}
/***
*@Description: 地区经济-对比
*@Param:
*@return: com.dsk.acc.security.common.msg.RestResponse
*@Author: Dgm
*@date: 2023/5/18 10:29
*/
@PostMapping("/regional/multipleCompare")
public AjaxResult regionalMultipleCompare(@RequestBody OpRegionalEconomicRegionalCompareDto compareDto) {
return economicService.regionalMultipleCompare(compareDto);
}
}
package com.dsk.jsk.controller;
import com.alibaba.fastjson2.JSONObject;
import com.dsk.common.core.domain.AjaxResult;
import com.dsk.jsk.service.service.RegionalEnterprisesService;
import com.dsk.search.controller.PageQueryLimit;
import com.dsk.search.domain.ComposeQueryDto;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.PostMapping;
import org.springframework.web.bind.annotation.RequestBody;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;
/**
* @ClassName RegionalEnterprisesController
* @Description 区域企业
* @Author Dgm
* @Date 2023/5/24 16:20
* @Version
*/
@RestController
@RequestMapping(value="/enterprises")
public class RegionalEnterprisesController {
@Autowired
private RegionalEnterprisesService regionalEnterprisesService;
@PostMapping("regional/page")
public AjaxResult page(@RequestBody JSONObject object) throws Exception{
ComposeQueryDto compose = JSONObject.parseObject(object.toJSONString(), ComposeQueryDto.class);
compose.getPage().setPage(compose.getPageNum());
compose.getPage().setLimit(compose.getPageSize());
compose.getPage().setField(compose.getField());
compose.getPage().setOrder(compose.getOrder());
if (PageQueryLimit.pageLimit(compose.getPage())){
return AjaxResult.error("翻页已达到上限");
}
return regionalEnterprisesService.enterprisePage(compose);
}
}
package com.dsk.jsk.controller;
import com.dsk.common.core.domain.AjaxResult;
import com.dsk.jsk.domain.*;
import com.dsk.jsk.service.service.SpecialPurposeBondsService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.PostMapping;
import org.springframework.web.bind.annotation.RequestBody;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;
import javax.validation.Valid;
/**
* @ClassName SpecialBondProjectsController
* @Description 专项债项目
* @Author Dgm
* @Date 2023/5/18 10:09
* @Version 1.0.0
*/
@RestController
@RequestMapping(value ="/specialPurposeBonds")
public class SpecialBondProjectsController {
@Autowired
private SpecialPurposeBondsService specialPurposeBondsService;
/***
*@Description: 专项债项目分页列表
*@Param:
*@return: com.dsk.common.core.domain.AjaxResult
*@Author: Dgm
*@date: 2023/5/18 10:29
*/
@PostMapping("/projects/page")
public AjaxResult page(@RequestBody SpecialPurposeBondsPageDto pageDto) {
return specialPurposeBondsService.page(pageDto);
}
/***
*@Description: 专项债项目详情
*@Param:
*@return: com.dsk.common.core.domain.AjaxResult
*@Author: Dgm
*@date: 2023/5/18 10:29
*/
@PostMapping("/details")
public AjaxResult details(@RequestBody @Valid SpecialBondInformationDetailsDto detailsDto) {
return specialPurposeBondsService.details(detailsDto);
}
/***
*@Description: 专项债-项目类别统计
*@Param:
*@return: com.dsk.common.core.domain.AjaxResult
*@Author: Dgm
*@date: 2023/5/18 10:29
*/
@PostMapping("/bond/statistics")
public AjaxResult bondStatistics(@RequestBody SpecialPurposeBondsDto dto) {
return specialPurposeBondsService.bondStatistics(dto);
}
/***
*@Description: 专项债分页列表
*@Param:
*@return: com.dsk.common.core.domain.AjaxResult
*@Author: Dgm
*@date: 2023/5/18 10:29
*/
@PostMapping("/bond/page")
public AjaxResult bondPage(@RequestBody SpecialBondInformationPageDto dto) {
return specialPurposeBondsService.bondPage(dto);
}
}
package com.dsk.jsk.controller;
import com.dsk.common.core.domain.AjaxResult;
import com.dsk.jsk.domain.UrbanInvestmentPlatformDto;
import com.dsk.jsk.service.service.UrbanInvestmentPlatformService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.*;
/**
* @ClassName UrbanInvestmentPlatformController
* @Description 城投平台
* @Author Dgm
* @Date 2023/5/18 10:09
* @Version 1.0.0
*/
@RestController
@RequestMapping(value ="/urbanInvestment")
public class UrbanInvestmentPlatformController {
@Autowired
private UrbanInvestmentPlatformService urbanInvestmentPlatformService;
/***
*@Description: 城投平台分页列表
*@Param:
*@return: com.dsk.common.core.domain.AjaxResult
*@Author: Dgm
*@date: 2023/5/18 10:29
*/
@PostMapping("/page")
public AjaxResult page(@RequestBody UrbanInvestmentPlatformDto dto) {
return urbanInvestmentPlatformService.page(dto);
}
/***
*@Description: 城投平台详情
*@Param:
*@return: com.dsk.common.core.domain.AjaxResult
*@Author: Dgm
*@date: 2023/5/18 10:29
*/
@PostMapping("/details/{id}")
public AjaxResult details(@PathVariable("id") String id) {
return urbanInvestmentPlatformService.details(id);
}
/***
*@Description: 城投平台统计
*@Param:
*@return: com.dsk.common.core.domain.AjaxResult
*@Author: Dgm
*@date: 2023/5/18 10:29
*/
@PostMapping("/statistics")
public AjaxResult statistics(@RequestBody UrbanInvestmentPlatformDto dto) {
return urbanInvestmentPlatformService.statistics(dto);
}
}
package com.dsk.jsk.domain;
import lombok.Data;
import javax.validation.constraints.NotNull;
/**
* @ClassName OpRegionalEconomicDataV1Dto
* @Description 区域经济大全-详情
* @Author Dgm
* @Date 2023/5/23 14:05
* @Version
*/
@Data
public class OpRegionalEconomicDataDetailsDto {
/**
* id
*/
@NotNull(message = "id 不能为空")
private Integer id;
}
package com.dsk.jsk.domain;
import lombok.Data;
import javax.validation.constraints.NotNull;
/**
* @ClassName OpRegionalEconomicDataV1Dto
* @Description 专项债-项目类别统计
* @Author Dgm
* @Date 2023/5/23 14:05
* @Version
*/
@Data
public class OpRegionalEconomicDataRegionalListDto {
/**
* id
*/
@NotNull(message = "id 不能为空")
private Integer id;
/**
* 省Id
*/
@NotNull(message = "provinceId 不能为空")
private Integer provinceId;
/**
* 市Id
*/
private Integer cityId;
/**
* 区Id
*/
private Integer areaId;
}
package com.dsk.jsk.domain;
import lombok.Data;
import javax.validation.constraints.NotNull;
/**
* @ClassName OpRegionalEconomicDataV1Dto
* @Description 地区经济
* @Author Dgm
* @Date 2023/5/23 14:05
* @Version
*/
@Data
public class OpRegionalEconomicDataStatisticsRegionalDto {
/**
* id
*/
@NotNull(message = "id 不能为空")
private Integer id;
/**
* 年份
*/
private Integer year;
/**
* 省Id
*/
private Integer provinceId;
/**
* 市Id
*/
private Integer cityId;
/**
* 区Id
*/
private Integer areaId;
}
package com.dsk.jsk.domain;
import lombok.Data;
/**
* @ClassName OpRegionalEconomicDataV1Dto
* @Description 专项债-项目类别统计
* @Author Dgm
* @Date 2023/5/23 14:05
* @Version
*/
@Data
public class OpRegionalEconomicDataV1Dto {
/**
* id
*/
private Integer id;
/**
* 年份
*/
private Integer year;
/**
* 省Id
*/
private Integer provinceId;
/**
* 市Id
*/
private Integer cityId;
/**
* 区Id
*/
private Integer areaId;
/**
* 城市类型 1:直辖市
*/
private Integer cityType;
/**
* 城市类型 1:直辖市
*/
private Integer provinceType;
}
package com.dsk.jsk.domain;
import com.dsk.common.core.domain.model.BasePage;
import lombok.Data;
import java.util.List;
/**
* @ClassName OpRegionalEconomicDataV1PageDto
* @Description 专项债-项目类别统计
* @Author Dgm
* @Date 2023/5/23 14:05
* @Version
*/
@Data
public class OpRegionalEconomicDataV1PageDto extends BasePage {
/**
* 年份
*/
private Integer year;
/**
* 省
*/
private List<Integer> provinceIds;
/**
* 市
*/
private List<Integer> cityIds;
/**
* 区
*/
private List<Integer> areaIds;
/**
* 全国宏观经济:1 / 辖区经济:2 / 地区对比:3
*/
private Integer type;
/**
* 排序字段 默认gdp
*/
private String field = "gdp";
/**
* 排序 (降序desc 升序asc)
*/
private String order = "desc";
}
package com.dsk.jsk.domain;
import lombok.Data;
/**
* @ClassName OpRegionalEconomicDataYearsListDto
* @Description 获取年份
* @Author Dgm
* @Date 2023/5/23 14:05
* @Version
*/
@Data
public class OpRegionalEconomicDataYearsListDto {
private Integer year;
}
package com.dsk.jsk.domain;
import cn.hutool.core.util.ObjectUtil;
import java.util.List;
/**
* @ClassName OpRegionalEconomicRegionalCompareDto
* @Description 地区经济-对比
* @Author Dgm
* @Date 2023/5/23 14:05
* @Version
*/
public class OpRegionalEconomicRegionalCompareDto {
/**
* 年份
*/
private Integer year;
private List<OpRegionalEconomicDataStatisticsRegionalDto> compareList;
public Integer getYear() {
return year;
}
public void setYear(Integer year) {
this.year = year;
}
public List<OpRegionalEconomicDataStatisticsRegionalDto> getCompareList() {
if (ObjectUtil.isNotEmpty(compareList)) {
for (OpRegionalEconomicDataStatisticsRegionalDto dataStatisticsRegionalDto : compareList) {
dataStatisticsRegionalDto.setYear(year);
}
}
return compareList;
}
public void setCompareList(List<OpRegionalEconomicDataStatisticsRegionalDto> compareList) {
this.compareList = compareList;
}
@Override
public String toString() {
return "OpRegionalEconomicRegionalCompareDto{" +
"year=" + year +
", compareList=" + compareList +
'}';
}
}
package com.dsk.jsk.domain;
import lombok.Data;
import javax.validation.constraints.NotNull;
/**
* @ClassName SpecialBondInformationDetailsDto
* @Description 专项债-详情
* @Author Dgm
* @Date 2023/5/23 14:05
* @Version
*/
@Data
public class SpecialBondInformationDetailsDto {
/**
* 专项债券唯一标识
*/
@NotNull(message = "id 不能为空")
private Integer id;
}
package com.dsk.jsk.domain;
import com.dsk.common.core.domain.model.BasePage;
import lombok.Data;
/**
* @ClassName SpecialBondInformationPageDto
* @Description 专项债-详情分页
* @Author Dgm
* @Date 2023/5/23 14:05
* @Version
*/
@Data
public class SpecialBondInformationPageDto extends BasePage {
/**
* 专项债券唯一标识
*/
private String specialBondUuid;
}
package com.dsk.jsk.domain;
import lombok.Data;
/**
* 组合查询参数
* @author Administrator
*
*/
@Data
public class SpecialBondProjectDto {
Long id;
String uuid;
String projectName;
//match精确 like模糊
String nameType;
String projectType;
//项目总投资
String projectTotalInvestment;
//项目资本金
String projectCapital;
//专项债金额
String specialCapital;
//项目主体
String projectEntity;
//项目主体id
Long projectEntityId;
//主管部门
String chargeDepartment;
//实施单位
String piu;
Long piuId;
String domicile;
String province;
String city;
String area;
}
package com.dsk.jsk.domain;
import lombok.Data;
/**
* @ClassName SpecialPurposeBonds
* @Description 专项债-项目类别统计
* @Author Dgm
* @Date 2023/5/23 14:05
* @Version
*/
@Data
public class SpecialPurposeBondsDto {
/**
* 省Id
*/
private Integer provinceId;
/**
* 市Id
*/
private Integer cityId;
/**
* 区Id
*/
private Integer areaId;
/**
* 项目类型
*/
private String specialBondProjectType;
/**
* 项目个数
*/
private Integer count;
/**
* 投资金额
*/
private Double projectTotalInvestment;
/**
* 比例(%)
*/
private Double proportion;
/**
* 排序字段
*/
private String field;
/**
* 排序 (降序desc 升序asc)
*/
private String order;
/**
* 是否为历史(1是,0否)
*/
private Integer isHistory;
}
package com.dsk.jsk.domain;
import com.dsk.common.core.domain.model.BasePage;
import lombok.Data;
/**
* @ClassName SpecialPurposeBonds
* @Description 专项债-项目分页列表
* @Author Dgm
* @Date 2023/5/23 14:05
* @Version
*/
@Data
public class SpecialPurposeBondsPageDto extends BasePage {
/**
* 省Id
*/
private Integer provinceId;
/**
* 市Id
*/
private Integer cityId;
/**
* 区Id
*/
private Integer areaId;
/**
* 排序字段 默认-投资金额
*/
private String field;
/**
* 排序 (降序desc 升序asc)
*/
private String order;
/**
* 是否为历史(1是,0否)
*/
private Integer isHistory;
}
package com.dsk.jsk.domain;
import com.dsk.common.core.domain.model.BasePage;
import lombok.Data;
import java.util.List;
/**
* @ClassName UrbanInvestmentPlatformDto
* @Description 城投平台参数对象
* @Author Dgm
* @Date 2023/5/23 14:05
* @Version
*/
@Data
public class UrbanInvestmentPlatformDto extends BasePage {
/**
* 行政级别
*/
private String uipExecutiveLevel;
/**
* 城投业务类型
*/
private List<String> uipBusinessType;
/**
* 主体评级
*/
private List<String> bratingSubjectLevel;
/**
* 股东背景
*/
private List<String> shareholderBg;
/**
* 股权关系
*/
private List<String> equityRelationship;
/**
* 平台重要性
*/
private List<String> platformImportance;
/**
* 所属开发区
*/
private List<String> developmentZone;
/**
* 省
*/
private List<Integer> provinceIds;
/**
* 市
*/
private List<Integer> cityIds;
/**
* 区
*/
private List<Integer> areaIds;
/**
* 关键词
*/
private String keyword;
/**
* 排序字段
*/
private String field;
/**
* 字段 desc asc
*/
private String order;
/**
* 含下属区:1 本级:2
*/
private Integer type =1;
}
package com.dsk.jsk.domain;
import lombok.Data;
import java.util.Objects;
/**
* @ClassName UrbanInvestmentPlatformSubjectLevelDto
* @Description 信用评级
* @Author Dgm
* @Date 2023/5/23 14:05
* @Version
*/
@Data
public class UrbanInvestmentPlatformSubjectLevelDto {
/**
* 企业Id
*/
private Long companyId;
/**
* 主体评级
*/
private String bratingSubjectLevel;
@Override
public boolean equals(Object o) {
if (this == o) {
return true;
}
if (o == null || getClass() != o.getClass()) {
return false;
}
UrbanInvestmentPlatformSubjectLevelDto that = (UrbanInvestmentPlatformSubjectLevelDto) o;
return Objects.equals(companyId, that.companyId);
}
@Override
public int hashCode() {
return Objects.hash(companyId);
}
}
package com.dsk.jsk.service.service;
import com.dsk.common.core.domain.AjaxResult;
import com.dsk.jsk.domain.*;
import com.dsk.search.domain.OpRegionalLocalDto;
/**
* @ClassName EconomicService
* @Description 经济大全业务层
* @Author Dgm
* @Date 2023/5/18 10:17
* @Version 1.00
*/
public interface EconomicService {
/***
*@Description: 全国经济大全分页列表
*@Param:
*@return: com.dsk.common.core.domain.AjaxResult
*@Author: Dgm
*@date: 2023/5/18 10:25
*/
AjaxResult nationalPage(OpRegionalEconomicDataV1PageDto dto);
/***
*@Description: 全国经济大全分页列表
*@Param:
*@return: com.dsk.common.core.domain.AjaxResult
*@Author: Dgm
*@date: 2023/5/18 10:25
*/
AjaxResult yearsList(OpRegionalEconomicDataYearsListDto dataYearsListDto);
/***
*@Description: 全国经济大全详情
*@Param:
*@return: com.dsk.common.core.domain.AjaxResult
*@Author: Dgm
*@date: 2023/5/18 10:25
*/
AjaxResult details(OpRegionalEconomicDataDetailsDto detailsDto);
/***
*@Description: 获取当前地区
*@Param:
*@return: com.dsk.common.core.domain.AjaxResult
*@Author: Dgm
*@date: 2023/5/18 10:25
*/
AjaxResult location(OpRegionalLocalDto detailsDto);
/***
*@Description: 地区经济统计
*@Param:
*@return: com.dsk.common.core.domain.AjaxResult
*@Author: Dgm
*@date: 2023/5/18 10:25
*/
AjaxResult statisticsRegional(OpRegionalEconomicDataStatisticsRegionalDto dto);
/***
*@Description: 地区经济-分页列表
*@Param:
*@return: com.dsk.common.core.domain.AjaxResult
*@Author: Dgm
*@date: 2023/5/18 10:25
*/
AjaxResult regionalList(OpRegionalEconomicDataRegionalListDto dto);
/***
*@Description: 对比经济
*@Param:
*@return: com.dsk.common.core.domain.AjaxResult
*@Author: Dgm
*@date: 2023/5/18 10:25
*/
AjaxResult regionalCompare(OpRegionalEconomicDataStatisticsRegionalDto dto);
/***
*@Description: 地区经济-对比
*@Param:
*@return: com.dsk.common.core.domain.AjaxResult
*@Author: Dgm
*@date: 2023/5/18 10:25
*/
AjaxResult regionalMultipleCompare (OpRegionalEconomicRegionalCompareDto dto);
}
package com.dsk.jsk.service.service;
import com.dsk.system.domain.business.BusinessBacklog;
import com.dsk.system.domain.business.dto.BusinessBacklogListDto;
import com.dsk.system.domain.business.vo.BusinessBacklogListVo;
import java.util.List;
/**
* 项目工作待办Service接口
*
* @author llx
* @date 2023-05-17
*/
public interface IBusinessBacklogService
{
/**
* 查询项目工作待办
*
* @param id 项目工作待办主键
* @return 项目工作待办
*/
public BusinessBacklog selectBusinessBacklogById(Integer id);
/**
* 查询项目工作待办列表
*/
public List<BusinessBacklogListVo> selectBusinessBacklogList(BusinessBacklogListDto dto);
/**
* 新增项目工作待办
*
* @param businessBacklog 项目工作待办
* @return 结果
*/
public int insertBusinessBacklog(BusinessBacklog businessBacklog);
/**
* 修改项目工作待办
*
* @param businessBacklog 项目工作待办
* @return 结果
*/
public int updateBusinessBacklog(BusinessBacklog businessBacklog);
/**
* 批量删除项目工作待办
*
* @param ids 需要删除的项目工作待办主键集合
* @return 结果
*/
public int deleteBusinessBacklogByIds(Long[] ids);
/**
* 删除项目工作待办信息
*
* @param id 项目工作待办主键
* @return 结果
*/
public int deleteBusinessBacklogById(Long id);
Integer overdueCount(Integer businessId);
}
package com.dsk.jsk.service.service;
import com.dsk.common.core.domain.entity.BusinessFollowRecord;
import com.dsk.system.domain.business.dto.BusinessIdDto;
import com.dsk.system.domain.business.dto.BusinessListDto;
import com.dsk.system.domain.business.vo.BusinessListVo;
import java.util.List;
/**
* 项目跟进记录Service接口
*
* @author lxl
* @date 2023-05-17
*/
public interface IBusinessFollowRecordService
{
/**
* 查询项目跟进记录
*
* @param id 项目跟进记录主键
* @return 项目跟进记录
*/
public BusinessFollowRecord selectBusinessFollowRecordById(Long id);
/**
* 根据项目id查询项目跟进记录
*
* @param businessId 项目跟进记录
* @return 项目跟进记录集合
*/
public List<BusinessFollowRecord> selectBusinessFollowRecordList(BusinessIdDto businessId);
/**
* 分页查询跟进动态
*
* @param dto
* @return
*/
List<BusinessFollowRecord> allFollow(BusinessListDto dto);
/**
* 分页查询项目跟进记录列表
*
* @param businessFollowRecord 项目跟进记录
* @return 项目跟进记录集合
*/
public List<BusinessFollowRecord> businessFollowRecordPaging(BusinessFollowRecord businessFollowRecord);
/**
* 新增项目跟进记录
*
* @param businessFollowRecord 项目跟进记录
* @return 结果
*/
public int insertBusinessFollowRecord(BusinessFollowRecord businessFollowRecord);
/**
* 查询关联项目
* @param userId
* @return
*/
List<BusinessListVo> selectRelateProject (Integer userId);
/**
* 查询关联业主企业
* @param userId
* @return
*/
List<String> selectRelateCompany (Integer userId);
/**
* 修改项目跟进记录
*
* @param businessFollowRecord 项目跟进记录
* @return 结果
*/
public int updateBusinessFollowRecord(BusinessFollowRecord businessFollowRecord);
/**
* 批量删除项目跟进记录
*
* @param ids 需要删除的项目跟进记录主键集合
* @return 结果
*/
public int deleteBusinessFollowRecordByIds(Long[] ids);
/**
* 删除项目跟进记录信息
*
* @param id 项目跟进记录主键
* @return 结果
*/
public int deleteBusinessFollowRecordById(Long id);
}
package com.dsk.jsk.service.service;
import com.dsk.common.core.domain.AjaxResult;
import com.dsk.common.core.domain.entity.BusinessInfo;
import com.dsk.system.domain.business.dto.BusinessAddDto;
import com.dsk.system.domain.business.dto.BusinessListDto;
import com.dsk.system.domain.business.vo.BusinessLikeProjectNameListVo;
import com.dsk.system.domain.customer.dto.CustomerBusinessSearchDto;
import com.dsk.system.domain.customer.vo.CustomerBusinessListVo;
import com.dsk.system.domain.business.vo.BusinessBrowseVo;
import com.dsk.system.domain.business.vo.BusinessListVo;
import org.springframework.web.multipart.MultipartFile;
import java.util.List;
import java.util.Map;
/**
* 项目详情Service接口
*
* @date 2023-05-17
*/
public interface IBusinessInfoService
{
/**
* 查询项目详情
*
* @param id 项目详情主键
* @return 项目详情
*/
public BusinessInfo selectBusinessInfoById(Integer id);
/**
* 查询项目建设内容
*
* @param id 项目详情主键
* @return
*/
BusinessInfo getConstruction(Integer id);
/**
* 查询项目详情列表
*
* @param dto 项目详情
* @return 项目详情集合
*/
public List<BusinessListVo> selectBusinessInfoList(BusinessListDto dto);
/**
* 查询项目速览
* @param businessId
* @return
*/
BusinessBrowseVo browse(Integer businessId);
/**
* 查询所有项目名称(支持模糊查询)
* @return
*/
List<BusinessLikeProjectNameListVo> selectProjectName(BusinessListDto dto);
/**
* 项目批量导入
*/
AjaxResult batchUpload(MultipartFile file);
/**
* 新增项目详情
*
* @param dto 项目详情
* @return 结果
*/
public AjaxResult insertBusinessInfo(BusinessAddDto dto);
/**
* 修改项目详情
*
* @param businessInfo 项目详情
* @return 结果
*/
public int updateBusinessInfo(BusinessInfo businessInfo);
/**
* 批量删除项目详情
*
* @param ids 需要删除的项目详情主键集合
* @return 结果
*/
public int deleteBusinessInfoByIds(Long[] ids);
/**
* 删除项目详情信息
*
* @param id 项目详情主键
* @return 结果
*/
public int deleteBusinessInfoById(Long id);
int selectCountByStatusAndCustomerId(Integer status,String customerId);
List<CustomerBusinessListVo> selectCustomerBusinessList(CustomerBusinessSearchDto dto);
}
package com.dsk.jsk.service.service;
import com.dsk.common.core.domain.entity.BusinessLabel;
import com.dsk.system.domain.business.dto.BusinessIdDto;
import java.util.List;
/**
* 项目标签Service接口
*
* @date 2023-05-17
*/
public interface IBusinessLabelService
{
/**
* 查询项目标签
*
* @param id 项目标签主键
* @return 项目标签
*/
public BusinessLabel selectBusinessLabelById(Long id);
/**
* 查询项目标签列表
*
* @param businessLabel 项目标签
* @return 项目标签集合
*/
public List<BusinessLabel> selectBusinessLabelList(BusinessLabel businessLabel);
/**
* 新增项目标签
*
* @param businessLabel 项目标签
* @return 结果
*/
public int insertBusinessLabel(BusinessLabel businessLabel);
/**
* 修改项目标签
*
* @param businessLabel 项目标签
* @return 结果
*/
public int updateBusinessLabel(BusinessLabel businessLabel);
/**
* 批量删除项目标签
*
* @param ids 需要删除的项目标签主键集合
* @return 结果
*/
public int deleteBusinessLabelByIds(Long[] ids);
/**
* 删除项目标签信息
*
* @param dto 项目主键
* @return 结果
*/
public int deleteBusinessLabelById(BusinessIdDto dto);
}
package com.dsk.jsk.service.service;
import com.alibaba.fastjson2.JSONObject;
import com.dsk.common.core.domain.AjaxResult;
import com.dsk.system.domain.business.dto.BusinessSearchDto;
import com.dsk.system.domain.business.vo.BusinessAnalyzeVo;
import java.util.List;
import java.util.Map;
/**
* @author lcl
* @create 2023/8/14
*/
public interface IBusinessOverviewService {
Map<String, Object> statusStatistics(BusinessSearchDto dto);
List<BusinessAnalyzeVo> amountAnalyze(BusinessSearchDto dto);
List<BusinessAnalyzeVo> typeAnalyze(BusinessSearchDto dto);
List<BusinessAnalyzeVo> categoryAnalyze(BusinessSearchDto dto);
AjaxResult countGroupByProvince(JSONObject object);
AjaxResult rangByMoney(JSONObject object);
}
package com.dsk.jsk.service.service;
import com.dsk.common.core.domain.entity.BusinessRelateCompany;
import com.dsk.system.domain.business.dto.BusinessIdDto;
import java.util.List;
/**
* 项目关联单位Service接口
*
* @author lxl
* @date 2023-05-17
*/
public interface IBusinessRelateCompanyService
{
/**
* 查询项目关联单位
*
* @param id 项目关联单位主键
* @return 项目关联单位
*/
public BusinessRelateCompany selectBusinessRelateCompanyById(Long id);
/**
* 查询项目关联单位列表
*
* @param businessRelateCompany 项目关联单位
* @return 项目关联单位集合
*/
public List<BusinessRelateCompany> selectBusinessRelateCompanyList(BusinessRelateCompany businessRelateCompany);
/**
* 新增项目关联单位
*
* @param businessRelateCompany 项目关联单位
* @return 结果
*/
public int insertBusinessRelateCompany(BusinessRelateCompany businessRelateCompany);
/**
* 修改项目关联单位
*
* @param businessRelateCompany 项目关联单位
* @return 结果
*/
public int updateBusinessRelateCompany(BusinessRelateCompany businessRelateCompany);
/**
* 批量删除项目关联单位
*
* @param ids 需要删除的项目关联单位主键集合
* @return 结果
*/
public int deleteBusinessRelateCompanyByIds(Long[] ids);
/**
* 删除项目关联单位信息
*
* @param id 项目关联单位主键
* @return 结果
*/
public int deleteBusinessRelateCompanyById(Long id);
/**
* 查询关联单位角色
*/
List<String> companyRoleList(BusinessIdDto dto);
}
package com.dsk.jsk.service.service;
import com.dsk.common.core.domain.entity.BusinessUser;
import java.util.List;
/**
* 项目用户关联Service接口
*
* @author lxl
* @date 2023-05-17
*/
public interface IBusinessUserService
{
/**
* 查询项目用户关联
*
* @param id 项目用户关联主键
* @return 项目用户关联
*/
public BusinessUser selectBusinessUserById(Long id);
/**
* 查询项目用户关联列表
*
* @param businessUser 项目用户关联
* @return 项目用户关联集合
*/
public List<BusinessUser> selectBusinessUserList(BusinessUser businessUser);
/**
* 新增项目用户关联
*
* @param businessUser 项目用户关联
* @return 结果
*/
public int insertBusinessUser(BusinessUser businessUser);
/**
* 修改项目用户关联
*
* @param businessUser 项目用户关联
* @return 结果
*/
public int updateBusinessUser(BusinessUser businessUser);
/**
* 批量删除项目用户关联
*
* @param ids 需要删除的项目用户关联主键集合
* @return 结果
*/
public int deleteBusinessUserByIds(Long[] ids);
/**
* 删除项目用户关联信息
*
* @param id 项目用户关联主键
* @return 结果
*/
public int deleteBusinessUserById(Long id);
}
package com.dsk.jsk.service.service;
import com.dsk.system.domain.customer.ContactInfo;
import com.dsk.system.domain.customer.dto.ContactInfoSearchDto;
import com.dsk.system.domain.customer.vo.ContactInfoListVo;
import java.util.List;
/**
* 用户联系人(CustomerContact)表服务接口
*
* @author makejava
* @since 2023-07-25 17:18:05
*/
public interface IContactInfoService {
/**
* 查询数据列表
*/
List<ContactInfoListVo> selectList(ContactInfoSearchDto dto);
/**
* 通过ID查询单条数据
*
* @param id 主键
* @return 实例对象
*/
ContactInfo selectById(Long id);
/**
* 新增数据
*
* @param bean 实例对象
* @return 实例对象
*/
boolean insert(ContactInfo bean);
/**
* 修改数据
*
* @param bean 实例对象
* @return 实例对象
*/
boolean update(ContactInfo bean);
/**
* 通过主键删除数据
*
* @param id 主键
* @return 是否成功
*/
boolean deleteById(Long id);
}
package com.dsk.jsk.service.service;
import com.dsk.system.domain.customer.CustomerFollowRecord;
import com.dsk.system.domain.customer.dto.CustomerFollowRecordSearchDto;
import com.dsk.system.domain.customer.vo.CustomerFollowRecordListVo;
import java.util.List;
/**
* 客户跟进记录(CustomerFollowRecord)表服务接口
*
* @author makejava
* @since 2023-05-18 15:07:59
*/
public interface ICustomerFollowRecordService {
List<CustomerFollowRecordListVo> selectList(CustomerFollowRecordSearchDto dto);
boolean add(CustomerFollowRecord followRecord);
boolean del(Long id);
}
package com.dsk.jsk.service.service;
import com.dsk.system.domain.customer.dto.CustomerSearchDto;
import com.dsk.system.domain.customer.vo.CustomerAnalyzeVo;
import java.util.List;
import java.util.Map;
/**
* @author lcl
* @create 2023/8/15
*/
public interface ICustomerOverviewService {
Map<String, Object> statistics(CustomerSearchDto dto);
List<CustomerAnalyzeVo> cooperationTop(CustomerSearchDto dto);
List<Map<String, Object>> creditLevel(CustomerSearchDto dto);
}
package com.dsk.jsk.service.service;
import com.dsk.system.domain.customer.Customer;
import com.dsk.system.domain.customer.dto.CustomerBusinessSearchDto;
import com.dsk.system.domain.customer.dto.CustomerSearchDto;
import com.dsk.system.domain.customer.vo.*;
import java.util.List;
/**
* 客户信息表(Customer)表服务接口
*
* @author makejava
* @since 2023-05-16 09:28:00
*/
public interface ICustomerService {
List<CustomerListVo> selectList(CustomerSearchDto dto);
CustomerVo info(String customerId);
boolean add(Customer customer);
boolean edit(Customer customer);
List<Customer> selectUserList();
List<CustomerBusinessListVo> selectBusinessList(CustomerBusinessSearchDto dto);
List<CustomerStatusListVo> selectStatusList(List<String> uipIds);
List<CustomerStatusListVo> selectStatusListByCompanyName(List<String> companyNames);
// List<String> selectUipIdList(List<String> uipIds);
Integer status(String companyName);
boolean cancelClaim(String companyName);
boolean historyClaim(String companyName);
Customer selectByCompanyNameAndUserId(String companyName);
}
package com.dsk.jsk.service.service;
import java.util.List;
import com.dsk.system.domain.SysConfig;
/**
* 参数配置 服务层
*
* @author dsk
*/
public interface ISysConfigService
{
/**
* 查询参数配置信息
*
* @param configId 参数配置ID
* @return 参数配置信息
*/
public SysConfig selectConfigById(Long configId);
/**
* 根据键名查询参数配置信息
*
* @param configKey 参数键名
* @return 参数键值
*/
public String selectConfigByKey(String configKey);
/**
* 获取验证码开关
*
* @return true开启,false关闭
*/
public boolean selectCaptchaEnabled();
/**
* 查询参数配置列表
*
* @param config 参数配置信息
* @return 参数配置集合
*/
public List<SysConfig> selectConfigList(SysConfig config);
/**
* 新增参数配置
*
* @param config 参数配置信息
* @return 结果
*/
public int insertConfig(SysConfig config);
/**
* 修改参数配置
*
* @param config 参数配置信息
* @return 结果
*/
public int updateConfig(SysConfig config);
/**
* 批量删除参数信息
*
* @param configIds 需要删除的参数ID
*/
public void deleteConfigByIds(Long[] configIds);
/**
* 加载参数缓存数据
*/
public void loadingConfigCache();
/**
* 清空参数缓存数据
*/
public void clearConfigCache();
/**
* 重置参数缓存数据
*/
public void resetConfigCache();
/**
* 校验参数键名是否唯一
*
* @param config 参数信息
* @return 结果
*/
public boolean checkConfigKeyUnique(SysConfig config);
}
package com.dsk.jsk.service.service;
import java.util.List;
import com.dsk.common.core.domain.TreeSelect;
import com.dsk.common.core.domain.entity.SysDept;
/**
* 部门管理 服务层
*
* @author dsk
*/
public interface ISysDeptService
{
/**
* 查询部门管理数据
*
* @param dept 部门信息
* @return 部门信息集合
*/
public List<SysDept> selectDeptList(SysDept dept);
/**
* 查询部门树结构信息
*
* @param dept 部门信息
* @return 部门树信息集合
*/
public List<TreeSelect> selectDeptTreeList(SysDept dept);
/**
* 构建前端所需要树结构
*
* @param depts 部门列表
* @return 树结构列表
*/
public List<SysDept> buildDeptTree(List<SysDept> depts);
/**
* 构建前端所需要下拉树结构
*
* @param depts 部门列表
* @return 下拉树结构列表
*/
public List<TreeSelect> buildDeptTreeSelect(List<SysDept> depts);
/**
* 根据角色ID查询部门树信息
*
* @param roleId 角色ID
* @return 选中部门列表
*/
public List<Long> selectDeptListByRoleId(Long roleId);
/**
* 根据部门ID查询信息
*
* @param deptId 部门ID
* @return 部门信息
*/
public SysDept selectDeptById(Long deptId);
/**
* 根据ID查询所有子部门(正常状态)
*
* @param deptId 部门ID
* @return 子部门数
*/
public int selectNormalChildrenDeptById(Long deptId);
/**
* 是否存在部门子节点
*
* @param deptId 部门ID
* @return 结果
*/
public boolean hasChildByDeptId(Long deptId);
/**
* 查询部门是否存在用户
*
* @param deptId 部门ID
* @return 结果 true 存在 false 不存在
*/
public boolean checkDeptExistUser(Long deptId);
/**
* 校验部门名称是否唯一
*
* @param dept 部门信息
* @return 结果
*/
public boolean checkDeptNameUnique(SysDept dept);
/**
* 校验部门是否有数据权限
*
* @param deptId 部门id
*/
public void checkDeptDataScope(Long deptId);
/**
* 新增保存部门信息
*
* @param dept 部门信息
* @return 结果
*/
public int insertDept(SysDept dept);
/**
* 修改保存部门信息
*
* @param dept 部门信息
* @return 结果
*/
public int updateDept(SysDept dept);
/**
* 删除部门管理信息
*
* @param deptId 部门ID
* @return 结果
*/
public int deleteDeptById(Long deptId);
}
package com.dsk.jsk.service.service;
import java.util.List;
import com.dsk.common.core.domain.entity.SysDictData;
/**
* 字典 业务层
*
* @author dsk
*/
public interface ISysDictDataService
{
/**
* 根据条件分页查询字典数据
*
* @param dictData 字典数据信息
* @return 字典数据集合信息
*/
public List<SysDictData> selectDictDataList(SysDictData dictData);
/**
* 根据字典类型和字典键值查询字典数据信息
*
* @param dictType 字典类型
* @param dictValue 字典键值
* @return 字典标签
*/
public String selectDictLabel(String dictType, String dictValue);
/**
* 根据字典数据ID查询信息
*
* @param dictCode 字典数据ID
* @return 字典数据
*/
public SysDictData selectDictDataById(Long dictCode);
/**
* 批量删除字典数据信息
*
* @param dictCodes 需要删除的字典数据ID
*/
public void deleteDictDataByIds(Long[] dictCodes);
/**
* 新增保存字典数据信息
*
* @param dictData 字典数据信息
* @return 结果
*/
public int insertDictData(SysDictData dictData);
/**
* 修改保存字典数据信息
*
* @param dictData 字典数据信息
* @return 结果
*/
public int updateDictData(SysDictData dictData);
}
package com.dsk.jsk.service.service;
import java.util.List;
import com.dsk.common.core.domain.entity.SysDictData;
import com.dsk.common.core.domain.entity.SysDictType;
/**
* 字典 业务层
*
* @author dsk
*/
public interface ISysDictTypeService
{
/**
* 根据条件分页查询字典类型
*
* @param dictType 字典类型信息
* @return 字典类型集合信息
*/
public List<SysDictType> selectDictTypeList(SysDictType dictType);
/**
* 根据所有字典类型
*
* @return 字典类型集合信息
*/
public List<SysDictType> selectDictTypeAll();
/**
* 根据字典类型查询字典数据
*
* @param dictType 字典类型
* @return 字典数据集合信息
*/
public List<SysDictData> selectDictDataByType(String dictType);
/**
* 根据字典类型ID查询信息
*
* @param dictId 字典类型ID
* @return 字典类型
*/
public SysDictType selectDictTypeById(Long dictId);
/**
* 根据字典类型查询信息
*
* @param dictType 字典类型
* @return 字典类型
*/
public SysDictType selectDictTypeByType(String dictType);
/**
* 批量删除字典信息
*
* @param dictIds 需要删除的字典ID
*/
public void deleteDictTypeByIds(Long[] dictIds);
/**
* 加载字典缓存数据
*/
public void loadingDictCache();
/**
* 清空字典缓存数据
*/
public void clearDictCache();
/**
* 重置字典缓存数据
*/
public void resetDictCache();
/**
* 新增保存字典类型信息
*
* @param dictType 字典类型信息
* @return 结果
*/
public int insertDictType(SysDictType dictType);
/**
* 修改保存字典类型信息
*
* @param dictType 字典类型信息
* @return 结果
*/
public int updateDictType(SysDictType dictType);
/**
* 校验字典类型称是否唯一
*
* @param dictType 字典类型
* @return 结果
*/
public boolean checkDictTypeUnique(SysDictType dictType);
}
package com.dsk.jsk.service.service;
import java.util.List;
import com.dsk.system.domain.SysLogininfor;
/**
* 系统访问日志情况信息 服务层
*
* @author dsk
*/
public interface ISysLogininforService
{
/**
* 新增系统登录日志
*
* @param logininfor 访问日志对象
*/
public void insertLogininfor(SysLogininfor logininfor);
/**
* 查询系统登录日志集合
*
* @param logininfor 访问日志对象
* @return 登录记录集合
*/
public List<SysLogininfor> selectLogininforList(SysLogininfor logininfor);
/**
* 批量删除系统登录日志
*
* @param infoIds 需要删除的登录日志ID
* @return 结果
*/
public int deleteLogininforByIds(Long[] infoIds);
/**
* 清空系统登录日志
*/
public void cleanLogininfor();
}
package com.dsk.jsk.service.service;
import java.util.List;
import java.util.Set;
import com.dsk.common.core.domain.TreeSelect;
import com.dsk.common.core.domain.entity.SysMenu;
import com.dsk.system.domain.vo.RouterVo;
/**
* 菜单 业务层
*
* @author dsk
*/
public interface ISysMenuService
{
/**
* 根据用户查询系统菜单列表
*
* @param userId 用户ID
* @return 菜单列表
*/
public List<SysMenu> selectMenuList(Long userId);
/**
* 根据用户查询系统菜单列表
*
* @param menu 菜单信息
* @param userId 用户ID
* @return 菜单列表
*/
public List<SysMenu> selectMenuList(SysMenu menu, Long userId);
/**
* 根据用户ID查询权限
*
* @param userId 用户ID
* @return 权限列表
*/
public Set<String> selectMenuPermsByUserId(Long userId);
/**
* 根据角色ID查询权限
*
* @param roleId 角色ID
* @return 权限列表
*/
public Set<String> selectMenuPermsByRoleId(Long roleId);
/**
* 根据用户ID查询菜单树信息
*
* @param userId 用户ID
* @return 菜单列表
*/
public List<SysMenu> selectMenuTreeByUserId(Long userId);
/**
* 根据角色ID查询菜单树信息
*
* @param roleId 角色ID
* @return 选中菜单列表
*/
public List<Long> selectMenuListByRoleId(Long roleId);
/**
* 构建前端路由所需要的菜单
*
* @param menus 菜单列表
* @return 路由列表
*/
public List<RouterVo> buildMenus(List<SysMenu> menus);
/**
* 构建前端所需要树结构
*
* @param menus 菜单列表
* @return 树结构列表
*/
public List<SysMenu> buildMenuTree(List<SysMenu> menus);
/**
* 构建前端所需要下拉树结构
*
* @param menus 菜单列表
* @return 下拉树结构列表
*/
public List<TreeSelect> buildMenuTreeSelect(List<SysMenu> menus);
/**
* 根据菜单ID查询信息
*
* @param menuId 菜单ID
* @return 菜单信息
*/
public SysMenu selectMenuById(Long menuId);
/**
* 是否存在菜单子节点
*
* @param menuId 菜单ID
* @return 结果 true 存在 false 不存在
*/
public boolean hasChildByMenuId(Long menuId);
/**
* 查询菜单是否存在角色
*
* @param menuId 菜单ID
* @return 结果 true 存在 false 不存在
*/
public boolean checkMenuExistRole(Long menuId);
/**
* 新增保存菜单信息
*
* @param menu 菜单信息
* @return 结果
*/
public int insertMenu(SysMenu menu);
/**
* 修改保存菜单信息
*
* @param menu 菜单信息
* @return 结果
*/
public int updateMenu(SysMenu menu);
/**
* 删除菜单管理信息
*
* @param menuId 菜单ID
* @return 结果
*/
public int deleteMenuById(Long menuId);
/**
* 校验菜单名称是否唯一
*
* @param menu 菜单信息
* @return 结果
*/
public boolean checkMenuNameUnique(SysMenu menu);
}
package com.dsk.jsk.service.service;
import java.util.List;
import com.dsk.system.domain.SysNotice;
/**
* 公告 服务层
*
* @author dsk
*/
public interface ISysNoticeService
{
/**
* 查询公告信息
*
* @param noticeId 公告ID
* @return 公告信息
*/
public SysNotice selectNoticeById(Long noticeId);
/**
* 查询公告列表
*
* @param notice 公告信息
* @return 公告集合
*/
public List<SysNotice> selectNoticeList(SysNotice notice);
/**
* 新增公告
*
* @param notice 公告信息
* @return 结果
*/
public int insertNotice(SysNotice notice);
/**
* 修改公告
*
* @param notice 公告信息
* @return 结果
*/
public int updateNotice(SysNotice notice);
/**
* 删除公告信息
*
* @param noticeId 公告ID
* @return 结果
*/
public int deleteNoticeById(Long noticeId);
/**
* 批量删除公告信息
*
* @param noticeIds 需要删除的公告ID
* @return 结果
*/
public int deleteNoticeByIds(Long[] noticeIds);
}
package com.dsk.jsk.service.service;
import java.util.List;
import com.dsk.system.domain.SysOperLog;
/**
* 操作日志 服务层
*
* @author dsk
*/
public interface ISysOperLogService
{
/**
* 新增操作日志
*
* @param operLog 操作日志对象
*/
public void insertOperlog(SysOperLog operLog);
/**
* 查询系统操作日志集合
*
* @param operLog 操作日志对象
* @return 操作日志集合
*/
public List<SysOperLog> selectOperLogList(SysOperLog operLog);
/**
* 批量删除系统操作日志
*
* @param operIds 需要删除的操作日志ID
* @return 结果
*/
public int deleteOperLogByIds(Long[] operIds);
/**
* 查询操作日志详细
*
* @param operId 操作ID
* @return 操作日志对象
*/
public SysOperLog selectOperLogById(Long operId);
/**
* 清空操作日志
*/
public void cleanOperLog();
}
package com.dsk.jsk.service.service;
import java.util.List;
import com.dsk.system.domain.SysPost;
/**
* 岗位信息 服务层
*
* @author dsk
*/
public interface ISysPostService
{
/**
* 查询岗位信息集合
*
* @param post 岗位信息
* @return 岗位列表
*/
public List<SysPost> selectPostList(SysPost post);
/**
* 查询所有岗位
*
* @return 岗位列表
*/
public List<SysPost> selectPostAll();
/**
* 通过岗位ID查询岗位信息
*
* @param postId 岗位ID
* @return 角色对象信息
*/
public SysPost selectPostById(Long postId);
/**
* 根据用户ID获取岗位选择框列表
*
* @param userId 用户ID
* @return 选中岗位ID列表
*/
public List<Long> selectPostListByUserId(Long userId);
/**
* 校验岗位名称
*
* @param post 岗位信息
* @return 结果
*/
public boolean checkPostNameUnique(SysPost post);
/**
* 校验岗位编码
*
* @param post 岗位信息
* @return 结果
*/
public boolean checkPostCodeUnique(SysPost post);
/**
* 通过岗位ID查询岗位使用数量
*
* @param postId 岗位ID
* @return 结果
*/
public int countUserPostById(Long postId);
/**
* 删除岗位信息
*
* @param postId 岗位ID
* @return 结果
*/
public int deletePostById(Long postId);
/**
* 批量删除岗位信息
*
* @param postIds 需要删除的岗位ID
* @return 结果
*/
public int deletePostByIds(Long[] postIds);
/**
* 新增保存岗位信息
*
* @param post 岗位信息
* @return 结果
*/
public int insertPost(SysPost post);
/**
* 修改保存岗位信息
*
* @param post 岗位信息
* @return 结果
*/
public int updatePost(SysPost post);
}
package com.dsk.jsk.service.service;
import java.util.List;
import java.util.Set;
import com.dsk.common.core.domain.entity.SysRole;
import com.dsk.system.domain.SysUserRole;
/**
* 角色业务层
*
* @author dsk
*/
public interface ISysRoleService
{
/**
* 根据条件分页查询角色数据
*
* @param role 角色信息
* @return 角色数据集合信息
*/
public List<SysRole> selectRoleList(SysRole role);
/**
* 根据用户ID查询角色列表
*
* @param userId 用户ID
* @return 角色列表
*/
public List<SysRole> selectRolesByUserId(Long userId);
/**
* 根据用户ID查询角色权限
*
* @param userId 用户ID
* @return 权限列表
*/
public Set<String> selectRolePermissionByUserId(Long userId);
/**
* 查询所有角色
*
* @return 角色列表
*/
public List<SysRole> selectRoleAll();
/**
* 根据用户ID获取角色选择框列表
*
* @param userId 用户ID
* @return 选中角色ID列表
*/
public List<Long> selectRoleListByUserId(Long userId);
/**
* 通过角色ID查询角色
*
* @param roleId 角色ID
* @return 角色对象信息
*/
public SysRole selectRoleById(Long roleId);
/**
* 校验角色名称是否唯一
*
* @param role 角色信息
* @return 结果
*/
public boolean checkRoleNameUnique(SysRole role);
/**
* 校验角色权限是否唯一
*
* @param role 角色信息
* @return 结果
*/
public boolean checkRoleKeyUnique(SysRole role);
/**
* 校验角色是否允许操作
*
* @param role 角色信息
*/
public void checkRoleAllowed(SysRole role);
/**
* 校验角色是否有数据权限
*
* @param roleId 角色id
*/
public void checkRoleDataScope(Long roleId);
/**
* 通过角色ID查询角色使用数量
*
* @param roleId 角色ID
* @return 结果
*/
public int countUserRoleByRoleId(Long roleId);
/**
* 新增保存角色信息
*
* @param role 角色信息
* @return 结果
*/
public int insertRole(SysRole role);
/**
* 修改保存角色信息
*
* @param role 角色信息
* @return 结果
*/
public int updateRole(SysRole role);
/**
* 修改角色状态
*
* @param role 角色信息
* @return 结果
*/
public int updateRoleStatus(SysRole role);
/**
* 修改数据权限信息
*
* @param role 角色信息
* @return 结果
*/
public int authDataScope(SysRole role);
/**
* 通过角色ID删除角色
*
* @param roleId 角色ID
* @return 结果
*/
public int deleteRoleById(Long roleId);
/**
* 批量删除角色信息
*
* @param roleIds 需要删除的角色ID
* @return 结果
*/
public int deleteRoleByIds(Long[] roleIds);
/**
* 取消授权用户角色
*
* @param userRole 用户和角色关联信息
* @return 结果
*/
public int deleteAuthUser(SysUserRole userRole);
/**
* 批量取消授权用户角色
*
* @param roleId 角色ID
* @param userIds 需要取消授权的用户数据ID
* @return 结果
*/
public int deleteAuthUsers(Long roleId, Long[] userIds);
/**
* 批量选择授权用户角色
*
* @param roleId 角色ID
* @param userIds 需要删除的用户数据ID
* @return 结果
*/
public int insertAuthUsers(Long roleId, Long[] userIds);
}
package com.dsk.jsk.service.service;
import com.dsk.common.core.domain.model.LoginUser;
import com.dsk.system.domain.SysUserOnline;
/**
* 在线用户 服务层
*
* @author dsk
*/
public interface ISysUserOnlineService
{
/**
* 通过登录地址查询信息
*
* @param ipaddr 登录地址
* @param user 用户信息
* @return 在线用户信息
*/
public SysUserOnline selectOnlineByIpaddr(String ipaddr, LoginUser user);
/**
* 通过用户名称查询信息
*
* @param userName 用户名称
* @param user 用户信息
* @return 在线用户信息
*/
public SysUserOnline selectOnlineByUserName(String userName, LoginUser user);
/**
* 通过登录地址/用户名称查询信息
*
* @param ipaddr 登录地址
* @param userName 用户名称
* @param user 用户信息
* @return 在线用户信息
*/
public SysUserOnline selectOnlineByInfo(String ipaddr, String userName, LoginUser user);
/**
* 设置在线用户信息
*
* @param user 用户信息
* @return 在线用户
*/
public SysUserOnline loginUserToUserOnline(LoginUser user);
}
package com.dsk.jsk.service.service;
import java.util.List;
import com.dsk.common.core.domain.entity.SysUser;
/**
* 用户 业务层
*
* @author dsk
*/
public interface ISysUserService
{
/**
* 根据条件分页查询用户列表
*
* @param user 用户信息
* @return 用户信息集合信息
*/
public List<SysUser> selectUserList(SysUser user);
/**
* 根据条件分页查询已分配用户角色列表
*
* @param user 用户信息
* @return 用户信息集合信息
*/
public List<SysUser> selectAllocatedList(SysUser user);
/**
* 根据条件分页查询未分配用户角色列表
*
* @param user 用户信息
* @return 用户信息集合信息
*/
public List<SysUser> selectUnallocatedList(SysUser user);
/**
* 通过用户名查询用户
*
* @param userName 用户名
* @return 用户对象信息
*/
public SysUser selectUserByUserName(String userName);
/**
* 通过用户ID查询用户
*
* @param userId 用户ID
* @return 用户对象信息
*/
public SysUser selectUserById(Long userId);
/**
* 根据用户ID查询用户所属角色组
*
* @param userName 用户名
* @return 结果
*/
public String selectUserRoleGroup(String userName);
/**
* 根据用户ID查询用户所属岗位组
*
* @param userName 用户名
* @return 结果
*/
public String selectUserPostGroup(String userName);
/**
* 校验用户名称是否唯一
*
* @param user 用户信息
* @return 结果
*/
public boolean checkUserNameUnique(SysUser user);
/**
* 校验手机号码是否唯一
*
* @param user 用户信息
* @return 结果
*/
public boolean checkPhoneUnique(SysUser user);
/**
* 校验email是否唯一
*
* @param user 用户信息
* @return 结果
*/
public boolean checkEmailUnique(SysUser user);
/**
* 校验用户是否允许操作
*
* @param user 用户信息
*/
public void checkUserAllowed(SysUser user);
/**
* 校验用户是否有数据权限
*
* @param userId 用户id
*/
public void checkUserDataScope(Long userId);
/**
* 新增用户信息
*
* @param user 用户信息
* @return 结果
*/
public int insertUser(SysUser user);
/**
* 注册用户信息
*
* @param user 用户信息
* @return 结果
*/
public boolean registerUser(SysUser user);
/**
* 修改用户信息
*
* @param user 用户信息
* @return 结果
*/
public int updateUser(SysUser user);
/**
* 用户授权角色
*
* @param userId 用户ID
* @param roleIds 角色组
*/
public void insertUserAuth(Long userId, Long[] roleIds);
/**
* 修改用户状态
*
* @param user 用户信息
* @return 结果
*/
public int updateUserStatus(SysUser user);
/**
* 修改用户基本信息
*
* @param user 用户信息
* @return 结果
*/
public int updateUserProfile(SysUser user);
/**
* 修改用户头像
*
* @param userName 用户名
* @param avatar 头像地址
* @return 结果
*/
public boolean updateUserAvatar(String userName, String avatar);
/**
* 重置用户密码
*
* @param user 用户信息
* @return 结果
*/
public int resetPwd(SysUser user);
/**
* 重置用户密码
*
* @param userName 用户名
* @param password 密码
* @return 结果
*/
public int resetUserPwd(String userName, String password);
/**
* 通过用户ID删除用户
*
* @param userId 用户ID
* @return 结果
*/
public int deleteUserById(Long userId);
/**
* 批量删除用户信息
*
* @param userIds 需要删除的用户ID
* @return 结果
*/
public int deleteUserByIds(Long[] userIds);
/**
* 导入用户数据
*
* @param userList 用户数据列表
* @param isUpdateSupport 是否更新支持,如果已存在,则进行更新数据
* @param operName 操作用户
* @return 结果
*/
public String importUser(List<SysUser> userList, Boolean isUpdateSupport, String operName);
}
package com.dsk.jsk.service.service;
import com.dsk.common.core.domain.AjaxResult;
import com.dsk.search.domain.ComposeQueryDto;
/**
* @ClassName EconomicService
* @Description 区域企业业务层
* @Author Dgm
* @Date 2023/5/18 10:17
* @Version 1.00
*/
public interface RegionalEnterprisesService {
/***
*@Description: 区域企业分页列表
*@Param:
*@return: com.dsk.common.core.domain.AjaxResult
*@Author: Dgm
*@date: 2023/5/18 10:25
*/
AjaxResult enterprisePage(ComposeQueryDto compose) throws Exception;
}
package com.dsk.jsk.service.service;
import com.dsk.common.core.domain.AjaxResult;
import com.dsk.jsk.domain.*;
/**
* @ClassName EconomicService
* @Description 专项债项目业务层
* @Author Dgm
* @Date 2023/5/18 10:17
* @Version 1.00
*/
public interface SpecialPurposeBondsService {
/***
*@Description: 专项债项目分页列表
*@Param:
*@return: com.dsk.common.core.domain.AjaxResult
*@Author: Dgm
*@date: 2023/5/18 10:25
*/
AjaxResult page(SpecialPurposeBondsPageDto dto);
/***
*@Description: 专项债项目详情
*@Param:
*@return: com.dsk.common.core.domain.AjaxResult
*@Author: Dgm
*@date: 2023/5/18 10:25
*/
AjaxResult details(SpecialBondInformationDetailsDto detailsDto);
/***
*@Description: 项目类别统计
*@Param:
*@return: com.dsk.common.core.domain.AjaxResult
*@Author: Dgm
*@date: 2023/5/18 10:25
*/
AjaxResult bondStatistics(SpecialPurposeBondsDto dto);
/***
*@Description: 专项债分页列表
*@Param:
*@return: com.dsk.common.core.domain.AjaxResult
*@Author: Dgm
*@date: 2023/5/18 10:29
*/
AjaxResult bondPage(SpecialBondInformationPageDto pageDto);
}
package com.dsk.jsk.service.service;
import com.dsk.system.domain.SysRegion;
import java.util.List;
/**
* 行政区编码表(SysRegion)表服务接口
*
* @author makejava
* @since 2023-06-28 11:23:12
*/
public interface SysRegionService {
List<SysRegion> selectByParentId(Integer parentId);
}
package com.dsk.jsk.service.service;
import com.dsk.common.core.domain.AjaxResult;
import com.dsk.jsk.domain.UrbanInvestmentPlatformDto;
/**
* @ClassName EconomicService
* @Description 城投平台业务层
* @Author Dgm
* @Date 2023/5/18 10:17
* @Version 1.00
*/
public interface UrbanInvestmentPlatformService {
/***
*@Description: 城投平台分页列表
*@Param:
*@return: com.dsk.common.core.domain.AjaxResult
*@Author: Dgm
*@date: 2023/5/18 10:25
*/
AjaxResult page(UrbanInvestmentPlatformDto dto);
/***
*@Description: 城投平台详情
*@Param:
*@return: com.dsk.common.core.domain.AjaxResult
*@Author: Dgm
*@date: 2023/5/18 10:25
*/
AjaxResult details(String id);
/***
*@Description: 城投平台统计
*@Param:
*@return: com.dsk.common.core.domain.AjaxResult
*@Author: Dgm
*@date: 2023/5/18 10:29
*/
AjaxResult statistics(UrbanInvestmentPlatformDto pageDto);
}
package com.dsk.jsk.service.service.impl;
import cn.hutool.core.bean.BeanException;
import cn.hutool.core.util.ObjectUtil;
import com.dsk.system.domain.business.BusinessBacklog;
import com.dsk.common.exception.base.BaseException;
import com.dsk.common.utils.DateUtils;
import com.dsk.system.domain.business.dto.BusinessBacklogListDto;
import com.dsk.system.domain.business.vo.BusinessBacklogListVo;
import com.dsk.system.mapper.BusinessBacklogMapper;
import com.dsk.system.service.IBusinessBacklogService;
import lombok.extern.slf4j.Slf4j;
import org.springframework.scheduling.annotation.Scheduled;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;
import javax.annotation.Resource;
import java.util.Date;
import java.util.List;
/**
* 项目工作待办Service业务层处理
*
* @author lxl
* @date 2023-05-17
*/
@Service
@Slf4j
public class BusinessBacklogServiceImpl implements IBusinessBacklogService {
@Resource
private BusinessBacklogMapper businessBacklogMapper;
/**
* 查询项目工作待办
*
* @param id 项目工作待办主键
* @return 项目工作待办
*/
@Override
public BusinessBacklog selectBusinessBacklogById(Integer id) {
return businessBacklogMapper.selectBusinessBacklogById(id);
}
/**
* 查询项目工作待办列表
*
* @param dto 项目工作待办
* @return 项目工作待办
*/
@Override
public List<BusinessBacklogListVo> selectBusinessBacklogList(BusinessBacklogListDto dto) {
if (ObjectUtil.isEmpty(dto.getBusinessId())) {
throw new BeanException("项目id不能为空!");
}
if (ObjectUtil.isEmpty(dto.getState())) {
throw new BeanException("工作代办状态不能为空!");
}
switch (dto.getState()){
case 0:
dto.setStartTime(new Date());
break;
case 1:
break;
case 2:
dto.setState(0);
dto.setEndTime(new Date());
break;
default:
throw new BeanException("工作代办状态参数错误!");
}
return businessBacklogMapper.selectBusinessBacklogList(dto);
}
/**
* 新增项目工作待办
*
* @param businessBacklog 项目工作待办
* @return 结果
*/
@Override
@Transactional
public int insertBusinessBacklog(BusinessBacklog businessBacklog) {
if(ObjectUtil.isNotEmpty(businessBacklog.getDueTime())){
if (businessBacklog.getDueTime().before(new Date())) throw new BaseException("到期时间必须大于当前时间");
}
return businessBacklogMapper.insertBusinessBacklog(businessBacklog);
}
/**
* 修改项目工作待办
*
* @param businessBacklog 项目工作待办
* @return 结果
*/
@Override
@Transactional
public int updateBusinessBacklog(BusinessBacklog businessBacklog) {
if (ObjectUtil.isEmpty(businessBacklog.getId())) {
throw new BeanException("id不能为空!");
}
if (ObjectUtil.isEmpty(businessBacklog.getState())) {
throw new BeanException("状态不能为空!");
}
switch (businessBacklog.getState()) {
case 0:
businessBacklog.setFinishTime(null);
break;
case 1:
businessBacklog.setFinishTime(new Date());
break;
default:
throw new BeanException("状态参数错误!");
}
return businessBacklogMapper.updateBusinessBacklog(businessBacklog);
}
/**
* 批量删除项目工作待办
*
* @param ids 需要删除的项目工作待办主键
* @return 结果
*/
@Override
public int deleteBusinessBacklogByIds(Long[] ids) {
return businessBacklogMapper.deleteBusinessBacklogByIds(ids);
}
/**
* 删除项目工作待办信息
*
* @param id 项目工作待办主键
* @return 结果
*/
@Override
public int deleteBusinessBacklogById(Long id) {
return businessBacklogMapper.deleteBusinessBacklogById(id);
}
@Override
public Integer overdueCount(Integer businessId) {
return businessBacklogMapper.overdueCount(businessId);
}
}
package com.dsk.jsk.service.service.impl;
import com.dsk.common.annotation.DataScope;
import com.dsk.common.core.domain.entity.BusinessFollowRecord;
import com.dsk.common.utils.DateUtils;
import com.dsk.system.domain.business.dto.BusinessIdDto;
import com.dsk.system.domain.business.dto.BusinessListDto;
import com.dsk.system.domain.business.vo.BusinessListVo;
import com.dsk.system.mapper.BusinessFollowRecordMapper;
import com.dsk.system.service.IBusinessFollowRecordService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;
import java.util.List;
/**
* 项目跟进记录Service业务层处理
*
* @author lxl
* @date 2023-05-17
*/
@Service
public class BusinessFollowRecordServiceImpl implements IBusinessFollowRecordService
{
@Autowired
private BusinessFollowRecordMapper businessFollowRecordMapper;
/**
* 查询项目跟进记录
*
* @param id 项目跟进记录主键
* @return 项目跟进记录
*/
@Override
public BusinessFollowRecord selectBusinessFollowRecordById(Long id)
{
return businessFollowRecordMapper.selectBusinessFollowRecordById(id);
}
@Override
public List<BusinessFollowRecord> selectBusinessFollowRecordList(BusinessIdDto businessId)
{
return businessFollowRecordMapper.selectBusinessFollowRecordList(businessId);
}
@Override
@DataScope(userAlias = "u",deptAlias = "d")
public List<BusinessFollowRecord> allFollow(BusinessListDto dto) {
//userId不传值,就查询全部
// if (dto.getUserId() == null) {
// Long deptId = SecurityUtils.getLoginUser().getDeptId();
// if (deptId == null) throw new BaseException("请登录");
// dto.setDeptId(deptId.intValue());
// }
return businessFollowRecordMapper.allFollow(dto);
}
@Override
public List<BusinessFollowRecord> businessFollowRecordPaging(BusinessFollowRecord businessFollowRecord) {
return businessFollowRecordMapper.businessFollowRecordPaging(businessFollowRecord);
}
/**
* 新增项目跟进记录
*
* @param businessFollowRecord 项目跟进记录
* @return 结果
*/
@Override
@Transactional
public int insertBusinessFollowRecord(BusinessFollowRecord businessFollowRecord)
{
return businessFollowRecordMapper.insertBusinessFollowRecord(businessFollowRecord);
}
@Override
public List<BusinessListVo> selectRelateProject(Integer userId) {
return businessFollowRecordMapper.selectRelateProject(userId);
}
@Override
public List<String> selectRelateCompany(Integer userId) {
return businessFollowRecordMapper.selectRelateCompany(userId);
}
/**
* 修改项目跟进记录
*
* @param businessFollowRecord 项目跟进记录
* @return 结果
*/
@Override
public int updateBusinessFollowRecord(BusinessFollowRecord businessFollowRecord)
{
businessFollowRecord.setUpdateTime(DateUtils.getNowDate());
return businessFollowRecordMapper.updateBusinessFollowRecord(businessFollowRecord);
}
/**
* 批量删除项目跟进记录
*
* @param ids 需要删除的项目跟进记录主键
* @return 结果
*/
@Override
@Transactional
public int deleteBusinessFollowRecordByIds(Long[] ids)
{
return businessFollowRecordMapper.deleteBusinessFollowRecordByIds(ids);
}
/**
* 删除项目跟进记录信息
*
* @param id 项目跟进记录主键
* @return 结果
*/
@Override
public int deleteBusinessFollowRecordById(Long id)
{
return businessFollowRecordMapper.deleteBusinessFollowRecordById(id);
}
}
package com.dsk.jsk.service.service.impl;
import cn.hutool.core.bean.BeanUtil;
import cn.hutool.core.collection.CollectionUtil;
import cn.hutool.core.map.MapUtil;
import cn.hutool.core.util.ObjectUtil;
import com.alibaba.fastjson2.JSONObject;
import com.dsk.common.annotation.DataScope;
import com.dsk.common.config.ShuZhiHuaConfig;
import com.dsk.common.constant.HttpStatus;
import com.dsk.common.core.domain.AjaxResult;
import com.dsk.common.core.domain.entity.*;
import com.dsk.common.exception.ServiceException;
import com.dsk.common.exception.base.BaseException;
import com.dsk.common.utils.*;
import com.dsk.common.utils.file.FileUtils;
import com.dsk.system.domain.business.dto.BusinessAddDto;
import com.dsk.system.domain.business.dto.BusinessExcelDto;
import com.dsk.system.domain.business.dto.BusinessListDto;
import com.dsk.system.domain.business.vo.BusinessLikeProjectNameListVo;
import com.dsk.system.domain.customer.Customer;
import com.dsk.system.domain.customer.dto.CustomerBusinessSearchDto;
import com.dsk.system.domain.customer.vo.CustomerBusinessListVo;
import com.dsk.system.domain.customer.vo.CustomerVo;
import com.dsk.system.domain.business.vo.BusinessBrowseVo;
import com.dsk.system.domain.business.vo.BusinessLabelVo;
import com.dsk.system.domain.business.vo.BusinessListVo;
import com.dsk.system.dskService.EnterpriseService;
import com.dsk.system.mapper.BusinessInfoMapper;
import com.dsk.system.mapper.BusinessLabelMapper;
import com.dsk.system.mapper.BusinessRelateCompanyMapper;
import com.dsk.system.mapper.BusinessUserMapper;
import com.dsk.system.service.IBusinessInfoService;
import com.dsk.system.service.ICustomerService;
import lombok.extern.slf4j.Slf4j;
import org.apache.commons.collections4.CollectionUtils;
import org.apache.commons.collections4.MapUtils;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;
import org.springframework.web.multipart.MultipartFile;
import javax.annotation.Resource;
import java.util.*;
/**
* 项目详情Service业务层处理
*
* @author lxl
* @date 2023-05-17
*/
@Service
@Slf4j
public class BusinessInfoServiceImpl implements IBusinessInfoService {
@Resource
private BusinessInfoMapper businessInfoMapper;
@Resource
private BusinessUserMapper businessUserMapper;
@Resource
private BusinessLabelMapper businessLabelMapper;
@Resource
private ReadBusinessInfoExcel readBusinessInfoExcel;
@Resource
private BusinessRelateCompanyMapper relateCompanyMapper;
@Resource
private DskOpenApiUtil dskOpenApiUtil;
@Autowired
private ICustomerService customerService;
@Autowired
private EnterpriseService enterpriseService;
/**
* 查询项目详情
*
* @param id 项目详情主键
* @return 项目详情
*/
@Override
public BusinessInfo selectBusinessInfoById(Integer id) {
return businessInfoMapper.selectBusinessInfoById(id);
}
@Override
public BusinessInfo getConstruction(Integer id) {
BusinessInfo businessInfo = businessInfoMapper.getConstruction(id);
return ObjectUtil.isEmpty(businessInfo) ? new BusinessInfo() : businessInfo;
}
/**
* 查询项目详情列表
*
* @param dto 项目详情
* @return 项目详情
*/
@Override
@DataScope(deptAlias = "d", userAlias = "u")
public List<BusinessListVo> selectBusinessInfoList(BusinessListDto dto) {
dto.setUserId(SecurityUtils.getUserId());
List<BusinessListVo> businessListVos = businessInfoMapper.selectBusinessInfoList(dto);
if (!CollectionUtils.isEmpty(businessListVos) && ObjectUtil.isNotEmpty(dto.getProjectName())) {
for (BusinessListVo vo : businessListVos) {
vo.setProjectName(StringUtils.markInRed(vo.getProjectName(), dto.getProjectName()));
vo.setOwnerCompany(StringUtils.markInRed(vo.getOwnerCompany(), dto.getProjectName()));
}
}
return businessListVos;
}
@Override
public BusinessBrowseVo browse(Integer businessId) {
BusinessBrowseVo businessBrowseVo = new BusinessBrowseVo();
//查询项目基本信息
BusinessInfo businessInfo = businessInfoMapper.selectBusinessInfoById(businessId);
if (ObjectUtil.isNotEmpty(businessInfo)) BeanUtil.copyProperties(businessInfo, businessBrowseVo);
//商务团队
businessBrowseVo.setTeam(businessUserMapper.selectCreatorByBusinessId(businessId));
//查询是否是项目创建人
Long userId = SecurityUtils.getLoginUser().getUserId();
if (userId == null) throw new BaseException("请登录");
Integer founder = businessUserMapper.selectFounder(businessId, userId);
businessBrowseVo.setIsFounder(founder == null ? 0 : founder);
//查询项目标签
List<BusinessLabel> labels = businessLabelMapper.selectBusinessLabelList(new BusinessLabel(businessId));
String labelList = CollectionUtil.isEmpty(labels) ? null : JSONObject.toJSONString(BeanUtil.copyToList(labels, BusinessLabelVo.class));
businessBrowseVo.setLabelList(labelList);
//相关数据统计
BusinessBrowseVo total = businessInfoMapper.selectTotal(businessId);
businessBrowseVo.setBacklogCount(total.getBacklogCount());
businessBrowseVo.setContactsCount(total.getContactsCount());
businessBrowseVo.setFollowRecordCount(total.getFollowRecordCount());
businessBrowseVo.setRelateCompanyCount(total.getRelateCompanyCount());
//资料文档统计
businessBrowseVo.setFileCount(FileUtils.getAllFileNames(ShuZhiHuaConfig.getProfile() + businessId).size());
return businessBrowseVo;
}
@Override
public List<BusinessLikeProjectNameListVo> selectProjectName(BusinessListDto dto) {
// List<BusinessLikeProjectNameListVo> vos = businessInfoMapper.selectProjectName(dto);
List<BusinessLikeProjectNameListVo> vos = new ArrayList<>();
try {
Map<String, Object> result = dskOpenApiUtil.requestBody("/nationzj/jskBid/news/findByName", toRequestMap(dto));
if (ObjectUtil.isNotEmpty(result.get("data"))) {
List<Map<String, Object>> list = (List<Map<String, Object>>) BeanUtil.beanToMap(result.get("data")).get("list");
if (!CollectionUtils.isEmpty(list)) {
for (Map<String, Object> map : list) {
BusinessLikeProjectNameListVo vo = new BusinessLikeProjectNameListVo();
vo.setProjectName(StringUtils.markInRed(MapUtil.getStr(map, "projectName"), dto.getProjectName()));
vo.setCompanyName(MapUtil.getStr(map, "tenderee"));
if (null!=map.get("projectContractAmount")&&ObjectUtil.isNotEmpty(map.get("projectContractAmount"))){
vo.setInvestmentAmount(MapUtil.getDouble(map, "projectContractAmount"));
}
// vo.setProjectType(MapUtil.getStr(map, "projectCategory"));
//项目阶段
vo.setProjectStage(MapUtil.getStr(map, "tenderStage"));
//项目类别
vo.setProjectCategory(MapUtil.getStr(map, "projectCategory"));
vos.add(vo);
}
}
}
} catch (Exception e) {
log.error("模糊查询项目名称调用失败!",e);
}
return vos;
}
private Map<String, Object> toRequestMap(BusinessListDto dto) {
Map<String, Object> page = new HashMap<>();
page.put("page", 1);
page.put("limit", 20);
Map<String, Object> map = new HashMap<>();
map.put("keyword", dto.getProjectName());
map.put("page", page);
return map;
}
@Override
public AjaxResult batchUpload(MultipartFile file) {
//获取当前登录用户id
Long userId = SecurityUtils.getLoginUser().getUserId();
if (userId == null) return AjaxResult.error("请登录");
int row = 3;//起始行数
int rowSuccess = 0;//成功条数
Integer errorCount = 0;//失败条数
List<String> result = new LinkedList();//导入结果汇总
List<BusinessExcelDto> businessInfoList = readBusinessInfoExcel.getExcelInfo(file);
if (CollectionUtil.isEmpty(businessInfoList)) return AjaxResult.error("文档中无项目信息,请按照模板文档格式上传");
for (BusinessExcelDto businessInfo : businessInfoList) {
//查询已有的项目名称
Integer count = businessInfoMapper.isRepetitionProjectName(businessInfo.getProjectName(), userId, businessInfo.getOwnerCompany());
row++;
if (count > 0) {
//如果存在,跳过该项目,不保存
// result.add("第" + row + "行的" + businessInfo.getProjectName() + "的项目已存在,跳过该项目,保存下一条");
log.info("第" + row + "行的" + businessInfo.getProjectName() + "的项目已存在,跳过该项目,保存下一条");
errorCount++;
} else {
//保存到数据库
BusinessAddDto businessAddDto = new BusinessAddDto();
BeanUtil.copyProperties(businessInfo, businessAddDto);
businessAddDto.setUserId(userId);
AjaxResult add = insertBusinessInfo(businessAddDto);
if (add.get("code").equals(HttpStatus.SUCCESS)) rowSuccess++;
}
}
result.add("导入项目成功条数" + rowSuccess);
result.add("导入项目去重条数" + errorCount);
AjaxResult success = AjaxResult.success(String.join(",", result));
success.put("successCount", rowSuccess);
return success;
}
/**
* 新增项目详情
*
* @param dto 项目详情
* @return 结果
*/
@Override
@Transactional
public AjaxResult insertBusinessInfo(BusinessAddDto dto) {
//新增前查询是否已存在
int count = businessInfoMapper.isRepetitionProjectName(dto.getProjectName(), dto.getUserId(), dto.getOwnerCompany());
if (count > 0) return AjaxResult.error("项目名称已存在");
//判断资金Double类型的位数
if (dto.getInvestmentAmount() != null) {
int front = CheckUtils.checkIntegerPlaces(dto.getInvestmentAmount());
int later = CheckUtils.checkDecimalPlaces(dto.getInvestmentAmount());
if (front > 9) return AjaxResult.error("小数点前最多支持9位");
if (later > 6) return AjaxResult.error("小数点后最多支持6位");
}
//新增项目主信息
BusinessInfo businessInfo = new BusinessInfo();
BeanUtil.copyProperties(dto, businessInfo);
CustomerVo vo = new CustomerVo();
if (ObjectUtil.isNotEmpty(dto.getCustomerId())) {
vo = customerService.info(dto.getCustomerId());
} else {
Customer verifyCustomer = customerService.selectByCompanyNameAndUserId(dto.getOwnerCompany());
if (ObjectUtil.isNotEmpty(verifyCustomer)) {
BeanUtil.copyProperties(verifyCustomer, vo);
} else {
vo.setCompanyName(dto.getOwnerCompany());
customerService.add(vo);
}
businessInfo.setCustomerId(vo.getCustomerId());
}
businessInfo.setConstructionUnit(vo.getCompanyName());
businessInfo.setConstructionUnitUipId(vo.getUipId());
businessInfo.setConstructionUnitCid(vo.getCompanyId());
businessInfo.setConstructionPrincipal(vo.getLegalPerson());
int addBusiness = businessInfoMapper.insertBusinessInfo(businessInfo);
if (addBusiness > 0) {
//获取登陆用户的部门id
//新增用户-项目关系信息
int addbusinessUser = businessUserMapper.insertBusinessUser(new BusinessUser(businessInfo.getId(), SecurityUtils.getDeptId(), dto.getUserId(), 1));
if (addbusinessUser == 0) {
throw new ServiceException("项目关系信息添加失败!");
}
}
int i = relateCompanyMapper.insertBusinessRelateCompany(dealwithCustomer(businessInfo));
if (i == 0) {
throw new ServiceException("业主单位信息添加失败!");
}
return AjaxResult.success();
}
/**
* 修改项目详情
*
* @param businessInfo 项目详情
* @return 结果
*/
@Override
@Transactional
public int updateBusinessInfo(BusinessInfo businessInfo) {
if (ObjectUtil.isEmpty(businessInfo.getId())) {
throw new BaseException("项目id不能为空!");
}
//判断资金Double类型的位数
if (ObjectUtil.isNotEmpty(businessInfo.getInvestmentAmount())) {
int front = CheckUtils.checkIntegerPlaces(businessInfo.getInvestmentAmount());
int later = CheckUtils.checkDecimalPlaces(businessInfo.getInvestmentAmount());
if (front > 9) throw new BaseException("500", "小数点前最多支持9位");
if (later > 6) throw new BaseException("500", "小数点后最多支持6位");
}
if (StringUtils.isNotEmpty(businessInfo.getConstructionPhone()) && StringUtils.isNotEmpty(businessInfo.getSupervisorPhone())) {
if (!CheckUtils.isPhone(businessInfo.getConstructionPhone()) || !CheckUtils.isPhone(businessInfo.getSupervisorPhone()))
throw new BaseException("500", "请输入正确的电话号码");
}
//查询企业的城投id和建设库id
BusinessRelateCompany relateCompany = relateCompanyMapper.selectByProprietor(businessInfo.getId());
if (ObjectUtil.isNotEmpty(businessInfo.getConstructionUnit())) {
Map<String, Object> map = enterpriseService.getCidAndUipIdByCompanyName(businessInfo.getConstructionUnit());
businessInfo.setConstructionUnitUipId(MapUtils.getString(map, "uipId"));
businessInfo.setConstructionUnitCid(MapUtils.getInteger(map, "companyId"));
//相关企业
if (ObjectUtil.isEmpty(relateCompany)) {
relateCompanyMapper.insertBusinessRelateCompany(dealwithCustomer(businessInfo));
}
if (ObjectUtil.isNotEmpty(relateCompany) && !businessInfo.getConstructionUnit().equals(relateCompany.getCompanyName())) {
relateCompany.setCompanyId(businessInfo.getConstructionUnitCid());
relateCompany.setCompanyUipId(businessInfo.getConstructionUnitUipId());
relateCompany.setCompanyName(businessInfo.getConstructionUnit());
relateCompanyMapper.updateBusinessRelateCompany(relateCompany);
}
}
if (ObjectUtil.isNotEmpty(relateCompany) &&
(ObjectUtil.isNotEmpty(businessInfo.getConstructionPhone())
|| ObjectUtil.isNotEmpty(businessInfo.getConstructionPrincipal()))) {
relateCompany.setPhone(businessInfo.getConstructionPhone());
relateCompany.setResponsiblePerson(businessInfo.getConstructionPrincipal());
relateCompanyMapper.updateBusinessRelateCompany(relateCompany);
}
return businessInfoMapper.updateBusinessInfo(businessInfo);
}
/**
* 批量删除项目
* 项目关联的其他所有表数据一并删除
*
* @param ids 需要删除的项目详情主键
* @return 结果
*/
@Override
@Transactional
public int deleteBusinessInfoByIds(Long[] ids) {
//删除项目详情,用户关联项目,项目工作代办,项目联系人,项目跟进记录,项目标签,项目相关企业
int deleteBusiness = businessInfoMapper.deleteBusinessInfoByIds(ids);
//删除项目上传的文件
for (Long id : ids) {
try {
FileUtils.delFolder(ShuZhiHuaConfig.getUploadPath() + id);
} catch (Exception e) {
e.printStackTrace();
}
}
return deleteBusiness;
}
/**
* 删除项目详情信息
*
* @param id 项目详情主键
* @return 结果
*/
@Override
public int deleteBusinessInfoById(Long id) {
return businessInfoMapper.deleteBusinessInfoById(id);
}
/**
* 查询项目数量
*
* @param status 项目状态
* @param customerId 客户id
* @return 项目数量
*/
@Override
public int selectCountByStatusAndCustomerId(Integer status, String customerId) {
return businessInfoMapper.selectCountByStatusAndCustomerId(status, customerId);
}
@Override
public List<CustomerBusinessListVo> selectCustomerBusinessList(CustomerBusinessSearchDto dto) {
return businessInfoMapper.selectCustomerBusinessList(dto);
}
private BusinessRelateCompany dealwithCustomer(BusinessInfo bean) {
BusinessRelateCompany relateCompany = new BusinessRelateCompany();
relateCompany.setBusinessId(bean.getId());
relateCompany.setCompanyId(bean.getConstructionUnitCid());
relateCompany.setCompanyUipId(bean.getConstructionUnitUipId());
relateCompany.setCompanyName(bean.getConstructionUnit());
relateCompany.setPhone(bean.getConstructionPhone());
relateCompany.setCompanyRole("招采单位");
relateCompany.setResponsiblePerson(bean.getConstructionPrincipal());
relateCompany.setIsProprietor(1);
relateCompany.setRemark("业主单位");
return relateCompany;
}
}
package com.dsk.jsk.service.service.impl;
import java.util.List;
import com.dsk.common.core.domain.entity.BusinessLabel;
import com.dsk.common.utils.DateUtils;
import com.dsk.system.domain.business.dto.BusinessIdDto;
import com.dsk.system.mapper.BusinessLabelMapper;
import com.dsk.system.service.IBusinessLabelService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;
import javax.annotation.Resource;
/**
* 项目标签Service业务层处理
*
* @date 2023-05-17
*/
@Service
public class BusinessLabelServiceImpl implements IBusinessLabelService
{
@Resource
private BusinessLabelMapper businessLabelMapper;
/**
* 查询项目标签
*
* @param id 项目标签主键
* @return 项目标签
*/
@Override
public BusinessLabel selectBusinessLabelById(Long id)
{
return businessLabelMapper.selectBusinessLabelById(id);
}
/**
* 查询项目标签列表
*
* @param businessLabel 项目标签
* @return 项目标签
*/
@Override
public List<BusinessLabel> selectBusinessLabelList(BusinessLabel businessLabel)
{
return businessLabelMapper.selectBusinessLabelList(businessLabel);
}
/**
* 新增项目标签
*
* @param businessLabel 项目标签
* @return 结果
*/
@Override
@Transactional
public int insertBusinessLabel(BusinessLabel businessLabel)
{
businessLabel.setCreateTime(DateUtils.getNowDate());
return businessLabelMapper.insertBusinessLabel(businessLabel);
}
/**
* 修改项目标签
*
* @param businessLabel 项目标签
* @return 结果
*/
@Override
public int updateBusinessLabel(BusinessLabel businessLabel)
{
businessLabel.setUpdateTime(DateUtils.getNowDate());
return businessLabelMapper.updateBusinessLabel(businessLabel);
}
/**
* 批量删除项目标签
*
* @param ids 需要删除的项目标签主键
* @return 结果
*/
@Override
public int deleteBusinessLabelByIds(Long[] ids)
{
return businessLabelMapper.deleteBusinessLabelByIds(ids);
}
/**
* 删除项目标签信息
*
* @param dto 项目主键
* @return 结果
*/
@Override
@Transactional
public int deleteBusinessLabelById(BusinessIdDto dto)
{
return businessLabelMapper.deleteBusinessLabelById(dto);
}
}
package com.dsk.jsk.service.service.impl;
import cn.hutool.core.bean.BeanUtil;
import com.alibaba.fastjson2.JSONObject;
import com.dsk.common.annotation.DataScope;
import com.dsk.common.core.domain.AjaxResult;
import com.dsk.common.utils.DskOpenApiUtil;
import com.dsk.system.domain.business.dto.BusinessSearchDto;
import com.dsk.system.domain.business.vo.BusinessAnalyzeVo;
import com.dsk.system.mapper.BusinessInfoMapper;
import com.dsk.system.service.IBusinessOverviewService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import javax.annotation.Resource;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
/**
* @author lcl
* @create 2023/8/14
*/
@Service
public class BusinessOverviewServiceImpl implements IBusinessOverviewService {
@Resource
private BusinessInfoMapper businessInfoMapper;
@Autowired
private DskOpenApiUtil dskOpenApiUtil;
@Override
@DataScope(userAlias = "u",deptAlias = "d")
public Map<String, Object> statusStatistics(BusinessSearchDto dto) {
Map<String, Object> resultMap = new HashMap<>();
//总
resultMap.put("totalCount",businessInfoMapper.selectCountByStatus(dto));
//储备
dto.setStatus(0);
resultMap.put("reserveCount",businessInfoMapper.selectCountByStatus(dto));
//跟进
dto.setStatus(1);
resultMap.put("followUpCount",businessInfoMapper.selectCountByStatus(dto));
//中标(已合作)
dto.setStatus(2);
resultMap.put("bidCount",businessInfoMapper.selectCountByStatus(dto));
return resultMap;
}
@Override
@DataScope(userAlias = "u",deptAlias = "d")
public List<BusinessAnalyzeVo> amountAnalyze(BusinessSearchDto dto) {
return businessInfoMapper.selectAmountAnalyze(dto);
}
@Override
@DataScope(userAlias = "u",deptAlias = "d")
public List<BusinessAnalyzeVo> typeAnalyze(BusinessSearchDto dto) {
return businessInfoMapper.selectTypeAnalyze(dto);
}
@Override
@DataScope(userAlias = "u",deptAlias = "d")
public List<BusinessAnalyzeVo> categoryAnalyze(BusinessSearchDto dto) {
return businessInfoMapper.selectCategoryAnalyze(dto);
}
@Override
public AjaxResult countGroupByProvince(JSONObject object) {
Map<String, Object> map = dskOpenApiUtil.requestBody("/nationzj/marketAnalysis/project/countGroupByProvince", object);
return BeanUtil.toBean(map, AjaxResult.class);
}
@Override
public AjaxResult rangByMoney(JSONObject object) {
Map<String, Object> map = dskOpenApiUtil.requestBody("/nationzj/marketAnalysis/project/rangByMoney", object);
return BeanUtil.toBean(map, AjaxResult.class);
}
}
package com.dsk.jsk.service.service.impl;
import cn.hutool.core.util.ObjectUtil;
import com.baomidou.mybatisplus.core.toolkit.Wrappers;
import com.dsk.common.core.domain.entity.BusinessRelateCompany;
import com.dsk.common.exception.base.BaseException;
import com.dsk.common.utils.CheckUtils;
import com.dsk.common.utils.DateUtils;
import com.dsk.system.domain.business.dto.BusinessIdDto;
import com.dsk.system.dskService.EnterpriseService;
import com.dsk.system.mapper.BusinessRelateCompanyMapper;
import com.dsk.system.service.IBusinessRelateCompanyService;
import org.apache.commons.collections4.MapUtils;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;
import javax.annotation.Resource;
import java.util.List;
import java.util.Map;
import java.util.stream.Collectors;
/**
* 项目关联单位Service业务层处理
*
* @author lxl
* @date 2023-05-17
*/
@Service
public class BusinessRelateCompanyServiceImpl implements IBusinessRelateCompanyService {
@Resource
private BusinessRelateCompanyMapper businessRelateCompanyMapper;
@Autowired
private EnterpriseService enterpriseService;
/**
* 查询项目关联单位
*
* @param id 项目关联单位主键
* @return 项目关联单位
*/
@Override
public BusinessRelateCompany selectBusinessRelateCompanyById(Long id) {
return businessRelateCompanyMapper.selectBusinessRelateCompanyById(id);
}
/**
* 查询项目关联单位列表
*
* @param businessRelateCompany 项目关联单位
* @return 项目关联单位
*/
@Override
public List<BusinessRelateCompany> selectBusinessRelateCompanyList(BusinessRelateCompany businessRelateCompany) {
return businessRelateCompanyMapper.selectBusinessRelateCompanyList(businessRelateCompany);
}
/**
* 新增项目关联单位
*
* @param businessRelateCompany 项目关联单位
* @return 结果
*/
@Override
@Transactional
public int insertBusinessRelateCompany(BusinessRelateCompany businessRelateCompany) {
if (ObjectUtil.isNotEmpty(businessRelateCompany.getPhone()) && !CheckUtils.isPhone(businessRelateCompany.getPhone())) {
throw new BaseException("500", "请输入正确的电话号码");
}
//查询企业的城投id和建设库id
Map<String, Object> map = enterpriseService.getCidAndUipIdByCompanyName(businessRelateCompany.getCompanyName());
businessRelateCompany.setCompanyUipId(MapUtils.getString(map, "uipId", null));
businessRelateCompany.setCompanyId(MapUtils.getInteger(map, "companyId", null));
return businessRelateCompanyMapper.insertBusinessRelateCompany(businessRelateCompany);
}
/**
* 修改项目关联单位
*
* @param businessRelateCompany 项目关联单位
* @return 结果
*/
@Override
@Transactional
public int updateBusinessRelateCompany(BusinessRelateCompany businessRelateCompany) {
if (ObjectUtil.isNotEmpty(businessRelateCompany.getPhone()) && !CheckUtils.isPhone(businessRelateCompany.getPhone())) {
throw new BaseException("500", "请输入正确的电话号码");
}
//查询企业的城投id和建设库id
Map<String, Object> map = enterpriseService.getCidAndUipIdByCompanyName(businessRelateCompany.getCompanyName());
businessRelateCompany.setCompanyUipId(MapUtils.getString(map, "uipId", null));
businessRelateCompany.setCompanyId(MapUtils.getInteger(map, "companyId", null));
return businessRelateCompanyMapper.updateBusinessRelateCompany(businessRelateCompany);
}
/**
* 批量删除项目关联单位
*
* @param ids 需要删除的项目关联单位主键
* @return 结果
*/
@Override
public int deleteBusinessRelateCompanyByIds(Long[] ids) {
return businessRelateCompanyMapper.deleteBusinessRelateCompanyByIds(ids);
}
/**
* 删除项目关联单位信息
*
* @param id 项目关联单位主键
* @return 结果
*/
@Override
public int deleteBusinessRelateCompanyById(Long id) {
return businessRelateCompanyMapper.deleteBusinessRelateCompanyById(id);
}
@Override
public List<String> companyRoleList(BusinessIdDto dto) {
List<BusinessRelateCompany> roleList = businessRelateCompanyMapper.selectList(Wrappers.<BusinessRelateCompany>lambdaQuery()
.select(BusinessRelateCompany::getCompanyRole)
.eq(BusinessRelateCompany::getBusinessId, dto.getBusinessId())
.groupBy(BusinessRelateCompany::getCompanyRole)
.orderByDesc(BusinessRelateCompany::getCreateTime));
return roleList.stream().map(p -> p.getCompanyRole()).collect(Collectors.toList());
}
}
package com.dsk.jsk.service.service.impl;
import java.util.List;
import com.dsk.common.core.domain.entity.BusinessUser;
import com.dsk.common.utils.DateUtils;
import com.dsk.system.mapper.BusinessUserMapper;
import com.dsk.system.service.IBusinessUserService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
/**
* 项目用户关联Service业务层处理
*
* @author lxl
* @date 2023-05-17
*/
@Service
public class BusinessUserServiceImpl implements IBusinessUserService
{
@Autowired
private BusinessUserMapper businessUserMapper;
/**
* 查询项目用户关联
*
* @param id 项目用户关联主键
* @return 项目用户关联
*/
@Override
public BusinessUser selectBusinessUserById(Long id)
{
return businessUserMapper.selectBusinessUserById(id);
}
/**
* 查询项目用户关联列表
*
* @param businessUser 项目用户关联
* @return 项目用户关联
*/
@Override
public List<BusinessUser> selectBusinessUserList(BusinessUser businessUser)
{
return businessUserMapper.selectBusinessUserList(businessUser);
}
/**
* 新增项目用户关联
*
* @param businessUser 项目用户关联
* @return 结果
*/
@Override
public int insertBusinessUser(BusinessUser businessUser)
{
businessUser.setCreateTime(DateUtils.getNowDate());
return businessUserMapper.insertBusinessUser(businessUser);
}
/**
* 修改项目用户关联
*
* @param businessUser 项目用户关联
* @return 结果
*/
@Override
public int updateBusinessUser(BusinessUser businessUser)
{
businessUser.setUpdateTime(DateUtils.getNowDate());
return businessUserMapper.updateBusinessUser(businessUser);
}
/**
* 批量删除项目用户关联
*
* @param ids 需要删除的项目用户关联主键
* @return 结果
*/
@Override
public int deleteBusinessUserByIds(Long[] ids)
{
return businessUserMapper.deleteBusinessUserByIds(ids);
}
/**
* 删除项目用户关联信息
*
* @param id 项目用户关联主键
* @return 结果
*/
@Override
public int deleteBusinessUserById(Long id)
{
return businessUserMapper.deleteBusinessUserById(id);
}
}
package com.dsk.jsk.service.service.impl;
import cn.hutool.core.bean.BeanException;
import com.dsk.common.core.domain.model.LoginUser;
import com.dsk.common.utils.SecurityUtils;
import com.dsk.system.domain.customer.ContactInfo;
import com.dsk.system.domain.customer.dto.ContactInfoSearchDto;
import com.dsk.system.domain.customer.vo.ContactInfoListVo;
import com.dsk.system.dskService.EnterpriseService;
import com.dsk.system.mapper.ContactInfoMapper;
import com.dsk.system.service.IContactInfoService;
import lombok.extern.slf4j.Slf4j;
import org.apache.commons.collections4.MapUtils;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import org.springframework.util.ObjectUtils;
import javax.annotation.Resource;
import java.util.List;
import java.util.Map;
/**
* 用户联系人(CustomerContact)表服务实现类
*
* @author makejava
* @since 2023-07-25 17:18:04
*/
@Slf4j
@Service
public class ContactInfoServiceImpl implements IContactInfoService {
@Resource
private ContactInfoMapper baseMapper;
@Autowired
private EnterpriseService enterpriseService;
// @Resource
// private ICustomerService customerService;
@Override
public List<ContactInfoListVo> selectList(ContactInfoSearchDto dto) {
return baseMapper.selectPageList(dto);
}
@Override
public ContactInfo selectById(Long id) {
return baseMapper.selectById(id);
}
@Override
public boolean insert(ContactInfo bean) {
verifyParameter(bean);
bean.setCreateBy(bean.getUpdateBy());
return baseMapper.insert(bean) > 0;
}
@Override
public boolean update(ContactInfo bean) {
if (ObjectUtils.isEmpty(bean.getId())) throw new BeanException("id不能为空!");
verifyParameter(bean);
return baseMapper.updateById(bean) > 0;
}
@Override
public boolean deleteById(Long id) {
return baseMapper.deleteById(id) > 0;
}
/**
* 参数验证
*/
private void verifyParameter(ContactInfo bean) {
if (!ObjectUtils.isEmpty(bean.getCompanyName())) {
Map<String, Object> map = enterpriseService.getCidAndUipIdByCompanyName(bean.getCompanyName());
bean.setCompanyId(MapUtils.getInteger(map, "companyId"));
bean.setUipId(MapUtils.getString(map, "uipId"));
}
// if (!ObjectUtils.isEmpty(bean.getCustomerId()) && ObjectUtils.isEmpty(bean.getId())) {
// CustomerVo info = customerService.info(bean.getCustomerId());
// bean.setCompanyName(info.getCompanyName());
// bean.setCompanyId(info.getCompanyId());
// bean.setUipId(info.getUipId());
// }
LoginUser loginUser = SecurityUtils.getLoginUser();
bean.setUpdateId(loginUser.getUserId());
bean.setUpdateBy(loginUser.getUser().getNickName());
}
}
package com.dsk.jsk.service.service.impl;
import cn.hutool.core.bean.BeanException;
import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
import com.baomidou.mybatisplus.core.toolkit.Wrappers;
import com.dsk.common.annotation.DataScope;
import com.dsk.common.utils.SecurityUtils;
import com.dsk.system.domain.customer.CustomerFollowRecord;
import com.dsk.system.domain.customer.dto.CustomerFollowRecordSearchDto;
import com.dsk.system.domain.customer.vo.CustomerFollowRecordListVo;
import com.dsk.system.mapper.CustomerFollowRecordMapper;
import com.dsk.system.service.ICustomerFollowRecordService;
import lombok.extern.slf4j.Slf4j;
import org.springframework.stereotype.Service;
import org.springframework.util.ObjectUtils;
import javax.annotation.Resource;
import java.util.List;
/**
* 客户跟进记录(CustomerFollowRecord)表服务实现类
*
* @author makejava
* @since 2023-05-18 15:07:59
*/
@Slf4j
@Service
public class CustomerFollowRecordServiceImpl implements ICustomerFollowRecordService {
@Resource
private CustomerFollowRecordMapper baseMapper;
@Override
@DataScope(deptAlias = "d",userAlias = "u")
public List<CustomerFollowRecordListVo> selectList(CustomerFollowRecordSearchDto dto) {
if (ObjectUtils.isEmpty(dto.getCustomerId())) {
dto.setUserId(SecurityUtils.getUserId());
}
// log.debug("dto.params.dataScope{}",dto.getParams().get("dataScope"));
return baseMapper.selectAuthList(dto);
}
@Override
public boolean add(CustomerFollowRecord followRecord) {
if (ObjectUtils.isEmpty(followRecord.getContent())) throw new BeanException("跟进内容不能为空");
if (ObjectUtils.isEmpty(followRecord.getCustomerId())) throw new BeanException("跟进客户不能为空");
followRecord.setUserId(SecurityUtils.getUserId());
return baseMapper.insert(followRecord) != 0;
}
@Override
public boolean del(Long id) {
return baseMapper.deleteById(id) != 0;
}
}
package com.dsk.jsk.service.service.impl;
import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
import com.baomidou.mybatisplus.core.toolkit.Wrappers;
import com.dsk.common.utils.SecurityUtils;
import com.dsk.system.domain.customer.Customer;
import com.dsk.system.domain.customer.dto.CustomerSearchDto;
import com.dsk.system.domain.customer.vo.CustomerAnalyzeVo;
import com.dsk.system.mapper.CustomerMapper;
import com.dsk.system.service.ICustomerOverviewService;
import org.springframework.stereotype.Service;
import javax.annotation.Resource;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
/**
* 客户概览相关
* @author lcl
* @create 2023/8/15
*/
@Service
public class CustomerOverviewServiceImpl implements ICustomerOverviewService {
@Resource
private CustomerMapper customerMapper;
@Override
public Map<String, Object> statistics(CustomerSearchDto dto) {
Map<String, Object> resultMap = new HashMap<>();
dto.setUserId(SecurityUtils.getUserId());
//总
resultMap.put("totalCount",customerMapper.selectCustomerCount(dto));
//国企
dto.setCompanyNature("国有企业");
resultMap.put("nationCount",customerMapper.selectCustomerCount(dto));
//央企
dto.setCompanyNature("央企");
resultMap.put("centreCount",customerMapper.selectCustomerCount(dto));
//事业
dto.setCompanyNature("事业单位");
resultMap.put("undertakingCount",customerMapper.selectCustomerCount(dto));
return resultMap;
}
@Override
public List<CustomerAnalyzeVo> cooperationTop(CustomerSearchDto dto) {
dto.setUserId(SecurityUtils.getUserId());
return customerMapper.selectCooperationTop(dto);
}
@Override
public List<Map<String, Object>> creditLevel(CustomerSearchDto dto) {
dto.setUserId(SecurityUtils.getUserId());
return customerMapper.selectCreditLevelGroup(dto);
}
}
package com.dsk.jsk.service.service.impl;
import cn.hutool.core.bean.BeanException;
import cn.hutool.core.bean.BeanUtil;
import cn.hutool.core.map.MapUtil;
import cn.hutool.core.util.ObjectUtil;
import com.baomidou.mybatisplus.core.toolkit.Wrappers;
import com.dsk.common.annotation.DataScope;
import com.dsk.common.core.domain.R;
import com.dsk.common.core.domain.entity.SysUser;
import com.dsk.common.exception.ServiceException;
import com.dsk.common.utils.SecurityUtils;
import com.dsk.common.utils.StringUtils;
import com.dsk.system.domain.customer.Customer;
import com.dsk.system.domain.customer.CustomerUser;
import com.dsk.system.domain.customer.dto.CustomerBusinessSearchDto;
import com.dsk.system.domain.customer.dto.CustomerSearchDto;
import com.dsk.system.domain.customer.vo.*;
import com.dsk.system.dskService.EnterpriseService;
import com.dsk.system.mapper.CustomerMapper;
import com.dsk.system.mapper.CustomerUserMapper;
import com.dsk.system.searchService.BusinessOpportunityRadarService;
import com.dsk.system.service.IBusinessInfoService;
import com.dsk.system.service.ICustomerService;
import lombok.extern.slf4j.Slf4j;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;
import org.springframework.util.CollectionUtils;
import org.springframework.util.ObjectUtils;
import javax.annotation.Resource;
import java.util.ArrayList;
import java.util.List;
import java.util.Map;
/**
* 客户信息表(Customer)表服务实现类
*
* @author makejava
* @since 2023-05-16 09:27:57
*/
@Slf4j
@Service
public class CustomerServiceImpl implements ICustomerService {
@Resource
private CustomerMapper baseMapper;
@Resource
private CustomerUserMapper customerUserMapper;
@Autowired
private IBusinessInfoService businessInfoService;
@Autowired
private EnterpriseService enterpriseService;
@Autowired
private BusinessOpportunityRadarService opportunityRadarService;
@Override
// @DataScope(deptAlias = "d", userAlias = "u")
public List<CustomerListVo> selectList(CustomerSearchDto dto) {
dto.setUserId(SecurityUtils.getUserId());
dto.setStatus(ObjectUtils.isEmpty(dto.getStatus()) ? 0 : dto.getStatus());
List<CustomerListVo> customerListVos = baseMapper.selectList(dto);
if (!CollectionUtils.isEmpty(customerListVos) && ObjectUtil.isNotEmpty(dto.getCompanyName())) {
for (CustomerListVo vo : customerListVos) {
vo.setCompanyName(StringUtils.markInRed(vo.getCompanyName(), dto.getCompanyName()));
}
}
return customerListVos;
}
@Override
public CustomerVo info(String customerId) {
CustomerVo vo = new CustomerVo();
BeanUtil.copyProperties(baseMapper.selectById(customerId), vo);
CustomerUser customerUser = customerUserMapper.selectOne(Wrappers.<CustomerUser>lambdaQuery()
.eq(CustomerUser::getCustomerId, customerId));
vo.setUserId(customerUser.getUserId());
return vo;
}
@Override
@Transactional(rollbackFor = Exception.class)
public boolean add(Customer customer) {
dealWithcustomerData(customer);
customer.setUipId(enterpriseService.getUipIdByCompanyNameOrCompanyId(customer.getCompanyName(), customer.getCompanyId()));
Long userId = SecurityUtils.getUserId();
customer.setCreateId(userId);
customer.setUpdateId(userId);
//查重
Customer verifyCustomer = baseMapper.selectByCompanyNameAndUserId(customer.getCompanyName(), userId);
if (!ObjectUtils.isEmpty(verifyCustomer)) {
throw new ServiceException("当前客户信息已存在,请勿重复添加!");
}
int i = baseMapper.insert(customer);
if (i == 0) throw new ServiceException("客户信息添加错误!");
int ui = customerUserMapper.insert(new CustomerUser(customer.getCustomerId(), userId));
if (ui == 0) throw new ServiceException("客户跟进人信息添加错误!");
return true;
}
@Override
@Transactional(rollbackFor = Exception.class)
public boolean edit(Customer customer) {
if (ObjectUtils.isEmpty(customer.getCustomerId())) throw new BeanException("客户id不能为空");
customer.setUpdateId(SecurityUtils.getUserId());
int u = baseMapper.updateById(customer);
return u != 0;
}
@Override
public List<Customer> selectUserList() {
return baseMapper.selectUserList(SecurityUtils.getUserId());
}
@Override
public List<CustomerBusinessListVo> selectBusinessList(CustomerBusinessSearchDto dto) {
if (ObjectUtils.isEmpty(dto.getCustomerId())) throw new BeanException("客户id不能为空");
dto.setUserId(SecurityUtils.getUserId());
return businessInfoService.selectCustomerBusinessList(dto);
}
@Override
public List<CustomerStatusListVo> selectStatusList(List<String> uipIds) {
return baseMapper.selectStatusList(uipIds, SecurityUtils.getUserId());
}
@Override
public List<CustomerStatusListVo> selectStatusListByCompanyName(List<String> companyNames) {
return baseMapper.selectStatusListByCompanyName(companyNames, SecurityUtils.getUserId());
}
// @Override
// public List<String> selectUipIdList(List<String> uipIds) {
// return baseMapper.selectUipIdList(uipIds, SecurityUtils.getUserId());
// }
@Override
public Integer status(String companyName) {
Customer cus = baseMapper.selectByCompanyNameAndUserId(companyName, SecurityUtils.getUserId());
if (ObjectUtils.isEmpty(cus)) {
return null;
}
CustomerUser customerUser = customerUserMapper.selectByCustomerIdAndUserId(cus.getCustomerId(), SecurityUtils.getUserId());
if (ObjectUtils.isEmpty(customerUser)) {
throw new ServiceException("数据错误!");
}
return customerUser.getStatus();
}
@Override
public boolean cancelClaim(String companyName) {
return updateClaimStatus(companyName, 1);
}
@Override
public boolean historyClaim(String companyName) {
return updateClaimStatus(companyName, 0);
}
@Override
public Customer selectByCompanyNameAndUserId(String companyName) {
return baseMapper.selectByCompanyNameAndUserId(companyName, SecurityUtils.getUserId());
}
//修改客户认领状态
private boolean updateClaimStatus(String companyName, Integer status) {
Customer cus = baseMapper.selectByCompanyNameAndUserId(companyName, SecurityUtils.getUserId());
if (ObjectUtils.isEmpty(cus)) {
throw new ServiceException("数据错误!");
}
CustomerUser customerUser = customerUserMapper.selectByCustomerIdAndUserId(cus.getCustomerId(), SecurityUtils.getUserId());
if (ObjectUtils.isEmpty(customerUser)) {
throw new ServiceException("数据错误!");
}
customerUser.setStatus(status);
return customerUserMapper.updateById(customerUser) == 1;
}
private void dealWithcustomerData(Customer customer) {
if (ObjectUtils.isEmpty(customer.getCompanyName())) throw new BeanException("企业名称不能为空");
try {
Map<String, Object> map = opportunityRadarService.enterpriseByName(customer.getCompanyName());
if (!ObjectUtils.isEmpty(map.get("data"))) {
Map<String, Object> data = BeanUtil.beanToMap(map.get("data"));
Integer companyId = MapUtil.getInt(data, "jskEid");
if (ObjectUtil.isNotEmpty(customer.getCompanyId()) && !customer.getCompanyId().equals(companyId)) {
return;
}
customer.setCompanyId(companyId);
if (ObjectUtils.isEmpty(customer.getLegalPerson())) {
customer.setLegalPerson(MapUtil.getStr(data, "legalPerson"));
}
if (ObjectUtils.isEmpty(customer.getRegisterCapital())) {
customer.setRegisterCapital(MapUtil.getStr(data, "registeredCapitalStr"));
}
if (ObjectUtils.isEmpty(customer.getProvinceId())) {
customer.setProvinceId(MapUtil.getInt(data, "provinceId"));
}
if (ObjectUtils.isEmpty(customer.getCityId())) {
customer.setCityId(MapUtil.getInt(data, "cityId"));
}
if (ObjectUtils.isEmpty(customer.getDistrictId())) {
customer.setDistrictId(MapUtil.getInt(data, "countyId"));
}
if (ObjectUtils.isEmpty(customer.getRegisterAddress())) {
if (ObjectUtil.isNotEmpty(MapUtil.getStr(data, "domicile"))) {
customer.setRegisterAddress(MapUtil.getStr(data, "domicile"));
} else {
String address = null;
if (ObjectUtils.isEmpty(MapUtil.getStr(data, "province"))) {
address = MapUtil.getStr(data, "province");
if (ObjectUtils.isEmpty(MapUtil.getStr(data, "city"))) {
address = address.concat("-").concat(MapUtil.getStr(data, "city"));
if (ObjectUtils.isEmpty(MapUtil.getStr(data, "county"))) {
address = address.concat("-").concat(MapUtil.getStr(data, "county"));
}
}
}
customer.setRegisterAddress(address);
}
}
if (ObjectUtils.isEmpty(customer.getCreditCode())) {
customer.setCreditCode(MapUtil.getStr(data, "creditCode"));
}
}
} catch (Exception e) {
log.debug("获取企业id错误!error:{}", e.getMessage());
}
}
}
package com.dsk.jsk.service.service.impl;
import cn.hutool.core.bean.BeanUtil;
import cn.hutool.core.util.ObjectUtil;
import com.dsk.acc.openapi.client.util.CommonUtils;
import com.dsk.common.constant.CacheConstants;
import com.dsk.common.core.domain.AjaxResult;
import com.dsk.common.core.redis.RedisCache;
import com.dsk.common.dtos.*;
import com.dsk.common.utils.DateUtils;
import com.dsk.common.utils.DskOpenApiUtil;
import com.dsk.common.utils.SecurityUtils;
import com.dsk.system.service.EconomicService;
import org.apache.commons.collections4.MapUtils;
import org.springframework.http.HttpStatus;
import org.springframework.stereotype.Service;
import javax.annotation.Resource;
import java.util.List;
import java.util.Map;
/**
* @ClassName EconomicServiceImpl
* @Description 经济大全实现
* @Author Dgm
* @Date 2023/5/18 10:23
* @Version
*/
@Service
public class EconomicServiceImpl implements EconomicService {
@Resource
private DskOpenApiUtil dskOpenApiUtil;
@Resource
private RedisCache redisCache;
/**
* 全国宏观经济:1 / 辖区经济:2 / 地区对比:3
*/
private static final Integer TYPE = 1;
/**
* 默认排序
*/
private static final String FIELD = "gdp";
private static final String ORDER = "desc";
@Override
public AjaxResult nationalPage(OpRegionalEconomicDataV1PageDto dto) {
if (ObjectUtil.isEmpty(dto.getYear())) {
dto.setYear(DateUtils.getYear() - 1);
}
Map<String, Object> map = dskOpenApiUtil.requestBody("/operate/economic/national/nationalPage", BeanUtil.beanToMap(dto, false, false));
Integer code = MapUtils.getInteger(map, "code", 300);
if (!code.equals(HttpStatus.OK.value())) {
throw new RuntimeException();
}
return BeanUtil.toBean(map, AjaxResult.class);
}
@Override
public AjaxResult yearsList(OpRegionalEconomicDataYearsListDto dto) {
Map<String, Object> map = dskOpenApiUtil.requestBody("/operate/economic/years/list", BeanUtil.beanToMap(dto, false, false));
return BeanUtil.toBean(map, AjaxResult.class);
}
@Override
public AjaxResult details(OpRegionalEconomicDataDetailsDto detailsDto) {
Map<String, Object> map = dskOpenApiUtil.requestBody("/operate/economic/details", BeanUtil.beanToMap(detailsDto, false, false));
return BeanUtil.toBean(map, AjaxResult.class);
}
@Override
public AjaxResult location(OpRegionalLocalDto detailsDto) {
Long userId = SecurityUtils.getLoginUser().getUserId();
String redisKey = CacheConstants.PERSONAL_LOCATION + userId;
if (ObjectUtil.isEmpty(detailsDto.getProvinceId()) && ObjectUtil.isEmpty(detailsDto.getCityId()) && ObjectUtil.isEmpty(detailsDto.getAreaId())) {
if (ObjectUtil.isNotEmpty(redisKey)) {
Map<String, Object> cacheMap = redisCache.getCacheMap(redisKey);
if (MapUtils.isNotEmpty(cacheMap)) {
return AjaxResult.success(cacheMap);
}
}
}
Map<String, Object> map = dskOpenApiUtil.requestBody("/operate/economic/location", BeanUtil.beanToMap(detailsDto, false, false));
Integer code = MapUtils.getInteger(map, "code", 300);
if (!code.equals(HttpStatus.OK.value())) {
throw new RuntimeException();
}
Map data = MapUtils.getMap(map, "data", null);
if (ObjectUtil.isNotEmpty(detailsDto.getProvinceId()) || ObjectUtil.isNotEmpty(detailsDto.getCityId()) || ObjectUtil.isNotEmpty(detailsDto.getAreaId())) {
redisCache.setCacheMap(redisKey, data);
}
return BeanUtil.toBean(map, AjaxResult.class);
}
@Override
public AjaxResult statisticsRegional(OpRegionalEconomicDataStatisticsRegionalDto dto) {
Map<String, Object> map = dskOpenApiUtil.requestBody("/operate/economic/statistics/regional", BeanUtil.beanToMap(dto, false, false));
return BeanUtil.toBean(map, AjaxResult.class);
}
@Override
public AjaxResult regionalList(OpRegionalEconomicDataRegionalListDto dto) {
Map<String, Object> map = dskOpenApiUtil.requestBody("/operate/economic/regional/list", BeanUtil.beanToMap(dto, false, false));
return BeanUtil.toBean(map, AjaxResult.class);
}
@Override
public AjaxResult regionalCompare(OpRegionalEconomicDataStatisticsRegionalDto dto) {
Map<String, Object> map = dskOpenApiUtil.requestBody("/operate/economic/regional/compare", BeanUtil.beanToMap(dto, false, false));
return BeanUtil.toBean(map, AjaxResult.class);
}
@Override
public AjaxResult regionalMultipleCompare(OpRegionalEconomicRegionalCompareDto dto) {
Map<String, Object> map = dskOpenApiUtil.requestBody("/operate/economic/regional/multipleCompare", BeanUtil.beanToMap(dto, false, false));
return BeanUtil.toBean(map, AjaxResult.class);
}
}
package com.dsk.jsk.service.service.impl;
import com.dsk.system.domain.business.dto.BusinessExcelDto;
import lombok.extern.slf4j.Slf4j;
import org.apache.poi.hssf.usermodel.HSSFWorkbook;
import org.apache.poi.ss.usermodel.*;
import org.apache.poi.xssf.usermodel.XSSFWorkbook;
import org.springframework.stereotype.Service;
import org.springframework.web.multipart.MultipartFile;
import java.io.IOException;
import java.io.InputStream;
import java.util.ArrayList;
import java.util.List;
/**
* @author lxl
* @Description:
* @Date 2023/6/1 下午 4:30
**/
@Slf4j
@Service
public class ReadBusinessInfoExcel {
// 总行数
private int totalRows = 0;
// 总条数
private int totalCells = 0;
public int getTotalRows() {
return totalRows;
}
public void setTotalRows(int totalRows) {
this.totalRows = totalRows;
}
public int getTotalCells() {
return totalCells;
}
public void setTotalCells(int totalCells) {
this.totalCells = totalCells;
}
/**
* 读EXCEL文件,获取信息集合
*
* @param mFile
* @return
*/
public List<BusinessExcelDto> getExcelInfo(MultipartFile mFile) {
String fileName = mFile.getOriginalFilename();// 获取文件名
try {
// 验证文件名是否合格
if (!validateExcel(fileName)) return null;
// 根据文件名判断文件是2003版本还是2007版本
boolean isExcel2003 = true;
if (isExcel2007(fileName)) isExcel2003 = false;
return createExcel(mFile.getInputStream(), isExcel2003);
} catch (Exception e) {
e.printStackTrace();
}
return null;
}
/**
* 根据excel里面的内容读取信息
*
* @param is 输入流
* @param isExcel2003 excel是2003还是2007版本
* @return
*/
public List<BusinessExcelDto> createExcel(InputStream is, boolean isExcel2003) {
try {
Workbook wb = null;
// 当excel是2003时,创建excel2003
if (isExcel2003) {
wb = new HSSFWorkbook(is);
} else {
// 当excel是2007时,创建excel2007
wb = new XSSFWorkbook(is);
}
return readExcelValue(wb);// 读取Excel里面客户的信息
} catch (IOException e) {
e.printStackTrace();
}
return null;
}
/**
* 读取Excel内容
*
* @param wb
* @return
*/
private List<BusinessExcelDto> readExcelValue(Workbook wb) {
//得到第一个shell
Sheet sheet = wb.getSheetAt(0);
//得到Excel的行数
this.totalRows = sheet.getPhysicalNumberOfRows();
//得到Excel的列数(前提是有行数)
if (totalRows > 1 && sheet.getRow(0) != null) {
this.totalCells = sheet.getRow(0).getPhysicalNumberOfCells();
}
// List<Map<String, Object>> list = new ArrayList<Map<String, Object>>();
ArrayList<BusinessExcelDto> list = new ArrayList<>();
//循环Excel行数
//
for (int r = 3; r < totalRows; r++) {
Row row = sheet.getRow(r);
if (row == null) {
continue;
}
//循环Excel的列
// Map<String, Object> map = new HashMap<String, Object>();
BusinessExcelDto businessExcelDto = new BusinessExcelDto();
for (int c = 0; c < this.totalCells; c++) {
Cell cell = row.getCell(c);
if (null != cell) {
//项目名称
if (c == 0) {
//如果是纯数字,比如你写的是25,cell.getNumericCellValue()获得是25.0,通过截取字符串去掉.0获得25
if (cell.getCellType() == CellType.NUMERIC) {
String name = String.valueOf(cell.getNumericCellValue());
businessExcelDto.setProjectName(name.substring(0, name.length() - 2 > 0 ? name.length() - 2 : 1));
} else {
businessExcelDto.setProjectName(cell.getStringCellValue());
}
//业主单位
} else if (c == 1) {
if (cell.getCellType() == CellType.NUMERIC) {
String company = String.valueOf(cell.getNumericCellValue());
businessExcelDto.setOwnerCompany(company.substring(0, company.length() - 2 > 0 ? company.length() - 2 : 1));
} else {
businessExcelDto.setOwnerCompany(cell.getStringCellValue());
}
//投资估算(万元)
} else if (c == 2) {
if (cell.getCellType() == CellType.NUMERIC) {
String amount = String.valueOf(cell.getNumericCellValue());
// businessExcelDto.setInvestmentAmount(amount.substring(0, amount.length() - 2 > 0 ? amount.length() - 2 : 1));
businessExcelDto.setInvestmentAmount(amount);
} else {
businessExcelDto.setInvestmentAmount(cell.getStringCellValue());
}
}
}
}
//添加到list
list.add(businessExcelDto);
}
log.info("项目批量导入Excel数据,{}",list);
return list;
}
/**
* 验证EXCEL文件
* @param filePath
* @return
*/
public boolean validateExcel(String filePath) {
if (filePath == null || !(isExcel2003(filePath) || isExcel2007(filePath))) {
log.info("文件不是excel格式");
return false;
}
return true;
}
// @描述:是否是2003的excel,返回true是2003
public static boolean isExcel2003(String filePath) {
return filePath.matches("^.+\\.(?i)(xls)$");
}
// @描述:是否是2007的excel,返回true是2007
public static boolean isExcel2007(String filePath) {
return filePath.matches("^.+\\.(?i)(xlsx)$");
}
}
package com.dsk.jsk.service.service.impl;
import cn.hutool.core.bean.BeanUtil;
import cn.hutool.core.util.ObjectUtil;
import com.dsk.acc.openapi.client.util.CommonUtils;
import com.dsk.common.core.domain.AjaxResult;
import com.dsk.common.dtos.ComposeQueryDto;
import com.dsk.common.utils.DskOpenApiUtil;
import com.dsk.system.service.RegionalEnterprisesService;
import org.apache.commons.collections4.CollectionUtils;
import org.apache.commons.collections4.MapUtils;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.http.HttpStatus;
import org.springframework.stereotype.Service;
import java.util.*;
/**
* @ClassName RegionalEnterprisesServiceImpl
* @Description 区域企业业务层实现
* @Author Dgm
* @Date 2023/5/18 10:23
* @Version
*/
@Service
public class RegionalEnterprisesServiceImpl implements RegionalEnterprisesService {
@Autowired
private DskOpenApiUtil dskOpenApiUtil;
@Override
public AjaxResult enterprisePage(ComposeQueryDto pageDto) {
Map<String, Object> map = dskOpenApiUtil.requestBody("/nationzj/enterprice/page",BeanUtil.beanToMap(pageDto, false, false));
Integer code = MapUtils.getInteger(map, "code", 300);
if (code.equals(HttpStatus.OK.value())) {
Map data = MapUtils.getMap(map, "data", null);
List<Object> list = CommonUtils.assertAsArray(MapUtils.getObject(data, "list", ""));
// 常合作客户
List<Integer> getTopCustomerIds = getTopCustomerIds(list);
Map<String,Object> topCustomerIdsMap = new HashMap<>(1);
topCustomerIdsMap.put("ids", getTopCustomerIds);
Map<String, Object> topCustomerMap = dskOpenApiUtil.requestBody("/operate/enterprise/selectCompanyNameList", topCustomerIdsMap);
// 常合作供应商
List<Integer> getTopSupplierIds = getTopSupplierIds(list);
Map<String,Object> topSupplierIdsMap = new HashMap<>(1);
topSupplierIdsMap.put("ids", getTopSupplierIds);
Map<String, Object> topSupplierMap = dskOpenApiUtil.requestBody("/operate/enterprise/selectCompanyNameList", topSupplierIdsMap);
if (CollectionUtils.isNotEmpty(list)) {
for (Object companyObj : list) {
Map<String, Object> companyMap = CommonUtils.assertAsMap(companyObj);
companyMap.put("topCustomer", null);
//常合作客户id
Integer topCustomerId = MapUtils.getInteger(companyMap, "topCustomerId");
if (ObjectUtil.isNotEmpty(topCustomerId)) {
Integer topCustomerCode = MapUtils.getInteger(topCustomerMap, "code", 300);
if (topCustomerCode.equals(HttpStatus.OK.value())) {
List<Map<String, Object>> companyNameList = (List<Map<String, Object>>)MapUtils.getObject(topCustomerMap, "data", null);
for (Map<String, Object> comMap : companyNameList) {
Integer id = MapUtils.getInteger(comMap, "id", 0);
if (id.equals(topCustomerId)) {
String companyName = MapUtils.getString(comMap, "companyName", null);
companyMap.put("topCustomer", companyName);
}
}
}
}
//常合作供应商id
Integer topSupplierId = MapUtils.getInteger(companyMap, "topSupplierId");
companyMap.put("topSupplier", null);
if (ObjectUtil.isNotEmpty(topSupplierId)) {
Integer topSupplierCode = MapUtils.getInteger(topSupplierMap, "code", 300);
if (topSupplierCode.equals(HttpStatus.OK.value())) {
List<Map<String, Object>> companyNameList = (List<Map<String, Object>>)MapUtils.getObject(topSupplierMap, "data", null);
for (Map<String, Object> comMap : companyNameList) {
Integer id = MapUtils.getInteger(comMap, "id", 0);
if (id.equals(topSupplierId)) {
String companyName = MapUtils.getString(comMap, "companyName", null);
companyMap.put("topSupplier", companyName);
}
}
}
}
}
}
}
return BeanUtil.toBean(map, AjaxResult.class);
}
/***
*@Description: 获取企业Id-客户
*@Param:
*@return: java.util.List<java.lang.Integer>
*@Author: Dgm
*@date: 2023/7/11 16:04
*/
public List<Integer> getTopCustomerIds(List<Object> list) {
List<Integer> getIds = new ArrayList<>(20);
for (Object companyObj : list) {
Map<String, Object> companyMap = CommonUtils.assertAsMap(companyObj);
//常合作客户id
Integer topCustomerId = MapUtils.getInteger(companyMap, "topCustomerId");
getIds.add(topCustomerId);
}
return getIds;
}
/***
*@Description: 获取企业Id-供应商
*@Param:
*@return: java.util.List<java.lang.Integer>
*@Author: Dgm
*@date: 2023/7/11 16:04
*/
public List<Integer> getTopSupplierIds(List<Object> list) {
List<Integer> getIds = new ArrayList<>(20);
for (Object companyObj : list) {
Map<String, Object> companyMap = CommonUtils.assertAsMap(companyObj);
//常合作供应商id
Integer topSupplierId = MapUtils.getInteger(companyMap, "topSupplierId");
getIds.add(topSupplierId);
}
return getIds;
}
}
package com.dsk.jsk.service.service.impl;
import cn.hutool.core.bean.BeanUtil;
import cn.hutool.core.util.ObjectUtil;
import com.dsk.acc.openapi.client.util.CommonUtils;
import com.dsk.common.core.domain.AjaxResult;
import com.dsk.common.dtos.SpecialBondInformationDetailsDto;
import com.dsk.common.dtos.SpecialBondInformationPageDto;
import com.dsk.common.dtos.SpecialPurposeBondsDto;
import com.dsk.common.dtos.SpecialPurposeBondsPageDto;
import com.dsk.common.utils.DskOpenApiUtil;
import com.dsk.system.service.SpecialPurposeBondsService;
import org.apache.commons.collections4.CollectionUtils;
import org.apache.commons.collections4.MapUtils;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.http.HttpStatus;
import org.springframework.stereotype.Service;
import java.util.Iterator;
import java.util.List;
import java.util.Map;
/**
* @ClassName EconomicServiceImpl
* @Description 专项债项目业务层实现
* @Author Dgm
* @Date 2023/5/18 10:23
* @Version
*/
@Service
public class SpecialPurposeBondsServiceImpl implements SpecialPurposeBondsService {
@Autowired
private DskOpenApiUtil dskOpenApiUtil;
@Override
public AjaxResult page(SpecialPurposeBondsPageDto dto) {
Map<String, Object> map = dskOpenApiUtil.requestBody("/operate/specialPurposeBonds/projects/page", BeanUtil.beanToMap(dto, false, false));
Integer code = MapUtils.getInteger(map, "code", 300);
if (code.equals(HttpStatus.OK.value())) {
Map data = MapUtils.getMap(map, "data", null);
List<Object> list = CommonUtils.assertAsArray(MapUtils.getObject(data, "list", ""));
if (CollectionUtils.isNotEmpty(list)) {
for (Object projectObj : list) {
Map<String, Object> projectMap = CommonUtils.assertAsMap(projectObj);
// 项目总投资
Double projectTotalInvestment = MapUtils.getDouble(projectMap, "projectTotalInvestment",0.00);
projectMap.put("projectTotalInvestment", projectTotalInvestment / 10000);
// 专项债用作资本金
Double specialBondCapital = MapUtils.getDouble(projectMap, "specialBondCapital",0.00);
projectMap.put("specialBondCapital", specialBondCapital / 10000);
// 项目资本金
Double projectCapital = MapUtils.getDouble(projectMap, "projectCapital",0.00);
projectMap.put("projectCapital", projectCapital / 10000);
}
}
}
return BeanUtil.toBean(map, AjaxResult.class);
}
@Override
public AjaxResult details(SpecialBondInformationDetailsDto detailsDto) {
Map<String, Object> map = dskOpenApiUtil.requestBody("/operate/specialPurposeBonds/details", BeanUtil.beanToMap(detailsDto, false, false));
Integer code = MapUtils.getInteger(map, "code", 300);
if (code.equals(HttpStatus.OK.value())) {
Map projectMap = MapUtils.getMap(map, "data", null);
if (ObjectUtil.isNotEmpty(projectMap)) {
// 项目总投资
Double projectTotalInvestment = MapUtils.getDouble(projectMap, "projectTotalInvestment",0.00);
projectMap.put("projectTotalInvestment", projectTotalInvestment / 10000);
// 专项债用作资本金
Double specialBondCapital = MapUtils.getDouble(projectMap, "specialBondCapital",0.00);
projectMap.put("specialBondCapital", specialBondCapital / 10000);
// 项目资本金
Double projectCapital = MapUtils.getDouble(projectMap, "projectCapital",0.00);
projectMap.put("projectCapital", projectCapital / 10000);
// 其他资金
Double otherFunds = MapUtils.getDouble(projectMap, "otherFunds",0.00);
projectMap.put("otherFunds", otherFunds / 10000);
// 计划使用专项债融资额
Double econData012 = MapUtils.getDouble(projectMap, "econData012",0.00);
projectMap.put("econData012", econData012 / 10000);
// 当前使用专项债融资额
Double econData013 = MapUtils.getDouble(projectMap, "econData013",0.00);
projectMap.put("econData013", econData013 / 10000);
// 其他融资
Double otherFinancing = MapUtils.getDouble(projectMap, "otherFinancing",0.00);
projectMap.put("otherFinancing", otherFinancing / 10000);
// 政府安排资金
Double govSupportFunds = MapUtils.getDouble(projectMap, "govSupportFunds",0.00);
projectMap.put("govSupportFunds", govSupportFunds / 10000);
// 项目预测总收益
Double projectForecastTotalRevenue = MapUtils.getDouble(projectMap, "projectForecastTotalRevenue",0.00);
projectMap.put("projectForecastTotalRevenue", projectForecastTotalRevenue / 10000);
}
}
return BeanUtil.toBean(map, AjaxResult.class);
}
@Override
public AjaxResult bondStatistics(SpecialPurposeBondsDto dto) {
// todo 临时处理 待还原
Map<String, Object> map = dskOpenApiUtil.requestBody("/operate/specialPurposeBonds/bond/statistics", BeanUtil.beanToMap(dto, false, false));
Integer code = MapUtils.getInteger(map, "code", 300);
if (code.equals(HttpStatus.OK.value())) {
List<Object> list = CommonUtils.assertAsArray(MapUtils.getObject(map, "data", ""));
Iterator<Object> it = list.iterator();
while (it.hasNext()) {
Map<String, Object> informationMap = (Map<String, Object>)it.next();
// 专项债用于项目规模
Integer count = MapUtils.getInteger(informationMap, "count",0);
if (count.equals(0)) {
it.remove();
}
}
}
return BeanUtil.toBean(map, AjaxResult.class);
}
@Override
public AjaxResult bondPage(SpecialBondInformationPageDto pageDto) {
Map<String, Object> map = dskOpenApiUtil.requestBody("/operate/specialPurposeBonds/bond/page", BeanUtil.beanToMap(pageDto, false, false));
Integer code = MapUtils.getInteger(map, "code", 300);
if (code.equals(HttpStatus.OK.value())) {
Map data = MapUtils.getMap(map, "data", null);
List<Object> list = CommonUtils.assertAsArray(MapUtils.getObject(data, "list", ""));
if (CollectionUtils.isNotEmpty(list)) {
for (Object informationObj : list) {
Map<String, Object> informationMap = CommonUtils.assertAsMap(informationObj);
// 专项债用于项目规模
Double isUsedProjectScale = MapUtils.getDouble(informationMap, "isUsedProjectScale",0.00);
informationMap.put("isUsedProjectScale", isUsedProjectScale / 10000);
}
}
}
return BeanUtil.toBean(map, AjaxResult.class);
}
}
package com.dsk.jsk.service.service.impl;
import java.util.Collection;
import java.util.List;
import javax.annotation.PostConstruct;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.context.annotation.Primary;
import org.springframework.stereotype.Service;
import com.dsk.common.annotation.DataSource;
import com.dsk.common.constant.CacheConstants;
import com.dsk.common.constant.UserConstants;
import com.dsk.common.core.redis.RedisCache;
import com.dsk.common.core.text.Convert;
import com.dsk.common.enums.DataSourceType;
import com.dsk.common.exception.ServiceException;
import com.dsk.common.utils.StringUtils;
import com.dsk.system.domain.SysConfig;
import com.dsk.system.mapper.SysConfigMapper;
import com.dsk.system.service.ISysConfigService;
/**
* 参数配置 服务层实现
*
* @author dsk
*/
@Service
public class SysConfigServiceImpl implements ISysConfigService
{
@Autowired
private SysConfigMapper configMapper;
@Autowired
private RedisCache redisCache;
/**
* 项目启动时,初始化参数到缓存
*/
@PostConstruct
public void init()
{
loadingConfigCache();
}
/**
* 查询参数配置信息
*
* @param configId 参数配置ID
* @return 参数配置信息
*/
@Override
@DataSource(DataSourceType.MASTER)
public SysConfig selectConfigById(Long configId)
{
SysConfig config = new SysConfig();
config.setConfigId(configId);
return configMapper.selectConfig(config);
}
/**
* 根据键名查询参数配置信息
*
* @param configKey 参数key
* @return 参数键值
*/
@Override
public String selectConfigByKey(String configKey)
{
String configValue = Convert.toStr(redisCache.getCacheObject(getCacheKey(configKey)));
if (StringUtils.isNotEmpty(configValue))
{
return configValue;
}
SysConfig config = new SysConfig();
config.setConfigKey(configKey);
SysConfig retConfig = configMapper.selectConfig(config);
if (StringUtils.isNotNull(retConfig))
{
redisCache.setCacheObject(getCacheKey(configKey), retConfig.getConfigValue());
return retConfig.getConfigValue();
}
return StringUtils.EMPTY;
}
/**
* 获取验证码开关
*
* @return true开启,false关闭
*/
@Override
public boolean selectCaptchaEnabled()
{
String captchaEnabled = selectConfigByKey("sys.account.captchaEnabled");
if (StringUtils.isEmpty(captchaEnabled))
{
return true;
}
return Convert.toBool(captchaEnabled);
}
/**
* 查询参数配置列表
*
* @param config 参数配置信息
* @return 参数配置集合
*/
@Override
public List<SysConfig> selectConfigList(SysConfig config)
{
return configMapper.selectConfigList(config);
}
/**
* 新增参数配置
*
* @param config 参数配置信息
* @return 结果
*/
@Override
public int insertConfig(SysConfig config)
{
int row = configMapper.insertConfig(config);
if (row > 0)
{
redisCache.setCacheObject(getCacheKey(config.getConfigKey()), config.getConfigValue());
}
return row;
}
/**
* 修改参数配置
*
* @param config 参数配置信息
* @return 结果
*/
@Override
public int updateConfig(SysConfig config)
{
SysConfig temp = configMapper.selectConfigById(config.getConfigId());
if (!StringUtils.equals(temp.getConfigKey(), config.getConfigKey()))
{
redisCache.deleteObject(getCacheKey(temp.getConfigKey()));
}
int row = configMapper.updateConfig(config);
if (row > 0)
{
redisCache.setCacheObject(getCacheKey(config.getConfigKey()), config.getConfigValue());
}
return row;
}
/**
* 批量删除参数信息
*
* @param configIds 需要删除的参数ID
*/
@Override
public void deleteConfigByIds(Long[] configIds)
{
for (Long configId : configIds)
{
SysConfig config = selectConfigById(configId);
if (StringUtils.equals(UserConstants.YES, config.getConfigType()))
{
throw new ServiceException(String.format("内置参数【%1$s】不能删除 ", config.getConfigKey()));
}
configMapper.deleteConfigById(configId);
redisCache.deleteObject(getCacheKey(config.getConfigKey()));
}
}
/**
* 加载参数缓存数据
*/
@Override
public void loadingConfigCache()
{
List<SysConfig> configsList = configMapper.selectConfigList(new SysConfig());
for (SysConfig config : configsList)
{
redisCache.setCacheObject(getCacheKey(config.getConfigKey()), config.getConfigValue());
}
}
/**
* 清空参数缓存数据
*/
@Override
public void clearConfigCache()
{
Collection<String> keys = redisCache.keys(CacheConstants.SYS_CONFIG_KEY + "*");
redisCache.deleteObject(keys);
}
/**
* 重置参数缓存数据
*/
@Override
public void resetConfigCache()
{
clearConfigCache();
loadingConfigCache();
}
/**
* 校验参数键名是否唯一
*
* @param config 参数配置信息
* @return 结果
*/
@Override
public boolean checkConfigKeyUnique(SysConfig config)
{
Long configId = StringUtils.isNull(config.getConfigId()) ? -1L : config.getConfigId();
SysConfig info = configMapper.checkConfigKeyUnique(config.getConfigKey());
if (StringUtils.isNotNull(info) && info.getConfigId().longValue() != configId.longValue())
{
return UserConstants.NOT_UNIQUE;
}
return UserConstants.UNIQUE;
}
/**
* 设置cache key
*
* @param configKey 参数键
* @return 缓存键key
*/
private String getCacheKey(String configKey)
{
return CacheConstants.SYS_CONFIG_KEY + configKey;
}
}
package com.dsk.jsk.service.service.impl;
import java.util.List;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.context.annotation.Primary;
import org.springframework.stereotype.Service;
import com.dsk.common.core.domain.entity.SysDictData;
import com.dsk.common.utils.DictUtils;
import com.dsk.system.mapper.SysDictDataMapper;
import com.dsk.system.service.ISysDictDataService;
/**
* 字典 业务层处理
*
* @author dsk
*/
@Service
public class SysDictDataServiceImpl implements ISysDictDataService
{
@Autowired
private SysDictDataMapper dictDataMapper;
/**
* 根据条件分页查询字典数据
*
* @param dictData 字典数据信息
* @return 字典数据集合信息
*/
@Override
public List<SysDictData> selectDictDataList(SysDictData dictData)
{
return dictDataMapper.selectDictDataList(dictData);
}
/**
* 根据字典类型和字典键值查询字典数据信息
*
* @param dictType 字典类型
* @param dictValue 字典键值
* @return 字典标签
*/
@Override
public String selectDictLabel(String dictType, String dictValue)
{
return dictDataMapper.selectDictLabel(dictType, dictValue);
}
/**
* 根据字典数据ID查询信息
*
* @param dictCode 字典数据ID
* @return 字典数据
*/
@Override
public SysDictData selectDictDataById(Long dictCode)
{
return dictDataMapper.selectDictDataById(dictCode);
}
/**
* 批量删除字典数据信息
*
* @param dictCodes 需要删除的字典数据ID
*/
@Override
public void deleteDictDataByIds(Long[] dictCodes)
{
for (Long dictCode : dictCodes)
{
SysDictData data = selectDictDataById(dictCode);
dictDataMapper.deleteDictDataById(dictCode);
List<SysDictData> dictDatas = dictDataMapper.selectDictDataByType(data.getDictType());
DictUtils.setDictCache(data.getDictType(), dictDatas);
}
}
/**
* 新增保存字典数据信息
*
* @param data 字典数据信息
* @return 结果
*/
@Override
public int insertDictData(SysDictData data)
{
int row = dictDataMapper.insertDictData(data);
if (row > 0)
{
List<SysDictData> dictDatas = dictDataMapper.selectDictDataByType(data.getDictType());
DictUtils.setDictCache(data.getDictType(), dictDatas);
}
return row;
}
/**
* 修改保存字典数据信息
*
* @param data 字典数据信息
* @return 结果
*/
@Override
public int updateDictData(SysDictData data)
{
int row = dictDataMapper.updateDictData(data);
if (row > 0)
{
List<SysDictData> dictDatas = dictDataMapper.selectDictDataByType(data.getDictType());
DictUtils.setDictCache(data.getDictType(), dictDatas);
}
return row;
}
}
package com.dsk.jsk.service.service.impl;
import java.util.Comparator;
import java.util.List;
import java.util.Map;
import java.util.stream.Collectors;
import javax.annotation.PostConstruct;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.context.annotation.Primary;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;
import com.dsk.common.constant.UserConstants;
import com.dsk.common.core.domain.entity.SysDictData;
import com.dsk.common.core.domain.entity.SysDictType;
import com.dsk.common.exception.ServiceException;
import com.dsk.common.utils.DictUtils;
import com.dsk.common.utils.StringUtils;
import com.dsk.system.mapper.SysDictDataMapper;
import com.dsk.system.mapper.SysDictTypeMapper;
import com.dsk.system.service.ISysDictTypeService;
/**
* 字典 业务层处理
*
* @author dsk
*/
@Service
public class SysDictTypeServiceImpl implements ISysDictTypeService
{
@Autowired
private SysDictTypeMapper dictTypeMapper;
@Autowired
private SysDictDataMapper dictDataMapper;
/**
* 项目启动时,初始化字典到缓存
*/
@PostConstruct
public void init()
{
loadingDictCache();
}
/**
* 根据条件分页查询字典类型
*
* @param dictType 字典类型信息
* @return 字典类型集合信息
*/
@Override
public List<SysDictType> selectDictTypeList(SysDictType dictType)
{
return dictTypeMapper.selectDictTypeList(dictType);
}
/**
* 根据所有字典类型
*
* @return 字典类型集合信息
*/
@Override
public List<SysDictType> selectDictTypeAll()
{
return dictTypeMapper.selectDictTypeAll();
}
/**
* 根据字典类型查询字典数据
*
* @param dictType 字典类型
* @return 字典数据集合信息
*/
@Override
public List<SysDictData> selectDictDataByType(String dictType)
{
List<SysDictData> dictDatas = DictUtils.getDictCache(dictType);
if (StringUtils.isNotEmpty(dictDatas))
{
return dictDatas;
}
dictDatas = dictDataMapper.selectDictDataByType(dictType);
if (StringUtils.isNotEmpty(dictDatas))
{
DictUtils.setDictCache(dictType, dictDatas);
return dictDatas;
}
return null;
}
/**
* 根据字典类型ID查询信息
*
* @param dictId 字典类型ID
* @return 字典类型
*/
@Override
public SysDictType selectDictTypeById(Long dictId)
{
return dictTypeMapper.selectDictTypeById(dictId);
}
/**
* 根据字典类型查询信息
*
* @param dictType 字典类型
* @return 字典类型
*/
@Override
public SysDictType selectDictTypeByType(String dictType)
{
return dictTypeMapper.selectDictTypeByType(dictType);
}
/**
* 批量删除字典类型信息
*
* @param dictIds 需要删除的字典ID
*/
@Override
public void deleteDictTypeByIds(Long[] dictIds)
{
for (Long dictId : dictIds)
{
SysDictType dictType = selectDictTypeById(dictId);
if (dictDataMapper.countDictDataByType(dictType.getDictType()) > 0)
{
throw new ServiceException(String.format("%1$s已分配,不能删除", dictType.getDictName()));
}
dictTypeMapper.deleteDictTypeById(dictId);
DictUtils.removeDictCache(dictType.getDictType());
}
}
/**
* 加载字典缓存数据
*/
@Override
public void loadingDictCache()
{
SysDictData dictData = new SysDictData();
dictData.setStatus("0");
Map<String, List<SysDictData>> dictDataMap = dictDataMapper.selectDictDataList(dictData).stream().collect(Collectors.groupingBy(SysDictData::getDictType));
for (Map.Entry<String, List<SysDictData>> entry : dictDataMap.entrySet())
{
DictUtils.setDictCache(entry.getKey(), entry.getValue().stream().sorted(Comparator.comparing(SysDictData::getDictSort)).collect(Collectors.toList()));
}
}
/**
* 清空字典缓存数据
*/
@Override
public void clearDictCache()
{
DictUtils.clearDictCache();
}
/**
* 重置字典缓存数据
*/
@Override
public void resetDictCache()
{
clearDictCache();
loadingDictCache();
}
/**
* 新增保存字典类型信息
*
* @param dict 字典类型信息
* @return 结果
*/
@Override
public int insertDictType(SysDictType dict)
{
int row = dictTypeMapper.insertDictType(dict);
if (row > 0)
{
DictUtils.setDictCache(dict.getDictType(), null);
}
return row;
}
/**
* 修改保存字典类型信息
*
* @param dict 字典类型信息
* @return 结果
*/
@Override
@Transactional
public int updateDictType(SysDictType dict)
{
SysDictType oldDict = dictTypeMapper.selectDictTypeById(dict.getDictId());
dictDataMapper.updateDictDataType(oldDict.getDictType(), dict.getDictType());
int row = dictTypeMapper.updateDictType(dict);
if (row > 0)
{
List<SysDictData> dictDatas = dictDataMapper.selectDictDataByType(dict.getDictType());
DictUtils.setDictCache(dict.getDictType(), dictDatas);
}
return row;
}
/**
* 校验字典类型称是否唯一
*
* @param dict 字典类型
* @return 结果
*/
@Override
public boolean checkDictTypeUnique(SysDictType dict)
{
Long dictId = StringUtils.isNull(dict.getDictId()) ? -1L : dict.getDictId();
SysDictType dictType = dictTypeMapper.checkDictTypeUnique(dict.getDictType());
if (StringUtils.isNotNull(dictType) && dictType.getDictId().longValue() != dictId.longValue())
{
return UserConstants.NOT_UNIQUE;
}
return UserConstants.UNIQUE;
}
}
package com.dsk.jsk.service.service.impl;
import java.util.List;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.context.annotation.Primary;
import org.springframework.stereotype.Service;
import com.dsk.system.domain.SysLogininfor;
import com.dsk.system.mapper.SysLogininforMapper;
import com.dsk.system.service.ISysLogininforService;
/**
* 系统访问日志情况信息 服务层处理
*
* @author dsk
*/
@Service
public class SysLogininforServiceImpl implements ISysLogininforService
{
@Autowired
private SysLogininforMapper logininforMapper;
/**
* 新增系统登录日志
*
* @param logininfor 访问日志对象
*/
@Override
public void insertLogininfor(SysLogininfor logininfor)
{
logininforMapper.insertLogininfor(logininfor);
}
/**
* 查询系统登录日志集合
*
* @param logininfor 访问日志对象
* @return 登录记录集合
*/
@Override
public List<SysLogininfor> selectLogininforList(SysLogininfor logininfor)
{
return logininforMapper.selectLogininforList(logininfor);
}
/**
* 批量删除系统登录日志
*
* @param infoIds 需要删除的登录日志ID
* @return 结果
*/
@Override
public int deleteLogininforByIds(Long[] infoIds)
{
return logininforMapper.deleteLogininforByIds(infoIds);
}
/**
* 清空系统登录日志
*/
@Override
public void cleanLogininfor()
{
logininforMapper.cleanLogininfor();
}
}
package com.dsk.jsk.service.service.impl;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.HashSet;
import java.util.Iterator;
import java.util.LinkedList;
import java.util.List;
import java.util.Set;
import java.util.stream.Collectors;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import com.dsk.common.constant.Constants;
import com.dsk.common.constant.UserConstants;
import com.dsk.common.core.domain.TreeSelect;
import com.dsk.common.core.domain.entity.SysMenu;
import com.dsk.common.core.domain.entity.SysRole;
import com.dsk.common.core.domain.entity.SysUser;
import com.dsk.common.utils.SecurityUtils;
import com.dsk.common.utils.StringUtils;
import com.dsk.system.domain.vo.MetaVo;
import com.dsk.system.domain.vo.RouterVo;
import com.dsk.system.mapper.SysMenuMapper;
import com.dsk.system.mapper.SysRoleMapper;
import com.dsk.system.mapper.SysRoleMenuMapper;
import com.dsk.system.service.ISysMenuService;
/**
* 菜单 业务层处理
*
* @author dsk
*/
@Service
public class SysMenuServiceImpl implements ISysMenuService
{
public static final String PREMISSION_STRING = "perms[\"{0}\"]";
@Autowired
private SysMenuMapper menuMapper;
@Autowired
private SysRoleMapper roleMapper;
@Autowired
private SysRoleMenuMapper roleMenuMapper;
/**
* 根据用户查询系统菜单列表
*
* @param userId 用户ID
* @return 菜单列表
*/
@Override
public List<SysMenu> selectMenuList(Long userId)
{
return selectMenuList(new SysMenu(), userId);
}
/**
* 查询系统菜单列表
*
* @param menu 菜单信息
* @return 菜单列表
*/
@Override
public List<SysMenu> selectMenuList(SysMenu menu, Long userId)
{
List<SysMenu> menuList = null;
// 管理员显示所有菜单信息
if (SysUser.isAdmin(userId))
{
menuList = menuMapper.selectMenuList(menu);
}
else
{
menu.getParams().put("userId", userId);
menuList = menuMapper.selectMenuListByUserId(menu);
}
return menuList;
}
/**
* 根据用户ID查询权限
*
* @param userId 用户ID
* @return 权限列表
*/
@Override
public Set<String> selectMenuPermsByUserId(Long userId)
{
List<String> perms = menuMapper.selectMenuPermsByUserId(userId);
Set<String> permsSet = new HashSet<>();
for (String perm : perms)
{
if (StringUtils.isNotEmpty(perm))
{
permsSet.addAll(Arrays.asList(perm.trim().split(",")));
}
}
return permsSet;
}
/**
* 根据角色ID查询权限
*
* @param roleId 角色ID
* @return 权限列表
*/
@Override
public Set<String> selectMenuPermsByRoleId(Long roleId)
{
List<String> perms = menuMapper.selectMenuPermsByRoleId(roleId);
Set<String> permsSet = new HashSet<>();
for (String perm : perms)
{
if (StringUtils.isNotEmpty(perm))
{
permsSet.addAll(Arrays.asList(perm.trim().split(",")));
}
}
return permsSet;
}
/**
* 根据用户ID查询菜单
*
* @param userId 用户名称
* @return 菜单列表
*/
@Override
public List<SysMenu> selectMenuTreeByUserId(Long userId)
{
List<SysMenu> menus = null;
if (SecurityUtils.isAdmin(userId))
{
menus = menuMapper.selectMenuTreeAll();
}
else
{
menus = menuMapper.selectMenuTreeByUserId(userId);
}
return getChildPerms(menus, 0);
}
/**
* 根据角色ID查询菜单树信息
*
* @param roleId 角色ID
* @return 选中菜单列表
*/
@Override
public List<Long> selectMenuListByRoleId(Long roleId)
{
SysRole role = roleMapper.selectRoleById(roleId);
return menuMapper.selectMenuListByRoleId(roleId, role.isMenuCheckStrictly());
}
/**
* 构建前端路由所需要的菜单
*
* @param menus 菜单列表
* @return 路由列表
*/
@Override
public List<RouterVo> buildMenus(List<SysMenu> menus)
{
List<RouterVo> routers = new LinkedList<RouterVo>();
for (SysMenu menu : menus)
{
RouterVo router = new RouterVo();
router.setHidden("1".equals(menu.getVisible()));
router.setName(getRouteName(menu));
router.setPath(getRouterPath(menu));
router.setComponent(getComponent(menu));
router.setQuery(menu.getQuery());
router.setMeta(new MetaVo(menu.getMenuName(), menu.getIcon(), StringUtils.equals("1", menu.getIsCache()), menu.getPath()));
List<SysMenu> cMenus = menu.getChildren();
if (StringUtils.isNotEmpty(cMenus) && UserConstants.TYPE_DIR.equals(menu.getMenuType()))
{
router.setAlwaysShow(true);
router.setRedirect("noRedirect");
router.setChildren(buildMenus(cMenus));
}
else if (isMenuFrame(menu))
{
router.setMeta(null);
List<RouterVo> childrenList = new ArrayList<RouterVo>();
RouterVo children = new RouterVo();
children.setPath(menu.getPath());
children.setComponent(menu.getComponent());
children.setName(StringUtils.capitalize(menu.getPath()));
children.setMeta(new MetaVo(menu.getMenuName(), menu.getIcon(), StringUtils.equals("1", menu.getIsCache()), menu.getPath()));
children.setQuery(menu.getQuery());
childrenList.add(children);
router.setChildren(childrenList);
}
else if (menu.getParentId().intValue() == 0 && isInnerLink(menu))
{
router.setMeta(new MetaVo(menu.getMenuName(), menu.getIcon()));
router.setPath("/");
List<RouterVo> childrenList = new ArrayList<RouterVo>();
RouterVo children = new RouterVo();
String routerPath = innerLinkReplaceEach(menu.getPath());
children.setPath(routerPath);
children.setComponent(UserConstants.INNER_LINK);
children.setName(StringUtils.capitalize(routerPath));
children.setMeta(new MetaVo(menu.getMenuName(), menu.getIcon(), menu.getPath()));
childrenList.add(children);
router.setChildren(childrenList);
}
routers.add(router);
}
return routers;
}
/**
* 构建前端所需要树结构
*
* @param menus 菜单列表
* @return 树结构列表
*/
@Override
public List<SysMenu> buildMenuTree(List<SysMenu> menus)
{
List<SysMenu> returnList = new ArrayList<SysMenu>();
List<Long> tempList = menus.stream().map(SysMenu::getMenuId).collect(Collectors.toList());
for (Iterator<SysMenu> iterator = menus.iterator(); iterator.hasNext();)
{
SysMenu menu = (SysMenu) iterator.next();
// 如果是顶级节点, 遍历该父节点的所有子节点
if (!tempList.contains(menu.getParentId()))
{
recursionFn(menus, menu);
returnList.add(menu);
}
}
if (returnList.isEmpty())
{
returnList = menus;
}
return returnList;
}
/**
* 构建前端所需要下拉树结构
*
* @param menus 菜单列表
* @return 下拉树结构列表
*/
@Override
public List<TreeSelect> buildMenuTreeSelect(List<SysMenu> menus)
{
List<SysMenu> menuTrees = buildMenuTree(menus);
return menuTrees.stream().map(TreeSelect::new).collect(Collectors.toList());
}
/**
* 根据菜单ID查询信息
*
* @param menuId 菜单ID
* @return 菜单信息
*/
@Override
public SysMenu selectMenuById(Long menuId)
{
return menuMapper.selectMenuById(menuId);
}
/**
* 是否存在菜单子节点
*
* @param menuId 菜单ID
* @return 结果
*/
@Override
public boolean hasChildByMenuId(Long menuId)
{
int result = menuMapper.hasChildByMenuId(menuId);
return result > 0;
}
/**
* 查询菜单使用数量
*
* @param menuId 菜单ID
* @return 结果
*/
@Override
public boolean checkMenuExistRole(Long menuId)
{
int result = roleMenuMapper.checkMenuExistRole(menuId);
return result > 0;
}
/**
* 新增保存菜单信息
*
* @param menu 菜单信息
* @return 结果
*/
@Override
public int insertMenu(SysMenu menu)
{
return menuMapper.insertMenu(menu);
}
/**
* 修改保存菜单信息
*
* @param menu 菜单信息
* @return 结果
*/
@Override
public int updateMenu(SysMenu menu)
{
return menuMapper.updateMenu(menu);
}
/**
* 删除菜单管理信息
*
* @param menuId 菜单ID
* @return 结果
*/
@Override
public int deleteMenuById(Long menuId)
{
return menuMapper.deleteMenuById(menuId);
}
/**
* 校验菜单名称是否唯一
*
* @param menu 菜单信息
* @return 结果
*/
@Override
public boolean checkMenuNameUnique(SysMenu menu)
{
Long menuId = StringUtils.isNull(menu.getMenuId()) ? -1L : menu.getMenuId();
SysMenu info = menuMapper.checkMenuNameUnique(menu.getMenuName(), menu.getParentId());
if (StringUtils.isNotNull(info) && info.getMenuId().longValue() != menuId.longValue())
{
return UserConstants.NOT_UNIQUE;
}
return UserConstants.UNIQUE;
}
/**
* 获取路由名称
*
* @param menu 菜单信息
* @return 路由名称
*/
public String getRouteName(SysMenu menu)
{
String routerName = StringUtils.capitalize(menu.getPath());
// 非外链并且是一级目录(类型为目录)
if (isMenuFrame(menu))
{
routerName = StringUtils.EMPTY;
}
return routerName;
}
/**
* 获取路由地址
*
* @param menu 菜单信息
* @return 路由地址
*/
public String getRouterPath(SysMenu menu)
{
String routerPath = menu.getPath();
// 内链打开外网方式
if (menu.getParentId().intValue() != 0 && isInnerLink(menu))
{
routerPath = innerLinkReplaceEach(routerPath);
}
// 非外链并且是一级目录(类型为目录)
if (0 == menu.getParentId().intValue() && UserConstants.TYPE_DIR.equals(menu.getMenuType())
&& UserConstants.NO_FRAME.equals(menu.getIsFrame()))
{
routerPath = "/" + menu.getPath();
}
// 非外链并且是一级目录(类型为菜单)
else if (isMenuFrame(menu))
{
routerPath = "/";
}
return routerPath;
}
/**
* 获取组件信息
*
* @param menu 菜单信息
* @return 组件信息
*/
public String getComponent(SysMenu menu)
{
String component = UserConstants.LAYOUT;
if (StringUtils.isNotEmpty(menu.getComponent()) && !isMenuFrame(menu))
{
component = menu.getComponent();
}
else if (StringUtils.isEmpty(menu.getComponent()) && menu.getParentId().intValue() != 0 && isInnerLink(menu))
{
component = UserConstants.INNER_LINK;
}
else if (StringUtils.isEmpty(menu.getComponent()) && isParentView(menu))
{
component = UserConstants.PARENT_VIEW;
}
return component;
}
/**
* 是否为菜单内部跳转
*
* @param menu 菜单信息
* @return 结果
*/
public boolean isMenuFrame(SysMenu menu)
{
return menu.getParentId().intValue() == 0 && UserConstants.TYPE_MENU.equals(menu.getMenuType())
&& menu.getIsFrame().equals(UserConstants.NO_FRAME);
}
/**
* 是否为内链组件
*
* @param menu 菜单信息
* @return 结果
*/
public boolean isInnerLink(SysMenu menu)
{
return menu.getIsFrame().equals(UserConstants.NO_FRAME) && StringUtils.ishttp(menu.getPath());
}
/**
* 是否为parent_view组件
*
* @param menu 菜单信息
* @return 结果
*/
public boolean isParentView(SysMenu menu)
{
return menu.getParentId().intValue() != 0 && UserConstants.TYPE_DIR.equals(menu.getMenuType());
}
/**
* 根据父节点的ID获取所有子节点
*
* @param list 分类表
* @param parentId 传入的父节点ID
* @return String
*/
public List<SysMenu> getChildPerms(List<SysMenu> list, int parentId)
{
List<SysMenu> returnList = new ArrayList<SysMenu>();
for (Iterator<SysMenu> iterator = list.iterator(); iterator.hasNext();)
{
SysMenu t = (SysMenu) iterator.next();
// 一、根据传入的某个父节点ID,遍历该父节点的所有子节点
if (t.getParentId() == parentId)
{
recursionFn(list, t);
returnList.add(t);
}
}
return returnList;
}
/**
* 递归列表
*
* @param list 分类表
* @param t 子节点
*/
private void recursionFn(List<SysMenu> list, SysMenu t)
{
// 得到子节点列表
List<SysMenu> childList = getChildList(list, t);
t.setChildren(childList);
for (SysMenu tChild : childList)
{
if (hasChild(list, tChild))
{
recursionFn(list, tChild);
}
}
}
/**
* 得到子节点列表
*/
private List<SysMenu> getChildList(List<SysMenu> list, SysMenu t)
{
List<SysMenu> tlist = new ArrayList<SysMenu>();
Iterator<SysMenu> it = list.iterator();
while (it.hasNext())
{
SysMenu n = (SysMenu) it.next();
if (n.getParentId().longValue() == t.getMenuId().longValue())
{
tlist.add(n);
}
}
return tlist;
}
/**
* 判断是否有子节点
*/
private boolean hasChild(List<SysMenu> list, SysMenu t)
{
return getChildList(list, t).size() > 0;
}
/**
* 内链域名特殊字符替换
*
* @return 替换后的内链域名
*/
public String innerLinkReplaceEach(String path)
{
return StringUtils.replaceEach(path, new String[] { Constants.HTTP, Constants.HTTPS, Constants.WWW, "." },
new String[] { "", "", "", "/" });
}
}
package com.dsk.jsk.service.service.impl;
import java.util.List;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.context.annotation.Primary;
import org.springframework.stereotype.Service;
import com.dsk.system.domain.SysNotice;
import com.dsk.system.mapper.SysNoticeMapper;
import com.dsk.system.service.ISysNoticeService;
/**
* 公告 服务层实现
*
* @author dsk
*/
@Service
public class SysNoticeServiceImpl implements ISysNoticeService
{
@Autowired
private SysNoticeMapper noticeMapper;
/**
* 查询公告信息
*
* @param noticeId 公告ID
* @return 公告信息
*/
@Override
public SysNotice selectNoticeById(Long noticeId)
{
return noticeMapper.selectNoticeById(noticeId);
}
/**
* 查询公告列表
*
* @param notice 公告信息
* @return 公告集合
*/
@Override
public List<SysNotice> selectNoticeList(SysNotice notice)
{
return noticeMapper.selectNoticeList(notice);
}
/**
* 新增公告
*
* @param notice 公告信息
* @return 结果
*/
@Override
public int insertNotice(SysNotice notice)
{
return noticeMapper.insertNotice(notice);
}
/**
* 修改公告
*
* @param notice 公告信息
* @return 结果
*/
@Override
public int updateNotice(SysNotice notice)
{
return noticeMapper.updateNotice(notice);
}
/**
* 删除公告对象
*
* @param noticeId 公告ID
* @return 结果
*/
@Override
public int deleteNoticeById(Long noticeId)
{
return noticeMapper.deleteNoticeById(noticeId);
}
/**
* 批量删除公告信息
*
* @param noticeIds 需要删除的公告ID
* @return 结果
*/
@Override
public int deleteNoticeByIds(Long[] noticeIds)
{
return noticeMapper.deleteNoticeByIds(noticeIds);
}
}
package com.dsk.jsk.service.service.impl;
import java.util.List;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.context.annotation.Primary;
import org.springframework.stereotype.Service;
import com.dsk.system.domain.SysOperLog;
import com.dsk.system.mapper.SysOperLogMapper;
import com.dsk.system.service.ISysOperLogService;
/**
* 操作日志 服务层处理
*
* @author dsk
*/
@Service
public class SysOperLogServiceImpl implements ISysOperLogService
{
@Autowired
private SysOperLogMapper operLogMapper;
/**
* 新增操作日志
*
* @param operLog 操作日志对象
*/
@Override
public void insertOperlog(SysOperLog operLog)
{
operLogMapper.insertOperlog(operLog);
}
/**
* 查询系统操作日志集合
*
* @param operLog 操作日志对象
* @return 操作日志集合
*/
@Override
public List<SysOperLog> selectOperLogList(SysOperLog operLog)
{
return operLogMapper.selectOperLogList(operLog);
}
/**
* 批量删除系统操作日志
*
* @param operIds 需要删除的操作日志ID
* @return 结果
*/
@Override
public int deleteOperLogByIds(Long[] operIds)
{
return operLogMapper.deleteOperLogByIds(operIds);
}
/**
* 查询操作日志详细
*
* @param operId 操作ID
* @return 操作日志对象
*/
@Override
public SysOperLog selectOperLogById(Long operId)
{
return operLogMapper.selectOperLogById(operId);
}
/**
* 清空操作日志
*/
@Override
public void cleanOperLog()
{
operLogMapper.cleanOperLog();
}
}
package com.dsk.jsk.service.service.impl;
import java.util.List;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.context.annotation.Primary;
import org.springframework.stereotype.Service;
import com.dsk.common.constant.UserConstants;
import com.dsk.common.exception.ServiceException;
import com.dsk.common.utils.StringUtils;
import com.dsk.system.domain.SysPost;
import com.dsk.system.mapper.SysPostMapper;
import com.dsk.system.mapper.SysUserPostMapper;
import com.dsk.system.service.ISysPostService;
/**
* 岗位信息 服务层处理
*
* @author dsk
*/
@Service
public class SysPostServiceImpl implements ISysPostService
{
@Autowired
private SysPostMapper postMapper;
@Autowired
private SysUserPostMapper userPostMapper;
/**
* 查询岗位信息集合
*
* @param post 岗位信息
* @return 岗位信息集合
*/
@Override
public List<SysPost> selectPostList(SysPost post)
{
return postMapper.selectPostList(post);
}
/**
* 查询所有岗位
*
* @return 岗位列表
*/
@Override
public List<SysPost> selectPostAll()
{
return postMapper.selectPostAll();
}
/**
* 通过岗位ID查询岗位信息
*
* @param postId 岗位ID
* @return 角色对象信息
*/
@Override
public SysPost selectPostById(Long postId)
{
return postMapper.selectPostById(postId);
}
/**
* 根据用户ID获取岗位选择框列表
*
* @param userId 用户ID
* @return 选中岗位ID列表
*/
@Override
public List<Long> selectPostListByUserId(Long userId)
{
return postMapper.selectPostListByUserId(userId);
}
/**
* 校验岗位名称是否唯一
*
* @param post 岗位信息
* @return 结果
*/
@Override
public boolean checkPostNameUnique(SysPost post)
{
Long postId = StringUtils.isNull(post.getPostId()) ? -1L : post.getPostId();
SysPost info = postMapper.checkPostNameUnique(post.getPostName());
if (StringUtils.isNotNull(info) && info.getPostId().longValue() != postId.longValue())
{
return UserConstants.NOT_UNIQUE;
}
return UserConstants.UNIQUE;
}
/**
* 校验岗位编码是否唯一
*
* @param post 岗位信息
* @return 结果
*/
@Override
public boolean checkPostCodeUnique(SysPost post)
{
Long postId = StringUtils.isNull(post.getPostId()) ? -1L : post.getPostId();
SysPost info = postMapper.checkPostCodeUnique(post.getPostCode());
if (StringUtils.isNotNull(info) && info.getPostId().longValue() != postId.longValue())
{
return UserConstants.NOT_UNIQUE;
}
return UserConstants.UNIQUE;
}
/**
* 通过岗位ID查询岗位使用数量
*
* @param postId 岗位ID
* @return 结果
*/
@Override
public int countUserPostById(Long postId)
{
return userPostMapper.countUserPostById(postId);
}
/**
* 删除岗位信息
*
* @param postId 岗位ID
* @return 结果
*/
@Override
public int deletePostById(Long postId)
{
return postMapper.deletePostById(postId);
}
/**
* 批量删除岗位信息
*
* @param postIds 需要删除的岗位ID
* @return 结果
*/
@Override
public int deletePostByIds(Long[] postIds)
{
for (Long postId : postIds)
{
SysPost post = selectPostById(postId);
if (countUserPostById(postId) > 0)
{
throw new ServiceException(String.format("%1$s已分配,不能删除", post.getPostName()));
}
}
return postMapper.deletePostByIds(postIds);
}
/**
* 新增保存岗位信息
*
* @param post 岗位信息
* @return 结果
*/
@Override
public int insertPost(SysPost post)
{
return postMapper.insertPost(post);
}
/**
* 修改保存岗位信息
*
* @param post 岗位信息
* @return 结果
*/
@Override
public int updatePost(SysPost post)
{
return postMapper.updatePost(post);
}
}
package com.dsk.jsk.service.service.impl;
import com.baomidou.mybatisplus.core.toolkit.Wrappers;
import com.dsk.system.domain.SysRegion;
import com.dsk.system.mapper.SysRegionMapper;
import com.dsk.system.service.SysRegionService;
import org.springframework.stereotype.Service;
import org.springframework.util.ObjectUtils;
import javax.annotation.Resource;
import java.util.List;
/**
* 行政区编码表(SysRegion)表服务实现类
*
* @author makejava
* @since 2023-06-28 11:23:12
*/
@Service("sysRegionService")
public class SysRegionServiceImpl implements SysRegionService {
@Resource
private SysRegionMapper baseMapper;
private static final Integer ACQUIESCE_PARENT_ID = 100000;
@Override
public List<SysRegion> selectByParentId(Integer parentId) {
return baseMapper.selectList(Wrappers.<SysRegion>lambdaQuery()
.eq(SysRegion::getParentId, ObjectUtils.isEmpty(parentId) ? ACQUIESCE_PARENT_ID : parentId)
.orderByAsc(SysRegion::getId));
}
}
package com.dsk.jsk.service.service.impl;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.HashSet;
import java.util.List;
import java.util.Set;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.context.annotation.Primary;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;
import com.dsk.common.annotation.DataScope;
import com.dsk.common.constant.UserConstants;
import com.dsk.common.core.domain.entity.SysRole;
import com.dsk.common.core.domain.entity.SysUser;
import com.dsk.common.exception.ServiceException;
import com.dsk.common.utils.SecurityUtils;
import com.dsk.common.utils.StringUtils;
import com.dsk.common.utils.spring.SpringUtils;
import com.dsk.system.domain.SysRoleDept;
import com.dsk.system.domain.SysRoleMenu;
import com.dsk.system.domain.SysUserRole;
import com.dsk.system.mapper.SysRoleDeptMapper;
import com.dsk.system.mapper.SysRoleMapper;
import com.dsk.system.mapper.SysRoleMenuMapper;
import com.dsk.system.mapper.SysUserRoleMapper;
import com.dsk.system.service.ISysRoleService;
/**
* 角色 业务层处理
*
* @author dsk
*/
@Service
public class SysRoleServiceImpl implements ISysRoleService
{
@Autowired
private SysRoleMapper roleMapper;
@Autowired
private SysRoleMenuMapper roleMenuMapper;
@Autowired
private SysUserRoleMapper userRoleMapper;
@Autowired
private SysRoleDeptMapper roleDeptMapper;
/**
* 根据条件分页查询角色数据
*
* @param role 角色信息
* @return 角色数据集合信息
*/
@Override
@DataScope(deptAlias = "d")
public List<SysRole> selectRoleList(SysRole role)
{
return roleMapper.selectRoleList(role);
}
/**
* 根据用户ID查询角色
*
* @param userId 用户ID
* @return 角色列表
*/
@Override
public List<SysRole> selectRolesByUserId(Long userId)
{
List<SysRole> userRoles = roleMapper.selectRolePermissionByUserId(userId);
List<SysRole> roles = selectRoleAll();
for (SysRole role : roles)
{
for (SysRole userRole : userRoles)
{
if (role.getRoleId().longValue() == userRole.getRoleId().longValue())
{
role.setFlag(true);
break;
}
}
}
return roles;
}
/**
* 根据用户ID查询权限
*
* @param userId 用户ID
* @return 权限列表
*/
@Override
public Set<String> selectRolePermissionByUserId(Long userId)
{
List<SysRole> perms = roleMapper.selectRolePermissionByUserId(userId);
Set<String> permsSet = new HashSet<>();
for (SysRole perm : perms)
{
if (StringUtils.isNotNull(perm))
{
permsSet.addAll(Arrays.asList(perm.getRoleKey().trim().split(",")));
}
}
return permsSet;
}
/**
* 查询所有角色
*
* @return 角色列表
*/
@Override
public List<SysRole> selectRoleAll()
{
return SpringUtils.getAopProxy(this).selectRoleList(new SysRole());
}
/**
* 根据用户ID获取角色选择框列表
*
* @param userId 用户ID
* @return 选中角色ID列表
*/
@Override
public List<Long> selectRoleListByUserId(Long userId)
{
return roleMapper.selectRoleListByUserId(userId);
}
/**
* 通过角色ID查询角色
*
* @param roleId 角色ID
* @return 角色对象信息
*/
@Override
public SysRole selectRoleById(Long roleId)
{
return roleMapper.selectRoleById(roleId);
}
/**
* 校验角色名称是否唯一
*
* @param role 角色信息
* @return 结果
*/
@Override
public boolean checkRoleNameUnique(SysRole role)
{
Long roleId = StringUtils.isNull(role.getRoleId()) ? -1L : role.getRoleId();
SysRole info = roleMapper.checkRoleNameUnique(role.getRoleName());
if (StringUtils.isNotNull(info) && info.getRoleId().longValue() != roleId.longValue())
{
return UserConstants.NOT_UNIQUE;
}
return UserConstants.UNIQUE;
}
/**
* 校验角色权限是否唯一
*
* @param role 角色信息
* @return 结果
*/
@Override
public boolean checkRoleKeyUnique(SysRole role)
{
Long roleId = StringUtils.isNull(role.getRoleId()) ? -1L : role.getRoleId();
SysRole info = roleMapper.checkRoleKeyUnique(role.getRoleKey());
if (StringUtils.isNotNull(info) && info.getRoleId().longValue() != roleId.longValue())
{
return UserConstants.NOT_UNIQUE;
}
return UserConstants.UNIQUE;
}
/**
* 校验角色是否允许操作
*
* @param role 角色信息
*/
@Override
public void checkRoleAllowed(SysRole role)
{
if (StringUtils.isNotNull(role.getRoleId()) && role.isAdmin())
{
throw new ServiceException("不允许操作超级管理员角色");
}
}
/**
* 校验角色是否有数据权限
*
* @param roleId 角色id
*/
@Override
public void checkRoleDataScope(Long roleId)
{
if (!SysUser.isAdmin(SecurityUtils.getUserId()))
{
SysRole role = new SysRole();
role.setRoleId(roleId);
List<SysRole> roles = SpringUtils.getAopProxy(this).selectRoleList(role);
if (StringUtils.isEmpty(roles))
{
throw new ServiceException("没有权限访问角色数据!");
}
}
}
/**
* 通过角色ID查询角色使用数量
*
* @param roleId 角色ID
* @return 结果
*/
@Override
public int countUserRoleByRoleId(Long roleId)
{
return userRoleMapper.countUserRoleByRoleId(roleId);
}
/**
* 新增保存角色信息
*
* @param role 角色信息
* @return 结果
*/
@Override
@Transactional
public int insertRole(SysRole role)
{
// 新增角色信息
roleMapper.insertRole(role);
return insertRoleMenu(role);
}
/**
* 修改保存角色信息
*
* @param role 角色信息
* @return 结果
*/
@Override
@Transactional
public int updateRole(SysRole role)
{
// 修改角色信息
roleMapper.updateRole(role);
// 删除角色与菜单关联
roleMenuMapper.deleteRoleMenuByRoleId(role.getRoleId());
return insertRoleMenu(role);
}
/**
* 修改角色状态
*
* @param role 角色信息
* @return 结果
*/
@Override
public int updateRoleStatus(SysRole role)
{
return roleMapper.updateRole(role);
}
/**
* 修改数据权限信息
*
* @param role 角色信息
* @return 结果
*/
@Override
@Transactional
public int authDataScope(SysRole role)
{
// 修改角色信息
roleMapper.updateRole(role);
// 删除角色与部门关联
roleDeptMapper.deleteRoleDeptByRoleId(role.getRoleId());
// 新增角色和部门信息(数据权限)
return insertRoleDept(role);
}
/**
* 新增角色菜单信息
*
* @param role 角色对象
*/
public int insertRoleMenu(SysRole role)
{
int rows = 1;
// 新增用户与角色管理
List<SysRoleMenu> list = new ArrayList<SysRoleMenu>();
for (Long menuId : role.getMenuIds())
{
SysRoleMenu rm = new SysRoleMenu();
rm.setRoleId(role.getRoleId());
rm.setMenuId(menuId);
list.add(rm);
}
if (list.size() > 0)
{
rows = roleMenuMapper.batchRoleMenu(list);
}
return rows;
}
/**
* 新增角色部门信息(数据权限)
*
* @param role 角色对象
*/
public int insertRoleDept(SysRole role)
{
int rows = 1;
// 新增角色与部门(数据权限)管理
List<SysRoleDept> list = new ArrayList<SysRoleDept>();
for (Long deptId : role.getDeptIds())
{
SysRoleDept rd = new SysRoleDept();
rd.setRoleId(role.getRoleId());
rd.setDeptId(deptId);
list.add(rd);
}
if (list.size() > 0)
{
rows = roleDeptMapper.batchRoleDept(list);
}
return rows;
}
/**
* 通过角色ID删除角色
*
* @param roleId 角色ID
* @return 结果
*/
@Override
@Transactional
public int deleteRoleById(Long roleId)
{
// 删除角色与菜单关联
roleMenuMapper.deleteRoleMenuByRoleId(roleId);
// 删除角色与部门关联
roleDeptMapper.deleteRoleDeptByRoleId(roleId);
return roleMapper.deleteRoleById(roleId);
}
/**
* 批量删除角色信息
*
* @param roleIds 需要删除的角色ID
* @return 结果
*/
@Override
@Transactional
public int deleteRoleByIds(Long[] roleIds)
{
for (Long roleId : roleIds)
{
checkRoleAllowed(new SysRole(roleId));
checkRoleDataScope(roleId);
SysRole role = selectRoleById(roleId);
if (countUserRoleByRoleId(roleId) > 0)
{
throw new ServiceException(String.format("%1$s已分配,不能删除", role.getRoleName()));
}
}
// 删除角色与菜单关联
roleMenuMapper.deleteRoleMenu(roleIds);
// 删除角色与部门关联
roleDeptMapper.deleteRoleDept(roleIds);
return roleMapper.deleteRoleByIds(roleIds);
}
/**
* 取消授权用户角色
*
* @param userRole 用户和角色关联信息
* @return 结果
*/
@Override
public int deleteAuthUser(SysUserRole userRole)
{
return userRoleMapper.deleteUserRoleInfo(userRole);
}
/**
* 批量取消授权用户角色
*
* @param roleId 角色ID
* @param userIds 需要取消授权的用户数据ID
* @return 结果
*/
@Override
public int deleteAuthUsers(Long roleId, Long[] userIds)
{
return userRoleMapper.deleteUserRoleInfos(roleId, userIds);
}
/**
* 批量选择授权用户角色
*
* @param roleId 角色ID
* @param userIds 需要授权的用户数据ID
* @return 结果
*/
@Override
public int insertAuthUsers(Long roleId, Long[] userIds)
{
// 新增用户与角色管理
List<SysUserRole> list = new ArrayList<SysUserRole>();
for (Long userId : userIds)
{
SysUserRole ur = new SysUserRole();
ur.setUserId(userId);
ur.setRoleId(roleId);
list.add(ur);
}
return userRoleMapper.batchUserRole(list);
}
}
package com.dsk.jsk.service.service.impl;
import org.springframework.context.annotation.Primary;
import org.springframework.stereotype.Service;
import com.dsk.common.core.domain.model.LoginUser;
import com.dsk.common.utils.StringUtils;
import com.dsk.system.domain.SysUserOnline;
import com.dsk.system.service.ISysUserOnlineService;
/**
* 在线用户 服务层处理
*
* @author dsk
*/
@Service
public class SysUserOnlineServiceImpl implements ISysUserOnlineService
{
/**
* 通过登录地址查询信息
*
* @param ipaddr 登录地址
* @param user 用户信息
* @return 在线用户信息
*/
@Override
public SysUserOnline selectOnlineByIpaddr(String ipaddr, LoginUser user)
{
if (StringUtils.equals(ipaddr, user.getIpaddr()))
{
return loginUserToUserOnline(user);
}
return null;
}
/**
* 通过用户名称查询信息
*
* @param userName 用户名称
* @param user 用户信息
* @return 在线用户信息
*/
@Override
public SysUserOnline selectOnlineByUserName(String userName, LoginUser user)
{
if (StringUtils.equals(userName, user.getUsername()))
{
return loginUserToUserOnline(user);
}
return null;
}
/**
* 通过登录地址/用户名称查询信息
*
* @param ipaddr 登录地址
* @param userName 用户名称
* @param user 用户信息
* @return 在线用户信息
*/
@Override
public SysUserOnline selectOnlineByInfo(String ipaddr, String userName, LoginUser user)
{
if (StringUtils.equals(ipaddr, user.getIpaddr()) && StringUtils.equals(userName, user.getUsername()))
{
return loginUserToUserOnline(user);
}
return null;
}
/**
* 设置在线用户信息
*
* @param user 用户信息
* @return 在线用户
*/
@Override
public SysUserOnline loginUserToUserOnline(LoginUser user)
{
if (StringUtils.isNull(user) || StringUtils.isNull(user.getUser()))
{
return null;
}
SysUserOnline sysUserOnline = new SysUserOnline();
sysUserOnline.setTokenId(user.getToken());
sysUserOnline.setUserName(user.getUsername());
sysUserOnline.setIpaddr(user.getIpaddr());
sysUserOnline.setLoginLocation(user.getLoginLocation());
sysUserOnline.setBrowser(user.getBrowser());
sysUserOnline.setOs(user.getOs());
sysUserOnline.setLoginTime(user.getLoginTime());
if (StringUtils.isNotNull(user.getUser().getDept()))
{
sysUserOnline.setDeptName(user.getUser().getDept().getDeptName());
}
return sysUserOnline;
}
}
package com.dsk.jsk.service.service.impl;
import java.util.ArrayList;
import java.util.List;
import java.util.stream.Collectors;
import javax.validation.Validator;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.context.annotation.Primary;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;
import org.springframework.util.CollectionUtils;
import com.dsk.common.annotation.DataScope;
import com.dsk.common.constant.UserConstants;
import com.dsk.common.core.domain.entity.SysRole;
import com.dsk.common.core.domain.entity.SysUser;
import com.dsk.common.exception.ServiceException;
import com.dsk.common.utils.SecurityUtils;
import com.dsk.common.utils.StringUtils;
import com.dsk.common.utils.bean.BeanValidators;
import com.dsk.common.utils.spring.SpringUtils;
import com.dsk.system.domain.SysPost;
import com.dsk.system.domain.SysUserPost;
import com.dsk.system.domain.SysUserRole;
import com.dsk.system.mapper.SysPostMapper;
import com.dsk.system.mapper.SysRoleMapper;
import com.dsk.system.mapper.SysUserMapper;
import com.dsk.system.mapper.SysUserPostMapper;
import com.dsk.system.mapper.SysUserRoleMapper;
import com.dsk.system.service.ISysConfigService;
import com.dsk.system.service.ISysUserService;
/**
* 用户 业务层处理
*
* @author dsk
*/
@Service
public class SysUserServiceImpl implements ISysUserService
{
private static final Logger log = LoggerFactory.getLogger(SysUserServiceImpl.class);
@Autowired
private SysUserMapper userMapper;
@Autowired
private SysRoleMapper roleMapper;
@Autowired
private SysPostMapper postMapper;
@Autowired
private SysUserRoleMapper userRoleMapper;
@Autowired
private SysUserPostMapper userPostMapper;
@Autowired
private ISysConfigService configService;
@Autowired
protected Validator validator;
/**
* 根据条件分页查询用户列表
*
* @param user 用户信息
* @return 用户信息集合信息
*/
@Override
@DataScope(deptAlias = "d", userAlias = "u")
public List<SysUser> selectUserList(SysUser user)
{
return userMapper.selectUserList(user);
}
/**
* 根据条件分页查询已分配用户角色列表
*
* @param user 用户信息
* @return 用户信息集合信息
*/
@Override
@DataScope(deptAlias = "d", userAlias = "u")
public List<SysUser> selectAllocatedList(SysUser user)
{
return userMapper.selectAllocatedList(user);
}
/**
* 根据条件分页查询未分配用户角色列表
*
* @param user 用户信息
* @return 用户信息集合信息
*/
@Override
@DataScope(deptAlias = "d", userAlias = "u")
public List<SysUser> selectUnallocatedList(SysUser user)
{
return userMapper.selectUnallocatedList(user);
}
/**
* 通过用户名查询用户
*
* @param userName 用户名
* @return 用户对象信息
*/
@Override
public SysUser selectUserByUserName(String userName)
{
return userMapper.selectUserByUserName(userName);
}
/**
* 通过用户ID查询用户
*
* @param userId 用户ID
* @return 用户对象信息
*/
@Override
public SysUser selectUserById(Long userId)
{
return userMapper.selectUserById(userId);
}
/**
* 查询用户所属角色组
*
* @param userName 用户名
* @return 结果
*/
@Override
public String selectUserRoleGroup(String userName)
{
List<SysRole> list = roleMapper.selectRolesByUserName(userName);
if (CollectionUtils.isEmpty(list))
{
return StringUtils.EMPTY;
}
return list.stream().map(SysRole::getRoleName).collect(Collectors.joining(","));
}
/**
* 查询用户所属岗位组
*
* @param userName 用户名
* @return 结果
*/
@Override
public String selectUserPostGroup(String userName)
{
List<SysPost> list = postMapper.selectPostsByUserName(userName);
if (CollectionUtils.isEmpty(list))
{
return StringUtils.EMPTY;
}
return list.stream().map(SysPost::getPostName).collect(Collectors.joining(","));
}
/**
* 校验用户名称是否唯一
*
* @param user 用户信息
* @return 结果
*/
@Override
public boolean checkUserNameUnique(SysUser user)
{
Long userId = StringUtils.isNull(user.getUserId()) ? -1L : user.getUserId();
SysUser info = userMapper.checkUserNameUnique(user.getUserName());
if (StringUtils.isNotNull(info) && info.getUserId().longValue() != userId.longValue())
{
return UserConstants.NOT_UNIQUE;
}
return UserConstants.UNIQUE;
}
/**
* 校验手机号码是否唯一
*
* @param user 用户信息
* @return
*/
@Override
public boolean checkPhoneUnique(SysUser user)
{
Long userId = StringUtils.isNull(user.getUserId()) ? -1L : user.getUserId();
SysUser info = userMapper.checkPhoneUnique(user.getPhonenumber());
if (StringUtils.isNotNull(info) && info.getUserId().longValue() != userId.longValue())
{
return UserConstants.NOT_UNIQUE;
}
return UserConstants.UNIQUE;
}
/**
* 校验email是否唯一
*
* @param user 用户信息
* @return
*/
@Override
public boolean checkEmailUnique(SysUser user)
{
Long userId = StringUtils.isNull(user.getUserId()) ? -1L : user.getUserId();
SysUser info = userMapper.checkEmailUnique(user.getEmail());
if (StringUtils.isNotNull(info) && info.getUserId().longValue() != userId.longValue())
{
return UserConstants.NOT_UNIQUE;
}
return UserConstants.UNIQUE;
}
/**
* 校验用户是否允许操作
*
* @param user 用户信息
*/
@Override
public void checkUserAllowed(SysUser user)
{
if (StringUtils.isNotNull(user.getUserId()) && user.isAdmin())
{
throw new ServiceException("不允许操作超级管理员用户");
}
}
/**
* 校验用户是否有数据权限
*
* @param userId 用户id
*/
@Override
public void checkUserDataScope(Long userId)
{
if (!SysUser.isAdmin(SecurityUtils.getUserId()))
{
SysUser user = new SysUser();
user.setUserId(userId);
List<SysUser> users = SpringUtils.getAopProxy(this).selectUserList(user);
if (StringUtils.isEmpty(users))
{
throw new ServiceException("没有权限访问用户数据!");
}
}
}
/**
* 新增保存用户信息
*
* @param user 用户信息
* @return 结果
*/
@Override
@Transactional
public int insertUser(SysUser user)
{
// 新增用户信息
int rows = userMapper.insertUser(user);
// 新增用户岗位关联
insertUserPost(user);
// 新增用户与角色管理
insertUserRole(user);
return rows;
}
/**
* 注册用户信息
*
* @param user 用户信息
* @return 结果
*/
@Override
public boolean registerUser(SysUser user)
{
return userMapper.insertUser(user) > 0;
}
/**
* 修改保存用户信息
*
* @param user 用户信息
* @return 结果
*/
@Override
@Transactional
public int updateUser(SysUser user)
{
Long userId = user.getUserId();
// 删除用户与角色关联
userRoleMapper.deleteUserRoleByUserId(userId);
// 新增用户与角色管理
insertUserRole(user);
// 删除用户与岗位关联
userPostMapper.deleteUserPostByUserId(userId);
// 新增用户与岗位管理
insertUserPost(user);
return userMapper.updateUser(user);
}
/**
* 用户授权角色
*
* @param userId 用户ID
* @param roleIds 角色组
*/
@Override
@Transactional
public void insertUserAuth(Long userId, Long[] roleIds)
{
userRoleMapper.deleteUserRoleByUserId(userId);
insertUserRole(userId, roleIds);
}
/**
* 修改用户状态
*
* @param user 用户信息
* @return 结果
*/
@Override
public int updateUserStatus(SysUser user)
{
return userMapper.updateUser(user);
}
/**
* 修改用户基本信息
*
* @param user 用户信息
* @return 结果
*/
@Override
public int updateUserProfile(SysUser user)
{
return userMapper.updateUser(user);
}
/**
* 修改用户头像
*
* @param userName 用户名
* @param avatar 头像地址
* @return 结果
*/
@Override
public boolean updateUserAvatar(String userName, String avatar)
{
return userMapper.updateUserAvatar(userName, avatar) > 0;
}
/**
* 重置用户密码
*
* @param user 用户信息
* @return 结果
*/
@Override
public int resetPwd(SysUser user)
{
return userMapper.updateUser(user);
}
/**
* 重置用户密码
*
* @param userName 用户名
* @param password 密码
* @return 结果
*/
@Override
public int resetUserPwd(String userName, String password)
{
return userMapper.resetUserPwd(userName, password);
}
/**
* 新增用户角色信息
*
* @param user 用户对象
*/
public void insertUserRole(SysUser user)
{
this.insertUserRole(user.getUserId(), user.getRoleIds());
}
/**
* 新增用户岗位信息
*
* @param user 用户对象
*/
public void insertUserPost(SysUser user)
{
Long[] posts = user.getPostIds();
if (StringUtils.isNotEmpty(posts))
{
// 新增用户与岗位管理
List<SysUserPost> list = new ArrayList<SysUserPost>(posts.length);
for (Long postId : posts)
{
SysUserPost up = new SysUserPost();
up.setUserId(user.getUserId());
up.setPostId(postId);
list.add(up);
}
userPostMapper.batchUserPost(list);
}
}
/**
* 新增用户角色信息
*
* @param userId 用户ID
* @param roleIds 角色组
*/
public void insertUserRole(Long userId, Long[] roleIds)
{
if (StringUtils.isNotEmpty(roleIds))
{
// 新增用户与角色管理
List<SysUserRole> list = new ArrayList<SysUserRole>(roleIds.length);
for (Long roleId : roleIds)
{
SysUserRole ur = new SysUserRole();
ur.setUserId(userId);
ur.setRoleId(roleId);
list.add(ur);
}
userRoleMapper.batchUserRole(list);
}
}
/**
* 通过用户ID删除用户
*
* @param userId 用户ID
* @return 结果
*/
@Override
@Transactional
public int deleteUserById(Long userId)
{
// 删除用户与角色关联
userRoleMapper.deleteUserRoleByUserId(userId);
// 删除用户与岗位表
userPostMapper.deleteUserPostByUserId(userId);
return userMapper.deleteUserById(userId);
}
/**
* 批量删除用户信息
*
* @param userIds 需要删除的用户ID
* @return 结果
*/
@Override
@Transactional
public int deleteUserByIds(Long[] userIds)
{
for (Long userId : userIds)
{
checkUserAllowed(new SysUser(userId));
checkUserDataScope(userId);
}
// 删除用户与角色关联
userRoleMapper.deleteUserRole(userIds);
// 删除用户与岗位关联
userPostMapper.deleteUserPost(userIds);
return userMapper.deleteUserByIds(userIds);
}
/**
* 导入用户数据
*
* @param userList 用户数据列表
* @param isUpdateSupport 是否更新支持,如果已存在,则进行更新数据
* @param operName 操作用户
* @return 结果
*/
@Override
public String importUser(List<SysUser> userList, Boolean isUpdateSupport, String operName)
{
if (StringUtils.isNull(userList) || userList.size() == 0)
{
throw new ServiceException("导入用户数据不能为空!");
}
int successNum = 0;
int failureNum = 0;
StringBuilder successMsg = new StringBuilder();
StringBuilder failureMsg = new StringBuilder();
String password = configService.selectConfigByKey("sys.user.initPassword");
for (SysUser user : userList)
{
try
{
// 验证是否存在这个用户
SysUser u = userMapper.selectUserByUserName(user.getUserName());
if (StringUtils.isNull(u))
{
BeanValidators.validateWithException(validator, user);
user.setPassword(SecurityUtils.encryptPassword(password));
user.setCreateBy(operName);
userMapper.insertUser(user);
successNum++;
successMsg.append("<br/>" + successNum + "、账号 " + user.getUserName() + " 导入成功");
}
else if (isUpdateSupport)
{
BeanValidators.validateWithException(validator, user);
checkUserAllowed(u);
checkUserDataScope(u.getUserId());
user.setUserId(u.getUserId());
user.setUpdateBy(operName);
userMapper.updateUser(user);
successNum++;
successMsg.append("<br/>" + successNum + "、账号 " + user.getUserName() + " 更新成功");
}
else
{
failureNum++;
failureMsg.append("<br/>" + failureNum + "、账号 " + user.getUserName() + " 已存在");
}
}
catch (Exception e)
{
failureNum++;
String msg = "<br/>" + failureNum + "、账号 " + user.getUserName() + " 导入失败:";
failureMsg.append(msg + e.getMessage());
log.error(msg, e);
}
}
if (failureNum > 0)
{
failureMsg.insert(0, "很抱歉,导入失败!共 " + failureNum + " 条数据格式不正确,错误如下:");
throw new ServiceException(failureMsg.toString());
}
else
{
successMsg.insert(0, "恭喜您,数据已全部导入成功!共 " + successNum + " 条,数据如下:");
}
return successMsg.toString();
}
}
package com.dsk.jsk.service.service.impl;
import cn.hutool.core.bean.BeanUtil;
import cn.hutool.core.util.ObjectUtil;
import com.dsk.acc.openapi.client.util.CommonUtils;
import com.dsk.common.core.domain.AjaxResult;
import com.dsk.common.dtos.UrbanInvestmentPlatformDto;
import com.dsk.common.dtos.UrbanInvestmentPlatformSubjectLevelDto;
import com.dsk.common.utils.DskOpenApiUtil;
import com.dsk.system.domain.customer.vo.CustomerStatusListVo;
import com.dsk.system.service.ICustomerService;
import com.dsk.system.service.UrbanInvestmentPlatformService;
import org.apache.commons.collections4.CollectionUtils;
import org.apache.commons.collections4.MapUtils;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.http.HttpStatus;
import org.springframework.stereotype.Service;
import java.util.*;
/**
* @ClassName EconomicServiceImpl
* @Description 城投平台业务层实现
* @Author Dgm
* @Date 2023/5/18 10:23
* @Version
*/
@Service
public class UrbanInvestmentPlatformServiceImpl implements UrbanInvestmentPlatformService {
@Autowired
private DskOpenApiUtil dskOpenApiUtil;
@Autowired
private ICustomerService iCustomerService;
@Override
public AjaxResult page(UrbanInvestmentPlatformDto pageDto) {
Map<String, Object> map = dskOpenApiUtil.requestBody("/operate/urbanInvestment/page", BeanUtil.beanToMap(pageDto, false, false));
Integer code = MapUtils.getInteger(map, "code", 300);
if (HttpStatus.OK.value() != code) {
throw new RuntimeException();
}
Map data = MapUtils.getMap(map, "data", null);
List<Object> list = CommonUtils.assertAsArray(MapUtils.getObject(data, "list", ""));
if (CollectionUtils.isEmpty(list)) {
return BeanUtil.toBean(map, AjaxResult.class);
}
ArrayList<String> companyNames = new ArrayList<>();
ArrayList<Long> cIds = new ArrayList<>();
for (Object dataMap : list) {
String name = MapUtils.getString(CommonUtils.assertAsMap(dataMap), "companyName");
if (ObjectUtil.isNotEmpty(name) && ObjectUtil.isNotEmpty(pageDto.getKeyword())) {
name = name.replaceAll("<font color='red'>","");
name = name.replaceAll("</font>","");
companyNames.add(name);
} else {
companyNames.add(name);
}
cIds.add(MapUtils.getLong(CommonUtils.assertAsMap(dataMap), "companyId"));
}
List<CustomerStatusListVo> customerStatusListVos = iCustomerService.selectStatusListByCompanyName(companyNames);
// Map<String, Object> bondCreditRatingBatchMap = new HashMap<>(1);
// bondCreditRatingBatchMap.put("cIds", cIds);
// Map<String, Object> bondCreditRatingMap = dskOpenApiUtil.requestBody("/operate/operate/enterprise/bondCreditRatingBatch", bondCreditRatingBatchMap);
// Integer codeRating = MapUtils.getInteger(bondCreditRatingMap, "code", 300);
// ArrayList<Map<String, Object>> objArrayList = new ArrayList(1);
// if (codeRating.equals(HttpStatus.OK.value())) {
// Object object = bondCreditRatingMap.get("data");
// if (ObjectUtil.isNotEmpty(object)) {
// objArrayList = (ArrayList)object;
// }
// }
//按照城投企业id合并两个list
//按照城投企业id合并两个list
for (Object companyObj : list) {
Map<String, Object> companyMap = CommonUtils.assertAsMap(companyObj);
Long companyId = MapUtils.getLong(companyMap, "companyId");
String uipId = MapUtils.getString(companyMap, "uipId");
String companyName = MapUtils.getString(companyMap, "companyName", "");
if (ObjectUtil.isNotEmpty(companyName) && ObjectUtil.isNotEmpty(pageDto.getKeyword())) {
companyName = companyName.replaceAll("<font color='red'>","");
companyName = companyName.replaceAll("</font>","");
}
companyMap.put("claimStatus", null);
// companyMap.put("bratingSubjectLevel", null);
for (CustomerStatusListVo vo : customerStatusListVos) {
if (companyName.equals(vo.getCompanyName())) {
companyMap.put("claimStatus", vo.getStatus());
}
}
// 去除重复的数据
// Set<UrbanInvestmentPlatformSubjectLevelDto> subjectLevelDtoSet = new HashSet<>();
// for (Map<String, Object> m : objArrayList) {
// UrbanInvestmentPlatformSubjectLevelDto dto = new UrbanInvestmentPlatformSubjectLevelDto();
// Long companyIdCredit = MapUtils.getLong(m, "companyId", 0L);
// String rate = MapUtils.getString(m, "bratingSubjectLevel");
// dto.setCompanyId(companyIdCredit);
// dto.setBratingSubjectLevel(rate);
// subjectLevelDtoSet.add(dto);
// }
// for (UrbanInvestmentPlatformSubjectLevelDto dto : subjectLevelDtoSet) {
// if (dto.getCompanyId().equals(companyId)) {
// companyMap.put("bratingSubjectLevel", dto.getBratingSubjectLevel());
// }
// }
}
return BeanUtil.toBean(map, AjaxResult.class);
}
@Override
public AjaxResult details(String id) {
Map<String, Object> bodyMap = new HashMap<>(1);
bodyMap.put("id", id);
Map<String, Object> map = dskOpenApiUtil.requestBody("/operate/urbanInvestment/details", bodyMap);
return BeanUtil.toBean(map, AjaxResult.class);
}
@Override
public AjaxResult statistics(UrbanInvestmentPlatformDto dto) {
Map<String, Object> map = dskOpenApiUtil.requestBody("/operate/urbanInvestment/statistics", BeanUtil.beanToMap(dto, false, false));
return BeanUtil.toBean(map, AjaxResult.class);
}
}
/**
*
*/
package com.dsk.jsk.util;
import java.util.Arrays;
import java.util.List;
/**
* 常量类
* @author xiaofei.qin
*
*/
public final class BizConstant {
/**
* http header里的常量
*/
public final static String HEADER_KEY_TOKEN = "token";
/**
* 中国的省份编码
*/
public final static int PROVINCE_CHINA = 100000;
public static final Integer BASE_CERTIFICATE_PARENT_ID = 0;
public final static String PROJECT_DATE_GROUP = "project_date_group";
public final static String FEEDBACK_GROUP = "feedback_group";
public final static String PROJECT_AMOUNT = "project_amount";
public final static String PROJECT_AMOUNT_2 = "project_amount2";
public final static String SPLIT_CHAR = ",";
public final static String SIKUYI = "全国建筑市场监管公共服务平台";
public final static String OTHER = "其他建筑市场平台";
public final static Integer PAGE_ROW = 10;
//权限表基础保存功能
public final static String basicsave = "ROLE_SYS_PERMISSION_SAVE";
//权限表基础修改功能
public final static String basicupdate = "ROLE_SYS_PERMISSION_UPDATE";
//权限表基础删除功能
public final static String basicdelete = "ROLE_SYS_PERMISSION_DEL";
public final static List<String> SPECIAL_CHARACTER = Arrays.asList("有限", "限公", "公司", "限责", "责任", "任公", "股份", "份有", "有限公", "限公司", "有限责", "有限公司", "有限责任",
"责任公司", "有限公司", "有限责任公司", "股份有限公司", "监理", "工程", "建筑", "建设");
public final static List<String> COMPANY_NOT_CHARACTER = Arrays.asList("日期", "时间", "公告", "中标",
"候选人", "公示", "联合体", "公开");
public final static List<String> CONSTRUCTION = Arrays.asList("建设", "安装", "总承包", "EPC", "施工",
"工程", "项目", "升级", "改造", "拆除", "绿化", "楼", "路", "桥", "水", "建", "工程", "测", "房",
"改造", "路", "道", "施", "建", "处理", "地", "坡", "沟", "池", "场", "修", "设",
"舍", "标段", "城", "治", "期", "堂", "消防", "小区", "饰", "景观", "园", "栋", "馆", "站"
, "中心", "座", "规划", "殿", "厅", "库", "公寓", "厦", "车间", "院", "屋", "水利", "厕所"
, "宅", "管网", "学", "砖", "所", "点", "家", "EPC", "PMC", "DB", "DBB", "CM", "BOT", "PPP");
public final static List<String> SUPERVISION = Arrays.asList("监理");
public final static List<String> SURVEY = Arrays.asList("勘察", "设计", "测绘");
public final static List<String> CONSULTATION = Arrays.asList("咨询", "管理");
public final static List<String> OTHERBID = Arrays.asList("采购");
public final static int CONSTRUCTIONNO = 1;
public final static int SUPERVISIONNO = 2;
public final static int SURVEYNO = 3;
public final static int CONSULTATIONNO = 4;
public final static int OTHERBIDNO = 5;
/**
* 中标项目名不包含字符
*/
public final static List<String> PROJECT_NOT_CHARACTER = Arrays.asList("报价", "联合", "日期", "时间", "公告", "投标", "公开", "公布", "如下", "中标", "编号", "建造师", "元", "唱标");
public final static List<String> COMPANY_CHARACTER = Arrays.asList("公司", "局", "院", "集团",
"所", "中心", "处", "厂", "大学", "队", "部", "站", "室", "场", "合作社");
public final static List<String> COMPANY_BUILD_CHARACTER = Arrays.asList("施工", "工程", "实业", "建筑", "建设", "安装", "勘察", "设计", "监理", "技术", "科技");
public final static List<String> PROVINCE = Arrays.asList("北京", "天津", "河北",
"山西", "内蒙古", "辽宁", "吉林", "黑龙江", "上海", "江苏", "浙江", "安徽",
"福建", "江西", "山东", "河南", "湖北", "湖南", "广东", "广西", "海南",
"重庆", "四川", "贵州", "云南", "西藏", "陕西", "甘肃", "青海", "宁夏", "新疆"
);
public final static List<String> SPIDER = Arrays.asList("baidu.com", "google", "google.com", "googlebot","YisouSpider","Bytespider","bytedance.com",
"so", "so.com", "360spider", "sogou", "sogou.com", "msn", "msn.com", "bing", "bing.com", "sm.cn", "youdao");
public final static String PROVINCE_CODE = "[{\"Code\":\"CN\",\"ProvinceName\":\"全国\"},{\"Code\":\"BJ\",\"ProvinceName\":\"北京\"},{\"Code\":\"TJ\",\"ProvinceName\":\"天津\"},{\"Code\":\"HB\",\"ProvinceName\":\"河北\"},{\"Code\":\"SX\",\"ProvinceName\":\"山西\"},{\"Code\":\"NMG\",\"ProvinceName\":\"内蒙古\"},{\"Code\":\"LN\",\"ProvinceName\":\"辽宁\"},{\"Code\":\"JL\",\"ProvinceName\":\"吉林\"},{\"Code\":\"HLJ\",\"ProvinceName\":\"黑龙江\"},{\"Code\":\"SH\",\"ProvinceName\":\"上海\"},{\"Code\":\"JS\",\"ProvinceName\":\"江苏\"},{\"Code\":\"ZJ\",\"ProvinceName\":\"浙江\"},{\"Code\":\"AH\",\"ProvinceName\":\"安徽\"},{\"Code\":\"FJ\",\"ProvinceName\":\"福建\"},{\"Code\":\"JX\",\"ProvinceName\":\"江西\"},{\"Code\":\"SD\",\"ProvinceName\":\"山东\"},{\"Code\":\"HEN\",\"ProvinceName\":\"河南\"},{\"Code\":\"HUB\",\"ProvinceName\":\"湖北\"},{\"Code\":\"HUN\",\"ProvinceName\":\"湖南\"},{\"Code\":\"GD\",\"ProvinceName\":\"广东\"},{\"Code\":\"GX\",\"ProvinceName\":\"广西\"},{\"Code\":\"HAIN\",\"ProvinceName\":\"海南\"},{\"Code\":\"CQ\",\"ProvinceName\":\"重庆\"},{\"Code\":\"SC\",\"ProvinceName\":\"四川\"},{\"Code\":\"GZ\",\"ProvinceName\":\"贵州\"},{\"Code\":\"YN\",\"ProvinceName\":\"云南\"},{\"Code\":\"XZ\",\"ProvinceName\":\"西藏\"},{\"Code\":\"SAX\",\"ProvinceName\":\"陕西\"},{\"Code\":\"GS\",\"ProvinceName\":\"甘肃\"},{\"Code\":\"QH\",\"ProvinceName\":\"青海\"},{\"Code\":\"NX\",\"ProvinceName\":\"宁夏\"},{\"Code\":\"XJ\",\"ProvinceName\":\"新疆\"}]";
public final static String PROVINCE_SIMPLE_CODE = "{\"CN\":\"全国\",\"BJ\":\"北京\",\"TJ\":\"天津\",\"HB\":\"河北\",\"SX\":\"山西\",\"NMG\":\"内蒙古\",\"LN\":\"辽宁\",\"JL\":\"吉林\",\"HLJ\":\"黑龙江\",\"SH\":\"上海\",\"JS\":\"江苏\",\"ZJ\":\"浙江\",\"AH\":\"安徽\",\"FJ\":\"福建\",\"JX\":\"江西\",\"SD\":\"山东\",\"HEN\":\"河南\",\"HUB\":\"湖北\",\"HUN\":\"湖南\",\"GD\":\"广东\",\"GX\":\"广西\",\"HAIN\":\"海南\",\"CQ\":\"重庆\",\"SC\":\"四川\",\"GZ\":\"贵州\",\"YN\":\"云南\",\"XZ\":\"西藏\",\"SAX\":\"陕西\",\"GS\":\"甘肃\",\"QH\":\"青海\",\"NX\":\"宁夏\",\"XJ\":\"新疆\"}";
public final static List<String> MESSY_CODE = Arrays.asList("Ð", "Ï", "¹", "Ê", "Õ", "¡", "Ö", "±", "¾", "µ", "½", "�");
public final static String accessToken = "token";
/**
* 冻结
*/
public final static String FROZEN = "frozen";
/**
* 启用
*/
public final static String DEFROST = "defrost";
/**
* 验证码短信模板: 您的注册校验码是${code},10分钟内有效,请勿将校验码泄漏给他人。如非本人操作,请忽略本条消息。
*/
public final static String SMS_181860796 = "SMS_181860796";
/**
* 密码短信模板: 感谢您注册建设库平台!您的初始密码为“${name}”请您尽快修改密码,提高账号安全性。
*/
public final static String SMS_145500857 = "SMS_145500857";
/**
* 注册成功
*/
public final static String SMS_174024045 = "SMS_174024045";
/**
* vip赠送
*/
public final static String SMS_174024049 = "SMS_174024049";
/**
* 活动手机验证码
*/
public final static String SMS_174029192 = "SMS_174029192";
/**
* H5引流页注册成功提示下载
*/
public final static String SMS_176528768 = "SMS_176528768";
/**
* H5引流页短信验证码
*/
public final static String SMS_176936886 = "SMS_176936886";
/**
* 密码登录提醒
*/
public final static String SMS_176938027 = "SMS_176938027";
/**
* 向好友推送招标公告
*/
public final static String SMS_182541746 = "SMS_182541746";
/**
* 用户订阅招标公告推送
*/
public final static String SMS_182541747 = "SMS_182541747";
public final static String SMS_136390617 = "SMS_136390617";
public final static String PROJECT_SOURCE = "project_source";
public final static int china = 100000;
public final static String China = "全国";
/**
* 最大页数
*/
public final static int MAX_PAGE_INDEX = 100;
/**
* 每页条数
*/
public final static int MAX_PAGE_SIZE = 20;
/**
* 每页条数
*/
public final static int MOBILE_MAX_PAGE_SIZE = 20;
/**
* 游客及普通用户显示条数
*/
public final static int VISITOR_ACCOUNT_PAGE_SIZE = 10;
/**
* 最大记录数
*/
public final static int MAX_RECORD_SIZE = 2000;
/**
* 生成账号
*/
public static final Integer USER_ACOUNT_BASE = 10000;
public static final Integer SVIP_MAX_EXPORT_COUNT = 20000;
public static final Integer MAX_EXPORT_COUNT = 2000;
/**
* 最大标签数
*/
public final static int MAX_LEBEL_SIZE = 200;
public final static int MAX_PAGE_SIZE_PC = 201;
/**
* 水滴信用信息更新时间
*/
public static final Integer SHUIDI_DATA_UPDATE_TIME = 2;
/**
* 水滴信用信息更新时间
*/
public static final Integer SHUIDI_DATA_UPDATE_TIME_ONE = 1;
public final static String CLIENT_IOS = "IOS";
public final static String CLIENT_MP = "mp";
public final static String CLIENT_NODEJS = "nodejs";
public final static String CLIENT_WRAP = "wrap";
public final static String CLIENT_ANDROID = "ANDROID";
public static final String MUNICIPALITY = "北京上海重庆天津";
public static final String NORTHCHINA = "北京市天津市河北省山西省内蒙古自治区";
public static final String SOUTHCHINA = "广东省海南省广西壮族自治区";
public static final String EASTCHINA = "上海市江苏省浙江省安徽省福建省江西省山东省";
public static final String MIDCHINA = "河南省湖北省湖南省";
public static final String WESTSOUTH = "重庆市四川省贵州省云南省西藏自治区";
public static final String EASTNORTH = "黑龙江省辽宁省吉林省";
public static final String WESTNORTH = "陕西省甘肃省青海省宁夏回族自治区新疆维吾尔自治区";
public final static String SERVICE_TYPE_VIP_CODE = "VIP";
public final static String SERVICE_TYPE_BZ = "BZ";
public final static String SERVICE_TYPE_PT = "PT";
public final static String SERVICE_TYPE_SD = "SD";
public final static String VIP_MVIP = "MVIP";
public final static String VIP_QVIP = "QVIP";
public final static String VIP_HYVIP = "HYVIP";
public final static String VIP_YVIP = "YVIP";
public final static String ONE_YEAR_VIP = "1YVIP";
public final static String TWO_YEAR_VIP = "2YVIP";
public final static String THREE_YEAR_VIP = "3YVIP";
public final static String STORE_NEW_CODE = "storeNew";
public final static String STORE_NEW_GROUP = "store";
public final static String SERVICE_TYPE_VIP = "2";
public final static String SERVICE_TYPE_BG = "1";
public final static String VIP = "vip";
public final static String START_TIME = "startTime";
public final static String END_TIME = "endTime";
public final static String VIP_TYPE_3_HOUR = "HOURVIP";
// 信用报告类型
public final static String GROUP_SERVICE_TYPE = "serviceType";
public final static String CODE_PT = "PT";
public final static String CODE_BZ = "BZ";
public final static String PT_USER = "pt_user";
public final static String VIP_USER = "vip_user";
/**
* 支付宝正式环境网关地址
*/
public static final String PAY_ALI_GATEURL = "https://openapi.alipay.com/gateway.do";
/**
* 支付宝正式环境APPID
*/
public static final String PAY_ALI_APPID = "2018103161911828";
public static final String RSA_PRIVATE_KEY = "MIIEvQIBADANBgkqhkiG9w0BAQEFAASCBKcwggSjAgEAAoIBAQDbCQx2tczOecOJ4weztxnamFkNDX2ng0t/UKNwZzi2huEh621cN772ck2yO72/rfyioCSHPAg86XPCtjxaAbIKVRR+w1AC5oG6foUl9H+Mu2lvd9d6hIUzl0mSH4MaHgT21BO6oYE9E4IvDcy5kWfdor46tqDd4Md6gXle79/pgIP2P/xV106mZ1DP8V4G0yopa1DZ1xmMyrJZryy/oRs44u2j75l6Xz551K/lGyh96GPW8X46Ar7iLTajx8tf3H1ssgxudEqYYBlFtwryPWwoQdWawK9uJmFKw73BplhpStQSHokmVwFsXPPLyT/GtWTVUd7dyvEKGXs86B7jkhXtAgMBAAECggEAB83Put8JWAXwmJYVLSsF6crpyVREuNYtt3CJEjUrSR2PIeVAdTurOx6hdAs63Hx3dtfb1VGnPXxX2oUhq1dKH6IeY9HTpPbPgnSFi++lJ795pzYO4FeeY1MtlN44jpKpPJ4bwdeFQkbSqZiFRctPdw8YVgExxBYBJXU9fMtxH+GacV0koZmI4DGxo4fv0LhT2M+8rG6584vP8mly0jji/rCVzh6LapTPNV1QHRWx5d4r6aAghQ4DxBx+WaFhq1j9NV2NgLhfflt+2NNlmJ4xD3sGAXrzPqolS3cGb4BR9jq2v6v1Qs1F7nsp0DzSI3FLuht0VluiIWj7e3fR2Bt1hQKBgQDx26A/dU2yLF8nRbG69XrHteL0ATYa6nrNa3EPze2vyLMLRTfA0Ocao8u7FyuhQA0mA0DIzT6mwvnEIKlGKC3/XRqqKZw5GdVq0BpDjvLhPg3cOVHxefogcM0AiBJzEgmXG8gUxgpUCL2mKpZO9HeEF3h9yay5m1uam/rjG5MISwKBgQDn18qbIy2TE+X5YptdRGuCOwGRH70hB6RCiQFZY8EZsjvj0+FzBAD9HZHy5aNVS6m1ynn8ArB9MUMvLp6K1rDz/YcQAxN3tF/KmcP7dpxBtsZI68xKqLNUTLe1mjGce3hjLtUXbmJOCGUN4yFbk+u98VuwCXyPPwml0HnAqwTnpwKBgQCbfc3avnnDMQ/D2eTYA/Z56xAMO7MjPtjQtGCt/oDvYKLrfgbIKgZKdEAI+m6MbveFFtZRwtKit/uIAk+R0UcxRBRejf3oIBm7YCtif8ba1OBoU1nBW+BZduv1iYYDAPe1dKD/6gq92BjFed/ExxsHi2dlx4EKmz0be2ijFhlDXQKBgAgYEIq5/61S1ISQXLw010wEo1ldskyk56crAVENmoA7KLwbeZN6YE516dKBEeK4cYRXPUr/DQpR3faXuhE+zY63GzAD63oSYgXAuIbe7TWeG+4PzWIN4bTfuMouR+0eomVUDTx0LhprUJvbgh6gW2qWMo1Cx4Z4vO19CcMgNVuhAoGAfJfl0gWBtc4rJ/mLz1YD08X0oEcTUvw+HSQTjtG4BHa1aI1jHXe9h1+uZm9eacxzqdJ03zfWThV66SAsKjXrbIrb9e2x2OcT9DdXoqF9R5aSQzpTdvK3NMmnE4AKbb32xrGlBgINCFvxcCRRlkPK0jwl8D3IrWE/+YAXhGGAcC8=";
public static final String RSA_PUBLIC_KEY = "MIIBIjANBgkqhkiG9w0BAQEFAAOCAQ8AMIIBCgKCAQEA2wkMdrXMznnDieMHs7cZ2phZDQ19p4NLf1CjcGc4tobhIettXDe+9nJNsju9v638oqAkhzwIPOlzwrY8WgGyClUUfsNQAuaBun6FJfR/jLtpb3fXeoSFM5dJkh+DGh4E9tQTuqGBPROCLw3MuZFn3aK+Orag3eDHeoF5Xu/f6YCD9j/8VddOpmdQz/FeBtMqKWtQ2dcZjMqyWa8sv6EbOOLto++Zel8+edSv5Rsofehj1vF+OgK+4i02o8fLX9x9bLIMbnRKmGAZRbcK8j1sKEHVmsCvbiZhSsO9waZYaUrUEh6JJlcBbFzzy8k/xrVk1VHe3crxChl7POge45IV7QIDAQAB";
/**
* 微信支付分配的商户号
*/
public static final String PAY_WX_MCHID = "1555277781";
/**
* trade_type=NATIVE,此参数必传。此id为二维码中包含的商品ID,商户自行定义。
*/
public static final String PAY_WX_PRODUCTID = "69641265";
/**
* 微信公众号appID
*/
public static final String WX_APPID = "wx3516e7f1706ef4f2";
/**
* 微信公众号appSecret
*/
public static final String WX_APPSECRET = "577265a4db8549fb275d84380ac782f9";
/**
* 微信分配的APP账号ID
*/
public static final String PAY_WX_APPID = "wx0bb7f3c347631215";
/**
* 微信分配的小程序账号ID
*/
public static final String PAY_WX_XCX_APPID = "wx34e8004a2b6c8f4b";
/**
* 微信分配的小程序商户号
*/
public static final String PAY_WX_XCX_MCHID = "wx34e8004a2b6c8f4b";
/**
* https://open.weixin.qq.com/
* 开发者平台app应用得secret:APP_SECRET
*/
public static final String PAY_WX_APP_SECRET = "daddb90bd88cb56e437ae2cecf0e8dd7";
/**
* 微信支付相关
* <p>
* 财付通商户号对应的密钥 <br/>
* 具体获得途径如下:<br/>
* 微信商户平台(pay.weixin.qq.com)-->账户设置-->API安全-->密钥设置
* </p>
*/
public static final String PAY_WX_SECRET = "hhFbrSQQ9W6rDxfn75C52zjTLjdFrYTg";
/**
* 微信支付网关地址
*/
public static final String PAY_WX_GATEURL = "https://api.mch.weixin.qq.com/pay/unifiedorder";
/**
* 调用微信PC端的交易类型
*/
public static final String PAY_WX_PC_TRADETYPE = "NATIVE";
/**
* 调用微信Wrap端的交易类型
*/
public static final String PAY_WX_WRAP_TRADETYPE = "MWEB";
/**
* 调用微信Wrap端的交易类型
*/
public static final String PAY_WX_JSAPI_TRADETYPE = "JSAPI";
/**
* 调用微信APP端的交易类型
*/
public static final String PAY_WX_APP_TRADETYPE = "APP";
}
package com.dsk.jsk.util;
import org.apache.commons.lang3.StringUtils;
import javax.servlet.http.HttpServletRequest;
import java.io.BufferedReader;
import java.io.Closeable;
import java.io.File;
import java.io.InputStreamReader;
import java.util.Arrays;
import java.util.List;
/**
* IP校验
*/
public class IpUtil {
public final static List<String> qihooSpider = Arrays.asList("180.153.232","180.153.234","180.153.236","180.163.220","42.236.101","42.236.102","42.236.103","42.236.10","42.236.12","42.236.13","42.236.14","42.236.15","42.236.16","42.236.17","42.236.46","42.236.48","42.236.49","42.236.50","42.236.51","42.236.52","42.236.53","42.236.54","42.236.55","42.236.99");
public final static List<String> YisouSpider = Arrays.asList("106.11.152","106.11.153","106.11.154","106.11.155","106.11.156","106.11.157","106.11.158","106.11.159","42.120.160","42.120.161","42.156.136","42.156.137","42.156.138","42.156.139","42.156.254");
public final static List<String> ByteSpider = Arrays.asList("110.249.201","110.249.202","111.225.147","111.225.148","111.225.149","220.243.135","220.243.136","60.8.165","60.8.9");
/**获取访问用户的客户端IP(适用于公网与局域网)*/
public static final String getIpAddr(final HttpServletRequest request){
try{
if (request == null) return null;
String ipString = request.getHeader("ali-cdn-real-ip");
if (StringUtils.isBlank(ipString) || "unknown".equalsIgnoreCase(ipString)) {
ipString = request.getHeader("x-forwarded-for");
}
if (StringUtils.isBlank(ipString) || "unknown".equalsIgnoreCase(ipString)) {
ipString = request.getHeader("Proxy-Client-IP");
}
if (StringUtils.isBlank(ipString) || "unknown".equalsIgnoreCase(ipString)) {
ipString = request.getHeader("X-Forwarded-For");
}
if (StringUtils.isBlank(ipString) || "unknown".equalsIgnoreCase(ipString)) {
ipString = request.getHeader("WL-Proxy-Client-IP");
}
if (StringUtils.isBlank(ipString) || "unknown".equalsIgnoreCase(ipString)) {
ipString = request.getHeader("X-Real-IP");
}
if (StringUtils.isBlank(ipString) || "unknown".equalsIgnoreCase(ipString)) {
ipString = request.getRemoteAddr();
}
// 多个路由时,取第一个非unknown的ip
final String[] arr = ipString.split(",");
for (final String str : arr) {
if (!"unknown".equalsIgnoreCase(str)) {
ipString = str;
break;
}
}
return ipString;
}catch(Exception e){
return null;
}
}
/**
* write specfield bytes to a byte array start from offset
*
* @param b
* @param offset
* @param v
* @param bytes
*/
public static void write( byte[] b, int offset, long v, int bytes) {
for ( int i = 0; i < bytes; i++ ) {
b[offset++] = (byte)((v >>> (8 * i)) & 0xFF);
}
}
/**
* write a int to a byte array
*
* @param b
* @param offset
* @param v
*/
public static void writeIntLong( byte[] b, int offset, long v ) {
b[offset++] = (byte)((v >> 0) & 0xFF);
b[offset++] = (byte)((v >> 8) & 0xFF);
b[offset++] = (byte)((v >> 16) & 0xFF);
b[offset ] = (byte)((v >> 24) & 0xFF);
}
/**
* get a int from a byte array start from the specifiled offset
*
* @param b
* @param offset
*/
public static long getIntLong( byte[] b, int offset ) {
return (
((b[offset++] & 0x000000FFL)) |
((b[offset++] << 8) & 0x0000FF00L) |
((b[offset++] << 16) & 0x00FF0000L) |
((b[offset ] << 24) & 0xFF000000L)
);
}
/**
* get a int from a byte array start from the specifield offset
*
* @param b
* @param offset
*/
public static int getInt3( byte[] b, int offset ) {
return (
(b[offset++] & 0x000000FF) |
(b[offset++] & 0x0000FF00) |
(b[offset ] & 0x00FF0000)
);
}
public static int getInt2( byte[] b, int offset ) {
return (
(b[offset++] & 0x000000FF) |
(b[offset ] & 0x0000FF00)
);
}
public static int getInt1( byte[] b, int offset ) {
return (
(b[offset] & 0x000000FF)
);
}
/**
* string ip to long ip
*
* @param ip
* @return long
*/
public static long ip2long( String ip ) {
String[] p = ip.split("\\.");
if ( p.length != 4 ) return 0;
int p1 = ((Integer.valueOf(p[0]) << 24) & 0xFF000000);
int p2 = ((Integer.valueOf(p[1]) << 16) & 0x00FF0000);
int p3 = ((Integer.valueOf(p[2]) << 8) & 0x0000FF00);
int p4 = ((Integer.valueOf(p[3]) << 0) & 0x000000FF);
return ((p1 | p2 | p3 | p4) & 0xFFFFFFFFL);
}
/**
* int to ip string
*
* @param ip
* @return string
*/
public static String long2ip( long ip ) {
StringBuilder sb = new StringBuilder();
sb
.append((ip >> 24) & 0xFF).append('.')
.append((ip >> 16) & 0xFF).append('.')
.append((ip >> 8) & 0xFF).append('.')
.append((ip >> 0) & 0xFF);
return sb.toString();
}
/**
* check the validate of the specifeld ip address
*
* @param ip
* @return boolean
*/
public static boolean isIpAddress( String ip ) {
String[] p = ip.split("\\.");
if ( p.length != 4 ) return false;
for ( String pp : p ) {
if ( pp.length() > 3 ) return false;
int val = Integer.valueOf(pp);
if ( val > 255 ) return false;
}
return true;
}
public static String execHostCmd(String ip) throws Exception {
return execCmd("host "+ip, null);
}
public static String isSpider(String ip) throws Exception {
String result = execCmd("host "+ip, null);
if(StringUtils.isNotBlank(ip)&&!isSpiderUa(result)){
for (String s : qihooSpider) {
if(ip.startsWith(s)){
return "so.com";
}
}
for (String s : YisouSpider) {
if(ip.startsWith(s)){
return "sm.cn";
}
}
for (String s : ByteSpider) {
if(ip.startsWith(s)){
return "bytedance.com";
}
}
}
return result;
}
/**
* 执行系统命令, 返回执行结果
*
* @param cmd 需要执行的命令
* @param dir 执行命令的子进程的工作目录, null 表示和当前主进程工作目录相同
*/
private static String execCmd(String cmd, File dir) throws Exception {
StringBuilder result = new StringBuilder();
Process process = null;
BufferedReader bufrIn = null;
BufferedReader bufrError = null;
try {
// 执行命令, 返回一个子进程对象(命令在子进程中执行)
process = Runtime.getRuntime().exec(cmd, null, dir);
// 方法阻塞, 等待命令执行完成(成功会返回0)
process.waitFor();
// 获取命令执行结果, 有两个结果: 正常的输出 和 错误的输出(PS: 子进程的输出就是主进程的输入)
bufrIn = new BufferedReader(new InputStreamReader(process.getInputStream(), "UTF-8"));
bufrError = new BufferedReader(new InputStreamReader(process.getErrorStream(), "UTF-8"));
// 读取输出
String line = null;
while ((line = bufrIn.readLine()) != null) {
result.append(line).append('n');
}
while ((line = bufrError.readLine()) != null) {
result.append(line).append('n');
}
} finally {
closeStream(bufrIn);
closeStream(bufrError);
// 销毁子进程
if (process != null) {
process.destroy();
}
}
// 返回执行结果
return result.toString();
}
private static void closeStream(Closeable stream) {
if (stream != null) {
try {
stream.close();
} catch (Exception e) {
// nothing
}
}
}
private static boolean isSpiderUa(String hostname){
List<String> spiders = BizConstant.SPIDER;
for (String spider : spiders) {
if (hostname.toLowerCase().contains(spider)){
return true;
}
}
return false;
}
}
package com.dsk.jsk.util;
import java.util.Collection;
import java.util.Iterator;
import java.util.List;
import java.util.Map;
import java.util.Set;
import java.util.concurrent.TimeUnit;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.data.redis.core.BoundSetOperations;
import org.springframework.data.redis.core.HashOperations;
import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.data.redis.core.ValueOperations;
import org.springframework.stereotype.Component;
/**
* spring redis 工具类
*
* @author dsk
**/
@SuppressWarnings(value = { "unchecked", "rawtypes" })
@Component
public class RedisCache
{
@Autowired
public RedisTemplate redisTemplate;
/**
* 缓存基本的对象,Integer、String、实体类等
*
* @param key 缓存的键值
* @param value 缓存的值
*/
public <T> void setCacheObject(final String key, final T value)
{
redisTemplate.opsForValue().set(key, value);
}
/**
* 缓存基本的对象,Integer、String、实体类等
*
* @param key 缓存的键值
* @param value 缓存的值
* @param timeout 时间
* @param timeUnit 时间颗粒度
*/
public <T> void setCacheObject(final String key, final T value, final Integer timeout, final TimeUnit timeUnit)
{
redisTemplate.opsForValue().set(key, value, timeout, timeUnit);
}
/**
* 设置有效时间
*
* @param key Redis键
* @param timeout 超时时间
* @return true=设置成功;false=设置失败
*/
public boolean expire(final String key, final long timeout)
{
return expire(key, timeout, TimeUnit.SECONDS);
}
/**
* 设置有效时间
*
* @param key Redis键
* @param timeout 超时时间
* @param unit 时间单位
* @return true=设置成功;false=设置失败
*/
public boolean expire(final String key, final long timeout, final TimeUnit unit)
{
return redisTemplate.expire(key, timeout, unit);
}
/**
* 获取有效时间
*
* @param key Redis键
* @return 有效时间
*/
public long getExpire(final String key)
{
return redisTemplate.getExpire(key);
}
/**
* 判断 key是否存在
*
* @param key 键
* @return true 存在 false不存在
*/
public Boolean hasKey(String key)
{
return redisTemplate.hasKey(key);
}
/**
* 获得缓存的基本对象。
*
* @param key 缓存键值
* @return 缓存键值对应的数据
*/
public <T> T getCacheObject(final String key)
{
ValueOperations<String, T> operation = redisTemplate.opsForValue();
return operation.get(key);
}
/**
* 删除单个对象
*
* @param key
*/
public boolean deleteObject(final String key)
{
return redisTemplate.delete(key);
}
/**
* 删除集合对象
*
* @param collection 多个对象
* @return
*/
public boolean deleteObject(final Collection collection)
{
return redisTemplate.delete(collection) > 0;
}
/**
* 缓存List数据
*
* @param key 缓存的键值
* @param dataList 待缓存的List数据
* @return 缓存的对象
*/
public <T> long setCacheList(final String key, final List<T> dataList)
{
Long count = redisTemplate.opsForList().rightPushAll(key, dataList);
return count == null ? 0 : count;
}
/**
* 获得缓存的list对象
*
* @param key 缓存的键值
* @return 缓存键值对应的数据
*/
public <T> List<T> getCacheList(final String key)
{
return redisTemplate.opsForList().range(key, 0, -1);
}
/**
* 缓存Set
*
* @param key 缓存键值
* @param dataSet 缓存的数据
* @return 缓存数据的对象
*/
public <T> BoundSetOperations<String, T> setCacheSet(final String key, final Set<T> dataSet)
{
BoundSetOperations<String, T> setOperation = redisTemplate.boundSetOps(key);
Iterator<T> it = dataSet.iterator();
while (it.hasNext())
{
setOperation.add(it.next());
}
return setOperation;
}
/**
* 获得缓存的set
*
* @param key
* @return
*/
public <T> Set<T> getCacheSet(final String key)
{
return redisTemplate.opsForSet().members(key);
}
/**
* 缓存Map
*
* @param key
* @param dataMap
*/
public <T> void setCacheMap(final String key, final Map<String, T> dataMap)
{
if (dataMap != null) {
redisTemplate.opsForHash().putAll(key, dataMap);
}
}
/**
* 获得缓存的Map
*
* @param key
* @return
*/
public <T> Map<String, T> getCacheMap(final String key)
{
return redisTemplate.opsForHash().entries(key);
}
/**
* 往Hash中存入数据
*
* @param key Redis键
* @param hKey Hash键
* @param value 值
*/
public <T> void setCacheMapValue(final String key, final String hKey, final T value)
{
redisTemplate.opsForHash().put(key, hKey, value);
}
/**
* 获取Hash中的数据
*
* @param key Redis键
* @param hKey Hash键
* @return Hash中的对象
*/
public <T> T getCacheMapValue(final String key, final String hKey)
{
HashOperations<String, String, T> opsForHash = redisTemplate.opsForHash();
return opsForHash.get(key, hKey);
}
/**
* 获取多个Hash中的数据
*
* @param key Redis键
* @param hKeys Hash键集合
* @return Hash对象集合
*/
public <T> List<T> getMultiCacheMapValue(final String key, final Collection<Object> hKeys)
{
return redisTemplate.opsForHash().multiGet(key, hKeys);
}
/**
* 删除Hash中的某条数据
*
* @param key Redis键
* @param hKey Hash键
* @return 是否成功
*/
public boolean deleteCacheMapValue(final String key, final String hKey)
{
return redisTemplate.opsForHash().delete(key, hKey) > 0;
}
/**
* 获得缓存的基本对象列表
*
* @param pattern 字符串前缀
* @return 对象列表
*/
public Collection<String> keys(final String pattern)
{
return redisTemplate.keys(pattern);
}
}
package com.dsk.search.controller;
import com.alibaba.fastjson2.JSONObject;
import com.dsk.common.core.domain.AjaxResult;
import com.dsk.search.domain.ComposeQueryDto;
import com.dsk.search.service.BusinessOpportunityRadarService;
import org.springframework.web.bind.annotation.RequestBody;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;
import javax.annotation.Resource;
/**
* 商机雷达 查询接口
* @author Administrator
*
*/
@RequestMapping("/radar")
@RestController
public class BusinessOpportunityRadarController {
@Resource
private BusinessOpportunityRadarService opportunityRadarService;
/*
* 公招标讯
*/
@RequestMapping("/jskBidPage")
public AjaxResult jskBidPage(@RequestBody JSONObject object) {
ComposeQueryDto compose = JSONObject.parseObject(object.toJSONString(), ComposeQueryDto.class);
if (PageQueryLimit.pageLimit(compose.getPage())){
return AjaxResult.error("翻页已达到上限");
}
return opportunityRadarService.jskBidPage(object);
}
/*
* 土地交易
*/
@RequestMapping("/landMarketPage")
public AjaxResult landMarketPage(@RequestBody JSONObject object) {
ComposeQueryDto compose = JSONObject.parseObject(object.toJSONString(), ComposeQueryDto.class);
if (PageQueryLimit.pageLimit(compose.getPage())){
return AjaxResult.error("翻页已达到上限");
}
return opportunityRadarService.landMarketPage(object);
}
/*
* 拟建项目
*/
@RequestMapping("/establishmentPage")
public AjaxResult establishmentPage(@RequestBody JSONObject object) {
ComposeQueryDto compose = JSONObject.parseObject(object.toJSONString(), ComposeQueryDto.class);
if (PageQueryLimit.pageLimit(compose.getPage())){
return AjaxResult.error("翻页已达到上限");
}
return opportunityRadarService.establishmentPage(object);
}
/*
* 开标记录
*/
@RequestMapping("/jskBidTenderPage")
public AjaxResult jskBidTenderPage(@RequestBody JSONObject object) {
ComposeQueryDto compose = JSONObject.parseObject(object.toJSONString(), ComposeQueryDto.class);
if (PageQueryLimit.pageLimit(compose.getPage())){
return AjaxResult.error("翻页已达到上限");
}
return opportunityRadarService.jskBidTenderPage(object);
}
/*
* 标讯pro
*/
@RequestMapping("/jskBidNewsPage")
public AjaxResult jskBidNewsPage(@RequestBody JSONObject object) {
ComposeQueryDto compose = JSONObject.parseObject(object.toJSONString(), ComposeQueryDto.class);
if (PageQueryLimit.pageLimit(compose.getPage())){
return AjaxResult.error("翻页已达到上限");
}
return opportunityRadarService.jskBidNewsPage(object);
}
/*
* 标讯pro 商机项目关联查询
*/
@RequestMapping("/jskBidNewsPage/findByName")
public AjaxResult findByName(@RequestBody JSONObject object) {
ComposeQueryDto compose = JSONObject.parseObject(object.toJSONString(), ComposeQueryDto.class);
if (PageQueryLimit.pageLimit(compose.getPage())){
return AjaxResult.error("翻页已达到上限");
}
return opportunityRadarService.findByName(object);
}
/*
* 专项债查询
*/
@RequestMapping("/bondProjectPage")
public AjaxResult bondProjectPage(@RequestBody JSONObject object) {
ComposeQueryDto compose = JSONObject.parseObject(object.toJSONString(), ComposeQueryDto.class);
if (PageQueryLimit.pageLimit(compose.getPage())){
return AjaxResult.error("翻页已达到上限");
}
return opportunityRadarService.bondProjectPage(object);
}
/*
* 投标计划查询
*/
@RequestMapping("/jskBidPlanPage")
public AjaxResult jskBidPlanPage(@RequestBody JSONObject object) {
ComposeQueryDto compose = JSONObject.parseObject(object.toJSONString(), ComposeQueryDto.class);
if (PageQueryLimit.pageLimit(compose.getPage())){
return AjaxResult.error("翻页已达到上限");
}
return opportunityRadarService.jskBidPlanPage(object);
}
/*
* 投标计划查询
*/
@RequestMapping("/jskBidPlan/getCapitalSourceSelect")
public AjaxResult getCapitalSourceSelect() {
return opportunityRadarService.getCapitalSourceSelect();
}
/*
* 推荐关键词
*/
@RequestMapping("/keywordList")
public AjaxResult keywordList() {
return opportunityRadarService.keywordList();
}
/*
* 招标来源网站
*/
@RequestMapping("/bidSourceList")
public AjaxResult bidSourceList(@RequestBody JSONObject object) {
return opportunityRadarService.bidSourceList(object);
}
/*
* 重点项目清单
*/
@RequestMapping("/importantPage")
public AjaxResult importantPage(@RequestBody JSONObject object) {
ComposeQueryDto compose = JSONObject.parseObject(object.toJSONString(), ComposeQueryDto.class);
if (PageQueryLimit.pageLimit(compose.getPage())){
return AjaxResult.error("翻页已达到上限");
}
return opportunityRadarService.importantPage(object);
}
}
package com.dsk.search.controller;
import com.alibaba.fastjson2.JSONObject;
import com.dsk.common.core.domain.AjaxResult;
import com.dsk.search.domain.ComposeQueryDto;
import com.dsk.search.service.BusinessOpportunityRadarService;
import org.springframework.web.bind.annotation.*;
import javax.annotation.Resource;
/**
* 查企业
* @author Administrator
*
*/
@RequestMapping("/enterprise")
@RestController
public class CompanySearchController {
@Resource
private BusinessOpportunityRadarService opportunityRadarService;
/*
* 模糊查询企业名称
*/
@RequestMapping("/index")
public AjaxResult landMarketPage(@RequestBody JSONObject object) {
ComposeQueryDto compose = JSONObject.parseObject(object.toJSONString(), ComposeQueryDto.class);
if (PageQueryLimit.pageLimit(compose.getPage())){
return AjaxResult.error("翻页已达到上限");
}
return opportunityRadarService.enterpriseIndex(object);
}
/*
* 完全匹配企业名称
*/
@GetMapping("/findByName/{keyword}")
public AjaxResult findByName(@PathVariable String keyword) {
return opportunityRadarService.enterpriseByName(keyword);
}
/*
* 完全匹配企业名称
*/
@PostMapping("/page")
public AjaxResult page(@RequestBody JSONObject object) {
ComposeQueryDto compose = JSONObject.parseObject(object.toJSONString(), ComposeQueryDto.class);
if (PageQueryLimit.pageLimit(compose.getPage())){
return AjaxResult.error("翻页已达到上限");
}
return opportunityRadarService.enterprisePage(object);
}
}
package com.dsk.search.controller;
import com.alibaba.fastjson2.JSONObject;
import com.dsk.common.constant.HttpStatus;
import com.dsk.common.core.controller.BaseController;
import com.dsk.common.core.domain.AjaxResult;
import com.dsk.common.core.page.TableDataInfo;
import com.dsk.search.service.MarketAnalysisService;
import org.springframework.web.bind.annotation.RequestBody;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;
import javax.annotation.Resource;
import java.util.ArrayList;
import java.util.Calendar;
import java.util.List;
/**
* 央企市场分析-统计
* @author Administrator
*
*/
@RequestMapping("/marketAnalysis")
@RestController
public class MarketAnalysisController extends BaseController {
@Resource
private MarketAnalysisService marketAnalysisService;
/*
* 各省份备案企业数量
*/
@RequestMapping("/areaGroupByProvince")
public AjaxResult areaGroupByProvince() {
return marketAnalysisService.areaGroupByProvince();
}
/*
* 资质等级按照行业、等级类型分组
*/
@RequestMapping("/certGroupByMajorAndLevel")
public AjaxResult certGroupByMajorAndLevel() {
return marketAnalysisService.certGroupByMajorAndLevel();
}
/*
* 资质等级按照大类、省份、等级类型分组
*/
@RequestMapping("/certGroupByMajorProvinceLevel")
public AjaxResult certGroupByMajorProvinceLevel() {
return marketAnalysisService.certGroupByMajorProvinceLevel();
}
/*
* 产业结构-按年份选择 各个项目类型项目总数
*/
@RequestMapping("/bidGroupCountByProjectType")
public AjaxResult bidGroupCountByProjectType(@RequestBody JSONObject object) {
return marketAnalysisService.bidGroupCountByProjectType(object);
}
/*
* 产业结构-近两年各个项目类型项目总数及金额占比
*/
@RequestMapping("/bidMoneyGroupByProjectType")
public AjaxResult bidMoneyGroupByProjectType(@RequestBody JSONObject object) {
return marketAnalysisService.bidMoneyGroupByProjectType(object);
}
//-----------------------------------中标----------------------------------
//全攻中标项目统计
@RequestMapping("/countBidByType")
public AjaxResult countBidByType(@RequestBody JSONObject object) {
return marketAnalysisService.countBidByType( object);
}
/*
* 全国各地区中标统计TOP10
*/
@RequestMapping("/countBidGroupByProvince")
public AjaxResult countBidGroupByProvince(@RequestBody JSONObject object) {
return marketAnalysisService.countBidGroupByProvince(object);
}
//全国中标金额分析
@RequestMapping("/rangeBidMoney")
public AjaxResult rangeBidMoney(@RequestBody JSONObject object) {
return marketAnalysisService.rangeBidMoney( object);
}
//全国中标趋势分析
@RequestMapping("/rangeBidFiveYears")
public AjaxResult rangeBidFiveYears() {
return marketAnalysisService.rangeBidFiveYears();
}
//全国中标下浮率分析
@RequestMapping("/lowerRateByYear")
public AjaxResult lowerRateByYear(@RequestBody JSONObject object) {
return marketAnalysisService.lowerRateByYear( object);
}
//全国中标业绩项目类型下浮率
@RequestMapping("/lowerRangeTenderType")
public AjaxResult lowerRangeTenderType(@RequestBody JSONObject object) {
return marketAnalysisService.lowerRangeTenderType( object);
}
//-----------------------------------土地----------------------------------
//央企数字化经营系统 土地交易
@RequestMapping("/countLandMarketByType")
public AjaxResult countLandMarketByType(@RequestBody JSONObject object){
return marketAnalysisService.countLandMarketByType(object);
}
//央企数字化经营系统 全国土地交易项目地区
@RequestMapping("/countLandMarketByProvince")
public AjaxResult countLandMarketByProvince(@RequestBody JSONObject object){
return marketAnalysisService.countLandMarketByProvince(object);
}
//央企数字化经营系统 全国土地交易项目地区
@RequestMapping("/countLandMarketByYear")
public AjaxResult countLandMarketByYear(){
return marketAnalysisService.countLandMarketByYear();
}
//-----------------------------------招标----------------------------------
//央企数字化经营系统 全国公招项目统计
@RequestMapping("/countNewsBidByYear")
public AjaxResult countNewsBidByYear(){
return marketAnalysisService.countNewsBidByYear();
}
//央企数字化经营系统 招标公告 全国各地区项目统计TOP10
@RequestMapping("/countNewsBidByProvince")
public AjaxResult countNewsBidByProvince(@RequestBody JSONObject object){
return marketAnalysisService.countNewsBidByProvince(object);
}
//央企数字化经营系统 招标公告 月度统计
@RequestMapping("/countNewsBidByMonth")
public AjaxResult countNewsBidByMonth(@RequestBody JSONObject object){
return marketAnalysisService.countNewsBidByMonth(object);
}
/*
* 招标数量按省份分组
*/
@RequestMapping("/countGroupByProvince")
public AjaxResult countGroupByProvince(@RequestBody JSONObject object) {
return marketAnalysisService.countGroupByProvince(object);
}
@RequestMapping("/getYear")
public TableDataInfo getYear(){
List<Integer> list = new ArrayList<>();
Calendar calendar = Calendar.getInstance();
int nowYear = calendar.get(Calendar.YEAR);
list.add(nowYear);
for (int i = 1; i < 5; i++) {
list.add(nowYear-i);
}
return getDataTable(list);
}
/*
* 中标数量按月份分组
*/
@RequestMapping("/countGroupByMonth")
public AjaxResult countGroupByMonth(@RequestBody JSONObject object) {
return marketAnalysisService.countGroupByMonth(object);
}
/**
* 响应请求分页数据
*/
@SuppressWarnings({ "rawtypes", "unchecked" })
protected TableDataInfo getDataTable(List<?> list) {
TableDataInfo rspData = new TableDataInfo();
rspData.setCode(HttpStatus.SUCCESS);
rspData.setMsg("查询成功");
rspData.setRows(list);
rspData.setTotal(new PageInfo(list).getTotal());
return rspData;
}
}
package com.dsk.search.controller;
import com.dsk.search.domain.Page;
/**
* @author lc
* @date 2023/6/20 17:48
*/
public class PageQueryLimit {
public static boolean pageLimit(Page page){
if (null == page) {
return true;
}
if (null==page.getLimit()||null==page.getPage()){
return true;
}
if ( page.getPage()*page.getLimit()>10000){
return true;
}
return false;
}
}
package com.dsk.search.domain;
import lombok.Data;
import java.util.Date;
import java.util.List;
/**
* 组合查询参数
* @author Administrator
*
*/
@Data
public class AchievementQueryDto {
/**
* 业绩所需参数
*/
// //中标面积
// Double tenderArea;
// //许可面积
// Double licenceArea;
// //竣工面积
// Double completionArea;
//招投标面积
Double startTenderArea;
Double endTenderArea;
//施工许可面积
Double startLicenceArea;
Double endLicenceArea;
//竣工验收面积
Double startCheckArea;
Double endCheckArea;
//竣工验收备案面积
Double startCompletionArea;
Double endCompletionArea;
//总面积
Double startTotalArea;
Double endTotalArea;
//面积体现节点
String areaStr;
//项目面积同时具备、任意均可 and/or
String areaQueryType;
//许可金额
Double licenceMoney;
//中标金额
Double startTenderMoney;
Double endTenderMoney;
//合同金额
Double startContractMoney;
Double endContractMoney;
//施工许可金额
Double startLicenceMoney;
Double endLicenceMoney;
//竣工验收实际造价
Double startCompletionMoney;
Double endCompletionMoney;
//竣工备案实际造价
Double startCheckMoney;
Double endCheckMoney;
//总投资
Double startInvest;
Double endInvest;
//项目金额同时具备、任意均可
String moneyQueryType;
//金额和面积同时具备、任意均可
String moneyAndAreaQueryType;
//业绩时间同时具备、任意均可
String timeQueryType;
String eid;
String buildCorpName;
String personName;
String ename;
// 项目来源 0=本地 1=四库一平台
Integer source;
Double startMoney;
Double endMoney;
//金额体现节点
String moneyStr;
// 关键词(包含)
List<KeywordDto> keywords;
// 关键词(不包含)
String keywordNot;
// 关键词(不包含)查询类型 project项目名称 scale建设规模 projectOrScale项目名称或建设规模
String keywordNotType;
// 业绩类型
String achievementType;
//单项查询 关键词包含
String singleKeywordIn;
//单项查询 关键词不包含
String singleKeywordOut;
//单项查询 关键词包含体现节点
String singleKeywordInNode;
//单项查询 关键词不包含体现节点
String singleKeywordOutNode;
//是否截图体现公司和规模 yes no
Boolean isSingleReflect;
//建设性质
String nature;
// 项目属地
String divisionStr;
//项目所在城市
String cityStr;
String province;
Integer provinceId;
String city;
Integer cityId;
String county;
Integer countyId;
Double startArea;
Double endArea;
//项目类别
String projectType;
// 工程用途
String purposeStr;
// 中标开始时间
Date startTenderTime;
// 中标结束时间
Date endTenderTime;
// 实际竣工开始日期
Date startCheckDate;
// 实际竣工结束日期
Date endCheckDate;
//竣工备案时间未公示
String hasCheckDate;
//实际开工开始日期
Date startWorkDate;
//实际开工结束日期
Date endWorkDate;
//合同日期开始
Date startContractDate;
//合同日期结束
Date endContractDate;
//施工许可开始日期
Date startLicenceDate;
//施工许可结束日期
Date endLicenceDate;
//施工图审开始日期
Date startCensorDate;
//施工图审结束日期
Date endCensorDate;
//竣工验收开始日期
Date startCheckCheckDate;
//竣工验收结束日期
Date endCheckCheckDate;
//竣工验收时间未公示
String hasCheckCheckDate;
// 业绩属性
String attributeStr;
// 业绩属性
String attributeQueryType;
// 项目经理
String pmStr;
// 项目经理同时具备、任意均可
String pmQueryType;
// 结构体系
String structure;
// 数据等级
String dataLevel;
//招投标数据等级
String tenderDataLevel;
//合同登记
String contractDataLevel;
//施工许可
String licenceDataLevel;
//竣工验收备案
String completionDataLevel;
//项目主体
String projectDataLevel;
//施工图审
String censorDataLevel;
//竣工验收
String checkDataLevel;
// 数据等级查询节点
String dataLevelStr;
// 数据等级查询方式 同时具备 任意均可
String dataLevelQueryType;
// 资金来源
String fundSource;
Double startLength;
Double endLength;
//施工许可
Double startLicenceLength;
Double endLicenceLength;
//竣工验收
Double startCheckCompletionLength;
Double endCheckCompletionLength;
//竣工验收备案
Double startCompletionLength;
Double endCompletionLength;
//长度体现节点
String lengthNode;
//长度筛选类型 or/and
String lengthType;
Double startSpan;
Double endSpan;
//施工许可
Double startLicenceSpan;
Double endLicenceSpan;
//竣工验收
Double startCheckCompletionSpan;
Double endCheckCompletionSpan;
//竣工验收备案
Double startCompletionSpan;
Double endCompletionSpan;
//跨度体现节点
String spanNode;
//跨度筛选类型 or/and
String spanType;
Integer achievementCount;
String type;
String tenderWay;
String md5Company;
// 企业业绩关键词
String keyword;
// 企业项目详情的中标开始时间 时间戳
Long startTenderDetailTime;
// 企业项目详情的中标结束时间 时间戳
Long endTenderDetailTime;
List<SkyProjectIndexDto> indexDtos;
//指标筛选类型 or/and
String indexQueryType;
//指标体现节点
String indexPoint;
}
package com.dsk.search.domain;
import lombok.Data;
/**
* @author liuchang
* @date 2020/7/24 13:47
*/
@Data
public class AptitudeDetailDto {
Integer categoryCode;
Integer typeCode;
Integer majorCode;
String levelCode;
}
package com.dsk.search.domain;
import lombok.Data;
import java.util.List;
/**
* @author liuchang
* @date 2020/7/24 13:47
*/
@Data
public class AptitudeDto {
//资质条件
String nameStr;
String codeStr;
//资质同时具备任意均可 and/or
String queryType;
//资质查询类型 qualification 按资质项 level 按等级
String aptitudeType;
//存放处理完后的资质条件
List<String> names;
Integer namesCount;
}
package com.dsk.search.domain;
import com.alibaba.fastjson2.annotation.JSONField;
import lombok.Getter;
import lombok.Setter;
import java.util.Date;
import java.util.List;
@Getter
@Setter
public class AptitudeQueryDto {
String ename;
String resultEname;
String businessScopeQueryType;
//资质查询范围 old 旧表 new 新表
String aptitudeSource;
//任意均可or 同时具备and 有且仅有only
String aptitudeQueryType;
List<AptitudeDto> aptitudeDtoList;
//资质排除
String outCodeStr;
//资质排除类型 任意均可or 同时具备and
String outQueryType;
//行业code
String industryCode;
Double registeredCapital;
Double leftRegisteredCapital;
Double rightRegisteredCapital;
Double leftActualCapi;
Double rightActualCapi;
String queryType;
//三体系查询方式 同时具备、任意均可
String systemQueryType;
//体系类型
List<Integer> systemType;
String systemTypeStr;
//参保人数 起
Integer startInsuredNum;
//参保人数 止
Integer endInsuredNum;
//是否有电话 0无 1有 2有手机号码 3有固定号码 4 有手机和固定号码
Integer hasPhone;
//是否高新技术企业 0否 1是
Integer isHighTech;
//税务登记 1:A级
Integer taxLvl;
String taxYear;
//企业类型
// 1 国有企业
// 2 集体企业
// 3 股份有限公司
// 4 有限责任公司
// 5 联营企业
// 6 港、澳、台商投资企业
// 7 私营企业
// 8 外商投资企业
// 9 个体工商户
// 10 股份制企业
// 11 事业单位
// 12 其他
String companyType;
//安许证到期日期参数
@JSONField(format="yyyy-MM-dd")
Date startLiceValidityDate;
@JSONField(format="yyyy-MM-dd")
Date endLiceValidityDate;
//资质编号
String aptitudeCertNo;
//安许证编号
String liceCertNo;
//资质到期日期参数
@JSONField(format="yyyy-MM-dd")
Date startAptitudeValidityDate;
@JSONField(format="yyyy-MM-dd")
Date endAptitudeValidityDate;
//成立日期
Date startRegisteredDate;
Date endRegisteredDate;
Integer hasAptitude;
Integer hasLiceCert;
Integer no;
Double rate;
String isLocalC;
String isISO;
String isEMS;
String isOHSMS;
String certData;
String nameSimple;
String logoUrl;
String registeredDate;
String liceValidityDate;
Integer liceValidDay;
String url;
String registeredCapitalStr;
String id;
String companyId;
Integer jskEid;
String regionId;
String source;
String name;
String businessStatus;
String formerName;
String creditCode;
String legalPerson;
String registrationType;
Double actualCapi;
String domicile;
String domicileNum;
String domicileCity;
String domicileCounty;
String registerProvince;
String registerCity;
String registerCounty;
Integer isCountryCredit;
String businessAddress;
String businessScope;
Integer isLocal;
String attn;
String phone;
String other;
String regionInfo;
@JSONField(format="yyyy-MM-dd")
Date rateTime;
// 资质数
Integer aptitudeCount;
// 项目数
Integer projectCount;
// 人数
Integer persionCount;
//最新中标个数
Integer recentlyCount;
Integer numPunish;
Integer badCreditChinaCount;
Integer zzZfcgsxCount;
Integer seriousIllegalCount;
Integer zzSxbzxCount;
Integer zzJdcgsxCount;
Integer zzRiskBidCount;
// -------------注册地与备案地 重构版----------------
String filePlaceCode;//备案地code
public Integer filePlaceType;//备案地类型 1 本省企业或外地备案 2 外地备案 3 本省企业
String province;//注册地 省级code 多个逗号隔开
String city;//注册地 市级code 多个逗号隔开
String county;//注册地 区级code 多个逗号隔开
String regionWeb;//企业备案网站
String tagCode;//企业标签
}
package com.dsk.search.domain;
import lombok.Data;
import java.util.Date;
/**
* @author 刘昌
* @date 2020/9/4 9:08
*/
@Data
public class AwardDto {
String id;
//建安宝企业id
String eid;
//奖项类型(建安标品汇)
String type;
//建设库公司id
Integer companyId;
//公司名称
String ename;
//奖项名称
String name;
String staffName;
//企业角色
String companyRole;
//项目名称
String projectName;
//项目类型
String projectType;
//验收等级
String grade;
String gradeStr;
//颁发机构 JSON数组
String organization;
//奖项级别
String level;
//奖项小类
String sectionType;
//行业类型
String industryType;
String industryTypeStr;
//省份
String province;
//省份ID
Integer provinceId;
//市
String city;
//城市ID
Integer cityId;
String area;
Integer areaId;
//格式化后的发布时间
Date publishDate;
//获奖年度
String year;
//获奖起始年度
Integer yearBegin;
//获奖截止年度
Integer yearOver;
//原文链接
String href;
//快照截图地址, 存相对路径
String pathSnapshot;
//符合荣誉条件的数量
Integer awardNum;
//省份列表
String provinceStr;
//市区列表
String cityStr;
//荣誉名称列表
String nameStr;
//颁发单位
String organizationStr;
//开始发布时间
String startPublishDate;
//结束时间
String endPublishDate;
}
package com.dsk.search.domain;
import lombok.Data;
import java.util.List;
/**
* @author 刘昌
* @date 2020/9/8 16:01
*/
@Data
public class AwardQueryDto {
List<AwardDto> awardDtos;
String awardDtoType;
}
package com.dsk.search.domain;
import lombok.Data;
//批量查询dto
@Data
public class BatchQueryDto {
String region;
String fileUrl;
String userId;
String exportExeclName;
String exportBackUrl;
String exportUniqueCode;
}
package com.dsk.search.domain;
import com.alibaba.fastjson2.annotation.JSONField;
import lombok.Data;
import java.util.Date;
/**
* 北京一体化查询参数
* @author Administrator
*
*/
@Data
public class BeijingQueryDto {
String id;
String achievementType;
String province;
String city;
String county;
//中标金额
Double startTenderMoney;
Double endTenderMoney;
//合同金额
Double startContractMoney;
Double endContractMoney;
//金额查询类型 and/or 默认任意均可
String moneyQueryType;
// 中标开始时间
@JSONField(format="yyyy-MM-dd")
Date startTenderDate;
// 中标结束时间
@JSONField(format="yyyy-MM-dd")
Date endTenderDate;
// 合同开始时间
@JSONField(format="yyyy-MM-dd")
Date startContractDate;
// 合同结束时间
@JSONField(format="yyyy-MM-dd")
Date endContractDate;
//时间查询类型 and/or 默认任意均可
String timeQueryType;
//建设单位
String buildCorpName;
//中标单位
String tenderCompany;
//招标代理
String agency;
//单项查询 关键词包含
String singleKeywordIn;
//单项查询 关键词不包含
String singleKeywordOut;
//单项查询 关键词包含体现节点
String singleKeywordInNode;
//单项查询 关键词不包含体现节点
String singleKeywordOutNode;
}
package com.dsk.search.domain;
import com.alibaba.fastjson2.annotation.JSONField;
import lombok.Getter;
import lombok.Setter;
import java.util.Date;
@Getter
@Setter
public class BusinessInfoDto {
String ename;
String resultEname;
String businessScopeQueryType;
Double registeredCapital;
Double leftRegisteredCapital;
Double rightRegisteredCapital;
Double leftActualCapi;
Double rightActualCapi;
String queryType;
//参保人数 起
Integer startInsuredNum;
//参保人数 止
Integer endInsuredNum;
//是否有电话 0否 1是
Integer hasPhone;
//是否高新技术企业 0否 1是
Integer isHighTech;
//税务登记 1:A级
Integer taxLvl;
String taxYear;
//企业类型
// 1 国有企业
// 2 集体企业
// 3 股份有限公司
// 4 有限责任公司
// 5 联营企业
// 6 港、澳、台商投资企业
// 7 私营企业
// 8 外商投资企业
// 9 个体工商户
// 10 股份制企业
// 11 事业单位
// 12 其他
String companyType;
//成立日期
Date startRegisteredDate;
Date endRegisteredDate;
Integer hasAptitude;
Integer hasLiceCert;
Integer no;
Double rate;
String isLocalC;
String isISO;
String isEMS;
String isOHSMS;
String certData;
String nameSimple;
String logoUrl;
String registeredDate;
String liceValidityDate;
Integer liceValidDay;
String url;
String registeredCapitalStr;
String id;
String companyId;
Integer jskEid;
String regionId;
String source;
String name;
//中文经营状态(枚举:在业、清算、迁入、迁出、停业、撤销、吊销、注销、不详)
String businessStatus;
String formerName;
String creditCode;
String legalPerson;
String registrationType;
Double actualCapi;
String domicile;
String domicileNum;
String domicileCity;
String domicileCounty;
String registerProvince;
String registerCity;
String registerCounty;
Integer isCountryCredit;
String businessAddress;
String businessScope;
Integer isLocal;
String attn;
String phone;
String other;
String regionInfo;
@JSONField(format="yyyy-MM-dd")
Date rateTime;
// 资质数
Integer aptitudeCount;
// 项目数
Integer projectCount;
// 人数
Integer persionCount;
//最新中标个数
Integer recentlyCount;
Integer numPunish;
Integer badCreditChinaCount;
Integer zzZfcgsxCount;
Integer seriousIllegalCount;
Integer zzSxbzxCount;
Integer zzJdcgsxCount;
Integer zzRiskBidCount;
// -------------注册地与备案地 重构版----------------
String filePlaceCode;//备案地code
public Integer filePlaceType;//备案地类型 1 本省企业或外地备案 2 外地备案 3 本省企业
String province;//注册地 省级code 多个逗号隔开
String city;//注册地 市级code 多个逗号隔开
String county;//注册地 区级code 多个逗号隔开
String regionWeb;//企业备案网站
String tagCode;//企业标签
}
package com.dsk.search.domain;
import com.alibaba.fastjson2.annotation.JSONField;
import lombok.Data;
import java.util.Date;
import java.util.List;
/**
* 人员查询实体类
* @author Administrator
*
*/
@Data
public class ComposePersonnelQueryDto {
// 人员姓名
String personName;
// 人员id
String staffId;
// 企业名称
String ename;
//yes有业绩 no没业绩
String mance;
//企业注册地
String domicile;
String domicileNum;
String domicileCity;
String domicileCounty;
//市
String registerCity;
//省份
String registerProvince;
//区
String registerCounty;
String cardNumber;
//证书and/or
String registerQueryType;
// 注册类型 只有一人多证and
List<RegisterTypeDto> registers;
//人员荣誉
List<AwardQueryDto> awardQueryDtos;
//人员荣誉同时具备任意均可
String personAwardQueryType;
//人员业绩同时具备任意均可
String achievementQueryType;
//四库业绩
List<AchievementQueryDto> achievementQueryDto;
//四库业绩完整版
List<AchievementQueryDto> achievementFullQueryDto;
//最新中标业绩
List<RecentlyBidQueryDto> recentlyBidQueryDto;
//一体化项目业绩
List<YitihuaAchievementQueryDto> yitihuaAchievements;
//一体化业绩精简版
List<YitihuaAchievementQueryDto> ythAchievements;
//一体化业绩完整版
List<YitihuaAchievementQueryDto> ythFullAchievements;
//全平台业绩
List<JabBasicEnterpriseProjectDto> basicAchievements;
//江西中标业绩
List<JiangxiBidQueryDto> jiangxiBidQueryDto;
//水利业绩
List<ShuiliAchievementQueryDto> shuiliAchievements;
//人员业绩条件是否与企业业绩条件相同
Boolean isSame;
//人员业绩企业一致
Integer achievementCount;
//一体化来源
String yitihuaSource;
//资质到期日期参数
@JSONField(format="yyyy-MM-dd")
Date startCertValidityDate;
@JSONField(format="yyyy-MM-dd")
Date endCertValidityDate;
String filePlaceCode;//备案地code
Integer filePlaceType;//备案地类型 1 本省企业或外地备案 2 外地备案 3 本省企业
String province;//注册地 省级code 多个逗号隔开
String city;//注册地 市级code 多个逗号隔开
String county;//注册地 区级code 多个逗号隔开
//是否有电话 0否 1是
Integer hasPhone;
//关键词
String keyword;
}
package com.dsk.search.domain;
import com.dsk.jsk.domain.BasePage;
import com.dsk.jsk.domain.SpecialBondProjectDto;
import lombok.Data;
import java.util.List;
/**
* 组合查询参数
* @author Administrator
*
*/
@Data
public class ComposeQueryDto extends BasePage {
String region;
String keyword;
String keywordNot;
Page page;
AptitudeQueryDto aptitudeQueryDto;
//工商信息
BusinessInfoDto businessInfoDto;
List<AchievementQueryDto> enterpriseAchievementQueryDto;
//完整版四库业绩
List<AchievementQueryDto> enterpriseAchievementFullQueryDto;
List<JiangxiBidQueryDto> jiangxiBidQueryDto;
BeijingQueryDto beijingQueryDto;
List<RecentlyBidQueryDto> recentlyBidQueryDto;
List<AwardQueryDto> awardQueryDtos;
String awardEname;
//人员证书专查
PersonnelCertificateQueryDto personnelCertificateQueryDto;
PersonnelCertificateQueryDto companyPersonnelCertQueryDto;
//项目负责人 (施工/监理/设计/勘察)
ComposePersonnelQueryDto composePersonnelQueryDto;
//项目负责人 (施工)
ComposePersonnelQueryDto composePersonnelQueryDtoV2;
// PersonnelQueryDto personnelQueryDto;
JskBidQueryDto jskBidQueryDto;
//标讯pro 招标
JskBidNewsDto jskBidNewsDto;
//标讯pro 中标候选人
JskBidCandidateDto jskBidCandidateDto;
//中标公示
JskBidWinListDto jskBidWinListDto;
//专项债项目
SpecialBondProjectDto specialBondProjectDto;
//投标计划
JskBidPlanDto jskBidPlanDto;
String achievementQueryType;
String awardQueryType;
Boolean isHighLightKeyword;
String eid;
String personId;
String md5Company;
List<String> exportHeader ;
//符合条件的荣誉类别 0 1 2 3
String awardType;
String badBehaviorEname;
//不良行为
List<CreditBehaviorDto> badBehaviors;
//信用评价
List<CreditEvaluateDto> creditEvaluates;
//良好行为
GoodBehaviorDto goodBehaviorDto;
String creditEvaluateType;
//全平台业绩
List<JabBasicEnterpriseProjectDto> basicAchievements;
//江西住建项目业绩
List<YitihuaAchievementQueryDto> yitihuaAchievements;
//一体化业绩精简版
List<YitihuaAchievementQueryDto> ythAchievements;
//一体化业绩完整版
List<YitihuaAchievementQueryDto> ythFullAchievements;
//水利业绩
List<ShuiliAchievementQueryDto> shuiliAchievements;
//土地招拍挂
LandMarketDto landMarketDto;
//拟建
EstablishmentDto establishmentDto;
EstablishmentDto bidPro;
String yitihuaSource;
String exportSource;
Integer exportCount;
String exportExeclName;
String exportBackUrl;
String exportUniqueCode;
String orderSn;
public Page getPage() {
if (page == null) {
page = new Page();
page.setPage(1);
page.setLimit(10);
}
return page;
}
}
package com.dsk.search.domain;
import lombok.Data;
import java.util.List;
@Data
public class ComposeRegisterDto {
// 注册类型
List<RegisterTypeDto> registerTypes;
// and/or
String registerQueryType;
// 注册人数
Integer registerCount;
// 个数类型 1 大于等于 2 等于 3小于等于
Integer countType;
}
package com.dsk.search.domain;
import lombok.Data;
import java.util.Date;
/**
* @author 刘昌
* @date 2020/9/4 9:08
*/
@Data
public class CreditBehaviorDto {
String category;
String type;
String subclass;
String org;
String dataSource;
String contentInfo;
String punishType;
Date startTime;
String behaviorTime;
String behaviorExportTime;
Date endTime;
Integer jskEid;
String ename;
}
package com.dsk.search.domain;
import lombok.Data;
import java.util.Date;
/**
* @author 刘昌
* @date 2020/9/4 9:08
*/
@Data
public class CreditEvaluateDto {
String keyword;
String no;
String ename;
String province;
String city;
String dataSource;
//企业类型
String type;
// 是否是及以上
Boolean attrComp;
//评价类型
String attribute;
//排名、评分
String rankOrLevel;
//等级
Integer startYear;
Integer endYear;
String jskEid;
String publishTime;
String timeSpan;
Date startTime;
Date endTime;
String quarter;
String issuteTime;
}
package com.dsk.search.domain;
import lombok.Data;
import java.io.Serializable;
import java.util.Date;
/**
* 时间筛选对象
*
* @author lcl
* @create 2021/9/6
*/
@Data
public class DateQueryDto implements Serializable {
//类型
private String type;
//筛选类型 and/or
private String queryType;
//开始时间
private Date startDate;
//结束时间
private Date endDate;
}
package com.dsk.search.domain;
import com.fasterxml.jackson.annotation.JsonInclude;
import lombok.Data;
import java.util.Date;
/**
* 企业
* @author Administrator
*
*/
@Data
@JsonInclude(JsonInclude.Include.NON_NULL)
public class Enterprise {
String id;
String companyId;
Integer jskEid;
String regionId;
String source;
String name;
String businessStatus;
String formerName;
String creditCode;
String legalPerson;
String registrationType;
Double registeredCapital;
Double actualCapi;
String registeredCapitalStr;
String domicile;
String domicileNum;
String domicileCity;
String registerProvince;
String registerCity;
Integer isCountryCredit;
String businessAddress;
String businessScope;
Integer isLocal;
String attn;
String phone;
String other;
String regionInfo;
Double rate;
Date rateTime;
// 资质数
Integer aptitudeCount;
// 项目数
Integer projectCount;
// 人数
Integer persionCount;
//最新中标个数
Integer recentlyCount;
Integer numPunish;
Integer badCreditChinaCount;
Integer zzZfcgsxCount;
Integer seriousIllegalCount;
Integer zzSxbzxCount;
Integer zzJdcgsxCount;
Integer zzRiskBidCount;
// -------------注册地与备案地 重构版----------------
String filePlaceCode;//备案地code
public Integer filePlaceType;//备案地类型 1 本省企业或外地备案 2 外地备案 3 本省企业
String province;//注册地 省级code 多个逗号隔开
String city;//注册地 市级code 多个逗号隔开
String county;//注册地 区级code 多个逗号隔开
}
package com.dsk.search.domain;
import com.fasterxml.jackson.annotation.JsonInclude;
import lombok.Data;
import java.util.Date;
import java.util.List;
@Data
@JsonInclude(JsonInclude.Include.NON_NULL)
public class EnterpriseDto{
Integer no;
Double rate;
String isLocalC;
String labels;
String isISO;
String isEMS;
String isOHSMS;
String certData;
String nameSimple;
String logoUrl;
String registeredDate;
String liceValidityDate;
//安许证-证书生效时间
String liceIssueDate;
String liceCertNo;
Integer liceValidDay;
String url;
String registeredCapitalStr;
String id;
String companyId;
Integer jskEid;
String regionId;
String source;
String name;
String businessStatus;
String formerName;
String creditCode;
String legalPerson;
String registrationType;
Double registeredCapital;
Double actualCapi;
String domicile;
String domicileNum;
String domicileCity;
String registerProvince;
String registerCity;
Integer isCountryCredit;
String businessAddress;
String businessScope;
Integer isLocal;
String attn;
String phone;
String companyType;
String other;
String regionInfo;
Date rateTime;
// 资质数
Integer aptitudeCount;
Integer aptitudeCountNew;
// 项目数
Integer projectCount;
// 人数
Integer persionCount;
//最新中标个数
Integer recentlyCount;
Integer skyCount;
Integer registeredPersonnelCount;
Integer jskBidCount;
Integer supplierCount;
Integer customerCount;
Integer threePersonnelCount;
Integer numPunish;
Integer badCreditChinaCount;
Integer zzZfcgsxCount;
Integer seriousIllegalCount;
Integer zzSxbzxCount;
Integer zzJdcgsxCount;
Integer zzRiskBidCount;
// -------------注册地与备案地 重构版----------------
String filePlaceCode;//备案地code
public Integer filePlaceType;//备案地类型 1 本省企业或外地备案 2 外地备案 3 本省企业
String province;//注册地 省级code 多个逗号隔开
String city;//注册地 市级code 多个逗号隔开
String county;//注册地 区级code 多个逗号隔开
//企业备案地
List<String> regionList;
}
package com.dsk.search.domain;
import java.io.*;
/**
* <pre>
* <b>.</b>
* <b>Description:实体类基类</b>
*
* <b>Author:</b> vip@chennxu.com
* <b>Date:</b> 2016年9月3日 上午11:49:20
* <b>Copyright:</b> Copyright &copy;2006-2015 chennxu.com Co., Ltd. All rights reserved.
* <b>Changelog:</b>
* Ver Date Author Detail
* ----------------------------------------------------------------------
* 1.0 2016年9月3日 上午11:49:20 vip@chennxu.com new file.
* </pre>
*/
public class Entity implements Serializable, Cloneable, Comparable<Entity> {
/**
* 序列化版本标示
*/
private static final long serialVersionUID = 1L;
/**
* 深度克隆
*
* @return 克隆后得到的对象
* @throws IOException
* @throws ClassNotFoundException
*/
public final Object deepClone() throws IOException, ClassNotFoundException {
ByteArrayOutputStream bos = new ByteArrayOutputStream();
ObjectOutputStream oos = new ObjectOutputStream(bos);
oos.writeObject(this);
ByteArrayInputStream bis = new ByteArrayInputStream(bos.toByteArray());
return new ObjectInputStream(bis).readObject();
}
@Override
protected Object clone() throws CloneNotSupportedException {
// TODO Auto-generated method stub
return super.clone();
}
public int compareTo(Entity o) {
return 0;
}
}
package com.dsk.search.domain;
import com.alibaba.fastjson2.annotation.JSONField;
import lombok.Data;
import java.util.Date;
/**
* 项目立项数据(JskProjectEstablishment)实体类
*
* @author pig4cloud
* @since 2022-04-09 17:06:01
*/
@Data
public class EstablishmentDto {
private String keyword;
private String keywordNot;
private String id;
/**
* 项目名称
*/
private String projectName;
/**
* 申请单位
*/
private String companyName;
private Integer companyId;
/**
* 立项阶段
*/
private String stage;
/**
* 审批部门
*/
private String examineOffice;
/**
* 项目类型
*/
private String projectType;
/**
* 事项名称
*/
private String examineContent;
/**
* 审批结果
*/
private String examineStatus;
/**
* 审批文号
*/
private String licenseNum;
/**
* 计划开工时间
*/
private String planStartTime;
@JSONField(format="yyyy-MM-dd")
private Date planStartTimeStart;
@JSONField(format="yyyy-MM-dd")
private Date planStartTimeEnd;
/**
* 建成时间
*/
@JSONField(format="yyyy-MM-dd")
private String planEndTime;
@JSONField(format="yyyy-MM-dd")
private Date planEndTimeStart;
@JSONField(format="yyyy-MM-dd")
private Date planEndTimeEnd;
/**
* 审批文件链接
*/
private String licenseUrl;
/**
* 复核通过时间
*/
private String reviewTime;
/**
* 办结时间
*/
private String handleTime;
@JSONField(format="yyyy-MM-dd")
private Date handleTimeStart;
@JSONField(format="yyyy-MM-dd")
private Date handleTimeEnd;
/**
* 项目代码
*/
private String projectCode;
/**
* 国家代码
*/
private String countryCode;
/**
* 省
*/
private Integer provinceId;
/**
* 市
*/
private Integer cityId;
/**
* 区
*/
private Integer districtId;
private String domicile;
/**
* 省
*/
private String province;
/**
* 市
*/
private String city;
/**
* 区
*/
private String district;
/**
* 总投资
*/
private Double money;
private Double startMoney;
private Double endMoney;
/**
* 资金来源
*/
private String sourceMoney;
/**
* 项目所属行业
*/
private String industry;
/**
* 建设性质
*/
private String buildNature;
/**
* 建设地点
*/
private String buildAddre;
/**
* 建设规模和内容
*/
private String buildScale;
/**
* 来源网站名称
*/
private String sourceName;
/**
* 详情页url
*/
private String sourceUrl;
private String personTel;
/**
* 是否为民介
*/
private Integer isProject;
private String isProjectStr;
private String approvalInfo;
private String marketingInfo;
/**
* 创建时间 设置为mysql自动创建
*/
private Date createTime;
private String updateTime;
}
\ No newline at end of file
package com.dsk.search.domain;
import lombok.Data;
import java.util.List;
/**
* @author lc
* @date 2023/1/16 16:08
*/
@Data
public class GoodBehaviorDto {
//三体系查询方式 同时具备、任意均可
String systemQueryType;
//体系类型
List<Integer> systemType;
String systemTypeStr;
//A级纳税人
String taxYear;
String taxYearQueryType;
//是否高新技术企业 0否 1是
Integer isHighTech;
String ename;
}
package com.dsk.search.domain;
import lombok.Data;
/**
* 头部查询参数
*
* @author lcl
* @create 2021/10/22
*/
@Data
public class HeaderDto{
private String queryStr;
private String sourceName;
private Page page;
}
package com.dsk.search.domain;
import lombok.Data;
import java.io.Serializable;
import java.util.List;
/**
* 全平台企业基本业绩信息(筛选条件)
*
* @author lcl
* @create 2021/9/6
*/
@Data
public class JabBasicEnterpriseProjectDto implements Serializable {
//参建单位
private String ename;
//建设单位
private String buildCorpName;
//业绩来源 多个空格隔开
private String achievementSource;
//业绩类型 多个空格隔开
private String achievementType;
//项目金额 最小值
private Double projectMoney;
private Double startMoney;
private Double endMoney;
//包含金额未公示 0:不包含 1:包含
private Integer isMoney;
//时间条件
private List<DateQueryDto> dateDtos;
//时间查询类型 and/or 默认任意均可
private String timeQueryType;
//关键词(包含) 单个空格隔开
private List<KeywordDto> keywords;
//关键词(不包含)
private String keywordNot;
private String keywordNotType;
//单项查询 关键词包含
String singleKeywordIn;
//单项查询 关键词不包含
String singleKeywordOut;
//单项查询 关键词包含体现节点
String singleKeywordInNode;
//单项查询 关键词不包含体现节点
String singleKeywordOutNode;
//是否截图体现公司和规模 yes no
Boolean isSingleReflect;
//省 多个空格隔开
private String divisionStr;
//市 多个空格隔开
private String cityStr;
//区 多个空格隔开
private String countyStr;
String province;
Integer provinceId;
String city;
Integer cityId;
String county;
Integer countyId;
//业绩数量
private Integer achievementCount;
}
package com.dsk.search.domain;
import lombok.Data;
import java.util.Date;
import java.util.List;
/**
* 组合查询参数
* @author Administrator
*
*/
@Data
public class JiangxiBidQueryDto {
//参建单位 施工单位
String ename;
//建设单位
String buildCorpName;
//中标金额
Double startMoney;
Double endMoney;
//包含金额未公示
String hasMoney;
// 中标开始时间
Date startTenderTime;
// 中标结束时间
Date endTenderTime;
//开工日期开始
Date startWorkDate;
//开工日期结束
Date endWorkDate;
//竣工日期开始
Date startCheckDate;
//竣工日期结束
Date endCheckDate;
// 实际竣工开始日期
Date startCheckCheckDate;
// 实际竣工结束日期
Date endCheckCheckDate;
//实际开工开始日期
Date startCheckWorkDate;
//实际开工结束日期
Date endCheckWorkDate;
//业绩时间同时具备、任意均可
String timeQueryType;
// 关键词(包含)
List<KeywordDto> keywords;
// 关键词(不包含)
String keywordNot;
// 关键词(不包含)查询类型 project项目名称 scale建设规模 projectOrScale项目名称或建设规模
String keywordNotType;
//单项查询 关键词包含
String singleKeywordIn;
//单项查询 关键词不包含
String singleKeywordOut;
//单项查询 关键词体现节点
String singleKeywordInNode;
//单项查询 关键词体现节点
String singleKeywordOutNode;
// // 项目属地
// String divisionStr;
//项目所在城市
String cityStr;
//所在区
String countyStr;
// 业绩数量
Integer achievementCount;
String city;
String county;
}
package com.dsk.search.domain;
import com.alibaba.fastjson2.annotation.JSONField;
import lombok.Data;
import java.util.Date;
import java.util.List;
import java.util.Map;
/**
* 组合查询参数
* @author Administrator
*
*/
@Data
public class JskBidCandidateDto {
String id;
//省
String province;
//市
String city;
//区
String county;
//项目名称
String projectName;
//项目类型
String projectType;
// 发布开始时间
@JSONField(format="yyyy-MM-dd")
Date startPubdate;
// 发布结束时间
@JSONField(format="yyyy-MM-dd")
Date endPubdate;
//中标金额开始
Double startProjectAmount;
//中标金额结束
Double endProjectAmount;
//最高限价开始
Double startMaxAmount;
//最高限价结束
Double endMaxAmount;
//下浮率开始
Double startLowerRate;
//下浮率结束
Double endLowerRate;
//中标候选人
String bidWinCompany;
//中标候选人id
String bidWinCompanyId;
//招标人
String tenderee;
//代理机构
String agency;
//最高限价
String maxAmount;
//中标金额
String projectAmount;
//下浮率
String lowerRate;
//名次
String rank;
//发布时间
String pubdate;
String tendereeId;
String tendereeTel;
String agencyId;
String agencyTel;
List<Map<String,String>> mapList;
}
package com.dsk.search.domain;
import com.alibaba.fastjson2.annotation.JSONField;
import lombok.Data;
import java.util.Date;
/**
* 组合查询参数
* @author Administrator
*
*/
@Data
public class JskBidNewsDto {
String id;
//省
String province;
//市
String city;
//区
String county;
//项目名称
String projectName;
//项目类型
String projectType;
//工程用途
String projectPurposes;
//工程用途
String projectLevel;
//评标办法
String bidAssessmentWay;
//评标委员会-有无业主代表,0为未知,1为无,2为有
String bidMettingHasProjectUnit;
//有无预付款,0为未知,1为无,2为有
String hasAdvanceAmount;
//保证金缴纳
String projectEnsureAmountPayType;
// 发布开始时间
@JSONField(format="yyyy-MM-dd")
Date startPubdate;
// 发布结束时间
@JSONField(format="yyyy-MM-dd")
Date endPubdate;
// 开标截至时间开始
@JSONField(format="yyyy-MM-dd")
Date startEndTimeDate;
// 开标截至时间结束
@JSONField(format="yyyy-MM-dd")
Date endEndTimeDate;
//项目金额开始
Double startProjectAmount;
//项目金额结束
Double endProjectAmount;
//项目投资额开始
Double startProjectInvestmentAmount;
//项目投资额结束
Double endProjectInvestmentAmount;
//合同估算价开始
Double startProjectContractAmount;
//合同估算价结束
Double endProjectContractAmount;
//建安费开始
Double startProjectSafeAmount;
//建安费结束
Double endProjectSafeAmount;
//勘察费开始
Double startProjectSurveyAmount;
//勘察费结束
Double endProjectSurveyAmount;
//设计费开始
Double startProjectDesignAmount;
//设计费结束
Double endProjectDesignAmount;
//投标保证金开始
Double startProjectEnsureAmount;
//投标保证金结束
Double endProjectEnsureAmount;
//资质要求
String qualiLimit;
//业绩要求
String projectLimit;
//人员要求
String personLimit;
//招标人
String tenderee;
//代理机构
String agency;
//时间
String dateStr;
//金额
String moneyStr;
String tendereeId;
String tendereeTel;
String agencyId;
String agencyTel;
String eligibleEnterprisesUrl;
String pubdate;
String endTimeDate;
String projectAmount;
//项目投资额
String projectInvestmentAmount;
//合同估算价
String projectContractAmount;
//建安费
String projectSafeAmount;
//综合单价
String projectComprehensiveAmount;
//勘察费
String projectSurveyAmount;
//设计费
String projectDesignAmount;
//投标保证金
String projectEnsureAmount;
//是否有文档
String hasFile;
//项目特点解析
String projectCharacteristics;
//市场分析及报价策略
String marketAnalysis;
//成本分析
String costAnalysis;
}
package com.dsk.search.domain;
import lombok.Data;
import java.util.Date;
/**
* 组合查询参数
* @author Administrator
*
*/
@Data
public class JskBidPlanDto {
String id;
String uuid;
String title;
String projectName;
String projectNumber;
//招标人
String tenderee;
String tendereeId;
String projectScale;
String province;
String city;
String area;
String domicile;
//标的物类型
String objectType;
//项目类型
String projectType;
//招标方式
String tenderWay;
//合同预估金额
Double planTenderAmount;
Double startPlanTenderAmount;
Double endPlanTenderAmount;
//资金来源
String projectCapitalSource;
//发布时间
String issueTime;
//发布时间开始
Date startIssueTime;
//发布时间结束
Date endIssueTime;
//计划发布开始时间
String planTenderDateStart;
//计划发布截止时间
String planTenderDateEnd;
//来源网站
String sourceName;
/**
* 修改时间
*/
String updateTime;
}
package com.dsk.search.domain;
import com.alibaba.fastjson2.annotation.JSONField;
import lombok.Data;
import java.util.Date;
/**
* 组合查询参数
* @author Administrator
*
*/
@Data
public class JskBidQueryDto {
String id;
String title;
//查找范围
String queryScope;
//"询价", "比选", "邀请", "竞争性谈判", "竞争性磋商", "单一来源", "竞价", "直接发包", "公开招标",其他',
String tenderingManner;
//招标金额
Double bidMoney;
String hasMoney;
Double startBidMoney;
Double endBidMoney;
String domicile;
String tenderStage;
String projectType;
String companyName;
String projectName;
String contentInfo;
Integer jskEid;
String tenderTime;
@JSONField(format="yyyy-MM-dd")
Date startTenderTime;
// 发布结束时间
@JSONField(format="yyyy-MM-dd")
Date endTenderTime;
String punishDate;
// 发布开始时间
@JSONField(format="yyyy-MM-dd")
Date startPunishDate;
// 发布结束时间
@JSONField(format="yyyy-MM-dd")
Date endPunishDate;
//行业
String industry;
// 标的物类型:工程/货物/服务/其他
String subjectMatter;
//中标标金额
Double startTenderMoney;
Double endTenderMoney;
String overTime;
String phonePoint;
String contact;
String contactTel;
String source;
String agency;
Integer agencyId;
String agencyContact;
String agencyContactTel;
String province;
String city;
String county;
/**
* 修改时间
*/
private String updateTime;
}
package com.dsk.search.domain;
import lombok.Data;
/**
* 中标公示查询参数
* @author Administrator
*
*/
@Data
public class JskBidWinListDto {
String winListUuid;
//招标单位
String tenderee;
//招标单位id
String tendereeId;
//省
String province;
String provinceId;
//市
String city;
String cityId;
//区
String area;
String areaId;
//中标项目编号
String bidWinProjectNo;
//项目名称
String projectName;
//项目id
String projectId;
//中标单位
String bidWinCompany;
//正文id
String contentId;
//下浮率
Double downfloatRate;
//其他来源
String otherSource;
//处理后的工期(天)
Integer dealProjectDuration;
//建造师名称
String constructor;
//建造师注册号
String constructorNo;
//处理后的中标金额(万元)
Double dealBidWinAmount;
//主来源网站名称
String sourceName;
//主来源详情页链接
String url;
//建设工程项目类型
String buildingProjectType;
//中标时间/发布时间
String issueTime;
}
package com.dsk.search.domain;
import com.fasterxml.jackson.annotation.JsonInclude;
import lombok.Data;
@Data
public class JskDataScreenDto {
@JsonInclude(JsonInclude.Include.NON_NULL)
public Integer provinceId;
@JsonInclude(JsonInclude.Include.NON_NULL)
public String certType;
public String subclass;
public String certLevel;
public String label;
public Integer count;
public String newProjectCount;
public String toDayBidAmount;
public String toDayBidCount;
public Page page;
}
package com.dsk.search.domain;
import lombok.Data;
@Data
public class KeywordDto {
// 关键词(包含)
private String keyword;
// 关键词(包含)查询类型 project项目名称 scale建设规模 projectOrScale项目名称或建设规模
private String keywordType;
//是否截图体现公司和规模 yes no
private Boolean isReflect;
//体现节点
private String keywordStr;
}
package com.dsk.search.domain;
import com.alibaba.fastjson2.annotation.JSONField;
import lombok.Data;
import java.util.Date;
@Data
public class LandMarketDto {
private Integer id;
/**
* 关键词
*/
private String keyword;
private String keywordNot;
/**
* 项目名称
*/
private String projectName;
/**
* 受让人
*/
private String companyName;
/**
* 企业ID
*/
private Integer companyId;
/**
* 出让面积
*/
private Double acreage;
private Double startAcreage;
private Double endAcreage;
/**
* 加价幅度
*/
private String addMoneyRange;
/**
* 招拍挂起始时间
*/
private Date auctionBeginTime;
/**
* 招拍挂截止时间
*/
private Date auctionEndTime;
/**
* 批准单位
*/
private String authority;
/**
* 保证金
*/
private Double bondmoney;
/**
* 建筑面积
*/
private Double buildArea;
private Double startBuildArea;
private Double endBuildArea;
/**
* 建筑密度
*/
private String buildingDensity;
/**
* 建筑限高
*/
private String buildingHeight;
private String domicile;
/**
* 省
*/
private String province;
/**
* 省ID
*/
private Integer provinceId;
/**
* 市
*/
private String city;
/**
* 市ID
*/
private Integer cityId;
/**
* 区
*/
private String area;
/**
* 区ID
*/
private Integer areaId;
/**
* 合同编号
*/
private String contractNum;
/**
* 合同签订日期
*/
private String contractSignTime;
/**
* 合同签订日期
*/
@JSONField(format="yyyy-MM-dd")
private Date contractSignTimeStart;
/**
* 合同签订日期
*/
@JSONField(format="yyyy-MM-dd")
private Date contractSignTimeEnd;
/**
* 约定开工时间
*/
private Date conventionBeginTime;
/**
* 约定竣工时间
*/
private Date conventionEndTime;
/**
* 约定交地时间
*/
private Date conventionLandTime;
/**
* 约定容积率
*/
private String conventionVolumeRate;
/**
* 结果详情url
*/
private String detailUrl;
/**
* 电子监管号
*/
private String electronicNumber;
private String gdgid;
/**
* 绿化率
*/
private String greeningRate;
/**
* 行业分类
*/
private String industry;
/**
* 投资强度
*/
private String investmentIntensity;
/**
* 报名起始时间
*/
private Date joinBeginTime;
/**
* 报名截止时间
*/
private Date joinEndTime;
/**
* 土地坐落
*/
private String landAddr;
/**
* 土地级别
*/
private String landLevel;
/**
* 地块名称
*/
private String landName;
/**
* 地块公示url
*/
private String landNoticeUrl;
/**
* 土地来源
*/
private String landSource;
/**
* 土地用途
*/
private String landUse;
/**
* 土地使用权人cid
*/
private Integer landUseCompanyId;
/**
* 土地使用权人
*/
private String landUseCompany;
/**
* 出让年限
*/
private String landUseYear;
/**
* 起始价
*/
private String moneyBegin;
/**
* 分期支付约定
*/
private String paymentAgreement;
/**
* 实际开工时间
*/
private Date realBeginTime;
/**
* 实际竣工时间
*/
private Date realEndTime;
/**
* 出让公告url
*/
private String sellNoticeUrl;
/**
* 供地方式/供应方式
*/
private String supplyLandWay;
/**
* 成交价格
*/
private Double transactionPrice;
/**
* 成交价格-起
*/
private Double startTransactionPrice;
/**
* 成交价格-止
*/
private Double endTransactionPrice;
/**
* 成交公示日期
*/
private String transactionPublicityTime;
/**
* 容积率
*/
private String volumeRate;
/**
* 约定容积率上限
*/
private Double volumeRateHigh;
/**
* 约定容积率下限
*/
private Double volumeRateLow;
/**
* 来源
*/
private String dataSource;
/**
* 创建时间
*/
private Date createTime;
/**
* 修改时间
*/
private String updateTime;
}
package com.dsk.search.domain;
import lombok.Data;
/**
* @ClassName OpRegionalLocalDto
* @Description 获取当前地区
* @Author Dgm
* @Date 2023/5/23 14:05
* @Version
*/
@Data
public class OpRegionalLocalDto {
/**
* 省Id
*/
private Integer provinceId;
/**
* 市Id
*/
private Integer cityId;
/**
* 区 Id
*/
private Integer areaId;
private String ip;
}
package com.dsk.search.domain;
import com.dsk.common.exception.BusinessException;
import com.github.pagehelper.PageHelper;
import lombok.AccessLevel;
import lombok.Getter;
import lombok.Setter;
import lombok.experimental.FieldDefaults;
import org.apache.commons.lang3.StringUtils;
import org.springframework.util.CollectionUtils;
import java.lang.reflect.Field;
import java.util.ArrayList;
import java.util.List;
import java.util.Map;
@Getter
@Setter
@FieldDefaults(level=AccessLevel.PRIVATE)
public class Page extends Entity {
public Page(){
}
public Page(Integer page, Integer limit) {
this.page = page;
this.limit = limit;
}
public Page(List<Map<String, Object>> list, Long total, Integer limit, Integer page){
this.list = list;
this.total = total;
this.page = page;
this.limit = limit;
}
/**
* 序列化版本标示
*/
private static final long serialVersionUID = 1L;
// 页码数
Integer page;
// 单页最大行数
Integer limit;
List<?> list;
String field;
String order;
Long total=0L;
@SuppressWarnings("rawtypes")
private void validateOrderField(boolean isPage, Class cls) {
if (isPage) {
PageHelper.startPage(page == null ? 1 : page, limit == null ? 10: limit);
}
if (!StringUtils.isEmpty(order) && cls != null&&!StringUtils.isEmpty(field)) {
String[] orders = this.order.split(",");
String[] fieldArray = this.field.split(",");
if (orders.length == fieldArray.length) {
List<Field> fields = ReflectionUtils.getDeclaredField(cls);
for (String sort : fieldArray) {
boolean isExsit = false;
for (Field field : fields) {
if (field.getName().equals(sort)) {
isExsit = true;
break;
}
}
if (!isExsit) {
throw new BusinessException("排序字段'{}'异常", sort);
}
}
StringBuilder orderBy = new StringBuilder();
for (int i = 0; i < fieldArray.length; i++) {
if (i!=0) {
orderBy.append(",");
}
orderBy.append(humpToLine(fieldArray[i])).append(orders[i].equalsIgnoreCase("desc")?" desc":" asc");
}
PageHelper.orderBy(orderBy.toString());
}
}
}
public void initPagingData(Class<?> cls){
this.validateOrderField(true, cls);
}
public void initAllData(Class<?> cls){
this.validateOrderField(false, cls);
}
public Page setResult(List<?> result){
com.github.pagehelper.Page<?> page = (com.github.pagehelper.Page<?>) result;
this.total = page.getTotal();
this.list = page.getResult();
return this;
}
public void setData(List<?> data) {
this.list = data;
}
public static String humpToLine(String str) {
return str.replaceAll("[A-Z]", "_$0").toLowerCase();
}
public List<?> getList() {
if(CollectionUtils.isEmpty(this.list)){
this.list = new ArrayList<>();
}
return list;
}
@Override
public String toString() {
return "com.md.common.entity.Page{" +
"serialVersionUID=" + serialVersionUID +
", page=" + page +
", limit=" + limit +
", list=" + list +
", field='" + field + '\'' +
", order='" + order + '\'' +
", total=" + total +
'}';
}
}
package com.dsk.search.domain;
import com.fasterxml.jackson.annotation.JsonInclude;
import lombok.Data;
@Data
@JsonInclude(JsonInclude.Include.NON_NULL)
public class Personnel {
String id;
String eid;
Integer jskEid;
String md5Company;
String name;
String sex;
String cardType;
String cardNo;
String ename;
String phone;
String registerCount;
String blaCount;
String changeCount;
String manceCount;
String noHaviorCount;
String haviorCount;
}
package com.dsk.search.domain;
import lombok.Data;
import java.util.List;
/**
* 人员查询实体类
* @author Administrator
*
*/
@Data
public class PersonnelCertificateQueryDto {
// 注册类型
List<ComposeRegisterDto> registers;
String queryType;
String queryCategory;
}
package com.dsk.search.domain;
import lombok.Data;
import java.util.Date;
@Data
public class PersonnelExeclDto {
String id;
String name;
String registerType;
String specialty;
String ename;
String cardNumber;
Date validDate;
String phone;
String pids;
String projectCount;
}
package com.dsk.search.domain;
import lombok.Data;
import java.util.List;
/**
* 人员查询实体类
* @author Administrator
*
*/
@Data
public class PersonnelQueryDto {
// 注册类型
List<RegisterTypeDto> registers;
// 人员姓名
String personName;
// 项目名称
String projectName;
// 业绩
Double startMoney;
Double endMoney;
// 企业名称
String ename;
// comp有竣工 yes有业绩 no没业绩
String mance;
String cardNumber;
String queryType;
String queryCategory;
//企业注册地
String domicile;
String domicileNum;
String domicileCity;
String registerProvince;
String registerCity;
//人员唯一标识
String md5Company;
//人员id
String staffId;
}
package com.dsk.search.domain;
import lombok.Data;
import java.util.Date;
import java.util.List;
/**
* 组合查询参数
* @author Administrator
*
*/
@Data
public class RecentlyBidQueryDto {
// 项目属地
String divisionStr;
Integer companyProvinceId;
// 项目属地
String cityStr;
String province;
Integer provinceId;
String city;
Integer cityId;
String county;
Integer countyId;
String eid;
String ename;
String pname;
String buildCorpName;
Double startMoney;
Double endMoney;
// 关键词(包含)
List<KeywordDto> keywords;
// 关键词(不包含)
String keywordNot;
//单项查询 关键词包含
String singleKeywordIn;
//单项查询 关键词不包含
String singleKeywordOut;
// 中标开始时间
Date startTenderTime;
// 中标结束时间
Date endTenderTime;
Integer achievementCount;
String projectName;
String tenderType;
String sourceName;
String projectType;
String projectTypeNew;
String hasMoney;
Double startLowerRate;
Double endLowerRate;
String hasLowerRate;
//业绩列表类型 lowerRate 下浮率业绩
String listType;
//是否有电话 0否 1是
Integer hasPhone;
}
package com.dsk.search.domain;
import java.lang.reflect.Field;
import java.util.ArrayList;
import java.util.List;
public class ReflectionUtils {
/**
* 获取全部属性 (追溯到所有顶级类)但不包括常量
*
* @param object
* @return
*/
public static List<Field> getDeclaredField(Object object) {
Class<?> clazz = object.getClass();
return getDeclaredField(clazz);
}
public static List<Field> getDeclaredField(Class<?> clazz) {
List<Field> fields = new ArrayList<Field>();
for (; clazz != Object.class; clazz = clazz.getSuperclass()) {
for (Field field : clazz.getDeclaredFields()) {
switch (field.getModifiers()) {
case 24:
case 25:
case 26:
case 28:
continue;
default:
fields.add(field);
break;
}
}
}
return fields;
}
}
package com.dsk.search.domain;
import lombok.Data;
@Data
public class RegisterTypeDto {
//来源
String personType;
// 注册专业
String registerSpecialty;
// 类型名称
String registerName;
}
package com.dsk.search.domain;
import lombok.Data;
import java.io.Serializable;
import java.util.Date;
import java.util.List;
/**
* 水利业绩筛选实体
*
* @author lcl
* @create 2021/8/30
*/
@Data
public class ShuiliAchievementQueryDto implements Serializable {
//参建单位
private String ename;
//建设单位
private String buildCorpName;
//项目负责人
private String projectPrincipal;
//业绩类型 单个
private String achievementType;
//工程类型
private String projectType;
//项目状态
private String projectStatus;
//工程等别
private String grade;
//工程级别
private String level;
//工程规模
private String projectScale;
//省
private String divisionStr;
//市
private String cityStr;
private String province;//注册地 省级code 多个逗号隔开
private String city;//注册地 市级code 多个逗号隔开
private String county;//注册地 区级code 多个逗号隔开
//关键词(包含) 多个空格分隔
private List<KeywordDto> keywords;
//关键词(不包含) 多个空格分隔
private String keywordNot;
private String keywordNotType;
//单项查询 关键词包含
private String singleKeywordIn;
//单项查询 关键词不包含
private String singleKeywordOut;
//单项查询 关键词包含体现节点
private String singleKeywordInNode;
//单项查询 关键词不包含体现节点
private String singleKeywordOutNode;
//项目金额(最大)
private Double endMoney;
//项目金额(最小)
private Double startMoney;
//项目金额体现 多个空格分隔
private String moneyStr;
//项目金额类型 and/or
private String moneyQueryType;
//实际开工时间(开始)
private Date startTimeFactBegin;
//实际开工时间(结束)
private Date startTimeFactEnd;
//实际竣工时间(开始)
private Date overTimeFactBegin;
//实际竣工时间(结束)
private Date overTimeFactEnd;
//开工日期(开始)
private Date startTimeBegin;
//开工日期(结束)
private Date startTimeEnd;
//完工日期(开始)
private Date overTimeBegin;
//完工日期(结束)
private Date overTimeEnd;
//合同签订日期(开始)
private Date contractDateBegin;
//合同签订日期(结束)
private Date contractDateEnd;
//报告提交日期(开始)
private Date reportCommitDateBegin;
//报告提交日期(结束)
private Date reportCommitDateEnd;
//时间类型 and/or
private String timeQueryType;
//截图体现节点
private String screenshotShowNode;
//截图体现类型 and/or
private String screenshotShowType;
//业绩数量
private Integer achievementCount;
}
package com.dsk.search.domain;
import lombok.Data;
@Data
public class SkyProjectIndexDto {
String descriptionType;
Double indexData;
}
package com.dsk.search.domain;
import lombok.Data;
import java.io.Serializable;
import java.util.Date;
import java.util.List;
/**
* 江西住建筛选实体
*
* @author lcl
* @create 2021/8/30
*/
@Data
public class YitihuaAchievementQueryDto implements Serializable {
//参建单位
private String ename;
//建设单位
private String buildCorpName;
//业绩类型 多个空格分隔
private String achievementType;
//项目分类 多个空格分隔
private String projectType;
//工程用途 多个空格分隔
private String purposeStr;
//建设性质 多个空格分隔
private String nature;
//招标方式 多个空格分隔
private String tenderWay;
//关键词(包含) 多个空格分隔
private List<KeywordDto> keywords;
//关键词(不包含) 多个空格分隔
private String keywordNot;
private String keywordNotType;
//单项查询 关键词包含
String singleKeywordIn;
//单项查询 关键词不包含
String singleKeywordOut;
//单项查询 关键词包含体现节点
String singleKeywordInNode;
//单项查询 关键词不包含体现节点
String singleKeywordOutNode;
//是否截图体现公司和规模 yes no
Boolean isSingleReflect;
//项目节点
private String attributeStr;
//项目节点类型 and/or
private String attributeQueryType;
//项目金额(最大)
private Double endMoney;
//项目金额(最小)
private Double startMoney;
//项目金额体现 多个空格分隔
private String moneyStr;
//中标金额
private Double startTenderMoney;
private Double endTenderMoney;
//合同金额
private Double startContractMoney;
private Double endContractMoney;
//施工许可金额
private Double startLicenceMoney;
private Double endLicenceMoney;
//竣工验收实际造价
private Double startCompletionMoney;
private Double endCompletionMoney;
//竣工备案实际造价
private Double startCheckMoney;
private Double endCheckMoney;
//总投资
private Double startInvest;
private Double endInvest;
//项目金额类型 and/or
private String moneyQueryType;
//项目面积(最大)
private Double endArea;
//项目面积(最小)
private Double startArea;
//项目面积体现 多个空格分隔
private String areaStr;
//招投标面积
private Double startTenderArea;
private Double endTenderArea;
//施工许可面积
private Double startLicenceArea;
private Double endLicenceArea;
//竣工验收面积
private Double startCheckArea;
private Double endCheckArea;
//竣工验收备案面积
private Double startCompletionArea;
private Double endCompletionArea;
//总面积
private Double startTotalArea;
private Double endTotalArea;
//项目面积类型 and/or
private String areaQueryType;
//金额和面积类型 and/or
private String moneyAndAreaQueryType;
//项目经理节点 多个空格分隔
private String pmStr;
//项目经理类型 and/or
private String pmQueryType;
//中标时间(开始-结束)
private Date startTenderTime;
private Date endTenderTime;
//合同签订时间(开始-结束)
private Date startContractDate;
private Date endContractDate;
//许可时间(开始-结束)
private Date startLicenceDate;
private Date endLicenceDate;
//备案开工时间(开始-结束)
private Date startWorkDate;
private Date endWorkDate;
//竣工备案时间(开始-结束)
private Date startCheckDate;
private Date endCheckDate;
//竣工备案时间未公示
private String hasCheckDate;
//实际开工时间(开始-结束)
private Date startCheckWorkDate;
private Date endCheckWorkDate;
//竣工验收时间(开始-结束)
private Date startCheckCheckDate;
private Date endCheckCheckDate;
//竣工验收时间未公示
private String hasCheckCheckDate;
//图审完成时间(开始-结束)
private Date startCensorDate;
private Date endCensorDate;
//时间类型 and/or
private String timeQueryType;
//省
private String divisionStr;
//市
private String cityStr;
//区
private String countyStr;
private String province;//注册地 省级code 多个逗号隔开
private String city;//注册地 市级code 多个逗号隔开
private String county;//注册地 区级code 多个逗号隔开
//业绩数量
private Integer achievementCount;
// 数据等级
private String dataLevel;
//招投标数据等级
private String tenderDataLevel;
//合同登记
private String contractDataLevel;
//施工许可
private String licenceDataLevel;
//竣工验收备案
private String completionDataLevel;
//项目主体
private String projectDataLevel;
//施工图审
private String censorDataLevel;
//竣工验收
private String checkDataLevel;
// 数据等级查询节点
private String dataLevelStr;
// 数据等级查询方式 同时具备 任意均可
private String dataLevelQueryType;
// 结构体系
private String structure;
//长度
private Double startLength;
//长度
private Double endLength;
//施工许可
private Double startLicenceLength;
private Double endLicenceLength;
//竣工验收
private Double startCheckCompletionLength;
private Double endCheckCompletionLength;
//竣工验收备案
private Double startCompletionLength;
private Double endCompletionLength;
//长度体现节点
private String lengthNode;
//长度筛选类型 or/and
private String lengthType;
//跨度
private Double startSpan;
//跨度
private Double endSpan;
//施工许可
private Double startLicenceSpan;
private Double endLicenceSpan;
//竣工验收
private Double startCheckCompletionSpan;
private Double endCheckCompletionSpan;
//竣工验收备案
private Double startCompletionSpan;
private Double endCompletionSpan;
//跨度体现节点
private String spanNode;
//跨度筛选类型 or/and
private String spanType;
}
package com.dsk.search.domain;
import lombok.Getter;
import lombok.Setter;
import java.util.List;
//在建导出参数接收
@Getter
@Setter
public class ZaiJianListDto {
List<String> md5CompanyList;
List<ZaiJianPersonnelDto> nullDataList;
}
package com.dsk.search.domain;
import com.fasterxml.jackson.annotation.JsonInclude;
import lombok.Data;
import java.util.Date;
@Data
@JsonInclude(JsonInclude.Include.NON_NULL)
public class ZaiJianPersonnelDto extends Personnel {
Integer no;
String id;
String registerType;
String cardNumber;
String sealNumber;
Date validDate;
String pid;
String eid;
Integer jskEid;
String specialty;
String ename;
String projectName;
String province;
Long tenderDate;
//中标时间
String tenderTime;
Double tenderMoney;
Integer period;
String registerInfo;
String otherRegisterInfo;
//项目状态
String status;
//人员角色
String personRole;
//业绩来源
String source;
String sourceName;
//业绩来源类型 1四库一平台 2最新中标 3全国公路
String sourceType;
//信息快照
String sourceUrl;
//合同金额
Double contractMoney;
//许可金额
Double licenceMoney;
//实际造价(竣工金额)
Double overMoney;
//结算金额
Double settlementMoney;
//金额信息
String totalMoney;
//合同时间
String contractDate;
//许可时间
String licenceDate;
//计划竣工时间
String planCompletionDate;
//实际竣工时间
String completionDate;
//计划开工时间
String planStartDate;
//实际开工时间
String startDate;
//计划交工时间
String planHandoverDate;
//实际交工时间
String handoverDate;
//时间信息
String totalDate;
//业绩个数
Long achievementCount;
//各自系统的人员id
String personId;
//快照
String snapshootPic;
//人员id
String staffId;
}
package com.dsk.search.service;
import cn.hutool.core.bean.BeanUtil;
import com.alibaba.fastjson2.JSONObject;
import com.dsk.common.core.domain.AjaxResult;
import com.dsk.common.utils.DskOpenApiUtil;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import java.util.HashMap;
import java.util.Map;
/**
* @Author liujie
* @ClassName MarketAnalysisServiceImpl
* @Date 2023/5/15 16:40
**/
@Service
public class BusinessOpportunityRadarService {
@Autowired
private DskOpenApiUtil dskOpenApiUtil;
public AjaxResult jskBidNewsPage(JSONObject object) {
Map<String, Object> map = dskOpenApiUtil.requestBody("/nationzj/jskBid/news/page", object);
return BeanUtil.toBean(map, AjaxResult.class);
}
public AjaxResult findByName(JSONObject object) {
Map<String, Object> map = dskOpenApiUtil.requestBody("/nationzj/jskBid/news/findByName", object);
return BeanUtil.toBean(map, AjaxResult.class);
}
public AjaxResult jskBidTenderPage(JSONObject object) {
Map<String, Object> map = dskOpenApiUtil.requestBody("/nationzj/jskBidTender/page", object);
return BeanUtil.toBean(map, AjaxResult.class);
}
public AjaxResult establishmentPage(JSONObject object) {
Map<String, Object> map = dskOpenApiUtil.requestBody("/nationzj/establishment/page", object);
return BeanUtil.toBean(map, AjaxResult.class);
}
public AjaxResult jskBidPage(JSONObject object) {
Map<String, Object> map = dskOpenApiUtil.requestBody("/nationzj/jskBid/page", object);
return BeanUtil.toBean(map, AjaxResult.class);
}
public AjaxResult landMarketPage(JSONObject object) {
Map<String, Object> map = dskOpenApiUtil.requestBody("/nationzj/landMarket/page", object);
return BeanUtil.toBean(map, AjaxResult.class);
}
public AjaxResult enterpriseIndex(JSONObject object) {
Map<String, Object> map = dskOpenApiUtil.requestBody("/nationzj/enterprice/index", object);
return BeanUtil.toBean(map, AjaxResult.class);
}
public AjaxResult enterprisePage(JSONObject object) {
Map<String, Object> map = dskOpenApiUtil.requestBody("/nationzj/enterprice/page", object);
return BeanUtil.toBean(map, AjaxResult.class);
}
public AjaxResult enterpriseByName(String keyword) {
Map<String, Object> params = new HashMap<>();
params.put("keyword", keyword);
Map<String, Object> map = dskOpenApiUtil.requestBody("/nationzj/enterprice/findByName", params);
return BeanUtil.toBean(map, AjaxResult.class);
}
public AjaxResult bondProjectPage(JSONObject object) {
Map<String, Object> map = dskOpenApiUtil.requestBody("/nationzj/bondProject/page", object);
return BeanUtil.toBean(map, AjaxResult.class);
}
public AjaxResult jskBidPlanPage(JSONObject object) {
Map<String, Object> map = dskOpenApiUtil.requestBody("/nationzj/jskBidPlan/page", object);
return BeanUtil.toBean(map, AjaxResult.class);
}
public AjaxResult getCapitalSourceSelect() {
Map<String, Object> map = dskOpenApiUtil.requestBody("/nationzj/jskBidPlan/getCapitalSourceSelect", null);
return BeanUtil.toBean(map, AjaxResult.class);
}
public AjaxResult keywordList() {
Map<String, Object> map = dskOpenApiUtil.requestBody("/nationzj/project/keywordList", null);
return BeanUtil.toBean(map, AjaxResult.class);
}
public AjaxResult bidSourceList(JSONObject object) {
Map<String, Object> map = dskOpenApiUtil.requestBody("/nationzj/jskBid/source", object);
return BeanUtil.toBean(map, AjaxResult.class);
}
public AjaxResult importantPage(JSONObject object) {
Map<String, Object> map = dskOpenApiUtil.requestBody("/nationzj/bondProject/importantPage", object);
return BeanUtil.toBean(map, AjaxResult.class);
}
}
package com.dsk.search.service;
import cn.hutool.core.bean.BeanUtil;
import com.alibaba.fastjson2.JSONObject;
import com.dsk.common.core.domain.AjaxResult;
import com.dsk.common.utils.DskOpenApiUtil;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import java.util.Map;
/**
* @Author liujie
* @ClassName MarketAnalysisServiceImpl
* @Date 2023/5/15 16:40
**/
@Service
public class MarketAnalysisService {
@Autowired
private DskOpenApiUtil dskOpenApiUtil;
public AjaxResult areaGroupByProvince() {
Map<String, Object> map = dskOpenApiUtil.requestBody("/nationzj/marketAnalysis/areaGroupByProvince", null);
return BeanUtil.toBean(map, AjaxResult.class);
}
public AjaxResult certGroupByMajorAndLevel() {
Map<String, Object> map = dskOpenApiUtil.requestBody("/nationzj/marketAnalysis/certGroupByMajorAndLevel", null);
return BeanUtil.toBean(map, AjaxResult.class);
}
public AjaxResult certGroupByMajorProvinceLevel() {
Map<String, Object> map = dskOpenApiUtil.requestBody("/nationzj/marketAnalysis/certGroupByMajorProvinceLevel", null);
return BeanUtil.toBean(map, AjaxResult.class);
}
public AjaxResult bidMoneyGroupByProjectType(JSONObject object) {
Map<String, Object> map = dskOpenApiUtil.requestBody("/nationzj/marketAnalysis/bidMoneyGroupByProjectType", object);
return BeanUtil.toBean(map, AjaxResult.class);
}
public AjaxResult bidGroupCountByProjectType(JSONObject object) {
Map<String, Object> map = dskOpenApiUtil.requestBody("/nationzj/marketAnalysis/bidGroupCountByProjectType", object);
return BeanUtil.toBean(map, AjaxResult.class);
}
public AjaxResult countGroupByProvince(JSONObject object) {
Map<String, Object> map = dskOpenApiUtil.requestBody("/nationzj/marketAnalysis/countGroupByProvince", object);
return BeanUtil.toBean(map, AjaxResult.class);
}
public AjaxResult countGroupByMonth(JSONObject object) {
Map<String, Object> map = dskOpenApiUtil.requestBody("/nationzj/marketAnalysis/countGroupByMonth", object);
return BeanUtil.toBean(map, AjaxResult.class);
}
public AjaxResult countNewsBidByMonth(JSONObject object) {
Map<String, Object> map = dskOpenApiUtil.requestBody("/nationzj/marketAnalysis/countNewsBidByMonth", object);
return BeanUtil.toBean(map, AjaxResult.class);
}
public AjaxResult countNewsBidByProvince(JSONObject object) {
Map<String, Object> map = dskOpenApiUtil.requestBody("/nationzj/marketAnalysis/countNewsBidByProvince", object);
return BeanUtil.toBean(map, AjaxResult.class);
}
public AjaxResult countNewsBidByYear() {
Map<String, Object> map = dskOpenApiUtil.requestBody("/nationzj/marketAnalysis/countNewsBidByYear", null);
return BeanUtil.toBean(map, AjaxResult.class);
}
public AjaxResult countLandMarketByYear() {
Map<String, Object> map = dskOpenApiUtil.requestBody("/nationzj/marketAnalysis/countLandMarketByYear", null);
return BeanUtil.toBean(map, AjaxResult.class);
}
public AjaxResult countLandMarketByProvince(JSONObject object) {
Map<String, Object> map = dskOpenApiUtil.requestBody("/nationzj/marketAnalysis/countLandMarketByProvince", object);
return BeanUtil.toBean(map, AjaxResult.class);
}
public AjaxResult countLandMarketByType(JSONObject object) {
Map<String, Object> map = dskOpenApiUtil.requestBody("/nationzj/marketAnalysis/countLandMarketByType", object);
return BeanUtil.toBean(map, AjaxResult.class);
}
public AjaxResult countBidGroupByProvince(JSONObject object) {
Map<String, Object> map = dskOpenApiUtil.requestBody("/nationzj/marketAnalysis/countBidGroupByProvince", object);
return BeanUtil.toBean(map, AjaxResult.class);
}
public AjaxResult countBidByType(JSONObject object) {
Map<String, Object> map = dskOpenApiUtil.requestBody("/nationzj/marketAnalysis/countBidByType", object);
return BeanUtil.toBean(map, AjaxResult.class);
}
public AjaxResult rangeBidMoney(JSONObject object) {
Map<String, Object> map = dskOpenApiUtil.requestBody("/nationzj/marketAnalysis/rangeBidMoney", object);
return BeanUtil.toBean(map, AjaxResult.class);
}
public AjaxResult rangeBidFiveYears() {
Map<String, Object> map = dskOpenApiUtil.requestBody("/nationzj/marketAnalysis/rangeBidFiveYears", null);
return BeanUtil.toBean(map, AjaxResult.class);
}
public AjaxResult lowerRateByYear(JSONObject object) {
Map<String, Object> map = dskOpenApiUtil.requestBody("/nationzj/marketAnalysis/lowerRateByYear", object);
return BeanUtil.toBean(map, AjaxResult.class);
}
public AjaxResult lowerRangeTenderType(JSONObject object) {
Map<String, Object> map = dskOpenApiUtil.requestBody("/nationzj/marketAnalysis/lowerRangeTenderType", object);
return BeanUtil.toBean(map, AjaxResult.class);
}
}
Markdown is supported
0% or
You are about to add 0 people to the discussion. Proceed with caution.
Finish editing this message first!
Please register or to comment