repo
stringlengths 1
191
⌀ | file
stringlengths 23
351
| code
stringlengths 0
5.32M
| file_length
int64 0
5.32M
| avg_line_length
float64 0
2.9k
| max_line_length
int64 0
288k
| extension_type
stringclasses 1
value |
|---|---|---|---|---|---|---|
train-ticket
|
train-ticket-master/ts-security-service/src/main/java/security/config/SecurityConfig.java
|
package security.config;
import edu.fudan.common.security.jwt.JWTFilter;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.security.config.annotation.method.configuration.EnableGlobalMethodSecurity;
import org.springframework.security.config.annotation.web.builders.HttpSecurity;
import org.springframework.security.config.annotation.web.configuration.EnableWebSecurity;
import org.springframework.security.config.annotation.web.configuration.WebSecurityConfigurerAdapter;
import org.springframework.security.config.http.SessionCreationPolicy;
import org.springframework.security.crypto.bcrypt.BCryptPasswordEncoder;
import org.springframework.security.crypto.password.PasswordEncoder;
import org.springframework.security.web.authentication.UsernamePasswordAuthenticationFilter;
import org.springframework.web.servlet.config.annotation.CorsRegistry;
import org.springframework.web.servlet.config.annotation.WebMvcConfigurer;
import org.springframework.web.servlet.config.annotation.WebMvcConfigurerAdapter;
import static org.springframework.web.cors.CorsConfiguration.ALL;
/**
* @author fdse
*/
@Configuration
@EnableWebSecurity
@EnableGlobalMethodSecurity(prePostEnabled = true)
public class SecurityConfig extends WebSecurityConfigurerAdapter {
/**
* load password encoder
*
* @return PasswordEncoder
*/
@Bean
public PasswordEncoder passwordEncoder() {
return new BCryptPasswordEncoder();
}
/**
* allow cors domain
* header By default, only six fields can be taken from the header, and the other fields can only be specified in the header.
* credentials Cookies are not sent by default and can only be true if a Cookie is needed
* Validity of this request
*
* @return WebMvcConfigurer
*/
@Bean
public WebMvcConfigurer corsConfigurer() {
return new WebMvcConfigurerAdapter() {
@Override
public void addCorsMappings(CorsRegistry registry) {
registry.addMapping("/**")
.allowedOrigins(ALL)
.allowedMethods(ALL)
.allowedHeaders(ALL)
.allowCredentials(false)
.maxAge(3600);
}
};
}
@Override
protected void configure(HttpSecurity httpSecurity) throws Exception {
httpSecurity.httpBasic().disable()
// close default csrf
.csrf().disable()
// close session
.sessionManagement().sessionCreationPolicy(SessionCreationPolicy.STATELESS)
.and()
.authorizeRequests()
.antMatchers("/api/v1/securityservice/**").hasAnyRole("ADMIN", "USER")
.antMatchers("/swagger-ui.html", "/webjars/**", "/images/**",
"/configuration/**", "/swagger-resources/**", "/v2/**").permitAll()
.anyRequest().authenticated()
.and()
.addFilterBefore(new JWTFilter(), UsernamePasswordAuthenticationFilter.class);
// close cache
httpSecurity.headers().cacheControl();
}
}
| 3,252 | 38.670732 | 130 |
java
|
train-ticket
|
train-ticket-master/ts-security-service/src/main/java/security/controller/SecurityController.java
|
package security.controller;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.http.HttpEntity;
import org.springframework.http.HttpHeaders;
import org.springframework.web.bind.annotation.*;
import security.entity.*;
import security.service.SecurityService;
import static org.springframework.http.ResponseEntity.ok;
/**
* @author fdse
*/
@RestController
@RequestMapping("/api/v1/securityservice")
public class SecurityController {
@Autowired
private SecurityService securityService;
private static final Logger LOGGER = LoggerFactory.getLogger(SecurityController.class);
@GetMapping(value = "/welcome")
public String home(@RequestHeader HttpHeaders headers) {
return "welcome to [Security Service]";
}
@CrossOrigin(origins = "*")
@GetMapping(path = "/securityConfigs")
public HttpEntity findAllSecurityConfig(@RequestHeader HttpHeaders headers) {
SecurityController.LOGGER.info("[findAllSecurityConfig][Find All]");
return ok(securityService.findAllSecurityConfig(headers));
}
@CrossOrigin(origins = "*")
@PostMapping(path = "/securityConfigs")
public HttpEntity create(@RequestBody SecurityConfig info, @RequestHeader HttpHeaders headers) {
SecurityController.LOGGER.info("[addNewSecurityConfig][Create][SecurityConfig Name: {}]", info.getName());
return ok(securityService.addNewSecurityConfig(info, headers));
}
@CrossOrigin(origins = "*")
@PutMapping(path = "/securityConfigs")
public HttpEntity update(@RequestBody SecurityConfig info, @RequestHeader HttpHeaders headers) {
SecurityController.LOGGER.info("[modifySecurityConfig][Update][SecurityConfig Name: {}]", info.getName());
return ok(securityService.modifySecurityConfig(info, headers));
}
@CrossOrigin(origins = "*")
@DeleteMapping(path = "/securityConfigs/{id}")
public HttpEntity delete(@PathVariable String id, @RequestHeader HttpHeaders headers) {
SecurityController.LOGGER.info("[deleteSecurityConfig][Delete][SecurityConfig Id: {}]", id);
return ok(securityService.deleteSecurityConfig(id, headers));
}
@CrossOrigin(origins = "*")
@GetMapping(path = "/securityConfigs/{accountId}")
public HttpEntity check(@PathVariable String accountId, @RequestHeader HttpHeaders headers) {
SecurityController.LOGGER.info("[check][Check Security][Check Account Id: {}]", accountId);
return ok(securityService.check(accountId, headers));
}
}
| 2,598 | 37.791045 | 114 |
java
|
train-ticket
|
train-ticket-master/ts-security-service/src/main/java/security/entity/SecurityConfig.java
|
package security.entity;
import com.fasterxml.jackson.annotation.JsonIgnoreProperties;
import lombok.Data;
import org.hibernate.annotations.GenericGenerator;
import javax.persistence.Column;
import javax.persistence.GeneratedValue;
import javax.persistence.Id;
import javax.persistence.Entity;
import java.util.UUID;
/**
* @author fdse
*/
@Data
@Entity
@GenericGenerator(name = "jpa-uuid", strategy = "org.hibernate.id.UUIDGenerator")
@JsonIgnoreProperties(ignoreUnknown = true)
public class SecurityConfig {
@Id
@GeneratedValue(generator = "jpa-uuid")
@Column(length = 36)
private String id;
private String name;
private String value;
private String description;
public SecurityConfig() {
//Default Constructor
}
}
| 772 | 18.820513 | 81 |
java
|
train-ticket
|
train-ticket-master/ts-security-service/src/main/java/security/init/InitData.java
|
package security.init;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.CommandLineRunner;
import org.springframework.stereotype.Component;
import security.entity.SecurityConfig;
import security.service.SecurityService;
/**
* @author fdse
*/
@Component
public class InitData implements CommandLineRunner {
@Autowired
private SecurityService securityService;
@Override
public void run(String... args) throws Exception {
// a man can not buy too many tickets in one hour
SecurityConfig info1 = new SecurityConfig();
info1.setName("max_order_1_hour");
info1.setValue(Integer.MAX_VALUE + "");
info1.setDescription("Max in 1 hour");
securityService.addNewSecurityConfig(info1,null);
SecurityConfig info2 = new SecurityConfig();
info2.setName("max_order_not_use");
info2.setValue(Integer.MAX_VALUE + "");
info2.setDescription("Max not used");
securityService.addNewSecurityConfig(info2,null);
}
}
| 1,052 | 29.970588 | 62 |
java
|
train-ticket
|
train-ticket-master/ts-security-service/src/main/java/security/repository/SecurityRepository.java
|
package security.repository;
import org.springframework.data.repository.CrudRepository;
import org.springframework.stereotype.Repository;
import security.entity.SecurityConfig;
import java.util.ArrayList;
import java.util.Optional;
/**
* @author fdse
*/
@Repository
public interface SecurityRepository extends CrudRepository<SecurityConfig,String> {
SecurityConfig findByName(String name);
Optional<SecurityConfig> findById(String id);
@Override
ArrayList<SecurityConfig> findAll();
void deleteById(String id);
}
| 544 | 19.185185 | 83 |
java
|
train-ticket
|
train-ticket-master/ts-security-service/src/main/java/security/service/SecurityService.java
|
package security.service;
import edu.fudan.common.util.Response;
import org.springframework.http.HttpHeaders;
import security.entity.*;
/**
* @author fdse
*/
public interface SecurityService {
Response findAllSecurityConfig(HttpHeaders headers);
Response addNewSecurityConfig(SecurityConfig info, HttpHeaders headers);
Response modifySecurityConfig(SecurityConfig info, HttpHeaders headers);
Response deleteSecurityConfig(String id, HttpHeaders headers);
Response check(String accountId, HttpHeaders headers);
}
| 542 | 22.608696 | 76 |
java
|
train-ticket
|
train-ticket-master/ts-security-service/src/main/java/security/service/SecurityServiceImpl.java
|
package security.service;
import edu.fudan.common.entity.OrderSecurity;
import edu.fudan.common.util.Response;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.cloud.client.ServiceInstance;
import org.springframework.cloud.client.discovery.DiscoveryClient;
import org.springframework.cloud.client.ServiceInstance;
import org.springframework.core.ParameterizedTypeReference;
import org.springframework.http.HttpEntity;
import org.springframework.http.HttpHeaders;
import org.springframework.http.HttpMethod;
import org.springframework.http.ResponseEntity;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;
import org.springframework.web.client.RestTemplate;
import security.entity.SecurityConfig;
import security.repository.SecurityRepository;
import java.util.ArrayList;
import java.util.Date;
import java.util.List;
import java.util.UUID;
/**
* @author fdse
*/
@Service
public class SecurityServiceImpl implements SecurityService {
@Autowired
private SecurityRepository securityRepository;
@Autowired
RestTemplate restTemplate;
@Autowired
private DiscoveryClient discoveryClient;
private static final Logger LOGGER = LoggerFactory.getLogger(SecurityServiceImpl.class);
private String getServiceUrl(String serviceName) {
return "http://" + serviceName;
}
String success = "Success";
@Override
public Response findAllSecurityConfig(HttpHeaders headers) {
ArrayList<SecurityConfig> securityConfigs = securityRepository.findAll();
if (securityConfigs != null && !securityConfigs.isEmpty()) {
return new Response<>(1, success, securityConfigs);
}
SecurityServiceImpl.LOGGER.warn("[findAllSecurityConfig][Find all security config warn][{}]","No content");
return new Response<>(0, "No Content", null);
}
@Override
public Response addNewSecurityConfig(SecurityConfig info, HttpHeaders headers) {
SecurityConfig sc = securityRepository.findByName(info.getName());
if (sc != null) {
SecurityServiceImpl.LOGGER.warn("[addNewSecurityConfig][Add new Security config warn][Security config already exist][SecurityConfigId: {},Name: {}]",sc.getId(),info.getName());
return new Response<>(0, "Security Config Already Exist", null);
} else {
SecurityConfig config = new SecurityConfig();
config.setId(UUID.randomUUID().toString());
config.setName(info.getName());
config.setValue(info.getValue());
config.setDescription(info.getDescription());
securityRepository.save(config);
return new Response<>(1, success, config);
}
}
@Override
public Response modifySecurityConfig(SecurityConfig info, HttpHeaders headers) {
SecurityConfig sc = securityRepository.findById(info.getId()).orElse(null);
if (sc == null) {
SecurityServiceImpl.LOGGER.error("[modifySecurityConfig][Modify Security config error][Security config not found][SecurityConfigId: {},Name: {}]",info.getId(),info.getName());
return new Response<>(0, "Security Config Not Exist", null);
} else {
sc.setName(info.getName());
sc.setValue(info.getValue());
sc.setDescription(info.getDescription());
securityRepository.save(sc);
return new Response<>(1, success, sc);
}
}
@Transactional
@Override
public Response deleteSecurityConfig(String id, HttpHeaders headers) {
securityRepository.deleteById(id);
SecurityConfig sc = securityRepository.findById(id).orElse(null);
if (sc == null) {
return new Response<>(1, success, id);
} else {
SecurityServiceImpl.LOGGER.error("[deleteSecurityConfig][Delete Security config error][Reason not clear][SecurityConfigId: {}]",id);
return new Response<>(0, "Reason Not clear", id);
}
}
@Override
public Response check(String accountId, HttpHeaders headers) {
//1.Get the orders in the past one hour and the total effective votes
SecurityServiceImpl.LOGGER.debug("[check][Get Order Num Info]");
OrderSecurity orderResult = getSecurityOrderInfoFromOrder(new Date(), accountId, headers);
OrderSecurity orderOtherResult = getSecurityOrderOtherInfoFromOrder(new Date(), accountId, headers);
int orderInOneHour = orderOtherResult.getOrderNumInLastOneHour() + orderResult.getOrderNumInLastOneHour();
int totalValidOrder = orderOtherResult.getOrderNumOfValidOrder() + orderResult.getOrderNumOfValidOrder();
//2. get critical configuration information
SecurityServiceImpl.LOGGER.debug("[check][Get Security Config Info]");
SecurityConfig configMaxInHour = securityRepository.findByName("max_order_1_hour");
SecurityConfig configMaxNotUse = securityRepository.findByName("max_order_not_use");
SecurityServiceImpl.LOGGER.info("[check][Max][Max In One Hour: {} Max Not Use: {}]", configMaxInHour.getValue(), configMaxNotUse.getValue());
int oneHourLine = Integer.parseInt(configMaxInHour.getValue());
int totalValidLine = Integer.parseInt(configMaxNotUse.getValue());
if (orderInOneHour > oneHourLine || totalValidOrder > totalValidLine) {
SecurityServiceImpl.LOGGER.warn("[check][Check Security config warn][Too much order in last one hour or too much valid order][AccountId: {}]",accountId);
return new Response<>(0, "Too much order in last one hour or too much valid order", accountId);
} else {
return new Response<>(1, "Success.r", accountId);
}
}
private OrderSecurity getSecurityOrderInfoFromOrder(Date checkDate, String accountId, HttpHeaders headers) {
HttpEntity requestEntity = new HttpEntity(null);
String order_service_url = getServiceUrl("ts-order-service");
ResponseEntity<Response<OrderSecurity>> re = restTemplate.exchange(
order_service_url + "/api/v1/orderservice/order/security/" + checkDate + "/" + accountId,
HttpMethod.GET,
requestEntity,
new ParameterizedTypeReference<Response<OrderSecurity>>() {
});
Response<OrderSecurity> response = re.getBody();
OrderSecurity result = response.getData();
SecurityServiceImpl.LOGGER.info("[getSecurityOrderInfoFromOrder][Get Order Info For Security][Last One Hour: {} Total Valid Order: {}]", result.getOrderNumInLastOneHour(), result.getOrderNumOfValidOrder());
return result;
}
private OrderSecurity getSecurityOrderOtherInfoFromOrder(Date checkDate, String accountId, HttpHeaders headers) {
HttpEntity requestEntity = new HttpEntity(null);
String order_other_service_url = getServiceUrl("ts-order-other-service");
ResponseEntity<Response<OrderSecurity>> re = restTemplate.exchange(
order_other_service_url + "/api/v1/orderOtherService/orderOther/security/" + checkDate + "/" + accountId,
HttpMethod.GET,
requestEntity,
new ParameterizedTypeReference<Response<OrderSecurity>>() {
});
Response<OrderSecurity> response = re.getBody();
OrderSecurity result = response.getData();
SecurityServiceImpl.LOGGER.info("[getSecurityOrderOtherInfoFromOrder][Get Order Other Info For Security][Last One Hour: {} Total Valid Order: {}]", result.getOrderNumInLastOneHour(), result.getOrderNumOfValidOrder());
return result;
}
}
| 7,832 | 47.652174 | 226 |
java
|
train-ticket
|
train-ticket-master/ts-security-service/src/test/java/security/controller/SecurityControllerTest.java
|
package security.controller;
import com.alibaba.fastjson.JSONObject;
import edu.fudan.common.util.Response;
import org.junit.Assert;
import org.junit.Before;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.junit.runners.JUnit4;
import org.mockito.InjectMocks;
import org.mockito.Mock;
import org.mockito.Mockito;
import org.mockito.MockitoAnnotations;
import org.springframework.http.*;
import org.springframework.test.web.servlet.MockMvc;
import org.springframework.test.web.servlet.request.MockMvcRequestBuilders;
import org.springframework.test.web.servlet.result.MockMvcResultMatchers;
import org.springframework.test.web.servlet.setup.MockMvcBuilders;
import security.entity.SecurityConfig;
import security.service.SecurityService;
@RunWith(JUnit4.class)
public class SecurityControllerTest {
@InjectMocks
private SecurityController securityController;
@Mock
private SecurityService securityService;
private MockMvc mockMvc;
private Response response = new Response();
@Before
public void setUp() {
MockitoAnnotations.initMocks(this);
mockMvc = MockMvcBuilders.standaloneSetup(securityController).build();
}
@Test
public void testHome() throws Exception {
mockMvc.perform(MockMvcRequestBuilders.get("/api/v1/securityservice/welcome"))
.andExpect(MockMvcResultMatchers.status().isOk())
.andExpect(MockMvcResultMatchers.content().string("welcome to [Security Service]"));
}
@Test
public void testFindAllSecurityConfig() throws Exception {
Mockito.when(securityService.findAllSecurityConfig(Mockito.any(HttpHeaders.class))).thenReturn(response);
String result = mockMvc.perform(MockMvcRequestBuilders.get("/api/v1/securityservice/securityConfigs"))
.andExpect(MockMvcResultMatchers.status().isOk())
.andReturn().getResponse().getContentAsString();
Assert.assertEquals(response, JSONObject.parseObject(result, Response.class));
}
@Test
public void testCreate() throws Exception {
SecurityConfig info = new SecurityConfig();
Mockito.when(securityService.addNewSecurityConfig(Mockito.any(SecurityConfig.class), Mockito.any(HttpHeaders.class))).thenReturn(response);
String requestJson = JSONObject.toJSONString(info);
String result = mockMvc.perform(MockMvcRequestBuilders.post("/api/v1/securityservice/securityConfigs").contentType(MediaType.APPLICATION_JSON).content(requestJson))
.andExpect(MockMvcResultMatchers.status().isOk())
.andReturn().getResponse().getContentAsString();
Assert.assertEquals(response, JSONObject.parseObject(result, Response.class));
}
@Test
public void testUpdate() throws Exception {
SecurityConfig info = new SecurityConfig();
Mockito.when(securityService.modifySecurityConfig(Mockito.any(SecurityConfig.class), Mockito.any(HttpHeaders.class))).thenReturn(response);
String requestJson = JSONObject.toJSONString(info);
String result = mockMvc.perform(MockMvcRequestBuilders.put("/api/v1/securityservice/securityConfigs").contentType(MediaType.APPLICATION_JSON).content(requestJson))
.andExpect(MockMvcResultMatchers.status().isOk())
.andReturn().getResponse().getContentAsString();
Assert.assertEquals(response, JSONObject.parseObject(result, Response.class));
}
@Test
public void testDelete() throws Exception {
Mockito.when(securityService.deleteSecurityConfig(Mockito.anyString(), Mockito.any(HttpHeaders.class))).thenReturn(response);
String result = mockMvc.perform(MockMvcRequestBuilders.delete("/api/v1/securityservice/securityConfigs/id"))
.andExpect(MockMvcResultMatchers.status().isOk())
.andReturn().getResponse().getContentAsString();
Assert.assertEquals(response, JSONObject.parseObject(result, Response.class));
}
@Test
public void testCheck() throws Exception {
Mockito.when(securityService.check(Mockito.anyString(), Mockito.any(HttpHeaders.class))).thenReturn(response);
String result = mockMvc.perform(MockMvcRequestBuilders.get("/api/v1/securityservice/securityConfigs/account_id"))
.andExpect(MockMvcResultMatchers.status().isOk())
.andReturn().getResponse().getContentAsString();
Assert.assertEquals(response, JSONObject.parseObject(result, Response.class));
}
}
| 4,520 | 46.09375 | 172 |
java
|
train-ticket
|
train-ticket-master/ts-security-service/src/test/java/security/service/SecurityServiceImplTest.java
|
package security.service;
import edu.fudan.common.entity.OrderSecurity;
import edu.fudan.common.util.Response;
import org.junit.Assert;
import org.junit.Before;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.junit.runners.JUnit4;
import org.mockito.InjectMocks;
import org.mockito.Mock;
import org.mockito.Mockito;
import org.mockito.MockitoAnnotations;
import org.springframework.core.ParameterizedTypeReference;
import org.springframework.http.*;
import org.springframework.web.client.RestTemplate;
import security.entity.SecurityConfig;
import security.repository.SecurityRepository;
import java.util.ArrayList;
import java.util.Optional;
import java.util.UUID;
@RunWith(JUnit4.class)
public class SecurityServiceImplTest {
@InjectMocks
private SecurityServiceImpl securityServiceImpl;
@Mock
private SecurityRepository securityRepository;
@Mock
private RestTemplate restTemplate;
private HttpHeaders headers = new HttpHeaders();
@Before
public void setUp() {
MockitoAnnotations.initMocks(this);
}
@Test
public void testFindAllSecurityConfig1() {
ArrayList<SecurityConfig> securityConfigs = new ArrayList<>();
securityConfigs.add(new SecurityConfig());
Mockito.when(securityRepository.findAll()).thenReturn(securityConfigs);
Response result = securityServiceImpl.findAllSecurityConfig(headers);
Assert.assertEquals(new Response<>(1, "Success", securityConfigs), result);
}
@Test
public void testFindAllSecurityConfig2() {
Mockito.when(securityRepository.findAll()).thenReturn(null);
Response result = securityServiceImpl.findAllSecurityConfig(headers);
Assert.assertEquals(new Response<>(0, "No Content", null), result);
}
@Test
public void testAddNewSecurityConfig1() {
SecurityConfig sc = new SecurityConfig();
Mockito.when(securityRepository.findByName(Mockito.anyString())).thenReturn(sc);
Response result = securityServiceImpl.addNewSecurityConfig(sc, headers);
Assert.assertEquals(new Response<>(0, "Security Config Already Exist", null), result);
}
@Test
public void testAddNewSecurityConfig2() {
SecurityConfig sc = new SecurityConfig();
Mockito.when(securityRepository.findByName(Mockito.anyString())).thenReturn(null);
Mockito.when(securityRepository.save(Mockito.any(SecurityConfig.class))).thenReturn(null);
Response result = securityServiceImpl.addNewSecurityConfig(sc, headers);
Assert.assertEquals("Success", result.getMsg());
}
@Test
public void testModifySecurityConfig1() {
SecurityConfig sc = new SecurityConfig();
Mockito.when(securityRepository.findById(Mockito.any(UUID.class).toString())).thenReturn(null);
Response result = securityServiceImpl.modifySecurityConfig(sc, headers);
Assert.assertEquals(new Response<>(0, "Security Config Not Exist", null), result);
}
@Test
public void testModifySecurityConfig2() {
SecurityConfig sc = new SecurityConfig();
Mockito.when(securityRepository.findById(Mockito.any(UUID.class).toString())).thenReturn(Optional.of(sc));
Mockito.when(securityRepository.save(Mockito.any(SecurityConfig.class))).thenReturn(null);
Response result = securityServiceImpl.modifySecurityConfig(sc, headers);
Assert.assertEquals(new Response<>(1, "Success", sc), result);
}
@Test
public void testDeleteSecurityConfig1() {
UUID id = UUID.randomUUID();
Mockito.doNothing().doThrow(new RuntimeException()).when(securityRepository).deleteById(Mockito.any(UUID.class).toString());
Mockito.when(securityRepository.findById(Mockito.any(UUID.class).toString())).thenReturn(null);
Response result = securityServiceImpl.deleteSecurityConfig(id.toString(), headers);
Assert.assertEquals(new Response<>(1, "Success", id.toString()), result);
}
@Test
public void testDeleteSecurityConfig2() {
UUID id = UUID.randomUUID();
SecurityConfig sc = new SecurityConfig();
Mockito.doNothing().doThrow(new RuntimeException()).when(securityRepository).deleteById(Mockito.any(UUID.class).toString());
Mockito.when(securityRepository.findById(Mockito.any(UUID.class).toString())).thenReturn(Optional.of(sc));
Response result = securityServiceImpl.deleteSecurityConfig(id.toString(), headers);
Assert.assertEquals("Reason Not clear", result.getMsg());
}
@Test
public void testCheck() {
//mock getSecurityOrderInfoFromOrder() and getSecurityOrderOtherInfoFromOrder()
OrderSecurity orderSecurity = new OrderSecurity(1, 1);
Response<OrderSecurity> response1 = new Response<>(null, null, orderSecurity);
ResponseEntity<Response<OrderSecurity>> re1 = new ResponseEntity<>(response1, HttpStatus.OK);
Mockito.when(restTemplate.exchange(
Mockito.anyString(),
Mockito.any(HttpMethod.class),
Mockito.any(HttpEntity.class),
Mockito.any(ParameterizedTypeReference.class)))
.thenReturn(re1);
SecurityConfig securityConfig = new SecurityConfig();
securityConfig.setValue("2");
Mockito.when(securityRepository.findByName(Mockito.anyString())).thenReturn(securityConfig);
Response result = securityServiceImpl.check("account_id", headers);
Assert.assertEquals(new Response<>(1, "Success.r", "account_id"), result);
}
}
| 5,569 | 40.879699 | 132 |
java
|
train-ticket
|
train-ticket-master/ts-station-food-service/src/main/java/food/StationFoodApplication.java
|
package food;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.boot.web.client.RestTemplateBuilder;
import org.springframework.cloud.client.discovery.EnableDiscoveryClient;
import org.springframework.cloud.client.loadbalancer.LoadBalanced;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.EnableAspectJAutoProxy;
import org.springframework.integration.annotation.IntegrationComponentScan;
import org.springframework.scheduling.annotation.EnableAsync;
import org.springframework.web.client.RestTemplate;
import springfox.documentation.swagger2.annotations.EnableSwagger2;
@SpringBootApplication
@EnableAspectJAutoProxy(proxyTargetClass = true)
@EnableAsync
@IntegrationComponentScan
@EnableSwagger2
@EnableDiscoveryClient
public class StationFoodApplication {
public static void main(String[] args) {
SpringApplication.run(StationFoodApplication.class, args);
}
@LoadBalanced
@Bean
public RestTemplate restTemplate(RestTemplateBuilder builder) {
return builder.build();
}
}
| 1,164 | 34.30303 | 75 |
java
|
train-ticket
|
train-ticket-master/ts-station-food-service/src/main/java/food/config/SecurityConfig.java
|
package food.config;
import edu.fudan.common.security.jwt.JWTFilter;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.security.config.annotation.method.configuration.EnableGlobalMethodSecurity;
import org.springframework.security.config.annotation.web.builders.HttpSecurity;
import org.springframework.security.config.annotation.web.configuration.EnableWebSecurity;
import org.springframework.security.config.annotation.web.configuration.WebSecurityConfigurerAdapter;
import org.springframework.security.config.http.SessionCreationPolicy;
import org.springframework.security.crypto.bcrypt.BCryptPasswordEncoder;
import org.springframework.security.crypto.password.PasswordEncoder;
import org.springframework.security.web.authentication.UsernamePasswordAuthenticationFilter;
import org.springframework.web.servlet.config.annotation.CorsRegistry;
import org.springframework.web.servlet.config.annotation.WebMvcConfigurer;
import org.springframework.web.servlet.config.annotation.WebMvcConfigurerAdapter;
import static org.springframework.web.cors.CorsConfiguration.ALL;
@Configuration
@EnableWebSecurity
@EnableGlobalMethodSecurity(prePostEnabled = true)
public class SecurityConfig extends WebSecurityConfigurerAdapter {
// load password encoder
@Bean
public PasswordEncoder passwordEncoder() {
return new BCryptPasswordEncoder();
}
/**
* allow cors domain
* header 在默认的情况下只能从头部取出6个字段，想要其他字段只能自己在头里指定
* credentials 默认不发送Cookie, 如果需要Cookie,这个值只能为true
* 本次请求检查的有效期
*
* @return
*/
@Bean
public WebMvcConfigurer corsConfigurer() {
return new WebMvcConfigurerAdapter() {
@Override
public void addCorsMappings(CorsRegistry registry) {
registry.addMapping("/**")
.allowedOrigins(ALL)
.allowedMethods(ALL)
.allowedHeaders(ALL)
.allowCredentials(false)
.maxAge(3600);
}
};
}
@Override
protected void configure(HttpSecurity httpSecurity) throws Exception {
httpSecurity.httpBasic().disable()
// close default csrf
.csrf().disable()
// close session
.sessionManagement().sessionCreationPolicy(SessionCreationPolicy.STATELESS)
.and()
.authorizeRequests()
.antMatchers("/api/v1/stationfoodservice/**").permitAll()
.antMatchers("/swagger-ui.html", "/webjars/**", "/images/**",
"/configuration/**", "/swagger-resources/**", "/v2/**").permitAll()
.anyRequest().authenticated()
.and()
.addFilterBefore(new JWTFilter(), UsernamePasswordAuthenticationFilter.class);
// close cache
httpSecurity.headers().cacheControl();
}
}
| 3,003 | 39.053333 | 102 |
java
|
train-ticket
|
train-ticket-master/ts-station-food-service/src/main/java/food/controller/StationFoodController.java
|
package food.controller;
import food.service.StationFoodService;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.http.HttpEntity;
import org.springframework.http.HttpHeaders;
import org.springframework.web.bind.annotation.*;
import java.util.List;
import static org.springframework.http.ResponseEntity.ok;
@RestController
@RequestMapping("/api/v1/stationfoodservice")
public class StationFoodController {
@Autowired
StationFoodService stationFoodService;
private static final Logger LOGGER = LoggerFactory.getLogger(StationFoodController.class);
@GetMapping(path = "/stationfoodstores/welcome")
public String home() {
return "Welcome to [ Food store Service ] !";
}
@CrossOrigin(origins = "*")
@GetMapping("/stationfoodstores")
public HttpEntity getAllFoodStores(@RequestHeader HttpHeaders headers) {
StationFoodController.LOGGER.info("[Food Map Service][Get All FoodStores]");
return ok(stationFoodService.listFoodStores(headers));
}
@CrossOrigin(origins = "*")
@GetMapping("/stationfoodstores/{stationId}")
public HttpEntity getFoodStoresOfStation(@PathVariable String stationName, @RequestHeader HttpHeaders headers) {
StationFoodController.LOGGER.info("[Food Map Service][Get FoodStores By StationName]");
return ok(stationFoodService.listFoodStoresByStationName(stationName, headers));
}
@CrossOrigin(origins = "*")
@PostMapping("/stationfoodstores")
public HttpEntity getFoodStoresByStationNames(@RequestBody List<String> stationNameList) {
StationFoodController.LOGGER.info("[Food Map Service][Get FoodStores By StationNames]");
return ok(stationFoodService.getFoodStoresByStationNames(stationNameList));
}
@GetMapping("/stationfoodstores/bystoreid/{stationFoodStoreId}")
public HttpEntity getFoodListByStationFoodStoreId(@PathVariable String stationFoodStoreId, @RequestHeader HttpHeaders headers) {
StationFoodController.LOGGER.info("[Food Map Service][Get Foodlist By stationFoodStoreId]");
return ok(stationFoodService.getStaionFoodStoreById(stationFoodStoreId));
}
}
| 2,244 | 39.818182 | 132 |
java
|
train-ticket
|
train-ticket-master/ts-station-food-service/src/main/java/food/entity/StationFoodStore.java
|
package food.entity;
import com.fasterxml.jackson.annotation.JsonIgnoreProperties;
import edu.fudan.common.entity.Food;
import lombok.Data;
import lombok.ToString;
import org.hibernate.annotations.GenericGenerator;
import javax.persistence.*;
import javax.validation.constraints.NotNull;
import java.util.List;
@Data
@Entity
@GenericGenerator(name = "jpa-uuid", strategy = "org.hibernate.id.UUIDGenerator")
@ToString
@JsonIgnoreProperties(ignoreUnknown = true)
@Table(indexes = {@Index(name = "station_store_idx", columnList = "station_name, store_name", unique = true)})
public class StationFoodStore {
@Id
@Column(name = "store_id")
private String id;
@NotNull
@Column(name = "station_name")
private String stationName;
@Column(name = "store_name")
private String storeName;
private String telephone;
private String businessTime;
private double deliveryFee;
@ElementCollection(targetClass = Food.class, fetch = FetchType.EAGER)
@CollectionTable(name = "station_food_list", joinColumns = @JoinColumn(name = "store_id"))
private List<Food> foodList;
public StationFoodStore(){
//Default Constructor
this.stationName = "";
}
}
| 1,218 | 24.395833 | 110 |
java
|
train-ticket
|
train-ticket-master/ts-station-food-service/src/main/java/food/init/InitData.java
|
package food.init;
import edu.fudan.common.entity.Food;
import food.entity.StationFoodStore;
import food.service.StationFoodService;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.CommandLineRunner;
import org.springframework.stereotype.Component;
import java.io.BufferedReader;
import java.io.InputStreamReader;
import java.util.ArrayList;
import java.util.List;
import java.util.UUID;
@Component
public class InitData implements CommandLineRunner{
@Autowired
StationFoodService service;
private static final Logger LOGGER = LoggerFactory.getLogger(InitData.class);
@Override
public void run(String... args) throws Exception {
BufferedReader br1 = new BufferedReader(new InputStreamReader(this.getClass().getResourceAsStream("/foodstores.txt")));
try{
String line = br1.readLine();
while( line != null ){
if( !line.trim().equals("") ){
StationFoodStore fs = new StationFoodStore();
fs.setId(UUID.randomUUID().toString());
String[] lineTemp = line.trim().split("=");
fs.setStationName(lineTemp[1]);
lineTemp = br1.readLine().trim().split("=");
fs.setStoreName(lineTemp[1]);
lineTemp = br1.readLine().trim().split("=");
fs.setTelephone(lineTemp[1]);
lineTemp = br1.readLine().trim().split("=");
fs.setBusinessTime(lineTemp[1]);
lineTemp = br1.readLine().trim().split("=");
fs.setDeliveryFee( Double.parseDouble(lineTemp[1]) );
lineTemp = br1.readLine().trim().split("=");
fs.setFoodList(toFoodList(lineTemp[1]));
service.createFoodStore(fs,null);
}
line = br1.readLine();
}
} catch(Exception e){
InitData.LOGGER.info("the foodstores.txt has format error!");
InitData.LOGGER.error(e.getMessage());
System.exit(1);
}
// BufferedReader br2 = new BufferedReader(new InputStreamReader(this.getClass().getResourceAsStream("/trainfood.txt")));
// try{
// String line2 = br2.readLine();
// while( line2 != null ){
// if( !line2.trim().equals("") ){
// TrainFood tf = new TrainFood();
// tf.setId(UUID.randomUUID());
// String[] lineTemp = line2.trim().split("=");
// tf.setTripId(lineTemp[1]);
// lineTemp = br2.readLine().trim().split("=");
// tf.setFoodList(toFoodList(lineTemp[1]));
// service.createTrainFood(tf,null);
// }
// line2 = br2.readLine();
// }
//
// } catch(Exception e){
// InitData.LOGGER.info("the trainfood.txt has format error!");
// InitData.LOGGER.error(e.getMessage());
// System.exit(1);
// }
}
private List<Food> toFoodList(String s){
InitData.LOGGER.info("s= {}", s);
String[] foodstring = s.split("_");
List<Food> foodList = new ArrayList<>();
for(int i = 0; i< foodstring.length; i++){
String[] foodTemp = foodstring[i].split(",");
Food food = new Food();
food.setFoodName(foodTemp[0]);
food.setPrice(Double.parseDouble(foodTemp[1]));
foodList.add(food);
}
return foodList;
}
}
| 3,686 | 34.114286 | 128 |
java
|
train-ticket
|
train-ticket-master/ts-station-food-service/src/main/java/food/repository/StationFoodRepository.java
|
package food.repository;
import food.entity.StationFoodStore;
import org.springframework.data.repository.CrudRepository;
import org.springframework.stereotype.Repository;
import java.util.List;
import java.util.Optional;
import java.util.UUID;
@Repository
public interface StationFoodRepository extends CrudRepository<StationFoodStore, String> {
@Override
Optional<StationFoodStore> findById(String id);
List<StationFoodStore> findByStationName(String stationName);
List<StationFoodStore> findByStationNameIn(List<String> stationNames);
@Override
List<StationFoodStore> findAll();
@Override
void deleteById(String id);
}
| 661 | 23.518519 | 89 |
java
|
train-ticket
|
train-ticket-master/ts-station-food-service/src/main/java/food/service/StationFoodService.java
|
package food.service;
import edu.fudan.common.util.Response;
import food.entity.*;
import org.springframework.http.HttpHeaders;
import java.util.List;
public interface StationFoodService {
// create data
Response createFoodStore(StationFoodStore fs, HttpHeaders headers);
// TrainFood createTrainFood(TrainFood tf, HttpHeaders headers);
// query all food
Response listFoodStores(HttpHeaders headers);
// Response listTrainFood(HttpHeaders headers);
// query according id
Response listFoodStoresByStationName(String stationName, HttpHeaders headers);
// Response listTrainFoodByTripId(String tripId, HttpHeaders headers);
Response getStaionFoodStoreById(String id);
Response getFoodStoresByStationNames(List<String> stationNames);
}
| 785 | 24.354839 | 82 |
java
|
train-ticket
|
train-ticket-master/ts-station-food-service/src/main/java/food/service/StationFoodServiceImpl.java
|
package food.service;
import edu.fudan.common.util.Response;
import food.entity.StationFoodStore;
import food.repository.StationFoodRepository;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.http.HttpHeaders;
import org.springframework.stereotype.Service;
import java.util.List;
@Service
public class StationFoodServiceImpl implements StationFoodService {
@Autowired
StationFoodRepository stationFoodRepository;
// @Autowired
// TrainFoodRepository trainFoodRepository;
private static final Logger LOGGER = LoggerFactory.getLogger(StationFoodServiceImpl.class);
String success = "Success";
String noContent = "No content";
@Override
public Response createFoodStore(StationFoodStore fs, HttpHeaders headers) {
StationFoodStore fsTemp = stationFoodRepository.findById(fs.getId()).orElse(null);
if (fsTemp != null) {
StationFoodServiceImpl.LOGGER.error("[Init FoodStore] Already Exists Id: {}", fs.getId());
return new Response<>(0, "Already Exists Id", null);
} else {
try{
stationFoodRepository.save(fs);
return new Response<>(1, "Save Success", fs);
}catch(Exception e){
return new Response<>(0, "Save failed", e.getMessage());
}
}
}
// @Override
// public TrainFood createTrainFood(TrainFood tf, HttpHeaders headers) {
// TrainFood tfTemp = trainFoodRepository.findById(tf.getId());
// if (tfTemp != null) {
// StationFoodServiceImpl.LOGGER.error("[Init TrainFood] Already Exists Id: {}", tf.getId());
// } else {
// trainFoodRepository.save(tf);
// }
// return tf;
// }
@Override
public Response listFoodStores(HttpHeaders headers) {
List<StationFoodStore> stationFoodStores = stationFoodRepository.findAll();
if (stationFoodStores != null && !stationFoodStores.isEmpty()) {
return new Response<>(1, success, stationFoodStores);
} else {
StationFoodServiceImpl.LOGGER.error("List food stores error: {}", "Food store is empty");
return new Response<>(0, "Food store is empty", null);
}
}
// @Override
// public Response listTrainFood(HttpHeaders headers) {
// List<TrainFood> trainFoodList = trainFoodRepository.findAll();
// if (trainFoodList != null && !trainFoodList.isEmpty()) {
// return new Response<>(1, success, trainFoodList);
// } else {
// StationFoodServiceImpl.LOGGER.error("List train food error: {}", noContent);
// return new Response<>(0, noContent, null);
// }
// }
@Override
public Response listFoodStoresByStationName(String stationName, HttpHeaders headers) {
List<StationFoodStore> stationFoodStoreList = stationFoodRepository.findByStationName(stationName);
if (stationFoodStoreList != null && !stationFoodStoreList.isEmpty()) {
return new Response<>(1, success, stationFoodStoreList);
} else {
StationFoodServiceImpl.LOGGER.error("List food stores by station id error: {}, stationName: {}", "Food store is empty", stationName);
return new Response<>(0, "Food store is empty", null);
}
}
// @Override
// public Response listTrainFoodByTripId(String tripId, HttpHeaders headers) {
// List<TrainFood> trainFoodList = trainFoodRepository.findByTripId(tripId);
// if (trainFoodList != null) {
// return new Response<>(1, success, trainFoodList);
// } else {
// StationFoodServiceImpl.LOGGER.error("List train food by trip id error: {}, tripId: {}", noContent, tripId);
// return new Response<>(0, noContent, null);
// }
// }
@Override
public Response getFoodStoresByStationNames(List<String> stationNames) {
List<StationFoodStore> stationFoodStoreList = stationFoodRepository.findByStationNameIn(stationNames);
if (stationFoodStoreList != null) {
return new Response<>(1, success, stationFoodStoreList);
} else {
StationFoodServiceImpl.LOGGER.error("List food stores by station ids error: {}, stationName list: {}", "Food store is empty", stationNames);
return new Response<>(0, noContent, null);
}
}
@Override
public Response getStaionFoodStoreById(String id) {
StationFoodStore stationFoodStore = stationFoodRepository.findById(id).orElse(null);
if (stationFoodStore == null) {
LOGGER.error("no such staionFoodStoreId: {}", id);
return new Response<>(0, noContent, null);
} else {
return new Response<>(1, success, stationFoodStore);
}
}
}
| 4,882 | 39.02459 | 152 |
java
|
train-ticket
|
train-ticket-master/ts-station-food-service/src/test/java/food/controller/StationFoodControllerTest.java
|
package food.controller;
import com.alibaba.fastjson.JSONObject;
import edu.fudan.common.util.Response;
import food.service.StationFoodService;
import org.junit.Assert;
import org.junit.Before;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.junit.runners.JUnit4;
import org.mockito.InjectMocks;
import org.mockito.Mock;
import org.mockito.Mockito;
import org.mockito.MockitoAnnotations;
import org.springframework.http.*;
import org.springframework.test.web.servlet.MockMvc;
import org.springframework.test.web.servlet.request.MockMvcRequestBuilders;
import org.springframework.test.web.servlet.result.MockMvcResultMatchers;
import org.springframework.test.web.servlet.setup.MockMvcBuilders;
import java.util.ArrayList;
import java.util.List;
@RunWith(JUnit4.class)
public class StationFoodControllerTest {
@InjectMocks
private StationFoodController stationFoodController;
@Mock
private StationFoodService stationFoodService;
private MockMvc mockMvc;
private Response response = new Response();
@Before
public void setUp() {
MockitoAnnotations.initMocks(this);
mockMvc = MockMvcBuilders.standaloneSetup(stationFoodController).build();
}
@Test
public void testHome() throws Exception {
mockMvc.perform(MockMvcRequestBuilders.get("/api/v1/foodmapservice/stationfoodstores/welcome"))
.andExpect(MockMvcResultMatchers.status().isOk())
.andExpect(MockMvcResultMatchers.content().string("Welcome to [ Food store Service ] !"));
}
@Test
public void testGetAllFoodStores() throws Exception {
Mockito.when(stationFoodService.listFoodStores(Mockito.any(HttpHeaders.class))).thenReturn(response);
String result = mockMvc.perform(MockMvcRequestBuilders.get("/api/v1/foodmapservice/stationfoodstores"))
.andExpect(MockMvcResultMatchers.status().isOk())
.andReturn().getResponse().getContentAsString();
Assert.assertEquals(response, JSONObject.parseObject(result, Response.class));
}
@Test
public void testGetFoodStoresOfStation() throws Exception {
Mockito.when(stationFoodService.listFoodStoresByStationName(Mockito.anyString(), Mockito.any(HttpHeaders.class))).thenReturn(response);
String result = mockMvc.perform(MockMvcRequestBuilders.get("/api/v1/foodmapservice/stationfoodstores/station_id"))
.andExpect(MockMvcResultMatchers.status().isOk())
.andReturn().getResponse().getContentAsString();
Assert.assertEquals(response, JSONObject.parseObject(result, Response.class));
}
@Test
public void testGetFoodStoresByStationNames() throws Exception {
List<String> stationIdList = new ArrayList<>();
Mockito.when(stationFoodService.getFoodStoresByStationNames(Mockito.anyList())).thenReturn(response);
String requestJson = JSONObject.toJSONString(stationIdList);
String result = mockMvc.perform(MockMvcRequestBuilders.post("/api/v1/foodmapservice/stationfoodstores").contentType(MediaType.APPLICATION_JSON).content(requestJson))
.andExpect(MockMvcResultMatchers.status().isOk())
.andReturn().getResponse().getContentAsString();
Assert.assertEquals(response, JSONObject.parseObject(result, Response.class));
}
}
| 3,352 | 41.987179 | 173 |
java
|
train-ticket
|
train-ticket-master/ts-station-food-service/src/test/java/food/service/StationFoodServiceImplTest.java
|
package food.service;
import edu.fudan.common.util.Response;
import food.entity.StationFoodStore;
import food.repository.StationFoodRepository;
import org.junit.Assert;
import org.junit.Before;
import org.junit.Test;
import org.mockito.InjectMocks;
import org.mockito.Mock;
import org.mockito.Mockito;
import org.mockito.MockitoAnnotations;
import org.springframework.http.HttpHeaders;
import java.util.Optional;
import java.util.ArrayList;
import java.util.List;
import java.util.Optional;
import java.util.UUID;
public class StationFoodServiceImplTest {
@InjectMocks
private StationFoodServiceImpl foodMapServiceImpl;
@Mock
private StationFoodRepository stationFoodRepository;
// @Mock
// private TrainFoodRepository trainFoodRepository;
private HttpHeaders headers = new HttpHeaders();
@Before
public void setUp() {
MockitoAnnotations.initMocks(this);
}
@Test
public void testCreateFoodStore1() {
StationFoodStore fss=new StationFoodStore();
Optional<StationFoodStore> fs = Optional.ofNullable(fss);
Mockito.when(stationFoodRepository.findById(Mockito.any(String.class))).thenReturn(fs);
Response result = foodMapServiceImpl.createFoodStore(fs.get(), headers);
Assert.assertEquals(new Response<>(0, "Already Exists Id", null), result);
}
@Test
public void testCreateFoodStore2() {
StationFoodStore fs = new StationFoodStore();
Mockito.when(stationFoodRepository.findById(Mockito.any(String.class))).thenReturn(null);
Mockito.when(stationFoodRepository.save(Mockito.any(StationFoodStore.class))).thenReturn(null);
Response result = foodMapServiceImpl.createFoodStore(fs, headers);
Assert.assertEquals(new Response<>(1, "Save Success", fs), result);
}
// @Test
// public void testCreateTrainFood1() {
// TrainFood tf = new TrainFood();
// Mockito.when(trainFoodRepository.findById(Mockito.any(UUID.class))).thenReturn(tf);
// TrainFood result = foodMapServiceImpl.createTrainFood(tf, headers);
// Assert.assertEquals(tf, result);
// }
//
// @Test
// public void testCreateTrainFood2() {
// TrainFood tf = new TrainFood();
// Mockito.when(trainFoodRepository.findById(Mockito.any(UUID.class))).thenReturn(null);
// Mockito.when(trainFoodRepository.save(Mockito.any(TrainFood.class))).thenReturn(null);
// TrainFood result = foodMapServiceImpl.createTrainFood(tf, headers);
// Assert.assertEquals(tf, result);
// }
@Test
public void testListFoodStores1() {
List<StationFoodStore> stationFoodStores = new ArrayList<>();
stationFoodStores.add(new StationFoodStore());
Mockito.when(stationFoodRepository.findAll()).thenReturn(stationFoodStores);
Response result = foodMapServiceImpl.listFoodStores(headers);
Assert.assertEquals(new Response<>(1, "Success", stationFoodStores), result);
}
@Test
public void testListFoodStores2() {
Mockito.when(stationFoodRepository.findAll()).thenReturn(null);
Response result = foodMapServiceImpl.listFoodStores(headers);
Assert.assertEquals(new Response<>(0, "Food store is empty", null), result);
}
// @Test
// public void testListTrainFood1() {
// List<TrainFood> trainFoodList = new ArrayList<>();
// trainFoodList.add(new TrainFood());
// Mockito.when(trainFoodRepository.findAll()).thenReturn(trainFoodList);
// Response result = foodMapServiceImpl.listTrainFood(headers);
// Assert.assertEquals(new Response<>(1, "Success", trainFoodList), result);
// }
//
// @Test
// public void testListTrainFood2() {
// Mockito.when(trainFoodRepository.findAll()).thenReturn(null);
// Response result = foodMapServiceImpl.listTrainFood(headers);
// Assert.assertEquals(new Response<>(0, "No content", null), result);
// }
@Test
public void testListFoodStoresByStationName1() {
List<StationFoodStore> stationFoodStoreList = new ArrayList<>();
stationFoodStoreList.add(new StationFoodStore());
Mockito.when(stationFoodRepository.findByStationName(Mockito.anyString())).thenReturn(stationFoodStoreList);
Response result = foodMapServiceImpl.listFoodStoresByStationName("station_id", headers);
Assert.assertEquals(new Response<>(1, "Success", stationFoodStoreList), result);
}
@Test
public void testListFoodStoresByStationName2() {
Mockito.when(stationFoodRepository.findByStationName(Mockito.anyString())).thenReturn(null);
Response result = foodMapServiceImpl.listFoodStoresByStationName("station_id", headers);
Assert.assertEquals(new Response<>(0, "Food store is empty", null), result);
}
// @Test
// public void testListTrainFoodByTripId1() {
// List<TrainFood> trainFoodList = new ArrayList<>();
// trainFoodList.add(new TrainFood());
// Mockito.when(trainFoodRepository.findByTripId(Mockito.anyString())).thenReturn(trainFoodList);
// Response result = foodMapServiceImpl.listTrainFoodByTripId("trip_id", headers);
// Assert.assertEquals(new Response<>(1, "Success", trainFoodList), result);
// }
//
// @Test
// public void testListTrainFoodByTripId2() {
// Mockito.when(trainFoodRepository.findByTripId(Mockito.anyString())).thenReturn(null);
// Response result = foodMapServiceImpl.listTrainFoodByTripId("trip_id", headers);
// Assert.assertEquals(new Response<>(0, "No content", null), result);
// }
@Test
public void testGetFoodStoresByStationNames1() {
List<String> stationIds = new ArrayList<>();
List<StationFoodStore> stationFoodStoreList = new ArrayList<>();
stationFoodStoreList.add(new StationFoodStore());
Mockito.when(stationFoodRepository.findByStationNameIn(Mockito.anyList())).thenReturn(stationFoodStoreList);
Response result = foodMapServiceImpl.getFoodStoresByStationNames(stationIds);
Assert.assertEquals(new Response<>(1, "Success", stationFoodStoreList), result);
}
@Test
public void testGetFoodStoresByStationNames2() {
List<String> stationIds = new ArrayList<>();
Mockito.when(stationFoodRepository.findByStationNameIn(Mockito.anyList())).thenReturn(null);
Response result = foodMapServiceImpl.getFoodStoresByStationNames(stationIds);
Assert.assertEquals(new Response<>(0, "No content", null), result);
}
}
| 6,536 | 40.903846 | 116 |
java
|
train-ticket
|
train-ticket-master/ts-station-service/src/main/java/fdse/microservice/StationApplication.java
|
package fdse.microservice;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.boot.web.client.RestTemplateBuilder;
import org.springframework.cloud.client.discovery.EnableDiscoveryClient;
import org.springframework.cloud.client.loadbalancer.LoadBalanced;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.EnableAspectJAutoProxy;
import org.springframework.integration.annotation.IntegrationComponentScan;
import org.springframework.scheduling.annotation.EnableAsync;
import org.springframework.web.client.RestTemplate;
import springfox.documentation.swagger2.annotations.EnableSwagger2;
@SpringBootApplication
@EnableAspectJAutoProxy(proxyTargetClass = true)
@EnableAsync
@IntegrationComponentScan
@EnableSwagger2
@EnableDiscoveryClient
public class StationApplication {
public static void main(String[] args) {
SpringApplication.run(StationApplication.class, args);
}
@LoadBalanced
@Bean
public RestTemplate restTemplate(RestTemplateBuilder builder) {
return builder.build();
}
}
| 1,139 | 33.545455 | 75 |
java
|
train-ticket
|
train-ticket-master/ts-station-service/src/main/java/fdse/microservice/config/SecurityConfig.java
|
package fdse.microservice.config;
import edu.fudan.common.security.jwt.JWTFilter;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.http.HttpMethod;
import org.springframework.security.config.annotation.method.configuration.EnableGlobalMethodSecurity;
import org.springframework.security.config.annotation.web.builders.HttpSecurity;
import org.springframework.security.config.annotation.web.configuration.EnableWebSecurity;
import org.springframework.security.config.annotation.web.configuration.WebSecurityConfigurerAdapter;
import org.springframework.security.config.http.SessionCreationPolicy;
import org.springframework.security.crypto.bcrypt.BCryptPasswordEncoder;
import org.springframework.security.crypto.password.PasswordEncoder;
import org.springframework.security.web.authentication.UsernamePasswordAuthenticationFilter;
import org.springframework.web.servlet.config.annotation.CorsRegistry;
import org.springframework.web.servlet.config.annotation.WebMvcConfigurer;
import org.springframework.web.servlet.config.annotation.WebMvcConfigurerAdapter;
import static org.springframework.web.cors.CorsConfiguration.ALL;
@Configuration
@EnableWebSecurity
@EnableGlobalMethodSecurity(prePostEnabled = true)
public class SecurityConfig extends WebSecurityConfigurerAdapter {
String admin = "ADMIN";
String stations = "/api/v1/stationservice/stations";
/**
* load password encoder
*
* @return PasswordEncoder
*/
@Bean
public PasswordEncoder passwordEncoder() {
return new BCryptPasswordEncoder();
}
/**
* allow cors domain
* header By default, only six fields can be taken from the header, and the other fields can only be specified in the header.
* credentials Cookies are not sent by default and can only be true if a Cookie is needed
* Validity of this request
*
* @return WebMvcConfigurer
*/
@Bean
public WebMvcConfigurer corsConfigurer() {
return new WebMvcConfigurerAdapter() {
@Override
public void addCorsMappings(CorsRegistry registry) {
registry.addMapping("/**")
.allowedOrigins(ALL)
.allowedMethods(ALL)
.allowedHeaders(ALL)
.allowCredentials(false)
.maxAge(3600);
}
};
}
@Override
protected void configure(HttpSecurity httpSecurity) throws Exception {
httpSecurity.httpBasic().disable()
// close default csrf
.csrf().disable()
// close session
.sessionManagement().sessionCreationPolicy(SessionCreationPolicy.STATELESS)
.and()
.authorizeRequests()
.antMatchers(HttpMethod.POST, stations).hasAnyRole(admin)
.antMatchers(HttpMethod.PUT, stations).hasAnyRole(admin)
.antMatchers(HttpMethod.DELETE, stations).hasAnyRole(admin)
.antMatchers("/api/v1/stationservice/**").permitAll()
.antMatchers("/swagger-ui.html", "/webjars/**", "/images/**",
"/configuration/**", "/swagger-resources/**", "/v2/**").permitAll()
.anyRequest().authenticated()
.and()
.addFilterBefore(new JWTFilter(), UsernamePasswordAuthenticationFilter.class);
// close cache
httpSecurity.headers().cacheControl();
}
}
| 3,573 | 40.55814 | 130 |
java
|
train-ticket
|
train-ticket-master/ts-station-service/src/main/java/fdse/microservice/controller/StationController.java
|
package fdse.microservice.controller;
import edu.fudan.common.util.Response;
import fdse.microservice.entity.*;
import fdse.microservice.service.StationService;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.http.HttpEntity;
import org.springframework.http.HttpHeaders;
import org.springframework.http.HttpStatus;
import org.springframework.http.ResponseEntity;
import org.springframework.web.bind.annotation.*;
import java.util.List;
import static org.springframework.http.ResponseEntity.ok;
@RestController
@RequestMapping("/api/v1/stationservice")
public class StationController {
@Autowired
private StationService stationService;
private static final Logger LOGGER = LoggerFactory.getLogger(StationController.class);
@GetMapping(path = "/welcome")
public String home(@RequestHeader HttpHeaders headers) {
return "Welcome to [ Station Service ] !";
}
@GetMapping(value = "/stations")
public HttpEntity query(@RequestHeader HttpHeaders headers) {
return ok(stationService.query(headers));
}
@PostMapping(value = "/stations")
public ResponseEntity<Response> create(@RequestBody Station station, @RequestHeader HttpHeaders headers) {
StationController.LOGGER.info("[create][Create station][name: {}]",station.getName());
return new ResponseEntity<>(stationService.create(station, headers), HttpStatus.CREATED);
}
@PutMapping(value = "/stations")
public HttpEntity update(@RequestBody Station station, @RequestHeader HttpHeaders headers) {
StationController.LOGGER.info("[update][Update station][StationId: {}]",station.getId());
return ok(stationService.update(station, headers));
}
@DeleteMapping(value = "/stations/{stationsId}")
public ResponseEntity<Response> delete(@PathVariable String stationsId, @RequestHeader HttpHeaders headers) {
StationController.LOGGER.info("[delete][Delete station][StationId: {}]",stationsId);
return ok(stationService.delete(stationsId, headers));
}
// according to station name ---> query station id
@GetMapping(value = "/stations/id/{stationNameForId}")
public HttpEntity queryForStationId(@PathVariable(value = "stationNameForId")
String stationName, @RequestHeader HttpHeaders headers) {
// string
StationController.LOGGER.info("[queryForId][Query for station id][StationName: {}]",stationName);
return ok(stationService.queryForId(stationName, headers));
}
// according to station name list ---> query all station ids
@CrossOrigin(origins = "*")
@PostMapping(value = "/stations/idlist")
public HttpEntity queryForIdBatch(@RequestBody List<String> stationNameList, @RequestHeader HttpHeaders headers) {
StationController.LOGGER.info("[queryForIdBatch][Query stations for id batch][StationNameNumbers: {}]",stationNameList.size());
return ok(stationService.queryForIdBatch(stationNameList, headers));
}
// according to station id ---> query station name
@CrossOrigin(origins = "*")
@GetMapping(value = "/stations/name/{stationIdForName}")
public HttpEntity queryById(@PathVariable(value = "stationIdForName")
String stationId, @RequestHeader HttpHeaders headers) {
StationController.LOGGER.info("[queryById][Query stations By Id][Id: {}]", stationId);
// string
return ok(stationService.queryById(stationId, headers));
}
// according to station id list ---> query all station names
@CrossOrigin(origins = "*")
@PostMapping(value = "/stations/namelist")
public HttpEntity queryForNameBatch(@RequestBody List<String> stationIdList, @RequestHeader HttpHeaders headers) {
StationController.LOGGER.info("[queryByIdBatch][Query stations for name batch][StationIdNumbers: {}]",stationIdList.size());
return ok(stationService.queryByIdBatch(stationIdList, headers));
}
}
| 4,100 | 42.62766 | 135 |
java
|
train-ticket
|
train-ticket-master/ts-station-service/src/main/java/fdse/microservice/entity/Station.java
|
package fdse.microservice.entity;
import lombok.Data;
import org.hibernate.annotations.GenericGenerator;
import javax.persistence.Column;
import javax.persistence.Entity;
import javax.persistence.GeneratedValue;
import javax.persistence.Id;
import javax.validation.Valid;
import javax.validation.constraints.NotNull;
import java.util.Locale;
import java.util.UUID;
@Data
@Entity
@GenericGenerator(name = "jpa-uuid", strategy = "org.hibernate.id.UUIDGenerator")
public class Station {
@Id
@GeneratedValue(generator = "jpa-uuid")
@Column(length = 36)
private String id;
@Valid
@NotNull
@Column(unique = true)
private String name;
private int stayTime;
public Station(){
this.name = "";
}
public void setName(String name) {
this.name = name.replace(" ", "").toLowerCase(Locale.ROOT);
}
public Station(String name) {
this.name = name.replace(" ", "").toLowerCase(Locale.ROOT);
}
public Station(String name, int stayTime) {
this.name = name.replace(" ", "").toLowerCase(Locale.ROOT);;
this.stayTime = stayTime;
}
}
| 1,129 | 21.6 | 81 |
java
|
train-ticket
|
train-ticket-master/ts-station-service/src/main/java/fdse/microservice/init/InitData.java
|
package fdse.microservice.init;
import fdse.microservice.entity.Station;
import fdse.microservice.service.StationService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.CommandLineRunner;
import org.springframework.stereotype.Component;
@Component
public class InitData implements CommandLineRunner {
@Autowired
StationService service;
@Override
public void run(String... args) throws Exception{
Station info = new Station();
info.setName("Shang Hai");
info.setStayTime(10);
service.create(info,null);
info = new Station();
info.setName("Shang Hai Hong Qiao");
info.setStayTime(10);
service.create(info,null);
info = new Station();
info.setName("Tai Yuan");
info.setStayTime(5);
service.create(info,null);
info = new Station();
info.setName("Bei Jing");
info.setStayTime(10);
service.create(info,null);
info = new Station();
info.setName("Nan Jing");
info.setStayTime(8);
service.create(info,null);
info = new Station();
info.setName("Shi Jia Zhuang");
info.setStayTime(8);
service.create(info,null);
info = new Station();
info.setName("Xu Zhou");
info.setStayTime(7);
service.create(info,null);
info = new Station();
info.setName("Ji Nan");
info.setStayTime(5);
service.create(info,null);
info = new Station();
info.setName("Hang Zhou");
info.setStayTime(9);
service.create(info,null);
info = new Station();
info.setName("Jia Xing Nan");
info.setStayTime(2);
service.create(info,null);
info = new Station();
info.setName("Zhen Jiang");
info.setStayTime(2);
service.create(info,null);
info = new Station();
info.setName("Wu Xi");
info.setStayTime(3);
service.create(info,null);
info = new Station();
info.setName("Su Zhou");
info.setStayTime(3);
service.create(info,null);
}
}
| 2,178 | 24.940476 | 62 |
java
|
train-ticket
|
train-ticket-master/ts-station-service/src/main/java/fdse/microservice/repository/StationRepository.java
|
package fdse.microservice.repository;
import fdse.microservice.entity.Station;
import org.springframework.data.jpa.repository.Query;
import org.springframework.data.repository.CrudRepository;
import org.springframework.stereotype.Repository;
import java.util.List;
import java.util.Optional;
@Repository
public interface StationRepository extends CrudRepository<Station,String> {
Station findByName(String name);
@Query(value="SELECT * from station where name in ?1", nativeQuery = true)
List<Station> findByNames(List<String> names);
Optional<Station> findById(String id);
@Override
List<Station> findAll();
}
| 642 | 25.791667 | 78 |
java
|
train-ticket
|
train-ticket-master/ts-station-service/src/main/java/fdse/microservice/service/StationService.java
|
package fdse.microservice.service;
import edu.fudan.common.util.Response;
import fdse.microservice.entity.*;
import org.springframework.http.HttpHeaders;
import java.util.List;
public interface StationService {
//CRUD
Response create(Station info, HttpHeaders headers);
boolean exist(String stationName, HttpHeaders headers);
Response update(Station info, HttpHeaders headers);
Response delete(String stationsId, HttpHeaders headers);
Response query(HttpHeaders headers);
Response queryForId(String stationName, HttpHeaders headers);
Response queryForIdBatch(List<String> nameList, HttpHeaders headers);
Response queryById(String stationId, HttpHeaders headers);
Response queryByIdBatch(List<String> stationIdList, HttpHeaders headers);
}
| 791 | 25.4 | 77 |
java
|
train-ticket
|
train-ticket-master/ts-station-service/src/main/java/fdse/microservice/service/StationServiceImpl.java
|
package fdse.microservice.service;
import edu.fudan.common.util.Response;
import fdse.microservice.entity.*;
import fdse.microservice.repository.StationRepository;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.http.HttpHeaders;
import org.springframework.stereotype.Service;
import java.util.*;
@Service
public class StationServiceImpl implements StationService {
@Autowired
private StationRepository repository;
String success = "Success";
private static final Logger LOGGER = LoggerFactory.getLogger(StationServiceImpl.class);
@Override
public Response create(Station station, HttpHeaders headers) {
if(station.getName().isEmpty()) {
StationServiceImpl.LOGGER.error("[create][Create station error][Name not specify]");
return new Response<>(0, "Name not specify", station);
}
if (repository.findByName(station.getName()) == null) {
station.setStayTime(station.getStayTime());
repository.save(station);
return new Response<>(1, "Create success", station);
}
StationServiceImpl.LOGGER.error("[create][Create station error][Already exists][StationId: {}]",station.getId());
return new Response<>(0, "Already exists", station);
}
@Override
public boolean exist(String stationName, HttpHeaders headers) {
boolean result = false;
if (repository.findByName(stationName) != null) {
result = true;
}
return result;
}
@Override
public Response update(Station info, HttpHeaders headers) {
Optional<Station> op = repository.findById(info.getId());
if (!op.isPresent()) {
StationServiceImpl.LOGGER.error("[update][Update station error][Station not found][StationId: {}]",info.getId());
return new Response<>(0, "Station not exist", null);
} else {
Station station = op.get();
station.setName(info.getName());
station.setStayTime(info.getStayTime());
repository.save(station);
return new Response<>(1, "Update success", station);
}
}
@Override
public Response delete(String stationsId, HttpHeaders headers) {
Optional<Station> op = repository.findById(stationsId);
if (op.isPresent()) {
Station station = op.get();
repository.delete(station);
return new Response<>(1, "Delete success", station);
}
StationServiceImpl.LOGGER.error("[delete][Delete station error][Station not found][StationId: {}]",stationsId);
return new Response<>(0, "Station not exist", null);
}
@Override
public Response query(HttpHeaders headers) {
List<Station> stations = repository.findAll();
if (stations != null && !stations.isEmpty()) {
return new Response<>(1, "Find all content", stations);
} else {
StationServiceImpl.LOGGER.warn("[query][Query stations warn][Find all stations: {}]","No content");
return new Response<>(0, "No content", null);
}
}
@Override
public Response queryForId(String stationName, HttpHeaders headers) {
Station station = repository.findByName(stationName);
if (station != null) {
return new Response<>(1, success, station.getId());
} else {
StationServiceImpl.LOGGER.warn("[queryForId][Find station id warn][Station not found][StationName: {}]",stationName);
return new Response<>(0, "Not exists", stationName);
}
}
@Override
public Response queryForIdBatch(List<String> nameList, HttpHeaders headers) {
Map<String, String> result = new HashMap<>();
List<Station> stations = repository.findByNames(nameList);
Map<String, String> stationMap = new HashMap<>();
for(Station s: stations) {
stationMap.put(s.getName(), s.getId());
}
for(String name: nameList){
result.put(name, stationMap.get(name));
}
if (!result.isEmpty()) {
return new Response<>(1, success, result);
} else {
StationServiceImpl.LOGGER.warn("[queryForIdBatch][Find station ids warn][Stations not found][StationNameNumber: {}]",nameList.size());
return new Response<>(0, "No content according to name list", null);
}
}
@Override
public Response queryById(String stationId, HttpHeaders headers) {
Optional<Station> station = repository.findById(stationId);
if (station.isPresent()) {
return new Response<>(1, success, station.get().getName());
} else {
StationServiceImpl.LOGGER.error("[queryById][Find station name error][Station not found][StationId: {}]",stationId);
return new Response<>(0, "No that stationId", stationId);
}
}
@Override
public Response queryByIdBatch(List<String> idList, HttpHeaders headers) {
ArrayList<String> result = new ArrayList<>();
for (int i = 0; i < idList.size(); i++) {
Optional<Station> stationOld = repository.findById(idList.get(i));
if(stationOld.isPresent()){
Station station=stationOld.get();
result.add(station.getName());
}
}
if (!result.isEmpty()) {
return new Response<>(1, success, result);
} else {
StationServiceImpl.LOGGER.error("[queryByIdBatch][Find station names error][Stations not found][StationIdNumber: {}]",idList.size());
return new Response<>(0, "No stationNamelist according to stationIdList", result);
}
}
}
| 5,817 | 36.535484 | 146 |
java
|
train-ticket
|
train-ticket-master/ts-station-service/src/test/java/fdse/microservice/controller/StationControllerTest.java
|
package fdse.microservice.controller;
import com.alibaba.fastjson.JSONObject;
import edu.fudan.common.util.Response;
import fdse.microservice.entity.Station;
import fdse.microservice.service.StationService;
import org.junit.Assert;
import org.junit.Before;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.junit.runners.JUnit4;
import org.mockito.InjectMocks;
import org.mockito.Mock;
import org.mockito.Mockito;
import org.mockito.MockitoAnnotations;
import org.springframework.http.*;
import org.springframework.test.web.servlet.MockMvc;
import org.springframework.test.web.servlet.request.MockMvcRequestBuilders;
import org.springframework.test.web.servlet.result.MockMvcResultMatchers;
import org.springframework.test.web.servlet.setup.MockMvcBuilders;
import java.util.ArrayList;
import java.util.List;
@RunWith(JUnit4.class)
public class StationControllerTest {
@InjectMocks
private StationController stationController;
@Mock
private StationService stationService;
private MockMvc mockMvc;
private Response response = new Response();
@Before
public void setUp() {
MockitoAnnotations.initMocks(this);
mockMvc = MockMvcBuilders.standaloneSetup(stationController).build();
}
@Test
public void testHome() throws Exception {
mockMvc.perform(MockMvcRequestBuilders.get("/api/v1/stationservice/welcome"))
.andExpect(MockMvcResultMatchers.status().isOk())
.andExpect(MockMvcResultMatchers.content().string("Welcome to [ Station Service ] !"));
}
@Test
public void testQuery() throws Exception {
Mockito.when(stationService.query(Mockito.any(HttpHeaders.class))).thenReturn(response);
String result = mockMvc.perform(MockMvcRequestBuilders.get("/api/v1/stationservice/stations"))
.andExpect(MockMvcResultMatchers.status().isOk())
.andReturn().getResponse().getContentAsString();
Assert.assertEquals(response, JSONObject.parseObject(result, Response.class));
}
@Test
public void testCreate() throws Exception {
Station station = new Station();
Mockito.when(stationService.create(Mockito.any(Station.class), Mockito.any(HttpHeaders.class))).thenReturn(response);
String requestJson = JSONObject.toJSONString(station);
String result = mockMvc.perform(MockMvcRequestBuilders.post("/api/v1/stationservice/stations").contentType(MediaType.APPLICATION_JSON).content(requestJson))
.andExpect(MockMvcResultMatchers.status().isCreated())
.andReturn().getResponse().getContentAsString();
Assert.assertEquals(response, JSONObject.parseObject(result, Response.class));
}
@Test
public void testUpdate() throws Exception {
Station station = new Station();
Mockito.when(stationService.update(Mockito.any(Station.class), Mockito.any(HttpHeaders.class))).thenReturn(response);
String requestJson = JSONObject.toJSONString(station);
String result = mockMvc.perform(MockMvcRequestBuilders.put("/api/v1/stationservice/stations").contentType(MediaType.APPLICATION_JSON).content(requestJson))
.andExpect(MockMvcResultMatchers.status().isOk())
.andReturn().getResponse().getContentAsString();
Assert.assertEquals(response, JSONObject.parseObject(result, Response.class));
}
@Test
public void testDelete() throws Exception {
Station station = new Station();
Mockito.when(stationService.delete(Mockito.anyString(), Mockito.any(HttpHeaders.class))).thenReturn(response);
String requestJson = JSONObject.toJSONString(station);
String result = mockMvc.perform(MockMvcRequestBuilders.delete("/api/v1/stationservice/stations").contentType(MediaType.APPLICATION_JSON).content(requestJson))
.andExpect(MockMvcResultMatchers.status().isOk())
.andReturn().getResponse().getContentAsString();
Assert.assertEquals(response, JSONObject.parseObject(result, Response.class));
}
@Test
public void testQueryForStationId() throws Exception {
Mockito.when(stationService.queryForId(Mockito.anyString(), Mockito.any(HttpHeaders.class))).thenReturn(response);
String result = mockMvc.perform(MockMvcRequestBuilders.get("/api/v1/stationservice/stations/id/station_name"))
.andExpect(MockMvcResultMatchers.status().isOk())
.andReturn().getResponse().getContentAsString();
Assert.assertEquals(response, JSONObject.parseObject(result, Response.class));
}
@Test
public void testQueryForIdBatch() throws Exception {
List<String> stationNameList = new ArrayList<>();
Mockito.when(stationService.queryForIdBatch(Mockito.anyList(), Mockito.any(HttpHeaders.class))).thenReturn(response);
String requestJson = JSONObject.toJSONString(stationNameList);
String result = mockMvc.perform(MockMvcRequestBuilders.post("/api/v1/stationservice/stations/idlist").contentType(MediaType.APPLICATION_JSON).content(requestJson))
.andExpect(MockMvcResultMatchers.status().isOk())
.andReturn().getResponse().getContentAsString();
Assert.assertEquals(response, JSONObject.parseObject(result, Response.class));
}
@Test
public void testQueryById() throws Exception {
Mockito.when(stationService.queryById(Mockito.anyString(), Mockito.any(HttpHeaders.class))).thenReturn(response);
String result = mockMvc.perform(MockMvcRequestBuilders.get("/api/v1/stationservice/stations/name/station_id"))
.andExpect(MockMvcResultMatchers.status().isOk())
.andReturn().getResponse().getContentAsString();
Assert.assertEquals(response, JSONObject.parseObject(result, Response.class));
}
@Test
public void testQueryForNameBatch() throws Exception {
List<String> stationIdList = new ArrayList<>();
Mockito.when(stationService.queryByIdBatch(Mockito.anyList(), Mockito.any(HttpHeaders.class))).thenReturn(response);
String requestJson = JSONObject.toJSONString(stationIdList);
String result = mockMvc.perform(MockMvcRequestBuilders.post("/api/v1/stationservice/stations/namelist").contentType(MediaType.APPLICATION_JSON).content(requestJson))
.andExpect(MockMvcResultMatchers.status().isOk())
.andReturn().getResponse().getContentAsString();
Assert.assertEquals(response, JSONObject.parseObject(result, Response.class));
}
}
| 6,591 | 48.939394 | 173 |
java
|
train-ticket
|
train-ticket-master/ts-station-service/src/test/java/fdse/microservice/service/StationServiceImplTest.java
|
package fdse.microservice.service;
import edu.fudan.common.util.Response;
import fdse.microservice.entity.Station;
import fdse.microservice.repository.StationRepository;
import org.junit.Assert;
import org.junit.Before;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.junit.runners.JUnit4;
import org.mockito.InjectMocks;
import org.mockito.Mock;
import org.mockito.Mockito;
import org.mockito.MockitoAnnotations;
import org.springframework.http.HttpHeaders;
import java.util.ArrayList;
import java.util.List;
@RunWith(JUnit4.class)
public class StationServiceImplTest {
@InjectMocks
private StationServiceImpl stationServiceImpl;
@Mock
private StationRepository repository;
private HttpHeaders headers = new HttpHeaders();
@Before
public void setUp() {
MockitoAnnotations.initMocks(this);
}
@Test
public void testCreate1() {
Station station = new Station();
Mockito.when(repository.findById(Mockito.anyString()).get()).thenReturn(null);
Mockito.when(repository.save(Mockito.any(Station.class))).thenReturn(null);
Response result = stationServiceImpl.create(station, headers);
Assert.assertEquals(new Response<>(1, "Create success", station), result);
}
@Test
public void testCreate2() {
Station station = new Station();
Mockito.when(repository.findById(Mockito.anyString()).get()).thenReturn(station);
Response result = stationServiceImpl.create(station, headers);
Assert.assertEquals(new Response<>(0, "Already exists", station), result);
}
@Test
public void testExist1() {
Station station = new Station();
Mockito.when(repository.findByName(Mockito.anyString())).thenReturn(station);
Assert.assertTrue(stationServiceImpl.exist("station_name", headers));
}
@Test
public void testExist2() {
Mockito.when(repository.findByName(Mockito.anyString())).thenReturn(null);
Assert.assertFalse(stationServiceImpl.exist("station_name", headers));
}
@Test
public void testUpdate1() {
Station info = new Station();
Mockito.when(repository.findById(Mockito.anyString())).thenReturn(null);
Response result = stationServiceImpl.update(info, headers);
Assert.assertEquals(new Response<>(0, "Station not exist", null), result);
}
@Test
public void testUpdate2() {
Station info = new Station();
Mockito.when(repository.findById(Mockito.anyString()).get()).thenReturn(info);
Mockito.when(repository.save(Mockito.any(Station.class))).thenReturn(null);
Response result = stationServiceImpl.update(info, headers);
Assert.assertEquals("Update success", result.getMsg());
}
@Test
public void testDelete1() {
Station info = new Station();
Mockito.when(repository.findById(Mockito.anyString()).get()).thenReturn(info);
Mockito.doNothing().doThrow(new RuntimeException()).when(repository).delete(Mockito.any(Station.class));
Response result = stationServiceImpl.delete(info.getId(), headers);
Assert.assertEquals("Delete success", result.getMsg());
}
@Test
public void testDelete2() {
Station info = new Station();
Mockito.when(repository.findById(Mockito.anyString())).thenReturn(null);
Response result = stationServiceImpl.delete(info.getId(), headers);
Assert.assertEquals(new Response<>(0, "Station not exist", null), result);
}
@Test
public void testQuery1() {
List<Station> stations = new ArrayList<>();
stations.add(new Station());
Mockito.when(repository.findAll()).thenReturn(stations);
Response result = stationServiceImpl.query(headers);
Assert.assertEquals(new Response<>(1, "Find all content", stations), result);
}
@Test
public void testQuery2() {
Mockito.when(repository.findAll()).thenReturn(null);
Response result = stationServiceImpl.query(headers);
Assert.assertEquals(new Response<>(0, "No content", null), result);
}
@Test
public void testQueryForId1() {
Station station = new Station();
Mockito.when(repository.findByName(Mockito.anyString())).thenReturn(station);
Response result = stationServiceImpl.queryForId("station_name", headers);
Assert.assertEquals(new Response<>(1, "Success", station.getId()), result);
}
@Test
public void testQueryForId2() {
Mockito.when(repository.findByName(Mockito.anyString())).thenReturn(null);
Response result = stationServiceImpl.queryForId("station_name", headers);
Assert.assertEquals(new Response<>(0, "Not exists", "station_name"), result);
}
@Test
public void testQueryForIdBatch1() {
List<String> nameList = new ArrayList<>();
Response result = stationServiceImpl.queryForIdBatch(nameList, headers);
Assert.assertEquals(new Response<>(0, "No content according to name list", null), result);
}
@Test
public void testQueryForIdBatch2() {
List<String> nameList = new ArrayList<>();
nameList.add("station_name");
Mockito.when(repository.findByName(Mockito.anyString())).thenReturn(null);
Response result = stationServiceImpl.queryForIdBatch(nameList, headers);
Assert.assertEquals("Success", result.getMsg());
}
@Test
public void testQueryById1() {
Station station = new Station();
Mockito.when(repository.findById(Mockito.anyString()).get()).thenReturn(station);
Response result = stationServiceImpl.queryById("station_id", headers);
Assert.assertEquals(new Response<>(1, "Success", ""), result);
}
@Test
public void testQueryById2() {
Mockito.when(repository.findById(Mockito.anyString())).thenReturn(null);
Response result = stationServiceImpl.queryById("station_id", headers);
Assert.assertEquals(new Response<>(0, "No that stationId", "station_id"), result);
}
@Test
public void testQueryByIdBatch1() {
List<String> idList = new ArrayList<>();
Response result = stationServiceImpl.queryByIdBatch(idList, headers);
Assert.assertEquals(new Response<>(0, "No stationNamelist according to stationIdList", new ArrayList<>()), result);
}
@Test
public void testQueryByIdBatch2() {
Station station = new Station();
List<String> idList = new ArrayList<>();
idList.add("station_id");
Mockito.when(repository.findById(Mockito.anyString()).get()).thenReturn(station);
Response result = stationServiceImpl.queryByIdBatch(idList, headers);
Assert.assertEquals("Success", result.getMsg());
}
}
| 6,788 | 36.716667 | 123 |
java
|
train-ticket
|
train-ticket-master/ts-train-food-service/src/main/java/trainFood/TrainFoodApplication.java
|
package trainFood;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.boot.web.client.RestTemplateBuilder;
import org.springframework.cloud.client.discovery.EnableDiscoveryClient;
import org.springframework.cloud.client.loadbalancer.LoadBalanced;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.EnableAspectJAutoProxy;
import org.springframework.integration.annotation.IntegrationComponentScan;
import org.springframework.scheduling.annotation.EnableAsync;
import org.springframework.web.client.RestTemplate;
import springfox.documentation.swagger2.annotations.EnableSwagger2;
@SpringBootApplication
@EnableAspectJAutoProxy(proxyTargetClass = true)
@EnableAsync
@IntegrationComponentScan
@EnableSwagger2
@EnableDiscoveryClient
public class TrainFoodApplication {
public static void main(String[] args) {
SpringApplication.run(TrainFoodApplication.class, args);
}
@LoadBalanced
@Bean
public RestTemplate restTemplate(RestTemplateBuilder builder) {
return builder.build();
}
}
| 1,164 | 35.40625 | 75 |
java
|
train-ticket
|
train-ticket-master/ts-train-food-service/src/main/java/trainFood/config/SecurityConfig.java
|
package trainFood.config;
import edu.fudan.common.security.jwt.JWTFilter;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.security.config.annotation.method.configuration.EnableGlobalMethodSecurity;
import org.springframework.security.config.annotation.web.builders.HttpSecurity;
import org.springframework.security.config.annotation.web.configuration.EnableWebSecurity;
import org.springframework.security.config.annotation.web.configuration.WebSecurityConfigurerAdapter;
import org.springframework.security.config.http.SessionCreationPolicy;
import org.springframework.security.crypto.bcrypt.BCryptPasswordEncoder;
import org.springframework.security.crypto.password.PasswordEncoder;
import org.springframework.security.web.authentication.UsernamePasswordAuthenticationFilter;
import org.springframework.web.servlet.config.annotation.CorsRegistry;
import org.springframework.web.servlet.config.annotation.WebMvcConfigurer;
import org.springframework.web.servlet.config.annotation.WebMvcConfigurerAdapter;
import static org.springframework.web.cors.CorsConfiguration.ALL;
@Configuration
@EnableWebSecurity
@EnableGlobalMethodSecurity(prePostEnabled = true)
public class SecurityConfig extends WebSecurityConfigurerAdapter {
// load password encoder
@Bean
public PasswordEncoder passwordEncoder() {
return new BCryptPasswordEncoder();
}
/**
* allow cors domain
* header 在默认的情况下只能从头部取出6个字段，想要其他字段只能自己在头里指定
* credentials 默认不发送Cookie, 如果需要Cookie,这个值只能为true
* 本次请求检查的有效期
*
* @return
*/
@Bean
public WebMvcConfigurer corsConfigurer() {
return new WebMvcConfigurerAdapter() {
@Override
public void addCorsMappings(CorsRegistry registry) {
registry.addMapping("/**")
.allowedOrigins(ALL)
.allowedMethods(ALL)
.allowedHeaders(ALL)
.allowCredentials(false)
.maxAge(3600);
}
};
}
@Override
protected void configure(HttpSecurity httpSecurity) throws Exception {
httpSecurity.httpBasic().disable()
// close default csrf
.csrf().disable()
// close session
.sessionManagement().sessionCreationPolicy(SessionCreationPolicy.STATELESS)
.and()
.authorizeRequests()
.antMatchers("/api/v1/trainfoodservice/**").permitAll()
.antMatchers("/swagger-ui.html", "/webjars/**", "/images/**",
"/configuration/**", "/swagger-resources/**", "/v2/**").permitAll()
.anyRequest().authenticated()
.and()
.addFilterBefore(new JWTFilter(), UsernamePasswordAuthenticationFilter.class);
// close cache
httpSecurity.headers().cacheControl();
}
}
| 3,006 | 39.093333 | 102 |
java
|
train-ticket
|
train-ticket-master/ts-train-food-service/src/main/java/trainFood/controller/TrainFoodController.java
|
package trainFood.controller;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.http.HttpEntity;
import org.springframework.http.HttpHeaders;
import org.springframework.web.bind.annotation.*;
import trainFood.service.TrainFoodService;
import static org.springframework.http.ResponseEntity.ok;
@RestController
@RequestMapping("/api/v1/trainfoodservice")
public class TrainFoodController {
@Autowired
TrainFoodService trainFoodService;
private static final Logger LOGGER = LoggerFactory.getLogger(TrainFoodController.class);
@GetMapping(path = "/trainfoods/welcome")
public String home() {
return "Welcome to [ Train Food Service ] !";
}
@CrossOrigin(origins = "*")
@GetMapping("/trainfoods")
public HttpEntity getAllTrainFood(@RequestHeader HttpHeaders headers) {
TrainFoodController.LOGGER.info("[Food Map Service][Get All TrainFoods]");
return ok(trainFoodService.listTrainFood(headers));
}
@CrossOrigin(origins = "*")
@GetMapping("/trainfoods/{tripId}")
public HttpEntity getTrainFoodOfTrip(@PathVariable String tripId, @RequestHeader HttpHeaders headers) {
TrainFoodController.LOGGER.info("[Food Map Service][Get TrainFoods By TripId]");
return ok(trainFoodService.listTrainFoodByTripId(tripId, headers));
}
}
| 1,414 | 33.512195 | 107 |
java
|
train-ticket
|
train-ticket-master/ts-train-food-service/src/main/java/trainFood/entity/TrainFood.java
|
package trainFood.entity;
import com.fasterxml.jackson.annotation.JsonIgnoreProperties;
import edu.fudan.common.entity.Food;
import lombok.Data;
import org.hibernate.annotations.GenericGenerator;
import javax.persistence.*;
import javax.validation.Valid;
import javax.validation.constraints.NotNull;
import java.util.List;
import java.util.UUID;
@Data
@Entity
@GenericGenerator(name = "jpa-uuid", strategy = "org.hibernate.id.UUIDGenerator")
@JsonIgnoreProperties(ignoreUnknown = true)
public class TrainFood {
@Id
@GeneratedValue(generator = "jpa-uuid")
@Column(length = 36)
private String id;
@NotNull
@Column(unique = true)
private String tripId;
@ElementCollection(targetClass = Food.class)
@CollectionTable(name = "train_food_list", joinColumns = @JoinColumn(name = "trip_id"))
private List<Food> foodList;
public TrainFood(){
//Default Constructor
this.tripId = "";
}
}
| 948 | 23.333333 | 91 |
java
|
train-ticket
|
train-ticket-master/ts-train-food-service/src/main/java/trainFood/init/InitData.java
|
package trainFood.init;
import edu.fudan.common.entity.Food;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.CommandLineRunner;
import org.springframework.stereotype.Component;
import trainFood.entity.TrainFood;
import trainFood.service.TrainFoodService;
import java.io.BufferedReader;
import java.io.InputStreamReader;
import java.util.ArrayList;
import java.util.List;
import java.util.UUID;
@Component
public class InitData implements CommandLineRunner{
@Autowired
TrainFoodService trainFoodService;
private static final Logger LOGGER = LoggerFactory.getLogger(InitData.class);
@Override
public void run(String... args) throws Exception {
BufferedReader br2 = new BufferedReader(new InputStreamReader(this.getClass().getResourceAsStream("/trainfood.txt")));
try{
String line2 = br2.readLine();
while( line2 != null ){
if( !line2.trim().equals("") ){
TrainFood tf = new TrainFood();
tf.setId(UUID.randomUUID().toString());
String[] lineTemp = line2.trim().split("=");
tf.setTripId(lineTemp[1]);
lineTemp = br2.readLine().trim().split("=");
tf.setFoodList(toFoodList(lineTemp[1]));
trainFoodService.createTrainFood(tf,null);
}
line2 = br2.readLine();
}
} catch(Exception e){
InitData.LOGGER.info("the trainfood.txt has format error!");
InitData.LOGGER.error(e.getMessage());
System.exit(1);
}
}
private List<Food> toFoodList(String s){
InitData.LOGGER.info("s= {}", s);
String[] foodstring = s.split("_");
List<Food> foodList = new ArrayList<>();
for(int i = 0; i< foodstring.length; i++){
String[] foodTemp = foodstring[i].split(",");
Food food = new Food();
food.setFoodName(foodTemp[0]);
food.setPrice(Double.parseDouble(foodTemp[1]));
foodList.add(food);
}
return foodList;
}
}
| 2,230 | 31.808824 | 126 |
java
|
train-ticket
|
train-ticket-master/ts-train-food-service/src/main/java/trainFood/repository/TrainFoodRepository.java
|
package trainFood.repository;
import org.springframework.data.repository.CrudRepository;
import org.springframework.stereotype.Repository;
import trainFood.entity.TrainFood;
import java.util.List;
import java.util.UUID;
@Repository
public interface TrainFoodRepository extends CrudRepository<TrainFood, String> {
TrainFood findById(UUID id);
@Override
List<TrainFood> findAll();
TrainFood findByTripId(String tripId);
void deleteById(UUID id);
}
| 474 | 19.652174 | 80 |
java
|
train-ticket
|
train-ticket-master/ts-train-food-service/src/main/java/trainFood/service/TrainFoodService.java
|
package trainFood.service;
import edu.fudan.common.util.Response;
import org.springframework.http.HttpHeaders;
import trainFood.entity.*;
public interface TrainFoodService {
TrainFood createTrainFood(TrainFood tf, HttpHeaders headers);
Response listTrainFood(HttpHeaders headers);
Response listTrainFoodByTripId(String tripId, HttpHeaders headers);
}
| 367 | 25.285714 | 71 |
java
|
train-ticket
|
train-ticket-master/ts-train-food-service/src/main/java/trainFood/service/TrainFoodServiceImpl.java
|
package trainFood.service;
import edu.fudan.common.util.Response;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.http.HttpHeaders;
import org.springframework.stereotype.Service;
import trainFood.entity.*;
import trainFood.repository.TrainFoodRepository;
import java.util.List;
@Service
public class TrainFoodServiceImpl implements TrainFoodService{
@Autowired
TrainFoodRepository trainFoodRepository;
private static final Logger LOGGER = LoggerFactory.getLogger(TrainFoodServiceImpl.class);
String success = "Success";
String noContent = "No content";
@Override
public TrainFood createTrainFood(TrainFood tf, HttpHeaders headers) {
TrainFood tfTemp = trainFoodRepository.findByTripId(tf.getTripId());
if (tfTemp != null) {
if(tfTemp.getFoodList().equals(tf.getFoodList())){
TrainFoodServiceImpl.LOGGER.error("[Init TrainFood] Already Exists TripId: {}", tf.getTripId());
}else{
tfTemp.setFoodList(tf.getFoodList());
trainFoodRepository.save(tfTemp);
}
} else {
trainFoodRepository.save(tf);
}
return tf;
}
@Override
public Response listTrainFood(HttpHeaders headers) {
List<TrainFood> trainFoodList = trainFoodRepository.findAll();
if (trainFoodList != null && !trainFoodList.isEmpty()) {
return new Response<>(1, success, trainFoodList);
} else {
TrainFoodServiceImpl.LOGGER.error("List train food error: {}", noContent);
return new Response<>(0, noContent, null);
}
}
@Override
public Response listTrainFoodByTripId(String tripId, HttpHeaders headers) {
TrainFood tf = trainFoodRepository.findByTripId(tripId);
if(tf == null){
return new Response<>(0, noContent, null);
}else{
return new Response<>(1, success, tf.getFoodList());
}
}
}
| 2,063 | 32.290323 | 112 |
java
|
train-ticket
|
train-ticket-master/ts-train-service/src/main/java/train/TrainApplication.java
|
package train;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.boot.web.client.RestTemplateBuilder;
import org.springframework.cloud.client.discovery.EnableDiscoveryClient;
import org.springframework.cloud.client.loadbalancer.LoadBalanced;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.EnableAspectJAutoProxy;
import org.springframework.integration.annotation.IntegrationComponentScan;
import org.springframework.scheduling.annotation.EnableAsync;
import org.springframework.web.client.RestTemplate;
import springfox.documentation.swagger2.annotations.EnableSwagger2;
@SpringBootApplication
@EnableAspectJAutoProxy(proxyTargetClass = true)
@EnableAsync
@IntegrationComponentScan
@EnableSwagger2
@EnableDiscoveryClient
public class TrainApplication {
public static void main(String[] args) {
SpringApplication.run(TrainApplication.class, args);
}
@LoadBalanced
@Bean
public RestTemplate restTemplate(RestTemplateBuilder builder) {
return builder.build();
}
}
| 1,153 | 33.969697 | 75 |
java
|
train-ticket
|
train-ticket-master/ts-train-service/src/main/java/train/config/SecurityConfig.java
|
package train.config;
import edu.fudan.common.security.jwt.JWTFilter;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.http.HttpMethod;
import org.springframework.security.config.annotation.method.configuration.EnableGlobalMethodSecurity;
import org.springframework.security.config.annotation.web.builders.HttpSecurity;
import org.springframework.security.config.annotation.web.configuration.EnableWebSecurity;
import org.springframework.security.config.annotation.web.configuration.WebSecurityConfigurerAdapter;
import org.springframework.security.config.http.SessionCreationPolicy;
import org.springframework.security.crypto.bcrypt.BCryptPasswordEncoder;
import org.springframework.security.crypto.password.PasswordEncoder;
import org.springframework.security.web.authentication.UsernamePasswordAuthenticationFilter;
import org.springframework.web.servlet.config.annotation.CorsRegistry;
import org.springframework.web.servlet.config.annotation.WebMvcConfigurer;
import org.springframework.web.servlet.config.annotation.WebMvcConfigurerAdapter;
import static org.springframework.web.cors.CorsConfiguration.ALL;
@Configuration
@EnableWebSecurity
@EnableGlobalMethodSecurity(prePostEnabled = true)
public class SecurityConfig extends WebSecurityConfigurerAdapter {
String admin = "ADMIN";
/**
* load password encoder
*
* @return PasswordEncoder
*/
@Bean
public PasswordEncoder passwordEncoder() {
return new BCryptPasswordEncoder();
}
/**
* allow cors domain
* header By default, only six fields can be taken from the header, and the other fields can only be specified in the header.
* credentials Cookies are not sent by default and can only be true if a Cookie is needed
* Validity of this request
*
* @return WebMvcConfigurer
*/
@Bean
public WebMvcConfigurer corsConfigurer() {
return new WebMvcConfigurerAdapter() {
@Override
public void addCorsMappings(CorsRegistry registry) {
registry.addMapping("/**")
.allowedOrigins(ALL)
.allowedMethods(ALL)
.allowedHeaders(ALL)
.allowCredentials(false)
.maxAge(3600);
}
};
}
@Override
protected void configure(HttpSecurity httpSecurity) throws Exception {
httpSecurity.httpBasic().disable()
// close default csrf
.csrf().disable()
// close session
.sessionManagement().sessionCreationPolicy(SessionCreationPolicy.STATELESS)
.and()
.authorizeRequests()
.antMatchers("/api/v1/trainservice/**").permitAll()
.antMatchers(HttpMethod.POST, "/api/v1/trainservice/trains").hasAnyRole(admin)
.antMatchers(HttpMethod.PUT, "/api/v1/trainservice/trains").hasAnyRole(admin)
.antMatchers(HttpMethod.DELETE, "/api/v1/trainservice/trains/*").hasAnyRole(admin)
.antMatchers("/swagger-ui.html", "/webjars/**", "/images/**",
"/configuration/**", "/swagger-resources/**", "/v2/**").permitAll()
.anyRequest().authenticated()
.and()
.addFilterBefore(new JWTFilter(), UsernamePasswordAuthenticationFilter.class);
// close cache
httpSecurity.headers().cacheControl();
}
}
| 3,567 | 40.976471 | 130 |
java
|
train-ticket
|
train-ticket-master/ts-train-service/src/main/java/train/controller/TrainController.java
|
package train.controller;
import edu.fudan.common.util.Response;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.http.HttpEntity;
import org.springframework.http.HttpHeaders;
import org.springframework.web.bind.annotation.*;
import train.entity.TrainType;
import train.service.TrainService;
import java.util.List;
import static org.springframework.http.ResponseEntity.ok;
@RestController
@RequestMapping("/api/v1/trainservice")
public class TrainController {
@Autowired
private TrainService trainService;
private static final Logger LOGGER = LoggerFactory.getLogger(TrainController.class);
@GetMapping(path = "/trains/welcome")
public String home(@RequestHeader HttpHeaders headers) {
return "Welcome to [ Train Service ] !";
}
@CrossOrigin(origins = "*")
@PostMapping(value = "/trains")
public HttpEntity create(@RequestBody TrainType trainType, @RequestHeader HttpHeaders headers) {
TrainController.LOGGER.info("[create][Create train][TrainTypeId: {}]",trainType.getId());
boolean isCreateSuccess = trainService.create(trainType, headers);
if (isCreateSuccess) {
return ok(new Response(1, "create success", null));
} else {
return ok(new Response(0, "train type already exist", trainType));
}
}
@CrossOrigin(origins = "*")
@GetMapping(value = "/trains/{id}")
public HttpEntity retrieve(@PathVariable String id, @RequestHeader HttpHeaders headers) {
TrainController.LOGGER.info("[retrieve][Retrieve train][TrainTypeId: {}]",id);
TrainType trainType = trainService.retrieve(id, headers);
if (trainType == null) {
return ok(new Response(0, "here is no TrainType with the trainType id: " + id, null));
} else {
return ok(new Response(1, "success", trainType));
}
}
@CrossOrigin(origins = "*")
@GetMapping(value = "/trains/byName/{name}")
public HttpEntity retrieveByName(@PathVariable String name, @RequestHeader HttpHeaders headers) {
TrainController.LOGGER.info("[retrieveByName][Retrieve train][TrainTypeName: {}]", name);
TrainType trainType = trainService.retrieveByName(name, headers);
if (trainType == null) {
return ok(new Response(0, "here is no TrainType with the trainType name: " + name, null));
} else {
return ok(new Response(1, "success", trainType));
}
}
@CrossOrigin(origins = "*")
@PostMapping(value = "/trains/byNames")
public HttpEntity retrieveByName(@RequestBody List<String> names, @RequestHeader HttpHeaders headers) {
TrainController.LOGGER.info("[retrieveByNames][Retrieve train][TrainTypeNames: {}]", names);
List<TrainType> trainTypes = trainService.retrieveByNames(names, headers);
if (trainTypes == null) {
return ok(new Response(0, "here is no TrainTypes with the trainType names: " + names, null));
} else {
return ok(new Response(1, "success", trainTypes));
}
}
@CrossOrigin(origins = "*")
@PutMapping(value = "/trains")
public HttpEntity update(@RequestBody TrainType trainType, @RequestHeader HttpHeaders headers) {
TrainController.LOGGER.info("[update][Update train][TrainTypeId: {}]",trainType.getId());
boolean isUpdateSuccess = trainService.update(trainType, headers);
if (isUpdateSuccess) {
return ok(new Response(1, "update success", isUpdateSuccess));
} else {
return ok(new Response(0, "there is no trainType with the trainType id", isUpdateSuccess));
}
}
@CrossOrigin(origins = "*")
@DeleteMapping(value = "/trains/{id}")
public HttpEntity delete(@PathVariable String id, @RequestHeader HttpHeaders headers) {
TrainController.LOGGER.info("[delete][Delete train][TrainTypeId: {}]",id);
boolean isDeleteSuccess = trainService.delete(id, headers);
if (isDeleteSuccess) {
return ok(new Response(1, "delete success", isDeleteSuccess));
} else {
return ok(new Response(0, "there is no train according to id", null));
}
}
@CrossOrigin(origins = "*")
@GetMapping(value = "/trains")
public HttpEntity query(@RequestHeader HttpHeaders headers) {
TrainController.LOGGER.info("[query][Query train]");
List<TrainType> trainTypes = trainService.query(headers);
if (trainTypes != null && !trainTypes.isEmpty()) {
return ok(new Response(1, "success", trainTypes));
} else {
return ok(new Response(0, "no content", trainTypes));
}
}
}
| 4,767 | 39.752137 | 107 |
java
|
train-ticket
|
train-ticket-master/ts-train-service/src/main/java/train/entity/TrainType.java
|
package train.entity;
import lombok.Data;
import lombok.NonNull;
import org.hibernate.annotations.GenericGenerator;
import javax.persistence.Column;
import javax.persistence.GeneratedValue;
import javax.persistence.Id;
import javax.persistence.Entity;
import javax.validation.Valid;
import javax.validation.constraints.NotNull;
@Data
@Entity
@GenericGenerator(name = "jpa-uuid", strategy = "org.hibernate.id.UUIDGenerator")
public class TrainType {
@Id
@GeneratedValue(generator = "jpa-uuid")
@Column(length = 36)
private String id;
@NotNull
@Column(name="name", unique = true)
private String name;
@Valid
@Column(name = "economy_class")
private int economyClass;
@Valid
@Column(name = "confort_class")
private int confortClass;
@Column(name = "average_speed")
private int averageSpeed;
public TrainType(){
//Default Constructor
}
public TrainType(String name, int economyClass, int confortClass) {
this.name = name;
this.economyClass = economyClass;
this.confortClass = confortClass;
}
public TrainType(String name, int economyClass, int confortClass, int averageSpeed) {
this.name = name;
this.economyClass = economyClass;
this.confortClass = confortClass;
this.averageSpeed = averageSpeed;
}
}
| 1,356 | 23.232143 | 89 |
java
|
train-ticket
|
train-ticket-master/ts-train-service/src/main/java/train/init/InitData.java
|
package train.init;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.CommandLineRunner;
import org.springframework.stereotype.Component;
import train.entity.TrainType;
import train.service.TrainService;
@Component
public class InitData implements CommandLineRunner {
@Autowired
TrainService service;
@Override
public void run(String... args) throws Exception {
TrainType info = new TrainType();
info.setName("GaoTieOne");
info.setConfortClass(Integer.MAX_VALUE);
info.setEconomyClass(Integer.MAX_VALUE);
info.setAverageSpeed(250);
service.create(info, null);
info = new TrainType();
info.setName("GaoTieTwo");
info.setConfortClass(Integer.MAX_VALUE);
info.setEconomyClass(Integer.MAX_VALUE);
info.setAverageSpeed(200);
service.create(info, null);
info = new TrainType();
info.setName("DongCheOne");
info.setConfortClass(Integer.MAX_VALUE);
info.setEconomyClass(Integer.MAX_VALUE);
info.setAverageSpeed(180);
service.create(info, null);
info = new TrainType();
info.setName("ZhiDa");
info.setConfortClass(Integer.MAX_VALUE);
info.setEconomyClass(Integer.MAX_VALUE);
info.setAverageSpeed(120);
service.create(info, null);
info = new TrainType();
info.setName("TeKuai");
info.setConfortClass(Integer.MAX_VALUE);
info.setEconomyClass(Integer.MAX_VALUE);
info.setAverageSpeed(120);
service.create(info, null);
info = new TrainType();
info.setName("KuaiSu");
info.setConfortClass(Integer.MAX_VALUE);
info.setEconomyClass(Integer.MAX_VALUE);
info.setAverageSpeed(90);
service.create(info, null);
}
}
| 1,858 | 28.983871 | 62 |
java
|
train-ticket
|
train-ticket-master/ts-train-service/src/main/java/train/repository/TrainTypeRepository.java
|
package train.repository;
import org.springframework.data.jpa.repository.Query;
import org.springframework.data.repository.CrudRepository;
import org.springframework.stereotype.Repository;
import train.entity.TrainType;
import java.util.List;
import java.util.Optional;
@Repository
public interface TrainTypeRepository extends CrudRepository<TrainType,String> {
Optional<TrainType> findById(String id);
@Override
List<TrainType> findAll();
void deleteById(String id);
TrainType findByName(String name);
@Query(value="SELECT * from train_type where name in ?1", nativeQuery = true)
List<TrainType> findByNames(List<String> names);
}
| 665 | 27.956522 | 81 |
java
|
train-ticket
|
train-ticket-master/ts-train-service/src/main/java/train/service/TrainService.java
|
package train.service;
import org.springframework.http.HttpHeaders;
import train.entity.TrainType;
import java.util.List;
public interface TrainService {
//CRUD
boolean create(TrainType trainType, HttpHeaders headers);
TrainType retrieve(String id,HttpHeaders headers);
TrainType retrieveByName(String name,HttpHeaders headers);
List<TrainType> retrieveByNames(List<String> name,HttpHeaders headers);
boolean update(TrainType trainType,HttpHeaders headers);
boolean delete(String id,HttpHeaders headers);
List<TrainType> query(HttpHeaders headers);
}
| 592 | 23.708333 | 75 |
java
|
train-ticket
|
train-ticket-master/ts-train-service/src/main/java/train/service/TrainServiceImpl.java
|
package train.service;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.http.HttpHeaders;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;
import train.entity.TrainType;
import train.repository.TrainTypeRepository;
import java.util.List;
@Service
public class TrainServiceImpl implements TrainService {
@Autowired
private TrainTypeRepository repository;
private static final Logger LOGGER = LoggerFactory.getLogger(TrainServiceImpl.class);
@Override
public boolean create(TrainType trainType, HttpHeaders headers) {
boolean result = false;
if(trainType.getName().isEmpty()){
TrainServiceImpl.LOGGER.error("[create][Create train error][Train Type name not specified]");
return result;
}
if (repository.findByName(trainType.getName()) == null) {
TrainType type = new TrainType(trainType.getName(), trainType.getEconomyClass(), trainType.getConfortClass());
type.setAverageSpeed(trainType.getAverageSpeed());
repository.save(type);
result = true;
}
else {
TrainServiceImpl.LOGGER.error("[create][Create train error][Train already exists][TrainTypeId: {}]",trainType.getId());
}
return result;
}
@Override
public TrainType retrieve(String id, HttpHeaders headers) {
if (!repository.findById(id).isPresent()) {
TrainServiceImpl.LOGGER.error("[retrieve][Retrieve train error][Train not found][TrainTypeId: {}]",id);
return null;
} else {
return repository.findById(id).get();
}
}
@Override
public TrainType retrieveByName(String name, HttpHeaders headers) {
TrainType tt = repository.findByName(name);
if (tt == null) {
TrainServiceImpl.LOGGER.error("[retrieveByName][RetrieveByName error][Train not found][TrainTypeName: {}]", name);
return null;
} else {
return tt;
}
}
@Override
public List<TrainType> retrieveByNames(List<String> names, HttpHeaders headers) {
List<TrainType> tt = repository.findByNames(names);
if (tt == null || tt.isEmpty()) {
TrainServiceImpl.LOGGER.error("[retrieveByNames][RetrieveByNames error][Train not found][TrainTypeNames: {}]", names);
return null;
} else {
return tt;
}
}
@Override
@Transactional
public boolean update(TrainType trainType, HttpHeaders headers) {
boolean result = false;
if (repository.findById(trainType.getId()).isPresent()) {
TrainType type = new TrainType(trainType.getName(), trainType.getEconomyClass(), trainType.getConfortClass(), trainType.getAverageSpeed());
type.setId(trainType.getId());
repository.save(type);
result = true;
}
else {
TrainServiceImpl.LOGGER.error("[update][Update train error][Train not found][TrainTypeId: {}]",trainType.getId());
}
return result;
}
@Override
public boolean delete(String id, HttpHeaders headers) {
boolean result = false;
if (repository.findById(id).isPresent()) {
repository.deleteById(id);
result = true;
}
else {
TrainServiceImpl.LOGGER.error("[delete][Delete train error][Train not found][TrainTypeId: {}]",id);
}
return result;
}
@Override
public List<TrainType> query(HttpHeaders headers) {
return repository.findAll();
}
}
| 3,741 | 33.648148 | 151 |
java
|
train-ticket
|
train-ticket-master/ts-train-service/src/test/java/train/controller/TrainControllerTest.java
|
package train.controller;
import com.alibaba.fastjson.JSONObject;
import edu.fudan.common.util.Response;
import org.junit.Assert;
import org.junit.Before;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.junit.runners.JUnit4;
import org.mockito.InjectMocks;
import org.mockito.Mock;
import org.mockito.Mockito;
import org.mockito.MockitoAnnotations;
import org.springframework.http.*;
import org.springframework.test.web.servlet.MockMvc;
import org.springframework.test.web.servlet.request.MockMvcRequestBuilders;
import org.springframework.test.web.servlet.result.MockMvcResultMatchers;
import org.springframework.test.web.servlet.setup.MockMvcBuilders;
import train.entity.TrainType;
import train.service.TrainService;
import java.util.ArrayList;
import java.util.List;
@RunWith(JUnit4.class)
public class TrainControllerTest {
@InjectMocks
private TrainController trainController;
@Mock
private TrainService trainService;
private MockMvc mockMvc;
@Before
public void setUp() {
MockitoAnnotations.initMocks(this);
mockMvc = MockMvcBuilders.standaloneSetup(trainController).build();
}
@Test
public void testHome() throws Exception {
mockMvc.perform(MockMvcRequestBuilders.get("/api/v1/trainservice/trains/welcome"))
.andExpect(MockMvcResultMatchers.status().isOk())
.andExpect(MockMvcResultMatchers.content().string("Welcome to [ Train Service ] !"));
}
@Test
public void testCreate1() throws Exception {
TrainType trainType = new TrainType();
Mockito.when(trainService.create(Mockito.any(TrainType.class), Mockito.any(HttpHeaders.class))).thenReturn(true);
String requestJson = JSONObject.toJSONString(trainType);
String result = mockMvc.perform(MockMvcRequestBuilders.post("/api/v1/trainservice/trains").contentType(MediaType.APPLICATION_JSON).content(requestJson))
.andExpect(MockMvcResultMatchers.status().isOk())
.andReturn().getResponse().getContentAsString();
Assert.assertEquals(new Response(1, "create success", null), JSONObject.parseObject(result, Response.class));
}
@Test
public void testCreate2() throws Exception {
TrainType trainType = new TrainType();
Mockito.when(trainService.create(Mockito.any(TrainType.class), Mockito.any(HttpHeaders.class))).thenReturn(false);
String requestJson = JSONObject.toJSONString(trainType);
String result = mockMvc.perform(MockMvcRequestBuilders.post("/api/v1/trainservice/trains").contentType(MediaType.APPLICATION_JSON).content(requestJson))
.andExpect(MockMvcResultMatchers.status().isOk())
.andReturn().getResponse().getContentAsString();
Assert.assertEquals("train type already exist", JSONObject.parseObject(result, Response.class).getMsg());
}
@Test
public void testRetrieve1() throws Exception {
Mockito.when(trainService.retrieve(Mockito.anyString(), Mockito.any(HttpHeaders.class))).thenReturn(null);
String result = mockMvc.perform(MockMvcRequestBuilders.get("/api/v1/trainservice/trains/wrong_id"))
.andExpect(MockMvcResultMatchers.status().isOk())
.andReturn().getResponse().getContentAsString();
Assert.assertEquals(new Response(0, "here is no TrainType with the trainType id: wrong_id", null), JSONObject.parseObject(result, Response.class));
}
@Test
public void testRetrieve2() throws Exception {
TrainType trainType = new TrainType();
Mockito.when(trainService.retrieve(Mockito.anyString(), Mockito.any(HttpHeaders.class))).thenReturn(trainType);
String result = mockMvc.perform(MockMvcRequestBuilders.get("/api/v1/trainservice/trains/id"))
.andExpect(MockMvcResultMatchers.status().isOk())
.andReturn().getResponse().getContentAsString();
Assert.assertEquals("success", JSONObject.parseObject(result, Response.class).getMsg());
}
@Test
public void testUpdate1() throws Exception {
TrainType trainType = new TrainType();
Mockito.when(trainService.update(Mockito.any(TrainType.class), Mockito.any(HttpHeaders.class))).thenReturn(true);
String requestJson = JSONObject.toJSONString(trainType);
String result = mockMvc.perform(MockMvcRequestBuilders.put("/api/v1/trainservice/trains").contentType(MediaType.APPLICATION_JSON).content(requestJson))
.andExpect(MockMvcResultMatchers.status().isOk())
.andReturn().getResponse().getContentAsString();
Assert.assertEquals(new Response(1, "update success", true), JSONObject.parseObject(result, Response.class));
}
@Test
public void testUpdate2() throws Exception {
TrainType trainType = new TrainType();
Mockito.when(trainService.update(Mockito.any(TrainType.class), Mockito.any(HttpHeaders.class))).thenReturn(false);
String requestJson = JSONObject.toJSONString(trainType);
String result = mockMvc.perform(MockMvcRequestBuilders.put("/api/v1/trainservice/trains").contentType(MediaType.APPLICATION_JSON).content(requestJson))
.andExpect(MockMvcResultMatchers.status().isOk())
.andReturn().getResponse().getContentAsString();
Assert.assertEquals(new Response(0, "there is no trainType with the trainType id", false), JSONObject.parseObject(result, Response.class));
}
@Test
public void testDelete1() throws Exception {
Mockito.when(trainService.delete(Mockito.anyString(), Mockito.any(HttpHeaders.class))).thenReturn(true);
String result = mockMvc.perform(MockMvcRequestBuilders.delete("/api/v1/trainservice/trains/id"))
.andExpect(MockMvcResultMatchers.status().isOk())
.andReturn().getResponse().getContentAsString();
Assert.assertEquals(new Response(1, "delete success", true), JSONObject.parseObject(result, Response.class));
}
@Test
public void testDelete2() throws Exception {
Mockito.when(trainService.delete(Mockito.anyString(), Mockito.any(HttpHeaders.class))).thenReturn(false);
String result = mockMvc.perform(MockMvcRequestBuilders.delete("/api/v1/trainservice/trains/id"))
.andExpect(MockMvcResultMatchers.status().isOk())
.andReturn().getResponse().getContentAsString();
Assert.assertEquals(new Response(0, "there is no train according to id", null), JSONObject.parseObject(result, Response.class));
}
@Test
public void testQuery1() throws Exception {
List<TrainType> trainTypes = new ArrayList<>();
trainTypes.add(new TrainType());
Mockito.when(trainService.query(Mockito.any(HttpHeaders.class))).thenReturn(trainTypes);
String result = mockMvc.perform(MockMvcRequestBuilders.get("/api/v1/trainservice/trains"))
.andExpect(MockMvcResultMatchers.status().isOk())
.andReturn().getResponse().getContentAsString();
Assert.assertEquals("success", JSONObject.parseObject(result, Response.class).getMsg());
}
@Test
public void testQuery2() throws Exception {
List<TrainType> trainTypes = new ArrayList<>();
Mockito.when(trainService.query(Mockito.any(HttpHeaders.class))).thenReturn(trainTypes);
String result = mockMvc.perform(MockMvcRequestBuilders.get("/api/v1/trainservice/trains"))
.andExpect(MockMvcResultMatchers.status().isOk())
.andReturn().getResponse().getContentAsString();
Assert.assertEquals("no content", JSONObject.parseObject(result, Response.class).getMsg());
}
}
| 7,712 | 50.07947 | 160 |
java
|
train-ticket
|
train-ticket-master/ts-train-service/src/test/java/train/service/TrainServiceImplTest.java
|
package train.service;
import org.junit.Assert;
import org.junit.Before;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.junit.runners.JUnit4;
import org.mockito.InjectMocks;
import org.mockito.Mock;
import org.mockito.Mockito;
import org.mockito.MockitoAnnotations;
import org.springframework.http.HttpHeaders;
import train.entity.TrainType;
import train.repository.TrainTypeRepository;
@RunWith(JUnit4.class)
public class TrainServiceImplTest {
@InjectMocks
private TrainServiceImpl trainServiceImpl;
@Mock
private TrainTypeRepository repository;
private HttpHeaders headers = new HttpHeaders();
@Before
public void setUp() {
MockitoAnnotations.initMocks(this);
}
@Test
public void testCreate1() {
TrainType trainType = new TrainType();
Mockito.when(repository.findById(Mockito.anyString())).thenReturn(null);
Mockito.when(repository.save(Mockito.any(TrainType.class))).thenReturn(null);
boolean result = trainServiceImpl.create(trainType, headers);
Assert.assertTrue(result);
}
@Test
public void testCreate2() {
TrainType trainType = new TrainType();
Mockito.when(repository.findById(Mockito.anyString()).get()).thenReturn(trainType);
boolean result = trainServiceImpl.create(trainType, headers);
Assert.assertFalse(result);
}
@Test
public void testRetrieve1() {
Mockito.when(repository.findById(Mockito.anyString())).thenReturn(null);
TrainType result = trainServiceImpl.retrieve("id", headers);
Assert.assertNull(result);
}
@Test
public void testRetrieve2() {
TrainType trainType = new TrainType();
Mockito.when(repository.findById(Mockito.anyString()).get()).thenReturn(trainType);
TrainType result = trainServiceImpl.retrieve("id", headers);
Assert.assertNotNull(result);
}
@Test
public void testUpdate1() {
TrainType trainType = new TrainType();
Mockito.when(repository.findById(Mockito.anyString()).get()).thenReturn(trainType);
Mockito.when(repository.save(Mockito.any(TrainType.class))).thenReturn(null);
boolean result = trainServiceImpl.update(trainType, headers);
Assert.assertTrue(result);
}
@Test
public void testUpdate2() {
TrainType trainType = new TrainType();
Mockito.when(repository.findById(Mockito.anyString())).thenReturn(null);
boolean result = trainServiceImpl.update(trainType, headers);
Assert.assertFalse(result);
}
@Test
public void testDelete1() {
TrainType trainType = new TrainType();
Mockito.when(repository.findById(Mockito.anyString()).get()).thenReturn(trainType);
Mockito.doNothing().doThrow(new RuntimeException()).when(repository).deleteById(Mockito.anyString());
boolean result = trainServiceImpl.delete("id", headers);
Assert.assertTrue(result);
}
@Test
public void testDelete2() {
Mockito.when(repository.findById(Mockito.anyString())).thenReturn(null);
boolean result = trainServiceImpl.delete("id", headers);
Assert.assertFalse(result);
}
@Test
public void testQuery() {
Mockito.when(repository.findAll()).thenReturn(null);
Assert.assertNull(trainServiceImpl.query(headers));
}
}
| 3,388 | 31.586538 | 109 |
java
|
train-ticket
|
train-ticket-master/ts-travel-plan-service/src/main/java/travelplan/TravelPlanApplication.java
|
package travelplan;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.boot.web.client.RestTemplateBuilder;
import org.springframework.cloud.client.discovery.EnableDiscoveryClient;
import org.springframework.cloud.client.loadbalancer.LoadBalanced;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.EnableAspectJAutoProxy;
import org.springframework.integration.annotation.IntegrationComponentScan;
import org.springframework.scheduling.annotation.EnableAsync;
import org.springframework.web.client.RestTemplate;
import springfox.documentation.swagger2.annotations.EnableSwagger2;
/**
* @author fdse
*/
@SpringBootApplication
@EnableAspectJAutoProxy(proxyTargetClass = true)
@EnableAsync
@IntegrationComponentScan
@EnableSwagger2
@EnableDiscoveryClient
public class TravelPlanApplication {
public static void main(String[] args) {
SpringApplication.run(TravelPlanApplication.class, args);
}
@LoadBalanced
@Bean
public RestTemplate restTemplate(RestTemplateBuilder builder) {
return builder.build();
}
}
| 1,191 | 33.057143 | 75 |
java
|
train-ticket
|
train-ticket-master/ts-travel-plan-service/src/main/java/travelplan/config/SecurityConfig.java
|
package travelplan.config;
import edu.fudan.common.security.jwt.JWTFilter;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.security.config.annotation.method.configuration.EnableGlobalMethodSecurity;
import org.springframework.security.config.annotation.web.builders.HttpSecurity;
import org.springframework.security.config.annotation.web.configuration.EnableWebSecurity;
import org.springframework.security.config.annotation.web.configuration.WebSecurityConfigurerAdapter;
import org.springframework.security.config.http.SessionCreationPolicy;
import org.springframework.security.crypto.bcrypt.BCryptPasswordEncoder;
import org.springframework.security.crypto.password.PasswordEncoder;
import org.springframework.security.web.authentication.UsernamePasswordAuthenticationFilter;
import org.springframework.web.servlet.config.annotation.CorsRegistry;
import org.springframework.web.servlet.config.annotation.WebMvcConfigurer;
import org.springframework.web.servlet.config.annotation.WebMvcConfigurerAdapter;
import static org.springframework.web.cors.CorsConfiguration.ALL;
/**
* @author fdse
*/
@Configuration
@EnableWebSecurity
@EnableGlobalMethodSecurity(prePostEnabled = true)
public class SecurityConfig extends WebSecurityConfigurerAdapter {
/**
* load password encoder
*
* @return PasswordEncoder
*/
@Bean
public PasswordEncoder passwordEncoder() {
return new BCryptPasswordEncoder();
}
/**
* allow cors domain
* header By default, only six fields can be taken from the header, and the other fields can only be specified in the header.
* credentials Cookies are not sent by default and can only be true if a Cookie is needed
* Validity of this request
*
* @return WebMvcConfigurer
*/
@Bean
public WebMvcConfigurer corsConfigurer() {
return new WebMvcConfigurerAdapter() {
@Override
public void addCorsMappings(CorsRegistry registry) {
registry.addMapping("/**")
.allowedOrigins(ALL)
.allowedMethods(ALL)
.allowedHeaders(ALL)
.allowCredentials(false)
.maxAge(3600);
}
};
}
@Override
protected void configure(HttpSecurity httpSecurity) throws Exception {
httpSecurity.httpBasic().disable()
// close default csrf
.csrf().disable()
// close session
.sessionManagement().sessionCreationPolicy(SessionCreationPolicy.STATELESS)
.and()
.authorizeRequests()
.antMatchers("/api/v1/travelplanservice/**").permitAll()
.antMatchers("/swagger-ui.html", "/webjars/**", "/images/**",
"/configuration/**", "/swagger-resources/**", "/v2/**").permitAll()
.anyRequest().authenticated()
.and()
.addFilterBefore(new JWTFilter(), UsernamePasswordAuthenticationFilter.class);
// close cache
httpSecurity.headers().cacheControl();
}
}
| 3,240 | 38.52439 | 130 |
java
|
train-ticket
|
train-ticket-master/ts-travel-plan-service/src/main/java/travelplan/controller/TravelPlanController.java
|
package travelplan.controller;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.http.HttpEntity;
import org.springframework.http.HttpHeaders;
import org.springframework.web.bind.annotation.*;
import edu.fudan.common.entity.TripInfo;
import travelplan.entity.TransferTravelInfo;
import travelplan.service.TravelPlanService;
import static org.springframework.http.ResponseEntity.ok;
/**
* @author fdse
*/
@RestController
@RequestMapping("api/v1/travelplanservice")
public class TravelPlanController {
@Autowired
TravelPlanService travelPlanService;
private static final Logger LOGGER = LoggerFactory.getLogger(TravelPlanController.class);
@GetMapping(path = "/welcome" )
public String home() {
return "Welcome to [ TravelPlan Service ] !";
}
@PostMapping(value="/travelPlan/transferResult" )
public HttpEntity getTransferResult(@RequestBody TransferTravelInfo info, @RequestHeader HttpHeaders headers) {
TravelPlanController.LOGGER.info("[getTransferSearch][Search Transit][start: {},end: {}]",info.getStartStation(),info.getEndStation());
return ok(travelPlanService.getTransferSearch(info, headers));
}
@PostMapping(value="/travelPlan/cheapest")
public HttpEntity getByCheapest(@RequestBody TripInfo queryInfo, @RequestHeader HttpHeaders headers) {
TravelPlanController.LOGGER.info("[getCheapest][Search Cheapest][start: {},end: {},time: {}]",queryInfo.getStartPlace(),queryInfo.getEndPlace(),queryInfo.getDepartureTime());
return ok(travelPlanService.getCheapest(queryInfo, headers));
}
@PostMapping(value="/travelPlan/quickest")
public HttpEntity getByQuickest(@RequestBody TripInfo queryInfo, @RequestHeader HttpHeaders headers) {
TravelPlanController.LOGGER.info("[getQuickest][Search Quickest][start: {},end: {},time: {}]",queryInfo.getStartPlace(),queryInfo.getEndPlace(),queryInfo.getDepartureTime());
return ok(travelPlanService.getQuickest(queryInfo, headers));
}
@PostMapping(value="/travelPlan/minStation")
public HttpEntity getByMinStation(@RequestBody TripInfo queryInfo, @RequestHeader HttpHeaders headers) {
TravelPlanController.LOGGER.info("[getMinStation][Search Min Station][start: {},end: {},time: {}]",queryInfo.getStartPlace(),queryInfo.getEndPlace(),queryInfo.getDepartureTime());
return ok(travelPlanService.getMinStation(queryInfo, headers));
}
}
| 2,526 | 43.333333 | 187 |
java
|
train-ticket
|
train-ticket-master/ts-travel-plan-service/src/main/java/travelplan/entity/TransferTravelInfo.java
|
package travelplan.entity;
import edu.fudan.common.util.StringUtils;
import lombok.Data;
import java.util.Date;
/**
* @author fdse
*/
@Data
public class TransferTravelInfo {
private String startStation;
private String viaStation;
private String endStation;
private String travelDate;
private String trainType;
public TransferTravelInfo() {
//Empty Constructor
}
public TransferTravelInfo(String startStation, String viaStation, String endStation, String travelDate, String trainType) {
this.startStation = startStation;
this.viaStation = viaStation;
this.endStation = endStation;
this.travelDate = travelDate;
this.trainType = trainType;
}
public Date getTravelDate() {
return StringUtils.String2Date(travelDate);
}
}
| 831 | 19.8 | 127 |
java
|
train-ticket
|
train-ticket-master/ts-travel-plan-service/src/main/java/travelplan/entity/TransferTravelResult.java
|
package travelplan.entity;
import edu.fudan.common.entity.TripResponse;
import lombok.Data;
import edu.fudan.common.entity.TripResponse;
import java.util.List;
/**
* @author fdse
*/
@Data
public class TransferTravelResult {
private List<TripResponse> firstSectionResult;
private List<TripResponse> secondSectionResult;
public TransferTravelResult() {
//Default Constructor
}
public TransferTravelResult(List<TripResponse> firstSectionResult, List<TripResponse> secondSectionResult) {
this.firstSectionResult = firstSectionResult;
this.secondSectionResult = secondSectionResult;
}
}
| 641 | 20.4 | 112 |
java
|
train-ticket
|
train-ticket-master/ts-travel-plan-service/src/main/java/travelplan/entity/TravelAdvanceResultUnit.java
|
package travelplan.entity;
import lombok.Data;
import java.util.Date;
import java.util.List;
/**
* @author fdse
*/
@Data
public class TravelAdvanceResultUnit {
private String tripId;
private String trainTypeId;
private String startStation;
private String endStation;
private List<String> stopStations;
private String priceForSecondClassSeat;
private int numberOfRestTicketSecondClass;
private String priceForFirstClassSeat;
private int numberOfRestTicketFirstClass;
private String startTime;
private String endTime;
public TravelAdvanceResultUnit() {
//Default Constructor
}
}
| 655 | 15 | 46 |
java
|
train-ticket
|
train-ticket-master/ts-travel-plan-service/src/main/java/travelplan/service/TravelPlanService.java
|
package travelplan.service;
import edu.fudan.common.util.Response;
import org.springframework.http.HttpHeaders;
import edu.fudan.common.entity.*;
import travelplan.entity.TransferTravelInfo;
/**
* @author fdse
*/
public interface TravelPlanService {
Response getTransferSearch(TransferTravelInfo info, HttpHeaders headers);
Response getCheapest(TripInfo info, HttpHeaders headers);
Response getQuickest(TripInfo info, HttpHeaders headers);
Response getMinStation(TripInfo info, HttpHeaders headers);
}
| 527 | 23 | 77 |
java
|
train-ticket
|
train-ticket-master/ts-travel-plan-service/src/main/java/travelplan/service/TravelPlanServiceImpl.java
|
package travelplan.service;
import edu.fudan.common.util.JsonUtils;
import edu.fudan.common.util.Response;
import edu.fudan.common.util.StringUtils;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.cloud.client.ServiceInstance;
import org.springframework.cloud.client.discovery.DiscoveryClient;
import org.springframework.core.ParameterizedTypeReference;
import org.springframework.http.HttpEntity;
import org.springframework.http.HttpHeaders;
import org.springframework.http.HttpMethod;
import org.springframework.http.ResponseEntity;
import org.springframework.stereotype.Service;
import org.springframework.web.client.RestTemplate;
import edu.fudan.common.entity.*;
import travelplan.entity.TransferTravelInfo;
import travelplan.entity.TransferTravelResult;
import travelplan.entity.TravelAdvanceResultUnit;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Date;
import java.util.List;
/**
* @author fdse
*/
@Service
public class TravelPlanServiceImpl implements TravelPlanService {
@Autowired
private RestTemplate restTemplate;
@Autowired
private DiscoveryClient discoveryClient;
private static final Logger LOGGER = LoggerFactory.getLogger(TravelPlanServiceImpl.class);
String success = "Success";
String cannotFind = "Cannot Find";
private String getServiceUrl(String serviceName) {
return "http://" + serviceName;
}
@Override
public Response getTransferSearch(TransferTravelInfo info, HttpHeaders headers) {
TripInfo queryInfoFirstSection = new TripInfo();
queryInfoFirstSection.setDepartureTime(StringUtils.Date2String(info.getTravelDate()));
queryInfoFirstSection.setStartPlace(info.getStartStation());
queryInfoFirstSection.setEndPlace(info.getViaStation());
List<TripResponse> firstSectionFromHighSpeed;
List<TripResponse> firstSectionFromNormal;
firstSectionFromHighSpeed = tripsFromHighSpeed(queryInfoFirstSection, headers);
firstSectionFromNormal = tripsFromNormal(queryInfoFirstSection, headers);
TripInfo queryInfoSecondSectoin = new TripInfo();
queryInfoSecondSectoin.setDepartureTime(StringUtils.Date2String(info.getTravelDate()));
queryInfoSecondSectoin.setStartPlace(info.getViaStation());
queryInfoSecondSectoin.setEndPlace(info.getEndStation());
List<TripResponse> secondSectionFromHighSpeed;
List<TripResponse> secondSectionFromNormal;
secondSectionFromHighSpeed = tripsFromHighSpeed(queryInfoSecondSectoin, headers);
secondSectionFromNormal = tripsFromNormal(queryInfoSecondSectoin, headers);
List<TripResponse> firstSection = new ArrayList<>();
firstSection.addAll(firstSectionFromHighSpeed);
firstSection.addAll(firstSectionFromNormal);
List<TripResponse> secondSection = new ArrayList<>();
secondSection.addAll(secondSectionFromHighSpeed);
secondSection.addAll(secondSectionFromNormal);
TransferTravelResult result = new TransferTravelResult();
result.setFirstSectionResult(firstSection);
result.setSecondSectionResult(secondSection);
return new Response<>(1, "Success.", result);
}
@Override
public Response getCheapest(TripInfo info, HttpHeaders headers) {
RoutePlanInfo routePlanInfo = new RoutePlanInfo();
routePlanInfo.setNum(5);
routePlanInfo.setStartStation(info.getStartPlace());
routePlanInfo.setEndStation(info.getEndPlace());
routePlanInfo.setTravelDate(info.getDepartureTime());
ArrayList<RoutePlanResultUnit> routePlanResultUnits = getRoutePlanResultCheapest(routePlanInfo, headers);
if (!routePlanResultUnits.isEmpty()) {
ArrayList<TravelAdvanceResultUnit> lists = new ArrayList<>();
for (int i = 0; i < routePlanResultUnits.size(); i++) {
RoutePlanResultUnit tempUnit = routePlanResultUnits.get(i);
TravelAdvanceResultUnit newUnit = new TravelAdvanceResultUnit();
newUnit.setTripId(tempUnit.getTripId());
newUnit.setEndStation(tempUnit.getEndStation());
newUnit.setTrainTypeId(tempUnit.getTrainTypeName());
newUnit.setStartStation(tempUnit.getStartStation());
List<String> stops = tempUnit.getStopStations();
newUnit.setStopStations(stops);
newUnit.setPriceForFirstClassSeat(tempUnit.getPriceForFirstClassSeat());
newUnit.setPriceForSecondClassSeat(tempUnit.getPriceForSecondClassSeat());
newUnit.setStartTime(tempUnit.getStartTime());
newUnit.setEndTime(tempUnit.getEndTime());
TrainType trainType = queryTrainTypeByName(tempUnit.getTrainTypeName(), headers);
int firstClassTotalNum = trainType.getConfortClass();
int secondClassTotalNum = trainType.getEconomyClass();
int first = getRestTicketNumber(info.getDepartureTime(), tempUnit.getTripId(),
tempUnit.getStartStation(), tempUnit.getEndStation(), SeatClass.FIRSTCLASS.getCode(), firstClassTotalNum, tempUnit.getStopStations(), headers);
int second = getRestTicketNumber(info.getDepartureTime(), tempUnit.getTripId(),
tempUnit.getStartStation(), tempUnit.getEndStation(), SeatClass.SECONDCLASS.getCode(), secondClassTotalNum, tempUnit.getStopStations(), headers);
newUnit.setNumberOfRestTicketFirstClass(first);
newUnit.setNumberOfRestTicketSecondClass(second);
lists.add(newUnit);
}
return new Response<>(1, success, lists);
} else {
TravelPlanServiceImpl.LOGGER.warn("[getCheapest][Get cheapest trip warn][Route Plan Result Units: {}]","No Content");
return new Response<>(0, cannotFind, null);
}
}
@Override
public Response getQuickest(TripInfo info, HttpHeaders headers) {
RoutePlanInfo routePlanInfo = new RoutePlanInfo();
routePlanInfo.setNum(5);
routePlanInfo.setStartStation(info.getStartPlace());
routePlanInfo.setEndStation(info.getEndPlace());
routePlanInfo.setTravelDate(info.getDepartureTime());
ArrayList<RoutePlanResultUnit> routePlanResultUnits = getRoutePlanResultQuickest(routePlanInfo, headers);
if (!routePlanResultUnits.isEmpty()) {
ArrayList<TravelAdvanceResultUnit> lists = new ArrayList<>();
for (int i = 0; i < routePlanResultUnits.size(); i++) {
RoutePlanResultUnit tempUnit = routePlanResultUnits.get(i);
TravelAdvanceResultUnit newUnit = new TravelAdvanceResultUnit();
newUnit.setTripId(tempUnit.getTripId());
newUnit.setTrainTypeId(tempUnit.getTrainTypeName());
newUnit.setEndStation(tempUnit.getEndStation());
newUnit.setStartStation(tempUnit.getStartStation());
List<String> stops = tempUnit.getStopStations();
newUnit.setStopStations(stops);
newUnit.setPriceForFirstClassSeat(tempUnit.getPriceForFirstClassSeat());
newUnit.setPriceForSecondClassSeat(tempUnit.getPriceForSecondClassSeat());
newUnit.setStartTime(tempUnit.getStartTime());
newUnit.setEndTime(tempUnit.getEndTime());
TrainType trainType = queryTrainTypeByName(tempUnit.getTrainTypeName(), headers);
int firstClassTotalNum = trainType.getConfortClass();
int secondClassTotalNum = trainType.getEconomyClass();
int first = getRestTicketNumber(info.getDepartureTime(), tempUnit.getTripId(),
tempUnit.getStartStation(), tempUnit.getEndStation(), SeatClass.FIRSTCLASS.getCode(), firstClassTotalNum, tempUnit.getStopStations(), headers);
int second = getRestTicketNumber(info.getDepartureTime(), tempUnit.getTripId(),
tempUnit.getStartStation(), tempUnit.getEndStation(), SeatClass.SECONDCLASS.getCode(), secondClassTotalNum, tempUnit.getStopStations(),headers);
newUnit.setNumberOfRestTicketFirstClass(first);
newUnit.setNumberOfRestTicketSecondClass(second);
lists.add(newUnit);
}
return new Response<>(1, success, lists);
} else {
TravelPlanServiceImpl.LOGGER.warn("[getQuickest][Get quickest trip warn][Route Plan Result Units: {}]","No Content");
return new Response<>(0, cannotFind, null);
}
}
@Override
public Response getMinStation(TripInfo info, HttpHeaders headers) {
RoutePlanInfo routePlanInfo = new RoutePlanInfo();
routePlanInfo.setNum(5);
routePlanInfo.setStartStation(info.getStartPlace());
routePlanInfo.setEndStation(info.getEndPlace());
routePlanInfo.setTravelDate(info.getDepartureTime());
ArrayList<RoutePlanResultUnit> routePlanResultUnits = getRoutePlanResultMinStation(routePlanInfo, headers);
if (!routePlanResultUnits.isEmpty()) {
ArrayList<TravelAdvanceResultUnit> lists = new ArrayList<>();
for (int i = 0; i < routePlanResultUnits.size(); i++) {
RoutePlanResultUnit tempUnit = routePlanResultUnits.get(i);
TravelAdvanceResultUnit newUnit = new TravelAdvanceResultUnit();
newUnit.setTripId(tempUnit.getTripId());
newUnit.setTrainTypeId(tempUnit.getTrainTypeName());
newUnit.setStartStation(tempUnit.getStartStation());
newUnit.setEndStation(tempUnit.getEndStation());
List<String> stops = tempUnit.getStopStations();
newUnit.setStopStations(stops);
newUnit.setPriceForFirstClassSeat(tempUnit.getPriceForFirstClassSeat());
newUnit.setPriceForSecondClassSeat(tempUnit.getPriceForSecondClassSeat());
newUnit.setEndTime(tempUnit.getEndTime());
newUnit.setStartTime(tempUnit.getStartTime());
TrainType trainType = queryTrainTypeByName(tempUnit.getTrainTypeName(), headers);
int firstClassTotalNum = trainType.getConfortClass();
int secondClassTotalNum = trainType.getEconomyClass();
int first = getRestTicketNumber(info.getDepartureTime(), tempUnit.getTripId(),
tempUnit.getStartStation(), tempUnit.getEndStation(), SeatClass.FIRSTCLASS.getCode(), firstClassTotalNum, tempUnit.getStopStations(), headers);
int second = getRestTicketNumber(info.getDepartureTime(), tempUnit.getTripId(),
tempUnit.getStartStation(), tempUnit.getEndStation(), SeatClass.SECONDCLASS.getCode(), secondClassTotalNum, tempUnit.getStopStations(), headers);
newUnit.setNumberOfRestTicketFirstClass(first);
newUnit.setNumberOfRestTicketSecondClass(second);
lists.add(newUnit);
}
return new Response<>(1, success, lists);
} else {
TravelPlanServiceImpl.LOGGER.warn("[getMinStation][Get min stations trip warn][Route Plan Result Units: {}]","No Content");
return new Response<>(0, cannotFind, null);
}
}
private int getRestTicketNumber(String travelDate, String trainNumber, String startStationName, String endStationName, int seatType, int totalNum, List<String> stations, HttpHeaders headers) {
Seat seatRequest = new Seat();
seatRequest.setDestStation(startStationName);
seatRequest.setStartStation(endStationName);
seatRequest.setTrainNumber(trainNumber);
seatRequest.setTravelDate(travelDate);
seatRequest.setSeatType(seatType);
seatRequest.setStations(stations);
seatRequest.setTotalNum(totalNum);
TravelPlanServiceImpl.LOGGER.info("[getRestTicketNumber][Seat Request][Seat Request is: {}]", seatRequest.toString());
HttpEntity requestEntity = new HttpEntity(seatRequest, null);
String seat_service_url = getServiceUrl("ts-seat-service");
ResponseEntity<Response<Integer>> re = restTemplate.exchange(
seat_service_url + "/api/v1/seatservice/seats/left_tickets",
HttpMethod.POST,
requestEntity,
new ParameterizedTypeReference<Response<Integer>>() {
});
return re.getBody().getData();
}
private ArrayList<RoutePlanResultUnit> getRoutePlanResultCheapest(RoutePlanInfo info, HttpHeaders headers) {
HttpEntity requestEntity = new HttpEntity(info, null);
String route_plan_service_url = getServiceUrl("ts-route-plan-service");
ResponseEntity<Response<ArrayList<RoutePlanResultUnit>>> re = restTemplate.exchange(
route_plan_service_url + "/api/v1/routeplanservice/routePlan/cheapestRoute",
HttpMethod.POST,
requestEntity,
new ParameterizedTypeReference<Response<ArrayList<RoutePlanResultUnit>>>() {
});
return re.getBody().getData();
}
private ArrayList<RoutePlanResultUnit> getRoutePlanResultQuickest(RoutePlanInfo info, HttpHeaders headers) {
HttpEntity requestEntity = new HttpEntity(info, null);
String route_plan_service_url = getServiceUrl("ts-route-plan-service");
ResponseEntity<Response<ArrayList<RoutePlanResultUnit>>> re = restTemplate.exchange(
route_plan_service_url + "/api/v1/routeplanservice/routePlan/quickestRoute",
HttpMethod.POST,
requestEntity,
new ParameterizedTypeReference<Response<ArrayList<RoutePlanResultUnit>>>() {
});
return re.getBody().getData();
}
private ArrayList<RoutePlanResultUnit> getRoutePlanResultMinStation(RoutePlanInfo info, HttpHeaders headers) {
HttpEntity requestEntity = new HttpEntity(info, null);
String route_plan_service_url = getServiceUrl("ts-route-plan-service");
ResponseEntity<Response<ArrayList<RoutePlanResultUnit>>> re = restTemplate.exchange(
route_plan_service_url + "/api/v1/routeplanservice/routePlan/minStopStations",
HttpMethod.POST,
requestEntity,
new ParameterizedTypeReference<Response<ArrayList<RoutePlanResultUnit>>>() {
});
return re.getBody().getData();
}
private List<TripResponse> tripsFromHighSpeed(TripInfo info, HttpHeaders headers) {
HttpEntity requestEntity = new HttpEntity(info, null);
String travel_service_url=getServiceUrl("ts-travel-service");
ResponseEntity<Response<List<TripResponse>>> re = restTemplate.exchange(
travel_service_url + "/api/v1/travelservice/trips/left",
HttpMethod.POST,
requestEntity,
new ParameterizedTypeReference<Response<List<TripResponse>>>() {
});
return re.getBody().getData();
}
private ArrayList<TripResponse> tripsFromNormal(TripInfo info, HttpHeaders headers) {
HttpEntity requestEntity = new HttpEntity(info, null);
String travel2_service_url=getServiceUrl("ts-travel2-service");
ResponseEntity<Response<ArrayList<TripResponse>>> re = restTemplate.exchange(
travel2_service_url + "/api/v1/travel2service/trips/left",
HttpMethod.POST,
requestEntity,
new ParameterizedTypeReference<Response<ArrayList<TripResponse>>>() {
});
return re.getBody().getData();
}
public TrainType queryTrainTypeByName(String trainTypeName, HttpHeaders headers) {
HttpEntity requestEntity = new HttpEntity(null);
String train_service_url=getServiceUrl("ts-train-service");
ResponseEntity<Response> re = restTemplate.exchange(
train_service_url + "/api/v1/trainservice/trains/byName/" + trainTypeName,
HttpMethod.GET,
requestEntity,
Response.class);
Response response = re.getBody();
return JsonUtils.conveterObject(response.getData(), TrainType.class);
}
}
| 16,503 | 48.861027 | 196 |
java
|
train-ticket
|
train-ticket-master/ts-travel-plan-service/src/test/java/travelplan/controller/TravelPlanControllerTest.java
|
package travelplan.controller;
import com.alibaba.fastjson.JSONObject;
import edu.fudan.common.util.Response;
import org.junit.Assert;
import org.junit.Before;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.junit.runners.JUnit4;
import org.mockito.InjectMocks;
import org.mockito.Mock;
import org.mockito.Mockito;
import org.mockito.MockitoAnnotations;
import org.springframework.http.*;
import org.springframework.test.web.servlet.MockMvc;
import org.springframework.test.web.servlet.request.MockMvcRequestBuilders;
import org.springframework.test.web.servlet.result.MockMvcResultMatchers;
import org.springframework.test.web.servlet.setup.MockMvcBuilders;
import travelplan.entity.TransferTravelInfo;
import edu.fudan.common.entity.TripInfo;
import travelplan.service.TravelPlanService;
@RunWith(JUnit4.class)
public class TravelPlanControllerTest {
@InjectMocks
private TravelPlanController travelPlanController;
@Mock
private TravelPlanService travelPlanService;
private MockMvc mockMvc;
private Response response = new Response();
@Before
public void setUp() {
MockitoAnnotations.initMocks(this);
mockMvc = MockMvcBuilders.standaloneSetup(travelPlanController).build();
}
@Test
public void testHome() throws Exception {
mockMvc.perform(MockMvcRequestBuilders.get("/api/v1/travelplanservice/welcome"))
.andExpect(MockMvcResultMatchers.status().isOk())
.andExpect(MockMvcResultMatchers.content().string("Welcome to [ TravelPlan Service ] !"));
}
@Test
public void testGetTransferResult() throws Exception {
TransferTravelInfo info = new TransferTravelInfo();
Mockito.when(travelPlanService.getTransferSearch(Mockito.any(TransferTravelInfo.class), Mockito.any(HttpHeaders.class))).thenReturn(response);
String requestJson = JSONObject.toJSONString(info);
String result = mockMvc.perform(MockMvcRequestBuilders.post("/api/v1/travelplanservice/travelPlan/transferResult").contentType(MediaType.APPLICATION_JSON).content(requestJson))
.andExpect(MockMvcResultMatchers.status().isOk())
.andReturn().getResponse().getContentAsString();
Assert.assertEquals(response, JSONObject.parseObject(result, Response.class));
}
@Test
public void testGetByCheapest() throws Exception {
TripInfo queryInfo = new TripInfo();
Mockito.when(travelPlanService.getCheapest(Mockito.any(TripInfo.class), Mockito.any(HttpHeaders.class))).thenReturn(response);
String requestJson = JSONObject.toJSONString(queryInfo);
String result = mockMvc.perform(MockMvcRequestBuilders.post("/api/v1/travelplanservice/travelPlan/cheapest").contentType(MediaType.APPLICATION_JSON).content(requestJson))
.andExpect(MockMvcResultMatchers.status().isOk())
.andReturn().getResponse().getContentAsString();
Assert.assertEquals(response, JSONObject.parseObject(result, Response.class));
}
@Test
public void testGetByQuickest() throws Exception {
TripInfo queryInfo = new TripInfo();
Mockito.when(travelPlanService.getQuickest(Mockito.any(TripInfo.class), Mockito.any(HttpHeaders.class))).thenReturn(response);
String requestJson = JSONObject.toJSONString(queryInfo);
String result = mockMvc.perform(MockMvcRequestBuilders.post("/api/v1/travelplanservice/travelPlan/quickest").contentType(MediaType.APPLICATION_JSON).content(requestJson))
.andExpect(MockMvcResultMatchers.status().isOk())
.andReturn().getResponse().getContentAsString();
Assert.assertEquals(response, JSONObject.parseObject(result, Response.class));
}
@Test
public void testGetByMinStation() throws Exception {
TripInfo queryInfo = new TripInfo();
Mockito.when(travelPlanService.getMinStation(Mockito.any(TripInfo.class), Mockito.any(HttpHeaders.class))).thenReturn(response);
String requestJson = JSONObject.toJSONString(queryInfo);
String result = mockMvc.perform(MockMvcRequestBuilders.post("/api/v1/travelplanservice/travelPlan/minStation").contentType(MediaType.APPLICATION_JSON).content(requestJson))
.andExpect(MockMvcResultMatchers.status().isOk())
.andReturn().getResponse().getContentAsString();
Assert.assertEquals(response, JSONObject.parseObject(result, Response.class));
}
}
| 4,480 | 47.706522 | 184 |
java
|
train-ticket
|
train-ticket-master/ts-travel-plan-service/src/test/java/travelplan/service/TravelPlanServiceImplTest.java
|
package travelplan.service;
import edu.fudan.common.util.Response;
import org.junit.Assert;
import org.junit.Before;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.junit.runners.JUnit4;
import org.mockito.InjectMocks;
import org.mockito.Mock;
import org.mockito.Mockito;
import org.mockito.MockitoAnnotations;
import org.springframework.core.ParameterizedTypeReference;
import org.springframework.http.*;
import org.springframework.web.client.RestTemplate;
import edu.fudan.common.entity.*;
import travelplan.entity.TransferTravelInfo;
import java.util.ArrayList;
import java.util.Date;
import java.util.List;
@RunWith(JUnit4.class)
public class TravelPlanServiceImplTest {
@InjectMocks
private TravelPlanServiceImpl travelPlanServiceImpl;
@Mock
private RestTemplate restTemplate;
private HttpHeaders headers = new HttpHeaders();
@Before
public void setUp() {
MockitoAnnotations.initMocks(this);
}
@Test
public void testGetTransferSearch() {
TransferTravelInfo info = new TransferTravelInfo("from_station", "", "to_station", "", "G");
//mock tripsFromHighSpeed() and tripsFromNormal()
List<TripResponse> tripResponseList = new ArrayList<>();
Response<List<TripResponse>> response1 = new Response<>(null, null, tripResponseList);
ResponseEntity<Response<List<TripResponse>>> re1 = new ResponseEntity<>(response1, HttpStatus.OK);
Mockito.when(restTemplate.exchange(
Mockito.anyString(),
Mockito.any(HttpMethod.class),
Mockito.any(HttpEntity.class),
Mockito.any(ParameterizedTypeReference.class)))
.thenReturn(re1);
Response result = travelPlanServiceImpl.getTransferSearch(info, headers);
Assert.assertEquals("Success.", result.getMsg());
}
@Test
public void testGetCheapest() {
TripInfo info = new TripInfo("start_station", "end_station", "");
//response for getRoutePlanResultCheapest()
RoutePlanResultUnit rpru = new RoutePlanResultUnit("trip_id", "type_id", "from_station", "to_station", new ArrayList<>(), "1.0", "2.0", "", "");
ArrayList<RoutePlanResultUnit> routePlanResultUnits = new ArrayList<RoutePlanResultUnit>(){{ add(rpru); }};
Response<ArrayList<RoutePlanResultUnit>> response1 = new Response<>(null, null, routePlanResultUnits);
ResponseEntity<Response<ArrayList<RoutePlanResultUnit>>> re1 = new ResponseEntity<>(response1, HttpStatus.OK);
//response for transferStationIdToStationName()
List<String> list = new ArrayList<>();
Response<List<String>> response2 = new Response<>(null, null, list);
ResponseEntity<Response<List<String>>> re2 = new ResponseEntity<>(response2, HttpStatus.OK);
//response for queryForStationId()
Response<String> response3 = new Response<>(null, null, "");
ResponseEntity<Response<String>> re3 = new ResponseEntity<>(response3, HttpStatus.OK);
//response for getRestTicketNumber()
Response<Integer> response4 = new Response<>(null, null, 0);
ResponseEntity<Response<Integer>> re4 = new ResponseEntity<>(response4, HttpStatus.OK);
Mockito.when(restTemplate.exchange(
Mockito.anyString(),
Mockito.any(HttpMethod.class),
Mockito.any(HttpEntity.class),
Mockito.any(ParameterizedTypeReference.class)))
.thenReturn(re1)
.thenReturn(re2)
.thenReturn(re3).thenReturn(re3).thenReturn(re4)
.thenReturn(re3).thenReturn(re3).thenReturn(re4);
Response result = travelPlanServiceImpl.getCheapest(info, headers);
Assert.assertEquals("Success", result.getMsg());
}
@Test
public void testGetQuickest() {
TripInfo info = new TripInfo("start_station", "end_station", "");
//response for getRoutePlanResultQuickest()
RoutePlanResultUnit rpru = new RoutePlanResultUnit("trip_id", "type_id", "from_station", "to_station", new ArrayList<>(), "1.0", "2.0", "", "");
ArrayList<RoutePlanResultUnit> routePlanResultUnits = new ArrayList<RoutePlanResultUnit>(){{ add(rpru); }};
Response<ArrayList<RoutePlanResultUnit>> response1 = new Response<>(null, null, routePlanResultUnits);
ResponseEntity<Response<ArrayList<RoutePlanResultUnit>>> re1 = new ResponseEntity<>(response1, HttpStatus.OK);
//response for transferStationIdToStationName()
List<String> list = new ArrayList<>();
Response<List<String>> response2 = new Response<>(null, null, list);
ResponseEntity<Response<List<String>>> re2 = new ResponseEntity<>(response2, HttpStatus.OK);
//response for queryForStationId()
Response<String> response3 = new Response<>(null, null, "");
ResponseEntity<Response<String>> re3 = new ResponseEntity<>(response3, HttpStatus.OK);
//response for getRestTicketNumber()
Response<Integer> response4 = new Response<>(null, null, 0);
ResponseEntity<Response<Integer>> re4 = new ResponseEntity<>(response4, HttpStatus.OK);
Mockito.when(restTemplate.exchange(
Mockito.anyString(),
Mockito.any(HttpMethod.class),
Mockito.any(HttpEntity.class),
Mockito.any(ParameterizedTypeReference.class)))
.thenReturn(re1)
.thenReturn(re2)
.thenReturn(re3).thenReturn(re3).thenReturn(re4)
.thenReturn(re3).thenReturn(re3).thenReturn(re4);
Response result = travelPlanServiceImpl.getQuickest(info, headers);
Assert.assertEquals("Success", result.getMsg());
}
@Test
public void testGetMinStation() {
TripInfo info = new TripInfo("start_station", "end_station", "");
//response for getRoutePlanResultMinStation()
RoutePlanResultUnit rpru = new RoutePlanResultUnit("trip_id", "type_id", "from_station", "to_station", new ArrayList<>(), "1.0", "2.0", "", "");
ArrayList<RoutePlanResultUnit> routePlanResultUnits = new ArrayList<RoutePlanResultUnit>(){{ add(rpru); }};
Response<ArrayList<RoutePlanResultUnit>> response1 = new Response<>(null, null, routePlanResultUnits);
ResponseEntity<Response<ArrayList<RoutePlanResultUnit>>> re1 = new ResponseEntity<>(response1, HttpStatus.OK);
//response for transferStationIdToStationName()
List<String> list = new ArrayList<>();
Response<List<String>> response2 = new Response<>(null, null, list);
ResponseEntity<Response<List<String>>> re2 = new ResponseEntity<>(response2, HttpStatus.OK);
//response for queryForStationId()
Response<String> response3 = new Response<>(null, null, "");
ResponseEntity<Response<String>> re3 = new ResponseEntity<>(response3, HttpStatus.OK);
//response for getRestTicketNumber()
Response<Integer> response4 = new Response<>(null, null, 0);
ResponseEntity<Response<Integer>> re4 = new ResponseEntity<>(response4, HttpStatus.OK);
Mockito.when(restTemplate.exchange(
Mockito.anyString(),
Mockito.any(HttpMethod.class),
Mockito.any(HttpEntity.class),
Mockito.any(ParameterizedTypeReference.class)))
.thenReturn(re1)
.thenReturn(re2)
.thenReturn(re3).thenReturn(re3).thenReturn(re4)
.thenReturn(re3).thenReturn(re3).thenReturn(re4);
Response result = travelPlanServiceImpl.getMinStation(info, headers);
Assert.assertEquals("Success", result.getMsg());
}
}
| 7,723 | 45.53012 | 152 |
java
|
train-ticket
|
train-ticket-master/ts-travel-service/src/main/java/travel/TravelApplication.java
|
package travel;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.boot.web.client.RestTemplateBuilder;
import org.springframework.cloud.client.discovery.EnableDiscoveryClient;
import org.springframework.cloud.client.loadbalancer.LoadBalanced;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.EnableAspectJAutoProxy;
import org.springframework.integration.annotation.IntegrationComponentScan;
import org.springframework.scheduling.annotation.EnableAsync;
import org.springframework.web.client.RestTemplate;
import springfox.documentation.swagger2.annotations.EnableSwagger2;
/**
* @author fdse
*/
@SpringBootApplication
@EnableAspectJAutoProxy(proxyTargetClass = true)
@EnableAsync
@IntegrationComponentScan
@EnableSwagger2
@EnableDiscoveryClient
public class TravelApplication {
public static void main(String[] args) {
SpringApplication.run(TravelApplication.class, args);
}
@LoadBalanced
@Bean
public RestTemplate restTemplate(RestTemplateBuilder builder) {
return builder.build();
}
}
| 1,180 | 31.805556 | 75 |
java
|
train-ticket
|
train-ticket-master/ts-travel-service/src/main/java/travel/config/SecurityConfig.java
|
package travel.config;
import edu.fudan.common.security.jwt.JWTFilter;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.http.HttpMethod;
import org.springframework.security.config.annotation.method.configuration.EnableGlobalMethodSecurity;
import org.springframework.security.config.annotation.web.builders.HttpSecurity;
import org.springframework.security.config.annotation.web.configuration.EnableWebSecurity;
import org.springframework.security.config.annotation.web.configuration.WebSecurityConfigurerAdapter;
import org.springframework.security.config.http.SessionCreationPolicy;
import org.springframework.security.crypto.bcrypt.BCryptPasswordEncoder;
import org.springframework.security.crypto.password.PasswordEncoder;
import org.springframework.security.web.authentication.UsernamePasswordAuthenticationFilter;
import org.springframework.web.servlet.config.annotation.CorsRegistry;
import org.springframework.web.servlet.config.annotation.WebMvcConfigurer;
import org.springframework.web.servlet.config.annotation.WebMvcConfigurerAdapter;
import static org.springframework.web.cors.CorsConfiguration.ALL;
/**
* @author fdse
*/
@Configuration
@EnableWebSecurity
@EnableGlobalMethodSecurity(prePostEnabled = true)
public class SecurityConfig extends WebSecurityConfigurerAdapter {
/**
* load password encoder
*
* @return PasswordEncoder
*/
@Bean
public PasswordEncoder passwordEncoder() {
return new BCryptPasswordEncoder();
}
/**
* allow cors domain
* header By default, only six fields can be taken from the header, and the other fields can only be specified in the header.
* credentials Cookies are not sent by default and can only be true if a Cookie is needed
* Validity of this request
*
* @return WebMvcConfigurer
*/
@Bean
public WebMvcConfigurer corsConfigurer() {
return new WebMvcConfigurerAdapter() {
@Override
public void addCorsMappings(CorsRegistry registry) {
registry.addMapping("/**")
.allowedOrigins(ALL)
.allowedMethods(ALL)
.allowedHeaders(ALL)
.allowCredentials(false)
.maxAge(3600);
}
};
}
@Override
protected void configure(HttpSecurity httpSecurity) throws Exception {
httpSecurity.httpBasic().disable()
// close default csrf
.csrf().disable()
// close session
.sessionManagement().sessionCreationPolicy(SessionCreationPolicy.STATELESS)
.and()
.authorizeRequests()
.antMatchers(HttpMethod.PUT, "/api/v1/travelservice/trips").hasAnyRole("ADMIN")
.antMatchers(HttpMethod.DELETE, "/api/v1/travelservice/trips/*").hasAnyRole("ADMIN")
.antMatchers("/api/v1/travelservice/**").permitAll()
.antMatchers("/swagger-ui.html", "/webjars/**", "/images/**",
"/configuration/**", "/swagger-resources/**", "/v2/**").permitAll()
.anyRequest().authenticated()
.and()
.addFilterBefore(new JWTFilter(), UsernamePasswordAuthenticationFilter.class);
// close cache
httpSecurity.headers().cacheControl();
}
}
| 3,474 | 39.406977 | 130 |
java
|
train-ticket
|
train-ticket-master/ts-travel-service/src/main/java/travel/controller/TravelController.java
|
package travel.controller;
import edu.fudan.common.entity.TravelInfo;
import edu.fudan.common.entity.TripAllDetailInfo;
import edu.fudan.common.entity.TripInfo;
import edu.fudan.common.entity.TripResponse;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.http.HttpEntity;
import org.springframework.http.HttpHeaders;
import org.springframework.http.HttpStatus;
import org.springframework.http.ResponseEntity;
import org.springframework.web.bind.annotation.*;
import edu.fudan.common.entity.TravelInfo;
import travel.entity.*;
import travel.service.TravelService;
import java.util.ArrayList;
import static org.springframework.http.ResponseEntity.ok;
/**
* @author fdse
*/
@RestController
@RequestMapping("/api/v1/travelservice")
public class TravelController {
@Autowired
private TravelService travelService;
private static final Logger LOGGER = LoggerFactory.getLogger(TravelController.class);
@GetMapping(path = "/welcome")
public String home(@RequestHeader HttpHeaders headers) {
return "Welcome to [ Travel Service ] !";
}
@GetMapping(value = "/train_types/{tripId}")
public HttpEntity getTrainTypeByTripId(@PathVariable String tripId,
@RequestHeader HttpHeaders headers) {
// TrainType
TravelController.LOGGER.info("[getTrainTypeByTripId][Get train Type by Trip id][TripId: {}]", tripId);
return ok(travelService.getTrainTypeByTripId(tripId, headers));
}
@GetMapping(value = "/routes/{tripId}")
public HttpEntity getRouteByTripId(@PathVariable String tripId,
@RequestHeader HttpHeaders headers) {
TravelController.LOGGER.info("[getRouteByTripId][Get Route By Trip ID][TripId: {}]", tripId);
//Route
return ok(travelService.getRouteByTripId(tripId, headers));
}
@PostMapping(value = "/trips/routes")
public HttpEntity getTripsByRouteId(@RequestBody ArrayList<String> routeIds,
@RequestHeader HttpHeaders headers) {
// ArrayList<ArrayList<Trip>>
TravelController.LOGGER.info("[getTripByRoute][Get Trips by Route ids][RouteIds: {}]", routeIds.size());
return ok(travelService.getTripByRoute(routeIds, headers));
}
@CrossOrigin(origins = "*")
@PostMapping(value = "/trips")
public HttpEntity<?> createTrip(@RequestBody TravelInfo routeIds, @RequestHeader HttpHeaders headers) {
// null
TravelController.LOGGER.info("[create][Create trip][TripId: {}]", routeIds.getTripId());
return new ResponseEntity<>(travelService.create(routeIds, headers), HttpStatus.CREATED);
}
/**
* Return Trip only, no left ticket information
*
* @param tripId trip id
* @param headers headers
* @return HttpEntity
*/
@CrossOrigin(origins = "*")
@GetMapping(value = "/trips/{tripId}")
public HttpEntity retrieve(@PathVariable String tripId, @RequestHeader HttpHeaders headers) {
// Trip
TravelController.LOGGER.info("[retrieve][Retrieve trip][TripId: {}]", tripId);
return ok(travelService.retrieve(tripId, headers));
}
@CrossOrigin(origins = "*")
@PutMapping(value = "/trips")
public HttpEntity updateTrip(@RequestBody TravelInfo info, @RequestHeader HttpHeaders headers) {
// Trip
TravelController.LOGGER.info("[update][Update trip][TripId: {}]", info.getTripId());
return ok(travelService.update(info, headers));
}
@CrossOrigin(origins = "*")
@DeleteMapping(value = "/trips/{tripId}")
public HttpEntity deleteTrip(@PathVariable String tripId, @RequestHeader HttpHeaders headers) {
// string
TravelController.LOGGER.info("[delete][Delete trip][TripId: {}]", tripId);
return ok(travelService.delete(tripId, headers));
}
/**
* Return Trips and the remaining tickets
*
* @param info trip info
* @param headers headers
* @return HttpEntity
*/
@CrossOrigin(origins = "*")
@PostMapping(value = "/trips/left")
public HttpEntity queryInfo(@RequestBody TripInfo info, @RequestHeader HttpHeaders headers) {
if (info.getStartPlace() == null || info.getStartPlace().length() == 0 ||
info.getEndPlace() == null || info.getEndPlace().length() == 0 ||
info.getDepartureTime() == null) {
TravelController.LOGGER.info("[query][Travel Query Fail][Something null]");
ArrayList<TripResponse> errorList = new ArrayList<>();
return ok(errorList);
}
TravelController.LOGGER.info("[query][Query TripResponse]");
return ok(travelService.queryByBatch(info, headers));
}
/**
* Return Trips and the remaining tickets
*
* @param info trip info
* @param headers headers
* @return HttpEntity
*/
@CrossOrigin(origins = "*")
@PostMapping(value = "/trips/left_parallel")
public HttpEntity queryInfoInparallel(@RequestBody TripInfo info, @RequestHeader HttpHeaders headers) {
if (info.getStartPlace() == null || info.getStartPlace().length() == 0 ||
info.getEndPlace() == null || info.getEndPlace().length() == 0 ||
info.getDepartureTime() == null) {
TravelController.LOGGER.info("[queryInParallel][Travel Query Fail][Something null]");
ArrayList<TripResponse> errorList = new ArrayList<>();
return ok(errorList);
}
TravelController.LOGGER.info("[queryInParallel][Query TripResponse]");
return ok(travelService.queryInParallel(info, headers));
}
/**
* Return a Trip and the remaining
*
* @param gtdi trip all detail info
* @param headers headers
* @return HttpEntity
*/
@CrossOrigin(origins = "*")
@PostMapping(value = "/trip_detail")
public HttpEntity getTripAllDetailInfo(@RequestBody TripAllDetailInfo gtdi, @RequestHeader HttpHeaders headers) {
// TripAllDetailInfo
// TripAllDetail tripAllDetail
TravelController.LOGGER.info("[getTripAllDetailInfo][Get trip detail][TripId: {}]", gtdi.getTripId());
return ok(travelService.getTripAllDetailInfo(gtdi, headers));
}
@CrossOrigin(origins = "*")
@GetMapping(value = "/trips")
public HttpEntity queryAll(@RequestHeader HttpHeaders headers) {
// List<Trip>
TravelController.LOGGER.info("[queryAll][Query all trips]");
return ok(travelService.queryAll(headers));
}
@CrossOrigin(origins = "*")
@GetMapping(value = "/admin_trip")
public HttpEntity adminQueryAll(@RequestHeader HttpHeaders headers) {
// ArrayList<AdminTrip>
TravelController.LOGGER.info("[adminQueryAll][Admin query all trips]");
return ok(travelService.adminQueryAll(headers));
}
}
| 6,986 | 37.816667 | 117 |
java
|
train-ticket
|
train-ticket-master/ts-travel-service/src/main/java/travel/entity/AdminTrip.java
|
package travel.entity;
import edu.fudan.common.entity.TrainType;
import edu.fudan.common.entity.Route;
import lombok.Data;
/**
* @author fdse
*/
@Data
public class AdminTrip {
private Trip trip;
private TrainType trainType;
private Route route;
public AdminTrip(){
//Default Constructor
}
}
| 326 | 13.863636 | 41 |
java
|
train-ticket
|
train-ticket-master/ts-travel-service/src/main/java/travel/entity/Travel.java
|
package travel.entity;
import edu.fudan.common.util.StringUtils;
import lombok.Data;
import travel.entity.Trip;
import java.util.Date;
/**
* @author fdse
*/
@Data
public class Travel {
private Trip trip;
private String startPlace;
private String endPlace;
private String departureTime;
public Travel(){
//Default Constructor
}
}
| 374 | 11.5 | 41 |
java
|
train-ticket
|
train-ticket-master/ts-travel-service/src/main/java/travel/entity/Trip.java
|
package travel.entity;
import edu.fudan.common.entity.TripId;
import edu.fudan.common.util.StringUtils;
import lombok.Data;
import org.hibernate.annotations.GenericGenerator;
import javax.persistence.*;
import javax.validation.Valid;
import javax.validation.constraints.NotNull;
import java.util.Date;
import java.util.UUID;
/**
* @author fdse
*/
@Data
@Entity
@GenericGenerator(name = "jpa-uuid", strategy = "org.hibernate.id.UUIDGenerator")
public class Trip {
@Valid
@Id
@GeneratedValue(generator = "jpa-uuid")
@Column(length = 36)
private String id;
@Embedded
private TripId tripId;
@Valid
@NotNull
private String trainTypeName;
private String routeId;
@Valid
@NotNull
private String startStationName;
@Valid
private String stationsName;
@Valid
@NotNull
private String terminalStationName;
@Valid
@NotNull
private String startTime;
@Valid
@NotNull
private String endTime;
public Trip(edu.fudan.common.entity.TripId tripId, String trainTypeName, String startStationName, String stationsName, String terminalStationName, String startTime, String endTime) {
this.tripId = tripId;
this.trainTypeName = trainTypeName;
this.startStationName = StringUtils.String2Lower(startStationName);
this.stationsName = StringUtils.String2Lower(stationsName);
this.terminalStationName = StringUtils.String2Lower(terminalStationName);
this.startTime = startTime;
this.endTime = endTime;
}
public Trip(TripId tripId, String trainTypeName, String routeId) {
this.tripId = tripId;
this.trainTypeName = trainTypeName;
this.routeId = routeId;
this.startStationName = "";
this.terminalStationName = "";
this.startTime = "";
this.endTime = "";
}
public Trip(){
//Default Constructor
this.trainTypeName = "";
this.startStationName = "";
this.terminalStationName = "";
this.startTime = "";
this.endTime = "";
}
}
| 2,090 | 23.313953 | 186 |
java
|
train-ticket
|
train-ticket-master/ts-travel-service/src/main/java/travel/entity/TripAllDetail.java
|
package travel.entity;
import edu.fudan.common.entity.TripResponse;
import lombok.Data;
import edu.fudan.common.entity.TripResponse;
/**
* @author fdse
*/
@Data
public class TripAllDetail {
private TripResponse tripResponse;
private Trip trip;
public TripAllDetail() {
}
public TripAllDetail(TripResponse tripResponse, Trip trip) {
this.tripResponse = tripResponse;
this.trip = trip;
}
}
| 437 | 15.846154 | 64 |
java
|
train-ticket
|
train-ticket-master/ts-travel-service/src/main/java/travel/init/InitData.java
|
package travel.init;
import edu.fudan.common.entity.TravelInfo;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.CommandLineRunner;
import org.springframework.stereotype.Component;
import travel.service.TravelService;
import java.util.Date;
/**
* @author fdse
*/
@Component
public class InitData implements CommandLineRunner{
@Autowired
TravelService service;
String gaoTieOne = "GaoTieOne";
String shanghai = "shanghai";
String suzhou = "suzhou";
String taiyuan = "taiyuan";
@Override
public void run(String... args)throws Exception{
TravelInfo info = new TravelInfo();
info.setTripId("G1234");
info.setTrainTypeName(gaoTieOne);
info.setRouteId("92708982-77af-4318-be25-57ccb0ff69ad");
info.setStartStationName(shanghai);
info.setStationsName(suzhou);
info.setTerminalStationName(taiyuan);
info.setStartTime("2013-05-04 09:00:00"); //NOSONAR
info.setEndTime("2013-05-04 15:51:52"); //NOSONAR
service.create(info,null);
info.setTripId("G1235");
info.setTrainTypeName(gaoTieOne);
info.setRouteId("aefcef3f-3f42-46e8-afd7-6cb2a928bd3d");
info.setStartStationName(shanghai);
info.setStationsName(suzhou);
info.setTerminalStationName(taiyuan);
info.setStartTime("2013-05-04 12:00:00"); //NOSONAR
info.setEndTime("2013-05-04 17:51:52"); //NOSONAR
service.create(info,null);
info.setTripId("G1236");
info.setTrainTypeName(gaoTieOne);
info.setRouteId("a3f256c1-0e43-4f7d-9c21-121bf258101f");
info.setStartStationName(shanghai);
info.setStationsName(suzhou);
info.setTerminalStationName(taiyuan);
info.setStartTime("2013-05-04 14:00:00"); //NOSONAR
info.setEndTime("2013-05-04 20:51:52"); //NOSONAR
service.create(info,null);
info.setTripId("G1237");
info.setTrainTypeName("GaoTieTwo");
info.setRouteId("084837bb-53c8-4438-87c8-0321a4d09917");
info.setStartStationName(shanghai);
info.setStationsName(suzhou);
info.setTerminalStationName(taiyuan);
info.setStartTime("2013-05-04 08:00:00"); //NOSONAR
info.setEndTime("2013-05-04 17:21:52"); //NOSONAR
service.create(info,null);
info.setTripId("D1345");
info.setTrainTypeName("DongCheOne");
info.setRouteId("f3d4d4ef-693b-4456-8eed-59c0d717dd08");
info.setStartStationName(shanghai);
info.setStationsName(suzhou);
info.setTerminalStationName(taiyuan);
info.setStartTime("2013-05-04 07:00:00"); //NOSONAR
info.setEndTime("2013-05-04 19:59:52"); //NOSONAR
service.create(info,null);
}
}
| 2,788 | 33.8625 | 64 |
java
|
train-ticket
|
train-ticket-master/ts-travel-service/src/main/java/travel/repository/TripRepository.java
|
package travel.repository;
import edu.fudan.common.entity.TripId;
import org.springframework.data.repository.CrudRepository;
import org.springframework.stereotype.Repository;
import travel.entity.Trip;
import java.util.ArrayList;
/**
* @author fdse
*/
@Repository
public interface TripRepository extends CrudRepository<Trip, TripId> {
Trip findByTripId(TripId tripId);
void deleteByTripId(TripId tripId);
@Override
ArrayList<Trip> findAll();
ArrayList<Trip> findByRouteId(String routeId);
}
| 519 | 20.666667 | 70 |
java
|
train-ticket
|
train-ticket-master/ts-travel-service/src/main/java/travel/service/TravelService.java
|
package travel.service;
import edu.fudan.common.entity.TravelInfo;
import edu.fudan.common.entity.TripAllDetailInfo;
import edu.fudan.common.entity.TripInfo;
import edu.fudan.common.util.Response;
import org.springframework.http.HttpHeaders;
import java.util.ArrayList;
/**
* @author Chenjie Xu
* @date 2017/5/9.
*/
public interface TravelService {
Response create(TravelInfo info, HttpHeaders headers);
Response retrieve(String tripId, HttpHeaders headers);
Response update(TravelInfo info, HttpHeaders headers);
Response delete(String tripId, HttpHeaders headers);
Response query(TripInfo info, HttpHeaders headers);
Response queryByBatch(TripInfo info, HttpHeaders headers);
Response queryInParallel(TripInfo info, HttpHeaders headers);
Response getTripAllDetailInfo(TripAllDetailInfo gtdi, HttpHeaders headers);
Response getRouteByTripId(String tripId, HttpHeaders headers);
Response getTrainTypeByTripId(String tripId, HttpHeaders headers);
Response queryAll(HttpHeaders headers);
Response getTripByRoute(ArrayList<String> routeIds, HttpHeaders headers);
Response adminQueryAll(HttpHeaders headers);
}
| 1,179 | 25.818182 | 79 |
java
|
train-ticket
|
train-ticket-master/ts-travel-service/src/main/java/travel/service/TravelServiceImpl.java
|
package travel.service;
import com.fasterxml.jackson.core.type.TypeReference;
import com.fasterxml.jackson.databind.ObjectMapper;
import edu.fudan.common.entity.*;
import edu.fudan.common.util.JsonUtils;
import edu.fudan.common.util.Response;
import edu.fudan.common.util.StringUtils;
import org.apache.skywalking.apm.toolkit.trace.TraceCrossThread;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.cloud.client.discovery.DiscoveryClient;
import org.springframework.core.ParameterizedTypeReference;
import org.springframework.http.HttpEntity;
import org.springframework.http.HttpHeaders;
import org.springframework.http.HttpMethod;
import org.springframework.http.ResponseEntity;
import org.springframework.scheduling.concurrent.CustomizableThreadFactory;
import org.springframework.stereotype.Service;
import org.springframework.web.client.RestTemplate;
import travel.entity.AdminTrip;
import travel.entity.Travel;
import travel.entity.Trip;
import travel.entity.TripAllDetail;
import travel.repository.TripRepository;
import javax.transaction.Transactional;
import java.util.*;
import java.util.concurrent.*;
/**
* @author fdse
*/
@Service
public class TravelServiceImpl implements TravelService {
@Autowired
private TripRepository repository;
@Autowired
private RestTemplate restTemplate;
@Autowired
private DiscoveryClient discoveryClient;
private static final Logger LOGGER = LoggerFactory.getLogger(TravelServiceImpl.class);
private static final ExecutorService executorService = Executors.newFixedThreadPool(20, new CustomizableThreadFactory("HttpClientThreadPool-"));
private String getServiceUrl(String serviceName) {
return "http://" + serviceName;
}
String success = "Success";
String noContent = "No Content";
@Override
public Response create(TravelInfo info, HttpHeaders headers) {
TripId ti = new TripId(info.getTripId());
if (repository.findByTripId(ti) == null) {
Trip trip = new Trip(ti, info.getTrainTypeName(), info.getStartStationName(),
info.getStationsName(), info.getTerminalStationName(), info.getStartTime(), info.getEndTime());
trip.setRouteId(info.getRouteId());
repository.save(trip);
return new Response<>(1, "Create trip:" + ti.toString() + ".", null);
} else {
TravelServiceImpl.LOGGER.error("[create][Create trip error][Trip already exists][TripId: {}]", info.getTripId());
return new Response<>(1, "Trip " + info.getTripId().toString() + " already exists", null);
}
}
@Override
public Response getRouteByTripId(String tripId, HttpHeaders headers) {
Route route = null;
if (null != tripId && tripId.length() >= 2) {
TripId tripId1 = new TripId(tripId);
Trip trip = repository.findByTripId(tripId1);
if (trip != null) {
route = getRouteByRouteId(trip.getRouteId(), headers);
} else {
TravelServiceImpl.LOGGER.error("[getRouteByTripId][Get route by Trip id error][Trip not found][TripId: {}]", tripId);
}
}
if (route != null) {
return new Response<>(1, success, route);
} else {
TravelServiceImpl.LOGGER.error("[getRouteByTripId][Get route by Trip id error][Route not found][TripId: {}]", tripId);
return new Response<>(0, noContent, null);
}
}
@Override
public Response getTrainTypeByTripId(String tripId, HttpHeaders headers) {
TripId tripId1 = new TripId(tripId);
TrainType trainType = null;
Trip trip = repository.findByTripId(tripId1);
if (trip != null) {
trainType = getTrainTypeByName(trip.getTrainTypeName(), headers);
} else {
TravelServiceImpl.LOGGER.error("[getTrainTypeByTripId][Get Train Type by Trip id error][Trip not found][TripId: {}]", tripId);
}
if (trainType != null) {
return new Response<>(1, success, trainType);
} else {
TravelServiceImpl.LOGGER.error("[getTrainTypeByTripId][Get Train Type by Trip id error][Train Type not found][TripId: {}]", tripId);
return new Response<>(0, noContent, null);
}
}
@Override
public Response getTripByRoute(ArrayList<String> routeIds, HttpHeaders headers) {
ArrayList<ArrayList<Trip>> tripList = new ArrayList<>();
for (String routeId : routeIds) {
ArrayList<Trip> tempTripList = repository.findByRouteId(routeId);
if (tempTripList == null) {
tempTripList = new ArrayList<>();
}
tripList.add(tempTripList);
}
if (!tripList.isEmpty()) {
return new Response<>(1, success, tripList);
} else {
TravelServiceImpl.LOGGER.warn("[getTripByRoute][Get trips by routes warn][Trip list][{}]", "No content");
return new Response<>(0, noContent, null);
}
}
@Override
public Response retrieve(String tripId, HttpHeaders headers) {
TripId ti = new TripId(tripId);
Trip trip = repository.findByTripId(ti);
if (trip != null) {
return new Response<>(1, "Search Trip Success by Trip Id " + tripId, trip);
} else {
TravelServiceImpl.LOGGER.error("[retrieve][Retrieve trip error][Trip not found][TripId: {}]", tripId);
return new Response<>(0, "No Content according to tripId" + tripId, null);
}
}
@Override
public Response update(TravelInfo info, HttpHeaders headers) {
TripId ti = new TripId(info.getTripId());
Trip t = repository.findByTripId(ti);
if (t != null) {
t.setStartStationName(info.getTrainTypeName());
t.setStartStationName( info.getStartStationName());
t.setStationsName(info.getStationsName());
t.setTerminalStationName(info.getTerminalStationName());
t.setStartTime(info.getStartTime());
t.setEndTime(info.getEndTime());
t.setRouteId(info.getRouteId());
repository.save(t);
return new Response<>(1, "Update trip:" + ti.toString(), t);
} else {
TravelServiceImpl.LOGGER.error("[update][Update trip error][Trip not found][TripId: {}]", info.getTripId());
return new Response<>(1, "Trip" + info.getTripId().toString() + "doesn 't exists", null);
}
}
@Override
@Transactional
public Response delete(String tripId, HttpHeaders headers) {
TripId ti = new TripId(tripId);
if (repository.findByTripId(ti) != null) {
repository.deleteByTripId(ti);
return new Response<>(1, "Delete trip:" + tripId + ".", tripId);
} else {
TravelServiceImpl.LOGGER.error("[delete][Delete trip error][Trip not found][TripId: {}]", tripId);
return new Response<>(0, "Trip " + tripId + " doesn't exist.", null);
}
}
@Override
public Response query(TripInfo info, HttpHeaders headers) {
//Gets the start and arrival stations of the train number to query. The originating and arriving stations received here are both station names, so two requests need to be sent to convert to station ids
String startPlaceName = info.getStartPlace();
String endPlaceName = info.getEndPlace();
//This is the final result
List<TripResponse> list = new ArrayList<>();
//Check all train info
List<Trip> allTripList = repository.findAll();
if(allTripList != null) {
for (Trip tempTrip : allTripList) {
//Get the detailed route list of this train
TripResponse response = getTickets(tempTrip, null, startPlaceName, endPlaceName, info.getDepartureTime(), headers);
if (response == null) {
TravelServiceImpl.LOGGER.warn("[query][Query trip error][Tickets not found][start: {},end: {},time: {}]", startPlaceName, endPlaceName, info.getDepartureTime());
}else{
list.add(response);
}
}
}
return new Response<>(1, success, list);
}
@Override
public Response queryByBatch(TripInfo info, HttpHeaders headers) {
//Gets the start and arrival stations of the train number to query. The originating and arriving stations received here are both station names, so two requests need to be sent to convert to station ids
String startPlaceName = info.getStartPlace();
String endPlaceName = info.getEndPlace();
//This is the final result
List<TripResponse> list = new ArrayList<>();
//Check all train info
List<Trip> allTripList = repository.findAll();
list = getTicketsByBatch(allTripList, startPlaceName, endPlaceName, info.getDepartureTime(), headers);
return new Response<>(1, success, list);
}
@TraceCrossThread
class MyCallable implements Callable<TripResponse> {
private TripInfo info;
private Trip tempTrip;
private HttpHeaders headers;
private String startPlaceName;
private String endPlaceName;
MyCallable(TripInfo info, String startPlaceName, String endPlaceName, Trip tempTrip, HttpHeaders headers) {
this.info = info;
this.tempTrip = tempTrip;
this.headers = headers;
this.startPlaceName = startPlaceName;
this.endPlaceName = endPlaceName;
}
@Override
public TripResponse call() throws Exception {
TravelServiceImpl.LOGGER.debug("[call][Start to query][tripId: {}, routeId: {}] ", tempTrip.getTripId().toString(), tempTrip.getRouteId());
String startPlaceName = info.getStartPlace();
String endPlaceName = info.getEndPlace();
//Route tempRoute = getRouteByRouteId(tempTrip.getRouteId(), headers);
TripResponse response = null;
response = getTickets(tempTrip, null, startPlaceName, endPlaceName, info.getDepartureTime(), headers);
if (response == null) {
TravelServiceImpl.LOGGER.warn("[call][Query trip error][Tickets not found][tripId: {}, routeId: {}, start: {}, end: {},time: {}]", tempTrip.getTripId().toString(), tempTrip.getRouteId(), startPlaceName, endPlaceName, info.getDepartureTime());
} else {
TravelServiceImpl.LOGGER.info("[call][Query trip success][tripId: {}, routeId: {}] ", tempTrip.getTripId().toString(), tempTrip.getRouteId());
}
return response;
}
}
@Override
public Response queryInParallel(TripInfo info, HttpHeaders headers) {
//Gets the start and arrival stations of the train number to query. The originating and arriving stations received here are both station names, so two requests need to be sent to convert to station ids
String startPlaceName = info.getStartPlace();
String endPlaceName = info.getEndPlace();
//This is the final result
List<TripResponse> list = new ArrayList<>();
//Check all train info
List<Trip> allTripList = repository.findAll();
List<Future<TripResponse>> futureList = new ArrayList<>();
if(allTripList != null ){
for (Trip tempTrip : allTripList) {
MyCallable callable = new MyCallable(info, startPlaceName, endPlaceName, tempTrip, headers);
Future<TripResponse> future = executorService.submit(callable);
futureList.add(future);
}
}
for (Future<TripResponse> future : futureList) {
try {
TripResponse response = future.get();
if (response != null) {
list.add(response);
}
} catch (Exception e) {
TravelServiceImpl.LOGGER.error("[queryInParallel][Query error]"+e.toString());
}
}
if (list.isEmpty()) {
return new Response<>(0, "No Trip info content", null);
} else {
return new Response<>(1, success, list);
}
}
@Override
public Response getTripAllDetailInfo(TripAllDetailInfo gtdi, HttpHeaders headers) {
TripAllDetail gtdr = new TripAllDetail();
TravelServiceImpl.LOGGER.debug("[getTripAllDetailInfo][TripId: {}]", gtdi.getTripId());
Trip trip = repository.findByTripId(new TripId(gtdi.getTripId()));
if (trip == null) {
gtdr.setTripResponse(null);
gtdr.setTrip(null);
TravelServiceImpl.LOGGER.error("[getTripAllDetailInfo][Get trip detail error][Trip not found][TripId: {}]", gtdi.getTripId());
return new Response<>(0, "Trip not found", gtdr);
} else {
String startPlaceName = gtdi.getFrom();
String endPlaceName = gtdi.getTo();
TripResponse tripResponse = getTickets(trip, null, startPlaceName, endPlaceName, gtdi.getTravelDate(), headers);
if (tripResponse == null) {
gtdr.setTripResponse(null);
gtdr.setTrip(null);
TravelServiceImpl.LOGGER.warn("[getTripAllDetailInfo][Get trip detail error][Tickets not found][start: {},end: {},time: {}]", startPlaceName, endPlaceName, gtdi.getTravelDate());
return new Response<>(0, "getTickets failed", gtdr);
} else {
gtdr.setTripResponse(tripResponse);
gtdr.setTrip(repository.findByTripId(new TripId(gtdi.getTripId())));
}
}
return new Response<>(1, success, gtdr);
}
private List<TripResponse> getTicketsByBatch(List<Trip> trips, String startPlaceName, String endPlaceName, String departureTime, HttpHeaders headers) {
List<TripResponse> responses = new ArrayList<>();
//Determine if the date checked is the same day and after
if (!afterToday(departureTime)) {
TravelServiceImpl.LOGGER.info("[getTickets][depaturetime not vailid][departuretime: {}]", departureTime);
return responses;
}
List<Travel> infos = new ArrayList<>();
Map<String, Trip> tripMap = new HashMap<>();
for(Trip trip: trips){
Travel query = new Travel();
query.setTrip(trip);
query.setStartPlace(startPlaceName);
query.setEndPlace(endPlaceName);
query.setDepartureTime(departureTime);
infos.add(query);
tripMap.put(trip.getTripId().toString(), trip);
}
TravelServiceImpl.LOGGER.info("[getTicketsByBatch][before get basic][trips: {}]", trips);
HttpEntity requestEntity = new HttpEntity(infos, null);
String basic_service_url = getServiceUrl("ts-basic-service");
ResponseEntity<Response> re = restTemplate.exchange(
basic_service_url + "/api/v1/basicservice/basic/travels",
HttpMethod.POST,
requestEntity,
Response.class);
Response r = re.getBody();
if(r.getStatus() == 0){
TravelServiceImpl.LOGGER.info("[getTicketsByBatch][Ts-basic-service response status is 0][response is: {}]", r);
return responses;
}
Map<String, TravelResult> trMap;
ObjectMapper mapper = new ObjectMapper();
try{
trMap = mapper.readValue(JsonUtils.object2Json(r.getData()), new TypeReference<Map<String, TravelResult>>(){});
}catch(Exception e) {
TravelServiceImpl.LOGGER.warn("[getTicketsByBatch][Ts-basic-service convert data failed][Fail msg: {}]", e.getMessage());
return responses;
}
for(Map.Entry<String, TravelResult> trEntry: trMap.entrySet()){
//Set the returned ticket information
String tripNumber = trEntry.getKey();
TravelResult tr = trEntry.getValue();
Trip trip = tripMap.get(tripNumber);
TripResponse response = setResponse(trip, tr, startPlaceName, endPlaceName, departureTime, headers);
responses.add(response);
}
return responses;
}
private TripResponse getTickets(Trip trip, Route route1, String startPlaceName, String endPlaceName, String departureTime, HttpHeaders headers) {
//Determine if the date checked is the same day and after
if (!afterToday(departureTime)) {
TravelServiceImpl.LOGGER.info("[getTickets][depaturetime not vailid][departuretime: {}]", departureTime);
return null;
}
Travel query = new Travel();
query.setTrip(trip);
query.setStartPlace(startPlaceName);
query.setEndPlace(endPlaceName);
query.setDepartureTime(departureTime);
TravelServiceImpl.LOGGER.info("[getTickets][before get basic][trip: {}]", trip);
HttpEntity requestEntity = new HttpEntity(query, null);
String basic_service_url = getServiceUrl("ts-basic-service");
ResponseEntity<Response> re = restTemplate.exchange(
basic_service_url + "/api/v1/basicservice/basic/travel",
HttpMethod.POST,
requestEntity,
Response.class);
Response r = re.getBody();
if(r.getStatus() == 0){
TravelServiceImpl.LOGGER.info("[getTickets][Ts-basic-service response status is 0][response is: {}]", r);
return null;
}
TravelResult resultForTravel = JsonUtils.conveterObject(re.getBody().getData(), TravelResult.class);
//Set the returned ticket information
return setResponse(trip, resultForTravel, startPlaceName, endPlaceName, departureTime, headers);
}
private TripResponse setResponse(Trip trip, TravelResult tr, String startPlaceName, String endPlaceName, String departureTime, HttpHeaders headers){
//Set the returned ticket information
TripResponse response = new TripResponse();
response.setConfortClass(50);
response.setEconomyClass(50);
Route route = tr.getRoute();
List<String> stationList = route.getStations();
int firstClassTotalNum = tr.getTrainType().getConfortClass();
int secondClassTotalNum = tr.getTrainType().getEconomyClass();
int first = getRestTicketNumber(departureTime, trip.getTripId().toString(),
startPlaceName, endPlaceName, SeatClass.FIRSTCLASS.getCode(), firstClassTotalNum, stationList, headers);
int second = getRestTicketNumber(departureTime, trip.getTripId().toString(),
startPlaceName, endPlaceName, SeatClass.SECONDCLASS.getCode(), secondClassTotalNum, stationList, headers);
response.setConfortClass(first);
response.setEconomyClass(second);
response.setStartStation(startPlaceName);
response.setTerminalStation(endPlaceName);
//Calculate the distance from the starting point
int indexStart = route.getStations().indexOf(startPlaceName);
int indexEnd = route.getStations().indexOf(endPlaceName);
int distanceStart = route.getDistances().get(indexStart) - route.getDistances().get(0);
int distanceEnd = route.getDistances().get(indexEnd) - route.getDistances().get(0);
TrainType trainType = tr.getTrainType();
//Train running time is calculated according to the average running speed of the train
int minutesStart = 60 * distanceStart / trainType.getAverageSpeed();
int minutesEnd = 60 * distanceEnd / trainType.getAverageSpeed();
Calendar calendarStart = Calendar.getInstance();
calendarStart.setTime(StringUtils.String2Date(trip.getStartTime()));
calendarStart.add(Calendar.MINUTE, minutesStart);
response.setStartTime(StringUtils.Date2String(calendarStart.getTime()));
TravelServiceImpl.LOGGER.info("[getTickets][Calculate distance][calculate time：{} time: {}]", minutesStart, calendarStart.getTime());
Calendar calendarEnd = Calendar.getInstance();
calendarEnd.setTime(StringUtils.String2Date(trip.getStartTime()));
calendarEnd.add(Calendar.MINUTE, minutesEnd);
response.setEndTime(StringUtils.Date2String(calendarEnd.getTime()));
TravelServiceImpl.LOGGER.info("[getTickets][Calculate distance][calculate time：{} time: {}]", minutesEnd, calendarEnd.getTime());
response.setTripId(trip.getTripId());
response.setTrainTypeName(trip.getTrainTypeName());
response.setPriceForConfortClass(tr.getPrices().get("confortClass"));
response.setPriceForEconomyClass(tr.getPrices().get("economyClass"));
return response;
}
@Override
public Response queryAll(HttpHeaders headers) {
List<Trip> tripList = repository.findAll();
if (tripList != null && !tripList.isEmpty()) {
TravelServiceImpl.LOGGER.info("[queryAll][Query all trips:][{}]", "tripList");
return new Response<>(1, success, tripList);
}
TravelServiceImpl.LOGGER.warn("[queryAll][Query all trips warn][{}]", "No Content");
return new Response<>(0, noContent, null);
}
private static boolean afterToday(String date) {
Calendar calDateA = Calendar.getInstance();
Date today = new Date();
calDateA.setTime(today);
Calendar calDateB = Calendar.getInstance();
calDateB.setTime(StringUtils.String2Date(date));
TravelServiceImpl.LOGGER.info("[today date][y: {}][m:{}][d: {}]",calDateA.get(Calendar.YEAR), calDateA.get(Calendar.MONTH), calDateA.get(Calendar.DATE));
TravelServiceImpl.LOGGER.info("[departrue date][y: {}][m:{}][d: {}]",calDateB.get(Calendar.YEAR), calDateB.get(Calendar.MONTH), calDateB.get(Calendar.DATE));
if (calDateA.get(Calendar.YEAR) > calDateB.get(Calendar.YEAR)) {
return false;
} else if (calDateA.get(Calendar.YEAR) == calDateB.get(Calendar.YEAR)) {
if (calDateA.get(Calendar.MONTH) > calDateB.get(Calendar.MONTH)) {
return false;
} else if (calDateA.get(Calendar.MONTH) == calDateB.get(Calendar.MONTH)) {
return calDateA.get(Calendar.DAY_OF_MONTH) <= calDateB.get(Calendar.DAY_OF_MONTH);
} else {
return true;
}
} else {
return true;
}
}
private TrainType getTrainTypeByName(String trainTypeName, HttpHeaders headers) {
HttpEntity requestEntity = new HttpEntity(null);
String train_service_url = getServiceUrl("ts-train-service");
ResponseEntity<Response<TrainType>> re = restTemplate.exchange(
train_service_url + "/api/v1/trainservice/trains/byName/" + trainTypeName,
HttpMethod.GET,
requestEntity,
new ParameterizedTypeReference<Response<TrainType>>() {
});
return re.getBody().getData();
}
private Route getRouteByRouteId(String routeId, HttpHeaders headers) {
TravelServiceImpl.LOGGER.info("[getRouteByRouteId][Get Route By Id][Route ID：{}]", routeId);
HttpEntity requestEntity = new HttpEntity(null);
String route_service_url = getServiceUrl("ts-route-service");
ResponseEntity<Response> re = restTemplate.exchange(
route_service_url + "/api/v1/routeservice/routes/" + routeId,
HttpMethod.GET,
requestEntity,
Response.class);
Response routeRes = re.getBody();
Route route1 = new Route();
TravelServiceImpl.LOGGER.info("[getRouteByRouteId][Get Route By Id][Routes Response is : {}]", routeRes.toString());
if (routeRes.getStatus() == 1) {
route1 = JsonUtils.conveterObject(routeRes.getData(), Route.class);
TravelServiceImpl.LOGGER.info("[getRouteByRouteId][Get Route By Id][Route is: {}]", route1.toString());
}
return route1;
}
private int getRestTicketNumber(String travelDate, String trainNumber, String startStationName, String endStationName, int seatType, int totalNum, List<String> stationList, HttpHeaders headers) {
Seat seatRequest = new Seat();
seatRequest.setDestStation(endStationName);
seatRequest.setStartStation(startStationName);
seatRequest.setTrainNumber(trainNumber);
seatRequest.setTravelDate(travelDate);
seatRequest.setSeatType(seatType);
seatRequest.setTotalNum(totalNum);
seatRequest.setStations(stationList);
TravelServiceImpl.LOGGER.info("[getRestTicketNumber][Seat request][request: {}]", seatRequest.toString());
HttpEntity requestEntity = new HttpEntity(seatRequest, null);
String seat_service_url = getServiceUrl("ts-seat-service");
ResponseEntity<Response<Integer>> re = restTemplate.exchange(
seat_service_url + "/api/v1/seatservice/seats/left_tickets",
HttpMethod.POST,
requestEntity,
new ParameterizedTypeReference<Response<Integer>>() {
});
TravelServiceImpl.LOGGER.info("[getRestTicketNumber][Get Rest tickets num][num is: {}]", re.getBody().toString());
return re.getBody().getData();
}
@Override
public Response adminQueryAll(HttpHeaders headers) {
List<Trip> trips = repository.findAll();
ArrayList<AdminTrip> adminTrips = new ArrayList<>();
if(trips != null){
for (Trip trip : trips) {
AdminTrip adminTrip = new AdminTrip();
adminTrip.setTrip(trip);
adminTrip.setRoute(getRouteByRouteId(trip.getRouteId(), headers));
adminTrip.setTrainType(getTrainTypeByName(trip.getTrainTypeName(), headers));
adminTrips.add(adminTrip);
}
}
if (!adminTrips.isEmpty()) {
return new Response<>(1, success, adminTrips);
} else {
TravelServiceImpl.LOGGER.warn("[adminQueryAll][Admin query all trips warn][{}]", "No Content");
return new Response<>(0, noContent, null);
}
}
}
| 26,357 | 44.05641 | 258 |
java
|
train-ticket
|
train-ticket-master/ts-travel-service/src/test/java/travel/controller/TravelControllerTest.java
|
package travel.controller;
import com.alibaba.fastjson.JSONObject;
import edu.fudan.common.entity.*;
import edu.fudan.common.entity.TravelInfo;
import edu.fudan.common.entity.TripAllDetailInfo;
import edu.fudan.common.entity.TripInfo;
import edu.fudan.common.entity.TripResponse;
import edu.fudan.common.util.Response;
import org.junit.Assert;
import org.junit.Before;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.junit.runners.JUnit4;
import org.mockito.InjectMocks;
import org.mockito.Mock;
import org.mockito.Mockito;
import org.mockito.MockitoAnnotations;
import org.springframework.http.*;
import org.springframework.test.web.servlet.MockMvc;
import org.springframework.test.web.servlet.request.MockMvcRequestBuilders;
import org.springframework.test.web.servlet.result.MockMvcResultMatchers;
import org.springframework.test.web.servlet.setup.MockMvcBuilders;
import travel.entity.Travel;
import travel.entity.AdminTrip;
import travel.service.TravelService;
import java.util.ArrayList;
import java.util.Date;
@RunWith(JUnit4.class)
public class TravelControllerTest {
@InjectMocks
private TravelController travelController;
@Mock
private TravelService service;
private MockMvc mockMvc;
private Response response = new Response();
@Before
public void setUp() {
MockitoAnnotations.initMocks(this);
mockMvc = MockMvcBuilders.standaloneSetup(travelController).build();
}
@Test
public void testHome() throws Exception {
mockMvc.perform(MockMvcRequestBuilders.get("/api/v1/travelservice/welcome"))
.andExpect(MockMvcResultMatchers.status().isOk())
.andExpect(MockMvcResultMatchers.content().string("Welcome to [ Travel Service ] !"));
}
@Test
public void testGetTrainTypeByTripId() throws Exception {
Mockito.when(service.getTrainTypeByTripId(Mockito.anyString(), Mockito.any(HttpHeaders.class))).thenReturn(response);
String result = mockMvc.perform(MockMvcRequestBuilders.get("/api/v1/travelservice/train_types/trip_id"))
.andExpect(MockMvcResultMatchers.status().isOk())
.andReturn().getResponse().getContentAsString();
Assert.assertEquals(response, JSONObject.parseObject(result, Response.class));
}
@Test
public void testGetRouteByTripId() throws Exception {
Mockito.when(service.getRouteByTripId(Mockito.anyString(), Mockito.any(HttpHeaders.class))).thenReturn(response);
String result = mockMvc.perform(MockMvcRequestBuilders.get("/api/v1/travelservice/routes/trip_id"))
.andExpect(MockMvcResultMatchers.status().isOk())
.andReturn().getResponse().getContentAsString();
Assert.assertEquals(response, JSONObject.parseObject(result, Response.class));
}
@Test
public void testGetTripsByRouteId() throws Exception {
ArrayList<String> routeIds = new ArrayList<>();
Mockito.when(service.getTripByRoute(Mockito.any(ArrayList.class), Mockito.any(HttpHeaders.class))).thenReturn(response);
String requestJson = JSONObject.toJSONString(routeIds);
String result = mockMvc.perform(MockMvcRequestBuilders.post("/api/v1/travelservice/trips/routes").contentType(MediaType.APPLICATION_JSON).content(requestJson))
.andExpect(MockMvcResultMatchers.status().isOk())
.andReturn().getResponse().getContentAsString();
Assert.assertEquals(response, JSONObject.parseObject(result, Response.class));
}
@Test
public void testCreateTrip() throws Exception {
TravelInfo routeIds = new TravelInfo();
Mockito.when(service.create(Mockito.any(TravelInfo.class), Mockito.any(HttpHeaders.class))).thenReturn(response);
String requestJson = JSONObject.toJSONString(routeIds);
String result = mockMvc.perform(MockMvcRequestBuilders.post("/api/v1/travelservice/trips").contentType(MediaType.APPLICATION_JSON).content(requestJson))
.andExpect(MockMvcResultMatchers.status().isCreated())
.andReturn().getResponse().getContentAsString();
Assert.assertEquals(response, JSONObject.parseObject(result, Response.class));
}
@Test
public void testRetrieve() throws Exception {
Mockito.when(service.retrieve(Mockito.anyString(), Mockito.any(HttpHeaders.class))).thenReturn(response);
String result = mockMvc.perform(MockMvcRequestBuilders.get("/api/v1/travelservice/trips/trip_id"))
.andExpect(MockMvcResultMatchers.status().isOk())
.andReturn().getResponse().getContentAsString();
Assert.assertEquals(response, JSONObject.parseObject(result, Response.class));
}
@Test
public void testUpdateTrip() throws Exception {
TravelInfo info = new TravelInfo();
Mockito.when(service.update(Mockito.any(TravelInfo.class), Mockito.any(HttpHeaders.class))).thenReturn(response);
String requestJson = JSONObject.toJSONString(info);
String result = mockMvc.perform(MockMvcRequestBuilders.put("/api/v1/travelservice/trips").contentType(MediaType.APPLICATION_JSON).content(requestJson))
.andExpect(MockMvcResultMatchers.status().isOk())
.andReturn().getResponse().getContentAsString();
Assert.assertEquals(response, JSONObject.parseObject(result, Response.class));
}
@Test
public void testDeleteTrip() throws Exception {
Mockito.when(service.delete(Mockito.anyString(), Mockito.any(HttpHeaders.class))).thenReturn(response);
String result = mockMvc.perform(MockMvcRequestBuilders.delete("/api/v1/travelservice/trips/trip_id"))
.andExpect(MockMvcResultMatchers.status().isOk())
.andReturn().getResponse().getContentAsString();
Assert.assertEquals(response, JSONObject.parseObject(result, Response.class));
}
@Test
public void testQueryInfo1() throws Exception {
TripInfo info = new TripInfo();
ArrayList<TripResponse> errorList = new ArrayList<>();
String requestJson = JSONObject.toJSONString(info);
String result = mockMvc.perform(MockMvcRequestBuilders.post("/api/v1/travelservice/trips/left").contentType(MediaType.APPLICATION_JSON).content(requestJson))
.andExpect(MockMvcResultMatchers.status().isOk())
.andReturn().getResponse().getContentAsString();
Assert.assertEquals(errorList, JSONObject.parseObject(result, ArrayList.class));
}
@Test
public void testQueryInfo2() throws Exception {
TripInfo info = new TripInfo("startPlace", "endPlace", "");
Mockito.when(service.query(Mockito.any(TripInfo.class), Mockito.any(HttpHeaders.class))).thenReturn(response);
String requestJson = JSONObject.toJSONString(info);
String result = mockMvc.perform(MockMvcRequestBuilders.post("/api/v1/travelservice/trips/left").contentType(MediaType.APPLICATION_JSON).content(requestJson))
.andExpect(MockMvcResultMatchers.status().isOk())
.andReturn().getResponse().getContentAsString();
Assert.assertEquals(response, JSONObject.parseObject(result, Response.class));
}
@Test
public void testGetTripAllDetailInfo() throws Exception {
TripAllDetailInfo gtdi = new TripAllDetailInfo();
Mockito.when(service.getTripAllDetailInfo(Mockito.any(TripAllDetailInfo.class), Mockito.any(HttpHeaders.class))).thenReturn(response);
String requestJson = JSONObject.toJSONString(gtdi);
String result = mockMvc.perform(MockMvcRequestBuilders.post("/api/v1/travelservice/trip_detail").contentType(MediaType.APPLICATION_JSON).content(requestJson))
.andExpect(MockMvcResultMatchers.status().isOk())
.andReturn().getResponse().getContentAsString();
Assert.assertEquals(response, JSONObject.parseObject(result, Response.class));
}
@Test
public void testQueryAll() throws Exception {
Mockito.when(service.queryAll(Mockito.any(HttpHeaders.class))).thenReturn(response);
String result = mockMvc.perform(MockMvcRequestBuilders.get("/api/v1/travelservice/trips"))
.andExpect(MockMvcResultMatchers.status().isOk())
.andReturn().getResponse().getContentAsString();
Assert.assertEquals(response, JSONObject.parseObject(result, Response.class));
}
@Test
public void testAdminQueryAll() throws Exception {
Mockito.when(service.adminQueryAll(Mockito.any(HttpHeaders.class))).thenReturn(response);
String result = mockMvc.perform(MockMvcRequestBuilders.get("/api/v1/travelservice/admin_trip"))
.andExpect(MockMvcResultMatchers.status().isOk())
.andReturn().getResponse().getContentAsString();
Assert.assertEquals(response, JSONObject.parseObject(result, Response.class));
}
}
| 8,929 | 49.738636 | 167 |
java
|
train-ticket
|
train-ticket-master/ts-travel-service/src/test/java/travel/service/TravelServiceImplTest.java
|
package travel.service;
import edu.fudan.common.entity.*;
import edu.fudan.common.util.Response;
import edu.fudan.common.util.StringUtils;
import org.junit.Assert;
import org.junit.Before;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.junit.runners.JUnit4;
import org.mockito.InjectMocks;
import org.mockito.Mock;
import org.mockito.Mockito;
import org.mockito.MockitoAnnotations;
import org.springframework.core.ParameterizedTypeReference;
import org.springframework.http.*;
import org.springframework.web.client.RestTemplate;
import travel.entity.*;
import travel.entity.Trip;
import travel.repository.TripRepository;
import java.util.ArrayList;
import java.util.Date;
@RunWith(JUnit4.class)
public class TravelServiceImplTest {
@InjectMocks
private TravelServiceImpl travelServiceImpl;
@Mock
private TripRepository repository;
@Mock
private RestTemplate restTemplate;
private HttpHeaders headers = new HttpHeaders();
String success = "Success";
String noCnontent = "No Content";
@Before
public void setUp() {
MockitoAnnotations.initMocks(this);
}
@Test
public void testGetRouteByTripId1() {
Mockito.when(repository.findByTripId(Mockito.any(TripId.class))).thenReturn(null);
Response result = travelServiceImpl.getRouteByTripId("K1255", headers);
Assert.assertEquals(new Response<>(0, "No Content", null), result);
}
@Test
public void testGetRouteByTripId2() {
Trip trip = new Trip();
Mockito.when(repository.findByTripId(Mockito.any(TripId.class))).thenReturn(trip);
//mock getRouteByRouteId()
Route route = new Route();
Response response = new Response(1, null, route);
ResponseEntity<Response> re = new ResponseEntity<>(response, HttpStatus.OK);
Mockito.when(restTemplate.exchange(
Mockito.anyString(),
Mockito.any(HttpMethod.class),
Mockito.any(HttpEntity.class),
Mockito.any(Class.class)))
.thenReturn(re);
Response result = travelServiceImpl.getRouteByTripId("K1255", headers);
Assert.assertEquals("Success", result.getMsg());
}
@Test
public void testGetTrainTypeByTripId() {
Trip trip = new Trip();
Mockito.when(repository.findByTripId(Mockito.any(TripId.class))).thenReturn(trip);
//mock getTrainType()
TrainType trainType = new TrainType();
Response<TrainType> response = new Response<>(null, null, trainType);
ResponseEntity<Response<TrainType>> re = new ResponseEntity<>(response, HttpStatus.OK);
Mockito.when(restTemplate.exchange(
Mockito.anyString(),
Mockito.any(HttpMethod.class),
Mockito.any(HttpEntity.class),
Mockito.any(ParameterizedTypeReference.class)))
.thenReturn(re);
Response result = travelServiceImpl.getTrainTypeByTripId("K1255", headers);
Assert.assertEquals(new Response<>(1, "Success", trainType), result);
}
@Test
public void testGetTripByRoute1() {
ArrayList<String> routeIds = new ArrayList<>();
Response result = travelServiceImpl.getTripByRoute(routeIds, headers);
Assert.assertEquals(new Response<>(0, noCnontent, null), result);
}
@Test
public void testGetTripByRoute2() {
ArrayList<String> routeIds = new ArrayList<>();
routeIds.add("route_id_1");
Mockito.when(repository.findByRouteId(Mockito.anyString())).thenReturn(null);
Response result = travelServiceImpl.getTripByRoute(routeIds, headers);
Assert.assertEquals(success, result.getMsg());
}
@Test
public void testCreate1() {
TravelInfo info = new TravelInfo();
info.setTripId("G");
Mockito.when(repository.findByTripId(Mockito.any(TripId.class))).thenReturn(null);
Mockito.when(repository.save(Mockito.any(Trip.class))).thenReturn(null);
Response result = travelServiceImpl.create(info, headers);
Assert.assertEquals(new Response<>(1, "Create trip:G.", null), result);
}
@Test
public void testCreate2() {
TravelInfo info = new TravelInfo();
info.setTripId("G");
Trip trip = new Trip();
Mockito.when(repository.findByTripId(Mockito.any(TripId.class))).thenReturn(trip);
Response result = travelServiceImpl.create(info, headers);
Assert.assertEquals(new Response<>(1, "Trip G already exists", null), result);
}
@Test
public void testRetrieve1() {
Trip trip = new Trip();
Mockito.when(repository.findByTripId(Mockito.any(TripId.class))).thenReturn(trip);
Response result = travelServiceImpl.retrieve("trip_id_1", headers);
Assert.assertEquals(new Response<>(1, "Search Trip Success by Trip Id trip_id_1", trip), result);
}
@Test
public void testRetrieve2() {
Trip trip = new Trip();
Mockito.when(repository.findByTripId(Mockito.any(TripId.class))).thenReturn(trip);
Response result = travelServiceImpl.retrieve("trip_id_1", headers);
Assert.assertEquals(new Response<>(1, "Search Trip Success by Trip Id trip_id_1", trip), result);
}
@Test
public void testUpdate1() {
TravelInfo info = new TravelInfo();
info.setTripId("G");
Trip trip = new Trip();
Mockito.when(repository.findByTripId(Mockito.any(TripId.class))).thenReturn(trip);
Mockito.when(repository.save(Mockito.any(Trip.class))).thenReturn(null);
Response result = travelServiceImpl.update(info, headers);
Assert.assertEquals("Update trip:G", result.getMsg());
}
@Test
public void testUpdate2() {
TravelInfo info = new TravelInfo();
info.setTripId("G");
Mockito.when(repository.findByTripId(Mockito.any(TripId.class))).thenReturn(null);
Response result = travelServiceImpl.update(info, headers);
Assert.assertEquals(new Response<>(1, "TripGdoesn 't exists", null), result);
}
@Test
public void testDelete1() {
Trip trip = new Trip();
Mockito.when(repository.findByTripId(Mockito.any(TripId.class))).thenReturn(trip);
Mockito.doNothing().doThrow(new RuntimeException()).when(repository).deleteByTripId(Mockito.any(TripId.class));
Response result = travelServiceImpl.delete("trip_id_1", headers);
Assert.assertEquals(new Response<>(1, "Delete trip:trip_id_1.", "trip_id_1"), result);
}
@Test
public void testDelete2() {
Mockito.when(repository.findByTripId(Mockito.any(TripId.class))).thenReturn(null);
Response result = travelServiceImpl.delete("trip_id_1", headers);
Assert.assertEquals(new Response<>(0, "Trip trip_id_1 doesn't exist.", null), result);
}
@Test
public void testQuery() {
TripInfo info = new TripInfo();
//mock queryForStationId()
Response<String> response1 = new Response<>(null, null, "");
ResponseEntity<Response<String>> re1 = new ResponseEntity<>(response1, HttpStatus.OK);
Mockito.when(restTemplate.exchange(
Mockito.anyString(),
Mockito.any(HttpMethod.class),
Mockito.any(HttpEntity.class),
Mockito.any(ParameterizedTypeReference.class)))
.thenReturn(re1);
ArrayList<Trip> tripList = new ArrayList<>();
Trip trip = new Trip();
trip.setRouteId("route_id");
tripList.add(trip);
Mockito.when(repository.findAll()).thenReturn(tripList);
//mock getRouteByRouteId()
Route route = new Route();
route.setStations(new ArrayList<>());
Response response2 = new Response(1, null, route);
ResponseEntity<Response> re2 = new ResponseEntity<>(response2, HttpStatus.OK);
Mockito.when(restTemplate.exchange(
Mockito.anyString(),
Mockito.any(HttpMethod.class),
Mockito.any(HttpEntity.class),
Mockito.any(Class.class)))
.thenReturn(re2);
Response result = travelServiceImpl.query(info, headers);
Assert.assertEquals(new Response<>(1, "Success", new ArrayList<>()), result);
}
@Test
public void testGetTripAllDetailInfo() {
TripAllDetailInfo gtdi = new TripAllDetailInfo();
gtdi.setTripId("Z1255");
gtdi.setFrom("from_station");
gtdi.setTo("to_station");
gtdi.setTravelDate(StringUtils.Date2String(new Date(System.currentTimeMillis() - 86400000)));
Trip trip = new Trip();
trip.setRouteId("route_id");
Mockito.when(repository.findByTripId(Mockito.any(TripId.class))).thenReturn(trip);
//mock queryForStationId()
Response<String> response1 = new Response<>(null, null, "");
ResponseEntity<Response<String>> re1 = new ResponseEntity<>(response1, HttpStatus.OK);
Mockito.when(restTemplate.exchange(
Mockito.anyString(),
Mockito.any(HttpMethod.class),
Mockito.any(HttpEntity.class),
Mockito.any(ParameterizedTypeReference.class)))
.thenReturn(re1);
//mock getRouteByRouteId()
Route route = new Route();
route.setStations(new ArrayList<>());
Response response2 = new Response(1, null, route);
ResponseEntity<Response> re2 = new ResponseEntity<>(response2, HttpStatus.OK);
Mockito.when(restTemplate.exchange(
Mockito.anyString(),
Mockito.any(HttpMethod.class),
Mockito.any(HttpEntity.class),
Mockito.any(Class.class)))
.thenReturn(re2);
Response result = travelServiceImpl.getTripAllDetailInfo(gtdi, headers);
Assert.assertEquals("Success", result.getMsg());
}
@Test
public void testQueryAll1() {
ArrayList<Trip> tripList = new ArrayList<>();
tripList.add(new Trip());
Mockito.when(repository.findAll()).thenReturn(tripList);
Response result = travelServiceImpl.queryAll(headers);
Assert.assertEquals(new Response<>(1, success, tripList), result);
}
@Test
public void testQueryAll2() {
Mockito.when(repository.findAll()).thenReturn(null);
Response result = travelServiceImpl.queryAll(headers);
Assert.assertEquals(new Response<>(0, noCnontent, null), result);
}
@Test
public void testAdminQueryAll1() {
ArrayList<Trip> tripList = new ArrayList<>();
Trip trip = new Trip();
trip.setRouteId("route_id");
tripList.add(trip);
Mockito.when(repository.findAll()).thenReturn(tripList);
//mock getRouteByRouteId()
Route route = new Route();
Response response2 = new Response(1, null, route);
ResponseEntity<Response> re2 = new ResponseEntity<>(response2, HttpStatus.OK);
Mockito.when(restTemplate.exchange(
Mockito.anyString(),
Mockito.any(HttpMethod.class),
Mockito.any(HttpEntity.class),
Mockito.any(Class.class)))
.thenReturn(re2);
//mock getTrainType()
TrainType trainType = new TrainType();
Response<TrainType> response = new Response<>(null, null, trainType);
ResponseEntity<Response<TrainType>> re = new ResponseEntity<>(response, HttpStatus.OK);
Mockito.when(restTemplate.exchange(
Mockito.anyString(),
Mockito.any(HttpMethod.class),
Mockito.any(HttpEntity.class),
Mockito.any(ParameterizedTypeReference.class)))
.thenReturn(re);
Response result = travelServiceImpl.adminQueryAll(headers);
Assert.assertEquals("Success", result.getMsg());
}
@Test
public void testAdminQueryAll2() {
ArrayList<Trip> tripList = new ArrayList<>();
Mockito.when(repository.findAll()).thenReturn(tripList);
Response result = travelServiceImpl.adminQueryAll(headers);
Assert.assertEquals(new Response<>(0, noCnontent, null), result);
}
}
| 12,231 | 38.973856 | 119 |
java
|
train-ticket
|
train-ticket-master/ts-travel2-service/src/main/java/travel2/Travel2Application.java
|
package travel2;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.boot.web.client.RestTemplateBuilder;
import org.springframework.cloud.client.discovery.EnableDiscoveryClient;
import org.springframework.cloud.client.loadbalancer.LoadBalanced;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.EnableAspectJAutoProxy;
import org.springframework.integration.annotation.IntegrationComponentScan;
import org.springframework.scheduling.annotation.EnableAsync;
import org.springframework.web.client.RestTemplate;
import springfox.documentation.swagger2.annotations.EnableSwagger2;
/**
* @author fdse
*/
@SpringBootApplication
@EnableAspectJAutoProxy(proxyTargetClass = true)
@EnableAsync
@IntegrationComponentScan
@EnableSwagger2
@EnableDiscoveryClient
public class Travel2Application {
public static void main(String[] args) {
SpringApplication.run(Travel2Application.class, args);
}
@LoadBalanced
@Bean
public RestTemplate restTemplate(RestTemplateBuilder builder) {
return builder.build();
}
}
| 1,183 | 31.888889 | 75 |
java
|
train-ticket
|
train-ticket-master/ts-travel2-service/src/main/java/travel2/config/SecurityConfig.java
|
package travel2.config;
import edu.fudan.common.security.jwt.JWTFilter;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.http.HttpMethod;
import org.springframework.security.config.annotation.method.configuration.EnableGlobalMethodSecurity;
import org.springframework.security.config.annotation.web.builders.HttpSecurity;
import org.springframework.security.config.annotation.web.configuration.EnableWebSecurity;
import org.springframework.security.config.annotation.web.configuration.WebSecurityConfigurerAdapter;
import org.springframework.security.config.http.SessionCreationPolicy;
import org.springframework.security.crypto.bcrypt.BCryptPasswordEncoder;
import org.springframework.security.crypto.password.PasswordEncoder;
import org.springframework.security.web.authentication.UsernamePasswordAuthenticationFilter;
import org.springframework.web.servlet.config.annotation.CorsRegistry;
import org.springframework.web.servlet.config.annotation.WebMvcConfigurer;
import org.springframework.web.servlet.config.annotation.WebMvcConfigurerAdapter;
import static org.springframework.web.cors.CorsConfiguration.ALL;
/**
* @author fdse
*/
@Configuration
@EnableWebSecurity
@EnableGlobalMethodSecurity(prePostEnabled = true)
public class SecurityConfig extends WebSecurityConfigurerAdapter {
String admin = "ADMIN";
String trips = "/api/v1/travel2service/trips";
/**
* load password encoder
*
* @return PasswordEncoder
*/
@Bean
public PasswordEncoder passwordEncoder() {
return new BCryptPasswordEncoder();
}
/**
* allow cors domain
* header By default, only six fields can be taken from the header, and the other fields can only be specified in the header.
* credentials Cookies are not sent by default and can only be true if a Cookie is needed
* Validity of this request
*
* @return WebMvcConfigurer
*/
@Bean
public WebMvcConfigurer corsConfigurer() {
return new WebMvcConfigurerAdapter() {
@Override
public void addCorsMappings(CorsRegistry registry) {
registry.addMapping("/**")
.allowedOrigins(ALL)
.allowedMethods(ALL)
.allowedHeaders(ALL)
.allowCredentials(false)
.maxAge(3600);
}
};
}
@Override
protected void configure(HttpSecurity httpSecurity) throws Exception {
httpSecurity.httpBasic().disable()
// close default csrf
.csrf().disable()
// close session
.sessionManagement().sessionCreationPolicy(SessionCreationPolicy.STATELESS)
.and()
.authorizeRequests()
.antMatchers("/api/v1/travel2service/**").permitAll()
.antMatchers(HttpMethod.PUT, trips).hasAnyRole(admin)
.antMatchers(HttpMethod.POST, trips).hasAnyRole(admin)
.antMatchers(HttpMethod.DELETE, trips).hasAnyRole(admin)
.antMatchers("/swagger-ui.html", "/webjars/**", "/images/**",
"/configuration/**", "/swagger-resources/**", "/v2/**").permitAll()
.anyRequest().authenticated()
.and()
.addFilterBefore(new JWTFilter(), UsernamePasswordAuthenticationFilter.class);
// close cache
httpSecurity.headers().cacheControl();
}
}
| 3,572 | 39.146067 | 130 |
java
|
train-ticket
|
train-ticket-master/ts-travel2-service/src/main/java/travel2/controller/Travel2Controller.java
|
package travel2.controller;
import edu.fudan.common.entity.TripResponse;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.http.HttpEntity;
import org.springframework.http.HttpHeaders;
import org.springframework.http.HttpStatus;
import org.springframework.http.ResponseEntity;
import org.springframework.web.bind.annotation.*;
import travel2.service.TravelService;
import java.util.ArrayList;
import static org.springframework.http.ResponseEntity.ok;
/**
* @author fdse
*/
@RestController
@RequestMapping("/api/v1/travel2service")
public class Travel2Controller {
@Autowired
private TravelService service;
private static final Logger LOGGER = LoggerFactory.getLogger(Travel2Controller.class);
@GetMapping(path = "/welcome")
public String home(@RequestHeader HttpHeaders headers) {
return "Welcome to [ Travle2 Service ] !";
}
@GetMapping(value = "/train_types/{tripId}")
public HttpEntity getTrainTypeByTripId(@PathVariable String tripId,
@RequestHeader HttpHeaders headers) {
// TrainType
Travel2Controller.LOGGER.info("[getTrainTypeByTripId][Get train by Trip id][TripId: {}]",tripId);
return ok(service.getTrainTypeByTripId(tripId, headers));
}
@GetMapping(value = "/routes/{tripId}")
public HttpEntity getRouteByTripId(@PathVariable String tripId,
@RequestHeader HttpHeaders headers) {
Travel2Controller.LOGGER.info("[getRouteByTripId][Get Route By Trip ID][TripId: {}]", tripId);
//Route
return ok(service.getRouteByTripId(tripId, headers));
}
@PostMapping(value = "/trips/routes")
public HttpEntity getTripsByRouteId(@RequestBody ArrayList<String> routeIds,
@RequestHeader HttpHeaders headers) {
// ArrayList<ArrayList<Trip>>
Travel2Controller.LOGGER.info("[getTripByRoute][Get trips by Route id][RouteIdNumber: {}]",routeIds.size());
return ok(service.getTripByRoute(routeIds, headers));
}
@CrossOrigin(origins = "*")
@PostMapping(value = "/trips")
public HttpEntity<?> createTrip(@RequestBody edu.fudan.common.entity.TravelInfo routeIds, @RequestHeader HttpHeaders headers) {
// null
Travel2Controller.LOGGER.info("[create][Create trip][TripId: {}]", routeIds.getTripId());
return new ResponseEntity<>(service.create(routeIds, headers), HttpStatus.CREATED);
}
/**
*Return Trip only, no left ticket information
*
* @param tripId trip id
* @param headers headers
* @return HttpEntity
*/
@CrossOrigin(origins = "*")
@GetMapping(value = "/trips/{tripId}")
public HttpEntity retrieve(@PathVariable String tripId, @RequestHeader HttpHeaders headers) {
// Trip
Travel2Controller.LOGGER.info("[retrieve][Retrieve trip][TripId: {}]",tripId);
return ok(service.retrieve(tripId, headers));
}
@CrossOrigin(origins = "*")
@PutMapping(value = "/trips")
public HttpEntity updateTrip(@RequestBody edu.fudan.common.entity.TravelInfo info, @RequestHeader HttpHeaders headers) {
// Trip
Travel2Controller.LOGGER.info("[update][Update trip][TripId: {}]",info.getTripId());
return ok(service.update(info, headers));
}
@CrossOrigin(origins = "*")
@DeleteMapping(value = "/trips/{tripId}")
public HttpEntity deleteTrip(@PathVariable String tripId, @RequestHeader HttpHeaders headers) {
// string
Travel2Controller.LOGGER.info("[delete][Delete trip][TripId: {}]",tripId);
return ok(service.delete(tripId, headers));
}
/**
* Return Trip and the remaining tickets
*
* @param info trip info
* @param headers headers
* @return HttpEntity
*/
@CrossOrigin(origins = "*")
@PostMapping(value = "/trips/left")
public HttpEntity queryInfo(@RequestBody edu.fudan.common.entity.TripInfo info, @RequestHeader HttpHeaders headers) {
if (info.getStartPlace() == null || info.getStartPlace().length() == 0 ||
info.getEndPlace() == null || info.getEndPlace().length() == 0 ||
info.getDepartureTime() == null) {
Travel2Controller.LOGGER.info("[query][Travel Query Fail][Something null]");
ArrayList<TripResponse> errorList = new ArrayList<>();
return ok(errorList);
}
Travel2Controller.LOGGER.info("[query][Query TripResponse]");
return ok(service.queryByBatch(info, headers));
}
/**
* Return a Trip and the remaining tickets
*
* @param gtdi trip all datail info
* @param headers headers
* @return HttpEntity
*/
@CrossOrigin(origins = "*")
@PostMapping(value = "/trip_detail")
public HttpEntity getTripAllDetailInfo(@RequestBody edu.fudan.common.entity.TripAllDetailInfo gtdi, @RequestHeader HttpHeaders headers) {
Travel2Controller.LOGGER.info("[getTripAllDetailInfo][Get trip detail][TripId: {}]",gtdi.getTripId());
return ok(service.getTripAllDetailInfo(gtdi, headers));
}
@CrossOrigin(origins = "*")
@GetMapping(value = "/trips")
public HttpEntity queryAll(@RequestHeader HttpHeaders headers) {
// List<Trip>
Travel2Controller.LOGGER.info("[queryAll][Query all trips]");
return ok(service.queryAll(headers));
}
@CrossOrigin(origins = "*")
@GetMapping(value = "/admin_trip")
public HttpEntity adminQueryAll(@RequestHeader HttpHeaders headers) {
// ArrayList<AdminTrip>
Travel2Controller.LOGGER.info("[adminQueryAll][Admin query all trips]");
return ok(service.adminQueryAll(headers));
}
}
| 5,828 | 37.86 | 141 |
java
|
train-ticket
|
train-ticket-master/ts-travel2-service/src/main/java/travel2/entity/AdminTrip.java
|
package travel2.entity;
import edu.fudan.common.entity.Route;
import edu.fudan.common.entity.TrainType;
import lombok.Data;
/**
* @author fdse
*/
@Data
public class AdminTrip {
private Trip trip;
private TrainType trainType;
private Route route;
public AdminTrip(){
//Default Constructor
}
}
| 326 | 14.571429 | 41 |
java
|
train-ticket
|
train-ticket-master/ts-travel2-service/src/main/java/travel2/entity/Travel.java
|
package travel2.entity;
import travel2.entity.Trip;
import edu.fudan.common.util.StringUtils;
import lombok.Data;
import java.util.Date;
/**
* @author fdse
*/
@Data
public class Travel {
private Trip trip;
private String startPlace;
private String endPlace;
private String departureTime;
public Travel(){
//Default Constructor
}
}
| 373 | 12.851852 | 41 |
java
|
train-ticket
|
train-ticket-master/ts-travel2-service/src/main/java/travel2/entity/Trip.java
|
package travel2.entity;
import edu.fudan.common.entity.TripId;
import edu.fudan.common.util.StringUtils;
import lombok.Data;
import org.hibernate.annotations.GenericGenerator;
import javax.persistence.*;
import javax.validation.Valid;
import javax.validation.constraints.NotNull;
import java.util.Date;
/**
* @author fdse
*/
@Data
@Entity
@Table(name = "trip2")
@GenericGenerator(name = "jpa-uuid", strategy = "org.hibernate.id.UUIDGenerator")
public class
Trip {
@Valid
@Id
@GeneratedValue(generator = "jpa-uuid")
@Column(length = 36)
private String id;
@Embedded
private TripId tripId;
@Valid
@NotNull
private String trainTypeName;
private String routeId;
@Valid
@NotNull
private String startStationName;
@Valid
private String stationsName;
@Valid
@NotNull
private String terminalStationName;
@Valid
@NotNull
private String startTime;
@Valid
@NotNull
private String endTime;
public Trip(edu.fudan.common.entity.TripId tripId, String trainTypeName, String startStationName, String stationsName, String terminalStationName, String startTime, String endTime) {
this.tripId = tripId;
this.trainTypeName = trainTypeName;
this.startStationName = StringUtils.String2Lower(startStationName);
this.stationsName = StringUtils.String2Lower(stationsName);
this.terminalStationName = StringUtils.String2Lower(terminalStationName);
this.startTime = startTime;
this.endTime = endTime;
}
public Trip(TripId tripId, String trainTypeName, String routeId) {
this.tripId = tripId;
this.trainTypeName = trainTypeName;
this.routeId = routeId;
this.startStationName = "";
this.terminalStationName = "";
this.startTime = "";
this.endTime = "";
}
public Trip(){
//Default Constructor
this.trainTypeName = "";
this.startStationName = "";
this.terminalStationName = "";
this.startTime = "";
this.endTime = "";
}
}
| 2,090 | 23.313953 | 186 |
java
|
train-ticket
|
train-ticket-master/ts-travel2-service/src/main/java/travel2/entity/TripAllDetail.java
|
package travel2.entity;
import edu.fudan.common.entity.TripResponse;
import lombok.AllArgsConstructor;
import lombok.Data;
import lombok.NoArgsConstructor;
/**
* @author fdse
*/
@Data
@NoArgsConstructor
@AllArgsConstructor
public class TripAllDetail {
private boolean status;
private String message;
private TripResponse tripResponse;
private Trip trip;
}
| 381 | 14.28 | 44 |
java
|
train-ticket
|
train-ticket-master/ts-travel2-service/src/main/java/travel2/init/InitData.java
|
package travel2.init;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.CommandLineRunner;
import org.springframework.stereotype.Component;
import edu.fudan.common.entity.TravelInfo;
import travel2.service.TravelService;
import java.util.Date;
/**
* @author fdse
*/
@Component
public class InitData implements CommandLineRunner {
@Autowired
TravelService service;
String zhiDa = "ZhiDa";
String shanghai = "shanghai";
String nanjing = "nanjing";
String beijing = "beijing";
@Override
public void run(String... args)throws Exception{
TravelInfo info = new TravelInfo();
info.setTripId("Z1234");
info.setTrainTypeName(zhiDa);
info.setRouteId("0b23bd3e-876a-4af3-b920-c50a90c90b04");
info.setStartStationName(shanghai);
info.setStationsName(nanjing);
info.setTerminalStationName(beijing);
info.setStartTime("2013-05-04 09:51:52"); //NOSONAR
info.setEndTime("2013-05-04 15:51:52"); //NOSONAR
service.create(info,null);
info.setTripId("Z1235");
info.setTrainTypeName(zhiDa);
info.setRouteId("9fc9c261-3263-4bfa-82f8-bb44e06b2f52");
info.setStartStationName(shanghai);
info.setStationsName(nanjing);
info.setTerminalStationName(beijing);
info.setStartTime("2013-05-04 11:31:52"); //NOSONAR
info.setEndTime("2013-05-04 17:51:52"); //NOSONAR
service.create(info,null);
info.setTripId("Z1236");
info.setTrainTypeName(zhiDa);
info.setRouteId("d693a2c5-ef87-4a3c-bef8-600b43f62c68");
info.setStartStationName(shanghai);
info.setStationsName(nanjing);
info.setTerminalStationName(beijing);
info.setStartTime("2013-05-04 7:05:52"); //NOSONAR
info.setEndTime("2013-05-04 12:51:52"); //NOSONAR
service.create(info,null);
info.setTripId("T1235");
info.setTrainTypeName("TeKuai");
info.setRouteId("20eb7122-3a11-423f-b10a-be0dc5bce7db");
info.setStartStationName(shanghai);
info.setStationsName(nanjing);
info.setTerminalStationName(beijing);
info.setStartTime("2013-05-04 08:31:52"); //NOSONAR
info.setEndTime("2013-05-04 17:21:52"); //NOSONAR
service.create(info,null);
info.setTripId("K1345");
info.setTrainTypeName("KuaiSu");
info.setRouteId("1367db1f-461e-4ab7-87ad-2bcc05fd9cb7");
info.setStartStationName(shanghai);
info.setStationsName(nanjing);
info.setTerminalStationName(beijing);
info.setStartTime("2013-05-04 07:51:52"); //NOSONAR
info.setEndTime("2013-05-04 19:59:52"); //NOSONAR
service.create(info,null);
}
}
| 2,769 | 34.063291 | 64 |
java
|
train-ticket
|
train-ticket-master/ts-travel2-service/src/main/java/travel2/repository/TripRepository.java
|
package travel2.repository;
import edu.fudan.common.entity.TripId;
import org.springframework.data.repository.CrudRepository;
import org.springframework.stereotype.Repository;
import travel2.entity.Trip;
import java.util.ArrayList;
/**
* @author fdse
*/
@Repository
public interface TripRepository extends CrudRepository<Trip, TripId> {
Trip findByTripId(TripId tripId);
void deleteByTripId(TripId tripId);
@Override
ArrayList<Trip> findAll();
ArrayList<Trip> findByRouteId(String routeId);
}
| 522 | 19.92 | 70 |
java
|
train-ticket
|
train-ticket-master/ts-travel2-service/src/main/java/travel2/service/TravelService.java
|
package travel2.service;
import edu.fudan.common.entity.TripInfo;
import edu.fudan.common.util.Response;
import org.springframework.http.HttpHeaders;
import java.util.ArrayList;
/**
* @author Chenjie Xu
* @date 2017/6/7.
*/
public interface TravelService {
Response create(edu.fudan.common.entity.TravelInfo info, HttpHeaders headers);
Response retrieve(String tripId, HttpHeaders headers);
Response update(edu.fudan.common.entity.TravelInfo info, HttpHeaders headers);
Response delete(String tripId, HttpHeaders headers);
Response query(TripInfo info, HttpHeaders headers);
Response queryByBatch(TripInfo info, HttpHeaders headers);
Response getTripAllDetailInfo(edu.fudan.common.entity.TripAllDetailInfo gtdi, HttpHeaders headers);
Response getRouteByTripId(String tripId, HttpHeaders headers);
Response getTrainTypeByTripId(String tripId, HttpHeaders headers);
Response queryAll(HttpHeaders headers);
Response getTripByRoute(ArrayList<String> routeIds, HttpHeaders headers);
Response adminQueryAll(HttpHeaders headers);
}
| 1,092 | 27.763158 | 103 |
java
|
train-ticket
|
train-ticket-master/ts-travel2-service/src/main/java/travel2/service/TravelServiceImpl.java
|
package travel2.service;
import com.fasterxml.jackson.core.type.TypeReference;
import com.fasterxml.jackson.databind.ObjectMapper;
import edu.fudan.common.entity.*;
import edu.fudan.common.util.JsonUtils;
import edu.fudan.common.util.Response;
import edu.fudan.common.util.StringUtils;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.cloud.client.discovery.DiscoveryClient;
import org.springframework.core.ParameterizedTypeReference;
import org.springframework.http.HttpEntity;
import org.springframework.http.HttpHeaders;
import org.springframework.http.HttpMethod;
import org.springframework.http.ResponseEntity;
import org.springframework.stereotype.Service;
import org.springframework.web.client.RestTemplate;
import travel2.entity.AdminTrip;
import travel2.entity.Trip;
import travel2.entity.Travel;
import travel2.entity.TripAllDetail;
import travel2.repository.TripRepository;
import javax.transaction.Transactional;
import java.util.*;
/**
* @author fdse
*/
@Service
public class TravelServiceImpl implements TravelService {
@Autowired
TripRepository repository;
@Autowired
private RestTemplate restTemplate;
@Autowired
private DiscoveryClient discoveryClient;
private static final Logger LOGGER = LoggerFactory.getLogger(TravelServiceImpl.class);
private String getServiceUrl(String serviceName) {
return "http://" + serviceName; }
String success = "Success";
String noCnontent = "No Content";
@Override
public Response getRouteByTripId(String tripId, HttpHeaders headers) {
TripId tripId1 = new TripId(tripId);
Trip trip = repository.findByTripId(tripId1);
if (trip == null) {
TravelServiceImpl.LOGGER.error("[getRouteByTripId][Get Route By Trip ID Fail][Trip Not Found][TripId: {}]", tripId);
return new Response<>(0, "\"[Get Route By Trip ID] Trip Not Found:\" + tripId", null);
} else {
Route route = getRouteByRouteId(trip.getRouteId(), headers);
if (route == null) {
TravelServiceImpl.LOGGER.error("[getRouteByTripId][Get route by Trip id error][Route not found][RouteId: {}]",trip.getRouteId());
return new Response<>(0, "\"[Get Route By Trip ID] Route Not Found:\" + trip.getRouteId()", null);
} else {
TravelServiceImpl.LOGGER.info("[getRouteByTripId][Get Route By Trip ID Success]");
return new Response<>(1, "[Get Route By Trip ID] Success", route);
}
}
}
@Override
public Response getTrainTypeByTripId(String tripId, HttpHeaders headers) {
TripId tripId1 = new TripId(tripId);
TrainType trainType = null;
Trip trip = repository.findByTripId(tripId1);
if (trip != null) {
trainType = getTrainTypeByName(trip.getTrainTypeName(), headers);
}
else {
TravelServiceImpl.LOGGER.error("[getTrainTypeByTripId[]Get Train Type by Trip id error][Trip not found][TripId: {}]",tripId);
}
if (trainType != null) {
return new Response<>(1, "Success query Train by trip id", trainType);
} else {
TravelServiceImpl.LOGGER.error("[getTrainTypeByTripId][Get Train Type by Trip id error][Train Type not found][TripId: {}]",tripId);
return new Response<>(0, noCnontent, null);
}
}
@Override
public Response getTripByRoute(ArrayList<String> routeIds, HttpHeaders headers) {
ArrayList<ArrayList<Trip>> tripList = new ArrayList<>();
for (String routeId : routeIds) {
ArrayList<Trip> tempTripList = repository.findByRouteId(routeId);
if (tempTripList == null) {
tempTripList = new ArrayList<>();
}
tripList.add(tempTripList);
}
if (!tripList.isEmpty()) {
return new Response<>(1, success, tripList);
} else {
TravelServiceImpl.LOGGER.warn("[getTripByRoute][Get Trips by Route ids warn][Trips not found][RouteIdNumber: {}]",routeIds.size());
return new Response<>(0, noCnontent, null);
}
}
@Override
public Response create(edu.fudan.common.entity.TravelInfo info, HttpHeaders headers) {
TripId ti = new TripId(info.getTripId());
if (repository.findByTripId(ti) == null) {
Trip trip = new Trip(ti, info.getTrainTypeName(), info.getStartStationName(),
info.getStationsName(), info.getTerminalStationName(), info.getStartTime(), info.getEndTime());
trip.setRouteId(info.getRouteId());
repository.save(trip);
return new Response<>(1, "Create trip info:" + ti.toString() + ".", null);
} else {
TravelServiceImpl.LOGGER.error("[getTripByRoute][Create trip error][Trip already exists][TripId: {}]",info.getTripId());
return new Response<>(1, "Trip " + info.getTripId() + " already exists", null);
}
}
@Override
public Response retrieve(String tripId, HttpHeaders headers) {
TripId ti = new TripId(tripId);
Trip trip = repository.findByTripId(ti);
if (trip != null) {
return new Response<>(1, "Search Trip Success by Trip Id " + tripId, trip);
} else {
TravelServiceImpl.LOGGER.error("[retrieve][Retrieve trip error][Trip not found][TripId: {}]",tripId);
return new Response<>(0, "No Content according to tripId" + tripId, null);
}
}
@Override
public Response update(edu.fudan.common.entity.TravelInfo info, HttpHeaders headers) {
TripId ti = new TripId(info.getTripId());
Trip t = repository.findByTripId(ti);
if (t != null) {
t.setStartStationName(info.getTrainTypeName());
t.setStartStationName( info.getStartStationName());
t.setStationsName(info.getStationsName());
t.setTerminalStationName(info.getTerminalStationName());
t.setStartTime(info.getStartTime());
t.setEndTime(info.getEndTime());
t.setRouteId(info.getRouteId());
repository.save(t);
return new Response<>(1, "Update trip info:" + ti.toString(), t);
} else {
TravelServiceImpl.LOGGER.error("[update][Update trip error][Trip not found][TripId: {}]",info.getTripId());
return new Response<>(1, "Trip" + info.getTripId() + "doesn 't exists", null);
}
}
@Override
@Transactional
public Response delete(String tripId, HttpHeaders headers) {
TripId ti = new TripId(tripId);
if (repository.findByTripId(ti) != null) {
repository.deleteByTripId(ti);
return new Response<>(1, "Delete trip:" + tripId + ".", tripId);
} else {
TravelServiceImpl.LOGGER.error("[delete][Delete trip error][Trip not found][TripId: {}]",tripId);
return new Response<>(0, "Trip " + tripId + " doesn't exist.", null);
}
}
@Override
public Response queryByBatch(TripInfo info, HttpHeaders headers) {
//Gets the start and arrival stations of the train number to query. The originating and arriving stations received here are both station names, so two requests need to be sent to convert to station ids
String startPlaceName = info.getStartPlace();
String endPlaceName = info.getEndPlace();
//This is the final result
List<TripResponse> list = new ArrayList<>();
//Check all train info
List<Trip> allTripList = repository.findAll();
list = getTicketsByBatch(allTripList, startPlaceName, endPlaceName, info.getDepartureTime(), headers);
return new Response<>(1, success, list);
}
@Override
public Response query(TripInfo info, HttpHeaders headers) {
//Gets the start and arrival stations of the train number to query. The originating and arriving stations received here are both station names, so two requests need to be sent to convert to station ids
String StartPlaceName = info.getStartPlace();
String endPlaceName = info.getEndPlace();
//This is the final result
ArrayList<TripResponse> list = new ArrayList<>();
//Check all train info
ArrayList<Trip> allTripList = repository.findAll();
if(allTripList != null){
for (Trip tempTrip : allTripList) {
//Get the detailed route list of this train
TripResponse response = getTickets(tempTrip, null, StartPlaceName, endPlaceName, info.getDepartureTime(), headers);
if (response == null) {
TravelServiceImpl.LOGGER.warn("[query][Query trip error][Tickets not found][start: {},end: {},time: {}]", StartPlaceName, endPlaceName, info.getDepartureTime());
}else{
list.add(response);
}
}
}
return new Response<>(1, "Success Query", list);
}
@Override
public Response getTripAllDetailInfo(TripAllDetailInfo gtdi, HttpHeaders headers) {
TripAllDetail gtdr = new TripAllDetail();
TravelServiceImpl.LOGGER.debug("[getTripAllDetailInfo][gtdi info: {}]", gtdi.toString());
Trip trip = repository.findByTripId(new TripId(gtdi.getTripId()));
if (trip == null) {
gtdr.setTripResponse(null);
gtdr.setTrip(null);
TravelServiceImpl.LOGGER.error("[getTripAllDetailInfo][Get trip detail error][Trip not found][TripId: {}]",gtdi.getTripId());
return new Response<>(0, "Trip not found", gtdr);
} else {
String endPlaceName = gtdi.getTo();
String StartPlaceName = gtdi.getFrom();
TripResponse tripResponse = getTickets(trip, null, gtdi.getFrom(), gtdi.getTo(), gtdi.getTravelDate(), headers);
if (tripResponse == null) {
gtdr.setTrip(null);
gtdr.setTripResponse(null);
TravelServiceImpl.LOGGER.warn("[getTripAllDetailInfo][Query trip error][Tickets not found][start: {},end: {}]", gtdi.getTo(), gtdi.getFrom());
return new Response<>(0, "getTickets failed", gtdr);
} else {
gtdr.setTripResponse(tripResponse);
gtdr.setTrip(repository.findByTripId(new TripId(gtdi.getTripId())));
}
}
return new Response<>(1, success, gtdr);
}
private List<TripResponse> getTicketsByBatch(List<Trip> trips, String startPlaceName, String endPlaceName, String departureTime, HttpHeaders headers) {
List<TripResponse> responses = new ArrayList<>();
//Determine if the date checked is the same day and after
if (!afterToday(departureTime)) {
TravelServiceImpl.LOGGER.info("[getTickets][depaturetime not vailid][departuretime: {}]", departureTime);
return responses;
}
List<Travel> infos = new ArrayList<>();
Map<String, Trip> tripMap = new HashMap<>();
for(Trip trip: trips){
Travel query = new Travel();
query.setTrip(trip);
query.setStartPlace(startPlaceName);
query.setEndPlace(endPlaceName);
query.setDepartureTime(departureTime);
infos.add(query);
tripMap.put(trip.getTripId().toString(), trip);
}
TravelServiceImpl.LOGGER.info("[getTicketsByBatch][before get basic][trips: {}]", trips);
HttpEntity requestEntity = new HttpEntity(infos, null);
String basic_service_url = getServiceUrl("ts-basic-service");
ResponseEntity<Response> re = restTemplate.exchange(
basic_service_url + "/api/v1/basicservice/basic/travels",
HttpMethod.POST,
requestEntity,
Response.class);
Response r = re.getBody();
if(r.getStatus() == 0){
TravelServiceImpl.LOGGER.info("[getTicketsByBatch][Ts-basic-service response status is 0][response is: {}]", r);
return responses;
}
Map<String, TravelResult> trMap;
ObjectMapper mapper = new ObjectMapper();
try{
trMap = mapper.readValue(JsonUtils.object2Json(r.getData()), new TypeReference<Map<String, TravelResult>>(){});
}catch(Exception e) {
TravelServiceImpl.LOGGER.warn("[getTicketsByBatch][Ts-basic-service convert data failed][Fail msg: {}]", e.getMessage());
return responses;
}
for(Map.Entry<String, TravelResult> trEntry: trMap.entrySet()){
//Set the returned ticket information
String tripNumber = trEntry.getKey();
TravelResult tr = trEntry.getValue();
Trip trip = tripMap.get(tripNumber);
TripResponse response = setResponse(trip, tr, startPlaceName, endPlaceName, departureTime, headers);
responses.add(response);
}
return responses;
}
private TripResponse getTickets(Trip trip, Route route1, String startPlaceName, String endPlaceName, String departureTime, HttpHeaders headers) {
//Determine if the date checked is the same day and after
if (!afterToday(departureTime)) {
return null;
}
Travel query = new Travel();
query.setTrip(trip);
query.setStartPlace(startPlaceName);
query.setEndPlace(endPlaceName);
query.setDepartureTime(departureTime);
HttpEntity requestEntity = new HttpEntity(query, null);
String basic_service_url = getServiceUrl("ts-basic-service");
ResponseEntity<Response<TravelResult>> re = restTemplate.exchange(
basic_service_url + "/api/v1/basicservice/basic/travel",
HttpMethod.POST,
requestEntity,
new ParameterizedTypeReference<Response<edu.fudan.common.entity.TravelResult>>() {
});
Response r = re.getBody();
if(r.getStatus() == 0){
TravelServiceImpl.LOGGER.info("[getTickets][Ts-basic-service response status is 0][response is: {}]", r);
return null;
}
TravelResult resultForTravel = re.getBody().getData();
//Set the returned ticket information
return setResponse(trip, resultForTravel, startPlaceName, endPlaceName, departureTime, headers);
}
private TripResponse setResponse(Trip trip, TravelResult tr, String startPlaceName, String endPlaceName, String departureTime, HttpHeaders headers){
//Set the returned ticket information
TripResponse response = new TripResponse();
response.setConfortClass(50);
response.setEconomyClass(50);
Route route = tr.getRoute();
List<String> stationList = route.getStations();
int firstClassTotalNum = tr.getTrainType().getConfortClass();
int secondClassTotalNum = tr.getTrainType().getEconomyClass();
int first = getRestTicketNumber(departureTime, trip.getTripId().toString(),
startPlaceName, endPlaceName, SeatClass.FIRSTCLASS.getCode(), firstClassTotalNum, stationList, headers);
int second = getRestTicketNumber(departureTime, trip.getTripId().toString(),
startPlaceName, endPlaceName, SeatClass.SECONDCLASS.getCode(), secondClassTotalNum, stationList, headers);
response.setConfortClass(first);
response.setEconomyClass(second);
response.setStartStation(startPlaceName);
response.setTerminalStation(endPlaceName);
//Calculate the distance from the starting point
int indexStart = route.getStations().indexOf(startPlaceName);
int indexEnd = route.getStations().indexOf(endPlaceName);
int distanceStart = route.getDistances().get(indexStart) - route.getDistances().get(0);
int distanceEnd = route.getDistances().get(indexEnd) - route.getDistances().get(0);
TrainType trainType = tr.getTrainType();
//Train running time is calculated according to the average running speed of the train
int minutesStart = 60 * distanceStart / trainType.getAverageSpeed();
int minutesEnd = 60 * distanceEnd / trainType.getAverageSpeed();
Calendar calendarStart = Calendar.getInstance();
calendarStart.setTime(StringUtils.String2Date(trip.getStartTime()));
calendarStart.add(Calendar.MINUTE, minutesStart);
response.setStartTime(StringUtils.Date2String(calendarStart.getTime()));
TravelServiceImpl.LOGGER.info("[getTickets][Calculate distance][calculate time：{} time: {}]", minutesStart, calendarStart.getTime());
Calendar calendarEnd = Calendar.getInstance();
calendarEnd.setTime(StringUtils.String2Date(trip.getStartTime()));
calendarEnd.add(Calendar.MINUTE, minutesEnd);
response.setEndTime(StringUtils.Date2String(calendarEnd.getTime()));
TravelServiceImpl.LOGGER.info("[getTickets][Calculate distance][calculate time：{} time: {}]", minutesEnd, calendarEnd.getTime());
response.setTripId(trip.getTripId());
response.setTrainTypeName(trip.getTrainTypeName());
response.setPriceForConfortClass(tr.getPrices().get("confortClass"));
response.setPriceForEconomyClass(tr.getPrices().get("economyClass"));
return response;
}
@Override
public Response queryAll(HttpHeaders headers) {
List<Trip> tripList = repository.findAll();
if (tripList != null && !tripList.isEmpty()) {
return new Response<>(1, success, tripList);
}
TravelServiceImpl.LOGGER.warn("[queryAll][Query all trips warn][{}]","No Content");
return new Response<>(0, noCnontent, null);
}
private static boolean afterToday(String date) {
Calendar calDateA = Calendar.getInstance();
Date today = new Date();
calDateA.setTime(today);
Calendar calDateB = Calendar.getInstance();
calDateB.setTime(StringUtils.String2Date(date));
if (calDateA.get(Calendar.YEAR) > calDateB.get(Calendar.YEAR)) {
return false;
} else if (calDateA.get(Calendar.YEAR) == calDateB.get(Calendar.YEAR)) {
if (calDateA.get(Calendar.MONTH) > calDateB.get(Calendar.MONTH)) {
return false;
} else if (calDateA.get(Calendar.MONTH) == calDateB.get(Calendar.MONTH)) {
return calDateA.get(Calendar.DAY_OF_MONTH) <= calDateB.get(Calendar.DAY_OF_MONTH);
} else {
return true;
}
} else {
return true;
}
}
private TrainType getTrainTypeByName(String trainTypeName, HttpHeaders headers) {
HttpEntity requestEntity = new HttpEntity(null);
String train_service_url = getServiceUrl("ts-train-service");
ResponseEntity<Response<TrainType>> re = restTemplate.exchange(
train_service_url + "/api/v1/trainservice/trains/byName/" + trainTypeName,
HttpMethod.GET,
requestEntity,
new ParameterizedTypeReference<Response<TrainType>>() {
});
return re.getBody().getData();
}
private Route getRouteByRouteId(String routeId, HttpHeaders headers) {
TravelServiceImpl.LOGGER.debug("[getRouteByRouteId][Get Route By Id][Route ID：{}]", routeId);
HttpEntity requestEntity = new HttpEntity(null);
String route_service_url = getServiceUrl("ts-route-service");
ResponseEntity<Response> re = restTemplate.exchange(
route_service_url + "/api/v1/routeservice/routes/" + routeId,
HttpMethod.GET,
requestEntity,
Response.class);
Response result = re.getBody();
if (result.getStatus() == 0 ) {
TravelServiceImpl.LOGGER.error("[getRouteByRouteId][Get Route By Id Fail][Route not found][RouteId: {}]", routeId);
return null;
} else {
TravelServiceImpl.LOGGER.info("[getRouteByRouteId][Get Route By Id Success]");
return JsonUtils.conveterObject(result.getData(), Route.class);
}
}
private int getRestTicketNumber(String travelDate, String trainNumber, String startStationName, String endStationName, int seatType, int totalNum, List<String> stationList, HttpHeaders headers) {
Seat seatRequest = new Seat();
seatRequest.setDestStation(endStationName);
seatRequest.setStartStation(startStationName);
seatRequest.setTrainNumber(trainNumber);
seatRequest.setTravelDate(travelDate);
seatRequest.setSeatType(seatType);
seatRequest.setTotalNum(totalNum);
seatRequest.setStations(stationList);
TravelServiceImpl.LOGGER.info("[getRestTicketNumber][Seat request][request: {}]", seatRequest.toString());
HttpEntity requestEntity = new HttpEntity(seatRequest, null);
String seat_service_url = getServiceUrl("ts-seat-service");
ResponseEntity<Response<Integer>> re = restTemplate.exchange(
seat_service_url + "/api/v1/seatservice/seats/left_tickets",
HttpMethod.POST,
requestEntity,
new ParameterizedTypeReference<Response<Integer>>() {
});
TravelServiceImpl.LOGGER.info("[getRestTicketNumber][Get Rest tickets num][num is: {}]", re.getBody().toString());
return re.getBody().getData();
}
@Override
public Response adminQueryAll(HttpHeaders headers) {
List<Trip> trips = repository.findAll();
ArrayList<AdminTrip> adminTrips = new ArrayList<>();
if(trips != null){
for (Trip trip : trips) {
AdminTrip adminTrip = new AdminTrip();
adminTrip.setRoute(getRouteByRouteId(trip.getRouteId(), headers));
adminTrip.setTrainType(getTrainTypeByName(trip.getTrainTypeName(), headers));
adminTrip.setTrip(trip);
adminTrips.add(adminTrip);
}
}
if (!adminTrips.isEmpty()) {
return new Response<>(1, "Travel Service Admin Query All Travel Success", adminTrips);
} else {
TravelServiceImpl.LOGGER.warn("[adminQueryAll][Admin query all trips warn][{}]","No Content");
return new Response<>(0, noCnontent, null);
}
}
}
| 22,486 | 44.154618 | 209 |
java
|
train-ticket
|
train-ticket-master/ts-travel2-service/src/test/java/travel2/controller/TravelControllerTest.java
|
package travel2.controller;
import com.alibaba.fastjson.JSONObject;
import edu.fudan.common.util.Response;
import org.junit.Assert;
import org.junit.Before;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.junit.runners.JUnit4;
import org.mockito.InjectMocks;
import org.mockito.Mock;
import org.mockito.Mockito;
import org.mockito.MockitoAnnotations;
import org.springframework.http.*;
import org.springframework.test.web.servlet.MockMvc;
import org.springframework.test.web.servlet.request.MockMvcRequestBuilders;
import org.springframework.test.web.servlet.result.MockMvcResultMatchers;
import org.springframework.test.web.servlet.setup.MockMvcBuilders;
import edu.fudan.common.entity.TravelInfo;
import edu.fudan.common.entity.TripAllDetailInfo;
import edu.fudan.common.entity.TripInfo;
import edu.fudan.common.entity.TripResponse;
import travel2.service.TravelService;
import java.util.ArrayList;
import java.util.Date;
@RunWith(JUnit4.class)
public class TravelControllerTest {
@InjectMocks
private Travel2Controller travel2Controller;
@Mock
private TravelService service;
private MockMvc mockMvc;
private Response response = new Response();
@Before
public void setUp() {
MockitoAnnotations.initMocks(this);
mockMvc = MockMvcBuilders.standaloneSetup(travel2Controller).build();
}
@Test
public void testHome() throws Exception {
mockMvc.perform(MockMvcRequestBuilders.get("/api/v1/travel2service/welcome"))
.andExpect(MockMvcResultMatchers.status().isOk())
.andExpect(MockMvcResultMatchers.content().string("Welcome to [ Travle2 Service ] !"));
}
@Test
public void testGetTrainTypeByTripId() throws Exception {
Mockito.when(service.getTrainTypeByTripId(Mockito.anyString(), Mockito.any(HttpHeaders.class))).thenReturn(response);
String result = mockMvc.perform(MockMvcRequestBuilders.get("/api/v1/travel2service/train_types/trip_id"))
.andExpect(MockMvcResultMatchers.status().isOk())
.andReturn().getResponse().getContentAsString();
Assert.assertEquals(response, JSONObject.parseObject(result, Response.class));
}
@Test
public void testGetRouteByTripId() throws Exception {
Mockito.when(service.getRouteByTripId(Mockito.anyString(), Mockito.any(HttpHeaders.class))).thenReturn(response);
String result = mockMvc.perform(MockMvcRequestBuilders.get("/api/v1/travel2service/routes/trip_id"))
.andExpect(MockMvcResultMatchers.status().isOk())
.andReturn().getResponse().getContentAsString();
Assert.assertEquals(response, JSONObject.parseObject(result, Response.class));
}
@Test
public void testGetTripsByRouteId() throws Exception {
ArrayList<String> routeIds = new ArrayList<>();
Mockito.when(service.getTripByRoute(Mockito.any(ArrayList.class), Mockito.any(HttpHeaders.class))).thenReturn(response);
String requestJson = JSONObject.toJSONString(routeIds);
String result = mockMvc.perform(MockMvcRequestBuilders.post("/api/v1/travel2service/trips/routes").contentType(MediaType.APPLICATION_JSON).content(requestJson))
.andExpect(MockMvcResultMatchers.status().isOk())
.andReturn().getResponse().getContentAsString();
Assert.assertEquals(response, JSONObject.parseObject(result, Response.class));
}
@Test
public void testCreateTrip() throws Exception {
TravelInfo routeIds = new TravelInfo();
Mockito.when(service.create(Mockito.any(TravelInfo.class), Mockito.any(HttpHeaders.class))).thenReturn(response);
String requestJson = JSONObject.toJSONString(routeIds);
String result = mockMvc.perform(MockMvcRequestBuilders.post("/api/v1/travel2service/trips").contentType(MediaType.APPLICATION_JSON).content(requestJson))
.andExpect(MockMvcResultMatchers.status().isCreated())
.andReturn().getResponse().getContentAsString();
Assert.assertEquals(response, JSONObject.parseObject(result, Response.class));
}
@Test
public void testRetrieve() throws Exception {
Mockito.when(service.retrieve(Mockito.anyString(), Mockito.any(HttpHeaders.class))).thenReturn(response);
String result = mockMvc.perform(MockMvcRequestBuilders.get("/api/v1/travel2service/trips/trip_id"))
.andExpect(MockMvcResultMatchers.status().isOk())
.andReturn().getResponse().getContentAsString();
Assert.assertEquals(response, JSONObject.parseObject(result, Response.class));
}
@Test
public void testUpdateTrip() throws Exception {
TravelInfo info = new TravelInfo();
Mockito.when(service.update(Mockito.any(TravelInfo.class), Mockito.any(HttpHeaders.class))).thenReturn(response);
String requestJson = JSONObject.toJSONString(info);
String result = mockMvc.perform(MockMvcRequestBuilders.put("/api/v1/travel2service/trips").contentType(MediaType.APPLICATION_JSON).content(requestJson))
.andExpect(MockMvcResultMatchers.status().isOk())
.andReturn().getResponse().getContentAsString();
Assert.assertEquals(response, JSONObject.parseObject(result, Response.class));
}
@Test
public void testDeleteTrip() throws Exception {
Mockito.when(service.delete(Mockito.anyString(), Mockito.any(HttpHeaders.class))).thenReturn(response);
String result = mockMvc.perform(MockMvcRequestBuilders.delete("/api/v1/travel2service/trips/trip_id"))
.andExpect(MockMvcResultMatchers.status().isOk())
.andReturn().getResponse().getContentAsString();
Assert.assertEquals(response, JSONObject.parseObject(result, Response.class));
}
@Test
public void testQueryInfo1() throws Exception {
TripInfo info = new TripInfo();
ArrayList<TripResponse> errorList = new ArrayList<>();
String requestJson = JSONObject.toJSONString(info);
String result = mockMvc.perform(MockMvcRequestBuilders.post("/api/v1/travel2service/trips/left").contentType(MediaType.APPLICATION_JSON).content(requestJson))
.andExpect(MockMvcResultMatchers.status().isOk())
.andReturn().getResponse().getContentAsString();
Assert.assertEquals(errorList, JSONObject.parseObject(result, ArrayList.class));
}
@Test
public void testQueryInfo2() throws Exception {
TripInfo info = new TripInfo("startPlace", "endPlace", "");
Mockito.when(service.query(Mockito.any(TripInfo.class), Mockito.any(HttpHeaders.class))).thenReturn(response);
String requestJson = JSONObject.toJSONString(info);
String result = mockMvc.perform(MockMvcRequestBuilders.post("/api/v1/travel2service/trips/left").contentType(MediaType.APPLICATION_JSON).content(requestJson))
.andExpect(MockMvcResultMatchers.status().isOk())
.andReturn().getResponse().getContentAsString();
Assert.assertEquals(response, JSONObject.parseObject(result, Response.class));
}
@Test
public void testGetTripAllDetailInfo() throws Exception {
TripAllDetailInfo gtdi = new TripAllDetailInfo();
Mockito.when(service.getTripAllDetailInfo(Mockito.any(TripAllDetailInfo.class), Mockito.any(HttpHeaders.class))).thenReturn(response);
String requestJson = JSONObject.toJSONString(gtdi);
String result = mockMvc.perform(MockMvcRequestBuilders.post("/api/v1/travel2service/trip_detail").contentType(MediaType.APPLICATION_JSON).content(requestJson))
.andExpect(MockMvcResultMatchers.status().isOk())
.andReturn().getResponse().getContentAsString();
Assert.assertEquals(response, JSONObject.parseObject(result, Response.class));
}
@Test
public void testQueryAll() throws Exception {
Mockito.when(service.queryAll(Mockito.any(HttpHeaders.class))).thenReturn(response);
String result = mockMvc.perform(MockMvcRequestBuilders.get("/api/v1/travel2service/trips"))
.andExpect(MockMvcResultMatchers.status().isOk())
.andReturn().getResponse().getContentAsString();
Assert.assertEquals(response, JSONObject.parseObject(result, Response.class));
}
@Test
public void testAdminQueryAll() throws Exception {
Mockito.when(service.adminQueryAll(Mockito.any(HttpHeaders.class))).thenReturn(response);
String result = mockMvc.perform(MockMvcRequestBuilders.get("/api/v1/travel2service/admin_trip"))
.andExpect(MockMvcResultMatchers.status().isOk())
.andReturn().getResponse().getContentAsString();
Assert.assertEquals(response, JSONObject.parseObject(result, Response.class));
}
}
| 8,853 | 50.179191 | 168 |
java
|
train-ticket
|
train-ticket-master/ts-travel2-service/src/test/java/travel2/service/TravelServiceImplTest.java
|
package travel2.service;
import edu.fudan.common.entity.TripId;
import edu.fudan.common.entity.TripAllDetailInfo;
import edu.fudan.common.entity.TripInfo;
import edu.fudan.common.util.Response;
import edu.fudan.common.util.StringUtils;
import org.junit.Assert;
import org.junit.Before;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.junit.runners.JUnit4;
import org.mockito.InjectMocks;
import org.mockito.Mock;
import org.mockito.Mockito;
import org.mockito.MockitoAnnotations;
import org.springframework.core.ParameterizedTypeReference;
import org.springframework.http.*;
import org.springframework.web.client.RestTemplate;
import travel2.entity.Trip;
import travel2.repository.TripRepository;
import java.util.ArrayList;
import java.util.Date;
@RunWith(JUnit4.class)
public class TravelServiceImplTest {
@InjectMocks
private TravelServiceImpl travel2ServiceImpl;
@Mock
private TripRepository repository;
@Mock
private RestTemplate restTemplate;
private HttpHeaders headers = new HttpHeaders();
String success = "Success";
String noCnontent = "No Content";
@Before
public void setUp() {
MockitoAnnotations.initMocks(this);
}
@Test
public void testGetRouteByTripId1() {
Mockito.when(repository.findByTripId(Mockito.any(TripId.class))).thenReturn(null);
Response result = travel2ServiceImpl.getRouteByTripId("K1255", headers);
Assert.assertEquals(new Response<>(0, "\"[Get Route By Trip ID] Trip Not Found:\" + tripId", null), result);
}
@Test
public void testGetRouteByTripId2() {
Trip trip = new Trip();
Mockito.when(repository.findByTripId(Mockito.any(TripId.class))).thenReturn(trip);
//mock getRouteByRouteId()
edu.fudan.common.entity.Route route = new edu.fudan.common.entity.Route();
Response response = new Response(1, null, route);
ResponseEntity<Response> re = new ResponseEntity<>(response, HttpStatus.OK);
Mockito.when(restTemplate.exchange(
Mockito.anyString(),
Mockito.any(HttpMethod.class),
Mockito.any(HttpEntity.class),
Mockito.any(Class.class)))
.thenReturn(re);
Response result = travel2ServiceImpl.getRouteByTripId("K1255", headers);
Assert.assertEquals("[Get Route By Trip ID] Success", result.getMsg());
}
@Test
public void testGetTrainTypeByTripId() {
Trip trip = new Trip();
Mockito.when(repository.findByTripId(Mockito.any(TripId.class))).thenReturn(trip);
//mock getTrainType()
edu.fudan.common.entity.TrainType trainType = new edu.fudan.common.entity.TrainType();
Response<edu.fudan.common.entity.TrainType> response = new Response<>(null, null, trainType);
ResponseEntity<Response<edu.fudan.common.entity.TrainType>> re = new ResponseEntity<>(response, HttpStatus.OK);
Mockito.when(restTemplate.exchange(
Mockito.anyString(),
Mockito.any(HttpMethod.class),
Mockito.any(HttpEntity.class),
Mockito.any(ParameterizedTypeReference.class)))
.thenReturn(re);
Response result = travel2ServiceImpl.getTrainTypeByTripId("K1255", headers);
Assert.assertEquals(new Response<>(1, "Success query Train by trip id", trainType), result);
}
@Test
public void testGetTripByRoute1() {
ArrayList<String> routeIds = new ArrayList<>();
Response result = travel2ServiceImpl.getTripByRoute(routeIds, headers);
Assert.assertEquals(new Response<>(0, noCnontent, null), result);
}
@Test
public void testGetTripByRoute2() {
ArrayList<String> routeIds = new ArrayList<>();
routeIds.add("route_id_1");
Mockito.when(repository.findByRouteId(Mockito.anyString())).thenReturn(null);
Response result = travel2ServiceImpl.getTripByRoute(routeIds, headers);
Assert.assertEquals(success, result.getMsg());
}
@Test
public void testCreate1() {
edu.fudan.common.entity.TravelInfo info = new edu.fudan.common.entity.TravelInfo();
info.setTripId("Z");
Mockito.when(repository.findByTripId(Mockito.any(TripId.class))).thenReturn(null);
Mockito.when(repository.save(Mockito.any(Trip.class))).thenReturn(null);
Response result = travel2ServiceImpl.create(info, headers);
Assert.assertEquals(new Response<>(1, "Create trip info:Z.", null), result);
}
@Test
public void testCreate2() {
edu.fudan.common.entity.TravelInfo info = new edu.fudan.common.entity.TravelInfo();
info.setTripId("Z");
Trip trip = new Trip();
Mockito.when(repository.findByTripId(Mockito.any(TripId.class))).thenReturn(trip);
Response result = travel2ServiceImpl.create(info, headers);
Assert.assertEquals(new Response<>(1, "Trip Z already exists", null), result);
}
@Test
public void testRetrieve1() {
Trip trip = new Trip();
Mockito.when(repository.findByTripId(Mockito.any(TripId.class))).thenReturn(trip);
Response result = travel2ServiceImpl.retrieve("trip_id_1", headers);
Assert.assertEquals(new Response<>(1, "Search Trip Success by Trip Id trip_id_1", trip), result);
}
@Test
public void testRetrieve2() {
Trip trip = new Trip();
Mockito.when(repository.findByTripId(Mockito.any(TripId.class))).thenReturn(trip);
Response result = travel2ServiceImpl.retrieve("trip_id_1", headers);
Assert.assertEquals(new Response<>(1, "Search Trip Success by Trip Id trip_id_1", trip), result);
}
@Test
public void testUpdate1() {
edu.fudan.common.entity.TravelInfo info = new edu.fudan.common.entity.TravelInfo();
info.setTripId("Z");
Trip trip = new Trip();
Mockito.when(repository.findByTripId(Mockito.any(TripId.class))).thenReturn(trip);
Mockito.when(repository.save(Mockito.any(Trip.class))).thenReturn(null);
Response result = travel2ServiceImpl.update(info, headers);
Assert.assertEquals("Update trip info:Z", result.getMsg());
}
@Test
public void testUpdate2() {
edu.fudan.common.entity.TravelInfo info = new edu.fudan.common.entity.TravelInfo();
info.setTripId("Z");
Mockito.when(repository.findByTripId(Mockito.any(TripId.class))).thenReturn(null);
Response result = travel2ServiceImpl.update(info, headers);
Assert.assertEquals(new Response<>(1, "TripZdoesn 't exists", null), result);
}
@Test
public void testDelete1() {
Trip trip = new Trip();
Mockito.when(repository.findByTripId(Mockito.any(TripId.class))).thenReturn(trip);
Mockito.doNothing().doThrow(new RuntimeException()).when(repository).deleteByTripId(Mockito.any(TripId.class));
Response result = travel2ServiceImpl.delete("trip_id_1", headers);
Assert.assertEquals(new Response<>(1, "Delete trip:trip_id_1.", "trip_id_1"), result);
}
@Test
public void testDelete2() {
Mockito.when(repository.findByTripId(Mockito.any(TripId.class))).thenReturn(null);
Response result = travel2ServiceImpl.delete("trip_id_1", headers);
Assert.assertEquals(new Response<>(0, "Trip trip_id_1 doesn't exist.", null), result);
}
@Test
public void testQuery() {
TripInfo info = new TripInfo();
//mock queryForStationId()
Response<String> response1 = new Response<>(null, null, "");
ResponseEntity<Response<String>> re1 = new ResponseEntity<>(response1, HttpStatus.OK);
Mockito.when(restTemplate.exchange(
Mockito.anyString(),
Mockito.any(HttpMethod.class),
Mockito.any(HttpEntity.class),
Mockito.any(ParameterizedTypeReference.class)))
.thenReturn(re1);
ArrayList<Trip> tripList = new ArrayList<>();
Trip trip = new Trip();
trip.setRouteId("route_id");
tripList.add(trip);
Mockito.when(repository.findAll()).thenReturn(tripList);
//mock getRouteByRouteId()
edu.fudan.common.entity.Route route = new edu.fudan.common.entity.Route();
route.setStations(new ArrayList<>());
Response response2 = new Response(1, null, route);
ResponseEntity<Response> re2 = new ResponseEntity<>(response2, HttpStatus.OK);
Mockito.when(restTemplate.exchange(
Mockito.anyString(),
Mockito.any(HttpMethod.class),
Mockito.any(HttpEntity.class),
Mockito.any(Class.class)))
.thenReturn(re2);
Response result = travel2ServiceImpl.query(info, headers);
Assert.assertEquals(new Response<>(1, "Success Query", new ArrayList<>()), result);
}
@Test
public void testGetTripAllDetailInfo() {
TripAllDetailInfo gtdi = new TripAllDetailInfo();
gtdi.setTripId("Z1255");
gtdi.setFrom("from_station");
gtdi.setTo("to_station");
gtdi.setTravelDate(StringUtils.Date2String(new Date(System.currentTimeMillis() - 86400000)));
Trip trip = new Trip();
trip.setRouteId("route_id");
Mockito.when(repository.findByTripId(Mockito.any(TripId.class))).thenReturn(trip);
//mock queryForStationId()
Response<String> response1 = new Response<>(null, null, "");
ResponseEntity<Response<String>> re1 = new ResponseEntity<>(response1, HttpStatus.OK);
Mockito.when(restTemplate.exchange(
Mockito.anyString(),
Mockito.any(HttpMethod.class),
Mockito.any(HttpEntity.class),
Mockito.any(ParameterizedTypeReference.class)))
.thenReturn(re1);
//mock getRouteByRouteId()
edu.fudan.common.entity.Route route = new edu.fudan.common.entity.Route();
route.setStations(new ArrayList<>());
Response response2 = new Response(1, null, route);
ResponseEntity<Response> re2 = new ResponseEntity<>(response2, HttpStatus.OK);
Mockito.when(restTemplate.exchange(
Mockito.anyString(),
Mockito.any(HttpMethod.class),
Mockito.any(HttpEntity.class),
Mockito.any(Class.class)))
.thenReturn(re2);
Response result = travel2ServiceImpl.getTripAllDetailInfo(gtdi, headers);
Assert.assertEquals("Success", result.getMsg());
}
@Test
public void testQueryAll1() {
ArrayList<Trip> tripList = new ArrayList<>();
tripList.add(new Trip());
Mockito.when(repository.findAll()).thenReturn(tripList);
Response result = travel2ServiceImpl.queryAll(headers);
Assert.assertEquals(new Response<>(1, success, tripList), result);
}
@Test
public void testQueryAll2() {
Mockito.when(repository.findAll()).thenReturn(null);
Response result = travel2ServiceImpl.queryAll(headers);
Assert.assertEquals(new Response<>(0, noCnontent, null), result);
}
@Test
public void testAdminQueryAll1() {
ArrayList<Trip> tripList = new ArrayList<>();
Trip trip = new Trip();
trip.setRouteId("route_id");
tripList.add(trip);
Mockito.when(repository.findAll()).thenReturn(tripList);
//mock getRouteByRouteId()
edu.fudan.common.entity.Route route = new edu.fudan.common.entity.Route();
Response response2 = new Response(1, null, route);
ResponseEntity<Response> re2 = new ResponseEntity<>(response2, HttpStatus.OK);
Mockito.when(restTemplate.exchange(
Mockito.anyString(),
Mockito.any(HttpMethod.class),
Mockito.any(HttpEntity.class),
Mockito.any(Class.class)))
.thenReturn(re2);
//mock getTrainType()
edu.fudan.common.entity.TrainType trainType = new edu.fudan.common.entity.TrainType();
Response<edu.fudan.common.entity.TrainType> response = new Response<>(null, null, trainType);
ResponseEntity<Response<edu.fudan.common.entity.TrainType>> re = new ResponseEntity<>(response, HttpStatus.OK);
Mockito.when(restTemplate.exchange(
Mockito.anyString(),
Mockito.any(HttpMethod.class),
Mockito.any(HttpEntity.class),
Mockito.any(ParameterizedTypeReference.class)))
.thenReturn(re);
Response result = travel2ServiceImpl.adminQueryAll(headers);
Assert.assertEquals("Travel Service Admin Query All Travel Success", result.getMsg());
}
@Test
public void testAdminQueryAll2() {
ArrayList<Trip> tripList = new ArrayList<>();
Mockito.when(repository.findAll()).thenReturn(tripList);
Response result = travel2ServiceImpl.adminQueryAll(headers);
Assert.assertEquals(new Response<>(0, noCnontent, null), result);
}
}
| 13,042 | 41.624183 | 119 |
java
|
train-ticket
|
train-ticket-master/ts-user-service/src/main/java/user/UserApplication.java
|
package user;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.boot.web.client.RestTemplateBuilder;
import org.springframework.cloud.client.discovery.EnableDiscoveryClient;
import org.springframework.cloud.client.loadbalancer.LoadBalanced;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.EnableAspectJAutoProxy;
import org.springframework.integration.annotation.IntegrationComponentScan;
import org.springframework.scheduling.annotation.EnableAsync;
import org.springframework.web.client.RestTemplate;
import springfox.documentation.swagger2.annotations.EnableSwagger2;
/**
* @author fdse
*/
@SpringBootApplication
@EnableAspectJAutoProxy(proxyTargetClass = true)
@EnableAsync
@IntegrationComponentScan
@EnableDiscoveryClient
@EnableSwagger2
public class UserApplication {
public static void main(String[] args) {
SpringApplication.run(UserApplication.class, args);
}
@LoadBalanced
@Bean
public RestTemplate restTemplate(RestTemplateBuilder builder) {
return builder.build();
}
}
| 1,172 | 33.5 | 75 |
java
|
train-ticket
|
train-ticket-master/ts-user-service/src/main/java/user/config/SecurityConfig.java
|
package user.config;
import edu.fudan.common.security.jwt.JWTFilter;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.http.HttpMethod;
import org.springframework.security.config.annotation.method.configuration.EnableGlobalMethodSecurity;
import org.springframework.security.config.annotation.web.builders.HttpSecurity;
import org.springframework.security.config.annotation.web.configuration.EnableWebSecurity;
import org.springframework.security.config.annotation.web.configuration.WebSecurityConfigurerAdapter;
import org.springframework.security.config.http.SessionCreationPolicy;
import org.springframework.security.crypto.bcrypt.BCryptPasswordEncoder;
import org.springframework.security.crypto.password.PasswordEncoder;
import org.springframework.security.web.authentication.UsernamePasswordAuthenticationFilter;
import org.springframework.web.servlet.config.annotation.CorsRegistry;
import org.springframework.web.servlet.config.annotation.WebMvcConfigurer;
import org.springframework.web.servlet.config.annotation.WebMvcConfigurerAdapter;
import static org.springframework.web.cors.CorsConfiguration.ALL;
/**
* @author fdse
*/
@Configuration
@EnableWebSecurity
@EnableGlobalMethodSecurity(prePostEnabled = true)
public class SecurityConfig extends WebSecurityConfigurerAdapter {
/**
* load password encoder
*
* @return PasswordEncoder
*/
@Bean
public PasswordEncoder passwordEncoder() {
return new BCryptPasswordEncoder();
}
/**
* allow cors domain
* header By default, only six fields can be taken from the header, and the other fields can only be specified in the header.
* credentials Cookies are not sent by default and can only be true if a Cookie is needed
* Validity of this request
*
* @return WebMvcConfigurer
*/
@Bean
public WebMvcConfigurer corsConfigurer() {
return new WebMvcConfigurerAdapter() {
@Override
public void addCorsMappings(CorsRegistry registry) {
registry.addMapping("/**")
.allowedOrigins(ALL)
.allowedMethods(ALL)
.allowedHeaders(ALL)
.allowCredentials(false)
.maxAge(3600);
}
};
}
@Override
protected void configure(HttpSecurity httpSecurity) throws Exception {
httpSecurity.httpBasic().disable()
// close default csrf
.csrf().disable()
// close session
.sessionManagement().sessionCreationPolicy(SessionCreationPolicy.STATELESS)
.and()
.authorizeRequests()
.antMatchers("/api/v1/userservice/users/**").permitAll()
.antMatchers(HttpMethod.DELETE, "/api/v1/userservice/users/*").hasAnyRole("ADMIN", "USER")
.antMatchers("/swagger-ui.html", "/webjars/**", "/images/**",
"/configuration/**", "/swagger-resources/**", "/v2/**").permitAll()
.anyRequest().authenticated()
.and()
.addFilterBefore(new JWTFilter(), UsernamePasswordAuthenticationFilter.class);
// close cache
httpSecurity.headers().cacheControl();
}
}
| 3,385 | 39.309524 | 130 |
java
|
train-ticket
|
train-ticket-master/ts-user-service/src/main/java/user/controller/UserController.java
|
package user.controller;
import edu.fudan.common.util.Response;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.http.HttpHeaders;
import org.springframework.http.HttpStatus;
import org.springframework.http.ResponseEntity;
import org.springframework.web.bind.annotation.*;
import user.dto.UserDto;
import user.service.UserService;
import java.util.UUID;
import static org.springframework.http.ResponseEntity.ok;
/**
* @author fdse
*/
@RestController
@RequestMapping("/api/v1/userservice/users")
public class UserController {
@Autowired
private UserService userService;
private static final Logger LOGGER = LoggerFactory.getLogger(UserController.class);
@GetMapping("/hello")
public String testHello() {
return "Hello";
}
@GetMapping
public ResponseEntity<Response> getAllUser(@RequestHeader HttpHeaders headers) {
UserController.LOGGER.info("[getAllUser][Get all user]");
return ok(userService.getAllUsers(headers));
}
@GetMapping("/{userName}")
public ResponseEntity<Response> getUserByUserName(@PathVariable String userName, @RequestHeader HttpHeaders headers) {
UserController.LOGGER.info("[getUserByUserName][Get user by user name][UserName: {}]",userName);
return ok(userService.findByUserName(userName, headers));
}
@GetMapping("/id/{userId}")
public ResponseEntity<Response> getUserByUserId(@PathVariable String userId, @RequestHeader HttpHeaders headers) {
UserController.LOGGER.info("[getUserByUserId][Get user by user id][UserId: {}]",userId);
return ok(userService.findByUserId(userId, headers));
}
@PostMapping("/register")
public ResponseEntity<Response> registerUser(@RequestBody UserDto userDto, @RequestHeader HttpHeaders headers) {
UserController.LOGGER.info("[registerUser][Register user][UserName: {}]",userDto.getUserName());
return ResponseEntity.status(HttpStatus.CREATED).body(userService.saveUser(userDto, headers));
}
@DeleteMapping("/{userId}")
public ResponseEntity<Response> deleteUserById(@PathVariable String userId,
@RequestHeader HttpHeaders headers) {
// only admin token can delete
UserController.LOGGER.info("[deleteUserById][Delete user][UserId: {}]",userId);
return ok(userService.deleteUser(userId, headers));
}
@PutMapping
public ResponseEntity<Response> updateUser(@RequestBody UserDto user,
@RequestHeader HttpHeaders headers) {
UserController.LOGGER.info("[updateUser][Update user][UserId: {}]",user.getUserId());
return ok(userService.updateUser(user, headers));
}
}
| 2,830 | 36.746667 | 122 |
java
|
train-ticket
|
train-ticket-master/ts-user-service/src/main/java/user/dto/AuthDto.java
|
package user.dto;
import lombok.AllArgsConstructor;
import lombok.Builder;
import lombok.Data;
import lombok.NoArgsConstructor;
/**
* user-service register user , then send to auth-service
*
* @author fdse
*/
@Data
@Builder
@NoArgsConstructor
@AllArgsConstructor
public class AuthDto {
private String userId;
private String userName;
private String password;
}
| 381 | 14.916667 | 57 |
java
|
train-ticket
|
train-ticket-master/ts-user-service/src/main/java/user/dto/Gender.java
|
package user.dto;
/**
* @author fdse
*/
public enum Gender {
/**
* null
*/
NONE(0, "Null"),
/**
* male
*/
MALE(1, "Male"),
/**
* female
*/
FEMALE(2, "Female"),
/**
* other
*/
OTHER(3, "Other");
private int code;
private String name;
Gender(int code, String name) {
this.code = code;
this.name = name;
}
public int getCode() {
return code;
}
public String getName() {
return name;
}
public static String getNameByCode(int code) {
Gender[] genderSet = Gender.values();
for (Gender gender : genderSet) {
if (gender.getCode() == code) {
return gender.getName();
}
}
return genderSet[0].getName();
}
}
| 823 | 14.846154 | 50 |
java
|
train-ticket
|
train-ticket-master/ts-user-service/src/main/java/user/dto/UserDto.java
|
package user.dto;
import lombok.*;
import java.util.UUID;
/**
* @author fdse
*/
@Data
@Builder
@AllArgsConstructor
@NoArgsConstructor
@ToString
public class UserDto {
private String userId;
private String userName;
private String password;
private int gender;
private int documentType;
private String documentNum;
private String email;
}
| 382 | 11.354839 | 31 |
java
|
train-ticket
|
train-ticket-master/ts-user-service/src/main/java/user/entity/User.java
|
package user.entity;
import lombok.AllArgsConstructor;
import lombok.Builder;
import lombok.Data;
import lombok.NoArgsConstructor;
import org.hibernate.annotations.GenericGenerator;
import javax.persistence.Column;
import javax.persistence.Entity;
import javax.persistence.GeneratedValue;
import javax.persistence.Id;
import java.util.UUID;
/**
* @author fdse
*/
@Data
@Builder
@AllArgsConstructor
@Entity
public class User {
// private UUID userId;
@Id
@Column(length = 36, name = "user_id")
private String userId;
@Column(name = "user_name")
private String userName;
private String password;
private int gender;
@Column(name = "document_type")
private int documentType;
@Column(name = "document_num")
private String documentNum;
private String email;
public User() {
this.userId = UUID.randomUUID().toString();
}
}
| 898 | 18.977778 | 51 |
java
|
train-ticket
|
train-ticket-master/ts-user-service/src/main/java/user/init/InitUser.java
|
package user.init;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.CommandLineRunner;
import org.springframework.security.crypto.password.PasswordEncoder;
import org.springframework.stereotype.Component;
import user.entity.User;
import user.repository.UserRepository;
import user.service.UserService;
import java.util.UUID;
/**
* @author fdse
*/
@Component
public class InitUser implements CommandLineRunner {
@Autowired
private UserRepository userRepository;
@Autowired
protected PasswordEncoder passwordEncoder;
@Autowired
private UserService userService;
@Override
public void run(String... strings) throws Exception {
User whetherExistUser = userRepository.findByUserName("fdse_microservice");
User user = User.builder()
.userId("4d2a46c7-71cb-4cf1-b5bb-b68406d9da6f")
.userName("fdse_microservice")
.password("111111")
.gender(1)
.documentType(1)
.documentNum("2135488099312X")
.email("[email protected]").build();
user.setUserId("4d2a46c7-71cb-4cf1-b5bb-b68406d9da6f");
if (whetherExistUser == null) {
userRepository.save(user);
}
}
}
| 1,307 | 27.434783 | 83 |
java
|
train-ticket
|
train-ticket-master/ts-user-service/src/main/java/user/repository/UserRepository.java
|
package user.repository;
import org.springframework.data.repository.CrudRepository;
import org.springframework.stereotype.Repository;
import user.entity.User;
import java.util.List;
import java.util.UUID;
/**
* @author fdse
*/
@Repository
public interface UserRepository extends CrudRepository<User, String> {
User findByUserName(String userName);
User findByUserId(String userId);
void deleteByUserId(String userId);
@Override
List<User> findAll();
}
| 481 | 18.28 | 70 |
java
|
train-ticket
|
train-ticket-master/ts-user-service/src/main/java/user/service/UserService.java
|
package user.service;
import edu.fudan.common.util.Response;
import org.springframework.http.HttpHeaders;
import user.dto.UserDto;
import java.util.UUID;
/**
* @author fdse
*/
public interface UserService {
Response saveUser(UserDto user, HttpHeaders headers);
Response getAllUsers(HttpHeaders headers);
Response findByUserName(String userName, HttpHeaders headers);
Response findByUserId(String userId, HttpHeaders headers);
Response deleteUser(String userId, HttpHeaders headers);
Response updateUser(UserDto user, HttpHeaders headers);
}
| 575 | 22.04 | 66 |
java
|
train-ticket
|
train-ticket-master/ts-user-service/src/main/java/user/service/impl/UserServiceImpl.java
|
package user.service.impl;
import edu.fudan.common.util.Response;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.cloud.client.ServiceInstance;
import org.springframework.cloud.client.discovery.DiscoveryClient;
import org.springframework.core.ParameterizedTypeReference;
import org.springframework.http.*;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;
import org.springframework.web.client.RestTemplate;
import user.dto.AuthDto;
import user.dto.UserDto;
import user.entity.User;
import user.repository.UserRepository;
import user.service.UserService;
import java.util.List;
import java.util.UUID;
/**
* @author fdse
*/
@Service
public class UserServiceImpl implements UserService {
private static final Logger LOGGER = LoggerFactory.getLogger(UserServiceImpl.class);
@Autowired
private UserRepository userRepository;
@Autowired
private DiscoveryClient discoveryClient;
@Autowired
private RestTemplate restTemplate;
private String getServiceUrl(String serviceName) {
return "http://" + serviceName;
}
@Override
public Response saveUser(UserDto userDto, HttpHeaders headers) {
LOGGER.info("[saveUser][Save User Name][user name: {}]", userDto.getUserName());
String userId = userDto.getUserId();
if (userDto.getUserId() == null) {
userId = UUID.randomUUID().toString();
}
User user = User.builder()
.userId(userId)
.userName(userDto.getUserName())
.password(userDto.getPassword())
.gender(userDto.getGender())
.documentType(userDto.getDocumentType())
.documentNum(userDto.getDocumentNum())
.email(userDto.getEmail()).build();
// avoid same user name
User user1 = userRepository.findByUserName(userDto.getUserName());
if (user1 == null) {
createDefaultAuthUser(AuthDto.builder().userId(userId + "")
.userName(user.getUserName())
.password(user.getPassword()).build());
User userSaveResult = userRepository.save(user);
LOGGER.info("[saveUser][Send authorization message to ts-auth-service....]");
return new Response<>(1, "REGISTER USER SUCCESS", userSaveResult);
} else {
UserServiceImpl.LOGGER.error("[saveUser][Save user error][User already exists][UserId: {}]",userDto.getUserId());
return new Response<>(0, "USER HAS ALREADY EXISTS", null);
}
}
private Response createDefaultAuthUser(AuthDto dto) {
LOGGER.info("[createDefaultAuthUser][CALL TO AUTH][AuthDto: {}]", dto.toString());
HttpHeaders headers = new HttpHeaders();
HttpEntity<AuthDto> entity = new HttpEntity<>(dto, null);
String auth_service_url = getServiceUrl("ts-auth-service");
List<ServiceInstance> auth_svcs = discoveryClient.getInstances("ts-auth-service");
if(auth_svcs.size() >0 ){
ServiceInstance auth_svc = auth_svcs.get(0);
LOGGER.info("[createDefaultAuthUser][CALL TO AUTH][auth_svc host: {}][auth_svc port: {}]", auth_svc.getHost(), auth_svc.getPort());
}else{
LOGGER.info("[createDefaultAuthUser][CALL TO AUTH][can not get auth url]");
}
ResponseEntity<Response<AuthDto>> res = restTemplate.exchange(auth_service_url + "/api/v1/auth",
HttpMethod.POST,
entity,
new ParameterizedTypeReference<Response<AuthDto>>() {
});
return res.getBody();
}
@Override
public Response getAllUsers(HttpHeaders headers) {
List<User> users = userRepository.findAll();
if (users != null && !users.isEmpty()) {
return new Response<>(1, "Success", users);
}
UserServiceImpl.LOGGER.warn("[getAllUsers][Get all users warn: {}]","No Content");
return new Response<>(0, "NO User", null);
}
@Override
public Response findByUserName(String userName, HttpHeaders headers) {
User user = userRepository.findByUserName(userName);
if (user != null) {
return new Response<>(1, "Find User Success", user);
}
UserServiceImpl.LOGGER.warn("[findByUserName][Get user by name warn,user is null][UserName: {}]",userName);
return new Response<>(0, "No User", null);
}
@Override
public Response findByUserId(String userId, HttpHeaders headers) {
User user = userRepository.findByUserId(userId);
if (user != null) {
return new Response<>(1, "Find User Success", user);
}
UserServiceImpl.LOGGER.error("[findByUserId][Get user by id error,user is null][UserId: {}]",userId);
return new Response<>(0, "No User", null);
}
@Override
@Transactional
public Response deleteUser(String userId, HttpHeaders headers) {
LOGGER.info("[deleteUser][DELETE USER BY ID][userId: {}]", userId);
User user = userRepository.findByUserId(userId);
if (user != null) {
// first only admin token can delete success
deleteUserAuth(userId, headers);
// second
userRepository.deleteByUserId(userId);
LOGGER.info("[deleteUser][DELETE SUCCESS][userId: {}]", userId);
return new Response<>(1, "DELETE SUCCESS", null);
} else {
UserServiceImpl.LOGGER.error("[deleteUser][Delete user error][User not found][UserId: {}]",userId);
return new Response<>(0, "USER NOT EXISTS", null);
}
}
@Override
@Transactional
public Response updateUser(UserDto userDto, HttpHeaders headers) {
LOGGER.info("[updateUser][UPDATE USER: {}]", userDto.toString());
User oldUser = userRepository.findByUserId(userDto.getUserId());
if (oldUser != null) {
User newUser = User.builder().email(userDto.getEmail())
.password(userDto.getPassword())
.userId(oldUser.getUserId())
.userName(userDto.getUserName())
.gender(userDto.getGender())
.documentNum(userDto.getDocumentNum())
.documentType(userDto.getDocumentType()).build();
userRepository.deleteByUserId(oldUser.getUserId());
userRepository.save(newUser);
return new Response<>(1, "SAVE USER SUCCESS", newUser);
} else {
UserServiceImpl.LOGGER.error("[updateUser][Update user error][User not found][UserId: {}]",userDto.getUserId());
return new Response(0, "USER NOT EXISTS", null);
}
}
public void deleteUserAuth(String userId, HttpHeaders headers) {
LOGGER.info("[deleteUserAuth][DELETE USER BY ID][userId: {}]", userId);
HttpHeaders newHeaders = new HttpHeaders();
String token = headers.getFirst(HttpHeaders.AUTHORIZATION);
newHeaders.set(HttpHeaders.AUTHORIZATION, token);
HttpEntity<Response> httpEntity = new HttpEntity<>(newHeaders);
String auth_service_url = getServiceUrl("ts-auth-service");
String AUTH_SERVICE_URI = auth_service_url + "/api/v1";
restTemplate.exchange(AUTH_SERVICE_URI + "/users/" + userId,
HttpMethod.DELETE,
httpEntity,
Response.class);
LOGGER.info("[deleteUserAuth][DELETE USER AUTH SUCCESS][userId: {}]", userId);
}
}
| 7,705 | 39.557895 | 143 |
java
|
train-ticket
|
train-ticket-master/ts-user-service/src/test/java/user/controller/UserControllerTest.java
|
package user.controller;
import com.alibaba.fastjson.JSONObject;
import edu.fudan.common.util.Response;
import org.junit.Assert;
import org.junit.Before;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.junit.runners.JUnit4;
import org.mockito.InjectMocks;
import org.mockito.Mock;
import org.mockito.Mockito;
import org.mockito.MockitoAnnotations;
import org.springframework.http.*;
import org.springframework.test.web.servlet.MockMvc;
import org.springframework.test.web.servlet.request.MockMvcRequestBuilders;
import org.springframework.test.web.servlet.result.MockMvcResultMatchers;
import org.springframework.test.web.servlet.setup.MockMvcBuilders;
import user.dto.UserDto;
import user.service.UserService;
import java.util.UUID;
@RunWith(JUnit4.class)
public class UserControllerTest {
@InjectMocks
private UserController userController;
@Mock
private UserService userService;
private MockMvc mockMvc;
private Response response = new Response();
@Before
public void setUp() {
MockitoAnnotations.initMocks(this);
mockMvc = MockMvcBuilders.standaloneSetup(userController).build();
}
@Test
public void testHome() throws Exception {
mockMvc.perform(MockMvcRequestBuilders.get("/api/v1/userservice/users/hello"))
.andExpect(MockMvcResultMatchers.status().isOk())
.andExpect(MockMvcResultMatchers.content().string("Hello"));
}
@Test
public void testGetAllUser() throws Exception {
Mockito.when(userService.getAllUsers(Mockito.any(HttpHeaders.class))).thenReturn(response);
String result = mockMvc.perform(MockMvcRequestBuilders.get("/api/v1/userservice/users"))
.andExpect(MockMvcResultMatchers.status().isOk())
.andReturn().getResponse().getContentAsString();
Assert.assertEquals(response, JSONObject.parseObject(result, Response.class));
}
@Test
public void testGetUserByUserName() throws Exception {
Mockito.when(userService.findByUserName(Mockito.anyString(), Mockito.any(HttpHeaders.class))).thenReturn(response);
String result = mockMvc.perform(MockMvcRequestBuilders.get("/api/v1/userservice/users/user_name"))
.andExpect(MockMvcResultMatchers.status().isOk())
.andReturn().getResponse().getContentAsString();
Assert.assertEquals(response, JSONObject.parseObject(result, Response.class));
}
@Test
public void testGetUserByUserId() throws Exception {
Mockito.when(userService.findByUserId(Mockito.anyString(), Mockito.any(HttpHeaders.class))).thenReturn(response);
String result = mockMvc.perform(MockMvcRequestBuilders.get("/api/v1/userservice/users/id/user_id"))
.andExpect(MockMvcResultMatchers.status().isOk())
.andReturn().getResponse().getContentAsString();
Assert.assertEquals(response, JSONObject.parseObject(result, Response.class));
}
@Test
public void testRegisterUser() throws Exception {
UserDto userDto = new UserDto();
Mockito.when(userService.saveUser(Mockito.any(UserDto.class), Mockito.any(HttpHeaders.class))).thenReturn(response);
String requestJson = JSONObject.toJSONString(userDto);
String result = mockMvc.perform(MockMvcRequestBuilders.post("/api/v1/userservice/users/register").contentType(MediaType.APPLICATION_JSON).content(requestJson))
.andExpect(MockMvcResultMatchers.status().isCreated())
.andReturn().getResponse().getContentAsString();
Assert.assertEquals(response, JSONObject.parseObject(result, Response.class));
}
@Test
public void testDeleteUserById() throws Exception {
UUID userId = UUID.randomUUID();
Mockito.when(userService.deleteUser(Mockito.any(UUID.class).toString(), Mockito.any(HttpHeaders.class))).thenReturn(response);
String result = mockMvc.perform(MockMvcRequestBuilders.delete("/api/v1/userservice/users/" + userId.toString()))
.andExpect(MockMvcResultMatchers.status().isOk())
.andReturn().getResponse().getContentAsString();
Assert.assertEquals(response, JSONObject.parseObject(result, Response.class));
}
@Test
public void testUpdateUser() throws Exception {
UserDto user = new UserDto();
Mockito.when(userService.updateUser(Mockito.any(UserDto.class), Mockito.any(HttpHeaders.class))).thenReturn(response);
String requestJson = JSONObject.toJSONString(user);
String result = mockMvc.perform(MockMvcRequestBuilders.put("/api/v1/userservice/users").contentType(MediaType.APPLICATION_JSON).content(requestJson))
.andExpect(MockMvcResultMatchers.status().isOk())
.andReturn().getResponse().getContentAsString();
Assert.assertEquals(response, JSONObject.parseObject(result, Response.class));
}
}
| 4,939 | 44.740741 | 167 |
java
|
train-ticket
|
train-ticket-master/ts-user-service/src/test/java/user/service/UserServiceImplTest.java
|
package user.service;
import edu.fudan.common.util.Response;
import org.junit.Assert;
import org.junit.Before;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.junit.runners.JUnit4;
import org.mockito.InjectMocks;
import org.mockito.Mock;
import org.mockito.Mockito;
import org.mockito.MockitoAnnotations;
import org.springframework.core.ParameterizedTypeReference;
import org.springframework.http.*;
import org.springframework.web.client.RestTemplate;
import user.dto.AuthDto;
import user.dto.UserDto;
import user.entity.User;
import user.repository.UserRepository;
import user.service.impl.UserServiceImpl;
import java.util.ArrayList;
import java.util.List;
import java.util.UUID;
@RunWith(JUnit4.class)
public class UserServiceImplTest {
@InjectMocks
private UserServiceImpl userServiceImpl;
@Mock
private UserRepository userRepository;
@Mock
private RestTemplate restTemplate;
private HttpHeaders headers = new HttpHeaders();
@Before
public void setUp() {
MockitoAnnotations.initMocks(this);
}
@Test
public void testSaveUser() {
UserDto userDto = new UserDto(UUID.randomUUID().toString(), "user_name", "xxx", 0, 1, "", "");
Mockito.when(userRepository.findByUserName(Mockito.anyString())).thenReturn(null);
//mock createDefaultAuthUser()
Response<ArrayList<AuthDto>> response1 = new Response<>();
ResponseEntity<Response<ArrayList<AuthDto>>> re1 = new ResponseEntity<>(response1, HttpStatus.OK);
Mockito.when(restTemplate.exchange(
Mockito.anyString(),
Mockito.any(HttpMethod.class),
Mockito.any(HttpEntity.class),
Mockito.any(ParameterizedTypeReference.class)))
.thenReturn(re1);
User user = new User();
Mockito.when(userRepository.save(Mockito.any(User.class))).thenReturn(user);
Response result = userServiceImpl.saveUser(userDto, headers);
Assert.assertEquals(new Response<>(1, "REGISTER USER SUCCESS", user), result);
}
@Test
public void testGetAllUsers1() {
List<User> users = new ArrayList<>();
users.add(new User());
Mockito.when(userRepository.findAll()).thenReturn(users);
Response result = userServiceImpl.getAllUsers(headers);
Assert.assertEquals(new Response<>(1, "Success", users), result);
}
@Test
public void testGetAllUsers2() {
Mockito.when(userRepository.findAll()).thenReturn(null);
Response result = userServiceImpl.getAllUsers(headers);
Assert.assertEquals(new Response<>(0, "NO User", null), result);
}
@Test
public void testFindByUserName1() {
User user = new User();
Mockito.when(userRepository.findByUserName(Mockito.anyString())).thenReturn(user);
Response result = userServiceImpl.findByUserName("user_name", headers);
Assert.assertEquals(new Response<>(1, "Find User Success", user), result);
}
@Test
public void testFindByUserName2() {
Mockito.when(userRepository.findByUserName(Mockito.anyString())).thenReturn(null);
Response result = userServiceImpl.findByUserName("user_name", headers);
Assert.assertEquals(new Response<>(0, "No User", null), result);
}
@Test
public void testFindByUserId1() {
UUID userId = UUID.randomUUID();
User user = new User();
Mockito.when(userRepository.findByUserId(Mockito.any(UUID.class).toString())).thenReturn(user);
Response result = userServiceImpl.findByUserId(userId.toString(), headers);
Assert.assertEquals(new Response<>(1, "Find User Success", user), result);
}
@Test
public void testFindByUserId2() {
UUID userId = UUID.randomUUID();
Mockito.when(userRepository.findByUserId(Mockito.any(UUID.class).toString())).thenReturn(null);
Response result = userServiceImpl.findByUserId(userId.toString(), headers);
Assert.assertEquals(new Response<>(0, "No User", null), result);
}
@Test
public void testDeleteUser1() {
String userId = UUID.randomUUID().toString();
User user = new User();
Mockito.when(userRepository.findByUserId(Mockito.any(UUID.class).toString())).thenReturn(user);
HttpEntity<Response> httpEntity = new HttpEntity<>(headers);
Mockito.when(restTemplate.exchange("http://ts-auth-service:12340/api/v1" + "/users/" + userId,
HttpMethod.DELETE,
httpEntity,
Response.class)).thenReturn(null);
Mockito.doNothing().doThrow(new RuntimeException()).when(userRepository).deleteByUserId(Mockito.any(UUID.class).toString());
Response result = userServiceImpl.deleteUser(userId, headers);
Assert.assertEquals(new Response<>(1, "DELETE SUCCESS", null), result);
}
@Test
public void testDeleteUser2() {
UUID userId = UUID.randomUUID();
Mockito.when(userRepository.findByUserId(Mockito.any(UUID.class).toString())).thenReturn(null);
Response result = userServiceImpl.deleteUser(userId.toString(), headers);
Assert.assertEquals(new Response<>(0, "USER NOT EXISTS", null), result);
}
@Test
public void testUpdateUser1() {
UserDto userDto = new UserDto();
User oldUser = new User();
Mockito.when(userRepository.findByUserName(Mockito.anyString())).thenReturn(oldUser);
Mockito.doNothing().doThrow(new RuntimeException()).when(userRepository).deleteByUserId(Mockito.any(UUID.class).toString());
Mockito.when(userRepository.save(Mockito.any(User.class))).thenReturn(null);
Response result = userServiceImpl.updateUser(userDto, headers);
Assert.assertEquals("SAVE USER SUCCESS", result.getMsg());
}
@Test
public void testUpdateUser2() {
UserDto userDto = new UserDto();
Mockito.when(userRepository.findByUserName(Mockito.anyString())).thenReturn(null);
Response result = userServiceImpl.updateUser(userDto, headers);
Assert.assertEquals(new Response(0, "USER NOT EXISTS", null), result);
}
@Test
public void testDeleteUserAuth() {
UUID userId = UUID.randomUUID();
HttpEntity<Response> httpEntity = new HttpEntity<>(headers);
Mockito.when(restTemplate.exchange("http://ts-auth-service:12340/api/v1" + "/users/" + userId,
HttpMethod.DELETE,
httpEntity,
Response.class)).thenReturn(null);
userServiceImpl.deleteUserAuth(userId.toString(), headers);
Mockito.verify(restTemplate, Mockito.times(1))
.exchange(Mockito.anyString(), Mockito.any(HttpMethod.class), Mockito.any(HttpEntity.class), Mockito.any(Class.class));
}
}
| 6,804 | 39.029412 | 135 |
java
|
train-ticket
|
train-ticket-master/ts-verification-code-service/src/main/java/verifycode/VerifyCodeApplication.java
|
package verifycode;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.boot.web.client.RestTemplateBuilder;
import org.springframework.cloud.client.discovery.EnableDiscoveryClient;
import org.springframework.cloud.client.loadbalancer.LoadBalanced;
import org.springframework.context.annotation.Bean;
import org.springframework.web.client.RestTemplate;
/**
* @author fdse
*/
@SpringBootApplication
@EnableDiscoveryClient
public class VerifyCodeApplication {
public static void main(String[] args) {
SpringApplication.run(VerifyCodeApplication.class, args);
}
@LoadBalanced
@Bean
public RestTemplate restTemplate(RestTemplateBuilder builder) {
return builder.build();
}
}
| 810 | 30.192308 | 72 |
java
|
train-ticket
|
train-ticket-master/ts-verification-code-service/src/main/java/verifycode/config/SecurityConfig.java
|
package verifycode.config;
import edu.fudan.common.security.jwt.JWTFilter;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.security.config.annotation.method.configuration.EnableGlobalMethodSecurity;
import org.springframework.security.config.annotation.web.builders.HttpSecurity;
import org.springframework.security.config.annotation.web.configuration.EnableWebSecurity;
import org.springframework.security.config.annotation.web.configuration.WebSecurityConfigurerAdapter;
import org.springframework.security.config.http.SessionCreationPolicy;
import org.springframework.security.crypto.bcrypt.BCryptPasswordEncoder;
import org.springframework.security.crypto.password.PasswordEncoder;
import org.springframework.security.web.authentication.UsernamePasswordAuthenticationFilter;
import org.springframework.web.servlet.config.annotation.CorsRegistry;
import org.springframework.web.servlet.config.annotation.WebMvcConfigurer;
import org.springframework.web.servlet.config.annotation.WebMvcConfigurerAdapter;
import static org.springframework.web.cors.CorsConfiguration.ALL;
/**
* @author LeBW
*/
@Configuration
@EnableWebSecurity
@EnableGlobalMethodSecurity(prePostEnabled = true)
public class SecurityConfig extends WebSecurityConfigurerAdapter {
/**
* load password encoder
*
* @return PasswordEncoder
*/
@Bean
public PasswordEncoder passwordEncoder() {
return new BCryptPasswordEncoder();
}
/**
* allow cors domain
* header By default, only six fields can be taken from the header, and the other fields can only be specified in the header.
* credentials Cookies are not sent by default and can only be true if a Cookie is needed
* Validity of this request
*
* @return WebMvcConfigurer
*/
@Bean
public WebMvcConfigurer corsConfigurer() {
return new WebMvcConfigurerAdapter() {
@Override
public void addCorsMappings(CorsRegistry registry) {
registry.addMapping("/**")
.allowedOrigins(ALL)
.allowedMethods(ALL)
.allowedHeaders(ALL)
.allowCredentials(false)
.maxAge(3600);
}
};
}
@Override
protected void configure(HttpSecurity httpSecurity) throws Exception {
httpSecurity.httpBasic().disable()
// close default csrf
.csrf().disable()
// close session
.sessionManagement().sessionCreationPolicy(SessionCreationPolicy.STATELESS)
.and()
.authorizeRequests()
.antMatchers("/api/v1/verifycode/**").permitAll()
.anyRequest().authenticated()
.and()
.addFilterBefore(new JWTFilter(), UsernamePasswordAuthenticationFilter.class);
// close cache
httpSecurity.headers().cacheControl();
}
}
| 3,063 | 37.3 | 130 |
java
|
train-ticket
|
train-ticket-master/ts-verification-code-service/src/main/java/verifycode/controller/VerifyCodeController.java
|
package verifycode.controller;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.http.HttpHeaders;
import org.springframework.web.bind.annotation.*;
import verifycode.service.VerifyCodeService;
import javax.imageio.ImageIO;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import java.awt.image.BufferedImage;
import java.io.IOException;
import java.io.OutputStream;
import java.util.Map;
/**
* @author fdse
*/
@RestController
@RequestMapping("/api/v1/verifycode")
public class VerifyCodeController {
private static final Logger LOGGER = LoggerFactory.getLogger(VerifyCodeController.class);
@Autowired
private VerifyCodeService verifyCodeService;
@GetMapping("/generate")
public void imageCode(@RequestHeader HttpHeaders headers,
HttpServletRequest request,
HttpServletResponse response) throws IOException {
VerifyCodeController.LOGGER.info("[imageCode][Image code]");
OutputStream os = response.getOutputStream();
Map<String, Object> map = verifyCodeService.getImageCode(60, 20, os, request, response, headers);
String simpleCaptcha = "simpleCaptcha";
request.getSession().setAttribute(simpleCaptcha, map.get("strEnsure").toString().toLowerCase());
request.getSession().setAttribute("codeTime", System.currentTimeMillis());
try {
ImageIO.write((BufferedImage) map.get("image"), "JPEG", os);
} catch (IOException e) {
//error
String error = "Can't generate verification code";
os.write(error.getBytes());
}
}
@GetMapping(value = "/verify/{verifyCode}")
public boolean verifyCode(@PathVariable String verifyCode, HttpServletRequest request,
HttpServletResponse response, @RequestHeader HttpHeaders headers) {
LOGGER.info("[verifyCode][receivedCode: {}]", verifyCode);
boolean result = verifyCodeService.verifyCode(request, response, verifyCode, headers);
LOGGER.info("[verifyCode][verify result: {}]", result);
return true;
}
}
| 2,248 | 37.775862 | 105 |
java
|
train-ticket
|
train-ticket-master/ts-verification-code-service/src/main/java/verifycode/service/VerifyCodeService.java
|
package verifycode.service;
import org.springframework.http.HttpHeaders;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import java.io.OutputStream;
import java.util.Map;
/**
* @author fdse
*/
public interface VerifyCodeService {
Map<String, Object> getImageCode(int width, int height, OutputStream os, HttpServletRequest request, HttpServletResponse response, HttpHeaders headers);
boolean verifyCode(HttpServletRequest request, HttpServletResponse response, String receivedCode, HttpHeaders headers);
}
| 567 | 27.4 | 156 |
java
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.