Commit 3b8c08a5 authored by zhoumaotao's avatar zhoumaotao

代码调整

parent c27c39c4

Too many changes to show.

To preserve performance only 1000 of 1000+ files are displayed.

This source diff could not be displayed because it is too large. You can view the blob instead.
# JDCLOUD # datasync
京东同步代码 京东订单接口调用
\ No newline at end of file \ No newline at end of file
# datasync
京东订单接口调用
\ No newline at end of file
<?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 http://maven.apache.org/maven-v4_0_0.xsd">
<modelVersion>4.0.0</modelVersion>
<groupId>com.gavel.dasyncweb</groupId>
<artifactId>dasyncweb</artifactId>
<packaging>pom</packaging>
<version>1.0</version>
<modules>
<module>gavel-local</module>
<module>gavel-datasync</module>
</modules>
</project>
<?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 http://maven.apache.org/xsd/maven-4.0.0.xsd">
<modelVersion>4.0.0</modelVersion>
<groupId>com.gavel.jdcloud</groupId>
<artifactId>jdcloud</artifactId>
<version>1.0.0</version>
<packaging>war</packaging>
<name>gavel</name>
<description>京苏电子商务ERP系统</description>
<parent>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-parent</artifactId>
<version>2.1.3.RELEASE</version>
<relativePath/>
</parent>
<properties>
<project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
<project.reporting.outputEncoding>UTF-8</project.reporting.outputEncoding>
<java.version>1.8</java.version>
<pom.package>war</pom.package>
<pom.packageName>gavel</pom.packageName>
</properties>
<dependencies>
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-web</artifactId>
<exclusions>
<exclusion>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-tomcat</artifactId>
</exclusion>
</exclusions>
</dependency>
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-thymeleaf</artifactId>
</dependency>
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-jdbc</artifactId>
</dependency>
<dependency>
<groupId>org.webjars</groupId>
<artifactId>webjars-locator</artifactId>
<version>0.32-1</version>
</dependency>
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-test</artifactId>
<scope>test</scope>
</dependency>
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-data-redis</artifactId>
</dependency>
<dependency>
<groupId>org.mybatis.spring.boot</groupId>
<artifactId>mybatis-spring-boot-starter</artifactId>
<version>1.3.2</version>
</dependency>
<dependency>
<groupId>javax.servlet</groupId>
<artifactId>javax.servlet-api</artifactId>
</dependency>
<dependency>
<groupId>com.gavel.platform</groupId>
<artifactId>gavel-persistence</artifactId>
<version>1.0.0</version>
</dependency>
<dependency>
<groupId>com.gavel.platform</groupId>
<artifactId>gavel-common</artifactId>
<version>1.0.0</version>
</dependency>
<dependency>
<groupId>com.gavel.platform</groupId>
<artifactId>gavel-kzzx</artifactId>
<version>1.0.0</version>
</dependency>
<dependency>
<groupId>com.gavel.platform</groupId>
<artifactId>gavel-framework</artifactId>
<version>1.0.0</version>
</dependency>
<dependency>
<groupId>com.gavel.platform</groupId>
<artifactId>gavel-timer</artifactId>
<version>1.0.0</version>
</dependency>
<dependency>
<groupId>commons-fileupload</groupId>
<artifactId>commons-fileupload</artifactId>
<version>1.3.1</version>
</dependency>
<dependency>
<groupId>com.jd</groupId>
<artifactId>open-api-sdk</artifactId>
<version>1.0.0</version>
</dependency>
<dependency>
<groupId>com.google.code.gson</groupId>
<artifactId>gson</artifactId>
<version>2.8.5</version>
</dependency>
<dependency>
<groupId>org.codehaus.jackson</groupId>
<artifactId>jackson-mapper-asl</artifactId>
<version>1.9.2</version>
</dependency>
<dependency>
<groupId>org.codehaus.jackson</groupId>
<artifactId>jackson-core-asl</artifactId>
<version>1.9.2</version>
</dependency>
<dependency>
<groupId>org.apache.httpcomponents</groupId>
<artifactId>httpclient</artifactId>
<version>4.5.8</version>
</dependency>
</dependencies>
<profiles>
<profile>
<!-- 开发环境 -->
<id>jar</id>
<activation>
<activeByDefault>true</activeByDefault>
</activation>
<properties>
<pom.package>jar</pom.package>
<pom.packageName>${project.artifactId}-${project.version}</pom.packageName>
<pom.profiles.active>dev</pom.profiles.active>
</properties>
<dependencies>
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-tomcat</artifactId>
</dependency>
</dependencies>
</profile>
<profile>
<id>war</id>
<properties>
<pom.package>war</pom.package>
<pom.packageName>${project.artifactId}</pom.packageName>
<pom.profiles.active>linux</pom.profiles.active>
</properties>
<dependencies>
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-tomcat</artifactId>
<scope>provided</scope>
</dependency>
</dependencies>
</profile>
</profiles>
<build>
<finalName>erp</finalName>
<resources>
<resource>
<directory>src/main/java</directory>
<includes>
<include>**/*.xml</include>
</includes>
<filtering>false</filtering>
</resource>
<resource>
<directory>src/main/resources</directory>
<includes>
<include>**/*</include>
</includes>
<filtering>false</filtering>
</resource>
</resources>
<plugins>
<plugin>
<groupId>org.apache.maven.plugins</groupId>
<artifactId>maven-compiler-plugin</artifactId>
<configuration>
<source>1.8</source>
<target>1.8</target>
<encoding>utf-8</encoding>
</configuration>
</plugin>
</plugins>
</build>
</project>
package com.gavel.jingsu;
import org.mybatis.spring.annotation.MapperScan;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.boot.builder.SpringApplicationBuilder;
import org.springframework.boot.web.servlet.support.SpringBootServletInitializer;
import org.springframework.context.annotation.ComponentScan;
import org.springframework.context.annotation.Profile;
@SpringBootApplication
@ComponentScan("com.gavel.*")
@MapperScan("com.gavel.**.mapper")
public class GavelApplication extends SpringBootServletInitializer {
public static void main(String[] args) {
SpringApplication.run(GavelApplication.class, args);
}
@Profile(value = { "war" })
@Override
protected SpringApplicationBuilder configure(SpringApplicationBuilder application) {
return application.sources(GavelApplication.class);
}
}
package com.gavel.jingsu.config;
import com.gavel.framework.cache.GavelCacheManager;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.boot.CommandLineRunner;
import org.springframework.cache.annotation.EnableCaching;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Conditional;
import org.springframework.context.annotation.Configuration;
import org.springframework.context.annotation.PropertySource;
import org.springframework.core.annotation.Order;
import org.springframework.data.redis.cache.RedisCacheConfiguration;
import org.springframework.data.redis.cache.RedisCacheManager;
import org.springframework.data.redis.cache.RedisCacheWriter;
import org.springframework.data.redis.connection.RedisConnectionFactory;
import org.springframework.data.redis.serializer.GenericJackson2JsonRedisSerializer;
import org.springframework.data.redis.serializer.RedisSerializationContext;
import org.springframework.data.redis.serializer.StringRedisSerializer;
import org.springframework.stereotype.Component;
import java.time.Duration;
@Conditional(CacheEnableCondition.class)
@EnableCaching
@PropertySource(value = "classpath:config.properties")
@Configuration
public class CacheConfig {
@Value("${spring.cache.ttl:240}")
private long ttl;
@Bean
public RedisCacheManager cacheManager(RedisConnectionFactory redisConnectionFactory){
//缓存配置对象
RedisCacheConfiguration redisCacheConfiguration = RedisCacheConfiguration.defaultCacheConfig();
redisCacheConfiguration = redisCacheConfiguration.entryTtl(Duration.ofMinutes(ttl)) //设置缓存的默认超时时间:30分钟
.disableCachingNullValues() //如果是空值,不缓存
.serializeKeysWith(RedisSerializationContext.SerializationPair.fromSerializer(new StringRedisSerializer())) //设置key序列化器
.serializeValuesWith(RedisSerializationContext.SerializationPair.fromSerializer((new GenericJackson2JsonRedisSerializer()))); //设置value序列化器
return RedisCacheManager
.builder(RedisCacheWriter.nonLockingRedisCacheWriter(redisConnectionFactory))
.cacheDefaults(redisCacheConfiguration).build();
}
@Component
@Order(1)
public class GavelCacheManagerInitRunner implements CommandLineRunner {
@Autowired
private GavelCacheManager cacheManager;
@Override
public void run(String... args) throws Exception {
cacheManager.init();
}
}
}
package com.gavel.jingsu.config;
import com.gavel.common.utils.PropertiesUtil;
import com.gavel.common.utils.StringUtils;
import org.springframework.context.annotation.Condition;
import org.springframework.context.annotation.ConditionContext;
import org.springframework.core.type.AnnotatedTypeMetadata;
public class CacheEnableCondition implements Condition{
@Override
public boolean matches(ConditionContext context, AnnotatedTypeMetadata metadata) {
//判断是否在Linux环境下运行程序
return StringUtils.equalsIgnoreCase("true", PropertiesUtil.readProperty("config.properties", "spring.cache.enable"));
}
}
package com.gavel.jingsu.config;
import com.alibaba.druid.pool.DruidDataSource;
import com.alibaba.druid.support.http.StatViewServlet;
import com.alibaba.druid.support.http.WebStatFilter;
import com.gavel.common.utils.StringUtils;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.boot.context.properties.ConfigurationProperties;
import org.springframework.boot.web.servlet.FilterRegistrationBean;
import org.springframework.boot.web.servlet.ServletRegistrationBean;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.context.annotation.PropertySource;
import javax.sql.DataSource;
@Configuration
@PropertySource(value = "classpath:jdbc.properties")
public class DataSourceConfig {
@Value("${druid.allow:}")
private String druidAllow;
@Value("${druid.deny:}")
private String druidDeny;
@Value("${druid.username:}")
private String druidUserName;
@Value("${druid.password:}")
private String druidPassword;
@Bean(destroyMethod = "close", initMethod = "init")
@ConfigurationProperties(prefix = "spring.datasource")
public DataSource druidDataSource() {
DruidDataSource druidDataSource = new DruidDataSource();
return druidDataSource;
}
/**
* 注册一个StatViewServlet
*
* @return
*/
@SuppressWarnings({ "rawtypes", "unchecked" })
@Bean
public ServletRegistrationBean druidStatViewServlet() {
ServletRegistrationBean servletRegistrationBean = new ServletRegistrationBean(new StatViewServlet(),
"/druid/*");
// 白名单:
if (StringUtils.isNotEmpty(druidAllow)) {
servletRegistrationBean.addInitParameter("allow", druidAllow);
}
//IP黑名单 (存在共同时,deny优先于allow)
if (StringUtils.isNotEmpty(druidDeny)) {
servletRegistrationBean.addInitParameter("deny", druidDeny);
}
//用户名
if (StringUtils.isNotEmpty(druidUserName)) {
servletRegistrationBean.addInitParameter("loginUsername", druidUserName);
}
//密码
if (StringUtils.isNotEmpty(druidPassword)) {
servletRegistrationBean.addInitParameter("loginPassword", druidPassword);
}
// 是否能够重置数据.
servletRegistrationBean.addInitParameter("resetEnable", "false");
return servletRegistrationBean;
}
/**
* 注册一个:filterRegistrationBean
*
* @return
*/
@SuppressWarnings({ "unchecked", "rawtypes" })
@Bean
public FilterRegistrationBean druidStatFilter() {
FilterRegistrationBean filterRegistrationBean = new FilterRegistrationBean(new WebStatFilter());
// 添加过滤规则.
filterRegistrationBean.addUrlPatterns("/*");
// 添加不需要忽略的格式信息.
filterRegistrationBean.addInitParameter("exclusions", "*.js,*.gif,*.jpg,*.png,*.css,*.ico,/druid/*");
return filterRegistrationBean;
}
}
package com.gavel.jingsu.config;
import com.gavel.framework.filter.AuthenticationFilter;
import com.gavel.framework.filter.RequestWrapperFilter;
import com.gavel.framework.filter.ThreadContextFilter;
import org.springframework.boot.web.servlet.FilterRegistrationBean;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.web.filter.CharacterEncodingFilter;
import java.util.Arrays;
@Configuration
public class FilterConfig {
@Bean
public CharacterEncodingFilter characterEncodingFilter() {
CharacterEncodingFilter filter = new CharacterEncodingFilter();
filter.setEncoding("UTF-8");
filter.setForceEncoding(true);
return filter;
}
@SuppressWarnings({ "rawtypes", "unchecked" })
@Bean
public FilterRegistrationBean authenticationFilter() {
// 用户认证
AuthenticationFilter authenticationFilter = new AuthenticationFilter();
FilterRegistrationBean registrationBean = new FilterRegistrationBean();
registrationBean.setName("authenticationFilter"); // 过滤器名称
registrationBean.setFilter(authenticationFilter); // 注入过滤器
registrationBean.setOrder(10);
registrationBean.addInitParameter("prefix", "/css,/js,/images,/lib,/fonts,/mock");
registrationBean.setUrlPatterns(Arrays.asList("/*")); //拦截规则
return registrationBean;
}
@SuppressWarnings({ "rawtypes", "unchecked" })
@Bean
public FilterRegistrationBean requestWrapperFilter() {
RequestWrapperFilter requestWrapperFilter = new RequestWrapperFilter();
FilterRegistrationBean registrationBean = new FilterRegistrationBean();
registrationBean.setName("requestWrapperFilter"); // 过滤器名称
registrationBean.setFilter(requestWrapperFilter); // 注入过滤器
registrationBean.setOrder(30); //过滤器顺序
registrationBean.setUrlPatterns(Arrays.asList("/*")); //拦截规则
return registrationBean;
}
@SuppressWarnings({ "rawtypes", "unchecked" })
@Bean
public FilterRegistrationBean threadContextFilter() {
ThreadContextFilter threadContextFilter = new ThreadContextFilter();
FilterRegistrationBean registrationBean = new FilterRegistrationBean();
registrationBean.setName("threadContextFilter"); // 过滤器名称
registrationBean.setFilter(threadContextFilter); // 注入过滤器
registrationBean.setOrder(40); //过滤器顺序
registrationBean.setUrlPatterns(Arrays.asList("/*")); //拦截规则
return registrationBean;
}
}
package com.gavel.jingsu.config;
import com.gavel.timer.scheduler.TimerJobFactory;
import com.gavel.timer.scheduler.TimerJobInit;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.CommandLineRunner;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.core.annotation.Order;
import org.springframework.scheduling.quartz.SchedulerFactoryBean;
import org.springframework.stereotype.Component;
@Configuration
public class InitConfig {
@Autowired
private TimerJobFactory timerJobFactory;
@Component
@Order(2) //通过order值的大小来决定启动的顺序
public class TimerJobInitRunner implements CommandLineRunner {
@Autowired
private TimerJobInit timerJobInit;
@Override
public void run(String... args) throws Exception {
timerJobInit.init();
}
}
//配置定时任务
@Bean("timerJobInit")
public TimerJobInit timerJobInitBean() {
TimerJobInit bean = new TimerJobInit();
return bean;
}
@Bean("timerJobFactory")
@Order(0)
public TimerJobFactory timerJobFactory() {
TimerJobFactory bean = new TimerJobFactory();
return bean;
}
@Bean("schedulerFactoryBean")
@Order(1)
public SchedulerFactoryBean schedulerFactoryBean() {
SchedulerFactoryBean bean = new SchedulerFactoryBean();
bean.setJobFactory(timerJobFactory);
bean.setWaitForJobsToCompleteOnShutdown(true);
bean.setStartupDelay(1);
return bean;
}
}
package com.gavel.jingsu.config;
import com.fasterxml.jackson.annotation.JsonAutoDetect;
import com.fasterxml.jackson.annotation.PropertyAccessor;
import com.fasterxml.jackson.databind.ObjectMapper;
import org.apache.commons.pool2.impl.GenericObjectPoolConfig;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.boot.autoconfigure.data.redis.RedisProperties;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.context.annotation.Primary;
import org.springframework.context.annotation.PropertySource;
import org.springframework.data.redis.connection.RedisPassword;
import org.springframework.data.redis.connection.RedisStandaloneConfiguration;
import org.springframework.data.redis.connection.lettuce.LettuceClientConfiguration;
import org.springframework.data.redis.connection.lettuce.LettuceConnectionFactory;
import org.springframework.data.redis.connection.lettuce.LettucePoolingClientConfiguration;
import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.data.redis.serializer.GenericJackson2JsonRedisSerializer;
import org.springframework.data.redis.serializer.Jackson2JsonRedisSerializer;
import org.springframework.data.redis.serializer.StringRedisSerializer;
import java.time.Duration;
@Configuration
@PropertySource(value = {"classpath:config.properties"})
public class RedisConfig {
@Autowired
private RedisProperties redisProperties;
@Value("${redis.username:}")
private String username;
@Value("${redis.password:}")
private String password;
@Value("${redis.host:localhost}")
private String host;
@Value("${redis.port:6379}")
private int port;
@Value("${redis.database:0}")
private Integer database;
//最大空闲数
@Value("${redis.pool.maxIdle:20}")
private int maxIdle;
//控制一个pool可分配多少个jedis实例,用来替换上面的maxActive
@Value("${redis.pool.maxTotal:100}")
private int maxTotal;
//连接池的最大数据库连接数
@Value("${redis.pool.maxActive:-1}")
private int maxActive;
//最大建立连接等待时间。如果超过此时间将接到异常
@Value("${redis.pool.maxWaitMillis:1000}")
private long maxWaitMillis;
//逐出连接的最小空闲时间 默认1800000毫秒(30分钟)
@Value("${redis.pool.minEvictableIdleTimeMillis:1800000}")
private Long minEvictableIdleTimeMillis;
//每次释放连接的最大数目
@Value("${redis.pool.numTestsPerEvictionRun:3}")
private Integer numTestsPerEvictionRun;
//逐出扫描的时间间隔(毫秒) 如果为负数,则不运行逐出线程
@Value("${redis.pool.timeBetweenEvictionRunsMillis:-1}")
private Long timeBetweenEvictionRunsMillis;
//是否在从池中取出连接前进行检验,如果检验失败,则从池中去除连接并尝试取出另一个
@Value("${redis.pool.testOnBorrow:true}")
private boolean testOnBorrow;
//在空闲时检查有效性
@Value("${spring.redis.testWhileIdle:false}")
private boolean testWhileIdle;
public String getUsername() {
return username;
}
public void setUsername(String username) {
this.username = username;
}
public String getPassword() {
return password;
}
public void setPassword(String password) {
this.password = password;
}
public String getHost() {
return host;
}
public void setHost(String host) {
this.host = host;
}
public int getPort() {
return port;
}
public void setPort(int port) {
this.port = port;
}
public Integer getDatabase() {
return database;
}
public void setDatabase(Integer database) {
this.database = database;
}
public int getMaxIdle() {
return maxIdle;
}
public void setMaxIdle(int maxIdle) {
this.maxIdle = maxIdle;
}
public int getMaxTotal() {
return maxTotal;
}
public void setMaxTotal(int maxTotal) {
this.maxTotal = maxTotal;
}
public int getMaxActive() {
return maxActive;
}
public void setMaxActive(int maxActive) {
this.maxActive = maxActive;
}
public long getMaxWaitMillis() {
return maxWaitMillis;
}
public void setMaxWaitMillis(long maxWaitMillis) {
this.maxWaitMillis = maxWaitMillis;
}
public Long getMinEvictableIdleTimeMillis() {
return minEvictableIdleTimeMillis;
}
public void setMinEvictableIdleTimeMillis(Long minEvictableIdleTimeMillis) {
this.minEvictableIdleTimeMillis = minEvictableIdleTimeMillis;
}
public Integer getNumTestsPerEvictionRun() {
return numTestsPerEvictionRun;
}
public void setNumTestsPerEvictionRun(Integer numTestsPerEvictionRun) {
this.numTestsPerEvictionRun = numTestsPerEvictionRun;
}
public Long getTimeBetweenEvictionRunsMillis() {
return timeBetweenEvictionRunsMillis;
}
public void setTimeBetweenEvictionRunsMillis(Long timeBetweenEvictionRunsMillis) {
this.timeBetweenEvictionRunsMillis = timeBetweenEvictionRunsMillis;
}
public boolean isTestOnBorrow() {
return testOnBorrow;
}
public void setTestOnBorrow(boolean testOnBorrow) {
this.testOnBorrow = testOnBorrow;
}
public boolean isTestWhileIdle() {
return testWhileIdle;
}
public void setTestWhileIdle(boolean testWhileIdle) {
this.testWhileIdle = testWhileIdle;
}
private LettuceClientConfiguration lettuceClientConfiguration(){
LettucePoolingClientConfiguration.LettucePoolingClientConfigurationBuilder builder = LettucePoolingClientConfiguration.builder();
builder.poolConfig(genericObjectPoolConfig());
if (this.redisProperties.isSsl()) {
builder.useSsl();
}
if (this.redisProperties.getTimeout() != null) {
Duration timeout = this.redisProperties.getTimeout();
builder.commandTimeout(timeout).shutdownTimeout(timeout);
}
builder.poolConfig(genericObjectPoolConfig());
return builder.build();
}
/**
* GenericObjectPoolConfig 连接池
* @return
*/
@Bean("genericObjectPoolConfig")
public GenericObjectPoolConfig<?> genericObjectPoolConfig() {
//连接池配置
GenericObjectPoolConfig<?> genericObjectPoolConfig = new GenericObjectPoolConfig<>();
// 最大空闲数
genericObjectPoolConfig.setMaxIdle(maxIdle);
// 连接池的最大数据库连接数
genericObjectPoolConfig.setMaxTotal(maxTotal);
// 最大建立连接等待时间
genericObjectPoolConfig.setMaxWaitMillis(maxWaitMillis);
// 逐出连接的最小空闲时间 默认1800000毫秒(30分钟)
genericObjectPoolConfig.setMinEvictableIdleTimeMillis(minEvictableIdleTimeMillis);
// 每次逐出检查时 逐出的最大数目 如果为负数就是 : 1/abs(n), 默认3
genericObjectPoolConfig.setNumTestsPerEvictionRun(numTestsPerEvictionRun);
// 逐出扫描的时间间隔(毫秒) 如果为负数,则不运行逐出线程, 默认-1
genericObjectPoolConfig.setTimeBetweenEvictionRunsMillis(timeBetweenEvictionRunsMillis);
// 是否在从池中取出连接前进行检验,如果检验失败,则从池中去除连接并尝试取出另一个
genericObjectPoolConfig.setTestOnBorrow(testOnBorrow);
// 在空闲时检查有效性, 默认false
genericObjectPoolConfig.setTestWhileIdle(testWhileIdle);
return genericObjectPoolConfig;
}
/**
* jedis连接工厂
* @return
*/
@Primary
@Bean("lettuceConnectionFactory")
public LettuceConnectionFactory lettuceConnectionFactory() {
RedisStandaloneConfiguration redisStandaloneConfiguration = new RedisStandaloneConfiguration();
//设置redis服务器的host或者ip地址
redisStandaloneConfiguration.setHostName(host);
redisStandaloneConfiguration.setPort(port);
redisStandaloneConfiguration.setPassword(RedisPassword.of(password));
redisStandaloneConfiguration.setDatabase(database);
return new LettuceConnectionFactory(redisStandaloneConfiguration, lettuceClientConfiguration());
}
@Bean
public RedisTemplate<String, Object> redisTemplate() {
RedisTemplate<String, Object> template = new RedisTemplate<String, Object>();
template.setConnectionFactory(lettuceConnectionFactory());
Jackson2JsonRedisSerializer<Object> jackson2JsonRedisSerializer = new Jackson2JsonRedisSerializer<>(Object.class);
ObjectMapper om = new ObjectMapper();
om.setVisibility(PropertyAccessor.ALL, JsonAutoDetect.Visibility.ANY);
om.enableDefaultTyping(ObjectMapper.DefaultTyping.NON_FINAL);
jackson2JsonRedisSerializer.setObjectMapper(om);
StringRedisSerializer stringRedisSerializer = new StringRedisSerializer();
// key采用String的序列化方式
template.setKeySerializer(stringRedisSerializer);
// hash的key也采用String的序列化方式
template.setHashKeySerializer(stringRedisSerializer);
// value序列化方式采用jackson
template.setValueSerializer(new GenericJackson2JsonRedisSerializer());
// hash的value序列化方式采用jackson
template.setHashValueSerializer(new GenericJackson2JsonRedisSerializer());
template.afterPropertiesSet();
return template;
}
}
package com.gavel.jingsu.config;
import org.apache.http.conn.HttpClientConnectionManager;
import org.apache.http.impl.client.HttpClientBuilder;
import org.apache.http.impl.conn.PoolingHttpClientConnectionManager;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.http.client.HttpComponentsClientHttpRequestFactory;
import org.springframework.http.converter.StringHttpMessageConverter;
import org.springframework.web.client.RestTemplate;
import java.nio.charset.StandardCharsets;
@Configuration
public class RestTemplateConfig {
@Bean
public HttpClientConnectionManager poolingConnectionManager() {
PoolingHttpClientConnectionManager poolingConnectionManager = new PoolingHttpClientConnectionManager();
poolingConnectionManager.setMaxTotal(1000); // 连接池最大连接数
poolingConnectionManager.setDefaultMaxPerRoute(500); // 每个主机的并发
return poolingConnectionManager;
}
@Bean
public HttpClientBuilder httpClientBuilder() {
HttpClientBuilder httpClientBuilder = HttpClientBuilder.create();
//设置HTTP连接管理器
httpClientBuilder.setConnectionManager(poolingConnectionManager());
return httpClientBuilder;
}
@Bean("restTemplate")
public RestTemplate restTemplate(){
HttpComponentsClientHttpRequestFactory httpRequestFactory = new HttpComponentsClientHttpRequestFactory();
httpRequestFactory.setHttpClient(httpClientBuilder().build());
httpRequestFactory.setConnectionRequestTimeout(3000);//获取链接超时时间
httpRequestFactory.setConnectTimeout(3000);//指客户端和服务器建立连接的timeout
httpRequestFactory.setReadTimeout(120000);//读取数据的超时时间
RestTemplate restTemplate=new RestTemplate(httpRequestFactory);
restTemplate.getMessageConverters().set(1, new StringHttpMessageConverter(StandardCharsets.UTF_8));
return restTemplate;
}
}
package com.gavel.jingsu.config;
import com.gavel.kzzx.auth.shiro.GavelAuthResource;
import com.gavel.kzzx.auth.shiro.GavelAuthorizationAttributeSourceAdvisor;
import com.gavel.kzzx.auth.shiro.GavelAuthorizingRealm;
import com.gavel.kzzx.auth.shiro.GavelHashedCredentialsMatcher;
import org.apache.shiro.cache.CacheManager;
import org.apache.shiro.cache.MemoryConstrainedCacheManager;
import org.apache.shiro.mgt.SecurityManager;
import org.apache.shiro.spring.web.ShiroFilterFactoryBean;
import org.apache.shiro.web.mgt.DefaultWebSecurityManager;
import org.springframework.aop.framework.autoproxy.DefaultAdvisorAutoProxyCreator;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
@Configuration
public class ShiroConfig {
@Bean
public ShiroFilterFactoryBean shirFilter(SecurityManager securityManager) {
ShiroFilterFactoryBean shiroFilterFactoryBean = new ShiroFilterFactoryBean();
// 必须设置 SecurityManager
shiroFilterFactoryBean.setSecurityManager(securityManager);
// 设置login URL
shiroFilterFactoryBean.setLoginUrl("/login_view");
// 登录成功后要跳转的链接
shiroFilterFactoryBean.setSuccessUrl("/index");
shiroFilterFactoryBean.setFilterChainDefinitionMap(GavelAuthResource.init());
return shiroFilterFactoryBean;
}
/*
* 凭证匹配器 (由于我们的密码校验交给Shiro的SimpleAuthenticationInfo进行处理了
* 所以我们需要修改下doGetAuthenticationInfo中的代码; )
*/
@Bean
public GavelHashedCredentialsMatcher hashedCredentialsMatcher() {
GavelHashedCredentialsMatcher hashedCredentialsMatcher = new GavelHashedCredentialsMatcher();
hashedCredentialsMatcher.setHashAlgorithmName("md5");// 散列算法:这里使用MD5算法;
hashedCredentialsMatcher.setHashIterations(1);// 散列的次数,比如散列两次,相当于md5(md5(""));
return hashedCredentialsMatcher;
}
@Bean
public GavelAuthorizingRealm shiroRealm() {
GavelAuthorizingRealm shiroRealm = new GavelAuthorizingRealm();
shiroRealm.setCredentialsMatcher(hashedCredentialsMatcher());
return shiroRealm;
}
@Bean
public SecurityManager securityManager() {
DefaultWebSecurityManager securityManager = new DefaultWebSecurityManager();
// 注入自定义的realm;
securityManager.setRealm(shiroRealm());
// 注入缓存管理器;
securityManager.setCacheManager(cacheManager());
return securityManager;
}
/*
* 开启shiro aop注解支持 使用代理方式;所以需要开启代码支持;
*/
@Bean
public GavelAuthorizationAttributeSourceAdvisor authorizationAttributeSourceAdvisor(
SecurityManager securityManager) {
GavelAuthorizationAttributeSourceAdvisor authorizationAttributeSourceAdvisor = new GavelAuthorizationAttributeSourceAdvisor();
authorizationAttributeSourceAdvisor.setSecurityManager(securityManager);
return authorizationAttributeSourceAdvisor;
}
/**
* DefaultAdvisorAutoProxyCreator,Spring的一个bean,由Advisor决定对哪些类的方法进行AOP代理。
*/
@Bean
public DefaultAdvisorAutoProxyCreator defaultAdvisorAutoProxyCreator() {
DefaultAdvisorAutoProxyCreator defaultAAP = new DefaultAdvisorAutoProxyCreator();
defaultAAP.setProxyTargetClass(true);
return defaultAAP;
}
/*
* shiro缓存管理器;
* 需要注入对应的其它的实体类中-->安全管理器:securityManager可见securityManager是整个shiro的核心;
*/
@Bean
public CacheManager cacheManager() {
return new MemoryConstrainedCacheManager();
}
}
package com.gavel.jingsu.config;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.stereotype.Controller;
import springfox.documentation.builders.ApiInfoBuilder;
import springfox.documentation.builders.PathSelectors;
import springfox.documentation.builders.RequestHandlerSelectors;
import springfox.documentation.service.ApiInfo;
import springfox.documentation.service.Contact;
import springfox.documentation.spi.DocumentationType;
import springfox.documentation.spring.web.plugins.Docket;
import springfox.documentation.swagger2.annotations.EnableSwagger2;
@Configuration
@EnableSwagger2
public class SwaggerConfig {
@Value("${server.isEnableSwagger:false}")
private boolean isEnableSwagger;
@Bean
public Docket createApi() {
return new Docket(DocumentationType.SWAGGER_2)
.apiInfo(apiInfo())
.enable(isEnableSwagger)
.select()
.apis(RequestHandlerSelectors.withClassAnnotation(Controller.class))
.paths(PathSelectors.any())
.build();
}
private ApiInfo apiInfo()
{
return new ApiInfoBuilder()
.title("erp")
.description("restful API specification about the erp project")
.version("1.0.0")
.contact(new Contact("", "", ""))
.build();
}
}
package com.gavel.jingsu.config;
import com.gavel.common.Constants;
import com.gavel.common.config.ResourceConfig;
import com.gavel.common.converter.json.Fastjson2HttpMessageConverter;
import com.gavel.common.utils.StringUtils;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.boot.web.servlet.MultipartConfigFactory;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.context.annotation.PropertySource;
import org.springframework.http.MediaType;
import org.springframework.util.unit.DataSize;
import org.springframework.web.servlet.config.annotation.ResourceHandlerRegistry;
import org.springframework.web.servlet.config.annotation.WebMvcConfigurer;
import org.springframework.web.servlet.view.freemarker.FreeMarkerConfigurer;
import org.springframework.web.servlet.view.freemarker.FreeMarkerViewResolver;
import javax.servlet.MultipartConfigElement;
import java.util.ArrayList;
import java.util.List;
@Configuration
@PropertySource(value = {"classpath:config.properties"})
public class WebMvcConfig implements WebMvcConfigurer{
//缺省为10G
@Value("${multipart.max-file-size:10240MB}")
private String maxFileSize;
//缺省为10G
@Value("${multipart.max-request-size:10240MB}")
private String maxRequestSize;
// @Value("${file.staticRealPath:}")
// private String realPath;
@Autowired
private ResourceConfig resourceConfig;
//设置fastjson
@Bean
public Fastjson2HttpMessageConverter fastJsonHttpMessageConverter() {
Fastjson2HttpMessageConverter fastConverter = new Fastjson2HttpMessageConverter();
List<MediaType> fastMediaTypes = new ArrayList<MediaType>();
fastMediaTypes.add(MediaType.APPLICATION_JSON_UTF8);
fastConverter.setSupportedMediaTypes(fastMediaTypes);
return fastConverter;
}
@Override
public void addResourceHandlers(ResourceHandlerRegistry registry) {
registry.addResourceHandler("/**")
.addResourceLocations("classpath:/static/")
.addResourceLocations("classpath:/resource/")
.addResourceLocations("classpath:/META-INF/resources/")
.addResourceLocations("classpath:/public/")
.resourceChain(false);
registry.addResourceHandler("/**")
.addResourceLocations("classpath:/static/")
.addResourceLocations("classpath:/resource/")
.addResourceLocations("classpath:/META-INF/resources/")
.addResourceLocations("classpath:/public/")
.resourceChain(false);
registry.addResourceHandler("/views/**")
.addResourceLocations("classpath:/templates/views/")
.resourceChain(false);
//设置swagger页面
registry.addResourceHandler("/swagger-ui.html")
.addResourceLocations("classpath:/META-INF/resources/")
.resourceChain(false);
/**
* 设置用户静态资源
*/
if(StringUtils.isNotEmpty(resourceConfig.getStorePath())){
registry.addResourceHandler(Constants.RES_FILE_PATH)
.addResourceLocations("file:" + resourceConfig.getStorePath())
.resourceChain(false);
}
}
@Bean("freemarkerConfig")
public FreeMarkerConfigurer freeMarkerConfigurerBean() {
FreeMarkerConfigurer freeMarkerConfigurer = new FreeMarkerConfigurer();
freeMarkerConfigurer.setTemplateLoaderPaths("classpath:/templates/views/");
freeMarkerConfigurer.setDefaultEncoding("UTF-8");
return freeMarkerConfigurer;
}
//配置FreeMarker视图解析器
@Bean
public FreeMarkerViewResolver freeMarkerViewResolverHtml() {
FreeMarkerViewResolver resolver = new FreeMarkerViewResolver();
resolver.setCache(false);
resolver.setPrefix("");
resolver.setSuffix(".html");
resolver.setOrder(0);
resolver.setContentType("text/html;charset=UTF-8");
resolver.setExposeSessionAttributes(true);
resolver.setRequestContextAttribute("request");
return resolver;
}
//配置FreeMarker视图解析器
@Bean
public FreeMarkerViewResolver freeMarkerViewResolverFtl() {
FreeMarkerViewResolver resolver = new FreeMarkerViewResolver();
resolver.setCache(false);
resolver.setPrefix("");
resolver.setSuffix(".ftl");
resolver.setOrder(1);
resolver.setContentType("text/html;charset=UTF-8");
resolver.setExposeSessionAttributes(true);
resolver.setRequestContextAttribute("request");
return resolver;
}
//配置附件上传相关参数
@Bean
public MultipartConfigElement multipartConfigElement() {
MultipartConfigFactory factory = new MultipartConfigFactory();
factory.setMaxFileSize(DataSize.parse(maxFileSize));
factory.setMaxRequestSize(DataSize.parse(maxRequestSize));
return factory.createMultipartConfig();
}
}
package com.gavel.jingsu.dpgl.controller;
import com.gavel.common.BaseURL;
import com.gavel.common.base.BaseEditJSON;
import com.gavel.common.base.controller.BaseController;
import com.gavel.common.converter.DataConvert;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.RequestBody;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RequestMethod;
import org.springframework.web.bind.annotation.ResponseBody;
import com.gavel.persistence.sql.RecordSet;
import com.gavel.common.annotation.ResourcePermissions;
import com.gavel.common.SystemOperation;
import com.alibaba.fastjson.JSONObject;
import com.gavel.common.utils.ThreadContext;
import com.gavel.jingsu.dpgl.service.DpxxService;
import com.gavel.jingsu.dpgl.vo.DpxxCondition;
import com.gavel.jingsu.dpgl.vo.DpxxVO;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
@Controller
@RequestMapping("dpgl/dpxx")
public class DpxxController extends BaseController {
@Autowired
private DpxxService dpxxService;
@ResourcePermissions()
@RequestMapping("/index")
public String index() {
return "dpgl/dpxx/index";
}
@ResourcePermissions({SystemOperation.BottonResource.ADD})
@RequestMapping("/add")
public String add() {
return "dpgl/dpxx/edit";
}
@ResourcePermissions({SystemOperation.BottonResource.EDIT})
@RequestMapping("/edit")
public String edit() {
return "dpgl/dpxx/edit";
}
@RequestMapping(value = BaseURL.GET, method = RequestMethod.POST)
@ResponseBody
public Object get(@RequestBody JSONObject param) {
DpxxCondition condition = DataConvert.getCondition(param, DpxxCondition.class);
RecordSet<DpxxVO> records = dpxxService.query(condition);
if ( records.getRecords()!=null && records.getRecords().size()>=1 ){
return buildReturnData(DpxxVO.class, records.getRecords().get(0));
}
return buildReturnData(DpxxVO.class, null);
}
@RequestMapping(value = BaseURL.QUERY, method = RequestMethod.POST)
@ResponseBody
public Object query(@RequestBody JSONObject param) {
DpxxCondition condition = DataConvert.getCondition(param, DpxxCondition.class);
RecordSet<DpxxVO> records = dpxxService.query(condition);
return buildReturnData(records, DpxxVO.class);
}
@ResourcePermissions(SystemOperation.BottonResource.ADD)
@RequestMapping(value = BaseURL.ADD, method = RequestMethod.POST)
@ResponseBody
public Object insert(@RequestBody JSONObject param) {
BaseEditJSON editJson = BaseEditJSON.parseJSON(param);
dpxxService.insert(editJson);
return ThreadContext.getReturnData();
}
@ResourcePermissions(SystemOperation.BottonResource.EDIT)
@RequestMapping(value = BaseURL.UPDATE, method = RequestMethod.POST)
@ResponseBody
public Object update(@RequestBody JSONObject param) {
BaseEditJSON editJson = BaseEditJSON.parseJSON(param);
dpxxService.update(editJson);
return ThreadContext.getReturnData();
}
@ResourcePermissions(SystemOperation.BottonResource.DELETE)
@RequestMapping(value = BaseURL.DELETE, method = RequestMethod.POST)
@ResponseBody
public Object delete(@RequestBody JSONObject param) {
BaseEditJSON editJson = BaseEditJSON.parseJSON(param);
dpxxService.delete(editJson);
return ThreadContext.getReturnData();
}
@ResourcePermissions(SystemOperation.BottonResource.EXPORT)
@RequestMapping(value = BaseURL.EXPORT, method = RequestMethod.POST)
@ResponseBody
public void export(HttpServletRequest request,HttpServletResponse response, @RequestBody JSONObject param) throws Exception {
DpxxCondition condition = DataConvert.getCondition(param, DpxxCondition.class);
RecordSet<DpxxVO> records = dpxxService.query(condition);
doExport(request, response, param, records.getRecords());
}
@RequestMapping(value = "convert", method = RequestMethod.POST)
@ResponseBody
public Object convert(@RequestBody JSONObject param) throws Exception {
try {
dpxxService.convert(param);
} catch (Exception e) {
ThreadContext.getReturnData().setSuccess(false);
ThreadContext.getReturnData().setMessage(e.getMessage());
}
return ThreadContext.getReturnData();
}
}
package com.gavel.jingsu.dpgl.controller;
import com.alibaba.fastjson.JSONObject;
import com.gavel.common.BaseURL;
import com.gavel.common.SystemOperation;
import com.gavel.common.annotation.ResourcePermissions;
import com.gavel.common.base.BaseEditJSON;
import com.gavel.common.base.controller.BaseController;
import com.gavel.common.converter.DataConvert;
import com.gavel.common.utils.ThreadContext;
import com.gavel.jingsu.dpgl.service.JDUBrandService;
import com.gavel.jingsu.dpgl.service.UBrandService;
import com.gavel.jingsu.dpgl.utils.SourceEnum;
import com.gavel.jingsu.dpgl.vo.UBrandCondition;
import com.gavel.jingsu.dpgl.vo.UBrandVO;
import com.gavel.persistence.sql.RecordSet;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.RequestBody;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RequestMethod;
import org.springframework.web.bind.annotation.ResponseBody;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
@Controller
@RequestMapping("dpgl/jdubrand")
public class JDUBrandController extends BaseController {
@Autowired
private JDUBrandService jduBrandService;
@ResourcePermissions()
@RequestMapping("/index")
public String index() {
return "dpgl/jdubrand/index";
}
@ResourcePermissions({SystemOperation.BottonResource.ADD})
@RequestMapping("/add")
public String add() {
return "dpgl/jdubrand/edit";
}
@ResourcePermissions({SystemOperation.BottonResource.EDIT})
@RequestMapping("/edit")
public String edit() {
return "dpgl/jdubrand/edit";
}
@RequestMapping(value = BaseURL.GET, method = RequestMethod.POST)
@ResponseBody
public Object get(@RequestBody JSONObject param) {
UBrandCondition condition = DataConvert.getCondition(param, UBrandCondition.class);
RecordSet<UBrandVO> records = jduBrandService.query(condition);
if ( records.getRecords()!=null && records.getRecords().size()>=1 ){
return buildReturnData(UBrandVO.class, records.getRecords().get(0));
}
return buildReturnData(UBrandVO.class, null);
}
@RequestMapping(value = BaseURL.QUERY, method = RequestMethod.POST)
@ResponseBody
public Object query(@RequestBody JSONObject param) {
UBrandCondition condition = DataConvert.getCondition(param, UBrandCondition.class);
condition.setType(SourceEnum.JD.getId());
RecordSet<UBrandVO> records = jduBrandService.query(condition);
return buildReturnData(records, UBrandVO.class);
}
@ResourcePermissions(SystemOperation.BottonResource.ADD)
@RequestMapping(value = BaseURL.ADD, method = RequestMethod.POST)
@ResponseBody
public Object insert(@RequestBody JSONObject param) {
BaseEditJSON editJson = BaseEditJSON.parseJSON(param);
jduBrandService.insert(editJson);
return ThreadContext.getReturnData();
}
@ResourcePermissions(SystemOperation.BottonResource.EDIT)
@RequestMapping(value = BaseURL.UPDATE, method = RequestMethod.POST)
@ResponseBody
public Object update(@RequestBody JSONObject param) {
BaseEditJSON editJson = BaseEditJSON.parseJSON(param);
jduBrandService.update(editJson);
return ThreadContext.getReturnData();
}
@ResourcePermissions(SystemOperation.BottonResource.DELETE)
@RequestMapping(value = BaseURL.DELETE, method = RequestMethod.POST)
@ResponseBody
public Object delete(@RequestBody JSONObject param) {
BaseEditJSON editJson = BaseEditJSON.parseJSON(param);
jduBrandService.delete(editJson);
return ThreadContext.getReturnData();
}
@ResourcePermissions(SystemOperation.BottonResource.EXPORT)
@RequestMapping(value = BaseURL.EXPORT, method = RequestMethod.POST)
@ResponseBody
public void export(HttpServletRequest request,HttpServletResponse response, @RequestBody JSONObject param) throws Exception {
UBrandCondition condition = DataConvert.getCondition(param, UBrandCondition.class);
condition.setType(SourceEnum.JD.getId());
RecordSet<UBrandVO> records = jduBrandService.query(condition);
doExport(request, response, param, records.getRecords());
}
@RequestMapping(value = "sync", method = RequestMethod.POST)
@ResponseBody
public Object sync(@RequestBody JSONObject param) throws Exception {
try {
jduBrandService.sync(param);
} catch (Exception e) {
ThreadContext.getReturnData().setSuccess(false);
ThreadContext.getReturnData().setMessage(e.getMessage());
}
return ThreadContext.getReturnData();
}
}
package com.gavel.jingsu.dpgl.controller;
import com.alibaba.fastjson.JSONObject;
import com.gavel.common.BaseURL;
import com.gavel.common.SystemOperation;
import com.gavel.common.annotation.ResourcePermissions;
import com.gavel.common.base.BaseEditJSON;
import com.gavel.common.base.controller.BaseController;
import com.gavel.common.converter.DataConvert;
import com.gavel.common.utils.ThreadContext;
import com.gavel.jingsu.dpgl.service.JDUCategoryService;
import com.gavel.jingsu.dpgl.utils.SourceEnum;
import com.gavel.jingsu.dpgl.vo.UCategoryCondition;
import com.gavel.jingsu.dpgl.vo.UCategoryVO;
import com.gavel.persistence.sql.RecordSet;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.RequestBody;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RequestMethod;
import org.springframework.web.bind.annotation.ResponseBody;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
@Controller
@RequestMapping("dpgl/jducategory")
public class JDUCategoryController extends BaseController {
@Autowired
private JDUCategoryService jduCategoryService;
@ResourcePermissions()
@RequestMapping("/index")
public String index() {
return "dpgl/jducategory/index";
}
@ResourcePermissions({SystemOperation.BottonResource.ADD})
@RequestMapping("/add")
public String add() {
return "dpgl/jducategory/edit";
}
@ResourcePermissions({SystemOperation.BottonResource.EDIT})
@RequestMapping("/edit")
public String edit() {
return "dpgl/jducategory/edit";
}
@RequestMapping(value = BaseURL.GET, method = RequestMethod.POST)
@ResponseBody
public Object get(@RequestBody JSONObject param) {
UCategoryCondition condition = DataConvert.getCondition(param, UCategoryCondition.class);
RecordSet<UCategoryVO> records = jduCategoryService.query(condition);
if ( records.getRecords()!=null && records.getRecords().size()>=1 ){
return buildReturnData(UCategoryVO.class, records.getRecords().get(0));
}
return buildReturnData(UCategoryVO.class, null);
}
@RequestMapping(value = BaseURL.QUERY, method = RequestMethod.POST)
@ResponseBody
public Object query(@RequestBody JSONObject param) {
UCategoryCondition condition = DataConvert.getCondition(param, UCategoryCondition.class);
condition.setType(SourceEnum.JD.getId());
RecordSet<UCategoryVO> records = jduCategoryService.query(condition);
return buildReturnData(records, UCategoryVO.class);
}
@ResourcePermissions(SystemOperation.BottonResource.ADD)
@RequestMapping(value = BaseURL.ADD, method = RequestMethod.POST)
@ResponseBody
public Object insert(@RequestBody JSONObject param) {
BaseEditJSON editJson = BaseEditJSON.parseJSON(param);
jduCategoryService.insert(editJson);
return ThreadContext.getReturnData();
}
@ResourcePermissions(SystemOperation.BottonResource.EDIT)
@RequestMapping(value = BaseURL.UPDATE, method = RequestMethod.POST)
@ResponseBody
public Object update(@RequestBody JSONObject param) {
BaseEditJSON editJson = BaseEditJSON.parseJSON(param);
jduCategoryService.update(editJson);
return ThreadContext.getReturnData();
}
@ResourcePermissions(SystemOperation.BottonResource.DELETE)
@RequestMapping(value = BaseURL.DELETE, method = RequestMethod.POST)
@ResponseBody
public Object delete(@RequestBody JSONObject param) {
BaseEditJSON editJson = BaseEditJSON.parseJSON(param);
jduCategoryService.delete(editJson);
return ThreadContext.getReturnData();
}
@ResourcePermissions(SystemOperation.BottonResource.EXPORT)
@RequestMapping(value = BaseURL.EXPORT, method = RequestMethod.POST)
@ResponseBody
public void export(HttpServletRequest request,HttpServletResponse response, @RequestBody JSONObject param) throws Exception {
UCategoryCondition condition = DataConvert.getCondition(param, UCategoryCondition.class);
condition.setType(SourceEnum.JD.getId());
RecordSet<UCategoryVO> records = jduCategoryService.query(condition);
doExport(request, response, param, records.getRecords());
}
@RequestMapping(value = "sync", method = RequestMethod.POST)
@ResponseBody
public Object sync(@RequestBody JSONObject param) throws Exception {
try {
jduCategoryService.sync(param);
} catch (Exception e) {
ThreadContext.getReturnData().setSuccess(false);
ThreadContext.getReturnData().setMessage(e.getMessage());
}
return ThreadContext.getReturnData();
}
@RequestMapping(value = "convert", method = RequestMethod.POST)
@ResponseBody
public Object convert(@RequestBody JSONObject param) throws Exception {
try {
jduCategoryService.convert(param);
} catch (Exception e) {
ThreadContext.getReturnData().setSuccess(false);
ThreadContext.getReturnData().setMessage(e.getMessage());
}
return ThreadContext.getReturnData();
}
}
package com.gavel.jingsu.dpgl.controller;
import com.alibaba.fastjson.JSONObject;
import com.gavel.common.BaseURL;
import com.gavel.common.SystemOperation;
import com.gavel.common.annotation.ResourcePermissions;
import com.gavel.common.base.BaseEditJSON;
import com.gavel.common.base.controller.BaseController;
import com.gavel.common.converter.DataConvert;
import com.gavel.common.utils.ThreadContext;
import com.gavel.jingsu.dpgl.service.JDUProductService;
import com.gavel.jingsu.dpgl.service.UProductService;
import com.gavel.jingsu.dpgl.utils.SourceEnum;
import com.gavel.jingsu.dpgl.vo.UProductCondition;
import com.gavel.jingsu.dpgl.vo.UProductVO;
import com.gavel.persistence.sql.RecordSet;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.RequestBody;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RequestMethod;
import org.springframework.web.bind.annotation.ResponseBody;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
@Controller
@RequestMapping("dpgl/jduproduct")
public class JDUProductController extends BaseController {
@Autowired
private JDUProductService jduProductService;
@ResourcePermissions()
@RequestMapping("/index")
public String index() {
return "dpgl/jduproduct/index";
}
@ResourcePermissions({SystemOperation.BottonResource.ADD})
@RequestMapping("/add")
public String add() {
return "dpgl/jduproduct/edit";
}
@ResourcePermissions({SystemOperation.BottonResource.EDIT})
@RequestMapping("/edit")
public String edit() {
return "dpgl/jduproduct/edit";
}
@RequestMapping(value = BaseURL.GET, method = RequestMethod.POST)
@ResponseBody
public Object get(@RequestBody JSONObject param) {
UProductCondition condition = DataConvert.getCondition(param, UProductCondition.class);
RecordSet<UProductVO> records = jduProductService.query(condition);
if ( records.getRecords()!=null && records.getRecords().size()>=1 ){
return buildReturnData(UProductVO.class, records.getRecords().get(0));
}
return buildReturnData(UProductVO.class, null);
}
@RequestMapping(value = BaseURL.QUERY, method = RequestMethod.POST)
@ResponseBody
public Object query(@RequestBody JSONObject param) {
UProductCondition condition = DataConvert.getCondition(param, UProductCondition.class);
condition.setType(SourceEnum.JD.getId());
RecordSet<UProductVO> records = jduProductService.query(condition);
return buildReturnData(records, UProductVO.class);
}
@ResourcePermissions(SystemOperation.BottonResource.ADD)
@RequestMapping(value = BaseURL.ADD, method = RequestMethod.POST)
@ResponseBody
public Object insert(@RequestBody JSONObject param) {
BaseEditJSON editJson = BaseEditJSON.parseJSON(param);
jduProductService.insert(editJson);
return ThreadContext.getReturnData();
}
@ResourcePermissions(SystemOperation.BottonResource.EDIT)
@RequestMapping(value = BaseURL.UPDATE, method = RequestMethod.POST)
@ResponseBody
public Object update(@RequestBody JSONObject param) {
BaseEditJSON editJson = BaseEditJSON.parseJSON(param);
jduProductService.update(editJson);
return ThreadContext.getReturnData();
}
@ResourcePermissions(SystemOperation.BottonResource.DELETE)
@RequestMapping(value = BaseURL.DELETE, method = RequestMethod.POST)
@ResponseBody
public Object delete(@RequestBody JSONObject param) {
BaseEditJSON editJson = BaseEditJSON.parseJSON(param);
jduProductService.delete(editJson);
return ThreadContext.getReturnData();
}
@ResourcePermissions(SystemOperation.BottonResource.EXPORT)
@RequestMapping(value = BaseURL.EXPORT, method = RequestMethod.POST)
@ResponseBody
public void export(HttpServletRequest request,HttpServletResponse response, @RequestBody JSONObject param) throws Exception {
UProductCondition condition = DataConvert.getCondition(param, UProductCondition.class);
condition.setType(SourceEnum.JD.getId());
RecordSet<UProductVO> records = jduProductService.query(condition);
doExport(request, response, param, records.getRecords());
}
@RequestMapping(value = "sync", method = RequestMethod.POST)
@ResponseBody
public Object sync(@RequestBody JSONObject param) throws Exception {
try {
jduProductService.sync(param);
} catch (Exception e) {
ThreadContext.getReturnData().setSuccess(false);
ThreadContext.getReturnData().setMessage(e.getMessage());
}
return ThreadContext.getReturnData();
}
@RequestMapping(value = "convert", method = RequestMethod.POST)
@ResponseBody
public Object convert(@RequestBody JSONObject param) throws Exception {
try {
jduProductService.convert(param);
} catch (Exception e) {
ThreadContext.getReturnData().setSuccess(false);
ThreadContext.getReturnData().setMessage(e.getMessage());
}
return ThreadContext.getReturnData();
}
}
package com.gavel.jingsu.dpgl.controller;
import com.alibaba.fastjson.JSONObject;
import com.gavel.common.BaseURL;
import com.gavel.common.SystemOperation;
import com.gavel.common.annotation.ResourcePermissions;
import com.gavel.common.base.BaseEditJSON;
import com.gavel.common.base.controller.BaseController;
import com.gavel.common.converter.DataConvert;
import com.gavel.common.utils.ThreadContext;
import com.gavel.jingsu.dpgl.persistent.USaleorder;
import com.gavel.jingsu.dpgl.service.JDUSaleorderService;
import com.gavel.jingsu.dpgl.utils.SourceEnum;
import com.gavel.jingsu.dpgl.vo.USaleorderCondition;
import com.gavel.jingsu.dpgl.vo.USaleorderVO;
import com.gavel.persistence.sql.RecordSet;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.RequestBody;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RequestMethod;
import org.springframework.web.bind.annotation.ResponseBody;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import java.util.List;
@Controller
@RequestMapping("dpgl/jdusaleorder")
public class JDUSaleorderController extends BaseController {
@Autowired
private JDUSaleorderService jduSaleorderService;
@ResourcePermissions()
@RequestMapping("/index")
public String index() {
return "dpgl/jdusaleorder/index";
}
@ResourcePermissions({SystemOperation.BottonResource.ADD})
@RequestMapping("/add")
public String add() {
return "dpgl/jdusaleorder/edit";
}
@ResourcePermissions({SystemOperation.BottonResource.EDIT})
@RequestMapping("/edit")
public String edit() {
return "dpgl/jdusaleorder/edit";
}
@RequestMapping(value = BaseURL.GET, method = RequestMethod.POST)
@ResponseBody
public Object get(@RequestBody JSONObject param) {
USaleorderCondition condition = DataConvert.getCondition(param, USaleorderCondition.class);
RecordSet<USaleorderVO> records = jduSaleorderService.query(condition);
if ( records.getRecords()!=null && records.getRecords().size()>=1 ){
return buildReturnData(USaleorderVO.class, records.getRecords().get(0));
}
return buildReturnData(USaleorderVO.class, null);
}
@RequestMapping(value = BaseURL.QUERY, method = RequestMethod.POST)
@ResponseBody
public Object query(@RequestBody JSONObject param) {
USaleorderCondition condition = DataConvert.getCondition(param, USaleorderCondition.class);
condition.setType(SourceEnum.JD.getId());
RecordSet<USaleorderVO> records = jduSaleorderService.query(condition);
return buildReturnData(records, USaleorderVO.class);
}
@ResourcePermissions(SystemOperation.BottonResource.ADD)
@RequestMapping(value = BaseURL.ADD, method = RequestMethod.POST)
@ResponseBody
public Object insert(@RequestBody JSONObject param) {
BaseEditJSON editJson = BaseEditJSON.parseJSON(param);
jduSaleorderService.insert(editJson);
return ThreadContext.getReturnData();
}
@ResourcePermissions(SystemOperation.BottonResource.EDIT)
@RequestMapping(value = BaseURL.UPDATE, method = RequestMethod.POST)
@ResponseBody
public Object update(@RequestBody JSONObject param) {
BaseEditJSON editJson = BaseEditJSON.parseJSON(param);
jduSaleorderService.update(editJson);
return ThreadContext.getReturnData();
}
@ResourcePermissions(SystemOperation.BottonResource.DELETE)
@RequestMapping(value = BaseURL.DELETE, method = RequestMethod.POST)
@ResponseBody
public Object delete(@RequestBody JSONObject param) {
BaseEditJSON editJson = BaseEditJSON.parseJSON(param);
jduSaleorderService.delete(editJson);
return ThreadContext.getReturnData();
}
@ResourcePermissions(SystemOperation.BottonResource.EXPORT)
@RequestMapping(value = BaseURL.EXPORT, method = RequestMethod.POST)
@ResponseBody
public void export(HttpServletRequest request,HttpServletResponse response, @RequestBody JSONObject param) throws Exception {
USaleorderCondition condition = DataConvert.getCondition(param, USaleorderCondition.class);
condition.setType(SourceEnum.JD.getId());
RecordSet<USaleorderVO> records = jduSaleorderService.query(condition);
doExport(request, response, param, records.getRecords());
}
@RequestMapping(value = "sync", method = RequestMethod.POST)
@ResponseBody
public Object sync(@RequestBody JSONObject param) throws Exception {
try {
jduSaleorderService.sync(param);
} catch (Exception e) {
ThreadContext.getReturnData().setSuccess(false);
ThreadContext.getReturnData().setMessage(e.getMessage());
}
return ThreadContext.getReturnData();
}
@RequestMapping(value = "convert", method = RequestMethod.POST)
@ResponseBody
public Object convert(@RequestBody JSONObject param) throws Exception {
try {
List<USaleorder> uSaleorders = DataConvert.getData2List(param.getJSONArray("data"), USaleorder.class);
jduSaleorderService.convert(uSaleorders);
} catch (Exception e) {
ThreadContext.getReturnData().setSuccess(false);
ThreadContext.getReturnData().setMessage(e.getMessage());
}
return ThreadContext.getReturnData();
}
}
package com.gavel.jingsu.dpgl.dao;
import com.gavel.common.base.dao.BaseDao;
import com.gavel.jingsu.dpgl.persistent.Dpxx;
import com.gavel.jingsu.dpgl.vo.DpxxCondition;
import com.gavel.jingsu.dpgl.vo.DpxxVO;
import com.gavel.persistence.sql.RecordSet;
import java.util.List;
public interface DpxxDao extends BaseDao {
public RecordSet<DpxxVO> query(DpxxCondition condition);
public List<Dpxx> loadDpxx(String platform);
}
package com.gavel.jingsu.dpgl.dao;
import com.gavel.common.base.dao.BaseDao;
import com.gavel.jingsu.dpgl.vo.UBrandCondition;
import com.gavel.jingsu.dpgl.vo.UBrandVO;
import com.gavel.persistence.sql.RecordSet;
public interface UBrandDao extends BaseDao {
public RecordSet<UBrandVO> query(UBrandCondition condition);
}
package com.gavel.jingsu.dpgl.dao;
import com.gavel.common.base.dao.BaseDao;
import com.gavel.jingsu.dpgl.vo.UCategoryCondition;
import com.gavel.jingsu.dpgl.vo.UCategoryVO;
import com.gavel.persistence.sql.RecordSet;
public interface UCategoryDao extends BaseDao {
public RecordSet<UCategoryVO> query(UCategoryCondition condition);
}
package com.gavel.jingsu.dpgl.dao;
import com.gavel.common.base.dao.BaseDao;
import com.gavel.jingsu.dpgl.persistent.UProduct;
import com.gavel.jingsu.dpgl.vo.UProductCondition;
import com.gavel.jingsu.dpgl.vo.UProductVO;
import com.gavel.persistence.sql.RecordSet;
import java.util.List;
public interface UProductDao extends BaseDao {
public RecordSet<UProductVO> query(UProductCondition condition);
List<UProduct> loadUProducts(long curStatus, int page_size);
}
package com.gavel.jingsu.dpgl.dao;
import com.gavel.common.base.dao.BaseDao;
import com.gavel.jingsu.dpgl.vo.USaleorderCondition;
import com.gavel.jingsu.dpgl.vo.USaleorderVO;
import com.gavel.persistence.sql.RecordSet;
public interface USaleorderDao extends BaseDao {
public RecordSet<USaleorderVO> query(USaleorderCondition condition);
}
package com.gavel.jingsu.dpgl.dao.impl;
import com.gavel.common.base.dao.impl.BaseDaoImpl;
import com.gavel.common.utils.StringUtils;
import com.gavel.jingsu.dpgl.dao.DpxxDao;
import com.gavel.jingsu.dpgl.persistent.Dpxx;
import com.gavel.jingsu.dpgl.vo.DpxxCondition;
import com.gavel.jingsu.dpgl.vo.DpxxVO;
import com.gavel.persistence.sql.RecordSet;
import com.gavel.persistence.sql.SqlMap;
import com.gavel.persistence.sql.SqlUtil;
import org.springframework.stereotype.Repository;
import java.util.List;
@Repository("dpxxDao")
public class DpxxDaoImpl extends BaseDaoImpl implements DpxxDao {
public RecordSet<DpxxVO> query(DpxxCondition condition){
SqlMap sqlMap = new SqlMap();
sqlMap.setPageNo(condition.getPageNo());
sqlMap.setRowCount(condition.getPageSize());
sqlMap.append("select DPXX_ID, DPXX_DPBM, DPXX_DPMC, DPXX_DPJC, DPXX_FZR, DPXX_LXFS, DPXX_BZ, DPXX_LOGO, ");
sqlMap.append(" DPXX_WHRID,DPXX_WHR,DPXX_WHSJ, DPXX_CJRID, DPXX_CJR, DPXX_CJSJ, DPXX_SYSVERSION, ");
sqlMap.append(" DPXX_APPKEY, DPXX_APPSECRET, DPXX_DPPT, DPXX_DPLX, DPXX_URL, DPXX_ZDTB ");
sqlMap.append("from DPXX ");
sqlMap.append("where 1 = 1 ");
if (StringUtils.isNotEmpty(condition.getId())){
sqlMap.append(" and " + SqlUtil.getWhereSql("DPXX_ID", condition.getId()));
sqlMap.setParamValue("DPXX_ID", condition.getId());
}
if (StringUtils.isNotEmpty(condition.getCondition())) {
sqlMap.append(" and (DPXX_DPBM like :condition or DPXX_DPMC like :condition )");
sqlMap.setParamValueLike("condition", condition.getCondition());
}
if (StringUtils.isNotEmpty(condition.getDppt())){
sqlMap.append(" and " + SqlUtil.getWhereSql("DPXX_DPPT", condition.getDppt().trim()));
sqlMap.setParamValue("DPXX_DPPT", condition.getDppt().trim());
}
sqlMap.query(DpxxVO.class);
return sqlMap.getRecordSet();
}
@Override
public List<Dpxx> loadDpxx(String platform) {
SqlMap sqlMap = new SqlMap();
sqlMap.append("select DPXX_ID, DPXX_DPBM, DPXX_DPMC, DPXX_DPJC, DPXX_FZR, DPXX_LXFS, DPXX_BZ, DPXX_LOGO, ");
sqlMap.append(" DPXX_WHRID,DPXX_WHR,DPXX_WHSJ, DPXX_CJRID, DPXX_CJR, DPXX_CJSJ, DPXX_SYSVERSION, ");
sqlMap.append(" DPXX_APPKEY, DPXX_APPSECRET, DPXX_DPPT, DPXX_DPLX, DPXX_URL, DPXX_ZDTB ");
sqlMap.append("from DPXX ");
sqlMap.append("where 1 = 1 ");
sqlMap.append(" and " + SqlUtil.getWhereLikeSql("DPXX_DPPT"));
sqlMap.setParamValue("DPXX_DPPT",platform);
return sqlMap.query(Dpxx.class);
}
}
package com.gavel.jingsu.dpgl.dao.impl;
import com.gavel.common.base.dao.impl.BaseDaoImpl;
import com.gavel.common.utils.StringUtils;
import com.gavel.jingsu.dpgl.dao.UBrandDao;
import com.gavel.jingsu.dpgl.vo.UBrandCondition;
import com.gavel.jingsu.dpgl.vo.UBrandVO;
import com.gavel.persistence.sql.RecordSet;
import com.gavel.persistence.sql.SqlMap;
import com.gavel.persistence.sql.SqlUtil;
import org.springframework.stereotype.Repository;
@Repository("uBrandDao")
public class UBrandDaoImpl extends BaseDaoImpl implements UBrandDao {
public RecordSet<UBrandVO> query(UBrandCondition condition){
SqlMap sqlMap = new SqlMap();
sqlMap.setPageNo(condition.getPageNo());
sqlMap.setRowCount(condition.getPageSize());
sqlMap.append("select U_BRAND_ID, U_BRAND_BRANDCODE, U_BRAND_BRANDNAME, ");
sqlMap.append(" U_BRAND_TYPE, U_BRAND_CATEGORYCODE,U_BRAND_SUPPLIERCODE, DPXX_DPMC ");
sqlMap.append("from U_BRAND ");
sqlMap.append(" left join DPXX on DPXX_DPBM = U_BRAND_SUPPLIERCODE ");
sqlMap.append("where 1 = 1 ");
if (StringUtils.isNotEmpty(condition.getId())){
sqlMap.append(" and " + SqlUtil.getWhereSql("U_BRAND_ID", condition.getId()));
sqlMap.setParamValue("U_BRAND_ID", condition.getId());
}
if (StringUtils.isNotEmpty(condition.getCode())){
sqlMap.append(" and " + SqlUtil.getWhereSql("U_BRAND_BRANDCODE", condition.getCode()));
sqlMap.setParamValue("U_BRAND_BRANDCODE", condition.getCode());
}
if (StringUtils.isNotEmpty(condition.getType())){
sqlMap.append(" and " + SqlUtil.getWhereSql("U_BRAND_TYPE", condition.getType()));
sqlMap.setParamValue("U_BRAND_TYPE", condition.getType());
}
if (StringUtils.isNotEmpty(condition.getName())){
sqlMap.append(" and U_BRAND_BRANDNAME like :U_BRAND_BRANDNAME ");
sqlMap.setParamValue("U_BRAND_BRANDNAME", "%" + condition.getName().trim() + "%");
}
if (StringUtils.isNotEmpty(condition.getSuppliercode())){
sqlMap.append(" and " + SqlUtil.getWhereSql("U_BRAND_SUPPLIERCODE", condition.getSuppliercode()));
sqlMap.setParamValue("U_BRAND_SUPPLIERCODE", condition.getSuppliercode());
}
sqlMap.append( "order by U_BRAND_BRANDCODE ");
sqlMap.query(UBrandVO.class);
return sqlMap.getRecordSet();
}
}
package com.gavel.jingsu.dpgl.dao.impl;
import com.gavel.common.base.dao.impl.BaseDaoImpl;
import com.gavel.common.utils.StringUtils;
import com.gavel.jingsu.dpgl.dao.UCategoryDao;
import com.gavel.jingsu.dpgl.vo.UCategoryCondition;
import com.gavel.jingsu.dpgl.vo.UCategoryVO;
import com.gavel.persistence.sql.RecordSet;
import com.gavel.persistence.sql.SqlMap;
import com.gavel.persistence.sql.SqlUtil;
import org.springframework.stereotype.Repository;
@Repository("uCategoryDao")
public class UCategoryDaoImpl extends BaseDaoImpl implements UCategoryDao {
public RecordSet<UCategoryVO> query(UCategoryCondition condition){
SqlMap sqlMap = new SqlMap();
sqlMap.setPageNo(condition.getPageNo());
sqlMap.setRowCount(condition.getPageSize());
sqlMap.append("select U_CATEGORY_ID, U_CATEGORY_CATEGORYCODE, U_CATEGORY_CATEGORYNAME, ");
sqlMap.append(" U_CATEGORY_GRADE,U_CATEGORY_ISBOTTOM, U_CATEGORY_DESCPATH,U_CATEGORY_TYPE, ");
sqlMap.append(" U_CATEGORY_FOURCATEGORY, U_CATEGORY_SUPPLIERCODE, U_CATEGORY_CPSL, DPXX_DPMC ");
sqlMap.append("from U_CATEGORY ");
sqlMap.append(" left join DPXX on DPXX_DPBM = U_CATEGORY_SUPPLIERCODE ");
sqlMap.append("where 1 = 1 ");
if (StringUtils.isNotEmpty(condition.getId())){
sqlMap.append(" and " + SqlUtil.getWhereSql("U_CATEGORY_ID", condition.getId()));
sqlMap.setParamValue("U_CATEGORY_ID", condition.getId());
}
if (StringUtils.isNotEmpty(condition.getCode())){
sqlMap.append(" and " + SqlUtil.getWhereSql("U_CATEGORY_CATEGORYCODE", condition.getCode()));
sqlMap.setParamValue("U_CATEGORY_CATEGORYCODE", condition.getCode());
}
if (StringUtils.isNotEmpty(condition.getName())){
sqlMap.append(" and U_CATEGORY_CATEGORYNAME like :U_CATEGORY_CATEGORYNAME ");
sqlMap.setParamValue("U_CATEGORY_CATEGORYNAME", "%" + condition.getName().trim() + "%");
}
if (StringUtils.isNotEmpty(condition.getSuppliercode())){
sqlMap.append(" and " + SqlUtil.getWhereSql("U_CATEGORY_SUPPLIERCODE", condition.getSuppliercode()));
sqlMap.setParamValue("U_CATEGORY_SUPPLIERCODE", condition.getSuppliercode());
}
if (StringUtils.isNotEmpty(condition.getType())){
sqlMap.append(" and " + SqlUtil.getWhereSql("U_CATEGORY_TYPE", condition.getType()));
sqlMap.setParamValue("U_CATEGORY_TYPE", condition.getType());
}
sqlMap.append(" order by U_CATEGORY_CATEGORYCODE ");
sqlMap.query(UCategoryVO.class);
return sqlMap.getRecordSet();
}
}
package com.gavel.jingsu.dpgl.dao.impl;
import com.gavel.common.base.dao.impl.BaseDaoImpl;
import com.gavel.common.utils.StringUtils;
import com.gavel.jingsu.dpgl.dao.UProductDao;
import com.gavel.jingsu.dpgl.persistent.UProduct;
import com.gavel.jingsu.dpgl.vo.UProductCondition;
import com.gavel.jingsu.dpgl.vo.UProductVO;
import com.gavel.persistence.sql.RecordSet;
import com.gavel.persistence.sql.SqlMap;
import com.gavel.persistence.sql.SqlUtil;
import org.springframework.stereotype.Repository;
import java.util.List;
@Repository("uProductDao")
public class UProductDaoImpl extends BaseDaoImpl implements UProductDao {
public RecordSet<UProductVO> query(UProductCondition condition){
SqlMap sqlMap = new SqlMap();
sqlMap.setPageNo(condition.getPageNo());
sqlMap.setRowCount(condition.getPageSize());
sqlMap.append("select U_PRODUCT_ID, U_PRODUCT_APPLYCODE, U_PRODUCT_APPLYSTATUS, U_PRODUCT_BRANDCODE, ");
sqlMap.append(" U_BRAND_BRANDNAME as U_PRODUCT_BRANDNAME ,U_PRODUCT_CATEGORYCODE,U_CATEGORY_CATEGORYNAME as U_PRODUCT_CATEGORYNAME,");
sqlMap.append(" U_PRODUCT_CHILDITEM, U_PRODUCT_CMTITLE, U_PRODUCT_CONTENTSTATUS ,U_PRODUCT_IMGAURL, U_PRODUCT_ITEMCODE, ");
sqlMap.append(" U_PRODUCT_PRODUCTCODE, U_PRODUCT_PUBLISHED, U_PRODUCT_SUPPLIERCODE,DPXX_DPMC,U_PRODUCT_MODIFYTIME, ");
sqlMap.append(" U_PRODUCT_STATUS, U_PRODUCT_SKUCODE, U_PRODUCT_SKUNAME,U_PRODUCT_TYPE,U_PRODUCT_SOURCE ");
sqlMap.append("from U_PRODUCT ");
sqlMap.append(" left join DPXX on DPXX_DPBM = U_PRODUCT_SUPPLIERCODE ");
sqlMap.append(" left join U_BRAND on U_BRAND_BRANDCODE = U_PRODUCT_BRANDCODE ");
sqlMap.append(" left join U_CATEGORY on U_CATEGORY_CATEGORYCODE = U_PRODUCT_CATEGORYCODE ");
sqlMap.append("where 1 = 1 ");
if (StringUtils.isNotEmpty(condition.getId())){
sqlMap.append(" and " + SqlUtil.getWhereSql("U_PRODUCT_ID", condition.getId()));
sqlMap.setParamValue("U_PRODUCT_ID", condition.getId());
}
if (StringUtils.isNotEmpty(condition.getItemcode())){
sqlMap.append(" and U_PRODUCT_PRODUCTCODE like :U_PRODUCT_PRODUCTCODE");
sqlMap.setParamValue("U_PRODUCT_PRODUCTCODE", "%" + condition.getItemcode().trim() + "%");
}
if (StringUtils.isNotEmpty(condition.getCmtitle())){
sqlMap.append(" and U_PRODUCT_CMTITLE like :U_PRODUCT_CMTITLE");
sqlMap.setParamValue("U_PRODUCT_CMTITLE", "%" + condition.getCmtitle().trim() + "%");
}
if (StringUtils.isNotEmpty(condition.getBrandname())){
sqlMap.append(" and U_PRODUCT_BRANDNAME like :U_PRODUCT_BRANDNAME");
sqlMap.setParamValue("U_PRODUCT_BRANDNAME", "%" + condition.getBrandname().trim() + "%");
}
if (StringUtils.isNotEmpty(condition.getCategoryname())){
sqlMap.append(" and U_PRODUCT_CATEGORYNAME like :U_PRODUCT_CATEGORYNAME");
sqlMap.setParamValue("U_PRODUCT_CATEGORYNAME", "%" + condition.getCategoryname().trim() + "%");
}
if (StringUtils.isNotEmpty(condition.getSuppliercode())){
sqlMap.append(" and " + SqlUtil.getWhereSql("U_PRODUCT_SUPPLIERCODE", condition.getSuppliercode()));
sqlMap.setParamValue("U_PRODUCT_SUPPLIERCODE", condition.getSuppliercode());
}
if (StringUtils.isNotEmpty(condition.getType())){
sqlMap.append(" and " + SqlUtil.getWhereSql("U_PRODUCT_TYPE", condition.getType()));
sqlMap.setParamValue("U_PRODUCT_TYPE", condition.getType());
}
sqlMap.query(UProductVO.class);
return sqlMap.getRecordSet();
}
@Override
public List<UProduct> loadUProducts(long curStatus, int page_size) {
SqlMap sqlMap = new SqlMap();
if ( page_size > 0 ) {
sqlMap.setPageNo(1);
sqlMap.setRowCount(page_size);
}
sqlMap.append("select U_PRODUCT_ID, U_PRODUCT_APPLYCODE, U_PRODUCT_APPLYSTATUS, U_PRODUCT_BRANDCODE, U_PRODUCT_BRANDNAME ");
sqlMap.append(" , U_PRODUCT_CATEGORYCODE, U_PRODUCT_CATEGORYNAME, U_PRODUCT_CHILDITEM, U_PRODUCT_CMTITLE, U_PRODUCT_CONTENTSTATUS ");
sqlMap.append(" , U_PRODUCT_IMGAURL, U_PRODUCT_ITEMCODE, U_PRODUCT_PRODUCTCODE, U_PRODUCT_PUBLISHED ");
sqlMap.append(" , U_PRODUCT_SUPPLIERCODE, U_PRODUCT_STATUS, U_PRODUCT_SKUCODE, U_PRODUCT_SKUNAME, U_PRODUCT_SOURCE ");
sqlMap.append(" from U_PRODUCT ");
sqlMap.append(" where isnull(U_PRODUCT_STATUS, 0) <> :U_PRODUCT_STATUS and isnull(U_PRODUCT_PRODUCTCODE, '') <> '' ");
sqlMap.append(" and not exists( select 1 from WLXX where WLXX_CODE = U_PRODUCT_PRODUCTCODE) ");
sqlMap.append(" order by U_PRODUCT_CATEGORYCODE ");
sqlMap.setParamValue("U_PRODUCT_STATUS", curStatus);
return sqlMap.query(UProduct.class);
}
}
package com.gavel.jingsu.dpgl.dao.impl;
import com.gavel.common.base.dao.impl.BaseDaoImpl;
import com.gavel.common.utils.DateUtils;
import com.gavel.common.utils.StringUtils;
import com.gavel.jingsu.dpgl.dao.USaleorderDao;
import com.gavel.jingsu.dpgl.vo.USaleorderCondition;
import com.gavel.jingsu.dpgl.vo.USaleorderVO;
import com.gavel.persistence.sql.RecordSet;
import com.gavel.persistence.sql.SqlMap;
import com.gavel.persistence.sql.SqlUtil;
import org.springframework.stereotype.Repository;
@Repository("uSaleorderDao")
public class USaleorderDaoImpl extends BaseDaoImpl implements USaleorderDao {
public RecordSet<USaleorderVO> query(USaleorderCondition condition){
SqlMap sqlMap = new SqlMap();
sqlMap.setPageNo(condition.getPageNo());
sqlMap.setRowCount(condition.getPageSize());
sqlMap.append("select U_SALEORDER_ID, U_SALEORDER_DPBM, U_SALEORDER_ORDERID, U_SALEORDER_ORDERITEMID, U_SALEORDER_PLATFORM, U_SALEORDER_CUSTOMERNAME, U_SALEORDER_MOBILEPHONE, U_SALEORDER_ADDRESS, U_SALEORDER_MEMBERORGNAME ");
sqlMap.append(" , U_SALEORDER_PRODUCTCODE, U_SALEORDER_PRODUCTNAME, U_SALEORDER_SALEQTY, U_SALEORDER_PRICE, U_SALEORDER_POSID, U_SALEORDER_REFUNDFEE, U_SALEORDER_REMARK, U_SALEORDER_REMARKCOLORFLAG, U_SALEORDER_SALETIME ");
sqlMap.append(" , U_SALEORDER_SHIPCONDITION, U_SALEORDER_STATUS, U_SALEORDER_SUPPLIERCMMDTYCODE, U_SALEORDER_SUPPLIERCODE, U_SALEORDER_SUPPLIERREMARK, U_SALEORDER_TELEPHONE, U_SALEORDER_WARECODE, U_SALEORDER_RETURNORDERFLAG ");
sqlMap.append(" , U_SALEORDER_RETURNSTATUS, U_SALEORDER_EXCHANGEGOODSFLAG, U_SALEORDER_RETURNFLAG, U_SALEORDER_GYAOBATCHNUM, U_SALEORDER_GYAOSPECIFICAT, U_SALEORDER_GYAOMANUFACT, U_SALEORDER_GYAOTERMVALIDITY, U_SALEORDER_STORECODE ");
sqlMap.append(" , U_SALEORDER_ISSHOWPRICE, U_SALEORDER_FACTORYIWDFLAG, U_SALEORDER_ZT, U_SALEORDER_TBSJ,U_SALEORDER_TYPE ");
sqlMap.append(" from U_SALEORDER ");
sqlMap.append(" where 1 = 1 ");
if (StringUtils.isNotEmpty(condition.getId())){
sqlMap.append(" and " + SqlUtil.getWhereSql("U_SALEORDER_ID", condition.getId()));
sqlMap.setParamValue("U_SALEORDER_ID", condition.getId());
}
if (StringUtils.isNotEmpty(condition.getDpbm())){
sqlMap.append(" and " + SqlUtil.getWhereSql("U_SALEORDER_DPBM", condition.getDpbm()));
sqlMap.setParamValue("U_SALEORDER_DPBM", condition.getDpbm());
}
if (StringUtils.isNotEmpty(condition.getOrderid())){
sqlMap.append(" and " + SqlUtil.getWhereSql("U_SALEORDER_ORDERID", condition.getOrderid()));
sqlMap.setParamValue("U_SALEORDER_ORDERID", condition.getOrderid());
}
if (StringUtils.isNotEmpty(condition.getStatus())){
sqlMap.append(" and " + SqlUtil.getWhereSql("U_SALEORDER_STATUS", condition.getStatus()));
sqlMap.setParamValue("U_SALEORDER_STATUS", condition.getStatus());
}
if (StringUtils.isNotEmpty(condition.getZt())){
sqlMap.append(" and " + SqlUtil.getWhereSql("U_SALEORDER_ZT", condition.getZt()));
sqlMap.setParamValue("U_SALEORDER_ZT", condition.getZt());
}
if (StringUtils.isNotEmpty(condition.getType())){
sqlMap.append(" and " + SqlUtil.getWhereSql("U_SALEORDER_TYPE", condition.getType()));
sqlMap.setParamValue("U_SALEORDER_TYPE", condition.getType());
}
if ( condition.getStart()!=null ){
sqlMap.append(" and U_SALEORDER_SALETIME >= :U_SALEORDER_SALETIME_START ");
sqlMap.setParamValue("U_SALEORDER_SALETIME_START", DateUtils.beginOfDay(condition.getStart()));
}
if ( condition.getEnd()!=null ){
sqlMap.append(" and U_SALEORDER_SALETIME <= :U_SALEORDER_SALETIME_END ");
sqlMap.setParamValue("U_SALEORDER_SALETIME_END", DateUtils.endOfDay(condition.getEnd()));
}
sqlMap.append(" order by U_SALEORDER_SALETIME desc, U_SALEORDER_ORDERID desc, U_SALEORDER_ORDERITEMID desc ");
sqlMap.query(USaleorderVO.class);
return sqlMap.getRecordSet();
}
}
package com.gavel.jingsu.dpgl.model;
import java.io.Serializable;
public class JDBrand implements Serializable {
/**
* {
* "id": "548835",
* "brandid": 548835,
* "name": "JingSu",
* "vendor": null
* },
*/
private String id;
private String brandid;
private String name;
private String vendor;
public String getId() {
return id;
}
public void setId(String id) {
this.id = id;
}
public String getBrandid() {
return brandid;
}
public void setBrandid(String brandid) {
this.brandid = brandid;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public String getVendor() {
return vendor;
}
public void setVendor(String vendor) {
this.vendor = vendor;
}
}
package com.gavel.jingsu.dpgl.model;
import java.io.Serializable;
import java.util.ArrayList;
import java.util.Date;
import java.util.List;
public class JDCategory implements Serializable {
/**
* {
* "id": "14087",
* "pid": null,
* "name": "胶粘剂",
* "level": 3,
* "pname": null,
* "vccode": null
* },
*/
private String id;
private String pid;
private String name;
private String level;
private String pname;
private String vccode;
public String getId() {
return id;
}
public void setId(String id) {
this.id = id;
}
public String getPid() {
return pid;
}
public void setPid(String pid) {
this.pid = pid;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public String getLevel() {
return level;
}
public void setLevel(String level) {
this.level = level;
}
public String getPname() {
return pname;
}
public void setPname(String pname) {
this.pname = pname;
}
public String getVccode() {
return vccode;
}
public void setVccode(String vccode) {
this.vccode = vccode;
}
}
package com.gavel.jingsu.dpgl.model;
import java.io.Serializable;
import java.util.ArrayList;
import java.util.Date;
import java.util.List;
public class JDPodata implements Serializable {
private String _id;
private String address;
private String branchName;
private String cityId;
private String cityName;
private String commodityName;
private Integer commodityNum;
private String consigneeName;
private Double cost;
private String countyId;
private String countyName;
private Date createDate;
private String customOrderId;
private Double jdPrice;
private String operatorState;
private Date orderCreateDate;
private String orderRemark;
private String orderState;
private String parentOrderId;
private Double pay;
private String paymentCategory;
private String paymentCategoryDispName;
private String telphone;
private String phone;
private String pin;
private String provinceId;
private String provinceName;
private Double reduceCount;
private String refundSourceFlag;
private String sendPay;
private String sku;
private Double totalCarriage;
private String townId;
private String townName;
private String upc;
private String vendorStoreId;
private List<JDPomxdata> orderDetailList = new ArrayList<>();
public String get_id() {
return _id;
}
public void set_id(String _id) {
this._id = _id;
}
public String getAddress() {
return address;
}
public void setAddress(String address) {
this.address = address;
}
public String getBranchName() {
return branchName;
}
public void setBranchName(String branchName) {
this.branchName = branchName;
}
public String getCityId() {
return cityId;
}
public void setCityId(String cityId) {
this.cityId = cityId;
}
public String getCityName() {
return cityName;
}
public void setCityName(String cityName) {
this.cityName = cityName;
}
public String getCommodityName() {
return commodityName;
}
public void setCommodityName(String commodityName) {
this.commodityName = commodityName;
}
public Integer getCommodityNum() {
return commodityNum;
}
public void setCommodityNum(Integer commodityNum) {
this.commodityNum = commodityNum;
}
public String getConsigneeName() {
return consigneeName;
}
public void setConsigneeName(String consigneeName) {
this.consigneeName = consigneeName;
}
public Double getCost() {
return cost;
}
public void setCost(Double cost) {
this.cost = cost;
}
public String getCountyId() {
return countyId;
}
public void setCountyId(String countyId) {
this.countyId = countyId;
}
public String getCountyName() {
return countyName;
}
public void setCountyName(String countyName) {
this.countyName = countyName;
}
public Date getCreateDate() {
return createDate;
}
public void setCreateDate(Date createDate) {
this.createDate = createDate;
}
public String getCustomOrderId() {
return customOrderId;
}
public void setCustomOrderId(String customOrderId) {
this.customOrderId = customOrderId;
}
public Double getJdPrice() {
return jdPrice;
}
public void setJdPrice(Double jdPrice) {
this.jdPrice = jdPrice;
}
public String getOperatorState() {
return operatorState;
}
public void setOperatorState(String operatorState) {
this.operatorState = operatorState;
}
public Date getOrderCreateDate() {
return orderCreateDate;
}
public void setOrderCreateDate(Date orderCreateDate) {
this.orderCreateDate = orderCreateDate;
}
public String getOrderRemark() {
return orderRemark;
}
public void setOrderRemark(String orderRemark) {
this.orderRemark = orderRemark;
}
public String getOrderState() {
return orderState;
}
public void setOrderState(String orderState) {
this.orderState = orderState;
}
public String getParentOrderId() {
return parentOrderId;
}
public void setParentOrderId(String parentOrderId) {
this.parentOrderId = parentOrderId;
}
public Double getPay() {
return pay;
}
public void setPay(Double pay) {
this.pay = pay;
}
public String getPaymentCategory() {
return paymentCategory;
}
public void setPaymentCategory(String paymentCategory) {
this.paymentCategory = paymentCategory;
}
public String getPaymentCategoryDispName() {
return paymentCategoryDispName;
}
public void setPaymentCategoryDispName(String paymentCategoryDispName) {
this.paymentCategoryDispName = paymentCategoryDispName;
}
public String getTelphone() {
return telphone;
}
public void setTelphone(String telphone) {
this.telphone = telphone;
}
public String getPhone() {
return phone;
}
public void setPhone(String phone) {
this.phone = phone;
}
public String getPin() {
return pin;
}
public void setPin(String pin) {
this.pin = pin;
}
public String getProvinceId() {
return provinceId;
}
public void setProvinceId(String provinceId) {
this.provinceId = provinceId;
}
public String getProvinceName() {
return provinceName;
}
public void setProvinceName(String provinceName) {
this.provinceName = provinceName;
}
public Double getReduceCount() {
return reduceCount;
}
public void setReduceCount(Double reduceCount) {
this.reduceCount = reduceCount;
}
public String getRefundSourceFlag() {
return refundSourceFlag;
}
public void setRefundSourceFlag(String refundSourceFlag) {
this.refundSourceFlag = refundSourceFlag;
}
public String getSendPay() {
return sendPay;
}
public void setSendPay(String sendPay) {
this.sendPay = sendPay;
}
public String getSku() {
return sku;
}
public void setSku(String sku) {
this.sku = sku;
}
public Double getTotalCarriage() {
return totalCarriage;
}
public void setTotalCarriage(Double totalCarriage) {
this.totalCarriage = totalCarriage;
}
public String getTownId() {
return townId;
}
public void setTownId(String townId) {
this.townId = townId;
}
public String getTownName() {
return townName;
}
public void setTownName(String townName) {
this.townName = townName;
}
public String getUpc() {
return upc;
}
public void setUpc(String upc) {
this.upc = upc;
}
public String getVendorStoreId() {
return vendorStoreId;
}
public void setVendorStoreId(String vendorStoreId) {
this.vendorStoreId = vendorStoreId;
}
public List<JDPomxdata> getOrderDetailList() {
return orderDetailList;
}
public void setOrderDetailList(List<JDPomxdata> orderDetailList) {
this.orderDetailList = orderDetailList;
}
}
package com.gavel.jingsu.dpgl.model;
import java.io.Serializable;
public class JDPomxdata implements Serializable {
private String sku;
private String upc;
private String wareName;
private String wareNum;
private String cost;
private String jdPrice;
private String discount;
private String poId;
private String roId;
public String getSku() {
return sku;
}
public void setSku(String sku) {
this.sku = sku;
}
public String getUpc() {
return upc;
}
public void setUpc(String upc) {
this.upc = upc;
}
public String getWareName() {
return wareName;
}
public void setWareName(String wareName) {
this.wareName = wareName;
}
public String getWareNum() {
return wareNum;
}
public void setWareNum(String wareNum) {
this.wareNum = wareNum;
}
public String getCost() {
return cost;
}
public void setCost(String cost) {
this.cost = cost;
}
public String getJdPrice() {
return jdPrice;
}
public void setJdPrice(String jdPrice) {
this.jdPrice = jdPrice;
}
public String getDiscount() {
return discount;
}
public void setDiscount(String discount) {
this.discount = discount;
}
public String getPoId() {
return poId;
}
public void setPoId(String poId) {
this.poId = poId;
}
public String getRoId() {
return roId;
}
public void setRoId(String roId) {
this.roId = roId;
}
@Override
public String toString() {
return "JDPomxdata{" +
"sku='" + sku + '\'' +
", upc='" + upc + '\'' +
", wareName='" + wareName + '\'' +
", wareNum=" + wareNum +
", cost=" + cost +
", jdPrice=" + jdPrice +
", discount=" + discount +
", poId='" + poId + '\'' +
", roId='" + roId + '\'' +
'}';
}
}
package com.gavel.jingsu.dpgl.model;
import java.io.Serializable;
import java.util.ArrayList;
public class JDProduct implements Serializable {
private String wareId; //商品编号
private String name; //商品名称
private String cid1;// 类目ID
private String cidName1; // 类目名称
private String brandid; //品牌ID
private String brandName; //品牌名称
private String vendorCode; //供应商简码
private String vendorName; //供应商名称
private ArrayList vcItems = new ArrayList();//SKU列表
public String getWareId() {
return wareId;
}
public void setWareId(String wareId) {
this.wareId = wareId;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public String getCid1() {
return cid1;
}
public void setCid1(String cid1) {
this.cid1 = cid1;
}
public String getCidName1() {
return cidName1;
}
public void setCidName1(String cidName1) {
this.cidName1 = cidName1;
}
public String getBrandid() {
return brandid;
}
public void setBrandid(String brandid) {
this.brandid = brandid;
}
public String getBrandName() {
return brandName;
}
public void setBrandName(String brandName) {
this.brandName = brandName;
}
public String getVendorCode() {
return vendorCode;
}
public void setVendorCode(String vendorCode) {
this.vendorCode = vendorCode;
}
public String getVendorName() {
return vendorName;
}
public void setVendorName(String vendorName) {
this.vendorName = vendorName;
}
public ArrayList getVcItems() {
return vcItems;
}
public void setVcItems(ArrayList vcItems) {
this.vcItems = vcItems;
}
}
package com.gavel.jingsu.dpgl.model;
import java.io.Serializable;
public class JDProductDetail implements Serializable {
private String skuId; //SKU编码
private String wareId; //商品名称
private String skuName; //商品SKU名称
private String marketPrice;//市场价
private String purchasePrice;//采购价
private String memberPrice; //京东价
private String itemNum;//货号
public String getSkuId() {
return skuId;
}
public void setSkuId(String skuId) {
this.skuId = skuId;
}
public String getWareId() {
return wareId;
}
public void setWareId(String wareId) {
this.wareId = wareId;
}
public String getSkuName() {
return skuName;
}
public void setSkuName(String skuName) {
this.skuName = skuName;
}
public String getMarketPrice() {
return marketPrice;
}
public void setMarketPrice(String marketPrice) {
this.marketPrice = marketPrice;
}
public String getPurchasePrice() {
return purchasePrice;
}
public void setPurchasePrice(String purchasePrice) {
this.purchasePrice = purchasePrice;
}
public String getMemberPrice() {
return memberPrice;
}
public void setMemberPrice(String memberPrice) {
this.memberPrice = memberPrice;
}
public String getItemNum() {
return itemNum;
}
public void setItemNum(String itemNum) {
this.itemNum = itemNum;
}
}
package com.gavel.jingsu.dpgl.persistent;
import java.util.Date;
import com.gavel.common.base.entity.BaseEntity;
import com.gavel.common.utils.CodeStrategy;
import com.gavel.persistence.annotation.FieldMeta;
import com.gavel.persistence.annotation.TableMeta;
@TableMeta(id = "DPXX", name = "DPXX")
public class Dpxx extends BaseEntity {
private static final long serialVersionUID = 1L;
@FieldMeta(fieldName = "DPXX_ID", caption = "ID", primaryKey = true, notEmpty = true, codeStrategy = CodeStrategy.UUID)
private String id;
@FieldMeta(fieldName = "DPXX_DPBM", caption = "店铺编码")
private String dpbm;
@FieldMeta(fieldName = "DPXX_DPMC", caption = "店铺名称")
private String dpmc;
@FieldMeta(fieldName = "DPXX_DPJC", caption = "店铺简称")
private String dpjc;
@FieldMeta(fieldName = "DPXX_FZR", caption = "负责人")
private String fzr;
@FieldMeta(fieldName = "DPXX_LXFS", caption = "联系方式")
private String lxfs;
@FieldMeta(fieldName = "DPXX_BZ", caption = "备注")
private String bz;
@FieldMeta(fieldName = "DPXX_LOGO", caption = "店铺LOGO")
private String logo;
@FieldMeta(fieldName = "DPXX_WHRID", caption = "维护人编码", autoUserId = true)
private String whrid;
@FieldMeta(fieldName = "DPXX_WHR", caption = "维护人", autoUserName = true)
private String whr;
@FieldMeta(fieldName = "DPXX_WHSJ", caption = "维护时间", autoDateTime = true)
private Date whsj;
@FieldMeta(fieldName = "DPXX_CJRID", caption = "创建人编码", autoUserId = true, initial = true)
private String cjrid;
@FieldMeta(fieldName = "DPXX_CJR", caption = "创建人", autoUserName = true, initial = true)
private String cjr;
@FieldMeta(fieldName = "DPXX_CJSJ", caption = "创建时间", autoDateTime = true, initial = true)
private Date cjsj;
@FieldMeta(fieldName = "DPXX_SYSVERSION", caption = "系统版本")
private Integer sysversion;
@FieldMeta(fieldName = "DPXX_APPKEY", caption = "应用KEY")
private String appkey;
@FieldMeta(fieldName = "DPXX_APPSECRET", caption = "应用SECRET")
private String appsecret;
@FieldMeta(fieldName = "DPXX_DPPT", caption = "店铺平台")
private String dppt;
@FieldMeta(fieldName = "DPXX_DPLX", caption = "店铺类型")
private String dplx;
@FieldMeta(fieldName = "DPXX_URL", caption = "店铺地址")
private String url;
@FieldMeta(fieldName = "DPXX_ZDTB", caption = "自动同步")
private String zdtb;
public String getId() {
return id;
}
public void setId(String id) {
this.id = id;
}
public String getDpbm() {
return dpbm;
}
public void setDpbm(String dpbm) {
this.dpbm = dpbm;
}
public String getDpmc() {
return dpmc;
}
public void setDpmc(String dpmc) {
this.dpmc = dpmc;
}
public String getDpjc() {
return dpjc;
}
public void setDpjc(String dpjc) {
this.dpjc = dpjc;
}
public String getFzr() {
return fzr;
}
public void setFzr(String fzr) {
this.fzr = fzr;
}
public String getLxfs() {
return lxfs;
}
public void setLxfs(String lxfs) {
this.lxfs = lxfs;
}
public String getBz() {
return bz;
}
public void setBz(String bz) {
this.bz = bz;
}
public String getLogo() {
return logo;
}
public void setLogo(String logo) {
this.logo = logo;
}
public String getWhrid() {
return whrid;
}
public void setWhrid(String whrid) {
this.whrid = whrid;
}
public String getWhr() {
return whr;
}
public void setWhr(String whr) {
this.whr = whr;
}
public Date getWhsj() {
return whsj;
}
public void setWhsj(Date whsj) {
this.whsj = whsj;
}
public String getCjrid() {
return cjrid;
}
public void setCjrid(String cjrid) {
this.cjrid = cjrid;
}
public String getCjr() {
return cjr;
}
public void setCjr(String cjr) {
this.cjr = cjr;
}
public Date getCjsj() {
return cjsj;
}
public void setCjsj(Date cjsj) {
this.cjsj = cjsj;
}
public Integer getSysversion() {
return sysversion;
}
public void setSysversion(Integer sysversion) {
this.sysversion = sysversion;
}
public String getAppkey() {
return appkey;
}
public void setAppkey(String appkey) {
this.appkey = appkey;
}
public String getAppsecret() {
return appsecret;
}
public void setAppsecret(String appsecret) {
this.appsecret = appsecret;
}
public String getDppt() {
return dppt;
}
public void setDppt(String dppt) {
this.dppt = dppt;
}
public String getDplx() {
return dplx;
}
public void setDplx(String dplx) {
this.dplx = dplx;
}
public String getUrl() {
return url;
}
public void setUrl(String url) {
this.url = url;
}
public String getZdtb() {
return zdtb;
}
public void setZdtb(String zdtb) {
this.zdtb = zdtb;
}
}
package com.gavel.jingsu.dpgl.persistent;
import com.gavel.common.base.entity.BaseEntity;
import com.gavel.common.utils.CodeStrategy;
import com.gavel.persistence.annotation.FieldMeta;
import com.gavel.persistence.annotation.TableMeta;
@TableMeta(id = "U_BRAND", name = "U_BRAND")
public class UBrand extends BaseEntity {
private static final long serialVersionUID = 1L;
@FieldMeta(fieldName = "U_BRAND_ID", caption = "ID", primaryKey = true,codeStrategy = CodeStrategy.UUID,notEmpty = true)
private String id;
@FieldMeta(fieldName = "U_BRAND_CATEGORYCODE", caption = "类目编码")
private String categorycode;
@FieldMeta(fieldName = "U_BRAND_BRANDCODE", caption = "品牌代码")
private String brandcode;
@FieldMeta(fieldName = "U_BRAND_BRANDNAME", caption = "品牌名称")
private String brandname;
@FieldMeta(fieldName = "U_BRAND_SUPPLIERCODE", caption = "供应商编码")
private String suppliercode;
@FieldMeta(fieldName = "U_BRAND_TYPE", caption = "品牌来源")//JD:京东,SUNING苏宁
private String type;
public String getId() {
return id;
}
public void setId(String id) {
this.id = id;
}
public String getCategorycode() {
return categorycode;
}
public void setCategorycode(String categorycode) {
this.categorycode = categorycode;
}
public String getBrandcode() {
return brandcode;
}
public void setBrandcode(String brandcode) {
this.brandcode = brandcode;
}
public String getBrandname() {
return brandname;
}
public void setBrandname(String brandname) {
this.brandname = brandname;
}
public String getSuppliercode() {
return suppliercode;
}
public void setSuppliercode(String suppliercode) {
this.suppliercode = suppliercode;
}
public String getType() {
return type;
}
public void setType(String type) {
this.type = type;
}
}
package com.gavel.jingsu.dpgl.persistent;
import com.gavel.common.base.entity.BaseEntity;
import com.gavel.persistence.annotation.FieldMeta;
import com.gavel.persistence.annotation.TableMeta;
@TableMeta(id = "U_CATEGORY", name = "U_CATEGORY")
public class UCategory extends BaseEntity {
private static final long serialVersionUID = 1L;
@FieldMeta(fieldName = "U_CATEGORY_ID", caption = "ID", primaryKey = true, notEmpty = true)
private String id;
@FieldMeta(fieldName = "U_CATEGORY_CATEGORYCODE", caption = "类目编码")
private String categorycode;
@FieldMeta(fieldName = "U_CATEGORY_CATEGORYNAME", caption = "类目名称")
private String categoryname;
@FieldMeta(fieldName = "U_CATEGORY_GRADE", caption = "当前类目层级")
private String grade;
@FieldMeta(fieldName = "U_CATEGORY_ISBOTTOM", caption = "子类目")
private String isbottom;
@FieldMeta(fieldName = "U_CATEGORY_DESCPATH", caption = "类目描述")
private String descpath;
@FieldMeta(fieldName = "U_CATEGORY_FOURCATEGORY", caption = "描述")
private String fourcategory;
@FieldMeta(fieldName = "U_CATEGORY_SUPPLIERCODE", caption = "供应商编码")
private String suppliercode;
@FieldMeta(fieldName = "U_CATEGORY_TYPE", caption = "类目来源")//JD:京东,SUNING苏宁
private String type;
@FieldMeta(fieldName = "U_CATEGORY_CPSL", caption = "产品数量")
private Integer cpsl;
public String getId() {
return id;
}
public void setId(String id) {
this.id = id;
}
public String getCategorycode() {
return categorycode;
}
public void setCategorycode(String categorycode) {
this.categorycode = categorycode;
}
public String getCategoryname() {
return categoryname;
}
public void setCategoryname(String categoryname) {
this.categoryname = categoryname;
}
public String getGrade() {
return grade;
}
public void setGrade(String grade) {
this.grade = grade;
}
public String getIsbottom() {
return isbottom;
}
public void setIsbottom(String isbottom) {
this.isbottom = isbottom;
}
public String getDescpath() {
return descpath;
}
public void setDescpath(String descpath) {
this.descpath = descpath;
}
public String getFourcategory() {
return fourcategory;
}
public void setFourcategory(String fourcategory) {
this.fourcategory = fourcategory;
}
public String getSuppliercode() {
return suppliercode;
}
public void setSuppliercode(String suppliercode) {
this.suppliercode = suppliercode;
}
public String getType() {
return type;
}
public void setType(String type) {
this.type = type;
}
public Integer getCpsl() {
return cpsl;
}
public void setCpsl(Integer cpsl) {
this.cpsl = cpsl;
}
}
package com.gavel.jingsu.dpgl.persistent;
import com.gavel.common.base.entity.BaseEntity;
import com.gavel.common.utils.CodeStrategy;
import com.gavel.persistence.annotation.FieldMeta;
import com.gavel.persistence.annotation.TableMeta;
import java.util.Date;
@TableMeta(id = "U_PRODUCT", name = "U_PRODUCT")
public class UProduct extends BaseEntity {
private static final long serialVersionUID = 1L;
@FieldMeta(fieldName = "U_PRODUCT_ID", caption = "ID", primaryKey = true,codeStrategy = CodeStrategy.UUID,notEmpty = true)
private String id;
@FieldMeta(fieldName = "U_PRODUCT_APPLYCODE", caption = "申请编码")
private String applycode;
@FieldMeta(fieldName = "U_PRODUCT_APPLYSTATUS", caption = "申请状态")
private String applystatus;
@FieldMeta(fieldName = "U_PRODUCT_BRANDCODE", caption = "商品品牌编码")
private String brandcode;
@FieldMeta(fieldName = "U_PRODUCT_BRANDNAME", caption = "商品品牌名称")
private String brandname;
@FieldMeta(fieldName = "U_PRODUCT_CATEGORYCODE", caption = "商品采购目录编码")
private String categorycode;
@FieldMeta(fieldName = "U_PRODUCT_CATEGORYNAME", caption = "商品采购目录名称")
private String categoryname;
@FieldMeta(fieldName = "U_PRODUCT_CHILDITEM", caption = "子商品信息")
private String childitem;
@FieldMeta(fieldName = "U_PRODUCT_CMTITLE", caption = "商品标题")
private String cmtitle;
@FieldMeta(fieldName = "U_PRODUCT_CONTENTSTATUS", caption = "内容状态")
private String contentstatus;
@FieldMeta(fieldName = "U_PRODUCT_IMGAURL", caption = "商家商品图片1地址URL")
private String imgaurl;
@FieldMeta(fieldName = "U_PRODUCT_ITEMCODE", caption = "商家商品编码")
private String itemcode;
@FieldMeta(fieldName = "U_PRODUCT_PRODUCTCODE", caption = "商品编码")
private String productcode;
@FieldMeta(fieldName = "U_PRODUCT_PUBLISHED", caption = "商品第一次提交时间")
private String published;
@FieldMeta(fieldName = "U_PRODUCT_SUPPLIERCODE", caption = "供应商编码")
private String suppliercode;
@FieldMeta(fieldName = "U_PRODUCT_STATUS", caption = "状态值")
private Long status;
@FieldMeta(fieldName = "U_PRODUCT_SKUCODE", caption = "SKU商品编码")
private String skucode;
@FieldMeta(fieldName = "U_PRODUCT_SKUNAME", caption = "SKU商品名称")
private String skuname;
@FieldMeta(fieldName = "U_PRODUCT_SOURCE", caption = "商品来源")
private String source;
@FieldMeta(fieldName = "U_PRODUCT_TYPE", caption = "商品来源")//JD:京东,SUNING苏宁
private String type;
@FieldMeta(fieldName = "U_PRODUCT_MODIFYTIME ", caption = "商品更新时间")
private Date modifytime;
public String getId() {
return id;
}
public void setId(String id) {
this.id = id;
}
public String getApplycode() {
return applycode;
}
public void setApplycode(String applycode) {
this.applycode = applycode;
}
public String getApplystatus() {
return applystatus;
}
public void setApplystatus(String applystatus) {
this.applystatus = applystatus;
}
public String getBrandcode() {
return brandcode;
}
public void setBrandcode(String brandcode) {
this.brandcode = brandcode;
}
public String getBrandname() {
return brandname;
}
public void setBrandname(String brandname) {
this.brandname = brandname;
}
public String getCategorycode() {
return categorycode;
}
public void setCategorycode(String categorycode) {
this.categorycode = categorycode;
}
public String getCategoryname() {
return categoryname;
}
public void setCategoryname(String categoryname) {
this.categoryname = categoryname;
}
public String getChilditem() {
return childitem;
}
public void setChilditem(String childitem) {
this.childitem = childitem;
}
public String getCmtitle() {
return cmtitle;
}
public void setCmtitle(String cmtitle) {
this.cmtitle = cmtitle;
}
public String getContentstatus() {
return contentstatus;
}
public void setContentstatus(String contentstatus) {
this.contentstatus = contentstatus;
}
public String getImgaurl() {
return imgaurl;
}
public void setImgaurl(String imgaurl) {
this.imgaurl = imgaurl;
}
public String getItemcode() {
return itemcode;
}
public void setItemcode(String itemcode) {
this.itemcode = itemcode;
}
public String getProductcode() {
return productcode;
}
public void setProductcode(String productcode) {
this.productcode = productcode;
}
public String getPublished() {
return published;
}
public void setPublished(String published) {
this.published = published;
}
public String getSuppliercode() {
return suppliercode;
}
public void setSuppliercode(String suppliercode) {
this.suppliercode = suppliercode;
}
public Long getStatus() {
return status;
}
public void setStatus(Long status) {
this.status = status;
}
public String getSkucode() {
return skucode;
}
public void setSkucode(String skucode) {
this.skucode = skucode;
}
public String getSkuname() {
return skuname;
}
public void setSkuname(String skuname) {
this.skuname = skuname;
}
public String getSource() {
return source;
}
public void setSource(String source) {
this.source = source;
}
public String getType() {
return type;
}
public void setType(String type) {
this.type = type;
}
public Date getModifytime() {
return modifytime;
}
public void setModifytime(Date modifytime) {
this.modifytime = modifytime;
}
}
package com.gavel.jingsu.dpgl.service;
import com.alibaba.fastjson.JSONObject;
import com.gavel.common.base.service.BaseEditService;
import com.gavel.jingsu.dpgl.persistent.Dpxx;
import com.gavel.jingsu.dpgl.vo.DpxxCondition;
import com.gavel.jingsu.dpgl.vo.DpxxVO;
import com.gavel.persistence.sql.RecordSet;
import java.util.List;
public interface DpxxService extends BaseEditService {
public RecordSet<DpxxVO> query(DpxxCondition condition);
public Dpxx query(String dpbm);
public void convert(JSONObject param);
public List<Dpxx> loadDpxx();
public List<Dpxx> loadJDDpxx();
}
package com.gavel.jingsu.dpgl.service;
import com.alibaba.fastjson.JSONObject;
import com.gavel.common.base.service.BaseEditService;
import com.gavel.jingsu.dpgl.vo.UBrandCondition;
import com.gavel.jingsu.dpgl.vo.UBrandVO;
import com.gavel.persistence.sql.RecordSet;
public interface JDUBrandService extends BaseEditService {
public RecordSet<UBrandVO> query(UBrandCondition condition);
public void sync(JSONObject param) throws Exception;
}
package com.gavel.jingsu.dpgl.service;
import com.alibaba.fastjson.JSONObject;
import com.gavel.common.base.service.BaseEditService;
import com.gavel.jingsu.dpgl.vo.UCategoryCondition;
import com.gavel.jingsu.dpgl.vo.UCategoryVO;
import com.gavel.persistence.sql.RecordSet;
public interface JDUCategoryService extends BaseEditService {
public RecordSet<UCategoryVO> query(UCategoryCondition condition);
public void sync(JSONObject param) throws Exception;
public void convert(JSONObject param);
}
package com.gavel.jingsu.dpgl.service;
import com.alibaba.fastjson.JSONObject;
import com.gavel.common.base.service.BaseEditService;
import com.gavel.jingsu.dpgl.vo.UProductCondition;
import com.gavel.jingsu.dpgl.vo.UProductVO;
import com.gavel.persistence.sql.RecordSet;
public interface JDUProductService extends BaseEditService {
public RecordSet<UProductVO> query(UProductCondition condition);
public void sync(JSONObject param) throws Exception;
public void convert(JSONObject param);
}
package com.gavel.jingsu.dpgl.service;
import com.alibaba.fastjson.JSONObject;
import com.gavel.common.base.service.BaseEditService;
import com.gavel.jingsu.dpgl.persistent.USaleorder;
import com.gavel.jingsu.dpgl.vo.USaleorderCondition;
import com.gavel.jingsu.dpgl.vo.USaleorderVO;
import com.gavel.persistence.sql.RecordSet;
import java.util.List;
public interface JDUSaleorderService extends BaseEditService {
public RecordSet<USaleorderVO> query(USaleorderCondition condition);
public void sync(JSONObject param) throws Exception;
public void convert(List<USaleorder> uSaleorders);
}
package com.gavel.jingsu.dpgl.service;
import com.alibaba.fastjson.JSONObject;
import com.gavel.common.base.service.BaseEditService;
import com.gavel.jingsu.dpgl.vo.UBrandCondition;
import com.gavel.jingsu.dpgl.vo.UBrandVO;
import com.gavel.persistence.sql.RecordSet;
public interface UBrandService extends BaseEditService {
public RecordSet<UBrandVO> query(UBrandCondition condition);
public void sync(JSONObject param) throws Exception;
}
package com.gavel.jingsu.dpgl.service;
import com.alibaba.fastjson.JSONObject;
import com.gavel.common.base.service.BaseEditService;
import com.gavel.jingsu.dpgl.vo.UCategoryCondition;
import com.gavel.jingsu.dpgl.vo.UCategoryVO;
import com.gavel.persistence.sql.RecordSet;
public interface UCategoryService extends BaseEditService {
public RecordSet<UCategoryVO> query(UCategoryCondition condition);
public void sync(JSONObject param) throws Exception;
public void convert(JSONObject param);
}
package com.gavel.jingsu.dpgl.service;
import com.alibaba.fastjson.JSONObject;
import com.gavel.common.base.service.BaseEditService;
import com.gavel.jingsu.dpgl.vo.UProductCondition;
import com.gavel.jingsu.dpgl.vo.UProductVO;
import com.gavel.persistence.sql.RecordSet;
public interface UProductService extends BaseEditService {
public RecordSet<UProductVO> query(UProductCondition condition);
public void sync(JSONObject param) throws Exception;
public void convert(JSONObject param);
}
package com.gavel.jingsu.dpgl.service;
import com.alibaba.fastjson.JSONObject;
import com.gavel.common.base.service.BaseEditService;
import com.gavel.jingsu.dpgl.vo.USaleorderCondition;
import com.gavel.jingsu.dpgl.vo.USaleorderVO;
import com.gavel.persistence.sql.RecordSet;
import java.util.List;
public interface USaleorderService extends BaseEditService {
public RecordSet<USaleorderVO> query(USaleorderCondition condition);
public void sync(JSONObject param) throws Exception;
public void convert(JSONObject param);
public void convert(List<USaleorderVO> uSaleorders);
// 名称 类型 示例值 描述
// APPLYCODE STRING 94D52E1D-32AE-4E8F-8A4A-D782E96F5171 申请编码
// STRING 10 申请状态:
// STRING 000C
// STRING 东盛
// STRING R2701002
// STRING 日用百货
// STRING
// STRING 夏装新款绣花文艺棉质T恤
// STRING 10 :
// STRING 商家商品图片1地址URL。 商家商品图片1地址URL。
// STRING 123
// STRING 140800123
// STRING 2015/8/5 18:53:57
// STRING 12345678912
}
package com.gavel.jingsu.dpgl.service.impl;
import com.alibaba.fastjson.JSONObject;
import com.gavel.common.base.service.impl.BaseEditServiceImpl;
import com.gavel.common.utils.StringUtils;
import com.gavel.jingsu.dpgl.dao.DpxxDao;
import com.gavel.jingsu.dpgl.persistent.Dpxx;
import com.gavel.jingsu.dpgl.service.DpxxService;
import com.gavel.jingsu.dpgl.vo.DpxxCondition;
import com.gavel.jingsu.dpgl.vo.DpxxVO;
import com.gavel.kzzx.dao.BmDao;
import com.gavel.kzzx.persistent.Bm;
import com.gavel.persistence.sql.RecordSet;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;
import java.util.List;
@Service("dpxxService")
@Transactional
public class DpxxServiceImpl extends BaseEditServiceImpl implements DpxxService {
@Autowired
private DpxxDao dpxxDao;
@Autowired
private BmDao bmDao;
@Override
public void initService() {
addMaster( Dpxx.class);
}
@Override
public RecordSet<DpxxVO> query(DpxxCondition condition) {
return dpxxDao.query(condition);
}
@Override
public Dpxx query(String dpbm) {
if (StringUtils.isBlank(dpbm)) {
return null;
}
Dpxx params = new Dpxx();
params.setDpbm(dpbm);
return dpxxDao.queryByEntity(params);
}
@Override
public void convert(JSONObject param) {
List<Dpxx> dpxxes = dpxxDao.queryListByEntity(new Dpxx());
if ( dpxxes==null || dpxxes.size()==0 ) {
System.out.println("店铺为空.");
return;
}
for (Dpxx dpxx : dpxxes) {
Bm bm = new Bm();
bm.setBmid(dpxx.getDpbm());
bm = bmDao.queryByEntity(bm);
if ( bm==null ) {
bm = new Bm();
bm.setBmid(dpxx.getDpbm());
bm.setBmmc(dpxx.getDpmc());
bmDao.insert(bm);
}
}
}
@Override
public List<Dpxx> loadDpxx() {
return dpxxDao.loadDpxx("苏宁");
}
@Override
public List<Dpxx> loadJDDpxx() {
return dpxxDao.loadDpxx("京东");
}
}
package com.gavel.jingsu.dpgl.service.impl;
import com.alibaba.fastjson.JSONObject;
import com.gavel.common.base.service.impl.BaseEditServiceImpl;
import com.gavel.common.converter.DataConvert;
import com.gavel.common.utils.MD5Utils;
import com.gavel.common.utils.StringUtils;
import com.gavel.jingsu.dpgl.dao.UBrandDao;
import com.gavel.jingsu.dpgl.model.JDBrand;
import com.gavel.jingsu.dpgl.persistent.Dpxx;
import com.gavel.jingsu.dpgl.persistent.UBrand;
import com.gavel.jingsu.dpgl.service.DpxxService;
import com.gavel.jingsu.dpgl.service.JDUBrandService;
import com.gavel.jingsu.dpgl.vo.UBrandCondition;
import com.gavel.jingsu.dpgl.vo.UBrandVO;
import com.gavel.jingsu.plat.jd.util.JDClientUtil;
import com.gavel.persistence.sql.RecordSet;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.http.HttpEntity;
import org.springframework.http.HttpHeaders;
import org.springframework.http.MediaType;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;
import org.springframework.web.client.RestTemplate;
import java.util.List;
@Service("jduBrandService")
@Transactional
public class JDUBrandServiceImpl extends BaseEditServiceImpl implements JDUBrandService {
private static final Logger LOG = LoggerFactory.getLogger(JDUBrandServiceImpl.class);
@Autowired
private UBrandDao uBrandDao;
@Autowired
private RestTemplate restTemplate;
@Autowired
private DpxxService dpxxService;
@Override
public void initService() {
addMaster( UBrand.class);
}
@Override
public RecordSet<UBrandVO> query(UBrandCondition condition) {
return uBrandDao.query(condition);
}
@Override
public void sync(JSONObject param) throws Exception {
List<Dpxx> dpxxs = dpxxService.loadJDDpxx();
LOG.info("品牌: " + (dpxxs==null ? 0 : dpxxs.size()) );
if ( dpxxs!=null ) {
for (Dpxx dpxx : dpxxs) {
loadCategory(dpxx.getDpbm(), JDClientUtil.BRAND_URL, JDClientUtil.MRO_TOKEN );
}
}
}
private void loadCategory(String supplierCode, String url, String token) throws Exception {
int total = 0;
int nextPageNo = 1;
int totalPageNo = 1;
final int size = 100;
JSONObject param = new JSONObject();
param.put("size",size);
HttpHeaders headers = new HttpHeaders();
headers.setContentType(MediaType.APPLICATION_JSON);
headers.set("Accept", "application/json");
headers.set("MRO-TOKEN",token);
while ( nextPageNo <= totalPageNo ) {
param.put("page",nextPageNo);
HttpEntity httpEntity = new HttpEntity<>(param, headers);
try {
JSONObject response = restTemplate.postForObject(url, httpEntity, JSONObject.class);
if ( response == null ) {
totalPageNo = 0;
continue;
}
if (StringUtils.isNotEmpty(response.getString("msg")) ) {
throw new RuntimeException(response.getString("code")+":"+response.getString("msg"));
}
nextPageNo =nextPageNo + 1;
totalPageNo =response.getInteger("totalPages");
List<JDBrand> jdBrandList = DataConvert.getData2List(response.getJSONArray("content"),JDBrand.class);
for (JDBrand jdBrand : jdBrandList) {
try {
UBrand brand = new UBrand();
//brand.setCategorycode(categoryCode);
brand.setBrandcode(jdBrand.getId());
brand.setBrandname(jdBrand.getName());
brand.setSuppliercode(supplierCode);
brand.setId(MD5Utils.md5Hex(supplierCode + "_" + "_" + jdBrand.getId()));
UBrand exist = uBrandDao.queryById(UBrand.class, brand.getId());
if ( exist==null ) {
uBrandDao.insert(brand);
} else {
uBrandDao.update(brand);
}
total++;
} catch (Exception e) {
LOG.error("品牌[" + jdBrand.getId() + "]: " + e.getMessage());
}
}
} catch (Exception e) {
LOG.error("同步品牌:"+e.getMessage());
}
}
}
}
package com.gavel.jingsu.dpgl.service.impl;
import com.alibaba.fastjson.JSONObject;
import com.gavel.common.base.service.impl.BaseEditServiceImpl;
import com.gavel.jingsu.dpgl.dao.UCategoryDao;
import com.gavel.jingsu.dpgl.persistent.UCategory;
import com.gavel.jingsu.dpgl.service.JDUCategoryService;
import com.gavel.jingsu.dpgl.vo.UCategoryCondition;
import com.gavel.jingsu.dpgl.vo.UCategoryVO;
import com.gavel.persistence.sql.RecordSet;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;
@Service("jduCategoryService")
@Transactional
public class JDUCategoryServiceImpl extends BaseEditServiceImpl implements JDUCategoryService {
private static final Logger LOG = LoggerFactory.getLogger(JDUCategoryServiceImpl.class);
@Autowired
private UCategoryDao uCategoryDao;
@Override
public void initService() {
addMaster( UCategory.class);
}
@Override
public RecordSet<UCategoryVO> query(UCategoryCondition condition) {
return uCategoryDao.query(condition);
}
@Override
public void sync(JSONObject param) throws Exception {
}
@Override
public void convert(JSONObject param) {
}
}
package com.gavel.jingsu.dpgl.service.impl;
import com.alibaba.fastjson.JSONObject;
import com.gavel.common.base.service.impl.BaseEditServiceImpl;
import com.gavel.jingsu.dpgl.dao.UProductDao;
import com.gavel.jingsu.dpgl.persistent.UProduct;
import com.gavel.jingsu.dpgl.service.JDUProductService;
import com.gavel.jingsu.dpgl.vo.UProductCondition;
import com.gavel.jingsu.dpgl.vo.UProductVO;
import com.gavel.persistence.sql.RecordSet;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;
@Service("jduProductService")
@Transactional
public class JDUProductServiceImpl extends BaseEditServiceImpl implements JDUProductService {
private static final Logger LOG = LoggerFactory.getLogger(JDUProductServiceImpl.class);
@Autowired
private UProductDao uProductDao;
@Override
public void initService() {
addMaster( UProduct.class);
}
@Override
public RecordSet<UProductVO> query(UProductCondition condition) {
return uProductDao.query(condition);
}
@Override
public void sync(JSONObject param) throws Exception {
}
@Override
public void convert(JSONObject param) {
}
}
package com.gavel.jingsu.dpgl.service.impl;
import com.alibaba.fastjson.JSONObject;
import com.gavel.common.base.entity.BaseEntity;
import com.gavel.common.base.service.impl.BaseEditServiceImpl;
import com.gavel.common.business.service.CommonService;
import com.gavel.common.converter.DataConvert;
import com.gavel.common.utils.DateUtils;
import com.gavel.common.utils.MD5Utils;
import com.gavel.common.utils.StringUtils;
import com.gavel.jingsu.dpgl.dao.USaleorderDao;
import com.gavel.jingsu.dpgl.model.JDPodata;
import com.gavel.jingsu.dpgl.model.JDPomxdata;
import com.gavel.jingsu.dpgl.persistent.Dpxx;
import com.gavel.jingsu.dpgl.persistent.USaleorder;
import com.gavel.jingsu.dpgl.service.DpxxService;
import com.gavel.jingsu.dpgl.service.JDUSaleorderService;
import com.gavel.jingsu.dpgl.utils.SourceEnum;
import com.gavel.jingsu.dpgl.vo.USaleorderCondition;
import com.gavel.jingsu.dpgl.vo.USaleorderVO;
import com.gavel.jingsu.plat.jd.util.JDClientUtil;
import com.gavel.persistence.sql.RecordSet;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.http.HttpEntity;
import org.springframework.http.HttpHeaders;
import org.springframework.http.MediaType;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;
import org.springframework.web.client.RestTemplate;
import java.text.SimpleDateFormat;
import java.util.ArrayList;
import java.util.Calendar;
import java.util.Date;
import java.util.List;
@Service("jduSaleorderService")
@Transactional
public class JDUSaleorderServiceImpl extends BaseEditServiceImpl implements JDUSaleorderService {
private static final Logger LOG = LoggerFactory.getLogger(JDUSaleorderServiceImpl.class);
private static final SimpleDateFormat DATE_FORMAT = new SimpleDateFormat("yyyy-MM-dd");
private static final SimpleDateFormat DATETIME_FORMAT = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
@Autowired
private USaleorderDao uSaleorderDao;
@Autowired
private CommonService commonService;
@Autowired
private DpxxService dpxxService;
@Autowired
private RestTemplate restTemplate;
@Override
public void initService() {
addMaster( USaleorder.class);
}
@Override
public void beforeInsert(BaseEntity entity) {
if (entity instanceof USaleorder) {
USaleorder uSaleorder = (USaleorder)entity;
uSaleorder.setType(SourceEnum.JD.getId());
}
}
@Override
public RecordSet<USaleorderVO> query(USaleorderCondition condition) {
return uSaleorderDao.query(condition);
}
@Override
public void sync(JSONObject param) throws Exception {
List<Dpxx> dpxxs = dpxxService.loadJDDpxx();
if ( dpxxs!=null ) {
for (Dpxx dpxx : dpxxs) {
jdloadSaleOrder(dpxx.getDpbm(), JDClientUtil.PO_URL, JDClientUtil.MRO_TOKEN);
}
}
}
@Override
public void convert(List<USaleorder> uSaleorders) {
}
private void jdloadSaleOrder(String supplierCode,String url, String token) throws Exception {
Date now = Calendar.getInstance().getTime();
// 最后一次成功同步的订单时间
// 初始日期
Calendar calendar = Calendar.getInstance();
calendar.set(2021, 0, 1, 0, 0, 0);
// 获取最后一次同步时间
int days = commonService.getSequenceNotIncrease(supplierCode, "JD_SALE_ORDER_SYNC");
if ( days <= 0 ) {
days = 0;
}
calendar.add(Calendar.DAY_OF_MONTH, days);
Date start = calendar.getTime();
Date end = now;
if ( start.after(end) ) {
start = DateUtils.beginOfDay(now);
end = now;
} else {
// 结束时间
for (int i = 1; i <= 30; i++) {
days++;
calendar.add(Calendar.DAY_OF_MONTH, 1);
if ( calendar.getTime().after(now) ) {
calendar.setTime(now);
days--;
break;
}
}
end = calendar.getTime();
}
LOG.info("[订单同步 SYN]: " + DATE_FORMAT.format(DateUtils.beginOfDay(start)) + " - " + DATE_FORMAT.format(DateUtils.endOfDay(end)));
int total = 0;
int nextPageNo = 1;
int totalPageNo = 1;
final int size = 100;
JSONObject param = new JSONObject();
param.put("size",size);
param.put("beginDate",DATE_FORMAT.format(DateUtils.beginOfDay(start)));
param.put("endDate",DATE_FORMAT.format(DateUtils.endOfDay(end)));
HttpHeaders headers = new HttpHeaders();
headers.setContentType(MediaType.APPLICATION_JSON);
headers.set("Accept", "application/json");
headers.set("MRO-TOKEN",token);
while ( nextPageNo <= totalPageNo ) {
param.put("page",nextPageNo);
HttpEntity httpEntity = new HttpEntity<>(param, headers);
try {
JSONObject response = restTemplate.postForObject(url, httpEntity, JSONObject.class);
if ( response == null ) {
totalPageNo = 0;
continue;
}
if (StringUtils.isNotEmpty(response.getString("msg")) ) {
throw new RuntimeException(response.getString("code")+":"+response.getString("msg"));
}
nextPageNo =nextPageNo + 1;
totalPageNo =response.getInteger("totalPages");
List<JDPodata> jdPodataList = DataConvert.getData2List(response.getJSONArray("content"),JDPodata.class);
List<USaleorder> uSaleorderList = new ArrayList<>();
for (JDPodata jdPodata : jdPodataList) {
try {
for(JDPomxdata jdPomxdata : jdPodata.getOrderDetailList()){
USaleorder saleorder = new USaleorder();
saleorder.setDpbm(supplierCode);//店铺编码
saleorder.setOrderid(jdPodata.getCustomOrderId());//客单编码
saleorder.setMobilephone(jdPodata.getPhone());//手机
saleorder.setAddress(jdPodata.getAddress());//地址
saleorder.setProductcode(jdPomxdata.getSku());//商品编号
saleorder.setProductname(jdPomxdata.getWareName());//商品名称
saleorder.setSaleqty(jdPomxdata.getWareNum());//商品数量
saleorder.setPrice(jdPomxdata.getJdPrice());//商品价格
saleorder.setRemark(jdPodata.getOrderRemark());//订单备注
saleorder.setSaletime(DATETIME_FORMAT.format(jdPodata.getOrderCreateDate()));//发货日期
saleorder.setStatus(jdPodata.getOrderState());//订单状态
saleorder.setTelephone(jdPodata.getTelphone());//座机
saleorder.setWarecode(jdPodata.getVendorStoreId());//仓库id
saleorder.setZt("I");
saleorder.setTbsj(Calendar.getInstance().getTime());
saleorder.setType(SourceEnum.JD.getId());
saleorder.setCustomername(jdPodata.getConsigneeName());//客户
saleorder.setId(MD5Utils.md5Hex(saleorder.getOrderid() + "_" + saleorder.getProductcode()));
USaleorder exist = uSaleorderDao.queryById(USaleorder.class, saleorder.getId());
if ( exist==null ) {
uSaleorderDao.insert(saleorder);
} else {
saleorder.setZt(exist.getZt());
uSaleorderDao.update(saleorder);
}
uSaleorderList.add(saleorder);
LOG.info("订单明细:"+jdPomxdata.toString());
total++;
}
} catch (Exception e) {
LOG.error("订单[" + jdPodata.getParentOrderId() + "/" + jdPodata.getCommodityName() + "]: " + e.getMessage());
}
}
//convert(uSaleorderList);
} catch (Exception e) {
LOG.error("同步订单异常:"+e.getMessage());
}
}
commonService.setSequenceValue(supplierCode, "JD_SALE_ORDER_SYNC", days);
LOG.info("[订单同步 SYN]: " + DATE_FORMAT.format(DateUtils.beginOfDay(start)) + " - " + DATE_FORMAT.format(DateUtils.endOfDay(end)) + " ==> " + total);
}
}
package com.gavel.jingsu.dpgl.service.impl;
import com.alibaba.fastjson.JSONObject;
import com.gavel.common.base.service.impl.BaseEditServiceImpl;
import com.gavel.jingsu.dpgl.dao.UBrandDao;
import com.gavel.jingsu.dpgl.persistent.UBrand;
import com.gavel.jingsu.dpgl.service.UBrandService;
import com.gavel.jingsu.dpgl.vo.UBrandCondition;
import com.gavel.jingsu.dpgl.vo.UBrandVO;
import com.gavel.persistence.sql.RecordSet;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;
@Service("uBrandService")
@Transactional
public class UBrandServiceImpl extends BaseEditServiceImpl implements UBrandService {
@Autowired
private UBrandDao uBrandDao;
@Override
public void initService() {
addMaster( UBrand.class);
}
@Override
public RecordSet<UBrandVO> query(UBrandCondition condition) {
return uBrandDao.query(condition);
}
@Override
public void sync(JSONObject param) throws Exception {
}
}
package com.gavel.jingsu.dpgl.service.impl;
import com.alibaba.fastjson.JSONObject;
import com.gavel.common.base.service.impl.BaseEditServiceImpl;
import com.gavel.jingsu.dpgl.dao.UCategoryDao;
import com.gavel.jingsu.dpgl.persistent.UCategory;
import com.gavel.jingsu.dpgl.service.UCategoryService;
import com.gavel.jingsu.dpgl.vo.UCategoryCondition;
import com.gavel.jingsu.dpgl.vo.UCategoryVO;
import com.gavel.persistence.sql.RecordSet;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;
@Service("uCategoryService")
@Transactional
public class UCategoryServiceImpl extends BaseEditServiceImpl implements UCategoryService {
@Autowired
private UCategoryDao uCategoryDao;
@Override
public void initService() {
addMaster( UCategory.class);
}
@Override
public RecordSet<UCategoryVO> query(UCategoryCondition condition) {
return uCategoryDao.query(condition);
}
@Override
public void sync(JSONObject param) throws Exception {
}
@Override
public void convert(JSONObject param) {
}
}
package com.gavel.jingsu.dpgl.service.impl;
import com.alibaba.fastjson.JSONObject;
import com.gavel.common.base.service.impl.BaseEditServiceImpl;
import com.gavel.jingsu.dpgl.dao.UProductDao;
import com.gavel.jingsu.dpgl.persistent.UProduct;
import com.gavel.jingsu.dpgl.service.UProductService;
import com.gavel.jingsu.dpgl.vo.UProductCondition;
import com.gavel.jingsu.dpgl.vo.UProductVO;
import com.gavel.persistence.sql.RecordSet;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import java.text.SimpleDateFormat;
@Service("uProductService")
public class UProductServiceImpl extends BaseEditServiceImpl implements UProductService {
@Autowired
private UProductDao uProductDao;
private static final SimpleDateFormat DATE_FORMAT = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
@Override
public void initService() {
addMaster( UProduct.class);
}
@Override
public RecordSet<UProductVO> query(UProductCondition condition) {
return uProductDao.query(condition);
}
@Override
public void sync(JSONObject param) throws Exception {
}
@Override
public void convert(JSONObject param) {
}
}
package com.gavel.jingsu.dpgl.service.impl;
import com.alibaba.fastjson.JSONObject;
import com.gavel.common.base.entity.BaseEntity;
import com.gavel.common.base.service.impl.BaseEditServiceImpl;
import com.gavel.jingsu.dpgl.persistent.USaleorder;
import com.gavel.jingsu.dpgl.service.USaleorderService;
import com.gavel.jingsu.dpgl.utils.SourceEnum;
import com.gavel.jingsu.dpgl.vo.USaleorderCondition;
import com.gavel.jingsu.dpgl.vo.USaleorderVO;
import com.gavel.persistence.sql.RecordSet;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;
import java.text.SimpleDateFormat;
import java.util.List;
@Service("uSaleorderService")
@Transactional
public class USaleorderServiceImpl extends BaseEditServiceImpl implements USaleorderService {
private static final SimpleDateFormat DATE_FORMAT = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
@Override
public void initService() {
addMaster( USaleorder.class);
}
@Override
public void beforeInsert(BaseEntity entity) {
if (entity instanceof USaleorder) {
USaleorder uSaleorder = (USaleorder)entity;
uSaleorder.setType(SourceEnum.SUNING.getId());
}
}
@Override
public RecordSet<USaleorderVO> query(USaleorderCondition condition) {
return null;
}
@Override
public void sync(JSONObject param) throws Exception {
}
@Override
public void convert(JSONObject param) {
}
@Override
public void convert(List<USaleorderVO> uSaleorders) {
}
}
package com.gavel.jingsu.dpgl.utils;
public enum Source {
SUNING("suning");
private String code;
Source(String code) {
this.code = code;
}
public String code() {
return code;
}
}
package com.gavel.jingsu.dpgl.utils;
import com.gavel.kzzx.model.GavelEnumModel;
import java.util.ArrayList;
import java.util.List;
public enum SourceEnum {
JD("JD","京东"),
SUNING("SUNING","苏宁");
private String id;
private String name;
SourceEnum(String id, String name) {
this.id = id;
this.name = name;
}
public String getId() {
return id;
}
public void setId(String id) {
this.id = id;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public static List<GavelEnumModel> toList() {
List<GavelEnumModel> list = new ArrayList<>();
for (SourceEnum e : SourceEnum.values()) {
GavelEnumModel gavelEnumModel = new GavelEnumModel();
gavelEnumModel.setId(e.getId());
gavelEnumModel.setName(e.getName());
list.add(gavelEnumModel);
}
return list;
}
}
package com.gavel.jingsu.dpgl.vo;
import com.gavel.jingsu.dpgl.persistent.Dpxx;
public class DpxxVO extends Dpxx {
private static final long serialVersionUID = 1L;
/*---------AutoBegin-----------*/
/*---------AutoEnd-------------*/
}
This diff is collapsed.
This diff is collapsed.
This diff is collapsed.
This diff is collapsed.
This diff is collapsed.
This diff is collapsed.
This diff is collapsed.
This diff is collapsed.
This diff is collapsed.
This diff is collapsed.
This diff is collapsed.
This diff is collapsed.
This diff is collapsed.
This diff is collapsed.
This diff is collapsed.
This diff is collapsed.
This diff is collapsed.
This diff is collapsed.
This diff is collapsed.
This diff is collapsed.
This diff is collapsed.
This diff is collapsed.
This diff is collapsed.
This diff is collapsed.
This diff is collapsed.
This diff is collapsed.
This diff is collapsed.
This diff is collapsed.
This diff is collapsed.
This diff is collapsed.
This diff is collapsed.
This diff is collapsed.
This diff is collapsed.
This diff is collapsed.
This diff is collapsed.
This diff is collapsed.
This diff is collapsed.
This diff is collapsed.
This diff is collapsed.
This diff is collapsed.
This diff is collapsed.
This diff is collapsed.
This diff is collapsed.
This diff is collapsed.
This diff is collapsed.
This diff is collapsed.
This diff is collapsed.
This diff is collapsed.
This diff is collapsed.
This diff is collapsed.
This diff is collapsed.
This diff is collapsed.
This diff is collapsed.
This diff is collapsed.
This diff is collapsed.
This diff is collapsed.
This diff is collapsed.
This diff is collapsed.
This diff is collapsed.
This diff is collapsed.
This diff is collapsed.
This diff is collapsed.
This diff is collapsed.
This diff is collapsed.
This diff is collapsed.
This diff is collapsed.
This diff is collapsed.
This diff is collapsed.
This diff is collapsed.
This diff is collapsed.
This diff is collapsed.
This diff is collapsed.
This diff is collapsed.
This diff is collapsed.
This diff is collapsed.
This diff is collapsed.
This diff is collapsed.
This diff is collapsed.
This diff is collapsed.
This diff is collapsed.
This diff is collapsed.
This diff is collapsed.
This diff is collapsed.
This diff is collapsed.
This diff is collapsed.
This diff is collapsed.
This diff is collapsed.
This diff is collapsed.
This diff is collapsed.
This diff is collapsed.
This diff is collapsed.
This diff is collapsed.
This diff is collapsed.
This diff is collapsed.
This diff is collapsed.
This diff is collapsed.
This diff is collapsed.
This diff is collapsed.
This diff is collapsed.
This diff is collapsed.
This diff is collapsed.
This diff is collapsed.
This diff is collapsed.
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