Commit 4d4c89ef authored by yaobaizheng's avatar yaobaizheng

合伙招商后台

parents
Pipeline #71 failed with stages
HELP.md
target/
!.mvn/wrapper/maven-wrapper.jar
!**/src/main/**/target/
!**/src/test/**/target/
### STS ###
.apt_generated
.classpath
.factorypath
.project
.settings
.springBeans
.sts4-cache
### IntelliJ IDEA ###
.idea
*.iws
*.iml
*.ipr
### NetBeans ###
/nbproject/private/
/nbbuild/
/dist/
/nbdist/
/.nb-gradle/
build/
!**/src/main/**/build/
!**/src/test/**/build/
### VS Code ###
.vscode/
# cfld-know-partner
## Getting started
To make it easy for you to get started with GitLab, here's a list of recommended next steps.
Already a pro? Just edit this README.md and make it your own. Want to make it easy? [Use the template at the bottom](#editing-this-readme)!
## Add your files
- [ ] [Create](https://docs.gitlab.com/ee/user/project/repository/web_editor.html#create-a-file) or [upload](https://docs.gitlab.com/ee/user/project/repository/web_editor.html#upload-a-file) files
- [ ] [Add files using the command line](https://docs.gitlab.com/ee/gitlab-basics/add-file.html#add-a-file-using-the-command-line) or push an existing Git repository with the following command:
```
cd existing_repo
git remote add origin http://10.90.102.101/cfld-group/cfld-know-partner.git
git branch -M main
git push -uf origin main
```
## Integrate with your tools
- [ ] [Set up project integrations](http://10.90.102.101/cfld-group/cfld-know-partner/-/settings/integrations)
## Collaborate with your team
- [ ] [Invite team members and collaborators](https://docs.gitlab.com/ee/user/project/members/)
- [ ] [Create a new merge request](https://docs.gitlab.com/ee/user/project/merge_requests/creating_merge_requests.html)
- [ ] [Automatically close issues from merge requests](https://docs.gitlab.com/ee/user/project/issues/managing_issues.html#closing-issues-automatically)
- [ ] [Enable merge request approvals](https://docs.gitlab.com/ee/user/project/merge_requests/approvals/)
- [ ] [Automatically merge when pipeline succeeds](https://docs.gitlab.com/ee/user/project/merge_requests/merge_when_pipeline_succeeds.html)
## Test and Deploy
Use the built-in continuous integration in GitLab.
- [ ] [Get started with GitLab CI/CD](https://docs.gitlab.com/ee/ci/quick_start/index.html)
- [ ] [Analyze your code for known vulnerabilities with Static Application Security Testing(SAST)](https://docs.gitlab.com/ee/user/application_security/sast/)
- [ ] [Deploy to Kubernetes, Amazon EC2, or Amazon ECS using Auto Deploy](https://docs.gitlab.com/ee/topics/autodevops/requirements.html)
- [ ] [Use pull-based deployments for improved Kubernetes management](https://docs.gitlab.com/ee/user/clusters/agent/)
- [ ] [Set up protected environments](https://docs.gitlab.com/ee/ci/environments/protected_environments.html)
***
# Editing this README
When you're ready to make this README your own, just edit this file and use the handy template below (or feel free to structure it however you want - this is just a starting point!). Thank you to [makeareadme.com](https://www.makeareadme.com/) for this template.
## Suggestions for a good README
Every project is different, so consider which of these sections apply to yours. The sections used in the template are suggestions for most open source projects. Also keep in mind that while a README can be too long and detailed, too long is better than too short. If you think your README is too long, consider utilizing another form of documentation rather than cutting out information.
## Name
Choose a self-explaining name for your project.
## Description
Let people know what your project can do specifically. Provide context and add a link to any reference visitors might be unfamiliar with. A list of Features or a Background subsection can also be added here. If there are alternatives to your project, this is a good place to list differentiating factors.
## Badges
On some READMEs, you may see small images that convey metadata, such as whether or not all the tests are passing for the project. You can use Shields to add some to your README. Many services also have instructions for adding a badge.
## Visuals
Depending on what you are making, it can be a good idea to include screenshots or even a video (you'll frequently see GIFs rather than actual videos). Tools like ttygif can help, but check out Asciinema for a more sophisticated method.
## Installation
Within a particular ecosystem, there may be a common way of installing things, such as using Yarn, NuGet, or Homebrew. However, consider the possibility that whoever is reading your README is a novice and would like more guidance. Listing specific steps helps remove ambiguity and gets people to using your project as quickly as possible. If it only runs in a specific context like a particular programming language version or operating system or has dependencies that have to be installed manually, also add a Requirements subsection.
## Usage
Use examples liberally, and show the expected output if you can. It's helpful to have inline the smallest example of usage that you can demonstrate, while providing links to more sophisticated examples if they are too long to reasonably include in the README.
## Support
Tell people where they can go to for help. It can be any combination of an issue tracker, a chat room, an email address, etc.
## Roadmap
If you have ideas for releases in the future, it is a good idea to list them in the README.
## Contributing
State if you are open to contributions and what your requirements are for accepting them.
For people who want to make changes to your project, it's helpful to have some documentation on how to get started. Perhaps there is a script that they should run or some environment variables that they need to set. Make these steps explicit. These instructions could also be useful to your future self.
You can also document commands to lint the code or run tests. These steps help to ensure high code quality and reduce the likelihood that the changes inadvertently break something. Having instructions for running tests is especially helpful if it requires external setup, such as starting a Selenium server for testing in a browser.
## Authors and acknowledgment
Show your appreciation to those who have contributed to the project.
## License
For open source projects, say how it is licensed.
## Project status
If you have run out of energy or time for your project, put a note at the top of the README saying that development has slowed down or stopped completely. Someone may choose to fork your project or volunteer to step in as a maintainer or owner, allowing your project to keep going. You can also make an explicit request for maintainers.
<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 https://maven.apache.org/xsd/maven-4.0.0.xsd">
<modelVersion>4.0.0</modelVersion>
<!--parent指明继承关系-->
<parent>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-parent</artifactId>
<version>2.7.15</version>
</parent>
<groupId>com.partner</groupId>
<artifactId>cfld-know-partner</artifactId>
<version>0.0.1-SNAPSHOT</version>
<name>partner-admin</name>
<description>partner-admin</description>
<packaging>jar</packaging>
<properties>
<java.version>1.8</java.version>
<pagehelper.boot.version>1.4.6</pagehelper.boot.version>
<mybatis.plus.version>3.5.2</mybatis.plus.version>
<druid.version>1.2.16</druid.version>
<hutool.version>5.8.20</hutool.version>
<lombook.version>1.18.28</lombook.version>
<swagger.version>3.0.0</swagger.version>
<swagger-models.version>1.6.2</swagger-models.version>
<knife4j.version>3.0.3</knife4j.version>
<commons.io.version>2.11.0</commons.io.version>
</properties>
<dependencies>
<!--mysql连接驱动-->
<dependency>
<groupId>com.mysql</groupId>
<artifactId>mysql-connector-j</artifactId>
<scope>runtime</scope>
</dependency>
<!-- 阿里数据库连接池 -->
<dependency>
<groupId>com.alibaba</groupId>
<artifactId>druid-spring-boot-starter</artifactId>
<version>${druid.version}</version>
</dependency>
<!-- pagehelper分页插件 -->
<dependency>
<groupId>com.github.pagehelper</groupId>
<artifactId>pagehelper-spring-boot-starter</artifactId>
<version>${pagehelper.boot.version}</version>
</dependency>
<!-- mybatis增强器依赖 -->
<dependency>
<groupId>com.baomidou</groupId>
<artifactId>mybatis-plus-boot-starter</artifactId>
<version>${mybatis.plus.version}</version>
</dependency>
<!-- mybatis-plus代码生成器依赖 -->
<!-- <dependency>-->
<!-- <groupId>com.baomidou</groupId>-->
<!-- <artifactId>mybatis-plus-generator</artifactId>-->
<!-- <version>${mybatis.plus.version}</version>-->
<!-- </dependency>-->
<!-- hutool工具包 -->
<dependency>
<groupId>cn.hutool</groupId>
<artifactId>hutool-all</artifactId>
<version>${hutool.version}</version>
</dependency>
<dependency>
<groupId>org.projectlombok</groupId>
<artifactId>lombok</artifactId>
<version>${lombook.version}</version>
</dependency>
<!-- Swagger3依赖 -->
<!-- <dependency>-->
<!-- <groupId>io.springfox</groupId>-->
<!-- <artifactId>springfox-boot-starter</artifactId>-->
<!-- <version>${swagger.version}</version>-->
<!-- </dependency>-->
<dependency>
<groupId>com.github.xiaoymin</groupId>
<artifactId>knife4j-spring-boot-starter</artifactId>
<version>${knife4j.version}</version>
</dependency>
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-web</artifactId>
</dependency>
<dependency>
<groupId>org.springframework</groupId>
<artifactId>spring-core</artifactId>
</dependency>
<!-- SpringBoot 拦截器 -->
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-aop</artifactId>
</dependency>
<!--热部署-->
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-devtools</artifactId>
<scope>runtime</scope>
<optional>true</optional>
</dependency>
<!--常用工具类 -->
<dependency>
<groupId>org.apache.commons</groupId>
<artifactId>commons-lang3</artifactId>
</dependency>
<!-- io常用工具类 -->
<dependency>
<groupId>commons-io</groupId>
<artifactId>commons-io</artifactId>
<version>${commons.io.version}</version>
</dependency>
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-test</artifactId>
<scope>test</scope>
</dependency>
<!-- #解决swagger报错 Failed to start bean ‘documentationPluginsBootstrapper’-->
<dependency>
<groupId>io.springfox</groupId>
<artifactId>springfox-spring-webmvc</artifactId>
<version>3.0.0</version>
</dependency>
<!--华为obs依赖 -->
<dependency>
<groupId>com.huaweicloud</groupId>
<artifactId>esdk-obs-java</artifactId>
<version>3.21.8</version>
</dependency>
<dependency>
<groupId>org.web3j</groupId>
<artifactId>core</artifactId>
<version>5.0.0</version>
</dependency>
<dependency>
<groupId>com.squareup.okhttp3</groupId>
<artifactId>okhttp</artifactId>
<version>4.3.1</version>
</dependency>
</dependencies>
<build>
<plugins>
<plugin>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-maven-plugin</artifactId>
<configuration>
<fork>true</fork> <!-- 如果没有该配置,devtools不会生效 -->
</configuration>
</plugin>
</plugins>
</build>
</project>
package com.partner.admin;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
@SpringBootApplication
public class DfldKnowPartnerApplication {
public static void main(String[] args) {
SpringApplication.run(DfldKnowPartnerApplication.class, args);
}
}
package com.partner.admin;
import org.springframework.boot.builder.SpringApplicationBuilder;
import org.springframework.boot.web.servlet.support.SpringBootServletInitializer;
public class ServletInitializer extends SpringBootServletInitializer {
@Override
protected SpringApplicationBuilder configure(SpringApplicationBuilder application) {
return application.sources(DfldKnowPartnerApplication.class);
}
}
package com.partner.admin.VO;
import com.partner.admin.domain.PartnerImageSource;
import io.swagger.annotations.ApiModel;
import io.swagger.annotations.ApiModelProperty;
import lombok.Data;
import java.io.Serializable;
import java.math.BigDecimal;
import java.util.ArrayList;
import java.util.List;
/**
*
*/
@Data
@ApiModel(value = "返回登陆时首页轮播图,统计数信息")
public class HomePageLoginInfoVO implements Serializable {
@ApiModelProperty(value = "轮播图")
private List<PartnerImageSource> partnerImageSourceList = new ArrayList<>();
@ApiModelProperty(value = "总项目量")
private Long projectAllCount = 0L;
@ApiModelProperty(value = "总投资额")
private BigDecimal projectInvestmentTotal = new BigDecimal(0.0);
@ApiModelProperty(value = "审核中的项目")
private Long projectExamineCount = 0L;
@ApiModelProperty(value = "推进中的项目")
private Long projectPushCount = 0L;
private static final long serialVersionUID = 1L;
}
\ No newline at end of file
package com.partner.admin.VO;
import com.partner.admin.domain.PartnerImageSource;
import io.swagger.annotations.ApiModel;
import io.swagger.annotations.ApiModelProperty;
import lombok.Data;
import java.io.Serializable;
import java.math.BigDecimal;
import java.util.ArrayList;
import java.util.List;
/**
*
*/
@Data
@ApiModel(value = "返回未登陆时首页轮播图,统计数信息")
public class HomePageLogoutInfoVO implements Serializable {
@ApiModelProperty(value = "轮播图")
private List<PartnerImageSource> partnerImageSourceList = new ArrayList<>();
@ApiModelProperty(value = "总项目量")
private Long projectAllCount = 0L;
@ApiModelProperty(value = "项目总投资额")
private BigDecimal projectInvestmentTotal = new BigDecimal(0.0);
@ApiModelProperty(value = "项目总固定资产投资额")
private BigDecimal projectInvestmentRegular = new BigDecimal(0.0);
@ApiModelProperty(value = "平台合伙人")
private Long partnerCount = 0L;
private static final long serialVersionUID = 1L;
}
\ No newline at end of file
package com.partner.admin.VO;
import com.partner.admin.domain.PartnerBaseInfo;
import com.partner.admin.domain.PartnerCoporateAccountInfo;
import com.partner.admin.domain.PartnerImageSource;
import lombok.Data;
import java.io.Serializable;
import java.util.ArrayList;
import java.util.List;
@Data
public class PartnerBaseInfoVO implements Serializable {
// /**
// * 合伙人id
// */
// @TableId
// private Integer id;
//
// /**
// * 昵称
// */
// private String nickName;
//
// /**
// * 头像
// */
// private String headerUrl;
//
// /**
// * 0-未认知 1-已认证 未认证不能做佣金提取 -真实姓名和身份证都有才认为认证通过
// */
// private Integer hasAuthentication;
//
// /**
// * 手机号
// */
// private String mobilePhone;
//
// /**
// * 资料完成度
// */
// private String infoPrecentage;
//
// /**
// * 真实姓名
// */
// private String realName;
//
// /**
// * 身份证号
// */
// private String idcardNumber;
//
// /**
// * 开户行
// */
// private String bank;
//
// /**
// * 银行账户
// */
// private String bankCard;
//
// /**
// * 在职公司
// */
// private String company;
//
// /**
// * 在职行业
// */
// private String industry;
//
// /**
// * 所在职位
// */
// private String position;
//
// /**
// * 负责内容
// */
// private String responsbility;
//
// /**
// * 邮箱地址
// */
// private String email;
//
// /**
// * 毕业院校
// */
// private String college;
//
// /**
// *
// */
// private String region;
//
// /**
// * 租户id
// */
// private Integer tenantId;
//
// /**
// *
// */
// private String openId;
private PartnerBaseInfo partnerBaseInfo = new PartnerBaseInfo();
private List<PartnerCoporateAccountInfoVO> partnerCoporateAccountInfoVO = new ArrayList<>();
private static final long serialVersionUID = 1L;
}
\ No newline at end of file
package com.partner.admin.VO;
import com.baomidou.mybatisplus.annotation.TableField;
import com.baomidou.mybatisplus.annotation.TableId;
import com.baomidou.mybatisplus.annotation.TableName;
import com.partner.admin.domain.PartnerCoporateAccountInfo;
import com.partner.admin.domain.PartnerImageSource;
import io.swagger.annotations.ApiModel;
import io.swagger.annotations.ApiModelProperty;
import lombok.Data;
import java.io.Serializable;
import java.util.ArrayList;
import java.util.Date;
import java.util.List;
/**
*
* @TableName partner_coporate_account_info
*/
@TableName(value ="partner_coporate_account_info")
@Data
public class PartnerCoporateAccountInfoVO implements Serializable {
private PartnerCoporateAccountInfo partnerCoporateAccountInfo = new PartnerCoporateAccountInfo();
private List<PartnerImageSource> partnerImageSourceList = new ArrayList<>();
@TableField(exist = false)
private static final long serialVersionUID = 1L;
}
\ No newline at end of file
package com.partner.admin.VO;
import com.baomidou.mybatisplus.annotation.IdType;
import com.baomidou.mybatisplus.annotation.TableField;
import com.baomidou.mybatisplus.annotation.TableId;
import com.baomidou.mybatisplus.annotation.TableName;
import io.swagger.annotations.ApiModel;
import io.swagger.annotations.ApiModelProperty;
import lombok.Data;
import java.io.Serializable;
import java.math.BigDecimal;
import java.util.Date;
/**
*
* @TableName partner_project_info
*/
@Data
@ApiModel(value="项目信息")
public class PartnerExamineProjectInfoVO implements Serializable {
/**
*
*/
@ApiModelProperty(hidden = true)
private Integer id;
/**
* 投资主体
*/
@ApiModelProperty(value = "投资主体")
private String investmentSubject;
/**
* 投资总额
*/
@ApiModelProperty(value = "投资总额")
private BigDecimal projectInvestmentTotal;
/**
* 固定资产投资总额
*/
@ApiModelProperty(value = "固定资产投资总额")
private BigDecimal projectInvestmentRegular;
/**
* 0-暂存 1-信息提报 2-项目查重通过 3-项目查重拒绝 4-招商公司匹配 5-企业对接 6-投资意向确认 7-确认项目信息 8-完成审核 9-项目信息 10-项目沟通 11-区域匹配 12-政企互访 13-项目谈判 14-项目签约 15-分配中 20-作废
*/
@ApiModelProperty(hidden = true)
private Integer status;
/**
* 0-暂存 1-信息提报 2-项目查重通过 3-项目查重拒绝 4-招商公司匹配 5-企业对接 6-投资意向确认 7-确认项目信息 8-完成审核 9-项目信息 10-项目沟通 11-区域匹配 12-政企互访 13-项目谈判 14-项目签约 15-分配中 20-作废
*/
@ApiModelProperty(hidden = true)
private String statusDescription;
/**
* 匹配招商公司
*/
@ApiModelProperty(value = "匹配招商公司")
private String investmentPromotionCompany;
/**
* 0-项目查重确认 1-确认项目所属 2-确认佣金比例
*/
@ApiModelProperty(hidden = true)
private Integer todoStatus;
@TableField(exist = false)
private static final long serialVersionUID = 1L;
}
\ No newline at end of file
package com.partner.admin.VO;
import com.baomidou.mybatisplus.annotation.IdType;
import com.baomidou.mybatisplus.annotation.TableField;
import com.baomidou.mybatisplus.annotation.TableId;
import com.baomidou.mybatisplus.annotation.TableName;
import io.swagger.annotations.ApiModel;
import io.swagger.annotations.ApiModelProperty;
import lombok.Data;
import java.io.Serializable;
import java.util.Date;
/**
* 用户信息表
* @TableName sys_user
*/
@Data
@ApiModel(value = "个人基本信息")
public class SysUserVO implements Serializable {
/**
* 用户ID
*/
@ApiModelProperty(value = "用户ID")
private Integer userId;
/**
* 登录账号
*/
@ApiModelProperty(value = "登录账号")
private String loginName;
/**
* 用户昵称
*/
@ApiModelProperty(value = "用户昵称")
private String userName;
/**
* 用户邮箱
*/
@ApiModelProperty(value = "用户邮箱")
private String email;
/**
* 手机号码
*/
@ApiModelProperty(value = "手机号码")
private String phonenumber;
/**
* 头像路径
*/
@ApiModelProperty(value = "头像路径")
private String avatar;
@ApiModelProperty(value = "token")
private String token;
private static final long serialVersionUID = 1L;
}
\ No newline at end of file
package com.partner.admin.common.config;
import org.mybatis.spring.annotation.MapperScan;
import org.springframework.context.annotation.Configuration;
import org.springframework.context.annotation.EnableAspectJAutoProxy;
/**
* @author yaobaizheng
*/
@Configuration
// 表示通过aop框架暴露该代理对象,AopContext能够访问
@EnableAspectJAutoProxy(exposeProxy = true)
// 指定要扫描的Mapper类的包的路径
@MapperScan("com.partner.**.mapper")
public class ApplicationConfig
{
}
package com.partner.admin.common.config;
import lombok.Data;
import org.springframework.boot.context.properties.ConfigurationProperties;
import org.springframework.stereotype.Component;
/**
* 全局配置类
* @author yaobaizheng
*/
@Data
@Component
@ConfigurationProperties(prefix = "partner")
public class PartnerConfig
{
private String profile;
private String obsPath;
private Integer tokenExpireTimeDays;
private Boolean enableUrlFilter;
}
package com.partner.admin.common.config;
import com.partner.admin.common.interceptor.LoginInterceptor;
import org.apache.commons.lang3.ArrayUtils;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.web.cors.CorsConfiguration;
import org.springframework.web.cors.UrlBasedCorsConfigurationSource;
import org.springframework.web.filter.CorsFilter;
import org.springframework.web.servlet.config.annotation.InterceptorRegistry;
import org.springframework.web.servlet.config.annotation.WebMvcConfigurer;
/**
* @author yaobaizheng
* @desc 解决跨域问题
*/
@Configuration
public class ResourceConfig implements WebMvcConfigurer {
@Autowired
LoginInterceptor loginInterceptor;
@Autowired
PartnerConfig parterConfig;
/**
* 自定义拦截规则
*/
@Override
public void addInterceptors(InterceptorRegistry registry)
{
if(parterConfig.getEnableUrlFilter()){
String[] excludeSwagger = new String[]{"/swagger-resources/**",
"/webjars/**", "/v2/**","/v3/**", "/swagger-ui.html/**",
"/api", "/api-docs", "/api-docs/**", "/doc.html/**"};
String[] excludeUrl = new String[]{"/weixin/**",
"/sysFile/**","/common/**"};
String[] excludePatterns = (String[]) ArrayUtils.addAll(excludeSwagger, excludeUrl);
System.out.println("自定义拦截器#############################################");
registry.addInterceptor(loginInterceptor)
.addPathPatterns("/**")
.excludePathPatterns(excludePatterns);
}
}
/**
* 跨域配置
*/
@Bean
public CorsFilter corsFilter()
{
CorsConfiguration config = new CorsConfiguration();
config.setAllowCredentials(true);
// 设置访问源地址
config.addAllowedOriginPattern("*");
// 设置访问源请求头
config.addAllowedHeader("*");
// 设置访问源请求方法
config.addAllowedMethod("*");
// 有效期 3600秒
config.setMaxAge(3600L);
// 添加映射路径,拦截一切请求
UrlBasedCorsConfigurationSource source = new UrlBasedCorsConfigurationSource();
source.registerCorsConfiguration("/**", config);
// 返回新的CorsFilter
return new CorsFilter(source);
}
}
package com.partner.admin.common.config;
import com.partner.admin.common.exception.APIExceptionEnum;
import com.partner.admin.common.utils.AjaxResult;
import io.swagger.annotations.ApiOperation;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import springfox.documentation.builders.ApiInfoBuilder;
import springfox.documentation.builders.PathSelectors;
import springfox.documentation.builders.RequestHandlerSelectors;
import springfox.documentation.builders.ResponseBuilder;
import springfox.documentation.service.ApiInfo;
import springfox.documentation.service.Contact;
import springfox.documentation.service.Response;
import springfox.documentation.spi.DocumentationType;
import springfox.documentation.spring.web.plugins.Docket;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;
import static org.springframework.http.HttpMethod.*;
/**
* Swagger3的接口配置,使用的是knife4j,Swagger3的增强
* @author 姚百政
*/
@Configuration
public class SwaggerConfig
{
/** 是否开启swagger */
@Value("${swagger.enabled}")
private boolean enabled;
/**
* 创建API
*/
@Bean
public Docket createRestApi()
{
/** 更改默认返回码 */
List<Response> responseList = new ArrayList<>();
Arrays.stream(AjaxResult.Type.values()).forEach(resultCode -> {
responseList.add(
new ResponseBuilder().code(String.valueOf( resultCode.value())).description(resultCode.message()).build()
);
});
return new Docket(DocumentationType.OAS_30)
.globalResponses(GET, responseList)
.globalResponses(POST, responseList)
.globalResponses(PUT, responseList)
.globalResponses(DELETE, responseList)
// .globalResponses(HEAD, responseList)
// .globalResponses(PATCH, responseList)
// .globalResponses(OPTIONS, responseList)
// .globalResponses(TRACE, responseList)
// 是否启用Swagger
.enable(enabled)
//分组设置
.groupName("合伙人平台基本接口")
// 用来创建该API的基本信息,展示在文档的页面中(自定义展示的信息)
.apiInfo(apiInfo())
// 设置哪些接口暴露给Swagger展示
.select()
// 扫描所有有注解的api,用这种方式更灵活
.apis(RequestHandlerSelectors.withMethodAnnotation(ApiOperation.class))
// 扫描指定包中的swagger注解
// .apis(RequestHandlerSelectors.basePackage("com.lyy.admin.controller"))
// 扫描所有
// .apis(RequestHandlerSelectors.any())
.paths(PathSelectors.any())
.build();
}
/**
* 添加摘要信息
*/
private ApiInfo apiInfo()
{
// 用ApiInfoBuilder进行定制
return new ApiInfoBuilder()
// 设置标题
.title("标题:合伙人招商平台_接口文档")
// 描述
.description("描述:合伙人招商平台后端接口")
// 作者信息
.contact(new Contact("PARTNER", null, null))
// 版本
.version("版本号:0.0.1" )
.build();
}
}
package com.partner.admin.common.constant;
/**
* 通用常量信息
* @author yaobaizheng
*/
public class Constants {
/**
* UTF-8 字符集
*/
public static final String UTF8 = "UTF-8";
/**
* GBK 字符集
*/
public static final String GBK = "GBK";
/**
* http请求
*/
public static final String HTTP = "http://";
/**
* https请求
*/
public static final String HTTPS = "https://";
/**
* 通用成功标识
*/
public static final String SUCCESS = "0";
/**
* 通用失败标识
*/
public static final String FAIL = "1";
/**
* 登录成功
*/
public static final String LOGIN_SUCCESS = "Success";
/**
* 注销
*/
public static final String LOGOUT = "Logout";
/**
* 注册
*/
public static final String REGISTER = "Register";
/**
* 登录失败
*/
public static final String LOGIN_FAIL = "Error";
/**
* 系统用户授权缓存
*/
public static final String SYS_AUTH_CACHE = "sys-authCache";
/**
* 参数管理 cache name
*/
public static final String SYS_CONFIG_CACHE = "sys-config";
/**
* 参数管理 cache key
*/
public static final String SYS_CONFIG_KEY = "sys_config:";
/**
* 字典管理 cache name
*/
public static final String SYS_DICT_CACHE = "sys-dict";
/**
* 字典管理 cache key
*/
public static final String SYS_DICT_KEY = "sys_dict:";
/**
* 资源映射路径 前缀
*/
public static final String RESOURCE_PREFIX = "/profile";
/**
* RMI 远程方法调用
*/
public static final String LOOKUP_RMI = "rmi:";
/**
* LDAP 远程方法调用
*/
public static final String LOOKUP_LDAP = "ldap:";
/**
* LDAPS 远程方法调用
*/
public static final String LOOKUP_LDAPS = "ldaps:";
/**
* 定时任务白名单配置(仅允许访问的包名,如其他需要可以自行添加)
*/
public static final String[] JOB_WHITELIST_STR = { "com.ruoyi" };
/**
* 定时任务违规的字符
*/
public static final String[] JOB_ERROR_STR = { "java.net.URL", "javax.naming.InitialContext", "org.yaml.snakeyaml",
"org.springframework", "org.apache", "com.ruoyi.common.utils.file", "com.ruoyi.common.config" };
}
\ No newline at end of file
package com.partner.admin.common.exception;
import lombok.Data;
@Data
public class APIException extends RuntimeException {
private int code;
private String message;
public int getCode() {
return code;
}
public String getMessage() {
return message;
}
public APIException(int code, String message) {
this.code = code;
this.message = message;
}
public APIException(APIExceptionEnum apiExceptionEnum) {
this.code = apiExceptionEnum.getCode();
this.message = apiExceptionEnum.getMessage();
}
}
package com.partner.admin.common.exception;
import lombok.Getter;
@Getter
public enum APIExceptionEnum {
//用户
USER_NOTEXISTS(4001, "当前用户不存在"),
USER_PASSWORD_ERROR(4002, "当前用户密码输入错误"),
USER_TOKEN_EXPIRE(4003, "当前会话失效,请重新登录"),
NOTEXISTS_EXCEPTION(4500, "数据不存在,请确认!"),
//
WX_GETPHONENUMBER_ERROR(40029, "微信获取手机号code码无效,或着微信异常,请重试!");
private int code;
private String message;
APIExceptionEnum(int code, String message) {
this.code = code;
this.message = message;
}
public int getCode() {
return code;
}
public String getMsg() {
return message;
}
}
package com.partner.admin.common.exception;
import com.fasterxml.jackson.core.JsonProcessingException;
import com.fasterxml.jackson.databind.ObjectMapper;
import com.partner.admin.common.utils.AjaxResult;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.core.MethodParameter;
import org.springframework.http.MediaType;
import org.springframework.http.server.ServerHttpRequest;
import org.springframework.http.server.ServerHttpResponse;
import org.springframework.validation.BindException;
import org.springframework.web.HttpRequestMethodNotSupportedException;
import org.springframework.web.bind.MissingPathVariableException;
import org.springframework.web.bind.annotation.ExceptionHandler;
import org.springframework.web.bind.annotation.RestControllerAdvice;
import org.springframework.web.method.annotation.MethodArgumentTypeMismatchException;
import org.springframework.web.servlet.mvc.method.annotation.ResponseBodyAdvice;
import javax.servlet.http.HttpServletRequest;
/**
* 全局异常处理器
* @author yaobaizheng
*/
@RestControllerAdvice(basePackages = "com.partner.admin.controller")
public class GlobalExceptionHandler implements ResponseBodyAdvice {
private static final Logger log = LoggerFactory.getLogger(GlobalExceptionHandler.class);
@Override
public boolean supports(MethodParameter returnType, Class converterType) {
boolean assignableFrom = returnType.getParameterType().isAssignableFrom(AjaxResult.class);
return !assignableFrom;
}
@Override
public Object beforeBodyWrite(Object body, MethodParameter returnType, MediaType selectedContentType, Class selectedConverterType, ServerHttpRequest request, ServerHttpResponse response) {
AjaxResult value = AjaxResult.success(body);
boolean isStringResult = returnType.getParameterType().equals(String.class);
if (isStringResult) {
ObjectMapper objectMapper = new ObjectMapper();
try {
String s = objectMapper.writeValueAsString(value);
return s;
} catch (JsonProcessingException e) {
e.printStackTrace();
try {
throw new Exception(e.getMessage());
} catch (Exception ex) {
ex.printStackTrace();
}
}
}
return value;
}
@ExceptionHandler(APIException.class)
public AjaxResult APIExceptionHandler(APIException apiException) {
int code = apiException.getCode();
String message = apiException.getMessage();
AjaxResult fail = AjaxResult.warn( message);
if(code == APIExceptionEnum.USER_TOKEN_EXPIRE.getCode()){
fail = AjaxResult.userTokenExpier(message);
}
return fail;
}
/**
* 请求方式不支持
*/
@ExceptionHandler(HttpRequestMethodNotSupportedException.class)
public AjaxResult handleHttpRequestMethodNotSupported(HttpRequestMethodNotSupportedException e,
HttpServletRequest request)
{
String requestURI = request.getRequestURI();
log.error("请求地址'{}',不支持'{}'请求", requestURI, e.getMethod());
return AjaxResult.error(e.getMessage());
}
/**
* 拦截未知的运行时异常
*/
@ExceptionHandler(RuntimeException.class)
public AjaxResult handleRuntimeException(RuntimeException e, HttpServletRequest request)
{
String requestURI = request.getRequestURI();
log.error("请求地址'{}',发生未知异常.", requestURI, e);
return AjaxResult.error(e.getMessage());
}
/**
* 系统异常
*/
@ExceptionHandler(Exception.class)
public AjaxResult handleException(Exception e, HttpServletRequest request)
{
String requestURI = request.getRequestURI();
log.error("请求地址'{}',发生系统异常.", requestURI, e);
return AjaxResult.error(e.getMessage());
}
/**
* 请求路径中缺少必需的路径变量
*/
@ExceptionHandler(MissingPathVariableException.class)
public AjaxResult handleMissingPathVariableException(MissingPathVariableException e, HttpServletRequest request)
{
String requestURI = request.getRequestURI();
log.error("请求路径中缺少必需的路径变量'{}',发生系统异常.", requestURI, e);
return AjaxResult.error(String.format("请求路径中缺少必需的路径变量[%s]", e.getVariableName()));
}
/**
* 请求参数类型不匹配
*/
@ExceptionHandler(MethodArgumentTypeMismatchException.class)
public AjaxResult handleMethodArgumentTypeMismatchException(MethodArgumentTypeMismatchException e,
HttpServletRequest request)
{
String requestURI = request.getRequestURI();
log.error("请求参数类型不匹配'{}',发生系统异常.", requestURI, e);
return AjaxResult.error(String.format("请求参数类型不匹配,参数[%s]要求类型为:'%s',但输入值为:'%s'", e.getName(), e.getRequiredType().getName(), e.getValue()));
}
/**
* 自定义验证异常
*/
@ExceptionHandler(BindException.class)
public AjaxResult handleBindException(BindException e)
{
log.error(e.getMessage(), e);
String message = e.getAllErrors().get(0).getDefaultMessage();
return AjaxResult.error(message);
}
}
package com.partner.admin.common.exception;
/**
* 工具类异常
* @author yaobaizheng
*/
public class UtilException extends RuntimeException
{
private static final long serialVersionUID = 8247610319171014183L;
public UtilException(Throwable e)
{
super(e.getMessage(), e);
}
public UtilException(String message)
{
super(message);
}
public UtilException(String message, Throwable throwable)
{
super(message, throwable);
}
}
package com.partner.admin.common.exception.base;
import com.partner.admin.common.utils.MessageUtils;
import com.partner.admin.common.utils.StringUtils;
/**
* 基础异常
*
* @author ruoyi
*/
public class BaseException extends RuntimeException
{
private static final long serialVersionUID = 1L;
/**
* 所属模块
*/
private String module;
/**
* 错误码
*/
private String code;
/**
* 错误码对应的参数
*/
private Object[] args;
/**
* 错误消息
*/
private String defaultMessage;
public BaseException(String module, String code, Object[] args, String defaultMessage)
{
this.module = module;
this.code = code;
this.args = args;
this.defaultMessage = defaultMessage;
}
public BaseException(String module, String code, Object[] args)
{
this(module, code, args, null);
}
public BaseException(String module, String defaultMessage)
{
this(module, null, null, defaultMessage);
}
public BaseException(String code, Object[] args)
{
this(null, code, args, null);
}
public BaseException(String defaultMessage)
{
this(null, null, null, defaultMessage);
}
@Override
public String getMessage()
{
String message = null;
if (!StringUtils.isEmpty(code))
{
message = MessageUtils.message(code, args);
}
if (message == null)
{
message = defaultMessage;
}
return message;
}
public String getModule()
{
return module;
}
public String getCode()
{
return code;
}
public Object[] getArgs()
{
return args;
}
public String getDefaultMessage()
{
return defaultMessage;
}
}
package com.partner.admin.common.exception.file;
import com.partner.admin.common.exception.base.BaseException;
/**
* 文件信息异常类
*
* @author ruoyi
*/
public class FileException extends BaseException
{
private static final long serialVersionUID = 1L;
public FileException(String code, Object[] args)
{
super("file", code, args, null);
}
}
package com.partner.admin.common.exception.file;
/**
* 文件名称超长限制异常类
*
* @author ruoyi
*/
public class FileNameLengthLimitExceededException extends FileException
{
private static final long serialVersionUID = 1L;
public FileNameLengthLimitExceededException(int defaultFileNameLength)
{
super("upload.filename.exceed.length", new Object[] { defaultFileNameLength });
}
}
package com.partner.admin.common.exception.file;
/**
* 文件名大小限制异常类
*
* @author ruoyi
*/
public class FileSizeLimitExceededException extends FileException
{
private static final long serialVersionUID = 1L;
public FileSizeLimitExceededException(long defaultMaxSize)
{
super("upload.exceed.maxSize", new Object[] { defaultMaxSize });
}
}
package com.partner.admin.common.exception.file;
import java.io.PrintStream;
import java.io.PrintWriter;
/**
* 文件上传异常类
*
* @author ruoyi
*/
public class FileUploadException extends Exception
{
private static final long serialVersionUID = 1L;
private final Throwable cause;
public FileUploadException()
{
this(null, null);
}
public FileUploadException(final String msg)
{
this(msg, null);
}
public FileUploadException(String msg, Throwable cause)
{
super(msg);
this.cause = cause;
}
@Override
public void printStackTrace(PrintStream stream)
{
super.printStackTrace(stream);
if (cause != null)
{
stream.println("Caused by:");
cause.printStackTrace(stream);
}
}
@Override
public void printStackTrace(PrintWriter writer)
{
super.printStackTrace(writer);
if (cause != null)
{
writer.println("Caused by:");
cause.printStackTrace(writer);
}
}
@Override
public Throwable getCause()
{
return cause;
}
}
package com.partner.admin.common.exception.file;
import java.util.Arrays;
/**
* 文件上传 误异常类
*
* @author ruoyi
*/
public class InvalidExtensionException extends FileUploadException
{
private static final long serialVersionUID = 1L;
private String[] allowedExtension;
private String extension;
private String filename;
public InvalidExtensionException(String[] allowedExtension, String extension, String filename)
{
super("文件[" + filename + "]后缀[" + extension + "]不正确,请上传" + Arrays.toString(allowedExtension) + "格式");
this.allowedExtension = allowedExtension;
this.extension = extension;
this.filename = filename;
}
public String[] getAllowedExtension()
{
return allowedExtension;
}
public String getExtension()
{
return extension;
}
public String getFilename()
{
return filename;
}
public static class InvalidImageExtensionException extends InvalidExtensionException
{
private static final long serialVersionUID = 1L;
public InvalidImageExtensionException(String[] allowedExtension, String extension, String filename)
{
super(allowedExtension, extension, filename);
}
}
public static class InvalidFlashExtensionException extends InvalidExtensionException
{
private static final long serialVersionUID = 1L;
public InvalidFlashExtensionException(String[] allowedExtension, String extension, String filename)
{
super(allowedExtension, extension, filename);
}
}
public static class InvalidMediaExtensionException extends InvalidExtensionException
{
private static final long serialVersionUID = 1L;
public InvalidMediaExtensionException(String[] allowedExtension, String extension, String filename)
{
super(allowedExtension, extension, filename);
}
}
public static class InvalidVideoExtensionException extends InvalidExtensionException
{
private static final long serialVersionUID = 1L;
public InvalidVideoExtensionException(String[] allowedExtension, String extension, String filename)
{
super(allowedExtension, extension, filename);
}
}
}
package com.partner.admin.common.interceptor;
import cn.hutool.core.date.DateTime;
import cn.hutool.core.date.DateUtil;
import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
import com.partner.admin.common.exception.APIException;
import com.partner.admin.common.exception.APIExceptionEnum;
import com.partner.admin.domain.Token;
import com.partner.admin.service.TokenService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Component;
import org.springframework.web.method.HandlerMethod;
import org.springframework.web.servlet.HandlerInterceptor;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import java.util.Date;
@Component
public class LoginInterceptor implements HandlerInterceptor {
@Autowired
TokenService sysUserTokenService;
@Override
public boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler) throws Exception {
//判断是不是swagger是就放行
// HandlerMethod handlerMethod=(HandlerMethod)handler;
// if("springfox.documentation.swagger.web.ApiResourceController".equals(handlerMethod.getBean().getClass().getName())){
// return true;
// }
String token = request.getHeader("token");// 从 http 请求头中取出 token
if(token == null || "".equals(token) ){
throw new APIException(APIExceptionEnum.USER_TOKEN_EXPIRE);
}
//判断token是否在有效期内
QueryWrapper<Token> sysUserTokenQW = new QueryWrapper<>();
sysUserTokenQW.eq("token",token);
Token sysUserToken = sysUserTokenService.getOne(sysUserTokenQW);
if(sysUserToken == null){
throw new APIException(APIExceptionEnum.USER_TOKEN_EXPIRE);
}
Date expireTime = sysUserToken.getExpireTime();
DateTime expireTimeNew = DateUtil.dateNew(expireTime);
DateTime currentTime = DateUtil.date();
if(!expireTimeNew.isAfter(currentTime)){
throw new APIException(APIExceptionEnum.USER_TOKEN_EXPIRE);
}
return true;
}
}
package com.partner.admin.common.menu;
public enum PartnerProjectStatusEnum {
// 0-暂存 1-信息提报 2-项目查重通过 3-项目查重拒绝 4-招商公司匹配 5-企业对接
// 6-投资意向确认 7-确认项目信息 8-完成审核
PROJECTSTATUS0(0,"暂存"),
PROJECTSTATUS1(1,"信息提报"),
PROJECTSTATUS2(2,"项目查重通过"),
PROJECTSTATUS3(3,"项目查重拒绝"),
PROJECTSTATUS4(4,"招商公司匹配"),
PROJECTSTATUS5(5,"企业对接"),
PROJECTSTATUS6(6,"投资意向确认"),
PROJECTSTATUS7(7,"确认项目信息"),
PROJECTSTATUS8(8,"完成审核"),
// 9-项目信息 10-项目沟通 11-区域匹配 12-政企互访 13-项目谈判 14-项目签约
// 15-分配中 20-作废
PROJECTSTATUS9(9,"项目信息"),
PROJECTSTATUS10(10,"项目沟通"),
PROJECTSTATUS11(11,"区域匹配"),
PROJECTSTATUS12(12,"政企互访"),
PROJECTSTATUS13(13,"项目谈判"),
PROJECTSTATUS14(14,"项目签约"),
PROJECTSTATUS15(15,"分配中"),
PROJECTSTATUS20(20,"作废");
private int code;
private String message;
PartnerProjectStatusEnum(int code,String message)
{
this.code = code;
this.message = message;
}
public int code()
{
return this.code;
}
public String message()
{
return this.message;
}
}
package com.partner.admin.common.page;
import com.partner.admin.common.utils.StringUtils;
/**
* 分页数据
* @author yaobaizheng
*/
public class PageDomain {
/** 当前记录起始索引 */
private Integer pageNum;
/** 每页显示记录数 */
private Integer pageSize;
/** 排序列 */
private String orderByColumn;
/** 排序的方向desc或者asc */
private String isAsc = "asc";
/** 分页参数合理化 */
private Boolean reasonable = true;
public String getOrderBy()
{
if (StringUtils.isEmpty(orderByColumn))
{
return "";
}
return StringUtils.toUnderScoreCase(orderByColumn) + " " + isAsc;
}
public Integer getPageNum()
{
return pageNum;
}
public void setPageNum(Integer pageNum)
{
this.pageNum = pageNum;
}
public Integer getPageSize()
{
return pageSize;
}
public void setPageSize(Integer pageSize)
{
this.pageSize = pageSize;
}
public String getOrderByColumn()
{
return orderByColumn;
}
public void setOrderByColumn(String orderByColumn)
{
this.orderByColumn = orderByColumn;
}
public String getIsAsc()
{
return isAsc;
}
public void setIsAsc(String isAsc)
{
this.isAsc = isAsc;
}
public Boolean getReasonable()
{
if (StringUtils.isNull(reasonable))
{
return Boolean.TRUE;
}
return reasonable;
}
public void setReasonable(Boolean reasonable)
{
this.reasonable = reasonable;
}
}
package com.partner.admin.common.page;
import java.io.Serializable;
import java.util.List;
/**
* 表格分页数据对象
* @author yaobaizheng
*/
public class TableDataInfo implements Serializable
{
private static final long serialVersionUID = 1L;
/** 总记录数 */
private long total;
/** 列表数据 */
private List<?> rows;
/**
* 表格数据对象
*/
public TableDataInfo()
{
}
/**
* 分页
*
* @param list 列表数据
* @param total 总记录数
*/
public TableDataInfo(List<?> list, int total)
{
this.rows = list;
this.total = total;
}
public long getTotal()
{
return total;
}
public void setTotal(long total)
{
this.total = total;
}
public List<?> getRows()
{
return rows;
}
public void setRows(List<?> rows)
{
this.rows = rows;
}
}
\ No newline at end of file
package com.partner.admin.common.page;
import com.partner.admin.common.text.Convert;
import com.partner.admin.common.utils.ServletUtils;
/**
* 表格数据处理
* @author yaobaizheng
*/
public class TableSupport
{
/**
* 当前记录起始索引
*/
public static final String PAGE_NUM = "pageNum";
/**
* 每页显示记录数
*/
public static final String PAGE_SIZE = "pageSize";
/**
* 排序列
*/
public static final String ORDER_BY_COLUMN = "orderByColumn";
/**
* 排序的方向 "desc" 或者 "asc".
*/
public static final String IS_ASC = "isAsc";
/**
* 分页参数合理化
*/
public static final String REASONABLE = "reasonable";
/**
* 封装分页对象
*/
public static PageDomain getPageDomain()
{
PageDomain pageDomain = new PageDomain();
pageDomain.setPageNum(Convert.toInt(ServletUtils.getParameter(PAGE_NUM), 1));
pageDomain.setPageSize(Convert.toInt(ServletUtils.getParameter(PAGE_SIZE), 10));
pageDomain.setOrderByColumn(ServletUtils.getParameter(ORDER_BY_COLUMN));
pageDomain.setIsAsc(ServletUtils.getParameter(IS_ASC));
pageDomain.setReasonable(ServletUtils.getParameterToBool(REASONABLE));
return pageDomain;
}
public static PageDomain buildPageRequest()
{
return getPageDomain();
}
}
package com.partner.admin.common.text;
import com.partner.admin.common.utils.StringUtils;
import java.nio.charset.Charset;
import java.nio.charset.StandardCharsets;
/**
* 字符集工具类
* @author yaobaizheng
*/
public class CharsetKit
{
/** ISO-8859-1 */
public static final String ISO_8859_1 = "ISO-8859-1";
/** UTF-8 */
public static final String UTF_8 = "UTF-8";
/** GBK */
public static final String GBK = "GBK";
/** ISO-8859-1 */
public static final Charset CHARSET_ISO_8859_1 = Charset.forName(ISO_8859_1);
/** UTF-8 */
public static final Charset CHARSET_UTF_8 = Charset.forName(UTF_8);
/** GBK */
public static final Charset CHARSET_GBK = Charset.forName(GBK);
/**
* 转换为Charset对象
*
* @param charset 字符集,为空则返回默认字符集
* @return Charset
*/
public static Charset charset(String charset)
{
return StringUtils.isEmpty(charset) ? Charset.defaultCharset() : Charset.forName(charset);
}
/**
* 转换字符串的字符集编码
*
* @param source 字符串
* @param srcCharset 源字符集,默认ISO-8859-1
* @param destCharset 目标字符集,默认UTF-8
* @return 转换后的字符集
*/
public static String convert(String source, String srcCharset, String destCharset)
{
return convert(source, Charset.forName(srcCharset), Charset.forName(destCharset));
}
/**
* 转换字符串的字符集编码
*
* @param source 字符串
* @param srcCharset 源字符集,默认ISO-8859-1
* @param destCharset 目标字符集,默认UTF-8
* @return 转换后的字符集
*/
public static String convert(String source, Charset srcCharset, Charset destCharset)
{
if (null == srcCharset)
{
srcCharset = StandardCharsets.ISO_8859_1;
}
if (null == destCharset)
{
destCharset = StandardCharsets.UTF_8;
}
if (StringUtils.isEmpty(source) || srcCharset.equals(destCharset))
{
return source;
}
return new String(source.getBytes(srcCharset), destCharset);
}
/**
* @return 系统字符集编码
*/
public static String systemCharset()
{
return Charset.defaultCharset().name();
}
}
package com.partner.admin.common.text;
import com.partner.admin.common.utils.StringUtils;
import org.apache.commons.lang3.ArrayUtils;
import java.math.BigDecimal;
import java.math.BigInteger;
import java.nio.ByteBuffer;
import java.nio.charset.Charset;
import java.text.NumberFormat;
import java.util.Set;
/**
* 类型转换器
* @author yaobaizheng
*/
public class Convert
{
/**
* 转换为字符串<br>
* 如果给定的值为null,或者转换失败,返回默认值<br>
* 转换失败不会报错
*
* @param value 被转换的值
* @param defaultValue 转换错误时的默认值
* @return 结果
*/
public static String toStr(Object value, String defaultValue)
{
if (null == value)
{
return defaultValue;
}
if (value instanceof String)
{
return (String) value;
}
return value.toString();
}
/**
* 转换为字符串<br>
* 如果给定的值为<code>null</code>,或者转换失败,返回默认值<code>null</code><br>
* 转换失败不会报错
*
* @param value 被转换的值
* @return 结果
*/
public static String toStr(Object value)
{
return toStr(value, null);
}
/**
* 转换为字符<br>
* 如果给定的值为null,或者转换失败,返回默认值<br>
* 转换失败不会报错
*
* @param value 被转换的值
* @param defaultValue 转换错误时的默认值
* @return 结果
*/
public static Character toChar(Object value, Character defaultValue)
{
if (null == value)
{
return defaultValue;
}
if (value instanceof Character)
{
return (Character) value;
}
final String valueStr = toStr(value, null);
return StringUtils.isEmpty(valueStr) ? defaultValue : valueStr.charAt(0);
}
/**
* 转换为字符<br>
* 如果给定的值为<code>null</code>,或者转换失败,返回默认值<code>null</code><br>
* 转换失败不会报错
*
* @param value 被转换的值
* @return 结果
*/
public static Character toChar(Object value)
{
return toChar(value, null);
}
/**
* 转换为byte<br>
* 如果给定的值为<code>null</code>,或者转换失败,返回默认值<br>
* 转换失败不会报错
*
* @param value 被转换的值
* @param defaultValue 转换错误时的默认值
* @return 结果
*/
public static Byte toByte(Object value, Byte defaultValue)
{
if (value == null)
{
return defaultValue;
}
if (value instanceof Byte)
{
return (Byte) value;
}
if (value instanceof Number)
{
return ((Number) value).byteValue();
}
final String valueStr = toStr(value, null);
if (StringUtils.isEmpty(valueStr))
{
return defaultValue;
}
try
{
return Byte.parseByte(valueStr);
}
catch (Exception e)
{
return defaultValue;
}
}
/**
* 转换为byte<br>
* 如果给定的值为<code>null</code>,或者转换失败,返回默认值<code>null</code><br>
* 转换失败不会报错
*
* @param value 被转换的值
* @return 结果
*/
public static Byte toByte(Object value)
{
return toByte(value, null);
}
/**
* 转换为Short<br>
* 如果给定的值为<code>null</code>,或者转换失败,返回默认值<br>
* 转换失败不会报错
*
* @param value 被转换的值
* @param defaultValue 转换错误时的默认值
* @return 结果
*/
public static Short toShort(Object value, Short defaultValue)
{
if (value == null)
{
return defaultValue;
}
if (value instanceof Short)
{
return (Short) value;
}
if (value instanceof Number)
{
return ((Number) value).shortValue();
}
final String valueStr = toStr(value, null);
if (StringUtils.isEmpty(valueStr))
{
return defaultValue;
}
try
{
return Short.parseShort(valueStr.trim());
}
catch (Exception e)
{
return defaultValue;
}
}
/**
* 转换为Short<br>
* 如果给定的值为<code>null</code>,或者转换失败,返回默认值<code>null</code><br>
* 转换失败不会报错
*
* @param value 被转换的值
* @return 结果
*/
public static Short toShort(Object value)
{
return toShort(value, null);
}
/**
* 转换为Number<br>
* 如果给定的值为空,或者转换失败,返回默认值<br>
* 转换失败不会报错
*
* @param value 被转换的值
* @param defaultValue 转换错误时的默认值
* @return 结果
*/
public static Number toNumber(Object value, Number defaultValue)
{
if (value == null)
{
return defaultValue;
}
if (value instanceof Number)
{
return (Number) value;
}
final String valueStr = toStr(value, null);
if (StringUtils.isEmpty(valueStr))
{
return defaultValue;
}
try
{
return NumberFormat.getInstance().parse(valueStr);
}
catch (Exception e)
{
return defaultValue;
}
}
/**
* 转换为Number<br>
* 如果给定的值为空,或者转换失败,返回默认值<code>null</code><br>
* 转换失败不会报错
*
* @param value 被转换的值
* @return 结果
*/
public static Number toNumber(Object value)
{
return toNumber(value, null);
}
/**
* 转换为int<br>
* 如果给定的值为空,或者转换失败,返回默认值<br>
* 转换失败不会报错
*
* @param value 被转换的值
* @param defaultValue 转换错误时的默认值
* @return 结果
*/
public static Integer toInt(Object value, Integer defaultValue)
{
if (value == null)
{
return defaultValue;
}
if (value instanceof Integer)
{
return (Integer) value;
}
if (value instanceof Number)
{
return ((Number) value).intValue();
}
final String valueStr = toStr(value, null);
if (StringUtils.isEmpty(valueStr))
{
return defaultValue;
}
try
{
return Integer.parseInt(valueStr.trim());
}
catch (Exception e)
{
return defaultValue;
}
}
/**
* 转换为int<br>
* 如果给定的值为<code>null</code>,或者转换失败,返回默认值<code>null</code><br>
* 转换失败不会报错
*
* @param value 被转换的值
* @return 结果
*/
public static Integer toInt(Object value)
{
return toInt(value, null);
}
/**
* 转换为Integer数组<br>
*
* @param str 被转换的值
* @return 结果
*/
public static Integer[] toIntArray(String str)
{
return toIntArray(",", str);
}
/**
* 转换为Long数组<br>
*
* @param str 被转换的值
* @return 结果
*/
public static Long[] toLongArray(String str)
{
return toLongArray(",", str);
}
/**
* 转换为Integer数组<br>
*
* @param split 分隔符
* @param split 被转换的值
* @return 结果
*/
public static Integer[] toIntArray(String split, String str)
{
if (StringUtils.isEmpty(str))
{
return new Integer[] {};
}
String[] arr = str.split(split);
final Integer[] ints = new Integer[arr.length];
for (int i = 0; i < arr.length; i++)
{
final Integer v = toInt(arr[i], 0);
ints[i] = v;
}
return ints;
}
/**
* 转换为Long数组<br>
*
* @param split 分隔符
* @param str 被转换的值
* @return 结果
*/
public static Long[] toLongArray(String split, String str)
{
if (StringUtils.isEmpty(str))
{
return new Long[] {};
}
String[] arr = str.split(split);
final Long[] longs = new Long[arr.length];
for (int i = 0; i < arr.length; i++)
{
final Long v = toLong(arr[i], null);
longs[i] = v;
}
return longs;
}
/**
* 转换为String数组<br>
*
* @param str 被转换的值
* @return 结果
*/
public static String[] toStrArray(String str)
{
return toStrArray(",", str);
}
/**
* 转换为String数组<br>
*
* @param split 分隔符
* @param split 被转换的值
* @return 结果
*/
public static String[] toStrArray(String split, String str)
{
return str.split(split);
}
/**
* 转换为long<br>
* 如果给定的值为空,或者转换失败,返回默认值<br>
* 转换失败不会报错
*
* @param value 被转换的值
* @param defaultValue 转换错误时的默认值
* @return 结果
*/
public static Long toLong(Object value, Long defaultValue)
{
if (value == null)
{
return defaultValue;
}
if (value instanceof Long)
{
return (Long) value;
}
if (value instanceof Number)
{
return ((Number) value).longValue();
}
final String valueStr = toStr(value, null);
if (StringUtils.isEmpty(valueStr))
{
return defaultValue;
}
try
{
// 支持科学计数法
return new BigDecimal(valueStr.trim()).longValue();
}
catch (Exception e)
{
return defaultValue;
}
}
/**
* 转换为long<br>
* 如果给定的值为<code>null</code>,或者转换失败,返回默认值<code>null</code><br>
* 转换失败不会报错
*
* @param value 被转换的值
* @return 结果
*/
public static Long toLong(Object value)
{
return toLong(value, null);
}
/**
* 转换为double<br>
* 如果给定的值为空,或者转换失败,返回默认值<br>
* 转换失败不会报错
*
* @param value 被转换的值
* @param defaultValue 转换错误时的默认值
* @return 结果
*/
public static Double toDouble(Object value, Double defaultValue)
{
if (value == null)
{
return defaultValue;
}
if (value instanceof Double)
{
return (Double) value;
}
if (value instanceof Number)
{
return ((Number) value).doubleValue();
}
final String valueStr = toStr(value, null);
if (StringUtils.isEmpty(valueStr))
{
return defaultValue;
}
try
{
// 支持科学计数法
return new BigDecimal(valueStr.trim()).doubleValue();
}
catch (Exception e)
{
return defaultValue;
}
}
/**
* 转换为double<br>
* 如果给定的值为空,或者转换失败,返回默认值<code>null</code><br>
* 转换失败不会报错
*
* @param value 被转换的值
* @return 结果
*/
public static Double toDouble(Object value)
{
return toDouble(value, null);
}
/**
* 转换为Float<br>
* 如果给定的值为空,或者转换失败,返回默认值<br>
* 转换失败不会报错
*
* @param value 被转换的值
* @param defaultValue 转换错误时的默认值
* @return 结果
*/
public static Float toFloat(Object value, Float defaultValue)
{
if (value == null)
{
return defaultValue;
}
if (value instanceof Float)
{
return (Float) value;
}
if (value instanceof Number)
{
return ((Number) value).floatValue();
}
final String valueStr = toStr(value, null);
if (StringUtils.isEmpty(valueStr))
{
return defaultValue;
}
try
{
return Float.parseFloat(valueStr.trim());
}
catch (Exception e)
{
return defaultValue;
}
}
/**
* 转换为Float<br>
* 如果给定的值为空,或者转换失败,返回默认值<code>null</code><br>
* 转换失败不会报错
*
* @param value 被转换的值
* @return 结果
*/
public static Float toFloat(Object value)
{
return toFloat(value, null);
}
/**
* 转换为boolean<br>
* String支持的值为:true、false、yes、ok、no,1,0 如果给定的值为空,或者转换失败,返回默认值<br>
* 转换失败不会报错
*
* @param value 被转换的值
* @param defaultValue 转换错误时的默认值
* @return 结果
*/
public static Boolean toBool(Object value, Boolean defaultValue)
{
if (value == null)
{
return defaultValue;
}
if (value instanceof Boolean)
{
return (Boolean) value;
}
String valueStr = toStr(value, null);
if (StringUtils.isEmpty(valueStr))
{
return defaultValue;
}
valueStr = valueStr.trim().toLowerCase();
switch (valueStr)
{
case "true":
case "yes":
case "ok":
case "1":
return true;
case "false":
case "no":
case "0":
return false;
default:
return defaultValue;
}
}
/**
* 转换为boolean<br>
* 如果给定的值为空,或者转换失败,返回默认值<code>null</code><br>
* 转换失败不会报错
*
* @param value 被转换的值
* @return 结果
*/
public static Boolean toBool(Object value)
{
return toBool(value, null);
}
/**
* 转换为Enum对象<br>
* 如果给定的值为空,或者转换失败,返回默认值<br>
*
* @param clazz Enum的Class
* @param value 值
* @param defaultValue 默认值
* @return Enum
*/
public static <E extends Enum<E>> E toEnum(Class<E> clazz, Object value, E defaultValue)
{
if (value == null)
{
return defaultValue;
}
if (clazz.isAssignableFrom(value.getClass()))
{
@SuppressWarnings("unchecked")
E myE = (E) value;
return myE;
}
final String valueStr = toStr(value, null);
if (StringUtils.isEmpty(valueStr))
{
return defaultValue;
}
try
{
return Enum.valueOf(clazz, valueStr);
}
catch (Exception e)
{
return defaultValue;
}
}
/**
* 转换为Enum对象<br>
* 如果给定的值为空,或者转换失败,返回默认值<code>null</code><br>
*
* @param clazz Enum的Class
* @param value 值
* @return Enum
*/
public static <E extends Enum<E>> E toEnum(Class<E> clazz, Object value)
{
return toEnum(clazz, value, null);
}
/**
* 转换为BigInteger<br>
* 如果给定的值为空,或者转换失败,返回默认值<br>
* 转换失败不会报错
*
* @param value 被转换的值
* @param defaultValue 转换错误时的默认值
* @return 结果
*/
public static BigInteger toBigInteger(Object value, BigInteger defaultValue)
{
if (value == null)
{
return defaultValue;
}
if (value instanceof BigInteger)
{
return (BigInteger) value;
}
if (value instanceof Long)
{
return BigInteger.valueOf((Long) value);
}
final String valueStr = toStr(value, null);
if (StringUtils.isEmpty(valueStr))
{
return defaultValue;
}
try
{
return new BigInteger(valueStr);
}
catch (Exception e)
{
return defaultValue;
}
}
/**
* 转换为BigInteger<br>
* 如果给定的值为空,或者转换失败,返回默认值<code>null</code><br>
* 转换失败不会报错
*
* @param value 被转换的值
* @return 结果
*/
public static BigInteger toBigInteger(Object value)
{
return toBigInteger(value, null);
}
/**
* 转换为BigDecimal<br>
* 如果给定的值为空,或者转换失败,返回默认值<br>
* 转换失败不会报错
*
* @param value 被转换的值
* @param defaultValue 转换错误时的默认值
* @return 结果
*/
public static BigDecimal toBigDecimal(Object value, BigDecimal defaultValue)
{
if (value == null)
{
return defaultValue;
}
if (value instanceof BigDecimal)
{
return (BigDecimal) value;
}
if (value instanceof Long)
{
return new BigDecimal((Long) value);
}
if (value instanceof Double)
{
return BigDecimal.valueOf((Double) value);
}
if (value instanceof Integer)
{
return new BigDecimal((Integer) value);
}
final String valueStr = toStr(value, null);
if (StringUtils.isEmpty(valueStr))
{
return defaultValue;
}
try
{
return new BigDecimal(valueStr);
}
catch (Exception e)
{
return defaultValue;
}
}
/**
* 转换为BigDecimal<br>
* 如果给定的值为空,或者转换失败,返回默认值<br>
* 转换失败不会报错
*
* @param value 被转换的值
* @return 结果
*/
public static BigDecimal toBigDecimal(Object value)
{
return toBigDecimal(value, null);
}
/**
* 将对象转为字符串<br>
* 1、Byte数组和ByteBuffer会被转换为对应字符串的数组 2、对象数组会调用Arrays.toString方法
*
* @param obj 对象
* @return 字符串
*/
public static String utf8Str(Object obj)
{
return str(obj, CharsetKit.CHARSET_UTF_8);
}
/**
* 将对象转为字符串<br>
* 1、Byte数组和ByteBuffer会被转换为对应字符串的数组 2、对象数组会调用Arrays.toString方法
*
* @param obj 对象
* @param charsetName 字符集
* @return 字符串
*/
public static String str(Object obj, String charsetName)
{
return str(obj, Charset.forName(charsetName));
}
/**
* 将对象转为字符串<br>
* 1、Byte数组和ByteBuffer会被转换为对应字符串的数组 2、对象数组会调用Arrays.toString方法
*
* @param obj 对象
* @param charset 字符集
* @return 字符串
*/
public static String str(Object obj, Charset charset)
{
if (null == obj)
{
return null;
}
if (obj instanceof String)
{
return (String) obj;
}
else if (obj instanceof byte[])
{
return str((byte[]) obj, charset);
}
else if (obj instanceof Byte[])
{
byte[] bytes = ArrayUtils.toPrimitive((Byte[]) obj);
return str(bytes, charset);
}
else if (obj instanceof ByteBuffer)
{
return str((ByteBuffer) obj, charset);
}
return obj.toString();
}
/**
* 将byte数组转为字符串
*
* @param bytes byte数组
* @param charset 字符集
* @return 字符串
*/
public static String str(byte[] bytes, String charset)
{
return str(bytes, StringUtils.isEmpty(charset) ? Charset.defaultCharset() : Charset.forName(charset));
}
/**
* 解码字节码
*
* @param data 字符串
* @param charset 字符集,如果此字段为空,则解码的结果取决于平台
* @return 解码后的字符串
*/
public static String str(byte[] data, Charset charset)
{
if (data == null)
{
return null;
}
if (null == charset)
{
return new String(data);
}
return new String(data, charset);
}
/**
* 将编码的byteBuffer数据转换为字符串
*
* @param data 数据
* @param charset 字符集,如果为空使用当前系统字符集
* @return 字符串
*/
public static String str(ByteBuffer data, String charset)
{
if (data == null)
{
return null;
}
return str(data, Charset.forName(charset));
}
/**
* 将编码的byteBuffer数据转换为字符串
*
* @param data 数据
* @param charset 字符集,如果为空使用当前系统字符集
* @return 字符串
*/
public static String str(ByteBuffer data, Charset charset)
{
if (null == charset)
{
charset = Charset.defaultCharset();
}
return charset.decode(data).toString();
}
// ----------------------------------------------------------------------- 全角半角转换
/**
* 半角转全角
*
* @param input String.
* @return 全角字符串.
*/
public static String toSBC(String input)
{
return toSBC(input, null);
}
/**
* 半角转全角
*
* @param input String
* @param notConvertSet 不替换的字符集合
* @return 全角字符串.
*/
public static String toSBC(String input, Set<Character> notConvertSet)
{
char c[] = input.toCharArray();
for (int i = 0; i < c.length; i++)
{
if (null != notConvertSet && notConvertSet.contains(c[i]))
{
// 跳过不替换的字符
continue;
}
if (c[i] == ' ')
{
c[i] = '\u3000';
}
else if (c[i] < '\177')
{
c[i] = (char) (c[i] + 65248);
}
}
return new String(c);
}
/**
* 全角转半角
*
* @param input String.
* @return 半角字符串
*/
public static String toDBC(String input)
{
return toDBC(input, null);
}
/**
* 替换全角为半角
*
* @param text 文本
* @param notConvertSet 不替换的字符集合
* @return 替换后的字符
*/
public static String toDBC(String text, Set<Character> notConvertSet)
{
char c[] = text.toCharArray();
for (int i = 0; i < c.length; i++)
{
if (null != notConvertSet && notConvertSet.contains(c[i]))
{
// 跳过不替换的字符
continue;
}
if (c[i] == '\u3000')
{
c[i] = ' ';
}
else if (c[i] > '\uFF00' && c[i] < '\uFF5F')
{
c[i] = (char) (c[i] - 65248);
}
}
String returnString = new String(c);
return returnString;
}
/**
* 数字金额大写转换 先写个完整的然后将如零拾替换成零
*
* @param n 数字
* @return 中文大写数字
*/
public static String digitUppercase(double n)
{
String[] fraction = { "角", "分" };
String[] digit = { "零", "壹", "贰", "叁", "肆", "伍", "陆", "柒", "捌", "玖" };
String[][] unit = { { "元", "万", "亿" }, { "", "拾", "佰", "仟" } };
String head = n < 0 ? "负" : "";
n = Math.abs(n);
String s = "";
for (int i = 0; i < fraction.length; i++)
{
s += (digit[(int) (Math.floor(n * 10 * Math.pow(10, i)) % 10)] + fraction[i]).replaceAll("(零.)+", "");
}
if (s.length() < 1)
{
s = "整";
}
int integerPart = (int) Math.floor(n);
for (int i = 0; i < unit[0].length && integerPart > 0; i++)
{
String p = "";
for (int j = 0; j < unit[1].length && n > 0; j++)
{
p = digit[integerPart % 10] + unit[1][j] + p;
integerPart = integerPart / 10;
}
s = p.replaceAll("(零.)*零$", "").replaceAll("^$", "零") + unit[0][i] + s;
}
return head + s.replaceAll("(零.)*零元", "元").replaceFirst("(零.)+", "").replaceAll("(零.)+", "零").replaceAll("^整$", "零元整");
}
}
package com.partner.admin.common.text;
import com.partner.admin.common.utils.StringUtils;
/**
* 字符串格式化
* @author yaobaizehng
*/
public class StrFormatter {
public static final String EMPTY_JSON = "{}";
public static final char C_BACKSLASH = '\\';
public static final char C_DELIM_START = '{';
public static final char C_DELIM_END = '}';
/**
* 格式化字符串<br>
* 此方法只是简单将占位符 {} 按照顺序替换为参数<br>
* 如果想输出 {} 使用 \\转义 { 即可,如果想输出 {} 之前的 \ 使用双转义符 \\\\ 即可<br>
* 例:<br>
* 通常使用:format("this is {} for {}", "a", "b") -> this is a for b<br>
* 转义{}: format("this is \\{} for {}", "a", "b") -> this is \{} for a<br>
* 转义\: format("this is \\\\{} for {}", "a", "b") -> this is \a for b<br>
*
* @param strPattern 字符串模板
* @param argArray 参数列表
* @return 结果
*/
public static String format(final String strPattern, final Object... argArray)
{
if (StringUtils.isEmpty(strPattern) || StringUtils.isEmpty(argArray))
{
return strPattern;
}
final int strPatternLength = strPattern.length();
// 初始化定义好的长度以获得更好的性能
StringBuilder sbuf = new StringBuilder(strPatternLength + 50);
int handledPosition = 0;
int delimIndex;// 占位符所在位置
for (int argIndex = 0; argIndex < argArray.length; argIndex++)
{
delimIndex = strPattern.indexOf(EMPTY_JSON, handledPosition);
if (delimIndex == -1)
{
if (handledPosition == 0)
{
return strPattern;
}
else
{ // 字符串模板剩余部分不再包含占位符,加入剩余部分后返回结果
sbuf.append(strPattern, handledPosition, strPatternLength);
return sbuf.toString();
}
}
else
{
if (delimIndex > 0 && strPattern.charAt(delimIndex - 1) == C_BACKSLASH)
{
if (delimIndex > 1 && strPattern.charAt(delimIndex - 2) == C_BACKSLASH)
{
// 转义符之前还有一个转义符,占位符依旧有效
sbuf.append(strPattern, handledPosition, delimIndex - 1);
sbuf.append(Convert.utf8Str(argArray[argIndex]));
handledPosition = delimIndex + 2;
}
else
{
// 占位符被转义
argIndex--;
sbuf.append(strPattern, handledPosition, delimIndex - 1);
sbuf.append(C_DELIM_START);
handledPosition = delimIndex + 1;
}
}
else
{
// 正常占位符
sbuf.append(strPattern, handledPosition, delimIndex);
sbuf.append(Convert.utf8Str(argArray[argIndex]));
handledPosition = delimIndex + 2;
}
}
}
// 加入最后一个占位符后所有的字符
sbuf.append(strPattern, handledPosition, strPattern.length());
return sbuf.toString();
}
}
package com.partner.admin.common.utils;
import java.util.HashMap;
import java.util.Objects;
/**
* 操作消息提醒
* @author yaobaizheng
*/
public class AjaxResult extends HashMap<String, Object>
{
private static final long serialVersionUID = 1L;
/** 状态码 */
public static final String CODE_TAG = "code";
/** 返回内容 */
public static final String MSG_TAG = "msg";
/** 数据对象 */
public static final String DATA_TAG = "data";
/**
* 状态类型
*/
public enum Type
{
/** 成功 */
SUCCESS(200,"成功"),
/** 警告 */
WARN(300,"警告"),
USER_TOKEN_EXPIRE(4003, "当前会话失效,请重新登录"),
/** 错误 */
ERROR(500,"错误");
private final int value;
private String message;
Type(int value,String message)
{
this.value = value;
this.message = message;
}
public int value()
{
return this.value;
}
public String message()
{
return this.message;
}
}
/**
* 初始化一个新创建的 AjaxResult 对象,使其表示一个空消息。
*/
public AjaxResult()
{
}
/**
* 初始化一个新创建的 AjaxResult 对象
*
* @param type 状态类型
* @param msg 返回内容
*/
public AjaxResult(Type type, String msg)
{
super.put(CODE_TAG, type.value);
super.put(MSG_TAG, msg);
}
/**
* 初始化一个新创建的 AjaxResult 对象
*
* @param type 状态类型
* @param msg 返回内容
* @param data 数据对象
*/
public AjaxResult(Type type, String msg, Object data)
{
super.put(CODE_TAG, type.value);
super.put(MSG_TAG, msg);
if (StringUtils.isNotNull(data))
{
super.put(DATA_TAG, data);
}
}
/**
* 返回成功消息
*
* @return 成功消息
*/
public static AjaxResult success()
{
return AjaxResult.success("操作成功");
}
/**
* 返回成功数据
*
* @return 成功消息
*/
public static AjaxResult success(Object data)
{
return AjaxResult.success("操作成功", data);
}
/**
* 返回成功消息
*
* @param msg 返回内容
* @return 成功消息
*/
public static AjaxResult success(String msg)
{
return AjaxResult.success(msg, null);
}
/**
* 返回成功消息
*
* @param msg 返回内容
* @param data 数据对象
* @return 成功消息
*/
public static AjaxResult success(String msg, Object data)
{
return new AjaxResult(Type.SUCCESS, msg, data);
}
/**
* 返回警告消息
*
* @param msg 返回内容
* @return 警告消息
*/
public static AjaxResult warn(String msg)
{
return AjaxResult.warn(msg, null);
}
/**
* 返回警告消息
*
* @param msg 返回内容
* @param data 数据对象
* @return 警告消息
*/
public static AjaxResult warn(String msg, Object data)
{
return new AjaxResult(Type.WARN, msg, data);
}
/**
* 返回错误消息
*
* @return
*/
public static AjaxResult error()
{
return AjaxResult.error("操作失败");
}
/**
* 返回错误消息
*
* @param msg 返回内容
* @return 警告消息
*/
public static AjaxResult error(String msg)
{
return AjaxResult.error(msg, null);
}
/**
* 返回错误消息
*
* @param msg 返回内容
* @param data 数据对象
* @return 警告消息
*/
public static AjaxResult error(String msg, Object data)
{
return new AjaxResult(Type.ERROR, msg, data);
}
public static AjaxResult userTokenExpier(String msg)
{
return new AjaxResult(Type.USER_TOKEN_EXPIRE, msg);
}
/**
* 是否为成功消息
*
* @return 结果
*/
public boolean isSuccess()
{
return Objects.equals(Type.SUCCESS.value, this.get(CODE_TAG));
}
/**
* 是否为警告消息
*
* @return 结果
*/
public boolean isWarn()
{
return Objects.equals(Type.WARN.value, this.get(CODE_TAG));
}
/**
* 是否为错误消息
*
* @return 结果
*/
public boolean isError()
{
return Objects.equals(Type.ERROR.value, this.get(CODE_TAG));
}
/**
* 方便链式调用
*
* @param key 键
* @param value 值
* @return 数据对象
*/
@Override
public AjaxResult put(String key, Object value)
{
super.put(key, value);
return this;
}
}
package com.partner.admin.common.utils;
import org.apache.commons.lang3.time.DateFormatUtils;
import java.lang.management.ManagementFactory;
import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.time.*;
import java.util.Date;
/**
* 时间工具类
*
* @author ruoyi
*/
public class DateUtils extends org.apache.commons.lang3.time.DateUtils
{
public static String YYYY = "yyyy";
public static String YYYY_MM = "yyyy-MM";
public static String YYYY_MM_DD = "yyyy-MM-dd";
public static String YYYYMMDDHHMMSS = "yyyyMMddHHmmss";
public static String YYYY_MM_DD_HH_MM_SS = "yyyy-MM-dd HH:mm:ss";
private static String[] parsePatterns = {
"yyyy-MM-dd", "yyyy-MM-dd HH:mm:ss", "yyyy-MM-dd HH:mm", "yyyy-MM",
"yyyy/MM/dd", "yyyy/MM/dd HH:mm:ss", "yyyy/MM/dd HH:mm", "yyyy/MM",
"yyyy.MM.dd", "yyyy.MM.dd HH:mm:ss", "yyyy.MM.dd HH:mm", "yyyy.MM"};
/**
* 获取当前Date型日期
*
* @return Date() 当前日期
*/
public static Date getNowDate()
{
return new Date();
}
/**
* 获取当前日期, 默认格式为yyyy-MM-dd
*
* @return String
*/
public static String getDate()
{
return dateTimeNow(YYYY_MM_DD);
}
public static final String getTime()
{
return dateTimeNow(YYYY_MM_DD_HH_MM_SS);
}
public static final String dateTimeNow()
{
return dateTimeNow(YYYYMMDDHHMMSS);
}
public static final String dateTimeNow(final String format)
{
return parseDateToStr(format, new Date());
}
public static final String dateTime(final Date date)
{
return parseDateToStr(YYYY_MM_DD, date);
}
public static final String parseDateToStr(final String format, final Date date)
{
return new SimpleDateFormat(format).format(date);
}
public static final Date dateTime(final String format, final String ts)
{
try
{
return new SimpleDateFormat(format).parse(ts);
}
catch (ParseException e)
{
throw new RuntimeException(e);
}
}
/**
* 日期路径 即年/月/日 如2018/08/08
*/
public static final String datePath()
{
Date now = new Date();
return DateFormatUtils.format(now, "yyyy/MM/dd");
}
/**
* 日期路径 即年/月/日 如20180808
*/
public static final String dateTime()
{
Date now = new Date();
return DateFormatUtils.format(now, "yyyyMMdd");
}
/**
* 日期型字符串转化为日期 格式
*/
public static Date parseDate(Object str)
{
if (str == null)
{
return null;
}
try
{
return parseDate(str.toString(), parsePatterns);
}
catch (ParseException e)
{
return null;
}
}
/**
* 获取服务器启动时间
*/
public static Date getServerStartDate()
{
long time = ManagementFactory.getRuntimeMXBean().getStartTime();
return new Date(time);
}
/**
* 计算相差天数
*/
public static int differentDaysByMillisecond(Date date1, Date date2)
{
return Math.abs((int) ((date2.getTime() - date1.getTime()) / (1000 * 3600 * 24)));
}
/**
* 计算时间差
*
* @param endDate 最后时间
* @param startTime 开始时间
* @return 时间差(天/小时/分钟)
*/
public static String timeDistance(Date endDate, Date startTime)
{
long nd = 1000 * 24 * 60 * 60;
long nh = 1000 * 60 * 60;
long nm = 1000 * 60;
// long ns = 1000;
// 获得两个时间的毫秒时间差异
long diff = endDate.getTime() - startTime.getTime();
// 计算差多少天
long day = diff / nd;
// 计算差多少小时
long hour = diff % nd / nh;
// 计算差多少分钟
long min = diff % nd % nh / nm;
// 计算差多少秒//输出结果
// long sec = diff % nd % nh % nm / ns;
return day + "天" + hour + "小时" + min + "分钟";
}
/**
* 增加 LocalDateTime ==> Date
*/
public static Date toDate(LocalDateTime temporalAccessor)
{
ZonedDateTime zdt = temporalAccessor.atZone(ZoneId.systemDefault());
return Date.from(zdt.toInstant());
}
/**
* 增加 LocalDate ==> Date
*/
public static Date toDate(LocalDate temporalAccessor)
{
LocalDateTime localDateTime = LocalDateTime.of(temporalAccessor, LocalTime.of(0, 0, 0));
ZonedDateTime zdt = localDateTime.atZone(ZoneId.systemDefault());
return Date.from(zdt.toInstant());
}
}
package com.partner.admin.common.utils;
import com.partner.admin.common.utils.spring.SpringUtils;
import org.springframework.context.MessageSource;
import org.springframework.context.i18n.LocaleContextHolder;
/**
* 获取i18n资源文件
*
* @author ruoyi
*/
public class MessageUtils
{
/**
* 根据消息键和参数 获取消息 委托给spring messageSource
*
* @param code 消息键
* @param args 参数
* @return 获取国际化翻译值
*/
public static String message(String code, Object... args)
{
MessageSource messageSource = SpringUtils.getBean(MessageSource.class);
return messageSource.getMessage(code, args, LocaleContextHolder.getLocale());
}
}
package com.partner.admin.common.utils;
import com.github.pagehelper.PageHelper;
import com.partner.admin.common.page.PageDomain;
import com.partner.admin.common.page.TableSupport;
/**
* 分页工具类
* @author yaobaizheng
*/
public class PageUtils extends PageHelper {
/**
* 设置请求分页数据
*/
public static void startPage(){
PageDomain pageDomain = TableSupport.buildPageRequest();
Integer pageNum = pageDomain.getPageNum();
Integer pageSize = pageDomain.getPageSize();
String orderBy = SqlUtil.escapeOrderBySql(pageDomain.getOrderBy());
Boolean reasonable = pageDomain.getReasonable();
PageHelper.startPage(pageNum, pageSize, orderBy).setReasonable(reasonable);
}
}
package com.partner.admin.common.utils;
import com.partner.admin.common.constant.Constants;
import com.partner.admin.common.text.Convert;
import org.springframework.web.context.request.RequestAttributes;
import org.springframework.web.context.request.RequestContextHolder;
import org.springframework.web.context.request.ServletRequestAttributes;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import javax.servlet.http.HttpSession;
import java.io.IOException;
import java.io.UnsupportedEncodingException;
import java.net.URLDecoder;
import java.net.URLEncoder;
/**
* 客户端工具类
* @author yaobaizheng
*/
public class ServletUtils
{
/**
* 定义移动端请求的所有可能类型
*/
private final static String[] agent = { "Android", "iPhone", "iPod", "iPad", "Windows Phone", "MQQBrowser" };
/**
* 获取String参数
*/
public static String getParameter(String name)
{
return getRequest().getParameter(name);
}
/**
* 获取String参数
*/
public static String getParameter(String name, String defaultValue)
{
return Convert.toStr(getRequest().getParameter(name), defaultValue);
}
/**
* 获取Integer参数
*/
public static Integer getParameterToInt(String name)
{
return Convert.toInt(getRequest().getParameter(name));
}
/**
* 获取Integer参数
*/
public static Integer getParameterToInt(String name, Integer defaultValue)
{
return Convert.toInt(getRequest().getParameter(name), defaultValue);
}
/**
* 获取Boolean参数
*/
public static Boolean getParameterToBool(String name)
{
return Convert.toBool(getRequest().getParameter(name));
}
/**
* 获取Boolean参数
*/
public static Boolean getParameterToBool(String name, Boolean defaultValue)
{
return Convert.toBool(getRequest().getParameter(name), defaultValue);
}
/**
* 获取request
*/
public static HttpServletRequest getRequest()
{
return getRequestAttributes().getRequest();
}
/**
* 获取response
*/
public static HttpServletResponse getResponse()
{
return getRequestAttributes().getResponse();
}
/**
* 获取session
*/
public static HttpSession getSession()
{
return getRequest().getSession();
}
public static ServletRequestAttributes getRequestAttributes()
{
RequestAttributes attributes = RequestContextHolder.getRequestAttributes();
return (ServletRequestAttributes) attributes;
}
/**
* 将字符串渲染到客户端
*
* @param response 渲染对象
* @param string 待渲染的字符串
* @return null
*/
public static String renderString(HttpServletResponse response, String string)
{
try
{
response.setContentType("application/json");
response.setCharacterEncoding("utf-8");
response.getWriter().print(string);
}
catch (IOException e)
{
e.printStackTrace();
}
return null;
}
/**
* 是否是Ajax异步请求
*
* @param request
*/
public static boolean isAjaxRequest(HttpServletRequest request)
{
String accept = request.getHeader("accept");
if (accept != null && accept.contains("application/json"))
{
return true;
}
String xRequestedWith = request.getHeader("X-Requested-With");
if (xRequestedWith != null && xRequestedWith.contains("XMLHttpRequest"))
{
return true;
}
String uri = request.getRequestURI();
if (StringUtils.inStringIgnoreCase(uri, ".json", ".xml"))
{
return true;
}
String ajax = request.getParameter("__ajax");
return StringUtils.inStringIgnoreCase(ajax, "json", "xml");
}
/**
* 判断User-Agent 是不是来自于手机
*/
public static boolean checkAgentIsMobile(String ua)
{
boolean flag = false;
if (!ua.contains("Windows NT") || (ua.contains("Windows NT") && ua.contains("compatible; MSIE 9.0;")))
{
// 排除 苹果桌面系统
if (!ua.contains("Windows NT") && !ua.contains("Macintosh"))
{
for (String item : agent)
{
if (ua.contains(item))
{
flag = true;
break;
}
}
}
}
return flag;
}
/**
* 内容编码
*
* @param str 内容
* @return 编码后的内容
*/
public static String urlEncode(String str)
{
try
{
return URLEncoder.encode(str, Constants.UTF8);
}
catch (UnsupportedEncodingException e)
{
return StringUtils.EMPTY;
}
}
/**
* 内容解码
*
* @param str 内容
* @return 解码后的内容
*/
public static String urlDecode(String str)
{
try
{
return URLDecoder.decode(str, Constants.UTF8);
}
catch (UnsupportedEncodingException e)
{
return StringUtils.EMPTY;
}
}
}
package com.partner.admin.common.utils;
import com.partner.admin.common.exception.UtilException;
/**
* sql操作工具类
* @author yaobaizheng
*/
public class SqlUtil
{
/**
* 定义常用的 sql关键字
*/
public static String SQL_REGEX = "and |extractvalue|updatexml|exec |insert |select |delete |update |drop |count |chr |mid |master |truncate |char |declare |or |+|user()";
/**
* 仅支持字母、数字、下划线、空格、逗号、小数点(支持多个字段排序)
*/
public static String SQL_PATTERN = "[a-zA-Z0-9_\\ \\,\\.]+";
/**
* 限制orderBy最大长度
*/
private static final int ORDER_BY_MAX_LENGTH = 500;
/**
* 检查字符,防止注入绕过
*/
public static String escapeOrderBySql(String value)
{
if (StringUtils.isNotEmpty(value) && !isValidOrderBySql(value))
{
throw new UtilException("参数不符合规范,不能进行查询");
}
if (StringUtils.length(value) > ORDER_BY_MAX_LENGTH)
{
throw new UtilException("参数已超过最大限制,不能进行查询");
}
return value;
}
/**
* 验证 order by 语法是否符合规范
*/
public static boolean isValidOrderBySql(String value)
{
return value.matches(SQL_PATTERN);
}
/**
* SQL关键字检查
*/
public static void filterKeyword(String value)
{
if (StringUtils.isEmpty(value))
{
return;
}
String[] sqlKeywords = StringUtils.split(SQL_REGEX, "\\|");
for (String sqlKeyword : sqlKeywords)
{
if (StringUtils.indexOfIgnoreCase(value, sqlKeyword) > -1)
{
throw new UtilException("参数存在SQL注入风险");
}
}
}
}
package com.partner.admin.common.utils;
import com.partner.admin.common.constant.Constants;
import com.partner.admin.common.text.StrFormatter;
import org.springframework.util.AntPathMatcher;
import java.util.*;
/**
* 字符串工具类
* @author yaobaizheng
*/
public class StringUtils extends org.apache.commons.lang3.StringUtils
{
/** 空字符串 */
private static final String NULLSTR = "";
/** 下划线 */
private static final char SEPARATOR = '_';
/**
* 获取参数不为空值
*
* @param value defaultValue 要判断的value
* @return value 返回值
*/
public static <T> T nvl(T value, T defaultValue)
{
return value != null ? value : defaultValue;
}
/**
* * 判断一个Collection是否为空, 包含List,Set,Queue
*
* @param coll 要判断的Collection
* @return true:为空 false:非空
*/
public static boolean isEmpty(Collection<?> coll)
{
return isNull(coll) || coll.isEmpty();
}
/**
* * 判断一个Collection是否非空,包含List,Set,Queue
*
* @param coll 要判断的Collection
* @return true:非空 false:空
*/
public static boolean isNotEmpty(Collection<?> coll)
{
return !isEmpty(coll);
}
/**
* * 判断一个对象数组是否为空
*
* @param objects 要判断的对象数组
** @return true:为空 false:非空
*/
public static boolean isEmpty(Object[] objects)
{
return isNull(objects) || (objects.length == 0);
}
/**
* * 判断一个对象数组是否非空
*
* @param objects 要判断的对象数组
* @return true:非空 false:空
*/
public static boolean isNotEmpty(Object[] objects)
{
return !isEmpty(objects);
}
/**
* * 判断一个Map是否为空
*
* @param map 要判断的Map
* @return true:为空 false:非空
*/
public static boolean isEmpty(Map<?, ?> map)
{
return isNull(map) || map.isEmpty();
}
/**
* * 判断一个Map是否为空
*
* @param map 要判断的Map
* @return true:非空 false:空
*/
public static boolean isNotEmpty(Map<?, ?> map)
{
return !isEmpty(map);
}
/**
* * 判断一个字符串是否为空串
*
* @param str String
* @return true:为空 false:非空
*/
public static boolean isEmpty(String str)
{
return isNull(str) || NULLSTR.equals(str.trim());
}
/**
* * 判断一个字符串是否为非空串
*
* @param str String
* @return true:非空串 false:空串
*/
public static boolean isNotEmpty(String str)
{
return !isEmpty(str);
}
/**
* * 判断一个对象是否为空
*
* @param object Object
* @return true:为空 false:非空
*/
public static boolean isNull(Object object)
{
return object == null;
}
/**
* * 判断一个对象是否非空
*
* @param object Object
* @return true:非空 false:空
*/
public static boolean isNotNull(Object object)
{
return !isNull(object);
}
/**
* * 判断一个对象是否是数组类型(Java基本型别的数组)
*
* @param object 对象
* @return true:是数组 false:不是数组
*/
public static boolean isArray(Object object)
{
return isNotNull(object) && object.getClass().isArray();
}
/**
* 去空格
*/
public static String trim(String str)
{
return (str == null ? "" : str.trim());
}
/**
* 截取字符串
*
* @param str 字符串
* @param start 开始
* @return 结果
*/
public static String substring(final String str, int start)
{
if (str == null)
{
return NULLSTR;
}
if (start < 0)
{
start = str.length() + start;
}
if (start < 0)
{
start = 0;
}
if (start > str.length())
{
return NULLSTR;
}
return str.substring(start);
}
/**
* 截取字符串
*
* @param str 字符串
* @param start 开始
* @param end 结束
* @return 结果
*/
public static String substring(final String str, int start, int end)
{
if (str == null)
{
return NULLSTR;
}
if (end < 0)
{
end = str.length() + end;
}
if (start < 0)
{
start = str.length() + start;
}
if (end > str.length())
{
end = str.length();
}
if (start > end)
{
return NULLSTR;
}
if (start < 0)
{
start = 0;
}
if (end < 0)
{
end = 0;
}
return str.substring(start, end);
}
/**
* 格式化文本, {} 表示占位符<br>
* 此方法只是简单将占位符 {} 按照顺序替换为参数<br>
* 如果想输出 {} 使用 \\转义 { 即可,如果想输出 {} 之前的 \ 使用双转义符 \\\\ 即可<br>
* 例:<br>
* 通常使用:format("this is {} for {}", "a", "b") -> this is a for b<br>
* 转义{}: format("this is \\{} for {}", "a", "b") -> this is \{} for a<br>
* 转义\: format("this is \\\\{} for {}", "a", "b") -> this is \a for b<br>
*
* @param template 文本模板,被替换的部分用 {} 表示
* @param params 参数值
* @return 格式化后的文本
*/
public static String format(String template, Object... params)
{
if (isEmpty(params) || isEmpty(template))
{
return template;
}
return StrFormatter.format(template, params);
}
/**
* 是否为http(s)://开头
*
* @param link 链接
* @return 结果
*/
public static boolean ishttp(String link)
{
return StringUtils.startsWithAny(link, Constants.HTTP, Constants.HTTPS);
}
/**
* 字符串转set
*
* @param str 字符串
* @param sep 分隔符
* @return set集合
*/
public static final Set<String> str2Set(String str, String sep)
{
return new HashSet<String>(str2List(str, sep, true, false));
}
/**
* 字符串转list
*
* @param str 字符串
* @param sep 分隔符
* @param filterBlank 过滤纯空白
* @param trim 去掉首尾空白
* @return list集合
*/
public static final List<String> str2List(String str, String sep, boolean filterBlank, boolean trim)
{
List<String> list = new ArrayList<String>();
if (StringUtils.isEmpty(str))
{
return list;
}
// 过滤空白字符串
if (filterBlank && StringUtils.isBlank(str))
{
return list;
}
String[] split = str.split(sep);
for (String string : split)
{
if (filterBlank && StringUtils.isBlank(string))
{
continue;
}
if (trim)
{
string = string.trim();
}
list.add(string);
}
return list;
}
/**
* 判断给定的collection列表中是否包含数组array 判断给定的数组array中是否包含给定的元素value
*
* @param collection 给定的集合
* @param array 给定的数组
* @return boolean 结果
*/
public static boolean containsAny(Collection<String> collection, String... array)
{
if (isEmpty(collection) || isEmpty(array))
{
return false;
}
else
{
for (String str : array)
{
if (collection.contains(str))
{
return true;
}
}
return false;
}
}
/**
* 查找指定字符串是否包含指定字符串列表中的任意一个字符串同时串忽略大小写
*
* @param cs 指定字符串
* @param searchCharSequences 需要检查的字符串数组
* @return 是否包含任意一个字符串
*/
public static boolean containsAnyIgnoreCase(CharSequence cs, CharSequence... searchCharSequences)
{
if (isEmpty(cs) || isEmpty(searchCharSequences))
{
return false;
}
for (CharSequence testStr : searchCharSequences)
{
if (containsIgnoreCase(cs, testStr))
{
return true;
}
}
return false;
}
/**
* 驼峰转下划线命名
*/
public static String toUnderScoreCase(String str)
{
if (str == null)
{
return null;
}
StringBuilder sb = new StringBuilder();
// 前置字符是否大写
boolean preCharIsUpperCase = true;
// 当前字符是否大写
boolean curreCharIsUpperCase = true;
// 下一字符是否大写
boolean nexteCharIsUpperCase = true;
for (int i = 0; i < str.length(); i++)
{
char c = str.charAt(i);
if (i > 0)
{
preCharIsUpperCase = Character.isUpperCase(str.charAt(i - 1));
}
else
{
preCharIsUpperCase = false;
}
curreCharIsUpperCase = Character.isUpperCase(c);
if (i < (str.length() - 1))
{
nexteCharIsUpperCase = Character.isUpperCase(str.charAt(i + 1));
}
if (preCharIsUpperCase && curreCharIsUpperCase && !nexteCharIsUpperCase)
{
sb.append(SEPARATOR);
}
else if ((i != 0 && !preCharIsUpperCase) && curreCharIsUpperCase)
{
sb.append(SEPARATOR);
}
sb.append(Character.toLowerCase(c));
}
return sb.toString();
}
/**
* 是否包含字符串
*
* @param str 验证字符串
* @param strs 字符串组
* @return 包含返回true
*/
public static boolean inStringIgnoreCase(String str, String... strs)
{
if (str != null && strs != null)
{
for (String s : strs)
{
if (str.equalsIgnoreCase(trim(s)))
{
return true;
}
}
}
return false;
}
/**
* 删除最后一个字符串
*
* @param str 输入字符串
* @param spit 以什么类型结尾的
* @return 截取后的字符串
*/
public static String lastStringDel(String str, String spit)
{
if (!StringUtils.isEmpty(str) && str.endsWith(spit))
{
return str.subSequence(0, str.length() - 1).toString();
}
return str;
}
/**
* 将下划线大写方式命名的字符串转换为驼峰式。如果转换前的下划线大写方式命名的字符串为空,则返回空字符串。 例如:HELLO_WORLD->HelloWorld
*
* @param name 转换前的下划线大写方式命名的字符串
* @return 转换后的驼峰式命名的字符串
*/
public static String convertToCamelCase(String name)
{
StringBuilder result = new StringBuilder();
// 快速检查
if (name == null || name.isEmpty())
{
// 没必要转换
return "";
}
else if (!name.contains("_"))
{
// 不含下划线,仅将首字母大写
return name.substring(0, 1).toUpperCase() + name.substring(1);
}
// 用下划线将原始字符串分割
String[] camels = name.split("_");
for (String camel : camels)
{
// 跳过原始字符串中开头、结尾的下换线或双重下划线
if (camel.isEmpty())
{
continue;
}
// 首字母大写
result.append(camel.substring(0, 1).toUpperCase());
result.append(camel.substring(1).toLowerCase());
}
return result.toString();
}
/**
* 驼峰式命名法
* 例如:user_name->userName
*/
public static String toCamelCase(String s)
{
if (s == null)
{
return null;
}
if (s.indexOf(SEPARATOR) == -1)
{
return s;
}
s = s.toLowerCase();
StringBuilder sb = new StringBuilder(s.length());
boolean upperCase = false;
for (int i = 0; i < s.length(); i++)
{
char c = s.charAt(i);
if (c == SEPARATOR)
{
upperCase = true;
}
else if (upperCase)
{
sb.append(Character.toUpperCase(c));
upperCase = false;
}
else
{
sb.append(c);
}
}
return sb.toString();
}
/**
* 查找指定字符串是否匹配指定字符串列表中的任意一个字符串
*
* @param str 指定字符串
* @param strs 需要检查的字符串数组
* @return 是否匹配
*/
public static boolean matches(String str, List<String> strs)
{
if (isEmpty(str) || isEmpty(strs))
{
return false;
}
for (String pattern : strs)
{
if (isMatch(pattern, str))
{
return true;
}
}
return false;
}
/**
* 判断url是否与规则配置:
* ? 表示单个字符;
* * 表示一层路径内的任意字符串,不可跨层级;
* ** 表示任意层路径;
*
* @param pattern 匹配规则
* @param url 需要匹配的url
* @return
*/
public static boolean isMatch(String pattern, String url)
{
AntPathMatcher matcher = new AntPathMatcher();
return matcher.match(pattern, url);
}
@SuppressWarnings("unchecked")
public static <T> T cast(Object obj)
{
return (T) obj;
}
/**
* 数字左边补齐0,使之达到指定长度。注意,如果数字转换为字符串后,长度大于size,则只保留 最后size个字符。
*
* @param num 数字对象
* @param size 字符串指定长度
* @return 返回数字的字符串格式,该字符串为指定长度。
*/
public static final String padl(final Number num, final int size)
{
return padl(num.toString(), size, '0');
}
/**
* 字符串左补齐。如果原始字符串s长度大于size,则只保留最后size个字符。
*
* @param s 原始字符串
* @param size 字符串指定长度
* @param c 用于补齐的字符
* @return 返回指定长度的字符串,由原字符串左补齐或截取得到。
*/
public static final String padl(final String s, final int size, final char c)
{
final StringBuilder sb = new StringBuilder(size);
if (s != null)
{
final int len = s.length();
if (s.length() <= size)
{
for (int i = size - len; i > 0; i--)
{
sb.append(c);
}
sb.append(s);
}
else
{
return s.substring(len - size, len);
}
}
else
{
for (int i = size; i > 0; i--)
{
sb.append(c);
}
}
return sb.toString();
}
}
package com.partner.admin.common.utils;
import cn.hutool.http.*;
import cn.hutool.json.JSONObject;
import cn.hutool.json.JSONUtil;
import javax.net.ssl.HttpsURLConnection;
import java.io.BufferedReader;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.io.OutputStream;
import java.net.ConnectException;
import java.net.URL;
import java.util.HashMap;
public class WeixinUtil {
public final static String appId = "wx4f764e291fbbbc1f";//"wx35350b50c51466bf";
public final static String appSecret = "5b89040e2105bf601133962be0532439";//"50f32ffb4d4a98350ceddae254d1e236";
/**
* 获取微信Access Token
* @return
*/
// public static String getAccessToken() {
// String accessToken = "";
//// String ACCESS_TOKEN_URL = "https://api.weixin.qq.com/sns/oauth2/access_token?appid="+appId+"&secret="+appSecret+"&code="+code+"&grant_type=authorization_code";
// String ACCESS_TOKEN_URL = "https://api.weixin.qq.com/cgi-bin/token?grant_type=client_credential&appid=" + appId + "&secret=" + appSecret;
// JSONObject jsonObject = httpRequest(ACCESS_TOKEN_URL, "GET", null);
// // 如果请求成功
// if (jsonObject != null) {
// accessToken = (String) jsonObject.get("access_token");
// }
// return String.valueOf(accessToken);
// }
/**
* 请求微信接口服务,获取小程序全局唯一后台接口调用凭据(access_token)
* https://developers.weixin.qq.com/miniprogram/dev/api-backend/open-api/access-token/auth.getAccessToken.html
*
* @param appid
* @param secretKey
* @return
*/
public static String getAccessToken(String appid, String secretKey) {
String result = null;
String accessToken = null ;
try {
String baseUrl = "https://api.weixin.qq.com/cgi-bin/token";
HashMap<String, Object> requestParam = new HashMap<>();
// 小程序 appId
requestParam.put("grant_type", "client_credential");
// 小程序唯一凭证id appid:(换成自己的)
requestParam.put("appid", appid);
// 小程序 appSecret(小程序的唯一凭证密钥,换成自己的)
requestParam.put("secret", secretKey);
// 发送GET请求读取调用微信接口获取openid用户唯一标识
result = HttpUtil.get(baseUrl, requestParam);
accessToken = JSONUtil.parseObj(result).getStr("access_token");
} catch (Exception e) {
e.printStackTrace();
}
return accessToken;
}
/**
* 请求微信接口服务,用code换取用户手机号(每个code只能使用一次,code的有效期为5min)
* https://developers.weixin.qq.com/miniprogram/dev/api-backend/open-api/phonenumber/phonenumber.getPhoneNumber.html
*
* @param code
* @param accessToken
* @return
*/
public static JSONObject getPhoneNumber(String code, String accessToken) {
String result = null;
try {
// 接口调用凭证:accessToken
String baseUrl = "https://api.weixin.qq.com/wxa/business/getuserphonenumber?access_token=" + accessToken;
HashMap<String, Object> requestParam = new HashMap<>();
// 手机号调用凭证
requestParam.put("code", code);
// 发送post请求读取调用微信接口获取openid用户唯一标识
String jsonStr = JSONUtil.toJsonStr(requestParam);
HttpResponse response = HttpRequest.post(baseUrl)
.header(Header.CONTENT_ENCODING, "UTF-8")
// 发送json数据需要设置contentType
.header(Header.CONTENT_TYPE, "application/x-www-form-urlencoded")
.body(jsonStr)
.execute();
if (response.getStatus() == HttpStatus.HTTP_OK) {
result = response.body();
}
} catch (Exception e) {
e.printStackTrace();
}
return JSONUtil.parseObj(result);
}
/**
* 请求微信接口服务,获取用户信息
* https://developers.weixin.qq.com/miniprogram/dev/api-backend/open-api/phonenumber/phonenumber.getPhoneNumber.html
*
* @param accessToken
* @param openid
* @param signature
* @param sig_method
* @return
*/
public static JSONObject getUserInfo(String accessToken,String openid,String signature,String sig_method) {
String result = null;
try {
// 接口调用凭证:accessToken
String baseUrl = "https://api.weixin.qq.com/wxa/business/getuserencryptkey?access_token=" + accessToken;
HashMap<String, Object> requestParam = new HashMap<>();
// 手机号调用凭证
requestParam.put("openid", openid);
requestParam.put("signature", signature);
requestParam.put("sig_method", sig_method);
// 发送post请求读取调用微信接口获取openid用户唯一标识
String jsonStr = JSONUtil.toJsonStr(requestParam);
HttpResponse response = HttpRequest.post(baseUrl)
.header(Header.CONTENT_ENCODING, "UTF-8")
// 发送json数据需要设置contentType
.header(Header.CONTENT_TYPE, "application/x-www-form-urlencoded")
.body(jsonStr)
.execute();
if (response.getStatus() == HttpStatus.HTTP_OK) {
result = response.body();
}
} catch (Exception e) {
e.printStackTrace();
}
return JSONUtil.parseObj(result);
}
/**
* 请求微信接口服务,获取用户信息
* https://developers.weixin.qq.com/miniprogram/dev/api-backend/open-api/phonenumber/phonenumber.getPhoneNumber.html
*
* @param accessToken
* @param code
* @return
*/
public static JSONObject getLogin(String accessToken,String code) {
String result = null;
try {
// 接口调用凭证:accessToken
String baseUrl = "https://api.weixin.qq.com/wxa/getpluginopenpid?access_token=" + accessToken;
HashMap<String, Object> requestParam = new HashMap<>();
// 手机号调用凭证
requestParam.put("code", code);
// 发送post请求读取调用微信接口获取openid用户唯一标识
String jsonStr = JSONUtil.toJsonStr(requestParam);
HttpResponse response = HttpRequest.post(baseUrl)
.header(Header.CONTENT_ENCODING, "UTF-8")
// 发送json数据需要设置contentType
.header(Header.CONTENT_TYPE, "application/x-www-form-urlencoded")
.body(jsonStr)
.execute();
if (response.getStatus() == HttpStatus.HTTP_OK) {
result = response.body();
}
} catch (Exception e) {
e.printStackTrace();
}
return JSONUtil.parseObj(result);
}
public static JSONObject httpRequest(String requestUrl, String requestMethod, String outputStr) {
JSONObject jsonObject = null;
StringBuffer buffer = new StringBuffer();
try {
URL url = new URL(requestUrl);
HttpsURLConnection httpUrlConn = (HttpsURLConnection) url.openConnection();
httpUrlConn.setDoOutput(true);
httpUrlConn.setDoInput(true);
httpUrlConn.setUseCaches(false);
// 设置请求方式(GET/POST)
httpUrlConn.setRequestMethod(requestMethod);
if ("GET".equalsIgnoreCase(requestMethod)) {
httpUrlConn.connect();
}
// 当有数据需要提交时
if (null != outputStr) {
OutputStream outputStream = httpUrlConn.getOutputStream();
// 注意编码格式,防止中文乱码
outputStream.write(outputStr.getBytes("UTF-8"));
outputStream.close();
}
InputStream inputStream = httpUrlConn.getInputStream();
InputStreamReader inputStreamReader = new InputStreamReader(inputStream, "utf-8");
BufferedReader streamReader = new BufferedReader(inputStreamReader);
StringBuilder responseStrBuilder = new StringBuilder();
String inputStr;
while ((inputStr = streamReader.readLine()) != null) responseStrBuilder.append(inputStr);
jsonObject = new JSONObject(responseStrBuilder.toString());
inputStreamReader.close();
// 释放资源
inputStream.close();
inputStream = null;
httpUrlConn.disconnect();
} catch (ConnectException ce) {
//log.error("Weixin server connection timed out.");
} catch (Exception e) {
//log.error("https request error:{}", e);
}
return jsonObject;
}
}
package com.partner.admin.common.utils.hwobs;
import org.apache.tomcat.util.codec.binary.Base64;
public final class Base64Utils {
public Base64Utils() {
}
public static byte[] decode(String base64) throws Exception {
return Base64.decodeBase64(base64);
}
public static String encode(byte[] bytes) throws Exception {
return new String(Base64.encodeBase64(bytes));
}
}
package com.partner.admin.common.utils.hwobs;
import com.obs.services.ObsClient;
import com.obs.services.model.ObsObject;
import org.apache.commons.io.IOUtils;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.stereotype.Component;
import javax.servlet.http.HttpServletResponse;
import java.io.*;
@Component
public class ObsUtils {
@Value("${huaweiObs.endPoint}")
private String endPoint;
@Value("${huaweiObs.ak}")
private String ak;
@Value("${huaweiObs.sk}")
private String sk;
@Value("${huaweiObs.bucketName}")
private String bucketName;
//文件上传
public void ObsUpload(String bucketName, String key, InputStream inputStream) throws IOException {
// 创建ObsClient实例
ObsClient obsClient = new ObsClient(ak, sk, endPoint);
obsClient.putObject(bucketName, key, inputStream);
obsClient.close();
}
//文件下载
public void downloadFile(HttpServletResponse response, String fileName) {
ObsClient obsClient = new ObsClient(ak, sk, endPoint);
ObsObject obsObject = obsClient.getObject(bucketName, fileName);
InputStream content = obsObject.getObjectContent();
response.setHeader("content-type", "application/octet-stream");
response.setContentType("application/octet-stream");
try {
response.setHeader("Content-Disposition", "attachment;filename=" + java.net.URLEncoder.encode(fileName, "UTF-8"));
} catch (Exception e) {
e.printStackTrace();
}
byte[] items = new byte[1024 * 10];
int i = 0;
try {
BufferedInputStream bufferedInputStream = new BufferedInputStream(content);
OutputStream outputStream = response.getOutputStream();
BufferedOutputStream outputStream1 = new BufferedOutputStream(outputStream);
while ((i = bufferedInputStream.read(items)) != -1) {
outputStream1.write(items, 0, i);
outputStream1.flush();
}
outputStream1.close();
outputStream.close();
bufferedInputStream.close();
content.close();
} catch (Exception e1) {
e1.printStackTrace();
}
}
/**
* @Description: 删除对象
*/
public void deleteFile(String bucketName, String fileName) {
ObsClient obsClient = new ObsClient(ak, sk, endPoint);
obsClient.deleteObject(bucketName, fileName);
}
/**
* @Description: 文件转base64
*/
public String fileToBase64(String fileName){
ObsClient obsClient = new ObsClient(ak, sk, endPoint);
ObsObject obsObject = obsClient.getObject(bucketName, fileName);
InputStream content = obsObject.getObjectContent();
try {
byte[] bytes = IOUtils.toByteArray(content);
content.close();
return Base64Utils.encode(bytes);
} catch (Exception e) {
e.printStackTrace();
}
return null;
}
}
package com.partner.admin.common.utils.spring;
import com.partner.admin.common.utils.StringUtils;
import org.springframework.aop.framework.AopContext;
import org.springframework.beans.BeansException;
import org.springframework.beans.factory.NoSuchBeanDefinitionException;
import org.springframework.beans.factory.config.BeanFactoryPostProcessor;
import org.springframework.beans.factory.config.ConfigurableListableBeanFactory;
import org.springframework.context.ApplicationContext;
import org.springframework.context.ApplicationContextAware;
import org.springframework.stereotype.Component;
/**
* spring工具类 方便在非spring管理环境中获取bean
*
* @author ruoyi
*/
@Component
public final class SpringUtils implements BeanFactoryPostProcessor, ApplicationContextAware
{
/** Spring应用上下文环境 */
private static ConfigurableListableBeanFactory beanFactory;
private static ApplicationContext applicationContext;
@Override
public void postProcessBeanFactory(ConfigurableListableBeanFactory beanFactory) throws BeansException
{
SpringUtils.beanFactory = beanFactory;
}
@Override
public void setApplicationContext(ApplicationContext applicationContext) throws BeansException
{
SpringUtils.applicationContext = applicationContext;
}
/**
* 获取对象
*
* @param name
* @return Object 一个以所给名字注册的bean的实例
* @throws BeansException
*
*/
@SuppressWarnings("unchecked")
public static <T> T getBean(String name) throws BeansException
{
return (T) beanFactory.getBean(name);
}
/**
* 获取类型为requiredType的对象
*
* @param clz
* @return
* @throws BeansException
*
*/
public static <T> T getBean(Class<T> clz) throws BeansException
{
T result = (T) beanFactory.getBean(clz);
return result;
}
/**
* 如果BeanFactory包含一个与所给名称匹配的bean定义,则返回true
*
* @param name
* @return boolean
*/
public static boolean containsBean(String name)
{
return beanFactory.containsBean(name);
}
/**
* 判断以给定名字注册的bean定义是一个singleton还是一个prototype。 如果与给定名字相应的bean定义没有被找到,将会抛出一个异常(NoSuchBeanDefinitionException)
*
* @param name
* @return boolean
* @throws NoSuchBeanDefinitionException
*
*/
public static boolean isSingleton(String name) throws NoSuchBeanDefinitionException
{
return beanFactory.isSingleton(name);
}
/**
* @param name
* @return Class 注册对象的类型
* @throws NoSuchBeanDefinitionException
*
*/
public static Class<?> getType(String name) throws NoSuchBeanDefinitionException
{
return beanFactory.getType(name);
}
/**
* 如果给定的bean名字在bean定义中有别名,则返回这些别名
*
* @param name
* @return
* @throws NoSuchBeanDefinitionException
*
*/
public static String[] getAliases(String name) throws NoSuchBeanDefinitionException
{
return beanFactory.getAliases(name);
}
/**
* 获取aop代理对象
*
* @param invoker
* @return
*/
@SuppressWarnings("unchecked")
public static <T> T getAopProxy(T invoker)
{
return (T) AopContext.currentProxy();
}
/**
* 获取当前的环境配置,无配置返回null
*
* @return 当前的环境配置
*/
public static String[] getActiveProfiles()
{
return applicationContext.getEnvironment().getActiveProfiles();
}
/**
* 获取当前的环境配置,当有多个环境配置时,只获取第一个
*
* @return 当前的环境配置
*/
public static String getActiveProfile()
{
final String[] activeProfiles = getActiveProfiles();
return StringUtils.isNotEmpty(activeProfiles) ? activeProfiles[0] : null;
}
/**
* 获取配置文件中的值
*
* @param key 配置文件的key
* @return 当前的配置文件的值
*
*/
public static String getRequiredProperty(String key)
{
return applicationContext.getEnvironment().getRequiredProperty(key);
}
}
package com.partner.admin.common.utils.uuid;
/**
* ID生成器工具类
*
* @author ruoyi
*/
public class IdUtils
{
/**
* 获取随机UUID
*
* @return 随机UUID
*/
public static String randomUUID()
{
return UUID.randomUUID().toString();
}
/**
* 简化的UUID,去掉了横线
*
* @return 简化的UUID,去掉了横线
*/
public static String simpleUUID()
{
return UUID.randomUUID().toString(true);
}
/**
* 获取随机UUID,使用性能更好的ThreadLocalRandom生成UUID
*
* @return 随机UUID
*/
public static String fastUUID()
{
return UUID.fastUUID().toString();
}
/**
* 简化的UUID,去掉了横线,使用性能更好的ThreadLocalRandom生成UUID
*
* @return 简化的UUID,去掉了横线
*/
public static String fastSimpleUUID()
{
return UUID.fastUUID().toString(true);
}
}
package com.partner.admin.common.utils.uuid;
import com.partner.admin.common.utils.DateUtils;
import com.partner.admin.common.utils.StringUtils;
import java.util.concurrent.atomic.AtomicInteger;
/**
* @author ruoyi 序列生成类
*/
public class Seq
{
// 通用序列类型
public static final String commSeqType = "COMMON";
// 上传序列类型
public static final String uploadSeqType = "UPLOAD";
// 通用接口序列数
private static AtomicInteger commSeq = new AtomicInteger(1);
// 上传接口序列数
private static AtomicInteger uploadSeq = new AtomicInteger(1);
// 机器标识
private static final String machineCode = "A";
/**
* 获取通用序列号
*
* @return 序列值
*/
public static String getId()
{
return getId(commSeqType);
}
/**
* 默认16位序列号 yyMMddHHmmss + 一位机器标识 + 3长度循环递增字符串
*
* @return 序列值
*/
public static String getId(String type)
{
AtomicInteger atomicInt = commSeq;
if (uploadSeqType.equals(type))
{
atomicInt = uploadSeq;
}
return getId(atomicInt, 3);
}
/**
* 通用接口序列号 yyMMddHHmmss + 一位机器标识 + length长度循环递增字符串
*
* @param atomicInt 序列数
* @param length 数值长度
* @return 序列值
*/
public static String getId(AtomicInteger atomicInt, int length)
{
String result = DateUtils.dateTimeNow();
result += machineCode;
result += getSeq(atomicInt, length);
return result;
}
/**
* 序列循环递增字符串[1, 10 的 (length)幂次方), 用0左补齐length位数
*
* @return 序列值
*/
private synchronized static String getSeq(AtomicInteger atomicInt, int length)
{
// 先取值再+1
int value = atomicInt.getAndIncrement();
// 如果更新后值>=10 的 (length)幂次方则重置为1
int maxSeq = (int) Math.pow(10, length);
if (atomicInt.get() >= maxSeq)
{
atomicInt.set(1);
}
// 转字符串,用0左补齐
return StringUtils.padl(value, length);
}
}
package com.partner.admin.common.utils.uuid;
import com.partner.admin.common.exception.UtilException;
import java.security.MessageDigest;
import java.security.NoSuchAlgorithmException;
import java.security.SecureRandom;
import java.util.Random;
import java.util.concurrent.ThreadLocalRandom;
/**
* 提供通用唯一识别码(universally unique identifier)(UUID)实现
*
* @author ruoyi
*/
public final class UUID implements java.io.Serializable, Comparable<UUID>
{
private static final long serialVersionUID = -1185015143654744140L;
/**
* SecureRandom 的单例
*
*/
private static class Holder
{
static final SecureRandom numberGenerator = getSecureRandom();
}
/** 此UUID的最高64有效位 */
private final long mostSigBits;
/** 此UUID的最低64有效位 */
private final long leastSigBits;
/**
* 私有构造
*
* @param data 数据
*/
private UUID(byte[] data)
{
long msb = 0;
long lsb = 0;
assert data.length == 16 : "data must be 16 bytes in length";
for (int i = 0; i < 8; i++)
{
msb = (msb << 8) | (data[i] & 0xff);
}
for (int i = 8; i < 16; i++)
{
lsb = (lsb << 8) | (data[i] & 0xff);
}
this.mostSigBits = msb;
this.leastSigBits = lsb;
}
/**
* 使用指定的数据构造新的 UUID。
*
* @param mostSigBits 用于 {@code UUID} 的最高有效 64 位
* @param leastSigBits 用于 {@code UUID} 的最低有效 64 位
*/
public UUID(long mostSigBits, long leastSigBits)
{
this.mostSigBits = mostSigBits;
this.leastSigBits = leastSigBits;
}
/**
* 获取类型 4(伪随机生成的)UUID 的静态工厂。
*
* @return 随机生成的 {@code UUID}
*/
public static UUID fastUUID()
{
return randomUUID(false);
}
/**
* 获取类型 4(伪随机生成的)UUID 的静态工厂。 使用加密的强伪随机数生成器生成该 UUID。
*
* @return 随机生成的 {@code UUID}
*/
public static UUID randomUUID()
{
return randomUUID(true);
}
/**
* 获取类型 4(伪随机生成的)UUID 的静态工厂。 使用加密的强伪随机数生成器生成该 UUID。
*
* @param isSecure 是否使用{@link SecureRandom}如果是可以获得更安全的随机码,否则可以得到更好的性能
* @return 随机生成的 {@code UUID}
*/
public static UUID randomUUID(boolean isSecure)
{
final Random ng = isSecure ? Holder.numberGenerator : getRandom();
byte[] randomBytes = new byte[16];
ng.nextBytes(randomBytes);
randomBytes[6] &= 0x0f; /* clear version */
randomBytes[6] |= 0x40; /* set to version 4 */
randomBytes[8] &= 0x3f; /* clear variant */
randomBytes[8] |= 0x80; /* set to IETF variant */
return new UUID(randomBytes);
}
/**
* 根据指定的字节数组获取类型 3(基于名称的)UUID 的静态工厂。
*
* @param name 用于构造 UUID 的字节数组。
*
* @return 根据指定数组生成的 {@code UUID}
*/
public static UUID nameUUIDFromBytes(byte[] name)
{
MessageDigest md;
try
{
md = MessageDigest.getInstance("MD5");
}
catch (NoSuchAlgorithmException nsae)
{
throw new InternalError("MD5 not supported");
}
byte[] md5Bytes = md.digest(name);
md5Bytes[6] &= 0x0f; /* clear version */
md5Bytes[6] |= 0x30; /* set to version 3 */
md5Bytes[8] &= 0x3f; /* clear variant */
md5Bytes[8] |= 0x80; /* set to IETF variant */
return new UUID(md5Bytes);
}
/**
* 根据 {@link #toString()} 方法中描述的字符串标准表示形式创建{@code UUID}。
*
* @param name 指定 {@code UUID} 字符串
* @return 具有指定值的 {@code UUID}
* @throws IllegalArgumentException 如果 name 与 {@link #toString} 中描述的字符串表示形式不符抛出此异常
*
*/
public static UUID fromString(String name)
{
String[] components = name.split("-");
if (components.length != 5)
{
throw new IllegalArgumentException("Invalid UUID string: " + name);
}
for (int i = 0; i < 5; i++)
{
components[i] = "0x" + components[i];
}
long mostSigBits = Long.decode(components[0]).longValue();
mostSigBits <<= 16;
mostSigBits |= Long.decode(components[1]).longValue();
mostSigBits <<= 16;
mostSigBits |= Long.decode(components[2]).longValue();
long leastSigBits = Long.decode(components[3]).longValue();
leastSigBits <<= 48;
leastSigBits |= Long.decode(components[4]).longValue();
return new UUID(mostSigBits, leastSigBits);
}
/**
* 返回此 UUID 的 128 位值中的最低有效 64 位。
*
* @return 此 UUID 的 128 位值中的最低有效 64 位。
*/
public long getLeastSignificantBits()
{
return leastSigBits;
}
/**
* 返回此 UUID 的 128 位值中的最高有效 64 位。
*
* @return 此 UUID 的 128 位值中最高有效 64 位。
*/
public long getMostSignificantBits()
{
return mostSigBits;
}
/**
* 与此 {@code UUID} 相关联的版本号. 版本号描述此 {@code UUID} 是如何生成的。
* <p>
* 版本号具有以下含意:
* <ul>
* <li>1 基于时间的 UUID
* <li>2 DCE 安全 UUID
* <li>3 基于名称的 UUID
* <li>4 随机生成的 UUID
* </ul>
*
* @return 此 {@code UUID} 的版本号
*/
public int version()
{
// Version is bits masked by 0x000000000000F000 in MS long
return (int) ((mostSigBits >> 12) & 0x0f);
}
/**
* 与此 {@code UUID} 相关联的变体号。变体号描述 {@code UUID} 的布局。
* <p>
* 变体号具有以下含意:
* <ul>
* <li>0 为 NCS 向后兼容保留
* <li>2 <a href="http://www.ietf.org/rfc/rfc4122.txt">IETF&nbsp;RFC&nbsp;4122</a>(Leach-Salz), 用于此类
* <li>6 保留,微软向后兼容
* <li>7 保留供以后定义使用
* </ul>
*
* @return 此 {@code UUID} 相关联的变体号
*/
public int variant()
{
// This field is composed of a varying number of bits.
// 0 - - Reserved for NCS backward compatibility
// 1 0 - The IETF aka Leach-Salz variant (used by this class)
// 1 1 0 Reserved, Microsoft backward compatibility
// 1 1 1 Reserved for future definition.
return (int) ((leastSigBits >>> (64 - (leastSigBits >>> 62))) & (leastSigBits >> 63));
}
/**
* 与此 UUID 相关联的时间戳值。
*
* <p>
* 60 位的时间戳值根据此 {@code UUID} 的 time_low、time_mid 和 time_hi 字段构造。<br>
* 所得到的时间戳以 100 毫微秒为单位,从 UTC(通用协调时间) 1582 年 10 月 15 日零时开始。
*
* <p>
* 时间戳值仅在在基于时间的 UUID(其 version 类型为 1)中才有意义。<br>
* 如果此 {@code UUID} 不是基于时间的 UUID,则此方法抛出 UnsupportedOperationException。
*
* @throws UnsupportedOperationException 如果此 {@code UUID} 不是 version 为 1 的 UUID。
*/
public long timestamp() throws UnsupportedOperationException
{
checkTimeBase();
return (mostSigBits & 0x0FFFL) << 48//
| ((mostSigBits >> 16) & 0x0FFFFL) << 32//
| mostSigBits >>> 32;
}
/**
* 与此 UUID 相关联的时钟序列值。
*
* <p>
* 14 位的时钟序列值根据此 UUID 的 clock_seq 字段构造。clock_seq 字段用于保证在基于时间的 UUID 中的时间唯一性。
* <p>
* {@code clockSequence} 值仅在基于时间的 UUID(其 version 类型为 1)中才有意义。 如果此 UUID 不是基于时间的 UUID,则此方法抛出
* UnsupportedOperationException。
*
* @return 此 {@code UUID} 的时钟序列
*
* @throws UnsupportedOperationException 如果此 UUID 的 version 不为 1
*/
public int clockSequence() throws UnsupportedOperationException
{
checkTimeBase();
return (int) ((leastSigBits & 0x3FFF000000000000L) >>> 48);
}
/**
* 与此 UUID 相关的节点值。
*
* <p>
* 48 位的节点值根据此 UUID 的 node 字段构造。此字段旨在用于保存机器的 IEEE 802 地址,该地址用于生成此 UUID 以保证空间唯一性。
* <p>
* 节点值仅在基于时间的 UUID(其 version 类型为 1)中才有意义。<br>
* 如果此 UUID 不是基于时间的 UUID,则此方法抛出 UnsupportedOperationException。
*
* @return 此 {@code UUID} 的节点值
*
* @throws UnsupportedOperationException 如果此 UUID 的 version 不为 1
*/
public long node() throws UnsupportedOperationException
{
checkTimeBase();
return leastSigBits & 0x0000FFFFFFFFFFFFL;
}
/**
* 返回此{@code UUID} 的字符串表现形式。
*
* <p>
* UUID 的字符串表示形式由此 BNF 描述:
*
* <pre>
* {@code
* UUID = <time_low>-<time_mid>-<time_high_and_version>-<variant_and_sequence>-<node>
* time_low = 4*<hexOctet>
* time_mid = 2*<hexOctet>
* time_high_and_version = 2*<hexOctet>
* variant_and_sequence = 2*<hexOctet>
* node = 6*<hexOctet>
* hexOctet = <hexDigit><hexDigit>
* hexDigit = [0-9a-fA-F]
* }
* </pre>
*
* </blockquote>
*
* @return 此{@code UUID} 的字符串表现形式
* @see #toString(boolean)
*/
@Override
public String toString()
{
return toString(false);
}
/**
* 返回此{@code UUID} 的字符串表现形式。
*
* <p>
* UUID 的字符串表示形式由此 BNF 描述:
*
* <pre>
* {@code
* UUID = <time_low>-<time_mid>-<time_high_and_version>-<variant_and_sequence>-<node>
* time_low = 4*<hexOctet>
* time_mid = 2*<hexOctet>
* time_high_and_version = 2*<hexOctet>
* variant_and_sequence = 2*<hexOctet>
* node = 6*<hexOctet>
* hexOctet = <hexDigit><hexDigit>
* hexDigit = [0-9a-fA-F]
* }
* </pre>
*
* </blockquote>
*
* @param isSimple 是否简单模式,简单模式为不带'-'的UUID字符串
* @return 此{@code UUID} 的字符串表现形式
*/
public String toString(boolean isSimple)
{
final StringBuilder builder = new StringBuilder(isSimple ? 32 : 36);
// time_low
builder.append(digits(mostSigBits >> 32, 8));
if (false == isSimple)
{
builder.append('-');
}
// time_mid
builder.append(digits(mostSigBits >> 16, 4));
if (false == isSimple)
{
builder.append('-');
}
// time_high_and_version
builder.append(digits(mostSigBits, 4));
if (false == isSimple)
{
builder.append('-');
}
// variant_and_sequence
builder.append(digits(leastSigBits >> 48, 4));
if (false == isSimple)
{
builder.append('-');
}
// node
builder.append(digits(leastSigBits, 12));
return builder.toString();
}
/**
* 返回此 UUID 的哈希码。
*
* @return UUID 的哈希码值。
*/
@Override
public int hashCode()
{
long hilo = mostSigBits ^ leastSigBits;
return ((int) (hilo >> 32)) ^ (int) hilo;
}
/**
* 将此对象与指定对象比较。
* <p>
* 当且仅当参数不为 {@code null}、而是一个 UUID 对象、具有与此 UUID 相同的 varriant、包含相同的值(每一位均相同)时,结果才为 {@code true}。
*
* @param obj 要与之比较的对象
*
* @return 如果对象相同,则返回 {@code true};否则返回 {@code false}
*/
@Override
public boolean equals(Object obj)
{
if ((null == obj) || (obj.getClass() != UUID.class))
{
return false;
}
UUID id = (UUID) obj;
return (mostSigBits == id.mostSigBits && leastSigBits == id.leastSigBits);
}
// Comparison Operations
/**
* 将此 UUID 与指定的 UUID 比较。
*
* <p>
* 如果两个 UUID 不同,且第一个 UUID 的最高有效字段大于第二个 UUID 的对应字段,则第一个 UUID 大于第二个 UUID。
*
* @param val 与此 UUID 比较的 UUID
*
* @return 在此 UUID 小于、等于或大于 val 时,分别返回 -1、0 或 1。
*
*/
@Override
public int compareTo(UUID val)
{
// The ordering is intentionally set up so that the UUIDs
// can simply be numerically compared as two numbers
return (this.mostSigBits < val.mostSigBits ? -1 : //
(this.mostSigBits > val.mostSigBits ? 1 : //
(this.leastSigBits < val.leastSigBits ? -1 : //
(this.leastSigBits > val.leastSigBits ? 1 : //
0))));
}
// -------------------------------------------------------------------------------------------------------------------
// Private method start
/**
* 返回指定数字对应的hex值
*
* @param val 值
* @param digits 位
* @return 值
*/
private static String digits(long val, int digits)
{
long hi = 1L << (digits * 4);
return Long.toHexString(hi | (val & (hi - 1))).substring(1);
}
/**
* 检查是否为time-based版本UUID
*/
private void checkTimeBase()
{
if (version() != 1)
{
throw new UnsupportedOperationException("Not a time-based UUID");
}
}
/**
* 获取{@link SecureRandom},类提供加密的强随机数生成器 (RNG)
*
* @return {@link SecureRandom}
*/
public static SecureRandom getSecureRandom()
{
try
{
return SecureRandom.getInstance("SHA1PRNG");
}
catch (NoSuchAlgorithmException e)
{
throw new UtilException(e);
}
}
/**
* 获取随机数生成器对象<br>
* ThreadLocalRandom是JDK 7之后提供并发产生随机数,能够解决多个线程发生的竞争争夺。
*
* @return {@link ThreadLocalRandom}
*/
public static ThreadLocalRandom getRandom()
{
return ThreadLocalRandom.current();
}
}
package com.partner.admin.controller;
import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
import com.github.pagehelper.PageInfo;
import com.partner.admin.VO.SysUserVO;
import com.partner.admin.common.exception.APIException;
import com.partner.admin.common.exception.APIExceptionEnum;
import com.partner.admin.common.page.TableDataInfo;
import com.partner.admin.common.utils.PageUtils;
import com.partner.admin.common.utils.ServletUtils;
import com.partner.admin.domain.SysUser;
import com.partner.admin.domain.Token;
import com.partner.admin.service.SysUserService;
import com.partner.admin.service.TokenService;
import org.apache.commons.lang3.ObjectUtils;
import org.springframework.beans.factory.annotation.Autowired;
import java.text.SimpleDateFormat;
import java.util.Date;
import java.util.List;
public class BaseController {
@Autowired
TokenService tokenService;
@Autowired
SysUserService sysUserService;
protected SysUserVO getUserInfo(){
String tokenStr = ServletUtils.getRequest().getHeader("token");
QueryWrapper<Token> sysUserTokenQW = new QueryWrapper<>();
sysUserTokenQW.eq("token",tokenStr);
Token token = tokenService.getOne(sysUserTokenQW);
if(ObjectUtils.isEmpty(token)){
throw new APIException(APIExceptionEnum.USER_TOKEN_EXPIRE);
}
QueryWrapper<SysUser> sysUserInfoQW = new QueryWrapper<>();
sysUserInfoQW.eq("user_id",token.getUserInfoId());
SysUser sysUser = sysUserService.getOne(sysUserInfoQW);
SysUserVO sysUserVO = new SysUserVO();
sysUserVO.setUserId(sysUser.getUserId());
sysUserVO.setLoginName(sysUser.getLoginName());
sysUserVO.setUserName(sysUser.getUserName());
//判断今天是否更新过token过期时间,没更新就去更新
if(ObjectUtils.isNotEmpty(token.getUpdateTime())){
Date updateTime = token.getUpdateTime();
SimpleDateFormat sdf2 = new SimpleDateFormat("yyyy-MM-dd");
String data2 = sdf2.format(updateTime);
Date date = new Date();
SimpleDateFormat sdf1 = new SimpleDateFormat("yyyy-MM-dd");
String data1 = sdf1.format(date);
if(!data1.equals(data2)){
sysUserService.getToken(sysUser, 1);
}
}
return sysUserVO;
}
/**
* 设置请求分页数据
*/
protected void startPage()
{
PageUtils.startPage();
}
protected TableDataInfo getDataTable(List<?> list)
{
TableDataInfo rspData = new TableDataInfo();
rspData.setRows(list);
rspData.setTotal(new PageInfo(list).getTotal());
return rspData;
}
}
package com.partner.admin.controller;
import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
import com.partner.admin.VO.HomePageLoginInfoVO;
import com.partner.admin.VO.HomePageLogoutInfoVO;
import com.partner.admin.domain.PartnerImageSource;
import com.partner.admin.domain.PartnerProjectInfo;
import com.partner.admin.service.PartnerImageSourceService;
import com.partner.admin.service.PartnerProjectInfoService;
import com.partner.admin.service.TokenService;
import io.swagger.annotations.Api;
import io.swagger.annotations.ApiOperation;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.PostMapping;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.ResponseBody;
import java.math.BigDecimal;
import java.util.List;
import java.util.Map;
/**
* 首页信息
* @author yaobaizheng
*/
@Controller
@RequestMapping("/common")
@Api(tags = "首页信息返回")
public class CommonController extends BaseController{
@Autowired
PartnerImageSourceService partnerImageSourceService;
@Autowired
PartnerProjectInfoService partnerProjectInfoService;
@PostMapping("/getLogOutHomePageInfo")
@ResponseBody
@ApiOperation(value = "返回未登陆时首页轮播图,统计数信息",notes = "直接调用")
public HomePageLogoutInfoVO getLogOutHomePageInfo() {
//首页轮播图
QueryWrapper<PartnerImageSource> pisQW = new QueryWrapper<PartnerImageSource>();
pisQW.eq("object_type", 4);
List<PartnerImageSource> pisList = partnerImageSourceService.list(pisQW);
//本意只使用合伙人平台的数据,但是鉴于数据为空,暂时不好看,暂时借用产业知道的数据,下面的以后会删除
// 统计数-总项目量+项目总投资额+项目总固定资产投资额+平台合伙人
HomePageLogoutInfoVO homePageLogoutInfoVO = partnerProjectInfoService.getLogoutStatistics();
homePageLogoutInfoVO.setPartnerImageSourceList(pisList);
return homePageLogoutInfoVO;
}
@PostMapping("/getLoginHomePageInfo")
@ResponseBody
@ApiOperation(value = "返回登陆时首页轮播图,统计数信息",notes = "直接调用")
public HomePageLoginInfoVO getLoginHomePageInfo() {
//首页轮播图
QueryWrapper<PartnerImageSource> pisQW = new QueryWrapper<>();
pisQW.eq("object_type", 5);
List<PartnerImageSource> pisList = partnerImageSourceService.list(pisQW);
//统计数-总项目量+总投资额+审核中的项目+推进中的项目
HomePageLoginInfoVO homePageLoginInfoVO = partnerProjectInfoService.getLoginStatistics(getUserInfo().getUserId());
homePageLoginInfoVO.setPartnerImageSourceList(pisList);
return homePageLoginInfoVO;
}
}
package com.partner.admin.controller;
import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
import com.partner.admin.VO.HomePageLoginInfoVO;
import com.partner.admin.VO.HomePageLogoutInfoVO;
import com.partner.admin.VO.PartnerExamineProjectInfoVO;
import com.partner.admin.common.menu.PartnerProjectStatusEnum;
import com.partner.admin.common.page.TableDataInfo;
import com.partner.admin.domain.PartnerImageSource;
import com.partner.admin.domain.PartnerProjectInfo;
import com.partner.admin.service.PartnerImageSourceService;
import com.partner.admin.service.PartnerProjectInfoService;
import io.swagger.annotations.Api;
import io.swagger.annotations.ApiImplicitParam;
import io.swagger.annotations.ApiImplicitParams;
import io.swagger.annotations.ApiOperation;
import org.springframework.beans.BeanUtils;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Controller;
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.ResponseBody;
import java.util.List;
/**
* 文件上传下载处理
* @author yaobaizheng
*/
@Controller
@RequestMapping("/partnerProject")
@Api(tags = "我的项目")
public class PartnerProjectController extends BaseController{
@Autowired
PartnerProjectInfoService partnerProjectInfoService;
@PostMapping("/getPersonProjectStatistics")
@ResponseBody
@ApiOperation(value = "顶部个人数据概览",notes = "直接调用")
public HomePageLoginInfoVO getPersonProjectStatistics() {
//统计数-总项目量+总投资额+审核中的项目+推进中的项目
HomePageLoginInfoVO homePageLoginInfoVO = partnerProjectInfoService.getLoginStatistics(getUserInfo().getUserId());
return homePageLoginInfoVO;
}
@PostMapping("/getPersonExamineProjectList")
@ResponseBody
@ApiOperation(value = "审核中列表",notes = "")
@ApiImplicitParams({
@ApiImplicitParam(name = "pageNum", value = "第几页(可为空,后台默认值:1)", type = "String"),
@ApiImplicitParam(name = "pageSize", value = "每页展示数据量(可为空,后台默认值:10)", type = "String"),
@ApiImplicitParam(name = "orderByColumn", value = "排序字段(可为空,传类属性)", type = "String"),
@ApiImplicitParam(name = "isAsc", value = "排序字段(可为空,请传asc或者desc)", type = "String")
})
public TableDataInfo getPersonExamineProjectList() {
QueryWrapper<PartnerProjectInfo> ppiQW = new QueryWrapper<>();
ppiQW.in("status", 1,2,3,4,5,6,7,8);
List<PartnerProjectInfo> list = partnerProjectInfoService.list(ppiQW);
return getDataTable(list);
}
@PostMapping("/getPersonPushProjectList")
@ResponseBody
@ApiOperation(value = "推进中列表",notes = "直接调用")
@ApiImplicitParams({
@ApiImplicitParam(name = "pageNum", value = "第几页(可为空,后台默认值:1)", type = "String"),
@ApiImplicitParam(name = "pageSize", value = "每页展示数据量(可为空,后台默认值:10)", type = "String"),
@ApiImplicitParam(name = "orderByColumn", value = "排序字段(可为空,传类属性)", type = "String"),
@ApiImplicitParam(name = "isAsc", value = "排序字段(可为空,请传asc或者desc)", type = "String")
})
public List<PartnerProjectInfo> getPersonPushProjectList() {
QueryWrapper<PartnerProjectInfo> ppiQW = new QueryWrapper<>();
ppiQW.in("status", 9,10,11,12,13,14);
return partnerProjectInfoService.list(ppiQW);
}
@PostMapping("/getPersonAllocationProjectList")
@ResponseBody
@ApiOperation(value = "分配中列表",notes = "直接调用")
@ApiImplicitParams({
@ApiImplicitParam(name = "pageNum", value = "第几页(可为空,后台默认值:1)", type = "String"),
@ApiImplicitParam(name = "pageSize", value = "每页展示数据量(可为空,后台默认值:10)", type = "String"),
@ApiImplicitParam(name = "orderByColumn", value = "排序字段(可为空,传类属性)", type = "String"),
@ApiImplicitParam(name = "isAsc", value = "排序字段(可为空,请传asc或者desc)", type = "String")
})
public List<PartnerProjectInfo> getPersonAllocationProjectList() {
QueryWrapper<PartnerProjectInfo> ppiQW = new QueryWrapper<>();
ppiQW.in("status", 15);
return partnerProjectInfoService.list(ppiQW);
}
@PostMapping("/getPersonSaveProjectList")
@ResponseBody
@ApiOperation(value = "草稿箱列表",notes = "直接调用")
@ApiImplicitParams({
@ApiImplicitParam(name = "pageNum", value = "第几页(可为空,后台默认值:1)", type = "String"),
@ApiImplicitParam(name = "pageSize", value = "每页展示数据量(可为空,后台默认值:10)", type = "String"),
@ApiImplicitParam(name = "orderByColumn", value = "排序字段(可为空,传类属性)", type = "String"),
@ApiImplicitParam(name = "isAsc", value = "排序字段(可为空,请传asc或者desc)", type = "String")
})
public List<PartnerProjectInfo> getPersonSaveProjectList() {
QueryWrapper<PartnerProjectInfo> ppiQW = new QueryWrapper<>();
ppiQW.in("status", 0);
return partnerProjectInfoService.list(ppiQW);
}
@PostMapping("/savePersonProject")
@ResponseBody
@ApiOperation(value = "保存项目",notes = "")
public PartnerProjectInfo savePersonProject(@RequestBody PartnerProjectInfo partnerProjectInfo) {
partnerProjectInfo.setPartnerId(getUserInfo().getUserId());
partnerProjectInfo.setStatus(PartnerProjectStatusEnum.PROJECTSTATUS0.code());
partnerProjectInfo.setStatusDescription(PartnerProjectStatusEnum.PROJECTSTATUS0.message());
partnerProjectInfoService.save(partnerProjectInfo);
return partnerProjectInfo;
}
@PostMapping("/submitPersonProject")
@ResponseBody
@ApiOperation(value = "提交项目",notes = "")
public PartnerProjectInfo submitPersonProject(@RequestBody PartnerProjectInfo partnerProjectInfo) {
partnerProjectInfo.setPartnerId(getUserInfo().getUserId());
partnerProjectInfo.setStatus(PartnerProjectStatusEnum.PROJECTSTATUS1.code());
partnerProjectInfo.setStatusDescription(PartnerProjectStatusEnum.PROJECTSTATUS1.message());
partnerProjectInfoService.save(partnerProjectInfo);
return partnerProjectInfo;
}
@PostMapping("/examineProjectDetail")
@ResponseBody
@ApiOperation(value = "审核中项目详情页",notes = "")
@ApiImplicitParam(name = "id", value = "项目id", type = "Integer")
public PartnerExamineProjectInfoVO examineProjectDetail(Integer id) {
PartnerProjectInfo partnerProjectInfo = partnerProjectInfoService.getById(id);
PartnerExamineProjectInfoVO partnerExamineProjectInfoVO = new PartnerExamineProjectInfoVO();
BeanUtils.copyProperties(partnerProjectInfo,partnerExamineProjectInfoVO);
return partnerExamineProjectInfoVO;
}
@PostMapping("/updatePersonProject")
@ResponseBody
@ApiOperation(value = "修改项目信息",notes = "")
public PartnerProjectInfo updatePersonProject(@RequestBody PartnerProjectInfo partnerProjectInfo) {
partnerProjectInfo.setPartnerId(getUserInfo().getUserId());
partnerProjectInfoService.updateById(partnerProjectInfo);
return partnerProjectInfo;
}
}
package com.partner.admin.controller;
import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
import com.partner.admin.VO.PartnerBaseInfoVO;
import com.partner.admin.VO.PartnerCoporateAccountInfoVO;
import com.partner.admin.domain.*;
import com.partner.admin.service.PartnerBaseInfoService;
import com.partner.admin.service.PartnerCoporateAccountInfoService;
import com.partner.admin.service.PartnerImageSourceService;
import com.partner.admin.service.UploadService;
import io.swagger.annotations.Api;
import io.swagger.annotations.ApiOperation;
import org.apache.commons.lang3.ObjectUtils;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Controller;
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.ResponseBody;
import java.util.ArrayList;
import java.util.List;
/**
* 首页信息
* @author yaobaizheng
*/
@Controller
@RequestMapping("/common")
@Api(tags = "我的")
public class PersonalController extends BaseController{
@Autowired
PartnerImageSourceService partnerImageSourceService;
@Autowired
PartnerBaseInfoService partnerBaseInfoService;
@Autowired
PartnerCoporateAccountInfoService partnerCoporateAccountInfoService;
@Autowired
UploadService uploadService;
@PostMapping("/getPersonalInfo")
@ResponseBody
@ApiOperation(value = "获取我的信息",notes = "")
public PartnerBaseInfoVO getPersonalInfo() {
PartnerBaseInfoVO partnerBaseInfoVO = new PartnerBaseInfoVO();
QueryWrapper<PartnerBaseInfo> pbiQW = new QueryWrapper<>();
pbiQW.eq("id", getUserInfo().getUserId());
PartnerBaseInfo partnerBaseInfo = partnerBaseInfoService.getOne(pbiQW);
partnerBaseInfoVO.setPartnerBaseInfo(partnerBaseInfo);
QueryWrapper<PartnerCoporateAccountInfo> pcaiQW = new QueryWrapper<>();
pcaiQW.eq("partner_id", getUserInfo().getUserId());
List<PartnerCoporateAccountInfo> partnerCoporateAccountInfoList = partnerCoporateAccountInfoService.list(pcaiQW);
List<PartnerCoporateAccountInfoVO> listVO = new ArrayList<>();
if(partnerCoporateAccountInfoList != null){
for (int i = 0; i < partnerCoporateAccountInfoList.size(); i++) {
QueryWrapper<PartnerImageSource> pisQW = new QueryWrapper<>();
pisQW.eq("object_id", partnerCoporateAccountInfoList.get(i).getId());
pisQW.eq("object_type", 3);
pisQW.orderByAsc("image_sort");
List<PartnerImageSource> list = partnerImageSourceService.list(pisQW);
PartnerCoporateAccountInfoVO partnerCoporateAccountInfoVO = new PartnerCoporateAccountInfoVO();
partnerCoporateAccountInfoVO.setPartnerCoporateAccountInfo(partnerCoporateAccountInfoList.get(i));
partnerCoporateAccountInfoVO.setPartnerImageSourceList(list);
listVO.add(partnerCoporateAccountInfoVO);
}
}
partnerBaseInfoVO.setPartnerCoporateAccountInfoVO(listVO);
return partnerBaseInfoVO;
}
@PostMapping("/saveOrUpdatePersonalInfo")
@ResponseBody
@ApiOperation(value = "保存我的信息",notes = "")
public PartnerBaseInfoVO saveOrUpdatePersonalInfo(@RequestBody PartnerBaseInfoVO partnerBaseInfoVO) {
Integer userId = getUserInfo().getUserId();
partnerBaseInfoVO.getPartnerBaseInfo().setId(userId);
partnerBaseInfoService.saveOrUpdate(partnerBaseInfoVO.getPartnerBaseInfo());
List<PartnerCoporateAccountInfoVO> list = partnerBaseInfoVO.getPartnerCoporateAccountInfoVO();
if(list != null){
for (int i = 0; i < list.size(); i++) {
PartnerCoporateAccountInfoVO partnerCoporateAccountInfoVO = list.get(i);
PartnerCoporateAccountInfo partnerCoporateAccountInfo = partnerCoporateAccountInfoVO.getPartnerCoporateAccountInfo();
partnerCoporateAccountInfo.setPartnerId(userId);
partnerCoporateAccountInfoService.saveOrUpdate(partnerCoporateAccountInfo);
List<PartnerImageSource> partnerImageSourceList = partnerCoporateAccountInfoVO.getPartnerImageSourceList();
if(partnerImageSourceList != null && partnerImageSourceList.size()>0){
for (int j = 0; j < partnerImageSourceList.size(); j++) {
partnerImageSourceList.get(j).setObjectType(3);
partnerImageSourceList.get(j).setObjectId(partnerCoporateAccountInfo.getId());
partnerImageSourceList.get(j).setImageSort(j);
partnerImageSourceService.saveOrUpdate(partnerImageSourceList.get(j));
}
}
}
}
return partnerBaseInfoVO;
}
@PostMapping("/deletePartnerImageSource")
@ResponseBody
@ApiOperation(value = "删除营业执照图片(逻辑删除)",notes = "")
public void deletePartnerImageSource(PartnerImageSource partnerImageSource) {
partnerImageSource.setStatus(0);
partnerImageSourceService.updateById(partnerImageSource);
}
}
package com.partner.admin.controller;
import com.partner.admin.common.config.PartnerConfig;
import com.partner.admin.service.UploadService;
import io.swagger.annotations.Api;
import io.swagger.annotations.ApiOperation;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.PostMapping;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.ResponseBody;
import org.springframework.web.multipart.MultipartFile;
/**
* 文件上传下载处理
* @author yaobaizheng
*/
@Controller
@RequestMapping("/sysFile")
@Api(tags = "文件上传")
public class SysFileController {
@Autowired
private PartnerConfig parterConfig;
@Autowired
UploadService uploadService;
@PostMapping("/uploadFileToHuaWeiOBS")
@ResponseBody
@ApiOperation(value = "文件上传华为OBS",notes = "")
public String uploadFileToHuaWeiOBS(MultipartFile file) throws Exception {
return parterConfig.getObsPath() + "/" + uploadService.uploadFile(file,"partner/file");
}
@PostMapping("/uploadImgToHuaWeiOBS")
@ResponseBody
@ApiOperation(value = "图片上传华为OBS",notes = "")
public String uploadImgToHuaWeiOBS(MultipartFile file) throws Exception {
return parterConfig.getObsPath() + "/" + uploadService.uploadFile(file,"partner/img");
}
@PostMapping("/uploadFileLocal")
@ResponseBody
@ApiOperation(value = "文件上传",notes = "")
public String uploadFileLocal(MultipartFile file) throws Exception {
return uploadService.uploadFileLocal( file,parterConfig.getProfile() + "/file/");
}
@PostMapping("/uploadImgLocal")
@ResponseBody
@ApiOperation(value = "图片上传",notes = "")
public String uploadImgLocal(MultipartFile file) throws Exception {
return uploadService.uploadFileLocal(file, parterConfig.getProfile() + "/img/");
}
}
package com.partner.admin.controller;
import cn.hutool.core.date.DateUtil;
import cn.hutool.json.JSONObject;
import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
import com.partner.admin.VO.SysUserVO;
import com.partner.admin.common.exception.APIException;
import com.partner.admin.common.exception.APIExceptionEnum;
import com.partner.admin.common.utils.WeixinUtil;
import com.partner.admin.domain.SysUser;
import com.partner.admin.service.SysUserService;
import io.swagger.annotations.Api;
import io.swagger.annotations.ApiOperation;
import org.apache.commons.lang3.StringUtils;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.PostMapping;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.ResponseBody;
import java.util.Date;
@Controller
@RequestMapping("/weixin")
@Api(tags = "微信接口")
public class WeixinController extends BaseController {
@Autowired
SysUserService sysUserService;
@PostMapping("/login")
@ResponseBody
@ApiOperation(value = "获取手机号码并登录",notes = "")
public SysUserVO login(String code) {
String accessToken = WeixinUtil.getAccessToken(WeixinUtil.appId, WeixinUtil.appSecret);
JSONObject phoneNumberObj = WeixinUtil.getPhoneNumber(code, accessToken);
System.out.println(phoneNumberObj.toString());
if(!"ok".equals(phoneNumberObj.getStr("errmsg"))){
System.out.println(phoneNumberObj.toString());
throw new APIException(APIExceptionEnum.WX_GETPHONENUMBER_ERROR);
}
String phoneNumber = phoneNumberObj.getJSONObject("phone_info").getStr("phoneNumber");
QueryWrapper<SysUser> sysUserInfoQW = new QueryWrapper<>();
sysUserInfoQW.eq("phonenumber",phoneNumber);
SysUser sysUserInfo = sysUserService.getOne(sysUserInfoQW);
SysUserVO sysUserInfoVO = new SysUserVO();
if(sysUserInfo == null){
sysUserInfo = new SysUser();
sysUserInfo.setPhonenumber(phoneNumber);
sysUserInfo.setAvatar("");
sysUserInfo.setUserName("微信用户");
sysUserInfo.setLoginName(phoneNumber);
sysUserInfo.setCreateTime(DateUtil.date());
sysUserInfo.setCreateBy("9999");
sysUserInfo.setSource(1);
sysUserService.save(sysUserInfo);
}
sysUserInfoVO.setLoginName(sysUserInfo.getLoginName());
sysUserInfoVO.setUserId(sysUserInfo.getUserId());
sysUserInfoVO.setPhonenumber(StringUtils.overlay(sysUserInfo.getPhonenumber(),"****", 3, 7));
sysUserInfoVO.setAvatar(sysUserInfo.getAvatar());
sysUserInfoVO.setUserName(sysUserInfo.getUserName());
String token = sysUserService.getToken(sysUserInfo, 1);
sysUserInfoVO.setToken(token);
return sysUserInfoVO;
}
}
package com.partner.admin.domain;
import com.baomidou.mybatisplus.annotation.IdType;
import com.baomidou.mybatisplus.annotation.TableField;
import com.baomidou.mybatisplus.annotation.TableId;
import com.baomidou.mybatisplus.annotation.TableName;
import java.io.Serializable;
import io.swagger.annotations.ApiModel;
import io.swagger.annotations.ApiModelProperty;
import lombok.Data;
/**
*
* @TableName partner_base_info
*/
@TableName(value ="partner_base_info")
@Data
@ApiModel(value = "我的信息")
public class PartnerBaseInfo implements Serializable {
/**
* 合伙人id
*/
@TableId
@ApiModelProperty(value = "合伙人id")
private Integer id;
/**
* 昵称
*/
@ApiModelProperty(value = "昵称")
private String nickName;
/**
* 头像
*/
@ApiModelProperty(value = "头像")
private String headerUrl;
/**
* 0-未认知 1-已认证 未认证不能做佣金提取 -真实姓名和身份证都有才认为认证通过
*/
@ApiModelProperty(hidden = true)
private Integer hasAuthentication;
/**
* 手机号
*/
@ApiModelProperty(value = "手机号")
private String mobilePhone;
/**
* 资料完成度
*/
@ApiModelProperty(hidden = true)
private String infoPrecentage;
/**
* 真实姓名
*/
@ApiModelProperty(value = "真实姓名")
private String realName;
/**
* 身份证号
*/
@ApiModelProperty(value = "身份证号")
private String idcardNumber;
/**
* 开户行
*/
@ApiModelProperty(value = "开户行")
private String bank;
/**
* 银行账户
*/
@ApiModelProperty(value = "银行账户")
private String bankCard;
/**
* 在职公司
*/
@ApiModelProperty(value = "在职公司")
private String company;
/**
* 在职行业
*/
@ApiModelProperty(value = "在职行业")
private String industry;
/**
* 所在职位
*/
@ApiModelProperty(value = "所在职位")
private String position;
/**
* 负责内容
*/
@ApiModelProperty(value = "负责内容")
private String responsbility;
/**
* 邮箱地址
*/
@ApiModelProperty(value = "邮箱地址")
private String email;
/**
* 毕业院校
*/
@ApiModelProperty(value = "毕业院校")
private String college;
/**
*
*/
@ApiModelProperty(hidden = true)
private String region;
/**
* 租户id
*/
@ApiModelProperty(hidden = true)
private Integer tenantId;
/**
*
*/
@ApiModelProperty(hidden = true)
private String openId;
@TableField(exist = false)
private static final long serialVersionUID = 1L;
}
\ No newline at end of file
package com.partner.admin.domain;
import com.baomidou.mybatisplus.annotation.IdType;
import com.baomidou.mybatisplus.annotation.TableField;
import com.baomidou.mybatisplus.annotation.TableId;
import com.baomidou.mybatisplus.annotation.TableName;
import java.io.Serializable;
import java.util.Date;
import io.swagger.annotations.ApiModel;
import io.swagger.annotations.ApiModelProperty;
import lombok.Data;
import org.springframework.format.annotation.DateTimeFormat;
/**
*
* @TableName partner_coporate_account_info
*/
@TableName(value ="partner_coporate_account_info")
@Data
@ApiModel(value = "对公收款账户")
public class PartnerCoporateAccountInfo implements Serializable {
/**
* id
*/
@TableId
@ApiModelProperty(value = "id")
private Integer id;
/**
*
*/
@ApiModelProperty(hidden = true)
@DateTimeFormat(pattern = "yyyy-MM-dd HH:mm:ss")
private Date createTime;
/**
*
*/
@ApiModelProperty(hidden = true)
@DateTimeFormat(pattern = "yyyy-MM-dd HH:mm:ss")
private Date updateTime;
/**
* 公司名称(对公收款账户)
*/
@ApiModelProperty(value = "公司名称")
private String corporateCollectionAccountCompanyName;
/**
* 银行账户
*/
@ApiModelProperty(value = "银行账户")
private String corporateCollectionAccountBankCard;
/**
* 注册地址
*/
@ApiModelProperty(value = "注册地址")
private String corporateCollectionAccountRegisterAddress;
/**
* 纳税号
*/
@ApiModelProperty(value = "纳税号")
private String corporateCollectionAccountTaxNumber;
/**
* 租户id
*/
@ApiModelProperty(hidden = true)
private Integer tenantId;
/**
* 合伙人id
*/
@ApiModelProperty(hidden = true)
private Integer partnerId;
@TableField(exist = false)
private static final long serialVersionUID = 1L;
}
\ No newline at end of file
package com.partner.admin.domain;
import com.baomidou.mybatisplus.annotation.IdType;
import com.baomidou.mybatisplus.annotation.TableField;
import com.baomidou.mybatisplus.annotation.TableId;
import com.baomidou.mybatisplus.annotation.TableName;
import java.io.Serializable;
import java.util.Date;
import io.swagger.annotations.ApiModel;
import io.swagger.annotations.ApiModelProperty;
import lombok.Data;
import org.springframework.format.annotation.DateTimeFormat;
/**
*
* @TableName partner_image_source
*/
@TableName(value ="partner_image_source")
@Data
@ApiModel(value = "图片上传")
public class PartnerImageSource implements Serializable {
/**
*
*/
@TableId(type = IdType.AUTO)
@ApiModelProperty(value = "图片id")
private Integer id;
/**
*
*/
@ApiModelProperty(hidden = true)
@DateTimeFormat(pattern = "yyyy-MM-dd HH:mm:ss")
private Date createTime;
/**
*
*/
@ApiModelProperty(hidden = true)
@DateTimeFormat(pattern = "yyyy-MM-dd HH:mm:ss")
private Date updateTime;
/**
* 图片url链接
*/
@ApiModelProperty(value = "图片url链接")
private String imageUrl;
/**
* 0-禁用 1-正常
*/
// @ApiModelProperty(value = "0-禁用 1-正常")
@ApiModelProperty(hidden = true)
private Integer status;
/**
* 项目 (1-合伙人管理/区域大纲 2-项目信息图片 3-对公账户营业执照)
*/
// @ApiModelProperty(value = "项目 (1-合伙人管理/区域大纲 2-项目信息图片 3-对公账户营业执照)")
@ApiModelProperty(hidden = true)
private Integer objectType;
/**
* 1-没有id 2-project_Info_id 3-coporate_account_info_id 4-未登录首页轮播图 5-登录首页轮播图
*/
// @ApiModelProperty(value = "1-没有id 2-project_Info_id 3-coporate_account_info_id")
@ApiModelProperty(hidden = true)
private Integer objectId;
/**
* 排序
*/
@ApiModelProperty(value = "排序")
private Integer imageSort;
/**
*
*/
@ApiModelProperty(hidden = true)
private Integer tenantId;
@TableField(exist = false)
private static final long serialVersionUID = 1L;
}
\ No newline at end of file
package com.partner.admin.domain;
import com.baomidou.mybatisplus.annotation.IdType;
import com.baomidou.mybatisplus.annotation.TableField;
import com.baomidou.mybatisplus.annotation.TableId;
import com.baomidou.mybatisplus.annotation.TableName;
import java.io.Serializable;
import java.math.BigDecimal;
import java.util.Date;
import io.swagger.annotations.ApiModel;
import io.swagger.annotations.ApiModelProperty;
import lombok.Data;
/**
*
* @TableName partner_project_info
*/
@TableName(value ="partner_project_info")
@Data
@ApiModel(value="项目信息")
public class PartnerProjectInfo implements Serializable {
/**
*
*/
@TableId(type = IdType.AUTO)
@ApiModelProperty(hidden = true)
private Integer id;
/**
* 投资主体
*/
@ApiModelProperty(value = "投资主体")
private String investmentSubject;
/**
* 企业亮点
*/
@ApiModelProperty(value = "企业亮点")
private String enterpriseHighlights;
/**
* 近年营收
*/
@ApiModelProperty(value = "近年营收")
private String continuousRevenue;
/**
* 产业基地
*/
@ApiModelProperty(value = "产业基地")
private String industrialBase;
/**
* 建设内容
*/
@ApiModelProperty(value = "建设内容")
private String constructionContent;
/**
* 投资总额
*/
@ApiModelProperty(value = "投资总额")
private BigDecimal projectInvestmentTotal;
/**
* 固定资产投资总额
*/
@ApiModelProperty(value = "固定资产投资总额")
private BigDecimal projectInvestmentRegular;
/**
* 项目诉求
*/
@ApiModelProperty(value = "项目诉求")
private String projectAppeal;
/**
* 意向区域
*/
@ApiModelProperty(value = "意向区域")
private String intendedRegion;
/**
* 佣金比例
*/
@ApiModelProperty(value = "佣金比例")
private String regionCommissionRate;
/**
* 载体类别
*/
@ApiModelProperty(value = "载体类别")
private String carrierType;
/**
* 土地需求(单位亩)
*/
@ApiModelProperty(value = "土地需求(单位亩)")
private String carrierRequirementsLandDemand;
/**
* 厂房需求(单位平米)
*/
@ApiModelProperty(value = "厂房需求(单位平米)")
private String carrierRequirementsFactoryDemand;
/**
* 决策人
*/
@ApiModelProperty(value = "决策人")
private String decisionMaker;
/**
* 决策人职位
*/
@ApiModelProperty(value = "决策人职位")
private String decisonMakerPosition;
/**
* 0-暂存 1-信息提报 2-项目查重通过 3-项目查重拒绝 4-招商公司匹配 5-企业对接 6-投资意向确认 7-确认项目信息 8-完成审核 9-项目信息 10-项目沟通 11-区域匹配 12-政企互访 13-项目谈判 14-项目签约 15-分配中 20-作废
*/
@ApiModelProperty(hidden = true)
private Integer status;
/**
* 0-暂存 1-信息提报 2-项目查重通过 3-项目查重拒绝 4-招商公司匹配 5-企业对接 6-投资意向确认 7-确认项目信息 8-完成审核 9-项目信息 10-项目沟通 11-区域匹配 12-政企互访 13-项目谈判 14-项目签约 15-分配中 20-作废
*/
@ApiModelProperty(hidden = true)
private String statusDescription;
/**
* 项目归属人
*/
@ApiModelProperty(value = "项目归属人")
private Integer partnerId;
/**
* 归属人是否已确认
*/
@ApiModelProperty(value = "归属人是否已确认")
private Integer partnerHasConfirm;
/**
* 匹配招商公司
*/
@ApiModelProperty(value = "匹配招商公司")
private String investmentPromotionCompany;
/**
* 租户id
*/
@ApiModelProperty(hidden = true)
private Integer tenantId;
/**
* 秘书id
*/
@ApiModelProperty(value = "秘书id")
private Integer secretaryId;
/**
*
*/
@ApiModelProperty(hidden = true)
private Date createTime;
/**
*
*/
@ApiModelProperty(hidden = true)
private Date updateTime;
/**
* 0-项目查重确认 1-确认项目所属 2-确认佣金比例
*/
@ApiModelProperty(hidden = true)
private Integer todoStatus;
@TableField(exist = false)
private static final long serialVersionUID = 1L;
}
\ No newline at end of file
package com.partner.admin.domain;
import com.baomidou.mybatisplus.annotation.IdType;
import com.baomidou.mybatisplus.annotation.TableField;
import com.baomidou.mybatisplus.annotation.TableId;
import com.baomidou.mybatisplus.annotation.TableName;
import java.io.Serializable;
import java.util.Date;
import lombok.Data;
/**
*
* @TableName partner_project_status_change_log
*/
@TableName(value ="partner_project_status_change_log")
@Data
public class PartnerProjectStatusChangeLog implements Serializable {
/**
*
*/
@TableId(type = IdType.AUTO)
private Integer id;
/**
*
*/
private Date createTime;
/**
*
*/
private Date updateTime;
/**
* 项目状态code
*/
private Integer projectStatus;
/**
* 项目状态
*/
private String projectStatusDisplay;
/**
*
*/
private Integer projectId;
/**
* 操作人
*/
private Integer operaterId;
/**
*
*/
private Integer tenantId;
/**
* 描述
*/
private String description;
@TableField(exist = false)
private static final long serialVersionUID = 1L;
}
\ No newline at end of file
package com.partner.admin.domain;
import com.baomidou.mybatisplus.annotation.IdType;
import com.baomidou.mybatisplus.annotation.TableField;
import com.baomidou.mybatisplus.annotation.TableId;
import com.baomidou.mybatisplus.annotation.TableName;
import java.io.Serializable;
import java.util.Date;
import lombok.Data;
/**
*
* @TableName partner_secretary
*/
@TableName(value ="partner_secretary")
@Data
public class PartnerSecretary implements Serializable {
/**
*
*/
@TableId(type = IdType.AUTO)
private Integer id;
/**
*
*/
private Date createTime;
/**
*
*/
private Date updateTime;
/**
* 名字
*/
private String name;
/**
* 头像
*/
private String headerUrl;
/**
* 电话号码
*/
private String telephone;
/**
* 微信二维码图片
*/
private String wxImageurl;
/**
* 成功落地项目数量
*/
private Integer successProjectNumber;
/**
* 当前服务的项目数量
*/
private Integer currentServiceProjectNumber;
@TableField(exist = false)
private static final long serialVersionUID = 1L;
}
\ No newline at end of file
package com.partner.admin.domain;
import com.baomidou.mybatisplus.annotation.IdType;
import com.baomidou.mybatisplus.annotation.TableField;
import com.baomidou.mybatisplus.annotation.TableId;
import com.baomidou.mybatisplus.annotation.TableName;
import java.io.Serializable;
import java.util.Date;
import lombok.Data;
/**
*
* @TableName partner_tanent_info
*/
@TableName(value ="partner_tanent_info")
@Data
public class PartnerTanentInfo implements Serializable {
/**
*
*/
@TableId(type = IdType.AUTO)
private Integer id;
/**
*
*/
private String tenantName;
/**
*
*/
private String status;
/**
*
*/
private Date createTime;
/**
*
*/
private Date updateTime;
@TableField(exist = false)
private static final long serialVersionUID = 1L;
}
\ No newline at end of file
package com.partner.admin.domain;
import com.baomidou.mybatisplus.annotation.IdType;
import com.baomidou.mybatisplus.annotation.TableField;
import com.baomidou.mybatisplus.annotation.TableId;
import com.baomidou.mybatisplus.annotation.TableName;
import java.io.Serializable;
import java.util.Date;
import lombok.Data;
/**
* 用户信息表
* @TableName sys_user
*/
@TableName(value ="sys_user")
@Data
public class SysUser implements Serializable {
/**
* 用户ID
*/
@TableId(type = IdType.AUTO)
private Integer userId;
/**
* 部门ID
*/
private Integer deptId;
/**
* 登录账号
*/
private String loginName;
/**
* 用户昵称
*/
private String userName;
/**
* 用户类型(00系统用户 01注册用户)
*/
private String userType;
/**
* 用户邮箱
*/
private String email;
/**
* 手机号码
*/
private String phonenumber;
/**
* 用户性别(0男 1女 2未知)
*/
private String sex;
/**
* 头像路径
*/
private String avatar;
/**
* 密码
*/
private String password;
/**
* 盐加密
*/
private String salt;
/**
* 帐号状态(0正常 1停用)
*/
private String status;
/**
* 删除标志(0代表存在 2代表删除)
*/
private String delFlag;
/**
* 最后登录IP
*/
private String loginIp;
/**
* 最后登录时间
*/
private Date loginDate;
/**
* 密码最后更新时间
*/
private Date pwdUpdateDate;
/**
* 创建者
*/
private String createBy;
/**
* 创建时间
*/
private Date createTime;
/**
* 更新者
*/
private String updateBy;
/**
* 更新时间
*/
private Date updateTime;
/**
* 备注
*/
private String remark;
/**
* 用户来源(1-微信小程序;2-后台管理)
*/
private Integer source;
@TableField(exist = false)
private static final long serialVersionUID = 1L;
}
\ No newline at end of file
package com.partner.admin.domain;
import com.baomidou.mybatisplus.annotation.IdType;
import com.baomidou.mybatisplus.annotation.TableField;
import com.baomidou.mybatisplus.annotation.TableId;
import com.baomidou.mybatisplus.annotation.TableName;
import java.io.Serializable;
import java.util.Date;
import lombok.Data;
/**
*
* @TableName token
*/
@TableName(value ="token")
@Data
public class Token implements Serializable {
/**
* id
*/
@TableId(type = IdType.AUTO)
private Integer id;
/**
* user_info表id
*/
private Integer userInfoId;
/**
* user_info表user_id字段
*/
private String userId;
/**
* user_info表user_name_en字段
*/
private String userNameEn;
/**
* token
*/
private String token;
/**
* 过期时间
*/
private Date expireTime;
/**
* 类型 1 移动端 2 pc端
*/
private Integer tokenType;
/**
* 创建时间
*/
private Date createTime;
/**
* 修改时间
*/
private Date updateTime;
@TableField(exist = false)
private static final long serialVersionUID = 1L;
}
\ No newline at end of file
package com.partner.admin.mapper;
import com.partner.admin.domain.PartnerBaseInfo;
import com.baomidou.mybatisplus.core.mapper.BaseMapper;
/**
* @author 26996
* @description 针对表【partner_base_info】的数据库操作Mapper
* @createDate 2023-10-11 10:07:10
* @Entity com.partner.admin.domain.PartnerBaseInfo
*/
public interface PartnerBaseInfoMapper extends BaseMapper<PartnerBaseInfo> {
}
package com.partner.admin.mapper;
import com.partner.admin.domain.PartnerCoporateAccountInfo;
import com.baomidou.mybatisplus.core.mapper.BaseMapper;
/**
* @author 26996
* @description 针对表【partner_coporate_account_info】的数据库操作Mapper
* @createDate 2023-10-11 10:18:10
* @Entity com.partner.admin.domain.PartnerCoporateAccountInfo
*/
public interface PartnerCoporateAccountInfoMapper extends BaseMapper<PartnerCoporateAccountInfo> {
}
package com.partner.admin.mapper;
import com.partner.admin.domain.PartnerImageSource;
import com.baomidou.mybatisplus.core.mapper.BaseMapper;
/**
* @author 26996
* @description 针对表【partner_image_source】的数据库操作Mapper
* @createDate 2023-10-09 16:41:12
* @Entity com.partner.admin.domain.PartnerImageSource
*/
public interface PartnerImageSourceMapper extends BaseMapper<PartnerImageSource> {
}
package com.partner.admin.mapper;
import com.partner.admin.VO.HomePageLoginInfoVO;
import com.partner.admin.VO.HomePageLogoutInfoVO;
import com.partner.admin.domain.PartnerProjectInfo;
import com.baomidou.mybatisplus.core.mapper.BaseMapper;
import java.util.Map;
/**
* @author 26996
* @description 针对表【partner_project_info】的数据库操作Mapper
* @createDate 2023-10-09 17:40:32
* @Entity com.partner.admin.domain.PartnerProjectInfo
*/
public interface PartnerProjectInfoMapper extends BaseMapper<PartnerProjectInfo> {
public HomePageLoginInfoVO getLoginStatistics(Integer userId);
public HomePageLogoutInfoVO getLogoutStatistics();
}
package com.partner.admin.mapper;
import com.partner.admin.domain.PartnerProjectStatusChangeLog;
import com.baomidou.mybatisplus.core.mapper.BaseMapper;
/**
* @author 26996
* @description 针对表【partner_project_status_change_log】的数据库操作Mapper
* @createDate 2023-10-09 16:41:12
* @Entity com.partner.admin.domain.PartnerProjectStatusChangeLog
*/
public interface PartnerProjectStatusChangeLogMapper extends BaseMapper<PartnerProjectStatusChangeLog> {
}
package com.partner.admin.mapper;
import com.partner.admin.domain.PartnerSecretary;
import com.baomidou.mybatisplus.core.mapper.BaseMapper;
/**
* @author 26996
* @description 针对表【partner_secretary】的数据库操作Mapper
* @createDate 2023-10-09 16:41:12
* @Entity com.partner.admin.domain.PartnerSecretary
*/
public interface PartnerSecretaryMapper extends BaseMapper<PartnerSecretary> {
}
package com.partner.admin.mapper;
import com.partner.admin.domain.PartnerTanentInfo;
import com.baomidou.mybatisplus.core.mapper.BaseMapper;
/**
* @author 26996
* @description 针对表【partner_tanent_info】的数据库操作Mapper
* @createDate 2023-10-09 16:41:12
* @Entity com.partner.admin.domain.PartnerTanentInfo
*/
public interface PartnerTanentInfoMapper extends BaseMapper<PartnerTanentInfo> {
}
package com.partner.admin.mapper;
import com.partner.admin.domain.SysUser;
import com.baomidou.mybatisplus.core.mapper.BaseMapper;
/**
* @author 26996
* @description 针对表【sys_user(用户信息表)】的数据库操作Mapper
* @createDate 2023-10-10 14:30:11
* @Entity com.partner.admin.domain.SysUser
*/
public interface SysUserMapper extends BaseMapper<SysUser> {
}
package com.partner.admin.mapper;
import com.partner.admin.domain.Token;
import com.baomidou.mybatisplus.core.mapper.BaseMapper;
/**
* @author 26996
* @description 针对表【token】的数据库操作Mapper
* @createDate 2023-10-10 14:50:39
* @Entity com.partner.admin.domain.Token
*/
public interface TokenMapper extends BaseMapper<Token> {
}
package com.partner.admin.service;
import com.partner.admin.domain.PartnerBaseInfo;
import com.baomidou.mybatisplus.extension.service.IService;
/**
* @author 26996
* @description 针对表【partner_base_info】的数据库操作Service
* @createDate 2023-10-11 10:07:10
*/
public interface PartnerBaseInfoService extends IService<PartnerBaseInfo> {
}
package com.partner.admin.service;
import com.partner.admin.domain.PartnerCoporateAccountInfo;
import com.baomidou.mybatisplus.extension.service.IService;
/**
* @author 26996
* @description 针对表【partner_coporate_account_info】的数据库操作Service
* @createDate 2023-10-11 10:18:10
*/
public interface PartnerCoporateAccountInfoService extends IService<PartnerCoporateAccountInfo> {
}
package com.partner.admin.service;
import com.partner.admin.domain.PartnerImageSource;
import com.baomidou.mybatisplus.extension.service.IService;
/**
* @author 26996
* @description 针对表【partner_image_source】的数据库操作Service
* @createDate 2023-10-09 16:41:12
*/
public interface PartnerImageSourceService extends IService<PartnerImageSource> {
}
package com.partner.admin.service;
import com.partner.admin.VO.HomePageLoginInfoVO;
import com.partner.admin.VO.HomePageLogoutInfoVO;
import com.partner.admin.domain.PartnerProjectInfo;
import com.baomidou.mybatisplus.extension.service.IService;
import com.partner.admin.mapper.PartnerProjectInfoMapper;
import java.util.Map;
/**
* @author 26996
* @description 针对表【partner_project_info】的数据库操作Service
* @createDate 2023-10-09 17:40:32
*/
public interface PartnerProjectInfoService extends IService<PartnerProjectInfo> {
public HomePageLoginInfoVO getLoginStatistics(Integer userId);
public HomePageLogoutInfoVO getLogoutStatistics();
}
package com.partner.admin.service;
import com.partner.admin.domain.PartnerProjectStatusChangeLog;
import com.baomidou.mybatisplus.extension.service.IService;
/**
* @author 26996
* @description 针对表【partner_project_status_change_log】的数据库操作Service
* @createDate 2023-10-09 16:41:12
*/
public interface PartnerProjectStatusChangeLogService extends IService<PartnerProjectStatusChangeLog> {
}
package com.partner.admin.service;
import com.partner.admin.domain.PartnerSecretary;
import com.baomidou.mybatisplus.extension.service.IService;
/**
* @author 26996
* @description 针对表【partner_secretary】的数据库操作Service
* @createDate 2023-10-09 16:41:12
*/
public interface PartnerSecretaryService extends IService<PartnerSecretary> {
}
package com.partner.admin.service;
import com.partner.admin.domain.PartnerTanentInfo;
import com.baomidou.mybatisplus.extension.service.IService;
/**
* @author 26996
* @description 针对表【partner_tanent_info】的数据库操作Service
* @createDate 2023-10-09 16:41:12
*/
public interface PartnerTanentInfoService extends IService<PartnerTanentInfo> {
}
package com.partner.admin.service;
import com.partner.admin.domain.SysUser;
import com.baomidou.mybatisplus.extension.service.IService;
/**
* @author 26996
* @description 针对表【sys_user(用户信息表)】的数据库操作Service
* @createDate 2023-10-10 14:30:11
*/
public interface SysUserService extends IService<SysUser> {
public String getToken(SysUser sysUser,Integer type);
}
package com.partner.admin.service;
import com.partner.admin.domain.Token;
import com.baomidou.mybatisplus.extension.service.IService;
/**
* @author 26996
* @description 针对表【token】的数据库操作Service
* @createDate 2023-10-10 14:50:39
*/
public interface TokenService extends IService<Token> {
}
package com.partner.admin.service;
import org.springframework.web.multipart.MultipartFile;
import javax.servlet.http.HttpServletResponse;
import java.util.Map;
public interface UploadService {
/**
* @Description: 文件上传
*/
String uploadFile(MultipartFile files,String rootPath) throws Exception;
/**
* @Description: 本地文件上传
*/
String uploadFileLocal(MultipartFile files, String rootPath) throws Exception;
/**
* @Description: 文件上传 返回值带原名
*/
Map<String, String> uploadFileReturnOriginalName(MultipartFile files);
/**
* @Description: 删除文件
*/
void deleteFile(String fileName);
/**
* @Description: 文件下载
*/
void downloadFile(String fileName, HttpServletResponse response);
/**
* @Description: 文件转base64
*/
String fileToBase64(String fileName);
}
package com.partner.admin.service.impl;
import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
import com.partner.admin.domain.PartnerBaseInfo;
import com.partner.admin.service.PartnerBaseInfoService;
import com.partner.admin.mapper.PartnerBaseInfoMapper;
import org.springframework.stereotype.Service;
/**
* @author 26996
* @description 针对表【partner_base_info】的数据库操作Service实现
* @createDate 2023-10-11 10:07:10
*/
@Service
public class PartnerBaseInfoServiceImpl extends ServiceImpl<PartnerBaseInfoMapper, PartnerBaseInfo>
implements PartnerBaseInfoService{
}
package com.partner.admin.service.impl;
import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
import com.partner.admin.domain.PartnerCoporateAccountInfo;
import com.partner.admin.service.PartnerCoporateAccountInfoService;
import com.partner.admin.mapper.PartnerCoporateAccountInfoMapper;
import org.springframework.stereotype.Service;
/**
* @author 26996
* @description 针对表【partner_coporate_account_info】的数据库操作Service实现
* @createDate 2023-10-11 10:18:10
*/
@Service
public class PartnerCoporateAccountInfoServiceImpl extends ServiceImpl<PartnerCoporateAccountInfoMapper, PartnerCoporateAccountInfo>
implements PartnerCoporateAccountInfoService{
}
package com.partner.admin.service.impl;
import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
import com.partner.admin.domain.PartnerImageSource;
import com.partner.admin.service.PartnerImageSourceService;
import com.partner.admin.mapper.PartnerImageSourceMapper;
import org.springframework.stereotype.Service;
/**
* @author 26996
* @description 针对表【partner_image_source】的数据库操作Service实现
* @createDate 2023-10-09 16:41:12
*/
@Service
public class PartnerImageSourceServiceImpl extends ServiceImpl<PartnerImageSourceMapper, PartnerImageSource>
implements PartnerImageSourceService{
}
package com.partner.admin.service.impl;
import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
import com.partner.admin.VO.HomePageLoginInfoVO;
import com.partner.admin.VO.HomePageLogoutInfoVO;
import com.partner.admin.domain.PartnerProjectInfo;
import com.partner.admin.service.PartnerProjectInfoService;
import com.partner.admin.mapper.PartnerProjectInfoMapper;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import java.util.Map;
/**
* @author 26996
* @description 针对表【partner_project_info】的数据库操作Service实现
* @createDate 2023-10-09 17:40:32
*/
@Service
public class PartnerProjectInfoServiceImpl extends ServiceImpl<PartnerProjectInfoMapper, PartnerProjectInfo>
implements PartnerProjectInfoService{
@Autowired
PartnerProjectInfoMapper partnerProjectInfoMapper;
public HomePageLoginInfoVO getLoginStatistics(Integer userId) {
return partnerProjectInfoMapper.getLoginStatistics(userId);
}
public HomePageLogoutInfoVO getLogoutStatistics() {
return partnerProjectInfoMapper.getLogoutStatistics();
}
}
package com.partner.admin.service.impl;
import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
import com.partner.admin.domain.PartnerProjectStatusChangeLog;
import com.partner.admin.service.PartnerProjectStatusChangeLogService;
import com.partner.admin.mapper.PartnerProjectStatusChangeLogMapper;
import org.springframework.stereotype.Service;
/**
* @author 26996
* @description 针对表【partner_project_status_change_log】的数据库操作Service实现
* @createDate 2023-10-09 16:41:12
*/
@Service
public class PartnerProjectStatusChangeLogServiceImpl extends ServiceImpl<PartnerProjectStatusChangeLogMapper, PartnerProjectStatusChangeLog>
implements PartnerProjectStatusChangeLogService{
}
package com.partner.admin.service.impl;
import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
import com.partner.admin.domain.PartnerSecretary;
import com.partner.admin.service.PartnerSecretaryService;
import com.partner.admin.mapper.PartnerSecretaryMapper;
import org.springframework.stereotype.Service;
/**
* @author 26996
* @description 针对表【partner_secretary】的数据库操作Service实现
* @createDate 2023-10-09 16:41:12
*/
@Service
public class PartnerSecretaryServiceImpl extends ServiceImpl<PartnerSecretaryMapper, PartnerSecretary>
implements PartnerSecretaryService{
}
package com.partner.admin.service.impl;
import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
import com.partner.admin.domain.PartnerTanentInfo;
import com.partner.admin.service.PartnerTanentInfoService;
import com.partner.admin.mapper.PartnerTanentInfoMapper;
import org.springframework.stereotype.Service;
/**
* @author 26996
* @description 针对表【partner_tanent_info】的数据库操作Service实现
* @createDate 2023-10-09 16:41:12
*/
@Service
public class PartnerTanentInfoServiceImpl extends ServiceImpl<PartnerTanentInfoMapper, PartnerTanentInfo>
implements PartnerTanentInfoService{
}
package com.partner.admin.service.impl;
import cn.hutool.core.date.DateTime;
import cn.hutool.core.date.DateUtil;
import cn.hutool.core.util.IdUtil;
import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
import com.partner.admin.common.config.PartnerConfig;
import com.partner.admin.domain.SysUser;
import com.partner.admin.domain.Token;
import com.partner.admin.mapper.TokenMapper;
import com.partner.admin.service.SysUserService;
import com.partner.admin.mapper.SysUserMapper;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
/**
* @author 26996
* @description 针对表【sys_user(用户信息表)】的数据库操作Service实现
* @createDate 2023-10-10 14:30:11
*/
@Service
public class SysUserServiceImpl extends ServiceImpl<SysUserMapper, SysUser>
implements SysUserService{
@Autowired
TokenMapper sysUserTokenMapper;
@Autowired
PartnerConfig parterConfig;
@Override
public String getToken(SysUser sysUser,Integer type){
//设置token
QueryWrapper<Token> sysUserTokenQW = new QueryWrapper<>();
sysUserTokenQW.eq("user_id",sysUser.getLoginName());
Token sysUserToken = sysUserTokenMapper.selectOne(sysUserTokenQW);
String token = "";
if(sysUserToken == null){
sysUserToken = new Token();
sysUserToken.setUserInfoId(sysUser.getUserId());
sysUserToken.setUserId(sysUser.getLoginName());
sysUserToken.setUserNameEn(sysUser.getUserName());
token = IdUtil.simpleUUID();
sysUserToken.setToken(token);
DateTime dateCreateTime = DateUtil.date();
DateTime dateExpireTime = DateUtil.offsetDay(dateCreateTime, parterConfig.getTokenExpireTimeDays());
sysUserToken.setExpireTime(dateExpireTime);
sysUserToken.setTokenType(type);
sysUserToken.setCreateTime(dateCreateTime);
sysUserTokenMapper.insert(sysUserToken);
}else{
token = sysUserToken.getToken();
DateTime dateUpdateTime = DateUtil.date();
DateTime dateExpireTime = DateUtil.offsetDay(dateUpdateTime, parterConfig.getTokenExpireTimeDays());
sysUserToken.setExpireTime(dateExpireTime);
sysUserToken.setUpdateTime(dateUpdateTime);
sysUserTokenMapper.updateById(sysUserToken);
}
return token;
}
}
package com.partner.admin.service.impl;
import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
import com.partner.admin.domain.Token;
import com.partner.admin.service.TokenService;
import com.partner.admin.mapper.TokenMapper;
import org.springframework.stereotype.Service;
/**
* @author 26996
* @description 针对表【token】的数据库操作Service实现
* @createDate 2023-10-10 14:50:39
*/
@Service
public class TokenServiceImpl extends ServiceImpl<TokenMapper, Token>
implements TokenService{
}
package com.partner.admin.service.impl;
import cn.hutool.core.date.DateUtil;
import cn.hutool.core.util.IdUtil;
import com.partner.admin.common.utils.hwobs.ObsUtils;
import com.partner.admin.service.UploadService;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.stereotype.Service;
import org.springframework.util.FileCopyUtils;
import org.springframework.web.multipart.MultipartFile;
import javax.annotation.Resource;
import javax.servlet.http.HttpServletResponse;
import java.io.File;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.time.LocalDateTime;
import java.util.HashMap;
import java.util.Map;
@Service
public class UploadServiceImpl implements UploadService {
@Value("${huaweiObs.bucketName}")
String bucketName;
@Resource
private ObsUtils obsUtils;
/**
* @param files
* @Description: 文件上传
* @return 文件存储路径
*/
@Override
public String uploadFile(MultipartFile files,String rootPath) throws Exception {
//华为obs
if(files == null || files.getSize() == 0){
throw new Exception("请上传文件,文件为空");
}
String fileOriginalName = files.getOriginalFilename();
String fileLastType = fileOriginalName.substring(files.getOriginalFilename().lastIndexOf("."));
// String date = LocalDateTimeUtils.formatNow("yyyy-MM-dd");
String date = DateUtil.format(LocalDateTime.now(), "yyyy-MM-dd");
String newFilename = IdUtil.simpleUUID() + fileLastType;
String filePath = "/" + date + "/" + newFilename;
InputStream inputStream = files.getInputStream();
obsUtils.ObsUpload(bucketName, rootPath + filePath, inputStream);
return rootPath + filePath;
}
@Override
public String uploadFileLocal(MultipartFile files, String rootPath) throws Exception {
//华为obs
if(files == null || files.getSize() == 0){
throw new Exception("请上传文件,文件为空");
}
String fileOriginalName = files.getOriginalFilename();
String fileLastType = fileOriginalName.substring(files.getOriginalFilename().lastIndexOf("."));
String date = DateUtil.format(LocalDateTime.now(), "yyyy-MM-dd");
String newFilename = IdUtil.simpleUUID() + fileLastType;
String filePath = rootPath + "/" + date +"/" ;
File file = new File(filePath);
if (!file.exists() && !file.isDirectory()) {
file.mkdirs();
}
filePath = filePath + newFilename;
InputStream inputStream = files.getInputStream();
FileCopyUtils.copy(inputStream, new FileOutputStream((new File(filePath))));
return filePath;
}
/**
* @param files
* @Description: 文件上传
* @return 文件原名,文件存储路径,文件类型
*/
@Override
public Map<String, String> uploadFileReturnOriginalName(MultipartFile files) {
String fileOriginalName = files.getOriginalFilename();
String fileLastType = fileOriginalName.substring(files.getOriginalFilename().lastIndexOf("."));
String newFilename = IdUtil.simpleUUID() + fileLastType;
// String date = LocalDateTimeUtils.formatNow("yyyy-MM-dd");
String date = DateUtil.format(LocalDateTime.now(), "yyyy-MM-dd");
String filePath = "file/" + date + "/" + newFilename;
try {
InputStream inputStream = files.getInputStream();
obsUtils.ObsUpload(bucketName, filePath, inputStream);
}catch (IOException e){
e.getStackTrace();
}
Map<String, String> result = new HashMap<>();
result.put("filePath", filePath);
result.put("fileOriginalName", fileOriginalName);
result.put("fileLastType", fileLastType);
return result;
}
/**
* @param fileName
* @Description: 删除文件
*/
@Override
public void deleteFile(String fileName) {
obsUtils.deleteFile(bucketName, fileName);
}
/**
* @param fileName
* @param response
* @Description: 文件下载
*/
@Override
public void downloadFile(String fileName, HttpServletResponse response) {
obsUtils.downloadFile(response, fileName);
}
/**
* @param fileName
* @Description: 文件转base64
*/
@Override
public String fileToBase64(String fileName) {
return obsUtils.fileToBase64(fileName);
}
}
spring:
datasource:
type: com.alibaba.druid.pool.DruidDataSource
driverClassName: com.mysql.cj.jdbc.Driver
url: jdbc:mysql://10.90.102.101:3306/knowdb?serverTimezone=UTC&useUnicode=true&characterEncoding=utf-8&useSSL=true
username: root
password: CF**ldcn
# 初始连接数
initialSize: 5
# 最小连接池数量
minIdle: 10
# 最大连接池数量
maxActive: 20
# 配置获取连接等待超时的时间
maxWait: 60000
# 配置连接超时时间
connectTimeout: 30000
# 配置网络超时时间
socketTimeout: 60000
# 配置间隔多久才进行一次检测,检测需要关闭的空闲连接,单位是毫秒
timeBetweenEvictionRunsMillis: 60000
# 配置一个连接在池中最小生存的时间,单位是毫秒
minEvictableIdleTimeMillis: 300000
# 配置一个连接在池中最大生存的时间,单位是毫秒
maxEvictableIdleTimeMillis: 900000
# 配置检测连接是否有效
validationQuery: SELECT 1 FROM DUAL
testWhileIdle: true
testOnBorrow: false
testOnReturn: false
webStatFilter:
enabled: true
statViewServlet:
enabled: true
# 设置白名单,不填则允许所有访问
allow:
url-pattern: /druid/*
# 控制台管理用户名和密码
login-username: yaobaizheng
login-password: 269969
filter:
stat:
enabled: true
# 慢SQL记录
log-slow-sql: true
slow-sql-millis: 1000
merge-sql: true
wall:
config:
multi-statement-allow: true
# 项目相关配置
partner:
# 本地文件路径 示例( Windows配置D:/uploadPath,Linux配置 /home/uploadPath)
profile: /home/lyy/uploadPath
# 华为OBS文件路径 示例( https://img-t.knowingindustry.com)
obsPath: http://img-t.knowingindustry.com/lyy
#密码盐
passwordSalt: cEhnigIPtyPimGbiLA1BeNO3Lt0Ybd#m
#token有效期 15天
tokenExpireTimeDays: 15
#是否开启自定义过滤器
enableUrlFilter: true
# 华为obs
huaweiObs:
endPoint: obs.cn-north-4.myhuaweicloud.com
ak: 5M4SFISSZI2CN4JVPHVI
sk: uZIdUJIwO0sKGVY0hltF9I6IbHEmjwCRco5JV7aM
bucketName: cfld-hw-obs-01
# Swagger配置
swagger:
# 是否开启swagger
enabled: true
# /**
# * 类属性:pCode
# * 注:对swagger来说首字母小写,后面紧跟着的字母是大写,最终到前端会变成PCode,
# * @ApiModelProperty(hidden = true)会失效,
# * 解决办法:1、在yml文件中添加
# * knife4j:
# * enable: true
# * 2、在方法上加@ApiOperationSupport(ignoreParameters = {"PCode"})
#*/
knife4j:
enable: true
\ No newline at end of file
spring:
datasource:
type: com.alibaba.druid.pool.DruidDataSource
driverClassName: com.mysql.cj.jdbc.Driver
url: jdbc:mysql://localhost:3306/knowdb?serverTimezone=UTC&useUnicode=true&characterEncoding=utf-8&useSSL=true
username: root
password: root
# 初始连接数
initialSize: 5
# 最小连接池数量
minIdle: 10
# 最大连接池数量
maxActive: 20
# 配置获取连接等待超时的时间
maxWait: 60000
# 配置连接超时时间
connectTimeout: 30000
# 配置网络超时时间
socketTimeout: 60000
# 配置间隔多久才进行一次检测,检测需要关闭的空闲连接,单位是毫秒
timeBetweenEvictionRunsMillis: 60000
# 配置一个连接在池中最小生存的时间,单位是毫秒
minEvictableIdleTimeMillis: 300000
# 配置一个连接在池中最大生存的时间,单位是毫秒
maxEvictableIdleTimeMillis: 900000
# 配置检测连接是否有效
validationQuery: SELECT 1 FROM DUAL
testWhileIdle: true
testOnBorrow: false
testOnReturn: false
webStatFilter:
enabled: true
statViewServlet:
enabled: true
# 设置白名单,不填则允许所有访问
allow:
url-pattern: /druid/*
# 控制台管理用户名和密码
login-username: yaobaizheng
login-password: 269969
filter:
stat:
enabled: true
# 慢SQL记录
log-slow-sql: true
slow-sql-millis: 1000
merge-sql: true
wall:
config:
multi-statement-allow: true
# 项目相关配置
partner:
# 本地文件路径 示例( Windows配置D:/uploadPath,Linux配置 /home/uploadPath)
profile: D:/uploadPath
# 华为OBS文件路径 示例(https://img-t.knowingindustry.com)
obsPath: https://img-t.knowingindustry.com
#密码盐
passwordSalt: cEhnigIPtyPimGbiLA1BeNO3Lt0Ybd#m
#token有效期 15天
tokenExpireTimeDays: 15
#是否开启自定义过滤器
enableUrlFilter: true
# 华为obs
huaweiObs:
endPoint: obs.cn-north-4.myhuaweicloud.com
ak: 5M4SFISSZI2CN4JVPHVI
sk: uZIdUJIwO0sKGVY0hltF9I6IbHEmjwCRco5JV7aM
bucketName: cfld-hw-obs-01
# Swagger配置
swagger:
# 是否开启swagger
enabled: true
# /**
# * 类属性:pCode
# * 注:对swagger来说首字母小写,后面紧跟着的字母是大写,最终到前端会变成PCode,
# * @ApiModelProperty(hidden = true)会失效,
# * 解决办法:1、在yml文件中添加
# * knife4j:
# * enable: true
# * 2、在方法上加@ApiOperationSupport(ignoreParameters = {"PCode"})
#*/
knife4j:
enable: true
\ No newline at end of file
spring:
datasource:
type: com.alibaba.druid.pool.DruidDataSource
driverClassName: com.mysql.cj.jdbc.Driver
url: jdbc:mysql://192.168.66.10:3306/knowdb?serverTimezone=UTC&useUnicode=true&characterEncoding=utf-8&useSSL=true
username: user_know
password: proF8HzEzMh
# 初始连接数
initialSize: 5
# 最小连接池数量
minIdle: 10
# 最大连接池数量
maxActive: 20
# 配置获取连接等待超时的时间
maxWait: 60000
# 配置连接超时时间
connectTimeout: 30000
# 配置网络超时时间
socketTimeout: 60000
# 配置间隔多久才进行一次检测,检测需要关闭的空闲连接,单位是毫秒
timeBetweenEvictionRunsMillis: 60000
# 配置一个连接在池中最小生存的时间,单位是毫秒
minEvictableIdleTimeMillis: 300000
# 配置一个连接在池中最大生存的时间,单位是毫秒
maxEvictableIdleTimeMillis: 900000
# 配置检测连接是否有效
validationQuery: SELECT 1 FROM DUAL
testWhileIdle: true
testOnBorrow: false
testOnReturn: false
webStatFilter:
enabled: true
statViewServlet:
enabled: true
# 设置白名单,不填则允许所有访问
allow:
url-pattern: /druid/*
# 控制台管理用户名和密码
login-username: yaobaizheng
login-password: 269969
filter:
stat:
enabled: true
# 慢SQL记录
log-slow-sql: true
slow-sql-millis: 1000
merge-sql: true
wall:
config:
multi-statement-allow: true
# 项目相关配置
partner:
# 本地文件路径 示例( Windows配置D:/uploadPath,Linux配置 /home/uploadPath)
profile: D:/uploadPath
# 华为OBS文件路径 示例( https://img-t.knowingindustry.com)
obsPath: http://img-t.knowingindustry.com
#密码盐
passwordSalt: cEhnigIPtyPimGbiLA1BeNO3Lt0Ybd#m
#token有效期 15天
tokenExpireTimeDays: 15
#是否开启自定义过滤器
enableUrlFilter: true
# 华为obs
huaweiObs:
endPoint: obs.cn-north-4.myhuaweicloud.com
ak: 5M4SFISSZI2CN4JVPHVI
sk: uZIdUJIwO0sKGVY0hltF9I6IbHEmjwCRco5JV7aM
bucketName: cfld-hw-obs-01
# Swagger配置
swagger:
# 是否开启swagger
enabled: true
# /**
# * 类属性:pCode
# * 注:对swagger来说首字母小写,后面紧跟着的字母是大写,最终到前端会变成PCode,
# * @ApiModelProperty(hidden = true)会失效,
# * 解决办法:1、在yml文件中添加
# * knife4j:
# * enable: true
# * 2、在方法上加@ApiOperationSupport(ignoreParameters = {"PCode"})
#*/
knife4j:
enable: true
\ No newline at end of file
spring:
datasource:
type: com.alibaba.druid.pool.DruidDataSource
driverClassName: com.mysql.cj.jdbc.Driver
url: jdbc:mysql://rm-2ze10ohzb1898j5qd.mysql.rds.aliyuncs.com:3306/know_db?serverTimezone=UTC&useUnicode=true&characterEncoding=utf-8&useSSL=true
username: liyeyun
password: CF**ldcn
# 初始连接数
initialSize: 5
# 最小连接池数量
minIdle: 10
# 最大连接池数量
maxActive: 20
# 配置获取连接等待超时的时间
maxWait: 60000
# 配置连接超时时间
connectTimeout: 30000
# 配置网络超时时间
socketTimeout: 60000
# 配置间隔多久才进行一次检测,检测需要关闭的空闲连接,单位是毫秒
timeBetweenEvictionRunsMillis: 60000
# 配置一个连接在池中最小生存的时间,单位是毫秒
minEvictableIdleTimeMillis: 300000
# 配置一个连接在池中最大生存的时间,单位是毫秒
maxEvictableIdleTimeMillis: 900000
# 配置检测连接是否有效
validationQuery: SELECT 1 FROM DUAL
testWhileIdle: true
testOnBorrow: false
testOnReturn: false
webStatFilter:
enabled: true
statViewServlet:
enabled: true
# 设置白名单,不填则允许所有访问
allow:
url-pattern: /druid/*
# 控制台管理用户名和密码
login-username: yaobaizheng
login-password: 269969
filter:
stat:
enabled: true
# 慢SQL记录
log-slow-sql: true
slow-sql-millis: 1000
merge-sql: true
wall:
config:
multi-statement-allow: true
# 项目相关配置
partner:
# 本地文件路径 示例( Windows配置D:/uploadPath,Linux配置 /home/uploadPath)
profile: D:/uploadPath
# 华为OBS文件路径 示例( https://img-t.knowingindustry.com)
obsPath: http://img-t.knowingindustry.com
#密码盐
passwordSalt: cEhnigIPtyPimGbiLA1BeNO3Lt0Ybd#m
#token有效期 15天
tokenExpireTimeDays: 15
#是否开启自定义过滤器
enableUrlFilter: true
# 华为obs
huaweiObs:
endPoint: obs.cn-north-4.myhuaweicloud.com
ak: 5M4SFISSZI2CN4JVPHVI
sk: uZIdUJIwO0sKGVY0hltF9I6IbHEmjwCRco5JV7aM
bucketName: cfld-hw-obs-01
# Swagger配置
swagger:
# 是否开启swagger
enabled: true
# /**
# * 类属性:pCode
# * 注:对swagger来说首字母小写,后面紧跟着的字母是大写,最终到前端会变成PCode,
# * @ApiModelProperty(hidden = true)会失效,
# * 解决办法:1、在yml文件中添加
# * knife4j:
# * enable: true
# * 2、在方法上加@ApiOperationSupport(ignoreParameters = {"PCode"})
#*/
knife4j:
enable: true
\ No newline at end of file
server:
# 服务器的HTTP端口,默认为80
port: 8085
servlet:
# 应用的访问路径
context-path: /partner
tomcat:
# tomcat的URI编码
uri-encoding: UTF-8
# 连接数满后的排队数,默认为100
accept-count: 1000
threads:
# tomcat最大线程数,默认为200
max: 800
# Tomcat启动初始化的线程数,默认值10
min-spare: 100
# 日志配置
logging:
level:
com.lyy: debug
org.springframework: warn
spring:
# 配置环境切换
profiles:
active: dev
# 文件上传
servlet:
multipart:
# 单个文件大小
max-file-size: 10MB
# 设置总上传的文件大小
max-request-size: 20MB
# 服务模块
devtools:
restart:
# 热部署开关
enabled: true
jackson:
time-zone: GMT+8
date-format: yyyy-MM-dd HH:mm:ss
mvc:
pathmatch:
matching-strategy: ant_path_matcher
mybatis-plus:
# 指定Mapper XML文件的位置,使用classpath通配符指定路径。
mapper-locations: classpath*:mapper/**/*Mapper.xml
configuration:
# 将 Java 实体类属性的驼峰命名规则转换为数据库字段的下划线命名规则
map-underscore-to-camel-case: true
# 是否开启二级缓存。
cache-enabled: false
# 这个配置会将执行的sql打印出来,在开发或测试的时候可以用
log-impl: org.apache.ibatis.logging.stdout.StdOutImpl
# 指定实体类的包路径,用于自动扫描并注册类型别名。
type-aliases-package: com.parter.**.domain
#处理自增id异常
global-config:
db-config:
id-type: auto
# PageHelper分页插件
pagehelper:
helperDialect: mysql
supportMethodsArguments: true
params: count=countSql
<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE mapper
PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN"
"http://mybatis.org/dtd/mybatis-3-mapper.dtd">
<mapper namespace="com.partner.admin.mapper.PartnerBaseInfoMapper">
<resultMap id="BaseResultMap" type="com.partner.admin.domain.PartnerBaseInfo">
<id property="id" column="id" jdbcType="INTEGER"/>
<result property="nickName" column="nick_name" jdbcType="VARCHAR"/>
<result property="headerUrl" column="header_url" jdbcType="VARCHAR"/>
<result property="hasAuthentication" column="has_authentication" jdbcType="TINYINT"/>
<result property="mobilePhone" column="mobile_phone" jdbcType="VARCHAR"/>
<result property="infoPrecentage" column="info_precentage" jdbcType="VARCHAR"/>
<result property="realName" column="real_name" jdbcType="VARCHAR"/>
<result property="idcardNumber" column="idcard_number" jdbcType="VARCHAR"/>
<result property="bank" column="bank" jdbcType="VARCHAR"/>
<result property="bankCard" column="bank_card" jdbcType="VARCHAR"/>
<result property="company" column="company" jdbcType="VARCHAR"/>
<result property="industry" column="industry" jdbcType="VARCHAR"/>
<result property="position" column="position" jdbcType="VARCHAR"/>
<result property="responsbility" column="responsbility" jdbcType="VARCHAR"/>
<result property="email" column="email" jdbcType="VARCHAR"/>
<result property="college" column="college" jdbcType="VARCHAR"/>
<result property="region" column="region" jdbcType="VARCHAR"/>
<result property="tenantId" column="tenant_id" jdbcType="INTEGER"/>
<result property="openId" column="open_id" jdbcType="VARCHAR"/>
</resultMap>
<sql id="Base_Column_List">
id,nick_name,header_url,
has_authentication,mobile_phone,info_precentage,
real_name,idcard_number,bank,
bank_card,company,industry,
position,responsbility,email,
college,region,tenant_id,
open_id
</sql>
</mapper>
<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE mapper
PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN"
"http://mybatis.org/dtd/mybatis-3-mapper.dtd">
<mapper namespace="com.partner.admin.mapper.PartnerCoporateAccountInfoMapper">
<resultMap id="BaseResultMap" type="com.partner.admin.domain.PartnerCoporateAccountInfo">
<id property="id" column="id" jdbcType="INTEGER"/>
<result property="createTime" column="create_time" jdbcType="TIMESTAMP"/>
<result property="updateTime" column="update_time" jdbcType="TIMESTAMP"/>
<result property="corporateCollectionAccountCompanyName" column="corporate_collection_account_company_name" jdbcType="VARCHAR"/>
<result property="corporateCollectionAccountBankCard" column="corporate_collection_account_bank_card" jdbcType="VARCHAR"/>
<result property="corporateCollectionAccountRegisterAddress" column="corporate_collection_account_register_address" jdbcType="VARCHAR"/>
<result property="corporateCollectionAccountTaxNumber" column="corporate_collection_account_tax_number" jdbcType="VARCHAR"/>
<result property="tenantId" column="tenant_id" jdbcType="INTEGER"/>
<result property="partnerId" column="partner_id" jdbcType="INTEGER"/>
</resultMap>
<sql id="Base_Column_List">
id,create_time,update_time,
corporate_collection_account_company_name,corporate_collection_account_bank_card,corporate_collection_account_register_address,
corporate_collection_account_tax_number,tenant_id,partner_id
</sql>
</mapper>
<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE mapper
PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN"
"http://mybatis.org/dtd/mybatis-3-mapper.dtd">
<mapper namespace="com.partner.admin.mapper.PartnerImageSourceMapper">
<resultMap id="BaseResultMap" type="com.partner.admin.domain.PartnerImageSource">
<id property="id" column="id" jdbcType="INTEGER"/>
<result property="createTime" column="create_time" jdbcType="TIMESTAMP"/>
<result property="updateTime" column="update_time" jdbcType="TIMESTAMP"/>
<result property="imageUrl" column="image_url" jdbcType="VARCHAR"/>
<result property="status" column="status" jdbcType="TINYINT"/>
<result property="objectType" column="object_type" jdbcType="INTEGER"/>
<result property="objectId" column="object_id" jdbcType="INTEGER"/>
<result property="imageSort" column="image_sort" jdbcType="INTEGER"/>
<result property="tenantId" column="tenant_id" jdbcType="INTEGER"/>
</resultMap>
<sql id="Base_Column_List">
id,create_time,update_time,
image_url,status,object_type,
object_id,image_sort,tenant_id
</sql>
</mapper>
<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE mapper
PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN"
"http://mybatis.org/dtd/mybatis-3-mapper.dtd">
<mapper namespace="com.partner.admin.mapper.PartnerProjectInfoMapper">
<resultMap id="BaseResultMap" type="com.partner.admin.domain.PartnerProjectInfo">
<id property="id" column="id" jdbcType="INTEGER"/>
<result property="investmentSubject" column="investment_subject" jdbcType="VARCHAR"/>
<result property="enterpriseHighlights" column="enterprise_highlights" jdbcType="VARCHAR"/>
<result property="continuousRevenue" column="continuous_revenue" jdbcType="VARCHAR"/>
<result property="industrialBase" column="industrial_base" jdbcType="VARCHAR"/>
<result property="constructionContent" column="construction_content" jdbcType="VARCHAR"/>
<result property="projectInvestmentTotal" column="project_investment_total" jdbcType="VARCHAR"/>
<result property="projectInvestmentRegular" column="project_investment_regular" jdbcType="VARCHAR"/>
<result property="projectAppeal" column="project_appeal" jdbcType="VARCHAR"/>
<result property="intendedRegion" column="intended_region" jdbcType="VARCHAR"/>
<result property="regionCommissionRate" column="region_commission_rate" jdbcType="VARCHAR"/>
<result property="carrierType" column="carrier_type" jdbcType="VARCHAR"/>
<result property="carrierRequirementsLandDemand" column="carrier_requirements_land_demand" jdbcType="VARCHAR"/>
<result property="carrierRequirementsFactoryDemand" column="carrier_requirements_factory_demand" jdbcType="VARCHAR"/>
<result property="decisionMaker" column="decision_maker" jdbcType="VARCHAR"/>
<result property="decisonMakerPosition" column="decison_maker_position" jdbcType="VARCHAR"/>
<result property="status" column="status" jdbcType="TINYINT"/>
<result property="statusDescription" column="status_description" jdbcType="VARCHAR"/>
<result property="partnerId" column="partner_id" jdbcType="INTEGER"/>
<result property="partnerHasConfirm" column="partner_has_confirm" jdbcType="TINYINT"/>
<result property="investmentPromotionCompany" column="investment_promotion_company" jdbcType="VARCHAR"/>
<result property="tenantId" column="tenant_id" jdbcType="INTEGER"/>
<result property="secretaryId" column="secretary_id" jdbcType="INTEGER"/>
<result property="createTime" column="create_time" jdbcType="TIMESTAMP"/>
<result property="updateTime" column="update_time" jdbcType="TIMESTAMP"/>
<result property="todoStatus" column="todo_status" jdbcType="TINYINT"/>
</resultMap>
<sql id="Base_Column_List">
id,investment_subject,enterprise_highlights,
continuous_revenue,industrial_base,construction_content,
project_investment_total,project_investment_regular,project_appeal,
intended_region,region_commission_rate,carrier_type,carrier_requirements_land_demand,
carrier_requirements_factory_demand,decision_maker,decison_maker_position,
status,status_description,partner_id,
partner_has_confirm,investment_promotion_company,tenant_id,
secretary_id,create_time,update_time,
todo_status
</sql>
<select id= "getLoginStatistics" parameterType="Integer" resultType="com.partner.admin.VO.HomePageLoginInfoVO">
-- 统计数-总项目量+总投资额+审核中的项目+推进中的项目
select sum(project_all_count) project_all_count,sum(project_investment_total) project_investment_total,
sum(project_examine_count) project_examine_count,sum(project_push_count) project_push_count
from (
select count(1) project_all_count,0 project_investment_total, 0 project_examine_count,0 project_push_count from partner_project_info
where partner_id = #{userId}
union all
select 0 project_all_count,sum(project_investment_total) project_investment_total, 0 project_examine_count,0 project_push_count from partner_project_info where partner_id = #{userId}
union all
select 0 project_all_count,0 project_investment_total, count(1) project_examine_count,0 project_push_count from partner_project_info
where status in (1,2,3,4,5,6,7,8) and partner_id = #{userId}
union all
select 0 project_all_count,0 project_investment_total, 0 project_examine_count, count(1) project_push_count from partner_project_info
where status in (9,10,11,12,13,14) and partner_id = #{userId}
) A
</select>
<select id= "getLogoutStatistics" resultType="com.partner.admin.VO.HomePageLogoutInfoVO">
select sum(project_all_count) project_all_count,sum(project_investment_total) project_investment_total,
sum(project_investment_regular) project_investment_regular,sum(partner_count) partner_count
from (
select count(1) project_all_count,0 project_investment_total, 0 project_investment_regular,0 partner_count from partner_project_info
union all
select 0 project_all_count,sum(project_investment_total) project_investment_total, 0 project_investment_regular,0 partner_count from partner_project_info
union all
select 0 project_all_count,0 project_investment_total, sum(project_investment_regular) project_investment_regular,0 partner_count from partner_project_info
union all
select 0 project_all_count,0 project_investment_total, 0 project_investment_regular, count(1) partner_count from sys_user
-- 本意只使用合伙人平台的数据,但是鉴于数据为空,暂时不好看,暂时借用产业知道的数据,下面的以后会删除
union all
select count(1) project_all_count,0 project_investment_total, 0 project_investment_regular,0 partner_count from project_info
union all
select 0 project_all_count,sum(invest_amount) project_investment_total, 0 project_investment_regular,0 partner_count from project_info
union all
select 0 project_all_count,0 project_investment_total, sum(fix_asset_invest_amount) project_investment_regular,0 partner_count from project_info
union all
select 0 project_all_count,0 project_investment_total, 0 project_investment_regular,count(1) partner_count from user_info
) A
</select>
</mapper>
<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE mapper
PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN"
"http://mybatis.org/dtd/mybatis-3-mapper.dtd">
<mapper namespace="com.partner.admin.mapper.PartnerProjectStatusChangeLogMapper">
<resultMap id="BaseResultMap" type="com.partner.admin.domain.PartnerProjectStatusChangeLog">
<id property="id" column="id" jdbcType="INTEGER"/>
<result property="createTime" column="create_time" jdbcType="TIMESTAMP"/>
<result property="updateTime" column="update_time" jdbcType="TIMESTAMP"/>
<result property="projectStatus" column="project_status" jdbcType="TINYINT"/>
<result property="projectStatusDisplay" column="project_status_display" jdbcType="VARCHAR"/>
<result property="projectId" column="project_id" jdbcType="INTEGER"/>
<result property="operaterId" column="operater_id" jdbcType="INTEGER"/>
<result property="tenantId" column="tenant_id" jdbcType="INTEGER"/>
<result property="description" column="description" jdbcType="VARCHAR"/>
</resultMap>
<sql id="Base_Column_List">
id,create_time,update_time,
project_status,project_status_display,project_id,
operater_id,tenant_id,description
</sql>
</mapper>
<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE mapper
PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN"
"http://mybatis.org/dtd/mybatis-3-mapper.dtd">
<mapper namespace="com.partner.admin.mapper.PartnerSecretaryMapper">
<resultMap id="BaseResultMap" type="com.partner.admin.domain.PartnerSecretary">
<id property="id" column="id" jdbcType="INTEGER"/>
<result property="createTime" column="create_time" jdbcType="TIMESTAMP"/>
<result property="updateTime" column="update_time" jdbcType="TIMESTAMP"/>
<result property="name" column="name" jdbcType="VARCHAR"/>
<result property="headerUrl" column="header_url" jdbcType="VARCHAR"/>
<result property="telephone" column="telephone" jdbcType="VARCHAR"/>
<result property="wxImageurl" column="wx_imageurl" jdbcType="VARCHAR"/>
<result property="successProjectNumber" column="success_project_number" jdbcType="INTEGER"/>
<result property="currentServiceProjectNumber" column="current_service_project_number" jdbcType="INTEGER"/>
</resultMap>
<sql id="Base_Column_List">
id,create_time,update_time,
name,header_url,telephone,
wx_imageurl,success_project_number,current_service_project_number
</sql>
</mapper>
<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE mapper
PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN"
"http://mybatis.org/dtd/mybatis-3-mapper.dtd">
<mapper namespace="com.partner.admin.mapper.PartnerTanentInfoMapper">
<resultMap id="BaseResultMap" type="com.partner.admin.domain.PartnerTanentInfo">
<id property="id" column="id" jdbcType="INTEGER"/>
<result property="tenantName" column="tenant_name" jdbcType="VARCHAR"/>
<result property="status" column="status" jdbcType="VARCHAR"/>
<result property="createTime" column="create_time" jdbcType="TIMESTAMP"/>
<result property="updateTime" column="update_time" jdbcType="TIMESTAMP"/>
</resultMap>
<sql id="Base_Column_List">
id,tenant_name,status,
create_time,update_time
</sql>
</mapper>
<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE mapper
PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN"
"http://mybatis.org/dtd/mybatis-3-mapper.dtd">
<mapper namespace="com.partner.admin.mapper.SysUserMapper">
<resultMap id="BaseResultMap" type="com.partner.admin.domain.SysUser">
<id property="userId" column="user_id" jdbcType="INTEGER"/>
<result property="deptId" column="dept_id" jdbcType="INTEGER"/>
<result property="loginName" column="login_name" jdbcType="VARCHAR"/>
<result property="userName" column="user_name" jdbcType="VARCHAR"/>
<result property="userType" column="user_type" jdbcType="VARCHAR"/>
<result property="email" column="email" jdbcType="VARCHAR"/>
<result property="phonenumber" column="phonenumber" jdbcType="VARCHAR"/>
<result property="sex" column="sex" jdbcType="CHAR"/>
<result property="avatar" column="avatar" jdbcType="VARCHAR"/>
<result property="password" column="password" jdbcType="VARCHAR"/>
<result property="salt" column="salt" jdbcType="VARCHAR"/>
<result property="status" column="status" jdbcType="CHAR"/>
<result property="delFlag" column="del_flag" jdbcType="CHAR"/>
<result property="loginIp" column="login_ip" jdbcType="VARCHAR"/>
<result property="loginDate" column="login_date" jdbcType="TIMESTAMP"/>
<result property="pwdUpdateDate" column="pwd_update_date" jdbcType="TIMESTAMP"/>
<result property="createBy" column="create_by" jdbcType="VARCHAR"/>
<result property="createTime" column="create_time" jdbcType="TIMESTAMP"/>
<result property="updateBy" column="update_by" jdbcType="VARCHAR"/>
<result property="updateTime" column="update_time" jdbcType="TIMESTAMP"/>
<result property="remark" column="remark" jdbcType="VARCHAR"/>
<result property="source" column="source" jdbcType="TINYINT"/>
</resultMap>
<sql id="Base_Column_List">
user_id,dept_id,login_name,
user_name,user_type,email,
phonenumber,sex,avatar,
password,salt,status,
del_flag,login_ip,login_date,
pwd_update_date,create_by,create_time,
update_by,update_time,remark,
source
</sql>
</mapper>
<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE mapper
PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN"
"http://mybatis.org/dtd/mybatis-3-mapper.dtd">
<mapper namespace="com.partner.admin.mapper.TokenMapper">
<resultMap id="BaseResultMap" type="com.partner.admin.domain.Token">
<id property="id" column="id" jdbcType="INTEGER"/>
<result property="userInfoId" column="user_info_id" jdbcType="INTEGER"/>
<result property="userId" column="user_id" jdbcType="VARCHAR"/>
<result property="userNameEn" column="user_name_en" jdbcType="VARCHAR"/>
<result property="token" column="token" jdbcType="VARCHAR"/>
<result property="expireTime" column="expire_time" jdbcType="TIMESTAMP"/>
<result property="tokenType" column="token_type" jdbcType="TINYINT"/>
<result property="createTime" column="create_time" jdbcType="TIMESTAMP"/>
<result property="updateTime" column="update_time" jdbcType="TIMESTAMP"/>
</resultMap>
<sql id="Base_Column_List">
id,user_info_id,user_id,
user_name_en,token,expire_time,
token_type,create_time,update_time
</sql>
</mapper>
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