Skip to content

caosy / fun-golf-mobile

Go to a project
Commit 257908e8 by caosy
Options

submit the old f-decoup

parents
Expand all
Inline Side-by-side
Showing with 4843 additions and 0 deletions
.checkstyle 0 → 100644
<?xml version="1.0" encoding="UTF-8"?>
<fileset-config file-format-version="1.2.0" simple-config="true" sync-formatter="false">
<fileset name="all" enabled="true" check-config-name="Sun Checks" local="false">
<file-match-pattern match-pattern="." include-pattern="true"/>
</fileset>
</fileset-config>
.gitattributes 0 → 100644
#* text eol=lf
.gitignore 0 → 100644
.project
.settings/
target/
.classpath
.springBeans
*.iml
.idea
/build
log
*.bak
/ConfigProfile.xml
.DS_Store
__ConfigTemp/
fun-golf-mobile.wiki @ e88404ad
Subproject commit e88404ad0715de26689dd3ccb3f7b0ebe8573766
pom.xml 0 → 100644
<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.ctrip.fun.golf</groupId>
<artifactId>fun-golf-mobile</artifactId>
<version>0.0.1-SNAPSHOT</version>
<packaging>war</packaging>
<name>fun-golf-mobile</name>
<url>http://maven.apache.org</url>
<properties>
<project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
<version.spring>3.2.5.RELEASE</version.spring>
<version.hibernate>4.1.8.Final</version.hibernate>
<version.hibernate-validator>4.3.1.Final</version.hibernate-validator>
<version.dbcp>1.4</version.dbcp>
<version.cglib>2.2.2</version.cglib>
<version.aspectjweaver>1.7.1</version.aspectjweaver>
<version.mysql>5.1.25</version.mysql>
<version.jackson>2.2.3</version.jackson>
<version.slf4j>1.7.5</version.slf4j>
<version-beanutils>1.9.1</version-beanutils>
<version.ehcache>2.8.2</version.ehcache>
<version.swagger-springmvc>1.0.2</version.swagger-springmvc>
</properties>
<dependencies>
<dependency>
<groupId>junit</groupId>
<artifactId>junit</artifactId>
<version>3.8.1</version>
<scope>test</scope>
</dependency>
<dependency>
<groupId>com.fasterxml.jackson.core</groupId>
<artifactId>jackson-databind</artifactId>
<version>${version.jackson}</version>
</dependency>
<dependency>
<groupId>commons-dbcp</groupId>
<artifactId>commons-dbcp</artifactId>
<version>${version.dbcp}</version>
</dependency>
<dependency>
<groupId>mysql</groupId>
<artifactId>mysql-connector-java</artifactId>
<version>${version.mysql}</version>
</dependency>
<!-- // org.springframework -->
<dependency>
<groupId>org.springframework</groupId>
<artifactId>spring-core</artifactId>
<version>${version.spring}</version>
</dependency>
<dependency>
<groupId>org.springframework</groupId>
<artifactId>spring-context</artifactId>
<version>${version.spring}</version>
</dependency>
<dependency>
<groupId>org.springframework</groupId>
<artifactId>spring-tx</artifactId>
<version>${version.spring}</version>
</dependency>
<dependency>
<groupId>org.springframework</groupId>
<artifactId>spring-webmvc</artifactId>
<version>${version.spring}</version>
</dependency>
<dependency>
<groupId>org.springframework</groupId>
<artifactId>spring-orm</artifactId>
<version>${version.spring}</version>
</dependency>
<dependency>
<groupId>org.springframework</groupId>
<artifactId>spring-context-support</artifactId>
<version>${version.spring}</version>
</dependency>
<dependency>
<groupId>org.aspectj</groupId>
<artifactId>aspectjweaver</artifactId>
<version>${version.aspectjweaver}</version>
</dependency>
<dependency>
<groupId>cglib</groupId>
<artifactId>cglib-nodep</artifactId>
<version>${version.cglib}</version>
</dependency>
<dependency>
<groupId>net.sf.ehcache</groupId>
<artifactId>ehcache</artifactId>
<version>${version.ehcache}</version>
</dependency>
<!-- Logging -->
<dependency>
<groupId>org.slf4j</groupId>
<artifactId>slf4j-api</artifactId>
<version>1.7.6</version>
</dependency>
<dependency>
<groupId>ch.qos.logback</groupId>
<artifactId>logback-classic</artifactId>
<version>1.1.2</version>
</dependency>
<dependency>
<groupId>org.slf4j</groupId>
<artifactId>jcl-over-slf4j</artifactId>
<version>1.7.6</version>
</dependency>
<dependency>
<groupId>net.logstash.logback</groupId>
<artifactId>logstash-logback-encoder</artifactId>
<version>4.3</version>
</dependency>
<dependency>
<groupId>org.apache.httpcomponents</groupId>
<artifactId>httpcore</artifactId>
<version>4.3.2</version>
</dependency>
<dependency>
<groupId>org.apache.httpcomponents</groupId>
<artifactId>httpclient</artifactId>
<version>4.3.4</version>
</dependency>
<dependency>
<groupId>dom4j</groupId>
<artifactId>dom4j</artifactId>
<version>1.6.1</version>
</dependency>
<!-- commons-beanutils -->
<dependency>
<groupId>commons-beanutils</groupId>
<artifactId>commons-beanutils</artifactId>
<version>${version-beanutils}</version>
</dependency>
<!-- Servlet -->
<dependency>
<groupId>javax.servlet</groupId>
<artifactId>servlet-api</artifactId>
<version>2.5</version>
<scope>provided</scope>
</dependency>
<dependency>
<groupId>javax.servlet.jsp</groupId>
<artifactId>jsp-api</artifactId>
<version>2.1</version>
<scope>provided</scope>
</dependency>
<dependency>
<groupId>javax.servlet</groupId>
<artifactId>jstl</artifactId>
<version>1.2</version>
</dependency>
<dependency>
<groupId>com.ctrip.fun</groupId>
<artifactId>fun-common-vo</artifactId>
<version>1.0.3-SNAPSHOT</version>
</dependency>
<dependency>
<groupId>com.ctrip.fun</groupId>
<artifactId>fun-common-core</artifactId>
<version>1.0.3-SNAPSHOT</version>
</dependency>
<dependency>
<groupId>org.neo4j</groupId>
<artifactId>neo4j-cypher-compiler-2.0</artifactId>
<version>2.0.3</version>
</dependency>
<dependency>
<groupId>com.google.code.gson</groupId>
<artifactId>gson</artifactId>
<version>2.3</version>
</dependency>
<dependency>
<groupId>commons-fileupload</groupId>
<artifactId>commons-fileupload</artifactId>
<version>1.2</version>
</dependency>
<dependency>
<groupId>commons-io</groupId>
<artifactId>commons-io</artifactId>
<version>2.4</version>
</dependency>
<!--swagger -->
<dependency>
<groupId>taglibs</groupId>
<artifactId>standard</artifactId>
<version>1.1.2</version>
</dependency>
<dependency>
<groupId>com.mangofactory</groupId>
<artifactId>swagger-springmvc</artifactId>
<version>${version.swagger-springmvc}</version>
</dependency>
<dependency>
<groupId>org.springframework</groupId>
<artifactId>spring-web</artifactId>
<version>${version.spring}</version>
</dependency>
<dependency>
<groupId>org.springframework</groupId>
<artifactId>spring-beans</artifactId>
<version>${version.spring}</version>
</dependency>
</dependencies>
<build>
<resources>
<resource>
<directory>src/main/resources</directory>
<filtering>true</filtering>
<!-- 资源根目录排除各环境的配置，使用单独的资源目录来指定 -->
<excludes>
<exclude>test/*</exclude>
<exclude>production/*</exclude>
<exclude>development/*</exclude>
<exclude>debug/*</exclude>
</excludes>
</resource>
</resources>
<finalName>fun-golf-mobile</finalName>
<pluginManagement>
<plugins>
<plugin>
<groupId>org.apache.maven.plugins</groupId>
<artifactId>maven-compiler-plugin</artifactId>
<version>3.1</version>
<configuration>
<source>1.7</source>
<target>1.7</target>
</configuration>
</plugin>
</plugins>
</pluginManagement>
</build>
<profiles>
<profile>
<id>development</id>
<activation>
<activeByDefault>true</activeByDefault>
</activation>
<build>
<filters>
<filter>src/main/resources/development/rpc.properties</filter>
<filter>src/main/resources/development/logback.properties</filter>
</filters>
</build>
</profile>
<profile>
<id>debug</id>
<build>
<filters>
<filter>src/main/resources/debug/rpc.properties</filter>
<filter>src/main/resources/debug/logback.properties</filter>
</filters>
</build>
</profile>
<profile>
<id>test</id>
<build>
<filters>
<filter>src/main/resources/test/rpc.properties</filter>
<filter>src/main/resources/test/logback.properties</filter>
</filters>
</build>
</profile>
<profile>
<id>production</id>
<build>
<filters>
<filter>src/main/resources/production/rpc.properties</filter>
<filter>src/main/resources/production/logback.properties</filter>
</filters>
</build>
</profile>
<profile>
<id>uat</id>
<build>
<filters>
<filter>src/main/resources/uat/rpc.properties</filter>
<filter>src/main/resources/uat/logback.properties</filter>
</filters>
</build>
</profile>
</profiles>
</project>
src/main/java/com/ctrip/fun/golf/api/advert/CampaignController.java 0 → 100644
package com.ctrip.fun.golf.api.advert;
import java.io.Serializable;
import java.util.HashMap;
import java.util.Map;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
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.ctrip.fun.common.vo.Response;
import com.ctrip.fun.common.vo.ResponseStatusEnum;
import com.ctrip.fun.common.vo.advert.CampaignTickRequestBean;
import com.ctrip.fun.golf.service.advert.CampaignService;
/**
* Created by l_cheng on 2014/11/17.
*/
@Controller
@RequestMapping(value = "/campaign")
public class CampaignController {
private static final Logger logger = LoggerFactory.getLogger(CampaignController.class);
@Autowired
private CampaignService campaignService;
public CampaignService getCampaignService() {
return campaignService;
}
public void setCampaignService(CampaignService campaignService) {
this.campaignService = campaignService;
}
@ResponseBody
@RequestMapping(value = "/tick", method = RequestMethod.POST)
public Response<Serializable> tick(@RequestBody CampaignTickRequestBean request) {
Response<Serializable> response = new Response<>();
response.setStatusEnum(ResponseStatusEnum.SUCCESS);
try {
campaignService.tick(request);
} catch (Exception ex) {
Map<String, String> tags = new HashMap<>();
tags.put("params", request.toString());
logger.error(ex.getMessage(), ex, tags);
response.setStatusEnum(ResponseStatusEnum.FAIL);
}
return response;
}
}
src/main/java/com/ctrip/fun/golf/api/basic/CommuneNoticeController.java 0 → 100644
package com.ctrip.fun.golf.api.basic;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RequestMethod;
import org.springframework.web.bind.annotation.ResponseBody;
import com.ctrip.fun.common.vo.basic.insideSms.InsideSmsBean;
import com.ctrip.fun.common.vo.basic.insideSms.InsideSmsQuery;
import com.ctrip.fun.common.vo.basic.insideSms.InsideSmsTypeEnum;
import com.ctrip.fun.golf.service.basic.InsideSmsService;
import com.ctrip.fun.golf.service.user.UserMService;
/**
* @author gaoc
*/
@Controller
@RequestMapping(value = "/communeNotice")
public class CommuneNoticeController {
@Autowired
private InsideSmsService insideSmsService = null;
@Autowired
private UserMService userService = null;
/**
* 获取公社通告信息列表
*/
@ResponseBody
@RequestMapping(value = "/list", method = RequestMethod.GET, params = { "pagerPerPage", "pagerOffset" })
public Object queryListAll(InsideSmsQuery query) {
query.setType(InsideSmsTypeEnum.COMMUNE.getValue());
return insideSmsService.queryListAll(query);
}
/**
* 根据信息id获取公社通告详细
*/
@ResponseBody
@RequestMapping(value = "/getById", method = RequestMethod.GET, params = { "id" })
public Object getByIdForAll(Integer id) {
InsideSmsBean bean = insideSmsService.getByIdForAll(id);
if (bean != null && bean.getType() != null && bean.getType() == InsideSmsTypeEnum.COMMUNE.getValue()) {
return bean;
}
return null;
}
}
src/main/java/com/ctrip/fun/golf/api/basic/DistrictMController.java 0 → 100644
package com.ctrip.fun.golf.api.basic;
import java.text.SimpleDateFormat;
import java.util.ArrayList;
import java.util.Date;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RequestMethod;
import org.springframework.web.bind.annotation.RequestParam;
import org.springframework.web.bind.annotation.ResponseBody;
import com.ctrip.fun.common.vo.ResponseError;
import com.ctrip.fun.common.vo.basic.GetDistrictWeatherForecastRequestDTO;
import com.ctrip.fun.common.vo.basic.GetDistrictWeatherForecastResponseDTO;
import com.ctrip.fun.golf.service.basic.DistrictMService;
/**
*
* @author Humt
*
*/
@Controller
@RequestMapping(value = "")
public class DistrictMController {
@Autowired
private DistrictMService districtService=null;
public DistrictMService getDistrictService() {
return districtService;
}
public void setDistrictService(DistrictMService districtService) {
this.districtService = districtService;
}
@ResponseBody
@RequestMapping(value = "/v1/districtWeatherForecasts", method = RequestMethod.GET, params = { "districtId"})
public Object GetDistrictWeatherForecast(@RequestParam Long districtId)
{
GetDistrictWeatherForecastRequestDTO request=new GetDistrictWeatherForecastRequestDTO();
List<Long> districtIds=new ArrayList<Long>();
districtIds.add(districtId);
request.setDate((new SimpleDateFormat("yyyy-MM-dd")).format(new Date()));
request.setDistrictIds(districtIds);
request.setDayCount(3);
request.setVersion(1);
GetDistrictWeatherForecastResponseDTO response=districtService.CallGetDistrictWeatherForecast(request);
if(response!=null && response.getResult()!=null && response.getResult().size()>0 && response.getResult().get(0).getWeatherForecasts().size()>0)
{
Map map = new HashMap();
List<Map> result = new ArrayList();
for(Integer i=0; i<response.getResult().get(0).getWeatherForecasts().size(); i++)
{
Map mp = new HashMap();
mp.put("date", response.getResult().get(0).getWeatherForecasts().get(i).getForecastDate());
mp.put("dayWeatheNo", response.getResult().get(0).getWeatherForecasts().get(i).getDayWeatheNo());
mp.put("dayWeatherName", response.getResult().get(0).getWeatherForecasts().get(i).getDayWeatherName());
mp.put("dayTemperature", response.getResult().get(0).getWeatherForecasts().get(i).getDayTemperature());
mp.put("dayWeatherImg", response.getResult().get(0).getWeatherForecasts().get(i).getDayWeatherImg());
mp.put("nightWeatheNo", response.getResult().get(0).getWeatherForecasts().get(i).getNightWeatheNo());
mp.put("nightWeatherName", response.getResult().get(0).getWeatherForecasts().get(i).getNightWeatherName());
mp.put("nightTemperature", response.getResult().get(0).getWeatherForecasts().get(i).getNightTemperature());
mp.put("nightWeatherImg", response.getResult().get(0).getWeatherForecasts().get(i).getNightWeatherImg());
result.add(mp);
}
map.put("count", response.getResult().get(0).getWeatherForecasts().size());
map.put("weathers", result);
return map;
}
else
{
ResponseError err=new ResponseError();
err.setCode(-1);
err.setMessage("获取天气数据失败！");
return err;
}
}
@ResponseBody
@RequestMapping(value = "/v2/courseWeatherForecasts", method = RequestMethod.GET, params = { "courseId"})
public Object GetCourseWeatherForecast(@RequestParam Long courseId)
{
GetDistrictWeatherForecastRequestDTO request=new GetDistrictWeatherForecastRequestDTO();
List<Long> districtIds=new ArrayList<Long>();
districtIds.add(courseId);
request.setDate((new SimpleDateFormat("yyyy-MM-dd")).format(new Date()));
request.setDistrictIds(districtIds);
request.setDayCount(3);
request.setVersion(2);
GetDistrictWeatherForecastResponseDTO response=districtService.CallGetDistrictWeatherForecast(request);
if(response!=null && response.getResult()!=null && response.getResult().size()>0 && response.getResult().get(0).getWeatherForecasts().size()>0)
{
Map map = new HashMap();
List<Map> result = new ArrayList();
for(Integer i=0; i<response.getResult().get(0).getWeatherForecasts().size(); i++)
{
Map mp = new HashMap();
mp.put("date", response.getResult().get(0).getWeatherForecasts().get(i).getForecastDate());
mp.put("dayWeatheNo", response.getResult().get(0).getWeatherForecasts().get(i).getDayWeatheNo());
mp.put("dayWeatherName", response.getResult().get(0).getWeatherForecasts().get(i).getDayWeatherName());
mp.put("dayTemperature", response.getResult().get(0).getWeatherForecasts().get(i).getDayTemperature());
mp.put("dayWeatherImg", response.getResult().get(0).getWeatherForecasts().get(i).getDayWeatherImg());
mp.put("nightWeatheNo", response.getResult().get(0).getWeatherForecasts().get(i).getNightWeatheNo());
mp.put("nightWeatherName", response.getResult().get(0).getWeatherForecasts().get(i).getNightWeatherName());
mp.put("nightTemperature", response.getResult().get(0).getWeatherForecasts().get(i).getNightTemperature());
mp.put("nightWeatherImg", response.getResult().get(0).getWeatherForecasts().get(i).getNightWeatherImg());
result.add(mp);
}
map.put("count", response.getResult().get(0).getWeatherForecasts().size());
map.put("weathers", result);
return map;
}
else
{
ResponseError err=new ResponseError();
err.setCode(-1);
err.setMessage("获取天气数据失败！");
return err;
}
}
}
src/main/java/com/ctrip/fun/golf/api/basic/ExpressController.java 0 → 100644
package com.ctrip.fun.golf.api.basic;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RequestMethod;
import org.springframework.web.bind.annotation.RequestParam;
import org.springframework.web.bind.annotation.ResponseBody;
import com.ctrip.fun.common.vo.basic.ExpressBean;
import com.ctrip.fun.golf.service.basic.ExpressService;
/**
* @author gaoc
*/
@Controller
@RequestMapping(value = "/express")
public class ExpressController {
@Autowired
private ExpressService expressService = null;
@ResponseBody
@RequestMapping(value = "/change", method = RequestMethod.POST)
public Object QueryVoucherListAction(@RequestParam String param, @RequestParam String sign) {
return expressService.mergeExpress(param, sign);
}
@ResponseBody
@RequestMapping(value = "/get", method = RequestMethod.GET)
public Object get(@RequestParam String expressNo) {
ExpressBean bean = expressService.getByExpressNo(expressNo);
if (bean != null) {
return bean;
} else {
return new ExpressBean();
}
}
}
src/main/java/com/ctrip/fun/golf/api/basic/InsideSmsController.java 0 → 100644
package com.ctrip.fun.golf.api.basic;
import java.util.HashMap;
import java.util.Map;
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.RequestParam;
import org.springframework.web.bind.annotation.ResponseBody;
import com.ctrip.fun.common.vo.basic.insideSms.InsideSmsQuery;
import com.ctrip.fun.common.vo.basic.insideSms.InsideSmsTypeEnum;
import com.ctrip.fun.common.vo.basic.insideSms.InsideSmsUsrBean;
import com.ctrip.fun.common.vo.basic.insideSms.InsideSmsUsrQuery;
import com.ctrip.fun.common.vo.basic.insideSms.InsideSmsUsrStatusEnum;
import com.ctrip.fun.golf.secrity.Security;
import com.ctrip.fun.golf.secrity.UserContext;
import com.ctrip.fun.golf.service.basic.InsideSmsService;
import com.ctrip.fun.golf.service.user.UserMService;
/**
* @author gaoc
*/
@Controller
@RequestMapping(value = "/insideSms")
public class InsideSmsController {
@Autowired
private InsideSmsService insideSmsService = null;
@Autowired
private UserMService userService = null;
/**
* 获取站内未读信息总数
*/
@ResponseBody
@RequestMapping(value = "/countNotView", method = RequestMethod.GET, params = { "token" })
public Object countNotView(@RequestParam String token) {
String uid = null;
try {
uid = userService.getUserId(token);
} catch (Exception e) {
}
long count = insideSmsService.countNotView(uid);
Map<String, Long> map = new HashMap<String, Long>();
map.put("count", count);
return map;
}
/**
* 获取个人站内信息列表
*/
@ResponseBody
@Security
@RequestMapping(value = "/queryListOne", method = RequestMethod.GET, params = { "token", "pagerOffset", "pagerPerPage" })
public Object queryList(@RequestParam String token, InsideSmsUsrQuery query) {
String uid = null;
try {
uid = userService.getUserId(token);
query.setUid(uid);
} catch (Exception e) {
}
return insideSmsService.queryList(query);
}
/**
* 获取群发站内信息列表
*/
@ResponseBody
@RequestMapping(value = "/queryListAll", method = RequestMethod.GET, params = { "pagerPerPage" })
public Object queryListAll(InsideSmsQuery query) {
query.setPagerOffset(0);
query.setType(InsideSmsTypeEnum.ALL.getValue());
return insideSmsService.queryListAll(query);
}
/**
* 根据用户UID和信息id获取信息详细
*/
@ResponseBody
@Security
@RequestMapping(value = "/getById", method = RequestMethod.GET, params = { "token", "id" })
public Object getById(@RequestParam String token, InsideSmsUsrQuery query) {
String uid = null;
try {
uid = userService.getUserId(token);
query.setUid(uid);
} catch (Exception e) {
}
return insideSmsService.findByIdAndUid(query);
}
/**
* 根据信息id获取群发信息详细
*/
@ResponseBody
@RequestMapping(value = "/getByIdForAll", method = RequestMethod.GET, params = { "id" })
public Object getByIdForAll(Integer id) {
return insideSmsService.getByIdForAll(id);
}
/**
* 修改单条站内信息状态 已读
*/
@Security(index = 1, field = "token")
@ResponseBody
@RequestMapping(value = "/viewStatus", method = RequestMethod.POST)
public Object viewStatus(@RequestBody InsideSmsUsrBean bean) {
bean.setStatus(InsideSmsUsrStatusEnum.VIEWED.getValue());
Integer status = insideSmsService.updateStatus(UserContext.getUserId(), bean);
Map<String, Integer> map = new HashMap<String, Integer>();
map.put("status", status);
return map;
}
/**
* 修改单条站内信息状态 删除
*/
@Security(index = 1, field = "token")
@ResponseBody
@RequestMapping(value = "/deleteStatus", method = RequestMethod.POST)
public Object deleteStatus(@RequestBody InsideSmsUsrBean bean) {
bean.setStatus(InsideSmsUsrStatusEnum.DELETED.getValue());
Integer status = insideSmsService.updateStatus(UserContext.getUserId(), bean);
Map<String, Integer> map = new HashMap<String, Integer>();
map.put("status", status);
return map;
}
/**
* 用户信息全部已读
*/
@Security(index = 1, field = "token")
@ResponseBody
@RequestMapping(value = "/viewAll", method = RequestMethod.POST)
public Object viewAll(@RequestBody InsideSmsUsrBean bean) {
Integer status = insideSmsService.viewAll(UserContext.getUserId());
Map<String, Integer> map = new HashMap<String, Integer>();
map.put("status", status);
return map;
}
/**
* 用户信息全部删除
*/
@Security(index = 1, field = "token")
@ResponseBody
@RequestMapping(value = "/deleteAll", method = RequestMethod.POST)
public Object deleteAll(@RequestBody InsideSmsUsrBean bean) {
Integer status = insideSmsService.deleteAll(UserContext.getUserId());
Map<String, Integer> map = new HashMap<String, Integer>();
map.put("status", status);
return map;
}
}
src/main/java/com/ctrip/fun/golf/api/basic/LuckMController.java 0 → 100644
package com.ctrip.fun.golf.api.basic;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Controller;
import org.springframework.util.StringUtils;
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.ctrip.fun.common.vo.Request;
import com.ctrip.fun.common.vo.basic.luckclient.LuckClientActivityQuery;
import com.ctrip.fun.common.vo.basic.luckclient.LuckClientActivityShareBean;
import com.ctrip.fun.common.vo.basic.luckclient.LuckClientPrizeDrawBean;
import com.ctrip.fun.golf.secrity.Security;
import com.ctrip.fun.golf.secrity.UserContext;
import com.ctrip.fun.golf.service.basic.LuckMService;
import com.ctrip.fun.golf.service.user.UserMService;
@Controller
@RequestMapping(value = "/luck")
public class LuckMController {
@Autowired
private LuckMService luckMService = null;
@Autowired
private UserMService userService = null;
/**
* 查询活动
*/
@ResponseBody
@RequestMapping(value = "/getActivity", method = RequestMethod.GET, params = { "token", "type" })
public Object getActivity(LuckClientActivityQuery queryBean) {
Request<LuckClientActivityQuery> request = new Request<LuckClientActivityQuery>();
if (StringUtils.hasText(queryBean.getToken())) {
String uid = null;
try {
uid = userService.getUserId(queryBean.getToken());
} catch (Exception e) {
}
queryBean.setUid(uid);
request.setUserId(uid);
}
request.setBody(queryBean);
return luckMService.getActivity(request);
}
/**
* 活动抽奖
*/
@ResponseBody
@Security(index = 1, field = "token")
@RequestMapping(value = "/luckDraw", method = RequestMethod.POST)
public Object luckDraw(@RequestBody LuckClientPrizeDrawBean bean) {
Request<LuckClientPrizeDrawBean> request = new Request<LuckClientPrizeDrawBean>();
String uid = UserContext.getUserId();
bean.setUid(uid);
request.setUserId(uid);
request.setBody(bean);
return luckMService.luckDraw(request);
}
/**
* 活动分享
*/
@ResponseBody
@Security(index = 1, field = "token")
@RequestMapping(value = "/share", method = RequestMethod.POST)
public Object share(@RequestBody LuckClientActivityShareBean bean) {
Request<LuckClientActivityShareBean> request = new Request<LuckClientActivityShareBean>();
String uid = UserContext.getUserId();
bean.setUid(uid);
request.setUserId(uid);
request.setBody(bean);
return luckMService.share(request);
}
}
src/main/java/com/ctrip/fun/golf/api/basic/PrePayCardController.java 0 → 100644
package com.ctrip.fun.golf.api.basic;
import java.util.HashMap;
import java.util.Map;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
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.RequestParam;
import org.springframework.web.bind.annotation.ResponseBody;
import com.ctrip.fun.common.vo.Request;
import com.ctrip.fun.common.vo.Response;
import com.ctrip.fun.common.vo.ResponseStatusEnum;
import com.ctrip.fun.common.vo.basic.PrePayCardBean;
import com.ctrip.fun.golf.service.basic.PrePayCardService;
@Controller
@RequestMapping(value = "/prepaycard")
public class PrePayCardController {
private static final Logger logger = LoggerFactory.getLogger(PrePayCardController.class);
@Autowired
private PrePayCardService prePayCardService;
@ResponseBody
@RequestMapping(value = "/get", method = RequestMethod.GET, params = { "cardId", "password" })
public Object get(@RequestParam String cardId, @RequestParam String password) {
Response<PrePayCardBean> response = null;
try {
PrePayCardBean vo = new PrePayCardBean();
vo.setCardId(cardId);
vo.setPassword(password);
response = prePayCardService.getByCardIdAndPassword(vo);
} catch (Exception ex) {
Map<String, String> tags = new HashMap<>();
tags.put("cardId", cardId);
tags.put("password", password);
logger.error(ex.getMessage(), ex, tags);
response = new Response<PrePayCardBean>();
response.setStatusEnum(ResponseStatusEnum.FAIL);
}
return response;
}
@RequestMapping(value = "/usePrePayCard", method = RequestMethod.POST)
@ResponseBody
public Object usePrePayCard(@RequestBody PrePayCardBean prePayCardBean) {
Response<Object> response = null;
Request<PrePayCardBean> request = new Request<PrePayCardBean>();
request.setBody(prePayCardBean);
try {
response = prePayCardService.updateStatusUsed(request);
} catch (Exception ex) {
Map<String, String> tags = new HashMap<>();
tags.put("prePayCardBean", prePayCardBean.toString());
logger.error(ex.getMessage(), ex, tags);
response = new Response<Object>();
response.setStatusEnum(ResponseStatusEnum.FAIL);
}
return response;
}
}
src/main/java/com/ctrip/fun/golf/api/basic/SignMController.java 0 → 100644
package com.ctrip.fun.golf.api.basic;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Controller;
import org.springframework.util.StringUtils;
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.ctrip.fun.common.vo.Request;
import com.ctrip.fun.common.vo.basic.signclient.SignClientRequestBean;
import com.ctrip.fun.golf.secrity.Security;
import com.ctrip.fun.golf.secrity.UserContext;
import com.ctrip.fun.golf.service.basic.SignMService;
import com.ctrip.fun.golf.service.user.UserMService;
@Controller
@RequestMapping(value = "/sign")
public class SignMController {
@Autowired
private SignMService signMService = null;
@Autowired
private UserMService userService = null;
/**
* 查询签到活动
*/
@ResponseBody
@RequestMapping(value = "/getSignConfig", method = RequestMethod.GET, params = { "token" })
public Object getActivity(SignClientRequestBean queryBean) {
Request<SignClientRequestBean> request = new Request<SignClientRequestBean>();
if (StringUtils.hasText(queryBean.getToken())) {
String uid = null;
try {
uid = userService.getUserId(queryBean.getToken());
} catch (Exception e) {
}
queryBean.setUid(uid);
request.setUserId(uid);
}
request.setBody(queryBean);
return signMService.getSignConfig(request);
}
/**
* 签到
*/
@ResponseBody
@Security(index = 1, field = "token")
@RequestMapping(value = "/sign", method = RequestMethod.POST)
public Object sign(@RequestBody SignClientRequestBean bean) {
Request<SignClientRequestBean> request = new Request<SignClientRequestBean>();
String uid = UserContext.getUserId();
bean.setUid(uid);
request.setUserId(uid);
request.setBody(bean);
return signMService.sign(request);
}
}
src/main/java/com/ctrip/fun/golf/api/basic/UserPrepayCardLogMController.java 0 → 100644
package com.ctrip.fun.golf.api.basic;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RequestMethod;
import org.springframework.web.bind.annotation.RequestParam;
import org.springframework.web.bind.annotation.ResponseBody;
import com.ctrip.fun.common.vo.Request;
import com.ctrip.fun.common.vo.Response;
import com.ctrip.fun.common.vo.ResponseError;
import com.ctrip.fun.common.vo.basic.UserPrepayCardInfoBean;
import com.ctrip.fun.common.vo.basic.UserPrepayCardLogQuery;
import com.ctrip.fun.golf.secrity.Security;
import com.ctrip.fun.golf.secrity.UserContext;
import com.ctrip.fun.golf.service.basic.UserPrepayCardLogMService;
/**
*
* @author jgsong
*
*/
@Controller
@RequestMapping(value = "")
public class UserPrepayCardLogMController {
private Logger logger = LoggerFactory.getLogger(UserPrepayCardLogMController.class);
@Autowired
private UserPrepayCardLogMService userPrepayCardLogMService = null;
public UserPrepayCardLogMService getUserPrepayCardLogMService() {
return userPrepayCardLogMService;
}
public void setUserPrepayCardLogMService(
UserPrepayCardLogMService userPrepayCardLogMService) {
this.userPrepayCardLogMService = userPrepayCardLogMService;
}
@ResponseBody
@Security
@RequestMapping(value = "/v1/me/prepayCardLogs", method = RequestMethod.GET,params = { "token", "pagerOffset", "pagerPerPage" })
public Object prepayCardLogsAction(@RequestParam String token, @RequestParam int pagerOffset, @RequestParam int pagerPerPage ){
UserPrepayCardLogQuery userPrepayCardLogQuery = new UserPrepayCardLogQuery();
Request<UserPrepayCardLogQuery> request=new Request<UserPrepayCardLogQuery>();
String uid=UserContext.getUserId();
request.setUserId(uid);
userPrepayCardLogQuery.setUid(uid);
userPrepayCardLogQuery.setPagerOffset(pagerOffset);
userPrepayCardLogQuery.setPageSize(pagerPerPage);
request.setBody(userPrepayCardLogQuery);
Response<UserPrepayCardInfoBean> response= userPrepayCardLogMService.prepayCardLogs(request);
if(response.getStatus()==-1)
{
ResponseError err=new ResponseError();
err.setCode(response.getStatus());
err.setMessage(response.getMessage());
return err;
}
return response.getBody();
}
}
src/main/java/com/ctrip/fun/golf/api/basic/VoucherMController.java 0 → 100644
package com.ctrip.fun.golf.api.basic;
import java.text.SimpleDateFormat;
import java.util.ArrayList;
import java.util.Collection;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RequestMethod;
import org.springframework.web.bind.annotation.RequestParam;
import org.springframework.web.bind.annotation.ResponseBody;
import com.ctrip.fun.common.vo.PagedResponseBean;
import com.ctrip.fun.common.vo.Request;
import com.ctrip.fun.common.vo.Response;
import com.ctrip.fun.common.vo.ResponseError;
import com.ctrip.fun.common.vo.SortDirectionEnum;
import com.ctrip.fun.common.vo.basic.VoucherItemDTO;
import com.ctrip.fun.common.vo.basic.VoucherQueryDto;
import com.ctrip.fun.common.vo.basic.VoucherQueryRequestDTO;
import com.ctrip.fun.golf.secrity.Security;
import com.ctrip.fun.golf.secrity.UserContext;
import com.ctrip.fun.golf.service.basic.VoucherMService;
/**
*
* @author Humt
*
*/
@Controller
@RequestMapping(value = "")
public class VoucherMController {
@Autowired
private VoucherMService voucherService = null;
public VoucherMService getVoucherService() {
return voucherService;
}
public void setVoucherService(VoucherMService voucherService) {
this.voucherService = voucherService;
}
@ResponseBody
@Security
@RequestMapping(value = "/v2/vouchers", method = RequestMethod.GET, params = { "token", "sortType", "pagerOffset", "pagerPerPage", "voucherType", "used", "sortDirection" })
public Object QueryVoucherListAction(@RequestParam String token, @RequestParam String sortType, @RequestParam int pagerOffset, @RequestParam int pagerPerPage,
@RequestParam int voucherType, @RequestParam int used, @RequestParam String sortDirection) {
Request<VoucherQueryRequestDTO> request = new Request<VoucherQueryRequestDTO>();
VoucherQueryRequestDTO voucherQuery = new VoucherQueryRequestDTO();
String uid = UserContext.getUserId();
request.setUserId(uid);
request.setBody(voucherQuery);
voucherQuery.setUserId(uid);
voucherQuery.setVoucherType(voucherType);
voucherQuery.setPlayDate(null);
voucherQuery.setUsed(used);
voucherQuery.setSortType(sortType);
voucherQuery.setPagerOffset(pagerOffset);
voucherQuery.setPagerPerPage(pagerPerPage);
voucherQuery.setSortField("");
if ("asc".equals(sortDirection.toLowerCase())) {
voucherQuery.setSortDirection(SortDirectionEnum.ASC);
} else {
voucherQuery.setSortDirection(SortDirectionEnum.DESC);
}
Response<PagedResponseBean<VoucherItemDTO>> response = voucherService.CallQueryVoucherList(request);
if (response.getStatus() == -1) {
ResponseError err = new ResponseError();
err.setCode(response.getStatus());
err.setMessage(response.getMessage());
return err;
} else {
Map map = new HashMap();
List<Map> result = new ArrayList();
Collection<VoucherItemDTO> beans = response.getBody().getResult();
if (beans != null) {
for (VoucherItemDTO voucherItem : beans) {
Map mp = new HashMap();
mp.put("id", voucherItem.getId());
mp.put("no", voucherItem.getNo());
mp.put("type", voucherItem.getType());
mp.put("amount", voucherItem.getAmount());
mp.put("startUseDate", new SimpleDateFormat("yyyy-MM-dd").format(voucherItem.getStartUseDate()));
mp.put("endUseDate", new SimpleDateFormat("yyyy-MM-dd").format(voucherItem.getEndUseDate()));
mp.put("used", voucherItem.getUsed());
mp.put("overdue", voucherItem.getOverdue());
result.add(mp);
}
}
map.put("count", response.getBody().getCount());
map.put("vouchers", result);
return map;
}
}
@ResponseBody
@Security
@RequestMapping(value = "/v3/vouchers", method = RequestMethod.GET, params = { "token", "sortType", "pagerOffset", "pagerPerPage", "voucherType", "playDate", "used", "sortDirection" })
public Object QueryVoucherListAction(@RequestParam String token, VoucherQueryRequestDTO voucherQuery) {
Request<VoucherQueryRequestDTO> request = new Request<VoucherQueryRequestDTO>();
String uid = UserContext.getUserId();
request.setUserId(uid);
request.setBody(voucherQuery);
voucherQuery.setUserId(uid);
voucherQuery.setSortField("");
Response<PagedResponseBean<VoucherItemDTO>> response = voucherService.CallQueryVoucherList(request);
if (response.getStatus() == -1) {
ResponseError err = new ResponseError();
err.setCode(response.getStatus());
err.setMessage(response.getMessage());
return err;
} else {
Map map = new HashMap();
List<Map> result = new ArrayList();
Collection<VoucherItemDTO> beans = response.getBody().getResult();
if (beans != null) {
for (VoucherItemDTO voucherItem : beans) {
Map mp = new HashMap();
mp.put("id", voucherItem.getId());
mp.put("no", voucherItem.getNo());
mp.put("type", voucherItem.getType());
mp.put("amount", voucherItem.getAmount());
mp.put("startUseDate", new SimpleDateFormat("yyyy-MM-dd").format(voucherItem.getStartUseDate()));
mp.put("endUseDate", new SimpleDateFormat("yyyy-MM-dd").format(voucherItem.getEndUseDate()));
mp.put("used", voucherItem.getUsed());
mp.put("overdue", voucherItem.getOverdue());
result.add(mp);
}
}
map.put("count", response.getBody().getCount());
map.put("vouchers", result);
return map;
}
}
@ResponseBody
@Security
@RequestMapping(value = "/voucher/queryListForPersonalCenter", method = RequestMethod.GET, params = { "token", "type", "used", "sortField", "sortDirection", "pagerOffset",
"pagerPerPage" })
public Object queryListForPersonalCenter(@RequestParam String token, VoucherQueryDto voucherQuery) {
voucherQuery.setUid(UserContext.getUserId());
return voucherService.queryListForPersonalCenter(voucherQuery);
}
@ResponseBody
@Security
@RequestMapping(value = "/voucher/queryListForCourseOrder", method = RequestMethod.GET, params = { "token", "resourceId", "playDate", "sortField", "sortDirection", "pagerOffset",
"pagerPerPage" })
public Object queryListForCourseOrder(@RequestParam String token, VoucherQueryDto voucherQuery) {
voucherQuery.setUid(UserContext.getUserId());
return voucherService.queryListForCourseOrder(voucherQuery);
}
@ResponseBody
@Security
@RequestMapping(value = "/voucher/queryListForTourOrder", method = RequestMethod.GET, params = { "token", "tourId", "playDate", "sortField", "sortDirection", "pagerOffset",
"pagerPerPage" })
public Object queryListForTourOrder(@RequestParam String token, VoucherQueryDto voucherQuery) {
voucherQuery.setUid(UserContext.getUserId());
return voucherService.queryListForTourOrder(voucherQuery);
}
@ResponseBody
@Security
@RequestMapping(value = "/voucher/queryListForEventActivityOrder", method = RequestMethod.GET, params = { "token", "resourceId", "playDate", "sortField", "sortDirection", "pagerOffset",
"pagerPerPage" })
public Object queryListForEventActivityOrder(@RequestParam String token, VoucherQueryDto voucherQuery) {
voucherQuery.setUid(UserContext.getUserId());
return voucherService.queryListForEventActivityOrder(voucherQuery);
}
@ResponseBody
@Security
@RequestMapping(value = "/voucher/queryListForMallOrder", method = RequestMethod.GET, params = { "token", "productId", "activityProductId", "amount", "sortField", "sortDirection",
"pagerOffset", "pagerPerPage" })
public Object queryListForMallOrder(@RequestParam String token, VoucherQueryDto voucherQuery) {
voucherQuery.setUid(UserContext.getUserId());
return voucherService.queryListForMallOrder(voucherQuery);
}
@ResponseBody
@Security
@RequestMapping(value = "/voucher/getRedeemCodeForMallOrder", method = RequestMethod.GET, params = { "token", "productId", "activityProductId", "redeemCode", "amount" })
public Object getRedeemCode(@RequestParam String token, VoucherQueryDto voucherQuery) {
voucherQuery.setUid(UserContext.getUserId());
return voucherService.getRedeemCodeForMallOrder(voucherQuery);
}
}
src/main/java/com/ctrip/fun/golf/api/client/ClientConfigController.java 0 → 100644
package com.ctrip.fun.golf.api.client;
import java.util.List;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Controller;
import org.springframework.util.StringUtils;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RequestMethod;
import org.springframework.web.bind.annotation.RequestParam;
import org.springframework.web.bind.annotation.ResponseBody;
import com.ctrip.fun.common.vo.Response;
import com.ctrip.fun.common.vo.ResponseStatusEnum;
import com.ctrip.fun.common.vo.client.ClientConfigBean;
import com.ctrip.fun.common.vo.client.ClientConfigQuery;
import com.ctrip.fun.golf.service.client.ClientConfigService;
@Controller
@RequestMapping(value = "/client/config")
public class ClientConfigController {
@Autowired
private ClientConfigService clientConfigService = null;
/**
* <pre>
* 1、APP的5.5.0以及以后的版本首页都调用此接口；
* 2、APP的5.5.0和5.6.0只传参数type；
* 3、APP的5.7.0以及以后的版本传参数type和appVersion；
* 4、homeconfig在5.7.0以及以后的版本按版本号区分。
* </pre>
*/
@ResponseBody
@RequestMapping(value = "/get", method = RequestMethod.GET, produces = "application/json;charset=UTF-8")
public Object get(ClientConfigQuery query) {
String type = query.getType();
if (StringUtils.hasText(query.getAppVersion()) && "homeconfig".equalsIgnoreCase(query.getType())) {
type = type + query.getAppVersion();
}
Response<ClientConfigBean> response = clientConfigService.getByType(type);
if (response == null || response.getBody() == null) {
return "";
}
String responseMessage = response.getBody().getMessage();
return responseMessage;
}
@ResponseBody
@RequestMapping(value = "/queryAll", method = RequestMethod.GET)
public Object getFirst() {
Response<List<ClientConfigBean>> response = null;
try {
response = clientConfigService.queryAll();
} catch (Exception e) {
response = new Response<List<ClientConfigBean>>();
response.setStatus(ResponseStatusEnum.FAIL.getValue());
response.setMessage(e.getMessage());
}
return response;
}
@ResponseBody
@RequestMapping(value = "/update", method = RequestMethod.POST)
public Object update(@RequestParam Integer id, @RequestParam String message) {
Response<Object> response = null;
ClientConfigBean bean = new ClientConfigBean();
bean.setId(id);
bean.setMessage(message);
try {
response = clientConfigService.update(bean);
} catch (Exception e) {
response = new Response<Object>();
response.setStatus(ResponseStatusEnum.FAIL.getValue());
response.setMessage(e.getMessage());
}
return response;
}
}
src/main/java/com/ctrip/fun/golf/api/course/GameCourseController.java 0 → 100644
package com.ctrip.fun.golf.api.course;
import java.lang.reflect.InvocationTargetException;
import java.util.ArrayList;
import java.util.List;
import org.apache.commons.beanutils.BeanUtils;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.PathVariable;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RequestMethod;
import org.springframework.web.bind.annotation.ResponseBody;
import com.ctrip.fun.common.vo.Response;
import com.ctrip.fun.common.vo.ResponseStatusEnum;
import com.ctrip.fun.common.vo.app.ReponseCourseGameBean;
import com.ctrip.fun.common.vo.app.RequestCourseGameBean;
import com.ctrip.fun.common.vo.product.CourseFairwayBean;
import com.ctrip.fun.common.vo.product.CourseZoneBean;
import com.ctrip.fun.golf.service.course.CourseService;
import com.ctrip.fun.golf.vo.course.CourseFairwayVO;
import com.ctrip.fun.golf.vo.course.CourseZoneVO;
import com.ctrip.fun.golf.vo.course.ReponseCourseGame;
@Controller
@RequestMapping(value = "/gamecourse")
public class GameCourseController {
@Autowired
private CourseService courseService = null;
private Logger logger = LoggerFactory.getLogger(GameCourseController.class);
private static final String sc50001 = "sc50001==>";
@RequestMapping(value = "/coursefairways_coursezone/{courseId}", method = RequestMethod.GET)
@ResponseBody
public Object getGameCoursefairwayAndCourseZone(@PathVariable("courseId") String courseId) {
RequestCourseGameBean csGameCourseQuery = new RequestCourseGameBean();
csGameCourseQuery.setCourseId(courseId);
Response<ReponseCourseGameBean> response = courseService.callGameCoursefairwayAndCourseZone(csGameCourseQuery);
Object result = null;
if(response.getStatus() == ResponseStatusEnum.SUCCESS.getValue()){
ReponseCourseGameBean reponseCourseGameBean = response.getBody();
ReponseCourseGame reponseCourseGame = new ReponseCourseGame();
List<CourseFairwayVO> courseFairwayVOlist = this.getCourseFairwayVOList(reponseCourseGameBean.getCourseFairwayList());
List<CourseZoneVO> cousrseZoneList= this.getCousrseZoneVOList(reponseCourseGameBean.getCousrseZoneList());
reponseCourseGame.setCourseFairwayList(courseFairwayVOlist);
reponseCourseGame.setCousrseZoneList(cousrseZoneList);
result = reponseCourseGame;
} else {
String errormsg = response.getMessage();
result = errormsg;
}
logger.info("\n" + sc50001 + result.toString());
return result;
}
private List<CourseZoneVO> getCousrseZoneVOList(List<CourseZoneBean> courseZoneBeanList) {
List<CourseZoneVO> cousrseZoneList = new ArrayList<CourseZoneVO>();
if (courseZoneBeanList != null) {
for (CourseZoneBean courseZoneBean : courseZoneBeanList) {
CourseZoneVO courseZoneVO = new CourseZoneVO();
try {
BeanUtils.copyProperties(courseZoneVO, courseZoneBean);
} catch (IllegalAccessException e) {
e.printStackTrace();
} catch (InvocationTargetException e) {
e.printStackTrace();
}
cousrseZoneList.add(courseZoneVO);
}
}
return cousrseZoneList;
}
private List<CourseFairwayVO> getCourseFairwayVOList(List<CourseFairwayBean> courseFairwayBeanList) {
List<CourseFairwayVO> courseFairwayVOList = new ArrayList<CourseFairwayVO>();
if (courseFairwayBeanList != null) {
for (CourseFairwayBean courseFairwayBean : courseFairwayBeanList) {
CourseFairwayVO courseFairwayVO = new CourseFairwayVO();
try {
BeanUtils.copyProperties(courseFairwayVO, courseFairwayBean);
} catch (IllegalAccessException e) {
e.printStackTrace();
} catch (InvocationTargetException e) {
e.printStackTrace();
}
courseFairwayVOList.add(courseFairwayVO);
}
}
return courseFairwayVOList;
}
public void setCourseService(CourseService courseService) {
this.courseService = courseService;
}
}
src/main/java/com/ctrip/fun/golf/api/distribution/DistributionMController.java 0 → 100644
package com.ctrip.fun.golf.api.distribution;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
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.ctrip.fun.common.vo.Request;
import com.ctrip.fun.common.vo.Response;
import com.ctrip.fun.common.vo.distribution.DistributionSalesQuery;
import com.ctrip.fun.common.vo.distribution.DistributionSalesResultBean;
import com.ctrip.fun.common.vo.distribution.DistributionSingleSalesQuery;
import com.ctrip.fun.common.vo.distribution.DistributionSingleSalesUserBean;
import com.ctrip.fun.golf.secrity.UserContext;
import com.ctrip.fun.golf.service.distribution.DistributionMService;
import com.ctrip.fun.mall.vo.LabelValueBean;
@Controller
@RequestMapping(value = "/distribution")
public class DistributionMController {
private Logger logger = LoggerFactory.getLogger(DistributionMController.class);
@Autowired
private DistributionMService distributionMService = null;
@ResponseBody
@RequestMapping(value = "/getDistributionUsualDistrict", method = RequestMethod.GET)
public Object getDistributionUsualDistrict() {
List<LabelValueBean<Integer>> response = new ArrayList<LabelValueBean<Integer>>();
Request<Object> request = new Request<Object>();
request.setUserId(UserContext.getUserId());
response = this.distributionMService.getDistributionUsualDistrict(request);
Map<String, Object> result = new HashMap<String, Object>();
result.put("distributionUsualDistrict", response);
return result;
}
@ResponseBody
@RequestMapping(value = "/queryDistributionSales", method = RequestMethod.POST)
public Object queryDistributionSales(@RequestBody DistributionSalesQuery distributionSalesQuery) {
Response<List<DistributionSalesResultBean>> response = new Response<List<DistributionSalesResultBean>>();
Request<DistributionSalesQuery> request = new Request<DistributionSalesQuery>();
request.setBody(distributionSalesQuery);
request.setUserId("");
response = this.distributionMService.queryDistributionSales(request);
Map<String, Object> result = new HashMap<String, Object>();
if (response.getStatus() != 0) {
result.put("code", response.getStatus());
result.put("message", response.getMessage());
return result;
}
List<Map<String, Object>> distributionSalesList = new ArrayList<Map<String, Object>>();
result.put("distributionSalesList", distributionSalesList);
if (response.getBody() != null) {
List<DistributionSalesResultBean> resultBeans = response.getBody();
for (int index = 0; index < response.getBody().size(); index++) {
DistributionSalesResultBean bean = resultBeans.get(index);
Map<String, Object> distributionSales = new HashMap<String, Object>();
distributionSales.put("rank", index + 1);
distributionSales.put("recommendCode", bean.getRecommendCode());
distributionSales.put("quantity", bean.getQuantity());
distributionSalesList.add(distributionSales);
}
}
return result;
}
/**
* 单人销量用户明细
*
* @param distributionSalesQuery
* @return
*/
@ResponseBody
@RequestMapping(value = "/queryDistributionSingleSalesUser", method = RequestMethod.POST)
public Object queryDistributionSingleSalesUser(@RequestBody DistributionSingleSalesQuery distributionSingleSalesQuery) {
Response<List<DistributionSingleSalesUserBean>> response = new Response<List<DistributionSingleSalesUserBean>>();
Request<DistributionSingleSalesQuery> request = new Request<DistributionSingleSalesQuery>();
request.setBody(distributionSingleSalesQuery);
request.setUserId("");
response = this.distributionMService.queryDistributionSingleSalesUser(request);
Map<String, Object> result = new HashMap<String, Object>();
if (response.getStatus() != 0) {
result.put("code", response.getStatus());
result.put("message", response.getMessage());
return result;
}
List<Map<String, Object>> distributionSingleSalesUserList = new ArrayList<Map<String, Object>>();
result.put("userList", distributionSingleSalesUserList);
if (response.getBody() != null) {
for (DistributionSingleSalesUserBean bean : response.getBody()) {
Map<String, Object> distributionSingleSalesUser = new HashMap<String, Object>();
distributionSingleSalesUser.put("userName", bean.getUserName());
distributionSingleSalesUser.put("mobilePhone", encrptMobilePhone(bean.getMobilePhone()));
distributionSingleSalesUserList.add(distributionSingleSalesUser);
}
}
return result;
}
private String encrptMobilePhone(String mobilePhone) {
if (mobilePhone == null || mobilePhone.length() < 7) {
return "";
}
String encrptMobilePhone = mobilePhone.substring(0, 3) + "****" + mobilePhone.substring(7);
return encrptMobilePhone;
}
}
src/main/java/com/ctrip/fun/golf/api/game/GamePlayerMController.java 0 → 100644
/**
* Copyright 2014 CTRIP Co.,Ltd. All rights reserved.
*/
package com.ctrip.fun.golf.api.game;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.PathVariable;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RequestMethod;
import org.springframework.web.bind.annotation.RequestParam;
import org.springframework.web.bind.annotation.ResponseBody;
import com.ctrip.fun.common.vo.game.GamePlayerRewardBean;
import com.ctrip.fun.common.vo.game.PlayerRewardDetailBean;
import com.ctrip.fun.common.vo.game.PlayerRewardQuery;
import com.ctrip.fun.golf.secrity.Security;
import com.ctrip.fun.golf.secrity.UserContext;
import com.ctrip.fun.golf.service.game.GamePlayerMService;
/**
* @author zgsong
* @version 1.0.0
*/
@Controller
@RequestMapping(value = "")
public class GamePlayerMController {
@Autowired
private GamePlayerMService gamePlayerMService = null;
@ResponseBody
@RequestMapping(value = "/games/myReward/{token}", method = RequestMethod.GET)
@Security
public Object queryPayerRewords(@PathVariable String token) {
String uid = UserContext.getUserId();
PlayerRewardQuery playerRewardQuery = new PlayerRewardQuery();
playerRewardQuery.setUid(uid);
List<GamePlayerRewardBean> gamePlayerRewardBeans = gamePlayerMService.queryPayerRewords(playerRewardQuery);
Map map = new HashMap();
List<Map> result = new ArrayList();
if (gamePlayerRewardBeans != null) {
for (GamePlayerRewardBean gamePlayerRewardBean : gamePlayerRewardBeans) {
Map mp = new HashMap();
mp.put("gameName", gamePlayerRewardBean.getGameName());
mp.put("gameId", gamePlayerRewardBean.getGameId());
mp.put("gameStatus", gamePlayerRewardBean.getGameStatus());
mp.put("gameStartDate", gamePlayerRewardBean.getGameStartDate());
mp.put("courseName", gamePlayerRewardBean.getCourseName());
mp.put("rewardStatus", gamePlayerRewardBean.getRewardStatus());
mp.put("overDate", gamePlayerRewardBean.getOverDate());
mp.put("activityId", gamePlayerRewardBean.getActivityId());
mp.put("address", gamePlayerRewardBean.getAddress());
List<Map> rewardList = new ArrayList();
List<PlayerRewardDetailBean> playerRewardDetailBeans = gamePlayerRewardBean.getPlayerRewardDetailBeans();
if (playerRewardDetailBeans != null) {
for (PlayerRewardDetailBean playerRewardDetailBean : playerRewardDetailBeans) {
Map reward = new HashMap();
reward.put("rewardName", playerRewardDetailBean.getName());
reward.put("rank", playerRewardDetailBean.getRank());
reward.put("imageUrl", playerRewardDetailBean.getImageUrl());
reward.put("num", playerRewardDetailBean.getNum());
reward.put("prizeName", playerRewardDetailBean.getPrizeName());
rewardList.add(reward);
}
}
mp.put("rewardList", rewardList);
result.add(mp);
}
}
map.put("gameRewardList", result);
return map;
}
@ResponseBody
@RequestMapping(value = "/games/drawRewards/{token}", method = RequestMethod.GET, params={"gameId"})
@Security
public Object drawGamePlayerRewards(@PathVariable String token,@RequestParam int gameId) {
String uid = UserContext.getUserId();
PlayerRewardQuery playerRewardQuery = new PlayerRewardQuery();
playerRewardQuery.setUid(uid);
playerRewardQuery.setGameId(gameId);
gamePlayerMService.drawGamePlayerRewards(playerRewardQuery);
Map map = new HashMap();
map.put("result", "success");
return map;
}
@ResponseBody
@RequestMapping(value = "/games/getRewardDetailById/{token}", method = RequestMethod.GET, params={"gameId"})
@Security
public Object getRewardDetailById(@PathVariable String token, @RequestParam int gameId) {
String uid = UserContext.getUserId();
PlayerRewardQuery playerRewardQuery = new PlayerRewardQuery();
playerRewardQuery.setUid(uid);
playerRewardQuery.setGameId(gameId);
GamePlayerRewardBean gprBean = gamePlayerMService.getRewardDetailById(playerRewardQuery);
Map map = new HashMap();
Map mp = new HashMap();
mp.put("gameName", gprBean.getGameName());
mp.put("gameId", gprBean.getGameId());
mp.put("gameStatus", gprBean.getGameStatus());
mp.put("gameStartDate", gprBean.getGameStartDate());
mp.put("courseName", gprBean.getCourseName());
mp.put("rewardStatus", gprBean.getRewardStatus());
mp.put("overDate", gprBean.getOverDate());
mp.put("activityId", gprBean.getActivityId());
mp.put("address", gprBean.getAddress());
List<Map> rewardList = new ArrayList();
List<PlayerRewardDetailBean> playerRewardDetailBeans = gprBean.getPlayerRewardDetailBeans();
if (playerRewardDetailBeans != null) {
for (PlayerRewardDetailBean playerRewardDetailBean : playerRewardDetailBeans) {
Map reward = new HashMap();
reward.put("rewardName", playerRewardDetailBean.getName());
reward.put("rank", playerRewardDetailBean.getRank());
reward.put("imageUrl", playerRewardDetailBean.getImageUrl());
reward.put("prizeName", playerRewardDetailBean.getPrizeName());
reward.put("num", playerRewardDetailBean.getNum());
reward.put("rankType", playerRewardDetailBean.getRankType());
rewardList.add(reward);
}
}
mp.put("rewardList", rewardList);
return mp;
}
@ResponseBody
@RequestMapping(value = "/games/hasNotFetchReward/{token}", method = RequestMethod.GET)
@Security
public Object hasNotFetchReward(@PathVariable String token) {
String uid = UserContext.getUserId();
PlayerRewardQuery playerRewardQuery = new PlayerRewardQuery();
playerRewardQuery.setUid(uid);
Boolean hasNotFetchReward = gamePlayerMService.hasNotFetchReward(playerRewardQuery);
Map map = new HashMap();
map.put("result", hasNotFetchReward);
return map;
}
@ResponseBody
@RequestMapping(value = "/games/hasNotReadScore/{token}", method = RequestMethod.GET)
@Security
public Object hasNotReadScore(@PathVariable String token) {
String uid = UserContext.getUserId();
PlayerRewardQuery playerRewardQuery = new PlayerRewardQuery();
playerRewardQuery.setUid(uid);
Boolean hasNotFetchReward = gamePlayerMService.hasNotReadScore(playerRewardQuery);
Map map = new HashMap();
map.put("result", hasNotFetchReward);
return map;
}
@ResponseBody
@RequestMapping(value = "/games/setReadScoreStatus/{token}", method = RequestMethod.GET)
@Security
public Object setReadScoreStatus(@PathVariable String token) {
String uid = UserContext.getUserId();
PlayerRewardQuery playerRewardQuery = new PlayerRewardQuery();
playerRewardQuery.setUid(uid);
Boolean hasNotFetchReward = gamePlayerMService.setReadScoreStatus(playerRewardQuery);
Map map = new HashMap();
map.put("result", hasNotFetchReward);
return map;
}
public GamePlayerMService getGamePlayerMService() {
return gamePlayerMService;
}
public void setGamePlayerMService(GamePlayerMService gamePlayerMService) {
this.gamePlayerMService = gamePlayerMService;
}
}
src/main/java/com/ctrip/fun/golf/api/game/ScoreMController.java 0 → 100644
package com.ctrip.fun.golf.api.game;
import java.io.IOException;
import java.util.ArrayList;
import java.util.Date;
import java.util.List;
import java.util.Map;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.PathVariable;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RequestMethod;
import org.springframework.web.bind.annotation.RequestParam;
import org.springframework.web.bind.annotation.ResponseBody;
import org.springframework.web.multipart.MultipartFile;
import org.springframework.web.multipart.MultipartHttpServletRequest;
import org.springframework.web.multipart.commons.CommonsMultipartFile;
import com.ctrip.fun.common.core.util.DateUtil;
import com.ctrip.fun.common.core.util.SysUtil;
import com.ctrip.fun.common.vo.Response;
import com.ctrip.fun.common.vo.ResponseStatusEnum;
import com.ctrip.fun.common.vo.basic.EntityImageBean;
import com.ctrip.fun.common.vo.score.ScorePhotoBean;
import com.ctrip.fun.common.vo.score.ScoreStatBean;
import com.ctrip.fun.common.vo.score.ScoreStatisticsQuery;
import com.ctrip.fun.golf.secrity.Security;
import com.ctrip.fun.golf.secrity.UserContext;
import com.ctrip.fun.golf.service.basic.EntityImageService;
import com.ctrip.fun.golf.service.game.ScoreMService;
@Controller
@RequestMapping(value = "/scores")
public class ScoreMController {
private final static String IMAGE_TYPE = "image/jpeg";
private final static String ENTITY_TYPE = "tempScore";
@Autowired
private EntityImageService entityImageService = null;
@Autowired
private ScoreMService scoreService = null;
private static Logger logger = LoggerFactory.getLogger(ScoreMController.class);
@RequestMapping(value = "/uploadPhoto/{token}", method = RequestMethod.POST)
@Security
@ResponseBody
public Response<Object> uploadPhoto (@PathVariable String token, MultipartHttpServletRequest request) {
Response<Object> response = new Response<Object>();
int maxUploadFileSize = scoreService.getMaxUploadFileSize();
String uid = UserContext.getUserId();
ScorePhotoBean bean = new ScorePhotoBean();
bean.setUid(uid);
List<CommonsMultipartFile> list = new ArrayList<CommonsMultipartFile>();
try{
int count = Integer.parseInt(request.getParameter("count"));
if (count > 4) {
response.setStatusEnum(ResponseStatusEnum.INVALID_PARAMETER);
return response;
}
int courseId = Integer.parseInt(request.getParameter("courseId"));
Date playDate = DateUtil.parseDate(request.getParameter("playDate"));
int teeColor = Integer.parseInt(request.getParameter("teeColor"));
String phone = request.getParameter("phone");
int position = Integer.parseInt(request.getParameter("position"));
String friendInfo = request.getParameter("friendInfo");
bean.setCount(count);
bean.setCourseId(courseId);
bean.setPlayDate(playDate);
bean.setTeeColor(teeColor);
bean.setPhone(phone);
bean.setPosition(position);
bean.setFriendInfo(friendInfo);
logger.info(SysUtil.getMethodName() + " request: " + bean.toString());
for (int i = 1; i <= count; i++) {
CommonsMultipartFile file = (CommonsMultipartFile) request.getFile("file" + i);
if (file != null) {
if (file.getSize() >= maxUploadFileSize) {
response.setStatusEnum(ResponseStatusEnum.FAIL);
logger.error(SysUtil.getMethodName() + " file " + i + "exceed max file size " + maxUploadFileSize);
return response;
}
list.add(file);
}
}
} catch (Exception e) {
response.setStatusEnum(ResponseStatusEnum.INVALID_PARAMETER);
logger.error(SysUtil.getMethodName() + " " + e.toString() + " " + ResponseStatusEnum.INVALID_PARAMETER.getMsg());
return response;
}
int entityId = scoreService.uploadTempScore(bean);
for(MultipartFile file : list) {
EntityImageBean eiBean;
try {
eiBean = entityImageService.upload(ENTITY_TYPE,entityId,null, file.getBytes());
int retkey = entityImageService.add("", eiBean);
if (retkey == 0) {
response.setStatusEnum(ResponseStatusEnum.FAIL);
logger.error(SysUtil.getMethodName() + "retKey = 0" + ", entityId = " + entityId);
return response;
}
} catch (IOException e) {
response.setStatusEnum(ResponseStatusEnum.FAIL);
logger.error(SysUtil.getMethodName() + " " + e.toString() + " " + ResponseStatusEnum.FAIL.getMsg());
return response;
}
}
response.setStatusEnum(ResponseStatusEnum.SUCCESS);
logger.info(SysUtil.getMethodName() + " response: " + ResponseStatusEnum.SUCCESS.getMsg());
return response;
}
@ResponseBody
@RequestMapping(value = "/userStatistic/{token}", method = RequestMethod.GET, params={"count", "type"})
@Security
public Response<ScoreStatBean> getUserStat(@PathVariable String token, @RequestParam int count, @RequestParam int type) {
String uid = UserContext.getUserId();
ScoreStatisticsQuery query = new ScoreStatisticsQuery();
logger.info(SysUtil.getMethodName() + " request: uid= " + uid + ", count= " + count + ", type= " + type);
query.setCount(count);
query.setType(type);
query.setUid(uid);
ScoreStatBean bean= scoreService.getUserStat(query);
Response<ScoreStatBean> response = new Response<ScoreStatBean>();
response.setBody(bean);
response.setMessage(ResponseStatusEnum.SUCCESS.getMsg());
response.setStatus(ResponseStatusEnum.SUCCESS.getValue());
logger.info(SysUtil.getMethodName() + "response: " + response.toString());
return response;
}
}
src/main/java/com/ctrip/fun/golf/api/game/ScoreMatchMController.java 0 → 100644
package com.ctrip.fun.golf.api.game;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import javax.servlet.http.HttpServletRequest;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.PathVariable;
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.RequestParam;
import org.springframework.web.bind.annotation.ResponseBody;
import com.ctrip.fun.common.vo.Request;
import com.ctrip.fun.common.vo.Response;
import com.ctrip.fun.common.vo.game.ScoreMatchBean;
import com.ctrip.fun.common.vo.game.ScoreMatchParam;
import com.ctrip.fun.common.vo.game.ScoreMatchQuery;
import com.ctrip.fun.common.vo.game.ScoreMatchRecordBean;
import com.ctrip.fun.common.vo.game.ScoreMatchRecordQuery;
import com.ctrip.fun.common.vo.user.SimpleUser;
import com.ctrip.fun.golf.secrity.Security;
import com.ctrip.fun.golf.secrity.UserContext;
import com.ctrip.fun.golf.service.game.ScoreMatchMService;
import com.ctrip.fun.mall.vo.order.MallAfterSalesOrderBean;
@Controller
@RequestMapping(value = "/scorematch")
public class ScoreMatchMController {
@Autowired
private ScoreMatchMService scoreMatchMService = null;
/**
* 官方赛事列表
*/
/*@ResponseBody
@RequestMapping(value = "/list", method = RequestMethod.GET, params = {"isOffice", "lat","lng", "pagerOffset", "pagerPerPage" })
public Object officeMatchlist(ScoreMatchQuery query){
return scoreMatchMService.list(query);
}*/
/**
* 我创建的赛事列表/官方赛事列表(isOffice)
*/
@Security
@ResponseBody
@RequestMapping(value = "/list/{token}", method = RequestMethod.GET, params = {"isOfficial", "lat","lng", "pagerOffset", "pagerPerPage" })
public Object myBuildMatchlist(@PathVariable String token, @RequestParam boolean isOfficial, @RequestParam double lat, @RequestParam double lng, @RequestParam int pagerOffset, @RequestParam int pagerPerPage){
ScoreMatchQuery query = new ScoreMatchQuery();
query.setLat(lat);
query.setLng(lng);
query.setPagerOffset(pagerOffset);
query.setPagerPerPage(pagerPerPage);
query.setOfficial(isOfficial);
String uid = UserContext.getUserId();
query.setCustomUid(uid);
return scoreMatchMService.list(query);
}
@Security
@ResponseBody
@RequestMapping(value = "/myRegisterList/{token}", method = RequestMethod.GET, params = { "pagerOffset", "pagerPerPage" })
public Object myBuildMatchlist(@PathVariable String token, @RequestParam int pagerOffset, @RequestParam int pagerPerPage){
ScoreMatchRecordQuery query = new ScoreMatchRecordQuery();
query.setPagerOffset(pagerOffset);
query.setPagerPerPage(pagerPerPage);
String uid = UserContext.getUserId();
query.setRegisterUser(uid);
return scoreMatchMService.myRegisterList(query);
}
/**
* 创建赛事
* @param token
* @param paramBean
* @return
*/
@Security
@ResponseBody
@RequestMapping(value = "/create/{token}", method = RequestMethod.POST)
public Response<ScoreMatchBean> createMatch(@PathVariable String token, @RequestBody ScoreMatchBean paramBean){
Request<ScoreMatchBean> request = new Request<ScoreMatchBean>();
request.setBody(paramBean);
request.setUserId(UserContext.getUserId());
Response<ScoreMatchBean> reponse = scoreMatchMService.createMatch(request);
return reponse;
}
/**
* 修改赛事
* @param token
* @param paramBean
* @return
*/
@Security
@ResponseBody
@RequestMapping(value = "/edit/{token}", method = RequestMethod.POST)
public Response<ScoreMatchBean> editMatch(@PathVariable String token, @RequestBody ScoreMatchBean paramBean){
Request<ScoreMatchBean> request = new Request<ScoreMatchBean>();
request.setBody(paramBean);
request.setUserId(UserContext.getUserId());
Response<ScoreMatchBean> reponse = scoreMatchMService.editMatch(request);
return reponse;
}
/**
* 关闭赛事
* @param token
* @param paramBean
* @return
*/
@Security
@ResponseBody
@RequestMapping(value = "/close/{token}", method = RequestMethod.POST)
public Response<List<ScoreMatchRecordBean>> closeMatch(@PathVariable String token, @RequestBody ScoreMatchParam param ){
// @PathVariable("matchId") Integer matchId, @P("isforce") boolean isforce){
Request<Map<String, Object>> request = new Request<Map<String, Object>>();
Map<String, Object> map = new HashMap<String, Object>();
map.put("matchId", param.getMatchId());
map.put("isforce", param.isIsforce());
request.setBody(map);
request.setUserId(UserContext.getUserId());
Response<List<ScoreMatchRecordBean>> reponse = scoreMatchMService.closeMatch(request);
return reponse;
}
/**
* 获得某场比赛的所有参与人员
* @param token
* @param paramBean
* @return
*/
@Security
@ResponseBody
@RequestMapping(value = "/recordUsers/{token}", method = RequestMethod.GET)
public Response<List<SimpleUser>> recordUsers(@PathVariable String token, @RequestParam Integer matchId){
Request<Integer> request = new Request<Integer>();
request.setBody(matchId);
request.setUserId(UserContext.getUserId());
Response<List<SimpleUser>> reponse = scoreMatchMService.findRecordUserList(request);
return reponse;
}
/**
* 获得某个比赛的详细信息
* @param token
* @param paramBean
* @return
*/
@Security
@ResponseBody
@RequestMapping(value = "/detail/{token}", method = RequestMethod.GET)
public Response<ScoreMatchBean> findMatchDetail(@PathVariable String token, @RequestParam Integer matchId){
Request<Integer> request = new Request<Integer>();
request.setBody(matchId);
request.setUserId(UserContext.getUserId());
Response<ScoreMatchBean> reponse = scoreMatchMService.findMatchDetail(request);
return reponse;
}
/**
* 获得某个比赛的详细信息
* @param token
* @param paramBean
* @return
*/
@Security
@ResponseBody
@RequestMapping(value = "/myMatchStatus/{token}", method = RequestMethod.GET)
public Response<ScoreMatchBean> myMatchStatus(@PathVariable String token){
Request<Integer> request = new Request<Integer>();
request.setBody(null);
request.setUserId(UserContext.getUserId());
Response<ScoreMatchBean> reponse = scoreMatchMService.findMyMatchStatus(request);
return reponse;
}
/**
* 加入赛事
* @param token
* @param paramBean
* @return
*/
@Security
@ResponseBody
@RequestMapping(value = "/join/{token}", method = RequestMethod.POST)
public Response<ScoreMatchBean> joinMatch(@PathVariable String token, @RequestBody ScoreMatchBean paramBean){
Request<ScoreMatchBean> request = new Request<ScoreMatchBean>();
request.setBody(paramBean);
request.setUserId(UserContext.getUserId());
Response<ScoreMatchBean> reponse = scoreMatchMService.joinMatch(request);
return reponse;
}
}
src/main/java/com/ctrip/fun/golf/api/gamehist/GameHistController.java 0 → 100644
package com.ctrip.fun.golf.api.gamehist;
public class GameHistController {
}
src/main/java/com/ctrip/fun/golf/api/impression/ImpressionController.java 0 → 100644
/**
* Copyright 2014 CTRIP Co.,Ltd. All rights reserved.
*/
package com.ctrip.fun.golf.api.impression;
import java.text.SimpleDateFormat;
import java.util.ArrayList;
import java.util.Date;
import java.util.HashMap;
import java.util.List;
import java.util.Locale;
import java.util.Map;
import javax.servlet.http.HttpServletRequest;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RequestMethod;
import org.springframework.web.bind.annotation.ResponseBody;
import com.ctrip.fun.common.vo.PagedResponseBean;
import com.ctrip.fun.common.vo.ResponseError;
import com.ctrip.fun.common.vo.SortDirectionEnum;
import com.ctrip.fun.common.vo.app.ImpressionQuery;
import com.ctrip.fun.common.vo.impression.ImpressionBean;
import com.ctrip.fun.common.vo.user.UserBean;
import com.ctrip.fun.golf.service.impression.ImpressionService;
import com.ctrip.fun.golf.service.user.UserMService;
/**
*
* @author lingsl
* @version 1.0.0
*/
@Controller
@RequestMapping(value = "/impression")
public class ImpressionController {
private Logger logger = LoggerFactory.getLogger(ImpressionController.class);
@Autowired
private ImpressionService impressionService;
@Autowired
private UserMService userMService;
private static SimpleDateFormat dateFormat1 = new SimpleDateFormat("yyyy-MM-dd");
private static SimpleDateFormat dateFormat2 = new SimpleDateFormat("MM-dd EEEE HH:mm",
Locale.SIMPLIFIED_CHINESE);
private static SimpleDateFormat dateFormat3 = new SimpleDateFormat("yyyy-MM-dd HH:mm");
@RequestMapping(value = "/list", method = RequestMethod.GET)
@ResponseBody
public Object list(HttpServletRequest request) {
List<Map<String, Object>> datas = new ArrayList<Map<String, Object>>();
ImpressionQuery query = new ImpressionQuery();
int currentPage = 0;
int pagerPerPage = 20;
int type = 0;
if (null != request.getParameter("pagerOffset")) {
try {
currentPage = Integer.parseInt(request.getParameter("pagerOffset"));
} catch (Exception e) {
}
}
if (null != request.getParameter("pagerPerPage")) {
try {
pagerPerPage = Integer.parseInt(request.getParameter("pagerPerPage"));
} catch (Exception e) {
}
}
if (null != request.getParameter("type")) {
try {
type = Integer.parseInt(request.getParameter("type"));
} catch (Exception e) {
}
}
query.setEnable(true);
query.setPagerPerPage(pagerPerPage);
query.setPagerOffset(currentPage * query.getPagerPerPage());
query.setSortField("id");
query.setSortDirection(SortDirectionEnum.DESC);
query.setType(type);
try {
PagedResponseBean<ImpressionBean> response = impressionService.list("", query);
if (response != null && response.getResult() != null && !response.getResult().isEmpty()) {
for (ImpressionBean ib : response.getResult()) {
Map<String, Object> data = new HashMap<String, Object>();
data.put("id", ib.getId());
data.put("title", ib.getTitle());
data.put("subTitle", ib.getSubTitle());
data.put("image", ib.getImage() + "?imageView2/1/w/500/h/260");
Date createdTime = ib.getCreatedTime();
data.put("createdTime", createdTime);
// 活动日期
data.put("date1", dateFormat1.format(ib.getTime()));
// 发布日期
data.put("date2", dateFormat2.format(createdTime));
datas.add(data);
}
}
} catch (Exception e) {
logger.error("获取印象列表数据失败," + e.getMessage());
ResponseError err = new ResponseError();
err.setCode(-1);
err.setMessage("获取印象列表数据失败！");
return err;
}
return datas;
}
@RequestMapping(value = "/detail", method = RequestMethod.GET)
@ResponseBody
public Object detail(HttpServletRequest request, String token) {
int id = 0;
if (null != request.getParameter("id")) {
try {
id = Integer.parseInt(request.getParameter("id"));
} catch (Exception e) {
}
}
// 获取查询用户
String userId = "";
try {
UserBean userBean = userMService.getUserBean(token);
userId = userBean.getUid();
} catch (Exception e) {
}
try {
ImpressionBean ib = impressionService.get(userId, id);
if (ib == null) {
ResponseError err = new ResponseError();
err.setCode(-1);
err.setMessage("该印象不存在或已被删除！");
return err;
}
if (ib.getEnable() == null || !ib.getEnable()) {
ResponseError err = new ResponseError();
err.setCode(-1);
err.setMessage("该印象尚未发布！");
return err;
}
Map<String, Object> data = new HashMap<String, Object>();
data.put("id", ib.getId());
data.put("operator", ib.getOperator());
data.put("title", ib.getTitle());
data.put("subTitle", ib.getSubTitle());
data.put("content", ib.getContent());
data.put("image", ib.getImage());
Date createdTime = ib.getCreatedTime();
data.put("createdTime", createdTime);
data.put("likeTime", ib.getLikeTime());
data.put("isLike", ib.getIslike());
data.put("date1", dateFormat1.format(ib.getTime()));
data.put("date2", dateFormat2.format(createdTime));
data.put("date3", dateFormat3.format(createdTime));
data.put("reviews", ib.getReviews());
return data;
} catch (Exception e) {
logger.error("获取印象数据失败," + e.getMessage());
ResponseError err = new ResponseError();
err.setCode(-1);
err.setMessage("获取印象数据失败！");
return err;
}
}
@RequestMapping(value = "/likeorcancel", method = RequestMethod.GET)
@ResponseBody
public Object likeOrCancel(HttpServletRequest request, String token) {
Map<String, Object> data = new HashMap<String, Object>();
int id = 0;
if (null != request.getParameter("id")) {
try {
id = Integer.parseInt(request.getParameter("id"));
} catch (Exception e) {
}
}
// 获取查询用户
String userId = "";
try {
UserBean userBean = userMService.getUserBean(token);
userId = userBean.getUid();
} catch (Exception e) {
}
if (userId == "") {
ResponseError err = new ResponseError();
err.setCode(-1);
err.setMessage("点赞失败,非法Token");
return err;
}
try {
ImpressionBean ib = impressionService.get(userId, id);
if (ib == null) {
ResponseError err = new ResponseError();
err.setCode(-1);
err.setMessage("印象不存在或已被删除");
return err;
}
boolean request_result = impressionService.likeOrCancel(userId, id);
data.put("isLike", request_result ? !ib.getIslike() : ib.getIslike());
data.put("code", request_result ? 0 : -1);
data.put("message", !request_result ? "点赞失败" : ib.getIslike() ? "已取消点赞" : "已点赞");
return data;
} catch (Exception e) {
logger.error("点赞失败," + e.getMessage());
ResponseError err = new ResponseError();
err.setCode(-1);
err.setMessage("点赞失败");
return err;
}
}
}
src/main/java/com/ctrip/fun/golf/api/impression/ReviewController.java 0 → 100644
/**
* Copyright 2014 CTRIP Co.,Ltd. All rights reserved.
*/
package com.ctrip.fun.golf.api.impression;
import java.text.SimpleDateFormat;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import javax.servlet.http.HttpServletRequest;
import org.apache.commons.lang.StringUtils;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
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.ctrip.fun.common.vo.PagedResponseBean;
import com.ctrip.fun.common.vo.Response;
import com.ctrip.fun.common.vo.ResponseError;
import com.ctrip.fun.common.vo.ResponseStatusEnum;
import com.ctrip.fun.common.vo.SortDirectionEnum;
import com.ctrip.fun.common.vo.app.ReviewQuery;
import com.ctrip.fun.common.vo.impression.ReviewBean;
import com.ctrip.fun.common.vo.user.UserBean;
import com.ctrip.fun.golf.service.impression.ImpressionService;
import com.ctrip.fun.golf.service.impression.ReviewService;
import com.ctrip.fun.golf.service.user.UserMService;
/**
* Controller - Review
*
* @author lingsl
* @version 1.0.0
*/
@Controller
@RequestMapping(value = "/review")
public class ReviewController {
private Logger logger = LoggerFactory.getLogger(ReviewController.class);
@Autowired
private ImpressionService impressionService;
@Autowired
private UserMService userMService;
@Autowired
private ReviewService reviewService;
@RequestMapping(value = "/add", method = RequestMethod.POST)
@ResponseBody
public Object add(@RequestBody ReviewForm reviewForm) {
String token = reviewForm.getToken();
Integer impressionId = reviewForm.getImpressionId();
String content = reviewForm.getContent();
if (StringUtils.isEmpty(content) || StringUtils.isEmpty(content.trim())) {
ResponseError err = new ResponseError();
err.setCode(-1);
err.setMessage("评论内容不能为空!");
return err;
}
if(content.length()>200){
ResponseError err = new ResponseError();
err.setCode(-1);
err.setMessage("评论内容长度不能查过200个字!");
return err;
}
// 获取查询用户
UserBean userBean = null;
try {
userBean = userMService.getUserBean(token);
} catch (Exception e) {
}
if (userBean == null) {
ResponseError err = new ResponseError();
err.setCode(-1);
err.setMessage("评论失败,非法Token!");
return err;
}
Response<Integer> response = reviewService.add(userBean.getUid(), content, impressionId);
if (response.getStatus() != ResponseStatusEnum.SUCCESS.getValue()) {
ResponseError err = new ResponseError();
err.setCode(-1);
err.setMessage(response.getMessage());
return err;
}
int reviewId = response.getBody();
Map<String, Object> data = new HashMap<String, Object>();
data.put("code", 0);
data.put("message", "评论成功!");
data.put("reviews", reviewService.count(impressionId));
Response<ReviewBean> response_review_bean = reviewService.get(reviewId);
if (response_review_bean != null
&& response_review_bean.getStatus() == ResponseStatusEnum.SUCCESS.getValue()
&& response_review_bean.getBody() != null) {
ReviewBean reviewBean = response_review_bean.getBody();
data.put("avatar", reviewBean.getAvatar());
SimpleDateFormat dateFormat = new SimpleDateFormat("MM-dd HH:mm");
data.put("createdTime", dateFormat.format(reviewBean.getCreatedTime()));
data.put("nickname", reviewBean.getNickName());
data.put("content", reviewBean.getContent());
}
return data;
}
@RequestMapping(value = "/list", method = RequestMethod.GET)
@ResponseBody
public Object list(HttpServletRequest request, Integer impressionId) {
List<Map<String, Object>> datas = new ArrayList<Map<String, Object>>();
ReviewQuery query = new ReviewQuery();
int currentPage = 0;
int pagerPerPage = 20;
if (null != request.getParameter("pagerOffset")) {
try {
currentPage = Integer.parseInt(request.getParameter("pagerOffset"));
} catch (Exception e) {
}
}
if (null != request.getParameter("pagerPerPage")) {
try {
pagerPerPage = Integer.parseInt(request.getParameter("pagerPerPage"));
} catch (Exception e) {
}
}
query.setImpressionId(impressionId);
query.setVisible(true);
query.setPagerPerPage(pagerPerPage);
query.setPagerOffset(currentPage * query.getPagerPerPage());
query.setSortField("id");
query.setSortDirection(SortDirectionEnum.DESC);
try {
SimpleDateFormat dateFormat = new SimpleDateFormat("MM-dd HH:mm");
PagedResponseBean<ReviewBean> response = reviewService.list("", query);
if (response != null && response.getResult() != null && !response.getResult().isEmpty()) {
for (ReviewBean rb : response.getResult()) {
Map<String, Object> data = new HashMap<String, Object>();
data.put("id", rb.getId());
data.put("content", rb.getContent());
data.put("nickname", rb.getNickName());
data.put("createdTime", dateFormat.format(rb.getCreatedTime()));
data.put("avatar", rb.getAvatar());
datas.add(data);
}
}
} catch (Exception e) {
logger.error("获取评论列表数据失败," + e.getMessage());
ResponseError err = new ResponseError();
err.setCode(-1);
err.setMessage("获取评论列表数据失败！");
return err;
}
return datas;
}
/**
* 封装添加评论时的bean
*
* @author lingsl
* @version 1.0.0
*/
static class ReviewForm {
private String token;
private Integer impressionId;
private String content;
/**
* @return the token
*/
public String getToken() {
return token;
}
/**
* @param token
* the token to set
*/
public void setToken(String token) {
this.token = token;
}
/**
* @return the impressionId
*/
public Integer getImpressionId() {
return impressionId;
}
/**
* @param impressionId
* the impressionId to set
*/
public void setImpressionId(Integer impressionId) {
this.impressionId = impressionId;
}
/**
* @return the content
*/
public String getContent() {
return content;
}
/**
* @param content
* the content to set
*/
public void setContent(String content) {
this.content = content;
}
}
}
src/main/java/com/ctrip/fun/golf/api/integral/IntegralController.java 0 → 100644
/**
* Copyright 2014 CTRIP Co.,Ltd. All rights reserved.
*/
package com.ctrip.fun.golf.api.integral;
import java.util.ArrayList;
import java.util.Collection;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.PathVariable;
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.RequestParam;
import org.springframework.web.bind.annotation.ResponseBody;
import com.ctrip.fun.common.core.util.DateUtil;
import com.ctrip.fun.common.vo.PagedResponseBean;
import com.ctrip.fun.common.vo.integral.IntegralConfigBean;
import com.ctrip.fun.common.vo.integral.IntegralGoodsBean;
import com.ctrip.fun.common.vo.integral.IntegralLogTypeEnum;
import com.ctrip.fun.common.vo.integral.IntegralQueryBean;
import com.ctrip.fun.common.vo.integral.UserMemberIntegralLogBean;
import com.ctrip.fun.golf.secrity.Security;
import com.ctrip.fun.golf.secrity.UserContext;
import com.ctrip.fun.golf.service.integral.IntegralService;
/**
* @author zgsong
* @version 1.0.0
*/
@Controller
@RequestMapping(value = "")
@SuppressWarnings("rawtypes")
public class IntegralController {
@Autowired
private IntegralService integralService;
@SuppressWarnings("unchecked")
@ResponseBody
@Security
@RequestMapping(value = "/v1/me/integral", method = RequestMethod.GET, params = { "token", "pagerOffset", "pagerPerPage", "sortField", "sortDirection" })
public Object queryIntegralLogs(@RequestParam String token, IntegralQueryBean integralQueryBean) {
String userId = UserContext.getUserId();
integralQueryBean.setUid(userId);
PagedResponseBean<UserMemberIntegralLogBean> pagedResponseBean = integralService.queryIntegralLogs(integralQueryBean);
Map map = new HashMap();
List<Map> result = new ArrayList();
Collection<UserMemberIntegralLogBean> beans = pagedResponseBean.getResult();
if (beans != null) {
for (UserMemberIntegralLogBean userMemberIntegralLogBean : beans) {
Map mp = new HashMap();
mp.put("amount", userMemberIntegralLogBean.getAmount());
mp.put("date", DateUtil.getDateTimeStr(userMemberIntegralLogBean.getOccurTime()));
mp.put("message", IntegralLogTypeEnum.valueOf(userMemberIntegralLogBean.getLogType()).getValue());
result.add(mp);
}
}
map.put("count", pagedResponseBean.getCount());
map.put("integrals", result);
return map;
}
@SuppressWarnings("unchecked")
@ResponseBody
@RequestMapping(value = "/v1/integral/goods", method = RequestMethod.GET, params = { "pagerOffset", "pagerPerPage", "sortField", "sortDirection" })
public Object queryGoods(IntegralQueryBean integralQueryBean) {
PagedResponseBean<IntegralGoodsBean> pagedResponseBean = integralService.queryGoods(integralQueryBean);
Map map = new HashMap();
List<Map> result = new ArrayList();
Collection<IntegralGoodsBean> beans = pagedResponseBean.getResult();
if (beans != null) {
for (IntegralGoodsBean integralGoodsBean : beans) {
Map mp = new HashMap();
mp.put("image", integralGoodsBean.getImage());
mp.put("name", integralGoodsBean.getName());
mp.put("amount", integralGoodsBean.getAmount());
result.add(mp);
}
}
map.put("count", pagedResponseBean.getCount());
map.put("goods", result);
return map;
}
@SuppressWarnings("unchecked")
@ResponseBody
@RequestMapping(value = "/v1/membership/config", method = RequestMethod.GET)
public Object getIntegralConfig() {
IntegralConfigBean integralConfigBean = integralService.getIntegralConfig();
Map mp = new HashMap();
mp.put("membershipDesc", integralConfigBean.getMembershipDesc());
mp.put("integralRule", integralConfigBean.getIntegralRule());
mp.put("regularMemberDesc", integralConfigBean.getRegularMemberDesc());
mp.put("goldMemberDesc", integralConfigBean.getGoldMemberDesc());
mp.put("diamondMemberDesc", integralConfigBean.getDiamondMemberDesc());
mp.put("platinumMemberDesc", integralConfigBean.getPlatinumMemberDesc());
return mp;
}
@SuppressWarnings("unchecked")
@ResponseBody
@Security
@RequestMapping(value = "/v1/integral/shareOrder/{token}", method = RequestMethod.POST)
public Object shareOrder(@PathVariable String token,@RequestBody UserMemberIntegralLogBean userMemberIntegralLogBean) {
String userId = UserContext.getUserId();
userMemberIntegralLogBean.setUid(userId);
Integer amount = integralService.shareOrder(userMemberIntegralLogBean);
Map map = new HashMap();
map.put("amount", amount);
return map;
}
public IntegralService getIntegralService() {
return integralService;
}
public void setIntegralService(IntegralService integralService) {
this.integralService = integralService;
}
}
src/main/java/com/ctrip/fun/golf/api/mall/brand/MallBrandController.java 0 → 100644
package com.ctrip.fun.golf.api.mall.brand;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RequestMethod;
import org.springframework.web.bind.annotation.ResponseBody;
import com.ctrip.fun.golf.service.mall.brand.MallBrandService;
@Controller
@RequestMapping(value = "/mall/brand")
public class MallBrandController {
@Autowired
private MallBrandService mallBrandService;
@ResponseBody
@RequestMapping(value = "/list", method = RequestMethod.GET, params = {})
public Object list() {
return mallBrandService.list();
}
@ResponseBody
@RequestMapping(value = "/listHot", method = RequestMethod.GET, params = {})
public Object listHot() {
return mallBrandService.listHot();
}
}
src/main/java/com/ctrip/fun/golf/api/mall/category/MallCategoryController.java 0 → 100644
package com.ctrip.fun.golf.api.mall.category;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RequestMethod;
import org.springframework.web.bind.annotation.RequestParam;
import org.springframework.web.bind.annotation.ResponseBody;
import com.ctrip.fun.golf.service.mall.category.MallCategoryService;
import com.ctrip.fun.mall.vo.category.MallCategoryQuery;
@Controller
@RequestMapping(value = "/mall/category")
public class MallCategoryController {
@Autowired
private MallCategoryService mallCategoryService;
@ResponseBody
@RequestMapping(value = "/listCategoryOne", method = RequestMethod.GET, params = {})
public Object listCategoryOne() {
return mallCategoryService.listCategoryOne();
}
@ResponseBody
@RequestMapping(value = "/listCategoryTwo", method = RequestMethod.GET, params = { "pid" })
public Object listCategoryTwo(@RequestParam Integer pid) {
return mallCategoryService.listCategoryTwo(pid);
}
@ResponseBody
@RequestMapping(value = "/listCategoryOneAndTwo", method = RequestMethod.GET, params = { "pagerOffset", "pagerPerPage" })
public Object listCategoryOneAndTwo(MallCategoryQuery query) {
return mallCategoryService.listCategoryOneAndTwo(query);
}
}
src/main/java/com/ctrip/fun/golf/api/mall/config/MallConfigController.java 0 → 100644
package com.ctrip.fun.golf.api.mall.config;
import javax.servlet.http.HttpServletResponse;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RequestMethod;
import org.springframework.web.bind.annotation.RequestParam;
import org.springframework.web.bind.annotation.ResponseBody;
import com.ctrip.fun.common.vo.Response;
import com.ctrip.fun.golf.service.mall.config.MallConfigService;
import com.ctrip.fun.mall.vo.config.MallConfigVO;
@Controller
@RequestMapping(value = "/mall/config")
public class MallConfigController {
@Autowired
private MallConfigService mallConfigService;
@ResponseBody
@RequestMapping(value = "/get", method = RequestMethod.GET, produces = "application/json;charset=UTF-8")
public Object get(@RequestParam String type, HttpServletResponse httpServletResponse) {
Response<MallConfigVO> response = mallConfigService.getByType(type);
if (response == null || response.getBody() == null) {
return "";
}
String responseMessage = response.getBody().getMessage();
return responseMessage;
}
}
src/main/java/com/ctrip/fun/golf/api/mall/order/MallAfterSalesOrderMController.java 0 → 100644
/**
* Copyright 2014 CTRIP Co.,Ltd. All rights reserved.
*/
package com.ctrip.fun.golf.api.mall.order;
import java.text.SimpleDateFormat;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
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.ctrip.fun.common.vo.PagedResponseBean;
import com.ctrip.fun.common.vo.Request;
import com.ctrip.fun.common.vo.Response;
import com.ctrip.fun.golf.secrity.Security;
import com.ctrip.fun.golf.secrity.UserContext;
import com.ctrip.fun.golf.service.mall.order.MallAfterSalesOrderMService;
import com.ctrip.fun.mall.vo.LabelValueBean;
import com.ctrip.fun.mall.vo.order.MallAfterSalesOrderBean;
import com.ctrip.fun.mall.vo.order.MallAfterSalesOrderQuery;
import com.ctrip.fun.mall.vo.order.MallOrderOperateBean;
/**
* @author thshi
* @version 1.0.0
*/
@Controller
@RequestMapping(value = "/mall/afterSalesOrder")
public class MallAfterSalesOrderMController {
@Autowired
private MallAfterSalesOrderMService mallAfterSalesOrderMService = null;
@ResponseBody
@RequestMapping(value = "/add", method = RequestMethod.POST)
@Security(index = 1, field = "token")
public Object addAfterSalesOrder(@RequestBody MallAfterSalesOrderBean afterSalesOrder) {
Request<MallAfterSalesOrderBean> request = new Request<MallAfterSalesOrderBean>();
afterSalesOrder.setUid(UserContext.getUserId());
request.setBody(afterSalesOrder);
request.setUserId(UserContext.getUserId());
Response<Object> reponse = mallAfterSalesOrderMService.addAfterSalesOrder(request);
return reponse;
}
@ResponseBody
@RequestMapping(value = "/express", method = RequestMethod.POST)
@Security(index = 1, field = "token")
public Object addCustomerExpress(@RequestBody MallAfterSalesOrderBean afterSalesOrder) {
Request<MallAfterSalesOrderBean> request = new Request<MallAfterSalesOrderBean>();
afterSalesOrder.setUid(UserContext.getUserId());
request.setBody(afterSalesOrder);
request.setUserId(UserContext.getUserId());
Response<Object> reponse = mallAfterSalesOrderMService.addCustomerExpress(request);
return reponse;
}
@ResponseBody
@Security(index = 1, field = "token")
@RequestMapping(value = "/checkProgress", method = RequestMethod.POST)
public Object queryProgresses(@RequestBody MallAfterSalesOrderQuery mallAfterSalesOrderQuery) {
PagedResponseBean<MallAfterSalesOrderBean> response = new PagedResponseBean<MallAfterSalesOrderBean>();
Request<MallAfterSalesOrderQuery> request = new Request<MallAfterSalesOrderQuery>();
request.setBody(mallAfterSalesOrderQuery);
mallAfterSalesOrderQuery.setUid(UserContext.getUserId());
request.setUserId(UserContext.getUserId());
response = this.mallAfterSalesOrderMService.queryProgresses(request);
Map<String, Object> result = new HashMap<String, Object>();
result.put("count", response.getCount());
List<Map<String, Object>> afterSalesOrdersProgress = new ArrayList<Map<String, Object>>();
result.put("afterSalesOrderProgress", afterSalesOrdersProgress);
if (response.getResult() != null) {
for (MallAfterSalesOrderBean bean : response.getResult()) {
Map<String, Object> progress = new HashMap<String, Object>();
progress.put("orderNo", bean.getOrderNo() + "");
progress.put("afterSalesOrderNo", bean.getAfterSalesOrderNo());
progress.put("applyTime", new SimpleDateFormat("yyyy-MM-dd HH:mm:ss").format(bean.getApplyTime()));
this.setOperationList(progress, bean);
afterSalesOrdersProgress.add(progress);
}
}
return result;
}
@ResponseBody
@RequestMapping(value = "/getExpressName", method = RequestMethod.GET)
public Object getExpressName() {
List<LabelValueBean<Integer>> response = new ArrayList<LabelValueBean<Integer>>();
Request<Object> request = new Request<Object>();
request.setUserId(UserContext.getUserId());
response = this.mallAfterSalesOrderMService.getExpressName(request);
Map<String, Object> result = new HashMap<String, Object>();
result.put("expressName", response);
return result;
}
@ResponseBody
@RequestMapping(value = "/getAfterSalesOrderType", method = RequestMethod.GET)
public Object getAfterSalesOrderType() {
List<LabelValueBean<Integer>> response = new ArrayList<LabelValueBean<Integer>>();
Request<Object> request = new Request<Object>();
request.setUserId(UserContext.getUserId());
response = this.mallAfterSalesOrderMService.getAfterSalesOrderType(request);
Map<String, Object> result = new HashMap<String, Object>();
result.put("afterSalesOrderType", response);
return result;
}
@ResponseBody
@RequestMapping(value = "/getAfterSalesOrderReason", method = RequestMethod.GET)
public Object getAfterSalesOrderReason() {
List<LabelValueBean<Integer>> response = new ArrayList<LabelValueBean<Integer>>();
Request<Object> request = new Request<Object>();
request.setUserId(UserContext.getUserId());
response = this.mallAfterSalesOrderMService.getAfterSalesOrderReason(request);
Map<String, Object> result = new HashMap<String, Object>();
result.put("afterSalesOrderReason", response);
return result;
}
private void setOperationList(Map<String, Object> progress, MallAfterSalesOrderBean bean) {
List<Map<String, Object>> operationList = new ArrayList<Map<String, Object>>();
if (bean.getMallOrderOperateBean() != null) {
for (MallOrderOperateBean mallOrderOperateBean : bean.getMallOrderOperateBean()) {
Map<String, Object> map = new HashMap<String, Object>();
map.put("description", mallOrderOperateBean.getOperateDescription());
map.put("remark", mallOrderOperateBean.getRemark());
map.put("operateTime", new SimpleDateFormat("yyyy-MM-dd HH:mm:ss").format(mallOrderOperateBean.getOperateTime()));
operationList.add(map);
}
}
progress.put("operations", operationList);
}
}
src/main/java/com/ctrip/fun/golf/api/mall/order/MallOrderMController.java 0 → 100644
/**
* Copyright 2014 CTRIP Co.,Ltd. All rights reserved.
*/
package com.ctrip.fun.golf.api.mall.order;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
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.ctrip.fun.common.vo.Request;
import com.ctrip.fun.common.vo.Response;
import com.ctrip.fun.common.vo.ResponseStatusEnum;
import com.ctrip.fun.golf.api.order.AbstractOrderMController;
import com.ctrip.fun.golf.secrity.Security;
import com.ctrip.fun.golf.secrity.UserContext;
import com.ctrip.fun.golf.service.mall.order.MallOrderMService;
import com.ctrip.fun.golf.service.order.AbstractOrderMService;
import com.ctrip.fun.mall.vo.order.MallOrderBean;
import com.ctrip.fun.mall.vo.order.MallOrderListItemBean;
import com.ctrip.fun.mall.vo.order.MallOrderResourceBean;
/**
* @author thshi
* @version 1.0.0
*/
@Controller
@RequestMapping(value = "{version}/mallOrder")
public class MallOrderMController extends AbstractOrderMController<MallOrderBean, MallOrderResourceBean, MallOrderListItemBean> {
@Autowired
private MallOrderMService mallOrderMService = null;
/**
* @return
* @see com.ctrip.fun.golf.api.order.AbstractOrderMController#getOrderService()
*/
@Override
protected AbstractOrderMService<MallOrderBean, MallOrderResourceBean, MallOrderListItemBean> getOrderService() {
return mallOrderMService;
}
/**
* @param map
* @param bean
* @see com.ctrip.fun.golf.api.order.AbstractOrderMController#setOrderListBean(java.util.Map, com.ctrip.fun.common.vo.order2.AbstractOrderListItemBean)
*/
@Override
protected void setOrderListBean(Map<String, Object> map, MallOrderListItemBean bean) {
map.put("freeze", bean.getFreeze());
map.put("saleAttrName1", bean.getSaleAttrName1());
map.put("saleAttrLabel1", bean.getSaleAttrLabel1());
map.put("saleAttrName2", bean.getSaleAttrName2());
map.put("saleAttrLabel2", bean.getSaleAttrLabel2());
map.put("productName", bean.getProductName());
map.put("productId", bean.getProductId());
map.put("merchantId", bean.getMerchantId());
// map.put("merchantName", bean.getMerchantName());
// 商户名不显示在手机端
map.put("merchantName", "");
map.put("hasAfterSalesOrder", bean.getHasAfterSalesOrder());
map.put("productItemId", bean.getProductItemId());
map.put("quantity", bean.getQuantity());
map.put("imagePath", this.mallOrderMService.getImagePath("150*150", bean.getImagePath()));
map.put("postageAmount", bean.getPostageAmount());
map.put("isLogistic", bean.getIsLogistic());
}
/**
* @param bean
* @param map
* @see com.ctrip.fun.golf.api.order.AbstractOrderMController#setOrderResourceList(com.ctrip.fun.common.vo.order2.AbstractOrderBean, java.util.Map)
*/
@Override
protected void setOrderResourceList(MallOrderBean bean, Map<String, Object> orderDetail) {
List<Map<String, Object>> resourceList = new ArrayList<Map<String, Object>>();
if (bean.getResourceList() != null) {
for (MallOrderResourceBean mallOrderResourceBean : bean.getResourceList()) {
Map<String, Object> map = getMallResourceMap(mallOrderResourceBean);
resourceList.add(map);
}
}
orderDetail.put("resourceList", resourceList);
}
/**
* @param mallOrderResourceBean
* @return
*/
private Map<String, Object> getMallResourceMap(MallOrderResourceBean mallOrderResourceBean) {
Map<String, Object> map = new HashMap<String, Object>();
map.put("productId", mallOrderResourceBean.getProductId());
map.put("productName", mallOrderResourceBean.getProductName());
map.put("productItemId", mallOrderResourceBean.getProductItemId());
map.put("saleAttrName1", mallOrderResourceBean.getSaleAttrName1());
map.put("saleAttrLabel1", mallOrderResourceBean.getSaleAttrLabel1());
map.put("saleAttrName2", mallOrderResourceBean.getSaleAttrName2());
map.put("saleAttrLabel2", mallOrderResourceBean.getSaleAttrLabel2());
map.put("amount", mallOrderResourceBean.getAmount());
map.put("salePrice", mallOrderResourceBean.getSalePrice());
map.put("quantity", mallOrderResourceBean.getQuantity());
map.put("imagePath", this.mallOrderMService.getImagePath("150*150", mallOrderResourceBean.getImagePath()));
map.put("cashRebate", mallOrderResourceBean.getCashRebate());
return map;
}
/**
* @param bean
* @param result
* @see com.ctrip.fun.golf.api.order.AbstractOrderMController#resetRebookOrderResourceList(com.ctrip.fun.common.vo.order2.AbstractOrderBean, java.util.Map)
*/
@Override
protected void setRebookOrderResourceList(MallOrderBean bean, Map<String, Object> orderDetail) {
List<Map<String, Object>> resourceList = new ArrayList<Map<String, Object>>();
if (bean.getResourceList() != null) {
for (MallOrderResourceBean mallOrderResourceBean : bean.getResourceList()) {
Map<String, Object> map = getMallResourceMap(mallOrderResourceBean);
resourceList.add(map);
}
}
orderDetail.put("resourceList", resourceList);
}
/**
* @param result
* @param bean
* @see com.ctrip.fun.golf.api.order.AbstractOrderMController#setOtherOrderBasic(java.util.Map, com.ctrip.fun.common.vo.order2.AbstractOrderBean)
*/
@Override
protected void setOtherOrderBasic(Map<String, Object> result, MallOrderBean bean) {
result.put("merchantId", bean.getMerchantId());
// result.put("merchantName", bean.getMerchantName());
// 商户名不显示在手机端
result.put("merchantName", "");
result.put("productId", bean.getProductId());
result.put("expressName", bean.getExpressName());
result.put("expressNo", bean.getExpressNo());
result.put("hasAfterSalesOrder", bean.getHasAfterSalesOrder());
result.put("freeze", bean.getFreeze());
result.put("afterSalesOrderNo", bean.getAfterSalesOrderNo());
result.put("activityProductId", bean.getActivityProductId());
result.put("customerServicePhone", bean.getCustomerServicePhone());
result.put("isLogistic", bean.getIsLogistic());
result.put("isInvoice", bean.getIsInvoice());
}
@ResponseBody
@Security(index = 1, field = "token")
@RequestMapping(value = "/orders/confirmReceving", method = RequestMethod.POST)
public Object confirmReceving(@RequestBody MallOrderBean bean) {
Response<String> response = new Response<String>();
Request<MallOrderBean> request = new Request<MallOrderBean>();
request.setBody(bean);
bean.setUid(UserContext.getUserId());
request.setUserId(UserContext.getUserId());
response = this.mallOrderMService.confirmReceving(request);
if (response.getStatus() == ResponseStatusEnum.SUCCESS.getValue()) {
Map<String, Object> map = new HashMap<String, Object>();
map.put("success", true);
return map;
} else {
return handFailResponse(response);
}
}
}
src/main/java/com/ctrip/fun/golf/api/mall/product/MallProductCommentMController.java 0 → 100644
package com.ctrip.fun.golf.api.mall.product;
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.ctrip.fun.common.vo.Request;
import com.ctrip.fun.common.vo.Response;
import com.ctrip.fun.golf.secrity.Security;
import com.ctrip.fun.golf.secrity.UserContext;
import com.ctrip.fun.golf.service.mall.product.MallProductCommentMService;
import com.ctrip.fun.mall.vo.product.MallProductCommentQuery;
import com.ctrip.fun.mall.vo.product.MallProductCommentVO;
@Controller
@RequestMapping(value = "/mall/product/comments")
public class MallProductCommentMController {
@Autowired
private MallProductCommentMService mallProductCommentService;
@ResponseBody
@RequestMapping(value = "/list", method = RequestMethod.GET, params = { "productId", "sortField", "sortDirection", "pagerOffset", "pagerPerPage" })
public Object list(MallProductCommentQuery query) {
return mallProductCommentService.list(query);
}
@ResponseBody
@RequestMapping(value = "/add", method = RequestMethod.POST)
@Security(index = 1, field = "token")
public Object addComment(@RequestBody MallProductCommentVO comment) {
Request<MallProductCommentVO> request = new Request<MallProductCommentVO>();
comment.setCommentUid(UserContext.getUserId());
request.setBody(comment);
request.setUserId(UserContext.getUserId());
Response<Object> reponse = mallProductCommentService.addComments(request);
return reponse;
}
@ResponseBody
@RequestMapping(value = "/getCommentsStatistics", method = RequestMethod.GET, params = { "productId" })
public Object getCommentsStatistics(Integer productId) {
Request<Integer> request = new Request<Integer>();
request.setBody(productId);
request.setUserId(UserContext.getUserId());
Response<Object> reponse = mallProductCommentService.getCommentsStatistics(request);
return reponse;
}
}
src/main/java/com/ctrip/fun/golf/api/mall/product/MallProductController.java 0 → 100644
package com.ctrip.fun.golf.api.mall.product;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
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.ctrip.fun.common.vo.PagedResponseBean;
import com.ctrip.fun.golf.secrity.Security;
import com.ctrip.fun.golf.secrity.UserContext;
import com.ctrip.fun.golf.service.mall.product.MallProductService;
import com.ctrip.fun.golf.service.user.UserMService;
import com.ctrip.fun.mall.vo.activity.MallActivityProductUserVO;
import com.ctrip.fun.mall.vo.product.MallProductQuery;
import com.ctrip.fun.mall.vo.productclient.MallClientProductVO;
@Controller
@RequestMapping(value = "/mall/product")
public class MallProductController {
@Autowired
private MallProductService mallProductService;
@Autowired
private UserMService userService = null;
@ResponseBody
@RequestMapping(value = "/list", method = RequestMethod.GET, params = { "categoryOneId", "categoryId", "brandId", "name", "sortField", "sortDirection", "pagerOffset", "pagerPerPage" })
public Object list(MallProductQuery query) {
return mallProductService.list(query);
}
/**
* 订单完成页推荐相关闪购商品
*
* @param query
* @return
*/
@ResponseBody
@RequestMapping(value = "/listForRecommended", method = RequestMethod.GET, params = { "token" })
public Object listForFlashRecommended(String token,MallProductQuery query) {
query.setPagerOffset(0);
query.setPagerPerPage(6);
PagedResponseBean<MallClientProductVO> result = mallProductService.listForFlash(query);
List<MallClientProductVO> list = new ArrayList<MallClientProductVO>();
Map<String,List<MallClientProductVO>> returnMap = new HashMap<String,List<MallClientProductVO>>();
if (result != null && result.getResult().size() > 0) {
int size = result.getResult().size();
if (size <= 3) {
returnMap.put("result", (List<MallClientProductVO>) result.getResult());
return returnMap;
} else {
List<MallClientProductVO> collection = (List<MallClientProductVO>) result.getResult();
int collectionSize = collection.size();
for (int i = 0; i < 3; i++) {
if (collectionSize > 0) {
int index = (int) (collectionSize * Math.random());
list.add(collection.get(index));
collection.remove(index);
collectionSize = collectionSize - 1;
}
}
}
}
returnMap.put("result", list);
return returnMap;
}
@ResponseBody
@RequestMapping(value = "/listForFlash", method = RequestMethod.GET, params = { "pagerOffset", "pagerPerPage" })
public Object listForFlash(MallProductQuery query) {
return mallProductService.listForFlash(query);
}
@ResponseBody
@RequestMapping(value = "/get", method = RequestMethod.GET, params = { "productId" })
public Object get(Integer productId) {
return mallProductService.get(productId);
}
@ResponseBody
@RequestMapping(value = "/getForFlash", method = RequestMethod.GET, params = { "token", "activityProductId" })
public Object getForFlash(String token, Integer activityProductId) {
String uid = null;
try {
uid = userService.getUserId(token);
} catch (Exception e) {
}
return mallProductService.getForFlash(uid, activityProductId);
}
@Security(index = 1, field = "token")
@ResponseBody
@RequestMapping(value = "/wantBuy", method = RequestMethod.POST)
public Object wantBuy(@RequestBody MallActivityProductUserVO vo) {
vo.setUid(UserContext.getUserId());
return mallProductService.executeWantBuy(vo.getUid(), vo);
}
@ResponseBody
@RequestMapping(value = "/getDimensionAndGraphicDetails", method = RequestMethod.GET, params = { "productId" })
public Object getDimensionAndGraphicDetails(Integer productId) {
return mallProductService.getDimensionAndGraphicDetails(productId);
}
@ResponseBody
@RequestMapping(value = "/homePageList", method = RequestMethod.GET)
public Object getHomePageList() {
return mallProductService.homePageList();
}
}
src/main/java/com/ctrip/fun/golf/api/mall/product/MallProductGroupController.java 0 → 100644
package com.ctrip.fun.golf.api.mall.product;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
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.ctrip.fun.common.vo.PagedResponseBean;
import com.ctrip.fun.golf.secrity.Security;
import com.ctrip.fun.golf.secrity.UserContext;
import com.ctrip.fun.golf.service.mall.product.MallProductGroupService;
import com.ctrip.fun.golf.service.mall.product.MallProductService;
import com.ctrip.fun.golf.service.user.UserMService;
import com.ctrip.fun.mall.vo.activity.MallActivityProductUserVO;
import com.ctrip.fun.mall.vo.product.MallProductQuery;
import com.ctrip.fun.mall.vo.productclient.MallClientProductVO;
@Controller
@RequestMapping(value = "/mall/product/group")
public class MallProductGroupController {
@Autowired
private MallProductGroupService mallProductGroupService;
@Autowired
private UserMService userService = null;
/**
* 爱玩限时抢购列表 取前5条
* @param query
* @return
*/
@ResponseBody
@RequestMapping(value = "/flashSale/list", method = RequestMethod.GET, params = {})
public Object flashSaleList(MallProductQuery query) {
return mallProductGroupService.flashSaleList(query);
}
/**
* 爱玩定制
* @param query
* @return
*/
@ResponseBody
@RequestMapping(value = "/customized/list", method = RequestMethod.GET, params = {})
public Object customizedList(MallProductQuery query) {
return mallProductGroupService.customizedList(query);
}
/**
* 爱玩工坊
* @param query
* @return
*/
@ResponseBody
@RequestMapping(value = "/workshop/list", method = RequestMethod.GET, params = {})
public Object workshopList(MallProductQuery query) {
return mallProductGroupService.workshopList(query);
}
/**
* 初学者爱玩
* @param query
* @return
*/
@ResponseBody
@RequestMapping(value = "/beginner/list", method = RequestMethod.GET, params = {})
public Object beginnerList(MallProductQuery query) {
return mallProductGroupService.beginnerList(query);
}
/**
* 青少年爱玩
* @param query
* @return
*/
@ResponseBody
@RequestMapping(value = "/junior/list", method = RequestMethod.GET, params = {})
public Object juniorList(MallProductQuery query) {
return mallProductGroupService.juniorList(query);
}
}
src/main/java/com/ctrip/fun/golf/api/membership/CourseCardsMController.java 0 → 100644
package com.ctrip.fun.golf.api.membership;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RequestMethod;
import org.springframework.web.bind.annotation.RequestParam;
import org.springframework.web.bind.annotation.ResponseBody;
import com.ctrip.fun.common.vo.PagedResponseBean;
import com.ctrip.fun.common.vo.membership.CourseCardsBean;
import com.ctrip.fun.common.vo.membership.MbsCardTypeQuery;
import com.ctrip.fun.golf.service.membership.CourseCardsMService;
@Controller
@RequestMapping(value = "")
public class CourseCardsMController {
@Autowired
private CourseCardsMService service = null;
public CourseCardsMService getService() {
return service;
}
public void setService(CourseCardsMService service) {
this.service = service;
}
@ResponseBody
@RequestMapping(value = "/v1/mbs/course/cardTypes", method = RequestMethod.GET)
public Object getCardTypesByCourseId(@RequestParam int courseId) {
MbsCardTypeQuery query = new MbsCardTypeQuery();
query.setCourseId(courseId);
PagedResponseBean<CourseCardsBean> pagedResponseBean = service.getCardsTypeByCourseId(query);
return pagedResponseBean;
}
}
src/main/java/com/ctrip/fun/golf/api/membership/MemberShipMcontroller.java 0 → 100644
package com.ctrip.fun.golf.api.membership;
import java.util.List;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RequestMethod;
import org.springframework.web.bind.annotation.RequestParam;
import org.springframework.web.bind.annotation.ResponseBody;
import com.ctrip.fun.common.vo.PagedResponseBean;
import com.ctrip.fun.common.vo.SortDirectionEnum;
import com.ctrip.fun.common.vo.membership.ConfigBean;
import com.ctrip.fun.common.vo.membership.CourseCardsBean;
import com.ctrip.fun.common.vo.membership.MbsCardTypeQuery;
import com.ctrip.fun.common.vo.membership.MbsCourseByNameQuery;
import com.ctrip.fun.common.vo.membership.MbsCourseByNameResponse;
import com.ctrip.fun.common.vo.membership.MbsCourseQuery;
import com.ctrip.fun.common.vo.membership.MbsCourseResponse;
import com.ctrip.fun.common.vo.membership.MbsOrderStatusEnum;
import com.ctrip.fun.golf.service.course.CourseService;
import com.ctrip.fun.golf.service.membership.MemberShipMService;
@Controller
@RequestMapping(value = "")
public class MemberShipMcontroller {
private Logger logger = LoggerFactory.getLogger(MemberShipMcontroller.class);
@Autowired
private MemberShipMService service = null;
@Autowired
private CourseService courseService = null;
public MemberShipMService getService() {
return service;
}
public void setService(MemberShipMService service) {
this.service = service;
}
public CourseService getCourseService() {
return courseService;
}
public void setCourseService(CourseService courseService) {
this.courseService = courseService;
}
@ResponseBody
@RequestMapping(value = "/v1/mbs/courses", method = RequestMethod.GET, params = { "cityId", "imageSize", "pagerOffset","pagerPerPage", "sortField", "sortDirection"})
public Object queryCourseList(@RequestParam int cityId, @RequestParam String imageSize,
@RequestParam int pagerOffset, @RequestParam int pagerPerPage, @RequestParam String sortField, @RequestParam String sortDirection){
MbsCourseQuery query = new MbsCourseQuery();
query.setCityId(cityId);
query.setImageSize(imageSize);
query.setPagerOffset(pagerOffset);
query.setPagerPerPage(pagerPerPage);
query.setSortField(sortField);
query.setStatus(MbsOrderStatusEnum.RELEASE);
if ("DESC".equals(sortDirection)) {
query.setSortDirection(SortDirectionEnum.DESC);
} else {
query.setSortDirection(SortDirectionEnum.ASC);
}
PagedResponseBean<MbsCourseResponse> pagedResponseBean = service.queryCourseList(query);
List<MbsCourseResponse> list = (List<MbsCourseResponse>) pagedResponseBean.getResult();
for (MbsCourseResponse mbsResponse: list) {
String imagePath = mbsResponse.getImagePath();
String url = courseService.getImagePath(query.getImageSize(), imagePath);
mbsResponse.setUrl(url);
}
return pagedResponseBean;
}
@ResponseBody
@RequestMapping(value = "/v1/mbs/coursesByName", method = RequestMethod.GET, params = {"cityId", "name", "pagerOffset", "pagerPerPage", "sortField", "sortDirection"})
public Object queryCourseListByName(@RequestParam int cityId, @RequestParam String name, @RequestParam int pagerOffset, @RequestParam int pagerPerPage,
@RequestParam String sortField, @RequestParam String sortDirection) {
MbsCourseByNameQuery query = new MbsCourseByNameQuery();
query.setCityId(cityId);
query.setName(name);
query.setPagerOffset(pagerOffset);
query.setPagerPerPage(pagerPerPage);
query.setSortField(sortField);
if ("DESC".equals(sortDirection)) {
query.setSortDirection(SortDirectionEnum.DESC);
} else {
query.setSortDirection(SortDirectionEnum.ASC);
}
PagedResponseBean<MbsCourseByNameResponse> pagedResponseBean = service.queryCourseListByName(query);
return pagedResponseBean;
}
@ResponseBody
@RequestMapping(value = "/v1/mbs/config", method = RequestMethod.GET)
public Object getConfig() {
ConfigBean response = service.getConfig();
return response;
}
}
src/main/java/com/ctrip/fun/golf/api/message/MessageReportController.java 0 → 100644
package com.ctrip.fun.golf.api.message;
import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.util.ArrayList;
import java.util.List;
import javax.servlet.http.HttpServletRequest;
import org.dom4j.Document;
import org.dom4j.DocumentException;
import org.dom4j.DocumentHelper;
import org.dom4j.Element;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
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.ctrip.fun.common.vo.basic.SmsBean;
import com.ctrip.fun.common.vo.basic.SmsStatus;
import com.ctrip.fun.golf.service.message.MessageReportService;
@Controller
@RequestMapping("/message")
public class MessageReportController {
private static final Logger logger = LoggerFactory.getLogger(MessageReportController.class);
@Autowired
private MessageReportService messageReportService = null;
@ResponseBody
@RequestMapping(value = "/MessageReportdfdf.do", method = RequestMethod.POST)
public Object getReport(@RequestBody String getData) {
// String getData = data.toString();
System.out.println(getData); // 显示接收的字符串
if (null == getData || "".equals(getData)) {
return "9";
} // 如果接收失败，返回9
else {
this.dealMessages(getData);
return "0";
} // 如果接收成功，返回0
}
/**
* 消息解析
*
* @param str
*/
private void dealMessages(String str) {
List<SmsBean> list = new ArrayList<SmsBean>();
Document doc = null;
try {
doc = DocumentHelper.parseText(str);
logger.info("str="+str);
if (null != doc) {
Element root = doc.getRootElement();
List<Element> reportElements = root.elements("report");
for (Element report : reportElements) {
String msg_id = report.elementText("msg_id");
String mobile = report.elementText("mobile");
String result = report.elementText("result");
String time = report.elementText("report_time");
SmsBean smsBean = new SmsBean();
logger.info(msg_id + ":" + mobile + ":" + result + ":" + time);
if (msg_id != null && !"".equals(msg_id)) {
smsBean.setMessageId(Long.parseLong(msg_id));
if(null!=mobile&&!"".equals(mobile)){
smsBean.setMobileNo(mobile);
}
if(null!=time&&!"".equals(time))
smsBean.setDataChangeLastTime(new SimpleDateFormat("yyyy-MM-dd HH:mm:ss").parse(time));
if ("0".equals(result)||"000".equals(result)) {
smsBean.setStatus(SmsStatus.SEND_SUCCESS.getKey());// 发送成功
} else {
logger.error(mobile+" failed code is " +result);
smsBean.setStatus(SmsStatus.SEND_FAIL.getKey());// 发送失败
}
list.add(smsBean);
} else {
continue;
}
}
this.messageReportService.updateSmsStatus(list);
}
} catch (DocumentException | ParseException e) {
e.printStackTrace();
}
}
}
src/main/java/com/ctrip/fun/golf/api/order/CommuneOrderMController.java 0 → 100644
/**
* Copyright 2014 CTRIP Co.,Ltd. All rights reserved.
*/
package com.ctrip.fun.golf.api.order;
import java.util.Map;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.RequestMapping;
import com.ctrip.fun.common.vo.order.CommuneOrderBean;
import com.ctrip.fun.common.vo.order.CommuneOrderListItemBean;
import com.ctrip.fun.common.vo.order.CommuneOrderResourceBean;
import com.ctrip.fun.golf.service.order.AbstractOrderMService;
import com.ctrip.fun.golf.service.order.CommuneOrderMService;
@Controller
@RequestMapping(value = "{version}/communeOrder")
public class CommuneOrderMController extends AbstractOrderMController<CommuneOrderBean, CommuneOrderResourceBean, CommuneOrderListItemBean> {
@Autowired
private CommuneOrderMService communeOrderMService = null;
@Override
protected AbstractOrderMService<CommuneOrderBean, CommuneOrderResourceBean, CommuneOrderListItemBean> getOrderService() {
return communeOrderMService;
}
@Override
protected void setOrderListBean(Map<String, Object> map, CommuneOrderListItemBean bean) {
// TODO Auto-generated method stub
}
@Override
protected void setOrderResourceList(CommuneOrderBean bean, Map<String, Object> map) {
// TODO Auto-generated method stub
}
@Override
protected void setOtherOrderBasic(Map<String, Object> result, CommuneOrderBean bean) {
// TODO Auto-generated method stub
}
@Override
protected void setRebookOrderResourceList(CommuneOrderBean bean, Map<String, Object> result) {
// TODO Auto-generated method stub
}
}
src/main/java/com/ctrip/fun/golf/api/order/CourseOrderMController.java 0 → 100644
/**
* Copyright 2014 CTRIP Co.,Ltd. All rights reserved.
*/
package com.ctrip.fun.golf.api.order;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.RequestMapping;
import com.ctrip.fun.common.core.util.DateUtil;
import com.ctrip.fun.common.vo.order.CourseOrderBean;
import com.ctrip.fun.common.vo.order.CourseOrderListItemBean;
import com.ctrip.fun.common.vo.order.CourseOrderResourceBean;
import com.ctrip.fun.golf.service.order.AbstractOrderMService;
import com.ctrip.fun.golf.service.order.CourseOrderMService;
/**
* @author zgsong
* @version 1.0.0
*/
@Controller
@RequestMapping(value = "{version}/courseOrder")
public class CourseOrderMController extends AbstractOrderMController<CourseOrderBean, CourseOrderResourceBean, CourseOrderListItemBean> {
@Autowired
private CourseOrderMService courseOrderMService = null;
/**
* @return
* @see com.ctrip.fun.golf.api.order.AbstractOrderMController#getOrderService()
*/
@Override
protected AbstractOrderMService<CourseOrderBean, CourseOrderResourceBean, CourseOrderListItemBean> getOrderService() {
return courseOrderMService;
}
/**
* @param map
* @param bean
* @see com.ctrip.fun.golf.api.order.AbstractOrderMController#setOrderListBean(java.util.Map, com.ctrip.fun.common.vo.order2.AbstractOrderListItemBean)
*/
@Override
protected void setOrderListBean(Map<String, Object> map, CourseOrderListItemBean bean) {
map.put("productId", bean.getProductId());
map.put("productName", bean.getProductName());
map.put("playDate", DateUtil.getDateStr(bean.getPlayDate()));
map.put("teeTime", bean.getTeeTime());
}
/**
* @param bean
* @param map
* @see com.ctrip.fun.golf.api.order.AbstractOrderMController#setOrderResourceList(com.ctrip.fun.common.vo.order2.AbstractOrderBean, java.util.Map)
*/
@Override
protected void setOrderResourceList(CourseOrderBean bean, Map<String, Object> orderDetail) {
List<Map<String, Object>> resourceList = new ArrayList<Map<String, Object>>();
if (bean.getResourceList() != null) {
for (CourseOrderResourceBean courseOrderResourceBean : bean.getResourceList()) {
Map<String, Object> map = getCourseResourceMap(courseOrderResourceBean);
resourceList.add(map);
}
}
orderDetail.put("resourceList", resourceList);
}
/**
* @param courseOrderResourceBean
* @return
*/
private Map<String, Object> getCourseResourceMap(CourseOrderResourceBean courseOrderResourceBean) {
Map<String, Object> map = new HashMap<String, Object>();
map.put("productId", courseOrderResourceBean.getProductId());
map.put("productName", courseOrderResourceBean.getProductName());
map.put("playDate", DateUtil.getDateStr(courseOrderResourceBean.getPlayDate()));
map.put("teeTime", courseOrderResourceBean.getTeeTime());
map.put("realPlayTime", courseOrderResourceBean.getRealPlayTime());
map.put("quantity", courseOrderResourceBean.getQuantity());
map.put("courseId", courseOrderResourceBean.getCourseId());
map.put("courseName", courseOrderResourceBean.getCourseName());
map.put("courseTel", courseOrderResourceBean.getCourseTel());
map.put("courseAddress", courseOrderResourceBean.getCourseAddress());
map.put("courseLng", courseOrderResourceBean.getCourseLng());
map.put("courseLat", courseOrderResourceBean.getCourseLat());
map.put("cancelTips", courseOrderResourceBean.getCancelTips());
map.put("tips", courseOrderResourceBean.getTips());
map.put("feeDesc", courseOrderResourceBean.getFeeDesc());
return map;
}
/**
* @param bean
* @param result
* @see com.ctrip.fun.golf.api.order.AbstractOrderMController#resetRebookOrderResourceList(com.ctrip.fun.common.vo.order2.AbstractOrderBean, java.util.Map)
*/
@Override
protected void setRebookOrderResourceList(CourseOrderBean bean, Map<String, Object> orderDetail) {
List<Map<String, Object>> resourceList = new ArrayList<Map<String, Object>>();
if (bean.getResourceList() != null) {
for (CourseOrderResourceBean courseOrderResourceBean : bean.getResourceList()) {
Map<String, Object> map = getCourseResourceMap(courseOrderResourceBean);
map.put("resourceType", courseOrderResourceBean.getResourceType());
map.put("currency", courseOrderResourceBean.getCurrency());
map.put("amount", courseOrderResourceBean.getAmount());
map.put("resourceId", courseOrderResourceBean.getResourceId());
map.put("salePrice", courseOrderResourceBean.getSalePrice());
map.put("resourceName", courseOrderResourceBean.getResourceName());
map.put("cashRebate", courseOrderResourceBean.getCashRebate());
map.put("prepaidPrice", courseOrderResourceBean.getPrepaidPrice());
map.put("freezeAmount", courseOrderResourceBean.getFreezeAmount());
map.put("startTime", courseOrderResourceBean.getStartTime());
map.put("memberPrice", courseOrderResourceBean.getMemberPrice());
map.put("memberCashRebate", courseOrderResourceBean.getMemberCashRebate());
resourceList.add(map);
}
}
orderDetail.put("resourceList", resourceList);
}
/**
* @param result
* @param bean
* @see com.ctrip.fun.golf.api.order.AbstractOrderMController#setOtherOrderBasic(java.util.Map, com.ctrip.fun.common.vo.order2.AbstractOrderBean)
*/
@Override
protected void setOtherOrderBasic(Map<String, Object> result, CourseOrderBean bean) {
result.put("campaignID", bean.getCampaignID());
result.put("sponsorUnitAmount", bean.getSponsorUnitAmount());
result.put("useMemberPrice", bean.getUseMemberPrice());
}
}
src/main/java/com/ctrip/fun/golf/api/order/EventActivityOrderMController.java 0 → 100644
/**
* Copyright 2014 CTRIP Co.,Ltd. All rights reserved.
*/
package com.ctrip.fun.golf.api.order;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.RequestMapping;
import com.ctrip.fun.common.core.util.DateUtil;
import com.ctrip.fun.common.vo.order.EventActivityOrderBean;
import com.ctrip.fun.common.vo.order.EventActivityOrderListItemBean;
import com.ctrip.fun.common.vo.order.EventActivityOrderResourceBean;
import com.ctrip.fun.golf.service.order.AbstractOrderMService;
import com.ctrip.fun.golf.service.order.EventActivityOrderMService;
/**
* @author zgsong
* @version 1.0.0
*/
@Controller
@RequestMapping(value = "{version}/eventActivityOrder")
public class EventActivityOrderMController extends AbstractOrderMController<EventActivityOrderBean, EventActivityOrderResourceBean, EventActivityOrderListItemBean> {
@Autowired
private EventActivityOrderMService eventActivityOrderMService = null;
/**
* @return
* @see com.ctrip.fun.golf.api.order.AbstractOrderMController#getOrderService()
*/
@Override
protected AbstractOrderMService<EventActivityOrderBean, EventActivityOrderResourceBean, EventActivityOrderListItemBean> getOrderService() {
return eventActivityOrderMService;
}
/**
* @param map
* @param bean
* @see com.ctrip.fun.golf.api.order.AbstractOrderMController#setOrderListBean(java.util.Map, com.ctrip.fun.common.vo.order2.AbstractOrderListItemBean)
*/
@Override
protected void setOrderListBean(Map<String, Object> map, EventActivityOrderListItemBean bean) {
map.put("productId", bean.getProductId());
map.put("productName", bean.getProductName());
map.put("playDate", DateUtil.getDateStr(bean.getPlayDate()));
map.put("startTime", bean.getStartTime());
}
/**
* @param bean
* @param map
* @see com.ctrip.fun.golf.api.order.AbstractOrderMController#setOrderResourceList(com.ctrip.fun.common.vo.order2.AbstractOrderBean, java.util.Map)
*/
@Override
protected void setOrderResourceList(EventActivityOrderBean bean, Map<String, Object> orderDetail) {
List<Map<String, Object>> resourceList = new ArrayList<Map<String, Object>>();
if (bean.getResourceList() != null) {
for (EventActivityOrderResourceBean eventActivityOrderResourceBean : bean.getResourceList()) {
Map<String, Object> map = getCourseResourceMap(eventActivityOrderResourceBean);
resourceList.add(map);
}
}
orderDetail.put("resourceList", resourceList);
}
/**
* @param eventActivityOrderResourceBean
* @return
*/
private Map<String, Object> getCourseResourceMap(EventActivityOrderResourceBean eventActivityOrderResourceBean) {
Map<String, Object> map = new HashMap<String, Object>();
map.put("productId", eventActivityOrderResourceBean.getProductId());
map.put("productName", eventActivityOrderResourceBean.getProductName());
map.put("playDate", DateUtil.getDateStr(eventActivityOrderResourceBean.getPlayDate()));
map.put("startTime", eventActivityOrderResourceBean.getStartTime());
map.put("quantity", eventActivityOrderResourceBean.getQuantity());
map.put("communeQuantity", eventActivityOrderResourceBean.getCommuneQuantity());
map.put("communeGuestquantity", eventActivityOrderResourceBean.getCommuneGuestQuantity());
map.put("courseId", eventActivityOrderResourceBean.getCourseId());
map.put("courseName", eventActivityOrderResourceBean.getCourseName());
map.put("courseTel", eventActivityOrderResourceBean.getCourseTel());
map.put("courseAddress", eventActivityOrderResourceBean.getCourseAddress());
map.put("courseLng", eventActivityOrderResourceBean.getCourseLng());
map.put("courseLat", eventActivityOrderResourceBean.getCourseLat());
map.put("cancelTips", eventActivityOrderResourceBean.getCancelTips());
map.put("tips", eventActivityOrderResourceBean.getTips());
map.put("feeDesc", eventActivityOrderResourceBean.getFeeDesc());
map.put("communePrice", eventActivityOrderResourceBean.getCommunePrice());
map.put("communeMinus", eventActivityOrderResourceBean.getCommuneMinus());
map.put("communeGuestPrice", eventActivityOrderResourceBean.getCommuneGuestPrice());
map.put("communeGuestMinus", eventActivityOrderResourceBean.getCommuneGuestMinus());
map.put("cashRebate", eventActivityOrderResourceBean.getCashRebate());
map.put("groupFlag", eventActivityOrderResourceBean.isGroupFlag());
map.put("resourceId", eventActivityOrderResourceBean.getResourceId());
map.put("resourceName", eventActivityOrderResourceBean.getResourceName());
return map;
}
/**
* @param bean
* @param result
* @see com.ctrip.fun.golf.api.order.AbstractOrderMController#resetRebookOrderResourceList(com.ctrip.fun.common.vo.order2.AbstractOrderBean, java.util.Map)
*/
@Override
protected void setRebookOrderResourceList(EventActivityOrderBean bean, Map<String, Object> orderDetail) {
List<Map<String, Object>> resourceList = new ArrayList<Map<String, Object>>();
if (bean.getResourceList() != null) {
for (EventActivityOrderResourceBean eventActivityOrderResourceBean : bean.getResourceList()) {
Map<String, Object> map = getCourseResourceMap(eventActivityOrderResourceBean);
map.put("resourceType", eventActivityOrderResourceBean.getResourceType());
map.put("currency", eventActivityOrderResourceBean.getCurrency());
map.put("amount", eventActivityOrderResourceBean.getAmount());
resourceList.add(map);
}
}
orderDetail.put("resourceList", resourceList);
}
/**
* @param result
* @param bean
* @see com.ctrip.fun.golf.api.order.AbstractOrderMController#setOtherOrderBasic(java.util.Map, com.ctrip.fun.common.vo.order2.AbstractOrderBean)
*/
@Override
protected void setOtherOrderBasic(Map<String, Object> result, EventActivityOrderBean bean) {
result.put("groupNum", bean.getGroupNum());
result.put("realTimeTeeTimeType", bean.getRealTimeTeeTimeType() != null ? bean.getRealTimeTeeTimeType() : 1);
result.put("teeTimeStr", bean.getTeeTimeStr());
}
}
src/main/java/com/ctrip/fun/golf/api/order/RechargeOrderMController.java 0 → 100644
/**
* Copyright 2014 CTRIP Co.,Ltd. All rights reserved.
*/
package com.ctrip.fun.golf.api.order;
import java.util.Map;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.RequestMapping;
import com.ctrip.fun.common.vo.order.RechargeOrderBean;
import com.ctrip.fun.common.vo.order.RechargeOrderListItemBean;
import com.ctrip.fun.common.vo.order.RechargeOrderResourceBean;
import com.ctrip.fun.golf.service.order.AbstractOrderMService;
import com.ctrip.fun.golf.service.order.RechargeOrderMService;
@Controller
@RequestMapping(value = "{version}/rechargeOrder")
public class RechargeOrderMController extends AbstractOrderMController<RechargeOrderBean, RechargeOrderResourceBean, RechargeOrderListItemBean> {
@Autowired
private RechargeOrderMService rechargeOrderMService = null;
@Override
protected AbstractOrderMService<RechargeOrderBean, RechargeOrderResourceBean, RechargeOrderListItemBean> getOrderService() {
return rechargeOrderMService;
}
@Override
protected void setOrderListBean(Map<String, Object> map, RechargeOrderListItemBean bean) {
map.put("recommendCode", bean.getRecommendCode());
}
@Override
protected void setOrderResourceList(RechargeOrderBean bean, Map<String, Object> map) {
map.put("recommendCode", bean.getRecommendCode());
}
@Override
protected void setOtherOrderBasic(Map<String, Object> result, RechargeOrderBean bean) {
// TODO Auto-generated method stub
}
@Override
protected void setRebookOrderResourceList(RechargeOrderBean bean, Map<String, Object> result) {
// TODO Auto-generated method stub
}
}
src/main/java/com/ctrip/fun/golf/api/outdoor/OutdoorMController.java 0 → 100644
/**
* Copyright 2014 CTRIP Co.,Ltd. All rights reserved.
*/
package com.ctrip.fun.golf.api.outdoor;
import java.util.HashMap;
import java.util.Map;
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.RequestHeader;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RequestMethod;
import org.springframework.web.bind.annotation.ResponseBody;
import com.ctrip.fun.common.vo.user.VerifyCodeBean;
import com.ctrip.fun.common.vo.user.VerifyResultBean;
import com.ctrip.fun.golf.service.outdoor.OutdoorMService;
/**
* @author zgsong
* @version 1.0.0
*/
@Controller
@RequestMapping(value = "")
@SuppressWarnings("rawtypes")
public class OutdoorMController {
@Autowired
private OutdoorMService outdoorMService = null;
/**
* 发送注册验证码
*
* @param clientIp
* @param verifyCodeBean
* @return
*/
@SuppressWarnings("unchecked")
@ResponseBody
@RequestMapping(value = "/v1/outdoor/sendVerifyCode", method = RequestMethod.POST)
public Object sendVerifyCode(@RequestHeader(value = "x-gate-request.client.ip", required = false) String clientIp, @RequestBody VerifyCodeBean verifyCodeBean) {
if (null == clientIp || "".equals(clientIp.trim()))
clientIp = "";
if (clientIp.contains(",")) {
clientIp = clientIp.split(",")[0];
}
verifyCodeBean.setUserIP(clientIp);
VerifyResultBean verifyResultBean = outdoorMService.sendVerifyCode(verifyCodeBean);
Map mp = new HashMap();
mp.put("maxSendTimes", verifyResultBean.getMaxSendTimes());
mp.put("leftSendTimes", verifyResultBean.getLeftSendTimes());
mp.put("code", verifyResultBean.getReturnCode());
mp.put("message", verifyResultBean.getMessage());
return mp;
}
/**
* 验证校验码
*
* @param clientIp
* @param verifyCodeBean
* @return
*/
@SuppressWarnings("unchecked")
@ResponseBody
@RequestMapping(value = "/v1/outdoor/validateCode", method = RequestMethod.POST)
public Object validateMobile(@RequestHeader(value = "x-gate-request.client.ip", required = false) String clientIp, @RequestBody VerifyCodeBean verifyCodeBean) {
if (null == clientIp || "".equals(clientIp.trim()))
clientIp = "";
if (clientIp.contains(",")) {
clientIp = clientIp.split(",")[0];
}
verifyCodeBean.setUserIP(clientIp);
VerifyResultBean verifyResultBean = outdoorMService.validateCode(verifyCodeBean);
Map mp = new HashMap();
mp.put("maxSendTimes", verifyResultBean.getMaxSendTimes());
mp.put("leftSendTimes", verifyResultBean.getLeftSendTimes());
mp.put("code", verifyResultBean.getReturnCode());
mp.put("message", verifyResultBean.getMessage());
return mp;
}
}
src/main/java/com/ctrip/fun/golf/api/score/CourseController.java 0 → 100644
/**
* Copyright 2014 CTRIP Co.,Ltd. All rights reserved.
*/
package com.ctrip.fun.golf.api.score;
import java.util.List;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.ResponseBody;
import com.ctrip.fun.common.core.util.StringUtils;
import com.ctrip.fun.common.vo.PagedResponseBean;
import com.ctrip.fun.common.vo.Response;
import com.ctrip.fun.common.vo.coursescore.CourseBean;
import com.ctrip.fun.common.vo.coursescore.CourseSearchVO;
import com.ctrip.fun.common.vo.user.UserBean;
import com.ctrip.fun.golf.service.course.CourseService;
import com.ctrip.fun.golf.service.user.UserMService;
/**
* Controller - 计分开始，选择的球场基础数据
*
* @author lingsl
* @version 1.0.0 2016-07-07
*/
@Controller("courseContrller")
@RequestMapping("/course")
public class CourseController {
@Autowired
private CourseService courseService;
@Autowired
private UserMService userMService;
/**
* 根据经纬度坐标按距离排序搜索球场
*
* @param lng
* @param lat
* @param page
* @param key
* @return
*/
@RequestMapping("search")
@ResponseBody
public PagedResponseBean<CourseBean> search(CourseSearchVO courseSearchVO) {
return courseService.search(courseSearchVO);
}
/**
* 常打球场
*
* @param token
* @return
*/
@RequestMapping("findCommonUsage")
@ResponseBody
public Response<List<CourseBean>> findCommonUsage(String token) {
Response<List<CourseBean>> response = new Response<List<CourseBean>>();
UserBean userBean = userMService.getUserBean(token);
if (userBean == null || StringUtils.isEmpty(userBean.getUid())) {
response.setMessage("非法token");
response.setStatus(401);
return response;
}
List<CourseBean> courseBeans = courseService.findCommonUsage(userBean.getUid());
response.setBody(courseBeans);
response.setMessage("success");
response.setStatus(0);
return response;
}
}
src/main/java/com/ctrip/fun/golf/api/system/CheckController.java 0 → 100644
package com.ctrip.fun.golf.api.system;
import java.util.ArrayList;
import java.util.List;
import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RequestMethod;
import org.springframework.web.bind.annotation.ResponseBody;
/**
* Created by l_cheng on 2014/9/15.
*/
@Controller
@RequestMapping(value = "/check")
public class CheckController {
@ResponseBody
@RequestMapping(value = "/ips", method = RequestMethod.GET)
public List<String> querySslIpList() {
List<String> list = new ArrayList<>();
list.add("140.207.228.190");
return list;
}
}
src/main/java/com/ctrip/fun/golf/api/umeng/UmengController.java 0 → 100644
/**
* Copyright 2014 CTRIP Co.,Ltd. All rights reserved.
*/
package com.ctrip.fun.golf.api.umeng;
import org.apache.commons.lang.StringUtils;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.PathVariable;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.ResponseBody;
import com.ctrip.fun.common.vo.Request;
import com.ctrip.fun.common.vo.Response;
import com.ctrip.fun.common.vo.umeng.accesstoken.UmengAccessToken;
import com.ctrip.fun.common.vo.user.UserBean;
import com.ctrip.fun.golf.service.umeng.UmengService;
import com.ctrip.fun.golf.service.user.UserMService;
/**
* @author lingsl
* @version 1.0.0
*/
@Controller
@RequestMapping(value = "umeng")
public class UmengController {
@Autowired
private UmengService umengService = null;
@Autowired
private UserMService userMService = null;
@ResponseBody
@RequestMapping(value = "/accessToken/{token}")
public Response<UmengAccessToken> getUmengAccessToken(@PathVariable("token") String token,
Integer userExtId) {
Response<UmengAccessToken> response = new Response<UmengAccessToken>();
if (userExtId == null || userExtId < 1) {
response.setMessage("ExtId参数有误");
response.setStatus(-1);
return response;
}
UserBean userBean = null;
try {
userBean = userMService.getUserBean(token);
} catch (Exception e) {
}
if (userBean == null || StringUtils.isEmpty(userBean.getUid())) {
response.setMessage("非法token");
response.setStatus(-1);
return response;
}
Request<Integer> request = new Request<Integer>();
request.setUserId(userBean.getUid());
request.setBody(userExtId);
return umengService.getUmengAccessToken(request);
}
}
src/main/java/com/ctrip/fun/golf/api/user/UserContractsMController.java 0 → 100644
package com.ctrip.fun.golf.api.user;
/**
* Copyright 2014 CTRIP Co.,Ltd. All rights reserved.
*/
import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.http.HttpStatus;
import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.PathVariable;
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 org.springframework.web.bind.annotation.ResponseStatus;
import com.ctrip.fun.common.core.util.DateUtil;
import com.ctrip.fun.common.core.util.SysUtil;
import com.ctrip.fun.common.vo.Response;
import com.ctrip.fun.common.vo.ResponseStatusEnum;
import com.ctrip.fun.common.vo.user.UserConractsBean;
import com.ctrip.fun.common.vo.user.UserConractsQuery;
import com.ctrip.fun.golf.secrity.Security;
import com.ctrip.fun.golf.service.user.UserContractsMService;
/**
* @author thshi
* @version 1.0.0
*/
@Controller
@RequestMapping(value = "")
@SuppressWarnings("rawtypes")
public class UserContractsMController {
private Logger logger = LoggerFactory.getLogger(UserContractsMController.class);
@Autowired
private UserContractsMService userContractsMService = null;
@SuppressWarnings("unchecked")
@ResponseBody
@RequestMapping(value = "/userContract/list/{token}", method = RequestMethod.GET)
public Object search(@PathVariable("token") String token) {
UserConractsQuery userContractsQuery = new UserConractsQuery();
userContractsQuery.setToken(token);
List<UserConractsBean> beans = userContractsMService.list(userContractsQuery);
Map map = new HashMap();
List<Map> result = new ArrayList();
if (beans != null) {
for (UserConractsBean userContractsBean : beans) {
Map mp = new HashMap();
mp.put("id", userContractsBean.getId());
mp.put("name", userContractsBean.getName());
mp.put("firstName", userContractsBean.getFirstName());
mp.put("lastName", userContractsBean.getLastName());
mp.put("identityType", userContractsBean.getIdentityType());
mp.put("identity", userContractsBean.getIdentity());
mp.put("mobilePhone", userContractsBean.getMobilePhone());
mp.put("sex", userContractsBean.getSex());
mp.put("nationality", userContractsBean.getNationality());
mp.put("birthDay", DateUtil.getDateStr(userContractsBean.getBirthDay()));
mp.put("uid", userContractsBean.getUid());
result.add(mp);
}
}
map.put("count", beans == null ? 0 : beans.size());
map.put("userContracts", result);
return map;
}
@RequestMapping(value = "/userContract/{id}", method = RequestMethod.PUT)
@ResponseStatus(HttpStatus.OK)
@ResponseBody
public Object updateUserContract(@PathVariable("id") Integer id, @RequestBody UserConractsBean userContractsBean) {
logger.info(SysUtil.getMethodName() + " request: " + userContractsBean.toString());
userContractsBean.setId(id);
Response<Integer> response = new Response<>();
response.setStatusEnum(ResponseStatusEnum.SUCCESS);
response.setMessage(ResponseStatusEnum.SUCCESS.getMsg());
try {
userContractsMService.saveOrUpdateUserContract(userContractsBean);
} catch (Exception e) {
response.setStatusEnum(ResponseStatusEnum.FAIL);
response.setMessage(ResponseStatusEnum.FAIL.getMsg());
logger.error("更新User Contracts异常", e);
}
return response;
}
@RequestMapping(value = "/userContract/add", method = RequestMethod.POST)
@ResponseStatus(HttpStatus.OK)
@ResponseBody
public Object saveOrUpdateUserContract(@RequestBody UserConractsBean userContractsBean) {
logger.info(SysUtil.getMethodName() + " request: " + userContractsBean.toString());
Response<Integer> response = new Response<>();
response.setStatusEnum(ResponseStatusEnum.SUCCESS);
response.setMessage(ResponseStatusEnum.SUCCESS.getMsg());
try {
userContractsMService.addUserContract(userContractsBean);
} catch (Exception e) {
response.setStatusEnum(ResponseStatusEnum.FAIL);
response.setMessage(ResponseStatusEnum.FAIL.getMsg());
logger.error("添加User Contracts异常", e);
}
return response;
}
@ResponseBody
@RequestMapping(value = "/userContract/delete/{token}", method = RequestMethod.POST)
@Security
public Object deleteInvoiceTitle(@PathVariable String token, @RequestBody UserConractsBean userContractsBean) {
logger.info(SysUtil.getMethodName() + " request: " + userContractsBean.toString());
Response<Integer> response = new Response<>();
response.setStatusEnum(ResponseStatusEnum.SUCCESS);
response.setMessage(ResponseStatusEnum.SUCCESS.getMsg());
try {
this.userContractsMService.deleteUserContract(userContractsBean.getId());
} catch (Exception e) {
response.setStatusEnum(ResponseStatusEnum.FAIL);
response.setMessage(ResponseStatusEnum.FAIL.getMsg());
logger.error("删除User Contracts异常", e);
}
return response;
}
public UserContractsMService getUserContractsMService() {
return userContractsMService;
}
public void setUserContractsMService(UserContractsMService userContractsMService) {
this.userContractsMService = userContractsMService;
}
}
src/main/java/com/ctrip/fun/golf/api/version/AppVersionController.java 0 → 100644
package com.ctrip.fun.golf.api.version;
import java.util.regex.Matcher;
import java.util.regex.Pattern;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RequestMethod;
import org.springframework.web.bind.annotation.RequestParam;
import org.springframework.web.bind.annotation.ResponseBody;
import com.ctrip.fun.common.vo.Response;
import com.ctrip.fun.common.vo.ResponseError;
import com.ctrip.fun.common.vo.ResponseStatusEnum;
import com.ctrip.fun.common.vo.app.AppClientVersionBean;
import com.ctrip.fun.common.vo.app.AppVersionAllBean;
import com.ctrip.fun.golf.service.version.AppVersionService;
@Controller
@RequestMapping(value = "/version")
public class AppVersionController {
private Pattern versionPattern = Pattern.compile("(\\d+)(.(\\d+))(.(\\d+))?(.(\\d+))?");
@Autowired
private AppVersionService appVersionService;
@RequestMapping(value = "/app/latest", method = RequestMethod.GET, params = { "osType", "osVersion", "appVersion" })
@ResponseBody
public Object getLatestVersion(@RequestParam Integer osType, @RequestParam String osVersion, @RequestParam String appVersion) {
AppClientVersionBean appClientVersionBean = parseVersionParameters(osType, osVersion, appVersion);
if (appClientVersionBean == null) {
return invalidParameterResponse();
}
Response<AppVersionAllBean> response = appVersionService.getCurrentAppVersion(appClientVersionBean);
if (response == null || response.getStatus() != ResponseStatusEnum.SUCCESS.getValue()) {
ResponseError err = new ResponseError();
err.setCode(response.getStatus());
err.setMessage(response.getMessage());
return err;
}
AppVersionAllBean appVersionAllBean = response.getBody();
return appVersionAllBean;
}
@RequestMapping(value = "/app/latest/clear_cache", method = RequestMethod.GET, params = { "osType", "osVersion", "appVersion" })
@ResponseBody
public Object clearLatestVersion(@RequestParam Integer osType, @RequestParam String osVersion, @RequestParam String appVersion) {
AppClientVersionBean appClientVersionBean = parseVersionParameters(osType, osVersion, appVersion);
if (appClientVersionBean == null) {
return invalidParameterResponse();
} else {
appVersionService.clearCurrentAppVersionCache(appClientVersionBean);
return 0;
}
}
@RequestMapping(value = "/app/latest/clear_cacheAll", method = RequestMethod.GET)
@ResponseBody
public Object clearLatestVersionAll() {
appVersionService.clearCurrentAppVersionAllCache();
return "OK:clean all app cache!";
}
private AppClientVersionBean parseVersionParameters(Integer osType, String osVersion, String version) {
Matcher osVersionMatcher = versionPattern.matcher(osVersion);
Matcher versionMatcher = versionPattern.matcher(version);
if (!osVersionMatcher.matches() || !versionMatcher.matches()) {
return null;
}
AppClientVersionBean appClientVersionBean = new AppClientVersionBean();
appClientVersionBean.setOsType(osType);
appClientVersionBean.setOsMajorVersion(Integer.parseInt(osVersionMatcher.group(1)));
appClientVersionBean.setOsMinorVersion(Integer.parseInt(osVersionMatcher.group(3)));
appClientVersionBean.setMajorVersion(Integer.parseInt(versionMatcher.group(1)));
appClientVersionBean.setMinorVersion(Integer.parseInt(versionMatcher.group(3)));
if (versionMatcher.group(5) != null) {
appClientVersionBean.setBuildNumber(Integer.parseInt(versionMatcher.group(5)));
if (versionMatcher.group(7) != null) {
appClientVersionBean.setRevisionNumber(Integer.parseInt(versionMatcher.group(7)));
}
}
return appClientVersionBean;
}
private ResponseError invalidParameterResponse() {
ResponseError err = new ResponseError();
err.setCode(ResponseStatusEnum.INVALID_PARAMETER.getValue());
err.setMessage(ResponseStatusEnum.INVALID_PARAMETER.getMsg());
return err;
}
}
src/main/java/com/ctrip/fun/golf/api/weather/MobileCourseWeatherController.java 0 → 100644
package com.ctrip.fun.golf.api.weather;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RequestMethod;
import org.springframework.web.bind.annotation.ResponseBody;
import com.ctrip.fun.common.vo.tour.TourPriceQuery;
import com.ctrip.fun.common.vo.weather.WeatherBean;
import com.ctrip.fun.common.vo.weather.WeatherQuery;
import com.ctrip.fun.golf.service.weather.MobileCourseWeatherService;
@Controller
@RequestMapping(value = "")
public class MobileCourseWeatherController {
@Autowired
private MobileCourseWeatherService mobileCourseWeatherService;
@SuppressWarnings("unchecked")
@ResponseBody
@RequestMapping(value = "/v1/courseWeatherForecasts", method = RequestMethod.GET, params = { "courseId" })
public Object courseWeatherList(WeatherQuery weatherQuery ) {
List<WeatherBean> beans = mobileCourseWeatherService.getweatherBeanList("", weatherQuery);
Map map = new HashMap();
List<Map> result = new ArrayList();
if (beans != null) {
map.put("count", beans.size());
for (WeatherBean weatherBean : beans) {
Map mp = new HashMap();
mp.put("days", weatherBean.getDays());
mp.put("week", weatherBean.getWeek());
mp.put("cityName", weatherBean.getCityName());
mp.put("temperature", weatherBean.getTemperature());
mp.put("humidity", weatherBean.getHumidity());
mp.put("weather", weatherBean.getWeather());
mp.put("weatherIcon", weatherBean.getWeatherIcon());
mp.put("weatherIcon1", weatherBean.getWeatherIcon1());
mp.put("wind", weatherBean.getWind());
mp.put("winp", weatherBean.getWinp());
result.add(mp);
}
}
else
{
map.put("count",0);
}
map.put("weathers", result);
return map;
}
public MobileCourseWeatherService getCourseWeatherService() {
return mobileCourseWeatherService;
}
public void setCourseWeatherService(MobileCourseWeatherService mobileCourseWeatherService) {
this.mobileCourseWeatherService = mobileCourseWeatherService;
}
}
src/main/java/com/ctrip/fun/golf/api/workPoint/WorkPointMController.java 0 → 100644
/**
* Copyright 2014 CTRIP Co.,Ltd. All rights reserved.
*/
package com.ctrip.fun.golf.api.workPoint;
import java.util.ArrayList;
import java.util.Collection;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RequestMethod;
import org.springframework.web.bind.annotation.RequestParam;
import org.springframework.web.bind.annotation.ResponseBody;
import com.ctrip.fun.common.core.util.DateUtil;
import com.ctrip.fun.common.vo.PagedResponseBean;
import com.ctrip.fun.common.vo.workPoint.UserWorkPointLogBean;
import com.ctrip.fun.common.vo.workPoint.WorkPointGoodsBean;
import com.ctrip.fun.common.vo.workPoint.WorkPointQueryBean;
import com.ctrip.fun.golf.secrity.Security;
import com.ctrip.fun.golf.secrity.UserContext;
import com.ctrip.fun.golf.service.workPoint.WorkPointMService;
/**
* @author zgsong
* @version 1.0.0
*/
@Controller
@RequestMapping(value = "")
@SuppressWarnings("rawtypes")
public class WorkPointMController {
@Autowired
private WorkPointMService workPointMService;
@SuppressWarnings("unchecked")
@ResponseBody
@Security
@RequestMapping(value = "/v1/me/workPoint", method = RequestMethod.GET, params = { "token", "pagerOffset", "pagerPerPage", "sortField", "sortDirection" })
public Object queryWorkPointMLogs(@RequestParam String token, WorkPointQueryBean workPointQueryBean) {
String userId = UserContext.getUserId();
workPointQueryBean.setUid(userId);
PagedResponseBean<UserWorkPointLogBean> pagedResponseBean = workPointMService.queryWorkPointLogs(workPointQueryBean);
Map map = new HashMap();
List<Map> result = new ArrayList();
Collection<UserWorkPointLogBean> beans = pagedResponseBean.getResult();
if (beans != null) {
for (UserWorkPointLogBean userWorkPointLogBean : beans) {
Map mp = new HashMap();
mp.put("amount", userWorkPointLogBean.getAmount());
mp.put("date", DateUtil.getDateTimeStr(userWorkPointLogBean.getOccurTime()));
mp.put("description", userWorkPointLogBean.getDescription());
result.add(mp);
}
}
map.put("count", pagedResponseBean.getCount());
map.put("workPoints", result);
return map;
}
@SuppressWarnings("unchecked")
@ResponseBody
@RequestMapping(value = "/v1/workPoint/goods", method = RequestMethod.GET, params = { "pagerOffset", "pagerPerPage", "sortField", "sortDirection", "imageSize" })
public Object queryGoods(WorkPointQueryBean workPointQueryBean) {
PagedResponseBean<WorkPointGoodsBean> pagedResponseBean = workPointMService.queryGoods(workPointQueryBean);
Map map = new HashMap();
List<Map> result = new ArrayList();
Collection<WorkPointGoodsBean> beans = pagedResponseBean.getResult();
if (beans != null) {
for (WorkPointGoodsBean workPointGoodsBean : beans) {
Map mp = new HashMap();
mp.put("image", workPointGoodsBean.getImage());
mp.put("name", workPointGoodsBean.getName());
mp.put("amount", workPointGoodsBean.getAmount());
mp.put("unit", workPointGoodsBean.getUnit());
result.add(mp);
}
}
map.put("count", pagedResponseBean.getCount());
map.put("goods", result);
return map;
}
public WorkPointMService getWorkPointMService() {
return workPointMService;
}
public void setWorkPointMService(WorkPointMService workPointMService) {
this.workPointMService = workPointMService;
}
}
src/main/java/com/ctrip/fun/golf/aspect/RestAspect.java 0 → 100644
package com.ctrip.fun.golf.aspect;
import java.lang.reflect.Method;
import org.aspectj.lang.ProceedingJoinPoint;
import org.aspectj.lang.annotation.Around;
import org.aspectj.lang.annotation.Aspect;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import com.ctrip.fun.common.core.util.BeanConverter;
import com.ctrip.fun.golf.exceptions.RestException;
import com.ctrip.fun.golf.secrity.Security;
import com.ctrip.fun.golf.secrity.UserContext;
import com.ctrip.fun.golf.service.user.UserMService;
import com.ctrip.fun.golf.vo.ErrorBean;
/**
*
* @author zgsong
*
*/
@Aspect
public class RestAspect {
private Logger logger = LoggerFactory.getLogger(RestAspect.class);
private UserMService userService = null;
@Around("execution(public * com.ctrip.fun.golf.api.*.*.*(..)) or execution(public * com.ctrip.fun.golf.api.*.*(..)) or execution(public * com.ctrip.fun.golf.api.mall.*.*.*(..)) or execution(public * com.ctrip.fun.golf.api.mall.*.*.*(..))")
public Object intercept(ProceedingJoinPoint point) throws Throwable {
Object retVal = null;
try {
this.authentication(point);
retVal = point.proceed(point.getArgs());
} catch (RestException restException) {
logger.error("invoke api fail", restException);
ErrorBean errorBean = new ErrorBean();
errorBean.setCode(restException.getCode());
errorBean.setMessage(restException.getMessage());
return errorBean;
} catch (Throwable e) {
logger.error("invoke api fail", e);
ErrorBean errorBean = new ErrorBean();
errorBean.setCode(500);
errorBean.setMessage("服务器内部错误");
return errorBean;
}
return retVal;
}
private void authentication(ProceedingJoinPoint point) throws Throwable {
String methodName = point.getSignature().getName();
// 目标方法不为空
if (!"".equals(methodName) && methodName != null) {
// set与get方法除外
Class targetClass = point.getTarget().getClass();
Method[] methods = targetClass.getMethods();
Method method = null;
for (Method m : methods) {
if (m.getName().equals(methodName)) {
method = m;
break;
}
}
if (method != null) {
boolean hasAnnotation = method.isAnnotationPresent(Security.class);
Security annotation = method.getAnnotation(Security.class);
if (hasAnnotation) {
if(annotation.isPasscode()){
String fieldName = annotation.field();
int index = annotation.index();
Object[] args = point.getArgs();
Object token=null;
if(fieldName==null||"".equals(fieldName)){
token = args[index-1];
}else if(args[index-1] instanceof String){
token = BeanConverter.getProperty(args[index-1], fieldName);
}
if(token != null && !"".equals(token)){
String userId = this.userService.getUserId((String) token);
UserContext.putUserId(userId);
}
}else{
String fieldName = annotation.field();
int index = annotation.index();
Object[] args = point.getArgs();
Object token=null;
if(fieldName==null||"".equals(fieldName)){
token = args[index-1];
}else{
token = BeanConverter.getProperty(args[index-1], fieldName);
}
String userId = this.userService.getUserId((String) token);
//String userId = "wwwwww";
UserContext.putUserId(userId);
}
}
}
}
}
public UserMService getUserService() {
return userService;
}
public void setUserService(UserMService userService) {
this.userService = userService;
}
}
src/main/java/com/ctrip/fun/golf/constant/GolfConstant.java 0 → 100644
package com.ctrip.fun.golf.constant;
public class GolfConstant {
public static String golf ="";
}
src/main/java/com/ctrip/fun/golf/exceptions/RestException.java 0 → 100644
package com.ctrip.fun.golf.exceptions;
import com.ctrip.fun.common.core.exceptions.NestedRuntimeException;
public class RestException extends NestedRuntimeException {
/**
* serialVersionUID
*/
private static final long serialVersionUID = -7283441855364556994L;
private int code;
private String msg;
public RestException(String msg, Throwable cause) {
super(msg, cause);
}
public RestException(int code, String msg, Throwable cause) {
super(msg, cause);
}
public RestException(int code, String msg) {
super(msg);
this.code=code;
}
public int getCode() {
return code;
}
public String getMsg() {
return msg;
}
public void setCode(int code) {
this.code = code;
}
public void setMsg(String msg) {
this.msg = msg;
}
}
src/main/java/com/ctrip/fun/golf/filter/CorsFilter.java 0 → 100644
package com.ctrip.fun.golf.filter;
import org.springframework.web.filter.OncePerRequestFilter;
import javax.servlet.FilterChain;
import javax.servlet.ServletException;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import java.io.IOException;
/**
* Created by simon on 7/22/14.
*/
public class CorsFilter extends OncePerRequestFilter {
@Override
protected void doFilterInternal(HttpServletRequest request, HttpServletResponse response, FilterChain filterChain)
throws ServletException, IOException {
response.addHeader("Access-Control-Allow-Origin", "*");
if (request.getHeader("Access-Control-Request-Method") != null && "OPTIONS".equals(request.getMethod())) {
// CORS "pre-flight" request
response.addHeader("Access-Control-Allow-Methods", "GET, POST, PUT, DELETE, OPTIONS");
response.addHeader("Access-Control-Allow-Headers", "Content-Type");
response.addHeader("Access-Control-Max-Age", "1800");//30 min
// Do not forward the request down the filter chain.
} else {
filterChain.doFilter(request, response);
}
}
}
src/main/java/com/ctrip/fun/golf/filter/GlobalHandlerInterceptor.java 0 → 100644
package com.ctrip.fun.golf.filter;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import org.springframework.web.servlet.ModelAndView;
import org.springframework.web.servlet.handler.HandlerInterceptorAdapter;
/**
* @content
* @author csleng
* @date
*/
public class GlobalHandlerInterceptor extends HandlerInterceptorAdapter {
@Override
public boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler) throws Exception {
return true;
}
@Override
public void postHandle(HttpServletRequest request, HttpServletResponse response, Object handler, ModelAndView modelAndView) throws Exception {
super.postHandle(request, response, handler, modelAndView);
}
}
src/main/webapp/lib/swagger-ui.js 0 → 100644
This source diff could not be displayed because it is too large. You can view the blob instead.
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 sign in to comment